From d346b08416e4e80511cbb170fa1b54e7e00f1c65 Mon Sep 17 00:00:00 2001 From: Clark McCauley Date: Fri, 27 Jan 2023 18:24:13 -0700 Subject: [PATCH] Updated default Typescript version to 4.9.3 (#10) --- config.go | 4 +- versions/v4.9.3/loader.go | 13 + versions/v4.9.3/v4.9.3.js | 174479 +++++++++++++++++++++++++++++++++++ 3 files changed, 174494 insertions(+), 2 deletions(-) create mode 100644 versions/v4.9.3/loader.go create mode 100644 versions/v4.9.3/v4.9.3.js diff --git a/config.go b/config.go index 3fa7a0e..eee00b9 100644 --- a/config.go +++ b/config.go @@ -5,7 +5,7 @@ import ( "fmt" "github.com/clarkmcc/go-typescript/utils" "github.com/clarkmcc/go-typescript/versions" - _ "github.com/clarkmcc/go-typescript/versions/v4.7.2" + _ "github.com/clarkmcc/go-typescript/versions/v4.9.3" "github.com/dop251/goja" ) @@ -60,7 +60,7 @@ func NewDefaultConfig() *Config { return &Config{ Runtime: goja.New(), CompileOptions: nil, - TypescriptSource: versions.DefaultRegistry.MustGet("v4.7.2"), + TypescriptSource: versions.DefaultRegistry.MustGet("v4.9.3"), ModuleName: "default", } } diff --git a/versions/v4.9.3/loader.go b/versions/v4.9.3/loader.go new file mode 100644 index 0000000..6e0446b --- /dev/null +++ b/versions/v4.9.3/loader.go @@ -0,0 +1,13 @@ +package v4_9_3 + +import ( + _ "embed" + "github.com/clarkmcc/go-typescript/versions" +) + +//go:embed v4.9.3.js +var Source string + +func init() { + versions.DefaultRegistry.MustRegister("v4.9.3", Source) +} diff --git a/versions/v4.9.3/v4.9.3.js b/versions/v4.9.3/v4.9.3.js new file mode 100644 index 0000000..426896e --- /dev/null +++ b/versions/v4.9.3/v4.9.3.js @@ -0,0 +1,174479 @@ +/*! ***************************************************************************** +Copyright (c) Microsoft Corporation. All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); you may not use +this file except in compliance with the License. You may obtain a copy of the +License at http://www.apache.org/licenses/LICENSE-2.0 + +THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED +WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, +MERCHANTABLITY OR NON-INFRINGEMENT. + +See the Apache Version 2.0 License for specific language governing permissions +and limitations under the License. +***************************************************************************** */ + +"use strict"; +var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) { + if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) { + if (ar || !(i in from)) { + if (!ar) ar = Array.prototype.slice.call(from, 0, i); + ar[i] = from[i]; + } + } + return to.concat(ar || Array.prototype.slice.call(from)); +}; +var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) { + if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; } + return cooked; +}; +var __generator = (this && this.__generator) || function (thisArg, body) { + var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; + return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; + function verb(n) { return function (v) { return step([n, v]); }; } + function step(op) { + if (f) throw new TypeError("Generator is already executing."); + while (g && (g = 0, op[0] && (_ = 0)), _) try { + if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; + if (y = 0, t) op = [op[0] & 2, t.value]; + switch (op[0]) { + case 0: case 1: t = op; break; + case 4: _.label++; return { value: op[1], done: false }; + case 5: _.label++; y = op[1]; op = [0]; continue; + case 7: op = _.ops.pop(); _.trys.pop(); continue; + default: + if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } + if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } + if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } + if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } + if (t[2]) _.ops.pop(); + _.trys.pop(); continue; + } + op = body.call(thisArg, _); + } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } + if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; + } +}; +var __rest = (this && this.__rest) || function (s, e) { + var t = {}; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) + t[p] = s[p]; + if (s != null && typeof Object.getOwnPropertySymbols === "function") + for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { + if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) + t[p[i]] = s[p[i]]; + } + return t; +}; +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var ts; +(function (ts) { + // WARNING: The script `configurePrerelease.ts` uses a regexp to parse out these values. + // If changing the text in this section, be sure to test `configurePrerelease` too. + ts.versionMajorMinor = "4.9"; + // The following is baselined as a literal template type without intervention + /** The version of the TypeScript compiler release */ + // eslint-disable-next-line @typescript-eslint/no-inferrable-types + ts.version = "".concat(ts.versionMajorMinor, ".3"); + /* @internal */ + var Comparison; + (function (Comparison) { + Comparison[Comparison["LessThan"] = -1] = "LessThan"; + Comparison[Comparison["EqualTo"] = 0] = "EqualTo"; + Comparison[Comparison["GreaterThan"] = 1] = "GreaterThan"; + })(Comparison = ts.Comparison || (ts.Comparison = {})); + /* @internal */ + var NativeCollections; + (function (NativeCollections) { + var globals = typeof globalThis !== "undefined" ? globalThis : + typeof global !== "undefined" ? global : + typeof self !== "undefined" ? self : + undefined; + /** + * Returns the native Map implementation if it is available and compatible (i.e. supports iteration). + */ + function tryGetNativeMap() { + // Internet Explorer's Map doesn't support iteration, so don't use it. + var gMap = globals === null || globals === void 0 ? void 0 : globals.Map; + // eslint-disable-next-line local/no-in-operator + var constructor = typeof gMap !== "undefined" && "entries" in gMap.prototype && new gMap([[0, 0]]).size === 1 ? gMap : undefined; + if (!constructor) { + throw new Error("No compatible Map implementation found."); + } + return constructor; + } + NativeCollections.tryGetNativeMap = tryGetNativeMap; + /** + * Returns the native Set implementation if it is available and compatible (i.e. supports iteration). + */ + function tryGetNativeSet() { + // Internet Explorer's Set doesn't support iteration, so don't use it. + var gSet = globals === null || globals === void 0 ? void 0 : globals.Set; + // eslint-disable-next-line local/no-in-operator + var constructor = typeof gSet !== "undefined" && "entries" in gSet.prototype && new gSet([0]).size === 1 ? gSet : undefined; + if (!constructor) { + throw new Error("No compatible Set implementation found."); + } + return constructor; + } + NativeCollections.tryGetNativeSet = tryGetNativeSet; + })(NativeCollections || (NativeCollections = {})); + /* @internal */ + ts.Map = NativeCollections.tryGetNativeMap(); + /* @internal */ + ts.Set = NativeCollections.tryGetNativeSet(); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + function getIterator(iterable) { + if (iterable) { + if (isArray(iterable)) + return arrayIterator(iterable); + if (iterable instanceof ts.Map) + return iterable.entries(); + if (iterable instanceof ts.Set) + return iterable.values(); + throw new Error("Iteration not supported."); + } + } + ts.getIterator = getIterator; + ts.emptyArray = []; + ts.emptyMap = new ts.Map(); + ts.emptySet = new ts.Set(); + function length(array) { + return array ? array.length : 0; + } + ts.length = length; + /** + * Iterates through 'array' by index and performs the callback on each element of array until the callback + * returns a truthy value, then returns that value. + * If no such value is found, the callback is applied to each element of array and undefined is returned. + */ + function forEach(array, callback) { + if (array) { + for (var i = 0; i < array.length; i++) { + var result = callback(array[i], i); + if (result) { + return result; + } + } + } + return undefined; + } + ts.forEach = forEach; + /** + * Like `forEach`, but iterates in reverse order. + */ + function forEachRight(array, callback) { + if (array) { + for (var i = array.length - 1; i >= 0; i--) { + var result = callback(array[i], i); + if (result) { + return result; + } + } + } + return undefined; + } + ts.forEachRight = forEachRight; + /** Like `forEach`, but suitable for use with numbers and strings (which may be falsy). */ + function firstDefined(array, callback) { + if (array === undefined) { + return undefined; + } + for (var i = 0; i < array.length; i++) { + var result = callback(array[i], i); + if (result !== undefined) { + return result; + } + } + return undefined; + } + ts.firstDefined = firstDefined; + function firstDefinedIterator(iter, callback) { + while (true) { + var iterResult = iter.next(); + if (iterResult.done) { + return undefined; + } + var result = callback(iterResult.value); + if (result !== undefined) { + return result; + } + } + } + ts.firstDefinedIterator = firstDefinedIterator; + function reduceLeftIterator(iterator, f, initial) { + var result = initial; + if (iterator) { + for (var step = iterator.next(), pos = 0; !step.done; step = iterator.next(), pos++) { + result = f(result, step.value, pos); + } + } + return result; + } + ts.reduceLeftIterator = reduceLeftIterator; + function zipWith(arrayA, arrayB, callback) { + var result = []; + ts.Debug.assertEqual(arrayA.length, arrayB.length); + for (var i = 0; i < arrayA.length; i++) { + result.push(callback(arrayA[i], arrayB[i], i)); + } + return result; + } + ts.zipWith = zipWith; + function zipToIterator(arrayA, arrayB) { + ts.Debug.assertEqual(arrayA.length, arrayB.length); + var i = 0; + return { + next: function () { + if (i === arrayA.length) { + return { value: undefined, done: true }; + } + i++; + return { value: [arrayA[i - 1], arrayB[i - 1]], done: false }; + } + }; + } + ts.zipToIterator = zipToIterator; + function zipToMap(keys, values) { + ts.Debug.assert(keys.length === values.length); + var map = new ts.Map(); + for (var i = 0; i < keys.length; ++i) { + map.set(keys[i], values[i]); + } + return map; + } + ts.zipToMap = zipToMap; + /** + * Creates a new array with `element` interspersed in between each element of `input` + * if there is more than 1 value in `input`. Otherwise, returns the existing array. + */ + function intersperse(input, element) { + if (input.length <= 1) { + return input; + } + var result = []; + for (var i = 0, n = input.length; i < n; i++) { + if (i) + result.push(element); + result.push(input[i]); + } + return result; + } + ts.intersperse = intersperse; + /** + * Iterates through `array` by index and performs the callback on each element of array until the callback + * returns a falsey value, then returns false. + * If no such value is found, the callback is applied to each element of array and `true` is returned. + */ + function every(array, callback) { + if (array) { + for (var i = 0; i < array.length; i++) { + if (!callback(array[i], i)) { + return false; + } + } + } + return true; + } + ts.every = every; + function find(array, predicate, startIndex) { + if (array === undefined) + return undefined; + for (var i = startIndex !== null && startIndex !== void 0 ? startIndex : 0; i < array.length; i++) { + var value = array[i]; + if (predicate(value, i)) { + return value; + } + } + return undefined; + } + ts.find = find; + function findLast(array, predicate, startIndex) { + if (array === undefined) + return undefined; + for (var i = startIndex !== null && startIndex !== void 0 ? startIndex : array.length - 1; i >= 0; i--) { + var value = array[i]; + if (predicate(value, i)) { + return value; + } + } + return undefined; + } + ts.findLast = findLast; + /** Works like Array.prototype.findIndex, returning `-1` if no element satisfying the predicate is found. */ + function findIndex(array, predicate, startIndex) { + if (array === undefined) + return -1; + for (var i = startIndex !== null && startIndex !== void 0 ? startIndex : 0; i < array.length; i++) { + if (predicate(array[i], i)) { + return i; + } + } + return -1; + } + ts.findIndex = findIndex; + function findLastIndex(array, predicate, startIndex) { + if (array === undefined) + return -1; + for (var i = startIndex !== null && startIndex !== void 0 ? startIndex : array.length - 1; i >= 0; i--) { + if (predicate(array[i], i)) { + return i; + } + } + return -1; + } + ts.findLastIndex = findLastIndex; + /** + * Returns the first truthy result of `callback`, or else fails. + * This is like `forEach`, but never returns undefined. + */ + function findMap(array, callback) { + for (var i = 0; i < array.length; i++) { + var result = callback(array[i], i); + if (result) { + return result; + } + } + return ts.Debug.fail(); + } + ts.findMap = findMap; + function contains(array, value, equalityComparer) { + if (equalityComparer === void 0) { equalityComparer = equateValues; } + if (array) { + for (var _i = 0, array_1 = array; _i < array_1.length; _i++) { + var v = array_1[_i]; + if (equalityComparer(v, value)) { + return true; + } + } + } + return false; + } + ts.contains = contains; + function arraysEqual(a, b, equalityComparer) { + if (equalityComparer === void 0) { equalityComparer = equateValues; } + return a.length === b.length && a.every(function (x, i) { return equalityComparer(x, b[i]); }); + } + ts.arraysEqual = arraysEqual; + function indexOfAnyCharCode(text, charCodes, start) { + for (var i = start || 0; i < text.length; i++) { + if (contains(charCodes, text.charCodeAt(i))) { + return i; + } + } + return -1; + } + ts.indexOfAnyCharCode = indexOfAnyCharCode; + function countWhere(array, predicate) { + var count = 0; + if (array) { + for (var i = 0; i < array.length; i++) { + var v = array[i]; + if (predicate(v, i)) { + count++; + } + } + } + return count; + } + ts.countWhere = countWhere; + function filter(array, f) { + if (array) { + var len = array.length; + var i = 0; + while (i < len && f(array[i])) + i++; + if (i < len) { + var result = array.slice(0, i); + i++; + while (i < len) { + var item = array[i]; + if (f(item)) { + result.push(item); + } + i++; + } + return result; + } + } + return array; + } + ts.filter = filter; + function filterMutate(array, f) { + var outIndex = 0; + for (var i = 0; i < array.length; i++) { + if (f(array[i], i, array)) { + array[outIndex] = array[i]; + outIndex++; + } + } + array.length = outIndex; + } + ts.filterMutate = filterMutate; + function clear(array) { + array.length = 0; + } + ts.clear = clear; + function map(array, f) { + var result; + if (array) { + result = []; + for (var i = 0; i < array.length; i++) { + result.push(f(array[i], i)); + } + } + return result; + } + ts.map = map; + function mapIterator(iter, mapFn) { + return { + next: function () { + var iterRes = iter.next(); + return iterRes.done ? iterRes : { value: mapFn(iterRes.value), done: false }; + } + }; + } + ts.mapIterator = mapIterator; + function sameMap(array, f) { + if (array) { + for (var i = 0; i < array.length; i++) { + var item = array[i]; + var mapped = f(item, i); + if (item !== mapped) { + var result = array.slice(0, i); + result.push(mapped); + for (i++; i < array.length; i++) { + result.push(f(array[i], i)); + } + return result; + } + } + } + return array; + } + ts.sameMap = sameMap; + /** + * Flattens an array containing a mix of array or non-array elements. + * + * @param array The array to flatten. + */ + function flatten(array) { + var result = []; + for (var _i = 0, array_2 = array; _i < array_2.length; _i++) { + var v = array_2[_i]; + if (v) { + if (isArray(v)) { + addRange(result, v); + } + else { + result.push(v); + } + } + } + return result; + } + ts.flatten = flatten; + /** + * Maps an array. If the mapped value is an array, it is spread into the result. + * + * @param array The array to map. + * @param mapfn The callback used to map the result into one or more values. + */ + function flatMap(array, mapfn) { + var result; + if (array) { + for (var i = 0; i < array.length; i++) { + var v = mapfn(array[i], i); + if (v) { + if (isArray(v)) { + result = addRange(result, v); + } + else { + result = append(result, v); + } + } + } + } + return result || ts.emptyArray; + } + ts.flatMap = flatMap; + function flatMapToMutable(array, mapfn) { + var result = []; + if (array) { + for (var i = 0; i < array.length; i++) { + var v = mapfn(array[i], i); + if (v) { + if (isArray(v)) { + addRange(result, v); + } + else { + result.push(v); + } + } + } + } + return result; + } + ts.flatMapToMutable = flatMapToMutable; + function flatMapIterator(iter, mapfn) { + var first = iter.next(); + if (first.done) { + return ts.emptyIterator; + } + var currentIter = getIterator(first.value); + return { + next: function () { + while (true) { + var currentRes = currentIter.next(); + if (!currentRes.done) { + return currentRes; + } + var iterRes = iter.next(); + if (iterRes.done) { + return iterRes; + } + currentIter = getIterator(iterRes.value); + } + }, + }; + function getIterator(x) { + var res = mapfn(x); + return res === undefined ? ts.emptyIterator : isArray(res) ? arrayIterator(res) : res; + } + } + ts.flatMapIterator = flatMapIterator; + function sameFlatMap(array, mapfn) { + var result; + if (array) { + for (var i = 0; i < array.length; i++) { + var item = array[i]; + var mapped = mapfn(item, i); + if (result || item !== mapped || isArray(mapped)) { + if (!result) { + result = array.slice(0, i); + } + if (isArray(mapped)) { + addRange(result, mapped); + } + else { + result.push(mapped); + } + } + } + } + return result || array; + } + ts.sameFlatMap = sameFlatMap; + function mapAllOrFail(array, mapFn) { + var result = []; + for (var i = 0; i < array.length; i++) { + var mapped = mapFn(array[i], i); + if (mapped === undefined) { + return undefined; + } + result.push(mapped); + } + return result; + } + ts.mapAllOrFail = mapAllOrFail; + function mapDefined(array, mapFn) { + var result = []; + if (array) { + for (var i = 0; i < array.length; i++) { + var mapped = mapFn(array[i], i); + if (mapped !== undefined) { + result.push(mapped); + } + } + } + return result; + } + ts.mapDefined = mapDefined; + function mapDefinedIterator(iter, mapFn) { + return { + next: function () { + while (true) { + var res = iter.next(); + if (res.done) { + return res; + } + var value = mapFn(res.value); + if (value !== undefined) { + return { value: value, done: false }; + } + } + } + }; + } + ts.mapDefinedIterator = mapDefinedIterator; + function mapDefinedEntries(map, f) { + if (!map) { + return undefined; + } + var result = new ts.Map(); + map.forEach(function (value, key) { + var entry = f(key, value); + if (entry !== undefined) { + var newKey = entry[0], newValue = entry[1]; + if (newKey !== undefined && newValue !== undefined) { + result.set(newKey, newValue); + } + } + }); + return result; + } + ts.mapDefinedEntries = mapDefinedEntries; + function mapDefinedValues(set, f) { + if (set) { + var result_1 = new ts.Set(); + set.forEach(function (value) { + var newValue = f(value); + if (newValue !== undefined) { + result_1.add(newValue); + } + }); + return result_1; + } + } + ts.mapDefinedValues = mapDefinedValues; + function getOrUpdate(map, key, callback) { + if (map.has(key)) { + return map.get(key); + } + var value = callback(); + map.set(key, value); + return value; + } + ts.getOrUpdate = getOrUpdate; + function tryAddToSet(set, value) { + if (!set.has(value)) { + set.add(value); + return true; + } + return false; + } + ts.tryAddToSet = tryAddToSet; + ts.emptyIterator = { next: function () { return ({ value: undefined, done: true }); } }; + function singleIterator(value) { + var done = false; + return { + next: function () { + var wasDone = done; + done = true; + return wasDone ? { value: undefined, done: true } : { value: value, done: false }; + } + }; + } + ts.singleIterator = singleIterator; + function spanMap(array, keyfn, mapfn) { + var result; + if (array) { + result = []; + var len = array.length; + var previousKey = void 0; + var key = void 0; + var start = 0; + var pos = 0; + while (start < len) { + while (pos < len) { + var value = array[pos]; + key = keyfn(value, pos); + if (pos === 0) { + previousKey = key; + } + else if (key !== previousKey) { + break; + } + pos++; + } + if (start < pos) { + var v = mapfn(array.slice(start, pos), previousKey, start, pos); + if (v) { + result.push(v); + } + start = pos; + } + previousKey = key; + pos++; + } + } + return result; + } + ts.spanMap = spanMap; + function mapEntries(map, f) { + if (!map) { + return undefined; + } + var result = new ts.Map(); + map.forEach(function (value, key) { + var _a = f(key, value), newKey = _a[0], newValue = _a[1]; + result.set(newKey, newValue); + }); + return result; + } + ts.mapEntries = mapEntries; + function some(array, predicate) { + if (array) { + if (predicate) { + for (var _i = 0, array_3 = array; _i < array_3.length; _i++) { + var v = array_3[_i]; + if (predicate(v)) { + return true; + } + } + } + else { + return array.length > 0; + } + } + return false; + } + ts.some = some; + /** Calls the callback with (start, afterEnd) index pairs for each range where 'pred' is true. */ + function getRangesWhere(arr, pred, cb) { + var start; + for (var i = 0; i < arr.length; i++) { + if (pred(arr[i])) { + start = start === undefined ? i : start; + } + else { + if (start !== undefined) { + cb(start, i); + start = undefined; + } + } + } + if (start !== undefined) + cb(start, arr.length); + } + ts.getRangesWhere = getRangesWhere; + function concatenate(array1, array2) { + if (!some(array2)) + return array1; + if (!some(array1)) + return array2; + return __spreadArray(__spreadArray([], array1, true), array2, true); + } + ts.concatenate = concatenate; + function selectIndex(_, i) { + return i; + } + function indicesOf(array) { + return array.map(selectIndex); + } + ts.indicesOf = indicesOf; + function deduplicateRelational(array, equalityComparer, comparer) { + // Perform a stable sort of the array. This ensures the first entry in a list of + // duplicates remains the first entry in the result. + var indices = indicesOf(array); + stableSortIndices(array, indices, comparer); + var last = array[indices[0]]; + var deduplicated = [indices[0]]; + for (var i = 1; i < indices.length; i++) { + var index = indices[i]; + var item = array[index]; + if (!equalityComparer(last, item)) { + deduplicated.push(index); + last = item; + } + } + // restore original order + deduplicated.sort(); + return deduplicated.map(function (i) { return array[i]; }); + } + function deduplicateEquality(array, equalityComparer) { + var result = []; + for (var _i = 0, array_4 = array; _i < array_4.length; _i++) { + var item = array_4[_i]; + pushIfUnique(result, item, equalityComparer); + } + return result; + } + /** + * Deduplicates an unsorted array. + * @param equalityComparer An `EqualityComparer` used to determine if two values are duplicates. + * @param comparer An optional `Comparer` used to sort entries before comparison, though the + * result will remain in the original order in `array`. + */ + function deduplicate(array, equalityComparer, comparer) { + return array.length === 0 ? [] : + array.length === 1 ? array.slice() : + comparer ? deduplicateRelational(array, equalityComparer, comparer) : + deduplicateEquality(array, equalityComparer); + } + ts.deduplicate = deduplicate; + /** + * Deduplicates an array that has already been sorted. + */ + function deduplicateSorted(array, comparer) { + if (array.length === 0) + return ts.emptyArray; + var last = array[0]; + var deduplicated = [last]; + for (var i = 1; i < array.length; i++) { + var next = array[i]; + switch (comparer(next, last)) { + // equality comparison + case true: + // relational comparison + // falls through + case 0 /* Comparison.EqualTo */: + continue; + case -1 /* Comparison.LessThan */: + // If `array` is sorted, `next` should **never** be less than `last`. + return ts.Debug.fail("Array is unsorted."); + } + deduplicated.push(last = next); + } + return deduplicated; + } + function createSortedArray() { + return []; // TODO: GH#19873 + } + ts.createSortedArray = createSortedArray; + function insertSorted(array, insert, compare, allowDuplicates) { + if (array.length === 0) { + array.push(insert); + return true; + } + var insertIndex = binarySearch(array, insert, identity, compare); + if (insertIndex < 0) { + array.splice(~insertIndex, 0, insert); + return true; + } + if (allowDuplicates) { + array.splice(insertIndex, 0, insert); + return true; + } + return false; + } + ts.insertSorted = insertSorted; + function sortAndDeduplicate(array, comparer, equalityComparer) { + return deduplicateSorted(sort(array, comparer), equalityComparer || comparer || compareStringsCaseSensitive); + } + ts.sortAndDeduplicate = sortAndDeduplicate; + function arrayIsSorted(array, comparer) { + if (array.length < 2) + return true; + var prevElement = array[0]; + for (var _i = 0, _a = array.slice(1); _i < _a.length; _i++) { + var element = _a[_i]; + if (comparer(prevElement, element) === 1 /* Comparison.GreaterThan */) { + return false; + } + prevElement = element; + } + return true; + } + ts.arrayIsSorted = arrayIsSorted; + function arrayIsEqualTo(array1, array2, equalityComparer) { + if (equalityComparer === void 0) { equalityComparer = equateValues; } + if (!array1 || !array2) { + return array1 === array2; + } + if (array1.length !== array2.length) { + return false; + } + for (var i = 0; i < array1.length; i++) { + if (!equalityComparer(array1[i], array2[i], i)) { + return false; + } + } + return true; + } + ts.arrayIsEqualTo = arrayIsEqualTo; + function compact(array) { + var result; + if (array) { + for (var i = 0; i < array.length; i++) { + var v = array[i]; + if (result || !v) { + if (!result) { + result = array.slice(0, i); + } + if (v) { + result.push(v); + } + } + } + } + return result || array; + } + ts.compact = compact; + /** + * Gets the relative complement of `arrayA` with respect to `arrayB`, returning the elements that + * are not present in `arrayA` but are present in `arrayB`. Assumes both arrays are sorted + * based on the provided comparer. + */ + function relativeComplement(arrayA, arrayB, comparer) { + if (!arrayB || !arrayA || arrayB.length === 0 || arrayA.length === 0) + return arrayB; + var result = []; + loopB: for (var offsetA = 0, offsetB = 0; offsetB < arrayB.length; offsetB++) { + if (offsetB > 0) { + // Ensure `arrayB` is properly sorted. + ts.Debug.assertGreaterThanOrEqual(comparer(arrayB[offsetB], arrayB[offsetB - 1]), 0 /* Comparison.EqualTo */); + } + loopA: for (var startA = offsetA; offsetA < arrayA.length; offsetA++) { + if (offsetA > startA) { + // Ensure `arrayA` is properly sorted. We only need to perform this check if + // `offsetA` has changed since we entered the loop. + ts.Debug.assertGreaterThanOrEqual(comparer(arrayA[offsetA], arrayA[offsetA - 1]), 0 /* Comparison.EqualTo */); + } + switch (comparer(arrayB[offsetB], arrayA[offsetA])) { + case -1 /* Comparison.LessThan */: + // If B is less than A, B does not exist in arrayA. Add B to the result and + // move to the next element in arrayB without changing the current position + // in arrayA. + result.push(arrayB[offsetB]); + continue loopB; + case 0 /* Comparison.EqualTo */: + // If B is equal to A, B exists in arrayA. Move to the next element in + // arrayB without adding B to the result or changing the current position + // in arrayA. + continue loopB; + case 1 /* Comparison.GreaterThan */: + // If B is greater than A, we need to keep looking for B in arrayA. Move to + // the next element in arrayA and recheck. + continue loopA; + } + } + } + return result; + } + ts.relativeComplement = relativeComplement; + function sum(array, prop) { + var result = 0; + for (var _i = 0, array_5 = array; _i < array_5.length; _i++) { + var v = array_5[_i]; + result += v[prop]; + } + return result; + } + ts.sum = sum; + function append(to, value) { + if (value === undefined) + return to; + if (to === undefined) + return [value]; + to.push(value); + return to; + } + ts.append = append; + function combine(xs, ys) { + if (xs === undefined) + return ys; + if (ys === undefined) + return xs; + if (isArray(xs)) + return isArray(ys) ? concatenate(xs, ys) : append(xs, ys); + if (isArray(ys)) + return append(ys, xs); + return [xs, ys]; + } + ts.combine = combine; + /** + * Gets the actual offset into an array for a relative offset. Negative offsets indicate a + * position offset from the end of the array. + */ + function toOffset(array, offset) { + return offset < 0 ? array.length + offset : offset; + } + function addRange(to, from, start, end) { + if (from === undefined || from.length === 0) + return to; + if (to === undefined) + return from.slice(start, end); + start = start === undefined ? 0 : toOffset(from, start); + end = end === undefined ? from.length : toOffset(from, end); + for (var i = start; i < end && i < from.length; i++) { + if (from[i] !== undefined) { + to.push(from[i]); + } + } + return to; + } + ts.addRange = addRange; + /** + * @return Whether the value was added. + */ + function pushIfUnique(array, toAdd, equalityComparer) { + if (contains(array, toAdd, equalityComparer)) { + return false; + } + else { + array.push(toAdd); + return true; + } + } + ts.pushIfUnique = pushIfUnique; + /** + * Unlike `pushIfUnique`, this can take `undefined` as an input, and returns a new array. + */ + function appendIfUnique(array, toAdd, equalityComparer) { + if (array) { + pushIfUnique(array, toAdd, equalityComparer); + return array; + } + else { + return [toAdd]; + } + } + ts.appendIfUnique = appendIfUnique; + function stableSortIndices(array, indices, comparer) { + // sort indices by value then position + indices.sort(function (x, y) { return comparer(array[x], array[y]) || compareValues(x, y); }); + } + /** + * Returns a new sorted array. + */ + function sort(array, comparer) { + return (array.length === 0 ? array : array.slice().sort(comparer)); + } + ts.sort = sort; + function arrayIterator(array) { + var i = 0; + return { next: function () { + if (i === array.length) { + return { value: undefined, done: true }; + } + else { + i++; + return { value: array[i - 1], done: false }; + } + } }; + } + ts.arrayIterator = arrayIterator; + function arrayReverseIterator(array) { + var i = array.length; + return { + next: function () { + if (i === 0) { + return { value: undefined, done: true }; + } + else { + i--; + return { value: array[i], done: false }; + } + } + }; + } + ts.arrayReverseIterator = arrayReverseIterator; + /** + * Stable sort of an array. Elements equal to each other maintain their relative position in the array. + */ + function stableSort(array, comparer) { + var indices = indicesOf(array); + stableSortIndices(array, indices, comparer); + return indices.map(function (i) { return array[i]; }); + } + ts.stableSort = stableSort; + function rangeEquals(array1, array2, pos, end) { + while (pos < end) { + if (array1[pos] !== array2[pos]) { + return false; + } + pos++; + } + return true; + } + ts.rangeEquals = rangeEquals; + /** + * Returns the element at a specific offset in an array if non-empty, `undefined` otherwise. + * A negative offset indicates the element should be retrieved from the end of the array. + */ + function elementAt(array, offset) { + if (array) { + offset = toOffset(array, offset); + if (offset < array.length) { + return array[offset]; + } + } + return undefined; + } + ts.elementAt = elementAt; + /** + * Returns the first element of an array if non-empty, `undefined` otherwise. + */ + function firstOrUndefined(array) { + return array === undefined || array.length === 0 ? undefined : array[0]; + } + ts.firstOrUndefined = firstOrUndefined; + function first(array) { + ts.Debug.assert(array.length !== 0); + return array[0]; + } + ts.first = first; + /** + * Returns the last element of an array if non-empty, `undefined` otherwise. + */ + function lastOrUndefined(array) { + return array === undefined || array.length === 0 ? undefined : array[array.length - 1]; + } + ts.lastOrUndefined = lastOrUndefined; + function last(array) { + ts.Debug.assert(array.length !== 0); + return array[array.length - 1]; + } + ts.last = last; + /** + * Returns the only element of an array if it contains only one element, `undefined` otherwise. + */ + function singleOrUndefined(array) { + return array && array.length === 1 + ? array[0] + : undefined; + } + ts.singleOrUndefined = singleOrUndefined; + /** + * Returns the only element of an array if it contains only one element; throws otherwise. + */ + function single(array) { + return ts.Debug.checkDefined(singleOrUndefined(array)); + } + ts.single = single; + function singleOrMany(array) { + return array && array.length === 1 + ? array[0] + : array; + } + ts.singleOrMany = singleOrMany; + function replaceElement(array, index, value) { + var result = array.slice(0); + result[index] = value; + return result; + } + ts.replaceElement = replaceElement; + /** + * Performs a binary search, finding the index at which `value` occurs in `array`. + * If no such index is found, returns the 2's-complement of first index at which + * `array[index]` exceeds `value`. + * @param array A sorted array whose first element must be no larger than number + * @param value The value to be searched for in the array. + * @param keySelector A callback used to select the search key from `value` and each element of + * `array`. + * @param keyComparer A callback used to compare two keys in a sorted array. + * @param offset An offset into `array` at which to start the search. + */ + function binarySearch(array, value, keySelector, keyComparer, offset) { + return binarySearchKey(array, keySelector(value), keySelector, keyComparer, offset); + } + ts.binarySearch = binarySearch; + /** + * Performs a binary search, finding the index at which an object with `key` occurs in `array`. + * If no such index is found, returns the 2's-complement of first index at which + * `array[index]` exceeds `key`. + * @param array A sorted array whose first element must be no larger than number + * @param key The key to be searched for in the array. + * @param keySelector A callback used to select the search key from each element of `array`. + * @param keyComparer A callback used to compare two keys in a sorted array. + * @param offset An offset into `array` at which to start the search. + */ + function binarySearchKey(array, key, keySelector, keyComparer, offset) { + if (!some(array)) { + return -1; + } + var low = offset || 0; + var high = array.length - 1; + while (low <= high) { + var middle = low + ((high - low) >> 1); + var midKey = keySelector(array[middle], middle); + switch (keyComparer(midKey, key)) { + case -1 /* Comparison.LessThan */: + low = middle + 1; + break; + case 0 /* Comparison.EqualTo */: + return middle; + case 1 /* Comparison.GreaterThan */: + high = middle - 1; + break; + } + } + return ~low; + } + ts.binarySearchKey = binarySearchKey; + function reduceLeft(array, f, initial, start, count) { + if (array && array.length > 0) { + var size = array.length; + if (size > 0) { + var pos = start === undefined || start < 0 ? 0 : start; + var end = count === undefined || pos + count > size - 1 ? size - 1 : pos + count; + var result = void 0; + if (arguments.length <= 2) { + result = array[pos]; + pos++; + } + else { + result = initial; + } + while (pos <= end) { + result = f(result, array[pos], pos); + pos++; + } + return result; + } + } + return initial; + } + ts.reduceLeft = reduceLeft; + var hasOwnProperty = Object.prototype.hasOwnProperty; + /** + * Indicates whether a map-like contains an own property with the specified key. + * + * @param map A map-like. + * @param key A property key. + */ + function hasProperty(map, key) { + return hasOwnProperty.call(map, key); + } + ts.hasProperty = hasProperty; + /** + * Gets the value of an owned property in a map-like. + * + * @param map A map-like. + * @param key A property key. + */ + function getProperty(map, key) { + return hasOwnProperty.call(map, key) ? map[key] : undefined; + } + ts.getProperty = getProperty; + /** + * Gets the owned, enumerable property keys of a map-like. + */ + function getOwnKeys(map) { + var keys = []; + for (var key in map) { + if (hasOwnProperty.call(map, key)) { + keys.push(key); + } + } + return keys; + } + ts.getOwnKeys = getOwnKeys; + function getAllKeys(obj) { + var result = []; + do { + var names = Object.getOwnPropertyNames(obj); + for (var _i = 0, names_1 = names; _i < names_1.length; _i++) { + var name = names_1[_i]; + pushIfUnique(result, name); + } + } while (obj = Object.getPrototypeOf(obj)); + return result; + } + ts.getAllKeys = getAllKeys; + function getOwnValues(collection) { + var values = []; + for (var key in collection) { + if (hasOwnProperty.call(collection, key)) { + values.push(collection[key]); + } + } + return values; + } + ts.getOwnValues = getOwnValues; + var _entries = Object.entries || (function (obj) { + var keys = getOwnKeys(obj); + var result = Array(keys.length); + for (var i = 0; i < keys.length; i++) { + result[i] = [keys[i], obj[keys[i]]]; + } + return result; + }); + function getEntries(obj) { + return obj ? _entries(obj) : []; + } + ts.getEntries = getEntries; + function arrayOf(count, f) { + var result = new Array(count); + for (var i = 0; i < count; i++) { + result[i] = f(i); + } + return result; + } + ts.arrayOf = arrayOf; + function arrayFrom(iterator, map) { + var result = []; + for (var iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) { + result.push(map ? map(iterResult.value) : iterResult.value); + } + return result; + } + ts.arrayFrom = arrayFrom; + function assign(t) { + var args = []; + for (var _i = 1; _i < arguments.length; _i++) { + args[_i - 1] = arguments[_i]; + } + for (var _a = 0, args_1 = args; _a < args_1.length; _a++) { + var arg = args_1[_a]; + if (arg === undefined) + continue; + for (var p in arg) { + if (hasProperty(arg, p)) { + t[p] = arg[p]; + } + } + } + return t; + } + ts.assign = assign; + /** + * Performs a shallow equality comparison of the contents of two map-likes. + * + * @param left A map-like whose properties should be compared. + * @param right A map-like whose properties should be compared. + */ + function equalOwnProperties(left, right, equalityComparer) { + if (equalityComparer === void 0) { equalityComparer = equateValues; } + if (left === right) + return true; + if (!left || !right) + return false; + for (var key in left) { + if (hasOwnProperty.call(left, key)) { + if (!hasOwnProperty.call(right, key)) + return false; + if (!equalityComparer(left[key], right[key])) + return false; + } + } + for (var key in right) { + if (hasOwnProperty.call(right, key)) { + if (!hasOwnProperty.call(left, key)) + return false; + } + } + return true; + } + ts.equalOwnProperties = equalOwnProperties; + function arrayToMap(array, makeKey, makeValue) { + if (makeValue === void 0) { makeValue = identity; } + var result = new ts.Map(); + for (var _i = 0, array_6 = array; _i < array_6.length; _i++) { + var value = array_6[_i]; + var key = makeKey(value); + if (key !== undefined) + result.set(key, makeValue(value)); + } + return result; + } + ts.arrayToMap = arrayToMap; + function arrayToNumericMap(array, makeKey, makeValue) { + if (makeValue === void 0) { makeValue = identity; } + var result = []; + for (var _i = 0, array_7 = array; _i < array_7.length; _i++) { + var value = array_7[_i]; + result[makeKey(value)] = makeValue(value); + } + return result; + } + ts.arrayToNumericMap = arrayToNumericMap; + function arrayToMultiMap(values, makeKey, makeValue) { + if (makeValue === void 0) { makeValue = identity; } + var result = createMultiMap(); + for (var _i = 0, values_1 = values; _i < values_1.length; _i++) { + var value = values_1[_i]; + result.add(makeKey(value), makeValue(value)); + } + return result; + } + ts.arrayToMultiMap = arrayToMultiMap; + function group(values, getGroupId, resultSelector) { + if (resultSelector === void 0) { resultSelector = identity; } + return arrayFrom(arrayToMultiMap(values, getGroupId).values(), resultSelector); + } + ts.group = group; + function clone(object) { + var result = {}; + for (var id in object) { + if (hasOwnProperty.call(object, id)) { + result[id] = object[id]; + } + } + return result; + } + ts.clone = clone; + /** + * Creates a new object by adding the own properties of `second`, then the own properties of `first`. + * + * NOTE: This means that if a property exists in both `first` and `second`, the property in `first` will be chosen. + */ + function extend(first, second) { + var result = {}; + for (var id in second) { + if (hasOwnProperty.call(second, id)) { + result[id] = second[id]; + } + } + for (var id in first) { + if (hasOwnProperty.call(first, id)) { + result[id] = first[id]; + } + } + return result; + } + ts.extend = extend; + function copyProperties(first, second) { + for (var id in second) { + if (hasOwnProperty.call(second, id)) { + first[id] = second[id]; + } + } + } + ts.copyProperties = copyProperties; + function maybeBind(obj, fn) { + return fn ? fn.bind(obj) : undefined; + } + ts.maybeBind = maybeBind; + function createMultiMap() { + var map = new ts.Map(); + map.add = multiMapAdd; + map.remove = multiMapRemove; + return map; + } + ts.createMultiMap = createMultiMap; + function multiMapAdd(key, value) { + var values = this.get(key); + if (values) { + values.push(value); + } + else { + this.set(key, values = [value]); + } + return values; + } + function multiMapRemove(key, value) { + var values = this.get(key); + if (values) { + unorderedRemoveItem(values, value); + if (!values.length) { + this.delete(key); + } + } + } + function createUnderscoreEscapedMultiMap() { + return createMultiMap(); + } + ts.createUnderscoreEscapedMultiMap = createUnderscoreEscapedMultiMap; + function createQueue(items) { + var elements = (items === null || items === void 0 ? void 0 : items.slice()) || []; + var headIndex = 0; + function isEmpty() { + return headIndex === elements.length; + } + function enqueue() { + var items = []; + for (var _i = 0; _i < arguments.length; _i++) { + items[_i] = arguments[_i]; + } + elements.push.apply(elements, items); + } + function dequeue() { + if (isEmpty()) { + throw new Error("Queue is empty"); + } + var result = elements[headIndex]; + elements[headIndex] = undefined; // Don't keep referencing dequeued item + headIndex++; + // If more than half of the queue is empty, copy the remaining elements to the + // front and shrink the array (unless we'd be saving fewer than 100 slots) + if (headIndex > 100 && headIndex > (elements.length >> 1)) { + var newLength = elements.length - headIndex; + elements.copyWithin(/*target*/ 0, /*start*/ headIndex); + elements.length = newLength; + headIndex = 0; + } + return result; + } + return { + enqueue: enqueue, + dequeue: dequeue, + isEmpty: isEmpty, + }; + } + ts.createQueue = createQueue; + /** + * Creates a Set with custom equality and hash code functionality. This is useful when you + * want to use something looser than object identity - e.g. "has the same span". + * + * If `equals(a, b)`, it must be the case that `getHashCode(a) === getHashCode(b)`. + * The converse is not required. + * + * To facilitate a perf optimization (lazy allocation of bucket arrays), `TElement` is + * assumed not to be an array type. + */ + function createSet(getHashCode, equals) { + var multiMap = new ts.Map(); + var size = 0; + function getElementIterator() { + var valueIt = multiMap.values(); + var arrayIt; + return { + next: function () { + while (true) { + if (arrayIt) { + var n = arrayIt.next(); + if (!n.done) { + return { value: n.value }; + } + arrayIt = undefined; + } + else { + var n = valueIt.next(); + if (n.done) { + return { value: undefined, done: true }; + } + if (!isArray(n.value)) { + return { value: n.value }; + } + arrayIt = arrayIterator(n.value); + } + } + } + }; + } + var set = { + has: function (element) { + var hash = getHashCode(element); + if (!multiMap.has(hash)) + return false; + var candidates = multiMap.get(hash); + if (!isArray(candidates)) + return equals(candidates, element); + for (var _i = 0, candidates_1 = candidates; _i < candidates_1.length; _i++) { + var candidate = candidates_1[_i]; + if (equals(candidate, element)) { + return true; + } + } + return false; + }, + add: function (element) { + var hash = getHashCode(element); + if (multiMap.has(hash)) { + var values = multiMap.get(hash); + if (isArray(values)) { + if (!contains(values, element, equals)) { + values.push(element); + size++; + } + } + else { + var value = values; + if (!equals(value, element)) { + multiMap.set(hash, [value, element]); + size++; + } + } + } + else { + multiMap.set(hash, element); + size++; + } + return this; + }, + delete: function (element) { + var hash = getHashCode(element); + if (!multiMap.has(hash)) + return false; + var candidates = multiMap.get(hash); + if (isArray(candidates)) { + for (var i = 0; i < candidates.length; i++) { + if (equals(candidates[i], element)) { + if (candidates.length === 1) { + multiMap.delete(hash); + } + else if (candidates.length === 2) { + multiMap.set(hash, candidates[1 - i]); + } + else { + unorderedRemoveItemAt(candidates, i); + } + size--; + return true; + } + } + } + else { + var candidate = candidates; + if (equals(candidate, element)) { + multiMap.delete(hash); + size--; + return true; + } + } + return false; + }, + clear: function () { + multiMap.clear(); + size = 0; + }, + get size() { + return size; + }, + forEach: function (action) { + for (var _i = 0, _a = arrayFrom(multiMap.values()); _i < _a.length; _i++) { + var elements = _a[_i]; + if (isArray(elements)) { + for (var _b = 0, elements_1 = elements; _b < elements_1.length; _b++) { + var element = elements_1[_b]; + action(element, element); + } + } + else { + var element = elements; + action(element, element); + } + } + }, + keys: function () { + return getElementIterator(); + }, + values: function () { + return getElementIterator(); + }, + entries: function () { + var it = getElementIterator(); + return { + next: function () { + var n = it.next(); + return n.done ? n : { value: [n.value, n.value] }; + } + }; + }, + }; + return set; + } + ts.createSet = createSet; + /** + * Tests whether a value is an array. + */ + function isArray(value) { + return Array.isArray ? Array.isArray(value) : value instanceof Array; + } + ts.isArray = isArray; + function toArray(value) { + return isArray(value) ? value : [value]; + } + ts.toArray = toArray; + /** + * Tests whether a value is string + */ + function isString(text) { + return typeof text === "string"; + } + ts.isString = isString; + function isNumber(x) { + return typeof x === "number"; + } + ts.isNumber = isNumber; + function tryCast(value, test) { + return value !== undefined && test(value) ? value : undefined; + } + ts.tryCast = tryCast; + function cast(value, test) { + if (value !== undefined && test(value)) + return value; + return ts.Debug.fail("Invalid cast. The supplied value ".concat(value, " did not pass the test '").concat(ts.Debug.getFunctionName(test), "'.")); + } + ts.cast = cast; + /** Does nothing. */ + function noop(_) { } + ts.noop = noop; + ts.noopPush = { + push: noop, + length: 0 + }; + /** Do nothing and return false */ + function returnFalse() { + return false; + } + ts.returnFalse = returnFalse; + /** Do nothing and return true */ + function returnTrue() { + return true; + } + ts.returnTrue = returnTrue; + /** Do nothing and return undefined */ + function returnUndefined() { + return undefined; + } + ts.returnUndefined = returnUndefined; + /** Returns its argument. */ + function identity(x) { + return x; + } + ts.identity = identity; + /** Returns lower case string */ + function toLowerCase(x) { + return x.toLowerCase(); + } + ts.toLowerCase = toLowerCase; + // We convert the file names to lower case as key for file name on case insensitive file system + // While doing so we need to handle special characters (eg \u0130) to ensure that we dont convert + // it to lower case, fileName with its lowercase form can exist along side it. + // Handle special characters and make those case sensitive instead + // + // |-#--|-Unicode--|-Char code-|-Desc-------------------------------------------------------------------| + // | 1. | i | 105 | Ascii i | + // | 2. | I | 73 | Ascii I | + // |-------- Special characters ------------------------------------------------------------------------| + // | 3. | \u0130 | 304 | Upper case I with dot above | + // | 4. | i,\u0307 | 105,775 | i, followed by 775: Lower case of (3rd item) | + // | 5. | I,\u0307 | 73,775 | I, followed by 775: Upper case of (4th item), lower case is (4th item) | + // | 6. | \u0131 | 305 | Lower case i without dot, upper case is I (2nd item) | + // | 7. | \u00DF | 223 | Lower case sharp s | + // + // Because item 3 is special where in its lowercase character has its own + // upper case form we cant convert its case. + // Rest special characters are either already in lower case format or + // they have corresponding upper case character so they dont need special handling + // + // But to avoid having to do string building for most common cases, also ignore + // a-z, 0-9, \u0131, \u00DF, \, /, ., : and space + var fileNameLowerCaseRegExp = /[^\u0130\u0131\u00DFa-z0-9\\/:\-_\. ]+/g; + /** + * Case insensitive file systems have descripencies in how they handle some characters (eg. turkish Upper case I with dot on top - \u0130) + * This function is used in places where we want to make file name as a key on these systems + * It is possible on mac to be able to refer to file name with I with dot on top as a fileName with its lower case form + * But on windows we cannot. Windows can have fileName with I with dot on top next to its lower case and they can not each be referred with the lowercase forms + * Technically we would want this function to be platform sepcific as well but + * our api has till now only taken caseSensitive as the only input and just for some characters we dont want to update API and ensure all customers use those api + * We could use upper case and we would still need to deal with the descripencies but + * we want to continue using lower case since in most cases filenames are lowercasewe and wont need any case changes and avoid having to store another string for the key + * So for this function purpose, we go ahead and assume character I with dot on top it as case sensitive since its very unlikely to use lower case form of that special character + */ + function toFileNameLowerCase(x) { + return fileNameLowerCaseRegExp.test(x) ? + x.replace(fileNameLowerCaseRegExp, toLowerCase) : + x; + } + ts.toFileNameLowerCase = toFileNameLowerCase; + /** Throws an error because a function is not implemented. */ + function notImplemented() { + throw new Error("Not implemented"); + } + ts.notImplemented = notImplemented; + function memoize(callback) { + var value; + return function () { + if (callback) { + value = callback(); + callback = undefined; + } + return value; + }; + } + ts.memoize = memoize; + /** A version of `memoize` that supports a single primitive argument */ + function memoizeOne(callback) { + var map = new ts.Map(); + return function (arg) { + var key = "".concat(typeof arg, ":").concat(arg); + var value = map.get(key); + if (value === undefined && !map.has(key)) { + value = callback(arg); + map.set(key, value); + } + return value; + }; + } + ts.memoizeOne = memoizeOne; + function compose(a, b, c, d, e) { + if (!!e) { + var args_2 = []; + for (var i = 0; i < arguments.length; i++) { + args_2[i] = arguments[i]; + } + return function (t) { return reduceLeft(args_2, function (u, f) { return f(u); }, t); }; + } + else if (d) { + return function (t) { return d(c(b(a(t)))); }; + } + else if (c) { + return function (t) { return c(b(a(t))); }; + } + else if (b) { + return function (t) { return b(a(t)); }; + } + else if (a) { + return function (t) { return a(t); }; + } + else { + return function (t) { return t; }; + } + } + ts.compose = compose; + var AssertionLevel; + (function (AssertionLevel) { + AssertionLevel[AssertionLevel["None"] = 0] = "None"; + AssertionLevel[AssertionLevel["Normal"] = 1] = "Normal"; + AssertionLevel[AssertionLevel["Aggressive"] = 2] = "Aggressive"; + AssertionLevel[AssertionLevel["VeryAggressive"] = 3] = "VeryAggressive"; + })(AssertionLevel = ts.AssertionLevel || (ts.AssertionLevel = {})); + function equateValues(a, b) { + return a === b; + } + ts.equateValues = equateValues; + /** + * Compare the equality of two strings using a case-sensitive ordinal comparison. + * + * Case-sensitive comparisons compare both strings one code-point at a time using the integer + * value of each code-point after applying `toUpperCase` to each string. We always map both + * strings to their upper-case form as some unicode characters do not properly round-trip to + * lowercase (such as `ẞ` (German sharp capital s)). + */ + function equateStringsCaseInsensitive(a, b) { + return a === b + || a !== undefined + && b !== undefined + && a.toUpperCase() === b.toUpperCase(); + } + ts.equateStringsCaseInsensitive = equateStringsCaseInsensitive; + /** + * Compare the equality of two strings using a case-sensitive ordinal comparison. + * + * Case-sensitive comparisons compare both strings one code-point at a time using the + * integer value of each code-point. + */ + function equateStringsCaseSensitive(a, b) { + return equateValues(a, b); + } + ts.equateStringsCaseSensitive = equateStringsCaseSensitive; + function compareComparableValues(a, b) { + return a === b ? 0 /* Comparison.EqualTo */ : + a === undefined ? -1 /* Comparison.LessThan */ : + b === undefined ? 1 /* Comparison.GreaterThan */ : + a < b ? -1 /* Comparison.LessThan */ : + 1 /* Comparison.GreaterThan */; + } + /** + * Compare two numeric values for their order relative to each other. + * To compare strings, use any of the `compareStrings` functions. + */ + function compareValues(a, b) { + return compareComparableValues(a, b); + } + ts.compareValues = compareValues; + /** + * Compare two TextSpans, first by `start`, then by `length`. + */ + function compareTextSpans(a, b) { + return compareValues(a === null || a === void 0 ? void 0 : a.start, b === null || b === void 0 ? void 0 : b.start) || compareValues(a === null || a === void 0 ? void 0 : a.length, b === null || b === void 0 ? void 0 : b.length); + } + ts.compareTextSpans = compareTextSpans; + function min(items, compare) { + return reduceLeft(items, function (x, y) { return compare(x, y) === -1 /* Comparison.LessThan */ ? x : y; }); + } + ts.min = min; + /** + * Compare two strings using a case-insensitive ordinal comparison. + * + * Ordinal comparisons are based on the difference between the unicode code points of both + * strings. Characters with multiple unicode representations are considered unequal. Ordinal + * comparisons provide predictable ordering, but place "a" after "B". + * + * Case-insensitive comparisons compare both strings one code-point at a time using the integer + * value of each code-point after applying `toUpperCase` to each string. We always map both + * strings to their upper-case form as some unicode characters do not properly round-trip to + * lowercase (such as `ẞ` (German sharp capital s)). + */ + function compareStringsCaseInsensitive(a, b) { + if (a === b) + return 0 /* Comparison.EqualTo */; + if (a === undefined) + return -1 /* Comparison.LessThan */; + if (b === undefined) + return 1 /* Comparison.GreaterThan */; + a = a.toUpperCase(); + b = b.toUpperCase(); + return a < b ? -1 /* Comparison.LessThan */ : a > b ? 1 /* Comparison.GreaterThan */ : 0 /* Comparison.EqualTo */; + } + ts.compareStringsCaseInsensitive = compareStringsCaseInsensitive; + /** + * Compare two strings using a case-sensitive ordinal comparison. + * + * Ordinal comparisons are based on the difference between the unicode code points of both + * strings. Characters with multiple unicode representations are considered unequal. Ordinal + * comparisons provide predictable ordering, but place "a" after "B". + * + * Case-sensitive comparisons compare both strings one code-point at a time using the integer + * value of each code-point. + */ + function compareStringsCaseSensitive(a, b) { + return compareComparableValues(a, b); + } + ts.compareStringsCaseSensitive = compareStringsCaseSensitive; + function getStringComparer(ignoreCase) { + return ignoreCase ? compareStringsCaseInsensitive : compareStringsCaseSensitive; + } + ts.getStringComparer = getStringComparer; + /** + * Creates a string comparer for use with string collation in the UI. + */ + var createUIStringComparer = (function () { + var defaultComparer; + var enUSComparer; + var stringComparerFactory = getStringComparerFactory(); + return createStringComparer; + function compareWithCallback(a, b, comparer) { + if (a === b) + return 0 /* Comparison.EqualTo */; + if (a === undefined) + return -1 /* Comparison.LessThan */; + if (b === undefined) + return 1 /* Comparison.GreaterThan */; + var value = comparer(a, b); + return value < 0 ? -1 /* Comparison.LessThan */ : value > 0 ? 1 /* Comparison.GreaterThan */ : 0 /* Comparison.EqualTo */; + } + function createIntlCollatorStringComparer(locale) { + // Intl.Collator.prototype.compare is bound to the collator. See NOTE in + // http://www.ecma-international.org/ecma-402/2.0/#sec-Intl.Collator.prototype.compare + var comparer = new Intl.Collator(locale, { usage: "sort", sensitivity: "variant" }).compare; + return function (a, b) { return compareWithCallback(a, b, comparer); }; + } + function createLocaleCompareStringComparer(locale) { + // if the locale is not the default locale (`undefined`), use the fallback comparer. + if (locale !== undefined) + return createFallbackStringComparer(); + return function (a, b) { return compareWithCallback(a, b, compareStrings); }; + function compareStrings(a, b) { + return a.localeCompare(b); + } + } + function createFallbackStringComparer() { + // An ordinal comparison puts "A" after "b", but for the UI we want "A" before "b". + // We first sort case insensitively. So "Aaa" will come before "baa". + // Then we sort case sensitively, so "aaa" will come before "Aaa". + // + // For case insensitive comparisons we always map both strings to their + // upper-case form as some unicode characters do not properly round-trip to + // lowercase (such as `ẞ` (German sharp capital s)). + return function (a, b) { return compareWithCallback(a, b, compareDictionaryOrder); }; + function compareDictionaryOrder(a, b) { + return compareStrings(a.toUpperCase(), b.toUpperCase()) || compareStrings(a, b); + } + function compareStrings(a, b) { + return a < b ? -1 /* Comparison.LessThan */ : a > b ? 1 /* Comparison.GreaterThan */ : 0 /* Comparison.EqualTo */; + } + } + function getStringComparerFactory() { + // If the host supports Intl, we use it for comparisons using the default locale. + if (typeof Intl === "object" && typeof Intl.Collator === "function") { + return createIntlCollatorStringComparer; + } + // If the host does not support Intl, we fall back to localeCompare. + // localeCompare in Node v0.10 is just an ordinal comparison, so don't use it. + if (typeof String.prototype.localeCompare === "function" && + typeof String.prototype.toLocaleUpperCase === "function" && + "a".localeCompare("B") < 0) { + return createLocaleCompareStringComparer; + } + // Otherwise, fall back to ordinal comparison: + return createFallbackStringComparer; + } + function createStringComparer(locale) { + // Hold onto common string comparers. This avoids constantly reallocating comparers during + // tests. + if (locale === undefined) { + return defaultComparer || (defaultComparer = stringComparerFactory(locale)); + } + else if (locale === "en-US") { + return enUSComparer || (enUSComparer = stringComparerFactory(locale)); + } + else { + return stringComparerFactory(locale); + } + } + })(); + var uiComparerCaseSensitive; + var uiLocale; + function getUILocale() { + return uiLocale; + } + ts.getUILocale = getUILocale; + function setUILocale(value) { + if (uiLocale !== value) { + uiLocale = value; + uiComparerCaseSensitive = undefined; + } + } + ts.setUILocale = setUILocale; + /** + * Compare two strings in a using the case-sensitive sort behavior of the UI locale. + * + * Ordering is not predictable between different host locales, but is best for displaying + * ordered data for UI presentation. Characters with multiple unicode representations may + * be considered equal. + * + * Case-sensitive comparisons compare strings that differ in base characters, or + * accents/diacritic marks, or case as unequal. + */ + function compareStringsCaseSensitiveUI(a, b) { + var comparer = uiComparerCaseSensitive || (uiComparerCaseSensitive = createUIStringComparer(uiLocale)); + return comparer(a, b); + } + ts.compareStringsCaseSensitiveUI = compareStringsCaseSensitiveUI; + function compareProperties(a, b, key, comparer) { + return a === b ? 0 /* Comparison.EqualTo */ : + a === undefined ? -1 /* Comparison.LessThan */ : + b === undefined ? 1 /* Comparison.GreaterThan */ : + comparer(a[key], b[key]); + } + ts.compareProperties = compareProperties; + /** True is greater than false. */ + function compareBooleans(a, b) { + return compareValues(a ? 1 : 0, b ? 1 : 0); + } + ts.compareBooleans = compareBooleans; + /** + * Given a name and a list of names that are *not* equal to the name, return a spelling suggestion if there is one that is close enough. + * Names less than length 3 only check for case-insensitive equality. + * + * find the candidate with the smallest Levenshtein distance, + * except for candidates: + * * With no name + * * Whose length differs from the target name by more than 0.34 of the length of the name. + * * Whose levenshtein distance is more than 0.4 of the length of the name + * (0.4 allows 1 substitution/transposition for every 5 characters, + * and 1 insertion/deletion at 3 characters) + */ + function getSpellingSuggestion(name, candidates, getName) { + var maximumLengthDifference = Math.max(2, Math.floor(name.length * 0.34)); + var bestDistance = Math.floor(name.length * 0.4) + 1; // If the best result is worse than this, don't bother. + var bestCandidate; + for (var _i = 0, candidates_2 = candidates; _i < candidates_2.length; _i++) { + var candidate = candidates_2[_i]; + var candidateName = getName(candidate); + if (candidateName !== undefined && Math.abs(candidateName.length - name.length) <= maximumLengthDifference) { + if (candidateName === name) { + continue; + } + // Only consider candidates less than 3 characters long when they differ by case. + // Otherwise, don't bother, since a user would usually notice differences of a 2-character name. + if (candidateName.length < 3 && candidateName.toLowerCase() !== name.toLowerCase()) { + continue; + } + var distance = levenshteinWithMax(name, candidateName, bestDistance - 0.1); + if (distance === undefined) { + continue; + } + ts.Debug.assert(distance < bestDistance); // Else `levenshteinWithMax` should return undefined + bestDistance = distance; + bestCandidate = candidate; + } + } + return bestCandidate; + } + ts.getSpellingSuggestion = getSpellingSuggestion; + function levenshteinWithMax(s1, s2, max) { + var previous = new Array(s2.length + 1); + var current = new Array(s2.length + 1); + /** Represents any value > max. We don't care about the particular value. */ + var big = max + 0.01; + for (var i = 0; i <= s2.length; i++) { + previous[i] = i; + } + for (var i = 1; i <= s1.length; i++) { + var c1 = s1.charCodeAt(i - 1); + var minJ = Math.ceil(i > max ? i - max : 1); + var maxJ = Math.floor(s2.length > max + i ? max + i : s2.length); + current[0] = i; + /** Smallest value of the matrix in the ith column. */ + var colMin = i; + for (var j = 1; j < minJ; j++) { + current[j] = big; + } + for (var j = minJ; j <= maxJ; j++) { + // case difference should be significantly cheaper than other differences + var substitutionDistance = s1[i - 1].toLowerCase() === s2[j - 1].toLowerCase() + ? (previous[j - 1] + 0.1) + : (previous[j - 1] + 2); + var dist = c1 === s2.charCodeAt(j - 1) + ? previous[j - 1] + : Math.min(/*delete*/ previous[j] + 1, /*insert*/ current[j - 1] + 1, /*substitute*/ substitutionDistance); + current[j] = dist; + colMin = Math.min(colMin, dist); + } + for (var j = maxJ + 1; j <= s2.length; j++) { + current[j] = big; + } + if (colMin > max) { + // Give up -- everything in this column is > max and it can't get better in future columns. + return undefined; + } + var temp = previous; + previous = current; + current = temp; + } + var res = previous[s2.length]; + return res > max ? undefined : res; + } + function endsWith(str, suffix) { + var expectedPos = str.length - suffix.length; + return expectedPos >= 0 && str.indexOf(suffix, expectedPos) === expectedPos; + } + ts.endsWith = endsWith; + function removeSuffix(str, suffix) { + return endsWith(str, suffix) ? str.slice(0, str.length - suffix.length) : str; + } + ts.removeSuffix = removeSuffix; + function tryRemoveSuffix(str, suffix) { + return endsWith(str, suffix) ? str.slice(0, str.length - suffix.length) : undefined; + } + ts.tryRemoveSuffix = tryRemoveSuffix; + function stringContains(str, substring) { + return str.indexOf(substring) !== -1; + } + ts.stringContains = stringContains; + /** + * Takes a string like "jquery-min.4.2.3" and returns "jquery" + */ + function removeMinAndVersionNumbers(fileName) { + // We used to use the regex /[.-]((min)|(\d+(\.\d+)*))$/ and would just .replace it twice. + // Unfortunately, that regex has O(n^2) performance because v8 doesn't match from the end of the string. + // Instead, we now essentially scan the filename (backwards) ourselves. + var end = fileName.length; + for (var pos = end - 1; pos > 0; pos--) { + var ch = fileName.charCodeAt(pos); + if (ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */) { + // Match a \d+ segment + do { + --pos; + ch = fileName.charCodeAt(pos); + } while (pos > 0 && ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */); + } + else if (pos > 4 && (ch === 110 /* CharacterCodes.n */ || ch === 78 /* CharacterCodes.N */)) { + // Looking for "min" or "min" + // Already matched the 'n' + --pos; + ch = fileName.charCodeAt(pos); + if (ch !== 105 /* CharacterCodes.i */ && ch !== 73 /* CharacterCodes.I */) { + break; + } + --pos; + ch = fileName.charCodeAt(pos); + if (ch !== 109 /* CharacterCodes.m */ && ch !== 77 /* CharacterCodes.M */) { + break; + } + --pos; + ch = fileName.charCodeAt(pos); + } + else { + // This character is not part of either suffix pattern + break; + } + if (ch !== 45 /* CharacterCodes.minus */ && ch !== 46 /* CharacterCodes.dot */) { + break; + } + end = pos; + } + // end might be fileName.length, in which case this should internally no-op + return end === fileName.length ? fileName : fileName.slice(0, end); + } + ts.removeMinAndVersionNumbers = removeMinAndVersionNumbers; + /** Remove an item from an array, moving everything to its right one space left. */ + function orderedRemoveItem(array, item) { + for (var i = 0; i < array.length; i++) { + if (array[i] === item) { + orderedRemoveItemAt(array, i); + return true; + } + } + return false; + } + ts.orderedRemoveItem = orderedRemoveItem; + /** Remove an item by index from an array, moving everything to its right one space left. */ + function orderedRemoveItemAt(array, index) { + // This seems to be faster than either `array.splice(i, 1)` or `array.copyWithin(i, i+ 1)`. + for (var i = index; i < array.length - 1; i++) { + array[i] = array[i + 1]; + } + array.pop(); + } + ts.orderedRemoveItemAt = orderedRemoveItemAt; + function unorderedRemoveItemAt(array, index) { + // Fill in the "hole" left at `index`. + array[index] = array[array.length - 1]; + array.pop(); + } + ts.unorderedRemoveItemAt = unorderedRemoveItemAt; + /** Remove the *first* occurrence of `item` from the array. */ + function unorderedRemoveItem(array, item) { + return unorderedRemoveFirstItemWhere(array, function (element) { return element === item; }); + } + ts.unorderedRemoveItem = unorderedRemoveItem; + /** Remove the *first* element satisfying `predicate`. */ + function unorderedRemoveFirstItemWhere(array, predicate) { + for (var i = 0; i < array.length; i++) { + if (predicate(array[i])) { + unorderedRemoveItemAt(array, i); + return true; + } + } + return false; + } + function createGetCanonicalFileName(useCaseSensitiveFileNames) { + return useCaseSensitiveFileNames ? identity : toFileNameLowerCase; + } + ts.createGetCanonicalFileName = createGetCanonicalFileName; + function patternText(_a) { + var prefix = _a.prefix, suffix = _a.suffix; + return "".concat(prefix, "*").concat(suffix); + } + ts.patternText = patternText; + /** + * Given that candidate matches pattern, returns the text matching the '*'. + * E.g.: matchedText(tryParsePattern("foo*baz"), "foobarbaz") === "bar" + */ + function matchedText(pattern, candidate) { + ts.Debug.assert(isPatternMatch(pattern, candidate)); + return candidate.substring(pattern.prefix.length, candidate.length - pattern.suffix.length); + } + ts.matchedText = matchedText; + /** Return the object corresponding to the best pattern to match `candidate`. */ + function findBestPatternMatch(values, getPattern, candidate) { + var matchedValue; + // use length of prefix as betterness criteria + var longestMatchPrefixLength = -1; + for (var _i = 0, values_2 = values; _i < values_2.length; _i++) { + var v = values_2[_i]; + var pattern = getPattern(v); + if (isPatternMatch(pattern, candidate) && pattern.prefix.length > longestMatchPrefixLength) { + longestMatchPrefixLength = pattern.prefix.length; + matchedValue = v; + } + } + return matchedValue; + } + ts.findBestPatternMatch = findBestPatternMatch; + function startsWith(str, prefix) { + return str.lastIndexOf(prefix, 0) === 0; + } + ts.startsWith = startsWith; + function removePrefix(str, prefix) { + return startsWith(str, prefix) ? str.substr(prefix.length) : str; + } + ts.removePrefix = removePrefix; + function tryRemovePrefix(str, prefix, getCanonicalFileName) { + if (getCanonicalFileName === void 0) { getCanonicalFileName = identity; } + return startsWith(getCanonicalFileName(str), getCanonicalFileName(prefix)) ? str.substring(prefix.length) : undefined; + } + ts.tryRemovePrefix = tryRemovePrefix; + function isPatternMatch(_a, candidate) { + var prefix = _a.prefix, suffix = _a.suffix; + return candidate.length >= prefix.length + suffix.length && + startsWith(candidate, prefix) && + endsWith(candidate, suffix); + } + ts.isPatternMatch = isPatternMatch; + function and(f, g) { + return function (arg) { return f(arg) && g(arg); }; + } + ts.and = and; + function or() { + var fs = []; + for (var _i = 0; _i < arguments.length; _i++) { + fs[_i] = arguments[_i]; + } + return function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + var lastResult; + for (var _a = 0, fs_1 = fs; _a < fs_1.length; _a++) { + var f = fs_1[_a]; + lastResult = f.apply(void 0, args); + if (lastResult) { + return lastResult; + } + } + return lastResult; + }; + } + ts.or = or; + function not(fn) { + return function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + return !fn.apply(void 0, args); + }; + } + ts.not = not; + function assertType(_) { } + ts.assertType = assertType; + function singleElementArray(t) { + return t === undefined ? undefined : [t]; + } + ts.singleElementArray = singleElementArray; + function enumerateInsertsAndDeletes(newItems, oldItems, comparer, inserted, deleted, unchanged) { + unchanged = unchanged || noop; + var newIndex = 0; + var oldIndex = 0; + var newLen = newItems.length; + var oldLen = oldItems.length; + var hasChanges = false; + while (newIndex < newLen && oldIndex < oldLen) { + var newItem = newItems[newIndex]; + var oldItem = oldItems[oldIndex]; + var compareResult = comparer(newItem, oldItem); + if (compareResult === -1 /* Comparison.LessThan */) { + inserted(newItem); + newIndex++; + hasChanges = true; + } + else if (compareResult === 1 /* Comparison.GreaterThan */) { + deleted(oldItem); + oldIndex++; + hasChanges = true; + } + else { + unchanged(oldItem, newItem); + newIndex++; + oldIndex++; + } + } + while (newIndex < newLen) { + inserted(newItems[newIndex++]); + hasChanges = true; + } + while (oldIndex < oldLen) { + deleted(oldItems[oldIndex++]); + hasChanges = true; + } + return hasChanges; + } + ts.enumerateInsertsAndDeletes = enumerateInsertsAndDeletes; + function fill(length, cb) { + var result = Array(length); + for (var i = 0; i < length; i++) { + result[i] = cb(i); + } + return result; + } + ts.fill = fill; + function cartesianProduct(arrays) { + var result = []; + cartesianProductWorker(arrays, result, /*outer*/ undefined, 0); + return result; + } + ts.cartesianProduct = cartesianProduct; + function cartesianProductWorker(arrays, result, outer, index) { + for (var _i = 0, _a = arrays[index]; _i < _a.length; _i++) { + var element = _a[_i]; + var inner = void 0; + if (outer) { + inner = outer.slice(); + inner.push(element); + } + else { + inner = [element]; + } + if (index === arrays.length - 1) { + result.push(inner); + } + else { + cartesianProductWorker(arrays, result, inner, index + 1); + } + } + } + /** + * Returns string left-padded with spaces or zeros until it reaches the given length. + * + * @param s String to pad. + * @param length Final padded length. If less than or equal to 's.length', returns 's' unchanged. + * @param padString Character to use as padding (default " "). + */ + function padLeft(s, length, padString) { + if (padString === void 0) { padString = " "; } + return length <= s.length ? s : padString.repeat(length - s.length) + s; + } + ts.padLeft = padLeft; + /** + * Returns string right-padded with spaces until it reaches the given length. + * + * @param s String to pad. + * @param length Final padded length. If less than or equal to 's.length', returns 's' unchanged. + * @param padString Character to use as padding (default " "). + */ + function padRight(s, length, padString) { + if (padString === void 0) { padString = " "; } + return length <= s.length ? s : s + padString.repeat(length - s.length); + } + ts.padRight = padRight; + function takeWhile(array, predicate) { + var len = array.length; + var index = 0; + while (index < len && predicate(array[index])) { + index++; + } + return array.slice(0, index); + } + ts.takeWhile = takeWhile; + /** + * Removes the leading and trailing white space and line terminator characters from a string. + */ + ts.trimString = !!String.prototype.trim ? (function (s) { return s.trim(); }) : function (s) { return ts.trimStringEnd(ts.trimStringStart(s)); }; + /** + * Returns a copy with trailing whitespace removed. + */ + ts.trimStringEnd = !!String.prototype.trimEnd ? (function (s) { return s.trimEnd(); }) : trimEndImpl; + /** + * Returns a copy with leading whitespace removed. + */ + ts.trimStringStart = !!String.prototype.trimStart ? (function (s) { return s.trimStart(); }) : function (s) { return s.replace(/^\s+/g, ""); }; + /** + * https://jsbench.me/gjkoxld4au/1 + * The simple regex for this, /\s+$/g is O(n^2) in v8. + * The native .trimEnd method is by far best, but since that's technically ES2019, + * we provide a (still much faster than the simple regex) fallback. + */ + function trimEndImpl(s) { + var end = s.length - 1; + while (end >= 0) { + if (!ts.isWhiteSpaceLike(s.charCodeAt(end))) + break; + end--; + } + return s.slice(0, end + 1); + } +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var LogLevel; + (function (LogLevel) { + LogLevel[LogLevel["Off"] = 0] = "Off"; + LogLevel[LogLevel["Error"] = 1] = "Error"; + LogLevel[LogLevel["Warning"] = 2] = "Warning"; + LogLevel[LogLevel["Info"] = 3] = "Info"; + LogLevel[LogLevel["Verbose"] = 4] = "Verbose"; + })(LogLevel = ts.LogLevel || (ts.LogLevel = {})); + var Debug; + (function (Debug) { + var typeScriptVersion; + /* eslint-disable prefer-const */ + var currentAssertionLevel = 0 /* AssertionLevel.None */; + Debug.currentLogLevel = LogLevel.Warning; + Debug.isDebugging = false; + Debug.enableDeprecationWarnings = true; + function getTypeScriptVersion() { + return typeScriptVersion !== null && typeScriptVersion !== void 0 ? typeScriptVersion : (typeScriptVersion = new ts.Version(ts.version)); + } + Debug.getTypeScriptVersion = getTypeScriptVersion; + function shouldLog(level) { + return Debug.currentLogLevel <= level; + } + Debug.shouldLog = shouldLog; + function logMessage(level, s) { + if (Debug.loggingHost && shouldLog(level)) { + Debug.loggingHost.log(level, s); + } + } + function log(s) { + logMessage(LogLevel.Info, s); + } + Debug.log = log; + (function (log_1) { + function error(s) { + logMessage(LogLevel.Error, s); + } + log_1.error = error; + function warn(s) { + logMessage(LogLevel.Warning, s); + } + log_1.warn = warn; + function log(s) { + logMessage(LogLevel.Info, s); + } + log_1.log = log; + function trace(s) { + logMessage(LogLevel.Verbose, s); + } + log_1.trace = trace; + })(log = Debug.log || (Debug.log = {})); + var assertionCache = {}; + function getAssertionLevel() { + return currentAssertionLevel; + } + Debug.getAssertionLevel = getAssertionLevel; + function setAssertionLevel(level) { + var prevAssertionLevel = currentAssertionLevel; + currentAssertionLevel = level; + if (level > prevAssertionLevel) { + // restore assertion functions for the current assertion level (see `shouldAssertFunction`). + for (var _i = 0, _a = ts.getOwnKeys(assertionCache); _i < _a.length; _i++) { + var key = _a[_i]; + var cachedFunc = assertionCache[key]; + if (cachedFunc !== undefined && Debug[key] !== cachedFunc.assertion && level >= cachedFunc.level) { + Debug[key] = cachedFunc; + assertionCache[key] = undefined; + } + } + } + } + Debug.setAssertionLevel = setAssertionLevel; + function shouldAssert(level) { + return currentAssertionLevel >= level; + } + Debug.shouldAssert = shouldAssert; + /** + * Tests whether an assertion function should be executed. If it shouldn't, it is cached and replaced with `ts.noop`. + * Replaced assertion functions are restored when `Debug.setAssertionLevel` is set to a high enough level. + * @param level The minimum assertion level required. + * @param name The name of the current assertion function. + */ + function shouldAssertFunction(level, name) { + if (!shouldAssert(level)) { + assertionCache[name] = { level: level, assertion: Debug[name] }; + Debug[name] = ts.noop; + return false; + } + return true; + } + function fail(message, stackCrawlMark) { + debugger; + var e = new Error(message ? "Debug Failure. ".concat(message) : "Debug Failure."); + if (Error.captureStackTrace) { + Error.captureStackTrace(e, stackCrawlMark || fail); + } + throw e; + } + Debug.fail = fail; + function failBadSyntaxKind(node, message, stackCrawlMark) { + return fail("".concat(message || "Unexpected node.", "\r\nNode ").concat(formatSyntaxKind(node.kind), " was unexpected."), stackCrawlMark || failBadSyntaxKind); + } + Debug.failBadSyntaxKind = failBadSyntaxKind; + function assert(expression, message, verboseDebugInfo, stackCrawlMark) { + if (!expression) { + message = message ? "False expression: ".concat(message) : "False expression."; + if (verboseDebugInfo) { + message += "\r\nVerbose Debug Information: " + (typeof verboseDebugInfo === "string" ? verboseDebugInfo : verboseDebugInfo()); + } + fail(message, stackCrawlMark || assert); + } + } + Debug.assert = assert; + function assertEqual(a, b, msg, msg2, stackCrawlMark) { + if (a !== b) { + var message = msg ? msg2 ? "".concat(msg, " ").concat(msg2) : msg : ""; + fail("Expected ".concat(a, " === ").concat(b, ". ").concat(message), stackCrawlMark || assertEqual); + } + } + Debug.assertEqual = assertEqual; + function assertLessThan(a, b, msg, stackCrawlMark) { + if (a >= b) { + fail("Expected ".concat(a, " < ").concat(b, ". ").concat(msg || ""), stackCrawlMark || assertLessThan); + } + } + Debug.assertLessThan = assertLessThan; + function assertLessThanOrEqual(a, b, stackCrawlMark) { + if (a > b) { + fail("Expected ".concat(a, " <= ").concat(b), stackCrawlMark || assertLessThanOrEqual); + } + } + Debug.assertLessThanOrEqual = assertLessThanOrEqual; + function assertGreaterThanOrEqual(a, b, stackCrawlMark) { + if (a < b) { + fail("Expected ".concat(a, " >= ").concat(b), stackCrawlMark || assertGreaterThanOrEqual); + } + } + Debug.assertGreaterThanOrEqual = assertGreaterThanOrEqual; + function assertIsDefined(value, message, stackCrawlMark) { + // eslint-disable-next-line no-null/no-null + if (value === undefined || value === null) { + fail(message, stackCrawlMark || assertIsDefined); + } + } + Debug.assertIsDefined = assertIsDefined; + function checkDefined(value, message, stackCrawlMark) { + assertIsDefined(value, message, stackCrawlMark || checkDefined); + return value; + } + Debug.checkDefined = checkDefined; + function assertEachIsDefined(value, message, stackCrawlMark) { + for (var _i = 0, value_1 = value; _i < value_1.length; _i++) { + var v = value_1[_i]; + assertIsDefined(v, message, stackCrawlMark || assertEachIsDefined); + } + } + Debug.assertEachIsDefined = assertEachIsDefined; + function checkEachDefined(value, message, stackCrawlMark) { + assertEachIsDefined(value, message, stackCrawlMark || checkEachDefined); + return value; + } + Debug.checkEachDefined = checkEachDefined; + function assertNever(member, message, stackCrawlMark) { + if (message === void 0) { message = "Illegal value:"; } + var detail = typeof member === "object" && ts.hasProperty(member, "kind") && ts.hasProperty(member, "pos") ? "SyntaxKind: " + formatSyntaxKind(member.kind) : JSON.stringify(member); + return fail("".concat(message, " ").concat(detail), stackCrawlMark || assertNever); + } + Debug.assertNever = assertNever; + function assertEachNode(nodes, test, message, stackCrawlMark) { + if (shouldAssertFunction(1 /* AssertionLevel.Normal */, "assertEachNode")) { + assert(test === undefined || ts.every(nodes, test), message || "Unexpected node.", function () { return "Node array did not pass test '".concat(getFunctionName(test), "'."); }, stackCrawlMark || assertEachNode); + } + } + Debug.assertEachNode = assertEachNode; + function assertNode(node, test, message, stackCrawlMark) { + if (shouldAssertFunction(1 /* AssertionLevel.Normal */, "assertNode")) { + assert(node !== undefined && (test === undefined || test(node)), message || "Unexpected node.", function () { return "Node ".concat(formatSyntaxKind(node === null || node === void 0 ? void 0 : node.kind), " did not pass test '").concat(getFunctionName(test), "'."); }, stackCrawlMark || assertNode); + } + } + Debug.assertNode = assertNode; + function assertNotNode(node, test, message, stackCrawlMark) { + if (shouldAssertFunction(1 /* AssertionLevel.Normal */, "assertNotNode")) { + assert(node === undefined || test === undefined || !test(node), message || "Unexpected node.", function () { return "Node ".concat(formatSyntaxKind(node.kind), " should not have passed test '").concat(getFunctionName(test), "'."); }, stackCrawlMark || assertNotNode); + } + } + Debug.assertNotNode = assertNotNode; + function assertOptionalNode(node, test, message, stackCrawlMark) { + if (shouldAssertFunction(1 /* AssertionLevel.Normal */, "assertOptionalNode")) { + assert(test === undefined || node === undefined || test(node), message || "Unexpected node.", function () { return "Node ".concat(formatSyntaxKind(node === null || node === void 0 ? void 0 : node.kind), " did not pass test '").concat(getFunctionName(test), "'."); }, stackCrawlMark || assertOptionalNode); + } + } + Debug.assertOptionalNode = assertOptionalNode; + function assertOptionalToken(node, kind, message, stackCrawlMark) { + if (shouldAssertFunction(1 /* AssertionLevel.Normal */, "assertOptionalToken")) { + assert(kind === undefined || node === undefined || node.kind === kind, message || "Unexpected node.", function () { return "Node ".concat(formatSyntaxKind(node === null || node === void 0 ? void 0 : node.kind), " was not a '").concat(formatSyntaxKind(kind), "' token."); }, stackCrawlMark || assertOptionalToken); + } + } + Debug.assertOptionalToken = assertOptionalToken; + function assertMissingNode(node, message, stackCrawlMark) { + if (shouldAssertFunction(1 /* AssertionLevel.Normal */, "assertMissingNode")) { + assert(node === undefined, message || "Unexpected node.", function () { return "Node ".concat(formatSyntaxKind(node.kind), " was unexpected'."); }, stackCrawlMark || assertMissingNode); + } + } + Debug.assertMissingNode = assertMissingNode; + function type(_value) { } + Debug.type = type; + function getFunctionName(func) { + if (typeof func !== "function") { + return ""; + } + else if (ts.hasProperty(func, "name")) { + return func.name; + } + else { + var text = Function.prototype.toString.call(func); + var match = /^function\s+([\w\$]+)\s*\(/.exec(text); + return match ? match[1] : ""; + } + } + Debug.getFunctionName = getFunctionName; + function formatSymbol(symbol) { + return "{ name: ".concat(ts.unescapeLeadingUnderscores(symbol.escapedName), "; flags: ").concat(formatSymbolFlags(symbol.flags), "; declarations: ").concat(ts.map(symbol.declarations, function (node) { return formatSyntaxKind(node.kind); }), " }"); + } + Debug.formatSymbol = formatSymbol; + /** + * Formats an enum value as a string for debugging and debug assertions. + */ + function formatEnum(value, enumObject, isFlags) { + if (value === void 0) { value = 0; } + var members = getEnumMembers(enumObject); + if (value === 0) { + return members.length > 0 && members[0][0] === 0 ? members[0][1] : "0"; + } + if (isFlags) { + var result = []; + var remainingFlags = value; + for (var _i = 0, members_1 = members; _i < members_1.length; _i++) { + var _a = members_1[_i], enumValue = _a[0], enumName = _a[1]; + if (enumValue > value) { + break; + } + if (enumValue !== 0 && enumValue & value) { + result.push(enumName); + remainingFlags &= ~enumValue; + } + } + if (remainingFlags === 0) { + return result.join("|"); + } + } + else { + for (var _b = 0, members_2 = members; _b < members_2.length; _b++) { + var _c = members_2[_b], enumValue = _c[0], enumName = _c[1]; + if (enumValue === value) { + return enumName; + } + } + } + return value.toString(); + } + Debug.formatEnum = formatEnum; + var enumMemberCache = new ts.Map(); + function getEnumMembers(enumObject) { + // Assuming enum objects do not change at runtime, we can cache the enum members list + // to reuse later. This saves us from reconstructing this each and every time we call + // a formatting function (which can be expensive for large enums like SyntaxKind). + var existing = enumMemberCache.get(enumObject); + if (existing) { + return existing; + } + var result = []; + for (var name in enumObject) { + var value = enumObject[name]; + if (typeof value === "number") { + result.push([value, name]); + } + } + var sorted = ts.stableSort(result, function (x, y) { return ts.compareValues(x[0], y[0]); }); + enumMemberCache.set(enumObject, sorted); + return sorted; + } + function formatSyntaxKind(kind) { + return formatEnum(kind, ts.SyntaxKind, /*isFlags*/ false); + } + Debug.formatSyntaxKind = formatSyntaxKind; + function formatSnippetKind(kind) { + return formatEnum(kind, ts.SnippetKind, /*isFlags*/ false); + } + Debug.formatSnippetKind = formatSnippetKind; + function formatNodeFlags(flags) { + return formatEnum(flags, ts.NodeFlags, /*isFlags*/ true); + } + Debug.formatNodeFlags = formatNodeFlags; + function formatModifierFlags(flags) { + return formatEnum(flags, ts.ModifierFlags, /*isFlags*/ true); + } + Debug.formatModifierFlags = formatModifierFlags; + function formatTransformFlags(flags) { + return formatEnum(flags, ts.TransformFlags, /*isFlags*/ true); + } + Debug.formatTransformFlags = formatTransformFlags; + function formatEmitFlags(flags) { + return formatEnum(flags, ts.EmitFlags, /*isFlags*/ true); + } + Debug.formatEmitFlags = formatEmitFlags; + function formatSymbolFlags(flags) { + return formatEnum(flags, ts.SymbolFlags, /*isFlags*/ true); + } + Debug.formatSymbolFlags = formatSymbolFlags; + function formatTypeFlags(flags) { + return formatEnum(flags, ts.TypeFlags, /*isFlags*/ true); + } + Debug.formatTypeFlags = formatTypeFlags; + function formatSignatureFlags(flags) { + return formatEnum(flags, ts.SignatureFlags, /*isFlags*/ true); + } + Debug.formatSignatureFlags = formatSignatureFlags; + function formatObjectFlags(flags) { + return formatEnum(flags, ts.ObjectFlags, /*isFlags*/ true); + } + Debug.formatObjectFlags = formatObjectFlags; + function formatFlowFlags(flags) { + return formatEnum(flags, ts.FlowFlags, /*isFlags*/ true); + } + Debug.formatFlowFlags = formatFlowFlags; + function formatRelationComparisonResult(result) { + return formatEnum(result, ts.RelationComparisonResult, /*isFlags*/ true); + } + Debug.formatRelationComparisonResult = formatRelationComparisonResult; + function formatCheckMode(mode) { + return formatEnum(mode, ts.CheckMode, /*isFlags*/ true); + } + Debug.formatCheckMode = formatCheckMode; + function formatSignatureCheckMode(mode) { + return formatEnum(mode, ts.SignatureCheckMode, /*isFlags*/ true); + } + Debug.formatSignatureCheckMode = formatSignatureCheckMode; + function formatTypeFacts(facts) { + return formatEnum(facts, ts.TypeFacts, /*isFlags*/ true); + } + Debug.formatTypeFacts = formatTypeFacts; + var isDebugInfoEnabled = false; + var extendedDebugModule; + function extendedDebug() { + enableDebugInfo(); + if (!extendedDebugModule) { + throw new Error("Debugging helpers could not be loaded."); + } + return extendedDebugModule; + } + function printControlFlowGraph(flowNode) { + return console.log(formatControlFlowGraph(flowNode)); + } + Debug.printControlFlowGraph = printControlFlowGraph; + function formatControlFlowGraph(flowNode) { + return extendedDebug().formatControlFlowGraph(flowNode); + } + Debug.formatControlFlowGraph = formatControlFlowGraph; + var flowNodeProto; + function attachFlowNodeDebugInfoWorker(flowNode) { + if (!("__debugFlowFlags" in flowNode)) { // eslint-disable-line local/no-in-operator + Object.defineProperties(flowNode, { + // for use with vscode-js-debug's new customDescriptionGenerator in launch.json + __tsDebuggerDisplay: { + value: function () { + var flowHeader = this.flags & 2 /* FlowFlags.Start */ ? "FlowStart" : + this.flags & 4 /* FlowFlags.BranchLabel */ ? "FlowBranchLabel" : + this.flags & 8 /* FlowFlags.LoopLabel */ ? "FlowLoopLabel" : + this.flags & 16 /* FlowFlags.Assignment */ ? "FlowAssignment" : + this.flags & 32 /* FlowFlags.TrueCondition */ ? "FlowTrueCondition" : + this.flags & 64 /* FlowFlags.FalseCondition */ ? "FlowFalseCondition" : + this.flags & 128 /* FlowFlags.SwitchClause */ ? "FlowSwitchClause" : + this.flags & 256 /* FlowFlags.ArrayMutation */ ? "FlowArrayMutation" : + this.flags & 512 /* FlowFlags.Call */ ? "FlowCall" : + this.flags & 1024 /* FlowFlags.ReduceLabel */ ? "FlowReduceLabel" : + this.flags & 1 /* FlowFlags.Unreachable */ ? "FlowUnreachable" : + "UnknownFlow"; + var remainingFlags = this.flags & ~(2048 /* FlowFlags.Referenced */ - 1); + return "".concat(flowHeader).concat(remainingFlags ? " (".concat(formatFlowFlags(remainingFlags), ")") : ""); + } + }, + __debugFlowFlags: { get: function () { return formatEnum(this.flags, ts.FlowFlags, /*isFlags*/ true); } }, + __debugToString: { value: function () { return formatControlFlowGraph(this); } } + }); + } + } + function attachFlowNodeDebugInfo(flowNode) { + if (isDebugInfoEnabled) { + if (typeof Object.setPrototypeOf === "function") { + // if we're in es2015, attach the method to a shared prototype for `FlowNode` + // so the method doesn't show up in the watch window. + if (!flowNodeProto) { + flowNodeProto = Object.create(Object.prototype); + attachFlowNodeDebugInfoWorker(flowNodeProto); + } + Object.setPrototypeOf(flowNode, flowNodeProto); + } + else { + // not running in an es2015 environment, attach the method directly. + attachFlowNodeDebugInfoWorker(flowNode); + } + } + } + Debug.attachFlowNodeDebugInfo = attachFlowNodeDebugInfo; + var nodeArrayProto; + function attachNodeArrayDebugInfoWorker(array) { + if (!("__tsDebuggerDisplay" in array)) { // eslint-disable-line local/no-in-operator + Object.defineProperties(array, { + __tsDebuggerDisplay: { + value: function (defaultValue) { + // An `Array` with extra properties is rendered as `[A, B, prop1: 1, prop2: 2]`. Most of + // these aren't immediately useful so we trim off the `prop1: ..., prop2: ...` part from the + // formatted string. + // This regex can trigger slow backtracking because of overlapping potential captures. + // We don't care, this is debug code that's only enabled with a debugger attached - + // we're just taking note of it for anyone checking regex performance in the future. + defaultValue = String(defaultValue).replace(/(?:,[\s\w\d_]+:[^,]+)+\]$/, "]"); + return "NodeArray ".concat(defaultValue); + } + } + }); + } + } + function attachNodeArrayDebugInfo(array) { + if (isDebugInfoEnabled) { + if (typeof Object.setPrototypeOf === "function") { + // if we're in es2015, attach the method to a shared prototype for `NodeArray` + // so the method doesn't show up in the watch window. + if (!nodeArrayProto) { + nodeArrayProto = Object.create(Array.prototype); + attachNodeArrayDebugInfoWorker(nodeArrayProto); + } + Object.setPrototypeOf(array, nodeArrayProto); + } + else { + // not running in an es2015 environment, attach the method directly. + attachNodeArrayDebugInfoWorker(array); + } + } + } + Debug.attachNodeArrayDebugInfo = attachNodeArrayDebugInfo; + /** + * Injects debug information into frequently used types. + */ + function enableDebugInfo() { + if (isDebugInfoEnabled) + return; + // avoid recomputing + var weakTypeTextMap; + var weakNodeTextMap; + function getWeakTypeTextMap() { + if (weakTypeTextMap === undefined) { + if (typeof WeakMap === "function") + weakTypeTextMap = new WeakMap(); + } + return weakTypeTextMap; + } + function getWeakNodeTextMap() { + if (weakNodeTextMap === undefined) { + if (typeof WeakMap === "function") + weakNodeTextMap = new WeakMap(); + } + return weakNodeTextMap; + } + // Add additional properties in debug mode to assist with debugging. + Object.defineProperties(ts.objectAllocator.getSymbolConstructor().prototype, { + // for use with vscode-js-debug's new customDescriptionGenerator in launch.json + __tsDebuggerDisplay: { + value: function () { + var symbolHeader = this.flags & 33554432 /* SymbolFlags.Transient */ ? "TransientSymbol" : + "Symbol"; + var remainingSymbolFlags = this.flags & ~33554432 /* SymbolFlags.Transient */; + return "".concat(symbolHeader, " '").concat(ts.symbolName(this), "'").concat(remainingSymbolFlags ? " (".concat(formatSymbolFlags(remainingSymbolFlags), ")") : ""); + } + }, + __debugFlags: { get: function () { return formatSymbolFlags(this.flags); } } + }); + Object.defineProperties(ts.objectAllocator.getTypeConstructor().prototype, { + // for use with vscode-js-debug's new customDescriptionGenerator in launch.json + __tsDebuggerDisplay: { + value: function () { + var typeHeader = this.flags & 98304 /* TypeFlags.Nullable */ ? "NullableType" : + this.flags & 384 /* TypeFlags.StringOrNumberLiteral */ ? "LiteralType ".concat(JSON.stringify(this.value)) : + this.flags & 2048 /* TypeFlags.BigIntLiteral */ ? "LiteralType ".concat(this.value.negative ? "-" : "").concat(this.value.base10Value, "n") : + this.flags & 8192 /* TypeFlags.UniqueESSymbol */ ? "UniqueESSymbolType" : + this.flags & 32 /* TypeFlags.Enum */ ? "EnumType" : + this.flags & 67359327 /* TypeFlags.Intrinsic */ ? "IntrinsicType ".concat(this.intrinsicName) : + this.flags & 1048576 /* TypeFlags.Union */ ? "UnionType" : + this.flags & 2097152 /* TypeFlags.Intersection */ ? "IntersectionType" : + this.flags & 4194304 /* TypeFlags.Index */ ? "IndexType" : + this.flags & 8388608 /* TypeFlags.IndexedAccess */ ? "IndexedAccessType" : + this.flags & 16777216 /* TypeFlags.Conditional */ ? "ConditionalType" : + this.flags & 33554432 /* TypeFlags.Substitution */ ? "SubstitutionType" : + this.flags & 262144 /* TypeFlags.TypeParameter */ ? "TypeParameter" : + this.flags & 524288 /* TypeFlags.Object */ ? + this.objectFlags & 3 /* ObjectFlags.ClassOrInterface */ ? "InterfaceType" : + this.objectFlags & 4 /* ObjectFlags.Reference */ ? "TypeReference" : + this.objectFlags & 8 /* ObjectFlags.Tuple */ ? "TupleType" : + this.objectFlags & 16 /* ObjectFlags.Anonymous */ ? "AnonymousType" : + this.objectFlags & 32 /* ObjectFlags.Mapped */ ? "MappedType" : + this.objectFlags & 1024 /* ObjectFlags.ReverseMapped */ ? "ReverseMappedType" : + this.objectFlags & 256 /* ObjectFlags.EvolvingArray */ ? "EvolvingArrayType" : + "ObjectType" : + "Type"; + var remainingObjectFlags = this.flags & 524288 /* TypeFlags.Object */ ? this.objectFlags & ~1343 /* ObjectFlags.ObjectTypeKindMask */ : 0; + return "".concat(typeHeader).concat(this.symbol ? " '".concat(ts.symbolName(this.symbol), "'") : "").concat(remainingObjectFlags ? " (".concat(formatObjectFlags(remainingObjectFlags), ")") : ""); + } + }, + __debugFlags: { get: function () { return formatTypeFlags(this.flags); } }, + __debugObjectFlags: { get: function () { return this.flags & 524288 /* TypeFlags.Object */ ? formatObjectFlags(this.objectFlags) : ""; } }, + __debugTypeToString: { + value: function () { + // avoid recomputing + var map = getWeakTypeTextMap(); + var text = map === null || map === void 0 ? void 0 : map.get(this); + if (text === undefined) { + text = this.checker.typeToString(this); + map === null || map === void 0 ? void 0 : map.set(this, text); + } + return text; + } + }, + }); + Object.defineProperties(ts.objectAllocator.getSignatureConstructor().prototype, { + __debugFlags: { get: function () { return formatSignatureFlags(this.flags); } }, + __debugSignatureToString: { value: function () { var _a; return (_a = this.checker) === null || _a === void 0 ? void 0 : _a.signatureToString(this); } } + }); + var nodeConstructors = [ + ts.objectAllocator.getNodeConstructor(), + ts.objectAllocator.getIdentifierConstructor(), + ts.objectAllocator.getTokenConstructor(), + ts.objectAllocator.getSourceFileConstructor() + ]; + for (var _i = 0, nodeConstructors_1 = nodeConstructors; _i < nodeConstructors_1.length; _i++) { + var ctor = nodeConstructors_1[_i]; + if (!ts.hasProperty(ctor.prototype, "__debugKind")) { + Object.defineProperties(ctor.prototype, { + // for use with vscode-js-debug's new customDescriptionGenerator in launch.json + __tsDebuggerDisplay: { + value: function () { + var nodeHeader = ts.isGeneratedIdentifier(this) ? "GeneratedIdentifier" : + ts.isIdentifier(this) ? "Identifier '".concat(ts.idText(this), "'") : + ts.isPrivateIdentifier(this) ? "PrivateIdentifier '".concat(ts.idText(this), "'") : + ts.isStringLiteral(this) ? "StringLiteral ".concat(JSON.stringify(this.text.length < 10 ? this.text : this.text.slice(10) + "...")) : + ts.isNumericLiteral(this) ? "NumericLiteral ".concat(this.text) : + ts.isBigIntLiteral(this) ? "BigIntLiteral ".concat(this.text, "n") : + ts.isTypeParameterDeclaration(this) ? "TypeParameterDeclaration" : + ts.isParameter(this) ? "ParameterDeclaration" : + ts.isConstructorDeclaration(this) ? "ConstructorDeclaration" : + ts.isGetAccessorDeclaration(this) ? "GetAccessorDeclaration" : + ts.isSetAccessorDeclaration(this) ? "SetAccessorDeclaration" : + ts.isCallSignatureDeclaration(this) ? "CallSignatureDeclaration" : + ts.isConstructSignatureDeclaration(this) ? "ConstructSignatureDeclaration" : + ts.isIndexSignatureDeclaration(this) ? "IndexSignatureDeclaration" : + ts.isTypePredicateNode(this) ? "TypePredicateNode" : + ts.isTypeReferenceNode(this) ? "TypeReferenceNode" : + ts.isFunctionTypeNode(this) ? "FunctionTypeNode" : + ts.isConstructorTypeNode(this) ? "ConstructorTypeNode" : + ts.isTypeQueryNode(this) ? "TypeQueryNode" : + ts.isTypeLiteralNode(this) ? "TypeLiteralNode" : + ts.isArrayTypeNode(this) ? "ArrayTypeNode" : + ts.isTupleTypeNode(this) ? "TupleTypeNode" : + ts.isOptionalTypeNode(this) ? "OptionalTypeNode" : + ts.isRestTypeNode(this) ? "RestTypeNode" : + ts.isUnionTypeNode(this) ? "UnionTypeNode" : + ts.isIntersectionTypeNode(this) ? "IntersectionTypeNode" : + ts.isConditionalTypeNode(this) ? "ConditionalTypeNode" : + ts.isInferTypeNode(this) ? "InferTypeNode" : + ts.isParenthesizedTypeNode(this) ? "ParenthesizedTypeNode" : + ts.isThisTypeNode(this) ? "ThisTypeNode" : + ts.isTypeOperatorNode(this) ? "TypeOperatorNode" : + ts.isIndexedAccessTypeNode(this) ? "IndexedAccessTypeNode" : + ts.isMappedTypeNode(this) ? "MappedTypeNode" : + ts.isLiteralTypeNode(this) ? "LiteralTypeNode" : + ts.isNamedTupleMember(this) ? "NamedTupleMember" : + ts.isImportTypeNode(this) ? "ImportTypeNode" : + formatSyntaxKind(this.kind); + return "".concat(nodeHeader).concat(this.flags ? " (".concat(formatNodeFlags(this.flags), ")") : ""); + } + }, + __debugKind: { get: function () { return formatSyntaxKind(this.kind); } }, + __debugNodeFlags: { get: function () { return formatNodeFlags(this.flags); } }, + __debugModifierFlags: { get: function () { return formatModifierFlags(ts.getEffectiveModifierFlagsNoCache(this)); } }, + __debugTransformFlags: { get: function () { return formatTransformFlags(this.transformFlags); } }, + __debugIsParseTreeNode: { get: function () { return ts.isParseTreeNode(this); } }, + __debugEmitFlags: { get: function () { return formatEmitFlags(ts.getEmitFlags(this)); } }, + __debugGetText: { + value: function (includeTrivia) { + if (ts.nodeIsSynthesized(this)) + return ""; + // avoid recomputing + var map = getWeakNodeTextMap(); + var text = map === null || map === void 0 ? void 0 : map.get(this); + if (text === undefined) { + var parseNode = ts.getParseTreeNode(this); + var sourceFile = parseNode && ts.getSourceFileOfNode(parseNode); + text = sourceFile ? ts.getSourceTextOfNodeFromSourceFile(sourceFile, parseNode, includeTrivia) : ""; + map === null || map === void 0 ? void 0 : map.set(this, text); + } + return text; + } + } + }); + } + } + // attempt to load extended debugging information + try { + if (ts.sys && ts.sys.require) { + var basePath = ts.getDirectoryPath(ts.resolvePath(ts.sys.getExecutingFilePath())); + var result = ts.sys.require(basePath, "./compiler-debug"); + if (!result.error) { + result.module.init(ts); + extendedDebugModule = result.module; + } + } + } + catch (_a) { + // do nothing + } + isDebugInfoEnabled = true; + } + Debug.enableDebugInfo = enableDebugInfo; + function formatDeprecationMessage(name, error, errorAfter, since, message) { + var deprecationMessage = error ? "DeprecationError: " : "DeprecationWarning: "; + deprecationMessage += "'".concat(name, "' "); + deprecationMessage += since ? "has been deprecated since v".concat(since) : "is deprecated"; + deprecationMessage += error ? " and can no longer be used." : errorAfter ? " and will no longer be usable after v".concat(errorAfter, ".") : "."; + deprecationMessage += message ? " ".concat(ts.formatStringFromArgs(message, [name], 0)) : ""; + return deprecationMessage; + } + function createErrorDeprecation(name, errorAfter, since, message) { + var deprecationMessage = formatDeprecationMessage(name, /*error*/ true, errorAfter, since, message); + return function () { + throw new TypeError(deprecationMessage); + }; + } + function createWarningDeprecation(name, errorAfter, since, message) { + var hasWrittenDeprecation = false; + return function () { + if (Debug.enableDeprecationWarnings && !hasWrittenDeprecation) { + log.warn(formatDeprecationMessage(name, /*error*/ false, errorAfter, since, message)); + hasWrittenDeprecation = true; + } + }; + } + function createDeprecation(name, options) { + var _a, _b; + if (options === void 0) { options = {}; } + var version = typeof options.typeScriptVersion === "string" ? new ts.Version(options.typeScriptVersion) : (_a = options.typeScriptVersion) !== null && _a !== void 0 ? _a : getTypeScriptVersion(); + var errorAfter = typeof options.errorAfter === "string" ? new ts.Version(options.errorAfter) : options.errorAfter; + var warnAfter = typeof options.warnAfter === "string" ? new ts.Version(options.warnAfter) : options.warnAfter; + var since = typeof options.since === "string" ? new ts.Version(options.since) : (_b = options.since) !== null && _b !== void 0 ? _b : warnAfter; + var error = options.error || errorAfter && version.compareTo(errorAfter) <= 0; + var warn = !warnAfter || version.compareTo(warnAfter) >= 0; + return error ? createErrorDeprecation(name, errorAfter, since, options.message) : + warn ? createWarningDeprecation(name, errorAfter, since, options.message) : + ts.noop; + } + Debug.createDeprecation = createDeprecation; + function wrapFunction(deprecation, func) { + return function () { + deprecation(); + return func.apply(this, arguments); + }; + } + function deprecate(func, options) { + var _a; + var deprecation = createDeprecation((_a = options === null || options === void 0 ? void 0 : options.name) !== null && _a !== void 0 ? _a : getFunctionName(func), options); + return wrapFunction(deprecation, func); + } + Debug.deprecate = deprecate; + function formatVariance(varianceFlags) { + var variance = varianceFlags & 7 /* VarianceFlags.VarianceMask */; + var result = variance === 0 /* VarianceFlags.Invariant */ ? "in out" : + variance === 3 /* VarianceFlags.Bivariant */ ? "[bivariant]" : + variance === 2 /* VarianceFlags.Contravariant */ ? "in" : + variance === 1 /* VarianceFlags.Covariant */ ? "out" : + variance === 4 /* VarianceFlags.Independent */ ? "[independent]" : ""; + if (varianceFlags & 8 /* VarianceFlags.Unmeasurable */) { + result += " (unmeasurable)"; + } + else if (varianceFlags & 16 /* VarianceFlags.Unreliable */) { + result += " (unreliable)"; + } + return result; + } + Debug.formatVariance = formatVariance; + var DebugTypeMapper = /** @class */ (function () { + function DebugTypeMapper() { + } + DebugTypeMapper.prototype.__debugToString = function () { + var _a; + type(this); + switch (this.kind) { + case 3 /* TypeMapKind.Function */: return ((_a = this.debugInfo) === null || _a === void 0 ? void 0 : _a.call(this)) || "(function mapper)"; + case 0 /* TypeMapKind.Simple */: return "".concat(this.source.__debugTypeToString(), " -> ").concat(this.target.__debugTypeToString()); + case 1 /* TypeMapKind.Array */: return ts.zipWith(this.sources, this.targets || ts.map(this.sources, function () { return "any"; }), function (s, t) { return "".concat(s.__debugTypeToString(), " -> ").concat(typeof t === "string" ? t : t.__debugTypeToString()); }).join(", "); + case 2 /* TypeMapKind.Deferred */: return ts.zipWith(this.sources, this.targets, function (s, t) { return "".concat(s.__debugTypeToString(), " -> ").concat(t().__debugTypeToString()); }).join(", "); + case 5 /* TypeMapKind.Merged */: + case 4 /* TypeMapKind.Composite */: return "m1: ".concat(this.mapper1.__debugToString().split("\n").join("\n "), "\nm2: ").concat(this.mapper2.__debugToString().split("\n").join("\n ")); + default: return assertNever(this); + } + }; + return DebugTypeMapper; + }()); + Debug.DebugTypeMapper = DebugTypeMapper; + function attachDebugPrototypeIfDebug(mapper) { + if (Debug.isDebugging) { + return Object.setPrototypeOf(mapper, DebugTypeMapper.prototype); + } + return mapper; + } + Debug.attachDebugPrototypeIfDebug = attachDebugPrototypeIfDebug; + })(Debug = ts.Debug || (ts.Debug = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + // https://semver.org/#spec-item-2 + // > A normal version number MUST take the form X.Y.Z where X, Y, and Z are non-negative + // > integers, and MUST NOT contain leading zeroes. X is the major version, Y is the minor + // > version, and Z is the patch version. Each element MUST increase numerically. + // + // NOTE: We differ here in that we allow X and X.Y, with missing parts having the default + // value of `0`. + var versionRegExp = /^(0|[1-9]\d*)(?:\.(0|[1-9]\d*)(?:\.(0|[1-9]\d*)(?:\-([a-z0-9-.]+))?(?:\+([a-z0-9-.]+))?)?)?$/i; + // https://semver.org/#spec-item-9 + // > A pre-release version MAY be denoted by appending a hyphen and a series of dot separated + // > identifiers immediately following the patch version. Identifiers MUST comprise only ASCII + // > alphanumerics and hyphen [0-9A-Za-z-]. Identifiers MUST NOT be empty. Numeric identifiers + // > MUST NOT include leading zeroes. + var prereleaseRegExp = /^(?:0|[1-9]\d*|[a-z-][a-z0-9-]*)(?:\.(?:0|[1-9]\d*|[a-z-][a-z0-9-]*))*$/i; + var prereleasePartRegExp = /^(?:0|[1-9]\d*|[a-z-][a-z0-9-]*)$/i; + // https://semver.org/#spec-item-10 + // > Build metadata MAY be denoted by appending a plus sign and a series of dot separated + // > identifiers immediately following the patch or pre-release version. Identifiers MUST + // > comprise only ASCII alphanumerics and hyphen [0-9A-Za-z-]. Identifiers MUST NOT be empty. + var buildRegExp = /^[a-z0-9-]+(?:\.[a-z0-9-]+)*$/i; + var buildPartRegExp = /^[a-z0-9-]+$/i; + // https://semver.org/#spec-item-9 + // > Numeric identifiers MUST NOT include leading zeroes. + var numericIdentifierRegExp = /^(0|[1-9]\d*)$/; + /** + * Describes a precise semantic version number, https://semver.org + */ + var Version = /** @class */ (function () { + function Version(major, minor, patch, prerelease, build) { + if (minor === void 0) { minor = 0; } + if (patch === void 0) { patch = 0; } + if (prerelease === void 0) { prerelease = ""; } + if (build === void 0) { build = ""; } + if (typeof major === "string") { + var result = ts.Debug.checkDefined(tryParseComponents(major), "Invalid version"); + (major = result.major, minor = result.minor, patch = result.patch, prerelease = result.prerelease, build = result.build); + } + ts.Debug.assert(major >= 0, "Invalid argument: major"); + ts.Debug.assert(minor >= 0, "Invalid argument: minor"); + ts.Debug.assert(patch >= 0, "Invalid argument: patch"); + var prereleaseArray = prerelease ? ts.isArray(prerelease) ? prerelease : prerelease.split(".") : ts.emptyArray; + var buildArray = build ? ts.isArray(build) ? build : build.split(".") : ts.emptyArray; + ts.Debug.assert(ts.every(prereleaseArray, function (s) { return prereleasePartRegExp.test(s); }), "Invalid argument: prerelease"); + ts.Debug.assert(ts.every(buildArray, function (s) { return buildPartRegExp.test(s); }), "Invalid argument: build"); + this.major = major; + this.minor = minor; + this.patch = patch; + this.prerelease = prereleaseArray; + this.build = buildArray; + } + Version.tryParse = function (text) { + var result = tryParseComponents(text); + if (!result) + return undefined; + var major = result.major, minor = result.minor, patch = result.patch, prerelease = result.prerelease, build = result.build; + return new Version(major, minor, patch, prerelease, build); + }; + Version.prototype.compareTo = function (other) { + // https://semver.org/#spec-item-11 + // > Precedence is determined by the first difference when comparing each of these + // > identifiers from left to right as follows: Major, minor, and patch versions are + // > always compared numerically. + // + // https://semver.org/#spec-item-11 + // > Precedence for two pre-release versions with the same major, minor, and patch version + // > MUST be determined by comparing each dot separated identifier from left to right until + // > a difference is found [...] + // + // https://semver.org/#spec-item-11 + // > Build metadata does not figure into precedence + if (this === other) + return 0 /* Comparison.EqualTo */; + if (other === undefined) + return 1 /* Comparison.GreaterThan */; + return ts.compareValues(this.major, other.major) + || ts.compareValues(this.minor, other.minor) + || ts.compareValues(this.patch, other.patch) + || comparePrereleaseIdentifiers(this.prerelease, other.prerelease); + }; + Version.prototype.increment = function (field) { + switch (field) { + case "major": return new Version(this.major + 1, 0, 0); + case "minor": return new Version(this.major, this.minor + 1, 0); + case "patch": return new Version(this.major, this.minor, this.patch + 1); + default: return ts.Debug.assertNever(field); + } + }; + Version.prototype.with = function (fields) { + var _a = fields.major, major = _a === void 0 ? this.major : _a, _b = fields.minor, minor = _b === void 0 ? this.minor : _b, _c = fields.patch, patch = _c === void 0 ? this.patch : _c, _d = fields.prerelease, prerelease = _d === void 0 ? this.prerelease : _d, _e = fields.build, build = _e === void 0 ? this.build : _e; + return new Version(major, minor, patch, prerelease, build); + }; + Version.prototype.toString = function () { + var result = "".concat(this.major, ".").concat(this.minor, ".").concat(this.patch); + if (ts.some(this.prerelease)) + result += "-".concat(this.prerelease.join(".")); + if (ts.some(this.build)) + result += "+".concat(this.build.join(".")); + return result; + }; + Version.zero = new Version(0, 0, 0, ["0"]); + return Version; + }()); + ts.Version = Version; + function tryParseComponents(text) { + var match = versionRegExp.exec(text); + if (!match) + return undefined; + var major = match[1], _a = match[2], minor = _a === void 0 ? "0" : _a, _b = match[3], patch = _b === void 0 ? "0" : _b, _c = match[4], prerelease = _c === void 0 ? "" : _c, _d = match[5], build = _d === void 0 ? "" : _d; + if (prerelease && !prereleaseRegExp.test(prerelease)) + return undefined; + if (build && !buildRegExp.test(build)) + return undefined; + return { + major: parseInt(major, 10), + minor: parseInt(minor, 10), + patch: parseInt(patch, 10), + prerelease: prerelease, + build: build + }; + } + function comparePrereleaseIdentifiers(left, right) { + // https://semver.org/#spec-item-11 + // > When major, minor, and patch are equal, a pre-release version has lower precedence + // > than a normal version. + if (left === right) + return 0 /* Comparison.EqualTo */; + if (left.length === 0) + return right.length === 0 ? 0 /* Comparison.EqualTo */ : 1 /* Comparison.GreaterThan */; + if (right.length === 0) + return -1 /* Comparison.LessThan */; + // https://semver.org/#spec-item-11 + // > Precedence for two pre-release versions with the same major, minor, and patch version + // > MUST be determined by comparing each dot separated identifier from left to right until + // > a difference is found [...] + var length = Math.min(left.length, right.length); + for (var i = 0; i < length; i++) { + var leftIdentifier = left[i]; + var rightIdentifier = right[i]; + if (leftIdentifier === rightIdentifier) + continue; + var leftIsNumeric = numericIdentifierRegExp.test(leftIdentifier); + var rightIsNumeric = numericIdentifierRegExp.test(rightIdentifier); + if (leftIsNumeric || rightIsNumeric) { + // https://semver.org/#spec-item-11 + // > Numeric identifiers always have lower precedence than non-numeric identifiers. + if (leftIsNumeric !== rightIsNumeric) + return leftIsNumeric ? -1 /* Comparison.LessThan */ : 1 /* Comparison.GreaterThan */; + // https://semver.org/#spec-item-11 + // > identifiers consisting of only digits are compared numerically + var result = ts.compareValues(+leftIdentifier, +rightIdentifier); + if (result) + return result; + } + else { + // https://semver.org/#spec-item-11 + // > identifiers with letters or hyphens are compared lexically in ASCII sort order. + var result = ts.compareStringsCaseSensitive(leftIdentifier, rightIdentifier); + if (result) + return result; + } + } + // https://semver.org/#spec-item-11 + // > A larger set of pre-release fields has a higher precedence than a smaller set, if all + // > of the preceding identifiers are equal. + return ts.compareValues(left.length, right.length); + } + /** + * Describes a semantic version range, per https://github.com/npm/node-semver#ranges + */ + var VersionRange = /** @class */ (function () { + function VersionRange(spec) { + this._alternatives = spec ? ts.Debug.checkDefined(parseRange(spec), "Invalid range spec.") : ts.emptyArray; + } + VersionRange.tryParse = function (text) { + var sets = parseRange(text); + if (sets) { + var range = new VersionRange(""); + range._alternatives = sets; + return range; + } + return undefined; + }; + /** + * Tests whether a version matches the range. This is equivalent to `satisfies(version, range, { includePrerelease: true })`. + * in `node-semver`. + */ + VersionRange.prototype.test = function (version) { + if (typeof version === "string") + version = new Version(version); + return testDisjunction(version, this._alternatives); + }; + VersionRange.prototype.toString = function () { + return formatDisjunction(this._alternatives); + }; + return VersionRange; + }()); + ts.VersionRange = VersionRange; + // https://github.com/npm/node-semver#range-grammar + // + // range-set ::= range ( logical-or range ) * + // range ::= hyphen | simple ( ' ' simple ) * | '' + // logical-or ::= ( ' ' ) * '||' ( ' ' ) * + var logicalOrRegExp = /\|\|/g; + var whitespaceRegExp = /\s+/g; + // https://github.com/npm/node-semver#range-grammar + // + // partial ::= xr ( '.' xr ( '.' xr qualifier ? )? )? + // xr ::= 'x' | 'X' | '*' | nr + // nr ::= '0' | ['1'-'9'] ( ['0'-'9'] ) * + // qualifier ::= ( '-' pre )? ( '+' build )? + // pre ::= parts + // build ::= parts + // parts ::= part ( '.' part ) * + // part ::= nr | [-0-9A-Za-z]+ + var partialRegExp = /^([xX*0]|[1-9]\d*)(?:\.([xX*0]|[1-9]\d*)(?:\.([xX*0]|[1-9]\d*)(?:-([a-z0-9-.]+))?(?:\+([a-z0-9-.]+))?)?)?$/i; + // https://github.com/npm/node-semver#range-grammar + // + // hyphen ::= partial ' - ' partial + var hyphenRegExp = /^\s*([a-z0-9-+.*]+)\s+-\s+([a-z0-9-+.*]+)\s*$/i; + // https://github.com/npm/node-semver#range-grammar + // + // simple ::= primitive | partial | tilde | caret + // primitive ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial + // tilde ::= '~' partial + // caret ::= '^' partial + var rangeRegExp = /^(~|\^|<|<=|>|>=|=)?\s*([a-z0-9-+.*]+)$/i; + function parseRange(text) { + var alternatives = []; + for (var _i = 0, _a = ts.trimString(text).split(logicalOrRegExp); _i < _a.length; _i++) { + var range = _a[_i]; + if (!range) + continue; + var comparators = []; + range = ts.trimString(range); + var match = hyphenRegExp.exec(range); + if (match) { + if (!parseHyphen(match[1], match[2], comparators)) + return undefined; + } + else { + for (var _b = 0, _c = range.split(whitespaceRegExp); _b < _c.length; _b++) { + var simple = _c[_b]; + var match_1 = rangeRegExp.exec(ts.trimString(simple)); + if (!match_1 || !parseComparator(match_1[1], match_1[2], comparators)) + return undefined; + } + } + alternatives.push(comparators); + } + return alternatives; + } + function parsePartial(text) { + var match = partialRegExp.exec(text); + if (!match) + return undefined; + var major = match[1], _a = match[2], minor = _a === void 0 ? "*" : _a, _b = match[3], patch = _b === void 0 ? "*" : _b, prerelease = match[4], build = match[5]; + var version = new Version(isWildcard(major) ? 0 : parseInt(major, 10), isWildcard(major) || isWildcard(minor) ? 0 : parseInt(minor, 10), isWildcard(major) || isWildcard(minor) || isWildcard(patch) ? 0 : parseInt(patch, 10), prerelease, build); + return { version: version, major: major, minor: minor, patch: patch }; + } + function parseHyphen(left, right, comparators) { + var leftResult = parsePartial(left); + if (!leftResult) + return false; + var rightResult = parsePartial(right); + if (!rightResult) + return false; + if (!isWildcard(leftResult.major)) { + comparators.push(createComparator(">=", leftResult.version)); + } + if (!isWildcard(rightResult.major)) { + comparators.push(isWildcard(rightResult.minor) ? createComparator("<", rightResult.version.increment("major")) : + isWildcard(rightResult.patch) ? createComparator("<", rightResult.version.increment("minor")) : + createComparator("<=", rightResult.version)); + } + return true; + } + function parseComparator(operator, text, comparators) { + var result = parsePartial(text); + if (!result) + return false; + var version = result.version, major = result.major, minor = result.minor, patch = result.patch; + if (!isWildcard(major)) { + switch (operator) { + case "~": + comparators.push(createComparator(">=", version)); + comparators.push(createComparator("<", version.increment(isWildcard(minor) ? "major" : + "minor"))); + break; + case "^": + comparators.push(createComparator(">=", version)); + comparators.push(createComparator("<", version.increment(version.major > 0 || isWildcard(minor) ? "major" : + version.minor > 0 || isWildcard(patch) ? "minor" : + "patch"))); + break; + case "<": + case ">=": + comparators.push(isWildcard(minor) || isWildcard(patch) ? createComparator(operator, version.with({ prerelease: "0" })) : + createComparator(operator, version)); + break; + case "<=": + case ">": + comparators.push(isWildcard(minor) ? createComparator(operator === "<=" ? "<" : ">=", version.increment("major").with({ prerelease: "0" })) : + isWildcard(patch) ? createComparator(operator === "<=" ? "<" : ">=", version.increment("minor").with({ prerelease: "0" })) : + createComparator(operator, version)); + break; + case "=": + case undefined: + if (isWildcard(minor) || isWildcard(patch)) { + comparators.push(createComparator(">=", version.with({ prerelease: "0" }))); + comparators.push(createComparator("<", version.increment(isWildcard(minor) ? "major" : "minor").with({ prerelease: "0" }))); + } + else { + comparators.push(createComparator("=", version)); + } + break; + default: + // unrecognized + return false; + } + } + else if (operator === "<" || operator === ">") { + comparators.push(createComparator("<", Version.zero)); + } + return true; + } + function isWildcard(part) { + return part === "*" || part === "x" || part === "X"; + } + function createComparator(operator, operand) { + return { operator: operator, operand: operand }; + } + function testDisjunction(version, alternatives) { + // an empty disjunction is treated as "*" (all versions) + if (alternatives.length === 0) + return true; + for (var _i = 0, alternatives_1 = alternatives; _i < alternatives_1.length; _i++) { + var alternative = alternatives_1[_i]; + if (testAlternative(version, alternative)) + return true; + } + return false; + } + function testAlternative(version, comparators) { + for (var _i = 0, comparators_1 = comparators; _i < comparators_1.length; _i++) { + var comparator = comparators_1[_i]; + if (!testComparator(version, comparator.operator, comparator.operand)) + return false; + } + return true; + } + function testComparator(version, operator, operand) { + var cmp = version.compareTo(operand); + switch (operator) { + case "<": return cmp < 0; + case "<=": return cmp <= 0; + case ">": return cmp > 0; + case ">=": return cmp >= 0; + case "=": return cmp === 0; + default: return ts.Debug.assertNever(operator); + } + } + function formatDisjunction(alternatives) { + return ts.map(alternatives, formatAlternative).join(" || ") || "*"; + } + function formatAlternative(comparators) { + return ts.map(comparators, formatComparator).join(" "); + } + function formatComparator(comparator) { + return "".concat(comparator.operator).concat(comparator.operand); + } +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + // The following definitions provide the minimum compatible support for the Web Performance User Timings API + // between browsers and NodeJS: + // eslint-disable-next-line @typescript-eslint/naming-convention + function hasRequiredAPI(performance, PerformanceObserver) { + return typeof performance === "object" && + typeof performance.timeOrigin === "number" && + typeof performance.mark === "function" && + typeof performance.measure === "function" && + typeof performance.now === "function" && + typeof performance.clearMarks === "function" && + typeof performance.clearMeasures === "function" && + typeof PerformanceObserver === "function"; + } + function tryGetWebPerformanceHooks() { + if (typeof performance === "object" && + typeof PerformanceObserver === "function" && + hasRequiredAPI(performance, PerformanceObserver)) { + return { + // For now we always write native performance events when running in the browser. We may + // make this conditional in the future if we find that native web performance hooks + // in the browser also slow down compilation. + shouldWriteNativeEvents: true, + performance: performance, + PerformanceObserver: PerformanceObserver + }; + } + } + function tryGetNodePerformanceHooks() { + if (typeof process !== "undefined" && process.nextTick && !process.browser && typeof module === "object" && typeof require === "function") { + try { + var performance_1; + var _a = require("perf_hooks"), nodePerformance_1 = _a.performance, PerformanceObserver_1 = _a.PerformanceObserver; + if (hasRequiredAPI(nodePerformance_1, PerformanceObserver_1)) { + performance_1 = nodePerformance_1; + // There is a bug in Node's performance.measure prior to 12.16.3/13.13.0 that does not + // match the Web Performance API specification. Node's implementation did not allow + // optional `start` and `end` arguments for `performance.measure`. + // See https://github.com/nodejs/node/pull/32651 for more information. + var version_1 = new ts.Version(process.versions.node); + var range = new ts.VersionRange("<12.16.3 || 13 <13.13"); + if (range.test(version_1)) { + performance_1 = { + get timeOrigin() { return nodePerformance_1.timeOrigin; }, + now: function () { return nodePerformance_1.now(); }, + mark: function (name) { return nodePerformance_1.mark(name); }, + measure: function (name, start, end) { + if (start === void 0) { start = "nodeStart"; } + if (end === undefined) { + end = "__performance.measure-fix__"; + nodePerformance_1.mark(end); + } + nodePerformance_1.measure(name, start, end); + if (end === "__performance.measure-fix__") { + nodePerformance_1.clearMarks("__performance.measure-fix__"); + } + }, + clearMarks: function (name) { return nodePerformance_1.clearMarks(name); }, + clearMeasures: function (name) { return nodePerformance_1.clearMeasures(name); }, + }; + } + return { + // By default, only write native events when generating a cpu profile or using the v8 profiler. + shouldWriteNativeEvents: false, + performance: performance_1, + PerformanceObserver: PerformanceObserver_1 + }; + } + } + catch (_b) { + // ignore errors + } + } + } + // Unlike with the native Map/Set 'tryGet' functions in corePublic.ts, we eagerly evaluate these + // since we will need them for `timestamp`, below. + var nativePerformanceHooks = tryGetWebPerformanceHooks() || tryGetNodePerformanceHooks(); + var nativePerformance = nativePerformanceHooks === null || nativePerformanceHooks === void 0 ? void 0 : nativePerformanceHooks.performance; + function tryGetNativePerformanceHooks() { + return nativePerformanceHooks; + } + ts.tryGetNativePerformanceHooks = tryGetNativePerformanceHooks; + /** Gets a timestamp with (at least) ms resolution */ + ts.timestamp = nativePerformance ? function () { return nativePerformance.now(); } : + Date.now ? Date.now : + function () { return +(new Date()); }; +})(ts || (ts = {})); +/*@internal*/ +/** Performance measurements for the compiler. */ +var ts; +(function (ts) { + var performance; + (function (performance) { + var perfHooks; + // when set, indicates the implementation of `Performance` to use for user timing. + // when unset, indicates user timing is unavailable or disabled. + var performanceImpl; + function createTimerIf(condition, measureName, startMarkName, endMarkName) { + return condition ? createTimer(measureName, startMarkName, endMarkName) : performance.nullTimer; + } + performance.createTimerIf = createTimerIf; + function createTimer(measureName, startMarkName, endMarkName) { + var enterCount = 0; + return { + enter: enter, + exit: exit + }; + function enter() { + if (++enterCount === 1) { + mark(startMarkName); + } + } + function exit() { + if (--enterCount === 0) { + mark(endMarkName); + measure(measureName, startMarkName, endMarkName); + } + else if (enterCount < 0) { + ts.Debug.fail("enter/exit count does not match."); + } + } + } + performance.createTimer = createTimer; + performance.nullTimer = { enter: ts.noop, exit: ts.noop }; + var enabled = false; + var timeorigin = ts.timestamp(); + var marks = new ts.Map(); + var counts = new ts.Map(); + var durations = new ts.Map(); + /** + * Marks a performance event. + * + * @param markName The name of the mark. + */ + function mark(markName) { + var _a; + if (enabled) { + var count = (_a = counts.get(markName)) !== null && _a !== void 0 ? _a : 0; + counts.set(markName, count + 1); + marks.set(markName, ts.timestamp()); + performanceImpl === null || performanceImpl === void 0 ? void 0 : performanceImpl.mark(markName); + } + } + performance.mark = mark; + /** + * Adds a performance measurement with the specified name. + * + * @param measureName The name of the performance measurement. + * @param startMarkName The name of the starting mark. If not supplied, the point at which the + * profiler was enabled is used. + * @param endMarkName The name of the ending mark. If not supplied, the current timestamp is + * used. + */ + function measure(measureName, startMarkName, endMarkName) { + var _a, _b; + if (enabled) { + var end = (_a = (endMarkName !== undefined ? marks.get(endMarkName) : undefined)) !== null && _a !== void 0 ? _a : ts.timestamp(); + var start = (_b = (startMarkName !== undefined ? marks.get(startMarkName) : undefined)) !== null && _b !== void 0 ? _b : timeorigin; + var previousDuration = durations.get(measureName) || 0; + durations.set(measureName, previousDuration + (end - start)); + performanceImpl === null || performanceImpl === void 0 ? void 0 : performanceImpl.measure(measureName, startMarkName, endMarkName); + } + } + performance.measure = measure; + /** + * Gets the number of times a marker was encountered. + * + * @param markName The name of the mark. + */ + function getCount(markName) { + return counts.get(markName) || 0; + } + performance.getCount = getCount; + /** + * Gets the total duration of all measurements with the supplied name. + * + * @param measureName The name of the measure whose durations should be accumulated. + */ + function getDuration(measureName) { + return durations.get(measureName) || 0; + } + performance.getDuration = getDuration; + /** + * Iterate over each measure, performing some action + * + * @param cb The action to perform for each measure + */ + function forEachMeasure(cb) { + durations.forEach(function (duration, measureName) { return cb(measureName, duration); }); + } + performance.forEachMeasure = forEachMeasure; + function forEachMark(cb) { + marks.forEach(function (_time, markName) { return cb(markName); }); + } + performance.forEachMark = forEachMark; + function clearMeasures(name) { + if (name !== undefined) + durations.delete(name); + else + durations.clear(); + performanceImpl === null || performanceImpl === void 0 ? void 0 : performanceImpl.clearMeasures(name); + } + performance.clearMeasures = clearMeasures; + function clearMarks(name) { + if (name !== undefined) { + counts.delete(name); + marks.delete(name); + } + else { + counts.clear(); + marks.clear(); + } + performanceImpl === null || performanceImpl === void 0 ? void 0 : performanceImpl.clearMarks(name); + } + performance.clearMarks = clearMarks; + /** + * Indicates whether the performance API is enabled. + */ + function isEnabled() { + return enabled; + } + performance.isEnabled = isEnabled; + /** Enables (and resets) performance measurements for the compiler. */ + function enable(system) { + var _a; + if (system === void 0) { system = ts.sys; } + if (!enabled) { + enabled = true; + perfHooks || (perfHooks = ts.tryGetNativePerformanceHooks()); + if (perfHooks) { + timeorigin = perfHooks.performance.timeOrigin; + // NodeJS's Web Performance API is currently slower than expected, but we'd still like + // to be able to leverage native trace events when node is run with either `--cpu-prof` + // or `--prof`, if we're running with our own `--generateCpuProfile` flag, or when + // running in debug mode (since its possible to generate a cpu profile while debugging). + if (perfHooks.shouldWriteNativeEvents || ((_a = system === null || system === void 0 ? void 0 : system.cpuProfilingEnabled) === null || _a === void 0 ? void 0 : _a.call(system)) || (system === null || system === void 0 ? void 0 : system.debugMode)) { + performanceImpl = perfHooks.performance; + } + } + } + return true; + } + performance.enable = enable; + /** Disables performance measurements for the compiler. */ + function disable() { + if (enabled) { + marks.clear(); + counts.clear(); + durations.clear(); + performanceImpl = undefined; + enabled = false; + } + } + performance.disable = disable; + })(performance = ts.performance || (ts.performance = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var _a; + var nullLogger = { + logEvent: ts.noop, + logErrEvent: ts.noop, + logPerfEvent: ts.noop, + logInfoEvent: ts.noop, + logStartCommand: ts.noop, + logStopCommand: ts.noop, + logStartUpdateProgram: ts.noop, + logStopUpdateProgram: ts.noop, + logStartUpdateGraph: ts.noop, + logStopUpdateGraph: ts.noop, + logStartResolveModule: ts.noop, + logStopResolveModule: ts.noop, + logStartParseSourceFile: ts.noop, + logStopParseSourceFile: ts.noop, + logStartReadFile: ts.noop, + logStopReadFile: ts.noop, + logStartBindFile: ts.noop, + logStopBindFile: ts.noop, + logStartScheduledOperation: ts.noop, + logStopScheduledOperation: ts.noop, + }; + // Load optional module to enable Event Tracing for Windows + // See https://github.com/microsoft/typescript-etw for more information + var etwModule; + try { + var etwModulePath = (_a = process.env.TS_ETW_MODULE_PATH) !== null && _a !== void 0 ? _a : "./node_modules/@microsoft/typescript-etw"; + // require() will throw an exception if the module is not found + // It may also return undefined if not installed properly + etwModule = require(etwModulePath); + } + catch (e) { + etwModule = undefined; + } + /** Performance logger that will generate ETW events if possible - check for `logEvent` member, as `etwModule` will be `{}` when browserified */ + ts.perfLogger = etwModule && etwModule.logEvent ? etwModule : nullLogger; +})(ts || (ts = {})); +/* Tracing events for the compiler. */ +/*@internal*/ +var ts; +(function (ts) { + // enable the above using startTracing() + // `tracingEnabled` should never be used directly, only through the above + var tracingEnabled; + (function (tracingEnabled) { + var fs; + var traceCount = 0; + var traceFd = 0; + var mode; + var typeCatalog = []; // NB: id is index + 1 + var legendPath; + var legend = []; + /** Starts tracing for the given project. */ + function startTracing(tracingMode, traceDir, configFilePath) { + ts.Debug.assert(!ts.tracing, "Tracing already started"); + if (fs === undefined) { + try { + fs = require("fs"); + } + catch (e) { + throw new Error("tracing requires having fs\n(original error: ".concat(e.message || e, ")")); + } + } + mode = tracingMode; + typeCatalog.length = 0; + if (legendPath === undefined) { + legendPath = ts.combinePaths(traceDir, "legend.json"); + } + // Note that writing will fail later on if it exists and is not a directory + if (!fs.existsSync(traceDir)) { + fs.mkdirSync(traceDir, { recursive: true }); + } + var countPart = mode === "build" ? ".".concat(process.pid, "-").concat(++traceCount) + : mode === "server" ? ".".concat(process.pid) + : ""; + var tracePath = ts.combinePaths(traceDir, "trace".concat(countPart, ".json")); + var typesPath = ts.combinePaths(traceDir, "types".concat(countPart, ".json")); + legend.push({ + configFilePath: configFilePath, + tracePath: tracePath, + typesPath: typesPath, + }); + traceFd = fs.openSync(tracePath, "w"); + ts.tracing = tracingEnabled; // only when traceFd is properly set + // Start with a prefix that contains some metadata that the devtools profiler expects (also avoids a warning on import) + var meta = { cat: "__metadata", ph: "M", ts: 1000 * ts.timestamp(), pid: 1, tid: 1 }; + fs.writeSync(traceFd, "[\n" + + [__assign({ name: "process_name", args: { name: "tsc" } }, meta), __assign({ name: "thread_name", args: { name: "Main" } }, meta), __assign(__assign({ name: "TracingStartedInBrowser" }, meta), { cat: "disabled-by-default-devtools.timeline" })] + .map(function (v) { return JSON.stringify(v); }).join(",\n")); + } + tracingEnabled.startTracing = startTracing; + /** Stops tracing for the in-progress project and dumps the type catalog. */ + function stopTracing() { + ts.Debug.assert(ts.tracing, "Tracing is not in progress"); + ts.Debug.assert(!!typeCatalog.length === (mode !== "server")); // Have a type catalog iff not in server mode + fs.writeSync(traceFd, "\n]\n"); + fs.closeSync(traceFd); + ts.tracing = undefined; + if (typeCatalog.length) { + dumpTypes(typeCatalog); + } + else { + // We pre-computed this path for convenience, but clear it + // now that the file won't be created. + legend[legend.length - 1].typesPath = undefined; + } + } + tracingEnabled.stopTracing = stopTracing; + function recordType(type) { + if (mode !== "server") { + typeCatalog.push(type); + } + } + tracingEnabled.recordType = recordType; + var Phase; + (function (Phase) { + Phase["Parse"] = "parse"; + Phase["Program"] = "program"; + Phase["Bind"] = "bind"; + Phase["Check"] = "check"; + Phase["CheckTypes"] = "checkTypes"; + Phase["Emit"] = "emit"; + Phase["Session"] = "session"; + })(Phase = tracingEnabled.Phase || (tracingEnabled.Phase = {})); + function instant(phase, name, args) { + writeEvent("I", phase, name, args, "\"s\":\"g\""); + } + tracingEnabled.instant = instant; + var eventStack = []; + /** + * @param separateBeginAndEnd - used for special cases where we need the trace point even if the event + * never terminates (typically for reducing a scenario too big to trace to one that can be completed). + * In the future we might implement an exit handler to dump unfinished events which would deprecate + * these operations. + */ + function push(phase, name, args, separateBeginAndEnd) { + if (separateBeginAndEnd === void 0) { separateBeginAndEnd = false; } + if (separateBeginAndEnd) { + writeEvent("B", phase, name, args); + } + eventStack.push({ phase: phase, name: name, args: args, time: 1000 * ts.timestamp(), separateBeginAndEnd: separateBeginAndEnd }); + } + tracingEnabled.push = push; + function pop(results) { + ts.Debug.assert(eventStack.length > 0); + writeStackEvent(eventStack.length - 1, 1000 * ts.timestamp(), results); + eventStack.length--; + } + tracingEnabled.pop = pop; + function popAll() { + var endTime = 1000 * ts.timestamp(); + for (var i = eventStack.length - 1; i >= 0; i--) { + writeStackEvent(i, endTime); + } + eventStack.length = 0; + } + tracingEnabled.popAll = popAll; + // sample every 10ms + var sampleInterval = 1000 * 10; + function writeStackEvent(index, endTime, results) { + var _a = eventStack[index], phase = _a.phase, name = _a.name, args = _a.args, time = _a.time, separateBeginAndEnd = _a.separateBeginAndEnd; + if (separateBeginAndEnd) { + ts.Debug.assert(!results, "`results` are not supported for events with `separateBeginAndEnd`"); + writeEvent("E", phase, name, args, /*extras*/ undefined, endTime); + } + // test if [time,endTime) straddles a sampling point + else if (sampleInterval - (time % sampleInterval) <= endTime - time) { + writeEvent("X", phase, name, __assign(__assign({}, args), { results: results }), "\"dur\":".concat(endTime - time), time); + } + } + function writeEvent(eventType, phase, name, args, extras, time) { + if (time === void 0) { time = 1000 * ts.timestamp(); } + // In server mode, there's no easy way to dump type information, so we drop events that would require it. + if (mode === "server" && phase === "checkTypes" /* Phase.CheckTypes */) + return; + ts.performance.mark("beginTracing"); + fs.writeSync(traceFd, ",\n{\"pid\":1,\"tid\":1,\"ph\":\"".concat(eventType, "\",\"cat\":\"").concat(phase, "\",\"ts\":").concat(time, ",\"name\":\"").concat(name, "\"")); + if (extras) + fs.writeSync(traceFd, ",".concat(extras)); + if (args) + fs.writeSync(traceFd, ",\"args\":".concat(JSON.stringify(args))); + fs.writeSync(traceFd, "}"); + ts.performance.mark("endTracing"); + ts.performance.measure("Tracing", "beginTracing", "endTracing"); + } + function getLocation(node) { + var file = ts.getSourceFileOfNode(node); + return !file + ? undefined + : { + path: file.path, + start: indexFromOne(ts.getLineAndCharacterOfPosition(file, node.pos)), + end: indexFromOne(ts.getLineAndCharacterOfPosition(file, node.end)), + }; + function indexFromOne(lc) { + return { + line: lc.line + 1, + character: lc.character + 1, + }; + } + } + function dumpTypes(types) { + var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x; + ts.performance.mark("beginDumpTypes"); + var typesPath = legend[legend.length - 1].typesPath; + var typesFd = fs.openSync(typesPath, "w"); + var recursionIdentityMap = new ts.Map(); + // Cleverness: no line break here so that the type ID will match the line number + fs.writeSync(typesFd, "["); + var numTypes = types.length; + for (var i = 0; i < numTypes; i++) { + var type = types[i]; + var objectFlags = type.objectFlags; + var symbol = (_a = type.aliasSymbol) !== null && _a !== void 0 ? _a : type.symbol; + // It's slow to compute the display text, so skip it unless it's really valuable (or cheap) + var display = void 0; + if ((objectFlags & 16 /* ObjectFlags.Anonymous */) | (type.flags & 2944 /* TypeFlags.Literal */)) { + try { + display = (_b = type.checker) === null || _b === void 0 ? void 0 : _b.typeToString(type); + } + catch (_y) { + display = undefined; + } + } + var indexedAccessProperties = {}; + if (type.flags & 8388608 /* TypeFlags.IndexedAccess */) { + var indexedAccessType = type; + indexedAccessProperties = { + indexedAccessObjectType: (_c = indexedAccessType.objectType) === null || _c === void 0 ? void 0 : _c.id, + indexedAccessIndexType: (_d = indexedAccessType.indexType) === null || _d === void 0 ? void 0 : _d.id, + }; + } + var referenceProperties = {}; + if (objectFlags & 4 /* ObjectFlags.Reference */) { + var referenceType = type; + referenceProperties = { + instantiatedType: (_e = referenceType.target) === null || _e === void 0 ? void 0 : _e.id, + typeArguments: (_f = referenceType.resolvedTypeArguments) === null || _f === void 0 ? void 0 : _f.map(function (t) { return t.id; }), + referenceLocation: getLocation(referenceType.node), + }; + } + var conditionalProperties = {}; + if (type.flags & 16777216 /* TypeFlags.Conditional */) { + var conditionalType = type; + conditionalProperties = { + conditionalCheckType: (_g = conditionalType.checkType) === null || _g === void 0 ? void 0 : _g.id, + conditionalExtendsType: (_h = conditionalType.extendsType) === null || _h === void 0 ? void 0 : _h.id, + conditionalTrueType: (_k = (_j = conditionalType.resolvedTrueType) === null || _j === void 0 ? void 0 : _j.id) !== null && _k !== void 0 ? _k : -1, + conditionalFalseType: (_m = (_l = conditionalType.resolvedFalseType) === null || _l === void 0 ? void 0 : _l.id) !== null && _m !== void 0 ? _m : -1, + }; + } + var substitutionProperties = {}; + if (type.flags & 33554432 /* TypeFlags.Substitution */) { + var substitutionType = type; + substitutionProperties = { + substitutionBaseType: (_o = substitutionType.baseType) === null || _o === void 0 ? void 0 : _o.id, + constraintType: (_p = substitutionType.constraint) === null || _p === void 0 ? void 0 : _p.id, + }; + } + var reverseMappedProperties = {}; + if (objectFlags & 1024 /* ObjectFlags.ReverseMapped */) { + var reverseMappedType = type; + reverseMappedProperties = { + reverseMappedSourceType: (_q = reverseMappedType.source) === null || _q === void 0 ? void 0 : _q.id, + reverseMappedMappedType: (_r = reverseMappedType.mappedType) === null || _r === void 0 ? void 0 : _r.id, + reverseMappedConstraintType: (_s = reverseMappedType.constraintType) === null || _s === void 0 ? void 0 : _s.id, + }; + } + var evolvingArrayProperties = {}; + if (objectFlags & 256 /* ObjectFlags.EvolvingArray */) { + var evolvingArrayType = type; + evolvingArrayProperties = { + evolvingArrayElementType: evolvingArrayType.elementType.id, + evolvingArrayFinalType: (_t = evolvingArrayType.finalArrayType) === null || _t === void 0 ? void 0 : _t.id, + }; + } + // We can't print out an arbitrary object, so just assign each one a unique number. + // Don't call it an "id" so people don't treat it as a type id. + var recursionToken = void 0; + var recursionIdentity = type.checker.getRecursionIdentity(type); + if (recursionIdentity) { + recursionToken = recursionIdentityMap.get(recursionIdentity); + if (!recursionToken) { + recursionToken = recursionIdentityMap.size; + recursionIdentityMap.set(recursionIdentity, recursionToken); + } + } + var descriptor = __assign(__assign(__assign(__assign(__assign(__assign(__assign({ id: type.id, intrinsicName: type.intrinsicName, symbolName: (symbol === null || symbol === void 0 ? void 0 : symbol.escapedName) && ts.unescapeLeadingUnderscores(symbol.escapedName), recursionId: recursionToken, isTuple: objectFlags & 8 /* ObjectFlags.Tuple */ ? true : undefined, unionTypes: (type.flags & 1048576 /* TypeFlags.Union */) ? (_u = type.types) === null || _u === void 0 ? void 0 : _u.map(function (t) { return t.id; }) : undefined, intersectionTypes: (type.flags & 2097152 /* TypeFlags.Intersection */) ? type.types.map(function (t) { return t.id; }) : undefined, aliasTypeArguments: (_v = type.aliasTypeArguments) === null || _v === void 0 ? void 0 : _v.map(function (t) { return t.id; }), keyofType: (type.flags & 4194304 /* TypeFlags.Index */) ? (_w = type.type) === null || _w === void 0 ? void 0 : _w.id : undefined }, indexedAccessProperties), referenceProperties), conditionalProperties), substitutionProperties), reverseMappedProperties), evolvingArrayProperties), { destructuringPattern: getLocation(type.pattern), firstDeclaration: getLocation((_x = symbol === null || symbol === void 0 ? void 0 : symbol.declarations) === null || _x === void 0 ? void 0 : _x[0]), flags: ts.Debug.formatTypeFlags(type.flags).split("|"), display: display }); + fs.writeSync(typesFd, JSON.stringify(descriptor)); + if (i < numTypes - 1) { + fs.writeSync(typesFd, ",\n"); + } + } + fs.writeSync(typesFd, "]\n"); + fs.closeSync(typesFd); + ts.performance.mark("endDumpTypes"); + ts.performance.measure("Dump types", "beginDumpTypes", "endDumpTypes"); + } + function dumpLegend() { + if (!legendPath) { + return; + } + fs.writeFileSync(legendPath, JSON.stringify(legend)); + } + tracingEnabled.dumpLegend = dumpLegend; + })(tracingEnabled || (tracingEnabled = {})); + // define after tracingEnabled is initialized + ts.startTracing = tracingEnabled.startTracing; + ts.dumpTracingLegend = tracingEnabled.dumpLegend; +})(ts || (ts = {})); +var ts; +(function (ts) { + // token > SyntaxKind.Identifier => token is a keyword + // Also, If you add a new SyntaxKind be sure to keep the `Markers` section at the bottom in sync + var SyntaxKind; + (function (SyntaxKind) { + SyntaxKind[SyntaxKind["Unknown"] = 0] = "Unknown"; + SyntaxKind[SyntaxKind["EndOfFileToken"] = 1] = "EndOfFileToken"; + SyntaxKind[SyntaxKind["SingleLineCommentTrivia"] = 2] = "SingleLineCommentTrivia"; + SyntaxKind[SyntaxKind["MultiLineCommentTrivia"] = 3] = "MultiLineCommentTrivia"; + SyntaxKind[SyntaxKind["NewLineTrivia"] = 4] = "NewLineTrivia"; + SyntaxKind[SyntaxKind["WhitespaceTrivia"] = 5] = "WhitespaceTrivia"; + // We detect and preserve #! on the first line + SyntaxKind[SyntaxKind["ShebangTrivia"] = 6] = "ShebangTrivia"; + // We detect and provide better error recovery when we encounter a git merge marker. This + // allows us to edit files with git-conflict markers in them in a much more pleasant manner. + SyntaxKind[SyntaxKind["ConflictMarkerTrivia"] = 7] = "ConflictMarkerTrivia"; + // Literals + SyntaxKind[SyntaxKind["NumericLiteral"] = 8] = "NumericLiteral"; + SyntaxKind[SyntaxKind["BigIntLiteral"] = 9] = "BigIntLiteral"; + SyntaxKind[SyntaxKind["StringLiteral"] = 10] = "StringLiteral"; + SyntaxKind[SyntaxKind["JsxText"] = 11] = "JsxText"; + SyntaxKind[SyntaxKind["JsxTextAllWhiteSpaces"] = 12] = "JsxTextAllWhiteSpaces"; + SyntaxKind[SyntaxKind["RegularExpressionLiteral"] = 13] = "RegularExpressionLiteral"; + SyntaxKind[SyntaxKind["NoSubstitutionTemplateLiteral"] = 14] = "NoSubstitutionTemplateLiteral"; + // Pseudo-literals + SyntaxKind[SyntaxKind["TemplateHead"] = 15] = "TemplateHead"; + SyntaxKind[SyntaxKind["TemplateMiddle"] = 16] = "TemplateMiddle"; + SyntaxKind[SyntaxKind["TemplateTail"] = 17] = "TemplateTail"; + // Punctuation + SyntaxKind[SyntaxKind["OpenBraceToken"] = 18] = "OpenBraceToken"; + SyntaxKind[SyntaxKind["CloseBraceToken"] = 19] = "CloseBraceToken"; + SyntaxKind[SyntaxKind["OpenParenToken"] = 20] = "OpenParenToken"; + SyntaxKind[SyntaxKind["CloseParenToken"] = 21] = "CloseParenToken"; + SyntaxKind[SyntaxKind["OpenBracketToken"] = 22] = "OpenBracketToken"; + SyntaxKind[SyntaxKind["CloseBracketToken"] = 23] = "CloseBracketToken"; + SyntaxKind[SyntaxKind["DotToken"] = 24] = "DotToken"; + SyntaxKind[SyntaxKind["DotDotDotToken"] = 25] = "DotDotDotToken"; + SyntaxKind[SyntaxKind["SemicolonToken"] = 26] = "SemicolonToken"; + SyntaxKind[SyntaxKind["CommaToken"] = 27] = "CommaToken"; + SyntaxKind[SyntaxKind["QuestionDotToken"] = 28] = "QuestionDotToken"; + SyntaxKind[SyntaxKind["LessThanToken"] = 29] = "LessThanToken"; + SyntaxKind[SyntaxKind["LessThanSlashToken"] = 30] = "LessThanSlashToken"; + SyntaxKind[SyntaxKind["GreaterThanToken"] = 31] = "GreaterThanToken"; + SyntaxKind[SyntaxKind["LessThanEqualsToken"] = 32] = "LessThanEqualsToken"; + SyntaxKind[SyntaxKind["GreaterThanEqualsToken"] = 33] = "GreaterThanEqualsToken"; + SyntaxKind[SyntaxKind["EqualsEqualsToken"] = 34] = "EqualsEqualsToken"; + SyntaxKind[SyntaxKind["ExclamationEqualsToken"] = 35] = "ExclamationEqualsToken"; + SyntaxKind[SyntaxKind["EqualsEqualsEqualsToken"] = 36] = "EqualsEqualsEqualsToken"; + SyntaxKind[SyntaxKind["ExclamationEqualsEqualsToken"] = 37] = "ExclamationEqualsEqualsToken"; + SyntaxKind[SyntaxKind["EqualsGreaterThanToken"] = 38] = "EqualsGreaterThanToken"; + SyntaxKind[SyntaxKind["PlusToken"] = 39] = "PlusToken"; + SyntaxKind[SyntaxKind["MinusToken"] = 40] = "MinusToken"; + SyntaxKind[SyntaxKind["AsteriskToken"] = 41] = "AsteriskToken"; + SyntaxKind[SyntaxKind["AsteriskAsteriskToken"] = 42] = "AsteriskAsteriskToken"; + SyntaxKind[SyntaxKind["SlashToken"] = 43] = "SlashToken"; + SyntaxKind[SyntaxKind["PercentToken"] = 44] = "PercentToken"; + SyntaxKind[SyntaxKind["PlusPlusToken"] = 45] = "PlusPlusToken"; + SyntaxKind[SyntaxKind["MinusMinusToken"] = 46] = "MinusMinusToken"; + SyntaxKind[SyntaxKind["LessThanLessThanToken"] = 47] = "LessThanLessThanToken"; + SyntaxKind[SyntaxKind["GreaterThanGreaterThanToken"] = 48] = "GreaterThanGreaterThanToken"; + SyntaxKind[SyntaxKind["GreaterThanGreaterThanGreaterThanToken"] = 49] = "GreaterThanGreaterThanGreaterThanToken"; + SyntaxKind[SyntaxKind["AmpersandToken"] = 50] = "AmpersandToken"; + SyntaxKind[SyntaxKind["BarToken"] = 51] = "BarToken"; + SyntaxKind[SyntaxKind["CaretToken"] = 52] = "CaretToken"; + SyntaxKind[SyntaxKind["ExclamationToken"] = 53] = "ExclamationToken"; + SyntaxKind[SyntaxKind["TildeToken"] = 54] = "TildeToken"; + SyntaxKind[SyntaxKind["AmpersandAmpersandToken"] = 55] = "AmpersandAmpersandToken"; + SyntaxKind[SyntaxKind["BarBarToken"] = 56] = "BarBarToken"; + SyntaxKind[SyntaxKind["QuestionToken"] = 57] = "QuestionToken"; + SyntaxKind[SyntaxKind["ColonToken"] = 58] = "ColonToken"; + SyntaxKind[SyntaxKind["AtToken"] = 59] = "AtToken"; + SyntaxKind[SyntaxKind["QuestionQuestionToken"] = 60] = "QuestionQuestionToken"; + /** Only the JSDoc scanner produces BacktickToken. The normal scanner produces NoSubstitutionTemplateLiteral and related kinds. */ + SyntaxKind[SyntaxKind["BacktickToken"] = 61] = "BacktickToken"; + /** Only the JSDoc scanner produces HashToken. The normal scanner produces PrivateIdentifier. */ + SyntaxKind[SyntaxKind["HashToken"] = 62] = "HashToken"; + // Assignments + SyntaxKind[SyntaxKind["EqualsToken"] = 63] = "EqualsToken"; + SyntaxKind[SyntaxKind["PlusEqualsToken"] = 64] = "PlusEqualsToken"; + SyntaxKind[SyntaxKind["MinusEqualsToken"] = 65] = "MinusEqualsToken"; + SyntaxKind[SyntaxKind["AsteriskEqualsToken"] = 66] = "AsteriskEqualsToken"; + SyntaxKind[SyntaxKind["AsteriskAsteriskEqualsToken"] = 67] = "AsteriskAsteriskEqualsToken"; + SyntaxKind[SyntaxKind["SlashEqualsToken"] = 68] = "SlashEqualsToken"; + SyntaxKind[SyntaxKind["PercentEqualsToken"] = 69] = "PercentEqualsToken"; + SyntaxKind[SyntaxKind["LessThanLessThanEqualsToken"] = 70] = "LessThanLessThanEqualsToken"; + SyntaxKind[SyntaxKind["GreaterThanGreaterThanEqualsToken"] = 71] = "GreaterThanGreaterThanEqualsToken"; + SyntaxKind[SyntaxKind["GreaterThanGreaterThanGreaterThanEqualsToken"] = 72] = "GreaterThanGreaterThanGreaterThanEqualsToken"; + SyntaxKind[SyntaxKind["AmpersandEqualsToken"] = 73] = "AmpersandEqualsToken"; + SyntaxKind[SyntaxKind["BarEqualsToken"] = 74] = "BarEqualsToken"; + SyntaxKind[SyntaxKind["BarBarEqualsToken"] = 75] = "BarBarEqualsToken"; + SyntaxKind[SyntaxKind["AmpersandAmpersandEqualsToken"] = 76] = "AmpersandAmpersandEqualsToken"; + SyntaxKind[SyntaxKind["QuestionQuestionEqualsToken"] = 77] = "QuestionQuestionEqualsToken"; + SyntaxKind[SyntaxKind["CaretEqualsToken"] = 78] = "CaretEqualsToken"; + // Identifiers and PrivateIdentifiers + SyntaxKind[SyntaxKind["Identifier"] = 79] = "Identifier"; + SyntaxKind[SyntaxKind["PrivateIdentifier"] = 80] = "PrivateIdentifier"; + // Reserved words + SyntaxKind[SyntaxKind["BreakKeyword"] = 81] = "BreakKeyword"; + SyntaxKind[SyntaxKind["CaseKeyword"] = 82] = "CaseKeyword"; + SyntaxKind[SyntaxKind["CatchKeyword"] = 83] = "CatchKeyword"; + SyntaxKind[SyntaxKind["ClassKeyword"] = 84] = "ClassKeyword"; + SyntaxKind[SyntaxKind["ConstKeyword"] = 85] = "ConstKeyword"; + SyntaxKind[SyntaxKind["ContinueKeyword"] = 86] = "ContinueKeyword"; + SyntaxKind[SyntaxKind["DebuggerKeyword"] = 87] = "DebuggerKeyword"; + SyntaxKind[SyntaxKind["DefaultKeyword"] = 88] = "DefaultKeyword"; + SyntaxKind[SyntaxKind["DeleteKeyword"] = 89] = "DeleteKeyword"; + SyntaxKind[SyntaxKind["DoKeyword"] = 90] = "DoKeyword"; + SyntaxKind[SyntaxKind["ElseKeyword"] = 91] = "ElseKeyword"; + SyntaxKind[SyntaxKind["EnumKeyword"] = 92] = "EnumKeyword"; + SyntaxKind[SyntaxKind["ExportKeyword"] = 93] = "ExportKeyword"; + SyntaxKind[SyntaxKind["ExtendsKeyword"] = 94] = "ExtendsKeyword"; + SyntaxKind[SyntaxKind["FalseKeyword"] = 95] = "FalseKeyword"; + SyntaxKind[SyntaxKind["FinallyKeyword"] = 96] = "FinallyKeyword"; + SyntaxKind[SyntaxKind["ForKeyword"] = 97] = "ForKeyword"; + SyntaxKind[SyntaxKind["FunctionKeyword"] = 98] = "FunctionKeyword"; + SyntaxKind[SyntaxKind["IfKeyword"] = 99] = "IfKeyword"; + SyntaxKind[SyntaxKind["ImportKeyword"] = 100] = "ImportKeyword"; + SyntaxKind[SyntaxKind["InKeyword"] = 101] = "InKeyword"; + SyntaxKind[SyntaxKind["InstanceOfKeyword"] = 102] = "InstanceOfKeyword"; + SyntaxKind[SyntaxKind["NewKeyword"] = 103] = "NewKeyword"; + SyntaxKind[SyntaxKind["NullKeyword"] = 104] = "NullKeyword"; + SyntaxKind[SyntaxKind["ReturnKeyword"] = 105] = "ReturnKeyword"; + SyntaxKind[SyntaxKind["SuperKeyword"] = 106] = "SuperKeyword"; + SyntaxKind[SyntaxKind["SwitchKeyword"] = 107] = "SwitchKeyword"; + SyntaxKind[SyntaxKind["ThisKeyword"] = 108] = "ThisKeyword"; + SyntaxKind[SyntaxKind["ThrowKeyword"] = 109] = "ThrowKeyword"; + SyntaxKind[SyntaxKind["TrueKeyword"] = 110] = "TrueKeyword"; + SyntaxKind[SyntaxKind["TryKeyword"] = 111] = "TryKeyword"; + SyntaxKind[SyntaxKind["TypeOfKeyword"] = 112] = "TypeOfKeyword"; + SyntaxKind[SyntaxKind["VarKeyword"] = 113] = "VarKeyword"; + SyntaxKind[SyntaxKind["VoidKeyword"] = 114] = "VoidKeyword"; + SyntaxKind[SyntaxKind["WhileKeyword"] = 115] = "WhileKeyword"; + SyntaxKind[SyntaxKind["WithKeyword"] = 116] = "WithKeyword"; + // Strict mode reserved words + SyntaxKind[SyntaxKind["ImplementsKeyword"] = 117] = "ImplementsKeyword"; + SyntaxKind[SyntaxKind["InterfaceKeyword"] = 118] = "InterfaceKeyword"; + SyntaxKind[SyntaxKind["LetKeyword"] = 119] = "LetKeyword"; + SyntaxKind[SyntaxKind["PackageKeyword"] = 120] = "PackageKeyword"; + SyntaxKind[SyntaxKind["PrivateKeyword"] = 121] = "PrivateKeyword"; + SyntaxKind[SyntaxKind["ProtectedKeyword"] = 122] = "ProtectedKeyword"; + SyntaxKind[SyntaxKind["PublicKeyword"] = 123] = "PublicKeyword"; + SyntaxKind[SyntaxKind["StaticKeyword"] = 124] = "StaticKeyword"; + SyntaxKind[SyntaxKind["YieldKeyword"] = 125] = "YieldKeyword"; + // Contextual keywords + SyntaxKind[SyntaxKind["AbstractKeyword"] = 126] = "AbstractKeyword"; + SyntaxKind[SyntaxKind["AccessorKeyword"] = 127] = "AccessorKeyword"; + SyntaxKind[SyntaxKind["AsKeyword"] = 128] = "AsKeyword"; + SyntaxKind[SyntaxKind["AssertsKeyword"] = 129] = "AssertsKeyword"; + SyntaxKind[SyntaxKind["AssertKeyword"] = 130] = "AssertKeyword"; + SyntaxKind[SyntaxKind["AnyKeyword"] = 131] = "AnyKeyword"; + SyntaxKind[SyntaxKind["AsyncKeyword"] = 132] = "AsyncKeyword"; + SyntaxKind[SyntaxKind["AwaitKeyword"] = 133] = "AwaitKeyword"; + SyntaxKind[SyntaxKind["BooleanKeyword"] = 134] = "BooleanKeyword"; + SyntaxKind[SyntaxKind["ConstructorKeyword"] = 135] = "ConstructorKeyword"; + SyntaxKind[SyntaxKind["DeclareKeyword"] = 136] = "DeclareKeyword"; + SyntaxKind[SyntaxKind["GetKeyword"] = 137] = "GetKeyword"; + SyntaxKind[SyntaxKind["InferKeyword"] = 138] = "InferKeyword"; + SyntaxKind[SyntaxKind["IntrinsicKeyword"] = 139] = "IntrinsicKeyword"; + SyntaxKind[SyntaxKind["IsKeyword"] = 140] = "IsKeyword"; + SyntaxKind[SyntaxKind["KeyOfKeyword"] = 141] = "KeyOfKeyword"; + SyntaxKind[SyntaxKind["ModuleKeyword"] = 142] = "ModuleKeyword"; + SyntaxKind[SyntaxKind["NamespaceKeyword"] = 143] = "NamespaceKeyword"; + SyntaxKind[SyntaxKind["NeverKeyword"] = 144] = "NeverKeyword"; + SyntaxKind[SyntaxKind["OutKeyword"] = 145] = "OutKeyword"; + SyntaxKind[SyntaxKind["ReadonlyKeyword"] = 146] = "ReadonlyKeyword"; + SyntaxKind[SyntaxKind["RequireKeyword"] = 147] = "RequireKeyword"; + SyntaxKind[SyntaxKind["NumberKeyword"] = 148] = "NumberKeyword"; + SyntaxKind[SyntaxKind["ObjectKeyword"] = 149] = "ObjectKeyword"; + SyntaxKind[SyntaxKind["SatisfiesKeyword"] = 150] = "SatisfiesKeyword"; + SyntaxKind[SyntaxKind["SetKeyword"] = 151] = "SetKeyword"; + SyntaxKind[SyntaxKind["StringKeyword"] = 152] = "StringKeyword"; + SyntaxKind[SyntaxKind["SymbolKeyword"] = 153] = "SymbolKeyword"; + SyntaxKind[SyntaxKind["TypeKeyword"] = 154] = "TypeKeyword"; + SyntaxKind[SyntaxKind["UndefinedKeyword"] = 155] = "UndefinedKeyword"; + SyntaxKind[SyntaxKind["UniqueKeyword"] = 156] = "UniqueKeyword"; + SyntaxKind[SyntaxKind["UnknownKeyword"] = 157] = "UnknownKeyword"; + SyntaxKind[SyntaxKind["FromKeyword"] = 158] = "FromKeyword"; + SyntaxKind[SyntaxKind["GlobalKeyword"] = 159] = "GlobalKeyword"; + SyntaxKind[SyntaxKind["BigIntKeyword"] = 160] = "BigIntKeyword"; + SyntaxKind[SyntaxKind["OverrideKeyword"] = 161] = "OverrideKeyword"; + SyntaxKind[SyntaxKind["OfKeyword"] = 162] = "OfKeyword"; + // Parse tree nodes + // Names + SyntaxKind[SyntaxKind["QualifiedName"] = 163] = "QualifiedName"; + SyntaxKind[SyntaxKind["ComputedPropertyName"] = 164] = "ComputedPropertyName"; + // Signature elements + SyntaxKind[SyntaxKind["TypeParameter"] = 165] = "TypeParameter"; + SyntaxKind[SyntaxKind["Parameter"] = 166] = "Parameter"; + SyntaxKind[SyntaxKind["Decorator"] = 167] = "Decorator"; + // TypeMember + SyntaxKind[SyntaxKind["PropertySignature"] = 168] = "PropertySignature"; + SyntaxKind[SyntaxKind["PropertyDeclaration"] = 169] = "PropertyDeclaration"; + SyntaxKind[SyntaxKind["MethodSignature"] = 170] = "MethodSignature"; + SyntaxKind[SyntaxKind["MethodDeclaration"] = 171] = "MethodDeclaration"; + SyntaxKind[SyntaxKind["ClassStaticBlockDeclaration"] = 172] = "ClassStaticBlockDeclaration"; + SyntaxKind[SyntaxKind["Constructor"] = 173] = "Constructor"; + SyntaxKind[SyntaxKind["GetAccessor"] = 174] = "GetAccessor"; + SyntaxKind[SyntaxKind["SetAccessor"] = 175] = "SetAccessor"; + SyntaxKind[SyntaxKind["CallSignature"] = 176] = "CallSignature"; + SyntaxKind[SyntaxKind["ConstructSignature"] = 177] = "ConstructSignature"; + SyntaxKind[SyntaxKind["IndexSignature"] = 178] = "IndexSignature"; + // Type + SyntaxKind[SyntaxKind["TypePredicate"] = 179] = "TypePredicate"; + SyntaxKind[SyntaxKind["TypeReference"] = 180] = "TypeReference"; + SyntaxKind[SyntaxKind["FunctionType"] = 181] = "FunctionType"; + SyntaxKind[SyntaxKind["ConstructorType"] = 182] = "ConstructorType"; + SyntaxKind[SyntaxKind["TypeQuery"] = 183] = "TypeQuery"; + SyntaxKind[SyntaxKind["TypeLiteral"] = 184] = "TypeLiteral"; + SyntaxKind[SyntaxKind["ArrayType"] = 185] = "ArrayType"; + SyntaxKind[SyntaxKind["TupleType"] = 186] = "TupleType"; + SyntaxKind[SyntaxKind["OptionalType"] = 187] = "OptionalType"; + SyntaxKind[SyntaxKind["RestType"] = 188] = "RestType"; + SyntaxKind[SyntaxKind["UnionType"] = 189] = "UnionType"; + SyntaxKind[SyntaxKind["IntersectionType"] = 190] = "IntersectionType"; + SyntaxKind[SyntaxKind["ConditionalType"] = 191] = "ConditionalType"; + SyntaxKind[SyntaxKind["InferType"] = 192] = "InferType"; + SyntaxKind[SyntaxKind["ParenthesizedType"] = 193] = "ParenthesizedType"; + SyntaxKind[SyntaxKind["ThisType"] = 194] = "ThisType"; + SyntaxKind[SyntaxKind["TypeOperator"] = 195] = "TypeOperator"; + SyntaxKind[SyntaxKind["IndexedAccessType"] = 196] = "IndexedAccessType"; + SyntaxKind[SyntaxKind["MappedType"] = 197] = "MappedType"; + SyntaxKind[SyntaxKind["LiteralType"] = 198] = "LiteralType"; + SyntaxKind[SyntaxKind["NamedTupleMember"] = 199] = "NamedTupleMember"; + SyntaxKind[SyntaxKind["TemplateLiteralType"] = 200] = "TemplateLiteralType"; + SyntaxKind[SyntaxKind["TemplateLiteralTypeSpan"] = 201] = "TemplateLiteralTypeSpan"; + SyntaxKind[SyntaxKind["ImportType"] = 202] = "ImportType"; + // Binding patterns + SyntaxKind[SyntaxKind["ObjectBindingPattern"] = 203] = "ObjectBindingPattern"; + SyntaxKind[SyntaxKind["ArrayBindingPattern"] = 204] = "ArrayBindingPattern"; + SyntaxKind[SyntaxKind["BindingElement"] = 205] = "BindingElement"; + // Expression + SyntaxKind[SyntaxKind["ArrayLiteralExpression"] = 206] = "ArrayLiteralExpression"; + SyntaxKind[SyntaxKind["ObjectLiteralExpression"] = 207] = "ObjectLiteralExpression"; + SyntaxKind[SyntaxKind["PropertyAccessExpression"] = 208] = "PropertyAccessExpression"; + SyntaxKind[SyntaxKind["ElementAccessExpression"] = 209] = "ElementAccessExpression"; + SyntaxKind[SyntaxKind["CallExpression"] = 210] = "CallExpression"; + SyntaxKind[SyntaxKind["NewExpression"] = 211] = "NewExpression"; + SyntaxKind[SyntaxKind["TaggedTemplateExpression"] = 212] = "TaggedTemplateExpression"; + SyntaxKind[SyntaxKind["TypeAssertionExpression"] = 213] = "TypeAssertionExpression"; + SyntaxKind[SyntaxKind["ParenthesizedExpression"] = 214] = "ParenthesizedExpression"; + SyntaxKind[SyntaxKind["FunctionExpression"] = 215] = "FunctionExpression"; + SyntaxKind[SyntaxKind["ArrowFunction"] = 216] = "ArrowFunction"; + SyntaxKind[SyntaxKind["DeleteExpression"] = 217] = "DeleteExpression"; + SyntaxKind[SyntaxKind["TypeOfExpression"] = 218] = "TypeOfExpression"; + SyntaxKind[SyntaxKind["VoidExpression"] = 219] = "VoidExpression"; + SyntaxKind[SyntaxKind["AwaitExpression"] = 220] = "AwaitExpression"; + SyntaxKind[SyntaxKind["PrefixUnaryExpression"] = 221] = "PrefixUnaryExpression"; + SyntaxKind[SyntaxKind["PostfixUnaryExpression"] = 222] = "PostfixUnaryExpression"; + SyntaxKind[SyntaxKind["BinaryExpression"] = 223] = "BinaryExpression"; + SyntaxKind[SyntaxKind["ConditionalExpression"] = 224] = "ConditionalExpression"; + SyntaxKind[SyntaxKind["TemplateExpression"] = 225] = "TemplateExpression"; + SyntaxKind[SyntaxKind["YieldExpression"] = 226] = "YieldExpression"; + SyntaxKind[SyntaxKind["SpreadElement"] = 227] = "SpreadElement"; + SyntaxKind[SyntaxKind["ClassExpression"] = 228] = "ClassExpression"; + SyntaxKind[SyntaxKind["OmittedExpression"] = 229] = "OmittedExpression"; + SyntaxKind[SyntaxKind["ExpressionWithTypeArguments"] = 230] = "ExpressionWithTypeArguments"; + SyntaxKind[SyntaxKind["AsExpression"] = 231] = "AsExpression"; + SyntaxKind[SyntaxKind["NonNullExpression"] = 232] = "NonNullExpression"; + SyntaxKind[SyntaxKind["MetaProperty"] = 233] = "MetaProperty"; + SyntaxKind[SyntaxKind["SyntheticExpression"] = 234] = "SyntheticExpression"; + SyntaxKind[SyntaxKind["SatisfiesExpression"] = 235] = "SatisfiesExpression"; + // Misc + SyntaxKind[SyntaxKind["TemplateSpan"] = 236] = "TemplateSpan"; + SyntaxKind[SyntaxKind["SemicolonClassElement"] = 237] = "SemicolonClassElement"; + // Element + SyntaxKind[SyntaxKind["Block"] = 238] = "Block"; + SyntaxKind[SyntaxKind["EmptyStatement"] = 239] = "EmptyStatement"; + SyntaxKind[SyntaxKind["VariableStatement"] = 240] = "VariableStatement"; + SyntaxKind[SyntaxKind["ExpressionStatement"] = 241] = "ExpressionStatement"; + SyntaxKind[SyntaxKind["IfStatement"] = 242] = "IfStatement"; + SyntaxKind[SyntaxKind["DoStatement"] = 243] = "DoStatement"; + SyntaxKind[SyntaxKind["WhileStatement"] = 244] = "WhileStatement"; + SyntaxKind[SyntaxKind["ForStatement"] = 245] = "ForStatement"; + SyntaxKind[SyntaxKind["ForInStatement"] = 246] = "ForInStatement"; + SyntaxKind[SyntaxKind["ForOfStatement"] = 247] = "ForOfStatement"; + SyntaxKind[SyntaxKind["ContinueStatement"] = 248] = "ContinueStatement"; + SyntaxKind[SyntaxKind["BreakStatement"] = 249] = "BreakStatement"; + SyntaxKind[SyntaxKind["ReturnStatement"] = 250] = "ReturnStatement"; + SyntaxKind[SyntaxKind["WithStatement"] = 251] = "WithStatement"; + SyntaxKind[SyntaxKind["SwitchStatement"] = 252] = "SwitchStatement"; + SyntaxKind[SyntaxKind["LabeledStatement"] = 253] = "LabeledStatement"; + SyntaxKind[SyntaxKind["ThrowStatement"] = 254] = "ThrowStatement"; + SyntaxKind[SyntaxKind["TryStatement"] = 255] = "TryStatement"; + SyntaxKind[SyntaxKind["DebuggerStatement"] = 256] = "DebuggerStatement"; + SyntaxKind[SyntaxKind["VariableDeclaration"] = 257] = "VariableDeclaration"; + SyntaxKind[SyntaxKind["VariableDeclarationList"] = 258] = "VariableDeclarationList"; + SyntaxKind[SyntaxKind["FunctionDeclaration"] = 259] = "FunctionDeclaration"; + SyntaxKind[SyntaxKind["ClassDeclaration"] = 260] = "ClassDeclaration"; + SyntaxKind[SyntaxKind["InterfaceDeclaration"] = 261] = "InterfaceDeclaration"; + SyntaxKind[SyntaxKind["TypeAliasDeclaration"] = 262] = "TypeAliasDeclaration"; + SyntaxKind[SyntaxKind["EnumDeclaration"] = 263] = "EnumDeclaration"; + SyntaxKind[SyntaxKind["ModuleDeclaration"] = 264] = "ModuleDeclaration"; + SyntaxKind[SyntaxKind["ModuleBlock"] = 265] = "ModuleBlock"; + SyntaxKind[SyntaxKind["CaseBlock"] = 266] = "CaseBlock"; + SyntaxKind[SyntaxKind["NamespaceExportDeclaration"] = 267] = "NamespaceExportDeclaration"; + SyntaxKind[SyntaxKind["ImportEqualsDeclaration"] = 268] = "ImportEqualsDeclaration"; + SyntaxKind[SyntaxKind["ImportDeclaration"] = 269] = "ImportDeclaration"; + SyntaxKind[SyntaxKind["ImportClause"] = 270] = "ImportClause"; + SyntaxKind[SyntaxKind["NamespaceImport"] = 271] = "NamespaceImport"; + SyntaxKind[SyntaxKind["NamedImports"] = 272] = "NamedImports"; + SyntaxKind[SyntaxKind["ImportSpecifier"] = 273] = "ImportSpecifier"; + SyntaxKind[SyntaxKind["ExportAssignment"] = 274] = "ExportAssignment"; + SyntaxKind[SyntaxKind["ExportDeclaration"] = 275] = "ExportDeclaration"; + SyntaxKind[SyntaxKind["NamedExports"] = 276] = "NamedExports"; + SyntaxKind[SyntaxKind["NamespaceExport"] = 277] = "NamespaceExport"; + SyntaxKind[SyntaxKind["ExportSpecifier"] = 278] = "ExportSpecifier"; + SyntaxKind[SyntaxKind["MissingDeclaration"] = 279] = "MissingDeclaration"; + // Module references + SyntaxKind[SyntaxKind["ExternalModuleReference"] = 280] = "ExternalModuleReference"; + // JSX + SyntaxKind[SyntaxKind["JsxElement"] = 281] = "JsxElement"; + SyntaxKind[SyntaxKind["JsxSelfClosingElement"] = 282] = "JsxSelfClosingElement"; + SyntaxKind[SyntaxKind["JsxOpeningElement"] = 283] = "JsxOpeningElement"; + SyntaxKind[SyntaxKind["JsxClosingElement"] = 284] = "JsxClosingElement"; + SyntaxKind[SyntaxKind["JsxFragment"] = 285] = "JsxFragment"; + SyntaxKind[SyntaxKind["JsxOpeningFragment"] = 286] = "JsxOpeningFragment"; + SyntaxKind[SyntaxKind["JsxClosingFragment"] = 287] = "JsxClosingFragment"; + SyntaxKind[SyntaxKind["JsxAttribute"] = 288] = "JsxAttribute"; + SyntaxKind[SyntaxKind["JsxAttributes"] = 289] = "JsxAttributes"; + SyntaxKind[SyntaxKind["JsxSpreadAttribute"] = 290] = "JsxSpreadAttribute"; + SyntaxKind[SyntaxKind["JsxExpression"] = 291] = "JsxExpression"; + // Clauses + SyntaxKind[SyntaxKind["CaseClause"] = 292] = "CaseClause"; + SyntaxKind[SyntaxKind["DefaultClause"] = 293] = "DefaultClause"; + SyntaxKind[SyntaxKind["HeritageClause"] = 294] = "HeritageClause"; + SyntaxKind[SyntaxKind["CatchClause"] = 295] = "CatchClause"; + SyntaxKind[SyntaxKind["AssertClause"] = 296] = "AssertClause"; + SyntaxKind[SyntaxKind["AssertEntry"] = 297] = "AssertEntry"; + SyntaxKind[SyntaxKind["ImportTypeAssertionContainer"] = 298] = "ImportTypeAssertionContainer"; + // Property assignments + SyntaxKind[SyntaxKind["PropertyAssignment"] = 299] = "PropertyAssignment"; + SyntaxKind[SyntaxKind["ShorthandPropertyAssignment"] = 300] = "ShorthandPropertyAssignment"; + SyntaxKind[SyntaxKind["SpreadAssignment"] = 301] = "SpreadAssignment"; + // Enum + SyntaxKind[SyntaxKind["EnumMember"] = 302] = "EnumMember"; + // Unparsed + SyntaxKind[SyntaxKind["UnparsedPrologue"] = 303] = "UnparsedPrologue"; + SyntaxKind[SyntaxKind["UnparsedPrepend"] = 304] = "UnparsedPrepend"; + SyntaxKind[SyntaxKind["UnparsedText"] = 305] = "UnparsedText"; + SyntaxKind[SyntaxKind["UnparsedInternalText"] = 306] = "UnparsedInternalText"; + SyntaxKind[SyntaxKind["UnparsedSyntheticReference"] = 307] = "UnparsedSyntheticReference"; + // Top-level nodes + SyntaxKind[SyntaxKind["SourceFile"] = 308] = "SourceFile"; + SyntaxKind[SyntaxKind["Bundle"] = 309] = "Bundle"; + SyntaxKind[SyntaxKind["UnparsedSource"] = 310] = "UnparsedSource"; + SyntaxKind[SyntaxKind["InputFiles"] = 311] = "InputFiles"; + // JSDoc nodes + SyntaxKind[SyntaxKind["JSDocTypeExpression"] = 312] = "JSDocTypeExpression"; + SyntaxKind[SyntaxKind["JSDocNameReference"] = 313] = "JSDocNameReference"; + SyntaxKind[SyntaxKind["JSDocMemberName"] = 314] = "JSDocMemberName"; + SyntaxKind[SyntaxKind["JSDocAllType"] = 315] = "JSDocAllType"; + SyntaxKind[SyntaxKind["JSDocUnknownType"] = 316] = "JSDocUnknownType"; + SyntaxKind[SyntaxKind["JSDocNullableType"] = 317] = "JSDocNullableType"; + SyntaxKind[SyntaxKind["JSDocNonNullableType"] = 318] = "JSDocNonNullableType"; + SyntaxKind[SyntaxKind["JSDocOptionalType"] = 319] = "JSDocOptionalType"; + SyntaxKind[SyntaxKind["JSDocFunctionType"] = 320] = "JSDocFunctionType"; + SyntaxKind[SyntaxKind["JSDocVariadicType"] = 321] = "JSDocVariadicType"; + SyntaxKind[SyntaxKind["JSDocNamepathType"] = 322] = "JSDocNamepathType"; + SyntaxKind[SyntaxKind["JSDoc"] = 323] = "JSDoc"; + /** @deprecated Use SyntaxKind.JSDoc */ + SyntaxKind[SyntaxKind["JSDocComment"] = 323] = "JSDocComment"; + SyntaxKind[SyntaxKind["JSDocText"] = 324] = "JSDocText"; + SyntaxKind[SyntaxKind["JSDocTypeLiteral"] = 325] = "JSDocTypeLiteral"; + SyntaxKind[SyntaxKind["JSDocSignature"] = 326] = "JSDocSignature"; + SyntaxKind[SyntaxKind["JSDocLink"] = 327] = "JSDocLink"; + SyntaxKind[SyntaxKind["JSDocLinkCode"] = 328] = "JSDocLinkCode"; + SyntaxKind[SyntaxKind["JSDocLinkPlain"] = 329] = "JSDocLinkPlain"; + SyntaxKind[SyntaxKind["JSDocTag"] = 330] = "JSDocTag"; + SyntaxKind[SyntaxKind["JSDocAugmentsTag"] = 331] = "JSDocAugmentsTag"; + SyntaxKind[SyntaxKind["JSDocImplementsTag"] = 332] = "JSDocImplementsTag"; + SyntaxKind[SyntaxKind["JSDocAuthorTag"] = 333] = "JSDocAuthorTag"; + SyntaxKind[SyntaxKind["JSDocDeprecatedTag"] = 334] = "JSDocDeprecatedTag"; + SyntaxKind[SyntaxKind["JSDocClassTag"] = 335] = "JSDocClassTag"; + SyntaxKind[SyntaxKind["JSDocPublicTag"] = 336] = "JSDocPublicTag"; + SyntaxKind[SyntaxKind["JSDocPrivateTag"] = 337] = "JSDocPrivateTag"; + SyntaxKind[SyntaxKind["JSDocProtectedTag"] = 338] = "JSDocProtectedTag"; + SyntaxKind[SyntaxKind["JSDocReadonlyTag"] = 339] = "JSDocReadonlyTag"; + SyntaxKind[SyntaxKind["JSDocOverrideTag"] = 340] = "JSDocOverrideTag"; + SyntaxKind[SyntaxKind["JSDocCallbackTag"] = 341] = "JSDocCallbackTag"; + SyntaxKind[SyntaxKind["JSDocEnumTag"] = 342] = "JSDocEnumTag"; + SyntaxKind[SyntaxKind["JSDocParameterTag"] = 343] = "JSDocParameterTag"; + SyntaxKind[SyntaxKind["JSDocReturnTag"] = 344] = "JSDocReturnTag"; + SyntaxKind[SyntaxKind["JSDocThisTag"] = 345] = "JSDocThisTag"; + SyntaxKind[SyntaxKind["JSDocTypeTag"] = 346] = "JSDocTypeTag"; + SyntaxKind[SyntaxKind["JSDocTemplateTag"] = 347] = "JSDocTemplateTag"; + SyntaxKind[SyntaxKind["JSDocTypedefTag"] = 348] = "JSDocTypedefTag"; + SyntaxKind[SyntaxKind["JSDocSeeTag"] = 349] = "JSDocSeeTag"; + SyntaxKind[SyntaxKind["JSDocPropertyTag"] = 350] = "JSDocPropertyTag"; + // Synthesized list + SyntaxKind[SyntaxKind["SyntaxList"] = 351] = "SyntaxList"; + // Transformation nodes + SyntaxKind[SyntaxKind["NotEmittedStatement"] = 352] = "NotEmittedStatement"; + SyntaxKind[SyntaxKind["PartiallyEmittedExpression"] = 353] = "PartiallyEmittedExpression"; + SyntaxKind[SyntaxKind["CommaListExpression"] = 354] = "CommaListExpression"; + SyntaxKind[SyntaxKind["MergeDeclarationMarker"] = 355] = "MergeDeclarationMarker"; + SyntaxKind[SyntaxKind["EndOfDeclarationMarker"] = 356] = "EndOfDeclarationMarker"; + SyntaxKind[SyntaxKind["SyntheticReferenceExpression"] = 357] = "SyntheticReferenceExpression"; + // Enum value count + SyntaxKind[SyntaxKind["Count"] = 358] = "Count"; + // Markers + SyntaxKind[SyntaxKind["FirstAssignment"] = 63] = "FirstAssignment"; + SyntaxKind[SyntaxKind["LastAssignment"] = 78] = "LastAssignment"; + SyntaxKind[SyntaxKind["FirstCompoundAssignment"] = 64] = "FirstCompoundAssignment"; + SyntaxKind[SyntaxKind["LastCompoundAssignment"] = 78] = "LastCompoundAssignment"; + SyntaxKind[SyntaxKind["FirstReservedWord"] = 81] = "FirstReservedWord"; + SyntaxKind[SyntaxKind["LastReservedWord"] = 116] = "LastReservedWord"; + SyntaxKind[SyntaxKind["FirstKeyword"] = 81] = "FirstKeyword"; + SyntaxKind[SyntaxKind["LastKeyword"] = 162] = "LastKeyword"; + SyntaxKind[SyntaxKind["FirstFutureReservedWord"] = 117] = "FirstFutureReservedWord"; + SyntaxKind[SyntaxKind["LastFutureReservedWord"] = 125] = "LastFutureReservedWord"; + SyntaxKind[SyntaxKind["FirstTypeNode"] = 179] = "FirstTypeNode"; + SyntaxKind[SyntaxKind["LastTypeNode"] = 202] = "LastTypeNode"; + SyntaxKind[SyntaxKind["FirstPunctuation"] = 18] = "FirstPunctuation"; + SyntaxKind[SyntaxKind["LastPunctuation"] = 78] = "LastPunctuation"; + SyntaxKind[SyntaxKind["FirstToken"] = 0] = "FirstToken"; + SyntaxKind[SyntaxKind["LastToken"] = 162] = "LastToken"; + SyntaxKind[SyntaxKind["FirstTriviaToken"] = 2] = "FirstTriviaToken"; + SyntaxKind[SyntaxKind["LastTriviaToken"] = 7] = "LastTriviaToken"; + SyntaxKind[SyntaxKind["FirstLiteralToken"] = 8] = "FirstLiteralToken"; + SyntaxKind[SyntaxKind["LastLiteralToken"] = 14] = "LastLiteralToken"; + SyntaxKind[SyntaxKind["FirstTemplateToken"] = 14] = "FirstTemplateToken"; + SyntaxKind[SyntaxKind["LastTemplateToken"] = 17] = "LastTemplateToken"; + SyntaxKind[SyntaxKind["FirstBinaryOperator"] = 29] = "FirstBinaryOperator"; + SyntaxKind[SyntaxKind["LastBinaryOperator"] = 78] = "LastBinaryOperator"; + SyntaxKind[SyntaxKind["FirstStatement"] = 240] = "FirstStatement"; + SyntaxKind[SyntaxKind["LastStatement"] = 256] = "LastStatement"; + SyntaxKind[SyntaxKind["FirstNode"] = 163] = "FirstNode"; + SyntaxKind[SyntaxKind["FirstJSDocNode"] = 312] = "FirstJSDocNode"; + SyntaxKind[SyntaxKind["LastJSDocNode"] = 350] = "LastJSDocNode"; + SyntaxKind[SyntaxKind["FirstJSDocTagNode"] = 330] = "FirstJSDocTagNode"; + SyntaxKind[SyntaxKind["LastJSDocTagNode"] = 350] = "LastJSDocTagNode"; + /* @internal */ SyntaxKind[SyntaxKind["FirstContextualKeyword"] = 126] = "FirstContextualKeyword"; + /* @internal */ SyntaxKind[SyntaxKind["LastContextualKeyword"] = 162] = "LastContextualKeyword"; + })(SyntaxKind = ts.SyntaxKind || (ts.SyntaxKind = {})); + var NodeFlags; + (function (NodeFlags) { + NodeFlags[NodeFlags["None"] = 0] = "None"; + NodeFlags[NodeFlags["Let"] = 1] = "Let"; + NodeFlags[NodeFlags["Const"] = 2] = "Const"; + NodeFlags[NodeFlags["NestedNamespace"] = 4] = "NestedNamespace"; + NodeFlags[NodeFlags["Synthesized"] = 8] = "Synthesized"; + NodeFlags[NodeFlags["Namespace"] = 16] = "Namespace"; + NodeFlags[NodeFlags["OptionalChain"] = 32] = "OptionalChain"; + NodeFlags[NodeFlags["ExportContext"] = 64] = "ExportContext"; + NodeFlags[NodeFlags["ContainsThis"] = 128] = "ContainsThis"; + NodeFlags[NodeFlags["HasImplicitReturn"] = 256] = "HasImplicitReturn"; + NodeFlags[NodeFlags["HasExplicitReturn"] = 512] = "HasExplicitReturn"; + NodeFlags[NodeFlags["GlobalAugmentation"] = 1024] = "GlobalAugmentation"; + NodeFlags[NodeFlags["HasAsyncFunctions"] = 2048] = "HasAsyncFunctions"; + NodeFlags[NodeFlags["DisallowInContext"] = 4096] = "DisallowInContext"; + NodeFlags[NodeFlags["YieldContext"] = 8192] = "YieldContext"; + NodeFlags[NodeFlags["DecoratorContext"] = 16384] = "DecoratorContext"; + NodeFlags[NodeFlags["AwaitContext"] = 32768] = "AwaitContext"; + NodeFlags[NodeFlags["DisallowConditionalTypesContext"] = 65536] = "DisallowConditionalTypesContext"; + NodeFlags[NodeFlags["ThisNodeHasError"] = 131072] = "ThisNodeHasError"; + NodeFlags[NodeFlags["JavaScriptFile"] = 262144] = "JavaScriptFile"; + NodeFlags[NodeFlags["ThisNodeOrAnySubNodesHasError"] = 524288] = "ThisNodeOrAnySubNodesHasError"; + NodeFlags[NodeFlags["HasAggregatedChildData"] = 1048576] = "HasAggregatedChildData"; + // These flags will be set when the parser encounters a dynamic import expression or 'import.meta' to avoid + // walking the tree if the flags are not set. However, these flags are just a approximation + // (hence why it's named "PossiblyContainsDynamicImport") because once set, the flags never get cleared. + // During editing, if a dynamic import is removed, incremental parsing will *NOT* clear this flag. + // This means that the tree will always be traversed during module resolution, or when looking for external module indicators. + // However, the removal operation should not occur often and in the case of the + // removal, it is likely that users will add the import anyway. + // The advantage of this approach is its simplicity. For the case of batch compilation, + // we guarantee that users won't have to pay the price of walking the tree if a dynamic import isn't used. + /* @internal */ NodeFlags[NodeFlags["PossiblyContainsDynamicImport"] = 2097152] = "PossiblyContainsDynamicImport"; + /* @internal */ NodeFlags[NodeFlags["PossiblyContainsImportMeta"] = 4194304] = "PossiblyContainsImportMeta"; + NodeFlags[NodeFlags["JSDoc"] = 8388608] = "JSDoc"; + /* @internal */ NodeFlags[NodeFlags["Ambient"] = 16777216] = "Ambient"; + /* @internal */ NodeFlags[NodeFlags["InWithStatement"] = 33554432] = "InWithStatement"; + NodeFlags[NodeFlags["JsonFile"] = 67108864] = "JsonFile"; + /* @internal */ NodeFlags[NodeFlags["TypeCached"] = 134217728] = "TypeCached"; + /* @internal */ NodeFlags[NodeFlags["Deprecated"] = 268435456] = "Deprecated"; + NodeFlags[NodeFlags["BlockScoped"] = 3] = "BlockScoped"; + NodeFlags[NodeFlags["ReachabilityCheckFlags"] = 768] = "ReachabilityCheckFlags"; + NodeFlags[NodeFlags["ReachabilityAndEmitFlags"] = 2816] = "ReachabilityAndEmitFlags"; + // Parsing context flags + NodeFlags[NodeFlags["ContextFlags"] = 50720768] = "ContextFlags"; + // Exclude these flags when parsing a Type + NodeFlags[NodeFlags["TypeExcludesFlags"] = 40960] = "TypeExcludesFlags"; + // Represents all flags that are potentially set once and + // never cleared on SourceFiles which get re-used in between incremental parses. + // See the comment above on `PossiblyContainsDynamicImport` and `PossiblyContainsImportMeta`. + /* @internal */ NodeFlags[NodeFlags["PermanentlySetIncrementalFlags"] = 6291456] = "PermanentlySetIncrementalFlags"; + })(NodeFlags = ts.NodeFlags || (ts.NodeFlags = {})); + var ModifierFlags; + (function (ModifierFlags) { + ModifierFlags[ModifierFlags["None"] = 0] = "None"; + ModifierFlags[ModifierFlags["Export"] = 1] = "Export"; + ModifierFlags[ModifierFlags["Ambient"] = 2] = "Ambient"; + ModifierFlags[ModifierFlags["Public"] = 4] = "Public"; + ModifierFlags[ModifierFlags["Private"] = 8] = "Private"; + ModifierFlags[ModifierFlags["Protected"] = 16] = "Protected"; + ModifierFlags[ModifierFlags["Static"] = 32] = "Static"; + ModifierFlags[ModifierFlags["Readonly"] = 64] = "Readonly"; + ModifierFlags[ModifierFlags["Accessor"] = 128] = "Accessor"; + ModifierFlags[ModifierFlags["Abstract"] = 256] = "Abstract"; + ModifierFlags[ModifierFlags["Async"] = 512] = "Async"; + ModifierFlags[ModifierFlags["Default"] = 1024] = "Default"; + ModifierFlags[ModifierFlags["Const"] = 2048] = "Const"; + ModifierFlags[ModifierFlags["HasComputedJSDocModifiers"] = 4096] = "HasComputedJSDocModifiers"; + ModifierFlags[ModifierFlags["Deprecated"] = 8192] = "Deprecated"; + ModifierFlags[ModifierFlags["Override"] = 16384] = "Override"; + ModifierFlags[ModifierFlags["In"] = 32768] = "In"; + ModifierFlags[ModifierFlags["Out"] = 65536] = "Out"; + ModifierFlags[ModifierFlags["Decorator"] = 131072] = "Decorator"; + ModifierFlags[ModifierFlags["HasComputedFlags"] = 536870912] = "HasComputedFlags"; + ModifierFlags[ModifierFlags["AccessibilityModifier"] = 28] = "AccessibilityModifier"; + // Accessibility modifiers and 'readonly' can be attached to a parameter in a constructor to make it a property. + ModifierFlags[ModifierFlags["ParameterPropertyModifier"] = 16476] = "ParameterPropertyModifier"; + ModifierFlags[ModifierFlags["NonPublicAccessibilityModifier"] = 24] = "NonPublicAccessibilityModifier"; + ModifierFlags[ModifierFlags["TypeScriptModifier"] = 117086] = "TypeScriptModifier"; + ModifierFlags[ModifierFlags["ExportDefault"] = 1025] = "ExportDefault"; + ModifierFlags[ModifierFlags["All"] = 258047] = "All"; + ModifierFlags[ModifierFlags["Modifier"] = 126975] = "Modifier"; + })(ModifierFlags = ts.ModifierFlags || (ts.ModifierFlags = {})); + var JsxFlags; + (function (JsxFlags) { + JsxFlags[JsxFlags["None"] = 0] = "None"; + /** An element from a named property of the JSX.IntrinsicElements interface */ + JsxFlags[JsxFlags["IntrinsicNamedElement"] = 1] = "IntrinsicNamedElement"; + /** An element inferred from the string index signature of the JSX.IntrinsicElements interface */ + JsxFlags[JsxFlags["IntrinsicIndexedElement"] = 2] = "IntrinsicIndexedElement"; + JsxFlags[JsxFlags["IntrinsicElement"] = 3] = "IntrinsicElement"; + })(JsxFlags = ts.JsxFlags || (ts.JsxFlags = {})); + /* @internal */ + var RelationComparisonResult; + (function (RelationComparisonResult) { + RelationComparisonResult[RelationComparisonResult["Succeeded"] = 1] = "Succeeded"; + RelationComparisonResult[RelationComparisonResult["Failed"] = 2] = "Failed"; + RelationComparisonResult[RelationComparisonResult["Reported"] = 4] = "Reported"; + RelationComparisonResult[RelationComparisonResult["ReportsUnmeasurable"] = 8] = "ReportsUnmeasurable"; + RelationComparisonResult[RelationComparisonResult["ReportsUnreliable"] = 16] = "ReportsUnreliable"; + RelationComparisonResult[RelationComparisonResult["ReportsMask"] = 24] = "ReportsMask"; + })(RelationComparisonResult = ts.RelationComparisonResult || (ts.RelationComparisonResult = {})); + var GeneratedIdentifierFlags; + (function (GeneratedIdentifierFlags) { + // Kinds + GeneratedIdentifierFlags[GeneratedIdentifierFlags["None"] = 0] = "None"; + /*@internal*/ GeneratedIdentifierFlags[GeneratedIdentifierFlags["Auto"] = 1] = "Auto"; + /*@internal*/ GeneratedIdentifierFlags[GeneratedIdentifierFlags["Loop"] = 2] = "Loop"; + /*@internal*/ GeneratedIdentifierFlags[GeneratedIdentifierFlags["Unique"] = 3] = "Unique"; + /*@internal*/ GeneratedIdentifierFlags[GeneratedIdentifierFlags["Node"] = 4] = "Node"; + /*@internal*/ GeneratedIdentifierFlags[GeneratedIdentifierFlags["KindMask"] = 7] = "KindMask"; + // Flags + GeneratedIdentifierFlags[GeneratedIdentifierFlags["ReservedInNestedScopes"] = 8] = "ReservedInNestedScopes"; + GeneratedIdentifierFlags[GeneratedIdentifierFlags["Optimistic"] = 16] = "Optimistic"; + GeneratedIdentifierFlags[GeneratedIdentifierFlags["FileLevel"] = 32] = "FileLevel"; + GeneratedIdentifierFlags[GeneratedIdentifierFlags["AllowNameSubstitution"] = 64] = "AllowNameSubstitution"; + })(GeneratedIdentifierFlags = ts.GeneratedIdentifierFlags || (ts.GeneratedIdentifierFlags = {})); + var TokenFlags; + (function (TokenFlags) { + TokenFlags[TokenFlags["None"] = 0] = "None"; + /* @internal */ + TokenFlags[TokenFlags["PrecedingLineBreak"] = 1] = "PrecedingLineBreak"; + /* @internal */ + TokenFlags[TokenFlags["PrecedingJSDocComment"] = 2] = "PrecedingJSDocComment"; + /* @internal */ + TokenFlags[TokenFlags["Unterminated"] = 4] = "Unterminated"; + /* @internal */ + TokenFlags[TokenFlags["ExtendedUnicodeEscape"] = 8] = "ExtendedUnicodeEscape"; + TokenFlags[TokenFlags["Scientific"] = 16] = "Scientific"; + TokenFlags[TokenFlags["Octal"] = 32] = "Octal"; + TokenFlags[TokenFlags["HexSpecifier"] = 64] = "HexSpecifier"; + TokenFlags[TokenFlags["BinarySpecifier"] = 128] = "BinarySpecifier"; + TokenFlags[TokenFlags["OctalSpecifier"] = 256] = "OctalSpecifier"; + /* @internal */ + TokenFlags[TokenFlags["ContainsSeparator"] = 512] = "ContainsSeparator"; + /* @internal */ + TokenFlags[TokenFlags["UnicodeEscape"] = 1024] = "UnicodeEscape"; + /* @internal */ + TokenFlags[TokenFlags["ContainsInvalidEscape"] = 2048] = "ContainsInvalidEscape"; + /* @internal */ + TokenFlags[TokenFlags["BinaryOrOctalSpecifier"] = 384] = "BinaryOrOctalSpecifier"; + /* @internal */ + TokenFlags[TokenFlags["NumericLiteralFlags"] = 1008] = "NumericLiteralFlags"; + /* @internal */ + TokenFlags[TokenFlags["TemplateLiteralLikeFlags"] = 2048] = "TemplateLiteralLikeFlags"; + })(TokenFlags = ts.TokenFlags || (ts.TokenFlags = {})); + // NOTE: Ensure this is up-to-date with src/debug/debug.ts + var FlowFlags; + (function (FlowFlags) { + FlowFlags[FlowFlags["Unreachable"] = 1] = "Unreachable"; + FlowFlags[FlowFlags["Start"] = 2] = "Start"; + FlowFlags[FlowFlags["BranchLabel"] = 4] = "BranchLabel"; + FlowFlags[FlowFlags["LoopLabel"] = 8] = "LoopLabel"; + FlowFlags[FlowFlags["Assignment"] = 16] = "Assignment"; + FlowFlags[FlowFlags["TrueCondition"] = 32] = "TrueCondition"; + FlowFlags[FlowFlags["FalseCondition"] = 64] = "FalseCondition"; + FlowFlags[FlowFlags["SwitchClause"] = 128] = "SwitchClause"; + FlowFlags[FlowFlags["ArrayMutation"] = 256] = "ArrayMutation"; + FlowFlags[FlowFlags["Call"] = 512] = "Call"; + FlowFlags[FlowFlags["ReduceLabel"] = 1024] = "ReduceLabel"; + FlowFlags[FlowFlags["Referenced"] = 2048] = "Referenced"; + FlowFlags[FlowFlags["Shared"] = 4096] = "Shared"; + FlowFlags[FlowFlags["Label"] = 12] = "Label"; + FlowFlags[FlowFlags["Condition"] = 96] = "Condition"; + })(FlowFlags = ts.FlowFlags || (ts.FlowFlags = {})); + /* @internal */ + var CommentDirectiveType; + (function (CommentDirectiveType) { + CommentDirectiveType[CommentDirectiveType["ExpectError"] = 0] = "ExpectError"; + CommentDirectiveType[CommentDirectiveType["Ignore"] = 1] = "Ignore"; + })(CommentDirectiveType = ts.CommentDirectiveType || (ts.CommentDirectiveType = {})); + var OperationCanceledException = /** @class */ (function () { + function OperationCanceledException() { + } + return OperationCanceledException; + }()); + ts.OperationCanceledException = OperationCanceledException; + /*@internal*/ + var FileIncludeKind; + (function (FileIncludeKind) { + FileIncludeKind[FileIncludeKind["RootFile"] = 0] = "RootFile"; + FileIncludeKind[FileIncludeKind["SourceFromProjectReference"] = 1] = "SourceFromProjectReference"; + FileIncludeKind[FileIncludeKind["OutputFromProjectReference"] = 2] = "OutputFromProjectReference"; + FileIncludeKind[FileIncludeKind["Import"] = 3] = "Import"; + FileIncludeKind[FileIncludeKind["ReferenceFile"] = 4] = "ReferenceFile"; + FileIncludeKind[FileIncludeKind["TypeReferenceDirective"] = 5] = "TypeReferenceDirective"; + FileIncludeKind[FileIncludeKind["LibFile"] = 6] = "LibFile"; + FileIncludeKind[FileIncludeKind["LibReferenceDirective"] = 7] = "LibReferenceDirective"; + FileIncludeKind[FileIncludeKind["AutomaticTypeDirectiveFile"] = 8] = "AutomaticTypeDirectiveFile"; + })(FileIncludeKind = ts.FileIncludeKind || (ts.FileIncludeKind = {})); + /*@internal*/ + var FilePreprocessingDiagnosticsKind; + (function (FilePreprocessingDiagnosticsKind) { + FilePreprocessingDiagnosticsKind[FilePreprocessingDiagnosticsKind["FilePreprocessingReferencedDiagnostic"] = 0] = "FilePreprocessingReferencedDiagnostic"; + FilePreprocessingDiagnosticsKind[FilePreprocessingDiagnosticsKind["FilePreprocessingFileExplainingDiagnostic"] = 1] = "FilePreprocessingFileExplainingDiagnostic"; + })(FilePreprocessingDiagnosticsKind = ts.FilePreprocessingDiagnosticsKind || (ts.FilePreprocessingDiagnosticsKind = {})); + /* @internal */ + var StructureIsReused; + (function (StructureIsReused) { + StructureIsReused[StructureIsReused["Not"] = 0] = "Not"; + StructureIsReused[StructureIsReused["SafeModules"] = 1] = "SafeModules"; + StructureIsReused[StructureIsReused["Completely"] = 2] = "Completely"; + })(StructureIsReused = ts.StructureIsReused || (ts.StructureIsReused = {})); + /** Return code used by getEmitOutput function to indicate status of the function */ + var ExitStatus; + (function (ExitStatus) { + // Compiler ran successfully. Either this was a simple do-nothing compilation (for example, + // when -version or -help was provided, or this was a normal compilation, no diagnostics + // were produced, and all outputs were generated successfully. + ExitStatus[ExitStatus["Success"] = 0] = "Success"; + // Diagnostics were produced and because of them no code was generated. + ExitStatus[ExitStatus["DiagnosticsPresent_OutputsSkipped"] = 1] = "DiagnosticsPresent_OutputsSkipped"; + // Diagnostics were produced and outputs were generated in spite of them. + ExitStatus[ExitStatus["DiagnosticsPresent_OutputsGenerated"] = 2] = "DiagnosticsPresent_OutputsGenerated"; + // When build skipped because passed in project is invalid + ExitStatus[ExitStatus["InvalidProject_OutputsSkipped"] = 3] = "InvalidProject_OutputsSkipped"; + // When build is skipped because project references form cycle + ExitStatus[ExitStatus["ProjectReferenceCycle_OutputsSkipped"] = 4] = "ProjectReferenceCycle_OutputsSkipped"; + /** @deprecated Use ProjectReferenceCycle_OutputsSkipped instead. */ + ExitStatus[ExitStatus["ProjectReferenceCycle_OutputsSkupped"] = 4] = "ProjectReferenceCycle_OutputsSkupped"; + })(ExitStatus = ts.ExitStatus || (ts.ExitStatus = {})); + /* @internal */ + var MemberOverrideStatus; + (function (MemberOverrideStatus) { + MemberOverrideStatus[MemberOverrideStatus["Ok"] = 0] = "Ok"; + MemberOverrideStatus[MemberOverrideStatus["NeedsOverride"] = 1] = "NeedsOverride"; + MemberOverrideStatus[MemberOverrideStatus["HasInvalidOverride"] = 2] = "HasInvalidOverride"; + })(MemberOverrideStatus = ts.MemberOverrideStatus || (ts.MemberOverrideStatus = {})); + /* @internal */ + var UnionReduction; + (function (UnionReduction) { + UnionReduction[UnionReduction["None"] = 0] = "None"; + UnionReduction[UnionReduction["Literal"] = 1] = "Literal"; + UnionReduction[UnionReduction["Subtype"] = 2] = "Subtype"; + })(UnionReduction = ts.UnionReduction || (ts.UnionReduction = {})); + /* @internal */ + var ContextFlags; + (function (ContextFlags) { + ContextFlags[ContextFlags["None"] = 0] = "None"; + ContextFlags[ContextFlags["Signature"] = 1] = "Signature"; + ContextFlags[ContextFlags["NoConstraints"] = 2] = "NoConstraints"; + ContextFlags[ContextFlags["Completions"] = 4] = "Completions"; + ContextFlags[ContextFlags["SkipBindingPatterns"] = 8] = "SkipBindingPatterns"; + })(ContextFlags = ts.ContextFlags || (ts.ContextFlags = {})); + // NOTE: If modifying this enum, must modify `TypeFormatFlags` too! + var NodeBuilderFlags; + (function (NodeBuilderFlags) { + NodeBuilderFlags[NodeBuilderFlags["None"] = 0] = "None"; + // Options + NodeBuilderFlags[NodeBuilderFlags["NoTruncation"] = 1] = "NoTruncation"; + NodeBuilderFlags[NodeBuilderFlags["WriteArrayAsGenericType"] = 2] = "WriteArrayAsGenericType"; + NodeBuilderFlags[NodeBuilderFlags["GenerateNamesForShadowedTypeParams"] = 4] = "GenerateNamesForShadowedTypeParams"; + NodeBuilderFlags[NodeBuilderFlags["UseStructuralFallback"] = 8] = "UseStructuralFallback"; + NodeBuilderFlags[NodeBuilderFlags["ForbidIndexedAccessSymbolReferences"] = 16] = "ForbidIndexedAccessSymbolReferences"; + NodeBuilderFlags[NodeBuilderFlags["WriteTypeArgumentsOfSignature"] = 32] = "WriteTypeArgumentsOfSignature"; + NodeBuilderFlags[NodeBuilderFlags["UseFullyQualifiedType"] = 64] = "UseFullyQualifiedType"; + NodeBuilderFlags[NodeBuilderFlags["UseOnlyExternalAliasing"] = 128] = "UseOnlyExternalAliasing"; + NodeBuilderFlags[NodeBuilderFlags["SuppressAnyReturnType"] = 256] = "SuppressAnyReturnType"; + NodeBuilderFlags[NodeBuilderFlags["WriteTypeParametersInQualifiedName"] = 512] = "WriteTypeParametersInQualifiedName"; + NodeBuilderFlags[NodeBuilderFlags["MultilineObjectLiterals"] = 1024] = "MultilineObjectLiterals"; + NodeBuilderFlags[NodeBuilderFlags["WriteClassExpressionAsTypeLiteral"] = 2048] = "WriteClassExpressionAsTypeLiteral"; + NodeBuilderFlags[NodeBuilderFlags["UseTypeOfFunction"] = 4096] = "UseTypeOfFunction"; + NodeBuilderFlags[NodeBuilderFlags["OmitParameterModifiers"] = 8192] = "OmitParameterModifiers"; + NodeBuilderFlags[NodeBuilderFlags["UseAliasDefinedOutsideCurrentScope"] = 16384] = "UseAliasDefinedOutsideCurrentScope"; + NodeBuilderFlags[NodeBuilderFlags["UseSingleQuotesForStringLiteralType"] = 268435456] = "UseSingleQuotesForStringLiteralType"; + NodeBuilderFlags[NodeBuilderFlags["NoTypeReduction"] = 536870912] = "NoTypeReduction"; + NodeBuilderFlags[NodeBuilderFlags["OmitThisParameter"] = 33554432] = "OmitThisParameter"; + // Error handling + NodeBuilderFlags[NodeBuilderFlags["AllowThisInObjectLiteral"] = 32768] = "AllowThisInObjectLiteral"; + NodeBuilderFlags[NodeBuilderFlags["AllowQualifiedNameInPlaceOfIdentifier"] = 65536] = "AllowQualifiedNameInPlaceOfIdentifier"; + /** @deprecated AllowQualifedNameInPlaceOfIdentifier. Use AllowQualifiedNameInPlaceOfIdentifier instead. */ + NodeBuilderFlags[NodeBuilderFlags["AllowQualifedNameInPlaceOfIdentifier"] = 65536] = "AllowQualifedNameInPlaceOfIdentifier"; + NodeBuilderFlags[NodeBuilderFlags["AllowAnonymousIdentifier"] = 131072] = "AllowAnonymousIdentifier"; + NodeBuilderFlags[NodeBuilderFlags["AllowEmptyUnionOrIntersection"] = 262144] = "AllowEmptyUnionOrIntersection"; + NodeBuilderFlags[NodeBuilderFlags["AllowEmptyTuple"] = 524288] = "AllowEmptyTuple"; + NodeBuilderFlags[NodeBuilderFlags["AllowUniqueESSymbolType"] = 1048576] = "AllowUniqueESSymbolType"; + NodeBuilderFlags[NodeBuilderFlags["AllowEmptyIndexInfoType"] = 2097152] = "AllowEmptyIndexInfoType"; + /* @internal */ NodeBuilderFlags[NodeBuilderFlags["WriteComputedProps"] = 1073741824] = "WriteComputedProps"; + // Errors (cont.) + NodeBuilderFlags[NodeBuilderFlags["AllowNodeModulesRelativePaths"] = 67108864] = "AllowNodeModulesRelativePaths"; + /* @internal */ NodeBuilderFlags[NodeBuilderFlags["DoNotIncludeSymbolChain"] = 134217728] = "DoNotIncludeSymbolChain"; + NodeBuilderFlags[NodeBuilderFlags["IgnoreErrors"] = 70221824] = "IgnoreErrors"; + // State + NodeBuilderFlags[NodeBuilderFlags["InObjectTypeLiteral"] = 4194304] = "InObjectTypeLiteral"; + NodeBuilderFlags[NodeBuilderFlags["InTypeAlias"] = 8388608] = "InTypeAlias"; + NodeBuilderFlags[NodeBuilderFlags["InInitialEntityName"] = 16777216] = "InInitialEntityName"; + })(NodeBuilderFlags = ts.NodeBuilderFlags || (ts.NodeBuilderFlags = {})); + // Ensure the shared flags between this and `NodeBuilderFlags` stay in alignment + var TypeFormatFlags; + (function (TypeFormatFlags) { + TypeFormatFlags[TypeFormatFlags["None"] = 0] = "None"; + TypeFormatFlags[TypeFormatFlags["NoTruncation"] = 1] = "NoTruncation"; + TypeFormatFlags[TypeFormatFlags["WriteArrayAsGenericType"] = 2] = "WriteArrayAsGenericType"; + // hole because there's a hole in node builder flags + TypeFormatFlags[TypeFormatFlags["UseStructuralFallback"] = 8] = "UseStructuralFallback"; + // hole because there's a hole in node builder flags + TypeFormatFlags[TypeFormatFlags["WriteTypeArgumentsOfSignature"] = 32] = "WriteTypeArgumentsOfSignature"; + TypeFormatFlags[TypeFormatFlags["UseFullyQualifiedType"] = 64] = "UseFullyQualifiedType"; + // hole because `UseOnlyExternalAliasing` is here in node builder flags, but functions which take old flags use `SymbolFormatFlags` instead + TypeFormatFlags[TypeFormatFlags["SuppressAnyReturnType"] = 256] = "SuppressAnyReturnType"; + // hole because `WriteTypeParametersInQualifiedName` is here in node builder flags, but functions which take old flags use `SymbolFormatFlags` for this instead + TypeFormatFlags[TypeFormatFlags["MultilineObjectLiterals"] = 1024] = "MultilineObjectLiterals"; + TypeFormatFlags[TypeFormatFlags["WriteClassExpressionAsTypeLiteral"] = 2048] = "WriteClassExpressionAsTypeLiteral"; + TypeFormatFlags[TypeFormatFlags["UseTypeOfFunction"] = 4096] = "UseTypeOfFunction"; + TypeFormatFlags[TypeFormatFlags["OmitParameterModifiers"] = 8192] = "OmitParameterModifiers"; + TypeFormatFlags[TypeFormatFlags["UseAliasDefinedOutsideCurrentScope"] = 16384] = "UseAliasDefinedOutsideCurrentScope"; + TypeFormatFlags[TypeFormatFlags["UseSingleQuotesForStringLiteralType"] = 268435456] = "UseSingleQuotesForStringLiteralType"; + TypeFormatFlags[TypeFormatFlags["NoTypeReduction"] = 536870912] = "NoTypeReduction"; + TypeFormatFlags[TypeFormatFlags["OmitThisParameter"] = 33554432] = "OmitThisParameter"; + // Error Handling + TypeFormatFlags[TypeFormatFlags["AllowUniqueESSymbolType"] = 1048576] = "AllowUniqueESSymbolType"; + // TypeFormatFlags exclusive + TypeFormatFlags[TypeFormatFlags["AddUndefined"] = 131072] = "AddUndefined"; + TypeFormatFlags[TypeFormatFlags["WriteArrowStyleSignature"] = 262144] = "WriteArrowStyleSignature"; + // State + TypeFormatFlags[TypeFormatFlags["InArrayType"] = 524288] = "InArrayType"; + TypeFormatFlags[TypeFormatFlags["InElementType"] = 2097152] = "InElementType"; + TypeFormatFlags[TypeFormatFlags["InFirstTypeArgument"] = 4194304] = "InFirstTypeArgument"; + TypeFormatFlags[TypeFormatFlags["InTypeAlias"] = 8388608] = "InTypeAlias"; + /** @deprecated */ TypeFormatFlags[TypeFormatFlags["WriteOwnNameForAnyLike"] = 0] = "WriteOwnNameForAnyLike"; + TypeFormatFlags[TypeFormatFlags["NodeBuilderFlagsMask"] = 848330091] = "NodeBuilderFlagsMask"; + })(TypeFormatFlags = ts.TypeFormatFlags || (ts.TypeFormatFlags = {})); + var SymbolFormatFlags; + (function (SymbolFormatFlags) { + SymbolFormatFlags[SymbolFormatFlags["None"] = 0] = "None"; + // Write symbols's type argument if it is instantiated symbol + // eg. class C { p: T } <-- Show p as C.p here + // var a: C; + // var p = a.p; <--- Here p is property of C so show it as C.p instead of just C.p + SymbolFormatFlags[SymbolFormatFlags["WriteTypeParametersOrArguments"] = 1] = "WriteTypeParametersOrArguments"; + // Use only external alias information to get the symbol name in the given context + // eg. module m { export class c { } } import x = m.c; + // When this flag is specified m.c will be used to refer to the class instead of alias symbol x + SymbolFormatFlags[SymbolFormatFlags["UseOnlyExternalAliasing"] = 2] = "UseOnlyExternalAliasing"; + // Build symbol name using any nodes needed, instead of just components of an entity name + SymbolFormatFlags[SymbolFormatFlags["AllowAnyNodeKind"] = 4] = "AllowAnyNodeKind"; + // Prefer aliases which are not directly visible + SymbolFormatFlags[SymbolFormatFlags["UseAliasDefinedOutsideCurrentScope"] = 8] = "UseAliasDefinedOutsideCurrentScope"; + // { [E.A]: 1 } + /* @internal */ SymbolFormatFlags[SymbolFormatFlags["WriteComputedProps"] = 16] = "WriteComputedProps"; + // Skip building an accessible symbol chain + /* @internal */ SymbolFormatFlags[SymbolFormatFlags["DoNotIncludeSymbolChain"] = 32] = "DoNotIncludeSymbolChain"; + })(SymbolFormatFlags = ts.SymbolFormatFlags || (ts.SymbolFormatFlags = {})); + /* @internal */ + var SymbolAccessibility; + (function (SymbolAccessibility) { + SymbolAccessibility[SymbolAccessibility["Accessible"] = 0] = "Accessible"; + SymbolAccessibility[SymbolAccessibility["NotAccessible"] = 1] = "NotAccessible"; + SymbolAccessibility[SymbolAccessibility["CannotBeNamed"] = 2] = "CannotBeNamed"; + })(SymbolAccessibility = ts.SymbolAccessibility || (ts.SymbolAccessibility = {})); + /* @internal */ + var SyntheticSymbolKind; + (function (SyntheticSymbolKind) { + SyntheticSymbolKind[SyntheticSymbolKind["UnionOrIntersection"] = 0] = "UnionOrIntersection"; + SyntheticSymbolKind[SyntheticSymbolKind["Spread"] = 1] = "Spread"; + })(SyntheticSymbolKind = ts.SyntheticSymbolKind || (ts.SyntheticSymbolKind = {})); + var TypePredicateKind; + (function (TypePredicateKind) { + TypePredicateKind[TypePredicateKind["This"] = 0] = "This"; + TypePredicateKind[TypePredicateKind["Identifier"] = 1] = "Identifier"; + TypePredicateKind[TypePredicateKind["AssertsThis"] = 2] = "AssertsThis"; + TypePredicateKind[TypePredicateKind["AssertsIdentifier"] = 3] = "AssertsIdentifier"; + })(TypePredicateKind = ts.TypePredicateKind || (ts.TypePredicateKind = {})); + /** Indicates how to serialize the name for a TypeReferenceNode when emitting decorator metadata */ + /* @internal */ + var TypeReferenceSerializationKind; + (function (TypeReferenceSerializationKind) { + // The TypeReferenceNode could not be resolved. + // The type name should be emitted using a safe fallback. + TypeReferenceSerializationKind[TypeReferenceSerializationKind["Unknown"] = 0] = "Unknown"; + // The TypeReferenceNode resolves to a type with a constructor + // function that can be reached at runtime (e.g. a `class` + // declaration or a `var` declaration for the static side + // of a type, such as the global `Promise` type in lib.d.ts). + TypeReferenceSerializationKind[TypeReferenceSerializationKind["TypeWithConstructSignatureAndValue"] = 1] = "TypeWithConstructSignatureAndValue"; + // The TypeReferenceNode resolves to a Void-like, Nullable, or Never type. + TypeReferenceSerializationKind[TypeReferenceSerializationKind["VoidNullableOrNeverType"] = 2] = "VoidNullableOrNeverType"; + // The TypeReferenceNode resolves to a Number-like type. + TypeReferenceSerializationKind[TypeReferenceSerializationKind["NumberLikeType"] = 3] = "NumberLikeType"; + // The TypeReferenceNode resolves to a BigInt-like type. + TypeReferenceSerializationKind[TypeReferenceSerializationKind["BigIntLikeType"] = 4] = "BigIntLikeType"; + // The TypeReferenceNode resolves to a String-like type. + TypeReferenceSerializationKind[TypeReferenceSerializationKind["StringLikeType"] = 5] = "StringLikeType"; + // The TypeReferenceNode resolves to a Boolean-like type. + TypeReferenceSerializationKind[TypeReferenceSerializationKind["BooleanType"] = 6] = "BooleanType"; + // The TypeReferenceNode resolves to an Array-like type. + TypeReferenceSerializationKind[TypeReferenceSerializationKind["ArrayLikeType"] = 7] = "ArrayLikeType"; + // The TypeReferenceNode resolves to the ESSymbol type. + TypeReferenceSerializationKind[TypeReferenceSerializationKind["ESSymbolType"] = 8] = "ESSymbolType"; + // The TypeReferenceNode resolved to the global Promise constructor symbol. + TypeReferenceSerializationKind[TypeReferenceSerializationKind["Promise"] = 9] = "Promise"; + // The TypeReferenceNode resolves to a Function type or a type with call signatures. + TypeReferenceSerializationKind[TypeReferenceSerializationKind["TypeWithCallSignature"] = 10] = "TypeWithCallSignature"; + // The TypeReferenceNode resolves to any other type. + TypeReferenceSerializationKind[TypeReferenceSerializationKind["ObjectType"] = 11] = "ObjectType"; + })(TypeReferenceSerializationKind = ts.TypeReferenceSerializationKind || (ts.TypeReferenceSerializationKind = {})); + var SymbolFlags; + (function (SymbolFlags) { + SymbolFlags[SymbolFlags["None"] = 0] = "None"; + SymbolFlags[SymbolFlags["FunctionScopedVariable"] = 1] = "FunctionScopedVariable"; + SymbolFlags[SymbolFlags["BlockScopedVariable"] = 2] = "BlockScopedVariable"; + SymbolFlags[SymbolFlags["Property"] = 4] = "Property"; + SymbolFlags[SymbolFlags["EnumMember"] = 8] = "EnumMember"; + SymbolFlags[SymbolFlags["Function"] = 16] = "Function"; + SymbolFlags[SymbolFlags["Class"] = 32] = "Class"; + SymbolFlags[SymbolFlags["Interface"] = 64] = "Interface"; + SymbolFlags[SymbolFlags["ConstEnum"] = 128] = "ConstEnum"; + SymbolFlags[SymbolFlags["RegularEnum"] = 256] = "RegularEnum"; + SymbolFlags[SymbolFlags["ValueModule"] = 512] = "ValueModule"; + SymbolFlags[SymbolFlags["NamespaceModule"] = 1024] = "NamespaceModule"; + SymbolFlags[SymbolFlags["TypeLiteral"] = 2048] = "TypeLiteral"; + SymbolFlags[SymbolFlags["ObjectLiteral"] = 4096] = "ObjectLiteral"; + SymbolFlags[SymbolFlags["Method"] = 8192] = "Method"; + SymbolFlags[SymbolFlags["Constructor"] = 16384] = "Constructor"; + SymbolFlags[SymbolFlags["GetAccessor"] = 32768] = "GetAccessor"; + SymbolFlags[SymbolFlags["SetAccessor"] = 65536] = "SetAccessor"; + SymbolFlags[SymbolFlags["Signature"] = 131072] = "Signature"; + SymbolFlags[SymbolFlags["TypeParameter"] = 262144] = "TypeParameter"; + SymbolFlags[SymbolFlags["TypeAlias"] = 524288] = "TypeAlias"; + SymbolFlags[SymbolFlags["ExportValue"] = 1048576] = "ExportValue"; + SymbolFlags[SymbolFlags["Alias"] = 2097152] = "Alias"; + SymbolFlags[SymbolFlags["Prototype"] = 4194304] = "Prototype"; + SymbolFlags[SymbolFlags["ExportStar"] = 8388608] = "ExportStar"; + SymbolFlags[SymbolFlags["Optional"] = 16777216] = "Optional"; + SymbolFlags[SymbolFlags["Transient"] = 33554432] = "Transient"; + SymbolFlags[SymbolFlags["Assignment"] = 67108864] = "Assignment"; + SymbolFlags[SymbolFlags["ModuleExports"] = 134217728] = "ModuleExports"; + /* @internal */ + SymbolFlags[SymbolFlags["All"] = 67108863] = "All"; + SymbolFlags[SymbolFlags["Enum"] = 384] = "Enum"; + SymbolFlags[SymbolFlags["Variable"] = 3] = "Variable"; + SymbolFlags[SymbolFlags["Value"] = 111551] = "Value"; + SymbolFlags[SymbolFlags["Type"] = 788968] = "Type"; + SymbolFlags[SymbolFlags["Namespace"] = 1920] = "Namespace"; + SymbolFlags[SymbolFlags["Module"] = 1536] = "Module"; + SymbolFlags[SymbolFlags["Accessor"] = 98304] = "Accessor"; + // Variables can be redeclared, but can not redeclare a block-scoped declaration with the + // same name, or any other value that is not a variable, e.g. ValueModule or Class + SymbolFlags[SymbolFlags["FunctionScopedVariableExcludes"] = 111550] = "FunctionScopedVariableExcludes"; + // Block-scoped declarations are not allowed to be re-declared + // they can not merge with anything in the value space + SymbolFlags[SymbolFlags["BlockScopedVariableExcludes"] = 111551] = "BlockScopedVariableExcludes"; + SymbolFlags[SymbolFlags["ParameterExcludes"] = 111551] = "ParameterExcludes"; + SymbolFlags[SymbolFlags["PropertyExcludes"] = 0] = "PropertyExcludes"; + SymbolFlags[SymbolFlags["EnumMemberExcludes"] = 900095] = "EnumMemberExcludes"; + SymbolFlags[SymbolFlags["FunctionExcludes"] = 110991] = "FunctionExcludes"; + SymbolFlags[SymbolFlags["ClassExcludes"] = 899503] = "ClassExcludes"; + SymbolFlags[SymbolFlags["InterfaceExcludes"] = 788872] = "InterfaceExcludes"; + SymbolFlags[SymbolFlags["RegularEnumExcludes"] = 899327] = "RegularEnumExcludes"; + SymbolFlags[SymbolFlags["ConstEnumExcludes"] = 899967] = "ConstEnumExcludes"; + SymbolFlags[SymbolFlags["ValueModuleExcludes"] = 110735] = "ValueModuleExcludes"; + SymbolFlags[SymbolFlags["NamespaceModuleExcludes"] = 0] = "NamespaceModuleExcludes"; + SymbolFlags[SymbolFlags["MethodExcludes"] = 103359] = "MethodExcludes"; + SymbolFlags[SymbolFlags["GetAccessorExcludes"] = 46015] = "GetAccessorExcludes"; + SymbolFlags[SymbolFlags["SetAccessorExcludes"] = 78783] = "SetAccessorExcludes"; + SymbolFlags[SymbolFlags["AccessorExcludes"] = 13247] = "AccessorExcludes"; + SymbolFlags[SymbolFlags["TypeParameterExcludes"] = 526824] = "TypeParameterExcludes"; + SymbolFlags[SymbolFlags["TypeAliasExcludes"] = 788968] = "TypeAliasExcludes"; + SymbolFlags[SymbolFlags["AliasExcludes"] = 2097152] = "AliasExcludes"; + SymbolFlags[SymbolFlags["ModuleMember"] = 2623475] = "ModuleMember"; + SymbolFlags[SymbolFlags["ExportHasLocal"] = 944] = "ExportHasLocal"; + SymbolFlags[SymbolFlags["BlockScoped"] = 418] = "BlockScoped"; + SymbolFlags[SymbolFlags["PropertyOrAccessor"] = 98308] = "PropertyOrAccessor"; + SymbolFlags[SymbolFlags["ClassMember"] = 106500] = "ClassMember"; + /* @internal */ + SymbolFlags[SymbolFlags["ExportSupportsDefaultModifier"] = 112] = "ExportSupportsDefaultModifier"; + /* @internal */ + SymbolFlags[SymbolFlags["ExportDoesNotSupportDefaultModifier"] = -113] = "ExportDoesNotSupportDefaultModifier"; + /* @internal */ + // The set of things we consider semantically classifiable. Used to speed up the LS during + // classification. + SymbolFlags[SymbolFlags["Classifiable"] = 2885600] = "Classifiable"; + /* @internal */ + SymbolFlags[SymbolFlags["LateBindingContainer"] = 6256] = "LateBindingContainer"; + })(SymbolFlags = ts.SymbolFlags || (ts.SymbolFlags = {})); + /* @internal */ + var EnumKind; + (function (EnumKind) { + EnumKind[EnumKind["Numeric"] = 0] = "Numeric"; + EnumKind[EnumKind["Literal"] = 1] = "Literal"; // Literal enum (each member has a TypeFlags.EnumLiteral type) + })(EnumKind = ts.EnumKind || (ts.EnumKind = {})); + /* @internal */ + var CheckFlags; + (function (CheckFlags) { + CheckFlags[CheckFlags["Instantiated"] = 1] = "Instantiated"; + CheckFlags[CheckFlags["SyntheticProperty"] = 2] = "SyntheticProperty"; + CheckFlags[CheckFlags["SyntheticMethod"] = 4] = "SyntheticMethod"; + CheckFlags[CheckFlags["Readonly"] = 8] = "Readonly"; + CheckFlags[CheckFlags["ReadPartial"] = 16] = "ReadPartial"; + CheckFlags[CheckFlags["WritePartial"] = 32] = "WritePartial"; + CheckFlags[CheckFlags["HasNonUniformType"] = 64] = "HasNonUniformType"; + CheckFlags[CheckFlags["HasLiteralType"] = 128] = "HasLiteralType"; + CheckFlags[CheckFlags["ContainsPublic"] = 256] = "ContainsPublic"; + CheckFlags[CheckFlags["ContainsProtected"] = 512] = "ContainsProtected"; + CheckFlags[CheckFlags["ContainsPrivate"] = 1024] = "ContainsPrivate"; + CheckFlags[CheckFlags["ContainsStatic"] = 2048] = "ContainsStatic"; + CheckFlags[CheckFlags["Late"] = 4096] = "Late"; + CheckFlags[CheckFlags["ReverseMapped"] = 8192] = "ReverseMapped"; + CheckFlags[CheckFlags["OptionalParameter"] = 16384] = "OptionalParameter"; + CheckFlags[CheckFlags["RestParameter"] = 32768] = "RestParameter"; + CheckFlags[CheckFlags["DeferredType"] = 65536] = "DeferredType"; + CheckFlags[CheckFlags["HasNeverType"] = 131072] = "HasNeverType"; + CheckFlags[CheckFlags["Mapped"] = 262144] = "Mapped"; + CheckFlags[CheckFlags["StripOptional"] = 524288] = "StripOptional"; + CheckFlags[CheckFlags["Unresolved"] = 1048576] = "Unresolved"; + CheckFlags[CheckFlags["Synthetic"] = 6] = "Synthetic"; + CheckFlags[CheckFlags["Discriminant"] = 192] = "Discriminant"; + CheckFlags[CheckFlags["Partial"] = 48] = "Partial"; + })(CheckFlags = ts.CheckFlags || (ts.CheckFlags = {})); + var InternalSymbolName; + (function (InternalSymbolName) { + InternalSymbolName["Call"] = "__call"; + InternalSymbolName["Constructor"] = "__constructor"; + InternalSymbolName["New"] = "__new"; + InternalSymbolName["Index"] = "__index"; + InternalSymbolName["ExportStar"] = "__export"; + InternalSymbolName["Global"] = "__global"; + InternalSymbolName["Missing"] = "__missing"; + InternalSymbolName["Type"] = "__type"; + InternalSymbolName["Object"] = "__object"; + InternalSymbolName["JSXAttributes"] = "__jsxAttributes"; + InternalSymbolName["Class"] = "__class"; + InternalSymbolName["Function"] = "__function"; + InternalSymbolName["Computed"] = "__computed"; + InternalSymbolName["Resolving"] = "__resolving__"; + InternalSymbolName["ExportEquals"] = "export="; + InternalSymbolName["Default"] = "default"; + InternalSymbolName["This"] = "this"; + })(InternalSymbolName = ts.InternalSymbolName || (ts.InternalSymbolName = {})); + /* @internal */ + var NodeCheckFlags; + (function (NodeCheckFlags) { + NodeCheckFlags[NodeCheckFlags["TypeChecked"] = 1] = "TypeChecked"; + NodeCheckFlags[NodeCheckFlags["LexicalThis"] = 2] = "LexicalThis"; + NodeCheckFlags[NodeCheckFlags["CaptureThis"] = 4] = "CaptureThis"; + NodeCheckFlags[NodeCheckFlags["CaptureNewTarget"] = 8] = "CaptureNewTarget"; + NodeCheckFlags[NodeCheckFlags["SuperInstance"] = 256] = "SuperInstance"; + NodeCheckFlags[NodeCheckFlags["SuperStatic"] = 512] = "SuperStatic"; + NodeCheckFlags[NodeCheckFlags["ContextChecked"] = 1024] = "ContextChecked"; + NodeCheckFlags[NodeCheckFlags["MethodWithSuperPropertyAccessInAsync"] = 2048] = "MethodWithSuperPropertyAccessInAsync"; + NodeCheckFlags[NodeCheckFlags["MethodWithSuperPropertyAssignmentInAsync"] = 4096] = "MethodWithSuperPropertyAssignmentInAsync"; + NodeCheckFlags[NodeCheckFlags["CaptureArguments"] = 8192] = "CaptureArguments"; + NodeCheckFlags[NodeCheckFlags["EnumValuesComputed"] = 16384] = "EnumValuesComputed"; + NodeCheckFlags[NodeCheckFlags["LexicalModuleMergesWithClass"] = 32768] = "LexicalModuleMergesWithClass"; + NodeCheckFlags[NodeCheckFlags["LoopWithCapturedBlockScopedBinding"] = 65536] = "LoopWithCapturedBlockScopedBinding"; + NodeCheckFlags[NodeCheckFlags["ContainsCapturedBlockScopeBinding"] = 131072] = "ContainsCapturedBlockScopeBinding"; + NodeCheckFlags[NodeCheckFlags["CapturedBlockScopedBinding"] = 262144] = "CapturedBlockScopedBinding"; + NodeCheckFlags[NodeCheckFlags["BlockScopedBindingInLoop"] = 524288] = "BlockScopedBindingInLoop"; + NodeCheckFlags[NodeCheckFlags["ClassWithBodyScopedClassBinding"] = 1048576] = "ClassWithBodyScopedClassBinding"; + NodeCheckFlags[NodeCheckFlags["BodyScopedClassBinding"] = 2097152] = "BodyScopedClassBinding"; + NodeCheckFlags[NodeCheckFlags["NeedsLoopOutParameter"] = 4194304] = "NeedsLoopOutParameter"; + NodeCheckFlags[NodeCheckFlags["AssignmentsMarked"] = 8388608] = "AssignmentsMarked"; + NodeCheckFlags[NodeCheckFlags["ClassWithConstructorReference"] = 16777216] = "ClassWithConstructorReference"; + NodeCheckFlags[NodeCheckFlags["ConstructorReferenceInClass"] = 33554432] = "ConstructorReferenceInClass"; + NodeCheckFlags[NodeCheckFlags["ContainsClassWithPrivateIdentifiers"] = 67108864] = "ContainsClassWithPrivateIdentifiers"; + NodeCheckFlags[NodeCheckFlags["ContainsSuperPropertyInStaticInitializer"] = 134217728] = "ContainsSuperPropertyInStaticInitializer"; + NodeCheckFlags[NodeCheckFlags["InCheckIdentifier"] = 268435456] = "InCheckIdentifier"; + })(NodeCheckFlags = ts.NodeCheckFlags || (ts.NodeCheckFlags = {})); + var TypeFlags; + (function (TypeFlags) { + TypeFlags[TypeFlags["Any"] = 1] = "Any"; + TypeFlags[TypeFlags["Unknown"] = 2] = "Unknown"; + TypeFlags[TypeFlags["String"] = 4] = "String"; + TypeFlags[TypeFlags["Number"] = 8] = "Number"; + TypeFlags[TypeFlags["Boolean"] = 16] = "Boolean"; + TypeFlags[TypeFlags["Enum"] = 32] = "Enum"; + TypeFlags[TypeFlags["BigInt"] = 64] = "BigInt"; + TypeFlags[TypeFlags["StringLiteral"] = 128] = "StringLiteral"; + TypeFlags[TypeFlags["NumberLiteral"] = 256] = "NumberLiteral"; + TypeFlags[TypeFlags["BooleanLiteral"] = 512] = "BooleanLiteral"; + TypeFlags[TypeFlags["EnumLiteral"] = 1024] = "EnumLiteral"; + TypeFlags[TypeFlags["BigIntLiteral"] = 2048] = "BigIntLiteral"; + TypeFlags[TypeFlags["ESSymbol"] = 4096] = "ESSymbol"; + TypeFlags[TypeFlags["UniqueESSymbol"] = 8192] = "UniqueESSymbol"; + TypeFlags[TypeFlags["Void"] = 16384] = "Void"; + TypeFlags[TypeFlags["Undefined"] = 32768] = "Undefined"; + TypeFlags[TypeFlags["Null"] = 65536] = "Null"; + TypeFlags[TypeFlags["Never"] = 131072] = "Never"; + TypeFlags[TypeFlags["TypeParameter"] = 262144] = "TypeParameter"; + TypeFlags[TypeFlags["Object"] = 524288] = "Object"; + TypeFlags[TypeFlags["Union"] = 1048576] = "Union"; + TypeFlags[TypeFlags["Intersection"] = 2097152] = "Intersection"; + TypeFlags[TypeFlags["Index"] = 4194304] = "Index"; + TypeFlags[TypeFlags["IndexedAccess"] = 8388608] = "IndexedAccess"; + TypeFlags[TypeFlags["Conditional"] = 16777216] = "Conditional"; + TypeFlags[TypeFlags["Substitution"] = 33554432] = "Substitution"; + TypeFlags[TypeFlags["NonPrimitive"] = 67108864] = "NonPrimitive"; + TypeFlags[TypeFlags["TemplateLiteral"] = 134217728] = "TemplateLiteral"; + TypeFlags[TypeFlags["StringMapping"] = 268435456] = "StringMapping"; + /* @internal */ + TypeFlags[TypeFlags["AnyOrUnknown"] = 3] = "AnyOrUnknown"; + /* @internal */ + TypeFlags[TypeFlags["Nullable"] = 98304] = "Nullable"; + TypeFlags[TypeFlags["Literal"] = 2944] = "Literal"; + TypeFlags[TypeFlags["Unit"] = 109440] = "Unit"; + TypeFlags[TypeFlags["StringOrNumberLiteral"] = 384] = "StringOrNumberLiteral"; + /* @internal */ + TypeFlags[TypeFlags["StringOrNumberLiteralOrUnique"] = 8576] = "StringOrNumberLiteralOrUnique"; + /* @internal */ + TypeFlags[TypeFlags["DefinitelyFalsy"] = 117632] = "DefinitelyFalsy"; + TypeFlags[TypeFlags["PossiblyFalsy"] = 117724] = "PossiblyFalsy"; + /* @internal */ + TypeFlags[TypeFlags["Intrinsic"] = 67359327] = "Intrinsic"; + /* @internal */ + TypeFlags[TypeFlags["Primitive"] = 131068] = "Primitive"; + TypeFlags[TypeFlags["StringLike"] = 402653316] = "StringLike"; + TypeFlags[TypeFlags["NumberLike"] = 296] = "NumberLike"; + TypeFlags[TypeFlags["BigIntLike"] = 2112] = "BigIntLike"; + TypeFlags[TypeFlags["BooleanLike"] = 528] = "BooleanLike"; + TypeFlags[TypeFlags["EnumLike"] = 1056] = "EnumLike"; + TypeFlags[TypeFlags["ESSymbolLike"] = 12288] = "ESSymbolLike"; + TypeFlags[TypeFlags["VoidLike"] = 49152] = "VoidLike"; + /* @internal */ + TypeFlags[TypeFlags["DefinitelyNonNullable"] = 470302716] = "DefinitelyNonNullable"; + /* @internal */ + TypeFlags[TypeFlags["DisjointDomains"] = 469892092] = "DisjointDomains"; + TypeFlags[TypeFlags["UnionOrIntersection"] = 3145728] = "UnionOrIntersection"; + TypeFlags[TypeFlags["StructuredType"] = 3670016] = "StructuredType"; + TypeFlags[TypeFlags["TypeVariable"] = 8650752] = "TypeVariable"; + TypeFlags[TypeFlags["InstantiableNonPrimitive"] = 58982400] = "InstantiableNonPrimitive"; + TypeFlags[TypeFlags["InstantiablePrimitive"] = 406847488] = "InstantiablePrimitive"; + TypeFlags[TypeFlags["Instantiable"] = 465829888] = "Instantiable"; + TypeFlags[TypeFlags["StructuredOrInstantiable"] = 469499904] = "StructuredOrInstantiable"; + /* @internal */ + TypeFlags[TypeFlags["ObjectFlagsType"] = 3899393] = "ObjectFlagsType"; + /* @internal */ + TypeFlags[TypeFlags["Simplifiable"] = 25165824] = "Simplifiable"; + /* @internal */ + TypeFlags[TypeFlags["Singleton"] = 67358815] = "Singleton"; + // 'Narrowable' types are types where narrowing actually narrows. + // This *should* be every type other than null, undefined, void, and never + TypeFlags[TypeFlags["Narrowable"] = 536624127] = "Narrowable"; + // The following flags are aggregated during union and intersection type construction + /* @internal */ + TypeFlags[TypeFlags["IncludesMask"] = 205258751] = "IncludesMask"; + // The following flags are used for different purposes during union and intersection type construction + /* @internal */ + TypeFlags[TypeFlags["IncludesMissingType"] = 262144] = "IncludesMissingType"; + /* @internal */ + TypeFlags[TypeFlags["IncludesNonWideningType"] = 4194304] = "IncludesNonWideningType"; + /* @internal */ + TypeFlags[TypeFlags["IncludesWildcard"] = 8388608] = "IncludesWildcard"; + /* @internal */ + TypeFlags[TypeFlags["IncludesEmptyObject"] = 16777216] = "IncludesEmptyObject"; + /* @internal */ + TypeFlags[TypeFlags["IncludesInstantiable"] = 33554432] = "IncludesInstantiable"; + /* @internal */ + TypeFlags[TypeFlags["NotPrimitiveUnion"] = 36323363] = "NotPrimitiveUnion"; + })(TypeFlags = ts.TypeFlags || (ts.TypeFlags = {})); + // Types included in TypeFlags.ObjectFlagsType have an objectFlags property. Some ObjectFlags + // are specific to certain types and reuse the same bit position. Those ObjectFlags require a check + // for a certain TypeFlags value to determine their meaning. + var ObjectFlags; + (function (ObjectFlags) { + ObjectFlags[ObjectFlags["Class"] = 1] = "Class"; + ObjectFlags[ObjectFlags["Interface"] = 2] = "Interface"; + ObjectFlags[ObjectFlags["Reference"] = 4] = "Reference"; + ObjectFlags[ObjectFlags["Tuple"] = 8] = "Tuple"; + ObjectFlags[ObjectFlags["Anonymous"] = 16] = "Anonymous"; + ObjectFlags[ObjectFlags["Mapped"] = 32] = "Mapped"; + ObjectFlags[ObjectFlags["Instantiated"] = 64] = "Instantiated"; + ObjectFlags[ObjectFlags["ObjectLiteral"] = 128] = "ObjectLiteral"; + ObjectFlags[ObjectFlags["EvolvingArray"] = 256] = "EvolvingArray"; + ObjectFlags[ObjectFlags["ObjectLiteralPatternWithComputedProperties"] = 512] = "ObjectLiteralPatternWithComputedProperties"; + ObjectFlags[ObjectFlags["ReverseMapped"] = 1024] = "ReverseMapped"; + ObjectFlags[ObjectFlags["JsxAttributes"] = 2048] = "JsxAttributes"; + ObjectFlags[ObjectFlags["JSLiteral"] = 4096] = "JSLiteral"; + ObjectFlags[ObjectFlags["FreshLiteral"] = 8192] = "FreshLiteral"; + ObjectFlags[ObjectFlags["ArrayLiteral"] = 16384] = "ArrayLiteral"; + /* @internal */ + ObjectFlags[ObjectFlags["PrimitiveUnion"] = 32768] = "PrimitiveUnion"; + /* @internal */ + ObjectFlags[ObjectFlags["ContainsWideningType"] = 65536] = "ContainsWideningType"; + /* @internal */ + ObjectFlags[ObjectFlags["ContainsObjectOrArrayLiteral"] = 131072] = "ContainsObjectOrArrayLiteral"; + /* @internal */ + ObjectFlags[ObjectFlags["NonInferrableType"] = 262144] = "NonInferrableType"; + /* @internal */ + ObjectFlags[ObjectFlags["CouldContainTypeVariablesComputed"] = 524288] = "CouldContainTypeVariablesComputed"; + /* @internal */ + ObjectFlags[ObjectFlags["CouldContainTypeVariables"] = 1048576] = "CouldContainTypeVariables"; + ObjectFlags[ObjectFlags["ClassOrInterface"] = 3] = "ClassOrInterface"; + /* @internal */ + ObjectFlags[ObjectFlags["RequiresWidening"] = 196608] = "RequiresWidening"; + /* @internal */ + ObjectFlags[ObjectFlags["PropagatingFlags"] = 458752] = "PropagatingFlags"; + // Object flags that uniquely identify the kind of ObjectType + /* @internal */ + ObjectFlags[ObjectFlags["ObjectTypeKindMask"] = 1343] = "ObjectTypeKindMask"; + // Flags that require TypeFlags.Object + ObjectFlags[ObjectFlags["ContainsSpread"] = 2097152] = "ContainsSpread"; + ObjectFlags[ObjectFlags["ObjectRestType"] = 4194304] = "ObjectRestType"; + ObjectFlags[ObjectFlags["InstantiationExpressionType"] = 8388608] = "InstantiationExpressionType"; + /* @internal */ + ObjectFlags[ObjectFlags["IsClassInstanceClone"] = 16777216] = "IsClassInstanceClone"; + // Flags that require TypeFlags.Object and ObjectFlags.Reference + /* @internal */ + ObjectFlags[ObjectFlags["IdenticalBaseTypeCalculated"] = 33554432] = "IdenticalBaseTypeCalculated"; + /* @internal */ + ObjectFlags[ObjectFlags["IdenticalBaseTypeExists"] = 67108864] = "IdenticalBaseTypeExists"; + // Flags that require TypeFlags.UnionOrIntersection or TypeFlags.Substitution + /* @internal */ + ObjectFlags[ObjectFlags["IsGenericTypeComputed"] = 2097152] = "IsGenericTypeComputed"; + /* @internal */ + ObjectFlags[ObjectFlags["IsGenericObjectType"] = 4194304] = "IsGenericObjectType"; + /* @internal */ + ObjectFlags[ObjectFlags["IsGenericIndexType"] = 8388608] = "IsGenericIndexType"; + /* @internal */ + ObjectFlags[ObjectFlags["IsGenericType"] = 12582912] = "IsGenericType"; + // Flags that require TypeFlags.Union + /* @internal */ + ObjectFlags[ObjectFlags["ContainsIntersections"] = 16777216] = "ContainsIntersections"; + /* @internal */ + ObjectFlags[ObjectFlags["IsUnknownLikeUnionComputed"] = 33554432] = "IsUnknownLikeUnionComputed"; + /* @internal */ + ObjectFlags[ObjectFlags["IsUnknownLikeUnion"] = 67108864] = "IsUnknownLikeUnion"; + /* @internal */ + // Flags that require TypeFlags.Intersection + /* @internal */ + ObjectFlags[ObjectFlags["IsNeverIntersectionComputed"] = 16777216] = "IsNeverIntersectionComputed"; + /* @internal */ + ObjectFlags[ObjectFlags["IsNeverIntersection"] = 33554432] = "IsNeverIntersection"; + })(ObjectFlags = ts.ObjectFlags || (ts.ObjectFlags = {})); + /* @internal */ + var VarianceFlags; + (function (VarianceFlags) { + VarianceFlags[VarianceFlags["Invariant"] = 0] = "Invariant"; + VarianceFlags[VarianceFlags["Covariant"] = 1] = "Covariant"; + VarianceFlags[VarianceFlags["Contravariant"] = 2] = "Contravariant"; + VarianceFlags[VarianceFlags["Bivariant"] = 3] = "Bivariant"; + VarianceFlags[VarianceFlags["Independent"] = 4] = "Independent"; + VarianceFlags[VarianceFlags["VarianceMask"] = 7] = "VarianceMask"; + VarianceFlags[VarianceFlags["Unmeasurable"] = 8] = "Unmeasurable"; + VarianceFlags[VarianceFlags["Unreliable"] = 16] = "Unreliable"; + VarianceFlags[VarianceFlags["AllowsStructuralFallback"] = 24] = "AllowsStructuralFallback"; + })(VarianceFlags = ts.VarianceFlags || (ts.VarianceFlags = {})); + var ElementFlags; + (function (ElementFlags) { + ElementFlags[ElementFlags["Required"] = 1] = "Required"; + ElementFlags[ElementFlags["Optional"] = 2] = "Optional"; + ElementFlags[ElementFlags["Rest"] = 4] = "Rest"; + ElementFlags[ElementFlags["Variadic"] = 8] = "Variadic"; + ElementFlags[ElementFlags["Fixed"] = 3] = "Fixed"; + ElementFlags[ElementFlags["Variable"] = 12] = "Variable"; + ElementFlags[ElementFlags["NonRequired"] = 14] = "NonRequired"; + ElementFlags[ElementFlags["NonRest"] = 11] = "NonRest"; + })(ElementFlags = ts.ElementFlags || (ts.ElementFlags = {})); + /* @internal */ + var AccessFlags; + (function (AccessFlags) { + AccessFlags[AccessFlags["None"] = 0] = "None"; + AccessFlags[AccessFlags["IncludeUndefined"] = 1] = "IncludeUndefined"; + AccessFlags[AccessFlags["NoIndexSignatures"] = 2] = "NoIndexSignatures"; + AccessFlags[AccessFlags["Writing"] = 4] = "Writing"; + AccessFlags[AccessFlags["CacheSymbol"] = 8] = "CacheSymbol"; + AccessFlags[AccessFlags["NoTupleBoundsCheck"] = 16] = "NoTupleBoundsCheck"; + AccessFlags[AccessFlags["ExpressionPosition"] = 32] = "ExpressionPosition"; + AccessFlags[AccessFlags["ReportDeprecated"] = 64] = "ReportDeprecated"; + AccessFlags[AccessFlags["SuppressNoImplicitAnyError"] = 128] = "SuppressNoImplicitAnyError"; + AccessFlags[AccessFlags["Contextual"] = 256] = "Contextual"; + AccessFlags[AccessFlags["Persistent"] = 1] = "Persistent"; + })(AccessFlags = ts.AccessFlags || (ts.AccessFlags = {})); + /* @internal */ + var JsxReferenceKind; + (function (JsxReferenceKind) { + JsxReferenceKind[JsxReferenceKind["Component"] = 0] = "Component"; + JsxReferenceKind[JsxReferenceKind["Function"] = 1] = "Function"; + JsxReferenceKind[JsxReferenceKind["Mixed"] = 2] = "Mixed"; + })(JsxReferenceKind = ts.JsxReferenceKind || (ts.JsxReferenceKind = {})); + var SignatureKind; + (function (SignatureKind) { + SignatureKind[SignatureKind["Call"] = 0] = "Call"; + SignatureKind[SignatureKind["Construct"] = 1] = "Construct"; + })(SignatureKind = ts.SignatureKind || (ts.SignatureKind = {})); + /* @internal */ + var SignatureFlags; + (function (SignatureFlags) { + SignatureFlags[SignatureFlags["None"] = 0] = "None"; + // Propagating flags + SignatureFlags[SignatureFlags["HasRestParameter"] = 1] = "HasRestParameter"; + SignatureFlags[SignatureFlags["HasLiteralTypes"] = 2] = "HasLiteralTypes"; + SignatureFlags[SignatureFlags["Abstract"] = 4] = "Abstract"; + // Non-propagating flags + SignatureFlags[SignatureFlags["IsInnerCallChain"] = 8] = "IsInnerCallChain"; + SignatureFlags[SignatureFlags["IsOuterCallChain"] = 16] = "IsOuterCallChain"; + SignatureFlags[SignatureFlags["IsUntypedSignatureInJSFile"] = 32] = "IsUntypedSignatureInJSFile"; + // We do not propagate `IsInnerCallChain` or `IsOuterCallChain` to instantiated signatures, as that would result in us + // attempting to add `| undefined` on each recursive call to `getReturnTypeOfSignature` when + // instantiating the return type. + SignatureFlags[SignatureFlags["PropagatingFlags"] = 39] = "PropagatingFlags"; + SignatureFlags[SignatureFlags["CallChainFlags"] = 24] = "CallChainFlags"; + })(SignatureFlags = ts.SignatureFlags || (ts.SignatureFlags = {})); + var IndexKind; + (function (IndexKind) { + IndexKind[IndexKind["String"] = 0] = "String"; + IndexKind[IndexKind["Number"] = 1] = "Number"; + })(IndexKind = ts.IndexKind || (ts.IndexKind = {})); + /* @internal */ + var TypeMapKind; + (function (TypeMapKind) { + TypeMapKind[TypeMapKind["Simple"] = 0] = "Simple"; + TypeMapKind[TypeMapKind["Array"] = 1] = "Array"; + TypeMapKind[TypeMapKind["Deferred"] = 2] = "Deferred"; + TypeMapKind[TypeMapKind["Function"] = 3] = "Function"; + TypeMapKind[TypeMapKind["Composite"] = 4] = "Composite"; + TypeMapKind[TypeMapKind["Merged"] = 5] = "Merged"; + })(TypeMapKind = ts.TypeMapKind || (ts.TypeMapKind = {})); + var InferencePriority; + (function (InferencePriority) { + InferencePriority[InferencePriority["NakedTypeVariable"] = 1] = "NakedTypeVariable"; + InferencePriority[InferencePriority["SpeculativeTuple"] = 2] = "SpeculativeTuple"; + InferencePriority[InferencePriority["SubstituteSource"] = 4] = "SubstituteSource"; + InferencePriority[InferencePriority["HomomorphicMappedType"] = 8] = "HomomorphicMappedType"; + InferencePriority[InferencePriority["PartialHomomorphicMappedType"] = 16] = "PartialHomomorphicMappedType"; + InferencePriority[InferencePriority["MappedTypeConstraint"] = 32] = "MappedTypeConstraint"; + InferencePriority[InferencePriority["ContravariantConditional"] = 64] = "ContravariantConditional"; + InferencePriority[InferencePriority["ReturnType"] = 128] = "ReturnType"; + InferencePriority[InferencePriority["LiteralKeyof"] = 256] = "LiteralKeyof"; + InferencePriority[InferencePriority["NoConstraints"] = 512] = "NoConstraints"; + InferencePriority[InferencePriority["AlwaysStrict"] = 1024] = "AlwaysStrict"; + InferencePriority[InferencePriority["MaxValue"] = 2048] = "MaxValue"; + InferencePriority[InferencePriority["PriorityImpliesCombination"] = 416] = "PriorityImpliesCombination"; + InferencePriority[InferencePriority["Circularity"] = -1] = "Circularity"; + })(InferencePriority = ts.InferencePriority || (ts.InferencePriority = {})); + /* @internal */ + var InferenceFlags; + (function (InferenceFlags) { + InferenceFlags[InferenceFlags["None"] = 0] = "None"; + InferenceFlags[InferenceFlags["NoDefault"] = 1] = "NoDefault"; + InferenceFlags[InferenceFlags["AnyDefault"] = 2] = "AnyDefault"; + InferenceFlags[InferenceFlags["SkippedGenericFunction"] = 4] = "SkippedGenericFunction"; + })(InferenceFlags = ts.InferenceFlags || (ts.InferenceFlags = {})); + /** + * Ternary values are defined such that + * x & y picks the lesser in the order False < Unknown < Maybe < True, and + * x | y picks the greater in the order False < Unknown < Maybe < True. + * Generally, Ternary.Maybe is used as the result of a relation that depends on itself, and + * Ternary.Unknown is used as the result of a variance check that depends on itself. We make + * a distinction because we don't want to cache circular variance check results. + */ + /* @internal */ + var Ternary; + (function (Ternary) { + Ternary[Ternary["False"] = 0] = "False"; + Ternary[Ternary["Unknown"] = 1] = "Unknown"; + Ternary[Ternary["Maybe"] = 3] = "Maybe"; + Ternary[Ternary["True"] = -1] = "True"; + })(Ternary = ts.Ternary || (ts.Ternary = {})); + /* @internal */ + var AssignmentDeclarationKind; + (function (AssignmentDeclarationKind) { + AssignmentDeclarationKind[AssignmentDeclarationKind["None"] = 0] = "None"; + /// exports.name = expr + /// module.exports.name = expr + AssignmentDeclarationKind[AssignmentDeclarationKind["ExportsProperty"] = 1] = "ExportsProperty"; + /// module.exports = expr + AssignmentDeclarationKind[AssignmentDeclarationKind["ModuleExports"] = 2] = "ModuleExports"; + /// className.prototype.name = expr + AssignmentDeclarationKind[AssignmentDeclarationKind["PrototypeProperty"] = 3] = "PrototypeProperty"; + /// this.name = expr + AssignmentDeclarationKind[AssignmentDeclarationKind["ThisProperty"] = 4] = "ThisProperty"; + // F.name = expr + AssignmentDeclarationKind[AssignmentDeclarationKind["Property"] = 5] = "Property"; + // F.prototype = { ... } + AssignmentDeclarationKind[AssignmentDeclarationKind["Prototype"] = 6] = "Prototype"; + // Object.defineProperty(x, 'name', { value: any, writable?: boolean (false by default) }); + // Object.defineProperty(x, 'name', { get: Function, set: Function }); + // Object.defineProperty(x, 'name', { get: Function }); + // Object.defineProperty(x, 'name', { set: Function }); + AssignmentDeclarationKind[AssignmentDeclarationKind["ObjectDefinePropertyValue"] = 7] = "ObjectDefinePropertyValue"; + // Object.defineProperty(exports || module.exports, 'name', ...); + AssignmentDeclarationKind[AssignmentDeclarationKind["ObjectDefinePropertyExports"] = 8] = "ObjectDefinePropertyExports"; + // Object.defineProperty(Foo.prototype, 'name', ...); + AssignmentDeclarationKind[AssignmentDeclarationKind["ObjectDefinePrototypeProperty"] = 9] = "ObjectDefinePrototypeProperty"; + })(AssignmentDeclarationKind = ts.AssignmentDeclarationKind || (ts.AssignmentDeclarationKind = {})); + var DiagnosticCategory; + (function (DiagnosticCategory) { + DiagnosticCategory[DiagnosticCategory["Warning"] = 0] = "Warning"; + DiagnosticCategory[DiagnosticCategory["Error"] = 1] = "Error"; + DiagnosticCategory[DiagnosticCategory["Suggestion"] = 2] = "Suggestion"; + DiagnosticCategory[DiagnosticCategory["Message"] = 3] = "Message"; + })(DiagnosticCategory = ts.DiagnosticCategory || (ts.DiagnosticCategory = {})); + /* @internal */ + function diagnosticCategoryName(d, lowerCase) { + if (lowerCase === void 0) { lowerCase = true; } + var name = DiagnosticCategory[d.category]; + return lowerCase ? name.toLowerCase() : name; + } + ts.diagnosticCategoryName = diagnosticCategoryName; + var ModuleResolutionKind; + (function (ModuleResolutionKind) { + ModuleResolutionKind[ModuleResolutionKind["Classic"] = 1] = "Classic"; + ModuleResolutionKind[ModuleResolutionKind["NodeJs"] = 2] = "NodeJs"; + // Starting with node12, node's module resolver has significant departures from traditional cjs resolution + // to better support ecmascript modules and their use within node - however more features are still being added. + // TypeScript's Node ESM support was introduced after Node 12 went end-of-life, and Node 14 is the earliest stable + // version that supports both pattern trailers - *but*, Node 16 is the first version that also supports ECMASCript 2022. + // In turn, we offer both a `NodeNext` moving resolution target, and a `Node16` version-anchored resolution target + ModuleResolutionKind[ModuleResolutionKind["Node16"] = 3] = "Node16"; + ModuleResolutionKind[ModuleResolutionKind["NodeNext"] = 99] = "NodeNext"; + })(ModuleResolutionKind = ts.ModuleResolutionKind || (ts.ModuleResolutionKind = {})); + var ModuleDetectionKind; + (function (ModuleDetectionKind) { + /** + * Files with imports, exports and/or import.meta are considered modules + */ + ModuleDetectionKind[ModuleDetectionKind["Legacy"] = 1] = "Legacy"; + /** + * Legacy, but also files with jsx under react-jsx or react-jsxdev and esm mode files under moduleResolution: node16+ + */ + ModuleDetectionKind[ModuleDetectionKind["Auto"] = 2] = "Auto"; + /** + * Consider all non-declaration files modules, regardless of present syntax + */ + ModuleDetectionKind[ModuleDetectionKind["Force"] = 3] = "Force"; + })(ModuleDetectionKind = ts.ModuleDetectionKind || (ts.ModuleDetectionKind = {})); + var WatchFileKind; + (function (WatchFileKind) { + WatchFileKind[WatchFileKind["FixedPollingInterval"] = 0] = "FixedPollingInterval"; + WatchFileKind[WatchFileKind["PriorityPollingInterval"] = 1] = "PriorityPollingInterval"; + WatchFileKind[WatchFileKind["DynamicPriorityPolling"] = 2] = "DynamicPriorityPolling"; + WatchFileKind[WatchFileKind["FixedChunkSizePolling"] = 3] = "FixedChunkSizePolling"; + WatchFileKind[WatchFileKind["UseFsEvents"] = 4] = "UseFsEvents"; + WatchFileKind[WatchFileKind["UseFsEventsOnParentDirectory"] = 5] = "UseFsEventsOnParentDirectory"; + })(WatchFileKind = ts.WatchFileKind || (ts.WatchFileKind = {})); + var WatchDirectoryKind; + (function (WatchDirectoryKind) { + WatchDirectoryKind[WatchDirectoryKind["UseFsEvents"] = 0] = "UseFsEvents"; + WatchDirectoryKind[WatchDirectoryKind["FixedPollingInterval"] = 1] = "FixedPollingInterval"; + WatchDirectoryKind[WatchDirectoryKind["DynamicPriorityPolling"] = 2] = "DynamicPriorityPolling"; + WatchDirectoryKind[WatchDirectoryKind["FixedChunkSizePolling"] = 3] = "FixedChunkSizePolling"; + })(WatchDirectoryKind = ts.WatchDirectoryKind || (ts.WatchDirectoryKind = {})); + var PollingWatchKind; + (function (PollingWatchKind) { + PollingWatchKind[PollingWatchKind["FixedInterval"] = 0] = "FixedInterval"; + PollingWatchKind[PollingWatchKind["PriorityInterval"] = 1] = "PriorityInterval"; + PollingWatchKind[PollingWatchKind["DynamicPriority"] = 2] = "DynamicPriority"; + PollingWatchKind[PollingWatchKind["FixedChunkSize"] = 3] = "FixedChunkSize"; + })(PollingWatchKind = ts.PollingWatchKind || (ts.PollingWatchKind = {})); + var ModuleKind; + (function (ModuleKind) { + ModuleKind[ModuleKind["None"] = 0] = "None"; + ModuleKind[ModuleKind["CommonJS"] = 1] = "CommonJS"; + ModuleKind[ModuleKind["AMD"] = 2] = "AMD"; + ModuleKind[ModuleKind["UMD"] = 3] = "UMD"; + ModuleKind[ModuleKind["System"] = 4] = "System"; + // NOTE: ES module kinds should be contiguous to more easily check whether a module kind is *any* ES module kind. + // Non-ES module kinds should not come between ES2015 (the earliest ES module kind) and ESNext (the last ES + // module kind). + ModuleKind[ModuleKind["ES2015"] = 5] = "ES2015"; + ModuleKind[ModuleKind["ES2020"] = 6] = "ES2020"; + ModuleKind[ModuleKind["ES2022"] = 7] = "ES2022"; + ModuleKind[ModuleKind["ESNext"] = 99] = "ESNext"; + // Node16+ is an amalgam of commonjs (albeit updated) and es2022+, and represents a distinct module system from es2020/esnext + ModuleKind[ModuleKind["Node16"] = 100] = "Node16"; + ModuleKind[ModuleKind["NodeNext"] = 199] = "NodeNext"; + })(ModuleKind = ts.ModuleKind || (ts.ModuleKind = {})); + var JsxEmit; + (function (JsxEmit) { + JsxEmit[JsxEmit["None"] = 0] = "None"; + JsxEmit[JsxEmit["Preserve"] = 1] = "Preserve"; + JsxEmit[JsxEmit["React"] = 2] = "React"; + JsxEmit[JsxEmit["ReactNative"] = 3] = "ReactNative"; + JsxEmit[JsxEmit["ReactJSX"] = 4] = "ReactJSX"; + JsxEmit[JsxEmit["ReactJSXDev"] = 5] = "ReactJSXDev"; + })(JsxEmit = ts.JsxEmit || (ts.JsxEmit = {})); + var ImportsNotUsedAsValues; + (function (ImportsNotUsedAsValues) { + ImportsNotUsedAsValues[ImportsNotUsedAsValues["Remove"] = 0] = "Remove"; + ImportsNotUsedAsValues[ImportsNotUsedAsValues["Preserve"] = 1] = "Preserve"; + ImportsNotUsedAsValues[ImportsNotUsedAsValues["Error"] = 2] = "Error"; + })(ImportsNotUsedAsValues = ts.ImportsNotUsedAsValues || (ts.ImportsNotUsedAsValues = {})); + var NewLineKind; + (function (NewLineKind) { + NewLineKind[NewLineKind["CarriageReturnLineFeed"] = 0] = "CarriageReturnLineFeed"; + NewLineKind[NewLineKind["LineFeed"] = 1] = "LineFeed"; + })(NewLineKind = ts.NewLineKind || (ts.NewLineKind = {})); + var ScriptKind; + (function (ScriptKind) { + ScriptKind[ScriptKind["Unknown"] = 0] = "Unknown"; + ScriptKind[ScriptKind["JS"] = 1] = "JS"; + ScriptKind[ScriptKind["JSX"] = 2] = "JSX"; + ScriptKind[ScriptKind["TS"] = 3] = "TS"; + ScriptKind[ScriptKind["TSX"] = 4] = "TSX"; + ScriptKind[ScriptKind["External"] = 5] = "External"; + ScriptKind[ScriptKind["JSON"] = 6] = "JSON"; + /** + * Used on extensions that doesn't define the ScriptKind but the content defines it. + * Deferred extensions are going to be included in all project contexts. + */ + ScriptKind[ScriptKind["Deferred"] = 7] = "Deferred"; + })(ScriptKind = ts.ScriptKind || (ts.ScriptKind = {})); + var ScriptTarget; + (function (ScriptTarget) { + ScriptTarget[ScriptTarget["ES3"] = 0] = "ES3"; + ScriptTarget[ScriptTarget["ES5"] = 1] = "ES5"; + ScriptTarget[ScriptTarget["ES2015"] = 2] = "ES2015"; + ScriptTarget[ScriptTarget["ES2016"] = 3] = "ES2016"; + ScriptTarget[ScriptTarget["ES2017"] = 4] = "ES2017"; + ScriptTarget[ScriptTarget["ES2018"] = 5] = "ES2018"; + ScriptTarget[ScriptTarget["ES2019"] = 6] = "ES2019"; + ScriptTarget[ScriptTarget["ES2020"] = 7] = "ES2020"; + ScriptTarget[ScriptTarget["ES2021"] = 8] = "ES2021"; + ScriptTarget[ScriptTarget["ES2022"] = 9] = "ES2022"; + ScriptTarget[ScriptTarget["ESNext"] = 99] = "ESNext"; + ScriptTarget[ScriptTarget["JSON"] = 100] = "JSON"; + ScriptTarget[ScriptTarget["Latest"] = 99] = "Latest"; + })(ScriptTarget = ts.ScriptTarget || (ts.ScriptTarget = {})); + var LanguageVariant; + (function (LanguageVariant) { + LanguageVariant[LanguageVariant["Standard"] = 0] = "Standard"; + LanguageVariant[LanguageVariant["JSX"] = 1] = "JSX"; + })(LanguageVariant = ts.LanguageVariant || (ts.LanguageVariant = {})); + var WatchDirectoryFlags; + (function (WatchDirectoryFlags) { + WatchDirectoryFlags[WatchDirectoryFlags["None"] = 0] = "None"; + WatchDirectoryFlags[WatchDirectoryFlags["Recursive"] = 1] = "Recursive"; + })(WatchDirectoryFlags = ts.WatchDirectoryFlags || (ts.WatchDirectoryFlags = {})); + /* @internal */ + var CharacterCodes; + (function (CharacterCodes) { + CharacterCodes[CharacterCodes["nullCharacter"] = 0] = "nullCharacter"; + CharacterCodes[CharacterCodes["maxAsciiCharacter"] = 127] = "maxAsciiCharacter"; + CharacterCodes[CharacterCodes["lineFeed"] = 10] = "lineFeed"; + CharacterCodes[CharacterCodes["carriageReturn"] = 13] = "carriageReturn"; + CharacterCodes[CharacterCodes["lineSeparator"] = 8232] = "lineSeparator"; + CharacterCodes[CharacterCodes["paragraphSeparator"] = 8233] = "paragraphSeparator"; + CharacterCodes[CharacterCodes["nextLine"] = 133] = "nextLine"; + // Unicode 3.0 space characters + CharacterCodes[CharacterCodes["space"] = 32] = "space"; + CharacterCodes[CharacterCodes["nonBreakingSpace"] = 160] = "nonBreakingSpace"; + CharacterCodes[CharacterCodes["enQuad"] = 8192] = "enQuad"; + CharacterCodes[CharacterCodes["emQuad"] = 8193] = "emQuad"; + CharacterCodes[CharacterCodes["enSpace"] = 8194] = "enSpace"; + CharacterCodes[CharacterCodes["emSpace"] = 8195] = "emSpace"; + CharacterCodes[CharacterCodes["threePerEmSpace"] = 8196] = "threePerEmSpace"; + CharacterCodes[CharacterCodes["fourPerEmSpace"] = 8197] = "fourPerEmSpace"; + CharacterCodes[CharacterCodes["sixPerEmSpace"] = 8198] = "sixPerEmSpace"; + CharacterCodes[CharacterCodes["figureSpace"] = 8199] = "figureSpace"; + CharacterCodes[CharacterCodes["punctuationSpace"] = 8200] = "punctuationSpace"; + CharacterCodes[CharacterCodes["thinSpace"] = 8201] = "thinSpace"; + CharacterCodes[CharacterCodes["hairSpace"] = 8202] = "hairSpace"; + CharacterCodes[CharacterCodes["zeroWidthSpace"] = 8203] = "zeroWidthSpace"; + CharacterCodes[CharacterCodes["narrowNoBreakSpace"] = 8239] = "narrowNoBreakSpace"; + CharacterCodes[CharacterCodes["ideographicSpace"] = 12288] = "ideographicSpace"; + CharacterCodes[CharacterCodes["mathematicalSpace"] = 8287] = "mathematicalSpace"; + CharacterCodes[CharacterCodes["ogham"] = 5760] = "ogham"; + CharacterCodes[CharacterCodes["_"] = 95] = "_"; + CharacterCodes[CharacterCodes["$"] = 36] = "$"; + CharacterCodes[CharacterCodes["_0"] = 48] = "_0"; + CharacterCodes[CharacterCodes["_1"] = 49] = "_1"; + CharacterCodes[CharacterCodes["_2"] = 50] = "_2"; + CharacterCodes[CharacterCodes["_3"] = 51] = "_3"; + CharacterCodes[CharacterCodes["_4"] = 52] = "_4"; + CharacterCodes[CharacterCodes["_5"] = 53] = "_5"; + CharacterCodes[CharacterCodes["_6"] = 54] = "_6"; + CharacterCodes[CharacterCodes["_7"] = 55] = "_7"; + CharacterCodes[CharacterCodes["_8"] = 56] = "_8"; + CharacterCodes[CharacterCodes["_9"] = 57] = "_9"; + CharacterCodes[CharacterCodes["a"] = 97] = "a"; + CharacterCodes[CharacterCodes["b"] = 98] = "b"; + CharacterCodes[CharacterCodes["c"] = 99] = "c"; + CharacterCodes[CharacterCodes["d"] = 100] = "d"; + CharacterCodes[CharacterCodes["e"] = 101] = "e"; + CharacterCodes[CharacterCodes["f"] = 102] = "f"; + CharacterCodes[CharacterCodes["g"] = 103] = "g"; + CharacterCodes[CharacterCodes["h"] = 104] = "h"; + CharacterCodes[CharacterCodes["i"] = 105] = "i"; + CharacterCodes[CharacterCodes["j"] = 106] = "j"; + CharacterCodes[CharacterCodes["k"] = 107] = "k"; + CharacterCodes[CharacterCodes["l"] = 108] = "l"; + CharacterCodes[CharacterCodes["m"] = 109] = "m"; + CharacterCodes[CharacterCodes["n"] = 110] = "n"; + CharacterCodes[CharacterCodes["o"] = 111] = "o"; + CharacterCodes[CharacterCodes["p"] = 112] = "p"; + CharacterCodes[CharacterCodes["q"] = 113] = "q"; + CharacterCodes[CharacterCodes["r"] = 114] = "r"; + CharacterCodes[CharacterCodes["s"] = 115] = "s"; + CharacterCodes[CharacterCodes["t"] = 116] = "t"; + CharacterCodes[CharacterCodes["u"] = 117] = "u"; + CharacterCodes[CharacterCodes["v"] = 118] = "v"; + CharacterCodes[CharacterCodes["w"] = 119] = "w"; + CharacterCodes[CharacterCodes["x"] = 120] = "x"; + CharacterCodes[CharacterCodes["y"] = 121] = "y"; + CharacterCodes[CharacterCodes["z"] = 122] = "z"; + CharacterCodes[CharacterCodes["A"] = 65] = "A"; + CharacterCodes[CharacterCodes["B"] = 66] = "B"; + CharacterCodes[CharacterCodes["C"] = 67] = "C"; + CharacterCodes[CharacterCodes["D"] = 68] = "D"; + CharacterCodes[CharacterCodes["E"] = 69] = "E"; + CharacterCodes[CharacterCodes["F"] = 70] = "F"; + CharacterCodes[CharacterCodes["G"] = 71] = "G"; + CharacterCodes[CharacterCodes["H"] = 72] = "H"; + CharacterCodes[CharacterCodes["I"] = 73] = "I"; + CharacterCodes[CharacterCodes["J"] = 74] = "J"; + CharacterCodes[CharacterCodes["K"] = 75] = "K"; + CharacterCodes[CharacterCodes["L"] = 76] = "L"; + CharacterCodes[CharacterCodes["M"] = 77] = "M"; + CharacterCodes[CharacterCodes["N"] = 78] = "N"; + CharacterCodes[CharacterCodes["O"] = 79] = "O"; + CharacterCodes[CharacterCodes["P"] = 80] = "P"; + CharacterCodes[CharacterCodes["Q"] = 81] = "Q"; + CharacterCodes[CharacterCodes["R"] = 82] = "R"; + CharacterCodes[CharacterCodes["S"] = 83] = "S"; + CharacterCodes[CharacterCodes["T"] = 84] = "T"; + CharacterCodes[CharacterCodes["U"] = 85] = "U"; + CharacterCodes[CharacterCodes["V"] = 86] = "V"; + CharacterCodes[CharacterCodes["W"] = 87] = "W"; + CharacterCodes[CharacterCodes["X"] = 88] = "X"; + CharacterCodes[CharacterCodes["Y"] = 89] = "Y"; + CharacterCodes[CharacterCodes["Z"] = 90] = "Z"; + CharacterCodes[CharacterCodes["ampersand"] = 38] = "ampersand"; + CharacterCodes[CharacterCodes["asterisk"] = 42] = "asterisk"; + CharacterCodes[CharacterCodes["at"] = 64] = "at"; + CharacterCodes[CharacterCodes["backslash"] = 92] = "backslash"; + CharacterCodes[CharacterCodes["backtick"] = 96] = "backtick"; + CharacterCodes[CharacterCodes["bar"] = 124] = "bar"; + CharacterCodes[CharacterCodes["caret"] = 94] = "caret"; + CharacterCodes[CharacterCodes["closeBrace"] = 125] = "closeBrace"; + CharacterCodes[CharacterCodes["closeBracket"] = 93] = "closeBracket"; + CharacterCodes[CharacterCodes["closeParen"] = 41] = "closeParen"; + CharacterCodes[CharacterCodes["colon"] = 58] = "colon"; + CharacterCodes[CharacterCodes["comma"] = 44] = "comma"; + CharacterCodes[CharacterCodes["dot"] = 46] = "dot"; + CharacterCodes[CharacterCodes["doubleQuote"] = 34] = "doubleQuote"; + CharacterCodes[CharacterCodes["equals"] = 61] = "equals"; + CharacterCodes[CharacterCodes["exclamation"] = 33] = "exclamation"; + CharacterCodes[CharacterCodes["greaterThan"] = 62] = "greaterThan"; + CharacterCodes[CharacterCodes["hash"] = 35] = "hash"; + CharacterCodes[CharacterCodes["lessThan"] = 60] = "lessThan"; + CharacterCodes[CharacterCodes["minus"] = 45] = "minus"; + CharacterCodes[CharacterCodes["openBrace"] = 123] = "openBrace"; + CharacterCodes[CharacterCodes["openBracket"] = 91] = "openBracket"; + CharacterCodes[CharacterCodes["openParen"] = 40] = "openParen"; + CharacterCodes[CharacterCodes["percent"] = 37] = "percent"; + CharacterCodes[CharacterCodes["plus"] = 43] = "plus"; + CharacterCodes[CharacterCodes["question"] = 63] = "question"; + CharacterCodes[CharacterCodes["semicolon"] = 59] = "semicolon"; + CharacterCodes[CharacterCodes["singleQuote"] = 39] = "singleQuote"; + CharacterCodes[CharacterCodes["slash"] = 47] = "slash"; + CharacterCodes[CharacterCodes["tilde"] = 126] = "tilde"; + CharacterCodes[CharacterCodes["backspace"] = 8] = "backspace"; + CharacterCodes[CharacterCodes["formFeed"] = 12] = "formFeed"; + CharacterCodes[CharacterCodes["byteOrderMark"] = 65279] = "byteOrderMark"; + CharacterCodes[CharacterCodes["tab"] = 9] = "tab"; + CharacterCodes[CharacterCodes["verticalTab"] = 11] = "verticalTab"; + })(CharacterCodes = ts.CharacterCodes || (ts.CharacterCodes = {})); + var Extension; + (function (Extension) { + Extension["Ts"] = ".ts"; + Extension["Tsx"] = ".tsx"; + Extension["Dts"] = ".d.ts"; + Extension["Js"] = ".js"; + Extension["Jsx"] = ".jsx"; + Extension["Json"] = ".json"; + Extension["TsBuildInfo"] = ".tsbuildinfo"; + Extension["Mjs"] = ".mjs"; + Extension["Mts"] = ".mts"; + Extension["Dmts"] = ".d.mts"; + Extension["Cjs"] = ".cjs"; + Extension["Cts"] = ".cts"; + Extension["Dcts"] = ".d.cts"; + })(Extension = ts.Extension || (ts.Extension = {})); + /* @internal */ + var TransformFlags; + (function (TransformFlags) { + TransformFlags[TransformFlags["None"] = 0] = "None"; + // Facts + // - Flags used to indicate that a node or subtree contains syntax that requires transformation. + TransformFlags[TransformFlags["ContainsTypeScript"] = 1] = "ContainsTypeScript"; + TransformFlags[TransformFlags["ContainsJsx"] = 2] = "ContainsJsx"; + TransformFlags[TransformFlags["ContainsESNext"] = 4] = "ContainsESNext"; + TransformFlags[TransformFlags["ContainsES2022"] = 8] = "ContainsES2022"; + TransformFlags[TransformFlags["ContainsES2021"] = 16] = "ContainsES2021"; + TransformFlags[TransformFlags["ContainsES2020"] = 32] = "ContainsES2020"; + TransformFlags[TransformFlags["ContainsES2019"] = 64] = "ContainsES2019"; + TransformFlags[TransformFlags["ContainsES2018"] = 128] = "ContainsES2018"; + TransformFlags[TransformFlags["ContainsES2017"] = 256] = "ContainsES2017"; + TransformFlags[TransformFlags["ContainsES2016"] = 512] = "ContainsES2016"; + TransformFlags[TransformFlags["ContainsES2015"] = 1024] = "ContainsES2015"; + TransformFlags[TransformFlags["ContainsGenerator"] = 2048] = "ContainsGenerator"; + TransformFlags[TransformFlags["ContainsDestructuringAssignment"] = 4096] = "ContainsDestructuringAssignment"; + // Markers + // - Flags used to indicate that a subtree contains a specific transformation. + TransformFlags[TransformFlags["ContainsTypeScriptClassSyntax"] = 8192] = "ContainsTypeScriptClassSyntax"; + TransformFlags[TransformFlags["ContainsLexicalThis"] = 16384] = "ContainsLexicalThis"; + TransformFlags[TransformFlags["ContainsRestOrSpread"] = 32768] = "ContainsRestOrSpread"; + TransformFlags[TransformFlags["ContainsObjectRestOrSpread"] = 65536] = "ContainsObjectRestOrSpread"; + TransformFlags[TransformFlags["ContainsComputedPropertyName"] = 131072] = "ContainsComputedPropertyName"; + TransformFlags[TransformFlags["ContainsBlockScopedBinding"] = 262144] = "ContainsBlockScopedBinding"; + TransformFlags[TransformFlags["ContainsBindingPattern"] = 524288] = "ContainsBindingPattern"; + TransformFlags[TransformFlags["ContainsYield"] = 1048576] = "ContainsYield"; + TransformFlags[TransformFlags["ContainsAwait"] = 2097152] = "ContainsAwait"; + TransformFlags[TransformFlags["ContainsHoistedDeclarationOrCompletion"] = 4194304] = "ContainsHoistedDeclarationOrCompletion"; + TransformFlags[TransformFlags["ContainsDynamicImport"] = 8388608] = "ContainsDynamicImport"; + TransformFlags[TransformFlags["ContainsClassFields"] = 16777216] = "ContainsClassFields"; + TransformFlags[TransformFlags["ContainsDecorators"] = 33554432] = "ContainsDecorators"; + TransformFlags[TransformFlags["ContainsPossibleTopLevelAwait"] = 67108864] = "ContainsPossibleTopLevelAwait"; + TransformFlags[TransformFlags["ContainsLexicalSuper"] = 134217728] = "ContainsLexicalSuper"; + TransformFlags[TransformFlags["ContainsUpdateExpressionForIdentifier"] = 268435456] = "ContainsUpdateExpressionForIdentifier"; + TransformFlags[TransformFlags["ContainsPrivateIdentifierInExpression"] = 536870912] = "ContainsPrivateIdentifierInExpression"; + TransformFlags[TransformFlags["HasComputedFlags"] = -2147483648] = "HasComputedFlags"; + // Assertions + // - Bitmasks that are used to assert facts about the syntax of a node and its subtree. + TransformFlags[TransformFlags["AssertTypeScript"] = 1] = "AssertTypeScript"; + TransformFlags[TransformFlags["AssertJsx"] = 2] = "AssertJsx"; + TransformFlags[TransformFlags["AssertESNext"] = 4] = "AssertESNext"; + TransformFlags[TransformFlags["AssertES2022"] = 8] = "AssertES2022"; + TransformFlags[TransformFlags["AssertES2021"] = 16] = "AssertES2021"; + TransformFlags[TransformFlags["AssertES2020"] = 32] = "AssertES2020"; + TransformFlags[TransformFlags["AssertES2019"] = 64] = "AssertES2019"; + TransformFlags[TransformFlags["AssertES2018"] = 128] = "AssertES2018"; + TransformFlags[TransformFlags["AssertES2017"] = 256] = "AssertES2017"; + TransformFlags[TransformFlags["AssertES2016"] = 512] = "AssertES2016"; + TransformFlags[TransformFlags["AssertES2015"] = 1024] = "AssertES2015"; + TransformFlags[TransformFlags["AssertGenerator"] = 2048] = "AssertGenerator"; + TransformFlags[TransformFlags["AssertDestructuringAssignment"] = 4096] = "AssertDestructuringAssignment"; + // Scope Exclusions + // - Bitmasks that exclude flags from propagating out of a specific context + // into the subtree flags of their container. + TransformFlags[TransformFlags["OuterExpressionExcludes"] = -2147483648] = "OuterExpressionExcludes"; + TransformFlags[TransformFlags["PropertyAccessExcludes"] = -2147483648] = "PropertyAccessExcludes"; + TransformFlags[TransformFlags["NodeExcludes"] = -2147483648] = "NodeExcludes"; + TransformFlags[TransformFlags["ArrowFunctionExcludes"] = -2072174592] = "ArrowFunctionExcludes"; + TransformFlags[TransformFlags["FunctionExcludes"] = -1937940480] = "FunctionExcludes"; + TransformFlags[TransformFlags["ConstructorExcludes"] = -1937948672] = "ConstructorExcludes"; + TransformFlags[TransformFlags["MethodOrAccessorExcludes"] = -2005057536] = "MethodOrAccessorExcludes"; + TransformFlags[TransformFlags["PropertyExcludes"] = -2013249536] = "PropertyExcludes"; + TransformFlags[TransformFlags["ClassExcludes"] = -2147344384] = "ClassExcludes"; + TransformFlags[TransformFlags["ModuleExcludes"] = -1941676032] = "ModuleExcludes"; + TransformFlags[TransformFlags["TypeExcludes"] = -2] = "TypeExcludes"; + TransformFlags[TransformFlags["ObjectLiteralExcludes"] = -2147278848] = "ObjectLiteralExcludes"; + TransformFlags[TransformFlags["ArrayLiteralOrCallOrNewExcludes"] = -2147450880] = "ArrayLiteralOrCallOrNewExcludes"; + TransformFlags[TransformFlags["VariableDeclarationListExcludes"] = -2146893824] = "VariableDeclarationListExcludes"; + TransformFlags[TransformFlags["ParameterExcludes"] = -2147483648] = "ParameterExcludes"; + TransformFlags[TransformFlags["CatchClauseExcludes"] = -2147418112] = "CatchClauseExcludes"; + TransformFlags[TransformFlags["BindingPatternExcludes"] = -2147450880] = "BindingPatternExcludes"; + TransformFlags[TransformFlags["ContainsLexicalThisOrSuper"] = 134234112] = "ContainsLexicalThisOrSuper"; + // Propagating flags + // - Bitmasks for flags that should propagate from a child + TransformFlags[TransformFlags["PropertyNamePropagatingFlags"] = 134234112] = "PropertyNamePropagatingFlags"; + // Masks + // - Additional bitmasks + })(TransformFlags = ts.TransformFlags || (ts.TransformFlags = {})); + // Reference: https://code.visualstudio.com/docs/editor/userdefinedsnippets#_snippet-syntax + /* @internal */ + var SnippetKind; + (function (SnippetKind) { + SnippetKind[SnippetKind["TabStop"] = 0] = "TabStop"; + SnippetKind[SnippetKind["Placeholder"] = 1] = "Placeholder"; + SnippetKind[SnippetKind["Choice"] = 2] = "Choice"; + SnippetKind[SnippetKind["Variable"] = 3] = "Variable"; + })(SnippetKind = ts.SnippetKind || (ts.SnippetKind = {})); + var EmitFlags; + (function (EmitFlags) { + EmitFlags[EmitFlags["None"] = 0] = "None"; + EmitFlags[EmitFlags["SingleLine"] = 1] = "SingleLine"; + EmitFlags[EmitFlags["AdviseOnEmitNode"] = 2] = "AdviseOnEmitNode"; + EmitFlags[EmitFlags["NoSubstitution"] = 4] = "NoSubstitution"; + EmitFlags[EmitFlags["CapturesThis"] = 8] = "CapturesThis"; + EmitFlags[EmitFlags["NoLeadingSourceMap"] = 16] = "NoLeadingSourceMap"; + EmitFlags[EmitFlags["NoTrailingSourceMap"] = 32] = "NoTrailingSourceMap"; + EmitFlags[EmitFlags["NoSourceMap"] = 48] = "NoSourceMap"; + EmitFlags[EmitFlags["NoNestedSourceMaps"] = 64] = "NoNestedSourceMaps"; + EmitFlags[EmitFlags["NoTokenLeadingSourceMaps"] = 128] = "NoTokenLeadingSourceMaps"; + EmitFlags[EmitFlags["NoTokenTrailingSourceMaps"] = 256] = "NoTokenTrailingSourceMaps"; + EmitFlags[EmitFlags["NoTokenSourceMaps"] = 384] = "NoTokenSourceMaps"; + EmitFlags[EmitFlags["NoLeadingComments"] = 512] = "NoLeadingComments"; + EmitFlags[EmitFlags["NoTrailingComments"] = 1024] = "NoTrailingComments"; + EmitFlags[EmitFlags["NoComments"] = 1536] = "NoComments"; + EmitFlags[EmitFlags["NoNestedComments"] = 2048] = "NoNestedComments"; + EmitFlags[EmitFlags["HelperName"] = 4096] = "HelperName"; + EmitFlags[EmitFlags["ExportName"] = 8192] = "ExportName"; + EmitFlags[EmitFlags["LocalName"] = 16384] = "LocalName"; + EmitFlags[EmitFlags["InternalName"] = 32768] = "InternalName"; + EmitFlags[EmitFlags["Indented"] = 65536] = "Indented"; + EmitFlags[EmitFlags["NoIndentation"] = 131072] = "NoIndentation"; + EmitFlags[EmitFlags["AsyncFunctionBody"] = 262144] = "AsyncFunctionBody"; + EmitFlags[EmitFlags["ReuseTempVariableScope"] = 524288] = "ReuseTempVariableScope"; + EmitFlags[EmitFlags["CustomPrologue"] = 1048576] = "CustomPrologue"; + EmitFlags[EmitFlags["NoHoisting"] = 2097152] = "NoHoisting"; + EmitFlags[EmitFlags["HasEndOfDeclarationMarker"] = 4194304] = "HasEndOfDeclarationMarker"; + EmitFlags[EmitFlags["Iterator"] = 8388608] = "Iterator"; + EmitFlags[EmitFlags["NoAsciiEscaping"] = 16777216] = "NoAsciiEscaping"; + /*@internal*/ EmitFlags[EmitFlags["TypeScriptClassWrapper"] = 33554432] = "TypeScriptClassWrapper"; + /*@internal*/ EmitFlags[EmitFlags["NeverApplyImportHelper"] = 67108864] = "NeverApplyImportHelper"; + /*@internal*/ EmitFlags[EmitFlags["IgnoreSourceNewlines"] = 134217728] = "IgnoreSourceNewlines"; + /*@internal*/ EmitFlags[EmitFlags["Immutable"] = 268435456] = "Immutable"; + /*@internal*/ EmitFlags[EmitFlags["IndirectCall"] = 536870912] = "IndirectCall"; + })(EmitFlags = ts.EmitFlags || (ts.EmitFlags = {})); + /** + * Used by the checker, this enum keeps track of external emit helpers that should be type + * checked. + */ + /* @internal */ + var ExternalEmitHelpers; + (function (ExternalEmitHelpers) { + ExternalEmitHelpers[ExternalEmitHelpers["Extends"] = 1] = "Extends"; + ExternalEmitHelpers[ExternalEmitHelpers["Assign"] = 2] = "Assign"; + ExternalEmitHelpers[ExternalEmitHelpers["Rest"] = 4] = "Rest"; + ExternalEmitHelpers[ExternalEmitHelpers["Decorate"] = 8] = "Decorate"; + ExternalEmitHelpers[ExternalEmitHelpers["Metadata"] = 16] = "Metadata"; + ExternalEmitHelpers[ExternalEmitHelpers["Param"] = 32] = "Param"; + ExternalEmitHelpers[ExternalEmitHelpers["Awaiter"] = 64] = "Awaiter"; + ExternalEmitHelpers[ExternalEmitHelpers["Generator"] = 128] = "Generator"; + ExternalEmitHelpers[ExternalEmitHelpers["Values"] = 256] = "Values"; + ExternalEmitHelpers[ExternalEmitHelpers["Read"] = 512] = "Read"; + ExternalEmitHelpers[ExternalEmitHelpers["SpreadArray"] = 1024] = "SpreadArray"; + ExternalEmitHelpers[ExternalEmitHelpers["Await"] = 2048] = "Await"; + ExternalEmitHelpers[ExternalEmitHelpers["AsyncGenerator"] = 4096] = "AsyncGenerator"; + ExternalEmitHelpers[ExternalEmitHelpers["AsyncDelegator"] = 8192] = "AsyncDelegator"; + ExternalEmitHelpers[ExternalEmitHelpers["AsyncValues"] = 16384] = "AsyncValues"; + ExternalEmitHelpers[ExternalEmitHelpers["ExportStar"] = 32768] = "ExportStar"; + ExternalEmitHelpers[ExternalEmitHelpers["ImportStar"] = 65536] = "ImportStar"; + ExternalEmitHelpers[ExternalEmitHelpers["ImportDefault"] = 131072] = "ImportDefault"; + ExternalEmitHelpers[ExternalEmitHelpers["MakeTemplateObject"] = 262144] = "MakeTemplateObject"; + ExternalEmitHelpers[ExternalEmitHelpers["ClassPrivateFieldGet"] = 524288] = "ClassPrivateFieldGet"; + ExternalEmitHelpers[ExternalEmitHelpers["ClassPrivateFieldSet"] = 1048576] = "ClassPrivateFieldSet"; + ExternalEmitHelpers[ExternalEmitHelpers["ClassPrivateFieldIn"] = 2097152] = "ClassPrivateFieldIn"; + ExternalEmitHelpers[ExternalEmitHelpers["CreateBinding"] = 4194304] = "CreateBinding"; + ExternalEmitHelpers[ExternalEmitHelpers["FirstEmitHelper"] = 1] = "FirstEmitHelper"; + ExternalEmitHelpers[ExternalEmitHelpers["LastEmitHelper"] = 4194304] = "LastEmitHelper"; + // Helpers included by ES2015 for..of + ExternalEmitHelpers[ExternalEmitHelpers["ForOfIncludes"] = 256] = "ForOfIncludes"; + // Helpers included by ES2017 for..await..of + ExternalEmitHelpers[ExternalEmitHelpers["ForAwaitOfIncludes"] = 16384] = "ForAwaitOfIncludes"; + // Helpers included by ES2017 async generators + ExternalEmitHelpers[ExternalEmitHelpers["AsyncGeneratorIncludes"] = 6144] = "AsyncGeneratorIncludes"; + // Helpers included by yield* in ES2017 async generators + ExternalEmitHelpers[ExternalEmitHelpers["AsyncDelegatorIncludes"] = 26624] = "AsyncDelegatorIncludes"; + // Helpers included by ES2015 spread + ExternalEmitHelpers[ExternalEmitHelpers["SpreadIncludes"] = 1536] = "SpreadIncludes"; + })(ExternalEmitHelpers = ts.ExternalEmitHelpers || (ts.ExternalEmitHelpers = {})); + var EmitHint; + (function (EmitHint) { + EmitHint[EmitHint["SourceFile"] = 0] = "SourceFile"; + EmitHint[EmitHint["Expression"] = 1] = "Expression"; + EmitHint[EmitHint["IdentifierName"] = 2] = "IdentifierName"; + EmitHint[EmitHint["MappedTypeParameter"] = 3] = "MappedTypeParameter"; + EmitHint[EmitHint["Unspecified"] = 4] = "Unspecified"; + EmitHint[EmitHint["EmbeddedStatement"] = 5] = "EmbeddedStatement"; + EmitHint[EmitHint["JsxAttributeValue"] = 6] = "JsxAttributeValue"; + })(EmitHint = ts.EmitHint || (ts.EmitHint = {})); + var OuterExpressionKinds; + (function (OuterExpressionKinds) { + OuterExpressionKinds[OuterExpressionKinds["Parentheses"] = 1] = "Parentheses"; + OuterExpressionKinds[OuterExpressionKinds["TypeAssertions"] = 2] = "TypeAssertions"; + OuterExpressionKinds[OuterExpressionKinds["NonNullAssertions"] = 4] = "NonNullAssertions"; + OuterExpressionKinds[OuterExpressionKinds["PartiallyEmittedExpressions"] = 8] = "PartiallyEmittedExpressions"; + OuterExpressionKinds[OuterExpressionKinds["Assertions"] = 6] = "Assertions"; + OuterExpressionKinds[OuterExpressionKinds["All"] = 15] = "All"; + OuterExpressionKinds[OuterExpressionKinds["ExcludeJSDocTypeAssertion"] = 16] = "ExcludeJSDocTypeAssertion"; + })(OuterExpressionKinds = ts.OuterExpressionKinds || (ts.OuterExpressionKinds = {})); + /* @internal */ + var LexicalEnvironmentFlags; + (function (LexicalEnvironmentFlags) { + LexicalEnvironmentFlags[LexicalEnvironmentFlags["None"] = 0] = "None"; + LexicalEnvironmentFlags[LexicalEnvironmentFlags["InParameters"] = 1] = "InParameters"; + LexicalEnvironmentFlags[LexicalEnvironmentFlags["VariablesHoistedInParameters"] = 2] = "VariablesHoistedInParameters"; // a temp variable was hoisted while visiting a parameter list + })(LexicalEnvironmentFlags = ts.LexicalEnvironmentFlags || (ts.LexicalEnvironmentFlags = {})); + /*@internal*/ + var BundleFileSectionKind; + (function (BundleFileSectionKind) { + BundleFileSectionKind["Prologue"] = "prologue"; + BundleFileSectionKind["EmitHelpers"] = "emitHelpers"; + BundleFileSectionKind["NoDefaultLib"] = "no-default-lib"; + BundleFileSectionKind["Reference"] = "reference"; + BundleFileSectionKind["Type"] = "type"; + BundleFileSectionKind["TypeResolutionModeRequire"] = "type-require"; + BundleFileSectionKind["TypeResolutionModeImport"] = "type-import"; + BundleFileSectionKind["Lib"] = "lib"; + BundleFileSectionKind["Prepend"] = "prepend"; + BundleFileSectionKind["Text"] = "text"; + BundleFileSectionKind["Internal"] = "internal"; + // comments? + })(BundleFileSectionKind = ts.BundleFileSectionKind || (ts.BundleFileSectionKind = {})); + var ListFormat; + (function (ListFormat) { + ListFormat[ListFormat["None"] = 0] = "None"; + // Line separators + ListFormat[ListFormat["SingleLine"] = 0] = "SingleLine"; + ListFormat[ListFormat["MultiLine"] = 1] = "MultiLine"; + ListFormat[ListFormat["PreserveLines"] = 2] = "PreserveLines"; + ListFormat[ListFormat["LinesMask"] = 3] = "LinesMask"; + // Delimiters + ListFormat[ListFormat["NotDelimited"] = 0] = "NotDelimited"; + ListFormat[ListFormat["BarDelimited"] = 4] = "BarDelimited"; + ListFormat[ListFormat["AmpersandDelimited"] = 8] = "AmpersandDelimited"; + ListFormat[ListFormat["CommaDelimited"] = 16] = "CommaDelimited"; + ListFormat[ListFormat["AsteriskDelimited"] = 32] = "AsteriskDelimited"; + ListFormat[ListFormat["DelimitersMask"] = 60] = "DelimitersMask"; + ListFormat[ListFormat["AllowTrailingComma"] = 64] = "AllowTrailingComma"; + // Whitespace + ListFormat[ListFormat["Indented"] = 128] = "Indented"; + ListFormat[ListFormat["SpaceBetweenBraces"] = 256] = "SpaceBetweenBraces"; + ListFormat[ListFormat["SpaceBetweenSiblings"] = 512] = "SpaceBetweenSiblings"; + // Brackets/Braces + ListFormat[ListFormat["Braces"] = 1024] = "Braces"; + ListFormat[ListFormat["Parenthesis"] = 2048] = "Parenthesis"; + ListFormat[ListFormat["AngleBrackets"] = 4096] = "AngleBrackets"; + ListFormat[ListFormat["SquareBrackets"] = 8192] = "SquareBrackets"; + ListFormat[ListFormat["BracketsMask"] = 15360] = "BracketsMask"; + ListFormat[ListFormat["OptionalIfUndefined"] = 16384] = "OptionalIfUndefined"; + ListFormat[ListFormat["OptionalIfEmpty"] = 32768] = "OptionalIfEmpty"; + ListFormat[ListFormat["Optional"] = 49152] = "Optional"; + // Other + ListFormat[ListFormat["PreferNewLine"] = 65536] = "PreferNewLine"; + ListFormat[ListFormat["NoTrailingNewLine"] = 131072] = "NoTrailingNewLine"; + ListFormat[ListFormat["NoInterveningComments"] = 262144] = "NoInterveningComments"; + ListFormat[ListFormat["NoSpaceIfEmpty"] = 524288] = "NoSpaceIfEmpty"; + ListFormat[ListFormat["SingleElement"] = 1048576] = "SingleElement"; + ListFormat[ListFormat["SpaceAfterList"] = 2097152] = "SpaceAfterList"; + // Precomputed Formats + ListFormat[ListFormat["Modifiers"] = 2359808] = "Modifiers"; + ListFormat[ListFormat["HeritageClauses"] = 512] = "HeritageClauses"; + ListFormat[ListFormat["SingleLineTypeLiteralMembers"] = 768] = "SingleLineTypeLiteralMembers"; + ListFormat[ListFormat["MultiLineTypeLiteralMembers"] = 32897] = "MultiLineTypeLiteralMembers"; + ListFormat[ListFormat["SingleLineTupleTypeElements"] = 528] = "SingleLineTupleTypeElements"; + ListFormat[ListFormat["MultiLineTupleTypeElements"] = 657] = "MultiLineTupleTypeElements"; + ListFormat[ListFormat["UnionTypeConstituents"] = 516] = "UnionTypeConstituents"; + ListFormat[ListFormat["IntersectionTypeConstituents"] = 520] = "IntersectionTypeConstituents"; + ListFormat[ListFormat["ObjectBindingPatternElements"] = 525136] = "ObjectBindingPatternElements"; + ListFormat[ListFormat["ArrayBindingPatternElements"] = 524880] = "ArrayBindingPatternElements"; + ListFormat[ListFormat["ObjectLiteralExpressionProperties"] = 526226] = "ObjectLiteralExpressionProperties"; + ListFormat[ListFormat["ImportClauseEntries"] = 526226] = "ImportClauseEntries"; + ListFormat[ListFormat["ArrayLiteralExpressionElements"] = 8914] = "ArrayLiteralExpressionElements"; + ListFormat[ListFormat["CommaListElements"] = 528] = "CommaListElements"; + ListFormat[ListFormat["CallExpressionArguments"] = 2576] = "CallExpressionArguments"; + ListFormat[ListFormat["NewExpressionArguments"] = 18960] = "NewExpressionArguments"; + ListFormat[ListFormat["TemplateExpressionSpans"] = 262144] = "TemplateExpressionSpans"; + ListFormat[ListFormat["SingleLineBlockStatements"] = 768] = "SingleLineBlockStatements"; + ListFormat[ListFormat["MultiLineBlockStatements"] = 129] = "MultiLineBlockStatements"; + ListFormat[ListFormat["VariableDeclarationList"] = 528] = "VariableDeclarationList"; + ListFormat[ListFormat["SingleLineFunctionBodyStatements"] = 768] = "SingleLineFunctionBodyStatements"; + ListFormat[ListFormat["MultiLineFunctionBodyStatements"] = 1] = "MultiLineFunctionBodyStatements"; + ListFormat[ListFormat["ClassHeritageClauses"] = 0] = "ClassHeritageClauses"; + ListFormat[ListFormat["ClassMembers"] = 129] = "ClassMembers"; + ListFormat[ListFormat["InterfaceMembers"] = 129] = "InterfaceMembers"; + ListFormat[ListFormat["EnumMembers"] = 145] = "EnumMembers"; + ListFormat[ListFormat["CaseBlockClauses"] = 129] = "CaseBlockClauses"; + ListFormat[ListFormat["NamedImportsOrExportsElements"] = 525136] = "NamedImportsOrExportsElements"; + ListFormat[ListFormat["JsxElementOrFragmentChildren"] = 262144] = "JsxElementOrFragmentChildren"; + ListFormat[ListFormat["JsxElementAttributes"] = 262656] = "JsxElementAttributes"; + ListFormat[ListFormat["CaseOrDefaultClauseStatements"] = 163969] = "CaseOrDefaultClauseStatements"; + ListFormat[ListFormat["HeritageClauseTypes"] = 528] = "HeritageClauseTypes"; + ListFormat[ListFormat["SourceFileStatements"] = 131073] = "SourceFileStatements"; + ListFormat[ListFormat["Decorators"] = 2146305] = "Decorators"; + ListFormat[ListFormat["TypeArguments"] = 53776] = "TypeArguments"; + ListFormat[ListFormat["TypeParameters"] = 53776] = "TypeParameters"; + ListFormat[ListFormat["Parameters"] = 2576] = "Parameters"; + ListFormat[ListFormat["IndexSignatureParameters"] = 8848] = "IndexSignatureParameters"; + ListFormat[ListFormat["JSDocComment"] = 33] = "JSDocComment"; + })(ListFormat = ts.ListFormat || (ts.ListFormat = {})); + /* @internal */ + var PragmaKindFlags; + (function (PragmaKindFlags) { + PragmaKindFlags[PragmaKindFlags["None"] = 0] = "None"; + /** + * Triple slash comment of the form + * /// + */ + PragmaKindFlags[PragmaKindFlags["TripleSlashXML"] = 1] = "TripleSlashXML"; + /** + * Single line comment of the form + * // @pragma-name argval1 argval2 + * or + * /// @pragma-name argval1 argval2 + */ + PragmaKindFlags[PragmaKindFlags["SingleLine"] = 2] = "SingleLine"; + /** + * Multiline non-jsdoc pragma of the form + * /* @pragma-name argval1 argval2 * / + */ + PragmaKindFlags[PragmaKindFlags["MultiLine"] = 4] = "MultiLine"; + PragmaKindFlags[PragmaKindFlags["All"] = 7] = "All"; + PragmaKindFlags[PragmaKindFlags["Default"] = 7] = "Default"; + })(PragmaKindFlags = ts.PragmaKindFlags || (ts.PragmaKindFlags = {})); + // While not strictly a type, this is here because `PragmaMap` needs to be here to be used with `SourceFile`, and we don't + // fancy effectively defining it twice, once in value-space and once in type-space + /* @internal */ + ts.commentPragmas = { + "reference": { + args: [ + { name: "types", optional: true, captureSpan: true }, + { name: "lib", optional: true, captureSpan: true }, + { name: "path", optional: true, captureSpan: true }, + { name: "no-default-lib", optional: true }, + { name: "resolution-mode", optional: true } + ], + kind: 1 /* PragmaKindFlags.TripleSlashXML */ + }, + "amd-dependency": { + args: [{ name: "path" }, { name: "name", optional: true }], + kind: 1 /* PragmaKindFlags.TripleSlashXML */ + }, + "amd-module": { + args: [{ name: "name" }], + kind: 1 /* PragmaKindFlags.TripleSlashXML */ + }, + "ts-check": { + kind: 2 /* PragmaKindFlags.SingleLine */ + }, + "ts-nocheck": { + kind: 2 /* PragmaKindFlags.SingleLine */ + }, + "jsx": { + args: [{ name: "factory" }], + kind: 4 /* PragmaKindFlags.MultiLine */ + }, + "jsxfrag": { + args: [{ name: "factory" }], + kind: 4 /* PragmaKindFlags.MultiLine */ + }, + "jsximportsource": { + args: [{ name: "factory" }], + kind: 4 /* PragmaKindFlags.MultiLine */ + }, + "jsxruntime": { + args: [{ name: "factory" }], + kind: 4 /* PragmaKindFlags.MultiLine */ + }, + }; +})(ts || (ts = {})); +var ts; +(function (ts) { + /** + * djb2 hashing algorithm + * http://www.cse.yorku.ca/~oz/hash.html + */ + /* @internal */ + function generateDjb2Hash(data) { + var acc = 5381; + for (var i = 0; i < data.length; i++) { + acc = ((acc << 5) + acc) + data.charCodeAt(i); + } + return acc.toString(); + } + ts.generateDjb2Hash = generateDjb2Hash; + /** + * Set a high stack trace limit to provide more information in case of an error. + * Called for command-line and server use cases. + * Not called if TypeScript is used as a library. + */ + /* @internal */ + function setStackTraceLimit() { + if (Error.stackTraceLimit < 100) { // Also tests that we won't set the property if it doesn't exist. + Error.stackTraceLimit = 100; + } + } + ts.setStackTraceLimit = setStackTraceLimit; + var FileWatcherEventKind; + (function (FileWatcherEventKind) { + FileWatcherEventKind[FileWatcherEventKind["Created"] = 0] = "Created"; + FileWatcherEventKind[FileWatcherEventKind["Changed"] = 1] = "Changed"; + FileWatcherEventKind[FileWatcherEventKind["Deleted"] = 2] = "Deleted"; + })(FileWatcherEventKind = ts.FileWatcherEventKind || (ts.FileWatcherEventKind = {})); + /* @internal */ + var PollingInterval; + (function (PollingInterval) { + PollingInterval[PollingInterval["High"] = 2000] = "High"; + PollingInterval[PollingInterval["Medium"] = 500] = "Medium"; + PollingInterval[PollingInterval["Low"] = 250] = "Low"; + })(PollingInterval = ts.PollingInterval || (ts.PollingInterval = {})); + /* @internal */ + ts.missingFileModifiedTime = new Date(0); // Any subsequent modification will occur after this time + /* @internal */ + function getModifiedTime(host, fileName) { + return host.getModifiedTime(fileName) || ts.missingFileModifiedTime; + } + ts.getModifiedTime = getModifiedTime; + function createPollingIntervalBasedLevels(levels) { + var _a; + return _a = {}, + _a[PollingInterval.Low] = levels.Low, + _a[PollingInterval.Medium] = levels.Medium, + _a[PollingInterval.High] = levels.High, + _a; + } + var defaultChunkLevels = { Low: 32, Medium: 64, High: 256 }; + var pollingChunkSize = createPollingIntervalBasedLevels(defaultChunkLevels); + /* @internal */ + ts.unchangedPollThresholds = createPollingIntervalBasedLevels(defaultChunkLevels); + function setCustomPollingValues(system) { + if (!system.getEnvironmentVariable) { + return; + } + var pollingIntervalChanged = setCustomLevels("TSC_WATCH_POLLINGINTERVAL", PollingInterval); + pollingChunkSize = getCustomPollingBasedLevels("TSC_WATCH_POLLINGCHUNKSIZE", defaultChunkLevels) || pollingChunkSize; + ts.unchangedPollThresholds = getCustomPollingBasedLevels("TSC_WATCH_UNCHANGEDPOLLTHRESHOLDS", defaultChunkLevels) || ts.unchangedPollThresholds; + function getLevel(envVar, level) { + return system.getEnvironmentVariable("".concat(envVar, "_").concat(level.toUpperCase())); + } + function getCustomLevels(baseVariable) { + var customLevels; + setCustomLevel("Low"); + setCustomLevel("Medium"); + setCustomLevel("High"); + return customLevels; + function setCustomLevel(level) { + var customLevel = getLevel(baseVariable, level); + if (customLevel) { + (customLevels || (customLevels = {}))[level] = Number(customLevel); + } + } + } + function setCustomLevels(baseVariable, levels) { + var customLevels = getCustomLevels(baseVariable); + if (customLevels) { + setLevel("Low"); + setLevel("Medium"); + setLevel("High"); + return true; + } + return false; + function setLevel(level) { + levels[level] = customLevels[level] || levels[level]; + } + } + function getCustomPollingBasedLevels(baseVariable, defaultLevels) { + var customLevels = getCustomLevels(baseVariable); + return (pollingIntervalChanged || customLevels) && + createPollingIntervalBasedLevels(customLevels ? __assign(__assign({}, defaultLevels), customLevels) : defaultLevels); + } + } + function pollWatchedFileQueue(host, queue, pollIndex, chunkSize, callbackOnWatchFileStat) { + var definedValueCopyToIndex = pollIndex; + // Max visit would be all elements of the queue + for (var canVisit = queue.length; chunkSize && canVisit; nextPollIndex(), canVisit--) { + var watchedFile = queue[pollIndex]; + if (!watchedFile) { + continue; + } + else if (watchedFile.isClosed) { + queue[pollIndex] = undefined; + continue; + } + // Only files polled count towards chunkSize + chunkSize--; + var fileChanged = onWatchedFileStat(watchedFile, getModifiedTime(host, watchedFile.fileName)); + if (watchedFile.isClosed) { + // Closed watcher as part of callback + queue[pollIndex] = undefined; + continue; + } + callbackOnWatchFileStat === null || callbackOnWatchFileStat === void 0 ? void 0 : callbackOnWatchFileStat(watchedFile, pollIndex, fileChanged); + // Defragment the queue while we are at it + if (queue[pollIndex]) { + // Copy this file to the non hole location + if (definedValueCopyToIndex < pollIndex) { + queue[definedValueCopyToIndex] = watchedFile; + queue[pollIndex] = undefined; + } + definedValueCopyToIndex++; + } + } + // Return next poll index + return pollIndex; + function nextPollIndex() { + pollIndex++; + if (pollIndex === queue.length) { + if (definedValueCopyToIndex < pollIndex) { + // There are holes from definedValueCopyToIndex to end of queue, change queue size + queue.length = definedValueCopyToIndex; + } + pollIndex = 0; + definedValueCopyToIndex = 0; + } + } + } + function createDynamicPriorityPollingWatchFile(host) { + var watchedFiles = []; + var changedFilesInLastPoll = []; + var lowPollingIntervalQueue = createPollingIntervalQueue(PollingInterval.Low); + var mediumPollingIntervalQueue = createPollingIntervalQueue(PollingInterval.Medium); + var highPollingIntervalQueue = createPollingIntervalQueue(PollingInterval.High); + return watchFile; + function watchFile(fileName, callback, defaultPollingInterval) { + var file = { + fileName: fileName, + callback: callback, + unchangedPolls: 0, + mtime: getModifiedTime(host, fileName) + }; + watchedFiles.push(file); + addToPollingIntervalQueue(file, defaultPollingInterval); + return { + close: function () { + file.isClosed = true; + // Remove from watchedFiles + ts.unorderedRemoveItem(watchedFiles, file); + // Do not update polling interval queue since that will happen as part of polling + } + }; + } + function createPollingIntervalQueue(pollingInterval) { + var queue = []; + queue.pollingInterval = pollingInterval; + queue.pollIndex = 0; + queue.pollScheduled = false; + return queue; + } + function pollPollingIntervalQueue(queue) { + queue.pollIndex = pollQueue(queue, queue.pollingInterval, queue.pollIndex, pollingChunkSize[queue.pollingInterval]); + // Set the next polling index and timeout + if (queue.length) { + scheduleNextPoll(queue.pollingInterval); + } + else { + ts.Debug.assert(queue.pollIndex === 0); + queue.pollScheduled = false; + } + } + function pollLowPollingIntervalQueue(queue) { + // Always poll complete list of changedFilesInLastPoll + pollQueue(changedFilesInLastPoll, PollingInterval.Low, /*pollIndex*/ 0, changedFilesInLastPoll.length); + // Finally do the actual polling of the queue + pollPollingIntervalQueue(queue); + // Schedule poll if there are files in changedFilesInLastPoll but no files in the actual queue + // as pollPollingIntervalQueue wont schedule for next poll + if (!queue.pollScheduled && changedFilesInLastPoll.length) { + scheduleNextPoll(PollingInterval.Low); + } + } + function pollQueue(queue, pollingInterval, pollIndex, chunkSize) { + return pollWatchedFileQueue(host, queue, pollIndex, chunkSize, onWatchFileStat); + function onWatchFileStat(watchedFile, pollIndex, fileChanged) { + if (fileChanged) { + watchedFile.unchangedPolls = 0; + // Changed files go to changedFilesInLastPoll queue + if (queue !== changedFilesInLastPoll) { + queue[pollIndex] = undefined; + addChangedFileToLowPollingIntervalQueue(watchedFile); + } + } + else if (watchedFile.unchangedPolls !== ts.unchangedPollThresholds[pollingInterval]) { + watchedFile.unchangedPolls++; + } + else if (queue === changedFilesInLastPoll) { + // Restart unchangedPollCount for unchanged file and move to low polling interval queue + watchedFile.unchangedPolls = 1; + queue[pollIndex] = undefined; + addToPollingIntervalQueue(watchedFile, PollingInterval.Low); + } + else if (pollingInterval !== PollingInterval.High) { + watchedFile.unchangedPolls++; + queue[pollIndex] = undefined; + addToPollingIntervalQueue(watchedFile, pollingInterval === PollingInterval.Low ? PollingInterval.Medium : PollingInterval.High); + } + } + } + function pollingIntervalQueue(pollingInterval) { + switch (pollingInterval) { + case PollingInterval.Low: + return lowPollingIntervalQueue; + case PollingInterval.Medium: + return mediumPollingIntervalQueue; + case PollingInterval.High: + return highPollingIntervalQueue; + } + } + function addToPollingIntervalQueue(file, pollingInterval) { + pollingIntervalQueue(pollingInterval).push(file); + scheduleNextPollIfNotAlreadyScheduled(pollingInterval); + } + function addChangedFileToLowPollingIntervalQueue(file) { + changedFilesInLastPoll.push(file); + scheduleNextPollIfNotAlreadyScheduled(PollingInterval.Low); + } + function scheduleNextPollIfNotAlreadyScheduled(pollingInterval) { + if (!pollingIntervalQueue(pollingInterval).pollScheduled) { + scheduleNextPoll(pollingInterval); + } + } + function scheduleNextPoll(pollingInterval) { + pollingIntervalQueue(pollingInterval).pollScheduled = host.setTimeout(pollingInterval === PollingInterval.Low ? pollLowPollingIntervalQueue : pollPollingIntervalQueue, pollingInterval, pollingIntervalQueue(pollingInterval)); + } + } + function createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames) { + // One file can have multiple watchers + var fileWatcherCallbacks = ts.createMultiMap(); + var dirWatchers = new ts.Map(); + var toCanonicalName = ts.createGetCanonicalFileName(useCaseSensitiveFileNames); + return nonPollingWatchFile; + function nonPollingWatchFile(fileName, callback, _pollingInterval, fallbackOptions) { + var filePath = toCanonicalName(fileName); + fileWatcherCallbacks.add(filePath, callback); + var dirPath = ts.getDirectoryPath(filePath) || "."; + var watcher = dirWatchers.get(dirPath) || + createDirectoryWatcher(ts.getDirectoryPath(fileName) || ".", dirPath, fallbackOptions); + watcher.referenceCount++; + return { + close: function () { + if (watcher.referenceCount === 1) { + watcher.close(); + dirWatchers.delete(dirPath); + } + else { + watcher.referenceCount--; + } + fileWatcherCallbacks.remove(filePath, callback); + } + }; + } + function createDirectoryWatcher(dirName, dirPath, fallbackOptions) { + var watcher = fsWatch(dirName, 1 /* FileSystemEntryKind.Directory */, function (_eventName, relativeFileName, modifiedTime) { + // When files are deleted from disk, the triggered "rename" event would have a relativefileName of "undefined" + if (!ts.isString(relativeFileName)) + return; + var fileName = ts.getNormalizedAbsolutePath(relativeFileName, dirName); + // Some applications save a working file via rename operations + var callbacks = fileName && fileWatcherCallbacks.get(toCanonicalName(fileName)); + if (callbacks) { + for (var _i = 0, callbacks_1 = callbacks; _i < callbacks_1.length; _i++) { + var fileCallback = callbacks_1[_i]; + fileCallback(fileName, FileWatcherEventKind.Changed, modifiedTime); + } + } + }, + /*recursive*/ false, PollingInterval.Medium, fallbackOptions); + watcher.referenceCount = 0; + dirWatchers.set(dirPath, watcher); + return watcher; + } + } + function createFixedChunkSizePollingWatchFile(host) { + var watchedFiles = []; + var pollIndex = 0; + var pollScheduled; + return watchFile; + function watchFile(fileName, callback) { + var file = { + fileName: fileName, + callback: callback, + mtime: getModifiedTime(host, fileName) + }; + watchedFiles.push(file); + scheduleNextPoll(); + return { + close: function () { + file.isClosed = true; + ts.unorderedRemoveItem(watchedFiles, file); + } + }; + } + function pollQueue() { + pollScheduled = undefined; + pollIndex = pollWatchedFileQueue(host, watchedFiles, pollIndex, pollingChunkSize[PollingInterval.Low]); + scheduleNextPoll(); + } + function scheduleNextPoll() { + if (!watchedFiles.length || pollScheduled) + return; + pollScheduled = host.setTimeout(pollQueue, PollingInterval.High); + } + } + function createSingleWatcherPerName(cache, useCaseSensitiveFileNames, name, callback, createWatcher) { + var toCanonicalFileName = ts.createGetCanonicalFileName(useCaseSensitiveFileNames); + var path = toCanonicalFileName(name); + var existing = cache.get(path); + if (existing) { + existing.callbacks.push(callback); + } + else { + cache.set(path, { + watcher: createWatcher(( + // Cant infer types correctly so lets satisfy checker + function (param1, param2, param3) { var _a; return (_a = cache.get(path)) === null || _a === void 0 ? void 0 : _a.callbacks.slice().forEach(function (cb) { return cb(param1, param2, param3); }); })), + callbacks: [callback] + }); + } + return { + close: function () { + var watcher = cache.get(path); + // Watcher is not expected to be undefined, but if it is normally its because + // exception was thrown somewhere else and watch state is not what it should be + if (!watcher) + return; + if (!ts.orderedRemoveItem(watcher.callbacks, callback) || watcher.callbacks.length) + return; + cache.delete(path); + ts.closeFileWatcherOf(watcher); + } + }; + } + /** + * Returns true if file status changed + */ + function onWatchedFileStat(watchedFile, modifiedTime) { + var oldTime = watchedFile.mtime.getTime(); + var newTime = modifiedTime.getTime(); + if (oldTime !== newTime) { + watchedFile.mtime = modifiedTime; + // Pass modified times so tsc --build can use it + watchedFile.callback(watchedFile.fileName, getFileWatcherEventKind(oldTime, newTime), modifiedTime); + return true; + } + return false; + } + /*@internal*/ + function getFileWatcherEventKind(oldTime, newTime) { + return oldTime === 0 + ? FileWatcherEventKind.Created + : newTime === 0 + ? FileWatcherEventKind.Deleted + : FileWatcherEventKind.Changed; + } + ts.getFileWatcherEventKind = getFileWatcherEventKind; + /*@internal*/ + ts.ignoredPaths = ["/node_modules/.", "/.git", "/.#"]; + var curSysLog = ts.noop; // eslint-disable-line prefer-const + /*@internal*/ + function sysLog(s) { + return curSysLog(s); + } + ts.sysLog = sysLog; + /*@internal*/ + function setSysLog(logger) { + curSysLog = logger; + } + ts.setSysLog = setSysLog; + /** + * Watch the directory recursively using host provided method to watch child directories + * that means if this is recursive watcher, watch the children directories as well + * (eg on OS that dont support recursive watch using fs.watch use fs.watchFile) + */ + function createDirectoryWatcherSupportingRecursive(_a) { + var watchDirectory = _a.watchDirectory, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, getCurrentDirectory = _a.getCurrentDirectory, getAccessibleSortedChildDirectories = _a.getAccessibleSortedChildDirectories, fileSystemEntryExists = _a.fileSystemEntryExists, realpath = _a.realpath, setTimeout = _a.setTimeout, clearTimeout = _a.clearTimeout; + var cache = new ts.Map(); + var callbackCache = ts.createMultiMap(); + var cacheToUpdateChildWatches = new ts.Map(); + var timerToUpdateChildWatches; + var filePathComparer = ts.getStringComparer(!useCaseSensitiveFileNames); + var toCanonicalFilePath = ts.createGetCanonicalFileName(useCaseSensitiveFileNames); + return function (dirName, callback, recursive, options) { return recursive ? + createDirectoryWatcher(dirName, options, callback) : + watchDirectory(dirName, callback, recursive, options); }; + /** + * Create the directory watcher for the dirPath. + */ + function createDirectoryWatcher(dirName, options, callback) { + var dirPath = toCanonicalFilePath(dirName); + var directoryWatcher = cache.get(dirPath); + if (directoryWatcher) { + directoryWatcher.refCount++; + } + else { + directoryWatcher = { + watcher: watchDirectory(dirName, function (fileName) { + if (isIgnoredPath(fileName, options)) + return; + if (options === null || options === void 0 ? void 0 : options.synchronousWatchDirectory) { + // Call the actual callback + invokeCallbacks(dirPath, fileName); + // Iterate through existing children and update the watches if needed + updateChildWatches(dirName, dirPath, options); + } + else { + nonSyncUpdateChildWatches(dirName, dirPath, fileName, options); + } + }, /*recursive*/ false, options), + refCount: 1, + childWatches: ts.emptyArray + }; + cache.set(dirPath, directoryWatcher); + updateChildWatches(dirName, dirPath, options); + } + var callbackToAdd = callback && { dirName: dirName, callback: callback }; + if (callbackToAdd) { + callbackCache.add(dirPath, callbackToAdd); + } + return { + dirName: dirName, + close: function () { + var directoryWatcher = ts.Debug.checkDefined(cache.get(dirPath)); + if (callbackToAdd) + callbackCache.remove(dirPath, callbackToAdd); + directoryWatcher.refCount--; + if (directoryWatcher.refCount) + return; + cache.delete(dirPath); + ts.closeFileWatcherOf(directoryWatcher); + directoryWatcher.childWatches.forEach(ts.closeFileWatcher); + } + }; + } + function invokeCallbacks(dirPath, fileNameOrInvokeMap, fileNames) { + var fileName; + var invokeMap; + if (ts.isString(fileNameOrInvokeMap)) { + fileName = fileNameOrInvokeMap; + } + else { + invokeMap = fileNameOrInvokeMap; + } + // Call the actual callback + callbackCache.forEach(function (callbacks, rootDirName) { + var _a; + if (invokeMap && invokeMap.get(rootDirName) === true) + return; + if (rootDirName === dirPath || (ts.startsWith(dirPath, rootDirName) && dirPath[rootDirName.length] === ts.directorySeparator)) { + if (invokeMap) { + if (fileNames) { + var existing = invokeMap.get(rootDirName); + if (existing) { + (_a = existing).push.apply(_a, fileNames); + } + else { + invokeMap.set(rootDirName, fileNames.slice()); + } + } + else { + invokeMap.set(rootDirName, true); + } + } + else { + callbacks.forEach(function (_a) { + var callback = _a.callback; + return callback(fileName); + }); + } + } + }); + } + function nonSyncUpdateChildWatches(dirName, dirPath, fileName, options) { + // Iterate through existing children and update the watches if needed + var parentWatcher = cache.get(dirPath); + if (parentWatcher && fileSystemEntryExists(dirName, 1 /* FileSystemEntryKind.Directory */)) { + // Schedule the update and postpone invoke for callbacks + scheduleUpdateChildWatches(dirName, dirPath, fileName, options); + return; + } + // Call the actual callbacks and remove child watches + invokeCallbacks(dirPath, fileName); + removeChildWatches(parentWatcher); + } + function scheduleUpdateChildWatches(dirName, dirPath, fileName, options) { + var existing = cacheToUpdateChildWatches.get(dirPath); + if (existing) { + existing.fileNames.push(fileName); + } + else { + cacheToUpdateChildWatches.set(dirPath, { dirName: dirName, options: options, fileNames: [fileName] }); + } + if (timerToUpdateChildWatches) { + clearTimeout(timerToUpdateChildWatches); + timerToUpdateChildWatches = undefined; + } + timerToUpdateChildWatches = setTimeout(onTimerToUpdateChildWatches, 1000); + } + function onTimerToUpdateChildWatches() { + timerToUpdateChildWatches = undefined; + sysLog("sysLog:: onTimerToUpdateChildWatches:: ".concat(cacheToUpdateChildWatches.size)); + var start = ts.timestamp(); + var invokeMap = new ts.Map(); + while (!timerToUpdateChildWatches && cacheToUpdateChildWatches.size) { + var result = cacheToUpdateChildWatches.entries().next(); + ts.Debug.assert(!result.done); + var _a = result.value, dirPath = _a[0], _b = _a[1], dirName = _b.dirName, options = _b.options, fileNames = _b.fileNames; + cacheToUpdateChildWatches.delete(dirPath); + // Because the child refresh is fresh, we would need to invalidate whole root directory being watched + // to ensure that all the changes are reflected at this time + var hasChanges = updateChildWatches(dirName, dirPath, options); + invokeCallbacks(dirPath, invokeMap, hasChanges ? undefined : fileNames); + } + sysLog("sysLog:: invokingWatchers:: Elapsed:: ".concat(ts.timestamp() - start, "ms:: ").concat(cacheToUpdateChildWatches.size)); + callbackCache.forEach(function (callbacks, rootDirName) { + var existing = invokeMap.get(rootDirName); + if (existing) { + callbacks.forEach(function (_a) { + var callback = _a.callback, dirName = _a.dirName; + if (ts.isArray(existing)) { + existing.forEach(callback); + } + else { + callback(dirName); + } + }); + } + }); + var elapsed = ts.timestamp() - start; + sysLog("sysLog:: Elapsed:: ".concat(elapsed, "ms:: onTimerToUpdateChildWatches:: ").concat(cacheToUpdateChildWatches.size, " ").concat(timerToUpdateChildWatches)); + } + function removeChildWatches(parentWatcher) { + if (!parentWatcher) + return; + var existingChildWatches = parentWatcher.childWatches; + parentWatcher.childWatches = ts.emptyArray; + for (var _i = 0, existingChildWatches_1 = existingChildWatches; _i < existingChildWatches_1.length; _i++) { + var childWatcher = existingChildWatches_1[_i]; + childWatcher.close(); + removeChildWatches(cache.get(toCanonicalFilePath(childWatcher.dirName))); + } + } + function updateChildWatches(parentDir, parentDirPath, options) { + // Iterate through existing children and update the watches if needed + var parentWatcher = cache.get(parentDirPath); + if (!parentWatcher) + return false; + var newChildWatches; + var hasChanges = ts.enumerateInsertsAndDeletes(fileSystemEntryExists(parentDir, 1 /* FileSystemEntryKind.Directory */) ? ts.mapDefined(getAccessibleSortedChildDirectories(parentDir), function (child) { + var childFullName = ts.getNormalizedAbsolutePath(child, parentDir); + // Filter our the symbolic link directories since those arent included in recursive watch + // which is same behaviour when recursive: true is passed to fs.watch + return !isIgnoredPath(childFullName, options) && filePathComparer(childFullName, ts.normalizePath(realpath(childFullName))) === 0 /* Comparison.EqualTo */ ? childFullName : undefined; + }) : ts.emptyArray, parentWatcher.childWatches, function (child, childWatcher) { return filePathComparer(child, childWatcher.dirName); }, createAndAddChildDirectoryWatcher, ts.closeFileWatcher, addChildDirectoryWatcher); + parentWatcher.childWatches = newChildWatches || ts.emptyArray; + return hasChanges; + /** + * Create new childDirectoryWatcher and add it to the new ChildDirectoryWatcher list + */ + function createAndAddChildDirectoryWatcher(childName) { + var result = createDirectoryWatcher(childName, options); + addChildDirectoryWatcher(result); + } + /** + * Add child directory watcher to the new ChildDirectoryWatcher list + */ + function addChildDirectoryWatcher(childWatcher) { + (newChildWatches || (newChildWatches = [])).push(childWatcher); + } + } + function isIgnoredPath(path, options) { + return ts.some(ts.ignoredPaths, function (searchPath) { return isInPath(path, searchPath); }) || + isIgnoredByWatchOptions(path, options, useCaseSensitiveFileNames, getCurrentDirectory); + } + function isInPath(path, searchPath) { + if (ts.stringContains(path, searchPath)) + return true; + if (useCaseSensitiveFileNames) + return false; + return ts.stringContains(toCanonicalFilePath(path), searchPath); + } + } + /*@internal*/ + var FileSystemEntryKind; + (function (FileSystemEntryKind) { + FileSystemEntryKind[FileSystemEntryKind["File"] = 0] = "File"; + FileSystemEntryKind[FileSystemEntryKind["Directory"] = 1] = "Directory"; + })(FileSystemEntryKind = ts.FileSystemEntryKind || (ts.FileSystemEntryKind = {})); + function createFileWatcherCallback(callback) { + return function (_fileName, eventKind, modifiedTime) { return callback(eventKind === FileWatcherEventKind.Changed ? "change" : "rename", "", modifiedTime); }; + } + function createFsWatchCallbackForFileWatcherCallback(fileName, callback, getModifiedTime) { + return function (eventName, _relativeFileName, modifiedTime) { + if (eventName === "rename") { + // Check time stamps rather than file system entry checks + modifiedTime || (modifiedTime = getModifiedTime(fileName) || ts.missingFileModifiedTime); + callback(fileName, modifiedTime !== ts.missingFileModifiedTime ? FileWatcherEventKind.Created : FileWatcherEventKind.Deleted, modifiedTime); + } + else { + // Change + callback(fileName, FileWatcherEventKind.Changed, modifiedTime); + } + }; + } + function isIgnoredByWatchOptions(pathToCheck, options, useCaseSensitiveFileNames, getCurrentDirectory) { + return ((options === null || options === void 0 ? void 0 : options.excludeDirectories) || (options === null || options === void 0 ? void 0 : options.excludeFiles)) && (ts.matchesExclude(pathToCheck, options === null || options === void 0 ? void 0 : options.excludeFiles, useCaseSensitiveFileNames, getCurrentDirectory()) || + ts.matchesExclude(pathToCheck, options === null || options === void 0 ? void 0 : options.excludeDirectories, useCaseSensitiveFileNames, getCurrentDirectory())); + } + function createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback, options, useCaseSensitiveFileNames, getCurrentDirectory) { + return function (eventName, relativeFileName) { + // In watchDirectory we only care about adding and removing files (when event name is + // "rename"); changes made within files are handled by corresponding fileWatchers (when + // event name is "change") + if (eventName === "rename") { + // When deleting a file, the passed baseFileName is null + var fileName = !relativeFileName ? directoryName : ts.normalizePath(ts.combinePaths(directoryName, relativeFileName)); + if (!relativeFileName || !isIgnoredByWatchOptions(fileName, options, useCaseSensitiveFileNames, getCurrentDirectory)) { + callback(fileName); + } + } + }; + } + /*@internal*/ + function createSystemWatchFunctions(_a) { + var pollingWatchFileWorker = _a.pollingWatchFileWorker, getModifiedTime = _a.getModifiedTime, setTimeout = _a.setTimeout, clearTimeout = _a.clearTimeout, fsWatchWorker = _a.fsWatchWorker, fileSystemEntryExists = _a.fileSystemEntryExists, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, getCurrentDirectory = _a.getCurrentDirectory, fsSupportsRecursiveFsWatch = _a.fsSupportsRecursiveFsWatch, getAccessibleSortedChildDirectories = _a.getAccessibleSortedChildDirectories, realpath = _a.realpath, tscWatchFile = _a.tscWatchFile, useNonPollingWatchers = _a.useNonPollingWatchers, tscWatchDirectory = _a.tscWatchDirectory, inodeWatching = _a.inodeWatching, sysLog = _a.sysLog; + var pollingWatches = new ts.Map(); + var fsWatches = new ts.Map(); + var fsWatchesRecursive = new ts.Map(); + var dynamicPollingWatchFile; + var fixedChunkSizePollingWatchFile; + var nonPollingWatchFile; + var hostRecursiveDirectoryWatcher; + var hitSystemWatcherLimit = false; + return { + watchFile: watchFile, + watchDirectory: watchDirectory + }; + function watchFile(fileName, callback, pollingInterval, options) { + options = updateOptionsForWatchFile(options, useNonPollingWatchers); + var watchFileKind = ts.Debug.checkDefined(options.watchFile); + switch (watchFileKind) { + case ts.WatchFileKind.FixedPollingInterval: + return pollingWatchFile(fileName, callback, PollingInterval.Low, /*options*/ undefined); + case ts.WatchFileKind.PriorityPollingInterval: + return pollingWatchFile(fileName, callback, pollingInterval, /*options*/ undefined); + case ts.WatchFileKind.DynamicPriorityPolling: + return ensureDynamicPollingWatchFile()(fileName, callback, pollingInterval, /*options*/ undefined); + case ts.WatchFileKind.FixedChunkSizePolling: + return ensureFixedChunkSizePollingWatchFile()(fileName, callback, /* pollingInterval */ undefined, /*options*/ undefined); + case ts.WatchFileKind.UseFsEvents: + return fsWatch(fileName, 0 /* FileSystemEntryKind.File */, createFsWatchCallbackForFileWatcherCallback(fileName, callback, getModifiedTime), + /*recursive*/ false, pollingInterval, ts.getFallbackOptions(options)); + case ts.WatchFileKind.UseFsEventsOnParentDirectory: + if (!nonPollingWatchFile) { + nonPollingWatchFile = createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames); + } + return nonPollingWatchFile(fileName, callback, pollingInterval, ts.getFallbackOptions(options)); + default: + ts.Debug.assertNever(watchFileKind); + } + } + function ensureDynamicPollingWatchFile() { + return dynamicPollingWatchFile || (dynamicPollingWatchFile = createDynamicPriorityPollingWatchFile({ getModifiedTime: getModifiedTime, setTimeout: setTimeout })); + } + function ensureFixedChunkSizePollingWatchFile() { + return fixedChunkSizePollingWatchFile || (fixedChunkSizePollingWatchFile = createFixedChunkSizePollingWatchFile({ getModifiedTime: getModifiedTime, setTimeout: setTimeout })); + } + function updateOptionsForWatchFile(options, useNonPollingWatchers) { + if (options && options.watchFile !== undefined) + return options; + switch (tscWatchFile) { + case "PriorityPollingInterval": + // Use polling interval based on priority when create watch using host.watchFile + return { watchFile: ts.WatchFileKind.PriorityPollingInterval }; + case "DynamicPriorityPolling": + // Use polling interval but change the interval depending on file changes and their default polling interval + return { watchFile: ts.WatchFileKind.DynamicPriorityPolling }; + case "UseFsEvents": + // Use notifications from FS to watch with falling back to fs.watchFile + return generateWatchFileOptions(ts.WatchFileKind.UseFsEvents, ts.PollingWatchKind.PriorityInterval, options); + case "UseFsEventsWithFallbackDynamicPolling": + // Use notifications from FS to watch with falling back to dynamic watch file + return generateWatchFileOptions(ts.WatchFileKind.UseFsEvents, ts.PollingWatchKind.DynamicPriority, options); + case "UseFsEventsOnParentDirectory": + useNonPollingWatchers = true; + // fall through + default: + return useNonPollingWatchers ? + // Use notifications from FS to watch with falling back to fs.watchFile + generateWatchFileOptions(ts.WatchFileKind.UseFsEventsOnParentDirectory, ts.PollingWatchKind.PriorityInterval, options) : + // Default to using fs events + { watchFile: ts.WatchFileKind.UseFsEvents }; + } + } + function generateWatchFileOptions(watchFile, fallbackPolling, options) { + var defaultFallbackPolling = options === null || options === void 0 ? void 0 : options.fallbackPolling; + return { + watchFile: watchFile, + fallbackPolling: defaultFallbackPolling === undefined ? + fallbackPolling : + defaultFallbackPolling + }; + } + function watchDirectory(directoryName, callback, recursive, options) { + if (fsSupportsRecursiveFsWatch) { + return fsWatch(directoryName, 1 /* FileSystemEntryKind.Directory */, createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback, options, useCaseSensitiveFileNames, getCurrentDirectory), recursive, PollingInterval.Medium, ts.getFallbackOptions(options)); + } + if (!hostRecursiveDirectoryWatcher) { + hostRecursiveDirectoryWatcher = createDirectoryWatcherSupportingRecursive({ + useCaseSensitiveFileNames: useCaseSensitiveFileNames, + getCurrentDirectory: getCurrentDirectory, + fileSystemEntryExists: fileSystemEntryExists, + getAccessibleSortedChildDirectories: getAccessibleSortedChildDirectories, + watchDirectory: nonRecursiveWatchDirectory, + realpath: realpath, + setTimeout: setTimeout, + clearTimeout: clearTimeout + }); + } + return hostRecursiveDirectoryWatcher(directoryName, callback, recursive, options); + } + function nonRecursiveWatchDirectory(directoryName, callback, recursive, options) { + ts.Debug.assert(!recursive); + var watchDirectoryOptions = updateOptionsForWatchDirectory(options); + var watchDirectoryKind = ts.Debug.checkDefined(watchDirectoryOptions.watchDirectory); + switch (watchDirectoryKind) { + case ts.WatchDirectoryKind.FixedPollingInterval: + return pollingWatchFile(directoryName, function () { return callback(directoryName); }, PollingInterval.Medium, + /*options*/ undefined); + case ts.WatchDirectoryKind.DynamicPriorityPolling: + return ensureDynamicPollingWatchFile()(directoryName, function () { return callback(directoryName); }, PollingInterval.Medium, + /*options*/ undefined); + case ts.WatchDirectoryKind.FixedChunkSizePolling: + return ensureFixedChunkSizePollingWatchFile()(directoryName, function () { return callback(directoryName); }, + /* pollingInterval */ undefined, + /*options*/ undefined); + case ts.WatchDirectoryKind.UseFsEvents: + return fsWatch(directoryName, 1 /* FileSystemEntryKind.Directory */, createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback, options, useCaseSensitiveFileNames, getCurrentDirectory), recursive, PollingInterval.Medium, ts.getFallbackOptions(watchDirectoryOptions)); + default: + ts.Debug.assertNever(watchDirectoryKind); + } + } + function updateOptionsForWatchDirectory(options) { + if (options && options.watchDirectory !== undefined) + return options; + switch (tscWatchDirectory) { + case "RecursiveDirectoryUsingFsWatchFile": + // Use polling interval based on priority when create watch using host.watchFile + return { watchDirectory: ts.WatchDirectoryKind.FixedPollingInterval }; + case "RecursiveDirectoryUsingDynamicPriorityPolling": + // Use polling interval but change the interval depending on file changes and their default polling interval + return { watchDirectory: ts.WatchDirectoryKind.DynamicPriorityPolling }; + default: + var defaultFallbackPolling = options === null || options === void 0 ? void 0 : options.fallbackPolling; + return { + watchDirectory: ts.WatchDirectoryKind.UseFsEvents, + fallbackPolling: defaultFallbackPolling !== undefined ? + defaultFallbackPolling : + undefined + }; + } + } + function pollingWatchFile(fileName, callback, pollingInterval, options) { + return createSingleWatcherPerName(pollingWatches, useCaseSensitiveFileNames, fileName, callback, function (cb) { return pollingWatchFileWorker(fileName, cb, pollingInterval, options); }); + } + function fsWatch(fileOrDirectory, entryKind, callback, recursive, fallbackPollingInterval, fallbackOptions) { + return createSingleWatcherPerName(recursive ? fsWatchesRecursive : fsWatches, useCaseSensitiveFileNames, fileOrDirectory, callback, function (cb) { return fsWatchHandlingExistenceOnHost(fileOrDirectory, entryKind, cb, recursive, fallbackPollingInterval, fallbackOptions); }); + } + function fsWatchHandlingExistenceOnHost(fileOrDirectory, entryKind, callback, recursive, fallbackPollingInterval, fallbackOptions) { + var lastDirectoryPartWithDirectorySeparator; + var lastDirectoryPart; + if (inodeWatching) { + lastDirectoryPartWithDirectorySeparator = fileOrDirectory.substring(fileOrDirectory.lastIndexOf(ts.directorySeparator)); + lastDirectoryPart = lastDirectoryPartWithDirectorySeparator.slice(ts.directorySeparator.length); + } + /** Watcher for the file system entry depending on whether it is missing or present */ + var watcher = !fileSystemEntryExists(fileOrDirectory, entryKind) ? + watchMissingFileSystemEntry() : + watchPresentFileSystemEntry(); + return { + close: function () { + // Close the watcher (either existing file system entry watcher or missing file system entry watcher) + if (watcher) { + watcher.close(); + watcher = undefined; + } + } + }; + function updateWatcher(createWatcher) { + // If watcher is not closed, update it + if (watcher) { + sysLog("sysLog:: ".concat(fileOrDirectory, ":: Changing watcher to ").concat(createWatcher === watchPresentFileSystemEntry ? "Present" : "Missing", "FileSystemEntryWatcher")); + watcher.close(); + watcher = createWatcher(); + } + } + /** + * Watch the file or directory that is currently present + * and when the watched file or directory is deleted, switch to missing file system entry watcher + */ + function watchPresentFileSystemEntry() { + if (hitSystemWatcherLimit) { + sysLog("sysLog:: ".concat(fileOrDirectory, ":: Defaulting to watchFile")); + return watchPresentFileSystemEntryWithFsWatchFile(); + } + try { + var presentWatcher = fsWatchWorker(fileOrDirectory, recursive, inodeWatching ? + callbackChangingToMissingFileSystemEntry : + callback); + // Watch the missing file or directory or error + presentWatcher.on("error", function () { + callback("rename", ""); + updateWatcher(watchMissingFileSystemEntry); + }); + return presentWatcher; + } + catch (e) { + // Catch the exception and use polling instead + // Eg. on linux the number of watches are limited and one could easily exhaust watches and the exception ENOSPC is thrown when creating watcher at that point + // so instead of throwing error, use fs.watchFile + hitSystemWatcherLimit || (hitSystemWatcherLimit = e.code === "ENOSPC"); + sysLog("sysLog:: ".concat(fileOrDirectory, ":: Changing to watchFile")); + return watchPresentFileSystemEntryWithFsWatchFile(); + } + } + function callbackChangingToMissingFileSystemEntry(event, relativeName) { + // In some scenarios, file save operation fires event with fileName.ext~ instead of fileName.ext + // To ensure we see the file going missing and coming back up (file delete and then recreated) + // and watches being updated correctly we are calling back with fileName.ext as well as fileName.ext~ + // The worst is we have fired event that was not needed but we wont miss any changes + // especially in cases where file goes missing and watches wrong inode + var originalRelativeName; + if (relativeName && ts.endsWith(relativeName, "~")) { + originalRelativeName = relativeName; + relativeName = relativeName.slice(0, relativeName.length - 1); + } + // because relativeName is not guaranteed to be correct we need to check on each rename with few combinations + // Eg on ubuntu while watching app/node_modules the relativeName is "node_modules" which is neither relative nor full path + if (event === "rename" && + (!relativeName || + relativeName === lastDirectoryPart || + ts.endsWith(relativeName, lastDirectoryPartWithDirectorySeparator))) { + var modifiedTime = getModifiedTime(fileOrDirectory) || ts.missingFileModifiedTime; + if (originalRelativeName) + callback(event, originalRelativeName, modifiedTime); + callback(event, relativeName, modifiedTime); + if (inodeWatching) { + // If this was rename event, inode has changed means we need to update watcher + updateWatcher(modifiedTime === ts.missingFileModifiedTime ? watchMissingFileSystemEntry : watchPresentFileSystemEntry); + } + else if (modifiedTime === ts.missingFileModifiedTime) { + updateWatcher(watchMissingFileSystemEntry); + } + } + else { + if (originalRelativeName) + callback(event, originalRelativeName); + callback(event, relativeName); + } + } + /** + * Watch the file or directory using fs.watchFile since fs.watch threw exception + * Eg. on linux the number of watches are limited and one could easily exhaust watches and the exception ENOSPC is thrown when creating watcher at that point + */ + function watchPresentFileSystemEntryWithFsWatchFile() { + return watchFile(fileOrDirectory, createFileWatcherCallback(callback), fallbackPollingInterval, fallbackOptions); + } + /** + * Watch the file or directory that is missing + * and switch to existing file or directory when the missing filesystem entry is created + */ + function watchMissingFileSystemEntry() { + return watchFile(fileOrDirectory, function (_fileName, eventKind, modifiedTime) { + if (eventKind === FileWatcherEventKind.Created) { + modifiedTime || (modifiedTime = getModifiedTime(fileOrDirectory) || ts.missingFileModifiedTime); + if (modifiedTime !== ts.missingFileModifiedTime) { + callback("rename", "", modifiedTime); + // Call the callback for current file or directory + // For now it could be callback for the inner directory creation, + // but just return current directory, better than current no-op + updateWatcher(watchPresentFileSystemEntry); + } + } + }, fallbackPollingInterval, fallbackOptions); + } + } + } + ts.createSystemWatchFunctions = createSystemWatchFunctions; + /** + * patch writefile to create folder before writing the file + */ + /*@internal*/ + function patchWriteFileEnsuringDirectory(sys) { + // patch writefile to create folder before writing the file + var originalWriteFile = sys.writeFile; + sys.writeFile = function (path, data, writeBom) { + return ts.writeFileEnsuringDirectories(path, data, !!writeBom, function (path, data, writeByteOrderMark) { return originalWriteFile.call(sys, path, data, writeByteOrderMark); }, function (path) { return sys.createDirectory(path); }, function (path) { return sys.directoryExists(path); }); + }; + } + ts.patchWriteFileEnsuringDirectory = patchWriteFileEnsuringDirectory; + function getNodeMajorVersion() { + if (typeof process === "undefined") { + return undefined; + } + var version = process.version; + if (!version) { + return undefined; + } + var dot = version.indexOf("."); + if (dot === -1) { + return undefined; + } + return parseInt(version.substring(1, dot)); + } + ts.getNodeMajorVersion = getNodeMajorVersion; + // TODO: GH#18217 this is used as if it's certainly defined in many places. + // eslint-disable-next-line prefer-const + ts.sys = (function () { + // NodeJS detects "\uFEFF" at the start of the string and *replaces* it with the actual + // byte order mark from the specified encoding. Using any other byte order mark does + // not actually work. + var byteOrderMarkIndicator = "\uFEFF"; + function getNodeSystem() { + var nativePattern = /^native |^\([^)]+\)$|^(internal[\\/]|[a-zA-Z0-9_\s]+(\.js)?$)/; + var _fs = require("fs"); + var _path = require("path"); + var _os = require("os"); + // crypto can be absent on reduced node installations + var _crypto; + try { + _crypto = require("crypto"); + } + catch (_a) { + _crypto = undefined; + } + var activeSession; + var profilePath = "./profile.cpuprofile"; + var Buffer = require("buffer").Buffer; + var nodeVersion = getNodeMajorVersion(); + var isNode4OrLater = nodeVersion >= 4; + var isLinuxOrMacOs = process.platform === "linux" || process.platform === "darwin"; + var platform = _os.platform(); + var useCaseSensitiveFileNames = isFileSystemCaseSensitive(); + var fsRealpath = !!_fs.realpathSync.native ? process.platform === "win32" ? fsRealPathHandlingLongPath : _fs.realpathSync.native : _fs.realpathSync; + var fsSupportsRecursiveFsWatch = isNode4OrLater && (process.platform === "win32" || process.platform === "darwin"); + var getCurrentDirectory = ts.memoize(function () { return process.cwd(); }); + var _b = createSystemWatchFunctions({ + pollingWatchFileWorker: fsWatchFileWorker, + getModifiedTime: getModifiedTime, + setTimeout: setTimeout, + clearTimeout: clearTimeout, + fsWatchWorker: fsWatchWorker, + useCaseSensitiveFileNames: useCaseSensitiveFileNames, + getCurrentDirectory: getCurrentDirectory, + fileSystemEntryExists: fileSystemEntryExists, + // Node 4.0 `fs.watch` function supports the "recursive" option on both OSX and Windows + // (ref: https://github.com/nodejs/node/pull/2649 and https://github.com/Microsoft/TypeScript/issues/4643) + fsSupportsRecursiveFsWatch: fsSupportsRecursiveFsWatch, + getAccessibleSortedChildDirectories: function (path) { return getAccessibleFileSystemEntries(path).directories; }, + realpath: realpath, + tscWatchFile: process.env.TSC_WATCHFILE, + useNonPollingWatchers: process.env.TSC_NONPOLLING_WATCHER, + tscWatchDirectory: process.env.TSC_WATCHDIRECTORY, + inodeWatching: isLinuxOrMacOs, + sysLog: sysLog, + }), watchFile = _b.watchFile, watchDirectory = _b.watchDirectory; + var nodeSystem = { + args: process.argv.slice(2), + newLine: _os.EOL, + useCaseSensitiveFileNames: useCaseSensitiveFileNames, + write: function (s) { + process.stdout.write(s); + }, + getWidthOfTerminal: function () { + return process.stdout.columns; + }, + writeOutputIsTTY: function () { + return process.stdout.isTTY; + }, + readFile: readFile, + writeFile: writeFile, + watchFile: watchFile, + watchDirectory: watchDirectory, + resolvePath: function (path) { return _path.resolve(path); }, + fileExists: fileExists, + directoryExists: directoryExists, + createDirectory: function (directoryName) { + if (!nodeSystem.directoryExists(directoryName)) { + // Wrapped in a try-catch to prevent crashing if we are in a race + // with another copy of ourselves to create the same directory + try { + _fs.mkdirSync(directoryName); + } + catch (e) { + if (e.code !== "EEXIST") { + // Failed for some other reason (access denied?); still throw + throw e; + } + } + } + }, + getExecutingFilePath: function () { + return __filename; + }, + getCurrentDirectory: getCurrentDirectory, + getDirectories: getDirectories, + getEnvironmentVariable: function (name) { + return process.env[name] || ""; + }, + readDirectory: readDirectory, + getModifiedTime: getModifiedTime, + setModifiedTime: setModifiedTime, + deleteFile: deleteFile, + createHash: _crypto ? createSHA256Hash : generateDjb2Hash, + createSHA256Hash: _crypto ? createSHA256Hash : undefined, + getMemoryUsage: function () { + if (global.gc) { + global.gc(); + } + return process.memoryUsage().heapUsed; + }, + getFileSize: function (path) { + try { + var stat = statSync(path); + if (stat === null || stat === void 0 ? void 0 : stat.isFile()) { + return stat.size; + } + } + catch ( /*ignore*/_a) { /*ignore*/ } + return 0; + }, + exit: function (exitCode) { + disableCPUProfiler(function () { return process.exit(exitCode); }); + }, + enableCPUProfiler: enableCPUProfiler, + disableCPUProfiler: disableCPUProfiler, + cpuProfilingEnabled: function () { return !!activeSession || ts.contains(process.execArgv, "--cpu-prof") || ts.contains(process.execArgv, "--prof"); }, + realpath: realpath, + debugMode: !!process.env.NODE_INSPECTOR_IPC || !!process.env.VSCODE_INSPECTOR_OPTIONS || ts.some(process.execArgv, function (arg) { return /^--(inspect|debug)(-brk)?(=\d+)?$/i.test(arg); }), + tryEnableSourceMapsForHost: function () { + try { + require("source-map-support").install(); + } + catch (_a) { + // Could not enable source maps. + } + }, + setTimeout: setTimeout, + clearTimeout: clearTimeout, + clearScreen: function () { + process.stdout.write("\x1Bc"); + }, + setBlocking: function () { + if (process.stdout && process.stdout._handle && process.stdout._handle.setBlocking) { + process.stdout._handle.setBlocking(true); + } + }, + bufferFrom: bufferFrom, + base64decode: function (input) { return bufferFrom(input, "base64").toString("utf8"); }, + base64encode: function (input) { return bufferFrom(input).toString("base64"); }, + require: function (baseDir, moduleName) { + try { + var modulePath = ts.resolveJSModule(moduleName, baseDir, nodeSystem); + return { module: require(modulePath), modulePath: modulePath, error: undefined }; + } + catch (error) { + return { module: undefined, modulePath: undefined, error: error }; + } + } + }; + return nodeSystem; + /** + * `throwIfNoEntry` was added so recently that it's not in the node types. + * This helper encapsulates the mitigating usage of `any`. + * See https://github.com/nodejs/node/pull/33716 + */ + function statSync(path) { + // throwIfNoEntry will be ignored by older versions of node + return _fs.statSync(path, { throwIfNoEntry: false }); + } + /** + * Uses the builtin inspector APIs to capture a CPU profile + * See https://nodejs.org/api/inspector.html#inspector_example_usage for details + */ + function enableCPUProfiler(path, cb) { + if (activeSession) { + cb(); + return false; + } + var inspector = require("inspector"); + if (!inspector || !inspector.Session) { + cb(); + return false; + } + var session = new inspector.Session(); + session.connect(); + session.post("Profiler.enable", function () { + session.post("Profiler.start", function () { + activeSession = session; + profilePath = path; + cb(); + }); + }); + return true; + } + /** + * Strips non-TS paths from the profile, so users with private projects shouldn't + * need to worry about leaking paths by submitting a cpu profile to us + */ + function cleanupPaths(profile) { + var externalFileCounter = 0; + var remappedPaths = new ts.Map(); + var normalizedDir = ts.normalizeSlashes(__dirname); + // Windows rooted dir names need an extra `/` prepended to be valid file:/// urls + var fileUrlRoot = "file://".concat(ts.getRootLength(normalizedDir) === 1 ? "" : "/").concat(normalizedDir); + for (var _i = 0, _a = profile.nodes; _i < _a.length; _i++) { + var node = _a[_i]; + if (node.callFrame.url) { + var url = ts.normalizeSlashes(node.callFrame.url); + if (ts.containsPath(fileUrlRoot, url, useCaseSensitiveFileNames)) { + node.callFrame.url = ts.getRelativePathToDirectoryOrUrl(fileUrlRoot, url, fileUrlRoot, ts.createGetCanonicalFileName(useCaseSensitiveFileNames), /*isAbsolutePathAnUrl*/ true); + } + else if (!nativePattern.test(url)) { + node.callFrame.url = (remappedPaths.has(url) ? remappedPaths : remappedPaths.set(url, "external".concat(externalFileCounter, ".js"))).get(url); + externalFileCounter++; + } + } + } + return profile; + } + function disableCPUProfiler(cb) { + if (activeSession && activeSession !== "stopping") { + var s_1 = activeSession; + activeSession.post("Profiler.stop", function (err, _a) { + var _b; + var profile = _a.profile; + if (!err) { + try { + if ((_b = statSync(profilePath)) === null || _b === void 0 ? void 0 : _b.isDirectory()) { + profilePath = _path.join(profilePath, "".concat((new Date()).toISOString().replace(/:/g, "-"), "+P").concat(process.pid, ".cpuprofile")); + } + } + catch (_c) { + // do nothing and ignore fallible fs operation + } + try { + _fs.mkdirSync(_path.dirname(profilePath), { recursive: true }); + } + catch (_d) { + // do nothing and ignore fallible fs operation + } + _fs.writeFileSync(profilePath, JSON.stringify(cleanupPaths(profile))); + } + activeSession = undefined; + s_1.disconnect(); + cb(); + }); + activeSession = "stopping"; + return true; + } + else { + cb(); + return false; + } + } + function bufferFrom(input, encoding) { + // See https://github.com/Microsoft/TypeScript/issues/25652 + return Buffer.from && Buffer.from !== Int8Array.from + ? Buffer.from(input, encoding) + : new Buffer(input, encoding); + } + function isFileSystemCaseSensitive() { + // win32\win64 are case insensitive platforms + if (platform === "win32" || platform === "win64") { + return false; + } + // If this file exists under a different case, we must be case-insensitve. + return !fileExists(swapCase(__filename)); + } + /** Convert all lowercase chars to uppercase, and vice-versa */ + function swapCase(s) { + return s.replace(/\w/g, function (ch) { + var up = ch.toUpperCase(); + return ch === up ? ch.toLowerCase() : up; + }); + } + function fsWatchFileWorker(fileName, callback, pollingInterval) { + _fs.watchFile(fileName, { persistent: true, interval: pollingInterval }, fileChanged); + var eventKind; + return { + close: function () { return _fs.unwatchFile(fileName, fileChanged); } + }; + function fileChanged(curr, prev) { + // previous event kind check is to ensure we recongnize the file as previously also missing when it is restored or renamed twice (that is it disappears and reappears) + // In such case, prevTime returned is same as prev time of event when file was deleted as per node documentation + var isPreviouslyDeleted = +prev.mtime === 0 || eventKind === FileWatcherEventKind.Deleted; + if (+curr.mtime === 0) { + if (isPreviouslyDeleted) { + // Already deleted file, no need to callback again + return; + } + eventKind = FileWatcherEventKind.Deleted; + } + else if (isPreviouslyDeleted) { + eventKind = FileWatcherEventKind.Created; + } + // If there is no change in modified time, ignore the event + else if (+curr.mtime === +prev.mtime) { + return; + } + else { + // File changed + eventKind = FileWatcherEventKind.Changed; + } + callback(fileName, eventKind, curr.mtime); + } + } + function fsWatchWorker(fileOrDirectory, recursive, callback) { + // Node 4.0 `fs.watch` function supports the "recursive" option on both OSX and Windows + // (ref: https://github.com/nodejs/node/pull/2649 and https://github.com/Microsoft/TypeScript/issues/4643) + return _fs.watch(fileOrDirectory, fsSupportsRecursiveFsWatch ? + { persistent: true, recursive: !!recursive } : { persistent: true }, callback); + } + function readFileWorker(fileName, _encoding) { + var buffer; + try { + buffer = _fs.readFileSync(fileName); + } + catch (e) { + return undefined; + } + var len = buffer.length; + if (len >= 2 && buffer[0] === 0xFE && buffer[1] === 0xFF) { + // Big endian UTF-16 byte order mark detected. Since big endian is not supported by node.js, + // flip all byte pairs and treat as little endian. + len &= ~1; // Round down to a multiple of 2 + for (var i = 0; i < len; i += 2) { + var temp = buffer[i]; + buffer[i] = buffer[i + 1]; + buffer[i + 1] = temp; + } + return buffer.toString("utf16le", 2); + } + if (len >= 2 && buffer[0] === 0xFF && buffer[1] === 0xFE) { + // Little endian UTF-16 byte order mark detected + return buffer.toString("utf16le", 2); + } + if (len >= 3 && buffer[0] === 0xEF && buffer[1] === 0xBB && buffer[2] === 0xBF) { + // UTF-8 byte order mark detected + return buffer.toString("utf8", 3); + } + // Default is UTF-8 with no byte order mark + return buffer.toString("utf8"); + } + function readFile(fileName, _encoding) { + ts.perfLogger.logStartReadFile(fileName); + var file = readFileWorker(fileName, _encoding); + ts.perfLogger.logStopReadFile(); + return file; + } + function writeFile(fileName, data, writeByteOrderMark) { + ts.perfLogger.logEvent("WriteFile: " + fileName); + // If a BOM is required, emit one + if (writeByteOrderMark) { + data = byteOrderMarkIndicator + data; + } + var fd; + try { + fd = _fs.openSync(fileName, "w"); + _fs.writeSync(fd, data, /*position*/ undefined, "utf8"); + } + finally { + if (fd !== undefined) { + _fs.closeSync(fd); + } + } + } + function getAccessibleFileSystemEntries(path) { + ts.perfLogger.logEvent("ReadDir: " + (path || ".")); + try { + var entries = _fs.readdirSync(path || ".", { withFileTypes: true }); + var files = []; + var directories = []; + for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) { + var dirent = entries_1[_i]; + // withFileTypes is not supported before Node 10.10. + var entry = typeof dirent === "string" ? dirent : dirent.name; + // This is necessary because on some file system node fails to exclude + // "." and "..". See https://github.com/nodejs/node/issues/4002 + if (entry === "." || entry === "..") { + continue; + } + var stat = void 0; + if (typeof dirent === "string" || dirent.isSymbolicLink()) { + var name = ts.combinePaths(path, entry); + try { + stat = statSync(name); + if (!stat) { + continue; + } + } + catch (e) { + continue; + } + } + else { + stat = dirent; + } + if (stat.isFile()) { + files.push(entry); + } + else if (stat.isDirectory()) { + directories.push(entry); + } + } + files.sort(); + directories.sort(); + return { files: files, directories: directories }; + } + catch (e) { + return ts.emptyFileSystemEntries; + } + } + function readDirectory(path, extensions, excludes, includes, depth) { + return ts.matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames, process.cwd(), depth, getAccessibleFileSystemEntries, realpath); + } + function fileSystemEntryExists(path, entryKind) { + // Since the error thrown by fs.statSync isn't used, we can avoid collecting a stack trace to improve + // the CPU time performance. + var originalStackTraceLimit = Error.stackTraceLimit; + Error.stackTraceLimit = 0; + try { + var stat = statSync(path); + if (!stat) { + return false; + } + switch (entryKind) { + case 0 /* FileSystemEntryKind.File */: return stat.isFile(); + case 1 /* FileSystemEntryKind.Directory */: return stat.isDirectory(); + default: return false; + } + } + catch (e) { + return false; + } + finally { + Error.stackTraceLimit = originalStackTraceLimit; + } + } + function fileExists(path) { + return fileSystemEntryExists(path, 0 /* FileSystemEntryKind.File */); + } + function directoryExists(path) { + return fileSystemEntryExists(path, 1 /* FileSystemEntryKind.Directory */); + } + function getDirectories(path) { + return getAccessibleFileSystemEntries(path).directories.slice(); + } + function fsRealPathHandlingLongPath(path) { + return path.length < 260 ? _fs.realpathSync.native(path) : _fs.realpathSync(path); + } + function realpath(path) { + try { + return fsRealpath(path); + } + catch (_a) { + return path; + } + } + function getModifiedTime(path) { + var _a; + // Since the error thrown by fs.statSync isn't used, we can avoid collecting a stack trace to improve + // the CPU time performance. + var originalStackTraceLimit = Error.stackTraceLimit; + Error.stackTraceLimit = 0; + try { + return (_a = statSync(path)) === null || _a === void 0 ? void 0 : _a.mtime; + } + catch (e) { + return undefined; + } + finally { + Error.stackTraceLimit = originalStackTraceLimit; + } + } + function setModifiedTime(path, time) { + try { + _fs.utimesSync(path, time, time); + } + catch (e) { + return; + } + } + function deleteFile(path) { + try { + return _fs.unlinkSync(path); + } + catch (e) { + return; + } + } + function createSHA256Hash(data) { + var hash = _crypto.createHash("sha256"); + hash.update(data); + return hash.digest("hex"); + } + } + var sys; + if (typeof process !== "undefined" && process.nextTick && !process.browser && typeof require !== "undefined") { + // process and process.nextTick checks if current environment is node-like + // process.browser check excludes webpack and browserify + sys = getNodeSystem(); + } + if (sys) { + // patch writefile to create folder before writing the file + patchWriteFileEnsuringDirectory(sys); + } + return sys; + })(); + /*@internal*/ + function setSys(s) { + ts.sys = s; + } + ts.setSys = setSys; + if (ts.sys && ts.sys.getEnvironmentVariable) { + setCustomPollingValues(ts.sys); + ts.Debug.setAssertionLevel(/^development$/i.test(ts.sys.getEnvironmentVariable("NODE_ENV")) + ? 1 /* AssertionLevel.Normal */ + : 0 /* AssertionLevel.None */); + } + if (ts.sys && ts.sys.debugMode) { + ts.Debug.isDebugging = true; + } +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + /** + * Internally, we represent paths as strings with '/' as the directory separator. + * When we make system calls (eg: LanguageServiceHost.getDirectory()), + * we expect the host to correctly handle paths in our specified format. + */ + ts.directorySeparator = "/"; + ts.altDirectorySeparator = "\\"; + var urlSchemeSeparator = "://"; + var backslashRegExp = /\\/g; + //// Path Tests + /** + * Determines whether a charCode corresponds to `/` or `\`. + */ + function isAnyDirectorySeparator(charCode) { + return charCode === 47 /* CharacterCodes.slash */ || charCode === 92 /* CharacterCodes.backslash */; + } + ts.isAnyDirectorySeparator = isAnyDirectorySeparator; + /** + * Determines whether a path starts with a URL scheme (e.g. starts with `http://`, `ftp://`, `file://`, etc.). + */ + function isUrl(path) { + return getEncodedRootLength(path) < 0; + } + ts.isUrl = isUrl; + /** + * Determines whether a path is an absolute disk path (e.g. starts with `/`, or a dos path + * like `c:`, `c:\` or `c:/`). + */ + function isRootedDiskPath(path) { + return getEncodedRootLength(path) > 0; + } + ts.isRootedDiskPath = isRootedDiskPath; + /** + * Determines whether a path consists only of a path root. + */ + function isDiskPathRoot(path) { + var rootLength = getEncodedRootLength(path); + return rootLength > 0 && rootLength === path.length; + } + ts.isDiskPathRoot = isDiskPathRoot; + /** + * Determines whether a path starts with an absolute path component (i.e. `/`, `c:/`, `file://`, etc.). + * + * ```ts + * // POSIX + * pathIsAbsolute("/path/to/file.ext") === true + * // DOS + * pathIsAbsolute("c:/path/to/file.ext") === true + * // URL + * pathIsAbsolute("file:///path/to/file.ext") === true + * // Non-absolute + * pathIsAbsolute("path/to/file.ext") === false + * pathIsAbsolute("./path/to/file.ext") === false + * ``` + */ + function pathIsAbsolute(path) { + return getEncodedRootLength(path) !== 0; + } + ts.pathIsAbsolute = pathIsAbsolute; + /** + * Determines whether a path starts with a relative path component (i.e. `.` or `..`). + */ + function pathIsRelative(path) { + return /^\.\.?($|[\\/])/.test(path); + } + ts.pathIsRelative = pathIsRelative; + /** + * Determines whether a path is neither relative nor absolute, e.g. "path/to/file". + * Also known misleadingly as "non-relative". + */ + function pathIsBareSpecifier(path) { + return !pathIsAbsolute(path) && !pathIsRelative(path); + } + ts.pathIsBareSpecifier = pathIsBareSpecifier; + function hasExtension(fileName) { + return ts.stringContains(getBaseFileName(fileName), "."); + } + ts.hasExtension = hasExtension; + function fileExtensionIs(path, extension) { + return path.length > extension.length && ts.endsWith(path, extension); + } + ts.fileExtensionIs = fileExtensionIs; + function fileExtensionIsOneOf(path, extensions) { + for (var _i = 0, extensions_1 = extensions; _i < extensions_1.length; _i++) { + var extension = extensions_1[_i]; + if (fileExtensionIs(path, extension)) { + return true; + } + } + return false; + } + ts.fileExtensionIsOneOf = fileExtensionIsOneOf; + /** + * Determines whether a path has a trailing separator (`/` or `\\`). + */ + function hasTrailingDirectorySeparator(path) { + return path.length > 0 && isAnyDirectorySeparator(path.charCodeAt(path.length - 1)); + } + ts.hasTrailingDirectorySeparator = hasTrailingDirectorySeparator; + //// Path Parsing + function isVolumeCharacter(charCode) { + return (charCode >= 97 /* CharacterCodes.a */ && charCode <= 122 /* CharacterCodes.z */) || + (charCode >= 65 /* CharacterCodes.A */ && charCode <= 90 /* CharacterCodes.Z */); + } + function getFileUrlVolumeSeparatorEnd(url, start) { + var ch0 = url.charCodeAt(start); + if (ch0 === 58 /* CharacterCodes.colon */) + return start + 1; + if (ch0 === 37 /* CharacterCodes.percent */ && url.charCodeAt(start + 1) === 51 /* CharacterCodes._3 */) { + var ch2 = url.charCodeAt(start + 2); + if (ch2 === 97 /* CharacterCodes.a */ || ch2 === 65 /* CharacterCodes.A */) + return start + 3; + } + return -1; + } + /** + * Returns length of the root part of a path or URL (i.e. length of "/", "x:/", "//server/share/, file:///user/files"). + * If the root is part of a URL, the twos-complement of the root length is returned. + */ + function getEncodedRootLength(path) { + if (!path) + return 0; + var ch0 = path.charCodeAt(0); + // POSIX or UNC + if (ch0 === 47 /* CharacterCodes.slash */ || ch0 === 92 /* CharacterCodes.backslash */) { + if (path.charCodeAt(1) !== ch0) + return 1; // POSIX: "/" (or non-normalized "\") + var p1 = path.indexOf(ch0 === 47 /* CharacterCodes.slash */ ? ts.directorySeparator : ts.altDirectorySeparator, 2); + if (p1 < 0) + return path.length; // UNC: "//server" or "\\server" + return p1 + 1; // UNC: "//server/" or "\\server\" + } + // DOS + if (isVolumeCharacter(ch0) && path.charCodeAt(1) === 58 /* CharacterCodes.colon */) { + var ch2 = path.charCodeAt(2); + if (ch2 === 47 /* CharacterCodes.slash */ || ch2 === 92 /* CharacterCodes.backslash */) + return 3; // DOS: "c:/" or "c:\" + if (path.length === 2) + return 2; // DOS: "c:" (but not "c:d") + } + // URL + var schemeEnd = path.indexOf(urlSchemeSeparator); + if (schemeEnd !== -1) { + var authorityStart = schemeEnd + urlSchemeSeparator.length; + var authorityEnd = path.indexOf(ts.directorySeparator, authorityStart); + if (authorityEnd !== -1) { // URL: "file:///", "file://server/", "file://server/path" + // For local "file" URLs, include the leading DOS volume (if present). + // Per https://www.ietf.org/rfc/rfc1738.txt, a host of "" or "localhost" is a + // special case interpreted as "the machine from which the URL is being interpreted". + var scheme = path.slice(0, schemeEnd); + var authority = path.slice(authorityStart, authorityEnd); + if (scheme === "file" && (authority === "" || authority === "localhost") && + isVolumeCharacter(path.charCodeAt(authorityEnd + 1))) { + var volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path, authorityEnd + 2); + if (volumeSeparatorEnd !== -1) { + if (path.charCodeAt(volumeSeparatorEnd) === 47 /* CharacterCodes.slash */) { + // URL: "file:///c:/", "file://localhost/c:/", "file:///c%3a/", "file://localhost/c%3a/" + return ~(volumeSeparatorEnd + 1); + } + if (volumeSeparatorEnd === path.length) { + // URL: "file:///c:", "file://localhost/c:", "file:///c$3a", "file://localhost/c%3a" + // but not "file:///c:d" or "file:///c%3ad" + return ~volumeSeparatorEnd; + } + } + } + return ~(authorityEnd + 1); // URL: "file://server/", "http://server/" + } + return ~path.length; // URL: "file://server", "http://server" + } + // relative + return 0; + } + /** + * Returns length of the root part of a path or URL (i.e. length of "/", "x:/", "//server/share/, file:///user/files"). + * + * For example: + * ```ts + * getRootLength("a") === 0 // "" + * getRootLength("/") === 1 // "/" + * getRootLength("c:") === 2 // "c:" + * getRootLength("c:d") === 0 // "" + * getRootLength("c:/") === 3 // "c:/" + * getRootLength("c:\\") === 3 // "c:\\" + * getRootLength("//server") === 7 // "//server" + * getRootLength("//server/share") === 8 // "//server/" + * getRootLength("\\\\server") === 7 // "\\\\server" + * getRootLength("\\\\server\\share") === 8 // "\\\\server\\" + * getRootLength("file:///path") === 8 // "file:///" + * getRootLength("file:///c:") === 10 // "file:///c:" + * getRootLength("file:///c:d") === 8 // "file:///" + * getRootLength("file:///c:/path") === 11 // "file:///c:/" + * getRootLength("file://server") === 13 // "file://server" + * getRootLength("file://server/path") === 14 // "file://server/" + * getRootLength("http://server") === 13 // "http://server" + * getRootLength("http://server/path") === 14 // "http://server/" + * ``` + */ + function getRootLength(path) { + var rootLength = getEncodedRootLength(path); + return rootLength < 0 ? ~rootLength : rootLength; + } + ts.getRootLength = getRootLength; + function getDirectoryPath(path) { + path = normalizeSlashes(path); + // If the path provided is itself the root, then return it. + var rootLength = getRootLength(path); + if (rootLength === path.length) + return path; + // return the leading portion of the path up to the last (non-terminal) directory separator + // but not including any trailing directory separator. + path = removeTrailingDirectorySeparator(path); + return path.slice(0, Math.max(rootLength, path.lastIndexOf(ts.directorySeparator))); + } + ts.getDirectoryPath = getDirectoryPath; + function getBaseFileName(path, extensions, ignoreCase) { + path = normalizeSlashes(path); + // if the path provided is itself the root, then it has not file name. + var rootLength = getRootLength(path); + if (rootLength === path.length) + return ""; + // return the trailing portion of the path starting after the last (non-terminal) directory + // separator but not including any trailing directory separator. + path = removeTrailingDirectorySeparator(path); + var name = path.slice(Math.max(getRootLength(path), path.lastIndexOf(ts.directorySeparator) + 1)); + var extension = extensions !== undefined && ignoreCase !== undefined ? getAnyExtensionFromPath(name, extensions, ignoreCase) : undefined; + return extension ? name.slice(0, name.length - extension.length) : name; + } + ts.getBaseFileName = getBaseFileName; + function tryGetExtensionFromPath(path, extension, stringEqualityComparer) { + if (!ts.startsWith(extension, ".")) + extension = "." + extension; + if (path.length >= extension.length && path.charCodeAt(path.length - extension.length) === 46 /* CharacterCodes.dot */) { + var pathExtension = path.slice(path.length - extension.length); + if (stringEqualityComparer(pathExtension, extension)) { + return pathExtension; + } + } + } + function getAnyExtensionFromPathWorker(path, extensions, stringEqualityComparer) { + if (typeof extensions === "string") { + return tryGetExtensionFromPath(path, extensions, stringEqualityComparer) || ""; + } + for (var _i = 0, extensions_2 = extensions; _i < extensions_2.length; _i++) { + var extension = extensions_2[_i]; + var result = tryGetExtensionFromPath(path, extension, stringEqualityComparer); + if (result) + return result; + } + return ""; + } + function getAnyExtensionFromPath(path, extensions, ignoreCase) { + // Retrieves any string from the final "." onwards from a base file name. + // Unlike extensionFromPath, which throws an exception on unrecognized extensions. + if (extensions) { + return getAnyExtensionFromPathWorker(removeTrailingDirectorySeparator(path), extensions, ignoreCase ? ts.equateStringsCaseInsensitive : ts.equateStringsCaseSensitive); + } + var baseFileName = getBaseFileName(path); + var extensionIndex = baseFileName.lastIndexOf("."); + if (extensionIndex >= 0) { + return baseFileName.substring(extensionIndex); + } + return ""; + } + ts.getAnyExtensionFromPath = getAnyExtensionFromPath; + function pathComponents(path, rootLength) { + var root = path.substring(0, rootLength); + var rest = path.substring(rootLength).split(ts.directorySeparator); + if (rest.length && !ts.lastOrUndefined(rest)) + rest.pop(); + return __spreadArray([root], rest, true); + } + /** + * Parse a path into an array containing a root component (at index 0) and zero or more path + * components (at indices > 0). The result is not normalized. + * If the path is relative, the root component is `""`. + * If the path is absolute, the root component includes the first path separator (`/`). + * + * ```ts + * // POSIX + * getPathComponents("/path/to/file.ext") === ["/", "path", "to", "file.ext"] + * getPathComponents("/path/to/") === ["/", "path", "to"] + * getPathComponents("/") === ["/"] + * // DOS + * getPathComponents("c:/path/to/file.ext") === ["c:/", "path", "to", "file.ext"] + * getPathComponents("c:/path/to/") === ["c:/", "path", "to"] + * getPathComponents("c:/") === ["c:/"] + * getPathComponents("c:") === ["c:"] + * // URL + * getPathComponents("http://typescriptlang.org/path/to/file.ext") === ["http://typescriptlang.org/", "path", "to", "file.ext"] + * getPathComponents("http://typescriptlang.org/path/to/") === ["http://typescriptlang.org/", "path", "to"] + * getPathComponents("http://typescriptlang.org/") === ["http://typescriptlang.org/"] + * getPathComponents("http://typescriptlang.org") === ["http://typescriptlang.org"] + * getPathComponents("file://server/path/to/file.ext") === ["file://server/", "path", "to", "file.ext"] + * getPathComponents("file://server/path/to/") === ["file://server/", "path", "to"] + * getPathComponents("file://server/") === ["file://server/"] + * getPathComponents("file://server") === ["file://server"] + * getPathComponents("file:///path/to/file.ext") === ["file:///", "path", "to", "file.ext"] + * getPathComponents("file:///path/to/") === ["file:///", "path", "to"] + * getPathComponents("file:///") === ["file:///"] + * getPathComponents("file://") === ["file://"] + */ + function getPathComponents(path, currentDirectory) { + if (currentDirectory === void 0) { currentDirectory = ""; } + path = combinePaths(currentDirectory, path); + return pathComponents(path, getRootLength(path)); + } + ts.getPathComponents = getPathComponents; + //// Path Formatting + /** + * Formats a parsed path consisting of a root component (at index 0) and zero or more path + * segments (at indices > 0). + * + * ```ts + * getPathFromPathComponents(["/", "path", "to", "file.ext"]) === "/path/to/file.ext" + * ``` + */ + function getPathFromPathComponents(pathComponents) { + if (pathComponents.length === 0) + return ""; + var root = pathComponents[0] && ensureTrailingDirectorySeparator(pathComponents[0]); + return root + pathComponents.slice(1).join(ts.directorySeparator); + } + ts.getPathFromPathComponents = getPathFromPathComponents; + //// Path Normalization + /** + * Normalize path separators, converting `\` into `/`. + */ + function normalizeSlashes(path) { + return path.indexOf("\\") !== -1 + ? path.replace(backslashRegExp, ts.directorySeparator) + : path; + } + ts.normalizeSlashes = normalizeSlashes; + /** + * Reduce an array of path components to a more simplified path by navigating any + * `"."` or `".."` entries in the path. + */ + function reducePathComponents(components) { + if (!ts.some(components)) + return []; + var reduced = [components[0]]; + for (var i = 1; i < components.length; i++) { + var component = components[i]; + if (!component) + continue; + if (component === ".") + continue; + if (component === "..") { + if (reduced.length > 1) { + if (reduced[reduced.length - 1] !== "..") { + reduced.pop(); + continue; + } + } + else if (reduced[0]) + continue; + } + reduced.push(component); + } + return reduced; + } + ts.reducePathComponents = reducePathComponents; + /** + * Combines paths. If a path is absolute, it replaces any previous path. Relative paths are not simplified. + * + * ```ts + * // Non-rooted + * combinePaths("path", "to", "file.ext") === "path/to/file.ext" + * combinePaths("path", "dir", "..", "to", "file.ext") === "path/dir/../to/file.ext" + * // POSIX + * combinePaths("/path", "to", "file.ext") === "/path/to/file.ext" + * combinePaths("/path", "/to", "file.ext") === "/to/file.ext" + * // DOS + * combinePaths("c:/path", "to", "file.ext") === "c:/path/to/file.ext" + * combinePaths("c:/path", "c:/to", "file.ext") === "c:/to/file.ext" + * // URL + * combinePaths("file:///path", "to", "file.ext") === "file:///path/to/file.ext" + * combinePaths("file:///path", "file:///to", "file.ext") === "file:///to/file.ext" + * ``` + */ + function combinePaths(path) { + var paths = []; + for (var _i = 1; _i < arguments.length; _i++) { + paths[_i - 1] = arguments[_i]; + } + if (path) + path = normalizeSlashes(path); + for (var _a = 0, paths_1 = paths; _a < paths_1.length; _a++) { + var relativePath = paths_1[_a]; + if (!relativePath) + continue; + relativePath = normalizeSlashes(relativePath); + if (!path || getRootLength(relativePath) !== 0) { + path = relativePath; + } + else { + path = ensureTrailingDirectorySeparator(path) + relativePath; + } + } + return path; + } + ts.combinePaths = combinePaths; + /** + * Combines and resolves paths. If a path is absolute, it replaces any previous path. Any + * `.` and `..` path components are resolved. Trailing directory separators are preserved. + * + * ```ts + * resolvePath("/path", "to", "file.ext") === "path/to/file.ext" + * resolvePath("/path", "to", "file.ext/") === "path/to/file.ext/" + * resolvePath("/path", "dir", "..", "to", "file.ext") === "path/to/file.ext" + * ``` + */ + function resolvePath(path) { + var paths = []; + for (var _i = 1; _i < arguments.length; _i++) { + paths[_i - 1] = arguments[_i]; + } + return normalizePath(ts.some(paths) ? combinePaths.apply(void 0, __spreadArray([path], paths, false)) : normalizeSlashes(path)); + } + ts.resolvePath = resolvePath; + /** + * Parse a path into an array containing a root component (at index 0) and zero or more path + * components (at indices > 0). The result is normalized. + * If the path is relative, the root component is `""`. + * If the path is absolute, the root component includes the first path separator (`/`). + * + * ```ts + * getNormalizedPathComponents("to/dir/../file.ext", "/path/") === ["/", "path", "to", "file.ext"] + * ``` + */ + function getNormalizedPathComponents(path, currentDirectory) { + return reducePathComponents(getPathComponents(path, currentDirectory)); + } + ts.getNormalizedPathComponents = getNormalizedPathComponents; + function getNormalizedAbsolutePath(fileName, currentDirectory) { + return getPathFromPathComponents(getNormalizedPathComponents(fileName, currentDirectory)); + } + ts.getNormalizedAbsolutePath = getNormalizedAbsolutePath; + function normalizePath(path) { + path = normalizeSlashes(path); + // Most paths don't require normalization + if (!relativePathSegmentRegExp.test(path)) { + return path; + } + // Some paths only require cleanup of `/./` or leading `./` + var simplified = path.replace(/\/\.\//g, "/").replace(/^\.\//, ""); + if (simplified !== path) { + path = simplified; + if (!relativePathSegmentRegExp.test(path)) { + return path; + } + } + // Other paths require full normalization + var normalized = getPathFromPathComponents(reducePathComponents(getPathComponents(path))); + return normalized && hasTrailingDirectorySeparator(path) ? ensureTrailingDirectorySeparator(normalized) : normalized; + } + ts.normalizePath = normalizePath; + function getPathWithoutRoot(pathComponents) { + if (pathComponents.length === 0) + return ""; + return pathComponents.slice(1).join(ts.directorySeparator); + } + function getNormalizedAbsolutePathWithoutRoot(fileName, currentDirectory) { + return getPathWithoutRoot(getNormalizedPathComponents(fileName, currentDirectory)); + } + ts.getNormalizedAbsolutePathWithoutRoot = getNormalizedAbsolutePathWithoutRoot; + function toPath(fileName, basePath, getCanonicalFileName) { + var nonCanonicalizedPath = isRootedDiskPath(fileName) + ? normalizePath(fileName) + : getNormalizedAbsolutePath(fileName, basePath); + return getCanonicalFileName(nonCanonicalizedPath); + } + ts.toPath = toPath; + function removeTrailingDirectorySeparator(path) { + if (hasTrailingDirectorySeparator(path)) { + return path.substr(0, path.length - 1); + } + return path; + } + ts.removeTrailingDirectorySeparator = removeTrailingDirectorySeparator; + function ensureTrailingDirectorySeparator(path) { + if (!hasTrailingDirectorySeparator(path)) { + return path + ts.directorySeparator; + } + return path; + } + ts.ensureTrailingDirectorySeparator = ensureTrailingDirectorySeparator; + /** + * Ensures a path is either absolute (prefixed with `/` or `c:`) or dot-relative (prefixed + * with `./` or `../`) so as not to be confused with an unprefixed module name. + * + * ```ts + * ensurePathIsNonModuleName("/path/to/file.ext") === "/path/to/file.ext" + * ensurePathIsNonModuleName("./path/to/file.ext") === "./path/to/file.ext" + * ensurePathIsNonModuleName("../path/to/file.ext") === "../path/to/file.ext" + * ensurePathIsNonModuleName("path/to/file.ext") === "./path/to/file.ext" + * ``` + */ + function ensurePathIsNonModuleName(path) { + return !pathIsAbsolute(path) && !pathIsRelative(path) ? "./" + path : path; + } + ts.ensurePathIsNonModuleName = ensurePathIsNonModuleName; + function changeAnyExtension(path, ext, extensions, ignoreCase) { + var pathext = extensions !== undefined && ignoreCase !== undefined ? getAnyExtensionFromPath(path, extensions, ignoreCase) : getAnyExtensionFromPath(path); + return pathext ? path.slice(0, path.length - pathext.length) + (ts.startsWith(ext, ".") ? ext : "." + ext) : path; + } + ts.changeAnyExtension = changeAnyExtension; + //// Path Comparisons + // check path for these segments: '', '.'. '..' + var relativePathSegmentRegExp = /(?:\/\/)|(?:^|\/)\.\.?(?:$|\/)/; + function comparePathsWorker(a, b, componentComparer) { + if (a === b) + return 0 /* Comparison.EqualTo */; + if (a === undefined) + return -1 /* Comparison.LessThan */; + if (b === undefined) + return 1 /* Comparison.GreaterThan */; + // NOTE: Performance optimization - shortcut if the root segments differ as there would be no + // need to perform path reduction. + var aRoot = a.substring(0, getRootLength(a)); + var bRoot = b.substring(0, getRootLength(b)); + var result = ts.compareStringsCaseInsensitive(aRoot, bRoot); + if (result !== 0 /* Comparison.EqualTo */) { + return result; + } + // NOTE: Performance optimization - shortcut if there are no relative path segments in + // the non-root portion of the path + var aRest = a.substring(aRoot.length); + var bRest = b.substring(bRoot.length); + if (!relativePathSegmentRegExp.test(aRest) && !relativePathSegmentRegExp.test(bRest)) { + return componentComparer(aRest, bRest); + } + // The path contains a relative path segment. Normalize the paths and perform a slower component + // by component comparison. + var aComponents = reducePathComponents(getPathComponents(a)); + var bComponents = reducePathComponents(getPathComponents(b)); + var sharedLength = Math.min(aComponents.length, bComponents.length); + for (var i = 1; i < sharedLength; i++) { + var result_2 = componentComparer(aComponents[i], bComponents[i]); + if (result_2 !== 0 /* Comparison.EqualTo */) { + return result_2; + } + } + return ts.compareValues(aComponents.length, bComponents.length); + } + /** + * Performs a case-sensitive comparison of two paths. Path roots are always compared case-insensitively. + */ + function comparePathsCaseSensitive(a, b) { + return comparePathsWorker(a, b, ts.compareStringsCaseSensitive); + } + ts.comparePathsCaseSensitive = comparePathsCaseSensitive; + /** + * Performs a case-insensitive comparison of two paths. + */ + function comparePathsCaseInsensitive(a, b) { + return comparePathsWorker(a, b, ts.compareStringsCaseInsensitive); + } + ts.comparePathsCaseInsensitive = comparePathsCaseInsensitive; + function comparePaths(a, b, currentDirectory, ignoreCase) { + if (typeof currentDirectory === "string") { + a = combinePaths(currentDirectory, a); + b = combinePaths(currentDirectory, b); + } + else if (typeof currentDirectory === "boolean") { + ignoreCase = currentDirectory; + } + return comparePathsWorker(a, b, ts.getStringComparer(ignoreCase)); + } + ts.comparePaths = comparePaths; + function containsPath(parent, child, currentDirectory, ignoreCase) { + if (typeof currentDirectory === "string") { + parent = combinePaths(currentDirectory, parent); + child = combinePaths(currentDirectory, child); + } + else if (typeof currentDirectory === "boolean") { + ignoreCase = currentDirectory; + } + if (parent === undefined || child === undefined) + return false; + if (parent === child) + return true; + var parentComponents = reducePathComponents(getPathComponents(parent)); + var childComponents = reducePathComponents(getPathComponents(child)); + if (childComponents.length < parentComponents.length) { + return false; + } + var componentEqualityComparer = ignoreCase ? ts.equateStringsCaseInsensitive : ts.equateStringsCaseSensitive; + for (var i = 0; i < parentComponents.length; i++) { + var equalityComparer = i === 0 ? ts.equateStringsCaseInsensitive : componentEqualityComparer; + if (!equalityComparer(parentComponents[i], childComponents[i])) { + return false; + } + } + return true; + } + ts.containsPath = containsPath; + /** + * Determines whether `fileName` starts with the specified `directoryName` using the provided path canonicalization callback. + * Comparison is case-sensitive between the canonical paths. + * + * Use `containsPath` if file names are not already reduced and absolute. + */ + function startsWithDirectory(fileName, directoryName, getCanonicalFileName) { + var canonicalFileName = getCanonicalFileName(fileName); + var canonicalDirectoryName = getCanonicalFileName(directoryName); + return ts.startsWith(canonicalFileName, canonicalDirectoryName + "/") || ts.startsWith(canonicalFileName, canonicalDirectoryName + "\\"); + } + ts.startsWithDirectory = startsWithDirectory; + //// Relative Paths + function getPathComponentsRelativeTo(from, to, stringEqualityComparer, getCanonicalFileName) { + var fromComponents = reducePathComponents(getPathComponents(from)); + var toComponents = reducePathComponents(getPathComponents(to)); + var start; + for (start = 0; start < fromComponents.length && start < toComponents.length; start++) { + var fromComponent = getCanonicalFileName(fromComponents[start]); + var toComponent = getCanonicalFileName(toComponents[start]); + var comparer = start === 0 ? ts.equateStringsCaseInsensitive : stringEqualityComparer; + if (!comparer(fromComponent, toComponent)) + break; + } + if (start === 0) { + return toComponents; + } + var components = toComponents.slice(start); + var relative = []; + for (; start < fromComponents.length; start++) { + relative.push(".."); + } + return __spreadArray(__spreadArray([""], relative, true), components, true); + } + ts.getPathComponentsRelativeTo = getPathComponentsRelativeTo; + function getRelativePathFromDirectory(fromDirectory, to, getCanonicalFileNameOrIgnoreCase) { + ts.Debug.assert((getRootLength(fromDirectory) > 0) === (getRootLength(to) > 0), "Paths must either both be absolute or both be relative"); + var getCanonicalFileName = typeof getCanonicalFileNameOrIgnoreCase === "function" ? getCanonicalFileNameOrIgnoreCase : ts.identity; + var ignoreCase = typeof getCanonicalFileNameOrIgnoreCase === "boolean" ? getCanonicalFileNameOrIgnoreCase : false; + var pathComponents = getPathComponentsRelativeTo(fromDirectory, to, ignoreCase ? ts.equateStringsCaseInsensitive : ts.equateStringsCaseSensitive, getCanonicalFileName); + return getPathFromPathComponents(pathComponents); + } + ts.getRelativePathFromDirectory = getRelativePathFromDirectory; + function convertToRelativePath(absoluteOrRelativePath, basePath, getCanonicalFileName) { + return !isRootedDiskPath(absoluteOrRelativePath) + ? absoluteOrRelativePath + : getRelativePathToDirectoryOrUrl(basePath, absoluteOrRelativePath, basePath, getCanonicalFileName, /*isAbsolutePathAnUrl*/ false); + } + ts.convertToRelativePath = convertToRelativePath; + function getRelativePathFromFile(from, to, getCanonicalFileName) { + return ensurePathIsNonModuleName(getRelativePathFromDirectory(getDirectoryPath(from), to, getCanonicalFileName)); + } + ts.getRelativePathFromFile = getRelativePathFromFile; + function getRelativePathToDirectoryOrUrl(directoryPathOrUrl, relativeOrAbsolutePath, currentDirectory, getCanonicalFileName, isAbsolutePathAnUrl) { + var pathComponents = getPathComponentsRelativeTo(resolvePath(currentDirectory, directoryPathOrUrl), resolvePath(currentDirectory, relativeOrAbsolutePath), ts.equateStringsCaseSensitive, getCanonicalFileName); + var firstComponent = pathComponents[0]; + if (isAbsolutePathAnUrl && isRootedDiskPath(firstComponent)) { + var prefix = firstComponent.charAt(0) === ts.directorySeparator ? "file://" : "file:///"; + pathComponents[0] = prefix + firstComponent; + } + return getPathFromPathComponents(pathComponents); + } + ts.getRelativePathToDirectoryOrUrl = getRelativePathToDirectoryOrUrl; + function forEachAncestorDirectory(directory, callback) { + while (true) { + var result = callback(directory); + if (result !== undefined) { + return result; + } + var parentPath = getDirectoryPath(directory); + if (parentPath === directory) { + return undefined; + } + directory = parentPath; + } + } + ts.forEachAncestorDirectory = forEachAncestorDirectory; + function isNodeModulesDirectory(dirPath) { + return ts.endsWith(dirPath, "/node_modules"); + } + ts.isNodeModulesDirectory = isNodeModulesDirectory; +})(ts || (ts = {})); +// +// generated from './diagnosticMessages.json' in 'src/compiler' +/* @internal */ +var ts; +(function (ts) { + function diag(code, category, key, message, reportsUnnecessary, elidedInCompatabilityPyramid, reportsDeprecated) { + return { code: code, category: category, key: key, message: message, reportsUnnecessary: reportsUnnecessary, elidedInCompatabilityPyramid: elidedInCompatabilityPyramid, reportsDeprecated: reportsDeprecated }; + } + ts.Diagnostics = { + Unterminated_string_literal: diag(1002, ts.DiagnosticCategory.Error, "Unterminated_string_literal_1002", "Unterminated string literal."), + Identifier_expected: diag(1003, ts.DiagnosticCategory.Error, "Identifier_expected_1003", "Identifier expected."), + _0_expected: diag(1005, ts.DiagnosticCategory.Error, "_0_expected_1005", "'{0}' expected."), + A_file_cannot_have_a_reference_to_itself: diag(1006, ts.DiagnosticCategory.Error, "A_file_cannot_have_a_reference_to_itself_1006", "A file cannot have a reference to itself."), + The_parser_expected_to_find_a_1_to_match_the_0_token_here: diag(1007, ts.DiagnosticCategory.Error, "The_parser_expected_to_find_a_1_to_match_the_0_token_here_1007", "The parser expected to find a '{1}' to match the '{0}' token here."), + Trailing_comma_not_allowed: diag(1009, ts.DiagnosticCategory.Error, "Trailing_comma_not_allowed_1009", "Trailing comma not allowed."), + Asterisk_Slash_expected: diag(1010, ts.DiagnosticCategory.Error, "Asterisk_Slash_expected_1010", "'*/' expected."), + An_element_access_expression_should_take_an_argument: diag(1011, ts.DiagnosticCategory.Error, "An_element_access_expression_should_take_an_argument_1011", "An element access expression should take an argument."), + Unexpected_token: diag(1012, ts.DiagnosticCategory.Error, "Unexpected_token_1012", "Unexpected token."), + A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma: diag(1013, ts.DiagnosticCategory.Error, "A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma_1013", "A rest parameter or binding pattern may not have a trailing comma."), + A_rest_parameter_must_be_last_in_a_parameter_list: diag(1014, ts.DiagnosticCategory.Error, "A_rest_parameter_must_be_last_in_a_parameter_list_1014", "A rest parameter must be last in a parameter list."), + Parameter_cannot_have_question_mark_and_initializer: diag(1015, ts.DiagnosticCategory.Error, "Parameter_cannot_have_question_mark_and_initializer_1015", "Parameter cannot have question mark and initializer."), + A_required_parameter_cannot_follow_an_optional_parameter: diag(1016, ts.DiagnosticCategory.Error, "A_required_parameter_cannot_follow_an_optional_parameter_1016", "A required parameter cannot follow an optional parameter."), + An_index_signature_cannot_have_a_rest_parameter: diag(1017, ts.DiagnosticCategory.Error, "An_index_signature_cannot_have_a_rest_parameter_1017", "An index signature cannot have a rest parameter."), + An_index_signature_parameter_cannot_have_an_accessibility_modifier: diag(1018, ts.DiagnosticCategory.Error, "An_index_signature_parameter_cannot_have_an_accessibility_modifier_1018", "An index signature parameter cannot have an accessibility modifier."), + An_index_signature_parameter_cannot_have_a_question_mark: diag(1019, ts.DiagnosticCategory.Error, "An_index_signature_parameter_cannot_have_a_question_mark_1019", "An index signature parameter cannot have a question mark."), + An_index_signature_parameter_cannot_have_an_initializer: diag(1020, ts.DiagnosticCategory.Error, "An_index_signature_parameter_cannot_have_an_initializer_1020", "An index signature parameter cannot have an initializer."), + An_index_signature_must_have_a_type_annotation: diag(1021, ts.DiagnosticCategory.Error, "An_index_signature_must_have_a_type_annotation_1021", "An index signature must have a type annotation."), + An_index_signature_parameter_must_have_a_type_annotation: diag(1022, ts.DiagnosticCategory.Error, "An_index_signature_parameter_must_have_a_type_annotation_1022", "An index signature parameter must have a type annotation."), + readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature: diag(1024, ts.DiagnosticCategory.Error, "readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature_1024", "'readonly' modifier can only appear on a property declaration or index signature."), + An_index_signature_cannot_have_a_trailing_comma: diag(1025, ts.DiagnosticCategory.Error, "An_index_signature_cannot_have_a_trailing_comma_1025", "An index signature cannot have a trailing comma."), + Accessibility_modifier_already_seen: diag(1028, ts.DiagnosticCategory.Error, "Accessibility_modifier_already_seen_1028", "Accessibility modifier already seen."), + _0_modifier_must_precede_1_modifier: diag(1029, ts.DiagnosticCategory.Error, "_0_modifier_must_precede_1_modifier_1029", "'{0}' modifier must precede '{1}' modifier."), + _0_modifier_already_seen: diag(1030, ts.DiagnosticCategory.Error, "_0_modifier_already_seen_1030", "'{0}' modifier already seen."), + _0_modifier_cannot_appear_on_class_elements_of_this_kind: diag(1031, ts.DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_class_elements_of_this_kind_1031", "'{0}' modifier cannot appear on class elements of this kind."), + super_must_be_followed_by_an_argument_list_or_member_access: diag(1034, ts.DiagnosticCategory.Error, "super_must_be_followed_by_an_argument_list_or_member_access_1034", "'super' must be followed by an argument list or member access."), + Only_ambient_modules_can_use_quoted_names: diag(1035, ts.DiagnosticCategory.Error, "Only_ambient_modules_can_use_quoted_names_1035", "Only ambient modules can use quoted names."), + Statements_are_not_allowed_in_ambient_contexts: diag(1036, ts.DiagnosticCategory.Error, "Statements_are_not_allowed_in_ambient_contexts_1036", "Statements are not allowed in ambient contexts."), + A_declare_modifier_cannot_be_used_in_an_already_ambient_context: diag(1038, ts.DiagnosticCategory.Error, "A_declare_modifier_cannot_be_used_in_an_already_ambient_context_1038", "A 'declare' modifier cannot be used in an already ambient context."), + Initializers_are_not_allowed_in_ambient_contexts: diag(1039, ts.DiagnosticCategory.Error, "Initializers_are_not_allowed_in_ambient_contexts_1039", "Initializers are not allowed in ambient contexts."), + _0_modifier_cannot_be_used_in_an_ambient_context: diag(1040, ts.DiagnosticCategory.Error, "_0_modifier_cannot_be_used_in_an_ambient_context_1040", "'{0}' modifier cannot be used in an ambient context."), + _0_modifier_cannot_be_used_here: diag(1042, ts.DiagnosticCategory.Error, "_0_modifier_cannot_be_used_here_1042", "'{0}' modifier cannot be used here."), + _0_modifier_cannot_appear_on_a_module_or_namespace_element: diag(1044, ts.DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_a_module_or_namespace_element_1044", "'{0}' modifier cannot appear on a module or namespace element."), + Top_level_declarations_in_d_ts_files_must_start_with_either_a_declare_or_export_modifier: diag(1046, ts.DiagnosticCategory.Error, "Top_level_declarations_in_d_ts_files_must_start_with_either_a_declare_or_export_modifier_1046", "Top-level declarations in .d.ts files must start with either a 'declare' or 'export' modifier."), + A_rest_parameter_cannot_be_optional: diag(1047, ts.DiagnosticCategory.Error, "A_rest_parameter_cannot_be_optional_1047", "A rest parameter cannot be optional."), + A_rest_parameter_cannot_have_an_initializer: diag(1048, ts.DiagnosticCategory.Error, "A_rest_parameter_cannot_have_an_initializer_1048", "A rest parameter cannot have an initializer."), + A_set_accessor_must_have_exactly_one_parameter: diag(1049, ts.DiagnosticCategory.Error, "A_set_accessor_must_have_exactly_one_parameter_1049", "A 'set' accessor must have exactly one parameter."), + A_set_accessor_cannot_have_an_optional_parameter: diag(1051, ts.DiagnosticCategory.Error, "A_set_accessor_cannot_have_an_optional_parameter_1051", "A 'set' accessor cannot have an optional parameter."), + A_set_accessor_parameter_cannot_have_an_initializer: diag(1052, ts.DiagnosticCategory.Error, "A_set_accessor_parameter_cannot_have_an_initializer_1052", "A 'set' accessor parameter cannot have an initializer."), + A_set_accessor_cannot_have_rest_parameter: diag(1053, ts.DiagnosticCategory.Error, "A_set_accessor_cannot_have_rest_parameter_1053", "A 'set' accessor cannot have rest parameter."), + A_get_accessor_cannot_have_parameters: diag(1054, ts.DiagnosticCategory.Error, "A_get_accessor_cannot_have_parameters_1054", "A 'get' accessor cannot have parameters."), + Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value: diag(1055, ts.DiagnosticCategory.Error, "Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Prom_1055", "Type '{0}' is not a valid async function return type in ES5/ES3 because it does not refer to a Promise-compatible constructor value."), + Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher: diag(1056, ts.DiagnosticCategory.Error, "Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher_1056", "Accessors are only available when targeting ECMAScript 5 and higher."), + The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1058, ts.DiagnosticCategory.Error, "The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_t_1058", "The return type of an async function must either be a valid promise or must not contain a callable 'then' member."), + A_promise_must_have_a_then_method: diag(1059, ts.DiagnosticCategory.Error, "A_promise_must_have_a_then_method_1059", "A promise must have a 'then' method."), + The_first_parameter_of_the_then_method_of_a_promise_must_be_a_callback: diag(1060, ts.DiagnosticCategory.Error, "The_first_parameter_of_the_then_method_of_a_promise_must_be_a_callback_1060", "The first parameter of the 'then' method of a promise must be a callback."), + Enum_member_must_have_initializer: diag(1061, ts.DiagnosticCategory.Error, "Enum_member_must_have_initializer_1061", "Enum member must have initializer."), + Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method: diag(1062, ts.DiagnosticCategory.Error, "Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method_1062", "Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method."), + An_export_assignment_cannot_be_used_in_a_namespace: diag(1063, ts.DiagnosticCategory.Error, "An_export_assignment_cannot_be_used_in_a_namespace_1063", "An export assignment cannot be used in a namespace."), + The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0: diag(1064, ts.DiagnosticCategory.Error, "The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_wri_1064", "The return type of an async function or method must be the global Promise type. Did you mean to write 'Promise<{0}>'?"), + In_ambient_enum_declarations_member_initializer_must_be_constant_expression: diag(1066, ts.DiagnosticCategory.Error, "In_ambient_enum_declarations_member_initializer_must_be_constant_expression_1066", "In ambient enum declarations member initializer must be constant expression."), + Unexpected_token_A_constructor_method_accessor_or_property_was_expected: diag(1068, ts.DiagnosticCategory.Error, "Unexpected_token_A_constructor_method_accessor_or_property_was_expected_1068", "Unexpected token. A constructor, method, accessor, or property was expected."), + Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces: diag(1069, ts.DiagnosticCategory.Error, "Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces_1069", "Unexpected token. A type parameter name was expected without curly braces."), + _0_modifier_cannot_appear_on_a_type_member: diag(1070, ts.DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_a_type_member_1070", "'{0}' modifier cannot appear on a type member."), + _0_modifier_cannot_appear_on_an_index_signature: diag(1071, ts.DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_an_index_signature_1071", "'{0}' modifier cannot appear on an index signature."), + A_0_modifier_cannot_be_used_with_an_import_declaration: diag(1079, ts.DiagnosticCategory.Error, "A_0_modifier_cannot_be_used_with_an_import_declaration_1079", "A '{0}' modifier cannot be used with an import declaration."), + Invalid_reference_directive_syntax: diag(1084, ts.DiagnosticCategory.Error, "Invalid_reference_directive_syntax_1084", "Invalid 'reference' directive syntax."), + Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_Use_the_syntax_0: diag(1085, ts.DiagnosticCategory.Error, "Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_Use_the_syntax_0_1085", "Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '{0}'."), + _0_modifier_cannot_appear_on_a_constructor_declaration: diag(1089, ts.DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_a_constructor_declaration_1089", "'{0}' modifier cannot appear on a constructor declaration."), + _0_modifier_cannot_appear_on_a_parameter: diag(1090, ts.DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_a_parameter_1090", "'{0}' modifier cannot appear on a parameter."), + Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement: diag(1091, ts.DiagnosticCategory.Error, "Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement_1091", "Only a single variable declaration is allowed in a 'for...in' statement."), + Type_parameters_cannot_appear_on_a_constructor_declaration: diag(1092, ts.DiagnosticCategory.Error, "Type_parameters_cannot_appear_on_a_constructor_declaration_1092", "Type parameters cannot appear on a constructor declaration."), + Type_annotation_cannot_appear_on_a_constructor_declaration: diag(1093, ts.DiagnosticCategory.Error, "Type_annotation_cannot_appear_on_a_constructor_declaration_1093", "Type annotation cannot appear on a constructor declaration."), + An_accessor_cannot_have_type_parameters: diag(1094, ts.DiagnosticCategory.Error, "An_accessor_cannot_have_type_parameters_1094", "An accessor cannot have type parameters."), + A_set_accessor_cannot_have_a_return_type_annotation: diag(1095, ts.DiagnosticCategory.Error, "A_set_accessor_cannot_have_a_return_type_annotation_1095", "A 'set' accessor cannot have a return type annotation."), + An_index_signature_must_have_exactly_one_parameter: diag(1096, ts.DiagnosticCategory.Error, "An_index_signature_must_have_exactly_one_parameter_1096", "An index signature must have exactly one parameter."), + _0_list_cannot_be_empty: diag(1097, ts.DiagnosticCategory.Error, "_0_list_cannot_be_empty_1097", "'{0}' list cannot be empty."), + Type_parameter_list_cannot_be_empty: diag(1098, ts.DiagnosticCategory.Error, "Type_parameter_list_cannot_be_empty_1098", "Type parameter list cannot be empty."), + Type_argument_list_cannot_be_empty: diag(1099, ts.DiagnosticCategory.Error, "Type_argument_list_cannot_be_empty_1099", "Type argument list cannot be empty."), + Invalid_use_of_0_in_strict_mode: diag(1100, ts.DiagnosticCategory.Error, "Invalid_use_of_0_in_strict_mode_1100", "Invalid use of '{0}' in strict mode."), + with_statements_are_not_allowed_in_strict_mode: diag(1101, ts.DiagnosticCategory.Error, "with_statements_are_not_allowed_in_strict_mode_1101", "'with' statements are not allowed in strict mode."), + delete_cannot_be_called_on_an_identifier_in_strict_mode: diag(1102, ts.DiagnosticCategory.Error, "delete_cannot_be_called_on_an_identifier_in_strict_mode_1102", "'delete' cannot be called on an identifier in strict mode."), + for_await_loops_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules: diag(1103, ts.DiagnosticCategory.Error, "for_await_loops_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules_1103", "'for await' loops are only allowed within async functions and at the top levels of modules."), + A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement: diag(1104, ts.DiagnosticCategory.Error, "A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement_1104", "A 'continue' statement can only be used within an enclosing iteration statement."), + A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement: diag(1105, ts.DiagnosticCategory.Error, "A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement_1105", "A 'break' statement can only be used within an enclosing iteration or switch statement."), + The_left_hand_side_of_a_for_of_statement_may_not_be_async: diag(1106, ts.DiagnosticCategory.Error, "The_left_hand_side_of_a_for_of_statement_may_not_be_async_1106", "The left-hand side of a 'for...of' statement may not be 'async'."), + Jump_target_cannot_cross_function_boundary: diag(1107, ts.DiagnosticCategory.Error, "Jump_target_cannot_cross_function_boundary_1107", "Jump target cannot cross function boundary."), + A_return_statement_can_only_be_used_within_a_function_body: diag(1108, ts.DiagnosticCategory.Error, "A_return_statement_can_only_be_used_within_a_function_body_1108", "A 'return' statement can only be used within a function body."), + Expression_expected: diag(1109, ts.DiagnosticCategory.Error, "Expression_expected_1109", "Expression expected."), + Type_expected: diag(1110, ts.DiagnosticCategory.Error, "Type_expected_1110", "Type expected."), + A_default_clause_cannot_appear_more_than_once_in_a_switch_statement: diag(1113, ts.DiagnosticCategory.Error, "A_default_clause_cannot_appear_more_than_once_in_a_switch_statement_1113", "A 'default' clause cannot appear more than once in a 'switch' statement."), + Duplicate_label_0: diag(1114, ts.DiagnosticCategory.Error, "Duplicate_label_0_1114", "Duplicate label '{0}'."), + A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement: diag(1115, ts.DiagnosticCategory.Error, "A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement_1115", "A 'continue' statement can only jump to a label of an enclosing iteration statement."), + A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement: diag(1116, ts.DiagnosticCategory.Error, "A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement_1116", "A 'break' statement can only jump to a label of an enclosing statement."), + An_object_literal_cannot_have_multiple_properties_with_the_same_name: diag(1117, ts.DiagnosticCategory.Error, "An_object_literal_cannot_have_multiple_properties_with_the_same_name_1117", "An object literal cannot have multiple properties with the same name."), + An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name: diag(1118, ts.DiagnosticCategory.Error, "An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name_1118", "An object literal cannot have multiple get/set accessors with the same name."), + An_object_literal_cannot_have_property_and_accessor_with_the_same_name: diag(1119, ts.DiagnosticCategory.Error, "An_object_literal_cannot_have_property_and_accessor_with_the_same_name_1119", "An object literal cannot have property and accessor with the same name."), + An_export_assignment_cannot_have_modifiers: diag(1120, ts.DiagnosticCategory.Error, "An_export_assignment_cannot_have_modifiers_1120", "An export assignment cannot have modifiers."), + Octal_literals_are_not_allowed_in_strict_mode: diag(1121, ts.DiagnosticCategory.Error, "Octal_literals_are_not_allowed_in_strict_mode_1121", "Octal literals are not allowed in strict mode."), + Variable_declaration_list_cannot_be_empty: diag(1123, ts.DiagnosticCategory.Error, "Variable_declaration_list_cannot_be_empty_1123", "Variable declaration list cannot be empty."), + Digit_expected: diag(1124, ts.DiagnosticCategory.Error, "Digit_expected_1124", "Digit expected."), + Hexadecimal_digit_expected: diag(1125, ts.DiagnosticCategory.Error, "Hexadecimal_digit_expected_1125", "Hexadecimal digit expected."), + Unexpected_end_of_text: diag(1126, ts.DiagnosticCategory.Error, "Unexpected_end_of_text_1126", "Unexpected end of text."), + Invalid_character: diag(1127, ts.DiagnosticCategory.Error, "Invalid_character_1127", "Invalid character."), + Declaration_or_statement_expected: diag(1128, ts.DiagnosticCategory.Error, "Declaration_or_statement_expected_1128", "Declaration or statement expected."), + Statement_expected: diag(1129, ts.DiagnosticCategory.Error, "Statement_expected_1129", "Statement expected."), + case_or_default_expected: diag(1130, ts.DiagnosticCategory.Error, "case_or_default_expected_1130", "'case' or 'default' expected."), + Property_or_signature_expected: diag(1131, ts.DiagnosticCategory.Error, "Property_or_signature_expected_1131", "Property or signature expected."), + Enum_member_expected: diag(1132, ts.DiagnosticCategory.Error, "Enum_member_expected_1132", "Enum member expected."), + Variable_declaration_expected: diag(1134, ts.DiagnosticCategory.Error, "Variable_declaration_expected_1134", "Variable declaration expected."), + Argument_expression_expected: diag(1135, ts.DiagnosticCategory.Error, "Argument_expression_expected_1135", "Argument expression expected."), + Property_assignment_expected: diag(1136, ts.DiagnosticCategory.Error, "Property_assignment_expected_1136", "Property assignment expected."), + Expression_or_comma_expected: diag(1137, ts.DiagnosticCategory.Error, "Expression_or_comma_expected_1137", "Expression or comma expected."), + Parameter_declaration_expected: diag(1138, ts.DiagnosticCategory.Error, "Parameter_declaration_expected_1138", "Parameter declaration expected."), + Type_parameter_declaration_expected: diag(1139, ts.DiagnosticCategory.Error, "Type_parameter_declaration_expected_1139", "Type parameter declaration expected."), + Type_argument_expected: diag(1140, ts.DiagnosticCategory.Error, "Type_argument_expected_1140", "Type argument expected."), + String_literal_expected: diag(1141, ts.DiagnosticCategory.Error, "String_literal_expected_1141", "String literal expected."), + Line_break_not_permitted_here: diag(1142, ts.DiagnosticCategory.Error, "Line_break_not_permitted_here_1142", "Line break not permitted here."), + or_expected: diag(1144, ts.DiagnosticCategory.Error, "or_expected_1144", "'{' or ';' expected."), + or_JSX_element_expected: diag(1145, ts.DiagnosticCategory.Error, "or_JSX_element_expected_1145", "'{' or JSX element expected."), + Declaration_expected: diag(1146, ts.DiagnosticCategory.Error, "Declaration_expected_1146", "Declaration expected."), + Import_declarations_in_a_namespace_cannot_reference_a_module: diag(1147, ts.DiagnosticCategory.Error, "Import_declarations_in_a_namespace_cannot_reference_a_module_1147", "Import declarations in a namespace cannot reference a module."), + Cannot_use_imports_exports_or_module_augmentations_when_module_is_none: diag(1148, ts.DiagnosticCategory.Error, "Cannot_use_imports_exports_or_module_augmentations_when_module_is_none_1148", "Cannot use imports, exports, or module augmentations when '--module' is 'none'."), + File_name_0_differs_from_already_included_file_name_1_only_in_casing: diag(1149, ts.DiagnosticCategory.Error, "File_name_0_differs_from_already_included_file_name_1_only_in_casing_1149", "File name '{0}' differs from already included file name '{1}' only in casing."), + const_declarations_must_be_initialized: diag(1155, ts.DiagnosticCategory.Error, "const_declarations_must_be_initialized_1155", "'const' declarations must be initialized."), + const_declarations_can_only_be_declared_inside_a_block: diag(1156, ts.DiagnosticCategory.Error, "const_declarations_can_only_be_declared_inside_a_block_1156", "'const' declarations can only be declared inside a block."), + let_declarations_can_only_be_declared_inside_a_block: diag(1157, ts.DiagnosticCategory.Error, "let_declarations_can_only_be_declared_inside_a_block_1157", "'let' declarations can only be declared inside a block."), + Unterminated_template_literal: diag(1160, ts.DiagnosticCategory.Error, "Unterminated_template_literal_1160", "Unterminated template literal."), + Unterminated_regular_expression_literal: diag(1161, ts.DiagnosticCategory.Error, "Unterminated_regular_expression_literal_1161", "Unterminated regular expression literal."), + An_object_member_cannot_be_declared_optional: diag(1162, ts.DiagnosticCategory.Error, "An_object_member_cannot_be_declared_optional_1162", "An object member cannot be declared optional."), + A_yield_expression_is_only_allowed_in_a_generator_body: diag(1163, ts.DiagnosticCategory.Error, "A_yield_expression_is_only_allowed_in_a_generator_body_1163", "A 'yield' expression is only allowed in a generator body."), + Computed_property_names_are_not_allowed_in_enums: diag(1164, ts.DiagnosticCategory.Error, "Computed_property_names_are_not_allowed_in_enums_1164", "Computed property names are not allowed in enums."), + A_computed_property_name_in_an_ambient_context_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: diag(1165, ts.DiagnosticCategory.Error, "A_computed_property_name_in_an_ambient_context_must_refer_to_an_expression_whose_type_is_a_literal_t_1165", "A computed property name in an ambient context must refer to an expression whose type is a literal type or a 'unique symbol' type."), + A_computed_property_name_in_a_class_property_declaration_must_have_a_simple_literal_type_or_a_unique_symbol_type: diag(1166, ts.DiagnosticCategory.Error, "A_computed_property_name_in_a_class_property_declaration_must_have_a_simple_literal_type_or_a_unique_1166", "A computed property name in a class property declaration must have a simple literal type or a 'unique symbol' type."), + A_computed_property_name_in_a_method_overload_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: diag(1168, ts.DiagnosticCategory.Error, "A_computed_property_name_in_a_method_overload_must_refer_to_an_expression_whose_type_is_a_literal_ty_1168", "A computed property name in a method overload must refer to an expression whose type is a literal type or a 'unique symbol' type."), + A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: diag(1169, ts.DiagnosticCategory.Error, "A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_1169", "A computed property name in an interface must refer to an expression whose type is a literal type or a 'unique symbol' type."), + A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: diag(1170, ts.DiagnosticCategory.Error, "A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type__1170", "A computed property name in a type literal must refer to an expression whose type is a literal type or a 'unique symbol' type."), + A_comma_expression_is_not_allowed_in_a_computed_property_name: diag(1171, ts.DiagnosticCategory.Error, "A_comma_expression_is_not_allowed_in_a_computed_property_name_1171", "A comma expression is not allowed in a computed property name."), + extends_clause_already_seen: diag(1172, ts.DiagnosticCategory.Error, "extends_clause_already_seen_1172", "'extends' clause already seen."), + extends_clause_must_precede_implements_clause: diag(1173, ts.DiagnosticCategory.Error, "extends_clause_must_precede_implements_clause_1173", "'extends' clause must precede 'implements' clause."), + Classes_can_only_extend_a_single_class: diag(1174, ts.DiagnosticCategory.Error, "Classes_can_only_extend_a_single_class_1174", "Classes can only extend a single class."), + implements_clause_already_seen: diag(1175, ts.DiagnosticCategory.Error, "implements_clause_already_seen_1175", "'implements' clause already seen."), + Interface_declaration_cannot_have_implements_clause: diag(1176, ts.DiagnosticCategory.Error, "Interface_declaration_cannot_have_implements_clause_1176", "Interface declaration cannot have 'implements' clause."), + Binary_digit_expected: diag(1177, ts.DiagnosticCategory.Error, "Binary_digit_expected_1177", "Binary digit expected."), + Octal_digit_expected: diag(1178, ts.DiagnosticCategory.Error, "Octal_digit_expected_1178", "Octal digit expected."), + Unexpected_token_expected: diag(1179, ts.DiagnosticCategory.Error, "Unexpected_token_expected_1179", "Unexpected token. '{' expected."), + Property_destructuring_pattern_expected: diag(1180, ts.DiagnosticCategory.Error, "Property_destructuring_pattern_expected_1180", "Property destructuring pattern expected."), + Array_element_destructuring_pattern_expected: diag(1181, ts.DiagnosticCategory.Error, "Array_element_destructuring_pattern_expected_1181", "Array element destructuring pattern expected."), + A_destructuring_declaration_must_have_an_initializer: diag(1182, ts.DiagnosticCategory.Error, "A_destructuring_declaration_must_have_an_initializer_1182", "A destructuring declaration must have an initializer."), + An_implementation_cannot_be_declared_in_ambient_contexts: diag(1183, ts.DiagnosticCategory.Error, "An_implementation_cannot_be_declared_in_ambient_contexts_1183", "An implementation cannot be declared in ambient contexts."), + Modifiers_cannot_appear_here: diag(1184, ts.DiagnosticCategory.Error, "Modifiers_cannot_appear_here_1184", "Modifiers cannot appear here."), + Merge_conflict_marker_encountered: diag(1185, ts.DiagnosticCategory.Error, "Merge_conflict_marker_encountered_1185", "Merge conflict marker encountered."), + A_rest_element_cannot_have_an_initializer: diag(1186, ts.DiagnosticCategory.Error, "A_rest_element_cannot_have_an_initializer_1186", "A rest element cannot have an initializer."), + A_parameter_property_may_not_be_declared_using_a_binding_pattern: diag(1187, ts.DiagnosticCategory.Error, "A_parameter_property_may_not_be_declared_using_a_binding_pattern_1187", "A parameter property may not be declared using a binding pattern."), + Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement: diag(1188, ts.DiagnosticCategory.Error, "Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement_1188", "Only a single variable declaration is allowed in a 'for...of' statement."), + The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer: diag(1189, ts.DiagnosticCategory.Error, "The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer_1189", "The variable declaration of a 'for...in' statement cannot have an initializer."), + The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer: diag(1190, ts.DiagnosticCategory.Error, "The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer_1190", "The variable declaration of a 'for...of' statement cannot have an initializer."), + An_import_declaration_cannot_have_modifiers: diag(1191, ts.DiagnosticCategory.Error, "An_import_declaration_cannot_have_modifiers_1191", "An import declaration cannot have modifiers."), + Module_0_has_no_default_export: diag(1192, ts.DiagnosticCategory.Error, "Module_0_has_no_default_export_1192", "Module '{0}' has no default export."), + An_export_declaration_cannot_have_modifiers: diag(1193, ts.DiagnosticCategory.Error, "An_export_declaration_cannot_have_modifiers_1193", "An export declaration cannot have modifiers."), + Export_declarations_are_not_permitted_in_a_namespace: diag(1194, ts.DiagnosticCategory.Error, "Export_declarations_are_not_permitted_in_a_namespace_1194", "Export declarations are not permitted in a namespace."), + export_Asterisk_does_not_re_export_a_default: diag(1195, ts.DiagnosticCategory.Error, "export_Asterisk_does_not_re_export_a_default_1195", "'export *' does not re-export a default."), + Catch_clause_variable_type_annotation_must_be_any_or_unknown_if_specified: diag(1196, ts.DiagnosticCategory.Error, "Catch_clause_variable_type_annotation_must_be_any_or_unknown_if_specified_1196", "Catch clause variable type annotation must be 'any' or 'unknown' if specified."), + Catch_clause_variable_cannot_have_an_initializer: diag(1197, ts.DiagnosticCategory.Error, "Catch_clause_variable_cannot_have_an_initializer_1197", "Catch clause variable cannot have an initializer."), + An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive: diag(1198, ts.DiagnosticCategory.Error, "An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive_1198", "An extended Unicode escape value must be between 0x0 and 0x10FFFF inclusive."), + Unterminated_Unicode_escape_sequence: diag(1199, ts.DiagnosticCategory.Error, "Unterminated_Unicode_escape_sequence_1199", "Unterminated Unicode escape sequence."), + Line_terminator_not_permitted_before_arrow: diag(1200, ts.DiagnosticCategory.Error, "Line_terminator_not_permitted_before_arrow_1200", "Line terminator not permitted before arrow."), + Import_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_import_d_from_mod_or_another_module_format_instead: diag(1202, ts.DiagnosticCategory.Error, "Import_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_import_Asterisk_as_1202", "Import assignment cannot be used when targeting ECMAScript modules. Consider using 'import * as ns from \"mod\"', 'import {a} from \"mod\"', 'import d from \"mod\"', or another module format instead."), + Export_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_export_default_or_another_module_format_instead: diag(1203, ts.DiagnosticCategory.Error, "Export_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_export_default_or__1203", "Export assignment cannot be used when targeting ECMAScript modules. Consider using 'export default' or another module format instead."), + Re_exporting_a_type_when_the_isolatedModules_flag_is_provided_requires_using_export_type: diag(1205, ts.DiagnosticCategory.Error, "Re_exporting_a_type_when_the_isolatedModules_flag_is_provided_requires_using_export_type_1205", "Re-exporting a type when the '--isolatedModules' flag is provided requires using 'export type'."), + Decorators_are_not_valid_here: diag(1206, ts.DiagnosticCategory.Error, "Decorators_are_not_valid_here_1206", "Decorators are not valid here."), + Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name: diag(1207, ts.DiagnosticCategory.Error, "Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name_1207", "Decorators cannot be applied to multiple get/set accessors of the same name."), + _0_cannot_be_compiled_under_isolatedModules_because_it_is_considered_a_global_script_file_Add_an_import_export_or_an_empty_export_statement_to_make_it_a_module: diag(1208, ts.DiagnosticCategory.Error, "_0_cannot_be_compiled_under_isolatedModules_because_it_is_considered_a_global_script_file_Add_an_imp_1208", "'{0}' cannot be compiled under '--isolatedModules' because it is considered a global script file. Add an import, export, or an empty 'export {}' statement to make it a module."), + Invalid_optional_chain_from_new_expression_Did_you_mean_to_call_0: diag(1209, ts.DiagnosticCategory.Error, "Invalid_optional_chain_from_new_expression_Did_you_mean_to_call_0_1209", "Invalid optional chain from new expression. Did you mean to call '{0}()'?"), + Code_contained_in_a_class_is_evaluated_in_JavaScript_s_strict_mode_which_does_not_allow_this_use_of_0_For_more_information_see_https_Colon_Slash_Slashdeveloper_mozilla_org_Slashen_US_Slashdocs_SlashWeb_SlashJavaScript_SlashReference_SlashStrict_mode: diag(1210, ts.DiagnosticCategory.Error, "Code_contained_in_a_class_is_evaluated_in_JavaScript_s_strict_mode_which_does_not_allow_this_use_of__1210", "Code contained in a class is evaluated in JavaScript's strict mode which does not allow this use of '{0}'. For more information, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode."), + A_class_declaration_without_the_default_modifier_must_have_a_name: diag(1211, ts.DiagnosticCategory.Error, "A_class_declaration_without_the_default_modifier_must_have_a_name_1211", "A class declaration without the 'default' modifier must have a name."), + Identifier_expected_0_is_a_reserved_word_in_strict_mode: diag(1212, ts.DiagnosticCategory.Error, "Identifier_expected_0_is_a_reserved_word_in_strict_mode_1212", "Identifier expected. '{0}' is a reserved word in strict mode."), + Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode: diag(1213, ts.DiagnosticCategory.Error, "Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_stric_1213", "Identifier expected. '{0}' is a reserved word in strict mode. Class definitions are automatically in strict mode."), + Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode: diag(1214, ts.DiagnosticCategory.Error, "Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode_1214", "Identifier expected. '{0}' is a reserved word in strict mode. Modules are automatically in strict mode."), + Invalid_use_of_0_Modules_are_automatically_in_strict_mode: diag(1215, ts.DiagnosticCategory.Error, "Invalid_use_of_0_Modules_are_automatically_in_strict_mode_1215", "Invalid use of '{0}'. Modules are automatically in strict mode."), + Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules: diag(1216, ts.DiagnosticCategory.Error, "Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules_1216", "Identifier expected. '__esModule' is reserved as an exported marker when transforming ECMAScript modules."), + Export_assignment_is_not_supported_when_module_flag_is_system: diag(1218, ts.DiagnosticCategory.Error, "Export_assignment_is_not_supported_when_module_flag_is_system_1218", "Export assignment is not supported when '--module' flag is 'system'."), + Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_the_experimentalDecorators_option_in_your_tsconfig_or_jsconfig_to_remove_this_warning: diag(1219, ts.DiagnosticCategory.Error, "Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_t_1219", "Experimental support for decorators is a feature that is subject to change in a future release. Set the 'experimentalDecorators' option in your 'tsconfig' or 'jsconfig' to remove this warning."), + Generators_are_not_allowed_in_an_ambient_context: diag(1221, ts.DiagnosticCategory.Error, "Generators_are_not_allowed_in_an_ambient_context_1221", "Generators are not allowed in an ambient context."), + An_overload_signature_cannot_be_declared_as_a_generator: diag(1222, ts.DiagnosticCategory.Error, "An_overload_signature_cannot_be_declared_as_a_generator_1222", "An overload signature cannot be declared as a generator."), + _0_tag_already_specified: diag(1223, ts.DiagnosticCategory.Error, "_0_tag_already_specified_1223", "'{0}' tag already specified."), + Signature_0_must_be_a_type_predicate: diag(1224, ts.DiagnosticCategory.Error, "Signature_0_must_be_a_type_predicate_1224", "Signature '{0}' must be a type predicate."), + Cannot_find_parameter_0: diag(1225, ts.DiagnosticCategory.Error, "Cannot_find_parameter_0_1225", "Cannot find parameter '{0}'."), + Type_predicate_0_is_not_assignable_to_1: diag(1226, ts.DiagnosticCategory.Error, "Type_predicate_0_is_not_assignable_to_1_1226", "Type predicate '{0}' is not assignable to '{1}'."), + Parameter_0_is_not_in_the_same_position_as_parameter_1: diag(1227, ts.DiagnosticCategory.Error, "Parameter_0_is_not_in_the_same_position_as_parameter_1_1227", "Parameter '{0}' is not in the same position as parameter '{1}'."), + A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods: diag(1228, ts.DiagnosticCategory.Error, "A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods_1228", "A type predicate is only allowed in return type position for functions and methods."), + A_type_predicate_cannot_reference_a_rest_parameter: diag(1229, ts.DiagnosticCategory.Error, "A_type_predicate_cannot_reference_a_rest_parameter_1229", "A type predicate cannot reference a rest parameter."), + A_type_predicate_cannot_reference_element_0_in_a_binding_pattern: diag(1230, ts.DiagnosticCategory.Error, "A_type_predicate_cannot_reference_element_0_in_a_binding_pattern_1230", "A type predicate cannot reference element '{0}' in a binding pattern."), + An_export_assignment_must_be_at_the_top_level_of_a_file_or_module_declaration: diag(1231, ts.DiagnosticCategory.Error, "An_export_assignment_must_be_at_the_top_level_of_a_file_or_module_declaration_1231", "An export assignment must be at the top level of a file or module declaration."), + An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module: diag(1232, ts.DiagnosticCategory.Error, "An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module_1232", "An import declaration can only be used at the top level of a namespace or module."), + An_export_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module: diag(1233, ts.DiagnosticCategory.Error, "An_export_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module_1233", "An export declaration can only be used at the top level of a namespace or module."), + An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file: diag(1234, ts.DiagnosticCategory.Error, "An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file_1234", "An ambient module declaration is only allowed at the top level in a file."), + A_namespace_declaration_is_only_allowed_at_the_top_level_of_a_namespace_or_module: diag(1235, ts.DiagnosticCategory.Error, "A_namespace_declaration_is_only_allowed_at_the_top_level_of_a_namespace_or_module_1235", "A namespace declaration is only allowed at the top level of a namespace or module."), + The_return_type_of_a_property_decorator_function_must_be_either_void_or_any: diag(1236, ts.DiagnosticCategory.Error, "The_return_type_of_a_property_decorator_function_must_be_either_void_or_any_1236", "The return type of a property decorator function must be either 'void' or 'any'."), + The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any: diag(1237, ts.DiagnosticCategory.Error, "The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any_1237", "The return type of a parameter decorator function must be either 'void' or 'any'."), + Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression: diag(1238, ts.DiagnosticCategory.Error, "Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression_1238", "Unable to resolve signature of class decorator when called as an expression."), + Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression: diag(1239, ts.DiagnosticCategory.Error, "Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression_1239", "Unable to resolve signature of parameter decorator when called as an expression."), + Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression: diag(1240, ts.DiagnosticCategory.Error, "Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression_1240", "Unable to resolve signature of property decorator when called as an expression."), + Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression: diag(1241, ts.DiagnosticCategory.Error, "Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression_1241", "Unable to resolve signature of method decorator when called as an expression."), + abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration: diag(1242, ts.DiagnosticCategory.Error, "abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration_1242", "'abstract' modifier can only appear on a class, method, or property declaration."), + _0_modifier_cannot_be_used_with_1_modifier: diag(1243, ts.DiagnosticCategory.Error, "_0_modifier_cannot_be_used_with_1_modifier_1243", "'{0}' modifier cannot be used with '{1}' modifier."), + Abstract_methods_can_only_appear_within_an_abstract_class: diag(1244, ts.DiagnosticCategory.Error, "Abstract_methods_can_only_appear_within_an_abstract_class_1244", "Abstract methods can only appear within an abstract class."), + Method_0_cannot_have_an_implementation_because_it_is_marked_abstract: diag(1245, ts.DiagnosticCategory.Error, "Method_0_cannot_have_an_implementation_because_it_is_marked_abstract_1245", "Method '{0}' cannot have an implementation because it is marked abstract."), + An_interface_property_cannot_have_an_initializer: diag(1246, ts.DiagnosticCategory.Error, "An_interface_property_cannot_have_an_initializer_1246", "An interface property cannot have an initializer."), + A_type_literal_property_cannot_have_an_initializer: diag(1247, ts.DiagnosticCategory.Error, "A_type_literal_property_cannot_have_an_initializer_1247", "A type literal property cannot have an initializer."), + A_class_member_cannot_have_the_0_keyword: diag(1248, ts.DiagnosticCategory.Error, "A_class_member_cannot_have_the_0_keyword_1248", "A class member cannot have the '{0}' keyword."), + A_decorator_can_only_decorate_a_method_implementation_not_an_overload: diag(1249, ts.DiagnosticCategory.Error, "A_decorator_can_only_decorate_a_method_implementation_not_an_overload_1249", "A decorator can only decorate a method implementation, not an overload."), + Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5: diag(1250, ts.DiagnosticCategory.Error, "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_1250", "Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'."), + Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Class_definitions_are_automatically_in_strict_mode: diag(1251, ts.DiagnosticCategory.Error, "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Class_d_1251", "Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'. Class definitions are automatically in strict mode."), + Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Modules_are_automatically_in_strict_mode: diag(1252, ts.DiagnosticCategory.Error, "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Modules_1252", "Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'. Modules are automatically in strict mode."), + A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_reference: diag(1254, ts.DiagnosticCategory.Error, "A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_refere_1254", "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference."), + A_definite_assignment_assertion_is_not_permitted_in_this_context: diag(1255, ts.DiagnosticCategory.Error, "A_definite_assignment_assertion_is_not_permitted_in_this_context_1255", "A definite assignment assertion '!' is not permitted in this context."), + A_required_element_cannot_follow_an_optional_element: diag(1257, ts.DiagnosticCategory.Error, "A_required_element_cannot_follow_an_optional_element_1257", "A required element cannot follow an optional element."), + A_default_export_must_be_at_the_top_level_of_a_file_or_module_declaration: diag(1258, ts.DiagnosticCategory.Error, "A_default_export_must_be_at_the_top_level_of_a_file_or_module_declaration_1258", "A default export must be at the top level of a file or module declaration."), + Module_0_can_only_be_default_imported_using_the_1_flag: diag(1259, ts.DiagnosticCategory.Error, "Module_0_can_only_be_default_imported_using_the_1_flag_1259", "Module '{0}' can only be default-imported using the '{1}' flag"), + Keywords_cannot_contain_escape_characters: diag(1260, ts.DiagnosticCategory.Error, "Keywords_cannot_contain_escape_characters_1260", "Keywords cannot contain escape characters."), + Already_included_file_name_0_differs_from_file_name_1_only_in_casing: diag(1261, ts.DiagnosticCategory.Error, "Already_included_file_name_0_differs_from_file_name_1_only_in_casing_1261", "Already included file name '{0}' differs from file name '{1}' only in casing."), + Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module: diag(1262, ts.DiagnosticCategory.Error, "Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module_1262", "Identifier expected. '{0}' is a reserved word at the top-level of a module."), + Declarations_with_initializers_cannot_also_have_definite_assignment_assertions: diag(1263, ts.DiagnosticCategory.Error, "Declarations_with_initializers_cannot_also_have_definite_assignment_assertions_1263", "Declarations with initializers cannot also have definite assignment assertions."), + Declarations_with_definite_assignment_assertions_must_also_have_type_annotations: diag(1264, ts.DiagnosticCategory.Error, "Declarations_with_definite_assignment_assertions_must_also_have_type_annotations_1264", "Declarations with definite assignment assertions must also have type annotations."), + A_rest_element_cannot_follow_another_rest_element: diag(1265, ts.DiagnosticCategory.Error, "A_rest_element_cannot_follow_another_rest_element_1265", "A rest element cannot follow another rest element."), + An_optional_element_cannot_follow_a_rest_element: diag(1266, ts.DiagnosticCategory.Error, "An_optional_element_cannot_follow_a_rest_element_1266", "An optional element cannot follow a rest element."), + Property_0_cannot_have_an_initializer_because_it_is_marked_abstract: diag(1267, ts.DiagnosticCategory.Error, "Property_0_cannot_have_an_initializer_because_it_is_marked_abstract_1267", "Property '{0}' cannot have an initializer because it is marked abstract."), + An_index_signature_parameter_type_must_be_string_number_symbol_or_a_template_literal_type: diag(1268, ts.DiagnosticCategory.Error, "An_index_signature_parameter_type_must_be_string_number_symbol_or_a_template_literal_type_1268", "An index signature parameter type must be 'string', 'number', 'symbol', or a template literal type."), + Cannot_use_export_import_on_a_type_or_type_only_namespace_when_the_isolatedModules_flag_is_provided: diag(1269, ts.DiagnosticCategory.Error, "Cannot_use_export_import_on_a_type_or_type_only_namespace_when_the_isolatedModules_flag_is_provided_1269", "Cannot use 'export import' on a type or type-only namespace when the '--isolatedModules' flag is provided."), + Decorator_function_return_type_0_is_not_assignable_to_type_1: diag(1270, ts.DiagnosticCategory.Error, "Decorator_function_return_type_0_is_not_assignable_to_type_1_1270", "Decorator function return type '{0}' is not assignable to type '{1}'."), + Decorator_function_return_type_is_0_but_is_expected_to_be_void_or_any: diag(1271, ts.DiagnosticCategory.Error, "Decorator_function_return_type_is_0_but_is_expected_to_be_void_or_any_1271", "Decorator function return type is '{0}' but is expected to be 'void' or 'any'."), + A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled: diag(1272, ts.DiagnosticCategory.Error, "A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_w_1272", "A type referenced in a decorated signature must be imported with 'import type' or a namespace import when 'isolatedModules' and 'emitDecoratorMetadata' are enabled."), + _0_modifier_cannot_appear_on_a_type_parameter: diag(1273, ts.DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_a_type_parameter_1273", "'{0}' modifier cannot appear on a type parameter"), + _0_modifier_can_only_appear_on_a_type_parameter_of_a_class_interface_or_type_alias: diag(1274, ts.DiagnosticCategory.Error, "_0_modifier_can_only_appear_on_a_type_parameter_of_a_class_interface_or_type_alias_1274", "'{0}' modifier can only appear on a type parameter of a class, interface or type alias"), + accessor_modifier_can_only_appear_on_a_property_declaration: diag(1275, ts.DiagnosticCategory.Error, "accessor_modifier_can_only_appear_on_a_property_declaration_1275", "'accessor' modifier can only appear on a property declaration."), + An_accessor_property_cannot_be_declared_optional: diag(1276, ts.DiagnosticCategory.Error, "An_accessor_property_cannot_be_declared_optional_1276", "An 'accessor' property cannot be declared optional."), + with_statements_are_not_allowed_in_an_async_function_block: diag(1300, ts.DiagnosticCategory.Error, "with_statements_are_not_allowed_in_an_async_function_block_1300", "'with' statements are not allowed in an async function block."), + await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules: diag(1308, ts.DiagnosticCategory.Error, "await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules_1308", "'await' expressions are only allowed within async functions and at the top levels of modules."), + The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level: diag(1309, ts.DiagnosticCategory.Error, "The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level_1309", "The current file is a CommonJS module and cannot use 'await' at the top level."), + Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_part_of_a_destructuring_pattern: diag(1312, ts.DiagnosticCategory.Error, "Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_1312", "Did you mean to use a ':'? An '=' can only follow a property name when the containing object literal is part of a destructuring pattern."), + The_body_of_an_if_statement_cannot_be_the_empty_statement: diag(1313, ts.DiagnosticCategory.Error, "The_body_of_an_if_statement_cannot_be_the_empty_statement_1313", "The body of an 'if' statement cannot be the empty statement."), + Global_module_exports_may_only_appear_in_module_files: diag(1314, ts.DiagnosticCategory.Error, "Global_module_exports_may_only_appear_in_module_files_1314", "Global module exports may only appear in module files."), + Global_module_exports_may_only_appear_in_declaration_files: diag(1315, ts.DiagnosticCategory.Error, "Global_module_exports_may_only_appear_in_declaration_files_1315", "Global module exports may only appear in declaration files."), + Global_module_exports_may_only_appear_at_top_level: diag(1316, ts.DiagnosticCategory.Error, "Global_module_exports_may_only_appear_at_top_level_1316", "Global module exports may only appear at top level."), + A_parameter_property_cannot_be_declared_using_a_rest_parameter: diag(1317, ts.DiagnosticCategory.Error, "A_parameter_property_cannot_be_declared_using_a_rest_parameter_1317", "A parameter property cannot be declared using a rest parameter."), + An_abstract_accessor_cannot_have_an_implementation: diag(1318, ts.DiagnosticCategory.Error, "An_abstract_accessor_cannot_have_an_implementation_1318", "An abstract accessor cannot have an implementation."), + A_default_export_can_only_be_used_in_an_ECMAScript_style_module: diag(1319, ts.DiagnosticCategory.Error, "A_default_export_can_only_be_used_in_an_ECMAScript_style_module_1319", "A default export can only be used in an ECMAScript-style module."), + Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1320, ts.DiagnosticCategory.Error, "Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member_1320", "Type of 'await' operand must either be a valid promise or must not contain a callable 'then' member."), + Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1321, ts.DiagnosticCategory.Error, "Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_cal_1321", "Type of 'yield' operand in an async generator must either be a valid promise or must not contain a callable 'then' member."), + Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1322, ts.DiagnosticCategory.Error, "Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_con_1322", "Type of iterated elements of a 'yield*' operand must either be a valid promise or must not contain a callable 'then' member."), + Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node16_or_nodenext: diag(1323, ts.DiagnosticCategory.Error, "Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd__1323", "Dynamic imports are only supported when the '--module' flag is set to 'es2020', 'es2022', 'esnext', 'commonjs', 'amd', 'system', 'umd', 'node16', or 'nodenext'."), + Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_node16_or_nodenext: diag(1324, ts.DiagnosticCategory.Error, "Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_node16_or_nod_1324", "Dynamic imports only support a second argument when the '--module' option is set to 'esnext', 'node16', or 'nodenext'."), + Argument_of_dynamic_import_cannot_be_spread_element: diag(1325, ts.DiagnosticCategory.Error, "Argument_of_dynamic_import_cannot_be_spread_element_1325", "Argument of dynamic import cannot be spread element."), + This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments: diag(1326, ts.DiagnosticCategory.Error, "This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot__1326", "This use of 'import' is invalid. 'import()' calls can be written, but they must have parentheses and cannot have type arguments."), + String_literal_with_double_quotes_expected: diag(1327, ts.DiagnosticCategory.Error, "String_literal_with_double_quotes_expected_1327", "String literal with double quotes expected."), + Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_literal: diag(1328, ts.DiagnosticCategory.Error, "Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_li_1328", "Property value can only be string literal, numeric literal, 'true', 'false', 'null', object literal or array literal."), + _0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write_0: diag(1329, ts.DiagnosticCategory.Error, "_0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write__1329", "'{0}' accepts too few arguments to be used as a decorator here. Did you mean to call it first and write '@{0}()'?"), + A_property_of_an_interface_or_type_literal_whose_type_is_a_unique_symbol_type_must_be_readonly: diag(1330, ts.DiagnosticCategory.Error, "A_property_of_an_interface_or_type_literal_whose_type_is_a_unique_symbol_type_must_be_readonly_1330", "A property of an interface or type literal whose type is a 'unique symbol' type must be 'readonly'."), + A_property_of_a_class_whose_type_is_a_unique_symbol_type_must_be_both_static_and_readonly: diag(1331, ts.DiagnosticCategory.Error, "A_property_of_a_class_whose_type_is_a_unique_symbol_type_must_be_both_static_and_readonly_1331", "A property of a class whose type is a 'unique symbol' type must be both 'static' and 'readonly'."), + A_variable_whose_type_is_a_unique_symbol_type_must_be_const: diag(1332, ts.DiagnosticCategory.Error, "A_variable_whose_type_is_a_unique_symbol_type_must_be_const_1332", "A variable whose type is a 'unique symbol' type must be 'const'."), + unique_symbol_types_may_not_be_used_on_a_variable_declaration_with_a_binding_name: diag(1333, ts.DiagnosticCategory.Error, "unique_symbol_types_may_not_be_used_on_a_variable_declaration_with_a_binding_name_1333", "'unique symbol' types may not be used on a variable declaration with a binding name."), + unique_symbol_types_are_only_allowed_on_variables_in_a_variable_statement: diag(1334, ts.DiagnosticCategory.Error, "unique_symbol_types_are_only_allowed_on_variables_in_a_variable_statement_1334", "'unique symbol' types are only allowed on variables in a variable statement."), + unique_symbol_types_are_not_allowed_here: diag(1335, ts.DiagnosticCategory.Error, "unique_symbol_types_are_not_allowed_here_1335", "'unique symbol' types are not allowed here."), + An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_object_type_instead: diag(1337, ts.DiagnosticCategory.Error, "An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_o_1337", "An index signature parameter type cannot be a literal type or generic type. Consider using a mapped object type instead."), + infer_declarations_are_only_permitted_in_the_extends_clause_of_a_conditional_type: diag(1338, ts.DiagnosticCategory.Error, "infer_declarations_are_only_permitted_in_the_extends_clause_of_a_conditional_type_1338", "'infer' declarations are only permitted in the 'extends' clause of a conditional type."), + Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here: diag(1339, ts.DiagnosticCategory.Error, "Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here_1339", "Module '{0}' does not refer to a value, but is used as a value here."), + Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0: diag(1340, ts.DiagnosticCategory.Error, "Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0_1340", "Module '{0}' does not refer to a type, but is used as a type here. Did you mean 'typeof import('{0}')'?"), + Class_constructor_may_not_be_an_accessor: diag(1341, ts.DiagnosticCategory.Error, "Class_constructor_may_not_be_an_accessor_1341", "Class constructor may not be an accessor."), + Type_arguments_cannot_be_used_here: diag(1342, ts.DiagnosticCategory.Error, "Type_arguments_cannot_be_used_here_1342", "Type arguments cannot be used here."), + The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system_node16_or_nodenext: diag(1343, ts.DiagnosticCategory.Error, "The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system__1343", "The 'import.meta' meta-property is only allowed when the '--module' option is 'es2020', 'es2022', 'esnext', 'system', 'node16', or 'nodenext'."), + A_label_is_not_allowed_here: diag(1344, ts.DiagnosticCategory.Error, "A_label_is_not_allowed_here_1344", "'A label is not allowed here."), + An_expression_of_type_void_cannot_be_tested_for_truthiness: diag(1345, ts.DiagnosticCategory.Error, "An_expression_of_type_void_cannot_be_tested_for_truthiness_1345", "An expression of type 'void' cannot be tested for truthiness."), + This_parameter_is_not_allowed_with_use_strict_directive: diag(1346, ts.DiagnosticCategory.Error, "This_parameter_is_not_allowed_with_use_strict_directive_1346", "This parameter is not allowed with 'use strict' directive."), + use_strict_directive_cannot_be_used_with_non_simple_parameter_list: diag(1347, ts.DiagnosticCategory.Error, "use_strict_directive_cannot_be_used_with_non_simple_parameter_list_1347", "'use strict' directive cannot be used with non-simple parameter list."), + Non_simple_parameter_declared_here: diag(1348, ts.DiagnosticCategory.Error, "Non_simple_parameter_declared_here_1348", "Non-simple parameter declared here."), + use_strict_directive_used_here: diag(1349, ts.DiagnosticCategory.Error, "use_strict_directive_used_here_1349", "'use strict' directive used here."), + Print_the_final_configuration_instead_of_building: diag(1350, ts.DiagnosticCategory.Message, "Print_the_final_configuration_instead_of_building_1350", "Print the final configuration instead of building."), + An_identifier_or_keyword_cannot_immediately_follow_a_numeric_literal: diag(1351, ts.DiagnosticCategory.Error, "An_identifier_or_keyword_cannot_immediately_follow_a_numeric_literal_1351", "An identifier or keyword cannot immediately follow a numeric literal."), + A_bigint_literal_cannot_use_exponential_notation: diag(1352, ts.DiagnosticCategory.Error, "A_bigint_literal_cannot_use_exponential_notation_1352", "A bigint literal cannot use exponential notation."), + A_bigint_literal_must_be_an_integer: diag(1353, ts.DiagnosticCategory.Error, "A_bigint_literal_must_be_an_integer_1353", "A bigint literal must be an integer."), + readonly_type_modifier_is_only_permitted_on_array_and_tuple_literal_types: diag(1354, ts.DiagnosticCategory.Error, "readonly_type_modifier_is_only_permitted_on_array_and_tuple_literal_types_1354", "'readonly' type modifier is only permitted on array and tuple literal types."), + A_const_assertions_can_only_be_applied_to_references_to_enum_members_or_string_number_boolean_array_or_object_literals: diag(1355, ts.DiagnosticCategory.Error, "A_const_assertions_can_only_be_applied_to_references_to_enum_members_or_string_number_boolean_array__1355", "A 'const' assertions can only be applied to references to enum members, or string, number, boolean, array, or object literals."), + Did_you_mean_to_mark_this_function_as_async: diag(1356, ts.DiagnosticCategory.Error, "Did_you_mean_to_mark_this_function_as_async_1356", "Did you mean to mark this function as 'async'?"), + An_enum_member_name_must_be_followed_by_a_or: diag(1357, ts.DiagnosticCategory.Error, "An_enum_member_name_must_be_followed_by_a_or_1357", "An enum member name must be followed by a ',', '=', or '}'."), + Tagged_template_expressions_are_not_permitted_in_an_optional_chain: diag(1358, ts.DiagnosticCategory.Error, "Tagged_template_expressions_are_not_permitted_in_an_optional_chain_1358", "Tagged template expressions are not permitted in an optional chain."), + Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here: diag(1359, ts.DiagnosticCategory.Error, "Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here_1359", "Identifier expected. '{0}' is a reserved word that cannot be used here."), + Type_0_does_not_satisfy_the_expected_type_1: diag(1360, ts.DiagnosticCategory.Error, "Type_0_does_not_satisfy_the_expected_type_1_1360", "Type '{0}' does not satisfy the expected type '{1}'."), + _0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type: diag(1361, ts.DiagnosticCategory.Error, "_0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type_1361", "'{0}' cannot be used as a value because it was imported using 'import type'."), + _0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type: diag(1362, ts.DiagnosticCategory.Error, "_0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type_1362", "'{0}' cannot be used as a value because it was exported using 'export type'."), + A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both: diag(1363, ts.DiagnosticCategory.Error, "A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both_1363", "A type-only import can specify a default import or named bindings, but not both."), + Convert_to_type_only_export: diag(1364, ts.DiagnosticCategory.Message, "Convert_to_type_only_export_1364", "Convert to type-only export"), + Convert_all_re_exported_types_to_type_only_exports: diag(1365, ts.DiagnosticCategory.Message, "Convert_all_re_exported_types_to_type_only_exports_1365", "Convert all re-exported types to type-only exports"), + Split_into_two_separate_import_declarations: diag(1366, ts.DiagnosticCategory.Message, "Split_into_two_separate_import_declarations_1366", "Split into two separate import declarations"), + Split_all_invalid_type_only_imports: diag(1367, ts.DiagnosticCategory.Message, "Split_all_invalid_type_only_imports_1367", "Split all invalid type-only imports"), + Class_constructor_may_not_be_a_generator: diag(1368, ts.DiagnosticCategory.Error, "Class_constructor_may_not_be_a_generator_1368", "Class constructor may not be a generator."), + Did_you_mean_0: diag(1369, ts.DiagnosticCategory.Message, "Did_you_mean_0_1369", "Did you mean '{0}'?"), + This_import_is_never_used_as_a_value_and_must_use_import_type_because_importsNotUsedAsValues_is_set_to_error: diag(1371, ts.DiagnosticCategory.Error, "This_import_is_never_used_as_a_value_and_must_use_import_type_because_importsNotUsedAsValues_is_set__1371", "This import is never used as a value and must use 'import type' because 'importsNotUsedAsValues' is set to 'error'."), + Convert_to_type_only_import: diag(1373, ts.DiagnosticCategory.Message, "Convert_to_type_only_import_1373", "Convert to type-only import"), + Convert_all_imports_not_used_as_a_value_to_type_only_imports: diag(1374, ts.DiagnosticCategory.Message, "Convert_all_imports_not_used_as_a_value_to_type_only_imports_1374", "Convert all imports not used as a value to type-only imports"), + await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module: diag(1375, ts.DiagnosticCategory.Error, "await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_fi_1375", "'await' expressions are only allowed at the top level of a file when that file is a module, but this file has no imports or exports. Consider adding an empty 'export {}' to make this file a module."), + _0_was_imported_here: diag(1376, ts.DiagnosticCategory.Message, "_0_was_imported_here_1376", "'{0}' was imported here."), + _0_was_exported_here: diag(1377, ts.DiagnosticCategory.Message, "_0_was_exported_here_1377", "'{0}' was exported here."), + Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher: diag(1378, ts.DiagnosticCategory.Error, "Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_n_1378", "Top-level 'await' expressions are only allowed when the 'module' option is set to 'es2022', 'esnext', 'system', 'node16', or 'nodenext', and the 'target' option is set to 'es2017' or higher."), + An_import_alias_cannot_reference_a_declaration_that_was_exported_using_export_type: diag(1379, ts.DiagnosticCategory.Error, "An_import_alias_cannot_reference_a_declaration_that_was_exported_using_export_type_1379", "An import alias cannot reference a declaration that was exported using 'export type'."), + An_import_alias_cannot_reference_a_declaration_that_was_imported_using_import_type: diag(1380, ts.DiagnosticCategory.Error, "An_import_alias_cannot_reference_a_declaration_that_was_imported_using_import_type_1380", "An import alias cannot reference a declaration that was imported using 'import type'."), + Unexpected_token_Did_you_mean_or_rbrace: diag(1381, ts.DiagnosticCategory.Error, "Unexpected_token_Did_you_mean_or_rbrace_1381", "Unexpected token. Did you mean `{'}'}` or `}`?"), + Unexpected_token_Did_you_mean_or_gt: diag(1382, ts.DiagnosticCategory.Error, "Unexpected_token_Did_you_mean_or_gt_1382", "Unexpected token. Did you mean `{'>'}` or `>`?"), + Only_named_exports_may_use_export_type: diag(1383, ts.DiagnosticCategory.Error, "Only_named_exports_may_use_export_type_1383", "Only named exports may use 'export type'."), + Function_type_notation_must_be_parenthesized_when_used_in_a_union_type: diag(1385, ts.DiagnosticCategory.Error, "Function_type_notation_must_be_parenthesized_when_used_in_a_union_type_1385", "Function type notation must be parenthesized when used in a union type."), + Constructor_type_notation_must_be_parenthesized_when_used_in_a_union_type: diag(1386, ts.DiagnosticCategory.Error, "Constructor_type_notation_must_be_parenthesized_when_used_in_a_union_type_1386", "Constructor type notation must be parenthesized when used in a union type."), + Function_type_notation_must_be_parenthesized_when_used_in_an_intersection_type: diag(1387, ts.DiagnosticCategory.Error, "Function_type_notation_must_be_parenthesized_when_used_in_an_intersection_type_1387", "Function type notation must be parenthesized when used in an intersection type."), + Constructor_type_notation_must_be_parenthesized_when_used_in_an_intersection_type: diag(1388, ts.DiagnosticCategory.Error, "Constructor_type_notation_must_be_parenthesized_when_used_in_an_intersection_type_1388", "Constructor type notation must be parenthesized when used in an intersection type."), + _0_is_not_allowed_as_a_variable_declaration_name: diag(1389, ts.DiagnosticCategory.Error, "_0_is_not_allowed_as_a_variable_declaration_name_1389", "'{0}' is not allowed as a variable declaration name."), + _0_is_not_allowed_as_a_parameter_name: diag(1390, ts.DiagnosticCategory.Error, "_0_is_not_allowed_as_a_parameter_name_1390", "'{0}' is not allowed as a parameter name."), + An_import_alias_cannot_use_import_type: diag(1392, ts.DiagnosticCategory.Error, "An_import_alias_cannot_use_import_type_1392", "An import alias cannot use 'import type'"), + Imported_via_0_from_file_1: diag(1393, ts.DiagnosticCategory.Message, "Imported_via_0_from_file_1_1393", "Imported via {0} from file '{1}'"), + Imported_via_0_from_file_1_with_packageId_2: diag(1394, ts.DiagnosticCategory.Message, "Imported_via_0_from_file_1_with_packageId_2_1394", "Imported via {0} from file '{1}' with packageId '{2}'"), + Imported_via_0_from_file_1_to_import_importHelpers_as_specified_in_compilerOptions: diag(1395, ts.DiagnosticCategory.Message, "Imported_via_0_from_file_1_to_import_importHelpers_as_specified_in_compilerOptions_1395", "Imported via {0} from file '{1}' to import 'importHelpers' as specified in compilerOptions"), + Imported_via_0_from_file_1_with_packageId_2_to_import_importHelpers_as_specified_in_compilerOptions: diag(1396, ts.DiagnosticCategory.Message, "Imported_via_0_from_file_1_with_packageId_2_to_import_importHelpers_as_specified_in_compilerOptions_1396", "Imported via {0} from file '{1}' with packageId '{2}' to import 'importHelpers' as specified in compilerOptions"), + Imported_via_0_from_file_1_to_import_jsx_and_jsxs_factory_functions: diag(1397, ts.DiagnosticCategory.Message, "Imported_via_0_from_file_1_to_import_jsx_and_jsxs_factory_functions_1397", "Imported via {0} from file '{1}' to import 'jsx' and 'jsxs' factory functions"), + Imported_via_0_from_file_1_with_packageId_2_to_import_jsx_and_jsxs_factory_functions: diag(1398, ts.DiagnosticCategory.Message, "Imported_via_0_from_file_1_with_packageId_2_to_import_jsx_and_jsxs_factory_functions_1398", "Imported via {0} from file '{1}' with packageId '{2}' to import 'jsx' and 'jsxs' factory functions"), + File_is_included_via_import_here: diag(1399, ts.DiagnosticCategory.Message, "File_is_included_via_import_here_1399", "File is included via import here."), + Referenced_via_0_from_file_1: diag(1400, ts.DiagnosticCategory.Message, "Referenced_via_0_from_file_1_1400", "Referenced via '{0}' from file '{1}'"), + File_is_included_via_reference_here: diag(1401, ts.DiagnosticCategory.Message, "File_is_included_via_reference_here_1401", "File is included via reference here."), + Type_library_referenced_via_0_from_file_1: diag(1402, ts.DiagnosticCategory.Message, "Type_library_referenced_via_0_from_file_1_1402", "Type library referenced via '{0}' from file '{1}'"), + Type_library_referenced_via_0_from_file_1_with_packageId_2: diag(1403, ts.DiagnosticCategory.Message, "Type_library_referenced_via_0_from_file_1_with_packageId_2_1403", "Type library referenced via '{0}' from file '{1}' with packageId '{2}'"), + File_is_included_via_type_library_reference_here: diag(1404, ts.DiagnosticCategory.Message, "File_is_included_via_type_library_reference_here_1404", "File is included via type library reference here."), + Library_referenced_via_0_from_file_1: diag(1405, ts.DiagnosticCategory.Message, "Library_referenced_via_0_from_file_1_1405", "Library referenced via '{0}' from file '{1}'"), + File_is_included_via_library_reference_here: diag(1406, ts.DiagnosticCategory.Message, "File_is_included_via_library_reference_here_1406", "File is included via library reference here."), + Matched_by_include_pattern_0_in_1: diag(1407, ts.DiagnosticCategory.Message, "Matched_by_include_pattern_0_in_1_1407", "Matched by include pattern '{0}' in '{1}'"), + File_is_matched_by_include_pattern_specified_here: diag(1408, ts.DiagnosticCategory.Message, "File_is_matched_by_include_pattern_specified_here_1408", "File is matched by include pattern specified here."), + Part_of_files_list_in_tsconfig_json: diag(1409, ts.DiagnosticCategory.Message, "Part_of_files_list_in_tsconfig_json_1409", "Part of 'files' list in tsconfig.json"), + File_is_matched_by_files_list_specified_here: diag(1410, ts.DiagnosticCategory.Message, "File_is_matched_by_files_list_specified_here_1410", "File is matched by 'files' list specified here."), + Output_from_referenced_project_0_included_because_1_specified: diag(1411, ts.DiagnosticCategory.Message, "Output_from_referenced_project_0_included_because_1_specified_1411", "Output from referenced project '{0}' included because '{1}' specified"), + Output_from_referenced_project_0_included_because_module_is_specified_as_none: diag(1412, ts.DiagnosticCategory.Message, "Output_from_referenced_project_0_included_because_module_is_specified_as_none_1412", "Output from referenced project '{0}' included because '--module' is specified as 'none'"), + File_is_output_from_referenced_project_specified_here: diag(1413, ts.DiagnosticCategory.Message, "File_is_output_from_referenced_project_specified_here_1413", "File is output from referenced project specified here."), + Source_from_referenced_project_0_included_because_1_specified: diag(1414, ts.DiagnosticCategory.Message, "Source_from_referenced_project_0_included_because_1_specified_1414", "Source from referenced project '{0}' included because '{1}' specified"), + Source_from_referenced_project_0_included_because_module_is_specified_as_none: diag(1415, ts.DiagnosticCategory.Message, "Source_from_referenced_project_0_included_because_module_is_specified_as_none_1415", "Source from referenced project '{0}' included because '--module' is specified as 'none'"), + File_is_source_from_referenced_project_specified_here: diag(1416, ts.DiagnosticCategory.Message, "File_is_source_from_referenced_project_specified_here_1416", "File is source from referenced project specified here."), + Entry_point_of_type_library_0_specified_in_compilerOptions: diag(1417, ts.DiagnosticCategory.Message, "Entry_point_of_type_library_0_specified_in_compilerOptions_1417", "Entry point of type library '{0}' specified in compilerOptions"), + Entry_point_of_type_library_0_specified_in_compilerOptions_with_packageId_1: diag(1418, ts.DiagnosticCategory.Message, "Entry_point_of_type_library_0_specified_in_compilerOptions_with_packageId_1_1418", "Entry point of type library '{0}' specified in compilerOptions with packageId '{1}'"), + File_is_entry_point_of_type_library_specified_here: diag(1419, ts.DiagnosticCategory.Message, "File_is_entry_point_of_type_library_specified_here_1419", "File is entry point of type library specified here."), + Entry_point_for_implicit_type_library_0: diag(1420, ts.DiagnosticCategory.Message, "Entry_point_for_implicit_type_library_0_1420", "Entry point for implicit type library '{0}'"), + Entry_point_for_implicit_type_library_0_with_packageId_1: diag(1421, ts.DiagnosticCategory.Message, "Entry_point_for_implicit_type_library_0_with_packageId_1_1421", "Entry point for implicit type library '{0}' with packageId '{1}'"), + Library_0_specified_in_compilerOptions: diag(1422, ts.DiagnosticCategory.Message, "Library_0_specified_in_compilerOptions_1422", "Library '{0}' specified in compilerOptions"), + File_is_library_specified_here: diag(1423, ts.DiagnosticCategory.Message, "File_is_library_specified_here_1423", "File is library specified here."), + Default_library: diag(1424, ts.DiagnosticCategory.Message, "Default_library_1424", "Default library"), + Default_library_for_target_0: diag(1425, ts.DiagnosticCategory.Message, "Default_library_for_target_0_1425", "Default library for target '{0}'"), + File_is_default_library_for_target_specified_here: diag(1426, ts.DiagnosticCategory.Message, "File_is_default_library_for_target_specified_here_1426", "File is default library for target specified here."), + Root_file_specified_for_compilation: diag(1427, ts.DiagnosticCategory.Message, "Root_file_specified_for_compilation_1427", "Root file specified for compilation"), + File_is_output_of_project_reference_source_0: diag(1428, ts.DiagnosticCategory.Message, "File_is_output_of_project_reference_source_0_1428", "File is output of project reference source '{0}'"), + File_redirects_to_file_0: diag(1429, ts.DiagnosticCategory.Message, "File_redirects_to_file_0_1429", "File redirects to file '{0}'"), + The_file_is_in_the_program_because_Colon: diag(1430, ts.DiagnosticCategory.Message, "The_file_is_in_the_program_because_Colon_1430", "The file is in the program because:"), + for_await_loops_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module: diag(1431, ts.DiagnosticCategory.Error, "for_await_loops_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_1431", "'for await' loops are only allowed at the top level of a file when that file is a module, but this file has no imports or exports. Consider adding an empty 'export {}' to make this file a module."), + Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher: diag(1432, ts.DiagnosticCategory.Error, "Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_nod_1432", "Top-level 'for await' loops are only allowed when the 'module' option is set to 'es2022', 'esnext', 'system', 'node16', or 'nodenext', and the 'target' option is set to 'es2017' or higher."), + Decorators_may_not_be_applied_to_this_parameters: diag(1433, ts.DiagnosticCategory.Error, "Decorators_may_not_be_applied_to_this_parameters_1433", "Decorators may not be applied to 'this' parameters."), + Unexpected_keyword_or_identifier: diag(1434, ts.DiagnosticCategory.Error, "Unexpected_keyword_or_identifier_1434", "Unexpected keyword or identifier."), + Unknown_keyword_or_identifier_Did_you_mean_0: diag(1435, ts.DiagnosticCategory.Error, "Unknown_keyword_or_identifier_Did_you_mean_0_1435", "Unknown keyword or identifier. Did you mean '{0}'?"), + Decorators_must_precede_the_name_and_all_keywords_of_property_declarations: diag(1436, ts.DiagnosticCategory.Error, "Decorators_must_precede_the_name_and_all_keywords_of_property_declarations_1436", "Decorators must precede the name and all keywords of property declarations."), + Namespace_must_be_given_a_name: diag(1437, ts.DiagnosticCategory.Error, "Namespace_must_be_given_a_name_1437", "Namespace must be given a name."), + Interface_must_be_given_a_name: diag(1438, ts.DiagnosticCategory.Error, "Interface_must_be_given_a_name_1438", "Interface must be given a name."), + Type_alias_must_be_given_a_name: diag(1439, ts.DiagnosticCategory.Error, "Type_alias_must_be_given_a_name_1439", "Type alias must be given a name."), + Variable_declaration_not_allowed_at_this_location: diag(1440, ts.DiagnosticCategory.Error, "Variable_declaration_not_allowed_at_this_location_1440", "Variable declaration not allowed at this location."), + Cannot_start_a_function_call_in_a_type_annotation: diag(1441, ts.DiagnosticCategory.Error, "Cannot_start_a_function_call_in_a_type_annotation_1441", "Cannot start a function call in a type annotation."), + Expected_for_property_initializer: diag(1442, ts.DiagnosticCategory.Error, "Expected_for_property_initializer_1442", "Expected '=' for property initializer."), + Module_declaration_names_may_only_use_or_quoted_strings: diag(1443, ts.DiagnosticCategory.Error, "Module_declaration_names_may_only_use_or_quoted_strings_1443", "Module declaration names may only use ' or \" quoted strings."), + _0_is_a_type_and_must_be_imported_using_a_type_only_import_when_preserveValueImports_and_isolatedModules_are_both_enabled: diag(1444, ts.DiagnosticCategory.Error, "_0_is_a_type_and_must_be_imported_using_a_type_only_import_when_preserveValueImports_and_isolatedMod_1444", "'{0}' is a type and must be imported using a type-only import when 'preserveValueImports' and 'isolatedModules' are both enabled."), + _0_resolves_to_a_type_only_declaration_and_must_be_imported_using_a_type_only_import_when_preserveValueImports_and_isolatedModules_are_both_enabled: diag(1446, ts.DiagnosticCategory.Error, "_0_resolves_to_a_type_only_declaration_and_must_be_imported_using_a_type_only_import_when_preserveVa_1446", "'{0}' resolves to a type-only declaration and must be imported using a type-only import when 'preserveValueImports' and 'isolatedModules' are both enabled."), + _0_resolves_to_a_type_only_declaration_and_must_be_re_exported_using_a_type_only_re_export_when_isolatedModules_is_enabled: diag(1448, ts.DiagnosticCategory.Error, "_0_resolves_to_a_type_only_declaration_and_must_be_re_exported_using_a_type_only_re_export_when_isol_1448", "'{0}' resolves to a type-only declaration and must be re-exported using a type-only re-export when 'isolatedModules' is enabled."), + Preserve_unused_imported_values_in_the_JavaScript_output_that_would_otherwise_be_removed: diag(1449, ts.DiagnosticCategory.Message, "Preserve_unused_imported_values_in_the_JavaScript_output_that_would_otherwise_be_removed_1449", "Preserve unused imported values in the JavaScript output that would otherwise be removed."), + Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_assertion_as_arguments: diag(1450, ts.DiagnosticCategory.Message, "Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_assertion_as_arguments_1450", "Dynamic imports can only accept a module specifier and an optional assertion as arguments"), + Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member_declaration_property_access_or_on_the_left_hand_side_of_an_in_expression: diag(1451, ts.DiagnosticCategory.Error, "Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member__1451", "Private identifiers are only allowed in class bodies and may only be used as part of a class member declaration, property access, or on the left-hand-side of an 'in' expression"), + resolution_mode_assertions_are_only_supported_when_moduleResolution_is_node16_or_nodenext: diag(1452, ts.DiagnosticCategory.Error, "resolution_mode_assertions_are_only_supported_when_moduleResolution_is_node16_or_nodenext_1452", "'resolution-mode' assertions are only supported when `moduleResolution` is `node16` or `nodenext`."), + resolution_mode_should_be_either_require_or_import: diag(1453, ts.DiagnosticCategory.Error, "resolution_mode_should_be_either_require_or_import_1453", "`resolution-mode` should be either `require` or `import`."), + resolution_mode_can_only_be_set_for_type_only_imports: diag(1454, ts.DiagnosticCategory.Error, "resolution_mode_can_only_be_set_for_type_only_imports_1454", "`resolution-mode` can only be set for type-only imports."), + resolution_mode_is_the_only_valid_key_for_type_import_assertions: diag(1455, ts.DiagnosticCategory.Error, "resolution_mode_is_the_only_valid_key_for_type_import_assertions_1455", "`resolution-mode` is the only valid key for type import assertions."), + Type_import_assertions_should_have_exactly_one_key_resolution_mode_with_value_import_or_require: diag(1456, ts.DiagnosticCategory.Error, "Type_import_assertions_should_have_exactly_one_key_resolution_mode_with_value_import_or_require_1456", "Type import assertions should have exactly one key - `resolution-mode` - with value `import` or `require`."), + Matched_by_default_include_pattern_Asterisk_Asterisk_Slash_Asterisk: diag(1457, ts.DiagnosticCategory.Message, "Matched_by_default_include_pattern_Asterisk_Asterisk_Slash_Asterisk_1457", "Matched by default include pattern '**/*'"), + File_is_ECMAScript_module_because_0_has_field_type_with_value_module: diag(1458, ts.DiagnosticCategory.Message, "File_is_ECMAScript_module_because_0_has_field_type_with_value_module_1458", "File is ECMAScript module because '{0}' has field \"type\" with value \"module\""), + File_is_CommonJS_module_because_0_has_field_type_whose_value_is_not_module: diag(1459, ts.DiagnosticCategory.Message, "File_is_CommonJS_module_because_0_has_field_type_whose_value_is_not_module_1459", "File is CommonJS module because '{0}' has field \"type\" whose value is not \"module\""), + File_is_CommonJS_module_because_0_does_not_have_field_type: diag(1460, ts.DiagnosticCategory.Message, "File_is_CommonJS_module_because_0_does_not_have_field_type_1460", "File is CommonJS module because '{0}' does not have field \"type\""), + File_is_CommonJS_module_because_package_json_was_not_found: diag(1461, ts.DiagnosticCategory.Message, "File_is_CommonJS_module_because_package_json_was_not_found_1461", "File is CommonJS module because 'package.json' was not found"), + The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output: diag(1470, ts.DiagnosticCategory.Error, "The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output_1470", "The 'import.meta' meta-property is not allowed in files which will build into CommonJS output."), + Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_cannot_be_imported_with_require_Use_an_ECMAScript_import_instead: diag(1471, ts.DiagnosticCategory.Error, "Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_c_1471", "Module '{0}' cannot be imported using this construct. The specifier only resolves to an ES module, which cannot be imported with 'require'. Use an ECMAScript import instead."), + catch_or_finally_expected: diag(1472, ts.DiagnosticCategory.Error, "catch_or_finally_expected_1472", "'catch' or 'finally' expected."), + An_import_declaration_can_only_be_used_at_the_top_level_of_a_module: diag(1473, ts.DiagnosticCategory.Error, "An_import_declaration_can_only_be_used_at_the_top_level_of_a_module_1473", "An import declaration can only be used at the top level of a module."), + An_export_declaration_can_only_be_used_at_the_top_level_of_a_module: diag(1474, ts.DiagnosticCategory.Error, "An_export_declaration_can_only_be_used_at_the_top_level_of_a_module_1474", "An export declaration can only be used at the top level of a module."), + Control_what_method_is_used_to_detect_module_format_JS_files: diag(1475, ts.DiagnosticCategory.Message, "Control_what_method_is_used_to_detect_module_format_JS_files_1475", "Control what method is used to detect module-format JS files."), + auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_with_module_Colon_node16_as_modules: diag(1476, ts.DiagnosticCategory.Message, "auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_w_1476", "\"auto\": Treat files with imports, exports, import.meta, jsx (with jsx: react-jsx), or esm format (with module: node16+) as modules."), + An_instantiation_expression_cannot_be_followed_by_a_property_access: diag(1477, ts.DiagnosticCategory.Error, "An_instantiation_expression_cannot_be_followed_by_a_property_access_1477", "An instantiation expression cannot be followed by a property access."), + Identifier_or_string_literal_expected: diag(1478, ts.DiagnosticCategory.Error, "Identifier_or_string_literal_expected_1478", "Identifier or string literal expected."), + The_current_file_is_a_CommonJS_module_whose_imports_will_produce_require_calls_however_the_referenced_file_is_an_ECMAScript_module_and_cannot_be_imported_with_require_Consider_writing_a_dynamic_import_0_call_instead: diag(1479, ts.DiagnosticCategory.Error, "The_current_file_is_a_CommonJS_module_whose_imports_will_produce_require_calls_however_the_reference_1479", "The current file is a CommonJS module whose imports will produce 'require' calls; however, the referenced file is an ECMAScript module and cannot be imported with 'require'. Consider writing a dynamic 'import(\"{0}\")' call instead."), + To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_create_a_local_package_json_file_with_type_Colon_module: diag(1480, ts.DiagnosticCategory.Message, "To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_create_a_local_packag_1480", "To convert this file to an ECMAScript module, change its file extension to '{0}' or create a local package.json file with `{ \"type\": \"module\" }`."), + To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_add_the_field_type_Colon_module_to_1: diag(1481, ts.DiagnosticCategory.Message, "To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_add_the_field_type_Co_1481", "To convert this file to an ECMAScript module, change its file extension to '{0}', or add the field `\"type\": \"module\"` to '{1}'."), + To_convert_this_file_to_an_ECMAScript_module_add_the_field_type_Colon_module_to_0: diag(1482, ts.DiagnosticCategory.Message, "To_convert_this_file_to_an_ECMAScript_module_add_the_field_type_Colon_module_to_0_1482", "To convert this file to an ECMAScript module, add the field `\"type\": \"module\"` to '{0}'."), + To_convert_this_file_to_an_ECMAScript_module_create_a_local_package_json_file_with_type_Colon_module: diag(1483, ts.DiagnosticCategory.Message, "To_convert_this_file_to_an_ECMAScript_module_create_a_local_package_json_file_with_type_Colon_module_1483", "To convert this file to an ECMAScript module, create a local package.json file with `{ \"type\": \"module\" }`."), + The_types_of_0_are_incompatible_between_these_types: diag(2200, ts.DiagnosticCategory.Error, "The_types_of_0_are_incompatible_between_these_types_2200", "The types of '{0}' are incompatible between these types."), + The_types_returned_by_0_are_incompatible_between_these_types: diag(2201, ts.DiagnosticCategory.Error, "The_types_returned_by_0_are_incompatible_between_these_types_2201", "The types returned by '{0}' are incompatible between these types."), + Call_signature_return_types_0_and_1_are_incompatible: diag(2202, ts.DiagnosticCategory.Error, "Call_signature_return_types_0_and_1_are_incompatible_2202", "Call signature return types '{0}' and '{1}' are incompatible.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ true), + Construct_signature_return_types_0_and_1_are_incompatible: diag(2203, ts.DiagnosticCategory.Error, "Construct_signature_return_types_0_and_1_are_incompatible_2203", "Construct signature return types '{0}' and '{1}' are incompatible.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ true), + Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: diag(2204, ts.DiagnosticCategory.Error, "Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1_2204", "Call signatures with no arguments have incompatible return types '{0}' and '{1}'.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ true), + Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: diag(2205, ts.DiagnosticCategory.Error, "Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1_2205", "Construct signatures with no arguments have incompatible return types '{0}' and '{1}'.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ true), + The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement: diag(2206, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement_2206", "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement."), + The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement: diag(2207, ts.DiagnosticCategory.Error, "The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement_2207", "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement."), + This_type_parameter_might_need_an_extends_0_constraint: diag(2208, ts.DiagnosticCategory.Error, "This_type_parameter_might_need_an_extends_0_constraint_2208", "This type parameter might need an `extends {0}` constraint."), + The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2209, ts.DiagnosticCategory.Error, "The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_roo_2209", "The project root is ambiguous, but is required to resolve export map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."), + The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate: diag(2210, ts.DiagnosticCategory.Error, "The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_roo_2210", "The project root is ambiguous, but is required to resolve import map entry '{0}' in file '{1}'. Supply the `rootDir` compiler option to disambiguate."), + Add_extends_constraint: diag(2211, ts.DiagnosticCategory.Message, "Add_extends_constraint_2211", "Add `extends` constraint."), + Add_extends_constraint_to_all_type_parameters: diag(2212, ts.DiagnosticCategory.Message, "Add_extends_constraint_to_all_type_parameters_2212", "Add `extends` constraint to all type parameters"), + Duplicate_identifier_0: diag(2300, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_2300", "Duplicate identifier '{0}'."), + Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: diag(2301, ts.DiagnosticCategory.Error, "Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2301", "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor."), + Static_members_cannot_reference_class_type_parameters: diag(2302, ts.DiagnosticCategory.Error, "Static_members_cannot_reference_class_type_parameters_2302", "Static members cannot reference class type parameters."), + Circular_definition_of_import_alias_0: diag(2303, ts.DiagnosticCategory.Error, "Circular_definition_of_import_alias_0_2303", "Circular definition of import alias '{0}'."), + Cannot_find_name_0: diag(2304, ts.DiagnosticCategory.Error, "Cannot_find_name_0_2304", "Cannot find name '{0}'."), + Module_0_has_no_exported_member_1: diag(2305, ts.DiagnosticCategory.Error, "Module_0_has_no_exported_member_1_2305", "Module '{0}' has no exported member '{1}'."), + File_0_is_not_a_module: diag(2306, ts.DiagnosticCategory.Error, "File_0_is_not_a_module_2306", "File '{0}' is not a module."), + Cannot_find_module_0_or_its_corresponding_type_declarations: diag(2307, ts.DiagnosticCategory.Error, "Cannot_find_module_0_or_its_corresponding_type_declarations_2307", "Cannot find module '{0}' or its corresponding type declarations."), + Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambiguity: diag(2308, ts.DiagnosticCategory.Error, "Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambig_2308", "Module {0} has already exported a member named '{1}'. Consider explicitly re-exporting to resolve the ambiguity."), + An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements: diag(2309, ts.DiagnosticCategory.Error, "An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements_2309", "An export assignment cannot be used in a module with other exported elements."), + Type_0_recursively_references_itself_as_a_base_type: diag(2310, ts.DiagnosticCategory.Error, "Type_0_recursively_references_itself_as_a_base_type_2310", "Type '{0}' recursively references itself as a base type."), + Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function: diag(2311, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function_2311", "Cannot find name '{0}'. Did you mean to write this in an async function?"), + An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_members: diag(2312, ts.DiagnosticCategory.Error, "An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_me_2312", "An interface can only extend an object type or intersection of object types with statically known members."), + Type_parameter_0_has_a_circular_constraint: diag(2313, ts.DiagnosticCategory.Error, "Type_parameter_0_has_a_circular_constraint_2313", "Type parameter '{0}' has a circular constraint."), + Generic_type_0_requires_1_type_argument_s: diag(2314, ts.DiagnosticCategory.Error, "Generic_type_0_requires_1_type_argument_s_2314", "Generic type '{0}' requires {1} type argument(s)."), + Type_0_is_not_generic: diag(2315, ts.DiagnosticCategory.Error, "Type_0_is_not_generic_2315", "Type '{0}' is not generic."), + Global_type_0_must_be_a_class_or_interface_type: diag(2316, ts.DiagnosticCategory.Error, "Global_type_0_must_be_a_class_or_interface_type_2316", "Global type '{0}' must be a class or interface type."), + Global_type_0_must_have_1_type_parameter_s: diag(2317, ts.DiagnosticCategory.Error, "Global_type_0_must_have_1_type_parameter_s_2317", "Global type '{0}' must have {1} type parameter(s)."), + Cannot_find_global_type_0: diag(2318, ts.DiagnosticCategory.Error, "Cannot_find_global_type_0_2318", "Cannot find global type '{0}'."), + Named_property_0_of_types_1_and_2_are_not_identical: diag(2319, ts.DiagnosticCategory.Error, "Named_property_0_of_types_1_and_2_are_not_identical_2319", "Named property '{0}' of types '{1}' and '{2}' are not identical."), + Interface_0_cannot_simultaneously_extend_types_1_and_2: diag(2320, ts.DiagnosticCategory.Error, "Interface_0_cannot_simultaneously_extend_types_1_and_2_2320", "Interface '{0}' cannot simultaneously extend types '{1}' and '{2}'."), + Excessive_stack_depth_comparing_types_0_and_1: diag(2321, ts.DiagnosticCategory.Error, "Excessive_stack_depth_comparing_types_0_and_1_2321", "Excessive stack depth comparing types '{0}' and '{1}'."), + Type_0_is_not_assignable_to_type_1: diag(2322, ts.DiagnosticCategory.Error, "Type_0_is_not_assignable_to_type_1_2322", "Type '{0}' is not assignable to type '{1}'."), + Cannot_redeclare_exported_variable_0: diag(2323, ts.DiagnosticCategory.Error, "Cannot_redeclare_exported_variable_0_2323", "Cannot redeclare exported variable '{0}'."), + Property_0_is_missing_in_type_1: diag(2324, ts.DiagnosticCategory.Error, "Property_0_is_missing_in_type_1_2324", "Property '{0}' is missing in type '{1}'."), + Property_0_is_private_in_type_1_but_not_in_type_2: diag(2325, ts.DiagnosticCategory.Error, "Property_0_is_private_in_type_1_but_not_in_type_2_2325", "Property '{0}' is private in type '{1}' but not in type '{2}'."), + Types_of_property_0_are_incompatible: diag(2326, ts.DiagnosticCategory.Error, "Types_of_property_0_are_incompatible_2326", "Types of property '{0}' are incompatible."), + Property_0_is_optional_in_type_1_but_required_in_type_2: diag(2327, ts.DiagnosticCategory.Error, "Property_0_is_optional_in_type_1_but_required_in_type_2_2327", "Property '{0}' is optional in type '{1}' but required in type '{2}'."), + Types_of_parameters_0_and_1_are_incompatible: diag(2328, ts.DiagnosticCategory.Error, "Types_of_parameters_0_and_1_are_incompatible_2328", "Types of parameters '{0}' and '{1}' are incompatible."), + Index_signature_for_type_0_is_missing_in_type_1: diag(2329, ts.DiagnosticCategory.Error, "Index_signature_for_type_0_is_missing_in_type_1_2329", "Index signature for type '{0}' is missing in type '{1}'."), + _0_and_1_index_signatures_are_incompatible: diag(2330, ts.DiagnosticCategory.Error, "_0_and_1_index_signatures_are_incompatible_2330", "'{0}' and '{1}' index signatures are incompatible."), + this_cannot_be_referenced_in_a_module_or_namespace_body: diag(2331, ts.DiagnosticCategory.Error, "this_cannot_be_referenced_in_a_module_or_namespace_body_2331", "'this' cannot be referenced in a module or namespace body."), + this_cannot_be_referenced_in_current_location: diag(2332, ts.DiagnosticCategory.Error, "this_cannot_be_referenced_in_current_location_2332", "'this' cannot be referenced in current location."), + this_cannot_be_referenced_in_constructor_arguments: diag(2333, ts.DiagnosticCategory.Error, "this_cannot_be_referenced_in_constructor_arguments_2333", "'this' cannot be referenced in constructor arguments."), + this_cannot_be_referenced_in_a_static_property_initializer: diag(2334, ts.DiagnosticCategory.Error, "this_cannot_be_referenced_in_a_static_property_initializer_2334", "'this' cannot be referenced in a static property initializer."), + super_can_only_be_referenced_in_a_derived_class: diag(2335, ts.DiagnosticCategory.Error, "super_can_only_be_referenced_in_a_derived_class_2335", "'super' can only be referenced in a derived class."), + super_cannot_be_referenced_in_constructor_arguments: diag(2336, ts.DiagnosticCategory.Error, "super_cannot_be_referenced_in_constructor_arguments_2336", "'super' cannot be referenced in constructor arguments."), + Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors: diag(2337, ts.DiagnosticCategory.Error, "Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors_2337", "Super calls are not permitted outside constructors or in nested functions inside constructors."), + super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class: diag(2338, ts.DiagnosticCategory.Error, "super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_der_2338", "'super' property access is permitted only in a constructor, member function, or member accessor of a derived class."), + Property_0_does_not_exist_on_type_1: diag(2339, ts.DiagnosticCategory.Error, "Property_0_does_not_exist_on_type_1_2339", "Property '{0}' does not exist on type '{1}'."), + Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword: diag(2340, ts.DiagnosticCategory.Error, "Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword_2340", "Only public and protected methods of the base class are accessible via the 'super' keyword."), + Property_0_is_private_and_only_accessible_within_class_1: diag(2341, ts.DiagnosticCategory.Error, "Property_0_is_private_and_only_accessible_within_class_1_2341", "Property '{0}' is private and only accessible within class '{1}'."), + This_syntax_requires_an_imported_helper_named_1_which_does_not_exist_in_0_Consider_upgrading_your_version_of_0: diag(2343, ts.DiagnosticCategory.Error, "This_syntax_requires_an_imported_helper_named_1_which_does_not_exist_in_0_Consider_upgrading_your_ve_2343", "This syntax requires an imported helper named '{1}' which does not exist in '{0}'. Consider upgrading your version of '{0}'."), + Type_0_does_not_satisfy_the_constraint_1: diag(2344, ts.DiagnosticCategory.Error, "Type_0_does_not_satisfy_the_constraint_1_2344", "Type '{0}' does not satisfy the constraint '{1}'."), + Argument_of_type_0_is_not_assignable_to_parameter_of_type_1: diag(2345, ts.DiagnosticCategory.Error, "Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_2345", "Argument of type '{0}' is not assignable to parameter of type '{1}'."), + Call_target_does_not_contain_any_signatures: diag(2346, ts.DiagnosticCategory.Error, "Call_target_does_not_contain_any_signatures_2346", "Call target does not contain any signatures."), + Untyped_function_calls_may_not_accept_type_arguments: diag(2347, ts.DiagnosticCategory.Error, "Untyped_function_calls_may_not_accept_type_arguments_2347", "Untyped function calls may not accept type arguments."), + Value_of_type_0_is_not_callable_Did_you_mean_to_include_new: diag(2348, ts.DiagnosticCategory.Error, "Value_of_type_0_is_not_callable_Did_you_mean_to_include_new_2348", "Value of type '{0}' is not callable. Did you mean to include 'new'?"), + This_expression_is_not_callable: diag(2349, ts.DiagnosticCategory.Error, "This_expression_is_not_callable_2349", "This expression is not callable."), + Only_a_void_function_can_be_called_with_the_new_keyword: diag(2350, ts.DiagnosticCategory.Error, "Only_a_void_function_can_be_called_with_the_new_keyword_2350", "Only a void function can be called with the 'new' keyword."), + This_expression_is_not_constructable: diag(2351, ts.DiagnosticCategory.Error, "This_expression_is_not_constructable_2351", "This expression is not constructable."), + Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first: diag(2352, ts.DiagnosticCategory.Error, "Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the__2352", "Conversion of type '{0}' to type '{1}' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first."), + Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1: diag(2353, ts.DiagnosticCategory.Error, "Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1_2353", "Object literal may only specify known properties, and '{0}' does not exist in type '{1}'."), + This_syntax_requires_an_imported_helper_but_module_0_cannot_be_found: diag(2354, ts.DiagnosticCategory.Error, "This_syntax_requires_an_imported_helper_but_module_0_cannot_be_found_2354", "This syntax requires an imported helper but module '{0}' cannot be found."), + A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value: diag(2355, ts.DiagnosticCategory.Error, "A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_2355", "A function whose declared type is neither 'void' nor 'any' must return a value."), + An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type: diag(2356, ts.DiagnosticCategory.Error, "An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type_2356", "An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type."), + The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access: diag(2357, ts.DiagnosticCategory.Error, "The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access_2357", "The operand of an increment or decrement operator must be a variable or a property access."), + The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: diag(2358, ts.DiagnosticCategory.Error, "The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_paramete_2358", "The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter."), + The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type: diag(2359, ts.DiagnosticCategory.Error, "The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_F_2359", "The right-hand side of an 'instanceof' expression must be of type 'any' or of a type assignable to the 'Function' interface type."), + The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type: diag(2362, ts.DiagnosticCategory.Error, "The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type_2362", "The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type."), + The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type: diag(2363, ts.DiagnosticCategory.Error, "The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type_2363", "The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type."), + The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access: diag(2364, ts.DiagnosticCategory.Error, "The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access_2364", "The left-hand side of an assignment expression must be a variable or a property access."), + Operator_0_cannot_be_applied_to_types_1_and_2: diag(2365, ts.DiagnosticCategory.Error, "Operator_0_cannot_be_applied_to_types_1_and_2_2365", "Operator '{0}' cannot be applied to types '{1}' and '{2}'."), + Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined: diag(2366, ts.DiagnosticCategory.Error, "Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined_2366", "Function lacks ending return statement and return type does not include 'undefined'."), + This_comparison_appears_to_be_unintentional_because_the_types_0_and_1_have_no_overlap: diag(2367, ts.DiagnosticCategory.Error, "This_comparison_appears_to_be_unintentional_because_the_types_0_and_1_have_no_overlap_2367", "This comparison appears to be unintentional because the types '{0}' and '{1}' have no overlap."), + Type_parameter_name_cannot_be_0: diag(2368, ts.DiagnosticCategory.Error, "Type_parameter_name_cannot_be_0_2368", "Type parameter name cannot be '{0}'."), + A_parameter_property_is_only_allowed_in_a_constructor_implementation: diag(2369, ts.DiagnosticCategory.Error, "A_parameter_property_is_only_allowed_in_a_constructor_implementation_2369", "A parameter property is only allowed in a constructor implementation."), + A_rest_parameter_must_be_of_an_array_type: diag(2370, ts.DiagnosticCategory.Error, "A_rest_parameter_must_be_of_an_array_type_2370", "A rest parameter must be of an array type."), + A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation: diag(2371, ts.DiagnosticCategory.Error, "A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation_2371", "A parameter initializer is only allowed in a function or constructor implementation."), + Parameter_0_cannot_reference_itself: diag(2372, ts.DiagnosticCategory.Error, "Parameter_0_cannot_reference_itself_2372", "Parameter '{0}' cannot reference itself."), + Parameter_0_cannot_reference_identifier_1_declared_after_it: diag(2373, ts.DiagnosticCategory.Error, "Parameter_0_cannot_reference_identifier_1_declared_after_it_2373", "Parameter '{0}' cannot reference identifier '{1}' declared after it."), + Duplicate_index_signature_for_type_0: diag(2374, ts.DiagnosticCategory.Error, "Duplicate_index_signature_for_type_0_2374", "Duplicate index signature for type '{0}'."), + Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties: diag(2375, ts.DiagnosticCategory.Error, "Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefi_2375", "Type '{0}' is not assignable to type '{1}' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties."), + A_super_call_must_be_the_first_statement_in_the_constructor_to_refer_to_super_or_this_when_a_derived_class_contains_initialized_properties_parameter_properties_or_private_identifiers: diag(2376, ts.DiagnosticCategory.Error, "A_super_call_must_be_the_first_statement_in_the_constructor_to_refer_to_super_or_this_when_a_derived_2376", "A 'super' call must be the first statement in the constructor to refer to 'super' or 'this' when a derived class contains initialized properties, parameter properties, or private identifiers."), + Constructors_for_derived_classes_must_contain_a_super_call: diag(2377, ts.DiagnosticCategory.Error, "Constructors_for_derived_classes_must_contain_a_super_call_2377", "Constructors for derived classes must contain a 'super' call."), + A_get_accessor_must_return_a_value: diag(2378, ts.DiagnosticCategory.Error, "A_get_accessor_must_return_a_value_2378", "A 'get' accessor must return a value."), + Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties: diag(2379, ts.DiagnosticCategory.Error, "Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_tr_2379", "Argument of type '{0}' is not assignable to parameter of type '{1}' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the types of the target's properties."), + The_return_type_of_a_get_accessor_must_be_assignable_to_its_set_accessor_type: diag(2380, ts.DiagnosticCategory.Error, "The_return_type_of_a_get_accessor_must_be_assignable_to_its_set_accessor_type_2380", "The return type of a 'get' accessor must be assignable to its 'set' accessor type"), + Overload_signatures_must_all_be_exported_or_non_exported: diag(2383, ts.DiagnosticCategory.Error, "Overload_signatures_must_all_be_exported_or_non_exported_2383", "Overload signatures must all be exported or non-exported."), + Overload_signatures_must_all_be_ambient_or_non_ambient: diag(2384, ts.DiagnosticCategory.Error, "Overload_signatures_must_all_be_ambient_or_non_ambient_2384", "Overload signatures must all be ambient or non-ambient."), + Overload_signatures_must_all_be_public_private_or_protected: diag(2385, ts.DiagnosticCategory.Error, "Overload_signatures_must_all_be_public_private_or_protected_2385", "Overload signatures must all be public, private or protected."), + Overload_signatures_must_all_be_optional_or_required: diag(2386, ts.DiagnosticCategory.Error, "Overload_signatures_must_all_be_optional_or_required_2386", "Overload signatures must all be optional or required."), + Function_overload_must_be_static: diag(2387, ts.DiagnosticCategory.Error, "Function_overload_must_be_static_2387", "Function overload must be static."), + Function_overload_must_not_be_static: diag(2388, ts.DiagnosticCategory.Error, "Function_overload_must_not_be_static_2388", "Function overload must not be static."), + Function_implementation_name_must_be_0: diag(2389, ts.DiagnosticCategory.Error, "Function_implementation_name_must_be_0_2389", "Function implementation name must be '{0}'."), + Constructor_implementation_is_missing: diag(2390, ts.DiagnosticCategory.Error, "Constructor_implementation_is_missing_2390", "Constructor implementation is missing."), + Function_implementation_is_missing_or_not_immediately_following_the_declaration: diag(2391, ts.DiagnosticCategory.Error, "Function_implementation_is_missing_or_not_immediately_following_the_declaration_2391", "Function implementation is missing or not immediately following the declaration."), + Multiple_constructor_implementations_are_not_allowed: diag(2392, ts.DiagnosticCategory.Error, "Multiple_constructor_implementations_are_not_allowed_2392", "Multiple constructor implementations are not allowed."), + Duplicate_function_implementation: diag(2393, ts.DiagnosticCategory.Error, "Duplicate_function_implementation_2393", "Duplicate function implementation."), + This_overload_signature_is_not_compatible_with_its_implementation_signature: diag(2394, ts.DiagnosticCategory.Error, "This_overload_signature_is_not_compatible_with_its_implementation_signature_2394", "This overload signature is not compatible with its implementation signature."), + Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local: diag(2395, ts.DiagnosticCategory.Error, "Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local_2395", "Individual declarations in merged declaration '{0}' must be all exported or all local."), + Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters: diag(2396, ts.DiagnosticCategory.Error, "Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters_2396", "Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters."), + Declaration_name_conflicts_with_built_in_global_identifier_0: diag(2397, ts.DiagnosticCategory.Error, "Declaration_name_conflicts_with_built_in_global_identifier_0_2397", "Declaration name conflicts with built-in global identifier '{0}'."), + constructor_cannot_be_used_as_a_parameter_property_name: diag(2398, ts.DiagnosticCategory.Error, "constructor_cannot_be_used_as_a_parameter_property_name_2398", "'constructor' cannot be used as a parameter property name."), + Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference: diag(2399, ts.DiagnosticCategory.Error, "Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference_2399", "Duplicate identifier '_this'. Compiler uses variable declaration '_this' to capture 'this' reference."), + Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference: diag(2400, ts.DiagnosticCategory.Error, "Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference_2400", "Expression resolves to variable declaration '_this' that compiler uses to capture 'this' reference."), + A_super_call_must_be_a_root_level_statement_within_a_constructor_of_a_derived_class_that_contains_initialized_properties_parameter_properties_or_private_identifiers: diag(2401, ts.DiagnosticCategory.Error, "A_super_call_must_be_a_root_level_statement_within_a_constructor_of_a_derived_class_that_contains_in_2401", "A 'super' call must be a root-level statement within a constructor of a derived class that contains initialized properties, parameter properties, or private identifiers."), + Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference: diag(2402, ts.DiagnosticCategory.Error, "Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference_2402", "Expression resolves to '_super' that compiler uses to capture base class reference."), + Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2: diag(2403, ts.DiagnosticCategory.Error, "Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_t_2403", "Subsequent variable declarations must have the same type. Variable '{0}' must be of type '{1}', but here has type '{2}'."), + The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation: diag(2404, ts.DiagnosticCategory.Error, "The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation_2404", "The left-hand side of a 'for...in' statement cannot use a type annotation."), + The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any: diag(2405, ts.DiagnosticCategory.Error, "The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any_2405", "The left-hand side of a 'for...in' statement must be of type 'string' or 'any'."), + The_left_hand_side_of_a_for_in_statement_must_be_a_variable_or_a_property_access: diag(2406, ts.DiagnosticCategory.Error, "The_left_hand_side_of_a_for_in_statement_must_be_a_variable_or_a_property_access_2406", "The left-hand side of a 'for...in' statement must be a variable or a property access."), + The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter_but_here_has_type_0: diag(2407, ts.DiagnosticCategory.Error, "The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter_but_2407", "The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter, but here has type '{0}'."), + Setters_cannot_return_a_value: diag(2408, ts.DiagnosticCategory.Error, "Setters_cannot_return_a_value_2408", "Setters cannot return a value."), + Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class: diag(2409, ts.DiagnosticCategory.Error, "Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class_2409", "Return type of constructor signature must be assignable to the instance type of the class."), + The_with_statement_is_not_supported_All_symbols_in_a_with_block_will_have_type_any: diag(2410, ts.DiagnosticCategory.Error, "The_with_statement_is_not_supported_All_symbols_in_a_with_block_will_have_type_any_2410", "The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'."), + Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_type_of_the_target: diag(2412, ts.DiagnosticCategory.Error, "Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefi_2412", "Type '{0}' is not assignable to type '{1}' with 'exactOptionalPropertyTypes: true'. Consider adding 'undefined' to the type of the target."), + Property_0_of_type_1_is_not_assignable_to_2_index_type_3: diag(2411, ts.DiagnosticCategory.Error, "Property_0_of_type_1_is_not_assignable_to_2_index_type_3_2411", "Property '{0}' of type '{1}' is not assignable to '{2}' index type '{3}'."), + _0_index_type_1_is_not_assignable_to_2_index_type_3: diag(2413, ts.DiagnosticCategory.Error, "_0_index_type_1_is_not_assignable_to_2_index_type_3_2413", "'{0}' index type '{1}' is not assignable to '{2}' index type '{3}'."), + Class_name_cannot_be_0: diag(2414, ts.DiagnosticCategory.Error, "Class_name_cannot_be_0_2414", "Class name cannot be '{0}'."), + Class_0_incorrectly_extends_base_class_1: diag(2415, ts.DiagnosticCategory.Error, "Class_0_incorrectly_extends_base_class_1_2415", "Class '{0}' incorrectly extends base class '{1}'."), + Property_0_in_type_1_is_not_assignable_to_the_same_property_in_base_type_2: diag(2416, ts.DiagnosticCategory.Error, "Property_0_in_type_1_is_not_assignable_to_the_same_property_in_base_type_2_2416", "Property '{0}' in type '{1}' is not assignable to the same property in base type '{2}'."), + Class_static_side_0_incorrectly_extends_base_class_static_side_1: diag(2417, ts.DiagnosticCategory.Error, "Class_static_side_0_incorrectly_extends_base_class_static_side_1_2417", "Class static side '{0}' incorrectly extends base class static side '{1}'."), + Type_of_computed_property_s_value_is_0_which_is_not_assignable_to_type_1: diag(2418, ts.DiagnosticCategory.Error, "Type_of_computed_property_s_value_is_0_which_is_not_assignable_to_type_1_2418", "Type of computed property's value is '{0}', which is not assignable to type '{1}'."), + Types_of_construct_signatures_are_incompatible: diag(2419, ts.DiagnosticCategory.Error, "Types_of_construct_signatures_are_incompatible_2419", "Types of construct signatures are incompatible."), + Class_0_incorrectly_implements_interface_1: diag(2420, ts.DiagnosticCategory.Error, "Class_0_incorrectly_implements_interface_1_2420", "Class '{0}' incorrectly implements interface '{1}'."), + A_class_can_only_implement_an_object_type_or_intersection_of_object_types_with_statically_known_members: diag(2422, ts.DiagnosticCategory.Error, "A_class_can_only_implement_an_object_type_or_intersection_of_object_types_with_statically_known_memb_2422", "A class can only implement an object type or intersection of object types with statically known members."), + Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor: diag(2423, ts.DiagnosticCategory.Error, "Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_access_2423", "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member accessor."), + Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function: diag(2425, ts.DiagnosticCategory.Error, "Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_functi_2425", "Class '{0}' defines instance member property '{1}', but extended class '{2}' defines it as instance member function."), + Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function: diag(2426, ts.DiagnosticCategory.Error, "Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_functi_2426", "Class '{0}' defines instance member accessor '{1}', but extended class '{2}' defines it as instance member function."), + Interface_name_cannot_be_0: diag(2427, ts.DiagnosticCategory.Error, "Interface_name_cannot_be_0_2427", "Interface name cannot be '{0}'."), + All_declarations_of_0_must_have_identical_type_parameters: diag(2428, ts.DiagnosticCategory.Error, "All_declarations_of_0_must_have_identical_type_parameters_2428", "All declarations of '{0}' must have identical type parameters."), + Interface_0_incorrectly_extends_interface_1: diag(2430, ts.DiagnosticCategory.Error, "Interface_0_incorrectly_extends_interface_1_2430", "Interface '{0}' incorrectly extends interface '{1}'."), + Enum_name_cannot_be_0: diag(2431, ts.DiagnosticCategory.Error, "Enum_name_cannot_be_0_2431", "Enum name cannot be '{0}'."), + In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enum_element: diag(2432, ts.DiagnosticCategory.Error, "In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enu_2432", "In an enum with multiple declarations, only one declaration can omit an initializer for its first enum element."), + A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merged: diag(2433, ts.DiagnosticCategory.Error, "A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merg_2433", "A namespace declaration cannot be in a different file from a class or function with which it is merged."), + A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged: diag(2434, ts.DiagnosticCategory.Error, "A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged_2434", "A namespace declaration cannot be located prior to a class or function with which it is merged."), + Ambient_modules_cannot_be_nested_in_other_modules_or_namespaces: diag(2435, ts.DiagnosticCategory.Error, "Ambient_modules_cannot_be_nested_in_other_modules_or_namespaces_2435", "Ambient modules cannot be nested in other modules or namespaces."), + Ambient_module_declaration_cannot_specify_relative_module_name: diag(2436, ts.DiagnosticCategory.Error, "Ambient_module_declaration_cannot_specify_relative_module_name_2436", "Ambient module declaration cannot specify relative module name."), + Module_0_is_hidden_by_a_local_declaration_with_the_same_name: diag(2437, ts.DiagnosticCategory.Error, "Module_0_is_hidden_by_a_local_declaration_with_the_same_name_2437", "Module '{0}' is hidden by a local declaration with the same name."), + Import_name_cannot_be_0: diag(2438, ts.DiagnosticCategory.Error, "Import_name_cannot_be_0_2438", "Import name cannot be '{0}'."), + Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relative_module_name: diag(2439, ts.DiagnosticCategory.Error, "Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relati_2439", "Import or export declaration in an ambient module declaration cannot reference module through relative module name."), + Import_declaration_conflicts_with_local_declaration_of_0: diag(2440, ts.DiagnosticCategory.Error, "Import_declaration_conflicts_with_local_declaration_of_0_2440", "Import declaration conflicts with local declaration of '{0}'."), + Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module: diag(2441, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_2441", "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of a module."), + Types_have_separate_declarations_of_a_private_property_0: diag(2442, ts.DiagnosticCategory.Error, "Types_have_separate_declarations_of_a_private_property_0_2442", "Types have separate declarations of a private property '{0}'."), + Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2: diag(2443, ts.DiagnosticCategory.Error, "Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2_2443", "Property '{0}' is protected but type '{1}' is not a class derived from '{2}'."), + Property_0_is_protected_in_type_1_but_public_in_type_2: diag(2444, ts.DiagnosticCategory.Error, "Property_0_is_protected_in_type_1_but_public_in_type_2_2444", "Property '{0}' is protected in type '{1}' but public in type '{2}'."), + Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses: diag(2445, ts.DiagnosticCategory.Error, "Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses_2445", "Property '{0}' is protected and only accessible within class '{1}' and its subclasses."), + Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1_This_is_an_instance_of_class_2: diag(2446, ts.DiagnosticCategory.Error, "Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1_This_is_an_instance_of_cl_2446", "Property '{0}' is protected and only accessible through an instance of class '{1}'. This is an instance of class '{2}'."), + The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead: diag(2447, ts.DiagnosticCategory.Error, "The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead_2447", "The '{0}' operator is not allowed for boolean types. Consider using '{1}' instead."), + Block_scoped_variable_0_used_before_its_declaration: diag(2448, ts.DiagnosticCategory.Error, "Block_scoped_variable_0_used_before_its_declaration_2448", "Block-scoped variable '{0}' used before its declaration."), + Class_0_used_before_its_declaration: diag(2449, ts.DiagnosticCategory.Error, "Class_0_used_before_its_declaration_2449", "Class '{0}' used before its declaration."), + Enum_0_used_before_its_declaration: diag(2450, ts.DiagnosticCategory.Error, "Enum_0_used_before_its_declaration_2450", "Enum '{0}' used before its declaration."), + Cannot_redeclare_block_scoped_variable_0: diag(2451, ts.DiagnosticCategory.Error, "Cannot_redeclare_block_scoped_variable_0_2451", "Cannot redeclare block-scoped variable '{0}'."), + An_enum_member_cannot_have_a_numeric_name: diag(2452, ts.DiagnosticCategory.Error, "An_enum_member_cannot_have_a_numeric_name_2452", "An enum member cannot have a numeric name."), + Variable_0_is_used_before_being_assigned: diag(2454, ts.DiagnosticCategory.Error, "Variable_0_is_used_before_being_assigned_2454", "Variable '{0}' is used before being assigned."), + Type_alias_0_circularly_references_itself: diag(2456, ts.DiagnosticCategory.Error, "Type_alias_0_circularly_references_itself_2456", "Type alias '{0}' circularly references itself."), + Type_alias_name_cannot_be_0: diag(2457, ts.DiagnosticCategory.Error, "Type_alias_name_cannot_be_0_2457", "Type alias name cannot be '{0}'."), + An_AMD_module_cannot_have_multiple_name_assignments: diag(2458, ts.DiagnosticCategory.Error, "An_AMD_module_cannot_have_multiple_name_assignments_2458", "An AMD module cannot have multiple name assignments."), + Module_0_declares_1_locally_but_it_is_not_exported: diag(2459, ts.DiagnosticCategory.Error, "Module_0_declares_1_locally_but_it_is_not_exported_2459", "Module '{0}' declares '{1}' locally, but it is not exported."), + Module_0_declares_1_locally_but_it_is_exported_as_2: diag(2460, ts.DiagnosticCategory.Error, "Module_0_declares_1_locally_but_it_is_exported_as_2_2460", "Module '{0}' declares '{1}' locally, but it is exported as '{2}'."), + Type_0_is_not_an_array_type: diag(2461, ts.DiagnosticCategory.Error, "Type_0_is_not_an_array_type_2461", "Type '{0}' is not an array type."), + A_rest_element_must_be_last_in_a_destructuring_pattern: diag(2462, ts.DiagnosticCategory.Error, "A_rest_element_must_be_last_in_a_destructuring_pattern_2462", "A rest element must be last in a destructuring pattern."), + A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature: diag(2463, ts.DiagnosticCategory.Error, "A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature_2463", "A binding pattern parameter cannot be optional in an implementation signature."), + A_computed_property_name_must_be_of_type_string_number_symbol_or_any: diag(2464, ts.DiagnosticCategory.Error, "A_computed_property_name_must_be_of_type_string_number_symbol_or_any_2464", "A computed property name must be of type 'string', 'number', 'symbol', or 'any'."), + this_cannot_be_referenced_in_a_computed_property_name: diag(2465, ts.DiagnosticCategory.Error, "this_cannot_be_referenced_in_a_computed_property_name_2465", "'this' cannot be referenced in a computed property name."), + super_cannot_be_referenced_in_a_computed_property_name: diag(2466, ts.DiagnosticCategory.Error, "super_cannot_be_referenced_in_a_computed_property_name_2466", "'super' cannot be referenced in a computed property name."), + A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type: diag(2467, ts.DiagnosticCategory.Error, "A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type_2467", "A computed property name cannot reference a type parameter from its containing type."), + Cannot_find_global_value_0: diag(2468, ts.DiagnosticCategory.Error, "Cannot_find_global_value_0_2468", "Cannot find global value '{0}'."), + The_0_operator_cannot_be_applied_to_type_symbol: diag(2469, ts.DiagnosticCategory.Error, "The_0_operator_cannot_be_applied_to_type_symbol_2469", "The '{0}' operator cannot be applied to type 'symbol'."), + Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher: diag(2472, ts.DiagnosticCategory.Error, "Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher_2472", "Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher."), + Enum_declarations_must_all_be_const_or_non_const: diag(2473, ts.DiagnosticCategory.Error, "Enum_declarations_must_all_be_const_or_non_const_2473", "Enum declarations must all be const or non-const."), + const_enum_member_initializers_can_only_contain_literal_values_and_other_computed_enum_values: diag(2474, ts.DiagnosticCategory.Error, "const_enum_member_initializers_can_only_contain_literal_values_and_other_computed_enum_values_2474", "const enum member initializers can only contain literal values and other computed enum values."), + const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment_or_type_query: diag(2475, ts.DiagnosticCategory.Error, "const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_im_2475", "'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment or type query."), + A_const_enum_member_can_only_be_accessed_using_a_string_literal: diag(2476, ts.DiagnosticCategory.Error, "A_const_enum_member_can_only_be_accessed_using_a_string_literal_2476", "A const enum member can only be accessed using a string literal."), + const_enum_member_initializer_was_evaluated_to_a_non_finite_value: diag(2477, ts.DiagnosticCategory.Error, "const_enum_member_initializer_was_evaluated_to_a_non_finite_value_2477", "'const' enum member initializer was evaluated to a non-finite value."), + const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN: diag(2478, ts.DiagnosticCategory.Error, "const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN_2478", "'const' enum member initializer was evaluated to disallowed value 'NaN'."), + let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations: diag(2480, ts.DiagnosticCategory.Error, "let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations_2480", "'let' is not allowed to be used as a name in 'let' or 'const' declarations."), + Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1: diag(2481, ts.DiagnosticCategory.Error, "Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1_2481", "Cannot initialize outer scoped variable '{0}' in the same scope as block scoped declaration '{1}'."), + The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation: diag(2483, ts.DiagnosticCategory.Error, "The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation_2483", "The left-hand side of a 'for...of' statement cannot use a type annotation."), + Export_declaration_conflicts_with_exported_declaration_of_0: diag(2484, ts.DiagnosticCategory.Error, "Export_declaration_conflicts_with_exported_declaration_of_0_2484", "Export declaration conflicts with exported declaration of '{0}'."), + The_left_hand_side_of_a_for_of_statement_must_be_a_variable_or_a_property_access: diag(2487, ts.DiagnosticCategory.Error, "The_left_hand_side_of_a_for_of_statement_must_be_a_variable_or_a_property_access_2487", "The left-hand side of a 'for...of' statement must be a variable or a property access."), + Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator: diag(2488, ts.DiagnosticCategory.Error, "Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator_2488", "Type '{0}' must have a '[Symbol.iterator]()' method that returns an iterator."), + An_iterator_must_have_a_next_method: diag(2489, ts.DiagnosticCategory.Error, "An_iterator_must_have_a_next_method_2489", "An iterator must have a 'next()' method."), + The_type_returned_by_the_0_method_of_an_iterator_must_have_a_value_property: diag(2490, ts.DiagnosticCategory.Error, "The_type_returned_by_the_0_method_of_an_iterator_must_have_a_value_property_2490", "The type returned by the '{0}()' method of an iterator must have a 'value' property."), + The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern: diag(2491, ts.DiagnosticCategory.Error, "The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern_2491", "The left-hand side of a 'for...in' statement cannot be a destructuring pattern."), + Cannot_redeclare_identifier_0_in_catch_clause: diag(2492, ts.DiagnosticCategory.Error, "Cannot_redeclare_identifier_0_in_catch_clause_2492", "Cannot redeclare identifier '{0}' in catch clause."), + Tuple_type_0_of_length_1_has_no_element_at_index_2: diag(2493, ts.DiagnosticCategory.Error, "Tuple_type_0_of_length_1_has_no_element_at_index_2_2493", "Tuple type '{0}' of length '{1}' has no element at index '{2}'."), + Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher: diag(2494, ts.DiagnosticCategory.Error, "Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher_2494", "Using a string in a 'for...of' statement is only supported in ECMAScript 5 and higher."), + Type_0_is_not_an_array_type_or_a_string_type: diag(2495, ts.DiagnosticCategory.Error, "Type_0_is_not_an_array_type_or_a_string_type_2495", "Type '{0}' is not an array type or a string type."), + The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression: diag(2496, ts.DiagnosticCategory.Error, "The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_stand_2496", "The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression."), + This_module_can_only_be_referenced_with_ECMAScript_imports_Slashexports_by_turning_on_the_0_flag_and_referencing_its_default_export: diag(2497, ts.DiagnosticCategory.Error, "This_module_can_only_be_referenced_with_ECMAScript_imports_Slashexports_by_turning_on_the_0_flag_and_2497", "This module can only be referenced with ECMAScript imports/exports by turning on the '{0}' flag and referencing its default export."), + Module_0_uses_export_and_cannot_be_used_with_export_Asterisk: diag(2498, ts.DiagnosticCategory.Error, "Module_0_uses_export_and_cannot_be_used_with_export_Asterisk_2498", "Module '{0}' uses 'export =' and cannot be used with 'export *'."), + An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments: diag(2499, ts.DiagnosticCategory.Error, "An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments_2499", "An interface can only extend an identifier/qualified-name with optional type arguments."), + A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments: diag(2500, ts.DiagnosticCategory.Error, "A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments_2500", "A class can only implement an identifier/qualified-name with optional type arguments."), + A_rest_element_cannot_contain_a_binding_pattern: diag(2501, ts.DiagnosticCategory.Error, "A_rest_element_cannot_contain_a_binding_pattern_2501", "A rest element cannot contain a binding pattern."), + _0_is_referenced_directly_or_indirectly_in_its_own_type_annotation: diag(2502, ts.DiagnosticCategory.Error, "_0_is_referenced_directly_or_indirectly_in_its_own_type_annotation_2502", "'{0}' is referenced directly or indirectly in its own type annotation."), + Cannot_find_namespace_0: diag(2503, ts.DiagnosticCategory.Error, "Cannot_find_namespace_0_2503", "Cannot find namespace '{0}'."), + Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator: diag(2504, ts.DiagnosticCategory.Error, "Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator_2504", "Type '{0}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator."), + A_generator_cannot_have_a_void_type_annotation: diag(2505, ts.DiagnosticCategory.Error, "A_generator_cannot_have_a_void_type_annotation_2505", "A generator cannot have a 'void' type annotation."), + _0_is_referenced_directly_or_indirectly_in_its_own_base_expression: diag(2506, ts.DiagnosticCategory.Error, "_0_is_referenced_directly_or_indirectly_in_its_own_base_expression_2506", "'{0}' is referenced directly or indirectly in its own base expression."), + Type_0_is_not_a_constructor_function_type: diag(2507, ts.DiagnosticCategory.Error, "Type_0_is_not_a_constructor_function_type_2507", "Type '{0}' is not a constructor function type."), + No_base_constructor_has_the_specified_number_of_type_arguments: diag(2508, ts.DiagnosticCategory.Error, "No_base_constructor_has_the_specified_number_of_type_arguments_2508", "No base constructor has the specified number of type arguments."), + Base_constructor_return_type_0_is_not_an_object_type_or_intersection_of_object_types_with_statically_known_members: diag(2509, ts.DiagnosticCategory.Error, "Base_constructor_return_type_0_is_not_an_object_type_or_intersection_of_object_types_with_statically_2509", "Base constructor return type '{0}' is not an object type or intersection of object types with statically known members."), + Base_constructors_must_all_have_the_same_return_type: diag(2510, ts.DiagnosticCategory.Error, "Base_constructors_must_all_have_the_same_return_type_2510", "Base constructors must all have the same return type."), + Cannot_create_an_instance_of_an_abstract_class: diag(2511, ts.DiagnosticCategory.Error, "Cannot_create_an_instance_of_an_abstract_class_2511", "Cannot create an instance of an abstract class."), + Overload_signatures_must_all_be_abstract_or_non_abstract: diag(2512, ts.DiagnosticCategory.Error, "Overload_signatures_must_all_be_abstract_or_non_abstract_2512", "Overload signatures must all be abstract or non-abstract."), + Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression: diag(2513, ts.DiagnosticCategory.Error, "Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression_2513", "Abstract method '{0}' in class '{1}' cannot be accessed via super expression."), + A_tuple_type_cannot_be_indexed_with_a_negative_value: diag(2514, ts.DiagnosticCategory.Error, "A_tuple_type_cannot_be_indexed_with_a_negative_value_2514", "A tuple type cannot be indexed with a negative value."), + Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2: diag(2515, ts.DiagnosticCategory.Error, "Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2_2515", "Non-abstract class '{0}' does not implement inherited abstract member '{1}' from class '{2}'."), + All_declarations_of_an_abstract_method_must_be_consecutive: diag(2516, ts.DiagnosticCategory.Error, "All_declarations_of_an_abstract_method_must_be_consecutive_2516", "All declarations of an abstract method must be consecutive."), + Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type: diag(2517, ts.DiagnosticCategory.Error, "Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type_2517", "Cannot assign an abstract constructor type to a non-abstract constructor type."), + A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard: diag(2518, ts.DiagnosticCategory.Error, "A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard_2518", "A 'this'-based type guard is not compatible with a parameter-based type guard."), + An_async_iterator_must_have_a_next_method: diag(2519, ts.DiagnosticCategory.Error, "An_async_iterator_must_have_a_next_method_2519", "An async iterator must have a 'next()' method."), + Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions: diag(2520, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions_2520", "Duplicate identifier '{0}'. Compiler uses declaration '{1}' to support async functions."), + The_arguments_object_cannot_be_referenced_in_an_async_function_or_method_in_ES3_and_ES5_Consider_using_a_standard_function_or_method: diag(2522, ts.DiagnosticCategory.Error, "The_arguments_object_cannot_be_referenced_in_an_async_function_or_method_in_ES3_and_ES5_Consider_usi_2522", "The 'arguments' object cannot be referenced in an async function or method in ES3 and ES5. Consider using a standard function or method."), + yield_expressions_cannot_be_used_in_a_parameter_initializer: diag(2523, ts.DiagnosticCategory.Error, "yield_expressions_cannot_be_used_in_a_parameter_initializer_2523", "'yield' expressions cannot be used in a parameter initializer."), + await_expressions_cannot_be_used_in_a_parameter_initializer: diag(2524, ts.DiagnosticCategory.Error, "await_expressions_cannot_be_used_in_a_parameter_initializer_2524", "'await' expressions cannot be used in a parameter initializer."), + Initializer_provides_no_value_for_this_binding_element_and_the_binding_element_has_no_default_value: diag(2525, ts.DiagnosticCategory.Error, "Initializer_provides_no_value_for_this_binding_element_and_the_binding_element_has_no_default_value_2525", "Initializer provides no value for this binding element and the binding element has no default value."), + A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface: diag(2526, ts.DiagnosticCategory.Error, "A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface_2526", "A 'this' type is available only in a non-static member of a class or interface."), + The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary: diag(2527, ts.DiagnosticCategory.Error, "The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary_2527", "The inferred type of '{0}' references an inaccessible '{1}' type. A type annotation is necessary."), + A_module_cannot_have_multiple_default_exports: diag(2528, ts.DiagnosticCategory.Error, "A_module_cannot_have_multiple_default_exports_2528", "A module cannot have multiple default exports."), + Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_functions: diag(2529, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_func_2529", "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of a module containing async functions."), + Property_0_is_incompatible_with_index_signature: diag(2530, ts.DiagnosticCategory.Error, "Property_0_is_incompatible_with_index_signature_2530", "Property '{0}' is incompatible with index signature."), + Object_is_possibly_null: diag(2531, ts.DiagnosticCategory.Error, "Object_is_possibly_null_2531", "Object is possibly 'null'."), + Object_is_possibly_undefined: diag(2532, ts.DiagnosticCategory.Error, "Object_is_possibly_undefined_2532", "Object is possibly 'undefined'."), + Object_is_possibly_null_or_undefined: diag(2533, ts.DiagnosticCategory.Error, "Object_is_possibly_null_or_undefined_2533", "Object is possibly 'null' or 'undefined'."), + A_function_returning_never_cannot_have_a_reachable_end_point: diag(2534, ts.DiagnosticCategory.Error, "A_function_returning_never_cannot_have_a_reachable_end_point_2534", "A function returning 'never' cannot have a reachable end point."), + Enum_type_0_has_members_with_initializers_that_are_not_literals: diag(2535, ts.DiagnosticCategory.Error, "Enum_type_0_has_members_with_initializers_that_are_not_literals_2535", "Enum type '{0}' has members with initializers that are not literals."), + Type_0_cannot_be_used_to_index_type_1: diag(2536, ts.DiagnosticCategory.Error, "Type_0_cannot_be_used_to_index_type_1_2536", "Type '{0}' cannot be used to index type '{1}'."), + Type_0_has_no_matching_index_signature_for_type_1: diag(2537, ts.DiagnosticCategory.Error, "Type_0_has_no_matching_index_signature_for_type_1_2537", "Type '{0}' has no matching index signature for type '{1}'."), + Type_0_cannot_be_used_as_an_index_type: diag(2538, ts.DiagnosticCategory.Error, "Type_0_cannot_be_used_as_an_index_type_2538", "Type '{0}' cannot be used as an index type."), + Cannot_assign_to_0_because_it_is_not_a_variable: diag(2539, ts.DiagnosticCategory.Error, "Cannot_assign_to_0_because_it_is_not_a_variable_2539", "Cannot assign to '{0}' because it is not a variable."), + Cannot_assign_to_0_because_it_is_a_read_only_property: diag(2540, ts.DiagnosticCategory.Error, "Cannot_assign_to_0_because_it_is_a_read_only_property_2540", "Cannot assign to '{0}' because it is a read-only property."), + Index_signature_in_type_0_only_permits_reading: diag(2542, ts.DiagnosticCategory.Error, "Index_signature_in_type_0_only_permits_reading_2542", "Index signature in type '{0}' only permits reading."), + Duplicate_identifier_newTarget_Compiler_uses_variable_declaration_newTarget_to_capture_new_target_meta_property_reference: diag(2543, ts.DiagnosticCategory.Error, "Duplicate_identifier_newTarget_Compiler_uses_variable_declaration_newTarget_to_capture_new_target_me_2543", "Duplicate identifier '_newTarget'. Compiler uses variable declaration '_newTarget' to capture 'new.target' meta-property reference."), + Expression_resolves_to_variable_declaration_newTarget_that_compiler_uses_to_capture_new_target_meta_property_reference: diag(2544, ts.DiagnosticCategory.Error, "Expression_resolves_to_variable_declaration_newTarget_that_compiler_uses_to_capture_new_target_meta__2544", "Expression resolves to variable declaration '_newTarget' that compiler uses to capture 'new.target' meta-property reference."), + A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any: diag(2545, ts.DiagnosticCategory.Error, "A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any_2545", "A mixin class must have a constructor with a single rest parameter of type 'any[]'."), + The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property: diag(2547, ts.DiagnosticCategory.Error, "The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_pro_2547", "The type returned by the '{0}()' method of an async iterator must be a promise for a type with a 'value' property."), + Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator: diag(2548, ts.DiagnosticCategory.Error, "Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator_2548", "Type '{0}' is not an array type or does not have a '[Symbol.iterator]()' method that returns an iterator."), + Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator: diag(2549, ts.DiagnosticCategory.Error, "Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns__2549", "Type '{0}' is not an array type or a string type or does not have a '[Symbol.iterator]()' method that returns an iterator."), + Property_0_does_not_exist_on_type_1_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_2_or_later: diag(2550, ts.DiagnosticCategory.Error, "Property_0_does_not_exist_on_type_1_Do_you_need_to_change_your_target_library_Try_changing_the_lib_c_2550", "Property '{0}' does not exist on type '{1}'. Do you need to change your target library? Try changing the 'lib' compiler option to '{2}' or later."), + Property_0_does_not_exist_on_type_1_Did_you_mean_2: diag(2551, ts.DiagnosticCategory.Error, "Property_0_does_not_exist_on_type_1_Did_you_mean_2_2551", "Property '{0}' does not exist on type '{1}'. Did you mean '{2}'?"), + Cannot_find_name_0_Did_you_mean_1: diag(2552, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Did_you_mean_1_2552", "Cannot find name '{0}'. Did you mean '{1}'?"), + Computed_values_are_not_permitted_in_an_enum_with_string_valued_members: diag(2553, ts.DiagnosticCategory.Error, "Computed_values_are_not_permitted_in_an_enum_with_string_valued_members_2553", "Computed values are not permitted in an enum with string valued members."), + Expected_0_arguments_but_got_1: diag(2554, ts.DiagnosticCategory.Error, "Expected_0_arguments_but_got_1_2554", "Expected {0} arguments, but got {1}."), + Expected_at_least_0_arguments_but_got_1: diag(2555, ts.DiagnosticCategory.Error, "Expected_at_least_0_arguments_but_got_1_2555", "Expected at least {0} arguments, but got {1}."), + A_spread_argument_must_either_have_a_tuple_type_or_be_passed_to_a_rest_parameter: diag(2556, ts.DiagnosticCategory.Error, "A_spread_argument_must_either_have_a_tuple_type_or_be_passed_to_a_rest_parameter_2556", "A spread argument must either have a tuple type or be passed to a rest parameter."), + Expected_0_type_arguments_but_got_1: diag(2558, ts.DiagnosticCategory.Error, "Expected_0_type_arguments_but_got_1_2558", "Expected {0} type arguments, but got {1}."), + Type_0_has_no_properties_in_common_with_type_1: diag(2559, ts.DiagnosticCategory.Error, "Type_0_has_no_properties_in_common_with_type_1_2559", "Type '{0}' has no properties in common with type '{1}'."), + Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it: diag(2560, ts.DiagnosticCategory.Error, "Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it_2560", "Value of type '{0}' has no properties in common with type '{1}'. Did you mean to call it?"), + Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_write_2: diag(2561, ts.DiagnosticCategory.Error, "Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_writ_2561", "Object literal may only specify known properties, but '{0}' does not exist in type '{1}'. Did you mean to write '{2}'?"), + Base_class_expressions_cannot_reference_class_type_parameters: diag(2562, ts.DiagnosticCategory.Error, "Base_class_expressions_cannot_reference_class_type_parameters_2562", "Base class expressions cannot reference class type parameters."), + The_containing_function_or_module_body_is_too_large_for_control_flow_analysis: diag(2563, ts.DiagnosticCategory.Error, "The_containing_function_or_module_body_is_too_large_for_control_flow_analysis_2563", "The containing function or module body is too large for control flow analysis."), + Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor: diag(2564, ts.DiagnosticCategory.Error, "Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor_2564", "Property '{0}' has no initializer and is not definitely assigned in the constructor."), + Property_0_is_used_before_being_assigned: diag(2565, ts.DiagnosticCategory.Error, "Property_0_is_used_before_being_assigned_2565", "Property '{0}' is used before being assigned."), + A_rest_element_cannot_have_a_property_name: diag(2566, ts.DiagnosticCategory.Error, "A_rest_element_cannot_have_a_property_name_2566", "A rest element cannot have a property name."), + Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations: diag(2567, ts.DiagnosticCategory.Error, "Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations_2567", "Enum declarations can only merge with namespace or other enum declarations."), + Property_0_may_not_exist_on_type_1_Did_you_mean_2: diag(2568, ts.DiagnosticCategory.Error, "Property_0_may_not_exist_on_type_1_Did_you_mean_2_2568", "Property '{0}' may not exist on type '{1}'. Did you mean '{2}'?"), + Could_not_find_name_0_Did_you_mean_1: diag(2570, ts.DiagnosticCategory.Error, "Could_not_find_name_0_Did_you_mean_1_2570", "Could not find name '{0}'. Did you mean '{1}'?"), + Object_is_of_type_unknown: diag(2571, ts.DiagnosticCategory.Error, "Object_is_of_type_unknown_2571", "Object is of type 'unknown'."), + A_rest_element_type_must_be_an_array_type: diag(2574, ts.DiagnosticCategory.Error, "A_rest_element_type_must_be_an_array_type_2574", "A rest element type must be an array type."), + No_overload_expects_0_arguments_but_overloads_do_exist_that_expect_either_1_or_2_arguments: diag(2575, ts.DiagnosticCategory.Error, "No_overload_expects_0_arguments_but_overloads_do_exist_that_expect_either_1_or_2_arguments_2575", "No overload expects {0} arguments, but overloads do exist that expect either {1} or {2} arguments."), + Property_0_does_not_exist_on_type_1_Did_you_mean_to_access_the_static_member_2_instead: diag(2576, ts.DiagnosticCategory.Error, "Property_0_does_not_exist_on_type_1_Did_you_mean_to_access_the_static_member_2_instead_2576", "Property '{0}' does not exist on type '{1}'. Did you mean to access the static member '{2}' instead?"), + Return_type_annotation_circularly_references_itself: diag(2577, ts.DiagnosticCategory.Error, "Return_type_annotation_circularly_references_itself_2577", "Return type annotation circularly references itself."), + Unused_ts_expect_error_directive: diag(2578, ts.DiagnosticCategory.Error, "Unused_ts_expect_error_directive_2578", "Unused '@ts-expect-error' directive."), + Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode: diag(2580, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashno_2580", "Cannot find name '{0}'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node`."), + Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slashjquery: diag(2581, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slash_2581", "Cannot find name '{0}'. Do you need to install type definitions for jQuery? Try `npm i --save-dev @types/jquery`."), + Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_types_Slashjest_or_npm_i_save_dev_types_Slashmocha: diag(2582, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_type_2582", "Cannot find name '{0}'. Do you need to install type definitions for a test runner? Try `npm i --save-dev @types/jest` or `npm i --save-dev @types/mocha`."), + Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_1_or_later: diag(2583, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_2583", "Cannot find name '{0}'. Do you need to change your target library? Try changing the 'lib' compiler option to '{1}' or later."), + Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_include_dom: diag(2584, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_2584", "Cannot find name '{0}'. Do you need to change your target library? Try changing the 'lib' compiler option to include 'dom'."), + _0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later: diag(2585, ts.DiagnosticCategory.Error, "_0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_2585", "'{0}' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the 'lib' compiler option to es2015 or later."), + Cannot_assign_to_0_because_it_is_a_constant: diag(2588, ts.DiagnosticCategory.Error, "Cannot_assign_to_0_because_it_is_a_constant_2588", "Cannot assign to '{0}' because it is a constant."), + Type_instantiation_is_excessively_deep_and_possibly_infinite: diag(2589, ts.DiagnosticCategory.Error, "Type_instantiation_is_excessively_deep_and_possibly_infinite_2589", "Type instantiation is excessively deep and possibly infinite."), + Expression_produces_a_union_type_that_is_too_complex_to_represent: diag(2590, ts.DiagnosticCategory.Error, "Expression_produces_a_union_type_that_is_too_complex_to_represent_2590", "Expression produces a union type that is too complex to represent."), + Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode_and_then_add_node_to_the_types_field_in_your_tsconfig: diag(2591, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashno_2591", "Cannot find name '{0}'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig."), + Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slashjquery_and_then_add_jquery_to_the_types_field_in_your_tsconfig: diag(2592, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slash_2592", "Cannot find name '{0}'. Do you need to install type definitions for jQuery? Try `npm i --save-dev @types/jquery` and then add 'jquery' to the types field in your tsconfig."), + Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_types_Slashjest_or_npm_i_save_dev_types_Slashmocha_and_then_add_jest_or_mocha_to_the_types_field_in_your_tsconfig: diag(2593, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_type_2593", "Cannot find name '{0}'. Do you need to install type definitions for a test runner? Try `npm i --save-dev @types/jest` or `npm i --save-dev @types/mocha` and then add 'jest' or 'mocha' to the types field in your tsconfig."), + This_module_is_declared_with_export_and_can_only_be_used_with_a_default_import_when_using_the_0_flag: diag(2594, ts.DiagnosticCategory.Error, "This_module_is_declared_with_export_and_can_only_be_used_with_a_default_import_when_using_the_0_flag_2594", "This module is declared with 'export =', and can only be used with a default import when using the '{0}' flag."), + _0_can_only_be_imported_by_using_a_default_import: diag(2595, ts.DiagnosticCategory.Error, "_0_can_only_be_imported_by_using_a_default_import_2595", "'{0}' can only be imported by using a default import."), + _0_can_only_be_imported_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import: diag(2596, ts.DiagnosticCategory.Error, "_0_can_only_be_imported_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import_2596", "'{0}' can only be imported by turning on the 'esModuleInterop' flag and using a default import."), + _0_can_only_be_imported_by_using_a_require_call_or_by_using_a_default_import: diag(2597, ts.DiagnosticCategory.Error, "_0_can_only_be_imported_by_using_a_require_call_or_by_using_a_default_import_2597", "'{0}' can only be imported by using a 'require' call or by using a default import."), + _0_can_only_be_imported_by_using_a_require_call_or_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import: diag(2598, ts.DiagnosticCategory.Error, "_0_can_only_be_imported_by_using_a_require_call_or_by_turning_on_the_esModuleInterop_flag_and_using__2598", "'{0}' can only be imported by using a 'require' call or by turning on the 'esModuleInterop' flag and using a default import."), + JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist: diag(2602, ts.DiagnosticCategory.Error, "JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist_2602", "JSX element implicitly has type 'any' because the global type 'JSX.Element' does not exist."), + Property_0_in_type_1_is_not_assignable_to_type_2: diag(2603, ts.DiagnosticCategory.Error, "Property_0_in_type_1_is_not_assignable_to_type_2_2603", "Property '{0}' in type '{1}' is not assignable to type '{2}'."), + JSX_element_type_0_does_not_have_any_construct_or_call_signatures: diag(2604, ts.DiagnosticCategory.Error, "JSX_element_type_0_does_not_have_any_construct_or_call_signatures_2604", "JSX element type '{0}' does not have any construct or call signatures."), + Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property: diag(2606, ts.DiagnosticCategory.Error, "Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property_2606", "Property '{0}' of JSX spread attribute is not assignable to target property."), + JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property: diag(2607, ts.DiagnosticCategory.Error, "JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property_2607", "JSX element class does not support attributes because it does not have a '{0}' property."), + The_global_type_JSX_0_may_not_have_more_than_one_property: diag(2608, ts.DiagnosticCategory.Error, "The_global_type_JSX_0_may_not_have_more_than_one_property_2608", "The global type 'JSX.{0}' may not have more than one property."), + JSX_spread_child_must_be_an_array_type: diag(2609, ts.DiagnosticCategory.Error, "JSX_spread_child_must_be_an_array_type_2609", "JSX spread child must be an array type."), + _0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property: diag(2610, ts.DiagnosticCategory.Error, "_0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property_2610", "'{0}' is defined as an accessor in class '{1}', but is overridden here in '{2}' as an instance property."), + _0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor: diag(2611, ts.DiagnosticCategory.Error, "_0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor_2611", "'{0}' is defined as a property in class '{1}', but is overridden here in '{2}' as an accessor."), + Property_0_will_overwrite_the_base_property_in_1_If_this_is_intentional_add_an_initializer_Otherwise_add_a_declare_modifier_or_remove_the_redundant_declaration: diag(2612, ts.DiagnosticCategory.Error, "Property_0_will_overwrite_the_base_property_in_1_If_this_is_intentional_add_an_initializer_Otherwise_2612", "Property '{0}' will overwrite the base property in '{1}'. If this is intentional, add an initializer. Otherwise, add a 'declare' modifier or remove the redundant declaration."), + Module_0_has_no_default_export_Did_you_mean_to_use_import_1_from_0_instead: diag(2613, ts.DiagnosticCategory.Error, "Module_0_has_no_default_export_Did_you_mean_to_use_import_1_from_0_instead_2613", "Module '{0}' has no default export. Did you mean to use 'import { {1} } from {0}' instead?"), + Module_0_has_no_exported_member_1_Did_you_mean_to_use_import_1_from_0_instead: diag(2614, ts.DiagnosticCategory.Error, "Module_0_has_no_exported_member_1_Did_you_mean_to_use_import_1_from_0_instead_2614", "Module '{0}' has no exported member '{1}'. Did you mean to use 'import {1} from {0}' instead?"), + Type_of_property_0_circularly_references_itself_in_mapped_type_1: diag(2615, ts.DiagnosticCategory.Error, "Type_of_property_0_circularly_references_itself_in_mapped_type_1_2615", "Type of property '{0}' circularly references itself in mapped type '{1}'."), + _0_can_only_be_imported_by_using_import_1_require_2_or_a_default_import: diag(2616, ts.DiagnosticCategory.Error, "_0_can_only_be_imported_by_using_import_1_require_2_or_a_default_import_2616", "'{0}' can only be imported by using 'import {1} = require({2})' or a default import."), + _0_can_only_be_imported_by_using_import_1_require_2_or_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import: diag(2617, ts.DiagnosticCategory.Error, "_0_can_only_be_imported_by_using_import_1_require_2_or_by_turning_on_the_esModuleInterop_flag_and_us_2617", "'{0}' can only be imported by using 'import {1} = require({2})' or by turning on the 'esModuleInterop' flag and using a default import."), + Source_has_0_element_s_but_target_requires_1: diag(2618, ts.DiagnosticCategory.Error, "Source_has_0_element_s_but_target_requires_1_2618", "Source has {0} element(s) but target requires {1}."), + Source_has_0_element_s_but_target_allows_only_1: diag(2619, ts.DiagnosticCategory.Error, "Source_has_0_element_s_but_target_allows_only_1_2619", "Source has {0} element(s) but target allows only {1}."), + Target_requires_0_element_s_but_source_may_have_fewer: diag(2620, ts.DiagnosticCategory.Error, "Target_requires_0_element_s_but_source_may_have_fewer_2620", "Target requires {0} element(s) but source may have fewer."), + Target_allows_only_0_element_s_but_source_may_have_more: diag(2621, ts.DiagnosticCategory.Error, "Target_allows_only_0_element_s_but_source_may_have_more_2621", "Target allows only {0} element(s) but source may have more."), + Source_provides_no_match_for_required_element_at_position_0_in_target: diag(2623, ts.DiagnosticCategory.Error, "Source_provides_no_match_for_required_element_at_position_0_in_target_2623", "Source provides no match for required element at position {0} in target."), + Source_provides_no_match_for_variadic_element_at_position_0_in_target: diag(2624, ts.DiagnosticCategory.Error, "Source_provides_no_match_for_variadic_element_at_position_0_in_target_2624", "Source provides no match for variadic element at position {0} in target."), + Variadic_element_at_position_0_in_source_does_not_match_element_at_position_1_in_target: diag(2625, ts.DiagnosticCategory.Error, "Variadic_element_at_position_0_in_source_does_not_match_element_at_position_1_in_target_2625", "Variadic element at position {0} in source does not match element at position {1} in target."), + Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target: diag(2626, ts.DiagnosticCategory.Error, "Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target_2626", "Type at position {0} in source is not compatible with type at position {1} in target."), + Type_at_positions_0_through_1_in_source_is_not_compatible_with_type_at_position_2_in_target: diag(2627, ts.DiagnosticCategory.Error, "Type_at_positions_0_through_1_in_source_is_not_compatible_with_type_at_position_2_in_target_2627", "Type at positions {0} through {1} in source is not compatible with type at position {2} in target."), + Cannot_assign_to_0_because_it_is_an_enum: diag(2628, ts.DiagnosticCategory.Error, "Cannot_assign_to_0_because_it_is_an_enum_2628", "Cannot assign to '{0}' because it is an enum."), + Cannot_assign_to_0_because_it_is_a_class: diag(2629, ts.DiagnosticCategory.Error, "Cannot_assign_to_0_because_it_is_a_class_2629", "Cannot assign to '{0}' because it is a class."), + Cannot_assign_to_0_because_it_is_a_function: diag(2630, ts.DiagnosticCategory.Error, "Cannot_assign_to_0_because_it_is_a_function_2630", "Cannot assign to '{0}' because it is a function."), + Cannot_assign_to_0_because_it_is_a_namespace: diag(2631, ts.DiagnosticCategory.Error, "Cannot_assign_to_0_because_it_is_a_namespace_2631", "Cannot assign to '{0}' because it is a namespace."), + Cannot_assign_to_0_because_it_is_an_import: diag(2632, ts.DiagnosticCategory.Error, "Cannot_assign_to_0_because_it_is_an_import_2632", "Cannot assign to '{0}' because it is an import."), + JSX_property_access_expressions_cannot_include_JSX_namespace_names: diag(2633, ts.DiagnosticCategory.Error, "JSX_property_access_expressions_cannot_include_JSX_namespace_names_2633", "JSX property access expressions cannot include JSX namespace names"), + _0_index_signatures_are_incompatible: diag(2634, ts.DiagnosticCategory.Error, "_0_index_signatures_are_incompatible_2634", "'{0}' index signatures are incompatible."), + Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable: diag(2635, ts.DiagnosticCategory.Error, "Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable_2635", "Type '{0}' has no signatures for which the type argument list is applicable."), + Type_0_is_not_assignable_to_type_1_as_implied_by_variance_annotation: diag(2636, ts.DiagnosticCategory.Error, "Type_0_is_not_assignable_to_type_1_as_implied_by_variance_annotation_2636", "Type '{0}' is not assignable to type '{1}' as implied by variance annotation."), + Variance_annotations_are_only_supported_in_type_aliases_for_object_function_constructor_and_mapped_types: diag(2637, ts.DiagnosticCategory.Error, "Variance_annotations_are_only_supported_in_type_aliases_for_object_function_constructor_and_mapped_t_2637", "Variance annotations are only supported in type aliases for object, function, constructor, and mapped types."), + Type_0_may_represent_a_primitive_value_which_is_not_permitted_as_the_right_operand_of_the_in_operator: diag(2638, ts.DiagnosticCategory.Error, "Type_0_may_represent_a_primitive_value_which_is_not_permitted_as_the_right_operand_of_the_in_operato_2638", "Type '{0}' may represent a primitive value, which is not permitted as the right operand of the 'in' operator."), + Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity: diag(2649, ts.DiagnosticCategory.Error, "Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity_2649", "Cannot augment module '{0}' with value exports because it resolves to a non-module entity."), + A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums: diag(2651, ts.DiagnosticCategory.Error, "A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_memb_2651", "A member initializer in a enum declaration cannot reference members declared after it, including members defined in other enums."), + Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead: diag(2652, ts.DiagnosticCategory.Error, "Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_d_2652", "Merged declaration '{0}' cannot include a default export declaration. Consider adding a separate 'export default {0}' declaration instead."), + Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1: diag(2653, ts.DiagnosticCategory.Error, "Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1_2653", "Non-abstract class expression does not implement inherited abstract member '{0}' from class '{1}'."), + JSX_expressions_must_have_one_parent_element: diag(2657, ts.DiagnosticCategory.Error, "JSX_expressions_must_have_one_parent_element_2657", "JSX expressions must have one parent element."), + Type_0_provides_no_match_for_the_signature_1: diag(2658, ts.DiagnosticCategory.Error, "Type_0_provides_no_match_for_the_signature_1_2658", "Type '{0}' provides no match for the signature '{1}'."), + super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_higher: diag(2659, ts.DiagnosticCategory.Error, "super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_highe_2659", "'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher."), + super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions: diag(2660, ts.DiagnosticCategory.Error, "super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions_2660", "'super' can only be referenced in members of derived classes or object literal expressions."), + Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module: diag(2661, ts.DiagnosticCategory.Error, "Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module_2661", "Cannot export '{0}'. Only local declarations can be exported from a module."), + Cannot_find_name_0_Did_you_mean_the_static_member_1_0: diag(2662, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Did_you_mean_the_static_member_1_0_2662", "Cannot find name '{0}'. Did you mean the static member '{1}.{0}'?"), + Cannot_find_name_0_Did_you_mean_the_instance_member_this_0: diag(2663, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Did_you_mean_the_instance_member_this_0_2663", "Cannot find name '{0}'. Did you mean the instance member 'this.{0}'?"), + Invalid_module_name_in_augmentation_module_0_cannot_be_found: diag(2664, ts.DiagnosticCategory.Error, "Invalid_module_name_in_augmentation_module_0_cannot_be_found_2664", "Invalid module name in augmentation, module '{0}' cannot be found."), + Invalid_module_name_in_augmentation_Module_0_resolves_to_an_untyped_module_at_1_which_cannot_be_augmented: diag(2665, ts.DiagnosticCategory.Error, "Invalid_module_name_in_augmentation_Module_0_resolves_to_an_untyped_module_at_1_which_cannot_be_augm_2665", "Invalid module name in augmentation. Module '{0}' resolves to an untyped module at '{1}', which cannot be augmented."), + Exports_and_export_assignments_are_not_permitted_in_module_augmentations: diag(2666, ts.DiagnosticCategory.Error, "Exports_and_export_assignments_are_not_permitted_in_module_augmentations_2666", "Exports and export assignments are not permitted in module augmentations."), + Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_module: diag(2667, ts.DiagnosticCategory.Error, "Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_mod_2667", "Imports are not permitted in module augmentations. Consider moving them to the enclosing external module."), + export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always_visible: diag(2668, ts.DiagnosticCategory.Error, "export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always__2668", "'export' modifier cannot be applied to ambient modules and module augmentations since they are always visible."), + Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_declarations: diag(2669, ts.DiagnosticCategory.Error, "Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_2669", "Augmentations for the global scope can only be directly nested in external modules or ambient module declarations."), + Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambient_context: diag(2670, ts.DiagnosticCategory.Error, "Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambien_2670", "Augmentations for the global scope should have 'declare' modifier unless they appear in already ambient context."), + Cannot_augment_module_0_because_it_resolves_to_a_non_module_entity: diag(2671, ts.DiagnosticCategory.Error, "Cannot_augment_module_0_because_it_resolves_to_a_non_module_entity_2671", "Cannot augment module '{0}' because it resolves to a non-module entity."), + Cannot_assign_a_0_constructor_type_to_a_1_constructor_type: diag(2672, ts.DiagnosticCategory.Error, "Cannot_assign_a_0_constructor_type_to_a_1_constructor_type_2672", "Cannot assign a '{0}' constructor type to a '{1}' constructor type."), + Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration: diag(2673, ts.DiagnosticCategory.Error, "Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration_2673", "Constructor of class '{0}' is private and only accessible within the class declaration."), + Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration: diag(2674, ts.DiagnosticCategory.Error, "Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration_2674", "Constructor of class '{0}' is protected and only accessible within the class declaration."), + Cannot_extend_a_class_0_Class_constructor_is_marked_as_private: diag(2675, ts.DiagnosticCategory.Error, "Cannot_extend_a_class_0_Class_constructor_is_marked_as_private_2675", "Cannot extend a class '{0}'. Class constructor is marked as private."), + Accessors_must_both_be_abstract_or_non_abstract: diag(2676, ts.DiagnosticCategory.Error, "Accessors_must_both_be_abstract_or_non_abstract_2676", "Accessors must both be abstract or non-abstract."), + A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type: diag(2677, ts.DiagnosticCategory.Error, "A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type_2677", "A type predicate's type must be assignable to its parameter's type."), + Type_0_is_not_comparable_to_type_1: diag(2678, ts.DiagnosticCategory.Error, "Type_0_is_not_comparable_to_type_1_2678", "Type '{0}' is not comparable to type '{1}'."), + A_function_that_is_called_with_the_new_keyword_cannot_have_a_this_type_that_is_void: diag(2679, ts.DiagnosticCategory.Error, "A_function_that_is_called_with_the_new_keyword_cannot_have_a_this_type_that_is_void_2679", "A function that is called with the 'new' keyword cannot have a 'this' type that is 'void'."), + A_0_parameter_must_be_the_first_parameter: diag(2680, ts.DiagnosticCategory.Error, "A_0_parameter_must_be_the_first_parameter_2680", "A '{0}' parameter must be the first parameter."), + A_constructor_cannot_have_a_this_parameter: diag(2681, ts.DiagnosticCategory.Error, "A_constructor_cannot_have_a_this_parameter_2681", "A constructor cannot have a 'this' parameter."), + this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation: diag(2683, ts.DiagnosticCategory.Error, "this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_2683", "'this' implicitly has type 'any' because it does not have a type annotation."), + The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1: diag(2684, ts.DiagnosticCategory.Error, "The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1_2684", "The 'this' context of type '{0}' is not assignable to method's 'this' of type '{1}'."), + The_this_types_of_each_signature_are_incompatible: diag(2685, ts.DiagnosticCategory.Error, "The_this_types_of_each_signature_are_incompatible_2685", "The 'this' types of each signature are incompatible."), + _0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead: diag(2686, ts.DiagnosticCategory.Error, "_0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead_2686", "'{0}' refers to a UMD global, but the current file is a module. Consider adding an import instead."), + All_declarations_of_0_must_have_identical_modifiers: diag(2687, ts.DiagnosticCategory.Error, "All_declarations_of_0_must_have_identical_modifiers_2687", "All declarations of '{0}' must have identical modifiers."), + Cannot_find_type_definition_file_for_0: diag(2688, ts.DiagnosticCategory.Error, "Cannot_find_type_definition_file_for_0_2688", "Cannot find type definition file for '{0}'."), + Cannot_extend_an_interface_0_Did_you_mean_implements: diag(2689, ts.DiagnosticCategory.Error, "Cannot_extend_an_interface_0_Did_you_mean_implements_2689", "Cannot extend an interface '{0}'. Did you mean 'implements'?"), + _0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Did_you_mean_to_use_1_in_0: diag(2690, ts.DiagnosticCategory.Error, "_0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Did_you_mean_to_use_1_in_0_2690", "'{0}' only refers to a type, but is being used as a value here. Did you mean to use '{1} in {0}'?"), + An_import_path_cannot_end_with_a_0_extension_Consider_importing_1_instead: diag(2691, ts.DiagnosticCategory.Error, "An_import_path_cannot_end_with_a_0_extension_Consider_importing_1_instead_2691", "An import path cannot end with a '{0}' extension. Consider importing '{1}' instead."), + _0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible: diag(2692, ts.DiagnosticCategory.Error, "_0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible_2692", "'{0}' is a primitive, but '{1}' is a wrapper object. Prefer using '{0}' when possible."), + _0_only_refers_to_a_type_but_is_being_used_as_a_value_here: diag(2693, ts.DiagnosticCategory.Error, "_0_only_refers_to_a_type_but_is_being_used_as_a_value_here_2693", "'{0}' only refers to a type, but is being used as a value here."), + Namespace_0_has_no_exported_member_1: diag(2694, ts.DiagnosticCategory.Error, "Namespace_0_has_no_exported_member_1_2694", "Namespace '{0}' has no exported member '{1}'."), + Left_side_of_comma_operator_is_unused_and_has_no_side_effects: diag(2695, ts.DiagnosticCategory.Error, "Left_side_of_comma_operator_is_unused_and_has_no_side_effects_2695", "Left side of comma operator is unused and has no side effects.", /*reportsUnnecessary*/ true), + The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead: diag(2696, ts.DiagnosticCategory.Error, "The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead_2696", "The 'Object' type is assignable to very few other types. Did you mean to use the 'any' type instead?"), + An_async_function_or_method_must_return_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option: diag(2697, ts.DiagnosticCategory.Error, "An_async_function_or_method_must_return_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_in_2697", "An async function or method must return a 'Promise'. Make sure you have a declaration for 'Promise' or include 'ES2015' in your '--lib' option."), + Spread_types_may_only_be_created_from_object_types: diag(2698, ts.DiagnosticCategory.Error, "Spread_types_may_only_be_created_from_object_types_2698", "Spread types may only be created from object types."), + Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1: diag(2699, ts.DiagnosticCategory.Error, "Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1_2699", "Static property '{0}' conflicts with built-in property 'Function.{0}' of constructor function '{1}'."), + Rest_types_may_only_be_created_from_object_types: diag(2700, ts.DiagnosticCategory.Error, "Rest_types_may_only_be_created_from_object_types_2700", "Rest types may only be created from object types."), + The_target_of_an_object_rest_assignment_must_be_a_variable_or_a_property_access: diag(2701, ts.DiagnosticCategory.Error, "The_target_of_an_object_rest_assignment_must_be_a_variable_or_a_property_access_2701", "The target of an object rest assignment must be a variable or a property access."), + _0_only_refers_to_a_type_but_is_being_used_as_a_namespace_here: diag(2702, ts.DiagnosticCategory.Error, "_0_only_refers_to_a_type_but_is_being_used_as_a_namespace_here_2702", "'{0}' only refers to a type, but is being used as a namespace here."), + The_operand_of_a_delete_operator_must_be_a_property_reference: diag(2703, ts.DiagnosticCategory.Error, "The_operand_of_a_delete_operator_must_be_a_property_reference_2703", "The operand of a 'delete' operator must be a property reference."), + The_operand_of_a_delete_operator_cannot_be_a_read_only_property: diag(2704, ts.DiagnosticCategory.Error, "The_operand_of_a_delete_operator_cannot_be_a_read_only_property_2704", "The operand of a 'delete' operator cannot be a read-only property."), + An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option: diag(2705, ts.DiagnosticCategory.Error, "An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_de_2705", "An async function or method in ES5/ES3 requires the 'Promise' constructor. Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your '--lib' option."), + Required_type_parameters_may_not_follow_optional_type_parameters: diag(2706, ts.DiagnosticCategory.Error, "Required_type_parameters_may_not_follow_optional_type_parameters_2706", "Required type parameters may not follow optional type parameters."), + Generic_type_0_requires_between_1_and_2_type_arguments: diag(2707, ts.DiagnosticCategory.Error, "Generic_type_0_requires_between_1_and_2_type_arguments_2707", "Generic type '{0}' requires between {1} and {2} type arguments."), + Cannot_use_namespace_0_as_a_value: diag(2708, ts.DiagnosticCategory.Error, "Cannot_use_namespace_0_as_a_value_2708", "Cannot use namespace '{0}' as a value."), + Cannot_use_namespace_0_as_a_type: diag(2709, ts.DiagnosticCategory.Error, "Cannot_use_namespace_0_as_a_type_2709", "Cannot use namespace '{0}' as a type."), + _0_are_specified_twice_The_attribute_named_0_will_be_overwritten: diag(2710, ts.DiagnosticCategory.Error, "_0_are_specified_twice_The_attribute_named_0_will_be_overwritten_2710", "'{0}' are specified twice. The attribute named '{0}' will be overwritten."), + A_dynamic_import_call_returns_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option: diag(2711, ts.DiagnosticCategory.Error, "A_dynamic_import_call_returns_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES20_2711", "A dynamic import call returns a 'Promise'. Make sure you have a declaration for 'Promise' or include 'ES2015' in your '--lib' option."), + A_dynamic_import_call_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option: diag(2712, ts.DiagnosticCategory.Error, "A_dynamic_import_call_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declarat_2712", "A dynamic import call in ES5/ES3 requires the 'Promise' constructor. Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your '--lib' option."), + Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_property_1_in_0_with_0_1: diag(2713, ts.DiagnosticCategory.Error, "Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_p_2713", "Cannot access '{0}.{1}' because '{0}' is a type, but not a namespace. Did you mean to retrieve the type of the property '{1}' in '{0}' with '{0}[\"{1}\"]'?"), + The_expression_of_an_export_assignment_must_be_an_identifier_or_qualified_name_in_an_ambient_context: diag(2714, ts.DiagnosticCategory.Error, "The_expression_of_an_export_assignment_must_be_an_identifier_or_qualified_name_in_an_ambient_context_2714", "The expression of an export assignment must be an identifier or qualified name in an ambient context."), + Abstract_property_0_in_class_1_cannot_be_accessed_in_the_constructor: diag(2715, ts.DiagnosticCategory.Error, "Abstract_property_0_in_class_1_cannot_be_accessed_in_the_constructor_2715", "Abstract property '{0}' in class '{1}' cannot be accessed in the constructor."), + Type_parameter_0_has_a_circular_default: diag(2716, ts.DiagnosticCategory.Error, "Type_parameter_0_has_a_circular_default_2716", "Type parameter '{0}' has a circular default."), + Subsequent_property_declarations_must_have_the_same_type_Property_0_must_be_of_type_1_but_here_has_type_2: diag(2717, ts.DiagnosticCategory.Error, "Subsequent_property_declarations_must_have_the_same_type_Property_0_must_be_of_type_1_but_here_has_t_2717", "Subsequent property declarations must have the same type. Property '{0}' must be of type '{1}', but here has type '{2}'."), + Duplicate_property_0: diag(2718, ts.DiagnosticCategory.Error, "Duplicate_property_0_2718", "Duplicate property '{0}'."), + Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated: diag(2719, ts.DiagnosticCategory.Error, "Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated_2719", "Type '{0}' is not assignable to type '{1}'. Two different types with this name exist, but they are unrelated."), + Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass: diag(2720, ts.DiagnosticCategory.Error, "Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclas_2720", "Class '{0}' incorrectly implements class '{1}'. Did you mean to extend '{1}' and inherit its members as a subclass?"), + Cannot_invoke_an_object_which_is_possibly_null: diag(2721, ts.DiagnosticCategory.Error, "Cannot_invoke_an_object_which_is_possibly_null_2721", "Cannot invoke an object which is possibly 'null'."), + Cannot_invoke_an_object_which_is_possibly_undefined: diag(2722, ts.DiagnosticCategory.Error, "Cannot_invoke_an_object_which_is_possibly_undefined_2722", "Cannot invoke an object which is possibly 'undefined'."), + Cannot_invoke_an_object_which_is_possibly_null_or_undefined: diag(2723, ts.DiagnosticCategory.Error, "Cannot_invoke_an_object_which_is_possibly_null_or_undefined_2723", "Cannot invoke an object which is possibly 'null' or 'undefined'."), + _0_has_no_exported_member_named_1_Did_you_mean_2: diag(2724, ts.DiagnosticCategory.Error, "_0_has_no_exported_member_named_1_Did_you_mean_2_2724", "'{0}' has no exported member named '{1}'. Did you mean '{2}'?"), + Class_name_cannot_be_Object_when_targeting_ES5_with_module_0: diag(2725, ts.DiagnosticCategory.Error, "Class_name_cannot_be_Object_when_targeting_ES5_with_module_0_2725", "Class name cannot be 'Object' when targeting ES5 with module {0}."), + Cannot_find_lib_definition_for_0: diag(2726, ts.DiagnosticCategory.Error, "Cannot_find_lib_definition_for_0_2726", "Cannot find lib definition for '{0}'."), + Cannot_find_lib_definition_for_0_Did_you_mean_1: diag(2727, ts.DiagnosticCategory.Error, "Cannot_find_lib_definition_for_0_Did_you_mean_1_2727", "Cannot find lib definition for '{0}'. Did you mean '{1}'?"), + _0_is_declared_here: diag(2728, ts.DiagnosticCategory.Message, "_0_is_declared_here_2728", "'{0}' is declared here."), + Property_0_is_used_before_its_initialization: diag(2729, ts.DiagnosticCategory.Error, "Property_0_is_used_before_its_initialization_2729", "Property '{0}' is used before its initialization."), + An_arrow_function_cannot_have_a_this_parameter: diag(2730, ts.DiagnosticCategory.Error, "An_arrow_function_cannot_have_a_this_parameter_2730", "An arrow function cannot have a 'this' parameter."), + Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_in_String: diag(2731, ts.DiagnosticCategory.Error, "Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_i_2731", "Implicit conversion of a 'symbol' to a 'string' will fail at runtime. Consider wrapping this expression in 'String(...)'."), + Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension: diag(2732, ts.DiagnosticCategory.Error, "Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension_2732", "Cannot find module '{0}'. Consider using '--resolveJsonModule' to import module with '.json' extension."), + Property_0_was_also_declared_here: diag(2733, ts.DiagnosticCategory.Error, "Property_0_was_also_declared_here_2733", "Property '{0}' was also declared here."), + Are_you_missing_a_semicolon: diag(2734, ts.DiagnosticCategory.Error, "Are_you_missing_a_semicolon_2734", "Are you missing a semicolon?"), + Did_you_mean_for_0_to_be_constrained_to_type_new_args_Colon_any_1: diag(2735, ts.DiagnosticCategory.Error, "Did_you_mean_for_0_to_be_constrained_to_type_new_args_Colon_any_1_2735", "Did you mean for '{0}' to be constrained to type 'new (...args: any[]) => {1}'?"), + Operator_0_cannot_be_applied_to_type_1: diag(2736, ts.DiagnosticCategory.Error, "Operator_0_cannot_be_applied_to_type_1_2736", "Operator '{0}' cannot be applied to type '{1}'."), + BigInt_literals_are_not_available_when_targeting_lower_than_ES2020: diag(2737, ts.DiagnosticCategory.Error, "BigInt_literals_are_not_available_when_targeting_lower_than_ES2020_2737", "BigInt literals are not available when targeting lower than ES2020."), + An_outer_value_of_this_is_shadowed_by_this_container: diag(2738, ts.DiagnosticCategory.Message, "An_outer_value_of_this_is_shadowed_by_this_container_2738", "An outer value of 'this' is shadowed by this container."), + Type_0_is_missing_the_following_properties_from_type_1_Colon_2: diag(2739, ts.DiagnosticCategory.Error, "Type_0_is_missing_the_following_properties_from_type_1_Colon_2_2739", "Type '{0}' is missing the following properties from type '{1}': {2}"), + Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more: diag(2740, ts.DiagnosticCategory.Error, "Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more_2740", "Type '{0}' is missing the following properties from type '{1}': {2}, and {3} more."), + Property_0_is_missing_in_type_1_but_required_in_type_2: diag(2741, ts.DiagnosticCategory.Error, "Property_0_is_missing_in_type_1_but_required_in_type_2_2741", "Property '{0}' is missing in type '{1}' but required in type '{2}'."), + The_inferred_type_of_0_cannot_be_named_without_a_reference_to_1_This_is_likely_not_portable_A_type_annotation_is_necessary: diag(2742, ts.DiagnosticCategory.Error, "The_inferred_type_of_0_cannot_be_named_without_a_reference_to_1_This_is_likely_not_portable_A_type_a_2742", "The inferred type of '{0}' cannot be named without a reference to '{1}'. This is likely not portable. A type annotation is necessary."), + No_overload_expects_0_type_arguments_but_overloads_do_exist_that_expect_either_1_or_2_type_arguments: diag(2743, ts.DiagnosticCategory.Error, "No_overload_expects_0_type_arguments_but_overloads_do_exist_that_expect_either_1_or_2_type_arguments_2743", "No overload expects {0} type arguments, but overloads do exist that expect either {1} or {2} type arguments."), + Type_parameter_defaults_can_only_reference_previously_declared_type_parameters: diag(2744, ts.DiagnosticCategory.Error, "Type_parameter_defaults_can_only_reference_previously_declared_type_parameters_2744", "Type parameter defaults can only reference previously declared type parameters."), + This_JSX_tag_s_0_prop_expects_type_1_which_requires_multiple_children_but_only_a_single_child_was_provided: diag(2745, ts.DiagnosticCategory.Error, "This_JSX_tag_s_0_prop_expects_type_1_which_requires_multiple_children_but_only_a_single_child_was_pr_2745", "This JSX tag's '{0}' prop expects type '{1}' which requires multiple children, but only a single child was provided."), + This_JSX_tag_s_0_prop_expects_a_single_child_of_type_1_but_multiple_children_were_provided: diag(2746, ts.DiagnosticCategory.Error, "This_JSX_tag_s_0_prop_expects_a_single_child_of_type_1_but_multiple_children_were_provided_2746", "This JSX tag's '{0}' prop expects a single child of type '{1}', but multiple children were provided."), + _0_components_don_t_accept_text_as_child_elements_Text_in_JSX_has_the_type_string_but_the_expected_type_of_1_is_2: diag(2747, ts.DiagnosticCategory.Error, "_0_components_don_t_accept_text_as_child_elements_Text_in_JSX_has_the_type_string_but_the_expected_t_2747", "'{0}' components don't accept text as child elements. Text in JSX has the type 'string', but the expected type of '{1}' is '{2}'."), + Cannot_access_ambient_const_enums_when_the_isolatedModules_flag_is_provided: diag(2748, ts.DiagnosticCategory.Error, "Cannot_access_ambient_const_enums_when_the_isolatedModules_flag_is_provided_2748", "Cannot access ambient const enums when the '--isolatedModules' flag is provided."), + _0_refers_to_a_value_but_is_being_used_as_a_type_here_Did_you_mean_typeof_0: diag(2749, ts.DiagnosticCategory.Error, "_0_refers_to_a_value_but_is_being_used_as_a_type_here_Did_you_mean_typeof_0_2749", "'{0}' refers to a value, but is being used as a type here. Did you mean 'typeof {0}'?"), + The_implementation_signature_is_declared_here: diag(2750, ts.DiagnosticCategory.Error, "The_implementation_signature_is_declared_here_2750", "The implementation signature is declared here."), + Circularity_originates_in_type_at_this_location: diag(2751, ts.DiagnosticCategory.Error, "Circularity_originates_in_type_at_this_location_2751", "Circularity originates in type at this location."), + The_first_export_default_is_here: diag(2752, ts.DiagnosticCategory.Error, "The_first_export_default_is_here_2752", "The first export default is here."), + Another_export_default_is_here: diag(2753, ts.DiagnosticCategory.Error, "Another_export_default_is_here_2753", "Another export default is here."), + super_may_not_use_type_arguments: diag(2754, ts.DiagnosticCategory.Error, "super_may_not_use_type_arguments_2754", "'super' may not use type arguments."), + No_constituent_of_type_0_is_callable: diag(2755, ts.DiagnosticCategory.Error, "No_constituent_of_type_0_is_callable_2755", "No constituent of type '{0}' is callable."), + Not_all_constituents_of_type_0_are_callable: diag(2756, ts.DiagnosticCategory.Error, "Not_all_constituents_of_type_0_are_callable_2756", "Not all constituents of type '{0}' are callable."), + Type_0_has_no_call_signatures: diag(2757, ts.DiagnosticCategory.Error, "Type_0_has_no_call_signatures_2757", "Type '{0}' has no call signatures."), + Each_member_of_the_union_type_0_has_signatures_but_none_of_those_signatures_are_compatible_with_each_other: diag(2758, ts.DiagnosticCategory.Error, "Each_member_of_the_union_type_0_has_signatures_but_none_of_those_signatures_are_compatible_with_each_2758", "Each member of the union type '{0}' has signatures, but none of those signatures are compatible with each other."), + No_constituent_of_type_0_is_constructable: diag(2759, ts.DiagnosticCategory.Error, "No_constituent_of_type_0_is_constructable_2759", "No constituent of type '{0}' is constructable."), + Not_all_constituents_of_type_0_are_constructable: diag(2760, ts.DiagnosticCategory.Error, "Not_all_constituents_of_type_0_are_constructable_2760", "Not all constituents of type '{0}' are constructable."), + Type_0_has_no_construct_signatures: diag(2761, ts.DiagnosticCategory.Error, "Type_0_has_no_construct_signatures_2761", "Type '{0}' has no construct signatures."), + Each_member_of_the_union_type_0_has_construct_signatures_but_none_of_those_signatures_are_compatible_with_each_other: diag(2762, ts.DiagnosticCategory.Error, "Each_member_of_the_union_type_0_has_construct_signatures_but_none_of_those_signatures_are_compatible_2762", "Each member of the union type '{0}' has construct signatures, but none of those signatures are compatible with each other."), + Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_for_of_will_always_send_0: diag(2763, ts.DiagnosticCategory.Error, "Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_for_of_will_always_s_2763", "Cannot iterate value because the 'next' method of its iterator expects type '{1}', but for-of will always send '{0}'."), + Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_spread_will_always_send_0: diag(2764, ts.DiagnosticCategory.Error, "Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_spread_will_al_2764", "Cannot iterate value because the 'next' method of its iterator expects type '{1}', but array spread will always send '{0}'."), + Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_destructuring_will_always_send_0: diag(2765, ts.DiagnosticCategory.Error, "Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_destructuring__2765", "Cannot iterate value because the 'next' method of its iterator expects type '{1}', but array destructuring will always send '{0}'."), + Cannot_delegate_iteration_to_value_because_the_next_method_of_its_iterator_expects_type_1_but_the_containing_generator_will_always_send_0: diag(2766, ts.DiagnosticCategory.Error, "Cannot_delegate_iteration_to_value_because_the_next_method_of_its_iterator_expects_type_1_but_the_co_2766", "Cannot delegate iteration to value because the 'next' method of its iterator expects type '{1}', but the containing generator will always send '{0}'."), + The_0_property_of_an_iterator_must_be_a_method: diag(2767, ts.DiagnosticCategory.Error, "The_0_property_of_an_iterator_must_be_a_method_2767", "The '{0}' property of an iterator must be a method."), + The_0_property_of_an_async_iterator_must_be_a_method: diag(2768, ts.DiagnosticCategory.Error, "The_0_property_of_an_async_iterator_must_be_a_method_2768", "The '{0}' property of an async iterator must be a method."), + No_overload_matches_this_call: diag(2769, ts.DiagnosticCategory.Error, "No_overload_matches_this_call_2769", "No overload matches this call."), + The_last_overload_gave_the_following_error: diag(2770, ts.DiagnosticCategory.Error, "The_last_overload_gave_the_following_error_2770", "The last overload gave the following error."), + The_last_overload_is_declared_here: diag(2771, ts.DiagnosticCategory.Error, "The_last_overload_is_declared_here_2771", "The last overload is declared here."), + Overload_0_of_1_2_gave_the_following_error: diag(2772, ts.DiagnosticCategory.Error, "Overload_0_of_1_2_gave_the_following_error_2772", "Overload {0} of {1}, '{2}', gave the following error."), + Did_you_forget_to_use_await: diag(2773, ts.DiagnosticCategory.Error, "Did_you_forget_to_use_await_2773", "Did you forget to use 'await'?"), + This_condition_will_always_return_true_since_this_function_is_always_defined_Did_you_mean_to_call_it_instead: diag(2774, ts.DiagnosticCategory.Error, "This_condition_will_always_return_true_since_this_function_is_always_defined_Did_you_mean_to_call_it_2774", "This condition will always return true since this function is always defined. Did you mean to call it instead?"), + Assertions_require_every_name_in_the_call_target_to_be_declared_with_an_explicit_type_annotation: diag(2775, ts.DiagnosticCategory.Error, "Assertions_require_every_name_in_the_call_target_to_be_declared_with_an_explicit_type_annotation_2775", "Assertions require every name in the call target to be declared with an explicit type annotation."), + Assertions_require_the_call_target_to_be_an_identifier_or_qualified_name: diag(2776, ts.DiagnosticCategory.Error, "Assertions_require_the_call_target_to_be_an_identifier_or_qualified_name_2776", "Assertions require the call target to be an identifier or qualified name."), + The_operand_of_an_increment_or_decrement_operator_may_not_be_an_optional_property_access: diag(2777, ts.DiagnosticCategory.Error, "The_operand_of_an_increment_or_decrement_operator_may_not_be_an_optional_property_access_2777", "The operand of an increment or decrement operator may not be an optional property access."), + The_target_of_an_object_rest_assignment_may_not_be_an_optional_property_access: diag(2778, ts.DiagnosticCategory.Error, "The_target_of_an_object_rest_assignment_may_not_be_an_optional_property_access_2778", "The target of an object rest assignment may not be an optional property access."), + The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access: diag(2779, ts.DiagnosticCategory.Error, "The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access_2779", "The left-hand side of an assignment expression may not be an optional property access."), + The_left_hand_side_of_a_for_in_statement_may_not_be_an_optional_property_access: diag(2780, ts.DiagnosticCategory.Error, "The_left_hand_side_of_a_for_in_statement_may_not_be_an_optional_property_access_2780", "The left-hand side of a 'for...in' statement may not be an optional property access."), + The_left_hand_side_of_a_for_of_statement_may_not_be_an_optional_property_access: diag(2781, ts.DiagnosticCategory.Error, "The_left_hand_side_of_a_for_of_statement_may_not_be_an_optional_property_access_2781", "The left-hand side of a 'for...of' statement may not be an optional property access."), + _0_needs_an_explicit_type_annotation: diag(2782, ts.DiagnosticCategory.Message, "_0_needs_an_explicit_type_annotation_2782", "'{0}' needs an explicit type annotation."), + _0_is_specified_more_than_once_so_this_usage_will_be_overwritten: diag(2783, ts.DiagnosticCategory.Error, "_0_is_specified_more_than_once_so_this_usage_will_be_overwritten_2783", "'{0}' is specified more than once, so this usage will be overwritten."), + get_and_set_accessors_cannot_declare_this_parameters: diag(2784, ts.DiagnosticCategory.Error, "get_and_set_accessors_cannot_declare_this_parameters_2784", "'get' and 'set' accessors cannot declare 'this' parameters."), + This_spread_always_overwrites_this_property: diag(2785, ts.DiagnosticCategory.Error, "This_spread_always_overwrites_this_property_2785", "This spread always overwrites this property."), + _0_cannot_be_used_as_a_JSX_component: diag(2786, ts.DiagnosticCategory.Error, "_0_cannot_be_used_as_a_JSX_component_2786", "'{0}' cannot be used as a JSX component."), + Its_return_type_0_is_not_a_valid_JSX_element: diag(2787, ts.DiagnosticCategory.Error, "Its_return_type_0_is_not_a_valid_JSX_element_2787", "Its return type '{0}' is not a valid JSX element."), + Its_instance_type_0_is_not_a_valid_JSX_element: diag(2788, ts.DiagnosticCategory.Error, "Its_instance_type_0_is_not_a_valid_JSX_element_2788", "Its instance type '{0}' is not a valid JSX element."), + Its_element_type_0_is_not_a_valid_JSX_element: diag(2789, ts.DiagnosticCategory.Error, "Its_element_type_0_is_not_a_valid_JSX_element_2789", "Its element type '{0}' is not a valid JSX element."), + The_operand_of_a_delete_operator_must_be_optional: diag(2790, ts.DiagnosticCategory.Error, "The_operand_of_a_delete_operator_must_be_optional_2790", "The operand of a 'delete' operator must be optional."), + Exponentiation_cannot_be_performed_on_bigint_values_unless_the_target_option_is_set_to_es2016_or_later: diag(2791, ts.DiagnosticCategory.Error, "Exponentiation_cannot_be_performed_on_bigint_values_unless_the_target_option_is_set_to_es2016_or_lat_2791", "Exponentiation cannot be performed on 'bigint' values unless the 'target' option is set to 'es2016' or later."), + Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_node_or_to_add_aliases_to_the_paths_option: diag(2792, ts.DiagnosticCategory.Error, "Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_node_or_to_add_aliases_to_th_2792", "Cannot find module '{0}'. Did you mean to set the 'moduleResolution' option to 'node', or to add aliases to the 'paths' option?"), + The_call_would_have_succeeded_against_this_implementation_but_implementation_signatures_of_overloads_are_not_externally_visible: diag(2793, ts.DiagnosticCategory.Error, "The_call_would_have_succeeded_against_this_implementation_but_implementation_signatures_of_overloads_2793", "The call would have succeeded against this implementation, but implementation signatures of overloads are not externally visible."), + Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise: diag(2794, ts.DiagnosticCategory.Error, "Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise_2794", "Expected {0} arguments, but got {1}. Did you forget to include 'void' in your type argument to 'Promise'?"), + The_intrinsic_keyword_can_only_be_used_to_declare_compiler_provided_intrinsic_types: diag(2795, ts.DiagnosticCategory.Error, "The_intrinsic_keyword_can_only_be_used_to_declare_compiler_provided_intrinsic_types_2795", "The 'intrinsic' keyword can only be used to declare compiler provided intrinsic types."), + It_is_likely_that_you_are_missing_a_comma_to_separate_these_two_template_expressions_They_form_a_tagged_template_expression_which_cannot_be_invoked: diag(2796, ts.DiagnosticCategory.Error, "It_is_likely_that_you_are_missing_a_comma_to_separate_these_two_template_expressions_They_form_a_tag_2796", "It is likely that you are missing a comma to separate these two template expressions. They form a tagged template expression which cannot be invoked."), + A_mixin_class_that_extends_from_a_type_variable_containing_an_abstract_construct_signature_must_also_be_declared_abstract: diag(2797, ts.DiagnosticCategory.Error, "A_mixin_class_that_extends_from_a_type_variable_containing_an_abstract_construct_signature_must_also_2797", "A mixin class that extends from a type variable containing an abstract construct signature must also be declared 'abstract'."), + The_declaration_was_marked_as_deprecated_here: diag(2798, ts.DiagnosticCategory.Error, "The_declaration_was_marked_as_deprecated_here_2798", "The declaration was marked as deprecated here."), + Type_produces_a_tuple_type_that_is_too_large_to_represent: diag(2799, ts.DiagnosticCategory.Error, "Type_produces_a_tuple_type_that_is_too_large_to_represent_2799", "Type produces a tuple type that is too large to represent."), + Expression_produces_a_tuple_type_that_is_too_large_to_represent: diag(2800, ts.DiagnosticCategory.Error, "Expression_produces_a_tuple_type_that_is_too_large_to_represent_2800", "Expression produces a tuple type that is too large to represent."), + This_condition_will_always_return_true_since_this_0_is_always_defined: diag(2801, ts.DiagnosticCategory.Error, "This_condition_will_always_return_true_since_this_0_is_always_defined_2801", "This condition will always return true since this '{0}' is always defined."), + Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher: diag(2802, ts.DiagnosticCategory.Error, "Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es201_2802", "Type '{0}' can only be iterated through when using the '--downlevelIteration' flag or with a '--target' of 'es2015' or higher."), + Cannot_assign_to_private_method_0_Private_methods_are_not_writable: diag(2803, ts.DiagnosticCategory.Error, "Cannot_assign_to_private_method_0_Private_methods_are_not_writable_2803", "Cannot assign to private method '{0}'. Private methods are not writable."), + Duplicate_identifier_0_Static_and_instance_elements_cannot_share_the_same_private_name: diag(2804, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_Static_and_instance_elements_cannot_share_the_same_private_name_2804", "Duplicate identifier '{0}'. Static and instance elements cannot share the same private name."), + Private_accessor_was_defined_without_a_getter: diag(2806, ts.DiagnosticCategory.Error, "Private_accessor_was_defined_without_a_getter_2806", "Private accessor was defined without a getter."), + This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_one_in_0_Consider_upgrading_your_version_of_0: diag(2807, ts.DiagnosticCategory.Error, "This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_o_2807", "This syntax requires an imported helper named '{1}' with {2} parameters, which is not compatible with the one in '{0}'. Consider upgrading your version of '{0}'."), + A_get_accessor_must_be_at_least_as_accessible_as_the_setter: diag(2808, ts.DiagnosticCategory.Error, "A_get_accessor_must_be_at_least_as_accessible_as_the_setter_2808", "A get accessor must be at least as accessible as the setter"), + Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_destructuring_assignment_you_might_need_to_wrap_the_the_whole_assignment_in_parentheses: diag(2809, ts.DiagnosticCategory.Error, "Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_d_2809", "Declaration or statement expected. This '=' follows a block of statements, so if you intended to write a destructuring assignment, you might need to wrap the the whole assignment in parentheses."), + Expected_1_argument_but_got_0_new_Promise_needs_a_JSDoc_hint_to_produce_a_resolve_that_can_be_called_without_arguments: diag(2810, ts.DiagnosticCategory.Error, "Expected_1_argument_but_got_0_new_Promise_needs_a_JSDoc_hint_to_produce_a_resolve_that_can_be_called_2810", "Expected 1 argument, but got 0. 'new Promise()' needs a JSDoc hint to produce a 'resolve' that can be called without arguments."), + Initializer_for_property_0: diag(2811, ts.DiagnosticCategory.Error, "Initializer_for_property_0_2811", "Initializer for property '{0}'"), + Property_0_does_not_exist_on_type_1_Try_changing_the_lib_compiler_option_to_include_dom: diag(2812, ts.DiagnosticCategory.Error, "Property_0_does_not_exist_on_type_1_Try_changing_the_lib_compiler_option_to_include_dom_2812", "Property '{0}' does not exist on type '{1}'. Try changing the 'lib' compiler option to include 'dom'."), + Class_declaration_cannot_implement_overload_list_for_0: diag(2813, ts.DiagnosticCategory.Error, "Class_declaration_cannot_implement_overload_list_for_0_2813", "Class declaration cannot implement overload list for '{0}'."), + Function_with_bodies_can_only_merge_with_classes_that_are_ambient: diag(2814, ts.DiagnosticCategory.Error, "Function_with_bodies_can_only_merge_with_classes_that_are_ambient_2814", "Function with bodies can only merge with classes that are ambient."), + arguments_cannot_be_referenced_in_property_initializers: diag(2815, ts.DiagnosticCategory.Error, "arguments_cannot_be_referenced_in_property_initializers_2815", "'arguments' cannot be referenced in property initializers."), + Cannot_use_this_in_a_static_property_initializer_of_a_decorated_class: diag(2816, ts.DiagnosticCategory.Error, "Cannot_use_this_in_a_static_property_initializer_of_a_decorated_class_2816", "Cannot use 'this' in a static property initializer of a decorated class."), + Property_0_has_no_initializer_and_is_not_definitely_assigned_in_a_class_static_block: diag(2817, ts.DiagnosticCategory.Error, "Property_0_has_no_initializer_and_is_not_definitely_assigned_in_a_class_static_block_2817", "Property '{0}' has no initializer and is not definitely assigned in a class static block."), + Duplicate_identifier_0_Compiler_reserves_name_1_when_emitting_super_references_in_static_initializers: diag(2818, ts.DiagnosticCategory.Error, "Duplicate_identifier_0_Compiler_reserves_name_1_when_emitting_super_references_in_static_initializer_2818", "Duplicate identifier '{0}'. Compiler reserves name '{1}' when emitting 'super' references in static initializers."), + Namespace_name_cannot_be_0: diag(2819, ts.DiagnosticCategory.Error, "Namespace_name_cannot_be_0_2819", "Namespace name cannot be '{0}'."), + Type_0_is_not_assignable_to_type_1_Did_you_mean_2: diag(2820, ts.DiagnosticCategory.Error, "Type_0_is_not_assignable_to_type_1_Did_you_mean_2_2820", "Type '{0}' is not assignable to type '{1}'. Did you mean '{2}'?"), + Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_or_nodenext: diag(2821, ts.DiagnosticCategory.Error, "Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_or_nodenext_2821", "Import assertions are only supported when the '--module' option is set to 'esnext' or 'nodenext'."), + Import_assertions_cannot_be_used_with_type_only_imports_or_exports: diag(2822, ts.DiagnosticCategory.Error, "Import_assertions_cannot_be_used_with_type_only_imports_or_exports_2822", "Import assertions cannot be used with type-only imports or exports."), + Cannot_find_namespace_0_Did_you_mean_1: diag(2833, ts.DiagnosticCategory.Error, "Cannot_find_namespace_0_Did_you_mean_1_2833", "Cannot find namespace '{0}'. Did you mean '{1}'?"), + Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node16_or_nodenext_Consider_adding_an_extension_to_the_import_path: diag(2834, ts.DiagnosticCategory.Error, "Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_n_2834", "Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node16' or 'nodenext'. Consider adding an extension to the import path."), + Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node16_or_nodenext_Did_you_mean_0: diag(2835, ts.DiagnosticCategory.Error, "Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_n_2835", "Relative import paths need explicit file extensions in EcmaScript imports when '--moduleResolution' is 'node16' or 'nodenext'. Did you mean '{0}'?"), + Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls: diag(2836, ts.DiagnosticCategory.Error, "Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls_2836", "Import assertions are not allowed on statements that transpile to commonjs 'require' calls."), + Import_assertion_values_must_be_string_literal_expressions: diag(2837, ts.DiagnosticCategory.Error, "Import_assertion_values_must_be_string_literal_expressions_2837", "Import assertion values must be string literal expressions."), + All_declarations_of_0_must_have_identical_constraints: diag(2838, ts.DiagnosticCategory.Error, "All_declarations_of_0_must_have_identical_constraints_2838", "All declarations of '{0}' must have identical constraints."), + This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value: diag(2839, ts.DiagnosticCategory.Error, "This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value_2839", "This condition will always return '{0}' since JavaScript compares objects by reference, not value."), + An_interface_cannot_extend_a_primitive_type_like_0_an_interface_can_only_extend_named_types_and_classes: diag(2840, ts.DiagnosticCategory.Error, "An_interface_cannot_extend_a_primitive_type_like_0_an_interface_can_only_extend_named_types_and_clas_2840", "An interface cannot extend a primitive type like '{0}'; an interface can only extend named types and classes"), + The_type_of_this_expression_cannot_be_named_without_a_resolution_mode_assertion_which_is_an_unstable_feature_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next: diag(2841, ts.DiagnosticCategory.Error, "The_type_of_this_expression_cannot_be_named_without_a_resolution_mode_assertion_which_is_an_unstable_2841", "The type of this expression cannot be named without a 'resolution-mode' assertion, which is an unstable feature. Use nightly TypeScript to silence this error. Try updating with 'npm install -D typescript@next'."), + _0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation: diag(2842, ts.DiagnosticCategory.Error, "_0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation_2842", "'{0}' is an unused renaming of '{1}'. Did you intend to use it as a type annotation?"), + We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here: diag(2843, ts.DiagnosticCategory.Error, "We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here_2843", "We can only write a type for '{0}' by adding a type for the entire parameter here."), + Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: diag(2844, ts.DiagnosticCategory.Error, "Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2844", "Type of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor."), + This_condition_will_always_return_0: diag(2845, ts.DiagnosticCategory.Error, "This_condition_will_always_return_0_2845", "This condition will always return '{0}'."), + Import_declaration_0_is_using_private_name_1: diag(4000, ts.DiagnosticCategory.Error, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."), + Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."), + Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."), + Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4006, ts.DiagnosticCategory.Error, "Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1_4006", "Type parameter '{0}' of constructor signature from exported interface has or is using private name '{1}'."), + Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4008, ts.DiagnosticCategory.Error, "Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1_4008", "Type parameter '{0}' of call signature from exported interface has or is using private name '{1}'."), + Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1: diag(4010, ts.DiagnosticCategory.Error, "Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1_4010", "Type parameter '{0}' of public static method from exported class has or is using private name '{1}'."), + Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1: diag(4012, ts.DiagnosticCategory.Error, "Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1_4012", "Type parameter '{0}' of public method from exported class has or is using private name '{1}'."), + Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1: diag(4014, ts.DiagnosticCategory.Error, "Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1_4014", "Type parameter '{0}' of method from exported interface has or is using private name '{1}'."), + Type_parameter_0_of_exported_function_has_or_is_using_private_name_1: diag(4016, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_function_has_or_is_using_private_name_1_4016", "Type parameter '{0}' of exported function has or is using private name '{1}'."), + Implements_clause_of_exported_class_0_has_or_is_using_private_name_1: diag(4019, ts.DiagnosticCategory.Error, "Implements_clause_of_exported_class_0_has_or_is_using_private_name_1_4019", "Implements clause of exported class '{0}' has or is using private name '{1}'."), + extends_clause_of_exported_class_0_has_or_is_using_private_name_1: diag(4020, ts.DiagnosticCategory.Error, "extends_clause_of_exported_class_0_has_or_is_using_private_name_1_4020", "'extends' clause of exported class '{0}' has or is using private name '{1}'."), + extends_clause_of_exported_class_has_or_is_using_private_name_0: diag(4021, ts.DiagnosticCategory.Error, "extends_clause_of_exported_class_has_or_is_using_private_name_0_4021", "'extends' clause of exported class has or is using private name '{0}'."), + extends_clause_of_exported_interface_0_has_or_is_using_private_name_1: diag(4022, ts.DiagnosticCategory.Error, "extends_clause_of_exported_interface_0_has_or_is_using_private_name_1_4022", "'extends' clause of exported interface '{0}' has or is using private name '{1}'."), + Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4023, ts.DiagnosticCategory.Error, "Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4023", "Exported variable '{0}' has or is using name '{1}' from external module {2} but cannot be named."), + Exported_variable_0_has_or_is_using_name_1_from_private_module_2: diag(4024, ts.DiagnosticCategory.Error, "Exported_variable_0_has_or_is_using_name_1_from_private_module_2_4024", "Exported variable '{0}' has or is using name '{1}' from private module '{2}'."), + Exported_variable_0_has_or_is_using_private_name_1: diag(4025, ts.DiagnosticCategory.Error, "Exported_variable_0_has_or_is_using_private_name_1_4025", "Exported variable '{0}' has or is using private name '{1}'."), + Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4026, ts.DiagnosticCategory.Error, "Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot__4026", "Public static property '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named."), + Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4027, ts.DiagnosticCategory.Error, "Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4027", "Public static property '{0}' of exported class has or is using name '{1}' from private module '{2}'."), + Public_static_property_0_of_exported_class_has_or_is_using_private_name_1: diag(4028, ts.DiagnosticCategory.Error, "Public_static_property_0_of_exported_class_has_or_is_using_private_name_1_4028", "Public static property '{0}' of exported class has or is using private name '{1}'."), + Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4029, ts.DiagnosticCategory.Error, "Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_name_4029", "Public property '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named."), + Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4030, ts.DiagnosticCategory.Error, "Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4030", "Public property '{0}' of exported class has or is using name '{1}' from private module '{2}'."), + Public_property_0_of_exported_class_has_or_is_using_private_name_1: diag(4031, ts.DiagnosticCategory.Error, "Public_property_0_of_exported_class_has_or_is_using_private_name_1_4031", "Public property '{0}' of exported class has or is using private name '{1}'."), + Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4032, ts.DiagnosticCategory.Error, "Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2_4032", "Property '{0}' of exported interface has or is using name '{1}' from private module '{2}'."), + Property_0_of_exported_interface_has_or_is_using_private_name_1: diag(4033, ts.DiagnosticCategory.Error, "Property_0_of_exported_interface_has_or_is_using_private_name_1_4033", "Property '{0}' of exported interface has or is using private name '{1}'."), + Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4034, ts.DiagnosticCategory.Error, "Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_name_1_from_private_mod_4034", "Parameter type of public static setter '{0}' from exported class has or is using name '{1}' from private module '{2}'."), + Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_private_name_1: diag(4035, ts.DiagnosticCategory.Error, "Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_private_name_1_4035", "Parameter type of public static setter '{0}' from exported class has or is using private name '{1}'."), + Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4036, ts.DiagnosticCategory.Error, "Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2_4036", "Parameter type of public setter '{0}' from exported class has or is using name '{1}' from private module '{2}'."), + Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_private_name_1: diag(4037, ts.DiagnosticCategory.Error, "Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_private_name_1_4037", "Parameter type of public setter '{0}' from exported class has or is using private name '{1}'."), + Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4038, ts.DiagnosticCategory.Error, "Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_external_modul_4038", "Return type of public static getter '{0}' from exported class has or is using name '{1}' from external module {2} but cannot be named."), + Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4039, ts.DiagnosticCategory.Error, "Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_4039", "Return type of public static getter '{0}' from exported class has or is using name '{1}' from private module '{2}'."), + Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_private_name_1: diag(4040, ts.DiagnosticCategory.Error, "Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_private_name_1_4040", "Return type of public static getter '{0}' from exported class has or is using private name '{1}'."), + Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4041, ts.DiagnosticCategory.Error, "Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_4041", "Return type of public getter '{0}' from exported class has or is using name '{1}' from external module {2} but cannot be named."), + Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4042, ts.DiagnosticCategory.Error, "Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2_4042", "Return type of public getter '{0}' from exported class has or is using name '{1}' from private module '{2}'."), + Return_type_of_public_getter_0_from_exported_class_has_or_is_using_private_name_1: diag(4043, ts.DiagnosticCategory.Error, "Return_type_of_public_getter_0_from_exported_class_has_or_is_using_private_name_1_4043", "Return type of public getter '{0}' from exported class has or is using private name '{1}'."), + Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: diag(4044, ts.DiagnosticCategory.Error, "Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_mod_4044", "Return type of constructor signature from exported interface has or is using name '{0}' from private module '{1}'."), + Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0: diag(4045, ts.DiagnosticCategory.Error, "Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0_4045", "Return type of constructor signature from exported interface has or is using private name '{0}'."), + Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: diag(4046, ts.DiagnosticCategory.Error, "Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1_4046", "Return type of call signature from exported interface has or is using name '{0}' from private module '{1}'."), + Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0: diag(4047, ts.DiagnosticCategory.Error, "Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0_4047", "Return type of call signature from exported interface has or is using private name '{0}'."), + Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: diag(4048, ts.DiagnosticCategory.Error, "Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1_4048", "Return type of index signature from exported interface has or is using name '{0}' from private module '{1}'."), + Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0: diag(4049, ts.DiagnosticCategory.Error, "Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0_4049", "Return type of index signature from exported interface has or is using private name '{0}'."), + Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: diag(4050, ts.DiagnosticCategory.Error, "Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module__4050", "Return type of public static method from exported class has or is using name '{0}' from external module {1} but cannot be named."), + Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1: diag(4051, ts.DiagnosticCategory.Error, "Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1_4051", "Return type of public static method from exported class has or is using name '{0}' from private module '{1}'."), + Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0: diag(4052, ts.DiagnosticCategory.Error, "Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0_4052", "Return type of public static method from exported class has or is using private name '{0}'."), + Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: diag(4053, ts.DiagnosticCategory.Error, "Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_c_4053", "Return type of public method from exported class has or is using name '{0}' from external module {1} but cannot be named."), + Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1: diag(4054, ts.DiagnosticCategory.Error, "Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1_4054", "Return type of public method from exported class has or is using name '{0}' from private module '{1}'."), + Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0: diag(4055, ts.DiagnosticCategory.Error, "Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0_4055", "Return type of public method from exported class has or is using private name '{0}'."), + Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1: diag(4056, ts.DiagnosticCategory.Error, "Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1_4056", "Return type of method from exported interface has or is using name '{0}' from private module '{1}'."), + Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0: diag(4057, ts.DiagnosticCategory.Error, "Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0_4057", "Return type of method from exported interface has or is using private name '{0}'."), + Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: diag(4058, ts.DiagnosticCategory.Error, "Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named_4058", "Return type of exported function has or is using name '{0}' from external module {1} but cannot be named."), + Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1: diag(4059, ts.DiagnosticCategory.Error, "Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1_4059", "Return type of exported function has or is using name '{0}' from private module '{1}'."), + Return_type_of_exported_function_has_or_is_using_private_name_0: diag(4060, ts.DiagnosticCategory.Error, "Return_type_of_exported_function_has_or_is_using_private_name_0_4060", "Return type of exported function has or is using private name '{0}'."), + Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4061, ts.DiagnosticCategory.Error, "Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_can_4061", "Parameter '{0}' of constructor from exported class has or is using name '{1}' from external module {2} but cannot be named."), + Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4062, ts.DiagnosticCategory.Error, "Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2_4062", "Parameter '{0}' of constructor from exported class has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1: diag(4063, ts.DiagnosticCategory.Error, "Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1_4063", "Parameter '{0}' of constructor from exported class has or is using private name '{1}'."), + Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4064, ts.DiagnosticCategory.Error, "Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_mod_4064", "Parameter '{0}' of constructor signature from exported interface has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4065, ts.DiagnosticCategory.Error, "Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1_4065", "Parameter '{0}' of constructor signature from exported interface has or is using private name '{1}'."), + Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4066, ts.DiagnosticCategory.Error, "Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2_4066", "Parameter '{0}' of call signature from exported interface has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4067, ts.DiagnosticCategory.Error, "Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1_4067", "Parameter '{0}' of call signature from exported interface has or is using private name '{1}'."), + Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4068, ts.DiagnosticCategory.Error, "Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module__4068", "Parameter '{0}' of public static method from exported class has or is using name '{1}' from external module {2} but cannot be named."), + Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4069, ts.DiagnosticCategory.Error, "Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2_4069", "Parameter '{0}' of public static method from exported class has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1: diag(4070, ts.DiagnosticCategory.Error, "Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1_4070", "Parameter '{0}' of public static method from exported class has or is using private name '{1}'."), + Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4071, ts.DiagnosticCategory.Error, "Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_c_4071", "Parameter '{0}' of public method from exported class has or is using name '{1}' from external module {2} but cannot be named."), + Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4072, ts.DiagnosticCategory.Error, "Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2_4072", "Parameter '{0}' of public method from exported class has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1: diag(4073, ts.DiagnosticCategory.Error, "Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1_4073", "Parameter '{0}' of public method from exported class has or is using private name '{1}'."), + Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4074, ts.DiagnosticCategory.Error, "Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2_4074", "Parameter '{0}' of method from exported interface has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1: diag(4075, ts.DiagnosticCategory.Error, "Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1_4075", "Parameter '{0}' of method from exported interface has or is using private name '{1}'."), + Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4076, ts.DiagnosticCategory.Error, "Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4076", "Parameter '{0}' of exported function has or is using name '{1}' from external module {2} but cannot be named."), + Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2: diag(4077, ts.DiagnosticCategory.Error, "Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2_4077", "Parameter '{0}' of exported function has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_exported_function_has_or_is_using_private_name_1: diag(4078, ts.DiagnosticCategory.Error, "Parameter_0_of_exported_function_has_or_is_using_private_name_1_4078", "Parameter '{0}' of exported function has or is using private name '{1}'."), + Exported_type_alias_0_has_or_is_using_private_name_1: diag(4081, ts.DiagnosticCategory.Error, "Exported_type_alias_0_has_or_is_using_private_name_1_4081", "Exported type alias '{0}' has or is using private name '{1}'."), + Default_export_of_the_module_has_or_is_using_private_name_0: diag(4082, ts.DiagnosticCategory.Error, "Default_export_of_the_module_has_or_is_using_private_name_0_4082", "Default export of the module has or is using private name '{0}'."), + Type_parameter_0_of_exported_type_alias_has_or_is_using_private_name_1: diag(4083, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_type_alias_has_or_is_using_private_name_1_4083", "Type parameter '{0}' of exported type alias has or is using private name '{1}'."), + Exported_type_alias_0_has_or_is_using_private_name_1_from_module_2: diag(4084, ts.DiagnosticCategory.Error, "Exported_type_alias_0_has_or_is_using_private_name_1_from_module_2_4084", "Exported type alias '{0}' has or is using private name '{1}' from module {2}."), + Conflicting_definitions_for_0_found_at_1_and_2_Consider_installing_a_specific_version_of_this_library_to_resolve_the_conflict: diag(4090, ts.DiagnosticCategory.Error, "Conflicting_definitions_for_0_found_at_1_and_2_Consider_installing_a_specific_version_of_this_librar_4090", "Conflicting definitions for '{0}' found at '{1}' and '{2}'. Consider installing a specific version of this library to resolve the conflict."), + Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4091, ts.DiagnosticCategory.Error, "Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2_4091", "Parameter '{0}' of index signature from exported interface has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4092, ts.DiagnosticCategory.Error, "Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_private_name_1_4092", "Parameter '{0}' of index signature from exported interface has or is using private name '{1}'."), + Property_0_of_exported_class_expression_may_not_be_private_or_protected: diag(4094, ts.DiagnosticCategory.Error, "Property_0_of_exported_class_expression_may_not_be_private_or_protected_4094", "Property '{0}' of exported class expression may not be private or protected."), + Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4095, ts.DiagnosticCategory.Error, "Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_4095", "Public static method '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named."), + Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4096, ts.DiagnosticCategory.Error, "Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4096", "Public static method '{0}' of exported class has or is using name '{1}' from private module '{2}'."), + Public_static_method_0_of_exported_class_has_or_is_using_private_name_1: diag(4097, ts.DiagnosticCategory.Error, "Public_static_method_0_of_exported_class_has_or_is_using_private_name_1_4097", "Public static method '{0}' of exported class has or is using private name '{1}'."), + Public_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4098, ts.DiagnosticCategory.Error, "Public_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4098", "Public method '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named."), + Public_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4099, ts.DiagnosticCategory.Error, "Public_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4099", "Public method '{0}' of exported class has or is using name '{1}' from private module '{2}'."), + Public_method_0_of_exported_class_has_or_is_using_private_name_1: diag(4100, ts.DiagnosticCategory.Error, "Public_method_0_of_exported_class_has_or_is_using_private_name_1_4100", "Public method '{0}' of exported class has or is using private name '{1}'."), + Method_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4101, ts.DiagnosticCategory.Error, "Method_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2_4101", "Method '{0}' of exported interface has or is using name '{1}' from private module '{2}'."), + Method_0_of_exported_interface_has_or_is_using_private_name_1: diag(4102, ts.DiagnosticCategory.Error, "Method_0_of_exported_interface_has_or_is_using_private_name_1_4102", "Method '{0}' of exported interface has or is using private name '{1}'."), + Type_parameter_0_of_exported_mapped_object_type_is_using_private_name_1: diag(4103, ts.DiagnosticCategory.Error, "Type_parameter_0_of_exported_mapped_object_type_is_using_private_name_1_4103", "Type parameter '{0}' of exported mapped object type is using private name '{1}'."), + The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1: diag(4104, ts.DiagnosticCategory.Error, "The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1_4104", "The type '{0}' is 'readonly' and cannot be assigned to the mutable type '{1}'."), + Private_or_protected_member_0_cannot_be_accessed_on_a_type_parameter: diag(4105, ts.DiagnosticCategory.Error, "Private_or_protected_member_0_cannot_be_accessed_on_a_type_parameter_4105", "Private or protected member '{0}' cannot be accessed on a type parameter."), + Parameter_0_of_accessor_has_or_is_using_private_name_1: diag(4106, ts.DiagnosticCategory.Error, "Parameter_0_of_accessor_has_or_is_using_private_name_1_4106", "Parameter '{0}' of accessor has or is using private name '{1}'."), + Parameter_0_of_accessor_has_or_is_using_name_1_from_private_module_2: diag(4107, ts.DiagnosticCategory.Error, "Parameter_0_of_accessor_has_or_is_using_name_1_from_private_module_2_4107", "Parameter '{0}' of accessor has or is using name '{1}' from private module '{2}'."), + Parameter_0_of_accessor_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4108, ts.DiagnosticCategory.Error, "Parameter_0_of_accessor_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4108", "Parameter '{0}' of accessor has or is using name '{1}' from external module '{2}' but cannot be named."), + Type_arguments_for_0_circularly_reference_themselves: diag(4109, ts.DiagnosticCategory.Error, "Type_arguments_for_0_circularly_reference_themselves_4109", "Type arguments for '{0}' circularly reference themselves."), + Tuple_type_arguments_circularly_reference_themselves: diag(4110, ts.DiagnosticCategory.Error, "Tuple_type_arguments_circularly_reference_themselves_4110", "Tuple type arguments circularly reference themselves."), + Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0: diag(4111, ts.DiagnosticCategory.Error, "Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0_4111", "Property '{0}' comes from an index signature, so it must be accessed with ['{0}']."), + This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class: diag(4112, ts.DiagnosticCategory.Error, "This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another__4112", "This member cannot have an 'override' modifier because its containing class '{0}' does not extend another class."), + This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0: diag(4113, ts.DiagnosticCategory.Error, "This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0_4113", "This member cannot have an 'override' modifier because it is not declared in the base class '{0}'."), + This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0: diag(4114, ts.DiagnosticCategory.Error, "This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0_4114", "This member must have an 'override' modifier because it overrides a member in the base class '{0}'."), + This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0: diag(4115, ts.DiagnosticCategory.Error, "This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0_4115", "This parameter property must have an 'override' modifier because it overrides a member in base class '{0}'."), + This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0: diag(4116, ts.DiagnosticCategory.Error, "This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared__4116", "This member must have an 'override' modifier because it overrides an abstract method that is declared in the base class '{0}'."), + This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1: diag(4117, ts.DiagnosticCategory.Error, "This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0_Did_you__4117", "This member cannot have an 'override' modifier because it is not declared in the base class '{0}'. Did you mean '{1}'?"), + The_type_of_this_node_cannot_be_serialized_because_its_property_0_cannot_be_serialized: diag(4118, ts.DiagnosticCategory.Error, "The_type_of_this_node_cannot_be_serialized_because_its_property_0_cannot_be_serialized_4118", "The type of this node cannot be serialized because its property '{0}' cannot be serialized."), + This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0: diag(4119, ts.DiagnosticCategory.Error, "This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_4119", "This member must have a JSDoc comment with an '@override' tag because it overrides a member in the base class '{0}'."), + This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0: diag(4120, ts.DiagnosticCategory.Error, "This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_4120", "This parameter property must have a JSDoc comment with an '@override' tag because it overrides a member in the base class '{0}'."), + This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class: diag(4121, ts.DiagnosticCategory.Error, "This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_4121", "This member cannot have a JSDoc comment with an '@override' tag because its containing class '{0}' does not extend another class."), + This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0: diag(4122, ts.DiagnosticCategory.Error, "This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base__4122", "This member cannot have a JSDoc comment with an '@override' tag because it is not declared in the base class '{0}'."), + This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1: diag(4123, ts.DiagnosticCategory.Error, "This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base__4123", "This member cannot have a JSDoc comment with an 'override' tag because it is not declared in the base class '{0}'. Did you mean '{1}'?"), + Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next: diag(4124, ts.DiagnosticCategory.Error, "Compiler_option_0_of_value_1_is_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_w_4124", "Compiler option '{0}' of value '{1}' is unstable. Use nightly TypeScript to silence this error. Try updating with 'npm install -D typescript@next'."), + resolution_mode_assertions_are_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next: diag(4125, ts.DiagnosticCategory.Error, "resolution_mode_assertions_are_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_wi_4125", "'resolution-mode' assertions are unstable. Use nightly TypeScript to silence this error. Try updating with 'npm install -D typescript@next'."), + The_current_host_does_not_support_the_0_option: diag(5001, ts.DiagnosticCategory.Error, "The_current_host_does_not_support_the_0_option_5001", "The current host does not support the '{0}' option."), + Cannot_find_the_common_subdirectory_path_for_the_input_files: diag(5009, ts.DiagnosticCategory.Error, "Cannot_find_the_common_subdirectory_path_for_the_input_files_5009", "Cannot find the common subdirectory path for the input files."), + File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0: diag(5010, ts.DiagnosticCategory.Error, "File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0_5010", "File specification cannot end in a recursive directory wildcard ('**'): '{0}'."), + Cannot_read_file_0_Colon_1: diag(5012, ts.DiagnosticCategory.Error, "Cannot_read_file_0_Colon_1_5012", "Cannot read file '{0}': {1}."), + Failed_to_parse_file_0_Colon_1: diag(5014, ts.DiagnosticCategory.Error, "Failed_to_parse_file_0_Colon_1_5014", "Failed to parse file '{0}': {1}."), + Unknown_compiler_option_0: diag(5023, ts.DiagnosticCategory.Error, "Unknown_compiler_option_0_5023", "Unknown compiler option '{0}'."), + Compiler_option_0_requires_a_value_of_type_1: diag(5024, ts.DiagnosticCategory.Error, "Compiler_option_0_requires_a_value_of_type_1_5024", "Compiler option '{0}' requires a value of type {1}."), + Unknown_compiler_option_0_Did_you_mean_1: diag(5025, ts.DiagnosticCategory.Error, "Unknown_compiler_option_0_Did_you_mean_1_5025", "Unknown compiler option '{0}'. Did you mean '{1}'?"), + Could_not_write_file_0_Colon_1: diag(5033, ts.DiagnosticCategory.Error, "Could_not_write_file_0_Colon_1_5033", "Could not write file '{0}': {1}."), + Option_project_cannot_be_mixed_with_source_files_on_a_command_line: diag(5042, ts.DiagnosticCategory.Error, "Option_project_cannot_be_mixed_with_source_files_on_a_command_line_5042", "Option 'project' cannot be mixed with source files on a command line."), + Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES2015_or_higher: diag(5047, ts.DiagnosticCategory.Error, "Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES_5047", "Option 'isolatedModules' can only be used when either option '--module' is provided or option 'target' is 'ES2015' or higher."), + Option_0_cannot_be_specified_when_option_target_is_ES3: diag(5048, ts.DiagnosticCategory.Error, "Option_0_cannot_be_specified_when_option_target_is_ES3_5048", "Option '{0}' cannot be specified when option 'target' is 'ES3'."), + Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided: diag(5051, ts.DiagnosticCategory.Error, "Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided_5051", "Option '{0} can only be used when either option '--inlineSourceMap' or option '--sourceMap' is provided."), + Option_0_cannot_be_specified_without_specifying_option_1: diag(5052, ts.DiagnosticCategory.Error, "Option_0_cannot_be_specified_without_specifying_option_1_5052", "Option '{0}' cannot be specified without specifying option '{1}'."), + Option_0_cannot_be_specified_with_option_1: diag(5053, ts.DiagnosticCategory.Error, "Option_0_cannot_be_specified_with_option_1_5053", "Option '{0}' cannot be specified with option '{1}'."), + A_tsconfig_json_file_is_already_defined_at_Colon_0: diag(5054, ts.DiagnosticCategory.Error, "A_tsconfig_json_file_is_already_defined_at_Colon_0_5054", "A 'tsconfig.json' file is already defined at: '{0}'."), + Cannot_write_file_0_because_it_would_overwrite_input_file: diag(5055, ts.DiagnosticCategory.Error, "Cannot_write_file_0_because_it_would_overwrite_input_file_5055", "Cannot write file '{0}' because it would overwrite input file."), + Cannot_write_file_0_because_it_would_be_overwritten_by_multiple_input_files: diag(5056, ts.DiagnosticCategory.Error, "Cannot_write_file_0_because_it_would_be_overwritten_by_multiple_input_files_5056", "Cannot write file '{0}' because it would be overwritten by multiple input files."), + Cannot_find_a_tsconfig_json_file_at_the_specified_directory_Colon_0: diag(5057, ts.DiagnosticCategory.Error, "Cannot_find_a_tsconfig_json_file_at_the_specified_directory_Colon_0_5057", "Cannot find a tsconfig.json file at the specified directory: '{0}'."), + The_specified_path_does_not_exist_Colon_0: diag(5058, ts.DiagnosticCategory.Error, "The_specified_path_does_not_exist_Colon_0_5058", "The specified path does not exist: '{0}'."), + Invalid_value_for_reactNamespace_0_is_not_a_valid_identifier: diag(5059, ts.DiagnosticCategory.Error, "Invalid_value_for_reactNamespace_0_is_not_a_valid_identifier_5059", "Invalid value for '--reactNamespace'. '{0}' is not a valid identifier."), + Pattern_0_can_have_at_most_one_Asterisk_character: diag(5061, ts.DiagnosticCategory.Error, "Pattern_0_can_have_at_most_one_Asterisk_character_5061", "Pattern '{0}' can have at most one '*' character."), + Substitution_0_in_pattern_1_can_have_at_most_one_Asterisk_character: diag(5062, ts.DiagnosticCategory.Error, "Substitution_0_in_pattern_1_can_have_at_most_one_Asterisk_character_5062", "Substitution '{0}' in pattern '{1}' can have at most one '*' character."), + Substitutions_for_pattern_0_should_be_an_array: diag(5063, ts.DiagnosticCategory.Error, "Substitutions_for_pattern_0_should_be_an_array_5063", "Substitutions for pattern '{0}' should be an array."), + Substitution_0_for_pattern_1_has_incorrect_type_expected_string_got_2: diag(5064, ts.DiagnosticCategory.Error, "Substitution_0_for_pattern_1_has_incorrect_type_expected_string_got_2_5064", "Substitution '{0}' for pattern '{1}' has incorrect type, expected 'string', got '{2}'."), + File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0: diag(5065, ts.DiagnosticCategory.Error, "File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildca_5065", "File specification cannot contain a parent directory ('..') that appears after a recursive directory wildcard ('**'): '{0}'."), + Substitutions_for_pattern_0_shouldn_t_be_an_empty_array: diag(5066, ts.DiagnosticCategory.Error, "Substitutions_for_pattern_0_shouldn_t_be_an_empty_array_5066", "Substitutions for pattern '{0}' shouldn't be an empty array."), + Invalid_value_for_jsxFactory_0_is_not_a_valid_identifier_or_qualified_name: diag(5067, ts.DiagnosticCategory.Error, "Invalid_value_for_jsxFactory_0_is_not_a_valid_identifier_or_qualified_name_5067", "Invalid value for 'jsxFactory'. '{0}' is not a valid identifier or qualified-name."), + Adding_a_tsconfig_json_file_will_help_organize_projects_that_contain_both_TypeScript_and_JavaScript_files_Learn_more_at_https_Colon_Slash_Slashaka_ms_Slashtsconfig: diag(5068, ts.DiagnosticCategory.Error, "Adding_a_tsconfig_json_file_will_help_organize_projects_that_contain_both_TypeScript_and_JavaScript__5068", "Adding a tsconfig.json file will help organize projects that contain both TypeScript and JavaScript files. Learn more at https://aka.ms/tsconfig."), + Option_0_cannot_be_specified_without_specifying_option_1_or_option_2: diag(5069, ts.DiagnosticCategory.Error, "Option_0_cannot_be_specified_without_specifying_option_1_or_option_2_5069", "Option '{0}' cannot be specified without specifying option '{1}' or option '{2}'."), + Option_resolveJsonModule_cannot_be_specified_without_node_module_resolution_strategy: diag(5070, ts.DiagnosticCategory.Error, "Option_resolveJsonModule_cannot_be_specified_without_node_module_resolution_strategy_5070", "Option '--resolveJsonModule' cannot be specified without 'node' module resolution strategy."), + Option_resolveJsonModule_can_only_be_specified_when_module_code_generation_is_commonjs_amd_es2015_or_esNext: diag(5071, ts.DiagnosticCategory.Error, "Option_resolveJsonModule_can_only_be_specified_when_module_code_generation_is_commonjs_amd_es2015_or_5071", "Option '--resolveJsonModule' can only be specified when module code generation is 'commonjs', 'amd', 'es2015' or 'esNext'."), + Unknown_build_option_0: diag(5072, ts.DiagnosticCategory.Error, "Unknown_build_option_0_5072", "Unknown build option '{0}'."), + Build_option_0_requires_a_value_of_type_1: diag(5073, ts.DiagnosticCategory.Error, "Build_option_0_requires_a_value_of_type_1_5073", "Build option '{0}' requires a value of type {1}."), + Option_incremental_can_only_be_specified_using_tsconfig_emitting_to_single_file_or_when_option_tsBuildInfoFile_is_specified: diag(5074, ts.DiagnosticCategory.Error, "Option_incremental_can_only_be_specified_using_tsconfig_emitting_to_single_file_or_when_option_tsBui_5074", "Option '--incremental' can only be specified using tsconfig, emitting to single file or when option '--tsBuildInfoFile' is specified."), + _0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_constraint_2: diag(5075, ts.DiagnosticCategory.Error, "_0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_5075", "'{0}' is assignable to the constraint of type '{1}', but '{1}' could be instantiated with a different subtype of constraint '{2}'."), + _0_and_1_operations_cannot_be_mixed_without_parentheses: diag(5076, ts.DiagnosticCategory.Error, "_0_and_1_operations_cannot_be_mixed_without_parentheses_5076", "'{0}' and '{1}' operations cannot be mixed without parentheses."), + Unknown_build_option_0_Did_you_mean_1: diag(5077, ts.DiagnosticCategory.Error, "Unknown_build_option_0_Did_you_mean_1_5077", "Unknown build option '{0}'. Did you mean '{1}'?"), + Unknown_watch_option_0: diag(5078, ts.DiagnosticCategory.Error, "Unknown_watch_option_0_5078", "Unknown watch option '{0}'."), + Unknown_watch_option_0_Did_you_mean_1: diag(5079, ts.DiagnosticCategory.Error, "Unknown_watch_option_0_Did_you_mean_1_5079", "Unknown watch option '{0}'. Did you mean '{1}'?"), + Watch_option_0_requires_a_value_of_type_1: diag(5080, ts.DiagnosticCategory.Error, "Watch_option_0_requires_a_value_of_type_1_5080", "Watch option '{0}' requires a value of type {1}."), + Cannot_find_a_tsconfig_json_file_at_the_current_directory_Colon_0: diag(5081, ts.DiagnosticCategory.Error, "Cannot_find_a_tsconfig_json_file_at_the_current_directory_Colon_0_5081", "Cannot find a tsconfig.json file at the current directory: {0}."), + _0_could_be_instantiated_with_an_arbitrary_type_which_could_be_unrelated_to_1: diag(5082, ts.DiagnosticCategory.Error, "_0_could_be_instantiated_with_an_arbitrary_type_which_could_be_unrelated_to_1_5082", "'{0}' could be instantiated with an arbitrary type which could be unrelated to '{1}'."), + Cannot_read_file_0: diag(5083, ts.DiagnosticCategory.Error, "Cannot_read_file_0_5083", "Cannot read file '{0}'."), + Tuple_members_must_all_have_names_or_all_not_have_names: diag(5084, ts.DiagnosticCategory.Error, "Tuple_members_must_all_have_names_or_all_not_have_names_5084", "Tuple members must all have names or all not have names."), + A_tuple_member_cannot_be_both_optional_and_rest: diag(5085, ts.DiagnosticCategory.Error, "A_tuple_member_cannot_be_both_optional_and_rest_5085", "A tuple member cannot be both optional and rest."), + A_labeled_tuple_element_is_declared_as_optional_with_a_question_mark_after_the_name_and_before_the_colon_rather_than_after_the_type: diag(5086, ts.DiagnosticCategory.Error, "A_labeled_tuple_element_is_declared_as_optional_with_a_question_mark_after_the_name_and_before_the_c_5086", "A labeled tuple element is declared as optional with a question mark after the name and before the colon, rather than after the type."), + A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type: diag(5087, ts.DiagnosticCategory.Error, "A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type_5087", "A labeled tuple element is declared as rest with a '...' before the name, rather than before the type."), + The_inferred_type_of_0_references_a_type_with_a_cyclic_structure_which_cannot_be_trivially_serialized_A_type_annotation_is_necessary: diag(5088, ts.DiagnosticCategory.Error, "The_inferred_type_of_0_references_a_type_with_a_cyclic_structure_which_cannot_be_trivially_serialize_5088", "The inferred type of '{0}' references a type with a cyclic structure which cannot be trivially serialized. A type annotation is necessary."), + Option_0_cannot_be_specified_when_option_jsx_is_1: diag(5089, ts.DiagnosticCategory.Error, "Option_0_cannot_be_specified_when_option_jsx_is_1_5089", "Option '{0}' cannot be specified when option 'jsx' is '{1}'."), + Non_relative_paths_are_not_allowed_when_baseUrl_is_not_set_Did_you_forget_a_leading_Slash: diag(5090, ts.DiagnosticCategory.Error, "Non_relative_paths_are_not_allowed_when_baseUrl_is_not_set_Did_you_forget_a_leading_Slash_5090", "Non-relative paths are not allowed when 'baseUrl' is not set. Did you forget a leading './'?"), + Option_preserveConstEnums_cannot_be_disabled_when_isolatedModules_is_enabled: diag(5091, ts.DiagnosticCategory.Error, "Option_preserveConstEnums_cannot_be_disabled_when_isolatedModules_is_enabled_5091", "Option 'preserveConstEnums' cannot be disabled when 'isolatedModules' is enabled."), + The_root_value_of_a_0_file_must_be_an_object: diag(5092, ts.DiagnosticCategory.Error, "The_root_value_of_a_0_file_must_be_an_object_5092", "The root value of a '{0}' file must be an object."), + Compiler_option_0_may_only_be_used_with_build: diag(5093, ts.DiagnosticCategory.Error, "Compiler_option_0_may_only_be_used_with_build_5093", "Compiler option '--{0}' may only be used with '--build'."), + Compiler_option_0_may_not_be_used_with_build: diag(5094, ts.DiagnosticCategory.Error, "Compiler_option_0_may_not_be_used_with_build_5094", "Compiler option '--{0}' may not be used with '--build'."), + Option_preserveValueImports_can_only_be_used_when_module_is_set_to_es2015_or_later: diag(5095, ts.DiagnosticCategory.Error, "Option_preserveValueImports_can_only_be_used_when_module_is_set_to_es2015_or_later_5095", "Option 'preserveValueImports' can only be used when 'module' is set to 'es2015' or later."), + Generates_a_sourcemap_for_each_corresponding_d_ts_file: diag(6000, ts.DiagnosticCategory.Message, "Generates_a_sourcemap_for_each_corresponding_d_ts_file_6000", "Generates a sourcemap for each corresponding '.d.ts' file."), + Concatenate_and_emit_output_to_single_file: diag(6001, ts.DiagnosticCategory.Message, "Concatenate_and_emit_output_to_single_file_6001", "Concatenate and emit output to single file."), + Generates_corresponding_d_ts_file: diag(6002, ts.DiagnosticCategory.Message, "Generates_corresponding_d_ts_file_6002", "Generates corresponding '.d.ts' file."), + Specify_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations: diag(6004, ts.DiagnosticCategory.Message, "Specify_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations_6004", "Specify the location where debugger should locate TypeScript files instead of source locations."), + Watch_input_files: diag(6005, ts.DiagnosticCategory.Message, "Watch_input_files_6005", "Watch input files."), + Redirect_output_structure_to_the_directory: diag(6006, ts.DiagnosticCategory.Message, "Redirect_output_structure_to_the_directory_6006", "Redirect output structure to the directory."), + Do_not_erase_const_enum_declarations_in_generated_code: diag(6007, ts.DiagnosticCategory.Message, "Do_not_erase_const_enum_declarations_in_generated_code_6007", "Do not erase const enum declarations in generated code."), + Do_not_emit_outputs_if_any_errors_were_reported: diag(6008, ts.DiagnosticCategory.Message, "Do_not_emit_outputs_if_any_errors_were_reported_6008", "Do not emit outputs if any errors were reported."), + Do_not_emit_comments_to_output: diag(6009, ts.DiagnosticCategory.Message, "Do_not_emit_comments_to_output_6009", "Do not emit comments to output."), + Do_not_emit_outputs: diag(6010, ts.DiagnosticCategory.Message, "Do_not_emit_outputs_6010", "Do not emit outputs."), + Allow_default_imports_from_modules_with_no_default_export_This_does_not_affect_code_emit_just_typechecking: diag(6011, ts.DiagnosticCategory.Message, "Allow_default_imports_from_modules_with_no_default_export_This_does_not_affect_code_emit_just_typech_6011", "Allow default imports from modules with no default export. This does not affect code emit, just typechecking."), + Skip_type_checking_of_declaration_files: diag(6012, ts.DiagnosticCategory.Message, "Skip_type_checking_of_declaration_files_6012", "Skip type checking of declaration files."), + Do_not_resolve_the_real_path_of_symlinks: diag(6013, ts.DiagnosticCategory.Message, "Do_not_resolve_the_real_path_of_symlinks_6013", "Do not resolve the real path of symlinks."), + Only_emit_d_ts_declaration_files: diag(6014, ts.DiagnosticCategory.Message, "Only_emit_d_ts_declaration_files_6014", "Only emit '.d.ts' declaration files."), + Specify_ECMAScript_target_version: diag(6015, ts.DiagnosticCategory.Message, "Specify_ECMAScript_target_version_6015", "Specify ECMAScript target version."), + Specify_module_code_generation: diag(6016, ts.DiagnosticCategory.Message, "Specify_module_code_generation_6016", "Specify module code generation."), + Print_this_message: diag(6017, ts.DiagnosticCategory.Message, "Print_this_message_6017", "Print this message."), + Print_the_compiler_s_version: diag(6019, ts.DiagnosticCategory.Message, "Print_the_compiler_s_version_6019", "Print the compiler's version."), + Compile_the_project_given_the_path_to_its_configuration_file_or_to_a_folder_with_a_tsconfig_json: diag(6020, ts.DiagnosticCategory.Message, "Compile_the_project_given_the_path_to_its_configuration_file_or_to_a_folder_with_a_tsconfig_json_6020", "Compile the project given the path to its configuration file, or to a folder with a 'tsconfig.json'."), + Syntax_Colon_0: diag(6023, ts.DiagnosticCategory.Message, "Syntax_Colon_0_6023", "Syntax: {0}"), + options: diag(6024, ts.DiagnosticCategory.Message, "options_6024", "options"), + file: diag(6025, ts.DiagnosticCategory.Message, "file_6025", "file"), + Examples_Colon_0: diag(6026, ts.DiagnosticCategory.Message, "Examples_Colon_0_6026", "Examples: {0}"), + Options_Colon: diag(6027, ts.DiagnosticCategory.Message, "Options_Colon_6027", "Options:"), + Version_0: diag(6029, ts.DiagnosticCategory.Message, "Version_0_6029", "Version {0}"), + Insert_command_line_options_and_files_from_a_file: diag(6030, ts.DiagnosticCategory.Message, "Insert_command_line_options_and_files_from_a_file_6030", "Insert command line options and files from a file."), + Starting_compilation_in_watch_mode: diag(6031, ts.DiagnosticCategory.Message, "Starting_compilation_in_watch_mode_6031", "Starting compilation in watch mode..."), + File_change_detected_Starting_incremental_compilation: diag(6032, ts.DiagnosticCategory.Message, "File_change_detected_Starting_incremental_compilation_6032", "File change detected. Starting incremental compilation..."), + KIND: diag(6034, ts.DiagnosticCategory.Message, "KIND_6034", "KIND"), + FILE: diag(6035, ts.DiagnosticCategory.Message, "FILE_6035", "FILE"), + VERSION: diag(6036, ts.DiagnosticCategory.Message, "VERSION_6036", "VERSION"), + LOCATION: diag(6037, ts.DiagnosticCategory.Message, "LOCATION_6037", "LOCATION"), + DIRECTORY: diag(6038, ts.DiagnosticCategory.Message, "DIRECTORY_6038", "DIRECTORY"), + STRATEGY: diag(6039, ts.DiagnosticCategory.Message, "STRATEGY_6039", "STRATEGY"), + FILE_OR_DIRECTORY: diag(6040, ts.DiagnosticCategory.Message, "FILE_OR_DIRECTORY_6040", "FILE OR DIRECTORY"), + Errors_Files: diag(6041, ts.DiagnosticCategory.Message, "Errors_Files_6041", "Errors Files"), + Generates_corresponding_map_file: diag(6043, ts.DiagnosticCategory.Message, "Generates_corresponding_map_file_6043", "Generates corresponding '.map' file."), + Compiler_option_0_expects_an_argument: diag(6044, ts.DiagnosticCategory.Error, "Compiler_option_0_expects_an_argument_6044", "Compiler option '{0}' expects an argument."), + Unterminated_quoted_string_in_response_file_0: diag(6045, ts.DiagnosticCategory.Error, "Unterminated_quoted_string_in_response_file_0_6045", "Unterminated quoted string in response file '{0}'."), + Argument_for_0_option_must_be_Colon_1: diag(6046, ts.DiagnosticCategory.Error, "Argument_for_0_option_must_be_Colon_1_6046", "Argument for '{0}' option must be: {1}."), + Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1: diag(6048, ts.DiagnosticCategory.Error, "Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1_6048", "Locale must be of the form or -. For example '{0}' or '{1}'."), + Unable_to_open_file_0: diag(6050, ts.DiagnosticCategory.Error, "Unable_to_open_file_0_6050", "Unable to open file '{0}'."), + Corrupted_locale_file_0: diag(6051, ts.DiagnosticCategory.Error, "Corrupted_locale_file_0_6051", "Corrupted locale file {0}."), + Raise_error_on_expressions_and_declarations_with_an_implied_any_type: diag(6052, ts.DiagnosticCategory.Message, "Raise_error_on_expressions_and_declarations_with_an_implied_any_type_6052", "Raise error on expressions and declarations with an implied 'any' type."), + File_0_not_found: diag(6053, ts.DiagnosticCategory.Error, "File_0_not_found_6053", "File '{0}' not found."), + File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1: diag(6054, ts.DiagnosticCategory.Error, "File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1_6054", "File '{0}' has an unsupported extension. The only supported extensions are {1}."), + Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures: diag(6055, ts.DiagnosticCategory.Message, "Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures_6055", "Suppress noImplicitAny errors for indexing objects lacking index signatures."), + Do_not_emit_declarations_for_code_that_has_an_internal_annotation: diag(6056, ts.DiagnosticCategory.Message, "Do_not_emit_declarations_for_code_that_has_an_internal_annotation_6056", "Do not emit declarations for code that has an '@internal' annotation."), + Specify_the_root_directory_of_input_files_Use_to_control_the_output_directory_structure_with_outDir: diag(6058, ts.DiagnosticCategory.Message, "Specify_the_root_directory_of_input_files_Use_to_control_the_output_directory_structure_with_outDir_6058", "Specify the root directory of input files. Use to control the output directory structure with --outDir."), + File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files: diag(6059, ts.DiagnosticCategory.Error, "File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files_6059", "File '{0}' is not under 'rootDir' '{1}'. 'rootDir' is expected to contain all source files."), + Specify_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix: diag(6060, ts.DiagnosticCategory.Message, "Specify_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix_6060", "Specify the end of line sequence to be used when emitting files: 'CRLF' (dos) or 'LF' (unix)."), + NEWLINE: diag(6061, ts.DiagnosticCategory.Message, "NEWLINE_6061", "NEWLINE"), + Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_null_on_command_line: diag(6064, ts.DiagnosticCategory.Error, "Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_null_on_command_line_6064", "Option '{0}' can only be specified in 'tsconfig.json' file or set to 'null' on command line."), + Enables_experimental_support_for_ES7_decorators: diag(6065, ts.DiagnosticCategory.Message, "Enables_experimental_support_for_ES7_decorators_6065", "Enables experimental support for ES7 decorators."), + Enables_experimental_support_for_emitting_type_metadata_for_decorators: diag(6066, ts.DiagnosticCategory.Message, "Enables_experimental_support_for_emitting_type_metadata_for_decorators_6066", "Enables experimental support for emitting type metadata for decorators."), + Specify_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6: diag(6069, ts.DiagnosticCategory.Message, "Specify_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6_6069", "Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6)."), + Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file: diag(6070, ts.DiagnosticCategory.Message, "Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file_6070", "Initializes a TypeScript project and creates a tsconfig.json file."), + Successfully_created_a_tsconfig_json_file: diag(6071, ts.DiagnosticCategory.Message, "Successfully_created_a_tsconfig_json_file_6071", "Successfully created a tsconfig.json file."), + Suppress_excess_property_checks_for_object_literals: diag(6072, ts.DiagnosticCategory.Message, "Suppress_excess_property_checks_for_object_literals_6072", "Suppress excess property checks for object literals."), + Stylize_errors_and_messages_using_color_and_context_experimental: diag(6073, ts.DiagnosticCategory.Message, "Stylize_errors_and_messages_using_color_and_context_experimental_6073", "Stylize errors and messages using color and context (experimental)."), + Do_not_report_errors_on_unused_labels: diag(6074, ts.DiagnosticCategory.Message, "Do_not_report_errors_on_unused_labels_6074", "Do not report errors on unused labels."), + Report_error_when_not_all_code_paths_in_function_return_a_value: diag(6075, ts.DiagnosticCategory.Message, "Report_error_when_not_all_code_paths_in_function_return_a_value_6075", "Report error when not all code paths in function return a value."), + Report_errors_for_fallthrough_cases_in_switch_statement: diag(6076, ts.DiagnosticCategory.Message, "Report_errors_for_fallthrough_cases_in_switch_statement_6076", "Report errors for fallthrough cases in switch statement."), + Do_not_report_errors_on_unreachable_code: diag(6077, ts.DiagnosticCategory.Message, "Do_not_report_errors_on_unreachable_code_6077", "Do not report errors on unreachable code."), + Disallow_inconsistently_cased_references_to_the_same_file: diag(6078, ts.DiagnosticCategory.Message, "Disallow_inconsistently_cased_references_to_the_same_file_6078", "Disallow inconsistently-cased references to the same file."), + Specify_library_files_to_be_included_in_the_compilation: diag(6079, ts.DiagnosticCategory.Message, "Specify_library_files_to_be_included_in_the_compilation_6079", "Specify library files to be included in the compilation."), + Specify_JSX_code_generation: diag(6080, ts.DiagnosticCategory.Message, "Specify_JSX_code_generation_6080", "Specify JSX code generation."), + File_0_has_an_unsupported_extension_so_skipping_it: diag(6081, ts.DiagnosticCategory.Message, "File_0_has_an_unsupported_extension_so_skipping_it_6081", "File '{0}' has an unsupported extension, so skipping it."), + Only_amd_and_system_modules_are_supported_alongside_0: diag(6082, ts.DiagnosticCategory.Error, "Only_amd_and_system_modules_are_supported_alongside_0_6082", "Only 'amd' and 'system' modules are supported alongside --{0}."), + Base_directory_to_resolve_non_absolute_module_names: diag(6083, ts.DiagnosticCategory.Message, "Base_directory_to_resolve_non_absolute_module_names_6083", "Base directory to resolve non-absolute module names."), + Deprecated_Use_jsxFactory_instead_Specify_the_object_invoked_for_createElement_when_targeting_react_JSX_emit: diag(6084, ts.DiagnosticCategory.Message, "Deprecated_Use_jsxFactory_instead_Specify_the_object_invoked_for_createElement_when_targeting_react__6084", "[Deprecated] Use '--jsxFactory' instead. Specify the object invoked for createElement when targeting 'react' JSX emit"), + Enable_tracing_of_the_name_resolution_process: diag(6085, ts.DiagnosticCategory.Message, "Enable_tracing_of_the_name_resolution_process_6085", "Enable tracing of the name resolution process."), + Resolving_module_0_from_1: diag(6086, ts.DiagnosticCategory.Message, "Resolving_module_0_from_1_6086", "======== Resolving module '{0}' from '{1}'. ========"), + Explicitly_specified_module_resolution_kind_Colon_0: diag(6087, ts.DiagnosticCategory.Message, "Explicitly_specified_module_resolution_kind_Colon_0_6087", "Explicitly specified module resolution kind: '{0}'."), + Module_resolution_kind_is_not_specified_using_0: diag(6088, ts.DiagnosticCategory.Message, "Module_resolution_kind_is_not_specified_using_0_6088", "Module resolution kind is not specified, using '{0}'."), + Module_name_0_was_successfully_resolved_to_1: diag(6089, ts.DiagnosticCategory.Message, "Module_name_0_was_successfully_resolved_to_1_6089", "======== Module name '{0}' was successfully resolved to '{1}'. ========"), + Module_name_0_was_not_resolved: diag(6090, ts.DiagnosticCategory.Message, "Module_name_0_was_not_resolved_6090", "======== Module name '{0}' was not resolved. ========"), + paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0: diag(6091, ts.DiagnosticCategory.Message, "paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0_6091", "'paths' option is specified, looking for a pattern to match module name '{0}'."), + Module_name_0_matched_pattern_1: diag(6092, ts.DiagnosticCategory.Message, "Module_name_0_matched_pattern_1_6092", "Module name '{0}', matched pattern '{1}'."), + Trying_substitution_0_candidate_module_location_Colon_1: diag(6093, ts.DiagnosticCategory.Message, "Trying_substitution_0_candidate_module_location_Colon_1_6093", "Trying substitution '{0}', candidate module location: '{1}'."), + Resolving_module_name_0_relative_to_base_url_1_2: diag(6094, ts.DiagnosticCategory.Message, "Resolving_module_name_0_relative_to_base_url_1_2_6094", "Resolving module name '{0}' relative to base url '{1}' - '{2}'."), + Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_type_1: diag(6095, ts.DiagnosticCategory.Message, "Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_type_1_6095", "Loading module as file / folder, candidate module location '{0}', target file type '{1}'."), + File_0_does_not_exist: diag(6096, ts.DiagnosticCategory.Message, "File_0_does_not_exist_6096", "File '{0}' does not exist."), + File_0_exist_use_it_as_a_name_resolution_result: diag(6097, ts.DiagnosticCategory.Message, "File_0_exist_use_it_as_a_name_resolution_result_6097", "File '{0}' exist - use it as a name resolution result."), + Loading_module_0_from_node_modules_folder_target_file_type_1: diag(6098, ts.DiagnosticCategory.Message, "Loading_module_0_from_node_modules_folder_target_file_type_1_6098", "Loading module '{0}' from 'node_modules' folder, target file type '{1}'."), + Found_package_json_at_0: diag(6099, ts.DiagnosticCategory.Message, "Found_package_json_at_0_6099", "Found 'package.json' at '{0}'."), + package_json_does_not_have_a_0_field: diag(6100, ts.DiagnosticCategory.Message, "package_json_does_not_have_a_0_field_6100", "'package.json' does not have a '{0}' field."), + package_json_has_0_field_1_that_references_2: diag(6101, ts.DiagnosticCategory.Message, "package_json_has_0_field_1_that_references_2_6101", "'package.json' has '{0}' field '{1}' that references '{2}'."), + Allow_javascript_files_to_be_compiled: diag(6102, ts.DiagnosticCategory.Message, "Allow_javascript_files_to_be_compiled_6102", "Allow javascript files to be compiled."), + Checking_if_0_is_the_longest_matching_prefix_for_1_2: diag(6104, ts.DiagnosticCategory.Message, "Checking_if_0_is_the_longest_matching_prefix_for_1_2_6104", "Checking if '{0}' is the longest matching prefix for '{1}' - '{2}'."), + Expected_type_of_0_field_in_package_json_to_be_1_got_2: diag(6105, ts.DiagnosticCategory.Message, "Expected_type_of_0_field_in_package_json_to_be_1_got_2_6105", "Expected type of '{0}' field in 'package.json' to be '{1}', got '{2}'."), + baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1: diag(6106, ts.DiagnosticCategory.Message, "baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1_6106", "'baseUrl' option is set to '{0}', using this value to resolve non-relative module name '{1}'."), + rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0: diag(6107, ts.DiagnosticCategory.Message, "rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0_6107", "'rootDirs' option is set, using it to resolve relative module name '{0}'."), + Longest_matching_prefix_for_0_is_1: diag(6108, ts.DiagnosticCategory.Message, "Longest_matching_prefix_for_0_is_1_6108", "Longest matching prefix for '{0}' is '{1}'."), + Loading_0_from_the_root_dir_1_candidate_location_2: diag(6109, ts.DiagnosticCategory.Message, "Loading_0_from_the_root_dir_1_candidate_location_2_6109", "Loading '{0}' from the root dir '{1}', candidate location '{2}'."), + Trying_other_entries_in_rootDirs: diag(6110, ts.DiagnosticCategory.Message, "Trying_other_entries_in_rootDirs_6110", "Trying other entries in 'rootDirs'."), + Module_resolution_using_rootDirs_has_failed: diag(6111, ts.DiagnosticCategory.Message, "Module_resolution_using_rootDirs_has_failed_6111", "Module resolution using 'rootDirs' has failed."), + Do_not_emit_use_strict_directives_in_module_output: diag(6112, ts.DiagnosticCategory.Message, "Do_not_emit_use_strict_directives_in_module_output_6112", "Do not emit 'use strict' directives in module output."), + Enable_strict_null_checks: diag(6113, ts.DiagnosticCategory.Message, "Enable_strict_null_checks_6113", "Enable strict null checks."), + Unknown_option_excludes_Did_you_mean_exclude: diag(6114, ts.DiagnosticCategory.Error, "Unknown_option_excludes_Did_you_mean_exclude_6114", "Unknown option 'excludes'. Did you mean 'exclude'?"), + Raise_error_on_this_expressions_with_an_implied_any_type: diag(6115, ts.DiagnosticCategory.Message, "Raise_error_on_this_expressions_with_an_implied_any_type_6115", "Raise error on 'this' expressions with an implied 'any' type."), + Resolving_type_reference_directive_0_containing_file_1_root_directory_2: diag(6116, ts.DiagnosticCategory.Message, "Resolving_type_reference_directive_0_containing_file_1_root_directory_2_6116", "======== Resolving type reference directive '{0}', containing file '{1}', root directory '{2}'. ========"), + Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2: diag(6119, ts.DiagnosticCategory.Message, "Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2_6119", "======== Type reference directive '{0}' was successfully resolved to '{1}', primary: {2}. ========"), + Type_reference_directive_0_was_not_resolved: diag(6120, ts.DiagnosticCategory.Message, "Type_reference_directive_0_was_not_resolved_6120", "======== Type reference directive '{0}' was not resolved. ========"), + Resolving_with_primary_search_path_0: diag(6121, ts.DiagnosticCategory.Message, "Resolving_with_primary_search_path_0_6121", "Resolving with primary search path '{0}'."), + Root_directory_cannot_be_determined_skipping_primary_search_paths: diag(6122, ts.DiagnosticCategory.Message, "Root_directory_cannot_be_determined_skipping_primary_search_paths_6122", "Root directory cannot be determined, skipping primary search paths."), + Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set: diag(6123, ts.DiagnosticCategory.Message, "Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set_6123", "======== Resolving type reference directive '{0}', containing file '{1}', root directory not set. ========"), + Type_declaration_files_to_be_included_in_compilation: diag(6124, ts.DiagnosticCategory.Message, "Type_declaration_files_to_be_included_in_compilation_6124", "Type declaration files to be included in compilation."), + Looking_up_in_node_modules_folder_initial_location_0: diag(6125, ts.DiagnosticCategory.Message, "Looking_up_in_node_modules_folder_initial_location_0_6125", "Looking up in 'node_modules' folder, initial location '{0}'."), + Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_modules_folder: diag(6126, ts.DiagnosticCategory.Message, "Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_mod_6126", "Containing file is not specified and root directory cannot be determined, skipping lookup in 'node_modules' folder."), + Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1: diag(6127, ts.DiagnosticCategory.Message, "Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1_6127", "======== Resolving type reference directive '{0}', containing file not set, root directory '{1}'. ========"), + Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set: diag(6128, ts.DiagnosticCategory.Message, "Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set_6128", "======== Resolving type reference directive '{0}', containing file not set, root directory not set. ========"), + Resolving_real_path_for_0_result_1: diag(6130, ts.DiagnosticCategory.Message, "Resolving_real_path_for_0_result_1_6130", "Resolving real path for '{0}', result '{1}'."), + Cannot_compile_modules_using_option_0_unless_the_module_flag_is_amd_or_system: diag(6131, ts.DiagnosticCategory.Error, "Cannot_compile_modules_using_option_0_unless_the_module_flag_is_amd_or_system_6131", "Cannot compile modules using option '{0}' unless the '--module' flag is 'amd' or 'system'."), + File_name_0_has_a_1_extension_stripping_it: diag(6132, ts.DiagnosticCategory.Message, "File_name_0_has_a_1_extension_stripping_it_6132", "File name '{0}' has a '{1}' extension - stripping it."), + _0_is_declared_but_its_value_is_never_read: diag(6133, ts.DiagnosticCategory.Error, "_0_is_declared_but_its_value_is_never_read_6133", "'{0}' is declared but its value is never read.", /*reportsUnnecessary*/ true), + Report_errors_on_unused_locals: diag(6134, ts.DiagnosticCategory.Message, "Report_errors_on_unused_locals_6134", "Report errors on unused locals."), + Report_errors_on_unused_parameters: diag(6135, ts.DiagnosticCategory.Message, "Report_errors_on_unused_parameters_6135", "Report errors on unused parameters."), + The_maximum_dependency_depth_to_search_under_node_modules_and_load_JavaScript_files: diag(6136, ts.DiagnosticCategory.Message, "The_maximum_dependency_depth_to_search_under_node_modules_and_load_JavaScript_files_6136", "The maximum dependency depth to search under node_modules and load JavaScript files."), + Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1: diag(6137, ts.DiagnosticCategory.Error, "Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1_6137", "Cannot import type declaration files. Consider importing '{0}' instead of '{1}'."), + Property_0_is_declared_but_its_value_is_never_read: diag(6138, ts.DiagnosticCategory.Error, "Property_0_is_declared_but_its_value_is_never_read_6138", "Property '{0}' is declared but its value is never read.", /*reportsUnnecessary*/ true), + Import_emit_helpers_from_tslib: diag(6139, ts.DiagnosticCategory.Message, "Import_emit_helpers_from_tslib_6139", "Import emit helpers from 'tslib'."), + Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using_cache_location_2: diag(6140, ts.DiagnosticCategory.Error, "Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using__6140", "Auto discovery for typings is enabled in project '{0}'. Running extra resolution pass for module '{1}' using cache location '{2}'."), + Parse_in_strict_mode_and_emit_use_strict_for_each_source_file: diag(6141, ts.DiagnosticCategory.Message, "Parse_in_strict_mode_and_emit_use_strict_for_each_source_file_6141", "Parse in strict mode and emit \"use strict\" for each source file."), + Module_0_was_resolved_to_1_but_jsx_is_not_set: diag(6142, ts.DiagnosticCategory.Error, "Module_0_was_resolved_to_1_but_jsx_is_not_set_6142", "Module '{0}' was resolved to '{1}', but '--jsx' is not set."), + Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1: diag(6144, ts.DiagnosticCategory.Message, "Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1_6144", "Module '{0}' was resolved as locally declared ambient module in file '{1}'."), + Module_0_was_resolved_as_ambient_module_declared_in_1_since_this_file_was_not_modified: diag(6145, ts.DiagnosticCategory.Message, "Module_0_was_resolved_as_ambient_module_declared_in_1_since_this_file_was_not_modified_6145", "Module '{0}' was resolved as ambient module declared in '{1}' since this file was not modified."), + Specify_the_JSX_factory_function_to_use_when_targeting_react_JSX_emit_e_g_React_createElement_or_h: diag(6146, ts.DiagnosticCategory.Message, "Specify_the_JSX_factory_function_to_use_when_targeting_react_JSX_emit_e_g_React_createElement_or_h_6146", "Specify the JSX factory function to use when targeting 'react' JSX emit, e.g. 'React.createElement' or 'h'."), + Resolution_for_module_0_was_found_in_cache_from_location_1: diag(6147, ts.DiagnosticCategory.Message, "Resolution_for_module_0_was_found_in_cache_from_location_1_6147", "Resolution for module '{0}' was found in cache from location '{1}'."), + Directory_0_does_not_exist_skipping_all_lookups_in_it: diag(6148, ts.DiagnosticCategory.Message, "Directory_0_does_not_exist_skipping_all_lookups_in_it_6148", "Directory '{0}' does not exist, skipping all lookups in it."), + Show_diagnostic_information: diag(6149, ts.DiagnosticCategory.Message, "Show_diagnostic_information_6149", "Show diagnostic information."), + Show_verbose_diagnostic_information: diag(6150, ts.DiagnosticCategory.Message, "Show_verbose_diagnostic_information_6150", "Show verbose diagnostic information."), + Emit_a_single_file_with_source_maps_instead_of_having_a_separate_file: diag(6151, ts.DiagnosticCategory.Message, "Emit_a_single_file_with_source_maps_instead_of_having_a_separate_file_6151", "Emit a single file with source maps instead of having a separate file."), + Emit_the_source_alongside_the_sourcemaps_within_a_single_file_requires_inlineSourceMap_or_sourceMap_to_be_set: diag(6152, ts.DiagnosticCategory.Message, "Emit_the_source_alongside_the_sourcemaps_within_a_single_file_requires_inlineSourceMap_or_sourceMap__6152", "Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set."), + Transpile_each_file_as_a_separate_module_similar_to_ts_transpileModule: diag(6153, ts.DiagnosticCategory.Message, "Transpile_each_file_as_a_separate_module_similar_to_ts_transpileModule_6153", "Transpile each file as a separate module (similar to 'ts.transpileModule')."), + Print_names_of_generated_files_part_of_the_compilation: diag(6154, ts.DiagnosticCategory.Message, "Print_names_of_generated_files_part_of_the_compilation_6154", "Print names of generated files part of the compilation."), + Print_names_of_files_part_of_the_compilation: diag(6155, ts.DiagnosticCategory.Message, "Print_names_of_files_part_of_the_compilation_6155", "Print names of files part of the compilation."), + The_locale_used_when_displaying_messages_to_the_user_e_g_en_us: diag(6156, ts.DiagnosticCategory.Message, "The_locale_used_when_displaying_messages_to_the_user_e_g_en_us_6156", "The locale used when displaying messages to the user (e.g. 'en-us')"), + Do_not_generate_custom_helper_functions_like_extends_in_compiled_output: diag(6157, ts.DiagnosticCategory.Message, "Do_not_generate_custom_helper_functions_like_extends_in_compiled_output_6157", "Do not generate custom helper functions like '__extends' in compiled output."), + Do_not_include_the_default_library_file_lib_d_ts: diag(6158, ts.DiagnosticCategory.Message, "Do_not_include_the_default_library_file_lib_d_ts_6158", "Do not include the default library file (lib.d.ts)."), + Do_not_add_triple_slash_references_or_imported_modules_to_the_list_of_compiled_files: diag(6159, ts.DiagnosticCategory.Message, "Do_not_add_triple_slash_references_or_imported_modules_to_the_list_of_compiled_files_6159", "Do not add triple-slash references or imported modules to the list of compiled files."), + Deprecated_Use_skipLibCheck_instead_Skip_type_checking_of_default_library_declaration_files: diag(6160, ts.DiagnosticCategory.Message, "Deprecated_Use_skipLibCheck_instead_Skip_type_checking_of_default_library_declaration_files_6160", "[Deprecated] Use '--skipLibCheck' instead. Skip type checking of default library declaration files."), + List_of_folders_to_include_type_definitions_from: diag(6161, ts.DiagnosticCategory.Message, "List_of_folders_to_include_type_definitions_from_6161", "List of folders to include type definitions from."), + Disable_size_limitations_on_JavaScript_projects: diag(6162, ts.DiagnosticCategory.Message, "Disable_size_limitations_on_JavaScript_projects_6162", "Disable size limitations on JavaScript projects."), + The_character_set_of_the_input_files: diag(6163, ts.DiagnosticCategory.Message, "The_character_set_of_the_input_files_6163", "The character set of the input files."), + Do_not_truncate_error_messages: diag(6165, ts.DiagnosticCategory.Message, "Do_not_truncate_error_messages_6165", "Do not truncate error messages."), + Output_directory_for_generated_declaration_files: diag(6166, ts.DiagnosticCategory.Message, "Output_directory_for_generated_declaration_files_6166", "Output directory for generated declaration files."), + A_series_of_entries_which_re_map_imports_to_lookup_locations_relative_to_the_baseUrl: diag(6167, ts.DiagnosticCategory.Message, "A_series_of_entries_which_re_map_imports_to_lookup_locations_relative_to_the_baseUrl_6167", "A series of entries which re-map imports to lookup locations relative to the 'baseUrl'."), + List_of_root_folders_whose_combined_content_represents_the_structure_of_the_project_at_runtime: diag(6168, ts.DiagnosticCategory.Message, "List_of_root_folders_whose_combined_content_represents_the_structure_of_the_project_at_runtime_6168", "List of root folders whose combined content represents the structure of the project at runtime."), + Show_all_compiler_options: diag(6169, ts.DiagnosticCategory.Message, "Show_all_compiler_options_6169", "Show all compiler options."), + Deprecated_Use_outFile_instead_Concatenate_and_emit_output_to_single_file: diag(6170, ts.DiagnosticCategory.Message, "Deprecated_Use_outFile_instead_Concatenate_and_emit_output_to_single_file_6170", "[Deprecated] Use '--outFile' instead. Concatenate and emit output to single file"), + Command_line_Options: diag(6171, ts.DiagnosticCategory.Message, "Command_line_Options_6171", "Command-line Options"), + Provide_full_support_for_iterables_in_for_of_spread_and_destructuring_when_targeting_ES5_or_ES3: diag(6179, ts.DiagnosticCategory.Message, "Provide_full_support_for_iterables_in_for_of_spread_and_destructuring_when_targeting_ES5_or_ES3_6179", "Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'."), + Enable_all_strict_type_checking_options: diag(6180, ts.DiagnosticCategory.Message, "Enable_all_strict_type_checking_options_6180", "Enable all strict type-checking options."), + Scoped_package_detected_looking_in_0: diag(6182, ts.DiagnosticCategory.Message, "Scoped_package_detected_looking_in_0_6182", "Scoped package detected, looking in '{0}'"), + Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2: diag(6183, ts.DiagnosticCategory.Message, "Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_6183", "Reusing resolution of module '{0}' from '{1}' of old program, it was successfully resolved to '{2}'."), + Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3: diag(6184, ts.DiagnosticCategory.Message, "Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package__6184", "Reusing resolution of module '{0}' from '{1}' of old program, it was successfully resolved to '{2}' with Package ID '{3}'."), + Enable_strict_checking_of_function_types: diag(6186, ts.DiagnosticCategory.Message, "Enable_strict_checking_of_function_types_6186", "Enable strict checking of function types."), + Enable_strict_checking_of_property_initialization_in_classes: diag(6187, ts.DiagnosticCategory.Message, "Enable_strict_checking_of_property_initialization_in_classes_6187", "Enable strict checking of property initialization in classes."), + Numeric_separators_are_not_allowed_here: diag(6188, ts.DiagnosticCategory.Error, "Numeric_separators_are_not_allowed_here_6188", "Numeric separators are not allowed here."), + Multiple_consecutive_numeric_separators_are_not_permitted: diag(6189, ts.DiagnosticCategory.Error, "Multiple_consecutive_numeric_separators_are_not_permitted_6189", "Multiple consecutive numeric separators are not permitted."), + Whether_to_keep_outdated_console_output_in_watch_mode_instead_of_clearing_the_screen: diag(6191, ts.DiagnosticCategory.Message, "Whether_to_keep_outdated_console_output_in_watch_mode_instead_of_clearing_the_screen_6191", "Whether to keep outdated console output in watch mode instead of clearing the screen."), + All_imports_in_import_declaration_are_unused: diag(6192, ts.DiagnosticCategory.Error, "All_imports_in_import_declaration_are_unused_6192", "All imports in import declaration are unused.", /*reportsUnnecessary*/ true), + Found_1_error_Watching_for_file_changes: diag(6193, ts.DiagnosticCategory.Message, "Found_1_error_Watching_for_file_changes_6193", "Found 1 error. Watching for file changes."), + Found_0_errors_Watching_for_file_changes: diag(6194, ts.DiagnosticCategory.Message, "Found_0_errors_Watching_for_file_changes_6194", "Found {0} errors. Watching for file changes."), + Resolve_keyof_to_string_valued_property_names_only_no_numbers_or_symbols: diag(6195, ts.DiagnosticCategory.Message, "Resolve_keyof_to_string_valued_property_names_only_no_numbers_or_symbols_6195", "Resolve 'keyof' to string valued property names only (no numbers or symbols)."), + _0_is_declared_but_never_used: diag(6196, ts.DiagnosticCategory.Error, "_0_is_declared_but_never_used_6196", "'{0}' is declared but never used.", /*reportsUnnecessary*/ true), + Include_modules_imported_with_json_extension: diag(6197, ts.DiagnosticCategory.Message, "Include_modules_imported_with_json_extension_6197", "Include modules imported with '.json' extension"), + All_destructured_elements_are_unused: diag(6198, ts.DiagnosticCategory.Error, "All_destructured_elements_are_unused_6198", "All destructured elements are unused.", /*reportsUnnecessary*/ true), + All_variables_are_unused: diag(6199, ts.DiagnosticCategory.Error, "All_variables_are_unused_6199", "All variables are unused.", /*reportsUnnecessary*/ true), + Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0: diag(6200, ts.DiagnosticCategory.Error, "Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0_6200", "Definitions of the following identifiers conflict with those in another file: {0}"), + Conflicts_are_in_this_file: diag(6201, ts.DiagnosticCategory.Message, "Conflicts_are_in_this_file_6201", "Conflicts are in this file."), + Project_references_may_not_form_a_circular_graph_Cycle_detected_Colon_0: diag(6202, ts.DiagnosticCategory.Error, "Project_references_may_not_form_a_circular_graph_Cycle_detected_Colon_0_6202", "Project references may not form a circular graph. Cycle detected: {0}"), + _0_was_also_declared_here: diag(6203, ts.DiagnosticCategory.Message, "_0_was_also_declared_here_6203", "'{0}' was also declared here."), + and_here: diag(6204, ts.DiagnosticCategory.Message, "and_here_6204", "and here."), + All_type_parameters_are_unused: diag(6205, ts.DiagnosticCategory.Error, "All_type_parameters_are_unused_6205", "All type parameters are unused."), + package_json_has_a_typesVersions_field_with_version_specific_path_mappings: diag(6206, ts.DiagnosticCategory.Message, "package_json_has_a_typesVersions_field_with_version_specific_path_mappings_6206", "'package.json' has a 'typesVersions' field with version-specific path mappings."), + package_json_does_not_have_a_typesVersions_entry_that_matches_version_0: diag(6207, ts.DiagnosticCategory.Message, "package_json_does_not_have_a_typesVersions_entry_that_matches_version_0_6207", "'package.json' does not have a 'typesVersions' entry that matches version '{0}'."), + package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2: diag(6208, ts.DiagnosticCategory.Message, "package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_ma_6208", "'package.json' has a 'typesVersions' entry '{0}' that matches compiler version '{1}', looking for a pattern to match module name '{2}'."), + package_json_has_a_typesVersions_entry_0_that_is_not_a_valid_semver_range: diag(6209, ts.DiagnosticCategory.Message, "package_json_has_a_typesVersions_entry_0_that_is_not_a_valid_semver_range_6209", "'package.json' has a 'typesVersions' entry '{0}' that is not a valid semver range."), + An_argument_for_0_was_not_provided: diag(6210, ts.DiagnosticCategory.Message, "An_argument_for_0_was_not_provided_6210", "An argument for '{0}' was not provided."), + An_argument_matching_this_binding_pattern_was_not_provided: diag(6211, ts.DiagnosticCategory.Message, "An_argument_matching_this_binding_pattern_was_not_provided_6211", "An argument matching this binding pattern was not provided."), + Did_you_mean_to_call_this_expression: diag(6212, ts.DiagnosticCategory.Message, "Did_you_mean_to_call_this_expression_6212", "Did you mean to call this expression?"), + Did_you_mean_to_use_new_with_this_expression: diag(6213, ts.DiagnosticCategory.Message, "Did_you_mean_to_use_new_with_this_expression_6213", "Did you mean to use 'new' with this expression?"), + Enable_strict_bind_call_and_apply_methods_on_functions: diag(6214, ts.DiagnosticCategory.Message, "Enable_strict_bind_call_and_apply_methods_on_functions_6214", "Enable strict 'bind', 'call', and 'apply' methods on functions."), + Using_compiler_options_of_project_reference_redirect_0: diag(6215, ts.DiagnosticCategory.Message, "Using_compiler_options_of_project_reference_redirect_0_6215", "Using compiler options of project reference redirect '{0}'."), + Found_1_error: diag(6216, ts.DiagnosticCategory.Message, "Found_1_error_6216", "Found 1 error."), + Found_0_errors: diag(6217, ts.DiagnosticCategory.Message, "Found_0_errors_6217", "Found {0} errors."), + Module_name_0_was_successfully_resolved_to_1_with_Package_ID_2: diag(6218, ts.DiagnosticCategory.Message, "Module_name_0_was_successfully_resolved_to_1_with_Package_ID_2_6218", "======== Module name '{0}' was successfully resolved to '{1}' with Package ID '{2}'. ========"), + Type_reference_directive_0_was_successfully_resolved_to_1_with_Package_ID_2_primary_Colon_3: diag(6219, ts.DiagnosticCategory.Message, "Type_reference_directive_0_was_successfully_resolved_to_1_with_Package_ID_2_primary_Colon_3_6219", "======== Type reference directive '{0}' was successfully resolved to '{1}' with Package ID '{2}', primary: {3}. ========"), + package_json_had_a_falsy_0_field: diag(6220, ts.DiagnosticCategory.Message, "package_json_had_a_falsy_0_field_6220", "'package.json' had a falsy '{0}' field."), + Disable_use_of_source_files_instead_of_declaration_files_from_referenced_projects: diag(6221, ts.DiagnosticCategory.Message, "Disable_use_of_source_files_instead_of_declaration_files_from_referenced_projects_6221", "Disable use of source files instead of declaration files from referenced projects."), + Emit_class_fields_with_Define_instead_of_Set: diag(6222, ts.DiagnosticCategory.Message, "Emit_class_fields_with_Define_instead_of_Set_6222", "Emit class fields with Define instead of Set."), + Generates_a_CPU_profile: diag(6223, ts.DiagnosticCategory.Message, "Generates_a_CPU_profile_6223", "Generates a CPU profile."), + Disable_solution_searching_for_this_project: diag(6224, ts.DiagnosticCategory.Message, "Disable_solution_searching_for_this_project_6224", "Disable solution searching for this project."), + Specify_strategy_for_watching_file_Colon_FixedPollingInterval_default_PriorityPollingInterval_DynamicPriorityPolling_FixedChunkSizePolling_UseFsEvents_UseFsEventsOnParentDirectory: diag(6225, ts.DiagnosticCategory.Message, "Specify_strategy_for_watching_file_Colon_FixedPollingInterval_default_PriorityPollingInterval_Dynami_6225", "Specify strategy for watching file: 'FixedPollingInterval' (default), 'PriorityPollingInterval', 'DynamicPriorityPolling', 'FixedChunkSizePolling', 'UseFsEvents', 'UseFsEventsOnParentDirectory'."), + Specify_strategy_for_watching_directory_on_platforms_that_don_t_support_recursive_watching_natively_Colon_UseFsEvents_default_FixedPollingInterval_DynamicPriorityPolling_FixedChunkSizePolling: diag(6226, ts.DiagnosticCategory.Message, "Specify_strategy_for_watching_directory_on_platforms_that_don_t_support_recursive_watching_natively__6226", "Specify strategy for watching directory on platforms that don't support recursive watching natively: 'UseFsEvents' (default), 'FixedPollingInterval', 'DynamicPriorityPolling', 'FixedChunkSizePolling'."), + Specify_strategy_for_creating_a_polling_watch_when_it_fails_to_create_using_file_system_events_Colon_FixedInterval_default_PriorityInterval_DynamicPriority_FixedChunkSize: diag(6227, ts.DiagnosticCategory.Message, "Specify_strategy_for_creating_a_polling_watch_when_it_fails_to_create_using_file_system_events_Colon_6227", "Specify strategy for creating a polling watch when it fails to create using file system events: 'FixedInterval' (default), 'PriorityInterval', 'DynamicPriority', 'FixedChunkSize'."), + Tag_0_expects_at_least_1_arguments_but_the_JSX_factory_2_provides_at_most_3: diag(6229, ts.DiagnosticCategory.Error, "Tag_0_expects_at_least_1_arguments_but_the_JSX_factory_2_provides_at_most_3_6229", "Tag '{0}' expects at least '{1}' arguments, but the JSX factory '{2}' provides at most '{3}'."), + Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_false_or_null_on_command_line: diag(6230, ts.DiagnosticCategory.Error, "Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_false_or_null_on_command_line_6230", "Option '{0}' can only be specified in 'tsconfig.json' file or set to 'false' or 'null' on command line."), + Could_not_resolve_the_path_0_with_the_extensions_Colon_1: diag(6231, ts.DiagnosticCategory.Error, "Could_not_resolve_the_path_0_with_the_extensions_Colon_1_6231", "Could not resolve the path '{0}' with the extensions: {1}."), + Declaration_augments_declaration_in_another_file_This_cannot_be_serialized: diag(6232, ts.DiagnosticCategory.Error, "Declaration_augments_declaration_in_another_file_This_cannot_be_serialized_6232", "Declaration augments declaration in another file. This cannot be serialized."), + This_is_the_declaration_being_augmented_Consider_moving_the_augmenting_declaration_into_the_same_file: diag(6233, ts.DiagnosticCategory.Error, "This_is_the_declaration_being_augmented_Consider_moving_the_augmenting_declaration_into_the_same_fil_6233", "This is the declaration being augmented. Consider moving the augmenting declaration into the same file."), + This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without: diag(6234, ts.DiagnosticCategory.Error, "This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without_6234", "This expression is not callable because it is a 'get' accessor. Did you mean to use it without '()'?"), + Disable_loading_referenced_projects: diag(6235, ts.DiagnosticCategory.Message, "Disable_loading_referenced_projects_6235", "Disable loading referenced projects."), + Arguments_for_the_rest_parameter_0_were_not_provided: diag(6236, ts.DiagnosticCategory.Error, "Arguments_for_the_rest_parameter_0_were_not_provided_6236", "Arguments for the rest parameter '{0}' were not provided."), + Generates_an_event_trace_and_a_list_of_types: diag(6237, ts.DiagnosticCategory.Message, "Generates_an_event_trace_and_a_list_of_types_6237", "Generates an event trace and a list of types."), + Specify_the_module_specifier_to_be_used_to_import_the_jsx_and_jsxs_factory_functions_from_eg_react: diag(6238, ts.DiagnosticCategory.Error, "Specify_the_module_specifier_to_be_used_to_import_the_jsx_and_jsxs_factory_functions_from_eg_react_6238", "Specify the module specifier to be used to import the 'jsx' and 'jsxs' factory functions from. eg, react"), + File_0_exists_according_to_earlier_cached_lookups: diag(6239, ts.DiagnosticCategory.Message, "File_0_exists_according_to_earlier_cached_lookups_6239", "File '{0}' exists according to earlier cached lookups."), + File_0_does_not_exist_according_to_earlier_cached_lookups: diag(6240, ts.DiagnosticCategory.Message, "File_0_does_not_exist_according_to_earlier_cached_lookups_6240", "File '{0}' does not exist according to earlier cached lookups."), + Resolution_for_type_reference_directive_0_was_found_in_cache_from_location_1: diag(6241, ts.DiagnosticCategory.Message, "Resolution_for_type_reference_directive_0_was_found_in_cache_from_location_1_6241", "Resolution for type reference directive '{0}' was found in cache from location '{1}'."), + Resolving_type_reference_directive_0_containing_file_1: diag(6242, ts.DiagnosticCategory.Message, "Resolving_type_reference_directive_0_containing_file_1_6242", "======== Resolving type reference directive '{0}', containing file '{1}'. ========"), + Interpret_optional_property_types_as_written_rather_than_adding_undefined: diag(6243, ts.DiagnosticCategory.Message, "Interpret_optional_property_types_as_written_rather_than_adding_undefined_6243", "Interpret optional property types as written, rather than adding 'undefined'."), + Modules: diag(6244, ts.DiagnosticCategory.Message, "Modules_6244", "Modules"), + File_Management: diag(6245, ts.DiagnosticCategory.Message, "File_Management_6245", "File Management"), + Emit: diag(6246, ts.DiagnosticCategory.Message, "Emit_6246", "Emit"), + JavaScript_Support: diag(6247, ts.DiagnosticCategory.Message, "JavaScript_Support_6247", "JavaScript Support"), + Type_Checking: diag(6248, ts.DiagnosticCategory.Message, "Type_Checking_6248", "Type Checking"), + Editor_Support: diag(6249, ts.DiagnosticCategory.Message, "Editor_Support_6249", "Editor Support"), + Watch_and_Build_Modes: diag(6250, ts.DiagnosticCategory.Message, "Watch_and_Build_Modes_6250", "Watch and Build Modes"), + Compiler_Diagnostics: diag(6251, ts.DiagnosticCategory.Message, "Compiler_Diagnostics_6251", "Compiler Diagnostics"), + Interop_Constraints: diag(6252, ts.DiagnosticCategory.Message, "Interop_Constraints_6252", "Interop Constraints"), + Backwards_Compatibility: diag(6253, ts.DiagnosticCategory.Message, "Backwards_Compatibility_6253", "Backwards Compatibility"), + Language_and_Environment: diag(6254, ts.DiagnosticCategory.Message, "Language_and_Environment_6254", "Language and Environment"), + Projects: diag(6255, ts.DiagnosticCategory.Message, "Projects_6255", "Projects"), + Output_Formatting: diag(6256, ts.DiagnosticCategory.Message, "Output_Formatting_6256", "Output Formatting"), + Completeness: diag(6257, ts.DiagnosticCategory.Message, "Completeness_6257", "Completeness"), + _0_should_be_set_inside_the_compilerOptions_object_of_the_config_json_file: diag(6258, ts.DiagnosticCategory.Error, "_0_should_be_set_inside_the_compilerOptions_object_of_the_config_json_file_6258", "'{0}' should be set inside the 'compilerOptions' object of the config json file"), + Found_1_error_in_1: diag(6259, ts.DiagnosticCategory.Message, "Found_1_error_in_1_6259", "Found 1 error in {1}"), + Found_0_errors_in_the_same_file_starting_at_Colon_1: diag(6260, ts.DiagnosticCategory.Message, "Found_0_errors_in_the_same_file_starting_at_Colon_1_6260", "Found {0} errors in the same file, starting at: {1}"), + Found_0_errors_in_1_files: diag(6261, ts.DiagnosticCategory.Message, "Found_0_errors_in_1_files_6261", "Found {0} errors in {1} files."), + Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve: diag(6270, ts.DiagnosticCategory.Message, "Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve_6270", "Directory '{0}' has no containing package.json scope. Imports will not resolve."), + Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1: diag(6271, ts.DiagnosticCategory.Message, "Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1_6271", "Import specifier '{0}' does not exist in package.json scope at path '{1}'."), + Invalid_import_specifier_0_has_no_possible_resolutions: diag(6272, ts.DiagnosticCategory.Message, "Invalid_import_specifier_0_has_no_possible_resolutions_6272", "Invalid import specifier '{0}' has no possible resolutions."), + package_json_scope_0_has_no_imports_defined: diag(6273, ts.DiagnosticCategory.Message, "package_json_scope_0_has_no_imports_defined_6273", "package.json scope '{0}' has no imports defined."), + package_json_scope_0_explicitly_maps_specifier_1_to_null: diag(6274, ts.DiagnosticCategory.Message, "package_json_scope_0_explicitly_maps_specifier_1_to_null_6274", "package.json scope '{0}' explicitly maps specifier '{1}' to null."), + package_json_scope_0_has_invalid_type_for_target_of_specifier_1: diag(6275, ts.DiagnosticCategory.Message, "package_json_scope_0_has_invalid_type_for_target_of_specifier_1_6275", "package.json scope '{0}' has invalid type for target of specifier '{1}'"), + Export_specifier_0_does_not_exist_in_package_json_scope_at_path_1: diag(6276, ts.DiagnosticCategory.Message, "Export_specifier_0_does_not_exist_in_package_json_scope_at_path_1_6276", "Export specifier '{0}' does not exist in package.json scope at path '{1}'."), + Enable_project_compilation: diag(6302, ts.DiagnosticCategory.Message, "Enable_project_compilation_6302", "Enable project compilation"), + Composite_projects_may_not_disable_declaration_emit: diag(6304, ts.DiagnosticCategory.Error, "Composite_projects_may_not_disable_declaration_emit_6304", "Composite projects may not disable declaration emit."), + Output_file_0_has_not_been_built_from_source_file_1: diag(6305, ts.DiagnosticCategory.Error, "Output_file_0_has_not_been_built_from_source_file_1_6305", "Output file '{0}' has not been built from source file '{1}'."), + Referenced_project_0_must_have_setting_composite_Colon_true: diag(6306, ts.DiagnosticCategory.Error, "Referenced_project_0_must_have_setting_composite_Colon_true_6306", "Referenced project '{0}' must have setting \"composite\": true."), + File_0_is_not_listed_within_the_file_list_of_project_1_Projects_must_list_all_files_or_use_an_include_pattern: diag(6307, ts.DiagnosticCategory.Error, "File_0_is_not_listed_within_the_file_list_of_project_1_Projects_must_list_all_files_or_use_an_includ_6307", "File '{0}' is not listed within the file list of project '{1}'. Projects must list all files or use an 'include' pattern."), + Cannot_prepend_project_0_because_it_does_not_have_outFile_set: diag(6308, ts.DiagnosticCategory.Error, "Cannot_prepend_project_0_because_it_does_not_have_outFile_set_6308", "Cannot prepend project '{0}' because it does not have 'outFile' set"), + Output_file_0_from_project_1_does_not_exist: diag(6309, ts.DiagnosticCategory.Error, "Output_file_0_from_project_1_does_not_exist_6309", "Output file '{0}' from project '{1}' does not exist"), + Referenced_project_0_may_not_disable_emit: diag(6310, ts.DiagnosticCategory.Error, "Referenced_project_0_may_not_disable_emit_6310", "Referenced project '{0}' may not disable emit."), + Project_0_is_out_of_date_because_output_1_is_older_than_input_2: diag(6350, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_output_1_is_older_than_input_2_6350", "Project '{0}' is out of date because output '{1}' is older than input '{2}'"), + Project_0_is_up_to_date_because_newest_input_1_is_older_than_output_2: diag(6351, ts.DiagnosticCategory.Message, "Project_0_is_up_to_date_because_newest_input_1_is_older_than_output_2_6351", "Project '{0}' is up to date because newest input '{1}' is older than output '{2}'"), + Project_0_is_out_of_date_because_output_file_1_does_not_exist: diag(6352, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_output_file_1_does_not_exist_6352", "Project '{0}' is out of date because output file '{1}' does not exist"), + Project_0_is_out_of_date_because_its_dependency_1_is_out_of_date: diag(6353, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_its_dependency_1_is_out_of_date_6353", "Project '{0}' is out of date because its dependency '{1}' is out of date"), + Project_0_is_up_to_date_with_d_ts_files_from_its_dependencies: diag(6354, ts.DiagnosticCategory.Message, "Project_0_is_up_to_date_with_d_ts_files_from_its_dependencies_6354", "Project '{0}' is up to date with .d.ts files from its dependencies"), + Projects_in_this_build_Colon_0: diag(6355, ts.DiagnosticCategory.Message, "Projects_in_this_build_Colon_0_6355", "Projects in this build: {0}"), + A_non_dry_build_would_delete_the_following_files_Colon_0: diag(6356, ts.DiagnosticCategory.Message, "A_non_dry_build_would_delete_the_following_files_Colon_0_6356", "A non-dry build would delete the following files: {0}"), + A_non_dry_build_would_build_project_0: diag(6357, ts.DiagnosticCategory.Message, "A_non_dry_build_would_build_project_0_6357", "A non-dry build would build project '{0}'"), + Building_project_0: diag(6358, ts.DiagnosticCategory.Message, "Building_project_0_6358", "Building project '{0}'..."), + Updating_output_timestamps_of_project_0: diag(6359, ts.DiagnosticCategory.Message, "Updating_output_timestamps_of_project_0_6359", "Updating output timestamps of project '{0}'..."), + Project_0_is_up_to_date: diag(6361, ts.DiagnosticCategory.Message, "Project_0_is_up_to_date_6361", "Project '{0}' is up to date"), + Skipping_build_of_project_0_because_its_dependency_1_has_errors: diag(6362, ts.DiagnosticCategory.Message, "Skipping_build_of_project_0_because_its_dependency_1_has_errors_6362", "Skipping build of project '{0}' because its dependency '{1}' has errors"), + Project_0_can_t_be_built_because_its_dependency_1_has_errors: diag(6363, ts.DiagnosticCategory.Message, "Project_0_can_t_be_built_because_its_dependency_1_has_errors_6363", "Project '{0}' can't be built because its dependency '{1}' has errors"), + Build_one_or_more_projects_and_their_dependencies_if_out_of_date: diag(6364, ts.DiagnosticCategory.Message, "Build_one_or_more_projects_and_their_dependencies_if_out_of_date_6364", "Build one or more projects and their dependencies, if out of date"), + Delete_the_outputs_of_all_projects: diag(6365, ts.DiagnosticCategory.Message, "Delete_the_outputs_of_all_projects_6365", "Delete the outputs of all projects."), + Show_what_would_be_built_or_deleted_if_specified_with_clean: diag(6367, ts.DiagnosticCategory.Message, "Show_what_would_be_built_or_deleted_if_specified_with_clean_6367", "Show what would be built (or deleted, if specified with '--clean')"), + Option_build_must_be_the_first_command_line_argument: diag(6369, ts.DiagnosticCategory.Error, "Option_build_must_be_the_first_command_line_argument_6369", "Option '--build' must be the first command line argument."), + Options_0_and_1_cannot_be_combined: diag(6370, ts.DiagnosticCategory.Error, "Options_0_and_1_cannot_be_combined_6370", "Options '{0}' and '{1}' cannot be combined."), + Updating_unchanged_output_timestamps_of_project_0: diag(6371, ts.DiagnosticCategory.Message, "Updating_unchanged_output_timestamps_of_project_0_6371", "Updating unchanged output timestamps of project '{0}'..."), + Project_0_is_out_of_date_because_output_of_its_dependency_1_has_changed: diag(6372, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_output_of_its_dependency_1_has_changed_6372", "Project '{0}' is out of date because output of its dependency '{1}' has changed"), + Updating_output_of_project_0: diag(6373, ts.DiagnosticCategory.Message, "Updating_output_of_project_0_6373", "Updating output of project '{0}'..."), + A_non_dry_build_would_update_timestamps_for_output_of_project_0: diag(6374, ts.DiagnosticCategory.Message, "A_non_dry_build_would_update_timestamps_for_output_of_project_0_6374", "A non-dry build would update timestamps for output of project '{0}'"), + A_non_dry_build_would_update_output_of_project_0: diag(6375, ts.DiagnosticCategory.Message, "A_non_dry_build_would_update_output_of_project_0_6375", "A non-dry build would update output of project '{0}'"), + Cannot_update_output_of_project_0_because_there_was_error_reading_file_1: diag(6376, ts.DiagnosticCategory.Message, "Cannot_update_output_of_project_0_because_there_was_error_reading_file_1_6376", "Cannot update output of project '{0}' because there was error reading file '{1}'"), + Cannot_write_file_0_because_it_will_overwrite_tsbuildinfo_file_generated_by_referenced_project_1: diag(6377, ts.DiagnosticCategory.Error, "Cannot_write_file_0_because_it_will_overwrite_tsbuildinfo_file_generated_by_referenced_project_1_6377", "Cannot write file '{0}' because it will overwrite '.tsbuildinfo' file generated by referenced project '{1}'"), + Composite_projects_may_not_disable_incremental_compilation: diag(6379, ts.DiagnosticCategory.Error, "Composite_projects_may_not_disable_incremental_compilation_6379", "Composite projects may not disable incremental compilation."), + Specify_file_to_store_incremental_compilation_information: diag(6380, ts.DiagnosticCategory.Message, "Specify_file_to_store_incremental_compilation_information_6380", "Specify file to store incremental compilation information"), + Project_0_is_out_of_date_because_output_for_it_was_generated_with_version_1_that_differs_with_current_version_2: diag(6381, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_output_for_it_was_generated_with_version_1_that_differs_with_curren_6381", "Project '{0}' is out of date because output for it was generated with version '{1}' that differs with current version '{2}'"), + Skipping_build_of_project_0_because_its_dependency_1_was_not_built: diag(6382, ts.DiagnosticCategory.Message, "Skipping_build_of_project_0_because_its_dependency_1_was_not_built_6382", "Skipping build of project '{0}' because its dependency '{1}' was not built"), + Project_0_can_t_be_built_because_its_dependency_1_was_not_built: diag(6383, ts.DiagnosticCategory.Message, "Project_0_can_t_be_built_because_its_dependency_1_was_not_built_6383", "Project '{0}' can't be built because its dependency '{1}' was not built"), + Have_recompiles_in_incremental_and_watch_assume_that_changes_within_a_file_will_only_affect_files_directly_depending_on_it: diag(6384, ts.DiagnosticCategory.Message, "Have_recompiles_in_incremental_and_watch_assume_that_changes_within_a_file_will_only_affect_files_di_6384", "Have recompiles in '--incremental' and '--watch' assume that changes within a file will only affect files directly depending on it."), + _0_is_deprecated: diag(6385, ts.DiagnosticCategory.Suggestion, "_0_is_deprecated_6385", "'{0}' is deprecated.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ undefined, /*reportsDeprecated*/ true), + Performance_timings_for_diagnostics_or_extendedDiagnostics_are_not_available_in_this_session_A_native_implementation_of_the_Web_Performance_API_could_not_be_found: diag(6386, ts.DiagnosticCategory.Message, "Performance_timings_for_diagnostics_or_extendedDiagnostics_are_not_available_in_this_session_A_nativ_6386", "Performance timings for '--diagnostics' or '--extendedDiagnostics' are not available in this session. A native implementation of the Web Performance API could not be found."), + The_signature_0_of_1_is_deprecated: diag(6387, ts.DiagnosticCategory.Suggestion, "The_signature_0_of_1_is_deprecated_6387", "The signature '{0}' of '{1}' is deprecated.", /*reportsUnnecessary*/ undefined, /*elidedInCompatabilityPyramid*/ undefined, /*reportsDeprecated*/ true), + Project_0_is_being_forcibly_rebuilt: diag(6388, ts.DiagnosticCategory.Message, "Project_0_is_being_forcibly_rebuilt_6388", "Project '{0}' is being forcibly rebuilt"), + Reusing_resolution_of_module_0_from_1_of_old_program_it_was_not_resolved: diag(6389, ts.DiagnosticCategory.Message, "Reusing_resolution_of_module_0_from_1_of_old_program_it_was_not_resolved_6389", "Reusing resolution of module '{0}' from '{1}' of old program, it was not resolved."), + Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2: diag(6390, ts.DiagnosticCategory.Message, "Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved__6390", "Reusing resolution of type reference directive '{0}' from '{1}' of old program, it was successfully resolved to '{2}'."), + Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3: diag(6391, ts.DiagnosticCategory.Message, "Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved__6391", "Reusing resolution of type reference directive '{0}' from '{1}' of old program, it was successfully resolved to '{2}' with Package ID '{3}'."), + Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_not_resolved: diag(6392, ts.DiagnosticCategory.Message, "Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_not_resolved_6392", "Reusing resolution of type reference directive '{0}' from '{1}' of old program, it was not resolved."), + Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3: diag(6393, ts.DiagnosticCategory.Message, "Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_6393", "Reusing resolution of module '{0}' from '{1}' found in cache from location '{2}', it was successfully resolved to '{3}'."), + Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3_with_Package_ID_4: diag(6394, ts.DiagnosticCategory.Message, "Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_6394", "Reusing resolution of module '{0}' from '{1}' found in cache from location '{2}', it was successfully resolved to '{3}' with Package ID '{4}'."), + Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_not_resolved: diag(6395, ts.DiagnosticCategory.Message, "Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_not_resolved_6395", "Reusing resolution of module '{0}' from '{1}' found in cache from location '{2}', it was not resolved."), + Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3: diag(6396, ts.DiagnosticCategory.Message, "Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_succes_6396", "Reusing resolution of type reference directive '{0}' from '{1}' found in cache from location '{2}', it was successfully resolved to '{3}'."), + Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3_with_Package_ID_4: diag(6397, ts.DiagnosticCategory.Message, "Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_succes_6397", "Reusing resolution of type reference directive '{0}' from '{1}' found in cache from location '{2}', it was successfully resolved to '{3}' with Package ID '{4}'."), + Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_not_resolved: diag(6398, ts.DiagnosticCategory.Message, "Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_not_re_6398", "Reusing resolution of type reference directive '{0}' from '{1}' found in cache from location '{2}', it was not resolved."), + Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_some_of_the_changes_were_not_emitted: diag(6399, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_some_of_the_changes_were_not_emitte_6399", "Project '{0}' is out of date because buildinfo file '{1}' indicates that some of the changes were not emitted"), + Project_0_is_up_to_date_but_needs_to_update_timestamps_of_output_files_that_are_older_than_input_files: diag(6400, ts.DiagnosticCategory.Message, "Project_0_is_up_to_date_but_needs_to_update_timestamps_of_output_files_that_are_older_than_input_fil_6400", "Project '{0}' is up to date but needs to update timestamps of output files that are older than input files"), + Project_0_is_out_of_date_because_there_was_error_reading_file_1: diag(6401, ts.DiagnosticCategory.Message, "Project_0_is_out_of_date_because_there_was_error_reading_file_1_6401", "Project '{0}' is out of date because there was error reading file '{1}'"), + Resolving_in_0_mode_with_conditions_1: diag(6402, ts.DiagnosticCategory.Message, "Resolving_in_0_mode_with_conditions_1_6402", "Resolving in {0} mode with conditions {1}."), + Matched_0_condition_1: diag(6403, ts.DiagnosticCategory.Message, "Matched_0_condition_1_6403", "Matched '{0}' condition '{1}'."), + Using_0_subpath_1_with_target_2: diag(6404, ts.DiagnosticCategory.Message, "Using_0_subpath_1_with_target_2_6404", "Using '{0}' subpath '{1}' with target '{2}'."), + Saw_non_matching_condition_0: diag(6405, ts.DiagnosticCategory.Message, "Saw_non_matching_condition_0_6405", "Saw non-matching condition '{0}'."), + The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1: diag(6500, ts.DiagnosticCategory.Message, "The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1_6500", "The expected type comes from property '{0}' which is declared here on type '{1}'"), + The_expected_type_comes_from_this_index_signature: diag(6501, ts.DiagnosticCategory.Message, "The_expected_type_comes_from_this_index_signature_6501", "The expected type comes from this index signature."), + The_expected_type_comes_from_the_return_type_of_this_signature: diag(6502, ts.DiagnosticCategory.Message, "The_expected_type_comes_from_the_return_type_of_this_signature_6502", "The expected type comes from the return type of this signature."), + Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing: diag(6503, ts.DiagnosticCategory.Message, "Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing_6503", "Print names of files that are part of the compilation and then stop processing."), + File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option: diag(6504, ts.DiagnosticCategory.Error, "File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option_6504", "File '{0}' is a JavaScript file. Did you mean to enable the 'allowJs' option?"), + Print_names_of_files_and_the_reason_they_are_part_of_the_compilation: diag(6505, ts.DiagnosticCategory.Message, "Print_names_of_files_and_the_reason_they_are_part_of_the_compilation_6505", "Print names of files and the reason they are part of the compilation."), + Consider_adding_a_declare_modifier_to_this_class: diag(6506, ts.DiagnosticCategory.Message, "Consider_adding_a_declare_modifier_to_this_class_6506", "Consider adding a 'declare' modifier to this class."), + Allow_JavaScript_files_to_be_a_part_of_your_program_Use_the_checkJS_option_to_get_errors_from_these_files: diag(6600, ts.DiagnosticCategory.Message, "Allow_JavaScript_files_to_be_a_part_of_your_program_Use_the_checkJS_option_to_get_errors_from_these__6600", "Allow JavaScript files to be a part of your program. Use the 'checkJS' option to get errors from these files."), + Allow_import_x_from_y_when_a_module_doesn_t_have_a_default_export: diag(6601, ts.DiagnosticCategory.Message, "Allow_import_x_from_y_when_a_module_doesn_t_have_a_default_export_6601", "Allow 'import x from y' when a module doesn't have a default export."), + Allow_accessing_UMD_globals_from_modules: diag(6602, ts.DiagnosticCategory.Message, "Allow_accessing_UMD_globals_from_modules_6602", "Allow accessing UMD globals from modules."), + Disable_error_reporting_for_unreachable_code: diag(6603, ts.DiagnosticCategory.Message, "Disable_error_reporting_for_unreachable_code_6603", "Disable error reporting for unreachable code."), + Disable_error_reporting_for_unused_labels: diag(6604, ts.DiagnosticCategory.Message, "Disable_error_reporting_for_unused_labels_6604", "Disable error reporting for unused labels."), + Ensure_use_strict_is_always_emitted: diag(6605, ts.DiagnosticCategory.Message, "Ensure_use_strict_is_always_emitted_6605", "Ensure 'use strict' is always emitted."), + Have_recompiles_in_projects_that_use_incremental_and_watch_mode_assume_that_changes_within_a_file_will_only_affect_files_directly_depending_on_it: diag(6606, ts.DiagnosticCategory.Message, "Have_recompiles_in_projects_that_use_incremental_and_watch_mode_assume_that_changes_within_a_file_wi_6606", "Have recompiles in projects that use 'incremental' and 'watch' mode assume that changes within a file will only affect files directly depending on it."), + Specify_the_base_directory_to_resolve_non_relative_module_names: diag(6607, ts.DiagnosticCategory.Message, "Specify_the_base_directory_to_resolve_non_relative_module_names_6607", "Specify the base directory to resolve non-relative module names."), + No_longer_supported_In_early_versions_manually_set_the_text_encoding_for_reading_files: diag(6608, ts.DiagnosticCategory.Message, "No_longer_supported_In_early_versions_manually_set_the_text_encoding_for_reading_files_6608", "No longer supported. In early versions, manually set the text encoding for reading files."), + Enable_error_reporting_in_type_checked_JavaScript_files: diag(6609, ts.DiagnosticCategory.Message, "Enable_error_reporting_in_type_checked_JavaScript_files_6609", "Enable error reporting in type-checked JavaScript files."), + Enable_constraints_that_allow_a_TypeScript_project_to_be_used_with_project_references: diag(6611, ts.DiagnosticCategory.Message, "Enable_constraints_that_allow_a_TypeScript_project_to_be_used_with_project_references_6611", "Enable constraints that allow a TypeScript project to be used with project references."), + Generate_d_ts_files_from_TypeScript_and_JavaScript_files_in_your_project: diag(6612, ts.DiagnosticCategory.Message, "Generate_d_ts_files_from_TypeScript_and_JavaScript_files_in_your_project_6612", "Generate .d.ts files from TypeScript and JavaScript files in your project."), + Specify_the_output_directory_for_generated_declaration_files: diag(6613, ts.DiagnosticCategory.Message, "Specify_the_output_directory_for_generated_declaration_files_6613", "Specify the output directory for generated declaration files."), + Create_sourcemaps_for_d_ts_files: diag(6614, ts.DiagnosticCategory.Message, "Create_sourcemaps_for_d_ts_files_6614", "Create sourcemaps for d.ts files."), + Output_compiler_performance_information_after_building: diag(6615, ts.DiagnosticCategory.Message, "Output_compiler_performance_information_after_building_6615", "Output compiler performance information after building."), + Disables_inference_for_type_acquisition_by_looking_at_filenames_in_a_project: diag(6616, ts.DiagnosticCategory.Message, "Disables_inference_for_type_acquisition_by_looking_at_filenames_in_a_project_6616", "Disables inference for type acquisition by looking at filenames in a project."), + Reduce_the_number_of_projects_loaded_automatically_by_TypeScript: diag(6617, ts.DiagnosticCategory.Message, "Reduce_the_number_of_projects_loaded_automatically_by_TypeScript_6617", "Reduce the number of projects loaded automatically by TypeScript."), + Remove_the_20mb_cap_on_total_source_code_size_for_JavaScript_files_in_the_TypeScript_language_server: diag(6618, ts.DiagnosticCategory.Message, "Remove_the_20mb_cap_on_total_source_code_size_for_JavaScript_files_in_the_TypeScript_language_server_6618", "Remove the 20mb cap on total source code size for JavaScript files in the TypeScript language server."), + Opt_a_project_out_of_multi_project_reference_checking_when_editing: diag(6619, ts.DiagnosticCategory.Message, "Opt_a_project_out_of_multi_project_reference_checking_when_editing_6619", "Opt a project out of multi-project reference checking when editing."), + Disable_preferring_source_files_instead_of_declaration_files_when_referencing_composite_projects: diag(6620, ts.DiagnosticCategory.Message, "Disable_preferring_source_files_instead_of_declaration_files_when_referencing_composite_projects_6620", "Disable preferring source files instead of declaration files when referencing composite projects."), + Emit_more_compliant_but_verbose_and_less_performant_JavaScript_for_iteration: diag(6621, ts.DiagnosticCategory.Message, "Emit_more_compliant_but_verbose_and_less_performant_JavaScript_for_iteration_6621", "Emit more compliant, but verbose and less performant JavaScript for iteration."), + Emit_a_UTF_8_Byte_Order_Mark_BOM_in_the_beginning_of_output_files: diag(6622, ts.DiagnosticCategory.Message, "Emit_a_UTF_8_Byte_Order_Mark_BOM_in_the_beginning_of_output_files_6622", "Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files."), + Only_output_d_ts_files_and_not_JavaScript_files: diag(6623, ts.DiagnosticCategory.Message, "Only_output_d_ts_files_and_not_JavaScript_files_6623", "Only output d.ts files and not JavaScript files."), + Emit_design_type_metadata_for_decorated_declarations_in_source_files: diag(6624, ts.DiagnosticCategory.Message, "Emit_design_type_metadata_for_decorated_declarations_in_source_files_6624", "Emit design-type metadata for decorated declarations in source files."), + Disable_the_type_acquisition_for_JavaScript_projects: diag(6625, ts.DiagnosticCategory.Message, "Disable_the_type_acquisition_for_JavaScript_projects_6625", "Disable the type acquisition for JavaScript projects"), + Emit_additional_JavaScript_to_ease_support_for_importing_CommonJS_modules_This_enables_allowSyntheticDefaultImports_for_type_compatibility: diag(6626, ts.DiagnosticCategory.Message, "Emit_additional_JavaScript_to_ease_support_for_importing_CommonJS_modules_This_enables_allowSyntheti_6626", "Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility."), + Filters_results_from_the_include_option: diag(6627, ts.DiagnosticCategory.Message, "Filters_results_from_the_include_option_6627", "Filters results from the `include` option."), + Remove_a_list_of_directories_from_the_watch_process: diag(6628, ts.DiagnosticCategory.Message, "Remove_a_list_of_directories_from_the_watch_process_6628", "Remove a list of directories from the watch process."), + Remove_a_list_of_files_from_the_watch_mode_s_processing: diag(6629, ts.DiagnosticCategory.Message, "Remove_a_list_of_files_from_the_watch_mode_s_processing_6629", "Remove a list of files from the watch mode's processing."), + Enable_experimental_support_for_TC39_stage_2_draft_decorators: diag(6630, ts.DiagnosticCategory.Message, "Enable_experimental_support_for_TC39_stage_2_draft_decorators_6630", "Enable experimental support for TC39 stage 2 draft decorators."), + Print_files_read_during_the_compilation_including_why_it_was_included: diag(6631, ts.DiagnosticCategory.Message, "Print_files_read_during_the_compilation_including_why_it_was_included_6631", "Print files read during the compilation including why it was included."), + Output_more_detailed_compiler_performance_information_after_building: diag(6632, ts.DiagnosticCategory.Message, "Output_more_detailed_compiler_performance_information_after_building_6632", "Output more detailed compiler performance information after building."), + Specify_one_or_more_path_or_node_module_references_to_base_configuration_files_from_which_settings_are_inherited: diag(6633, ts.DiagnosticCategory.Message, "Specify_one_or_more_path_or_node_module_references_to_base_configuration_files_from_which_settings_a_6633", "Specify one or more path or node module references to base configuration files from which settings are inherited."), + Specify_what_approach_the_watcher_should_use_if_the_system_runs_out_of_native_file_watchers: diag(6634, ts.DiagnosticCategory.Message, "Specify_what_approach_the_watcher_should_use_if_the_system_runs_out_of_native_file_watchers_6634", "Specify what approach the watcher should use if the system runs out of native file watchers."), + Include_a_list_of_files_This_does_not_support_glob_patterns_as_opposed_to_include: diag(6635, ts.DiagnosticCategory.Message, "Include_a_list_of_files_This_does_not_support_glob_patterns_as_opposed_to_include_6635", "Include a list of files. This does not support glob patterns, as opposed to `include`."), + Build_all_projects_including_those_that_appear_to_be_up_to_date: diag(6636, ts.DiagnosticCategory.Message, "Build_all_projects_including_those_that_appear_to_be_up_to_date_6636", "Build all projects, including those that appear to be up to date."), + Ensure_that_casing_is_correct_in_imports: diag(6637, ts.DiagnosticCategory.Message, "Ensure_that_casing_is_correct_in_imports_6637", "Ensure that casing is correct in imports."), + Emit_a_v8_CPU_profile_of_the_compiler_run_for_debugging: diag(6638, ts.DiagnosticCategory.Message, "Emit_a_v8_CPU_profile_of_the_compiler_run_for_debugging_6638", "Emit a v8 CPU profile of the compiler run for debugging."), + Allow_importing_helper_functions_from_tslib_once_per_project_instead_of_including_them_per_file: diag(6639, ts.DiagnosticCategory.Message, "Allow_importing_helper_functions_from_tslib_once_per_project_instead_of_including_them_per_file_6639", "Allow importing helper functions from tslib once per project, instead of including them per-file."), + Specify_a_list_of_glob_patterns_that_match_files_to_be_included_in_compilation: diag(6641, ts.DiagnosticCategory.Message, "Specify_a_list_of_glob_patterns_that_match_files_to_be_included_in_compilation_6641", "Specify a list of glob patterns that match files to be included in compilation."), + Save_tsbuildinfo_files_to_allow_for_incremental_compilation_of_projects: diag(6642, ts.DiagnosticCategory.Message, "Save_tsbuildinfo_files_to_allow_for_incremental_compilation_of_projects_6642", "Save .tsbuildinfo files to allow for incremental compilation of projects."), + Include_sourcemap_files_inside_the_emitted_JavaScript: diag(6643, ts.DiagnosticCategory.Message, "Include_sourcemap_files_inside_the_emitted_JavaScript_6643", "Include sourcemap files inside the emitted JavaScript."), + Include_source_code_in_the_sourcemaps_inside_the_emitted_JavaScript: diag(6644, ts.DiagnosticCategory.Message, "Include_source_code_in_the_sourcemaps_inside_the_emitted_JavaScript_6644", "Include source code in the sourcemaps inside the emitted JavaScript."), + Ensure_that_each_file_can_be_safely_transpiled_without_relying_on_other_imports: diag(6645, ts.DiagnosticCategory.Message, "Ensure_that_each_file_can_be_safely_transpiled_without_relying_on_other_imports_6645", "Ensure that each file can be safely transpiled without relying on other imports."), + Specify_what_JSX_code_is_generated: diag(6646, ts.DiagnosticCategory.Message, "Specify_what_JSX_code_is_generated_6646", "Specify what JSX code is generated."), + Specify_the_JSX_factory_function_used_when_targeting_React_JSX_emit_e_g_React_createElement_or_h: diag(6647, ts.DiagnosticCategory.Message, "Specify_the_JSX_factory_function_used_when_targeting_React_JSX_emit_e_g_React_createElement_or_h_6647", "Specify the JSX factory function used when targeting React JSX emit, e.g. 'React.createElement' or 'h'."), + Specify_the_JSX_Fragment_reference_used_for_fragments_when_targeting_React_JSX_emit_e_g_React_Fragment_or_Fragment: diag(6648, ts.DiagnosticCategory.Message, "Specify_the_JSX_Fragment_reference_used_for_fragments_when_targeting_React_JSX_emit_e_g_React_Fragme_6648", "Specify the JSX Fragment reference used for fragments when targeting React JSX emit e.g. 'React.Fragment' or 'Fragment'."), + Specify_module_specifier_used_to_import_the_JSX_factory_functions_when_using_jsx_Colon_react_jsx_Asterisk: diag(6649, ts.DiagnosticCategory.Message, "Specify_module_specifier_used_to_import_the_JSX_factory_functions_when_using_jsx_Colon_react_jsx_Ast_6649", "Specify module specifier used to import the JSX factory functions when using 'jsx: react-jsx*'."), + Make_keyof_only_return_strings_instead_of_string_numbers_or_symbols_Legacy_option: diag(6650, ts.DiagnosticCategory.Message, "Make_keyof_only_return_strings_instead_of_string_numbers_or_symbols_Legacy_option_6650", "Make keyof only return strings instead of string, numbers or symbols. Legacy option."), + Specify_a_set_of_bundled_library_declaration_files_that_describe_the_target_runtime_environment: diag(6651, ts.DiagnosticCategory.Message, "Specify_a_set_of_bundled_library_declaration_files_that_describe_the_target_runtime_environment_6651", "Specify a set of bundled library declaration files that describe the target runtime environment."), + Print_the_names_of_emitted_files_after_a_compilation: diag(6652, ts.DiagnosticCategory.Message, "Print_the_names_of_emitted_files_after_a_compilation_6652", "Print the names of emitted files after a compilation."), + Print_all_of_the_files_read_during_the_compilation: diag(6653, ts.DiagnosticCategory.Message, "Print_all_of_the_files_read_during_the_compilation_6653", "Print all of the files read during the compilation."), + Set_the_language_of_the_messaging_from_TypeScript_This_does_not_affect_emit: diag(6654, ts.DiagnosticCategory.Message, "Set_the_language_of_the_messaging_from_TypeScript_This_does_not_affect_emit_6654", "Set the language of the messaging from TypeScript. This does not affect emit."), + Specify_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations: diag(6655, ts.DiagnosticCategory.Message, "Specify_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations_6655", "Specify the location where debugger should locate map files instead of generated locations."), + Specify_the_maximum_folder_depth_used_for_checking_JavaScript_files_from_node_modules_Only_applicable_with_allowJs: diag(6656, ts.DiagnosticCategory.Message, "Specify_the_maximum_folder_depth_used_for_checking_JavaScript_files_from_node_modules_Only_applicabl_6656", "Specify the maximum folder depth used for checking JavaScript files from 'node_modules'. Only applicable with 'allowJs'."), + Specify_what_module_code_is_generated: diag(6657, ts.DiagnosticCategory.Message, "Specify_what_module_code_is_generated_6657", "Specify what module code is generated."), + Specify_how_TypeScript_looks_up_a_file_from_a_given_module_specifier: diag(6658, ts.DiagnosticCategory.Message, "Specify_how_TypeScript_looks_up_a_file_from_a_given_module_specifier_6658", "Specify how TypeScript looks up a file from a given module specifier."), + Set_the_newline_character_for_emitting_files: diag(6659, ts.DiagnosticCategory.Message, "Set_the_newline_character_for_emitting_files_6659", "Set the newline character for emitting files."), + Disable_emitting_files_from_a_compilation: diag(6660, ts.DiagnosticCategory.Message, "Disable_emitting_files_from_a_compilation_6660", "Disable emitting files from a compilation."), + Disable_generating_custom_helper_functions_like_extends_in_compiled_output: diag(6661, ts.DiagnosticCategory.Message, "Disable_generating_custom_helper_functions_like_extends_in_compiled_output_6661", "Disable generating custom helper functions like '__extends' in compiled output."), + Disable_emitting_files_if_any_type_checking_errors_are_reported: diag(6662, ts.DiagnosticCategory.Message, "Disable_emitting_files_if_any_type_checking_errors_are_reported_6662", "Disable emitting files if any type checking errors are reported."), + Disable_truncating_types_in_error_messages: diag(6663, ts.DiagnosticCategory.Message, "Disable_truncating_types_in_error_messages_6663", "Disable truncating types in error messages."), + Enable_error_reporting_for_fallthrough_cases_in_switch_statements: diag(6664, ts.DiagnosticCategory.Message, "Enable_error_reporting_for_fallthrough_cases_in_switch_statements_6664", "Enable error reporting for fallthrough cases in switch statements."), + Enable_error_reporting_for_expressions_and_declarations_with_an_implied_any_type: diag(6665, ts.DiagnosticCategory.Message, "Enable_error_reporting_for_expressions_and_declarations_with_an_implied_any_type_6665", "Enable error reporting for expressions and declarations with an implied 'any' type."), + Ensure_overriding_members_in_derived_classes_are_marked_with_an_override_modifier: diag(6666, ts.DiagnosticCategory.Message, "Ensure_overriding_members_in_derived_classes_are_marked_with_an_override_modifier_6666", "Ensure overriding members in derived classes are marked with an override modifier."), + Enable_error_reporting_for_codepaths_that_do_not_explicitly_return_in_a_function: diag(6667, ts.DiagnosticCategory.Message, "Enable_error_reporting_for_codepaths_that_do_not_explicitly_return_in_a_function_6667", "Enable error reporting for codepaths that do not explicitly return in a function."), + Enable_error_reporting_when_this_is_given_the_type_any: diag(6668, ts.DiagnosticCategory.Message, "Enable_error_reporting_when_this_is_given_the_type_any_6668", "Enable error reporting when 'this' is given the type 'any'."), + Disable_adding_use_strict_directives_in_emitted_JavaScript_files: diag(6669, ts.DiagnosticCategory.Message, "Disable_adding_use_strict_directives_in_emitted_JavaScript_files_6669", "Disable adding 'use strict' directives in emitted JavaScript files."), + Disable_including_any_library_files_including_the_default_lib_d_ts: diag(6670, ts.DiagnosticCategory.Message, "Disable_including_any_library_files_including_the_default_lib_d_ts_6670", "Disable including any library files, including the default lib.d.ts."), + Enforces_using_indexed_accessors_for_keys_declared_using_an_indexed_type: diag(6671, ts.DiagnosticCategory.Message, "Enforces_using_indexed_accessors_for_keys_declared_using_an_indexed_type_6671", "Enforces using indexed accessors for keys declared using an indexed type."), + Disallow_import_s_require_s_or_reference_s_from_expanding_the_number_of_files_TypeScript_should_add_to_a_project: diag(6672, ts.DiagnosticCategory.Message, "Disallow_import_s_require_s_or_reference_s_from_expanding_the_number_of_files_TypeScript_should_add__6672", "Disallow 'import's, 'require's or ''s from expanding the number of files TypeScript should add to a project."), + Disable_strict_checking_of_generic_signatures_in_function_types: diag(6673, ts.DiagnosticCategory.Message, "Disable_strict_checking_of_generic_signatures_in_function_types_6673", "Disable strict checking of generic signatures in function types."), + Add_undefined_to_a_type_when_accessed_using_an_index: diag(6674, ts.DiagnosticCategory.Message, "Add_undefined_to_a_type_when_accessed_using_an_index_6674", "Add 'undefined' to a type when accessed using an index."), + Enable_error_reporting_when_local_variables_aren_t_read: diag(6675, ts.DiagnosticCategory.Message, "Enable_error_reporting_when_local_variables_aren_t_read_6675", "Enable error reporting when local variables aren't read."), + Raise_an_error_when_a_function_parameter_isn_t_read: diag(6676, ts.DiagnosticCategory.Message, "Raise_an_error_when_a_function_parameter_isn_t_read_6676", "Raise an error when a function parameter isn't read."), + Deprecated_setting_Use_outFile_instead: diag(6677, ts.DiagnosticCategory.Message, "Deprecated_setting_Use_outFile_instead_6677", "Deprecated setting. Use 'outFile' instead."), + Specify_an_output_folder_for_all_emitted_files: diag(6678, ts.DiagnosticCategory.Message, "Specify_an_output_folder_for_all_emitted_files_6678", "Specify an output folder for all emitted files."), + Specify_a_file_that_bundles_all_outputs_into_one_JavaScript_file_If_declaration_is_true_also_designates_a_file_that_bundles_all_d_ts_output: diag(6679, ts.DiagnosticCategory.Message, "Specify_a_file_that_bundles_all_outputs_into_one_JavaScript_file_If_declaration_is_true_also_designa_6679", "Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output."), + Specify_a_set_of_entries_that_re_map_imports_to_additional_lookup_locations: diag(6680, ts.DiagnosticCategory.Message, "Specify_a_set_of_entries_that_re_map_imports_to_additional_lookup_locations_6680", "Specify a set of entries that re-map imports to additional lookup locations."), + Specify_a_list_of_language_service_plugins_to_include: diag(6681, ts.DiagnosticCategory.Message, "Specify_a_list_of_language_service_plugins_to_include_6681", "Specify a list of language service plugins to include."), + Disable_erasing_const_enum_declarations_in_generated_code: diag(6682, ts.DiagnosticCategory.Message, "Disable_erasing_const_enum_declarations_in_generated_code_6682", "Disable erasing 'const enum' declarations in generated code."), + Disable_resolving_symlinks_to_their_realpath_This_correlates_to_the_same_flag_in_node: diag(6683, ts.DiagnosticCategory.Message, "Disable_resolving_symlinks_to_their_realpath_This_correlates_to_the_same_flag_in_node_6683", "Disable resolving symlinks to their realpath. This correlates to the same flag in node."), + Disable_wiping_the_console_in_watch_mode: diag(6684, ts.DiagnosticCategory.Message, "Disable_wiping_the_console_in_watch_mode_6684", "Disable wiping the console in watch mode."), + Enable_color_and_formatting_in_TypeScript_s_output_to_make_compiler_errors_easier_to_read: diag(6685, ts.DiagnosticCategory.Message, "Enable_color_and_formatting_in_TypeScript_s_output_to_make_compiler_errors_easier_to_read_6685", "Enable color and formatting in TypeScript's output to make compiler errors easier to read."), + Specify_the_object_invoked_for_createElement_This_only_applies_when_targeting_react_JSX_emit: diag(6686, ts.DiagnosticCategory.Message, "Specify_the_object_invoked_for_createElement_This_only_applies_when_targeting_react_JSX_emit_6686", "Specify the object invoked for 'createElement'. This only applies when targeting 'react' JSX emit."), + Specify_an_array_of_objects_that_specify_paths_for_projects_Used_in_project_references: diag(6687, ts.DiagnosticCategory.Message, "Specify_an_array_of_objects_that_specify_paths_for_projects_Used_in_project_references_6687", "Specify an array of objects that specify paths for projects. Used in project references."), + Disable_emitting_comments: diag(6688, ts.DiagnosticCategory.Message, "Disable_emitting_comments_6688", "Disable emitting comments."), + Enable_importing_json_files: diag(6689, ts.DiagnosticCategory.Message, "Enable_importing_json_files_6689", "Enable importing .json files."), + Specify_the_root_folder_within_your_source_files: diag(6690, ts.DiagnosticCategory.Message, "Specify_the_root_folder_within_your_source_files_6690", "Specify the root folder within your source files."), + Allow_multiple_folders_to_be_treated_as_one_when_resolving_modules: diag(6691, ts.DiagnosticCategory.Message, "Allow_multiple_folders_to_be_treated_as_one_when_resolving_modules_6691", "Allow multiple folders to be treated as one when resolving modules."), + Skip_type_checking_d_ts_files_that_are_included_with_TypeScript: diag(6692, ts.DiagnosticCategory.Message, "Skip_type_checking_d_ts_files_that_are_included_with_TypeScript_6692", "Skip type checking .d.ts files that are included with TypeScript."), + Skip_type_checking_all_d_ts_files: diag(6693, ts.DiagnosticCategory.Message, "Skip_type_checking_all_d_ts_files_6693", "Skip type checking all .d.ts files."), + Create_source_map_files_for_emitted_JavaScript_files: diag(6694, ts.DiagnosticCategory.Message, "Create_source_map_files_for_emitted_JavaScript_files_6694", "Create source map files for emitted JavaScript files."), + Specify_the_root_path_for_debuggers_to_find_the_reference_source_code: diag(6695, ts.DiagnosticCategory.Message, "Specify_the_root_path_for_debuggers_to_find_the_reference_source_code_6695", "Specify the root path for debuggers to find the reference source code."), + Check_that_the_arguments_for_bind_call_and_apply_methods_match_the_original_function: diag(6697, ts.DiagnosticCategory.Message, "Check_that_the_arguments_for_bind_call_and_apply_methods_match_the_original_function_6697", "Check that the arguments for 'bind', 'call', and 'apply' methods match the original function."), + When_assigning_functions_check_to_ensure_parameters_and_the_return_values_are_subtype_compatible: diag(6698, ts.DiagnosticCategory.Message, "When_assigning_functions_check_to_ensure_parameters_and_the_return_values_are_subtype_compatible_6698", "When assigning functions, check to ensure parameters and the return values are subtype-compatible."), + When_type_checking_take_into_account_null_and_undefined: diag(6699, ts.DiagnosticCategory.Message, "When_type_checking_take_into_account_null_and_undefined_6699", "When type checking, take into account 'null' and 'undefined'."), + Check_for_class_properties_that_are_declared_but_not_set_in_the_constructor: diag(6700, ts.DiagnosticCategory.Message, "Check_for_class_properties_that_are_declared_but_not_set_in_the_constructor_6700", "Check for class properties that are declared but not set in the constructor."), + Disable_emitting_declarations_that_have_internal_in_their_JSDoc_comments: diag(6701, ts.DiagnosticCategory.Message, "Disable_emitting_declarations_that_have_internal_in_their_JSDoc_comments_6701", "Disable emitting declarations that have '@internal' in their JSDoc comments."), + Disable_reporting_of_excess_property_errors_during_the_creation_of_object_literals: diag(6702, ts.DiagnosticCategory.Message, "Disable_reporting_of_excess_property_errors_during_the_creation_of_object_literals_6702", "Disable reporting of excess property errors during the creation of object literals."), + Suppress_noImplicitAny_errors_when_indexing_objects_that_lack_index_signatures: diag(6703, ts.DiagnosticCategory.Message, "Suppress_noImplicitAny_errors_when_indexing_objects_that_lack_index_signatures_6703", "Suppress 'noImplicitAny' errors when indexing objects that lack index signatures."), + Synchronously_call_callbacks_and_update_the_state_of_directory_watchers_on_platforms_that_don_t_support_recursive_watching_natively: diag(6704, ts.DiagnosticCategory.Message, "Synchronously_call_callbacks_and_update_the_state_of_directory_watchers_on_platforms_that_don_t_supp_6704", "Synchronously call callbacks and update the state of directory watchers on platforms that don`t support recursive watching natively."), + Set_the_JavaScript_language_version_for_emitted_JavaScript_and_include_compatible_library_declarations: diag(6705, ts.DiagnosticCategory.Message, "Set_the_JavaScript_language_version_for_emitted_JavaScript_and_include_compatible_library_declaratio_6705", "Set the JavaScript language version for emitted JavaScript and include compatible library declarations."), + Log_paths_used_during_the_moduleResolution_process: diag(6706, ts.DiagnosticCategory.Message, "Log_paths_used_during_the_moduleResolution_process_6706", "Log paths used during the 'moduleResolution' process."), + Specify_the_path_to_tsbuildinfo_incremental_compilation_file: diag(6707, ts.DiagnosticCategory.Message, "Specify_the_path_to_tsbuildinfo_incremental_compilation_file_6707", "Specify the path to .tsbuildinfo incremental compilation file."), + Specify_options_for_automatic_acquisition_of_declaration_files: diag(6709, ts.DiagnosticCategory.Message, "Specify_options_for_automatic_acquisition_of_declaration_files_6709", "Specify options for automatic acquisition of declaration files."), + Specify_multiple_folders_that_act_like_Slashnode_modules_Slash_types: diag(6710, ts.DiagnosticCategory.Message, "Specify_multiple_folders_that_act_like_Slashnode_modules_Slash_types_6710", "Specify multiple folders that act like './node_modules/@types'."), + Specify_type_package_names_to_be_included_without_being_referenced_in_a_source_file: diag(6711, ts.DiagnosticCategory.Message, "Specify_type_package_names_to_be_included_without_being_referenced_in_a_source_file_6711", "Specify type package names to be included without being referenced in a source file."), + Emit_ECMAScript_standard_compliant_class_fields: diag(6712, ts.DiagnosticCategory.Message, "Emit_ECMAScript_standard_compliant_class_fields_6712", "Emit ECMAScript-standard-compliant class fields."), + Enable_verbose_logging: diag(6713, ts.DiagnosticCategory.Message, "Enable_verbose_logging_6713", "Enable verbose logging."), + Specify_how_directories_are_watched_on_systems_that_lack_recursive_file_watching_functionality: diag(6714, ts.DiagnosticCategory.Message, "Specify_how_directories_are_watched_on_systems_that_lack_recursive_file_watching_functionality_6714", "Specify how directories are watched on systems that lack recursive file-watching functionality."), + Specify_how_the_TypeScript_watch_mode_works: diag(6715, ts.DiagnosticCategory.Message, "Specify_how_the_TypeScript_watch_mode_works_6715", "Specify how the TypeScript watch mode works."), + Require_undeclared_properties_from_index_signatures_to_use_element_accesses: diag(6717, ts.DiagnosticCategory.Message, "Require_undeclared_properties_from_index_signatures_to_use_element_accesses_6717", "Require undeclared properties from index signatures to use element accesses."), + Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types: diag(6718, ts.DiagnosticCategory.Message, "Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types_6718", "Specify emit/checking behavior for imports that are only used for types."), + Default_catch_clause_variables_as_unknown_instead_of_any: diag(6803, ts.DiagnosticCategory.Message, "Default_catch_clause_variables_as_unknown_instead_of_any_6803", "Default catch clause variables as 'unknown' instead of 'any'."), + one_of_Colon: diag(6900, ts.DiagnosticCategory.Message, "one_of_Colon_6900", "one of:"), + one_or_more_Colon: diag(6901, ts.DiagnosticCategory.Message, "one_or_more_Colon_6901", "one or more:"), + type_Colon: diag(6902, ts.DiagnosticCategory.Message, "type_Colon_6902", "type:"), + default_Colon: diag(6903, ts.DiagnosticCategory.Message, "default_Colon_6903", "default:"), + module_system_or_esModuleInterop: diag(6904, ts.DiagnosticCategory.Message, "module_system_or_esModuleInterop_6904", "module === \"system\" or esModuleInterop"), + false_unless_strict_is_set: diag(6905, ts.DiagnosticCategory.Message, "false_unless_strict_is_set_6905", "`false`, unless `strict` is set"), + false_unless_composite_is_set: diag(6906, ts.DiagnosticCategory.Message, "false_unless_composite_is_set_6906", "`false`, unless `composite` is set"), + node_modules_bower_components_jspm_packages_plus_the_value_of_outDir_if_one_is_specified: diag(6907, ts.DiagnosticCategory.Message, "node_modules_bower_components_jspm_packages_plus_the_value_of_outDir_if_one_is_specified_6907", "`[\"node_modules\", \"bower_components\", \"jspm_packages\"]`, plus the value of `outDir` if one is specified."), + if_files_is_specified_otherwise_Asterisk_Asterisk_Slash_Asterisk: diag(6908, ts.DiagnosticCategory.Message, "if_files_is_specified_otherwise_Asterisk_Asterisk_Slash_Asterisk_6908", "`[]` if `files` is specified, otherwise `[\"**/*\"]`"), + true_if_composite_false_otherwise: diag(6909, ts.DiagnosticCategory.Message, "true_if_composite_false_otherwise_6909", "`true` if `composite`, `false` otherwise"), + module_AMD_or_UMD_or_System_or_ES6_then_Classic_Otherwise_Node: diag(69010, ts.DiagnosticCategory.Message, "module_AMD_or_UMD_or_System_or_ES6_then_Classic_Otherwise_Node_69010", "module === `AMD` or `UMD` or `System` or `ES6`, then `Classic`, Otherwise `Node`"), + Computed_from_the_list_of_input_files: diag(6911, ts.DiagnosticCategory.Message, "Computed_from_the_list_of_input_files_6911", "Computed from the list of input files"), + Platform_specific: diag(6912, ts.DiagnosticCategory.Message, "Platform_specific_6912", "Platform specific"), + You_can_learn_about_all_of_the_compiler_options_at_0: diag(6913, ts.DiagnosticCategory.Message, "You_can_learn_about_all_of_the_compiler_options_at_0_6913", "You can learn about all of the compiler options at {0}"), + Including_watch_w_will_start_watching_the_current_project_for_the_file_changes_Once_set_you_can_config_watch_mode_with_Colon: diag(6914, ts.DiagnosticCategory.Message, "Including_watch_w_will_start_watching_the_current_project_for_the_file_changes_Once_set_you_can_conf_6914", "Including --watch, -w will start watching the current project for the file changes. Once set, you can config watch mode with:"), + Using_build_b_will_make_tsc_behave_more_like_a_build_orchestrator_than_a_compiler_This_is_used_to_trigger_building_composite_projects_which_you_can_learn_more_about_at_0: diag(6915, ts.DiagnosticCategory.Message, "Using_build_b_will_make_tsc_behave_more_like_a_build_orchestrator_than_a_compiler_This_is_used_to_tr_6915", "Using --build, -b will make tsc behave more like a build orchestrator than a compiler. This is used to trigger building composite projects which you can learn more about at {0}"), + COMMON_COMMANDS: diag(6916, ts.DiagnosticCategory.Message, "COMMON_COMMANDS_6916", "COMMON COMMANDS"), + ALL_COMPILER_OPTIONS: diag(6917, ts.DiagnosticCategory.Message, "ALL_COMPILER_OPTIONS_6917", "ALL COMPILER OPTIONS"), + WATCH_OPTIONS: diag(6918, ts.DiagnosticCategory.Message, "WATCH_OPTIONS_6918", "WATCH OPTIONS"), + BUILD_OPTIONS: diag(6919, ts.DiagnosticCategory.Message, "BUILD_OPTIONS_6919", "BUILD OPTIONS"), + COMMON_COMPILER_OPTIONS: diag(6920, ts.DiagnosticCategory.Message, "COMMON_COMPILER_OPTIONS_6920", "COMMON COMPILER OPTIONS"), + COMMAND_LINE_FLAGS: diag(6921, ts.DiagnosticCategory.Message, "COMMAND_LINE_FLAGS_6921", "COMMAND LINE FLAGS"), + tsc_Colon_The_TypeScript_Compiler: diag(6922, ts.DiagnosticCategory.Message, "tsc_Colon_The_TypeScript_Compiler_6922", "tsc: The TypeScript Compiler"), + Compiles_the_current_project_tsconfig_json_in_the_working_directory: diag(6923, ts.DiagnosticCategory.Message, "Compiles_the_current_project_tsconfig_json_in_the_working_directory_6923", "Compiles the current project (tsconfig.json in the working directory.)"), + Ignoring_tsconfig_json_compiles_the_specified_files_with_default_compiler_options: diag(6924, ts.DiagnosticCategory.Message, "Ignoring_tsconfig_json_compiles_the_specified_files_with_default_compiler_options_6924", "Ignoring tsconfig.json, compiles the specified files with default compiler options."), + Build_a_composite_project_in_the_working_directory: diag(6925, ts.DiagnosticCategory.Message, "Build_a_composite_project_in_the_working_directory_6925", "Build a composite project in the working directory."), + Creates_a_tsconfig_json_with_the_recommended_settings_in_the_working_directory: diag(6926, ts.DiagnosticCategory.Message, "Creates_a_tsconfig_json_with_the_recommended_settings_in_the_working_directory_6926", "Creates a tsconfig.json with the recommended settings in the working directory."), + Compiles_the_TypeScript_project_located_at_the_specified_path: diag(6927, ts.DiagnosticCategory.Message, "Compiles_the_TypeScript_project_located_at_the_specified_path_6927", "Compiles the TypeScript project located at the specified path."), + An_expanded_version_of_this_information_showing_all_possible_compiler_options: diag(6928, ts.DiagnosticCategory.Message, "An_expanded_version_of_this_information_showing_all_possible_compiler_options_6928", "An expanded version of this information, showing all possible compiler options"), + Compiles_the_current_project_with_additional_settings: diag(6929, ts.DiagnosticCategory.Message, "Compiles_the_current_project_with_additional_settings_6929", "Compiles the current project, with additional settings."), + true_for_ES2022_and_above_including_ESNext: diag(6930, ts.DiagnosticCategory.Message, "true_for_ES2022_and_above_including_ESNext_6930", "`true` for ES2022 and above, including ESNext."), + List_of_file_name_suffixes_to_search_when_resolving_a_module: diag(6931, ts.DiagnosticCategory.Error, "List_of_file_name_suffixes_to_search_when_resolving_a_module_6931", "List of file name suffixes to search when resolving a module."), + Variable_0_implicitly_has_an_1_type: diag(7005, ts.DiagnosticCategory.Error, "Variable_0_implicitly_has_an_1_type_7005", "Variable '{0}' implicitly has an '{1}' type."), + Parameter_0_implicitly_has_an_1_type: diag(7006, ts.DiagnosticCategory.Error, "Parameter_0_implicitly_has_an_1_type_7006", "Parameter '{0}' implicitly has an '{1}' type."), + Member_0_implicitly_has_an_1_type: diag(7008, ts.DiagnosticCategory.Error, "Member_0_implicitly_has_an_1_type_7008", "Member '{0}' implicitly has an '{1}' type."), + new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type: diag(7009, ts.DiagnosticCategory.Error, "new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type_7009", "'new' expression, whose target lacks a construct signature, implicitly has an 'any' type."), + _0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type: diag(7010, ts.DiagnosticCategory.Error, "_0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type_7010", "'{0}', which lacks return-type annotation, implicitly has an '{1}' return type."), + Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type: diag(7011, ts.DiagnosticCategory.Error, "Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type_7011", "Function expression, which lacks return-type annotation, implicitly has an '{0}' return type."), + Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: diag(7013, ts.DiagnosticCategory.Error, "Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type_7013", "Construct signature, which lacks return-type annotation, implicitly has an 'any' return type."), + Function_type_which_lacks_return_type_annotation_implicitly_has_an_0_return_type: diag(7014, ts.DiagnosticCategory.Error, "Function_type_which_lacks_return_type_annotation_implicitly_has_an_0_return_type_7014", "Function type, which lacks return-type annotation, implicitly has an '{0}' return type."), + Element_implicitly_has_an_any_type_because_index_expression_is_not_of_type_number: diag(7015, ts.DiagnosticCategory.Error, "Element_implicitly_has_an_any_type_because_index_expression_is_not_of_type_number_7015", "Element implicitly has an 'any' type because index expression is not of type 'number'."), + Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type: diag(7016, ts.DiagnosticCategory.Error, "Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type_7016", "Could not find a declaration file for module '{0}'. '{1}' implicitly has an 'any' type."), + Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature: diag(7017, ts.DiagnosticCategory.Error, "Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_7017", "Element implicitly has an 'any' type because type '{0}' has no index signature."), + Object_literal_s_property_0_implicitly_has_an_1_type: diag(7018, ts.DiagnosticCategory.Error, "Object_literal_s_property_0_implicitly_has_an_1_type_7018", "Object literal's property '{0}' implicitly has an '{1}' type."), + Rest_parameter_0_implicitly_has_an_any_type: diag(7019, ts.DiagnosticCategory.Error, "Rest_parameter_0_implicitly_has_an_any_type_7019", "Rest parameter '{0}' implicitly has an 'any[]' type."), + Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: diag(7020, ts.DiagnosticCategory.Error, "Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type_7020", "Call signature, which lacks return-type annotation, implicitly has an 'any' return type."), + _0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer: diag(7022, ts.DiagnosticCategory.Error, "_0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or__7022", "'{0}' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer."), + _0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: diag(7023, ts.DiagnosticCategory.Error, "_0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_reference_7023", "'{0}' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions."), + Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: diag(7024, ts.DiagnosticCategory.Error, "Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_ref_7024", "Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions."), + Generator_implicitly_has_yield_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type_annotation: diag(7025, ts.DiagnosticCategory.Error, "Generator_implicitly_has_yield_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_retu_7025", "Generator implicitly has yield type '{0}' because it does not yield any values. Consider supplying a return type annotation."), + JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists: diag(7026, ts.DiagnosticCategory.Error, "JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists_7026", "JSX element implicitly has type 'any' because no interface 'JSX.{0}' exists."), + Unreachable_code_detected: diag(7027, ts.DiagnosticCategory.Error, "Unreachable_code_detected_7027", "Unreachable code detected.", /*reportsUnnecessary*/ true), + Unused_label: diag(7028, ts.DiagnosticCategory.Error, "Unused_label_7028", "Unused label.", /*reportsUnnecessary*/ true), + Fallthrough_case_in_switch: diag(7029, ts.DiagnosticCategory.Error, "Fallthrough_case_in_switch_7029", "Fallthrough case in switch."), + Not_all_code_paths_return_a_value: diag(7030, ts.DiagnosticCategory.Error, "Not_all_code_paths_return_a_value_7030", "Not all code paths return a value."), + Binding_element_0_implicitly_has_an_1_type: diag(7031, ts.DiagnosticCategory.Error, "Binding_element_0_implicitly_has_an_1_type_7031", "Binding element '{0}' implicitly has an '{1}' type."), + Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation: diag(7032, ts.DiagnosticCategory.Error, "Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation_7032", "Property '{0}' implicitly has type 'any', because its set accessor lacks a parameter type annotation."), + Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation: diag(7033, ts.DiagnosticCategory.Error, "Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation_7033", "Property '{0}' implicitly has type 'any', because its get accessor lacks a return type annotation."), + Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined: diag(7034, ts.DiagnosticCategory.Error, "Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined_7034", "Variable '{0}' implicitly has type '{1}' in some locations where its type cannot be determined."), + Try_npm_i_save_dev_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare_module_0: diag(7035, ts.DiagnosticCategory.Error, "Try_npm_i_save_dev_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare__7035", "Try `npm i --save-dev @types/{1}` if it exists or add a new declaration (.d.ts) file containing `declare module '{0}';`"), + Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0: diag(7036, ts.DiagnosticCategory.Error, "Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0_7036", "Dynamic import's specifier must be of type 'string', but here has type '{0}'."), + Enables_emit_interoperability_between_CommonJS_and_ES_Modules_via_creation_of_namespace_objects_for_all_imports_Implies_allowSyntheticDefaultImports: diag(7037, ts.DiagnosticCategory.Message, "Enables_emit_interoperability_between_CommonJS_and_ES_Modules_via_creation_of_namespace_objects_for__7037", "Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'."), + Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cause_a_failure_at_runtime_Consider_using_a_default_import_or_import_require_here_instead: diag(7038, ts.DiagnosticCategory.Message, "Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cau_7038", "Type originates at this import. A namespace-style import cannot be called or constructed, and will cause a failure at runtime. Consider using a default import or import require here instead."), + Mapped_object_type_implicitly_has_an_any_template_type: diag(7039, ts.DiagnosticCategory.Error, "Mapped_object_type_implicitly_has_an_any_template_type_7039", "Mapped object type implicitly has an 'any' template type."), + If_the_0_package_actually_exposes_this_module_consider_sending_a_pull_request_to_amend_https_Colon_Slash_Slashgithub_com_SlashDefinitelyTyped_SlashDefinitelyTyped_Slashtree_Slashmaster_Slashtypes_Slash_1: diag(7040, ts.DiagnosticCategory.Error, "If_the_0_package_actually_exposes_this_module_consider_sending_a_pull_request_to_amend_https_Colon_S_7040", "If the '{0}' package actually exposes this module, consider sending a pull request to amend 'https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/{1}'"), + The_containing_arrow_function_captures_the_global_value_of_this: diag(7041, ts.DiagnosticCategory.Error, "The_containing_arrow_function_captures_the_global_value_of_this_7041", "The containing arrow function captures the global value of 'this'."), + Module_0_was_resolved_to_1_but_resolveJsonModule_is_not_used: diag(7042, ts.DiagnosticCategory.Error, "Module_0_was_resolved_to_1_but_resolveJsonModule_is_not_used_7042", "Module '{0}' was resolved to '{1}', but '--resolveJsonModule' is not used."), + Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage: diag(7043, ts.DiagnosticCategory.Suggestion, "Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage_7043", "Variable '{0}' implicitly has an '{1}' type, but a better type may be inferred from usage."), + Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage: diag(7044, ts.DiagnosticCategory.Suggestion, "Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage_7044", "Parameter '{0}' implicitly has an '{1}' type, but a better type may be inferred from usage."), + Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage: diag(7045, ts.DiagnosticCategory.Suggestion, "Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage_7045", "Member '{0}' implicitly has an '{1}' type, but a better type may be inferred from usage."), + Variable_0_implicitly_has_type_1_in_some_locations_but_a_better_type_may_be_inferred_from_usage: diag(7046, ts.DiagnosticCategory.Suggestion, "Variable_0_implicitly_has_type_1_in_some_locations_but_a_better_type_may_be_inferred_from_usage_7046", "Variable '{0}' implicitly has type '{1}' in some locations, but a better type may be inferred from usage."), + Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage: diag(7047, ts.DiagnosticCategory.Suggestion, "Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage_7047", "Rest parameter '{0}' implicitly has an 'any[]' type, but a better type may be inferred from usage."), + Property_0_implicitly_has_type_any_but_a_better_type_for_its_get_accessor_may_be_inferred_from_usage: diag(7048, ts.DiagnosticCategory.Suggestion, "Property_0_implicitly_has_type_any_but_a_better_type_for_its_get_accessor_may_be_inferred_from_usage_7048", "Property '{0}' implicitly has type 'any', but a better type for its get accessor may be inferred from usage."), + Property_0_implicitly_has_type_any_but_a_better_type_for_its_set_accessor_may_be_inferred_from_usage: diag(7049, ts.DiagnosticCategory.Suggestion, "Property_0_implicitly_has_type_any_but_a_better_type_for_its_set_accessor_may_be_inferred_from_usage_7049", "Property '{0}' implicitly has type 'any', but a better type for its set accessor may be inferred from usage."), + _0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage: diag(7050, ts.DiagnosticCategory.Suggestion, "_0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage_7050", "'{0}' implicitly has an '{1}' return type, but a better type may be inferred from usage."), + Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1: diag(7051, ts.DiagnosticCategory.Error, "Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1_7051", "Parameter has a name but no type. Did you mean '{0}: {1}'?"), + Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_Did_you_mean_to_call_1: diag(7052, ts.DiagnosticCategory.Error, "Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_Did_you_mean_to_call_1_7052", "Element implicitly has an 'any' type because type '{0}' has no index signature. Did you mean to call '{1}'?"), + Element_implicitly_has_an_any_type_because_expression_of_type_0_can_t_be_used_to_index_type_1: diag(7053, ts.DiagnosticCategory.Error, "Element_implicitly_has_an_any_type_because_expression_of_type_0_can_t_be_used_to_index_type_1_7053", "Element implicitly has an 'any' type because expression of type '{0}' can't be used to index type '{1}'."), + No_index_signature_with_a_parameter_of_type_0_was_found_on_type_1: diag(7054, ts.DiagnosticCategory.Error, "No_index_signature_with_a_parameter_of_type_0_was_found_on_type_1_7054", "No index signature with a parameter of type '{0}' was found on type '{1}'."), + _0_which_lacks_return_type_annotation_implicitly_has_an_1_yield_type: diag(7055, ts.DiagnosticCategory.Error, "_0_which_lacks_return_type_annotation_implicitly_has_an_1_yield_type_7055", "'{0}', which lacks return-type annotation, implicitly has an '{1}' yield type."), + The_inferred_type_of_this_node_exceeds_the_maximum_length_the_compiler_will_serialize_An_explicit_type_annotation_is_needed: diag(7056, ts.DiagnosticCategory.Error, "The_inferred_type_of_this_node_exceeds_the_maximum_length_the_compiler_will_serialize_An_explicit_ty_7056", "The inferred type of this node exceeds the maximum length the compiler will serialize. An explicit type annotation is needed."), + yield_expression_implicitly_results_in_an_any_type_because_its_containing_generator_lacks_a_return_type_annotation: diag(7057, ts.DiagnosticCategory.Error, "yield_expression_implicitly_results_in_an_any_type_because_its_containing_generator_lacks_a_return_t_7057", "'yield' expression implicitly results in an 'any' type because its containing generator lacks a return-type annotation."), + If_the_0_package_actually_exposes_this_module_try_adding_a_new_declaration_d_ts_file_containing_declare_module_1: diag(7058, ts.DiagnosticCategory.Error, "If_the_0_package_actually_exposes_this_module_try_adding_a_new_declaration_d_ts_file_containing_decl_7058", "If the '{0}' package actually exposes this module, try adding a new declaration (.d.ts) file containing `declare module '{1}';`"), + This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Use_an_as_expression_instead: diag(7059, ts.DiagnosticCategory.Error, "This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Use_an_as_expression_instead_7059", "This syntax is reserved in files with the .mts or .cts extension. Use an `as` expression instead."), + This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Add_a_trailing_comma_or_explicit_constraint: diag(7060, ts.DiagnosticCategory.Error, "This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Add_a_trailing_comma_or_explicit_cons_7060", "This syntax is reserved in files with the .mts or .cts extension. Add a trailing comma or explicit constraint."), + A_mapped_type_may_not_declare_properties_or_methods: diag(7061, ts.DiagnosticCategory.Error, "A_mapped_type_may_not_declare_properties_or_methods_7061", "A mapped type may not declare properties or methods."), + You_cannot_rename_this_element: diag(8000, ts.DiagnosticCategory.Error, "You_cannot_rename_this_element_8000", "You cannot rename this element."), + You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library: diag(8001, ts.DiagnosticCategory.Error, "You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library_8001", "You cannot rename elements that are defined in the standard TypeScript library."), + import_can_only_be_used_in_TypeScript_files: diag(8002, ts.DiagnosticCategory.Error, "import_can_only_be_used_in_TypeScript_files_8002", "'import ... =' can only be used in TypeScript files."), + export_can_only_be_used_in_TypeScript_files: diag(8003, ts.DiagnosticCategory.Error, "export_can_only_be_used_in_TypeScript_files_8003", "'export =' can only be used in TypeScript files."), + Type_parameter_declarations_can_only_be_used_in_TypeScript_files: diag(8004, ts.DiagnosticCategory.Error, "Type_parameter_declarations_can_only_be_used_in_TypeScript_files_8004", "Type parameter declarations can only be used in TypeScript files."), + implements_clauses_can_only_be_used_in_TypeScript_files: diag(8005, ts.DiagnosticCategory.Error, "implements_clauses_can_only_be_used_in_TypeScript_files_8005", "'implements' clauses can only be used in TypeScript files."), + _0_declarations_can_only_be_used_in_TypeScript_files: diag(8006, ts.DiagnosticCategory.Error, "_0_declarations_can_only_be_used_in_TypeScript_files_8006", "'{0}' declarations can only be used in TypeScript files."), + Type_aliases_can_only_be_used_in_TypeScript_files: diag(8008, ts.DiagnosticCategory.Error, "Type_aliases_can_only_be_used_in_TypeScript_files_8008", "Type aliases can only be used in TypeScript files."), + The_0_modifier_can_only_be_used_in_TypeScript_files: diag(8009, ts.DiagnosticCategory.Error, "The_0_modifier_can_only_be_used_in_TypeScript_files_8009", "The '{0}' modifier can only be used in TypeScript files."), + Type_annotations_can_only_be_used_in_TypeScript_files: diag(8010, ts.DiagnosticCategory.Error, "Type_annotations_can_only_be_used_in_TypeScript_files_8010", "Type annotations can only be used in TypeScript files."), + Type_arguments_can_only_be_used_in_TypeScript_files: diag(8011, ts.DiagnosticCategory.Error, "Type_arguments_can_only_be_used_in_TypeScript_files_8011", "Type arguments can only be used in TypeScript files."), + Parameter_modifiers_can_only_be_used_in_TypeScript_files: diag(8012, ts.DiagnosticCategory.Error, "Parameter_modifiers_can_only_be_used_in_TypeScript_files_8012", "Parameter modifiers can only be used in TypeScript files."), + Non_null_assertions_can_only_be_used_in_TypeScript_files: diag(8013, ts.DiagnosticCategory.Error, "Non_null_assertions_can_only_be_used_in_TypeScript_files_8013", "Non-null assertions can only be used in TypeScript files."), + Type_assertion_expressions_can_only_be_used_in_TypeScript_files: diag(8016, ts.DiagnosticCategory.Error, "Type_assertion_expressions_can_only_be_used_in_TypeScript_files_8016", "Type assertion expressions can only be used in TypeScript files."), + Octal_literal_types_must_use_ES2015_syntax_Use_the_syntax_0: diag(8017, ts.DiagnosticCategory.Error, "Octal_literal_types_must_use_ES2015_syntax_Use_the_syntax_0_8017", "Octal literal types must use ES2015 syntax. Use the syntax '{0}'."), + Octal_literals_are_not_allowed_in_enums_members_initializer_Use_the_syntax_0: diag(8018, ts.DiagnosticCategory.Error, "Octal_literals_are_not_allowed_in_enums_members_initializer_Use_the_syntax_0_8018", "Octal literals are not allowed in enums members initializer. Use the syntax '{0}'."), + Report_errors_in_js_files: diag(8019, ts.DiagnosticCategory.Message, "Report_errors_in_js_files_8019", "Report errors in .js files."), + JSDoc_types_can_only_be_used_inside_documentation_comments: diag(8020, ts.DiagnosticCategory.Error, "JSDoc_types_can_only_be_used_inside_documentation_comments_8020", "JSDoc types can only be used inside documentation comments."), + JSDoc_typedef_tag_should_either_have_a_type_annotation_or_be_followed_by_property_or_member_tags: diag(8021, ts.DiagnosticCategory.Error, "JSDoc_typedef_tag_should_either_have_a_type_annotation_or_be_followed_by_property_or_member_tags_8021", "JSDoc '@typedef' tag should either have a type annotation or be followed by '@property' or '@member' tags."), + JSDoc_0_is_not_attached_to_a_class: diag(8022, ts.DiagnosticCategory.Error, "JSDoc_0_is_not_attached_to_a_class_8022", "JSDoc '@{0}' is not attached to a class."), + JSDoc_0_1_does_not_match_the_extends_2_clause: diag(8023, ts.DiagnosticCategory.Error, "JSDoc_0_1_does_not_match_the_extends_2_clause_8023", "JSDoc '@{0} {1}' does not match the 'extends {2}' clause."), + JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name: diag(8024, ts.DiagnosticCategory.Error, "JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_8024", "JSDoc '@param' tag has name '{0}', but there is no parameter with that name."), + Class_declarations_cannot_have_more_than_one_augments_or_extends_tag: diag(8025, ts.DiagnosticCategory.Error, "Class_declarations_cannot_have_more_than_one_augments_or_extends_tag_8025", "Class declarations cannot have more than one '@augments' or '@extends' tag."), + Expected_0_type_arguments_provide_these_with_an_extends_tag: diag(8026, ts.DiagnosticCategory.Error, "Expected_0_type_arguments_provide_these_with_an_extends_tag_8026", "Expected {0} type arguments; provide these with an '@extends' tag."), + Expected_0_1_type_arguments_provide_these_with_an_extends_tag: diag(8027, ts.DiagnosticCategory.Error, "Expected_0_1_type_arguments_provide_these_with_an_extends_tag_8027", "Expected {0}-{1} type arguments; provide these with an '@extends' tag."), + JSDoc_may_only_appear_in_the_last_parameter_of_a_signature: diag(8028, ts.DiagnosticCategory.Error, "JSDoc_may_only_appear_in_the_last_parameter_of_a_signature_8028", "JSDoc '...' may only appear in the last parameter of a signature."), + JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_had_an_array_type: diag(8029, ts.DiagnosticCategory.Error, "JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_h_8029", "JSDoc '@param' tag has name '{0}', but there is no parameter with that name. It would match 'arguments' if it had an array type."), + The_type_of_a_function_declaration_must_match_the_function_s_signature: diag(8030, ts.DiagnosticCategory.Error, "The_type_of_a_function_declaration_must_match_the_function_s_signature_8030", "The type of a function declaration must match the function's signature."), + You_cannot_rename_a_module_via_a_global_import: diag(8031, ts.DiagnosticCategory.Error, "You_cannot_rename_a_module_via_a_global_import_8031", "You cannot rename a module via a global import."), + Qualified_name_0_is_not_allowed_without_a_leading_param_object_1: diag(8032, ts.DiagnosticCategory.Error, "Qualified_name_0_is_not_allowed_without_a_leading_param_object_1_8032", "Qualified name '{0}' is not allowed without a leading '@param {object} {1}'."), + A_JSDoc_typedef_comment_may_not_contain_multiple_type_tags: diag(8033, ts.DiagnosticCategory.Error, "A_JSDoc_typedef_comment_may_not_contain_multiple_type_tags_8033", "A JSDoc '@typedef' comment may not contain multiple '@type' tags."), + The_tag_was_first_specified_here: diag(8034, ts.DiagnosticCategory.Error, "The_tag_was_first_specified_here_8034", "The tag was first specified here."), + You_cannot_rename_elements_that_are_defined_in_a_node_modules_folder: diag(8035, ts.DiagnosticCategory.Error, "You_cannot_rename_elements_that_are_defined_in_a_node_modules_folder_8035", "You cannot rename elements that are defined in a 'node_modules' folder."), + You_cannot_rename_elements_that_are_defined_in_another_node_modules_folder: diag(8036, ts.DiagnosticCategory.Error, "You_cannot_rename_elements_that_are_defined_in_another_node_modules_folder_8036", "You cannot rename elements that are defined in another 'node_modules' folder."), + Type_satisfaction_expressions_can_only_be_used_in_TypeScript_files: diag(8037, ts.DiagnosticCategory.Error, "Type_satisfaction_expressions_can_only_be_used_in_TypeScript_files_8037", "Type satisfaction expressions can only be used in TypeScript files."), + Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_declaration_emit: diag(9005, ts.DiagnosticCategory.Error, "Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_9005", "Declaration emit for this file requires using private name '{0}'. An explicit type annotation may unblock declaration emit."), + Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotation_may_unblock_declaration_emit: diag(9006, ts.DiagnosticCategory.Error, "Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotati_9006", "Declaration emit for this file requires using private name '{0}' from module '{1}'. An explicit type annotation may unblock declaration emit."), + JSX_attributes_must_only_be_assigned_a_non_empty_expression: diag(17000, ts.DiagnosticCategory.Error, "JSX_attributes_must_only_be_assigned_a_non_empty_expression_17000", "JSX attributes must only be assigned a non-empty 'expression'."), + JSX_elements_cannot_have_multiple_attributes_with_the_same_name: diag(17001, ts.DiagnosticCategory.Error, "JSX_elements_cannot_have_multiple_attributes_with_the_same_name_17001", "JSX elements cannot have multiple attributes with the same name."), + Expected_corresponding_JSX_closing_tag_for_0: diag(17002, ts.DiagnosticCategory.Error, "Expected_corresponding_JSX_closing_tag_for_0_17002", "Expected corresponding JSX closing tag for '{0}'."), + Cannot_use_JSX_unless_the_jsx_flag_is_provided: diag(17004, ts.DiagnosticCategory.Error, "Cannot_use_JSX_unless_the_jsx_flag_is_provided_17004", "Cannot use JSX unless the '--jsx' flag is provided."), + A_constructor_cannot_contain_a_super_call_when_its_class_extends_null: diag(17005, ts.DiagnosticCategory.Error, "A_constructor_cannot_contain_a_super_call_when_its_class_extends_null_17005", "A constructor cannot contain a 'super' call when its class extends 'null'."), + An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses: diag(17006, ts.DiagnosticCategory.Error, "An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_ex_17006", "An unary expression with the '{0}' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses."), + A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses: diag(17007, ts.DiagnosticCategory.Error, "A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Con_17007", "A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses."), + JSX_element_0_has_no_corresponding_closing_tag: diag(17008, ts.DiagnosticCategory.Error, "JSX_element_0_has_no_corresponding_closing_tag_17008", "JSX element '{0}' has no corresponding closing tag."), + super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class: diag(17009, ts.DiagnosticCategory.Error, "super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class_17009", "'super' must be called before accessing 'this' in the constructor of a derived class."), + Unknown_type_acquisition_option_0: diag(17010, ts.DiagnosticCategory.Error, "Unknown_type_acquisition_option_0_17010", "Unknown type acquisition option '{0}'."), + super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class: diag(17011, ts.DiagnosticCategory.Error, "super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class_17011", "'super' must be called before accessing a property of 'super' in the constructor of a derived class."), + _0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2: diag(17012, ts.DiagnosticCategory.Error, "_0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2_17012", "'{0}' is not a valid meta-property for keyword '{1}'. Did you mean '{2}'?"), + Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constructor: diag(17013, ts.DiagnosticCategory.Error, "Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constru_17013", "Meta-property '{0}' is only allowed in the body of a function declaration, function expression, or constructor."), + JSX_fragment_has_no_corresponding_closing_tag: diag(17014, ts.DiagnosticCategory.Error, "JSX_fragment_has_no_corresponding_closing_tag_17014", "JSX fragment has no corresponding closing tag."), + Expected_corresponding_closing_tag_for_JSX_fragment: diag(17015, ts.DiagnosticCategory.Error, "Expected_corresponding_closing_tag_for_JSX_fragment_17015", "Expected corresponding closing tag for JSX fragment."), + The_jsxFragmentFactory_compiler_option_must_be_provided_to_use_JSX_fragments_with_the_jsxFactory_compiler_option: diag(17016, ts.DiagnosticCategory.Error, "The_jsxFragmentFactory_compiler_option_must_be_provided_to_use_JSX_fragments_with_the_jsxFactory_com_17016", "The 'jsxFragmentFactory' compiler option must be provided to use JSX fragments with the 'jsxFactory' compiler option."), + An_jsxFrag_pragma_is_required_when_using_an_jsx_pragma_with_JSX_fragments: diag(17017, ts.DiagnosticCategory.Error, "An_jsxFrag_pragma_is_required_when_using_an_jsx_pragma_with_JSX_fragments_17017", "An @jsxFrag pragma is required when using an @jsx pragma with JSX fragments."), + Unknown_type_acquisition_option_0_Did_you_mean_1: diag(17018, ts.DiagnosticCategory.Error, "Unknown_type_acquisition_option_0_Did_you_mean_1_17018", "Unknown type acquisition option '{0}'. Did you mean '{1}'?"), + Circularity_detected_while_resolving_configuration_Colon_0: diag(18000, ts.DiagnosticCategory.Error, "Circularity_detected_while_resolving_configuration_Colon_0_18000", "Circularity detected while resolving configuration: {0}"), + The_files_list_in_config_file_0_is_empty: diag(18002, ts.DiagnosticCategory.Error, "The_files_list_in_config_file_0_is_empty_18002", "The 'files' list in config file '{0}' is empty."), + No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2: diag(18003, ts.DiagnosticCategory.Error, "No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2_18003", "No inputs were found in config file '{0}'. Specified 'include' paths were '{1}' and 'exclude' paths were '{2}'."), + File_is_a_CommonJS_module_it_may_be_converted_to_an_ES_module: diag(80001, ts.DiagnosticCategory.Suggestion, "File_is_a_CommonJS_module_it_may_be_converted_to_an_ES_module_80001", "File is a CommonJS module; it may be converted to an ES module."), + This_constructor_function_may_be_converted_to_a_class_declaration: diag(80002, ts.DiagnosticCategory.Suggestion, "This_constructor_function_may_be_converted_to_a_class_declaration_80002", "This constructor function may be converted to a class declaration."), + Import_may_be_converted_to_a_default_import: diag(80003, ts.DiagnosticCategory.Suggestion, "Import_may_be_converted_to_a_default_import_80003", "Import may be converted to a default import."), + JSDoc_types_may_be_moved_to_TypeScript_types: diag(80004, ts.DiagnosticCategory.Suggestion, "JSDoc_types_may_be_moved_to_TypeScript_types_80004", "JSDoc types may be moved to TypeScript types."), + require_call_may_be_converted_to_an_import: diag(80005, ts.DiagnosticCategory.Suggestion, "require_call_may_be_converted_to_an_import_80005", "'require' call may be converted to an import."), + This_may_be_converted_to_an_async_function: diag(80006, ts.DiagnosticCategory.Suggestion, "This_may_be_converted_to_an_async_function_80006", "This may be converted to an async function."), + await_has_no_effect_on_the_type_of_this_expression: diag(80007, ts.DiagnosticCategory.Suggestion, "await_has_no_effect_on_the_type_of_this_expression_80007", "'await' has no effect on the type of this expression."), + Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers: diag(80008, ts.DiagnosticCategory.Suggestion, "Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accur_80008", "Numeric literals with absolute values equal to 2^53 or greater are too large to be represented accurately as integers."), + Add_missing_super_call: diag(90001, ts.DiagnosticCategory.Message, "Add_missing_super_call_90001", "Add missing 'super()' call"), + Make_super_call_the_first_statement_in_the_constructor: diag(90002, ts.DiagnosticCategory.Message, "Make_super_call_the_first_statement_in_the_constructor_90002", "Make 'super()' call the first statement in the constructor"), + Change_extends_to_implements: diag(90003, ts.DiagnosticCategory.Message, "Change_extends_to_implements_90003", "Change 'extends' to 'implements'"), + Remove_unused_declaration_for_Colon_0: diag(90004, ts.DiagnosticCategory.Message, "Remove_unused_declaration_for_Colon_0_90004", "Remove unused declaration for: '{0}'"), + Remove_import_from_0: diag(90005, ts.DiagnosticCategory.Message, "Remove_import_from_0_90005", "Remove import from '{0}'"), + Implement_interface_0: diag(90006, ts.DiagnosticCategory.Message, "Implement_interface_0_90006", "Implement interface '{0}'"), + Implement_inherited_abstract_class: diag(90007, ts.DiagnosticCategory.Message, "Implement_inherited_abstract_class_90007", "Implement inherited abstract class"), + Add_0_to_unresolved_variable: diag(90008, ts.DiagnosticCategory.Message, "Add_0_to_unresolved_variable_90008", "Add '{0}.' to unresolved variable"), + Remove_variable_statement: diag(90010, ts.DiagnosticCategory.Message, "Remove_variable_statement_90010", "Remove variable statement"), + Remove_template_tag: diag(90011, ts.DiagnosticCategory.Message, "Remove_template_tag_90011", "Remove template tag"), + Remove_type_parameters: diag(90012, ts.DiagnosticCategory.Message, "Remove_type_parameters_90012", "Remove type parameters"), + Import_0_from_1: diag(90013, ts.DiagnosticCategory.Message, "Import_0_from_1_90013", "Import '{0}' from \"{1}\""), + Change_0_to_1: diag(90014, ts.DiagnosticCategory.Message, "Change_0_to_1_90014", "Change '{0}' to '{1}'"), + Declare_property_0: diag(90016, ts.DiagnosticCategory.Message, "Declare_property_0_90016", "Declare property '{0}'"), + Add_index_signature_for_property_0: diag(90017, ts.DiagnosticCategory.Message, "Add_index_signature_for_property_0_90017", "Add index signature for property '{0}'"), + Disable_checking_for_this_file: diag(90018, ts.DiagnosticCategory.Message, "Disable_checking_for_this_file_90018", "Disable checking for this file"), + Ignore_this_error_message: diag(90019, ts.DiagnosticCategory.Message, "Ignore_this_error_message_90019", "Ignore this error message"), + Initialize_property_0_in_the_constructor: diag(90020, ts.DiagnosticCategory.Message, "Initialize_property_0_in_the_constructor_90020", "Initialize property '{0}' in the constructor"), + Initialize_static_property_0: diag(90021, ts.DiagnosticCategory.Message, "Initialize_static_property_0_90021", "Initialize static property '{0}'"), + Change_spelling_to_0: diag(90022, ts.DiagnosticCategory.Message, "Change_spelling_to_0_90022", "Change spelling to '{0}'"), + Declare_method_0: diag(90023, ts.DiagnosticCategory.Message, "Declare_method_0_90023", "Declare method '{0}'"), + Declare_static_method_0: diag(90024, ts.DiagnosticCategory.Message, "Declare_static_method_0_90024", "Declare static method '{0}'"), + Prefix_0_with_an_underscore: diag(90025, ts.DiagnosticCategory.Message, "Prefix_0_with_an_underscore_90025", "Prefix '{0}' with an underscore"), + Rewrite_as_the_indexed_access_type_0: diag(90026, ts.DiagnosticCategory.Message, "Rewrite_as_the_indexed_access_type_0_90026", "Rewrite as the indexed access type '{0}'"), + Declare_static_property_0: diag(90027, ts.DiagnosticCategory.Message, "Declare_static_property_0_90027", "Declare static property '{0}'"), + Call_decorator_expression: diag(90028, ts.DiagnosticCategory.Message, "Call_decorator_expression_90028", "Call decorator expression"), + Add_async_modifier_to_containing_function: diag(90029, ts.DiagnosticCategory.Message, "Add_async_modifier_to_containing_function_90029", "Add async modifier to containing function"), + Replace_infer_0_with_unknown: diag(90030, ts.DiagnosticCategory.Message, "Replace_infer_0_with_unknown_90030", "Replace 'infer {0}' with 'unknown'"), + Replace_all_unused_infer_with_unknown: diag(90031, ts.DiagnosticCategory.Message, "Replace_all_unused_infer_with_unknown_90031", "Replace all unused 'infer' with 'unknown'"), + Add_parameter_name: diag(90034, ts.DiagnosticCategory.Message, "Add_parameter_name_90034", "Add parameter name"), + Declare_private_property_0: diag(90035, ts.DiagnosticCategory.Message, "Declare_private_property_0_90035", "Declare private property '{0}'"), + Replace_0_with_Promise_1: diag(90036, ts.DiagnosticCategory.Message, "Replace_0_with_Promise_1_90036", "Replace '{0}' with 'Promise<{1}>'"), + Fix_all_incorrect_return_type_of_an_async_functions: diag(90037, ts.DiagnosticCategory.Message, "Fix_all_incorrect_return_type_of_an_async_functions_90037", "Fix all incorrect return type of an async functions"), + Declare_private_method_0: diag(90038, ts.DiagnosticCategory.Message, "Declare_private_method_0_90038", "Declare private method '{0}'"), + Remove_unused_destructuring_declaration: diag(90039, ts.DiagnosticCategory.Message, "Remove_unused_destructuring_declaration_90039", "Remove unused destructuring declaration"), + Remove_unused_declarations_for_Colon_0: diag(90041, ts.DiagnosticCategory.Message, "Remove_unused_declarations_for_Colon_0_90041", "Remove unused declarations for: '{0}'"), + Declare_a_private_field_named_0: diag(90053, ts.DiagnosticCategory.Message, "Declare_a_private_field_named_0_90053", "Declare a private field named '{0}'."), + Includes_imports_of_types_referenced_by_0: diag(90054, ts.DiagnosticCategory.Message, "Includes_imports_of_types_referenced_by_0_90054", "Includes imports of types referenced by '{0}'"), + Remove_type_from_import_declaration_from_0: diag(90055, ts.DiagnosticCategory.Message, "Remove_type_from_import_declaration_from_0_90055", "Remove 'type' from import declaration from \"{0}\""), + Remove_type_from_import_of_0_from_1: diag(90056, ts.DiagnosticCategory.Message, "Remove_type_from_import_of_0_from_1_90056", "Remove 'type' from import of '{0}' from \"{1}\""), + Add_import_from_0: diag(90057, ts.DiagnosticCategory.Message, "Add_import_from_0_90057", "Add import from \"{0}\""), + Update_import_from_0: diag(90058, ts.DiagnosticCategory.Message, "Update_import_from_0_90058", "Update import from \"{0}\""), + Export_0_from_module_1: diag(90059, ts.DiagnosticCategory.Message, "Export_0_from_module_1_90059", "Export '{0}' from module '{1}'"), + Export_all_referenced_locals: diag(90060, ts.DiagnosticCategory.Message, "Export_all_referenced_locals_90060", "Export all referenced locals"), + Convert_function_to_an_ES2015_class: diag(95001, ts.DiagnosticCategory.Message, "Convert_function_to_an_ES2015_class_95001", "Convert function to an ES2015 class"), + Convert_0_to_1_in_0: diag(95003, ts.DiagnosticCategory.Message, "Convert_0_to_1_in_0_95003", "Convert '{0}' to '{1} in {0}'"), + Extract_to_0_in_1: diag(95004, ts.DiagnosticCategory.Message, "Extract_to_0_in_1_95004", "Extract to {0} in {1}"), + Extract_function: diag(95005, ts.DiagnosticCategory.Message, "Extract_function_95005", "Extract function"), + Extract_constant: diag(95006, ts.DiagnosticCategory.Message, "Extract_constant_95006", "Extract constant"), + Extract_to_0_in_enclosing_scope: diag(95007, ts.DiagnosticCategory.Message, "Extract_to_0_in_enclosing_scope_95007", "Extract to {0} in enclosing scope"), + Extract_to_0_in_1_scope: diag(95008, ts.DiagnosticCategory.Message, "Extract_to_0_in_1_scope_95008", "Extract to {0} in {1} scope"), + Annotate_with_type_from_JSDoc: diag(95009, ts.DiagnosticCategory.Message, "Annotate_with_type_from_JSDoc_95009", "Annotate with type from JSDoc"), + Infer_type_of_0_from_usage: diag(95011, ts.DiagnosticCategory.Message, "Infer_type_of_0_from_usage_95011", "Infer type of '{0}' from usage"), + Infer_parameter_types_from_usage: diag(95012, ts.DiagnosticCategory.Message, "Infer_parameter_types_from_usage_95012", "Infer parameter types from usage"), + Convert_to_default_import: diag(95013, ts.DiagnosticCategory.Message, "Convert_to_default_import_95013", "Convert to default import"), + Install_0: diag(95014, ts.DiagnosticCategory.Message, "Install_0_95014", "Install '{0}'"), + Replace_import_with_0: diag(95015, ts.DiagnosticCategory.Message, "Replace_import_with_0_95015", "Replace import with '{0}'."), + Use_synthetic_default_member: diag(95016, ts.DiagnosticCategory.Message, "Use_synthetic_default_member_95016", "Use synthetic 'default' member."), + Convert_to_ES_module: diag(95017, ts.DiagnosticCategory.Message, "Convert_to_ES_module_95017", "Convert to ES module"), + Add_undefined_type_to_property_0: diag(95018, ts.DiagnosticCategory.Message, "Add_undefined_type_to_property_0_95018", "Add 'undefined' type to property '{0}'"), + Add_initializer_to_property_0: diag(95019, ts.DiagnosticCategory.Message, "Add_initializer_to_property_0_95019", "Add initializer to property '{0}'"), + Add_definite_assignment_assertion_to_property_0: diag(95020, ts.DiagnosticCategory.Message, "Add_definite_assignment_assertion_to_property_0_95020", "Add definite assignment assertion to property '{0}'"), + Convert_all_type_literals_to_mapped_type: diag(95021, ts.DiagnosticCategory.Message, "Convert_all_type_literals_to_mapped_type_95021", "Convert all type literals to mapped type"), + Add_all_missing_members: diag(95022, ts.DiagnosticCategory.Message, "Add_all_missing_members_95022", "Add all missing members"), + Infer_all_types_from_usage: diag(95023, ts.DiagnosticCategory.Message, "Infer_all_types_from_usage_95023", "Infer all types from usage"), + Delete_all_unused_declarations: diag(95024, ts.DiagnosticCategory.Message, "Delete_all_unused_declarations_95024", "Delete all unused declarations"), + Prefix_all_unused_declarations_with_where_possible: diag(95025, ts.DiagnosticCategory.Message, "Prefix_all_unused_declarations_with_where_possible_95025", "Prefix all unused declarations with '_' where possible"), + Fix_all_detected_spelling_errors: diag(95026, ts.DiagnosticCategory.Message, "Fix_all_detected_spelling_errors_95026", "Fix all detected spelling errors"), + Add_initializers_to_all_uninitialized_properties: diag(95027, ts.DiagnosticCategory.Message, "Add_initializers_to_all_uninitialized_properties_95027", "Add initializers to all uninitialized properties"), + Add_definite_assignment_assertions_to_all_uninitialized_properties: diag(95028, ts.DiagnosticCategory.Message, "Add_definite_assignment_assertions_to_all_uninitialized_properties_95028", "Add definite assignment assertions to all uninitialized properties"), + Add_undefined_type_to_all_uninitialized_properties: diag(95029, ts.DiagnosticCategory.Message, "Add_undefined_type_to_all_uninitialized_properties_95029", "Add undefined type to all uninitialized properties"), + Change_all_jsdoc_style_types_to_TypeScript: diag(95030, ts.DiagnosticCategory.Message, "Change_all_jsdoc_style_types_to_TypeScript_95030", "Change all jsdoc-style types to TypeScript"), + Change_all_jsdoc_style_types_to_TypeScript_and_add_undefined_to_nullable_types: diag(95031, ts.DiagnosticCategory.Message, "Change_all_jsdoc_style_types_to_TypeScript_and_add_undefined_to_nullable_types_95031", "Change all jsdoc-style types to TypeScript (and add '| undefined' to nullable types)"), + Implement_all_unimplemented_interfaces: diag(95032, ts.DiagnosticCategory.Message, "Implement_all_unimplemented_interfaces_95032", "Implement all unimplemented interfaces"), + Install_all_missing_types_packages: diag(95033, ts.DiagnosticCategory.Message, "Install_all_missing_types_packages_95033", "Install all missing types packages"), + Rewrite_all_as_indexed_access_types: diag(95034, ts.DiagnosticCategory.Message, "Rewrite_all_as_indexed_access_types_95034", "Rewrite all as indexed access types"), + Convert_all_to_default_imports: diag(95035, ts.DiagnosticCategory.Message, "Convert_all_to_default_imports_95035", "Convert all to default imports"), + Make_all_super_calls_the_first_statement_in_their_constructor: diag(95036, ts.DiagnosticCategory.Message, "Make_all_super_calls_the_first_statement_in_their_constructor_95036", "Make all 'super()' calls the first statement in their constructor"), + Add_qualifier_to_all_unresolved_variables_matching_a_member_name: diag(95037, ts.DiagnosticCategory.Message, "Add_qualifier_to_all_unresolved_variables_matching_a_member_name_95037", "Add qualifier to all unresolved variables matching a member name"), + Change_all_extended_interfaces_to_implements: diag(95038, ts.DiagnosticCategory.Message, "Change_all_extended_interfaces_to_implements_95038", "Change all extended interfaces to 'implements'"), + Add_all_missing_super_calls: diag(95039, ts.DiagnosticCategory.Message, "Add_all_missing_super_calls_95039", "Add all missing super calls"), + Implement_all_inherited_abstract_classes: diag(95040, ts.DiagnosticCategory.Message, "Implement_all_inherited_abstract_classes_95040", "Implement all inherited abstract classes"), + Add_all_missing_async_modifiers: diag(95041, ts.DiagnosticCategory.Message, "Add_all_missing_async_modifiers_95041", "Add all missing 'async' modifiers"), + Add_ts_ignore_to_all_error_messages: diag(95042, ts.DiagnosticCategory.Message, "Add_ts_ignore_to_all_error_messages_95042", "Add '@ts-ignore' to all error messages"), + Annotate_everything_with_types_from_JSDoc: diag(95043, ts.DiagnosticCategory.Message, "Annotate_everything_with_types_from_JSDoc_95043", "Annotate everything with types from JSDoc"), + Add_to_all_uncalled_decorators: diag(95044, ts.DiagnosticCategory.Message, "Add_to_all_uncalled_decorators_95044", "Add '()' to all uncalled decorators"), + Convert_all_constructor_functions_to_classes: diag(95045, ts.DiagnosticCategory.Message, "Convert_all_constructor_functions_to_classes_95045", "Convert all constructor functions to classes"), + Generate_get_and_set_accessors: diag(95046, ts.DiagnosticCategory.Message, "Generate_get_and_set_accessors_95046", "Generate 'get' and 'set' accessors"), + Convert_require_to_import: diag(95047, ts.DiagnosticCategory.Message, "Convert_require_to_import_95047", "Convert 'require' to 'import'"), + Convert_all_require_to_import: diag(95048, ts.DiagnosticCategory.Message, "Convert_all_require_to_import_95048", "Convert all 'require' to 'import'"), + Move_to_a_new_file: diag(95049, ts.DiagnosticCategory.Message, "Move_to_a_new_file_95049", "Move to a new file"), + Remove_unreachable_code: diag(95050, ts.DiagnosticCategory.Message, "Remove_unreachable_code_95050", "Remove unreachable code"), + Remove_all_unreachable_code: diag(95051, ts.DiagnosticCategory.Message, "Remove_all_unreachable_code_95051", "Remove all unreachable code"), + Add_missing_typeof: diag(95052, ts.DiagnosticCategory.Message, "Add_missing_typeof_95052", "Add missing 'typeof'"), + Remove_unused_label: diag(95053, ts.DiagnosticCategory.Message, "Remove_unused_label_95053", "Remove unused label"), + Remove_all_unused_labels: diag(95054, ts.DiagnosticCategory.Message, "Remove_all_unused_labels_95054", "Remove all unused labels"), + Convert_0_to_mapped_object_type: diag(95055, ts.DiagnosticCategory.Message, "Convert_0_to_mapped_object_type_95055", "Convert '{0}' to mapped object type"), + Convert_namespace_import_to_named_imports: diag(95056, ts.DiagnosticCategory.Message, "Convert_namespace_import_to_named_imports_95056", "Convert namespace import to named imports"), + Convert_named_imports_to_namespace_import: diag(95057, ts.DiagnosticCategory.Message, "Convert_named_imports_to_namespace_import_95057", "Convert named imports to namespace import"), + Add_or_remove_braces_in_an_arrow_function: diag(95058, ts.DiagnosticCategory.Message, "Add_or_remove_braces_in_an_arrow_function_95058", "Add or remove braces in an arrow function"), + Add_braces_to_arrow_function: diag(95059, ts.DiagnosticCategory.Message, "Add_braces_to_arrow_function_95059", "Add braces to arrow function"), + Remove_braces_from_arrow_function: diag(95060, ts.DiagnosticCategory.Message, "Remove_braces_from_arrow_function_95060", "Remove braces from arrow function"), + Convert_default_export_to_named_export: diag(95061, ts.DiagnosticCategory.Message, "Convert_default_export_to_named_export_95061", "Convert default export to named export"), + Convert_named_export_to_default_export: diag(95062, ts.DiagnosticCategory.Message, "Convert_named_export_to_default_export_95062", "Convert named export to default export"), + Add_missing_enum_member_0: diag(95063, ts.DiagnosticCategory.Message, "Add_missing_enum_member_0_95063", "Add missing enum member '{0}'"), + Add_all_missing_imports: diag(95064, ts.DiagnosticCategory.Message, "Add_all_missing_imports_95064", "Add all missing imports"), + Convert_to_async_function: diag(95065, ts.DiagnosticCategory.Message, "Convert_to_async_function_95065", "Convert to async function"), + Convert_all_to_async_functions: diag(95066, ts.DiagnosticCategory.Message, "Convert_all_to_async_functions_95066", "Convert all to async functions"), + Add_missing_call_parentheses: diag(95067, ts.DiagnosticCategory.Message, "Add_missing_call_parentheses_95067", "Add missing call parentheses"), + Add_all_missing_call_parentheses: diag(95068, ts.DiagnosticCategory.Message, "Add_all_missing_call_parentheses_95068", "Add all missing call parentheses"), + Add_unknown_conversion_for_non_overlapping_types: diag(95069, ts.DiagnosticCategory.Message, "Add_unknown_conversion_for_non_overlapping_types_95069", "Add 'unknown' conversion for non-overlapping types"), + Add_unknown_to_all_conversions_of_non_overlapping_types: diag(95070, ts.DiagnosticCategory.Message, "Add_unknown_to_all_conversions_of_non_overlapping_types_95070", "Add 'unknown' to all conversions of non-overlapping types"), + Add_missing_new_operator_to_call: diag(95071, ts.DiagnosticCategory.Message, "Add_missing_new_operator_to_call_95071", "Add missing 'new' operator to call"), + Add_missing_new_operator_to_all_calls: diag(95072, ts.DiagnosticCategory.Message, "Add_missing_new_operator_to_all_calls_95072", "Add missing 'new' operator to all calls"), + Add_names_to_all_parameters_without_names: diag(95073, ts.DiagnosticCategory.Message, "Add_names_to_all_parameters_without_names_95073", "Add names to all parameters without names"), + Enable_the_experimentalDecorators_option_in_your_configuration_file: diag(95074, ts.DiagnosticCategory.Message, "Enable_the_experimentalDecorators_option_in_your_configuration_file_95074", "Enable the 'experimentalDecorators' option in your configuration file"), + Convert_parameters_to_destructured_object: diag(95075, ts.DiagnosticCategory.Message, "Convert_parameters_to_destructured_object_95075", "Convert parameters to destructured object"), + Extract_type: diag(95077, ts.DiagnosticCategory.Message, "Extract_type_95077", "Extract type"), + Extract_to_type_alias: diag(95078, ts.DiagnosticCategory.Message, "Extract_to_type_alias_95078", "Extract to type alias"), + Extract_to_typedef: diag(95079, ts.DiagnosticCategory.Message, "Extract_to_typedef_95079", "Extract to typedef"), + Infer_this_type_of_0_from_usage: diag(95080, ts.DiagnosticCategory.Message, "Infer_this_type_of_0_from_usage_95080", "Infer 'this' type of '{0}' from usage"), + Add_const_to_unresolved_variable: diag(95081, ts.DiagnosticCategory.Message, "Add_const_to_unresolved_variable_95081", "Add 'const' to unresolved variable"), + Add_const_to_all_unresolved_variables: diag(95082, ts.DiagnosticCategory.Message, "Add_const_to_all_unresolved_variables_95082", "Add 'const' to all unresolved variables"), + Add_await: diag(95083, ts.DiagnosticCategory.Message, "Add_await_95083", "Add 'await'"), + Add_await_to_initializer_for_0: diag(95084, ts.DiagnosticCategory.Message, "Add_await_to_initializer_for_0_95084", "Add 'await' to initializer for '{0}'"), + Fix_all_expressions_possibly_missing_await: diag(95085, ts.DiagnosticCategory.Message, "Fix_all_expressions_possibly_missing_await_95085", "Fix all expressions possibly missing 'await'"), + Remove_unnecessary_await: diag(95086, ts.DiagnosticCategory.Message, "Remove_unnecessary_await_95086", "Remove unnecessary 'await'"), + Remove_all_unnecessary_uses_of_await: diag(95087, ts.DiagnosticCategory.Message, "Remove_all_unnecessary_uses_of_await_95087", "Remove all unnecessary uses of 'await'"), + Enable_the_jsx_flag_in_your_configuration_file: diag(95088, ts.DiagnosticCategory.Message, "Enable_the_jsx_flag_in_your_configuration_file_95088", "Enable the '--jsx' flag in your configuration file"), + Add_await_to_initializers: diag(95089, ts.DiagnosticCategory.Message, "Add_await_to_initializers_95089", "Add 'await' to initializers"), + Extract_to_interface: diag(95090, ts.DiagnosticCategory.Message, "Extract_to_interface_95090", "Extract to interface"), + Convert_to_a_bigint_numeric_literal: diag(95091, ts.DiagnosticCategory.Message, "Convert_to_a_bigint_numeric_literal_95091", "Convert to a bigint numeric literal"), + Convert_all_to_bigint_numeric_literals: diag(95092, ts.DiagnosticCategory.Message, "Convert_all_to_bigint_numeric_literals_95092", "Convert all to bigint numeric literals"), + Convert_const_to_let: diag(95093, ts.DiagnosticCategory.Message, "Convert_const_to_let_95093", "Convert 'const' to 'let'"), + Prefix_with_declare: diag(95094, ts.DiagnosticCategory.Message, "Prefix_with_declare_95094", "Prefix with 'declare'"), + Prefix_all_incorrect_property_declarations_with_declare: diag(95095, ts.DiagnosticCategory.Message, "Prefix_all_incorrect_property_declarations_with_declare_95095", "Prefix all incorrect property declarations with 'declare'"), + Convert_to_template_string: diag(95096, ts.DiagnosticCategory.Message, "Convert_to_template_string_95096", "Convert to template string"), + Add_export_to_make_this_file_into_a_module: diag(95097, ts.DiagnosticCategory.Message, "Add_export_to_make_this_file_into_a_module_95097", "Add 'export {}' to make this file into a module"), + Set_the_target_option_in_your_configuration_file_to_0: diag(95098, ts.DiagnosticCategory.Message, "Set_the_target_option_in_your_configuration_file_to_0_95098", "Set the 'target' option in your configuration file to '{0}'"), + Set_the_module_option_in_your_configuration_file_to_0: diag(95099, ts.DiagnosticCategory.Message, "Set_the_module_option_in_your_configuration_file_to_0_95099", "Set the 'module' option in your configuration file to '{0}'"), + Convert_invalid_character_to_its_html_entity_code: diag(95100, ts.DiagnosticCategory.Message, "Convert_invalid_character_to_its_html_entity_code_95100", "Convert invalid character to its html entity code"), + Convert_all_invalid_characters_to_HTML_entity_code: diag(95101, ts.DiagnosticCategory.Message, "Convert_all_invalid_characters_to_HTML_entity_code_95101", "Convert all invalid characters to HTML entity code"), + Convert_all_const_to_let: diag(95102, ts.DiagnosticCategory.Message, "Convert_all_const_to_let_95102", "Convert all 'const' to 'let'"), + Convert_function_expression_0_to_arrow_function: diag(95105, ts.DiagnosticCategory.Message, "Convert_function_expression_0_to_arrow_function_95105", "Convert function expression '{0}' to arrow function"), + Convert_function_declaration_0_to_arrow_function: diag(95106, ts.DiagnosticCategory.Message, "Convert_function_declaration_0_to_arrow_function_95106", "Convert function declaration '{0}' to arrow function"), + Fix_all_implicit_this_errors: diag(95107, ts.DiagnosticCategory.Message, "Fix_all_implicit_this_errors_95107", "Fix all implicit-'this' errors"), + Wrap_invalid_character_in_an_expression_container: diag(95108, ts.DiagnosticCategory.Message, "Wrap_invalid_character_in_an_expression_container_95108", "Wrap invalid character in an expression container"), + Wrap_all_invalid_characters_in_an_expression_container: diag(95109, ts.DiagnosticCategory.Message, "Wrap_all_invalid_characters_in_an_expression_container_95109", "Wrap all invalid characters in an expression container"), + Visit_https_Colon_Slash_Slashaka_ms_Slashtsconfig_to_read_more_about_this_file: diag(95110, ts.DiagnosticCategory.Message, "Visit_https_Colon_Slash_Slashaka_ms_Slashtsconfig_to_read_more_about_this_file_95110", "Visit https://aka.ms/tsconfig to read more about this file"), + Add_a_return_statement: diag(95111, ts.DiagnosticCategory.Message, "Add_a_return_statement_95111", "Add a return statement"), + Remove_braces_from_arrow_function_body: diag(95112, ts.DiagnosticCategory.Message, "Remove_braces_from_arrow_function_body_95112", "Remove braces from arrow function body"), + Wrap_the_following_body_with_parentheses_which_should_be_an_object_literal: diag(95113, ts.DiagnosticCategory.Message, "Wrap_the_following_body_with_parentheses_which_should_be_an_object_literal_95113", "Wrap the following body with parentheses which should be an object literal"), + Add_all_missing_return_statement: diag(95114, ts.DiagnosticCategory.Message, "Add_all_missing_return_statement_95114", "Add all missing return statement"), + Remove_braces_from_all_arrow_function_bodies_with_relevant_issues: diag(95115, ts.DiagnosticCategory.Message, "Remove_braces_from_all_arrow_function_bodies_with_relevant_issues_95115", "Remove braces from all arrow function bodies with relevant issues"), + Wrap_all_object_literal_with_parentheses: diag(95116, ts.DiagnosticCategory.Message, "Wrap_all_object_literal_with_parentheses_95116", "Wrap all object literal with parentheses"), + Move_labeled_tuple_element_modifiers_to_labels: diag(95117, ts.DiagnosticCategory.Message, "Move_labeled_tuple_element_modifiers_to_labels_95117", "Move labeled tuple element modifiers to labels"), + Convert_overload_list_to_single_signature: diag(95118, ts.DiagnosticCategory.Message, "Convert_overload_list_to_single_signature_95118", "Convert overload list to single signature"), + Generate_get_and_set_accessors_for_all_overriding_properties: diag(95119, ts.DiagnosticCategory.Message, "Generate_get_and_set_accessors_for_all_overriding_properties_95119", "Generate 'get' and 'set' accessors for all overriding properties"), + Wrap_in_JSX_fragment: diag(95120, ts.DiagnosticCategory.Message, "Wrap_in_JSX_fragment_95120", "Wrap in JSX fragment"), + Wrap_all_unparented_JSX_in_JSX_fragment: diag(95121, ts.DiagnosticCategory.Message, "Wrap_all_unparented_JSX_in_JSX_fragment_95121", "Wrap all unparented JSX in JSX fragment"), + Convert_arrow_function_or_function_expression: diag(95122, ts.DiagnosticCategory.Message, "Convert_arrow_function_or_function_expression_95122", "Convert arrow function or function expression"), + Convert_to_anonymous_function: diag(95123, ts.DiagnosticCategory.Message, "Convert_to_anonymous_function_95123", "Convert to anonymous function"), + Convert_to_named_function: diag(95124, ts.DiagnosticCategory.Message, "Convert_to_named_function_95124", "Convert to named function"), + Convert_to_arrow_function: diag(95125, ts.DiagnosticCategory.Message, "Convert_to_arrow_function_95125", "Convert to arrow function"), + Remove_parentheses: diag(95126, ts.DiagnosticCategory.Message, "Remove_parentheses_95126", "Remove parentheses"), + Could_not_find_a_containing_arrow_function: diag(95127, ts.DiagnosticCategory.Message, "Could_not_find_a_containing_arrow_function_95127", "Could not find a containing arrow function"), + Containing_function_is_not_an_arrow_function: diag(95128, ts.DiagnosticCategory.Message, "Containing_function_is_not_an_arrow_function_95128", "Containing function is not an arrow function"), + Could_not_find_export_statement: diag(95129, ts.DiagnosticCategory.Message, "Could_not_find_export_statement_95129", "Could not find export statement"), + This_file_already_has_a_default_export: diag(95130, ts.DiagnosticCategory.Message, "This_file_already_has_a_default_export_95130", "This file already has a default export"), + Could_not_find_import_clause: diag(95131, ts.DiagnosticCategory.Message, "Could_not_find_import_clause_95131", "Could not find import clause"), + Could_not_find_namespace_import_or_named_imports: diag(95132, ts.DiagnosticCategory.Message, "Could_not_find_namespace_import_or_named_imports_95132", "Could not find namespace import or named imports"), + Selection_is_not_a_valid_type_node: diag(95133, ts.DiagnosticCategory.Message, "Selection_is_not_a_valid_type_node_95133", "Selection is not a valid type node"), + No_type_could_be_extracted_from_this_type_node: diag(95134, ts.DiagnosticCategory.Message, "No_type_could_be_extracted_from_this_type_node_95134", "No type could be extracted from this type node"), + Could_not_find_property_for_which_to_generate_accessor: diag(95135, ts.DiagnosticCategory.Message, "Could_not_find_property_for_which_to_generate_accessor_95135", "Could not find property for which to generate accessor"), + Name_is_not_valid: diag(95136, ts.DiagnosticCategory.Message, "Name_is_not_valid_95136", "Name is not valid"), + Can_only_convert_property_with_modifier: diag(95137, ts.DiagnosticCategory.Message, "Can_only_convert_property_with_modifier_95137", "Can only convert property with modifier"), + Switch_each_misused_0_to_1: diag(95138, ts.DiagnosticCategory.Message, "Switch_each_misused_0_to_1_95138", "Switch each misused '{0}' to '{1}'"), + Convert_to_optional_chain_expression: diag(95139, ts.DiagnosticCategory.Message, "Convert_to_optional_chain_expression_95139", "Convert to optional chain expression"), + Could_not_find_convertible_access_expression: diag(95140, ts.DiagnosticCategory.Message, "Could_not_find_convertible_access_expression_95140", "Could not find convertible access expression"), + Could_not_find_matching_access_expressions: diag(95141, ts.DiagnosticCategory.Message, "Could_not_find_matching_access_expressions_95141", "Could not find matching access expressions"), + Can_only_convert_logical_AND_access_chains: diag(95142, ts.DiagnosticCategory.Message, "Can_only_convert_logical_AND_access_chains_95142", "Can only convert logical AND access chains"), + Add_void_to_Promise_resolved_without_a_value: diag(95143, ts.DiagnosticCategory.Message, "Add_void_to_Promise_resolved_without_a_value_95143", "Add 'void' to Promise resolved without a value"), + Add_void_to_all_Promises_resolved_without_a_value: diag(95144, ts.DiagnosticCategory.Message, "Add_void_to_all_Promises_resolved_without_a_value_95144", "Add 'void' to all Promises resolved without a value"), + Use_element_access_for_0: diag(95145, ts.DiagnosticCategory.Message, "Use_element_access_for_0_95145", "Use element access for '{0}'"), + Use_element_access_for_all_undeclared_properties: diag(95146, ts.DiagnosticCategory.Message, "Use_element_access_for_all_undeclared_properties_95146", "Use element access for all undeclared properties."), + Delete_all_unused_imports: diag(95147, ts.DiagnosticCategory.Message, "Delete_all_unused_imports_95147", "Delete all unused imports"), + Infer_function_return_type: diag(95148, ts.DiagnosticCategory.Message, "Infer_function_return_type_95148", "Infer function return type"), + Return_type_must_be_inferred_from_a_function: diag(95149, ts.DiagnosticCategory.Message, "Return_type_must_be_inferred_from_a_function_95149", "Return type must be inferred from a function"), + Could_not_determine_function_return_type: diag(95150, ts.DiagnosticCategory.Message, "Could_not_determine_function_return_type_95150", "Could not determine function return type"), + Could_not_convert_to_arrow_function: diag(95151, ts.DiagnosticCategory.Message, "Could_not_convert_to_arrow_function_95151", "Could not convert to arrow function"), + Could_not_convert_to_named_function: diag(95152, ts.DiagnosticCategory.Message, "Could_not_convert_to_named_function_95152", "Could not convert to named function"), + Could_not_convert_to_anonymous_function: diag(95153, ts.DiagnosticCategory.Message, "Could_not_convert_to_anonymous_function_95153", "Could not convert to anonymous function"), + Can_only_convert_string_concatenation: diag(95154, ts.DiagnosticCategory.Message, "Can_only_convert_string_concatenation_95154", "Can only convert string concatenation"), + Selection_is_not_a_valid_statement_or_statements: diag(95155, ts.DiagnosticCategory.Message, "Selection_is_not_a_valid_statement_or_statements_95155", "Selection is not a valid statement or statements"), + Add_missing_function_declaration_0: diag(95156, ts.DiagnosticCategory.Message, "Add_missing_function_declaration_0_95156", "Add missing function declaration '{0}'"), + Add_all_missing_function_declarations: diag(95157, ts.DiagnosticCategory.Message, "Add_all_missing_function_declarations_95157", "Add all missing function declarations"), + Method_not_implemented: diag(95158, ts.DiagnosticCategory.Message, "Method_not_implemented_95158", "Method not implemented."), + Function_not_implemented: diag(95159, ts.DiagnosticCategory.Message, "Function_not_implemented_95159", "Function not implemented."), + Add_override_modifier: diag(95160, ts.DiagnosticCategory.Message, "Add_override_modifier_95160", "Add 'override' modifier"), + Remove_override_modifier: diag(95161, ts.DiagnosticCategory.Message, "Remove_override_modifier_95161", "Remove 'override' modifier"), + Add_all_missing_override_modifiers: diag(95162, ts.DiagnosticCategory.Message, "Add_all_missing_override_modifiers_95162", "Add all missing 'override' modifiers"), + Remove_all_unnecessary_override_modifiers: diag(95163, ts.DiagnosticCategory.Message, "Remove_all_unnecessary_override_modifiers_95163", "Remove all unnecessary 'override' modifiers"), + Can_only_convert_named_export: diag(95164, ts.DiagnosticCategory.Message, "Can_only_convert_named_export_95164", "Can only convert named export"), + Add_missing_properties: diag(95165, ts.DiagnosticCategory.Message, "Add_missing_properties_95165", "Add missing properties"), + Add_all_missing_properties: diag(95166, ts.DiagnosticCategory.Message, "Add_all_missing_properties_95166", "Add all missing properties"), + Add_missing_attributes: diag(95167, ts.DiagnosticCategory.Message, "Add_missing_attributes_95167", "Add missing attributes"), + Add_all_missing_attributes: diag(95168, ts.DiagnosticCategory.Message, "Add_all_missing_attributes_95168", "Add all missing attributes"), + Add_undefined_to_optional_property_type: diag(95169, ts.DiagnosticCategory.Message, "Add_undefined_to_optional_property_type_95169", "Add 'undefined' to optional property type"), + Convert_named_imports_to_default_import: diag(95170, ts.DiagnosticCategory.Message, "Convert_named_imports_to_default_import_95170", "Convert named imports to default import"), + Delete_unused_param_tag_0: diag(95171, ts.DiagnosticCategory.Message, "Delete_unused_param_tag_0_95171", "Delete unused '@param' tag '{0}'"), + Delete_all_unused_param_tags: diag(95172, ts.DiagnosticCategory.Message, "Delete_all_unused_param_tags_95172", "Delete all unused '@param' tags"), + Rename_param_tag_name_0_to_1: diag(95173, ts.DiagnosticCategory.Message, "Rename_param_tag_name_0_to_1_95173", "Rename '@param' tag name '{0}' to '{1}'"), + Use_0: diag(95174, ts.DiagnosticCategory.Message, "Use_0_95174", "Use `{0}`."), + Use_Number_isNaN_in_all_conditions: diag(95175, ts.DiagnosticCategory.Message, "Use_Number_isNaN_in_all_conditions_95175", "Use `Number.isNaN` in all conditions."), + No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer: diag(18004, ts.DiagnosticCategory.Error, "No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer_18004", "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer."), + Classes_may_not_have_a_field_named_constructor: diag(18006, ts.DiagnosticCategory.Error, "Classes_may_not_have_a_field_named_constructor_18006", "Classes may not have a field named 'constructor'."), + JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array: diag(18007, ts.DiagnosticCategory.Error, "JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array_18007", "JSX expressions may not use the comma operator. Did you mean to write an array?"), + Private_identifiers_cannot_be_used_as_parameters: diag(18009, ts.DiagnosticCategory.Error, "Private_identifiers_cannot_be_used_as_parameters_18009", "Private identifiers cannot be used as parameters."), + An_accessibility_modifier_cannot_be_used_with_a_private_identifier: diag(18010, ts.DiagnosticCategory.Error, "An_accessibility_modifier_cannot_be_used_with_a_private_identifier_18010", "An accessibility modifier cannot be used with a private identifier."), + The_operand_of_a_delete_operator_cannot_be_a_private_identifier: diag(18011, ts.DiagnosticCategory.Error, "The_operand_of_a_delete_operator_cannot_be_a_private_identifier_18011", "The operand of a 'delete' operator cannot be a private identifier."), + constructor_is_a_reserved_word: diag(18012, ts.DiagnosticCategory.Error, "constructor_is_a_reserved_word_18012", "'#constructor' is a reserved word."), + Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_identifier: diag(18013, ts.DiagnosticCategory.Error, "Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_identifier_18013", "Property '{0}' is not accessible outside class '{1}' because it has a private identifier."), + The_property_0_cannot_be_accessed_on_type_1_within_this_class_because_it_is_shadowed_by_another_private_identifier_with_the_same_spelling: diag(18014, ts.DiagnosticCategory.Error, "The_property_0_cannot_be_accessed_on_type_1_within_this_class_because_it_is_shadowed_by_another_priv_18014", "The property '{0}' cannot be accessed on type '{1}' within this class because it is shadowed by another private identifier with the same spelling."), + Property_0_in_type_1_refers_to_a_different_member_that_cannot_be_accessed_from_within_type_2: diag(18015, ts.DiagnosticCategory.Error, "Property_0_in_type_1_refers_to_a_different_member_that_cannot_be_accessed_from_within_type_2_18015", "Property '{0}' in type '{1}' refers to a different member that cannot be accessed from within type '{2}'."), + Private_identifiers_are_not_allowed_outside_class_bodies: diag(18016, ts.DiagnosticCategory.Error, "Private_identifiers_are_not_allowed_outside_class_bodies_18016", "Private identifiers are not allowed outside class bodies."), + The_shadowing_declaration_of_0_is_defined_here: diag(18017, ts.DiagnosticCategory.Error, "The_shadowing_declaration_of_0_is_defined_here_18017", "The shadowing declaration of '{0}' is defined here"), + The_declaration_of_0_that_you_probably_intended_to_use_is_defined_here: diag(18018, ts.DiagnosticCategory.Error, "The_declaration_of_0_that_you_probably_intended_to_use_is_defined_here_18018", "The declaration of '{0}' that you probably intended to use is defined here"), + _0_modifier_cannot_be_used_with_a_private_identifier: diag(18019, ts.DiagnosticCategory.Error, "_0_modifier_cannot_be_used_with_a_private_identifier_18019", "'{0}' modifier cannot be used with a private identifier."), + An_enum_member_cannot_be_named_with_a_private_identifier: diag(18024, ts.DiagnosticCategory.Error, "An_enum_member_cannot_be_named_with_a_private_identifier_18024", "An enum member cannot be named with a private identifier."), + can_only_be_used_at_the_start_of_a_file: diag(18026, ts.DiagnosticCategory.Error, "can_only_be_used_at_the_start_of_a_file_18026", "'#!' can only be used at the start of a file."), + Compiler_reserves_name_0_when_emitting_private_identifier_downlevel: diag(18027, ts.DiagnosticCategory.Error, "Compiler_reserves_name_0_when_emitting_private_identifier_downlevel_18027", "Compiler reserves name '{0}' when emitting private identifier downlevel."), + Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher: diag(18028, ts.DiagnosticCategory.Error, "Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher_18028", "Private identifiers are only available when targeting ECMAScript 2015 and higher."), + Private_identifiers_are_not_allowed_in_variable_declarations: diag(18029, ts.DiagnosticCategory.Error, "Private_identifiers_are_not_allowed_in_variable_declarations_18029", "Private identifiers are not allowed in variable declarations."), + An_optional_chain_cannot_contain_private_identifiers: diag(18030, ts.DiagnosticCategory.Error, "An_optional_chain_cannot_contain_private_identifiers_18030", "An optional chain cannot contain private identifiers."), + The_intersection_0_was_reduced_to_never_because_property_1_has_conflicting_types_in_some_constituents: diag(18031, ts.DiagnosticCategory.Error, "The_intersection_0_was_reduced_to_never_because_property_1_has_conflicting_types_in_some_constituent_18031", "The intersection '{0}' was reduced to 'never' because property '{1}' has conflicting types in some constituents."), + The_intersection_0_was_reduced_to_never_because_property_1_exists_in_multiple_constituents_and_is_private_in_some: diag(18032, ts.DiagnosticCategory.Error, "The_intersection_0_was_reduced_to_never_because_property_1_exists_in_multiple_constituents_and_is_pr_18032", "The intersection '{0}' was reduced to 'never' because property '{1}' exists in multiple constituents and is private in some."), + Only_numeric_enums_can_have_computed_members_but_this_expression_has_type_0_If_you_do_not_need_exhaustiveness_checks_consider_using_an_object_literal_instead: diag(18033, ts.DiagnosticCategory.Error, "Only_numeric_enums_can_have_computed_members_but_this_expression_has_type_0_If_you_do_not_need_exhau_18033", "Only numeric enums can have computed members, but this expression has type '{0}'. If you do not need exhaustiveness checks, consider using an object literal instead."), + Specify_the_JSX_fragment_factory_function_to_use_when_targeting_react_JSX_emit_with_jsxFactory_compiler_option_is_specified_e_g_Fragment: diag(18034, ts.DiagnosticCategory.Message, "Specify_the_JSX_fragment_factory_function_to_use_when_targeting_react_JSX_emit_with_jsxFactory_compi_18034", "Specify the JSX fragment factory function to use when targeting 'react' JSX emit with 'jsxFactory' compiler option is specified, e.g. 'Fragment'."), + Invalid_value_for_jsxFragmentFactory_0_is_not_a_valid_identifier_or_qualified_name: diag(18035, ts.DiagnosticCategory.Error, "Invalid_value_for_jsxFragmentFactory_0_is_not_a_valid_identifier_or_qualified_name_18035", "Invalid value for 'jsxFragmentFactory'. '{0}' is not a valid identifier or qualified-name."), + Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_decorator: diag(18036, ts.DiagnosticCategory.Error, "Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_dec_18036", "Class decorators can't be used with static private identifier. Consider removing the experimental decorator."), + Await_expression_cannot_be_used_inside_a_class_static_block: diag(18037, ts.DiagnosticCategory.Error, "Await_expression_cannot_be_used_inside_a_class_static_block_18037", "Await expression cannot be used inside a class static block."), + For_await_loops_cannot_be_used_inside_a_class_static_block: diag(18038, ts.DiagnosticCategory.Error, "For_await_loops_cannot_be_used_inside_a_class_static_block_18038", "'For await' loops cannot be used inside a class static block."), + Invalid_use_of_0_It_cannot_be_used_inside_a_class_static_block: diag(18039, ts.DiagnosticCategory.Error, "Invalid_use_of_0_It_cannot_be_used_inside_a_class_static_block_18039", "Invalid use of '{0}'. It cannot be used inside a class static block."), + A_return_statement_cannot_be_used_inside_a_class_static_block: diag(18041, ts.DiagnosticCategory.Error, "A_return_statement_cannot_be_used_inside_a_class_static_block_18041", "A 'return' statement cannot be used inside a class static block."), + _0_is_a_type_and_cannot_be_imported_in_JavaScript_files_Use_1_in_a_JSDoc_type_annotation: diag(18042, ts.DiagnosticCategory.Error, "_0_is_a_type_and_cannot_be_imported_in_JavaScript_files_Use_1_in_a_JSDoc_type_annotation_18042", "'{0}' is a type and cannot be imported in JavaScript files. Use '{1}' in a JSDoc type annotation."), + Types_cannot_appear_in_export_declarations_in_JavaScript_files: diag(18043, ts.DiagnosticCategory.Error, "Types_cannot_appear_in_export_declarations_in_JavaScript_files_18043", "Types cannot appear in export declarations in JavaScript files."), + _0_is_automatically_exported_here: diag(18044, ts.DiagnosticCategory.Message, "_0_is_automatically_exported_here_18044", "'{0}' is automatically exported here."), + Properties_with_the_accessor_modifier_are_only_available_when_targeting_ECMAScript_2015_and_higher: diag(18045, ts.DiagnosticCategory.Error, "Properties_with_the_accessor_modifier_are_only_available_when_targeting_ECMAScript_2015_and_higher_18045", "Properties with the 'accessor' modifier are only available when targeting ECMAScript 2015 and higher."), + _0_is_of_type_unknown: diag(18046, ts.DiagnosticCategory.Error, "_0_is_of_type_unknown_18046", "'{0}' is of type 'unknown'."), + _0_is_possibly_null: diag(18047, ts.DiagnosticCategory.Error, "_0_is_possibly_null_18047", "'{0}' is possibly 'null'."), + _0_is_possibly_undefined: diag(18048, ts.DiagnosticCategory.Error, "_0_is_possibly_undefined_18048", "'{0}' is possibly 'undefined'."), + _0_is_possibly_null_or_undefined: diag(18049, ts.DiagnosticCategory.Error, "_0_is_possibly_null_or_undefined_18049", "'{0}' is possibly 'null' or 'undefined'."), + The_value_0_cannot_be_used_here: diag(18050, ts.DiagnosticCategory.Error, "The_value_0_cannot_be_used_here_18050", "The value '{0}' cannot be used here."), + }; +})(ts || (ts = {})); +var ts; +(function (ts) { + var _a; + /* @internal */ + function tokenIsIdentifierOrKeyword(token) { + return token >= 79 /* SyntaxKind.Identifier */; + } + ts.tokenIsIdentifierOrKeyword = tokenIsIdentifierOrKeyword; + /* @internal */ + function tokenIsIdentifierOrKeywordOrGreaterThan(token) { + return token === 31 /* SyntaxKind.GreaterThanToken */ || tokenIsIdentifierOrKeyword(token); + } + ts.tokenIsIdentifierOrKeywordOrGreaterThan = tokenIsIdentifierOrKeywordOrGreaterThan; + /** @internal */ + ts.textToKeywordObj = (_a = { + abstract: 126 /* SyntaxKind.AbstractKeyword */, + accessor: 127 /* SyntaxKind.AccessorKeyword */, + any: 131 /* SyntaxKind.AnyKeyword */, + as: 128 /* SyntaxKind.AsKeyword */, + asserts: 129 /* SyntaxKind.AssertsKeyword */, + assert: 130 /* SyntaxKind.AssertKeyword */, + bigint: 160 /* SyntaxKind.BigIntKeyword */, + boolean: 134 /* SyntaxKind.BooleanKeyword */, + break: 81 /* SyntaxKind.BreakKeyword */, + case: 82 /* SyntaxKind.CaseKeyword */, + catch: 83 /* SyntaxKind.CatchKeyword */, + class: 84 /* SyntaxKind.ClassKeyword */, + continue: 86 /* SyntaxKind.ContinueKeyword */, + const: 85 /* SyntaxKind.ConstKeyword */ + }, + _a["" + "constructor"] = 135 /* SyntaxKind.ConstructorKeyword */, + _a.debugger = 87 /* SyntaxKind.DebuggerKeyword */, + _a.declare = 136 /* SyntaxKind.DeclareKeyword */, + _a.default = 88 /* SyntaxKind.DefaultKeyword */, + _a.delete = 89 /* SyntaxKind.DeleteKeyword */, + _a.do = 90 /* SyntaxKind.DoKeyword */, + _a.else = 91 /* SyntaxKind.ElseKeyword */, + _a.enum = 92 /* SyntaxKind.EnumKeyword */, + _a.export = 93 /* SyntaxKind.ExportKeyword */, + _a.extends = 94 /* SyntaxKind.ExtendsKeyword */, + _a.false = 95 /* SyntaxKind.FalseKeyword */, + _a.finally = 96 /* SyntaxKind.FinallyKeyword */, + _a.for = 97 /* SyntaxKind.ForKeyword */, + _a.from = 158 /* SyntaxKind.FromKeyword */, + _a.function = 98 /* SyntaxKind.FunctionKeyword */, + _a.get = 137 /* SyntaxKind.GetKeyword */, + _a.if = 99 /* SyntaxKind.IfKeyword */, + _a.implements = 117 /* SyntaxKind.ImplementsKeyword */, + _a.import = 100 /* SyntaxKind.ImportKeyword */, + _a.in = 101 /* SyntaxKind.InKeyword */, + _a.infer = 138 /* SyntaxKind.InferKeyword */, + _a.instanceof = 102 /* SyntaxKind.InstanceOfKeyword */, + _a.interface = 118 /* SyntaxKind.InterfaceKeyword */, + _a.intrinsic = 139 /* SyntaxKind.IntrinsicKeyword */, + _a.is = 140 /* SyntaxKind.IsKeyword */, + _a.keyof = 141 /* SyntaxKind.KeyOfKeyword */, + _a.let = 119 /* SyntaxKind.LetKeyword */, + _a.module = 142 /* SyntaxKind.ModuleKeyword */, + _a.namespace = 143 /* SyntaxKind.NamespaceKeyword */, + _a.never = 144 /* SyntaxKind.NeverKeyword */, + _a.new = 103 /* SyntaxKind.NewKeyword */, + _a.null = 104 /* SyntaxKind.NullKeyword */, + _a.number = 148 /* SyntaxKind.NumberKeyword */, + _a.object = 149 /* SyntaxKind.ObjectKeyword */, + _a.package = 120 /* SyntaxKind.PackageKeyword */, + _a.private = 121 /* SyntaxKind.PrivateKeyword */, + _a.protected = 122 /* SyntaxKind.ProtectedKeyword */, + _a.public = 123 /* SyntaxKind.PublicKeyword */, + _a.override = 161 /* SyntaxKind.OverrideKeyword */, + _a.out = 145 /* SyntaxKind.OutKeyword */, + _a.readonly = 146 /* SyntaxKind.ReadonlyKeyword */, + _a.require = 147 /* SyntaxKind.RequireKeyword */, + _a.global = 159 /* SyntaxKind.GlobalKeyword */, + _a.return = 105 /* SyntaxKind.ReturnKeyword */, + _a.satisfies = 150 /* SyntaxKind.SatisfiesKeyword */, + _a.set = 151 /* SyntaxKind.SetKeyword */, + _a.static = 124 /* SyntaxKind.StaticKeyword */, + _a.string = 152 /* SyntaxKind.StringKeyword */, + _a.super = 106 /* SyntaxKind.SuperKeyword */, + _a.switch = 107 /* SyntaxKind.SwitchKeyword */, + _a.symbol = 153 /* SyntaxKind.SymbolKeyword */, + _a.this = 108 /* SyntaxKind.ThisKeyword */, + _a.throw = 109 /* SyntaxKind.ThrowKeyword */, + _a.true = 110 /* SyntaxKind.TrueKeyword */, + _a.try = 111 /* SyntaxKind.TryKeyword */, + _a.type = 154 /* SyntaxKind.TypeKeyword */, + _a.typeof = 112 /* SyntaxKind.TypeOfKeyword */, + _a.undefined = 155 /* SyntaxKind.UndefinedKeyword */, + _a.unique = 156 /* SyntaxKind.UniqueKeyword */, + _a.unknown = 157 /* SyntaxKind.UnknownKeyword */, + _a.var = 113 /* SyntaxKind.VarKeyword */, + _a.void = 114 /* SyntaxKind.VoidKeyword */, + _a.while = 115 /* SyntaxKind.WhileKeyword */, + _a.with = 116 /* SyntaxKind.WithKeyword */, + _a.yield = 125 /* SyntaxKind.YieldKeyword */, + _a.async = 132 /* SyntaxKind.AsyncKeyword */, + _a.await = 133 /* SyntaxKind.AwaitKeyword */, + _a.of = 162 /* SyntaxKind.OfKeyword */, + _a); + var textToKeyword = new ts.Map(ts.getEntries(ts.textToKeywordObj)); + var textToToken = new ts.Map(ts.getEntries(__assign(__assign({}, ts.textToKeywordObj), { "{": 18 /* SyntaxKind.OpenBraceToken */, "}": 19 /* SyntaxKind.CloseBraceToken */, "(": 20 /* SyntaxKind.OpenParenToken */, ")": 21 /* SyntaxKind.CloseParenToken */, "[": 22 /* SyntaxKind.OpenBracketToken */, "]": 23 /* SyntaxKind.CloseBracketToken */, ".": 24 /* SyntaxKind.DotToken */, "...": 25 /* SyntaxKind.DotDotDotToken */, ";": 26 /* SyntaxKind.SemicolonToken */, ",": 27 /* SyntaxKind.CommaToken */, "<": 29 /* SyntaxKind.LessThanToken */, ">": 31 /* SyntaxKind.GreaterThanToken */, "<=": 32 /* SyntaxKind.LessThanEqualsToken */, ">=": 33 /* SyntaxKind.GreaterThanEqualsToken */, "==": 34 /* SyntaxKind.EqualsEqualsToken */, "!=": 35 /* SyntaxKind.ExclamationEqualsToken */, "===": 36 /* SyntaxKind.EqualsEqualsEqualsToken */, "!==": 37 /* SyntaxKind.ExclamationEqualsEqualsToken */, "=>": 38 /* SyntaxKind.EqualsGreaterThanToken */, "+": 39 /* SyntaxKind.PlusToken */, "-": 40 /* SyntaxKind.MinusToken */, "**": 42 /* SyntaxKind.AsteriskAsteriskToken */, "*": 41 /* SyntaxKind.AsteriskToken */, "/": 43 /* SyntaxKind.SlashToken */, "%": 44 /* SyntaxKind.PercentToken */, "++": 45 /* SyntaxKind.PlusPlusToken */, "--": 46 /* SyntaxKind.MinusMinusToken */, "<<": 47 /* SyntaxKind.LessThanLessThanToken */, ">": 48 /* SyntaxKind.GreaterThanGreaterThanToken */, ">>>": 49 /* SyntaxKind.GreaterThanGreaterThanGreaterThanToken */, "&": 50 /* SyntaxKind.AmpersandToken */, "|": 51 /* SyntaxKind.BarToken */, "^": 52 /* SyntaxKind.CaretToken */, "!": 53 /* SyntaxKind.ExclamationToken */, "~": 54 /* SyntaxKind.TildeToken */, "&&": 55 /* SyntaxKind.AmpersandAmpersandToken */, "||": 56 /* SyntaxKind.BarBarToken */, "?": 57 /* SyntaxKind.QuestionToken */, "??": 60 /* SyntaxKind.QuestionQuestionToken */, "?.": 28 /* SyntaxKind.QuestionDotToken */, ":": 58 /* SyntaxKind.ColonToken */, "=": 63 /* SyntaxKind.EqualsToken */, "+=": 64 /* SyntaxKind.PlusEqualsToken */, "-=": 65 /* SyntaxKind.MinusEqualsToken */, "*=": 66 /* SyntaxKind.AsteriskEqualsToken */, "**=": 67 /* SyntaxKind.AsteriskAsteriskEqualsToken */, "/=": 68 /* SyntaxKind.SlashEqualsToken */, "%=": 69 /* SyntaxKind.PercentEqualsToken */, "<<=": 70 /* SyntaxKind.LessThanLessThanEqualsToken */, ">>=": 71 /* SyntaxKind.GreaterThanGreaterThanEqualsToken */, ">>>=": 72 /* SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken */, "&=": 73 /* SyntaxKind.AmpersandEqualsToken */, "|=": 74 /* SyntaxKind.BarEqualsToken */, "^=": 78 /* SyntaxKind.CaretEqualsToken */, "||=": 75 /* SyntaxKind.BarBarEqualsToken */, "&&=": 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */, "??=": 77 /* SyntaxKind.QuestionQuestionEqualsToken */, "@": 59 /* SyntaxKind.AtToken */, "#": 62 /* SyntaxKind.HashToken */, "`": 61 /* SyntaxKind.BacktickToken */ }))); + /* + As per ECMAScript Language Specification 3th Edition, Section 7.6: Identifiers + IdentifierStart :: + Can contain Unicode 3.0.0 categories: + Uppercase letter (Lu), + Lowercase letter (Ll), + Titlecase letter (Lt), + Modifier letter (Lm), + Other letter (Lo), or + Letter number (Nl). + IdentifierPart :: = + Can contain IdentifierStart + Unicode 3.0.0 categories: + Non-spacing mark (Mn), + Combining spacing mark (Mc), + Decimal number (Nd), or + Connector punctuation (Pc). + + Codepoint ranges for ES3 Identifiers are extracted from the Unicode 3.0.0 specification at: + http://www.unicode.org/Public/3.0-Update/UnicodeData-3.0.0.txt + */ + var unicodeES3IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1610, 1649, 1747, 1749, 1749, 1765, 1766, 1786, 1788, 1808, 1808, 1810, 1836, 1920, 1957, 2309, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2784, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3294, 3294, 3296, 3297, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3424, 3425, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3805, 3840, 3840, 3904, 3911, 3913, 3946, 3976, 3979, 4096, 4129, 4131, 4135, 4137, 4138, 4176, 4181, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6067, 6176, 6263, 6272, 6312, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8319, 8319, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12346, 12353, 12436, 12445, 12446, 12449, 12538, 12540, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65138, 65140, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,]; + var unicodeES3IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 768, 846, 864, 866, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1155, 1158, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1441, 1443, 1465, 1467, 1469, 1471, 1471, 1473, 1474, 1476, 1476, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1621, 1632, 1641, 1648, 1747, 1749, 1756, 1759, 1768, 1770, 1773, 1776, 1788, 1808, 1836, 1840, 1866, 1920, 1968, 2305, 2307, 2309, 2361, 2364, 2381, 2384, 2388, 2392, 2403, 2406, 2415, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2492, 2494, 2500, 2503, 2504, 2507, 2509, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2562, 2562, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2649, 2652, 2654, 2654, 2662, 2676, 2689, 2691, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2784, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2876, 2883, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2913, 2918, 2927, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3031, 3031, 3047, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3134, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3168, 3169, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3262, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3297, 3302, 3311, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3390, 3395, 3398, 3400, 3402, 3405, 3415, 3415, 3424, 3425, 3430, 3439, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3805, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3946, 3953, 3972, 3974, 3979, 3984, 3991, 3993, 4028, 4038, 4038, 4096, 4129, 4131, 4135, 4137, 4138, 4140, 4146, 4150, 4153, 4160, 4169, 4176, 4185, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 4969, 4977, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6099, 6112, 6121, 6160, 6169, 6176, 6263, 6272, 6313, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8255, 8256, 8319, 8319, 8400, 8412, 8417, 8417, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12346, 12353, 12436, 12441, 12442, 12445, 12446, 12449, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65056, 65059, 65075, 65076, 65101, 65103, 65136, 65138, 65140, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65381, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,]; + /* + As per ECMAScript Language Specification 5th Edition, Section 7.6: ISyntaxToken Names and Identifiers + IdentifierStart :: + Can contain Unicode 6.2 categories: + Uppercase letter (Lu), + Lowercase letter (Ll), + Titlecase letter (Lt), + Modifier letter (Lm), + Other letter (Lo), or + Letter number (Nl). + IdentifierPart :: + Can contain IdentifierStart + Unicode 6.2 categories: + Non-spacing mark (Mn), + Combining spacing mark (Mc), + Decimal number (Nd), + Connector punctuation (Pc), + , or + . + + Codepoint ranges for ES5 Identifiers are extracted from the Unicode 6.2 specification at: + http://www.unicode.org/Public/6.2.0/ucd/UnicodeData.txt + */ + var unicodeES5IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2208, 2208, 2210, 2220, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2423, 2425, 2431, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3133, 3160, 3161, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3424, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6263, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6428, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7401, 7404, 7406, 7409, 7413, 7414, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11823, 11823, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42647, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43648, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,]; + var unicodeES5IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1488, 1514, 1520, 1522, 1552, 1562, 1568, 1641, 1646, 1747, 1749, 1756, 1759, 1768, 1770, 1788, 1791, 1791, 1808, 1866, 1869, 1969, 1984, 2037, 2042, 2042, 2048, 2093, 2112, 2139, 2208, 2208, 2210, 2220, 2276, 2302, 2304, 2403, 2406, 2415, 2417, 2423, 2425, 2431, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2561, 2563, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2652, 2654, 2654, 2662, 2677, 2689, 2691, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2787, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2915, 2918, 2927, 2929, 2929, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3024, 3024, 3031, 3031, 3046, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3160, 3161, 3168, 3171, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3260, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3299, 3302, 3311, 3313, 3314, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3396, 3398, 3400, 3402, 3406, 3415, 3415, 3424, 3427, 3430, 3439, 3450, 3455, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3807, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3948, 3953, 3972, 3974, 3991, 3993, 4028, 4038, 4038, 4096, 4169, 4176, 4253, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4957, 4959, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5908, 5920, 5940, 5952, 5971, 5984, 5996, 5998, 6000, 6002, 6003, 6016, 6099, 6103, 6103, 6108, 6109, 6112, 6121, 6155, 6157, 6160, 6169, 6176, 6263, 6272, 6314, 6320, 6389, 6400, 6428, 6432, 6443, 6448, 6459, 6470, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6617, 6656, 6683, 6688, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6823, 6823, 6912, 6987, 6992, 7001, 7019, 7027, 7040, 7155, 7168, 7223, 7232, 7241, 7245, 7293, 7376, 7378, 7380, 7414, 7424, 7654, 7676, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8204, 8205, 8255, 8256, 8276, 8276, 8305, 8305, 8319, 8319, 8336, 8348, 8400, 8412, 8417, 8417, 8421, 8432, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11647, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11744, 11775, 11823, 11823, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12348, 12353, 12438, 12441, 12442, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42539, 42560, 42607, 42612, 42621, 42623, 42647, 42655, 42737, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43047, 43072, 43123, 43136, 43204, 43216, 43225, 43232, 43255, 43259, 43259, 43264, 43309, 43312, 43347, 43360, 43388, 43392, 43456, 43471, 43481, 43520, 43574, 43584, 43597, 43600, 43609, 43616, 43638, 43642, 43643, 43648, 43714, 43739, 43741, 43744, 43759, 43762, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44010, 44012, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65024, 65039, 65056, 65062, 65075, 65076, 65101, 65103, 65136, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,]; + /** + * Generated by scripts/regenerate-unicode-identifier-parts.js on node v12.4.0 with unicode 12.1 + * based on http://www.unicode.org/reports/tr31/ and https://www.ecma-international.org/ecma-262/6.0/#sec-names-and-keywords + * unicodeESNextIdentifierStart corresponds to the ID_Start and Other_ID_Start property, and + * unicodeESNextIdentifierPart corresponds to ID_Continue, Other_ID_Continue, plus ID_Start and Other_ID_Start + */ + var unicodeESNextIdentifierStart = [65, 90, 97, 122, 170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 895, 895, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1327, 1329, 1366, 1369, 1369, 1376, 1416, 1488, 1514, 1519, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2144, 2154, 2208, 2228, 2230, 2237, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2432, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2556, 2556, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2809, 2809, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3129, 3133, 3133, 3160, 3162, 3168, 3169, 3200, 3200, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3412, 3414, 3423, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3718, 3722, 3724, 3747, 3749, 3749, 3751, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5109, 5112, 5117, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5880, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6264, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6430, 6480, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7296, 7304, 7312, 7354, 7357, 7359, 7401, 7404, 7406, 7411, 7413, 7414, 7418, 7418, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8472, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12443, 12447, 12449, 12538, 12540, 12543, 12549, 12591, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40943, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42653, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42943, 42946, 42950, 42999, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43261, 43262, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43488, 43492, 43494, 43503, 43514, 43518, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43646, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43824, 43866, 43868, 43879, 43888, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65536, 65547, 65549, 65574, 65576, 65594, 65596, 65597, 65599, 65613, 65616, 65629, 65664, 65786, 65856, 65908, 66176, 66204, 66208, 66256, 66304, 66335, 66349, 66378, 66384, 66421, 66432, 66461, 66464, 66499, 66504, 66511, 66513, 66517, 66560, 66717, 66736, 66771, 66776, 66811, 66816, 66855, 66864, 66915, 67072, 67382, 67392, 67413, 67424, 67431, 67584, 67589, 67592, 67592, 67594, 67637, 67639, 67640, 67644, 67644, 67647, 67669, 67680, 67702, 67712, 67742, 67808, 67826, 67828, 67829, 67840, 67861, 67872, 67897, 67968, 68023, 68030, 68031, 68096, 68096, 68112, 68115, 68117, 68119, 68121, 68149, 68192, 68220, 68224, 68252, 68288, 68295, 68297, 68324, 68352, 68405, 68416, 68437, 68448, 68466, 68480, 68497, 68608, 68680, 68736, 68786, 68800, 68850, 68864, 68899, 69376, 69404, 69415, 69415, 69424, 69445, 69600, 69622, 69635, 69687, 69763, 69807, 69840, 69864, 69891, 69926, 69956, 69956, 69968, 70002, 70006, 70006, 70019, 70066, 70081, 70084, 70106, 70106, 70108, 70108, 70144, 70161, 70163, 70187, 70272, 70278, 70280, 70280, 70282, 70285, 70287, 70301, 70303, 70312, 70320, 70366, 70405, 70412, 70415, 70416, 70419, 70440, 70442, 70448, 70450, 70451, 70453, 70457, 70461, 70461, 70480, 70480, 70493, 70497, 70656, 70708, 70727, 70730, 70751, 70751, 70784, 70831, 70852, 70853, 70855, 70855, 71040, 71086, 71128, 71131, 71168, 71215, 71236, 71236, 71296, 71338, 71352, 71352, 71424, 71450, 71680, 71723, 71840, 71903, 71935, 71935, 72096, 72103, 72106, 72144, 72161, 72161, 72163, 72163, 72192, 72192, 72203, 72242, 72250, 72250, 72272, 72272, 72284, 72329, 72349, 72349, 72384, 72440, 72704, 72712, 72714, 72750, 72768, 72768, 72818, 72847, 72960, 72966, 72968, 72969, 72971, 73008, 73030, 73030, 73056, 73061, 73063, 73064, 73066, 73097, 73112, 73112, 73440, 73458, 73728, 74649, 74752, 74862, 74880, 75075, 77824, 78894, 82944, 83526, 92160, 92728, 92736, 92766, 92880, 92909, 92928, 92975, 92992, 92995, 93027, 93047, 93053, 93071, 93760, 93823, 93952, 94026, 94032, 94032, 94099, 94111, 94176, 94177, 94179, 94179, 94208, 100343, 100352, 101106, 110592, 110878, 110928, 110930, 110948, 110951, 110960, 111355, 113664, 113770, 113776, 113788, 113792, 113800, 113808, 113817, 119808, 119892, 119894, 119964, 119966, 119967, 119970, 119970, 119973, 119974, 119977, 119980, 119982, 119993, 119995, 119995, 119997, 120003, 120005, 120069, 120071, 120074, 120077, 120084, 120086, 120092, 120094, 120121, 120123, 120126, 120128, 120132, 120134, 120134, 120138, 120144, 120146, 120485, 120488, 120512, 120514, 120538, 120540, 120570, 120572, 120596, 120598, 120628, 120630, 120654, 120656, 120686, 120688, 120712, 120714, 120744, 120746, 120770, 120772, 120779, 123136, 123180, 123191, 123197, 123214, 123214, 123584, 123627, 124928, 125124, 125184, 125251, 125259, 125259, 126464, 126467, 126469, 126495, 126497, 126498, 126500, 126500, 126503, 126503, 126505, 126514, 126516, 126519, 126521, 126521, 126523, 126523, 126530, 126530, 126535, 126535, 126537, 126537, 126539, 126539, 126541, 126543, 126545, 126546, 126548, 126548, 126551, 126551, 126553, 126553, 126555, 126555, 126557, 126557, 126559, 126559, 126561, 126562, 126564, 126564, 126567, 126570, 126572, 126578, 126580, 126583, 126585, 126588, 126590, 126590, 126592, 126601, 126603, 126619, 126625, 126627, 126629, 126633, 126635, 126651, 131072, 173782, 173824, 177972, 177984, 178205, 178208, 183969, 183984, 191456, 194560, 195101]; + var unicodeESNextIdentifierPart = [48, 57, 65, 90, 95, 95, 97, 122, 170, 170, 181, 181, 183, 183, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 895, 895, 902, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1327, 1329, 1366, 1369, 1369, 1376, 1416, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1488, 1514, 1519, 1522, 1552, 1562, 1568, 1641, 1646, 1747, 1749, 1756, 1759, 1768, 1770, 1788, 1791, 1791, 1808, 1866, 1869, 1969, 1984, 2037, 2042, 2042, 2045, 2045, 2048, 2093, 2112, 2139, 2144, 2154, 2208, 2228, 2230, 2237, 2259, 2273, 2275, 2403, 2406, 2415, 2417, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2556, 2556, 2558, 2558, 2561, 2563, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2652, 2654, 2654, 2662, 2677, 2689, 2691, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2787, 2790, 2799, 2809, 2815, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2915, 2918, 2927, 2929, 2929, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3024, 3024, 3031, 3031, 3046, 3055, 3072, 3084, 3086, 3088, 3090, 3112, 3114, 3129, 3133, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3160, 3162, 3168, 3171, 3174, 3183, 3200, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3260, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3299, 3302, 3311, 3313, 3314, 3328, 3331, 3333, 3340, 3342, 3344, 3346, 3396, 3398, 3400, 3402, 3406, 3412, 3415, 3423, 3427, 3430, 3439, 3450, 3455, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3558, 3567, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3718, 3722, 3724, 3747, 3749, 3749, 3751, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3807, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3948, 3953, 3972, 3974, 3991, 3993, 4028, 4038, 4038, 4096, 4169, 4176, 4253, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4957, 4959, 4969, 4977, 4992, 5007, 5024, 5109, 5112, 5117, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5880, 5888, 5900, 5902, 5908, 5920, 5940, 5952, 5971, 5984, 5996, 5998, 6000, 6002, 6003, 6016, 6099, 6103, 6103, 6108, 6109, 6112, 6121, 6155, 6157, 6160, 6169, 6176, 6264, 6272, 6314, 6320, 6389, 6400, 6430, 6432, 6443, 6448, 6459, 6470, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6618, 6656, 6683, 6688, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6823, 6823, 6832, 6845, 6912, 6987, 6992, 7001, 7019, 7027, 7040, 7155, 7168, 7223, 7232, 7241, 7245, 7293, 7296, 7304, 7312, 7354, 7357, 7359, 7376, 7378, 7380, 7418, 7424, 7673, 7675, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8255, 8256, 8276, 8276, 8305, 8305, 8319, 8319, 8336, 8348, 8400, 8412, 8417, 8417, 8421, 8432, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8472, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11647, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11744, 11775, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12348, 12353, 12438, 12441, 12447, 12449, 12538, 12540, 12543, 12549, 12591, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40943, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42539, 42560, 42607, 42612, 42621, 42623, 42737, 42775, 42783, 42786, 42888, 42891, 42943, 42946, 42950, 42999, 43047, 43072, 43123, 43136, 43205, 43216, 43225, 43232, 43255, 43259, 43259, 43261, 43309, 43312, 43347, 43360, 43388, 43392, 43456, 43471, 43481, 43488, 43518, 43520, 43574, 43584, 43597, 43600, 43609, 43616, 43638, 43642, 43714, 43739, 43741, 43744, 43759, 43762, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43824, 43866, 43868, 43879, 43888, 44010, 44012, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65024, 65039, 65056, 65071, 65075, 65076, 65101, 65103, 65136, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65536, 65547, 65549, 65574, 65576, 65594, 65596, 65597, 65599, 65613, 65616, 65629, 65664, 65786, 65856, 65908, 66045, 66045, 66176, 66204, 66208, 66256, 66272, 66272, 66304, 66335, 66349, 66378, 66384, 66426, 66432, 66461, 66464, 66499, 66504, 66511, 66513, 66517, 66560, 66717, 66720, 66729, 66736, 66771, 66776, 66811, 66816, 66855, 66864, 66915, 67072, 67382, 67392, 67413, 67424, 67431, 67584, 67589, 67592, 67592, 67594, 67637, 67639, 67640, 67644, 67644, 67647, 67669, 67680, 67702, 67712, 67742, 67808, 67826, 67828, 67829, 67840, 67861, 67872, 67897, 67968, 68023, 68030, 68031, 68096, 68099, 68101, 68102, 68108, 68115, 68117, 68119, 68121, 68149, 68152, 68154, 68159, 68159, 68192, 68220, 68224, 68252, 68288, 68295, 68297, 68326, 68352, 68405, 68416, 68437, 68448, 68466, 68480, 68497, 68608, 68680, 68736, 68786, 68800, 68850, 68864, 68903, 68912, 68921, 69376, 69404, 69415, 69415, 69424, 69456, 69600, 69622, 69632, 69702, 69734, 69743, 69759, 69818, 69840, 69864, 69872, 69881, 69888, 69940, 69942, 69951, 69956, 69958, 69968, 70003, 70006, 70006, 70016, 70084, 70089, 70092, 70096, 70106, 70108, 70108, 70144, 70161, 70163, 70199, 70206, 70206, 70272, 70278, 70280, 70280, 70282, 70285, 70287, 70301, 70303, 70312, 70320, 70378, 70384, 70393, 70400, 70403, 70405, 70412, 70415, 70416, 70419, 70440, 70442, 70448, 70450, 70451, 70453, 70457, 70459, 70468, 70471, 70472, 70475, 70477, 70480, 70480, 70487, 70487, 70493, 70499, 70502, 70508, 70512, 70516, 70656, 70730, 70736, 70745, 70750, 70751, 70784, 70853, 70855, 70855, 70864, 70873, 71040, 71093, 71096, 71104, 71128, 71133, 71168, 71232, 71236, 71236, 71248, 71257, 71296, 71352, 71360, 71369, 71424, 71450, 71453, 71467, 71472, 71481, 71680, 71738, 71840, 71913, 71935, 71935, 72096, 72103, 72106, 72151, 72154, 72161, 72163, 72164, 72192, 72254, 72263, 72263, 72272, 72345, 72349, 72349, 72384, 72440, 72704, 72712, 72714, 72758, 72760, 72768, 72784, 72793, 72818, 72847, 72850, 72871, 72873, 72886, 72960, 72966, 72968, 72969, 72971, 73014, 73018, 73018, 73020, 73021, 73023, 73031, 73040, 73049, 73056, 73061, 73063, 73064, 73066, 73102, 73104, 73105, 73107, 73112, 73120, 73129, 73440, 73462, 73728, 74649, 74752, 74862, 74880, 75075, 77824, 78894, 82944, 83526, 92160, 92728, 92736, 92766, 92768, 92777, 92880, 92909, 92912, 92916, 92928, 92982, 92992, 92995, 93008, 93017, 93027, 93047, 93053, 93071, 93760, 93823, 93952, 94026, 94031, 94087, 94095, 94111, 94176, 94177, 94179, 94179, 94208, 100343, 100352, 101106, 110592, 110878, 110928, 110930, 110948, 110951, 110960, 111355, 113664, 113770, 113776, 113788, 113792, 113800, 113808, 113817, 113821, 113822, 119141, 119145, 119149, 119154, 119163, 119170, 119173, 119179, 119210, 119213, 119362, 119364, 119808, 119892, 119894, 119964, 119966, 119967, 119970, 119970, 119973, 119974, 119977, 119980, 119982, 119993, 119995, 119995, 119997, 120003, 120005, 120069, 120071, 120074, 120077, 120084, 120086, 120092, 120094, 120121, 120123, 120126, 120128, 120132, 120134, 120134, 120138, 120144, 120146, 120485, 120488, 120512, 120514, 120538, 120540, 120570, 120572, 120596, 120598, 120628, 120630, 120654, 120656, 120686, 120688, 120712, 120714, 120744, 120746, 120770, 120772, 120779, 120782, 120831, 121344, 121398, 121403, 121452, 121461, 121461, 121476, 121476, 121499, 121503, 121505, 121519, 122880, 122886, 122888, 122904, 122907, 122913, 122915, 122916, 122918, 122922, 123136, 123180, 123184, 123197, 123200, 123209, 123214, 123214, 123584, 123641, 124928, 125124, 125136, 125142, 125184, 125259, 125264, 125273, 126464, 126467, 126469, 126495, 126497, 126498, 126500, 126500, 126503, 126503, 126505, 126514, 126516, 126519, 126521, 126521, 126523, 126523, 126530, 126530, 126535, 126535, 126537, 126537, 126539, 126539, 126541, 126543, 126545, 126546, 126548, 126548, 126551, 126551, 126553, 126553, 126555, 126555, 126557, 126557, 126559, 126559, 126561, 126562, 126564, 126564, 126567, 126570, 126572, 126578, 126580, 126583, 126585, 126588, 126590, 126590, 126592, 126601, 126603, 126619, 126625, 126627, 126629, 126633, 126635, 126651, 131072, 173782, 173824, 177972, 177984, 178205, 178208, 183969, 183984, 191456, 194560, 195101, 917760, 917999]; + /** + * Test for whether a single line comment with leading whitespace trimmed's text contains a directive. + */ + var commentDirectiveRegExSingleLine = /^\/\/\/?\s*@(ts-expect-error|ts-ignore)/; + /** + * Test for whether a multi-line comment with leading whitespace trimmed's last line contains a directive. + */ + var commentDirectiveRegExMultiLine = /^(?:\/|\*)*\s*@(ts-expect-error|ts-ignore)/; + function lookupInUnicodeMap(code, map) { + // Bail out quickly if it couldn't possibly be in the map. + if (code < map[0]) { + return false; + } + // Perform binary search in one of the Unicode range maps + var lo = 0; + var hi = map.length; + var mid; + while (lo + 1 < hi) { + mid = lo + (hi - lo) / 2; + // mid has to be even to catch a range's beginning + mid -= mid % 2; + if (map[mid] <= code && code <= map[mid + 1]) { + return true; + } + if (code < map[mid]) { + hi = mid; + } + else { + lo = mid + 2; + } + } + return false; + } + /* @internal */ function isUnicodeIdentifierStart(code, languageVersion) { + return languageVersion >= 2 /* ScriptTarget.ES2015 */ ? + lookupInUnicodeMap(code, unicodeESNextIdentifierStart) : + languageVersion === 1 /* ScriptTarget.ES5 */ ? lookupInUnicodeMap(code, unicodeES5IdentifierStart) : + lookupInUnicodeMap(code, unicodeES3IdentifierStart); + } + ts.isUnicodeIdentifierStart = isUnicodeIdentifierStart; + function isUnicodeIdentifierPart(code, languageVersion) { + return languageVersion >= 2 /* ScriptTarget.ES2015 */ ? + lookupInUnicodeMap(code, unicodeESNextIdentifierPart) : + languageVersion === 1 /* ScriptTarget.ES5 */ ? lookupInUnicodeMap(code, unicodeES5IdentifierPart) : + lookupInUnicodeMap(code, unicodeES3IdentifierPart); + } + function makeReverseMap(source) { + var result = []; + source.forEach(function (value, name) { + result[value] = name; + }); + return result; + } + var tokenStrings = makeReverseMap(textToToken); + function tokenToString(t) { + return tokenStrings[t]; + } + ts.tokenToString = tokenToString; + /* @internal */ + function stringToToken(s) { + return textToToken.get(s); + } + ts.stringToToken = stringToToken; + /* @internal */ + function computeLineStarts(text) { + var result = []; + var pos = 0; + var lineStart = 0; + while (pos < text.length) { + var ch = text.charCodeAt(pos); + pos++; + switch (ch) { + case 13 /* CharacterCodes.carriageReturn */: + if (text.charCodeAt(pos) === 10 /* CharacterCodes.lineFeed */) { + pos++; + } + // falls through + case 10 /* CharacterCodes.lineFeed */: + result.push(lineStart); + lineStart = pos; + break; + default: + if (ch > 127 /* CharacterCodes.maxAsciiCharacter */ && isLineBreak(ch)) { + result.push(lineStart); + lineStart = pos; + } + break; + } + } + result.push(lineStart); + return result; + } + ts.computeLineStarts = computeLineStarts; + function getPositionOfLineAndCharacter(sourceFile, line, character, allowEdits) { + return sourceFile.getPositionOfLineAndCharacter ? + sourceFile.getPositionOfLineAndCharacter(line, character, allowEdits) : + computePositionOfLineAndCharacter(getLineStarts(sourceFile), line, character, sourceFile.text, allowEdits); + } + ts.getPositionOfLineAndCharacter = getPositionOfLineAndCharacter; + /* @internal */ + function computePositionOfLineAndCharacter(lineStarts, line, character, debugText, allowEdits) { + if (line < 0 || line >= lineStarts.length) { + if (allowEdits) { + // Clamp line to nearest allowable value + line = line < 0 ? 0 : line >= lineStarts.length ? lineStarts.length - 1 : line; + } + else { + ts.Debug.fail("Bad line number. Line: ".concat(line, ", lineStarts.length: ").concat(lineStarts.length, " , line map is correct? ").concat(debugText !== undefined ? ts.arraysEqual(lineStarts, computeLineStarts(debugText)) : "unknown")); + } + } + var res = lineStarts[line] + character; + if (allowEdits) { + // Clamp to nearest allowable values to allow the underlying to be edited without crashing (accuracy is lost, instead) + // TODO: Somehow track edits between file as it was during the creation of sourcemap we have and the current file and + // apply them to the computed position to improve accuracy + return res > lineStarts[line + 1] ? lineStarts[line + 1] : typeof debugText === "string" && res > debugText.length ? debugText.length : res; + } + if (line < lineStarts.length - 1) { + ts.Debug.assert(res < lineStarts[line + 1]); + } + else if (debugText !== undefined) { + ts.Debug.assert(res <= debugText.length); // Allow single character overflow for trailing newline + } + return res; + } + ts.computePositionOfLineAndCharacter = computePositionOfLineAndCharacter; + /* @internal */ + function getLineStarts(sourceFile) { + return sourceFile.lineMap || (sourceFile.lineMap = computeLineStarts(sourceFile.text)); + } + ts.getLineStarts = getLineStarts; + /* @internal */ + function computeLineAndCharacterOfPosition(lineStarts, position) { + var lineNumber = computeLineOfPosition(lineStarts, position); + return { + line: lineNumber, + character: position - lineStarts[lineNumber] + }; + } + ts.computeLineAndCharacterOfPosition = computeLineAndCharacterOfPosition; + /** + * @internal + * We assume the first line starts at position 0 and 'position' is non-negative. + */ + function computeLineOfPosition(lineStarts, position, lowerBound) { + var lineNumber = ts.binarySearch(lineStarts, position, ts.identity, ts.compareValues, lowerBound); + if (lineNumber < 0) { + // If the actual position was not found, + // the binary search returns the 2's-complement of the next line start + // e.g. if the line starts at [5, 10, 23, 80] and the position requested was 20 + // then the search will return -2. + // + // We want the index of the previous line start, so we subtract 1. + // Review 2's-complement if this is confusing. + lineNumber = ~lineNumber - 1; + ts.Debug.assert(lineNumber !== -1, "position cannot precede the beginning of the file"); + } + return lineNumber; + } + ts.computeLineOfPosition = computeLineOfPosition; + /** @internal */ + function getLinesBetweenPositions(sourceFile, pos1, pos2) { + if (pos1 === pos2) + return 0; + var lineStarts = getLineStarts(sourceFile); + var lower = Math.min(pos1, pos2); + var isNegative = lower === pos2; + var upper = isNegative ? pos1 : pos2; + var lowerLine = computeLineOfPosition(lineStarts, lower); + var upperLine = computeLineOfPosition(lineStarts, upper, lowerLine); + return isNegative ? lowerLine - upperLine : upperLine - lowerLine; + } + ts.getLinesBetweenPositions = getLinesBetweenPositions; + function getLineAndCharacterOfPosition(sourceFile, position) { + return computeLineAndCharacterOfPosition(getLineStarts(sourceFile), position); + } + ts.getLineAndCharacterOfPosition = getLineAndCharacterOfPosition; + function isWhiteSpaceLike(ch) { + return isWhiteSpaceSingleLine(ch) || isLineBreak(ch); + } + ts.isWhiteSpaceLike = isWhiteSpaceLike; + /** Does not include line breaks. For that, see isWhiteSpaceLike. */ + function isWhiteSpaceSingleLine(ch) { + // Note: nextLine is in the Zs space, and should be considered to be a whitespace. + // It is explicitly not a line-break as it isn't in the exact set specified by EcmaScript. + return ch === 32 /* CharacterCodes.space */ || + ch === 9 /* CharacterCodes.tab */ || + ch === 11 /* CharacterCodes.verticalTab */ || + ch === 12 /* CharacterCodes.formFeed */ || + ch === 160 /* CharacterCodes.nonBreakingSpace */ || + ch === 133 /* CharacterCodes.nextLine */ || + ch === 5760 /* CharacterCodes.ogham */ || + ch >= 8192 /* CharacterCodes.enQuad */ && ch <= 8203 /* CharacterCodes.zeroWidthSpace */ || + ch === 8239 /* CharacterCodes.narrowNoBreakSpace */ || + ch === 8287 /* CharacterCodes.mathematicalSpace */ || + ch === 12288 /* CharacterCodes.ideographicSpace */ || + ch === 65279 /* CharacterCodes.byteOrderMark */; + } + ts.isWhiteSpaceSingleLine = isWhiteSpaceSingleLine; + function isLineBreak(ch) { + // ES5 7.3: + // The ECMAScript line terminator characters are listed in Table 3. + // Table 3: Line Terminator Characters + // Code Unit Value Name Formal Name + // \u000A Line Feed + // \u000D Carriage Return + // \u2028 Line separator + // \u2029 Paragraph separator + // Only the characters in Table 3 are treated as line terminators. Other new line or line + // breaking characters are treated as white space but not as line terminators. + return ch === 10 /* CharacterCodes.lineFeed */ || + ch === 13 /* CharacterCodes.carriageReturn */ || + ch === 8232 /* CharacterCodes.lineSeparator */ || + ch === 8233 /* CharacterCodes.paragraphSeparator */; + } + ts.isLineBreak = isLineBreak; + function isDigit(ch) { + return ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */; + } + function isHexDigit(ch) { + return isDigit(ch) || ch >= 65 /* CharacterCodes.A */ && ch <= 70 /* CharacterCodes.F */ || ch >= 97 /* CharacterCodes.a */ && ch <= 102 /* CharacterCodes.f */; + } + function isCodePoint(code) { + return code <= 0x10FFFF; + } + /* @internal */ + function isOctalDigit(ch) { + return ch >= 48 /* CharacterCodes._0 */ && ch <= 55 /* CharacterCodes._7 */; + } + ts.isOctalDigit = isOctalDigit; + function couldStartTrivia(text, pos) { + // Keep in sync with skipTrivia + var ch = text.charCodeAt(pos); + switch (ch) { + case 13 /* CharacterCodes.carriageReturn */: + case 10 /* CharacterCodes.lineFeed */: + case 9 /* CharacterCodes.tab */: + case 11 /* CharacterCodes.verticalTab */: + case 12 /* CharacterCodes.formFeed */: + case 32 /* CharacterCodes.space */: + case 47 /* CharacterCodes.slash */: + // starts of normal trivia + // falls through + case 60 /* CharacterCodes.lessThan */: + case 124 /* CharacterCodes.bar */: + case 61 /* CharacterCodes.equals */: + case 62 /* CharacterCodes.greaterThan */: + // Starts of conflict marker trivia + return true; + case 35 /* CharacterCodes.hash */: + // Only if its the beginning can we have #! trivia + return pos === 0; + default: + return ch > 127 /* CharacterCodes.maxAsciiCharacter */; + } + } + ts.couldStartTrivia = couldStartTrivia; + /* @internal */ + function skipTrivia(text, pos, stopAfterLineBreak, stopAtComments, inJSDoc) { + if (ts.positionIsSynthesized(pos)) { + return pos; + } + var canConsumeStar = false; + // Keep in sync with couldStartTrivia + while (true) { + var ch = text.charCodeAt(pos); + switch (ch) { + case 13 /* CharacterCodes.carriageReturn */: + if (text.charCodeAt(pos + 1) === 10 /* CharacterCodes.lineFeed */) { + pos++; + } + // falls through + case 10 /* CharacterCodes.lineFeed */: + pos++; + if (stopAfterLineBreak) { + return pos; + } + canConsumeStar = !!inJSDoc; + continue; + case 9 /* CharacterCodes.tab */: + case 11 /* CharacterCodes.verticalTab */: + case 12 /* CharacterCodes.formFeed */: + case 32 /* CharacterCodes.space */: + pos++; + continue; + case 47 /* CharacterCodes.slash */: + if (stopAtComments) { + break; + } + if (text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */) { + pos += 2; + while (pos < text.length) { + if (isLineBreak(text.charCodeAt(pos))) { + break; + } + pos++; + } + canConsumeStar = false; + continue; + } + if (text.charCodeAt(pos + 1) === 42 /* CharacterCodes.asterisk */) { + pos += 2; + while (pos < text.length) { + if (text.charCodeAt(pos) === 42 /* CharacterCodes.asterisk */ && text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */) { + pos += 2; + break; + } + pos++; + } + canConsumeStar = false; + continue; + } + break; + case 60 /* CharacterCodes.lessThan */: + case 124 /* CharacterCodes.bar */: + case 61 /* CharacterCodes.equals */: + case 62 /* CharacterCodes.greaterThan */: + if (isConflictMarkerTrivia(text, pos)) { + pos = scanConflictMarkerTrivia(text, pos); + canConsumeStar = false; + continue; + } + break; + case 35 /* CharacterCodes.hash */: + if (pos === 0 && isShebangTrivia(text, pos)) { + pos = scanShebangTrivia(text, pos); + canConsumeStar = false; + continue; + } + break; + case 42 /* CharacterCodes.asterisk */: + if (canConsumeStar) { + pos++; + canConsumeStar = false; + continue; + } + break; + default: + if (ch > 127 /* CharacterCodes.maxAsciiCharacter */ && (isWhiteSpaceLike(ch))) { + pos++; + continue; + } + break; + } + return pos; + } + } + ts.skipTrivia = skipTrivia; + // All conflict markers consist of the same character repeated seven times. If it is + // a <<<<<<< or >>>>>>> marker then it is also followed by a space. + var mergeConflictMarkerLength = "<<<<<<<".length; + function isConflictMarkerTrivia(text, pos) { + ts.Debug.assert(pos >= 0); + // Conflict markers must be at the start of a line. + if (pos === 0 || isLineBreak(text.charCodeAt(pos - 1))) { + var ch = text.charCodeAt(pos); + if ((pos + mergeConflictMarkerLength) < text.length) { + for (var i = 0; i < mergeConflictMarkerLength; i++) { + if (text.charCodeAt(pos + i) !== ch) { + return false; + } + } + return ch === 61 /* CharacterCodes.equals */ || + text.charCodeAt(pos + mergeConflictMarkerLength) === 32 /* CharacterCodes.space */; + } + } + return false; + } + function scanConflictMarkerTrivia(text, pos, error) { + if (error) { + error(ts.Diagnostics.Merge_conflict_marker_encountered, pos, mergeConflictMarkerLength); + } + var ch = text.charCodeAt(pos); + var len = text.length; + if (ch === 60 /* CharacterCodes.lessThan */ || ch === 62 /* CharacterCodes.greaterThan */) { + while (pos < len && !isLineBreak(text.charCodeAt(pos))) { + pos++; + } + } + else { + ts.Debug.assert(ch === 124 /* CharacterCodes.bar */ || ch === 61 /* CharacterCodes.equals */); + // Consume everything from the start of a ||||||| or ======= marker to the start + // of the next ======= or >>>>>>> marker. + while (pos < len) { + var currentChar = text.charCodeAt(pos); + if ((currentChar === 61 /* CharacterCodes.equals */ || currentChar === 62 /* CharacterCodes.greaterThan */) && currentChar !== ch && isConflictMarkerTrivia(text, pos)) { + break; + } + pos++; + } + } + return pos; + } + var shebangTriviaRegex = /^#!.*/; + /*@internal*/ + function isShebangTrivia(text, pos) { + // Shebangs check must only be done at the start of the file + ts.Debug.assert(pos === 0); + return shebangTriviaRegex.test(text); + } + ts.isShebangTrivia = isShebangTrivia; + /*@internal*/ + function scanShebangTrivia(text, pos) { + var shebang = shebangTriviaRegex.exec(text)[0]; + pos = pos + shebang.length; + return pos; + } + ts.scanShebangTrivia = scanShebangTrivia; + /** + * Invokes a callback for each comment range following the provided position. + * + * Single-line comment ranges include the leading double-slash characters but not the ending + * line break. Multi-line comment ranges include the leading slash-asterisk and trailing + * asterisk-slash characters. + * + * @param reduce If true, accumulates the result of calling the callback in a fashion similar + * to reduceLeft. If false, iteration stops when the callback returns a truthy value. + * @param text The source text to scan. + * @param pos The position at which to start scanning. + * @param trailing If false, whitespace is skipped until the first line break and comments + * between that location and the next token are returned. If true, comments occurring + * between the given position and the next line break are returned. + * @param cb The callback to execute as each comment range is encountered. + * @param state A state value to pass to each iteration of the callback. + * @param initial An initial value to pass when accumulating results (when "reduce" is true). + * @returns If "reduce" is true, the accumulated value. If "reduce" is false, the first truthy + * return value of the callback. + */ + function iterateCommentRanges(reduce, text, pos, trailing, cb, state, initial) { + var pendingPos; + var pendingEnd; + var pendingKind; + var pendingHasTrailingNewLine; + var hasPendingCommentRange = false; + var collecting = trailing; + var accumulator = initial; + if (pos === 0) { + collecting = true; + var shebang = getShebang(text); + if (shebang) { + pos = shebang.length; + } + } + scan: while (pos >= 0 && pos < text.length) { + var ch = text.charCodeAt(pos); + switch (ch) { + case 13 /* CharacterCodes.carriageReturn */: + if (text.charCodeAt(pos + 1) === 10 /* CharacterCodes.lineFeed */) { + pos++; + } + // falls through + case 10 /* CharacterCodes.lineFeed */: + pos++; + if (trailing) { + break scan; + } + collecting = true; + if (hasPendingCommentRange) { + pendingHasTrailingNewLine = true; + } + continue; + case 9 /* CharacterCodes.tab */: + case 11 /* CharacterCodes.verticalTab */: + case 12 /* CharacterCodes.formFeed */: + case 32 /* CharacterCodes.space */: + pos++; + continue; + case 47 /* CharacterCodes.slash */: + var nextChar = text.charCodeAt(pos + 1); + var hasTrailingNewLine = false; + if (nextChar === 47 /* CharacterCodes.slash */ || nextChar === 42 /* CharacterCodes.asterisk */) { + var kind = nextChar === 47 /* CharacterCodes.slash */ ? 2 /* SyntaxKind.SingleLineCommentTrivia */ : 3 /* SyntaxKind.MultiLineCommentTrivia */; + var startPos = pos; + pos += 2; + if (nextChar === 47 /* CharacterCodes.slash */) { + while (pos < text.length) { + if (isLineBreak(text.charCodeAt(pos))) { + hasTrailingNewLine = true; + break; + } + pos++; + } + } + else { + while (pos < text.length) { + if (text.charCodeAt(pos) === 42 /* CharacterCodes.asterisk */ && text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */) { + pos += 2; + break; + } + pos++; + } + } + if (collecting) { + if (hasPendingCommentRange) { + accumulator = cb(pendingPos, pendingEnd, pendingKind, pendingHasTrailingNewLine, state, accumulator); + if (!reduce && accumulator) { + // If we are not reducing and we have a truthy result, return it. + return accumulator; + } + } + pendingPos = startPos; + pendingEnd = pos; + pendingKind = kind; + pendingHasTrailingNewLine = hasTrailingNewLine; + hasPendingCommentRange = true; + } + continue; + } + break scan; + default: + if (ch > 127 /* CharacterCodes.maxAsciiCharacter */ && (isWhiteSpaceLike(ch))) { + if (hasPendingCommentRange && isLineBreak(ch)) { + pendingHasTrailingNewLine = true; + } + pos++; + continue; + } + break scan; + } + } + if (hasPendingCommentRange) { + accumulator = cb(pendingPos, pendingEnd, pendingKind, pendingHasTrailingNewLine, state, accumulator); + } + return accumulator; + } + function forEachLeadingCommentRange(text, pos, cb, state) { + return iterateCommentRanges(/*reduce*/ false, text, pos, /*trailing*/ false, cb, state); + } + ts.forEachLeadingCommentRange = forEachLeadingCommentRange; + function forEachTrailingCommentRange(text, pos, cb, state) { + return iterateCommentRanges(/*reduce*/ false, text, pos, /*trailing*/ true, cb, state); + } + ts.forEachTrailingCommentRange = forEachTrailingCommentRange; + function reduceEachLeadingCommentRange(text, pos, cb, state, initial) { + return iterateCommentRanges(/*reduce*/ true, text, pos, /*trailing*/ false, cb, state, initial); + } + ts.reduceEachLeadingCommentRange = reduceEachLeadingCommentRange; + function reduceEachTrailingCommentRange(text, pos, cb, state, initial) { + return iterateCommentRanges(/*reduce*/ true, text, pos, /*trailing*/ true, cb, state, initial); + } + ts.reduceEachTrailingCommentRange = reduceEachTrailingCommentRange; + function appendCommentRange(pos, end, kind, hasTrailingNewLine, _state, comments) { + if (!comments) { + comments = []; + } + comments.push({ kind: kind, pos: pos, end: end, hasTrailingNewLine: hasTrailingNewLine }); + return comments; + } + function getLeadingCommentRanges(text, pos) { + return reduceEachLeadingCommentRange(text, pos, appendCommentRange, /*state*/ undefined, /*initial*/ undefined); + } + ts.getLeadingCommentRanges = getLeadingCommentRanges; + function getTrailingCommentRanges(text, pos) { + return reduceEachTrailingCommentRange(text, pos, appendCommentRange, /*state*/ undefined, /*initial*/ undefined); + } + ts.getTrailingCommentRanges = getTrailingCommentRanges; + /** Optionally, get the shebang */ + function getShebang(text) { + var match = shebangTriviaRegex.exec(text); + if (match) { + return match[0]; + } + } + ts.getShebang = getShebang; + function isIdentifierStart(ch, languageVersion) { + return ch >= 65 /* CharacterCodes.A */ && ch <= 90 /* CharacterCodes.Z */ || ch >= 97 /* CharacterCodes.a */ && ch <= 122 /* CharacterCodes.z */ || + ch === 36 /* CharacterCodes.$ */ || ch === 95 /* CharacterCodes._ */ || + ch > 127 /* CharacterCodes.maxAsciiCharacter */ && isUnicodeIdentifierStart(ch, languageVersion); + } + ts.isIdentifierStart = isIdentifierStart; + function isIdentifierPart(ch, languageVersion, identifierVariant) { + return ch >= 65 /* CharacterCodes.A */ && ch <= 90 /* CharacterCodes.Z */ || ch >= 97 /* CharacterCodes.a */ && ch <= 122 /* CharacterCodes.z */ || + ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */ || ch === 36 /* CharacterCodes.$ */ || ch === 95 /* CharacterCodes._ */ || + // "-" and ":" are valid in JSX Identifiers + (identifierVariant === 1 /* LanguageVariant.JSX */ ? (ch === 45 /* CharacterCodes.minus */ || ch === 58 /* CharacterCodes.colon */) : false) || + ch > 127 /* CharacterCodes.maxAsciiCharacter */ && isUnicodeIdentifierPart(ch, languageVersion); + } + ts.isIdentifierPart = isIdentifierPart; + /* @internal */ + function isIdentifierText(name, languageVersion, identifierVariant) { + var ch = codePointAt(name, 0); + if (!isIdentifierStart(ch, languageVersion)) { + return false; + } + for (var i = charSize(ch); i < name.length; i += charSize(ch)) { + if (!isIdentifierPart(ch = codePointAt(name, i), languageVersion, identifierVariant)) { + return false; + } + } + return true; + } + ts.isIdentifierText = isIdentifierText; + // Creates a scanner over a (possibly unspecified) range of a piece of text. + function createScanner(languageVersion, skipTrivia, languageVariant, textInitial, onError, start, length) { + if (languageVariant === void 0) { languageVariant = 0 /* LanguageVariant.Standard */; } + var text = textInitial; + // Current position (end position of text of current token) + var pos; + // end of text + var end; + // Start position of whitespace before current token + var startPos; + // Start position of text of current token + var tokenPos; + var token; + var tokenValue; + var tokenFlags; + var commentDirectives; + var inJSDocType = 0; + setText(text, start, length); + var scanner = { + getStartPos: function () { return startPos; }, + getTextPos: function () { return pos; }, + getToken: function () { return token; }, + getTokenPos: function () { return tokenPos; }, + getTokenText: function () { return text.substring(tokenPos, pos); }, + getTokenValue: function () { return tokenValue; }, + hasUnicodeEscape: function () { return (tokenFlags & 1024 /* TokenFlags.UnicodeEscape */) !== 0; }, + hasExtendedUnicodeEscape: function () { return (tokenFlags & 8 /* TokenFlags.ExtendedUnicodeEscape */) !== 0; }, + hasPrecedingLineBreak: function () { return (tokenFlags & 1 /* TokenFlags.PrecedingLineBreak */) !== 0; }, + hasPrecedingJSDocComment: function () { return (tokenFlags & 2 /* TokenFlags.PrecedingJSDocComment */) !== 0; }, + isIdentifier: function () { return token === 79 /* SyntaxKind.Identifier */ || token > 116 /* SyntaxKind.LastReservedWord */; }, + isReservedWord: function () { return token >= 81 /* SyntaxKind.FirstReservedWord */ && token <= 116 /* SyntaxKind.LastReservedWord */; }, + isUnterminated: function () { return (tokenFlags & 4 /* TokenFlags.Unterminated */) !== 0; }, + getCommentDirectives: function () { return commentDirectives; }, + getNumericLiteralFlags: function () { return tokenFlags & 1008 /* TokenFlags.NumericLiteralFlags */; }, + getTokenFlags: function () { return tokenFlags; }, + reScanGreaterToken: reScanGreaterToken, + reScanAsteriskEqualsToken: reScanAsteriskEqualsToken, + reScanSlashToken: reScanSlashToken, + reScanTemplateToken: reScanTemplateToken, + reScanTemplateHeadOrNoSubstitutionTemplate: reScanTemplateHeadOrNoSubstitutionTemplate, + scanJsxIdentifier: scanJsxIdentifier, + scanJsxAttributeValue: scanJsxAttributeValue, + reScanJsxAttributeValue: reScanJsxAttributeValue, + reScanJsxToken: reScanJsxToken, + reScanLessThanToken: reScanLessThanToken, + reScanHashToken: reScanHashToken, + reScanQuestionToken: reScanQuestionToken, + reScanInvalidIdentifier: reScanInvalidIdentifier, + scanJsxToken: scanJsxToken, + scanJsDocToken: scanJsDocToken, + scan: scan, + getText: getText, + clearCommentDirectives: clearCommentDirectives, + setText: setText, + setScriptTarget: setScriptTarget, + setLanguageVariant: setLanguageVariant, + setOnError: setOnError, + setTextPos: setTextPos, + setInJSDocType: setInJSDocType, + tryScan: tryScan, + lookAhead: lookAhead, + scanRange: scanRange, + }; + if (ts.Debug.isDebugging) { + Object.defineProperty(scanner, "__debugShowCurrentPositionInText", { + get: function () { + var text = scanner.getText(); + return text.slice(0, scanner.getStartPos()) + "║" + text.slice(scanner.getStartPos()); + }, + }); + } + return scanner; + function error(message, errPos, length) { + if (errPos === void 0) { errPos = pos; } + if (onError) { + var oldPos = pos; + pos = errPos; + onError(message, length || 0); + pos = oldPos; + } + } + function scanNumberFragment() { + var start = pos; + var allowSeparator = false; + var isPreviousTokenSeparator = false; + var result = ""; + while (true) { + var ch = text.charCodeAt(pos); + if (ch === 95 /* CharacterCodes._ */) { + tokenFlags |= 512 /* TokenFlags.ContainsSeparator */; + if (allowSeparator) { + allowSeparator = false; + isPreviousTokenSeparator = true; + result += text.substring(start, pos); + } + else if (isPreviousTokenSeparator) { + error(ts.Diagnostics.Multiple_consecutive_numeric_separators_are_not_permitted, pos, 1); + } + else { + error(ts.Diagnostics.Numeric_separators_are_not_allowed_here, pos, 1); + } + pos++; + start = pos; + continue; + } + if (isDigit(ch)) { + allowSeparator = true; + isPreviousTokenSeparator = false; + pos++; + continue; + } + break; + } + if (text.charCodeAt(pos - 1) === 95 /* CharacterCodes._ */) { + error(ts.Diagnostics.Numeric_separators_are_not_allowed_here, pos - 1, 1); + } + return result + text.substring(start, pos); + } + function scanNumber() { + var start = pos; + var mainFragment = scanNumberFragment(); + var decimalFragment; + var scientificFragment; + if (text.charCodeAt(pos) === 46 /* CharacterCodes.dot */) { + pos++; + decimalFragment = scanNumberFragment(); + } + var end = pos; + if (text.charCodeAt(pos) === 69 /* CharacterCodes.E */ || text.charCodeAt(pos) === 101 /* CharacterCodes.e */) { + pos++; + tokenFlags |= 16 /* TokenFlags.Scientific */; + if (text.charCodeAt(pos) === 43 /* CharacterCodes.plus */ || text.charCodeAt(pos) === 45 /* CharacterCodes.minus */) + pos++; + var preNumericPart = pos; + var finalFragment = scanNumberFragment(); + if (!finalFragment) { + error(ts.Diagnostics.Digit_expected); + } + else { + scientificFragment = text.substring(end, preNumericPart) + finalFragment; + end = pos; + } + } + var result; + if (tokenFlags & 512 /* TokenFlags.ContainsSeparator */) { + result = mainFragment; + if (decimalFragment) { + result += "." + decimalFragment; + } + if (scientificFragment) { + result += scientificFragment; + } + } + else { + result = text.substring(start, end); // No need to use all the fragments; no _ removal needed + } + if (decimalFragment !== undefined || tokenFlags & 16 /* TokenFlags.Scientific */) { + checkForIdentifierStartAfterNumericLiteral(start, decimalFragment === undefined && !!(tokenFlags & 16 /* TokenFlags.Scientific */)); + return { + type: 8 /* SyntaxKind.NumericLiteral */, + value: "" + +result // if value is not an integer, it can be safely coerced to a number + }; + } + else { + tokenValue = result; + var type = checkBigIntSuffix(); // if value is an integer, check whether it is a bigint + checkForIdentifierStartAfterNumericLiteral(start); + return { type: type, value: tokenValue }; + } + } + function checkForIdentifierStartAfterNumericLiteral(numericStart, isScientific) { + if (!isIdentifierStart(codePointAt(text, pos), languageVersion)) { + return; + } + var identifierStart = pos; + var length = scanIdentifierParts().length; + if (length === 1 && text[identifierStart] === "n") { + if (isScientific) { + error(ts.Diagnostics.A_bigint_literal_cannot_use_exponential_notation, numericStart, identifierStart - numericStart + 1); + } + else { + error(ts.Diagnostics.A_bigint_literal_must_be_an_integer, numericStart, identifierStart - numericStart + 1); + } + } + else { + error(ts.Diagnostics.An_identifier_or_keyword_cannot_immediately_follow_a_numeric_literal, identifierStart, length); + pos = identifierStart; + } + } + function scanOctalDigits() { + var start = pos; + while (isOctalDigit(text.charCodeAt(pos))) { + pos++; + } + return +(text.substring(start, pos)); + } + /** + * Scans the given number of hexadecimal digits in the text, + * returning -1 if the given number is unavailable. + */ + function scanExactNumberOfHexDigits(count, canHaveSeparators) { + var valueString = scanHexDigits(/*minCount*/ count, /*scanAsManyAsPossible*/ false, canHaveSeparators); + return valueString ? parseInt(valueString, 16) : -1; + } + /** + * Scans as many hexadecimal digits as are available in the text, + * returning "" if the given number of digits was unavailable. + */ + function scanMinimumNumberOfHexDigits(count, canHaveSeparators) { + return scanHexDigits(/*minCount*/ count, /*scanAsManyAsPossible*/ true, canHaveSeparators); + } + function scanHexDigits(minCount, scanAsManyAsPossible, canHaveSeparators) { + var valueChars = []; + var allowSeparator = false; + var isPreviousTokenSeparator = false; + while (valueChars.length < minCount || scanAsManyAsPossible) { + var ch = text.charCodeAt(pos); + if (canHaveSeparators && ch === 95 /* CharacterCodes._ */) { + tokenFlags |= 512 /* TokenFlags.ContainsSeparator */; + if (allowSeparator) { + allowSeparator = false; + isPreviousTokenSeparator = true; + } + else if (isPreviousTokenSeparator) { + error(ts.Diagnostics.Multiple_consecutive_numeric_separators_are_not_permitted, pos, 1); + } + else { + error(ts.Diagnostics.Numeric_separators_are_not_allowed_here, pos, 1); + } + pos++; + continue; + } + allowSeparator = canHaveSeparators; + if (ch >= 65 /* CharacterCodes.A */ && ch <= 70 /* CharacterCodes.F */) { + ch += 97 /* CharacterCodes.a */ - 65 /* CharacterCodes.A */; // standardize hex literals to lowercase + } + else if (!((ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */) || + (ch >= 97 /* CharacterCodes.a */ && ch <= 102 /* CharacterCodes.f */))) { + break; + } + valueChars.push(ch); + pos++; + isPreviousTokenSeparator = false; + } + if (valueChars.length < minCount) { + valueChars = []; + } + if (text.charCodeAt(pos - 1) === 95 /* CharacterCodes._ */) { + error(ts.Diagnostics.Numeric_separators_are_not_allowed_here, pos - 1, 1); + } + return String.fromCharCode.apply(String, valueChars); + } + function scanString(jsxAttributeString) { + if (jsxAttributeString === void 0) { jsxAttributeString = false; } + var quote = text.charCodeAt(pos); + pos++; + var result = ""; + var start = pos; + while (true) { + if (pos >= end) { + result += text.substring(start, pos); + tokenFlags |= 4 /* TokenFlags.Unterminated */; + error(ts.Diagnostics.Unterminated_string_literal); + break; + } + var ch = text.charCodeAt(pos); + if (ch === quote) { + result += text.substring(start, pos); + pos++; + break; + } + if (ch === 92 /* CharacterCodes.backslash */ && !jsxAttributeString) { + result += text.substring(start, pos); + result += scanEscapeSequence(); + start = pos; + continue; + } + if (isLineBreak(ch) && !jsxAttributeString) { + result += text.substring(start, pos); + tokenFlags |= 4 /* TokenFlags.Unterminated */; + error(ts.Diagnostics.Unterminated_string_literal); + break; + } + pos++; + } + return result; + } + /** + * Sets the current 'tokenValue' and returns a NoSubstitutionTemplateLiteral or + * a literal component of a TemplateExpression. + */ + function scanTemplateAndSetTokenValue(isTaggedTemplate) { + var startedWithBacktick = text.charCodeAt(pos) === 96 /* CharacterCodes.backtick */; + pos++; + var start = pos; + var contents = ""; + var resultingToken; + while (true) { + if (pos >= end) { + contents += text.substring(start, pos); + tokenFlags |= 4 /* TokenFlags.Unterminated */; + error(ts.Diagnostics.Unterminated_template_literal); + resultingToken = startedWithBacktick ? 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */ : 17 /* SyntaxKind.TemplateTail */; + break; + } + var currChar = text.charCodeAt(pos); + // '`' + if (currChar === 96 /* CharacterCodes.backtick */) { + contents += text.substring(start, pos); + pos++; + resultingToken = startedWithBacktick ? 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */ : 17 /* SyntaxKind.TemplateTail */; + break; + } + // '${' + if (currChar === 36 /* CharacterCodes.$ */ && pos + 1 < end && text.charCodeAt(pos + 1) === 123 /* CharacterCodes.openBrace */) { + contents += text.substring(start, pos); + pos += 2; + resultingToken = startedWithBacktick ? 15 /* SyntaxKind.TemplateHead */ : 16 /* SyntaxKind.TemplateMiddle */; + break; + } + // Escape character + if (currChar === 92 /* CharacterCodes.backslash */) { + contents += text.substring(start, pos); + contents += scanEscapeSequence(isTaggedTemplate); + start = pos; + continue; + } + // Speculated ECMAScript 6 Spec 11.8.6.1: + // and LineTerminatorSequences are normalized to for Template Values + if (currChar === 13 /* CharacterCodes.carriageReturn */) { + contents += text.substring(start, pos); + pos++; + if (pos < end && text.charCodeAt(pos) === 10 /* CharacterCodes.lineFeed */) { + pos++; + } + contents += "\n"; + start = pos; + continue; + } + pos++; + } + ts.Debug.assert(resultingToken !== undefined); + tokenValue = contents; + return resultingToken; + } + function scanEscapeSequence(isTaggedTemplate) { + var start = pos; + pos++; + if (pos >= end) { + error(ts.Diagnostics.Unexpected_end_of_text); + return ""; + } + var ch = text.charCodeAt(pos); + pos++; + switch (ch) { + case 48 /* CharacterCodes._0 */: + // '\01' + if (isTaggedTemplate && pos < end && isDigit(text.charCodeAt(pos))) { + pos++; + tokenFlags |= 2048 /* TokenFlags.ContainsInvalidEscape */; + return text.substring(start, pos); + } + return "\0"; + case 98 /* CharacterCodes.b */: + return "\b"; + case 116 /* CharacterCodes.t */: + return "\t"; + case 110 /* CharacterCodes.n */: + return "\n"; + case 118 /* CharacterCodes.v */: + return "\v"; + case 102 /* CharacterCodes.f */: + return "\f"; + case 114 /* CharacterCodes.r */: + return "\r"; + case 39 /* CharacterCodes.singleQuote */: + return "\'"; + case 34 /* CharacterCodes.doubleQuote */: + return "\""; + case 117 /* CharacterCodes.u */: + if (isTaggedTemplate) { + // '\u' or '\u0' or '\u00' or '\u000' + for (var escapePos = pos; escapePos < pos + 4; escapePos++) { + if (escapePos < end && !isHexDigit(text.charCodeAt(escapePos)) && text.charCodeAt(escapePos) !== 123 /* CharacterCodes.openBrace */) { + pos = escapePos; + tokenFlags |= 2048 /* TokenFlags.ContainsInvalidEscape */; + return text.substring(start, pos); + } + } + } + // '\u{DDDDDDDD}' + if (pos < end && text.charCodeAt(pos) === 123 /* CharacterCodes.openBrace */) { + pos++; + // '\u{' + if (isTaggedTemplate && !isHexDigit(text.charCodeAt(pos))) { + tokenFlags |= 2048 /* TokenFlags.ContainsInvalidEscape */; + return text.substring(start, pos); + } + if (isTaggedTemplate) { + var savePos = pos; + var escapedValueString = scanMinimumNumberOfHexDigits(1, /*canHaveSeparators*/ false); + var escapedValue = escapedValueString ? parseInt(escapedValueString, 16) : -1; + // '\u{Not Code Point' or '\u{CodePoint' + if (!isCodePoint(escapedValue) || text.charCodeAt(pos) !== 125 /* CharacterCodes.closeBrace */) { + tokenFlags |= 2048 /* TokenFlags.ContainsInvalidEscape */; + return text.substring(start, pos); + } + else { + pos = savePos; + } + } + tokenFlags |= 8 /* TokenFlags.ExtendedUnicodeEscape */; + return scanExtendedUnicodeEscape(); + } + tokenFlags |= 1024 /* TokenFlags.UnicodeEscape */; + // '\uDDDD' + return scanHexadecimalEscape(/*numDigits*/ 4); + case 120 /* CharacterCodes.x */: + if (isTaggedTemplate) { + if (!isHexDigit(text.charCodeAt(pos))) { + tokenFlags |= 2048 /* TokenFlags.ContainsInvalidEscape */; + return text.substring(start, pos); + } + else if (!isHexDigit(text.charCodeAt(pos + 1))) { + pos++; + tokenFlags |= 2048 /* TokenFlags.ContainsInvalidEscape */; + return text.substring(start, pos); + } + } + // '\xDD' + return scanHexadecimalEscape(/*numDigits*/ 2); + // when encountering a LineContinuation (i.e. a backslash and a line terminator sequence), + // the line terminator is interpreted to be "the empty code unit sequence". + case 13 /* CharacterCodes.carriageReturn */: + if (pos < end && text.charCodeAt(pos) === 10 /* CharacterCodes.lineFeed */) { + pos++; + } + // falls through + case 10 /* CharacterCodes.lineFeed */: + case 8232 /* CharacterCodes.lineSeparator */: + case 8233 /* CharacterCodes.paragraphSeparator */: + return ""; + default: + return String.fromCharCode(ch); + } + } + function scanHexadecimalEscape(numDigits) { + var escapedValue = scanExactNumberOfHexDigits(numDigits, /*canHaveSeparators*/ false); + if (escapedValue >= 0) { + return String.fromCharCode(escapedValue); + } + else { + error(ts.Diagnostics.Hexadecimal_digit_expected); + return ""; + } + } + function scanExtendedUnicodeEscape() { + var escapedValueString = scanMinimumNumberOfHexDigits(1, /*canHaveSeparators*/ false); + var escapedValue = escapedValueString ? parseInt(escapedValueString, 16) : -1; + var isInvalidExtendedEscape = false; + // Validate the value of the digit + if (escapedValue < 0) { + error(ts.Diagnostics.Hexadecimal_digit_expected); + isInvalidExtendedEscape = true; + } + else if (escapedValue > 0x10FFFF) { + error(ts.Diagnostics.An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive); + isInvalidExtendedEscape = true; + } + if (pos >= end) { + error(ts.Diagnostics.Unexpected_end_of_text); + isInvalidExtendedEscape = true; + } + else if (text.charCodeAt(pos) === 125 /* CharacterCodes.closeBrace */) { + // Only swallow the following character up if it's a '}'. + pos++; + } + else { + error(ts.Diagnostics.Unterminated_Unicode_escape_sequence); + isInvalidExtendedEscape = true; + } + if (isInvalidExtendedEscape) { + return ""; + } + return utf16EncodeAsString(escapedValue); + } + // Current character is known to be a backslash. Check for Unicode escape of the form '\uXXXX' + // and return code point value if valid Unicode escape is found. Otherwise return -1. + function peekUnicodeEscape() { + if (pos + 5 < end && text.charCodeAt(pos + 1) === 117 /* CharacterCodes.u */) { + var start_1 = pos; + pos += 2; + var value = scanExactNumberOfHexDigits(4, /*canHaveSeparators*/ false); + pos = start_1; + return value; + } + return -1; + } + function peekExtendedUnicodeEscape() { + if (codePointAt(text, pos + 1) === 117 /* CharacterCodes.u */ && codePointAt(text, pos + 2) === 123 /* CharacterCodes.openBrace */) { + var start_2 = pos; + pos += 3; + var escapedValueString = scanMinimumNumberOfHexDigits(1, /*canHaveSeparators*/ false); + var escapedValue = escapedValueString ? parseInt(escapedValueString, 16) : -1; + pos = start_2; + return escapedValue; + } + return -1; + } + function scanIdentifierParts() { + var result = ""; + var start = pos; + while (pos < end) { + var ch = codePointAt(text, pos); + if (isIdentifierPart(ch, languageVersion)) { + pos += charSize(ch); + } + else if (ch === 92 /* CharacterCodes.backslash */) { + ch = peekExtendedUnicodeEscape(); + if (ch >= 0 && isIdentifierPart(ch, languageVersion)) { + pos += 3; + tokenFlags |= 8 /* TokenFlags.ExtendedUnicodeEscape */; + result += scanExtendedUnicodeEscape(); + start = pos; + continue; + } + ch = peekUnicodeEscape(); + if (!(ch >= 0 && isIdentifierPart(ch, languageVersion))) { + break; + } + tokenFlags |= 1024 /* TokenFlags.UnicodeEscape */; + result += text.substring(start, pos); + result += utf16EncodeAsString(ch); + // Valid Unicode escape is always six characters + pos += 6; + start = pos; + } + else { + break; + } + } + result += text.substring(start, pos); + return result; + } + function getIdentifierToken() { + // Reserved words are between 2 and 12 characters long and start with a lowercase letter + var len = tokenValue.length; + if (len >= 2 && len <= 12) { + var ch = tokenValue.charCodeAt(0); + if (ch >= 97 /* CharacterCodes.a */ && ch <= 122 /* CharacterCodes.z */) { + var keyword = textToKeyword.get(tokenValue); + if (keyword !== undefined) { + return token = keyword; + } + } + } + return token = 79 /* SyntaxKind.Identifier */; + } + function scanBinaryOrOctalDigits(base) { + var value = ""; + // For counting number of digits; Valid binaryIntegerLiteral must have at least one binary digit following B or b. + // Similarly valid octalIntegerLiteral must have at least one octal digit following o or O. + var separatorAllowed = false; + var isPreviousTokenSeparator = false; + while (true) { + var ch = text.charCodeAt(pos); + // Numeric separators are allowed anywhere within a numeric literal, except not at the beginning, or following another separator + if (ch === 95 /* CharacterCodes._ */) { + tokenFlags |= 512 /* TokenFlags.ContainsSeparator */; + if (separatorAllowed) { + separatorAllowed = false; + isPreviousTokenSeparator = true; + } + else if (isPreviousTokenSeparator) { + error(ts.Diagnostics.Multiple_consecutive_numeric_separators_are_not_permitted, pos, 1); + } + else { + error(ts.Diagnostics.Numeric_separators_are_not_allowed_here, pos, 1); + } + pos++; + continue; + } + separatorAllowed = true; + if (!isDigit(ch) || ch - 48 /* CharacterCodes._0 */ >= base) { + break; + } + value += text[pos]; + pos++; + isPreviousTokenSeparator = false; + } + if (text.charCodeAt(pos - 1) === 95 /* CharacterCodes._ */) { + // Literal ends with underscore - not allowed + error(ts.Diagnostics.Numeric_separators_are_not_allowed_here, pos - 1, 1); + } + return value; + } + function checkBigIntSuffix() { + if (text.charCodeAt(pos) === 110 /* CharacterCodes.n */) { + tokenValue += "n"; + // Use base 10 instead of base 2 or base 8 for shorter literals + if (tokenFlags & 384 /* TokenFlags.BinaryOrOctalSpecifier */) { + tokenValue = ts.parsePseudoBigInt(tokenValue) + "n"; + } + pos++; + return 9 /* SyntaxKind.BigIntLiteral */; + } + else { // not a bigint, so can convert to number in simplified form + // Number() may not support 0b or 0o, so use parseInt() instead + var numericValue = tokenFlags & 128 /* TokenFlags.BinarySpecifier */ + ? parseInt(tokenValue.slice(2), 2) // skip "0b" + : tokenFlags & 256 /* TokenFlags.OctalSpecifier */ + ? parseInt(tokenValue.slice(2), 8) // skip "0o" + : +tokenValue; + tokenValue = "" + numericValue; + return 8 /* SyntaxKind.NumericLiteral */; + } + } + function scan() { + var _a; + startPos = pos; + tokenFlags = 0 /* TokenFlags.None */; + var asteriskSeen = false; + while (true) { + tokenPos = pos; + if (pos >= end) { + return token = 1 /* SyntaxKind.EndOfFileToken */; + } + var ch = codePointAt(text, pos); + // Special handling for shebang + if (ch === 35 /* CharacterCodes.hash */ && pos === 0 && isShebangTrivia(text, pos)) { + pos = scanShebangTrivia(text, pos); + if (skipTrivia) { + continue; + } + else { + return token = 6 /* SyntaxKind.ShebangTrivia */; + } + } + switch (ch) { + case 10 /* CharacterCodes.lineFeed */: + case 13 /* CharacterCodes.carriageReturn */: + tokenFlags |= 1 /* TokenFlags.PrecedingLineBreak */; + if (skipTrivia) { + pos++; + continue; + } + else { + if (ch === 13 /* CharacterCodes.carriageReturn */ && pos + 1 < end && text.charCodeAt(pos + 1) === 10 /* CharacterCodes.lineFeed */) { + // consume both CR and LF + pos += 2; + } + else { + pos++; + } + return token = 4 /* SyntaxKind.NewLineTrivia */; + } + case 9 /* CharacterCodes.tab */: + case 11 /* CharacterCodes.verticalTab */: + case 12 /* CharacterCodes.formFeed */: + case 32 /* CharacterCodes.space */: + case 160 /* CharacterCodes.nonBreakingSpace */: + case 5760 /* CharacterCodes.ogham */: + case 8192 /* CharacterCodes.enQuad */: + case 8193 /* CharacterCodes.emQuad */: + case 8194 /* CharacterCodes.enSpace */: + case 8195 /* CharacterCodes.emSpace */: + case 8196 /* CharacterCodes.threePerEmSpace */: + case 8197 /* CharacterCodes.fourPerEmSpace */: + case 8198 /* CharacterCodes.sixPerEmSpace */: + case 8199 /* CharacterCodes.figureSpace */: + case 8200 /* CharacterCodes.punctuationSpace */: + case 8201 /* CharacterCodes.thinSpace */: + case 8202 /* CharacterCodes.hairSpace */: + case 8203 /* CharacterCodes.zeroWidthSpace */: + case 8239 /* CharacterCodes.narrowNoBreakSpace */: + case 8287 /* CharacterCodes.mathematicalSpace */: + case 12288 /* CharacterCodes.ideographicSpace */: + case 65279 /* CharacterCodes.byteOrderMark */: + if (skipTrivia) { + pos++; + continue; + } + else { + while (pos < end && isWhiteSpaceSingleLine(text.charCodeAt(pos))) { + pos++; + } + return token = 5 /* SyntaxKind.WhitespaceTrivia */; + } + case 33 /* CharacterCodes.exclamation */: + if (text.charCodeAt(pos + 1) === 61 /* CharacterCodes.equals */) { + if (text.charCodeAt(pos + 2) === 61 /* CharacterCodes.equals */) { + return pos += 3, token = 37 /* SyntaxKind.ExclamationEqualsEqualsToken */; + } + return pos += 2, token = 35 /* SyntaxKind.ExclamationEqualsToken */; + } + pos++; + return token = 53 /* SyntaxKind.ExclamationToken */; + case 34 /* CharacterCodes.doubleQuote */: + case 39 /* CharacterCodes.singleQuote */: + tokenValue = scanString(); + return token = 10 /* SyntaxKind.StringLiteral */; + case 96 /* CharacterCodes.backtick */: + return token = scanTemplateAndSetTokenValue(/* isTaggedTemplate */ false); + case 37 /* CharacterCodes.percent */: + if (text.charCodeAt(pos + 1) === 61 /* CharacterCodes.equals */) { + return pos += 2, token = 69 /* SyntaxKind.PercentEqualsToken */; + } + pos++; + return token = 44 /* SyntaxKind.PercentToken */; + case 38 /* CharacterCodes.ampersand */: + if (text.charCodeAt(pos + 1) === 38 /* CharacterCodes.ampersand */) { + if (text.charCodeAt(pos + 2) === 61 /* CharacterCodes.equals */) { + return pos += 3, token = 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */; + } + return pos += 2, token = 55 /* SyntaxKind.AmpersandAmpersandToken */; + } + if (text.charCodeAt(pos + 1) === 61 /* CharacterCodes.equals */) { + return pos += 2, token = 73 /* SyntaxKind.AmpersandEqualsToken */; + } + pos++; + return token = 50 /* SyntaxKind.AmpersandToken */; + case 40 /* CharacterCodes.openParen */: + pos++; + return token = 20 /* SyntaxKind.OpenParenToken */; + case 41 /* CharacterCodes.closeParen */: + pos++; + return token = 21 /* SyntaxKind.CloseParenToken */; + case 42 /* CharacterCodes.asterisk */: + if (text.charCodeAt(pos + 1) === 61 /* CharacterCodes.equals */) { + return pos += 2, token = 66 /* SyntaxKind.AsteriskEqualsToken */; + } + if (text.charCodeAt(pos + 1) === 42 /* CharacterCodes.asterisk */) { + if (text.charCodeAt(pos + 2) === 61 /* CharacterCodes.equals */) { + return pos += 3, token = 67 /* SyntaxKind.AsteriskAsteriskEqualsToken */; + } + return pos += 2, token = 42 /* SyntaxKind.AsteriskAsteriskToken */; + } + pos++; + if (inJSDocType && !asteriskSeen && (tokenFlags & 1 /* TokenFlags.PrecedingLineBreak */)) { + // decoration at the start of a JSDoc comment line + asteriskSeen = true; + continue; + } + return token = 41 /* SyntaxKind.AsteriskToken */; + case 43 /* CharacterCodes.plus */: + if (text.charCodeAt(pos + 1) === 43 /* CharacterCodes.plus */) { + return pos += 2, token = 45 /* SyntaxKind.PlusPlusToken */; + } + if (text.charCodeAt(pos + 1) === 61 /* CharacterCodes.equals */) { + return pos += 2, token = 64 /* SyntaxKind.PlusEqualsToken */; + } + pos++; + return token = 39 /* SyntaxKind.PlusToken */; + case 44 /* CharacterCodes.comma */: + pos++; + return token = 27 /* SyntaxKind.CommaToken */; + case 45 /* CharacterCodes.minus */: + if (text.charCodeAt(pos + 1) === 45 /* CharacterCodes.minus */) { + return pos += 2, token = 46 /* SyntaxKind.MinusMinusToken */; + } + if (text.charCodeAt(pos + 1) === 61 /* CharacterCodes.equals */) { + return pos += 2, token = 65 /* SyntaxKind.MinusEqualsToken */; + } + pos++; + return token = 40 /* SyntaxKind.MinusToken */; + case 46 /* CharacterCodes.dot */: + if (isDigit(text.charCodeAt(pos + 1))) { + tokenValue = scanNumber().value; + return token = 8 /* SyntaxKind.NumericLiteral */; + } + if (text.charCodeAt(pos + 1) === 46 /* CharacterCodes.dot */ && text.charCodeAt(pos + 2) === 46 /* CharacterCodes.dot */) { + return pos += 3, token = 25 /* SyntaxKind.DotDotDotToken */; + } + pos++; + return token = 24 /* SyntaxKind.DotToken */; + case 47 /* CharacterCodes.slash */: + // Single-line comment + if (text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */) { + pos += 2; + while (pos < end) { + if (isLineBreak(text.charCodeAt(pos))) { + break; + } + pos++; + } + commentDirectives = appendIfCommentDirective(commentDirectives, text.slice(tokenPos, pos), commentDirectiveRegExSingleLine, tokenPos); + if (skipTrivia) { + continue; + } + else { + return token = 2 /* SyntaxKind.SingleLineCommentTrivia */; + } + } + // Multi-line comment + if (text.charCodeAt(pos + 1) === 42 /* CharacterCodes.asterisk */) { + pos += 2; + if (text.charCodeAt(pos) === 42 /* CharacterCodes.asterisk */ && text.charCodeAt(pos + 1) !== 47 /* CharacterCodes.slash */) { + tokenFlags |= 2 /* TokenFlags.PrecedingJSDocComment */; + } + var commentClosed = false; + var lastLineStart = tokenPos; + while (pos < end) { + var ch_1 = text.charCodeAt(pos); + if (ch_1 === 42 /* CharacterCodes.asterisk */ && text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */) { + pos += 2; + commentClosed = true; + break; + } + pos++; + if (isLineBreak(ch_1)) { + lastLineStart = pos; + tokenFlags |= 1 /* TokenFlags.PrecedingLineBreak */; + } + } + commentDirectives = appendIfCommentDirective(commentDirectives, text.slice(lastLineStart, pos), commentDirectiveRegExMultiLine, lastLineStart); + if (!commentClosed) { + error(ts.Diagnostics.Asterisk_Slash_expected); + } + if (skipTrivia) { + continue; + } + else { + if (!commentClosed) { + tokenFlags |= 4 /* TokenFlags.Unterminated */; + } + return token = 3 /* SyntaxKind.MultiLineCommentTrivia */; + } + } + if (text.charCodeAt(pos + 1) === 61 /* CharacterCodes.equals */) { + return pos += 2, token = 68 /* SyntaxKind.SlashEqualsToken */; + } + pos++; + return token = 43 /* SyntaxKind.SlashToken */; + case 48 /* CharacterCodes._0 */: + if (pos + 2 < end && (text.charCodeAt(pos + 1) === 88 /* CharacterCodes.X */ || text.charCodeAt(pos + 1) === 120 /* CharacterCodes.x */)) { + pos += 2; + tokenValue = scanMinimumNumberOfHexDigits(1, /*canHaveSeparators*/ true); + if (!tokenValue) { + error(ts.Diagnostics.Hexadecimal_digit_expected); + tokenValue = "0"; + } + tokenValue = "0x" + tokenValue; + tokenFlags |= 64 /* TokenFlags.HexSpecifier */; + return token = checkBigIntSuffix(); + } + else if (pos + 2 < end && (text.charCodeAt(pos + 1) === 66 /* CharacterCodes.B */ || text.charCodeAt(pos + 1) === 98 /* CharacterCodes.b */)) { + pos += 2; + tokenValue = scanBinaryOrOctalDigits(/* base */ 2); + if (!tokenValue) { + error(ts.Diagnostics.Binary_digit_expected); + tokenValue = "0"; + } + tokenValue = "0b" + tokenValue; + tokenFlags |= 128 /* TokenFlags.BinarySpecifier */; + return token = checkBigIntSuffix(); + } + else if (pos + 2 < end && (text.charCodeAt(pos + 1) === 79 /* CharacterCodes.O */ || text.charCodeAt(pos + 1) === 111 /* CharacterCodes.o */)) { + pos += 2; + tokenValue = scanBinaryOrOctalDigits(/* base */ 8); + if (!tokenValue) { + error(ts.Diagnostics.Octal_digit_expected); + tokenValue = "0"; + } + tokenValue = "0o" + tokenValue; + tokenFlags |= 256 /* TokenFlags.OctalSpecifier */; + return token = checkBigIntSuffix(); + } + // Try to parse as an octal + if (pos + 1 < end && isOctalDigit(text.charCodeAt(pos + 1))) { + tokenValue = "" + scanOctalDigits(); + tokenFlags |= 32 /* TokenFlags.Octal */; + return token = 8 /* SyntaxKind.NumericLiteral */; + } + // This fall-through is a deviation from the EcmaScript grammar. The grammar says that a leading zero + // can only be followed by an octal digit, a dot, or the end of the number literal. However, we are being + // permissive and allowing decimal digits of the form 08* and 09* (which many browsers also do). + // falls through + case 49 /* CharacterCodes._1 */: + case 50 /* CharacterCodes._2 */: + case 51 /* CharacterCodes._3 */: + case 52 /* CharacterCodes._4 */: + case 53 /* CharacterCodes._5 */: + case 54 /* CharacterCodes._6 */: + case 55 /* CharacterCodes._7 */: + case 56 /* CharacterCodes._8 */: + case 57 /* CharacterCodes._9 */: + (_a = scanNumber(), token = _a.type, tokenValue = _a.value); + return token; + case 58 /* CharacterCodes.colon */: + pos++; + return token = 58 /* SyntaxKind.ColonToken */; + case 59 /* CharacterCodes.semicolon */: + pos++; + return token = 26 /* SyntaxKind.SemicolonToken */; + case 60 /* CharacterCodes.lessThan */: + if (isConflictMarkerTrivia(text, pos)) { + pos = scanConflictMarkerTrivia(text, pos, error); + if (skipTrivia) { + continue; + } + else { + return token = 7 /* SyntaxKind.ConflictMarkerTrivia */; + } + } + if (text.charCodeAt(pos + 1) === 60 /* CharacterCodes.lessThan */) { + if (text.charCodeAt(pos + 2) === 61 /* CharacterCodes.equals */) { + return pos += 3, token = 70 /* SyntaxKind.LessThanLessThanEqualsToken */; + } + return pos += 2, token = 47 /* SyntaxKind.LessThanLessThanToken */; + } + if (text.charCodeAt(pos + 1) === 61 /* CharacterCodes.equals */) { + return pos += 2, token = 32 /* SyntaxKind.LessThanEqualsToken */; + } + if (languageVariant === 1 /* LanguageVariant.JSX */ && + text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */ && + text.charCodeAt(pos + 2) !== 42 /* CharacterCodes.asterisk */) { + return pos += 2, token = 30 /* SyntaxKind.LessThanSlashToken */; + } + pos++; + return token = 29 /* SyntaxKind.LessThanToken */; + case 61 /* CharacterCodes.equals */: + if (isConflictMarkerTrivia(text, pos)) { + pos = scanConflictMarkerTrivia(text, pos, error); + if (skipTrivia) { + continue; + } + else { + return token = 7 /* SyntaxKind.ConflictMarkerTrivia */; + } + } + if (text.charCodeAt(pos + 1) === 61 /* CharacterCodes.equals */) { + if (text.charCodeAt(pos + 2) === 61 /* CharacterCodes.equals */) { + return pos += 3, token = 36 /* SyntaxKind.EqualsEqualsEqualsToken */; + } + return pos += 2, token = 34 /* SyntaxKind.EqualsEqualsToken */; + } + if (text.charCodeAt(pos + 1) === 62 /* CharacterCodes.greaterThan */) { + return pos += 2, token = 38 /* SyntaxKind.EqualsGreaterThanToken */; + } + pos++; + return token = 63 /* SyntaxKind.EqualsToken */; + case 62 /* CharacterCodes.greaterThan */: + if (isConflictMarkerTrivia(text, pos)) { + pos = scanConflictMarkerTrivia(text, pos, error); + if (skipTrivia) { + continue; + } + else { + return token = 7 /* SyntaxKind.ConflictMarkerTrivia */; + } + } + pos++; + return token = 31 /* SyntaxKind.GreaterThanToken */; + case 63 /* CharacterCodes.question */: + if (text.charCodeAt(pos + 1) === 46 /* CharacterCodes.dot */ && !isDigit(text.charCodeAt(pos + 2))) { + return pos += 2, token = 28 /* SyntaxKind.QuestionDotToken */; + } + if (text.charCodeAt(pos + 1) === 63 /* CharacterCodes.question */) { + if (text.charCodeAt(pos + 2) === 61 /* CharacterCodes.equals */) { + return pos += 3, token = 77 /* SyntaxKind.QuestionQuestionEqualsToken */; + } + return pos += 2, token = 60 /* SyntaxKind.QuestionQuestionToken */; + } + pos++; + return token = 57 /* SyntaxKind.QuestionToken */; + case 91 /* CharacterCodes.openBracket */: + pos++; + return token = 22 /* SyntaxKind.OpenBracketToken */; + case 93 /* CharacterCodes.closeBracket */: + pos++; + return token = 23 /* SyntaxKind.CloseBracketToken */; + case 94 /* CharacterCodes.caret */: + if (text.charCodeAt(pos + 1) === 61 /* CharacterCodes.equals */) { + return pos += 2, token = 78 /* SyntaxKind.CaretEqualsToken */; + } + pos++; + return token = 52 /* SyntaxKind.CaretToken */; + case 123 /* CharacterCodes.openBrace */: + pos++; + return token = 18 /* SyntaxKind.OpenBraceToken */; + case 124 /* CharacterCodes.bar */: + if (isConflictMarkerTrivia(text, pos)) { + pos = scanConflictMarkerTrivia(text, pos, error); + if (skipTrivia) { + continue; + } + else { + return token = 7 /* SyntaxKind.ConflictMarkerTrivia */; + } + } + if (text.charCodeAt(pos + 1) === 124 /* CharacterCodes.bar */) { + if (text.charCodeAt(pos + 2) === 61 /* CharacterCodes.equals */) { + return pos += 3, token = 75 /* SyntaxKind.BarBarEqualsToken */; + } + return pos += 2, token = 56 /* SyntaxKind.BarBarToken */; + } + if (text.charCodeAt(pos + 1) === 61 /* CharacterCodes.equals */) { + return pos += 2, token = 74 /* SyntaxKind.BarEqualsToken */; + } + pos++; + return token = 51 /* SyntaxKind.BarToken */; + case 125 /* CharacterCodes.closeBrace */: + pos++; + return token = 19 /* SyntaxKind.CloseBraceToken */; + case 126 /* CharacterCodes.tilde */: + pos++; + return token = 54 /* SyntaxKind.TildeToken */; + case 64 /* CharacterCodes.at */: + pos++; + return token = 59 /* SyntaxKind.AtToken */; + case 92 /* CharacterCodes.backslash */: + var extendedCookedChar = peekExtendedUnicodeEscape(); + if (extendedCookedChar >= 0 && isIdentifierStart(extendedCookedChar, languageVersion)) { + pos += 3; + tokenFlags |= 8 /* TokenFlags.ExtendedUnicodeEscape */; + tokenValue = scanExtendedUnicodeEscape() + scanIdentifierParts(); + return token = getIdentifierToken(); + } + var cookedChar = peekUnicodeEscape(); + if (cookedChar >= 0 && isIdentifierStart(cookedChar, languageVersion)) { + pos += 6; + tokenFlags |= 1024 /* TokenFlags.UnicodeEscape */; + tokenValue = String.fromCharCode(cookedChar) + scanIdentifierParts(); + return token = getIdentifierToken(); + } + error(ts.Diagnostics.Invalid_character); + pos++; + return token = 0 /* SyntaxKind.Unknown */; + case 35 /* CharacterCodes.hash */: + if (pos !== 0 && text[pos + 1] === "!") { + error(ts.Diagnostics.can_only_be_used_at_the_start_of_a_file); + pos++; + return token = 0 /* SyntaxKind.Unknown */; + } + var charAfterHash = codePointAt(text, pos + 1); + if (charAfterHash === 92 /* CharacterCodes.backslash */) { + pos++; + var extendedCookedChar_1 = peekExtendedUnicodeEscape(); + if (extendedCookedChar_1 >= 0 && isIdentifierStart(extendedCookedChar_1, languageVersion)) { + pos += 3; + tokenFlags |= 8 /* TokenFlags.ExtendedUnicodeEscape */; + tokenValue = "#" + scanExtendedUnicodeEscape() + scanIdentifierParts(); + return token = 80 /* SyntaxKind.PrivateIdentifier */; + } + var cookedChar_1 = peekUnicodeEscape(); + if (cookedChar_1 >= 0 && isIdentifierStart(cookedChar_1, languageVersion)) { + pos += 6; + tokenFlags |= 1024 /* TokenFlags.UnicodeEscape */; + tokenValue = "#" + String.fromCharCode(cookedChar_1) + scanIdentifierParts(); + return token = 80 /* SyntaxKind.PrivateIdentifier */; + } + pos--; + } + if (isIdentifierStart(charAfterHash, languageVersion)) { + pos++; + // We're relying on scanIdentifier's behavior and adjusting the token kind after the fact. + // Notably absent from this block is the fact that calling a function named "scanIdentifier", + // but identifiers don't include '#', and that function doesn't deal with it at all. + // This works because 'scanIdentifier' tries to reuse source characters and builds up substrings; + // however, it starts at the 'tokenPos' which includes the '#', and will "accidentally" prepend the '#' for us. + scanIdentifier(charAfterHash, languageVersion); + } + else { + tokenValue = "#"; + error(ts.Diagnostics.Invalid_character, pos++, charSize(ch)); + } + return token = 80 /* SyntaxKind.PrivateIdentifier */; + default: + var identifierKind = scanIdentifier(ch, languageVersion); + if (identifierKind) { + return token = identifierKind; + } + else if (isWhiteSpaceSingleLine(ch)) { + pos += charSize(ch); + continue; + } + else if (isLineBreak(ch)) { + tokenFlags |= 1 /* TokenFlags.PrecedingLineBreak */; + pos += charSize(ch); + continue; + } + var size = charSize(ch); + error(ts.Diagnostics.Invalid_character, pos, size); + pos += size; + return token = 0 /* SyntaxKind.Unknown */; + } + } + } + function reScanInvalidIdentifier() { + ts.Debug.assert(token === 0 /* SyntaxKind.Unknown */, "'reScanInvalidIdentifier' should only be called when the current token is 'SyntaxKind.Unknown'."); + pos = tokenPos = startPos; + tokenFlags = 0; + var ch = codePointAt(text, pos); + var identifierKind = scanIdentifier(ch, 99 /* ScriptTarget.ESNext */); + if (identifierKind) { + return token = identifierKind; + } + pos += charSize(ch); + return token; // Still `SyntaKind.Unknown` + } + function scanIdentifier(startCharacter, languageVersion) { + var ch = startCharacter; + if (isIdentifierStart(ch, languageVersion)) { + pos += charSize(ch); + while (pos < end && isIdentifierPart(ch = codePointAt(text, pos), languageVersion)) + pos += charSize(ch); + tokenValue = text.substring(tokenPos, pos); + if (ch === 92 /* CharacterCodes.backslash */) { + tokenValue += scanIdentifierParts(); + } + return getIdentifierToken(); + } + } + function reScanGreaterToken() { + if (token === 31 /* SyntaxKind.GreaterThanToken */) { + if (text.charCodeAt(pos) === 62 /* CharacterCodes.greaterThan */) { + if (text.charCodeAt(pos + 1) === 62 /* CharacterCodes.greaterThan */) { + if (text.charCodeAt(pos + 2) === 61 /* CharacterCodes.equals */) { + return pos += 3, token = 72 /* SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken */; + } + return pos += 2, token = 49 /* SyntaxKind.GreaterThanGreaterThanGreaterThanToken */; + } + if (text.charCodeAt(pos + 1) === 61 /* CharacterCodes.equals */) { + return pos += 2, token = 71 /* SyntaxKind.GreaterThanGreaterThanEqualsToken */; + } + pos++; + return token = 48 /* SyntaxKind.GreaterThanGreaterThanToken */; + } + if (text.charCodeAt(pos) === 61 /* CharacterCodes.equals */) { + pos++; + return token = 33 /* SyntaxKind.GreaterThanEqualsToken */; + } + } + return token; + } + function reScanAsteriskEqualsToken() { + ts.Debug.assert(token === 66 /* SyntaxKind.AsteriskEqualsToken */, "'reScanAsteriskEqualsToken' should only be called on a '*='"); + pos = tokenPos + 1; + return token = 63 /* SyntaxKind.EqualsToken */; + } + function reScanSlashToken() { + if (token === 43 /* SyntaxKind.SlashToken */ || token === 68 /* SyntaxKind.SlashEqualsToken */) { + var p = tokenPos + 1; + var inEscape = false; + var inCharacterClass = false; + while (true) { + // If we reach the end of a file, or hit a newline, then this is an unterminated + // regex. Report error and return what we have so far. + if (p >= end) { + tokenFlags |= 4 /* TokenFlags.Unterminated */; + error(ts.Diagnostics.Unterminated_regular_expression_literal); + break; + } + var ch = text.charCodeAt(p); + if (isLineBreak(ch)) { + tokenFlags |= 4 /* TokenFlags.Unterminated */; + error(ts.Diagnostics.Unterminated_regular_expression_literal); + break; + } + if (inEscape) { + // Parsing an escape character; + // reset the flag and just advance to the next char. + inEscape = false; + } + else if (ch === 47 /* CharacterCodes.slash */ && !inCharacterClass) { + // A slash within a character class is permissible, + // but in general it signals the end of the regexp literal. + p++; + break; + } + else if (ch === 91 /* CharacterCodes.openBracket */) { + inCharacterClass = true; + } + else if (ch === 92 /* CharacterCodes.backslash */) { + inEscape = true; + } + else if (ch === 93 /* CharacterCodes.closeBracket */) { + inCharacterClass = false; + } + p++; + } + while (p < end && isIdentifierPart(text.charCodeAt(p), languageVersion)) { + p++; + } + pos = p; + tokenValue = text.substring(tokenPos, pos); + token = 13 /* SyntaxKind.RegularExpressionLiteral */; + } + return token; + } + function appendIfCommentDirective(commentDirectives, text, commentDirectiveRegEx, lineStart) { + var type = getDirectiveFromComment(ts.trimStringStart(text), commentDirectiveRegEx); + if (type === undefined) { + return commentDirectives; + } + return ts.append(commentDirectives, { + range: { pos: lineStart, end: pos }, + type: type, + }); + } + function getDirectiveFromComment(text, commentDirectiveRegEx) { + var match = commentDirectiveRegEx.exec(text); + if (!match) { + return undefined; + } + switch (match[1]) { + case "ts-expect-error": + return 0 /* CommentDirectiveType.ExpectError */; + case "ts-ignore": + return 1 /* CommentDirectiveType.Ignore */; + } + return undefined; + } + /** + * Unconditionally back up and scan a template expression portion. + */ + function reScanTemplateToken(isTaggedTemplate) { + ts.Debug.assert(token === 19 /* SyntaxKind.CloseBraceToken */, "'reScanTemplateToken' should only be called on a '}'"); + pos = tokenPos; + return token = scanTemplateAndSetTokenValue(isTaggedTemplate); + } + function reScanTemplateHeadOrNoSubstitutionTemplate() { + pos = tokenPos; + return token = scanTemplateAndSetTokenValue(/* isTaggedTemplate */ true); + } + function reScanJsxToken(allowMultilineJsxText) { + if (allowMultilineJsxText === void 0) { allowMultilineJsxText = true; } + pos = tokenPos = startPos; + return token = scanJsxToken(allowMultilineJsxText); + } + function reScanLessThanToken() { + if (token === 47 /* SyntaxKind.LessThanLessThanToken */) { + pos = tokenPos + 1; + return token = 29 /* SyntaxKind.LessThanToken */; + } + return token; + } + function reScanHashToken() { + if (token === 80 /* SyntaxKind.PrivateIdentifier */) { + pos = tokenPos + 1; + return token = 62 /* SyntaxKind.HashToken */; + } + return token; + } + function reScanQuestionToken() { + ts.Debug.assert(token === 60 /* SyntaxKind.QuestionQuestionToken */, "'reScanQuestionToken' should only be called on a '??'"); + pos = tokenPos + 1; + return token = 57 /* SyntaxKind.QuestionToken */; + } + function scanJsxToken(allowMultilineJsxText) { + if (allowMultilineJsxText === void 0) { allowMultilineJsxText = true; } + startPos = tokenPos = pos; + if (pos >= end) { + return token = 1 /* SyntaxKind.EndOfFileToken */; + } + var char = text.charCodeAt(pos); + if (char === 60 /* CharacterCodes.lessThan */) { + if (text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */) { + pos += 2; + return token = 30 /* SyntaxKind.LessThanSlashToken */; + } + pos++; + return token = 29 /* SyntaxKind.LessThanToken */; + } + if (char === 123 /* CharacterCodes.openBrace */) { + pos++; + return token = 18 /* SyntaxKind.OpenBraceToken */; + } + // First non-whitespace character on this line. + var firstNonWhitespace = 0; + // These initial values are special because the first line is: + // firstNonWhitespace = 0 to indicate that we want leading whitespace, + while (pos < end) { + char = text.charCodeAt(pos); + if (char === 123 /* CharacterCodes.openBrace */) { + break; + } + if (char === 60 /* CharacterCodes.lessThan */) { + if (isConflictMarkerTrivia(text, pos)) { + pos = scanConflictMarkerTrivia(text, pos, error); + return token = 7 /* SyntaxKind.ConflictMarkerTrivia */; + } + break; + } + if (char === 62 /* CharacterCodes.greaterThan */) { + error(ts.Diagnostics.Unexpected_token_Did_you_mean_or_gt, pos, 1); + } + if (char === 125 /* CharacterCodes.closeBrace */) { + error(ts.Diagnostics.Unexpected_token_Did_you_mean_or_rbrace, pos, 1); + } + // FirstNonWhitespace is 0, then we only see whitespaces so far. If we see a linebreak, we want to ignore that whitespaces. + // i.e (- : whitespace) + //
---- + //
becomes
+ // + //
----
becomes
----
+ if (isLineBreak(char) && firstNonWhitespace === 0) { + firstNonWhitespace = -1; + } + else if (!allowMultilineJsxText && isLineBreak(char) && firstNonWhitespace > 0) { + // Stop JsxText on each line during formatting. This allows the formatter to + // indent each line correctly. + break; + } + else if (!isWhiteSpaceLike(char)) { + firstNonWhitespace = pos; + } + pos++; + } + tokenValue = text.substring(startPos, pos); + return firstNonWhitespace === -1 ? 12 /* SyntaxKind.JsxTextAllWhiteSpaces */ : 11 /* SyntaxKind.JsxText */; + } + // Scans a JSX identifier; these differ from normal identifiers in that + // they allow dashes + function scanJsxIdentifier() { + if (tokenIsIdentifierOrKeyword(token)) { + // An identifier or keyword has already been parsed - check for a `-` or a single instance of `:` and then append it and + // everything after it to the token + // Do note that this means that `scanJsxIdentifier` effectively _mutates_ the visible token without advancing to a new token + // Any caller should be expecting this behavior and should only read the pos or token value after calling it. + var namespaceSeparator = false; + while (pos < end) { + var ch = text.charCodeAt(pos); + if (ch === 45 /* CharacterCodes.minus */) { + tokenValue += "-"; + pos++; + continue; + } + else if (ch === 58 /* CharacterCodes.colon */ && !namespaceSeparator) { + tokenValue += ":"; + pos++; + namespaceSeparator = true; + token = 79 /* SyntaxKind.Identifier */; // swap from keyword kind to identifier kind + continue; + } + var oldPos = pos; + tokenValue += scanIdentifierParts(); // reuse `scanIdentifierParts` so unicode escapes are handled + if (pos === oldPos) { + break; + } + } + // Do not include a trailing namespace separator in the token, since this is against the spec. + if (tokenValue.slice(-1) === ":") { + tokenValue = tokenValue.slice(0, -1); + pos--; + } + return getIdentifierToken(); + } + return token; + } + function scanJsxAttributeValue() { + startPos = pos; + switch (text.charCodeAt(pos)) { + case 34 /* CharacterCodes.doubleQuote */: + case 39 /* CharacterCodes.singleQuote */: + tokenValue = scanString(/*jsxAttributeString*/ true); + return token = 10 /* SyntaxKind.StringLiteral */; + default: + // If this scans anything other than `{`, it's a parse error. + return scan(); + } + } + function reScanJsxAttributeValue() { + pos = tokenPos = startPos; + return scanJsxAttributeValue(); + } + function scanJsDocToken() { + startPos = tokenPos = pos; + tokenFlags = 0 /* TokenFlags.None */; + if (pos >= end) { + return token = 1 /* SyntaxKind.EndOfFileToken */; + } + var ch = codePointAt(text, pos); + pos += charSize(ch); + switch (ch) { + case 9 /* CharacterCodes.tab */: + case 11 /* CharacterCodes.verticalTab */: + case 12 /* CharacterCodes.formFeed */: + case 32 /* CharacterCodes.space */: + while (pos < end && isWhiteSpaceSingleLine(text.charCodeAt(pos))) { + pos++; + } + return token = 5 /* SyntaxKind.WhitespaceTrivia */; + case 64 /* CharacterCodes.at */: + return token = 59 /* SyntaxKind.AtToken */; + case 13 /* CharacterCodes.carriageReturn */: + if (text.charCodeAt(pos) === 10 /* CharacterCodes.lineFeed */) { + pos++; + } + // falls through + case 10 /* CharacterCodes.lineFeed */: + tokenFlags |= 1 /* TokenFlags.PrecedingLineBreak */; + return token = 4 /* SyntaxKind.NewLineTrivia */; + case 42 /* CharacterCodes.asterisk */: + return token = 41 /* SyntaxKind.AsteriskToken */; + case 123 /* CharacterCodes.openBrace */: + return token = 18 /* SyntaxKind.OpenBraceToken */; + case 125 /* CharacterCodes.closeBrace */: + return token = 19 /* SyntaxKind.CloseBraceToken */; + case 91 /* CharacterCodes.openBracket */: + return token = 22 /* SyntaxKind.OpenBracketToken */; + case 93 /* CharacterCodes.closeBracket */: + return token = 23 /* SyntaxKind.CloseBracketToken */; + case 60 /* CharacterCodes.lessThan */: + return token = 29 /* SyntaxKind.LessThanToken */; + case 62 /* CharacterCodes.greaterThan */: + return token = 31 /* SyntaxKind.GreaterThanToken */; + case 61 /* CharacterCodes.equals */: + return token = 63 /* SyntaxKind.EqualsToken */; + case 44 /* CharacterCodes.comma */: + return token = 27 /* SyntaxKind.CommaToken */; + case 46 /* CharacterCodes.dot */: + return token = 24 /* SyntaxKind.DotToken */; + case 96 /* CharacterCodes.backtick */: + return token = 61 /* SyntaxKind.BacktickToken */; + case 35 /* CharacterCodes.hash */: + return token = 62 /* SyntaxKind.HashToken */; + case 92 /* CharacterCodes.backslash */: + pos--; + var extendedCookedChar = peekExtendedUnicodeEscape(); + if (extendedCookedChar >= 0 && isIdentifierStart(extendedCookedChar, languageVersion)) { + pos += 3; + tokenFlags |= 8 /* TokenFlags.ExtendedUnicodeEscape */; + tokenValue = scanExtendedUnicodeEscape() + scanIdentifierParts(); + return token = getIdentifierToken(); + } + var cookedChar = peekUnicodeEscape(); + if (cookedChar >= 0 && isIdentifierStart(cookedChar, languageVersion)) { + pos += 6; + tokenFlags |= 1024 /* TokenFlags.UnicodeEscape */; + tokenValue = String.fromCharCode(cookedChar) + scanIdentifierParts(); + return token = getIdentifierToken(); + } + pos++; + return token = 0 /* SyntaxKind.Unknown */; + } + if (isIdentifierStart(ch, languageVersion)) { + var char = ch; + while (pos < end && isIdentifierPart(char = codePointAt(text, pos), languageVersion) || text.charCodeAt(pos) === 45 /* CharacterCodes.minus */) + pos += charSize(char); + tokenValue = text.substring(tokenPos, pos); + if (char === 92 /* CharacterCodes.backslash */) { + tokenValue += scanIdentifierParts(); + } + return token = getIdentifierToken(); + } + else { + return token = 0 /* SyntaxKind.Unknown */; + } + } + function speculationHelper(callback, isLookahead) { + var savePos = pos; + var saveStartPos = startPos; + var saveTokenPos = tokenPos; + var saveToken = token; + var saveTokenValue = tokenValue; + var saveTokenFlags = tokenFlags; + var result = callback(); + // If our callback returned something 'falsy' or we're just looking ahead, + // then unconditionally restore us to where we were. + if (!result || isLookahead) { + pos = savePos; + startPos = saveStartPos; + tokenPos = saveTokenPos; + token = saveToken; + tokenValue = saveTokenValue; + tokenFlags = saveTokenFlags; + } + return result; + } + function scanRange(start, length, callback) { + var saveEnd = end; + var savePos = pos; + var saveStartPos = startPos; + var saveTokenPos = tokenPos; + var saveToken = token; + var saveTokenValue = tokenValue; + var saveTokenFlags = tokenFlags; + var saveErrorExpectations = commentDirectives; + setText(text, start, length); + var result = callback(); + end = saveEnd; + pos = savePos; + startPos = saveStartPos; + tokenPos = saveTokenPos; + token = saveToken; + tokenValue = saveTokenValue; + tokenFlags = saveTokenFlags; + commentDirectives = saveErrorExpectations; + return result; + } + function lookAhead(callback) { + return speculationHelper(callback, /*isLookahead*/ true); + } + function tryScan(callback) { + return speculationHelper(callback, /*isLookahead*/ false); + } + function getText() { + return text; + } + function clearCommentDirectives() { + commentDirectives = undefined; + } + function setText(newText, start, length) { + text = newText || ""; + end = length === undefined ? text.length : start + length; + setTextPos(start || 0); + } + function setOnError(errorCallback) { + onError = errorCallback; + } + function setScriptTarget(scriptTarget) { + languageVersion = scriptTarget; + } + function setLanguageVariant(variant) { + languageVariant = variant; + } + function setTextPos(textPos) { + ts.Debug.assert(textPos >= 0); + pos = textPos; + startPos = textPos; + tokenPos = textPos; + token = 0 /* SyntaxKind.Unknown */; + tokenValue = undefined; + tokenFlags = 0 /* TokenFlags.None */; + } + function setInJSDocType(inType) { + inJSDocType += inType ? 1 : -1; + } + } + ts.createScanner = createScanner; + /* @internal */ + var codePointAt = String.prototype.codePointAt ? function (s, i) { return s.codePointAt(i); } : function codePointAt(str, i) { + // from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/codePointAt + var size = str.length; + // Account for out-of-bounds indices: + if (i < 0 || i >= size) { + return undefined; // String.codePointAt returns `undefined` for OOB indexes + } + // Get the first code unit + var first = str.charCodeAt(i); + // check if it’s the start of a surrogate pair + if (first >= 0xD800 && first <= 0xDBFF && size > i + 1) { // high surrogate and there is a next code unit + var second = str.charCodeAt(i + 1); + if (second >= 0xDC00 && second <= 0xDFFF) { // low surrogate + // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae + return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000; + } + } + return first; + }; + /* @internal */ + function charSize(ch) { + if (ch >= 0x10000) { + return 2; + } + return 1; + } + // Derived from the 10.1.1 UTF16Encoding of the ES6 Spec. + function utf16EncodeAsStringFallback(codePoint) { + ts.Debug.assert(0x0 <= codePoint && codePoint <= 0x10FFFF); + if (codePoint <= 65535) { + return String.fromCharCode(codePoint); + } + var codeUnit1 = Math.floor((codePoint - 65536) / 1024) + 0xD800; + var codeUnit2 = ((codePoint - 65536) % 1024) + 0xDC00; + return String.fromCharCode(codeUnit1, codeUnit2); + } + var utf16EncodeAsStringWorker = String.fromCodePoint ? function (codePoint) { return String.fromCodePoint(codePoint); } : utf16EncodeAsStringFallback; + /* @internal */ + function utf16EncodeAsString(codePoint) { + return utf16EncodeAsStringWorker(codePoint); + } + ts.utf16EncodeAsString = utf16EncodeAsString; +})(ts || (ts = {})); +var ts; +(function (ts) { + function isExternalModuleNameRelative(moduleName) { + // TypeScript 1.0 spec (April 2014): 11.2.1 + // An external module name is "relative" if the first term is "." or "..". + // Update: We also consider a path like `C:\foo.ts` "relative" because we do not search for it in `node_modules` or treat it as an ambient module. + return ts.pathIsRelative(moduleName) || ts.isRootedDiskPath(moduleName); + } + ts.isExternalModuleNameRelative = isExternalModuleNameRelative; + function sortAndDeduplicateDiagnostics(diagnostics) { + return ts.sortAndDeduplicate(diagnostics, ts.compareDiagnostics); + } + ts.sortAndDeduplicateDiagnostics = sortAndDeduplicateDiagnostics; + function getDefaultLibFileName(options) { + switch (ts.getEmitScriptTarget(options)) { + case 99 /* ScriptTarget.ESNext */: + return "lib.esnext.full.d.ts"; + case 9 /* ScriptTarget.ES2022 */: + return "lib.es2022.full.d.ts"; + case 8 /* ScriptTarget.ES2021 */: + return "lib.es2021.full.d.ts"; + case 7 /* ScriptTarget.ES2020 */: + return "lib.es2020.full.d.ts"; + case 6 /* ScriptTarget.ES2019 */: + return "lib.es2019.full.d.ts"; + case 5 /* ScriptTarget.ES2018 */: + return "lib.es2018.full.d.ts"; + case 4 /* ScriptTarget.ES2017 */: + return "lib.es2017.full.d.ts"; + case 3 /* ScriptTarget.ES2016 */: + return "lib.es2016.full.d.ts"; + case 2 /* ScriptTarget.ES2015 */: + return "lib.es6.d.ts"; // We don't use lib.es2015.full.d.ts due to breaking change. + default: + return "lib.d.ts"; + } + } + ts.getDefaultLibFileName = getDefaultLibFileName; + function textSpanEnd(span) { + return span.start + span.length; + } + ts.textSpanEnd = textSpanEnd; + function textSpanIsEmpty(span) { + return span.length === 0; + } + ts.textSpanIsEmpty = textSpanIsEmpty; + function textSpanContainsPosition(span, position) { + return position >= span.start && position < textSpanEnd(span); + } + ts.textSpanContainsPosition = textSpanContainsPosition; + /* @internal */ + function textRangeContainsPositionInclusive(span, position) { + return position >= span.pos && position <= span.end; + } + ts.textRangeContainsPositionInclusive = textRangeContainsPositionInclusive; + // Returns true if 'span' contains 'other'. + function textSpanContainsTextSpan(span, other) { + return other.start >= span.start && textSpanEnd(other) <= textSpanEnd(span); + } + ts.textSpanContainsTextSpan = textSpanContainsTextSpan; + function textSpanOverlapsWith(span, other) { + return textSpanOverlap(span, other) !== undefined; + } + ts.textSpanOverlapsWith = textSpanOverlapsWith; + function textSpanOverlap(span1, span2) { + var overlap = textSpanIntersection(span1, span2); + return overlap && overlap.length === 0 ? undefined : overlap; + } + ts.textSpanOverlap = textSpanOverlap; + function textSpanIntersectsWithTextSpan(span, other) { + return decodedTextSpanIntersectsWith(span.start, span.length, other.start, other.length); + } + ts.textSpanIntersectsWithTextSpan = textSpanIntersectsWithTextSpan; + function textSpanIntersectsWith(span, start, length) { + return decodedTextSpanIntersectsWith(span.start, span.length, start, length); + } + ts.textSpanIntersectsWith = textSpanIntersectsWith; + function decodedTextSpanIntersectsWith(start1, length1, start2, length2) { + var end1 = start1 + length1; + var end2 = start2 + length2; + return start2 <= end1 && end2 >= start1; + } + ts.decodedTextSpanIntersectsWith = decodedTextSpanIntersectsWith; + function textSpanIntersectsWithPosition(span, position) { + return position <= textSpanEnd(span) && position >= span.start; + } + ts.textSpanIntersectsWithPosition = textSpanIntersectsWithPosition; + function textSpanIntersection(span1, span2) { + var start = Math.max(span1.start, span2.start); + var end = Math.min(textSpanEnd(span1), textSpanEnd(span2)); + return start <= end ? createTextSpanFromBounds(start, end) : undefined; + } + ts.textSpanIntersection = textSpanIntersection; + function createTextSpan(start, length) { + if (start < 0) { + throw new Error("start < 0"); + } + if (length < 0) { + throw new Error("length < 0"); + } + return { start: start, length: length }; + } + ts.createTextSpan = createTextSpan; + function createTextSpanFromBounds(start, end) { + return createTextSpan(start, end - start); + } + ts.createTextSpanFromBounds = createTextSpanFromBounds; + function textChangeRangeNewSpan(range) { + return createTextSpan(range.span.start, range.newLength); + } + ts.textChangeRangeNewSpan = textChangeRangeNewSpan; + function textChangeRangeIsUnchanged(range) { + return textSpanIsEmpty(range.span) && range.newLength === 0; + } + ts.textChangeRangeIsUnchanged = textChangeRangeIsUnchanged; + function createTextChangeRange(span, newLength) { + if (newLength < 0) { + throw new Error("newLength < 0"); + } + return { span: span, newLength: newLength }; + } + ts.createTextChangeRange = createTextChangeRange; + ts.unchangedTextChangeRange = createTextChangeRange(createTextSpan(0, 0), 0); // eslint-disable-line prefer-const + /** + * Called to merge all the changes that occurred across several versions of a script snapshot + * into a single change. i.e. if a user keeps making successive edits to a script we will + * have a text change from V1 to V2, V2 to V3, ..., Vn. + * + * This function will then merge those changes into a single change range valid between V1 and + * Vn. + */ + function collapseTextChangeRangesAcrossMultipleVersions(changes) { + if (changes.length === 0) { + return ts.unchangedTextChangeRange; + } + if (changes.length === 1) { + return changes[0]; + } + // We change from talking about { { oldStart, oldLength }, newLength } to { oldStart, oldEnd, newEnd } + // as it makes things much easier to reason about. + var change0 = changes[0]; + var oldStartN = change0.span.start; + var oldEndN = textSpanEnd(change0.span); + var newEndN = oldStartN + change0.newLength; + for (var i = 1; i < changes.length; i++) { + var nextChange = changes[i]; + // Consider the following case: + // i.e. two edits. The first represents the text change range { { 10, 50 }, 30 }. i.e. The span starting + // at 10, with length 50 is reduced to length 30. The second represents the text change range { { 30, 30 }, 40 }. + // i.e. the span starting at 30 with length 30 is increased to length 40. + // + // 0 10 20 30 40 50 60 70 80 90 100 + // ------------------------------------------------------------------------------------------------------- + // | / + // | /---- + // T1 | /---- + // | /---- + // | /---- + // ------------------------------------------------------------------------------------------------------- + // | \ + // | \ + // T2 | \ + // | \ + // | \ + // ------------------------------------------------------------------------------------------------------- + // + // Merging these turns out to not be too difficult. First, determining the new start of the change is trivial + // it's just the min of the old and new starts. i.e.: + // + // 0 10 20 30 40 50 60 70 80 90 100 + // ------------------------------------------------------------*------------------------------------------ + // | / + // | /---- + // T1 | /---- + // | /---- + // | /---- + // ----------------------------------------$-------------------$------------------------------------------ + // . | \ + // . | \ + // T2 . | \ + // . | \ + // . | \ + // ----------------------------------------------------------------------*-------------------------------- + // + // (Note the dots represent the newly inferred start. + // Determining the new and old end is also pretty simple. Basically it boils down to paying attention to the + // absolute positions at the asterisks, and the relative change between the dollar signs. Basically, we see + // which if the two $'s precedes the other, and we move that one forward until they line up. in this case that + // means: + // + // 0 10 20 30 40 50 60 70 80 90 100 + // --------------------------------------------------------------------------------*---------------------- + // | / + // | /---- + // T1 | /---- + // | /---- + // | /---- + // ------------------------------------------------------------$------------------------------------------ + // . | \ + // . | \ + // T2 . | \ + // . | \ + // . | \ + // ----------------------------------------------------------------------*-------------------------------- + // + // In other words (in this case), we're recognizing that the second edit happened after where the first edit + // ended with a delta of 20 characters (60 - 40). Thus, if we go back in time to where the first edit started + // that's the same as if we started at char 80 instead of 60. + // + // As it so happens, the same logic applies if the second edit precedes the first edit. In that case rather + // than pushing the first edit forward to match the second, we'll push the second edit forward to match the + // first. + // + // In this case that means we have { oldStart: 10, oldEnd: 80, newEnd: 70 } or, in TextChangeRange + // semantics: { { start: 10, length: 70 }, newLength: 60 } + // + // The math then works out as follows. + // If we have { oldStart1, oldEnd1, newEnd1 } and { oldStart2, oldEnd2, newEnd2 } then we can compute the + // final result like so: + // + // { + // oldStart3: Min(oldStart1, oldStart2), + // oldEnd3: Max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1)), + // newEnd3: Max(newEnd2, newEnd2 + (newEnd1 - oldEnd2)) + // } + var oldStart1 = oldStartN; + var oldEnd1 = oldEndN; + var newEnd1 = newEndN; + var oldStart2 = nextChange.span.start; + var oldEnd2 = textSpanEnd(nextChange.span); + var newEnd2 = oldStart2 + nextChange.newLength; + oldStartN = Math.min(oldStart1, oldStart2); + oldEndN = Math.max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1)); + newEndN = Math.max(newEnd2, newEnd2 + (newEnd1 - oldEnd2)); + } + return createTextChangeRange(createTextSpanFromBounds(oldStartN, oldEndN), /*newLength*/ newEndN - oldStartN); + } + ts.collapseTextChangeRangesAcrossMultipleVersions = collapseTextChangeRangesAcrossMultipleVersions; + function getTypeParameterOwner(d) { + if (d && d.kind === 165 /* SyntaxKind.TypeParameter */) { + for (var current = d; current; current = current.parent) { + if (isFunctionLike(current) || isClassLike(current) || current.kind === 261 /* SyntaxKind.InterfaceDeclaration */) { + return current; + } + } + } + } + ts.getTypeParameterOwner = getTypeParameterOwner; + function isParameterPropertyDeclaration(node, parent) { + return ts.hasSyntacticModifier(node, 16476 /* ModifierFlags.ParameterPropertyModifier */) && parent.kind === 173 /* SyntaxKind.Constructor */; + } + ts.isParameterPropertyDeclaration = isParameterPropertyDeclaration; + function isEmptyBindingPattern(node) { + if (isBindingPattern(node)) { + return ts.every(node.elements, isEmptyBindingElement); + } + return false; + } + ts.isEmptyBindingPattern = isEmptyBindingPattern; + function isEmptyBindingElement(node) { + if (ts.isOmittedExpression(node)) { + return true; + } + return isEmptyBindingPattern(node.name); + } + ts.isEmptyBindingElement = isEmptyBindingElement; + function walkUpBindingElementsAndPatterns(binding) { + var node = binding.parent; + while (ts.isBindingElement(node.parent)) { + node = node.parent.parent; + } + return node.parent; + } + ts.walkUpBindingElementsAndPatterns = walkUpBindingElementsAndPatterns; + function getCombinedFlags(node, getFlags) { + if (ts.isBindingElement(node)) { + node = walkUpBindingElementsAndPatterns(node); + } + var flags = getFlags(node); + if (node.kind === 257 /* SyntaxKind.VariableDeclaration */) { + node = node.parent; + } + if (node && node.kind === 258 /* SyntaxKind.VariableDeclarationList */) { + flags |= getFlags(node); + node = node.parent; + } + if (node && node.kind === 240 /* SyntaxKind.VariableStatement */) { + flags |= getFlags(node); + } + return flags; + } + function getCombinedModifierFlags(node) { + return getCombinedFlags(node, ts.getEffectiveModifierFlags); + } + ts.getCombinedModifierFlags = getCombinedModifierFlags; + /* @internal */ + function getCombinedNodeFlagsAlwaysIncludeJSDoc(node) { + return getCombinedFlags(node, ts.getEffectiveModifierFlagsAlwaysIncludeJSDoc); + } + ts.getCombinedNodeFlagsAlwaysIncludeJSDoc = getCombinedNodeFlagsAlwaysIncludeJSDoc; + // Returns the node flags for this node and all relevant parent nodes. This is done so that + // nodes like variable declarations and binding elements can returned a view of their flags + // that includes the modifiers from their container. i.e. flags like export/declare aren't + // stored on the variable declaration directly, but on the containing variable statement + // (if it has one). Similarly, flags for let/const are stored on the variable declaration + // list. By calling this function, all those flags are combined so that the client can treat + // the node as if it actually had those flags. + function getCombinedNodeFlags(node) { + return getCombinedFlags(node, function (n) { return n.flags; }); + } + ts.getCombinedNodeFlags = getCombinedNodeFlags; + /* @internal */ + ts.supportedLocaleDirectories = ["cs", "de", "es", "fr", "it", "ja", "ko", "pl", "pt-br", "ru", "tr", "zh-cn", "zh-tw"]; + /** + * Checks to see if the locale is in the appropriate format, + * and if it is, attempts to set the appropriate language. + */ + function validateLocaleAndSetLanguage(locale, sys, errors) { + var lowerCaseLocale = locale.toLowerCase(); + var matchResult = /^([a-z]+)([_\-]([a-z]+))?$/.exec(lowerCaseLocale); + if (!matchResult) { + if (errors) { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1, "en", "ja-jp")); + } + return; + } + var language = matchResult[1]; + var territory = matchResult[3]; + // First try the entire locale, then fall back to just language if that's all we have. + // Either ways do not fail, and fallback to the English diagnostic strings. + if (ts.contains(ts.supportedLocaleDirectories, lowerCaseLocale) && !trySetLanguageAndTerritory(language, territory, errors)) { + trySetLanguageAndTerritory(language, /*territory*/ undefined, errors); + } + // Set the UI locale for string collation + ts.setUILocale(locale); + function trySetLanguageAndTerritory(language, territory, errors) { + var compilerFilePath = ts.normalizePath(sys.getExecutingFilePath()); + var containingDirectoryPath = ts.getDirectoryPath(compilerFilePath); + var filePath = ts.combinePaths(containingDirectoryPath, language); + if (territory) { + filePath = filePath + "-" + territory; + } + filePath = sys.resolvePath(ts.combinePaths(filePath, "diagnosticMessages.generated.json")); + if (!sys.fileExists(filePath)) { + return false; + } + // TODO: Add codePage support for readFile? + var fileContents = ""; + try { + fileContents = sys.readFile(filePath); + } + catch (e) { + if (errors) { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Unable_to_open_file_0, filePath)); + } + return false; + } + try { + // this is a global mutation (or live binding update)! + ts.setLocalizedDiagnosticMessages(JSON.parse(fileContents)); + } + catch (_a) { + if (errors) { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Corrupted_locale_file_0, filePath)); + } + return false; + } + return true; + } + } + ts.validateLocaleAndSetLanguage = validateLocaleAndSetLanguage; + function getOriginalNode(node, nodeTest) { + if (node) { + while (node.original !== undefined) { + node = node.original; + } + } + return !nodeTest || nodeTest(node) ? node : undefined; + } + ts.getOriginalNode = getOriginalNode; + function findAncestor(node, callback) { + while (node) { + var result = callback(node); + if (result === "quit") { + return undefined; + } + else if (result) { + return node; + } + node = node.parent; + } + return undefined; + } + ts.findAncestor = findAncestor; + /** + * Gets a value indicating whether a node originated in the parse tree. + * + * @param node The node to test. + */ + function isParseTreeNode(node) { + return (node.flags & 8 /* NodeFlags.Synthesized */) === 0; + } + ts.isParseTreeNode = isParseTreeNode; + function getParseTreeNode(node, nodeTest) { + if (node === undefined || isParseTreeNode(node)) { + return node; + } + node = node.original; + while (node) { + if (isParseTreeNode(node)) { + return !nodeTest || nodeTest(node) ? node : undefined; + } + node = node.original; + } + } + ts.getParseTreeNode = getParseTreeNode; + /** Add an extra underscore to identifiers that start with two underscores to avoid issues with magic names like '__proto__' */ + function escapeLeadingUnderscores(identifier) { + return (identifier.length >= 2 && identifier.charCodeAt(0) === 95 /* CharacterCodes._ */ && identifier.charCodeAt(1) === 95 /* CharacterCodes._ */ ? "_" + identifier : identifier); + } + ts.escapeLeadingUnderscores = escapeLeadingUnderscores; + /** + * Remove extra underscore from escaped identifier text content. + * + * @param identifier The escaped identifier text. + * @returns The unescaped identifier text. + */ + function unescapeLeadingUnderscores(identifier) { + var id = identifier; + return id.length >= 3 && id.charCodeAt(0) === 95 /* CharacterCodes._ */ && id.charCodeAt(1) === 95 /* CharacterCodes._ */ && id.charCodeAt(2) === 95 /* CharacterCodes._ */ ? id.substr(1) : id; + } + ts.unescapeLeadingUnderscores = unescapeLeadingUnderscores; + function idText(identifierOrPrivateName) { + return unescapeLeadingUnderscores(identifierOrPrivateName.escapedText); + } + ts.idText = idText; + function symbolName(symbol) { + if (symbol.valueDeclaration && isPrivateIdentifierClassElementDeclaration(symbol.valueDeclaration)) { + return idText(symbol.valueDeclaration.name); + } + return unescapeLeadingUnderscores(symbol.escapedName); + } + ts.symbolName = symbolName; + /** + * A JSDocTypedef tag has an _optional_ name field - if a name is not directly present, we should + * attempt to draw the name from the node the declaration is on (as that declaration is what its' symbol + * will be merged with) + */ + function nameForNamelessJSDocTypedef(declaration) { + var hostNode = declaration.parent.parent; + if (!hostNode) { + return undefined; + } + // Covers classes, functions - any named declaration host node + if (isDeclaration(hostNode)) { + return getDeclarationIdentifier(hostNode); + } + // Covers remaining cases (returning undefined if none match). + switch (hostNode.kind) { + case 240 /* SyntaxKind.VariableStatement */: + if (hostNode.declarationList && hostNode.declarationList.declarations[0]) { + return getDeclarationIdentifier(hostNode.declarationList.declarations[0]); + } + break; + case 241 /* SyntaxKind.ExpressionStatement */: + var expr = hostNode.expression; + if (expr.kind === 223 /* SyntaxKind.BinaryExpression */ && expr.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */) { + expr = expr.left; + } + switch (expr.kind) { + case 208 /* SyntaxKind.PropertyAccessExpression */: + return expr.name; + case 209 /* SyntaxKind.ElementAccessExpression */: + var arg = expr.argumentExpression; + if (ts.isIdentifier(arg)) { + return arg; + } + } + break; + case 214 /* SyntaxKind.ParenthesizedExpression */: { + return getDeclarationIdentifier(hostNode.expression); + } + case 253 /* SyntaxKind.LabeledStatement */: { + if (isDeclaration(hostNode.statement) || isExpression(hostNode.statement)) { + return getDeclarationIdentifier(hostNode.statement); + } + break; + } + } + } + function getDeclarationIdentifier(node) { + var name = getNameOfDeclaration(node); + return name && ts.isIdentifier(name) ? name : undefined; + } + /** @internal */ + function nodeHasName(statement, name) { + if (isNamedDeclaration(statement) && ts.isIdentifier(statement.name) && idText(statement.name) === idText(name)) { + return true; + } + if (ts.isVariableStatement(statement) && ts.some(statement.declarationList.declarations, function (d) { return nodeHasName(d, name); })) { + return true; + } + return false; + } + ts.nodeHasName = nodeHasName; + function getNameOfJSDocTypedef(declaration) { + return declaration.name || nameForNamelessJSDocTypedef(declaration); + } + ts.getNameOfJSDocTypedef = getNameOfJSDocTypedef; + /** @internal */ + function isNamedDeclaration(node) { + return !!node.name; // A 'name' property should always be a DeclarationName. + } + ts.isNamedDeclaration = isNamedDeclaration; + /** @internal */ + function getNonAssignedNameOfDeclaration(declaration) { + switch (declaration.kind) { + case 79 /* SyntaxKind.Identifier */: + return declaration; + case 350 /* SyntaxKind.JSDocPropertyTag */: + case 343 /* SyntaxKind.JSDocParameterTag */: { + var name = declaration.name; + if (name.kind === 163 /* SyntaxKind.QualifiedName */) { + return name.right; + } + break; + } + case 210 /* SyntaxKind.CallExpression */: + case 223 /* SyntaxKind.BinaryExpression */: { + var expr_1 = declaration; + switch (ts.getAssignmentDeclarationKind(expr_1)) { + case 1 /* AssignmentDeclarationKind.ExportsProperty */: + case 4 /* AssignmentDeclarationKind.ThisProperty */: + case 5 /* AssignmentDeclarationKind.Property */: + case 3 /* AssignmentDeclarationKind.PrototypeProperty */: + return ts.getElementOrPropertyAccessArgumentExpressionOrName(expr_1.left); + case 7 /* AssignmentDeclarationKind.ObjectDefinePropertyValue */: + case 8 /* AssignmentDeclarationKind.ObjectDefinePropertyExports */: + case 9 /* AssignmentDeclarationKind.ObjectDefinePrototypeProperty */: + return expr_1.arguments[1]; + default: + return undefined; + } + } + case 348 /* SyntaxKind.JSDocTypedefTag */: + return getNameOfJSDocTypedef(declaration); + case 342 /* SyntaxKind.JSDocEnumTag */: + return nameForNamelessJSDocTypedef(declaration); + case 274 /* SyntaxKind.ExportAssignment */: { + var expression = declaration.expression; + return ts.isIdentifier(expression) ? expression : undefined; + } + case 209 /* SyntaxKind.ElementAccessExpression */: + var expr = declaration; + if (ts.isBindableStaticElementAccessExpression(expr)) { + return expr.argumentExpression; + } + } + return declaration.name; + } + ts.getNonAssignedNameOfDeclaration = getNonAssignedNameOfDeclaration; + function getNameOfDeclaration(declaration) { + if (declaration === undefined) + return undefined; + return getNonAssignedNameOfDeclaration(declaration) || + (ts.isFunctionExpression(declaration) || ts.isArrowFunction(declaration) || ts.isClassExpression(declaration) ? getAssignedName(declaration) : undefined); + } + ts.getNameOfDeclaration = getNameOfDeclaration; + /*@internal*/ + function getAssignedName(node) { + if (!node.parent) { + return undefined; + } + else if (ts.isPropertyAssignment(node.parent) || ts.isBindingElement(node.parent)) { + return node.parent.name; + } + else if (ts.isBinaryExpression(node.parent) && node === node.parent.right) { + if (ts.isIdentifier(node.parent.left)) { + return node.parent.left; + } + else if (ts.isAccessExpression(node.parent.left)) { + return ts.getElementOrPropertyAccessArgumentExpressionOrName(node.parent.left); + } + } + else if (ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name)) { + return node.parent.name; + } + } + ts.getAssignedName = getAssignedName; + function getDecorators(node) { + if (ts.hasDecorators(node)) { + return ts.filter(node.modifiers, ts.isDecorator); + } + } + ts.getDecorators = getDecorators; + function getModifiers(node) { + if (ts.hasSyntacticModifier(node, 126975 /* ModifierFlags.Modifier */)) { + return ts.filter(node.modifiers, isModifier); + } + } + ts.getModifiers = getModifiers; + function getJSDocParameterTagsWorker(param, noCache) { + if (param.name) { + if (ts.isIdentifier(param.name)) { + var name_1 = param.name.escapedText; + return getJSDocTagsWorker(param.parent, noCache).filter(function (tag) { return ts.isJSDocParameterTag(tag) && ts.isIdentifier(tag.name) && tag.name.escapedText === name_1; }); + } + else { + var i = param.parent.parameters.indexOf(param); + ts.Debug.assert(i > -1, "Parameters should always be in their parents' parameter list"); + var paramTags = getJSDocTagsWorker(param.parent, noCache).filter(ts.isJSDocParameterTag); + if (i < paramTags.length) { + return [paramTags[i]]; + } + } + } + // return empty array for: out-of-order binding patterns and JSDoc function syntax, which has un-named parameters + return ts.emptyArray; + } + /** + * Gets the JSDoc parameter tags for the node if present. + * + * @remarks Returns any JSDoc param tag whose name matches the provided + * parameter, whether a param tag on a containing function + * expression, or a param tag on a variable declaration whose + * initializer is the containing function. The tags closest to the + * node are returned first, so in the previous example, the param + * tag on the containing function expression would be first. + * + * For binding patterns, parameter tags are matched by position. + */ + function getJSDocParameterTags(param) { + return getJSDocParameterTagsWorker(param, /*noCache*/ false); + } + ts.getJSDocParameterTags = getJSDocParameterTags; + /* @internal */ + function getJSDocParameterTagsNoCache(param) { + return getJSDocParameterTagsWorker(param, /*noCache*/ true); + } + ts.getJSDocParameterTagsNoCache = getJSDocParameterTagsNoCache; + function getJSDocTypeParameterTagsWorker(param, noCache) { + var name = param.name.escapedText; + return getJSDocTagsWorker(param.parent, noCache).filter(function (tag) { + return ts.isJSDocTemplateTag(tag) && tag.typeParameters.some(function (tp) { return tp.name.escapedText === name; }); + }); + } + /** + * Gets the JSDoc type parameter tags for the node if present. + * + * @remarks Returns any JSDoc template tag whose names match the provided + * parameter, whether a template tag on a containing function + * expression, or a template tag on a variable declaration whose + * initializer is the containing function. The tags closest to the + * node are returned first, so in the previous example, the template + * tag on the containing function expression would be first. + */ + function getJSDocTypeParameterTags(param) { + return getJSDocTypeParameterTagsWorker(param, /*noCache*/ false); + } + ts.getJSDocTypeParameterTags = getJSDocTypeParameterTags; + /* @internal */ + function getJSDocTypeParameterTagsNoCache(param) { + return getJSDocTypeParameterTagsWorker(param, /*noCache*/ true); + } + ts.getJSDocTypeParameterTagsNoCache = getJSDocTypeParameterTagsNoCache; + /** + * Return true if the node has JSDoc parameter tags. + * + * @remarks Includes parameter tags that are not directly on the node, + * for example on a variable declaration whose initializer is a function expression. + */ + function hasJSDocParameterTags(node) { + return !!getFirstJSDocTag(node, ts.isJSDocParameterTag); + } + ts.hasJSDocParameterTags = hasJSDocParameterTags; + /** Gets the JSDoc augments tag for the node if present */ + function getJSDocAugmentsTag(node) { + return getFirstJSDocTag(node, ts.isJSDocAugmentsTag); + } + ts.getJSDocAugmentsTag = getJSDocAugmentsTag; + /** Gets the JSDoc implements tags for the node if present */ + function getJSDocImplementsTags(node) { + return getAllJSDocTags(node, ts.isJSDocImplementsTag); + } + ts.getJSDocImplementsTags = getJSDocImplementsTags; + /** Gets the JSDoc class tag for the node if present */ + function getJSDocClassTag(node) { + return getFirstJSDocTag(node, ts.isJSDocClassTag); + } + ts.getJSDocClassTag = getJSDocClassTag; + /** Gets the JSDoc public tag for the node if present */ + function getJSDocPublicTag(node) { + return getFirstJSDocTag(node, ts.isJSDocPublicTag); + } + ts.getJSDocPublicTag = getJSDocPublicTag; + /*@internal*/ + function getJSDocPublicTagNoCache(node) { + return getFirstJSDocTag(node, ts.isJSDocPublicTag, /*noCache*/ true); + } + ts.getJSDocPublicTagNoCache = getJSDocPublicTagNoCache; + /** Gets the JSDoc private tag for the node if present */ + function getJSDocPrivateTag(node) { + return getFirstJSDocTag(node, ts.isJSDocPrivateTag); + } + ts.getJSDocPrivateTag = getJSDocPrivateTag; + /*@internal*/ + function getJSDocPrivateTagNoCache(node) { + return getFirstJSDocTag(node, ts.isJSDocPrivateTag, /*noCache*/ true); + } + ts.getJSDocPrivateTagNoCache = getJSDocPrivateTagNoCache; + /** Gets the JSDoc protected tag for the node if present */ + function getJSDocProtectedTag(node) { + return getFirstJSDocTag(node, ts.isJSDocProtectedTag); + } + ts.getJSDocProtectedTag = getJSDocProtectedTag; + /*@internal*/ + function getJSDocProtectedTagNoCache(node) { + return getFirstJSDocTag(node, ts.isJSDocProtectedTag, /*noCache*/ true); + } + ts.getJSDocProtectedTagNoCache = getJSDocProtectedTagNoCache; + /** Gets the JSDoc protected tag for the node if present */ + function getJSDocReadonlyTag(node) { + return getFirstJSDocTag(node, ts.isJSDocReadonlyTag); + } + ts.getJSDocReadonlyTag = getJSDocReadonlyTag; + /*@internal*/ + function getJSDocReadonlyTagNoCache(node) { + return getFirstJSDocTag(node, ts.isJSDocReadonlyTag, /*noCache*/ true); + } + ts.getJSDocReadonlyTagNoCache = getJSDocReadonlyTagNoCache; + function getJSDocOverrideTagNoCache(node) { + return getFirstJSDocTag(node, ts.isJSDocOverrideTag, /*noCache*/ true); + } + ts.getJSDocOverrideTagNoCache = getJSDocOverrideTagNoCache; + /** Gets the JSDoc deprecated tag for the node if present */ + function getJSDocDeprecatedTag(node) { + return getFirstJSDocTag(node, ts.isJSDocDeprecatedTag); + } + ts.getJSDocDeprecatedTag = getJSDocDeprecatedTag; + /*@internal */ + function getJSDocDeprecatedTagNoCache(node) { + return getFirstJSDocTag(node, ts.isJSDocDeprecatedTag, /*noCache*/ true); + } + ts.getJSDocDeprecatedTagNoCache = getJSDocDeprecatedTagNoCache; + /** Gets the JSDoc enum tag for the node if present */ + function getJSDocEnumTag(node) { + return getFirstJSDocTag(node, ts.isJSDocEnumTag); + } + ts.getJSDocEnumTag = getJSDocEnumTag; + /** Gets the JSDoc this tag for the node if present */ + function getJSDocThisTag(node) { + return getFirstJSDocTag(node, ts.isJSDocThisTag); + } + ts.getJSDocThisTag = getJSDocThisTag; + /** Gets the JSDoc return tag for the node if present */ + function getJSDocReturnTag(node) { + return getFirstJSDocTag(node, ts.isJSDocReturnTag); + } + ts.getJSDocReturnTag = getJSDocReturnTag; + /** Gets the JSDoc template tag for the node if present */ + function getJSDocTemplateTag(node) { + return getFirstJSDocTag(node, ts.isJSDocTemplateTag); + } + ts.getJSDocTemplateTag = getJSDocTemplateTag; + /** Gets the JSDoc type tag for the node if present and valid */ + function getJSDocTypeTag(node) { + // We should have already issued an error if there were multiple type jsdocs, so just use the first one. + var tag = getFirstJSDocTag(node, ts.isJSDocTypeTag); + if (tag && tag.typeExpression && tag.typeExpression.type) { + return tag; + } + return undefined; + } + ts.getJSDocTypeTag = getJSDocTypeTag; + /** + * Gets the type node for the node if provided via JSDoc. + * + * @remarks The search includes any JSDoc param tag that relates + * to the provided parameter, for example a type tag on the + * parameter itself, or a param tag on a containing function + * expression, or a param tag on a variable declaration whose + * initializer is the containing function. The tags closest to the + * node are examined first, so in the previous example, the type + * tag directly on the node would be returned. + */ + function getJSDocType(node) { + var tag = getFirstJSDocTag(node, ts.isJSDocTypeTag); + if (!tag && ts.isParameter(node)) { + tag = ts.find(getJSDocParameterTags(node), function (tag) { return !!tag.typeExpression; }); + } + return tag && tag.typeExpression && tag.typeExpression.type; + } + ts.getJSDocType = getJSDocType; + /** + * Gets the return type node for the node if provided via JSDoc return tag or type tag. + * + * @remarks `getJSDocReturnTag` just gets the whole JSDoc tag. This function + * gets the type from inside the braces, after the fat arrow, etc. + */ + function getJSDocReturnType(node) { + var returnTag = getJSDocReturnTag(node); + if (returnTag && returnTag.typeExpression) { + return returnTag.typeExpression.type; + } + var typeTag = getJSDocTypeTag(node); + if (typeTag && typeTag.typeExpression) { + var type = typeTag.typeExpression.type; + if (ts.isTypeLiteralNode(type)) { + var sig = ts.find(type.members, ts.isCallSignatureDeclaration); + return sig && sig.type; + } + if (ts.isFunctionTypeNode(type) || ts.isJSDocFunctionType(type)) { + return type.type; + } + } + } + ts.getJSDocReturnType = getJSDocReturnType; + function getJSDocTagsWorker(node, noCache) { + var tags = node.jsDocCache; + // If cache is 'null', that means we did the work of searching for JSDoc tags and came up with nothing. + if (tags === undefined || noCache) { + var comments = ts.getJSDocCommentsAndTags(node, noCache); + ts.Debug.assert(comments.length < 2 || comments[0] !== comments[1]); + tags = ts.flatMap(comments, function (j) { return ts.isJSDoc(j) ? j.tags : j; }); + if (!noCache) { + node.jsDocCache = tags; + } + } + return tags; + } + /** Get all JSDoc tags related to a node, including those on parent nodes. */ + function getJSDocTags(node) { + return getJSDocTagsWorker(node, /*noCache*/ false); + } + ts.getJSDocTags = getJSDocTags; + /* @internal */ + function getJSDocTagsNoCache(node) { + return getJSDocTagsWorker(node, /*noCache*/ true); + } + ts.getJSDocTagsNoCache = getJSDocTagsNoCache; + /** Get the first JSDoc tag of a specified kind, or undefined if not present. */ + function getFirstJSDocTag(node, predicate, noCache) { + return ts.find(getJSDocTagsWorker(node, noCache), predicate); + } + /** Gets all JSDoc tags that match a specified predicate */ + function getAllJSDocTags(node, predicate) { + return getJSDocTags(node).filter(predicate); + } + ts.getAllJSDocTags = getAllJSDocTags; + /** Gets all JSDoc tags of a specified kind */ + function getAllJSDocTagsOfKind(node, kind) { + return getJSDocTags(node).filter(function (doc) { return doc.kind === kind; }); + } + ts.getAllJSDocTagsOfKind = getAllJSDocTagsOfKind; + /** Gets the text of a jsdoc comment, flattening links to their text. */ + function getTextOfJSDocComment(comment) { + return typeof comment === "string" ? comment + : comment === null || comment === void 0 ? void 0 : comment.map(function (c) { return c.kind === 324 /* SyntaxKind.JSDocText */ ? c.text : formatJSDocLink(c); }).join(""); + } + ts.getTextOfJSDocComment = getTextOfJSDocComment; + function formatJSDocLink(link) { + var kind = link.kind === 327 /* SyntaxKind.JSDocLink */ ? "link" + : link.kind === 328 /* SyntaxKind.JSDocLinkCode */ ? "linkcode" + : "linkplain"; + var name = link.name ? ts.entityNameToString(link.name) : ""; + var space = link.name && link.text.startsWith("://") ? "" : " "; + return "{@".concat(kind, " ").concat(name).concat(space).concat(link.text, "}"); + } + /** + * Gets the effective type parameters. If the node was parsed in a + * JavaScript file, gets the type parameters from the `@template` tag from JSDoc. + * + * This does *not* return type parameters from a jsdoc reference to a generic type, eg + * + * type Id = (x: T) => T + * /** @type {Id} / + * function id(x) { return x } + */ + function getEffectiveTypeParameterDeclarations(node) { + if (ts.isJSDocSignature(node)) { + return ts.emptyArray; + } + if (ts.isJSDocTypeAlias(node)) { + ts.Debug.assert(node.parent.kind === 323 /* SyntaxKind.JSDoc */); + return ts.flatMap(node.parent.tags, function (tag) { return ts.isJSDocTemplateTag(tag) ? tag.typeParameters : undefined; }); + } + if (node.typeParameters) { + return node.typeParameters; + } + if (ts.canHaveIllegalTypeParameters(node) && node.typeParameters) { + return node.typeParameters; + } + if (ts.isInJSFile(node)) { + var decls = ts.getJSDocTypeParameterDeclarations(node); + if (decls.length) { + return decls; + } + var typeTag = getJSDocType(node); + if (typeTag && ts.isFunctionTypeNode(typeTag) && typeTag.typeParameters) { + return typeTag.typeParameters; + } + } + return ts.emptyArray; + } + ts.getEffectiveTypeParameterDeclarations = getEffectiveTypeParameterDeclarations; + function getEffectiveConstraintOfTypeParameter(node) { + return node.constraint ? node.constraint : + ts.isJSDocTemplateTag(node.parent) && node === node.parent.typeParameters[0] ? node.parent.constraint : + undefined; + } + ts.getEffectiveConstraintOfTypeParameter = getEffectiveConstraintOfTypeParameter; + // #region + function isMemberName(node) { + return node.kind === 79 /* SyntaxKind.Identifier */ || node.kind === 80 /* SyntaxKind.PrivateIdentifier */; + } + ts.isMemberName = isMemberName; + /* @internal */ + function isGetOrSetAccessorDeclaration(node) { + return node.kind === 175 /* SyntaxKind.SetAccessor */ || node.kind === 174 /* SyntaxKind.GetAccessor */; + } + ts.isGetOrSetAccessorDeclaration = isGetOrSetAccessorDeclaration; + function isPropertyAccessChain(node) { + return ts.isPropertyAccessExpression(node) && !!(node.flags & 32 /* NodeFlags.OptionalChain */); + } + ts.isPropertyAccessChain = isPropertyAccessChain; + function isElementAccessChain(node) { + return ts.isElementAccessExpression(node) && !!(node.flags & 32 /* NodeFlags.OptionalChain */); + } + ts.isElementAccessChain = isElementAccessChain; + function isCallChain(node) { + return ts.isCallExpression(node) && !!(node.flags & 32 /* NodeFlags.OptionalChain */); + } + ts.isCallChain = isCallChain; + function isOptionalChain(node) { + var kind = node.kind; + return !!(node.flags & 32 /* NodeFlags.OptionalChain */) && + (kind === 208 /* SyntaxKind.PropertyAccessExpression */ + || kind === 209 /* SyntaxKind.ElementAccessExpression */ + || kind === 210 /* SyntaxKind.CallExpression */ + || kind === 232 /* SyntaxKind.NonNullExpression */); + } + ts.isOptionalChain = isOptionalChain; + /* @internal */ + function isOptionalChainRoot(node) { + return isOptionalChain(node) && !ts.isNonNullExpression(node) && !!node.questionDotToken; + } + ts.isOptionalChainRoot = isOptionalChainRoot; + /** + * Determines whether a node is the expression preceding an optional chain (i.e. `a` in `a?.b`). + */ + /* @internal */ + function isExpressionOfOptionalChainRoot(node) { + return isOptionalChainRoot(node.parent) && node.parent.expression === node; + } + ts.isExpressionOfOptionalChainRoot = isExpressionOfOptionalChainRoot; + /** + * Determines whether a node is the outermost `OptionalChain` in an ECMAScript `OptionalExpression`: + * + * 1. For `a?.b.c`, the outermost chain is `a?.b.c` (`c` is the end of the chain starting at `a?.`) + * 2. For `a?.b!`, the outermost chain is `a?.b` (`b` is the end of the chain starting at `a?.`) + * 3. For `(a?.b.c).d`, the outermost chain is `a?.b.c` (`c` is the end of the chain starting at `a?.` since parens end the chain) + * 4. For `a?.b.c?.d`, both `a?.b.c` and `a?.b.c?.d` are outermost (`c` is the end of the chain starting at `a?.`, and `d` is + * the end of the chain starting at `c?.`) + * 5. For `a?.(b?.c).d`, both `b?.c` and `a?.(b?.c)d` are outermost (`c` is the end of the chain starting at `b`, and `d` is + * the end of the chain starting at `a?.`) + */ + /* @internal */ + function isOutermostOptionalChain(node) { + return !isOptionalChain(node.parent) // cases 1, 2, and 3 + || isOptionalChainRoot(node.parent) // case 4 + || node !== node.parent.expression; // case 5 + } + ts.isOutermostOptionalChain = isOutermostOptionalChain; + function isNullishCoalesce(node) { + return node.kind === 223 /* SyntaxKind.BinaryExpression */ && node.operatorToken.kind === 60 /* SyntaxKind.QuestionQuestionToken */; + } + ts.isNullishCoalesce = isNullishCoalesce; + function isConstTypeReference(node) { + return ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName) && + node.typeName.escapedText === "const" && !node.typeArguments; + } + ts.isConstTypeReference = isConstTypeReference; + function skipPartiallyEmittedExpressions(node) { + return ts.skipOuterExpressions(node, 8 /* OuterExpressionKinds.PartiallyEmittedExpressions */); + } + ts.skipPartiallyEmittedExpressions = skipPartiallyEmittedExpressions; + function isNonNullChain(node) { + return ts.isNonNullExpression(node) && !!(node.flags & 32 /* NodeFlags.OptionalChain */); + } + ts.isNonNullChain = isNonNullChain; + function isBreakOrContinueStatement(node) { + return node.kind === 249 /* SyntaxKind.BreakStatement */ || node.kind === 248 /* SyntaxKind.ContinueStatement */; + } + ts.isBreakOrContinueStatement = isBreakOrContinueStatement; + function isNamedExportBindings(node) { + return node.kind === 277 /* SyntaxKind.NamespaceExport */ || node.kind === 276 /* SyntaxKind.NamedExports */; + } + ts.isNamedExportBindings = isNamedExportBindings; + function isUnparsedTextLike(node) { + switch (node.kind) { + case 305 /* SyntaxKind.UnparsedText */: + case 306 /* SyntaxKind.UnparsedInternalText */: + return true; + default: + return false; + } + } + ts.isUnparsedTextLike = isUnparsedTextLike; + function isUnparsedNode(node) { + return isUnparsedTextLike(node) || + node.kind === 303 /* SyntaxKind.UnparsedPrologue */ || + node.kind === 307 /* SyntaxKind.UnparsedSyntheticReference */; + } + ts.isUnparsedNode = isUnparsedNode; + function isJSDocPropertyLikeTag(node) { + return node.kind === 350 /* SyntaxKind.JSDocPropertyTag */ || node.kind === 343 /* SyntaxKind.JSDocParameterTag */; + } + ts.isJSDocPropertyLikeTag = isJSDocPropertyLikeTag; + // #endregion + // #region + // Node tests + // + // All node tests in the following list should *not* reference parent pointers so that + // they may be used with transformations. + /* @internal */ + function isNode(node) { + return isNodeKind(node.kind); + } + ts.isNode = isNode; + /* @internal */ + function isNodeKind(kind) { + return kind >= 163 /* SyntaxKind.FirstNode */; + } + ts.isNodeKind = isNodeKind; + /** + * True if kind is of some token syntax kind. + * For example, this is true for an IfKeyword but not for an IfStatement. + * Literals are considered tokens, except TemplateLiteral, but does include TemplateHead/Middle/Tail. + */ + function isTokenKind(kind) { + return kind >= 0 /* SyntaxKind.FirstToken */ && kind <= 162 /* SyntaxKind.LastToken */; + } + ts.isTokenKind = isTokenKind; + /** + * True if node is of some token syntax kind. + * For example, this is true for an IfKeyword but not for an IfStatement. + * Literals are considered tokens, except TemplateLiteral, but does include TemplateHead/Middle/Tail. + */ + function isToken(n) { + return isTokenKind(n.kind); + } + ts.isToken = isToken; + // Node Arrays + /* @internal */ + function isNodeArray(array) { + return ts.hasProperty(array, "pos") && ts.hasProperty(array, "end"); + } + ts.isNodeArray = isNodeArray; + // Literals + /* @internal */ + function isLiteralKind(kind) { + return 8 /* SyntaxKind.FirstLiteralToken */ <= kind && kind <= 14 /* SyntaxKind.LastLiteralToken */; + } + ts.isLiteralKind = isLiteralKind; + function isLiteralExpression(node) { + return isLiteralKind(node.kind); + } + ts.isLiteralExpression = isLiteralExpression; + /** @internal */ + function isLiteralExpressionOfObject(node) { + switch (node.kind) { + case 207 /* SyntaxKind.ObjectLiteralExpression */: + case 206 /* SyntaxKind.ArrayLiteralExpression */: + case 13 /* SyntaxKind.RegularExpressionLiteral */: + case 215 /* SyntaxKind.FunctionExpression */: + case 228 /* SyntaxKind.ClassExpression */: + return true; + } + return false; + } + ts.isLiteralExpressionOfObject = isLiteralExpressionOfObject; + // Pseudo-literals + /* @internal */ + function isTemplateLiteralKind(kind) { + return 14 /* SyntaxKind.FirstTemplateToken */ <= kind && kind <= 17 /* SyntaxKind.LastTemplateToken */; + } + ts.isTemplateLiteralKind = isTemplateLiteralKind; + function isTemplateLiteralToken(node) { + return isTemplateLiteralKind(node.kind); + } + ts.isTemplateLiteralToken = isTemplateLiteralToken; + function isTemplateMiddleOrTemplateTail(node) { + var kind = node.kind; + return kind === 16 /* SyntaxKind.TemplateMiddle */ + || kind === 17 /* SyntaxKind.TemplateTail */; + } + ts.isTemplateMiddleOrTemplateTail = isTemplateMiddleOrTemplateTail; + function isImportOrExportSpecifier(node) { + return ts.isImportSpecifier(node) || ts.isExportSpecifier(node); + } + ts.isImportOrExportSpecifier = isImportOrExportSpecifier; + function isTypeOnlyImportOrExportDeclaration(node) { + switch (node.kind) { + case 273 /* SyntaxKind.ImportSpecifier */: + case 278 /* SyntaxKind.ExportSpecifier */: + return node.isTypeOnly || node.parent.parent.isTypeOnly; + case 271 /* SyntaxKind.NamespaceImport */: + return node.parent.isTypeOnly; + case 270 /* SyntaxKind.ImportClause */: + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return node.isTypeOnly; + default: + return false; + } + } + ts.isTypeOnlyImportOrExportDeclaration = isTypeOnlyImportOrExportDeclaration; + function isAssertionKey(node) { + return ts.isStringLiteral(node) || ts.isIdentifier(node); + } + ts.isAssertionKey = isAssertionKey; + function isStringTextContainingNode(node) { + return node.kind === 10 /* SyntaxKind.StringLiteral */ || isTemplateLiteralKind(node.kind); + } + ts.isStringTextContainingNode = isStringTextContainingNode; + // Identifiers + /* @internal */ + function isGeneratedIdentifier(node) { + return ts.isIdentifier(node) && (node.autoGenerateFlags & 7 /* GeneratedIdentifierFlags.KindMask */) > 0 /* GeneratedIdentifierFlags.None */; + } + ts.isGeneratedIdentifier = isGeneratedIdentifier; + /* @internal */ + function isGeneratedPrivateIdentifier(node) { + return ts.isPrivateIdentifier(node) && (node.autoGenerateFlags & 7 /* GeneratedIdentifierFlags.KindMask */) > 0 /* GeneratedIdentifierFlags.None */; + } + ts.isGeneratedPrivateIdentifier = isGeneratedPrivateIdentifier; + // Private Identifiers + /*@internal*/ + function isPrivateIdentifierClassElementDeclaration(node) { + return (ts.isPropertyDeclaration(node) || isMethodOrAccessor(node)) && ts.isPrivateIdentifier(node.name); + } + ts.isPrivateIdentifierClassElementDeclaration = isPrivateIdentifierClassElementDeclaration; + /*@internal*/ + function isPrivateIdentifierPropertyAccessExpression(node) { + return ts.isPropertyAccessExpression(node) && ts.isPrivateIdentifier(node.name); + } + ts.isPrivateIdentifierPropertyAccessExpression = isPrivateIdentifierPropertyAccessExpression; + // Keywords + /* @internal */ + function isModifierKind(token) { + switch (token) { + case 126 /* SyntaxKind.AbstractKeyword */: + case 127 /* SyntaxKind.AccessorKeyword */: + case 132 /* SyntaxKind.AsyncKeyword */: + case 85 /* SyntaxKind.ConstKeyword */: + case 136 /* SyntaxKind.DeclareKeyword */: + case 88 /* SyntaxKind.DefaultKeyword */: + case 93 /* SyntaxKind.ExportKeyword */: + case 101 /* SyntaxKind.InKeyword */: + case 123 /* SyntaxKind.PublicKeyword */: + case 121 /* SyntaxKind.PrivateKeyword */: + case 122 /* SyntaxKind.ProtectedKeyword */: + case 146 /* SyntaxKind.ReadonlyKeyword */: + case 124 /* SyntaxKind.StaticKeyword */: + case 145 /* SyntaxKind.OutKeyword */: + case 161 /* SyntaxKind.OverrideKeyword */: + return true; + } + return false; + } + ts.isModifierKind = isModifierKind; + /* @internal */ + function isParameterPropertyModifier(kind) { + return !!(ts.modifierToFlag(kind) & 16476 /* ModifierFlags.ParameterPropertyModifier */); + } + ts.isParameterPropertyModifier = isParameterPropertyModifier; + /* @internal */ + function isClassMemberModifier(idToken) { + return isParameterPropertyModifier(idToken) || + idToken === 124 /* SyntaxKind.StaticKeyword */ || + idToken === 161 /* SyntaxKind.OverrideKeyword */ || + idToken === 127 /* SyntaxKind.AccessorKeyword */; + } + ts.isClassMemberModifier = isClassMemberModifier; + function isModifier(node) { + return isModifierKind(node.kind); + } + ts.isModifier = isModifier; + function isEntityName(node) { + var kind = node.kind; + return kind === 163 /* SyntaxKind.QualifiedName */ + || kind === 79 /* SyntaxKind.Identifier */; + } + ts.isEntityName = isEntityName; + function isPropertyName(node) { + var kind = node.kind; + return kind === 79 /* SyntaxKind.Identifier */ + || kind === 80 /* SyntaxKind.PrivateIdentifier */ + || kind === 10 /* SyntaxKind.StringLiteral */ + || kind === 8 /* SyntaxKind.NumericLiteral */ + || kind === 164 /* SyntaxKind.ComputedPropertyName */; + } + ts.isPropertyName = isPropertyName; + function isBindingName(node) { + var kind = node.kind; + return kind === 79 /* SyntaxKind.Identifier */ + || kind === 203 /* SyntaxKind.ObjectBindingPattern */ + || kind === 204 /* SyntaxKind.ArrayBindingPattern */; + } + ts.isBindingName = isBindingName; + // Functions + function isFunctionLike(node) { + return !!node && isFunctionLikeKind(node.kind); + } + ts.isFunctionLike = isFunctionLike; + /* @internal */ + function isFunctionLikeOrClassStaticBlockDeclaration(node) { + return !!node && (isFunctionLikeKind(node.kind) || ts.isClassStaticBlockDeclaration(node)); + } + ts.isFunctionLikeOrClassStaticBlockDeclaration = isFunctionLikeOrClassStaticBlockDeclaration; + /* @internal */ + function isFunctionLikeDeclaration(node) { + return node && isFunctionLikeDeclarationKind(node.kind); + } + ts.isFunctionLikeDeclaration = isFunctionLikeDeclaration; + /* @internal */ + function isBooleanLiteral(node) { + return node.kind === 110 /* SyntaxKind.TrueKeyword */ || node.kind === 95 /* SyntaxKind.FalseKeyword */; + } + ts.isBooleanLiteral = isBooleanLiteral; + function isFunctionLikeDeclarationKind(kind) { + switch (kind) { + case 259 /* SyntaxKind.FunctionDeclaration */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 173 /* SyntaxKind.Constructor */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + return true; + default: + return false; + } + } + /* @internal */ + function isFunctionLikeKind(kind) { + switch (kind) { + case 170 /* SyntaxKind.MethodSignature */: + case 176 /* SyntaxKind.CallSignature */: + case 326 /* SyntaxKind.JSDocSignature */: + case 177 /* SyntaxKind.ConstructSignature */: + case 178 /* SyntaxKind.IndexSignature */: + case 181 /* SyntaxKind.FunctionType */: + case 320 /* SyntaxKind.JSDocFunctionType */: + case 182 /* SyntaxKind.ConstructorType */: + return true; + default: + return isFunctionLikeDeclarationKind(kind); + } + } + ts.isFunctionLikeKind = isFunctionLikeKind; + /* @internal */ + function isFunctionOrModuleBlock(node) { + return ts.isSourceFile(node) || ts.isModuleBlock(node) || ts.isBlock(node) && isFunctionLike(node.parent); + } + ts.isFunctionOrModuleBlock = isFunctionOrModuleBlock; + // Classes + function isClassElement(node) { + var kind = node.kind; + return kind === 173 /* SyntaxKind.Constructor */ + || kind === 169 /* SyntaxKind.PropertyDeclaration */ + || kind === 171 /* SyntaxKind.MethodDeclaration */ + || kind === 174 /* SyntaxKind.GetAccessor */ + || kind === 175 /* SyntaxKind.SetAccessor */ + || kind === 178 /* SyntaxKind.IndexSignature */ + || kind === 172 /* SyntaxKind.ClassStaticBlockDeclaration */ + || kind === 237 /* SyntaxKind.SemicolonClassElement */; + } + ts.isClassElement = isClassElement; + function isClassLike(node) { + return node && (node.kind === 260 /* SyntaxKind.ClassDeclaration */ || node.kind === 228 /* SyntaxKind.ClassExpression */); + } + ts.isClassLike = isClassLike; + function isAccessor(node) { + return node && (node.kind === 174 /* SyntaxKind.GetAccessor */ || node.kind === 175 /* SyntaxKind.SetAccessor */); + } + ts.isAccessor = isAccessor; + function isAutoAccessorPropertyDeclaration(node) { + return ts.isPropertyDeclaration(node) && ts.hasAccessorModifier(node); + } + ts.isAutoAccessorPropertyDeclaration = isAutoAccessorPropertyDeclaration; + /* @internal */ + function isMethodOrAccessor(node) { + switch (node.kind) { + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + return true; + default: + return false; + } + } + ts.isMethodOrAccessor = isMethodOrAccessor; + /* @internal */ + function isNamedClassElement(node) { + switch (node.kind) { + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 169 /* SyntaxKind.PropertyDeclaration */: + return true; + default: + return false; + } + } + ts.isNamedClassElement = isNamedClassElement; + // Type members + function isModifierLike(node) { + return isModifier(node) || ts.isDecorator(node); + } + ts.isModifierLike = isModifierLike; + function isTypeElement(node) { + var kind = node.kind; + return kind === 177 /* SyntaxKind.ConstructSignature */ + || kind === 176 /* SyntaxKind.CallSignature */ + || kind === 168 /* SyntaxKind.PropertySignature */ + || kind === 170 /* SyntaxKind.MethodSignature */ + || kind === 178 /* SyntaxKind.IndexSignature */ + || kind === 174 /* SyntaxKind.GetAccessor */ + || kind === 175 /* SyntaxKind.SetAccessor */; + } + ts.isTypeElement = isTypeElement; + function isClassOrTypeElement(node) { + return isTypeElement(node) || isClassElement(node); + } + ts.isClassOrTypeElement = isClassOrTypeElement; + function isObjectLiteralElementLike(node) { + var kind = node.kind; + return kind === 299 /* SyntaxKind.PropertyAssignment */ + || kind === 300 /* SyntaxKind.ShorthandPropertyAssignment */ + || kind === 301 /* SyntaxKind.SpreadAssignment */ + || kind === 171 /* SyntaxKind.MethodDeclaration */ + || kind === 174 /* SyntaxKind.GetAccessor */ + || kind === 175 /* SyntaxKind.SetAccessor */; + } + ts.isObjectLiteralElementLike = isObjectLiteralElementLike; + // Type + /** + * Node test that determines whether a node is a valid type node. + * This differs from the `isPartOfTypeNode` function which determines whether a node is *part* + * of a TypeNode. + */ + function isTypeNode(node) { + return ts.isTypeNodeKind(node.kind); + } + ts.isTypeNode = isTypeNode; + function isFunctionOrConstructorTypeNode(node) { + switch (node.kind) { + case 181 /* SyntaxKind.FunctionType */: + case 182 /* SyntaxKind.ConstructorType */: + return true; + } + return false; + } + ts.isFunctionOrConstructorTypeNode = isFunctionOrConstructorTypeNode; + // Binding patterns + /* @internal */ + function isBindingPattern(node) { + if (node) { + var kind = node.kind; + return kind === 204 /* SyntaxKind.ArrayBindingPattern */ + || kind === 203 /* SyntaxKind.ObjectBindingPattern */; + } + return false; + } + ts.isBindingPattern = isBindingPattern; + /* @internal */ + function isAssignmentPattern(node) { + var kind = node.kind; + return kind === 206 /* SyntaxKind.ArrayLiteralExpression */ + || kind === 207 /* SyntaxKind.ObjectLiteralExpression */; + } + ts.isAssignmentPattern = isAssignmentPattern; + /* @internal */ + function isArrayBindingElement(node) { + var kind = node.kind; + return kind === 205 /* SyntaxKind.BindingElement */ + || kind === 229 /* SyntaxKind.OmittedExpression */; + } + ts.isArrayBindingElement = isArrayBindingElement; + /** + * Determines whether the BindingOrAssignmentElement is a BindingElement-like declaration + */ + /* @internal */ + function isDeclarationBindingElement(bindingElement) { + switch (bindingElement.kind) { + case 257 /* SyntaxKind.VariableDeclaration */: + case 166 /* SyntaxKind.Parameter */: + case 205 /* SyntaxKind.BindingElement */: + return true; + } + return false; + } + ts.isDeclarationBindingElement = isDeclarationBindingElement; + /** + * Determines whether a node is a BindingOrAssignmentPattern + */ + /* @internal */ + function isBindingOrAssignmentPattern(node) { + return isObjectBindingOrAssignmentPattern(node) + || isArrayBindingOrAssignmentPattern(node); + } + ts.isBindingOrAssignmentPattern = isBindingOrAssignmentPattern; + /** + * Determines whether a node is an ObjectBindingOrAssignmentPattern + */ + /* @internal */ + function isObjectBindingOrAssignmentPattern(node) { + switch (node.kind) { + case 203 /* SyntaxKind.ObjectBindingPattern */: + case 207 /* SyntaxKind.ObjectLiteralExpression */: + return true; + } + return false; + } + ts.isObjectBindingOrAssignmentPattern = isObjectBindingOrAssignmentPattern; + /* @internal */ + function isObjectBindingOrAssignmentElement(node) { + switch (node.kind) { + case 205 /* SyntaxKind.BindingElement */: + case 299 /* SyntaxKind.PropertyAssignment */: // AssignmentProperty + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: // AssignmentProperty + case 301 /* SyntaxKind.SpreadAssignment */: // AssignmentRestProperty + return true; + } + return false; + } + ts.isObjectBindingOrAssignmentElement = isObjectBindingOrAssignmentElement; + /** + * Determines whether a node is an ArrayBindingOrAssignmentPattern + */ + /* @internal */ + function isArrayBindingOrAssignmentPattern(node) { + switch (node.kind) { + case 204 /* SyntaxKind.ArrayBindingPattern */: + case 206 /* SyntaxKind.ArrayLiteralExpression */: + return true; + } + return false; + } + ts.isArrayBindingOrAssignmentPattern = isArrayBindingOrAssignmentPattern; + /* @internal */ + function isPropertyAccessOrQualifiedNameOrImportTypeNode(node) { + var kind = node.kind; + return kind === 208 /* SyntaxKind.PropertyAccessExpression */ + || kind === 163 /* SyntaxKind.QualifiedName */ + || kind === 202 /* SyntaxKind.ImportType */; + } + ts.isPropertyAccessOrQualifiedNameOrImportTypeNode = isPropertyAccessOrQualifiedNameOrImportTypeNode; + // Expression + function isPropertyAccessOrQualifiedName(node) { + var kind = node.kind; + return kind === 208 /* SyntaxKind.PropertyAccessExpression */ + || kind === 163 /* SyntaxKind.QualifiedName */; + } + ts.isPropertyAccessOrQualifiedName = isPropertyAccessOrQualifiedName; + function isCallLikeExpression(node) { + switch (node.kind) { + case 283 /* SyntaxKind.JsxOpeningElement */: + case 282 /* SyntaxKind.JsxSelfClosingElement */: + case 210 /* SyntaxKind.CallExpression */: + case 211 /* SyntaxKind.NewExpression */: + case 212 /* SyntaxKind.TaggedTemplateExpression */: + case 167 /* SyntaxKind.Decorator */: + return true; + default: + return false; + } + } + ts.isCallLikeExpression = isCallLikeExpression; + function isCallOrNewExpression(node) { + return node.kind === 210 /* SyntaxKind.CallExpression */ || node.kind === 211 /* SyntaxKind.NewExpression */; + } + ts.isCallOrNewExpression = isCallOrNewExpression; + function isTemplateLiteral(node) { + var kind = node.kind; + return kind === 225 /* SyntaxKind.TemplateExpression */ + || kind === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */; + } + ts.isTemplateLiteral = isTemplateLiteral; + /* @internal */ + function isLeftHandSideExpression(node) { + return isLeftHandSideExpressionKind(skipPartiallyEmittedExpressions(node).kind); + } + ts.isLeftHandSideExpression = isLeftHandSideExpression; + function isLeftHandSideExpressionKind(kind) { + switch (kind) { + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 209 /* SyntaxKind.ElementAccessExpression */: + case 211 /* SyntaxKind.NewExpression */: + case 210 /* SyntaxKind.CallExpression */: + case 281 /* SyntaxKind.JsxElement */: + case 282 /* SyntaxKind.JsxSelfClosingElement */: + case 285 /* SyntaxKind.JsxFragment */: + case 212 /* SyntaxKind.TaggedTemplateExpression */: + case 206 /* SyntaxKind.ArrayLiteralExpression */: + case 214 /* SyntaxKind.ParenthesizedExpression */: + case 207 /* SyntaxKind.ObjectLiteralExpression */: + case 228 /* SyntaxKind.ClassExpression */: + case 215 /* SyntaxKind.FunctionExpression */: + case 79 /* SyntaxKind.Identifier */: + case 80 /* SyntaxKind.PrivateIdentifier */: // technically this is only an Expression if it's in a `#field in expr` BinaryExpression + case 13 /* SyntaxKind.RegularExpressionLiteral */: + case 8 /* SyntaxKind.NumericLiteral */: + case 9 /* SyntaxKind.BigIntLiteral */: + case 10 /* SyntaxKind.StringLiteral */: + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + case 225 /* SyntaxKind.TemplateExpression */: + case 95 /* SyntaxKind.FalseKeyword */: + case 104 /* SyntaxKind.NullKeyword */: + case 108 /* SyntaxKind.ThisKeyword */: + case 110 /* SyntaxKind.TrueKeyword */: + case 106 /* SyntaxKind.SuperKeyword */: + case 232 /* SyntaxKind.NonNullExpression */: + case 230 /* SyntaxKind.ExpressionWithTypeArguments */: + case 233 /* SyntaxKind.MetaProperty */: + case 100 /* SyntaxKind.ImportKeyword */: // technically this is only an Expression if it's in a CallExpression + return true; + default: + return false; + } + } + /* @internal */ + function isUnaryExpression(node) { + return isUnaryExpressionKind(skipPartiallyEmittedExpressions(node).kind); + } + ts.isUnaryExpression = isUnaryExpression; + function isUnaryExpressionKind(kind) { + switch (kind) { + case 221 /* SyntaxKind.PrefixUnaryExpression */: + case 222 /* SyntaxKind.PostfixUnaryExpression */: + case 217 /* SyntaxKind.DeleteExpression */: + case 218 /* SyntaxKind.TypeOfExpression */: + case 219 /* SyntaxKind.VoidExpression */: + case 220 /* SyntaxKind.AwaitExpression */: + case 213 /* SyntaxKind.TypeAssertionExpression */: + return true; + default: + return isLeftHandSideExpressionKind(kind); + } + } + /* @internal */ + function isUnaryExpressionWithWrite(expr) { + switch (expr.kind) { + case 222 /* SyntaxKind.PostfixUnaryExpression */: + return true; + case 221 /* SyntaxKind.PrefixUnaryExpression */: + return expr.operator === 45 /* SyntaxKind.PlusPlusToken */ || + expr.operator === 46 /* SyntaxKind.MinusMinusToken */; + default: + return false; + } + } + ts.isUnaryExpressionWithWrite = isUnaryExpressionWithWrite; + /* @internal */ + /** + * Determines whether a node is an expression based only on its kind. + * Use `isExpressionNode` if not in transforms. + */ + function isExpression(node) { + return isExpressionKind(skipPartiallyEmittedExpressions(node).kind); + } + ts.isExpression = isExpression; + function isExpressionKind(kind) { + switch (kind) { + case 224 /* SyntaxKind.ConditionalExpression */: + case 226 /* SyntaxKind.YieldExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + case 223 /* SyntaxKind.BinaryExpression */: + case 227 /* SyntaxKind.SpreadElement */: + case 231 /* SyntaxKind.AsExpression */: + case 229 /* SyntaxKind.OmittedExpression */: + case 354 /* SyntaxKind.CommaListExpression */: + case 353 /* SyntaxKind.PartiallyEmittedExpression */: + case 235 /* SyntaxKind.SatisfiesExpression */: + return true; + default: + return isUnaryExpressionKind(kind); + } + } + function isAssertionExpression(node) { + var kind = node.kind; + return kind === 213 /* SyntaxKind.TypeAssertionExpression */ + || kind === 231 /* SyntaxKind.AsExpression */; + } + ts.isAssertionExpression = isAssertionExpression; + /* @internal */ + function isNotEmittedOrPartiallyEmittedNode(node) { + return ts.isNotEmittedStatement(node) + || ts.isPartiallyEmittedExpression(node); + } + ts.isNotEmittedOrPartiallyEmittedNode = isNotEmittedOrPartiallyEmittedNode; + function isIterationStatement(node, lookInLabeledStatements) { + switch (node.kind) { + case 245 /* SyntaxKind.ForStatement */: + case 246 /* SyntaxKind.ForInStatement */: + case 247 /* SyntaxKind.ForOfStatement */: + case 243 /* SyntaxKind.DoStatement */: + case 244 /* SyntaxKind.WhileStatement */: + return true; + case 253 /* SyntaxKind.LabeledStatement */: + return lookInLabeledStatements && isIterationStatement(node.statement, lookInLabeledStatements); + } + return false; + } + ts.isIterationStatement = isIterationStatement; + /* @internal */ + function isScopeMarker(node) { + return ts.isExportAssignment(node) || ts.isExportDeclaration(node); + } + ts.isScopeMarker = isScopeMarker; + /* @internal */ + function hasScopeMarker(statements) { + return ts.some(statements, isScopeMarker); + } + ts.hasScopeMarker = hasScopeMarker; + /* @internal */ + function needsScopeMarker(result) { + return !ts.isAnyImportOrReExport(result) && !ts.isExportAssignment(result) && !ts.hasSyntacticModifier(result, 1 /* ModifierFlags.Export */) && !ts.isAmbientModule(result); + } + ts.needsScopeMarker = needsScopeMarker; + /* @internal */ + function isExternalModuleIndicator(result) { + // Exported top-level member indicates moduleness + return ts.isAnyImportOrReExport(result) || ts.isExportAssignment(result) || ts.hasSyntacticModifier(result, 1 /* ModifierFlags.Export */); + } + ts.isExternalModuleIndicator = isExternalModuleIndicator; + /* @internal */ + function isForInOrOfStatement(node) { + return node.kind === 246 /* SyntaxKind.ForInStatement */ || node.kind === 247 /* SyntaxKind.ForOfStatement */; + } + ts.isForInOrOfStatement = isForInOrOfStatement; + // Element + /* @internal */ + function isConciseBody(node) { + return ts.isBlock(node) + || isExpression(node); + } + ts.isConciseBody = isConciseBody; + /* @internal */ + function isFunctionBody(node) { + return ts.isBlock(node); + } + ts.isFunctionBody = isFunctionBody; + /* @internal */ + function isForInitializer(node) { + return ts.isVariableDeclarationList(node) + || isExpression(node); + } + ts.isForInitializer = isForInitializer; + /* @internal */ + function isModuleBody(node) { + var kind = node.kind; + return kind === 265 /* SyntaxKind.ModuleBlock */ + || kind === 264 /* SyntaxKind.ModuleDeclaration */ + || kind === 79 /* SyntaxKind.Identifier */; + } + ts.isModuleBody = isModuleBody; + /* @internal */ + function isNamespaceBody(node) { + var kind = node.kind; + return kind === 265 /* SyntaxKind.ModuleBlock */ + || kind === 264 /* SyntaxKind.ModuleDeclaration */; + } + ts.isNamespaceBody = isNamespaceBody; + /* @internal */ + function isJSDocNamespaceBody(node) { + var kind = node.kind; + return kind === 79 /* SyntaxKind.Identifier */ + || kind === 264 /* SyntaxKind.ModuleDeclaration */; + } + ts.isJSDocNamespaceBody = isJSDocNamespaceBody; + /* @internal */ + function isNamedImportBindings(node) { + var kind = node.kind; + return kind === 272 /* SyntaxKind.NamedImports */ + || kind === 271 /* SyntaxKind.NamespaceImport */; + } + ts.isNamedImportBindings = isNamedImportBindings; + /* @internal */ + function isModuleOrEnumDeclaration(node) { + return node.kind === 264 /* SyntaxKind.ModuleDeclaration */ || node.kind === 263 /* SyntaxKind.EnumDeclaration */; + } + ts.isModuleOrEnumDeclaration = isModuleOrEnumDeclaration; + function isDeclarationKind(kind) { + return kind === 216 /* SyntaxKind.ArrowFunction */ + || kind === 205 /* SyntaxKind.BindingElement */ + || kind === 260 /* SyntaxKind.ClassDeclaration */ + || kind === 228 /* SyntaxKind.ClassExpression */ + || kind === 172 /* SyntaxKind.ClassStaticBlockDeclaration */ + || kind === 173 /* SyntaxKind.Constructor */ + || kind === 263 /* SyntaxKind.EnumDeclaration */ + || kind === 302 /* SyntaxKind.EnumMember */ + || kind === 278 /* SyntaxKind.ExportSpecifier */ + || kind === 259 /* SyntaxKind.FunctionDeclaration */ + || kind === 215 /* SyntaxKind.FunctionExpression */ + || kind === 174 /* SyntaxKind.GetAccessor */ + || kind === 270 /* SyntaxKind.ImportClause */ + || kind === 268 /* SyntaxKind.ImportEqualsDeclaration */ + || kind === 273 /* SyntaxKind.ImportSpecifier */ + || kind === 261 /* SyntaxKind.InterfaceDeclaration */ + || kind === 288 /* SyntaxKind.JsxAttribute */ + || kind === 171 /* SyntaxKind.MethodDeclaration */ + || kind === 170 /* SyntaxKind.MethodSignature */ + || kind === 264 /* SyntaxKind.ModuleDeclaration */ + || kind === 267 /* SyntaxKind.NamespaceExportDeclaration */ + || kind === 271 /* SyntaxKind.NamespaceImport */ + || kind === 277 /* SyntaxKind.NamespaceExport */ + || kind === 166 /* SyntaxKind.Parameter */ + || kind === 299 /* SyntaxKind.PropertyAssignment */ + || kind === 169 /* SyntaxKind.PropertyDeclaration */ + || kind === 168 /* SyntaxKind.PropertySignature */ + || kind === 175 /* SyntaxKind.SetAccessor */ + || kind === 300 /* SyntaxKind.ShorthandPropertyAssignment */ + || kind === 262 /* SyntaxKind.TypeAliasDeclaration */ + || kind === 165 /* SyntaxKind.TypeParameter */ + || kind === 257 /* SyntaxKind.VariableDeclaration */ + || kind === 348 /* SyntaxKind.JSDocTypedefTag */ + || kind === 341 /* SyntaxKind.JSDocCallbackTag */ + || kind === 350 /* SyntaxKind.JSDocPropertyTag */; + } + function isDeclarationStatementKind(kind) { + return kind === 259 /* SyntaxKind.FunctionDeclaration */ + || kind === 279 /* SyntaxKind.MissingDeclaration */ + || kind === 260 /* SyntaxKind.ClassDeclaration */ + || kind === 261 /* SyntaxKind.InterfaceDeclaration */ + || kind === 262 /* SyntaxKind.TypeAliasDeclaration */ + || kind === 263 /* SyntaxKind.EnumDeclaration */ + || kind === 264 /* SyntaxKind.ModuleDeclaration */ + || kind === 269 /* SyntaxKind.ImportDeclaration */ + || kind === 268 /* SyntaxKind.ImportEqualsDeclaration */ + || kind === 275 /* SyntaxKind.ExportDeclaration */ + || kind === 274 /* SyntaxKind.ExportAssignment */ + || kind === 267 /* SyntaxKind.NamespaceExportDeclaration */; + } + function isStatementKindButNotDeclarationKind(kind) { + return kind === 249 /* SyntaxKind.BreakStatement */ + || kind === 248 /* SyntaxKind.ContinueStatement */ + || kind === 256 /* SyntaxKind.DebuggerStatement */ + || kind === 243 /* SyntaxKind.DoStatement */ + || kind === 241 /* SyntaxKind.ExpressionStatement */ + || kind === 239 /* SyntaxKind.EmptyStatement */ + || kind === 246 /* SyntaxKind.ForInStatement */ + || kind === 247 /* SyntaxKind.ForOfStatement */ + || kind === 245 /* SyntaxKind.ForStatement */ + || kind === 242 /* SyntaxKind.IfStatement */ + || kind === 253 /* SyntaxKind.LabeledStatement */ + || kind === 250 /* SyntaxKind.ReturnStatement */ + || kind === 252 /* SyntaxKind.SwitchStatement */ + || kind === 254 /* SyntaxKind.ThrowStatement */ + || kind === 255 /* SyntaxKind.TryStatement */ + || kind === 240 /* SyntaxKind.VariableStatement */ + || kind === 244 /* SyntaxKind.WhileStatement */ + || kind === 251 /* SyntaxKind.WithStatement */ + || kind === 352 /* SyntaxKind.NotEmittedStatement */ + || kind === 356 /* SyntaxKind.EndOfDeclarationMarker */ + || kind === 355 /* SyntaxKind.MergeDeclarationMarker */; + } + /* @internal */ + function isDeclaration(node) { + if (node.kind === 165 /* SyntaxKind.TypeParameter */) { + return (node.parent && node.parent.kind !== 347 /* SyntaxKind.JSDocTemplateTag */) || ts.isInJSFile(node); + } + return isDeclarationKind(node.kind); + } + ts.isDeclaration = isDeclaration; + /* @internal */ + function isDeclarationStatement(node) { + return isDeclarationStatementKind(node.kind); + } + ts.isDeclarationStatement = isDeclarationStatement; + /** + * Determines whether the node is a statement that is not also a declaration + */ + /* @internal */ + function isStatementButNotDeclaration(node) { + return isStatementKindButNotDeclarationKind(node.kind); + } + ts.isStatementButNotDeclaration = isStatementButNotDeclaration; + /* @internal */ + function isStatement(node) { + var kind = node.kind; + return isStatementKindButNotDeclarationKind(kind) + || isDeclarationStatementKind(kind) + || isBlockStatement(node); + } + ts.isStatement = isStatement; + function isBlockStatement(node) { + if (node.kind !== 238 /* SyntaxKind.Block */) + return false; + if (node.parent !== undefined) { + if (node.parent.kind === 255 /* SyntaxKind.TryStatement */ || node.parent.kind === 295 /* SyntaxKind.CatchClause */) { + return false; + } + } + return !ts.isFunctionBlock(node); + } + /** + * NOTE: This is similar to `isStatement` but does not access parent pointers. + */ + /* @internal */ + function isStatementOrBlock(node) { + var kind = node.kind; + return isStatementKindButNotDeclarationKind(kind) + || isDeclarationStatementKind(kind) + || kind === 238 /* SyntaxKind.Block */; + } + ts.isStatementOrBlock = isStatementOrBlock; + // Module references + /* @internal */ + function isModuleReference(node) { + var kind = node.kind; + return kind === 280 /* SyntaxKind.ExternalModuleReference */ + || kind === 163 /* SyntaxKind.QualifiedName */ + || kind === 79 /* SyntaxKind.Identifier */; + } + ts.isModuleReference = isModuleReference; + // JSX + /* @internal */ + function isJsxTagNameExpression(node) { + var kind = node.kind; + return kind === 108 /* SyntaxKind.ThisKeyword */ + || kind === 79 /* SyntaxKind.Identifier */ + || kind === 208 /* SyntaxKind.PropertyAccessExpression */; + } + ts.isJsxTagNameExpression = isJsxTagNameExpression; + /* @internal */ + function isJsxChild(node) { + var kind = node.kind; + return kind === 281 /* SyntaxKind.JsxElement */ + || kind === 291 /* SyntaxKind.JsxExpression */ + || kind === 282 /* SyntaxKind.JsxSelfClosingElement */ + || kind === 11 /* SyntaxKind.JsxText */ + || kind === 285 /* SyntaxKind.JsxFragment */; + } + ts.isJsxChild = isJsxChild; + /* @internal */ + function isJsxAttributeLike(node) { + var kind = node.kind; + return kind === 288 /* SyntaxKind.JsxAttribute */ + || kind === 290 /* SyntaxKind.JsxSpreadAttribute */; + } + ts.isJsxAttributeLike = isJsxAttributeLike; + /* @internal */ + function isStringLiteralOrJsxExpression(node) { + var kind = node.kind; + return kind === 10 /* SyntaxKind.StringLiteral */ + || kind === 291 /* SyntaxKind.JsxExpression */; + } + ts.isStringLiteralOrJsxExpression = isStringLiteralOrJsxExpression; + function isJsxOpeningLikeElement(node) { + var kind = node.kind; + return kind === 283 /* SyntaxKind.JsxOpeningElement */ + || kind === 282 /* SyntaxKind.JsxSelfClosingElement */; + } + ts.isJsxOpeningLikeElement = isJsxOpeningLikeElement; + // Clauses + function isCaseOrDefaultClause(node) { + var kind = node.kind; + return kind === 292 /* SyntaxKind.CaseClause */ + || kind === 293 /* SyntaxKind.DefaultClause */; + } + ts.isCaseOrDefaultClause = isCaseOrDefaultClause; + // JSDoc + /** True if node is of some JSDoc syntax kind. */ + /* @internal */ + function isJSDocNode(node) { + return node.kind >= 312 /* SyntaxKind.FirstJSDocNode */ && node.kind <= 350 /* SyntaxKind.LastJSDocNode */; + } + ts.isJSDocNode = isJSDocNode; + /** True if node is of a kind that may contain comment text. */ + function isJSDocCommentContainingNode(node) { + return node.kind === 323 /* SyntaxKind.JSDoc */ + || node.kind === 322 /* SyntaxKind.JSDocNamepathType */ + || node.kind === 324 /* SyntaxKind.JSDocText */ + || isJSDocLinkLike(node) + || isJSDocTag(node) + || ts.isJSDocTypeLiteral(node) + || ts.isJSDocSignature(node); + } + ts.isJSDocCommentContainingNode = isJSDocCommentContainingNode; + // TODO: determine what this does before making it public. + /* @internal */ + function isJSDocTag(node) { + return node.kind >= 330 /* SyntaxKind.FirstJSDocTagNode */ && node.kind <= 350 /* SyntaxKind.LastJSDocTagNode */; + } + ts.isJSDocTag = isJSDocTag; + function isSetAccessor(node) { + return node.kind === 175 /* SyntaxKind.SetAccessor */; + } + ts.isSetAccessor = isSetAccessor; + function isGetAccessor(node) { + return node.kind === 174 /* SyntaxKind.GetAccessor */; + } + ts.isGetAccessor = isGetAccessor; + /** True if has jsdoc nodes attached to it. */ + /* @internal */ + // TODO: GH#19856 Would like to return `node is Node & { jsDoc: JSDoc[] }` but it causes long compile times + function hasJSDocNodes(node) { + var jsDoc = node.jsDoc; + return !!jsDoc && jsDoc.length > 0; + } + ts.hasJSDocNodes = hasJSDocNodes; + /** True if has type node attached to it. */ + /* @internal */ + function hasType(node) { + return !!node.type; + } + ts.hasType = hasType; + /** True if has initializer node attached to it. */ + /* @internal */ + function hasInitializer(node) { + return !!node.initializer; + } + ts.hasInitializer = hasInitializer; + /** True if has initializer node attached to it. */ + function hasOnlyExpressionInitializer(node) { + switch (node.kind) { + case 257 /* SyntaxKind.VariableDeclaration */: + case 166 /* SyntaxKind.Parameter */: + case 205 /* SyntaxKind.BindingElement */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 299 /* SyntaxKind.PropertyAssignment */: + case 302 /* SyntaxKind.EnumMember */: + return true; + default: + return false; + } + } + ts.hasOnlyExpressionInitializer = hasOnlyExpressionInitializer; + function isObjectLiteralElement(node) { + return node.kind === 288 /* SyntaxKind.JsxAttribute */ || node.kind === 290 /* SyntaxKind.JsxSpreadAttribute */ || isObjectLiteralElementLike(node); + } + ts.isObjectLiteralElement = isObjectLiteralElement; + /* @internal */ + function isTypeReferenceType(node) { + return node.kind === 180 /* SyntaxKind.TypeReference */ || node.kind === 230 /* SyntaxKind.ExpressionWithTypeArguments */; + } + ts.isTypeReferenceType = isTypeReferenceType; + var MAX_SMI_X86 = 1073741823; + /* @internal */ + function guessIndentation(lines) { + var indentation = MAX_SMI_X86; + for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) { + var line = lines_1[_i]; + if (!line.length) { + continue; + } + var i = 0; + for (; i < line.length && i < indentation; i++) { + if (!ts.isWhiteSpaceLike(line.charCodeAt(i))) { + break; + } + } + if (i < indentation) { + indentation = i; + } + if (indentation === 0) { + return 0; + } + } + return indentation === MAX_SMI_X86 ? undefined : indentation; + } + ts.guessIndentation = guessIndentation; + function isStringLiteralLike(node) { + return node.kind === 10 /* SyntaxKind.StringLiteral */ || node.kind === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */; + } + ts.isStringLiteralLike = isStringLiteralLike; + function isJSDocLinkLike(node) { + return node.kind === 327 /* SyntaxKind.JSDocLink */ || node.kind === 328 /* SyntaxKind.JSDocLinkCode */ || node.kind === 329 /* SyntaxKind.JSDocLinkPlain */; + } + ts.isJSDocLinkLike = isJSDocLinkLike; + function hasRestParameter(s) { + var last = ts.lastOrUndefined(s.parameters); + return !!last && isRestParameter(last); + } + ts.hasRestParameter = hasRestParameter; + function isRestParameter(node) { + var type = ts.isJSDocParameterTag(node) ? (node.typeExpression && node.typeExpression.type) : node.type; + return node.dotDotDotToken !== undefined || !!type && type.kind === 321 /* SyntaxKind.JSDocVariadicType */; + } + ts.isRestParameter = isRestParameter; + // #endregion +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + ts.resolvingEmptyArray = []; + ts.externalHelpersModuleNameText = "tslib"; + ts.defaultMaximumTruncationLength = 160; + ts.noTruncationMaximumTruncationLength = 1000000; + function getDeclarationOfKind(symbol, kind) { + var declarations = symbol.declarations; + if (declarations) { + for (var _i = 0, declarations_1 = declarations; _i < declarations_1.length; _i++) { + var declaration = declarations_1[_i]; + if (declaration.kind === kind) { + return declaration; + } + } + } + return undefined; + } + ts.getDeclarationOfKind = getDeclarationOfKind; + function getDeclarationsOfKind(symbol, kind) { + return ts.filter(symbol.declarations || ts.emptyArray, function (d) { return d.kind === kind; }); + } + ts.getDeclarationsOfKind = getDeclarationsOfKind; + function createSymbolTable(symbols) { + var result = new ts.Map(); + if (symbols) { + for (var _i = 0, symbols_1 = symbols; _i < symbols_1.length; _i++) { + var symbol = symbols_1[_i]; + result.set(symbol.escapedName, symbol); + } + } + return result; + } + ts.createSymbolTable = createSymbolTable; + function isTransientSymbol(symbol) { + return (symbol.flags & 33554432 /* SymbolFlags.Transient */) !== 0; + } + ts.isTransientSymbol = isTransientSymbol; + var stringWriter = createSingleLineStringWriter(); + function createSingleLineStringWriter() { + var str = ""; + var writeText = function (text) { return str += text; }; + return { + getText: function () { return str; }, + write: writeText, + rawWrite: writeText, + writeKeyword: writeText, + writeOperator: writeText, + writePunctuation: writeText, + writeSpace: writeText, + writeStringLiteral: writeText, + writeLiteral: writeText, + writeParameter: writeText, + writeProperty: writeText, + writeSymbol: function (s, _) { return writeText(s); }, + writeTrailingSemicolon: writeText, + writeComment: writeText, + getTextPos: function () { return str.length; }, + getLine: function () { return 0; }, + getColumn: function () { return 0; }, + getIndent: function () { return 0; }, + isAtStartOfLine: function () { return false; }, + hasTrailingComment: function () { return false; }, + hasTrailingWhitespace: function () { return !!str.length && ts.isWhiteSpaceLike(str.charCodeAt(str.length - 1)); }, + // Completely ignore indentation for string writers. And map newlines to + // a single space. + writeLine: function () { return str += " "; }, + increaseIndent: ts.noop, + decreaseIndent: ts.noop, + clear: function () { return str = ""; }, + trackSymbol: function () { return false; }, + reportInaccessibleThisError: ts.noop, + reportInaccessibleUniqueSymbolError: ts.noop, + reportPrivateInBaseOfClassExpression: ts.noop, + }; + } + function changesAffectModuleResolution(oldOptions, newOptions) { + return oldOptions.configFilePath !== newOptions.configFilePath || + optionsHaveModuleResolutionChanges(oldOptions, newOptions); + } + ts.changesAffectModuleResolution = changesAffectModuleResolution; + function optionsHaveModuleResolutionChanges(oldOptions, newOptions) { + return optionsHaveChanges(oldOptions, newOptions, ts.moduleResolutionOptionDeclarations); + } + ts.optionsHaveModuleResolutionChanges = optionsHaveModuleResolutionChanges; + function changesAffectingProgramStructure(oldOptions, newOptions) { + return optionsHaveChanges(oldOptions, newOptions, ts.optionsAffectingProgramStructure); + } + ts.changesAffectingProgramStructure = changesAffectingProgramStructure; + function optionsHaveChanges(oldOptions, newOptions, optionDeclarations) { + return oldOptions !== newOptions && optionDeclarations.some(function (o) { + return !isJsonEqual(getCompilerOptionValue(oldOptions, o), getCompilerOptionValue(newOptions, o)); + }); + } + ts.optionsHaveChanges = optionsHaveChanges; + function forEachAncestor(node, callback) { + while (true) { + var res = callback(node); + if (res === "quit") + return undefined; + if (res !== undefined) + return res; + if (ts.isSourceFile(node)) + return undefined; + node = node.parent; + } + } + ts.forEachAncestor = forEachAncestor; + /** + * Calls `callback` for each entry in the map, returning the first truthy result. + * Use `map.forEach` instead for normal iteration. + */ + function forEachEntry(map, callback) { + var iterator = map.entries(); + for (var iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) { + var _a = iterResult.value, key = _a[0], value = _a[1]; + var result = callback(value, key); + if (result) { + return result; + } + } + return undefined; + } + ts.forEachEntry = forEachEntry; + /** `forEachEntry` for just keys. */ + function forEachKey(map, callback) { + var iterator = map.keys(); + for (var iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) { + var result = callback(iterResult.value); + if (result) { + return result; + } + } + return undefined; + } + ts.forEachKey = forEachKey; + /** Copy entries from `source` to `target`. */ + function copyEntries(source, target) { + source.forEach(function (value, key) { + target.set(key, value); + }); + } + ts.copyEntries = copyEntries; + function usingSingleLineStringWriter(action) { + var oldString = stringWriter.getText(); + try { + action(stringWriter); + return stringWriter.getText(); + } + finally { + stringWriter.clear(); + stringWriter.writeKeyword(oldString); + } + } + ts.usingSingleLineStringWriter = usingSingleLineStringWriter; + function getFullWidth(node) { + return node.end - node.pos; + } + ts.getFullWidth = getFullWidth; + function getResolvedModule(sourceFile, moduleNameText, mode) { + return sourceFile && sourceFile.resolvedModules && sourceFile.resolvedModules.get(moduleNameText, mode); + } + ts.getResolvedModule = getResolvedModule; + function setResolvedModule(sourceFile, moduleNameText, resolvedModule, mode) { + if (!sourceFile.resolvedModules) { + sourceFile.resolvedModules = ts.createModeAwareCache(); + } + sourceFile.resolvedModules.set(moduleNameText, mode, resolvedModule); + } + ts.setResolvedModule = setResolvedModule; + function setResolvedTypeReferenceDirective(sourceFile, typeReferenceDirectiveName, resolvedTypeReferenceDirective) { + if (!sourceFile.resolvedTypeReferenceDirectiveNames) { + sourceFile.resolvedTypeReferenceDirectiveNames = ts.createModeAwareCache(); + } + sourceFile.resolvedTypeReferenceDirectiveNames.set(typeReferenceDirectiveName, /*mode*/ undefined, resolvedTypeReferenceDirective); + } + ts.setResolvedTypeReferenceDirective = setResolvedTypeReferenceDirective; + function projectReferenceIsEqualTo(oldRef, newRef) { + return oldRef.path === newRef.path && + !oldRef.prepend === !newRef.prepend && + !oldRef.circular === !newRef.circular; + } + ts.projectReferenceIsEqualTo = projectReferenceIsEqualTo; + function moduleResolutionIsEqualTo(oldResolution, newResolution) { + return oldResolution.isExternalLibraryImport === newResolution.isExternalLibraryImport && + oldResolution.extension === newResolution.extension && + oldResolution.resolvedFileName === newResolution.resolvedFileName && + oldResolution.originalPath === newResolution.originalPath && + packageIdIsEqual(oldResolution.packageId, newResolution.packageId); + } + ts.moduleResolutionIsEqualTo = moduleResolutionIsEqualTo; + function packageIdIsEqual(a, b) { + return a === b || !!a && !!b && a.name === b.name && a.subModuleName === b.subModuleName && a.version === b.version; + } + function packageIdToPackageName(_a) { + var name = _a.name, subModuleName = _a.subModuleName; + return subModuleName ? "".concat(name, "/").concat(subModuleName) : name; + } + ts.packageIdToPackageName = packageIdToPackageName; + function packageIdToString(packageId) { + return "".concat(packageIdToPackageName(packageId), "@").concat(packageId.version); + } + ts.packageIdToString = packageIdToString; + function typeDirectiveIsEqualTo(oldResolution, newResolution) { + return oldResolution.resolvedFileName === newResolution.resolvedFileName + && oldResolution.primary === newResolution.primary + && oldResolution.originalPath === newResolution.originalPath; + } + ts.typeDirectiveIsEqualTo = typeDirectiveIsEqualTo; + function hasChangesInResolutions(names, newResolutions, oldResolutions, oldSourceFile, comparer) { + ts.Debug.assert(names.length === newResolutions.length); + for (var i = 0; i < names.length; i++) { + var newResolution = newResolutions[i]; + var entry = names[i]; + // We lower-case all type references because npm automatically lowercases all packages. See GH#9824. + var name = !ts.isString(entry) ? entry.fileName.toLowerCase() : entry; + var mode = !ts.isString(entry) ? ts.getModeForFileReference(entry, oldSourceFile === null || oldSourceFile === void 0 ? void 0 : oldSourceFile.impliedNodeFormat) : oldSourceFile && ts.getModeForResolutionAtIndex(oldSourceFile, i); + var oldResolution = oldResolutions && oldResolutions.get(name, mode); + var changed = oldResolution + ? !newResolution || !comparer(oldResolution, newResolution) + : newResolution; + if (changed) { + return true; + } + } + return false; + } + ts.hasChangesInResolutions = hasChangesInResolutions; + // Returns true if this node contains a parse error anywhere underneath it. + function containsParseError(node) { + aggregateChildData(node); + return (node.flags & 524288 /* NodeFlags.ThisNodeOrAnySubNodesHasError */) !== 0; + } + ts.containsParseError = containsParseError; + function aggregateChildData(node) { + if (!(node.flags & 1048576 /* NodeFlags.HasAggregatedChildData */)) { + // A node is considered to contain a parse error if: + // a) the parser explicitly marked that it had an error + // b) any of it's children reported that it had an error. + var thisNodeOrAnySubNodesHasError = ((node.flags & 131072 /* NodeFlags.ThisNodeHasError */) !== 0) || + ts.forEachChild(node, containsParseError); + // If so, mark ourselves accordingly. + if (thisNodeOrAnySubNodesHasError) { + node.flags |= 524288 /* NodeFlags.ThisNodeOrAnySubNodesHasError */; + } + // Also mark that we've propagated the child information to this node. This way we can + // always consult the bit directly on this node without needing to check its children + // again. + node.flags |= 1048576 /* NodeFlags.HasAggregatedChildData */; + } + } + function getSourceFileOfNode(node) { + while (node && node.kind !== 308 /* SyntaxKind.SourceFile */) { + node = node.parent; + } + return node; + } + ts.getSourceFileOfNode = getSourceFileOfNode; + function getSourceFileOfModule(module) { + return getSourceFileOfNode(module.valueDeclaration || getNonAugmentationDeclaration(module)); + } + ts.getSourceFileOfModule = getSourceFileOfModule; + function isPlainJsFile(file, checkJs) { + return !!file && (file.scriptKind === 1 /* ScriptKind.JS */ || file.scriptKind === 2 /* ScriptKind.JSX */) && !file.checkJsDirective && checkJs === undefined; + } + ts.isPlainJsFile = isPlainJsFile; + function isStatementWithLocals(node) { + switch (node.kind) { + case 238 /* SyntaxKind.Block */: + case 266 /* SyntaxKind.CaseBlock */: + case 245 /* SyntaxKind.ForStatement */: + case 246 /* SyntaxKind.ForInStatement */: + case 247 /* SyntaxKind.ForOfStatement */: + return true; + } + return false; + } + ts.isStatementWithLocals = isStatementWithLocals; + function getStartPositionOfLine(line, sourceFile) { + ts.Debug.assert(line >= 0); + return ts.getLineStarts(sourceFile)[line]; + } + ts.getStartPositionOfLine = getStartPositionOfLine; + // This is a useful function for debugging purposes. + function nodePosToString(node) { + var file = getSourceFileOfNode(node); + var loc = ts.getLineAndCharacterOfPosition(file, node.pos); + return "".concat(file.fileName, "(").concat(loc.line + 1, ",").concat(loc.character + 1, ")"); + } + ts.nodePosToString = nodePosToString; + function getEndLinePosition(line, sourceFile) { + ts.Debug.assert(line >= 0); + var lineStarts = ts.getLineStarts(sourceFile); + var lineIndex = line; + var sourceText = sourceFile.text; + if (lineIndex + 1 === lineStarts.length) { + // last line - return EOF + return sourceText.length - 1; + } + else { + // current line start + var start = lineStarts[lineIndex]; + // take the start position of the next line - 1 = it should be some line break + var pos = lineStarts[lineIndex + 1] - 1; + ts.Debug.assert(ts.isLineBreak(sourceText.charCodeAt(pos))); + // walk backwards skipping line breaks, stop the the beginning of current line. + // i.e: + // + // $ <- end of line for this position should match the start position + while (start <= pos && ts.isLineBreak(sourceText.charCodeAt(pos))) { + pos--; + } + return pos; + } + } + ts.getEndLinePosition = getEndLinePosition; + /** + * Returns a value indicating whether a name is unique globally or within the current file. + * Note: This does not consider whether a name appears as a free identifier or not, so at the expression `x.y` this includes both `x` and `y`. + */ + function isFileLevelUniqueName(sourceFile, name, hasGlobalName) { + return !(hasGlobalName && hasGlobalName(name)) && !sourceFile.identifiers.has(name); + } + ts.isFileLevelUniqueName = isFileLevelUniqueName; + // Returns true if this node is missing from the actual source code. A 'missing' node is different + // from 'undefined/defined'. When a node is undefined (which can happen for optional nodes + // in the tree), it is definitely missing. However, a node may be defined, but still be + // missing. This happens whenever the parser knows it needs to parse something, but can't + // get anything in the source code that it expects at that location. For example: + // + // let a: ; + // + // Here, the Type in the Type-Annotation is not-optional (as there is a colon in the source + // code). So the parser will attempt to parse out a type, and will create an actual node. + // However, this node will be 'missing' in the sense that no actual source-code/tokens are + // contained within it. + function nodeIsMissing(node) { + if (node === undefined) { + return true; + } + return node.pos === node.end && node.pos >= 0 && node.kind !== 1 /* SyntaxKind.EndOfFileToken */; + } + ts.nodeIsMissing = nodeIsMissing; + function nodeIsPresent(node) { + return !nodeIsMissing(node); + } + ts.nodeIsPresent = nodeIsPresent; + function insertStatementsAfterPrologue(to, from, isPrologueDirective) { + if (from === undefined || from.length === 0) + return to; + var statementIndex = 0; + // skip all prologue directives to insert at the correct position + for (; statementIndex < to.length; ++statementIndex) { + if (!isPrologueDirective(to[statementIndex])) { + break; + } + } + to.splice.apply(to, __spreadArray([statementIndex, 0], from, false)); + return to; + } + function insertStatementAfterPrologue(to, statement, isPrologueDirective) { + if (statement === undefined) + return to; + var statementIndex = 0; + // skip all prologue directives to insert at the correct position + for (; statementIndex < to.length; ++statementIndex) { + if (!isPrologueDirective(to[statementIndex])) { + break; + } + } + to.splice(statementIndex, 0, statement); + return to; + } + function isAnyPrologueDirective(node) { + return isPrologueDirective(node) || !!(getEmitFlags(node) & 1048576 /* EmitFlags.CustomPrologue */); + } + /** + * Prepends statements to an array while taking care of prologue directives. + */ + function insertStatementsAfterStandardPrologue(to, from) { + return insertStatementsAfterPrologue(to, from, isPrologueDirective); + } + ts.insertStatementsAfterStandardPrologue = insertStatementsAfterStandardPrologue; + function insertStatementsAfterCustomPrologue(to, from) { + return insertStatementsAfterPrologue(to, from, isAnyPrologueDirective); + } + ts.insertStatementsAfterCustomPrologue = insertStatementsAfterCustomPrologue; + /** + * Prepends statements to an array while taking care of prologue directives. + */ + function insertStatementAfterStandardPrologue(to, statement) { + return insertStatementAfterPrologue(to, statement, isPrologueDirective); + } + ts.insertStatementAfterStandardPrologue = insertStatementAfterStandardPrologue; + function insertStatementAfterCustomPrologue(to, statement) { + return insertStatementAfterPrologue(to, statement, isAnyPrologueDirective); + } + ts.insertStatementAfterCustomPrologue = insertStatementAfterCustomPrologue; + /** + * Determine if the given comment is a triple-slash + * + * @return true if the comment is a triple-slash comment else false + */ + function isRecognizedTripleSlashComment(text, commentPos, commentEnd) { + // Verify this is /// comment, but do the regexp match only when we first can find /// in the comment text + // so that we don't end up computing comment string and doing match for all // comments + if (text.charCodeAt(commentPos + 1) === 47 /* CharacterCodes.slash */ && + commentPos + 2 < commentEnd && + text.charCodeAt(commentPos + 2) === 47 /* CharacterCodes.slash */) { + var textSubStr = text.substring(commentPos, commentEnd); + return ts.fullTripleSlashReferencePathRegEx.test(textSubStr) || + ts.fullTripleSlashAMDReferencePathRegEx.test(textSubStr) || + fullTripleSlashReferenceTypeReferenceDirectiveRegEx.test(textSubStr) || + defaultLibReferenceRegEx.test(textSubStr) ? + true : false; + } + return false; + } + ts.isRecognizedTripleSlashComment = isRecognizedTripleSlashComment; + function isPinnedComment(text, start) { + return text.charCodeAt(start + 1) === 42 /* CharacterCodes.asterisk */ && + text.charCodeAt(start + 2) === 33 /* CharacterCodes.exclamation */; + } + ts.isPinnedComment = isPinnedComment; + function createCommentDirectivesMap(sourceFile, commentDirectives) { + var directivesByLine = new ts.Map(commentDirectives.map(function (commentDirective) { return ([ + "".concat(ts.getLineAndCharacterOfPosition(sourceFile, commentDirective.range.end).line), + commentDirective, + ]); })); + var usedLines = new ts.Map(); + return { getUnusedExpectations: getUnusedExpectations, markUsed: markUsed }; + function getUnusedExpectations() { + return ts.arrayFrom(directivesByLine.entries()) + .filter(function (_a) { + var line = _a[0], directive = _a[1]; + return directive.type === 0 /* CommentDirectiveType.ExpectError */ && !usedLines.get(line); + }) + .map(function (_a) { + var _ = _a[0], directive = _a[1]; + return directive; + }); + } + function markUsed(line) { + if (!directivesByLine.has("".concat(line))) { + return false; + } + usedLines.set("".concat(line), true); + return true; + } + } + ts.createCommentDirectivesMap = createCommentDirectivesMap; + function getTokenPosOfNode(node, sourceFile, includeJsDoc) { + // With nodes that have no width (i.e. 'Missing' nodes), we actually *don't* + // want to skip trivia because this will launch us forward to the next token. + if (nodeIsMissing(node)) { + return node.pos; + } + if (ts.isJSDocNode(node) || node.kind === 11 /* SyntaxKind.JsxText */) { + // JsxText cannot actually contain comments, even though the scanner will think it sees comments + return ts.skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.pos, /*stopAfterLineBreak*/ false, /*stopAtComments*/ true); + } + if (includeJsDoc && ts.hasJSDocNodes(node)) { + return getTokenPosOfNode(node.jsDoc[0], sourceFile); + } + // For a syntax list, it is possible that one of its children has JSDocComment nodes, while + // the syntax list itself considers them as normal trivia. Therefore if we simply skip + // trivia for the list, we may have skipped the JSDocComment as well. So we should process its + // first child to determine the actual position of its first token. + if (node.kind === 351 /* SyntaxKind.SyntaxList */ && node._children.length > 0) { + return getTokenPosOfNode(node._children[0], sourceFile, includeJsDoc); + } + return ts.skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.pos, + /*stopAfterLineBreak*/ false, + /*stopAtComments*/ false, isInJSDoc(node)); + } + ts.getTokenPosOfNode = getTokenPosOfNode; + function getNonDecoratorTokenPosOfNode(node, sourceFile) { + var lastDecorator = !nodeIsMissing(node) && ts.canHaveModifiers(node) ? ts.findLast(node.modifiers, ts.isDecorator) : undefined; + if (!lastDecorator) { + return getTokenPosOfNode(node, sourceFile); + } + return ts.skipTrivia((sourceFile || getSourceFileOfNode(node)).text, lastDecorator.end); + } + ts.getNonDecoratorTokenPosOfNode = getNonDecoratorTokenPosOfNode; + function getSourceTextOfNodeFromSourceFile(sourceFile, node, includeTrivia) { + if (includeTrivia === void 0) { includeTrivia = false; } + return getTextOfNodeFromSourceText(sourceFile.text, node, includeTrivia); + } + ts.getSourceTextOfNodeFromSourceFile = getSourceTextOfNodeFromSourceFile; + function isJSDocTypeExpressionOrChild(node) { + return !!ts.findAncestor(node, ts.isJSDocTypeExpression); + } + function isExportNamespaceAsDefaultDeclaration(node) { + return !!(ts.isExportDeclaration(node) && node.exportClause && ts.isNamespaceExport(node.exportClause) && node.exportClause.name.escapedText === "default"); + } + ts.isExportNamespaceAsDefaultDeclaration = isExportNamespaceAsDefaultDeclaration; + function getTextOfNodeFromSourceText(sourceText, node, includeTrivia) { + if (includeTrivia === void 0) { includeTrivia = false; } + if (nodeIsMissing(node)) { + return ""; + } + var text = sourceText.substring(includeTrivia ? node.pos : ts.skipTrivia(sourceText, node.pos), node.end); + if (isJSDocTypeExpressionOrChild(node)) { + // strip space + asterisk at line start + text = text.split(/\r\n|\n|\r/).map(function (line) { return ts.trimStringStart(line.replace(/^\s*\*/, "")); }).join("\n"); + } + return text; + } + ts.getTextOfNodeFromSourceText = getTextOfNodeFromSourceText; + function getTextOfNode(node, includeTrivia) { + if (includeTrivia === void 0) { includeTrivia = false; } + return getSourceTextOfNodeFromSourceFile(getSourceFileOfNode(node), node, includeTrivia); + } + ts.getTextOfNode = getTextOfNode; + function getPos(range) { + return range.pos; + } + /** + * Note: it is expected that the `nodeArray` and the `node` are within the same file. + * For example, searching for a `SourceFile` in a `SourceFile[]` wouldn't work. + */ + function indexOfNode(nodeArray, node) { + return ts.binarySearch(nodeArray, node, getPos, ts.compareValues); + } + ts.indexOfNode = indexOfNode; + /** + * Gets flags that control emit behavior of a node. + */ + function getEmitFlags(node) { + var emitNode = node.emitNode; + return emitNode && emitNode.flags || 0; + } + ts.getEmitFlags = getEmitFlags; + function getScriptTargetFeatures() { + return { + es2015: { + Array: ["find", "findIndex", "fill", "copyWithin", "entries", "keys", "values"], + RegExp: ["flags", "sticky", "unicode"], + Reflect: ["apply", "construct", "defineProperty", "deleteProperty", "get", " getOwnPropertyDescriptor", "getPrototypeOf", "has", "isExtensible", "ownKeys", "preventExtensions", "set", "setPrototypeOf"], + ArrayConstructor: ["from", "of"], + ObjectConstructor: ["assign", "getOwnPropertySymbols", "keys", "is", "setPrototypeOf"], + NumberConstructor: ["isFinite", "isInteger", "isNaN", "isSafeInteger", "parseFloat", "parseInt"], + Math: ["clz32", "imul", "sign", "log10", "log2", "log1p", "expm1", "cosh", "sinh", "tanh", "acosh", "asinh", "atanh", "hypot", "trunc", "fround", "cbrt"], + Map: ["entries", "keys", "values"], + Set: ["entries", "keys", "values"], + Promise: ts.emptyArray, + PromiseConstructor: ["all", "race", "reject", "resolve"], + Symbol: ["for", "keyFor"], + WeakMap: ["entries", "keys", "values"], + WeakSet: ["entries", "keys", "values"], + Iterator: ts.emptyArray, + AsyncIterator: ts.emptyArray, + String: ["codePointAt", "includes", "endsWith", "normalize", "repeat", "startsWith", "anchor", "big", "blink", "bold", "fixed", "fontcolor", "fontsize", "italics", "link", "small", "strike", "sub", "sup"], + StringConstructor: ["fromCodePoint", "raw"] + }, + es2016: { + Array: ["includes"] + }, + es2017: { + Atomics: ts.emptyArray, + SharedArrayBuffer: ts.emptyArray, + String: ["padStart", "padEnd"], + ObjectConstructor: ["values", "entries", "getOwnPropertyDescriptors"], + DateTimeFormat: ["formatToParts"] + }, + es2018: { + Promise: ["finally"], + RegExpMatchArray: ["groups"], + RegExpExecArray: ["groups"], + RegExp: ["dotAll"], + Intl: ["PluralRules"], + AsyncIterable: ts.emptyArray, + AsyncIterableIterator: ts.emptyArray, + AsyncGenerator: ts.emptyArray, + AsyncGeneratorFunction: ts.emptyArray, + NumberFormat: ["formatToParts"] + }, + es2019: { + Array: ["flat", "flatMap"], + ObjectConstructor: ["fromEntries"], + String: ["trimStart", "trimEnd", "trimLeft", "trimRight"], + Symbol: ["description"] + }, + es2020: { + BigInt: ts.emptyArray, + BigInt64Array: ts.emptyArray, + BigUint64Array: ts.emptyArray, + PromiseConstructor: ["allSettled"], + SymbolConstructor: ["matchAll"], + String: ["matchAll"], + DataView: ["setBigInt64", "setBigUint64", "getBigInt64", "getBigUint64"], + RelativeTimeFormat: ["format", "formatToParts", "resolvedOptions"] + }, + es2021: { + PromiseConstructor: ["any"], + String: ["replaceAll"] + }, + es2022: { + Array: ["at"], + String: ["at"], + Int8Array: ["at"], + Uint8Array: ["at"], + Uint8ClampedArray: ["at"], + Int16Array: ["at"], + Uint16Array: ["at"], + Int32Array: ["at"], + Uint32Array: ["at"], + Float32Array: ["at"], + Float64Array: ["at"], + BigInt64Array: ["at"], + BigUint64Array: ["at"], + ObjectConstructor: ["hasOwn"], + Error: ["cause"] + } + }; + } + ts.getScriptTargetFeatures = getScriptTargetFeatures; + var GetLiteralTextFlags; + (function (GetLiteralTextFlags) { + GetLiteralTextFlags[GetLiteralTextFlags["None"] = 0] = "None"; + GetLiteralTextFlags[GetLiteralTextFlags["NeverAsciiEscape"] = 1] = "NeverAsciiEscape"; + GetLiteralTextFlags[GetLiteralTextFlags["JsxAttributeEscape"] = 2] = "JsxAttributeEscape"; + GetLiteralTextFlags[GetLiteralTextFlags["TerminateUnterminatedLiterals"] = 4] = "TerminateUnterminatedLiterals"; + GetLiteralTextFlags[GetLiteralTextFlags["AllowNumericSeparator"] = 8] = "AllowNumericSeparator"; + })(GetLiteralTextFlags = ts.GetLiteralTextFlags || (ts.GetLiteralTextFlags = {})); + function getLiteralText(node, sourceFile, flags) { + var _a; + // If we don't need to downlevel and we can reach the original source text using + // the node's parent reference, then simply get the text as it was originally written. + if (sourceFile && canUseOriginalText(node, flags)) { + return getSourceTextOfNodeFromSourceFile(sourceFile, node); + } + // If we can't reach the original source text, use the canonical form if it's a number, + // or a (possibly escaped) quoted form of the original text if it's string-like. + switch (node.kind) { + case 10 /* SyntaxKind.StringLiteral */: { + var escapeText = flags & 2 /* GetLiteralTextFlags.JsxAttributeEscape */ ? escapeJsxAttributeString : + flags & 1 /* GetLiteralTextFlags.NeverAsciiEscape */ || (getEmitFlags(node) & 16777216 /* EmitFlags.NoAsciiEscaping */) ? escapeString : + escapeNonAsciiString; + if (node.singleQuote) { + return "'" + escapeText(node.text, 39 /* CharacterCodes.singleQuote */) + "'"; + } + else { + return '"' + escapeText(node.text, 34 /* CharacterCodes.doubleQuote */) + '"'; + } + } + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + case 15 /* SyntaxKind.TemplateHead */: + case 16 /* SyntaxKind.TemplateMiddle */: + case 17 /* SyntaxKind.TemplateTail */: { + // If a NoSubstitutionTemplateLiteral appears to have a substitution in it, the original text + // had to include a backslash: `not \${a} substitution`. + var escapeText = flags & 1 /* GetLiteralTextFlags.NeverAsciiEscape */ || (getEmitFlags(node) & 16777216 /* EmitFlags.NoAsciiEscaping */) ? escapeString : + escapeNonAsciiString; + var rawText = (_a = node.rawText) !== null && _a !== void 0 ? _a : escapeTemplateSubstitution(escapeText(node.text, 96 /* CharacterCodes.backtick */)); + switch (node.kind) { + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + return "`" + rawText + "`"; + case 15 /* SyntaxKind.TemplateHead */: + return "`" + rawText + "${"; + case 16 /* SyntaxKind.TemplateMiddle */: + return "}" + rawText + "${"; + case 17 /* SyntaxKind.TemplateTail */: + return "}" + rawText + "`"; + } + break; + } + case 8 /* SyntaxKind.NumericLiteral */: + case 9 /* SyntaxKind.BigIntLiteral */: + return node.text; + case 13 /* SyntaxKind.RegularExpressionLiteral */: + if (flags & 4 /* GetLiteralTextFlags.TerminateUnterminatedLiterals */ && node.isUnterminated) { + return node.text + (node.text.charCodeAt(node.text.length - 1) === 92 /* CharacterCodes.backslash */ ? " /" : "/"); + } + return node.text; + } + return ts.Debug.fail("Literal kind '".concat(node.kind, "' not accounted for.")); + } + ts.getLiteralText = getLiteralText; + function canUseOriginalText(node, flags) { + if (nodeIsSynthesized(node) || !node.parent || (flags & 4 /* GetLiteralTextFlags.TerminateUnterminatedLiterals */ && node.isUnterminated)) { + return false; + } + if (ts.isNumericLiteral(node) && node.numericLiteralFlags & 512 /* TokenFlags.ContainsSeparator */) { + return !!(flags & 8 /* GetLiteralTextFlags.AllowNumericSeparator */); + } + return !ts.isBigIntLiteral(node); + } + function getTextOfConstantValue(value) { + return ts.isString(value) ? '"' + escapeNonAsciiString(value) + '"' : "" + value; + } + ts.getTextOfConstantValue = getTextOfConstantValue; + // Make an identifier from an external module name by extracting the string after the last "/" and replacing + // all non-alphanumeric characters with underscores + function makeIdentifierFromModuleName(moduleName) { + return ts.getBaseFileName(moduleName).replace(/^(\d)/, "_$1").replace(/\W/g, "_"); + } + ts.makeIdentifierFromModuleName = makeIdentifierFromModuleName; + function isBlockOrCatchScoped(declaration) { + return (ts.getCombinedNodeFlags(declaration) & 3 /* NodeFlags.BlockScoped */) !== 0 || + isCatchClauseVariableDeclarationOrBindingElement(declaration); + } + ts.isBlockOrCatchScoped = isBlockOrCatchScoped; + function isCatchClauseVariableDeclarationOrBindingElement(declaration) { + var node = getRootDeclaration(declaration); + return node.kind === 257 /* SyntaxKind.VariableDeclaration */ && node.parent.kind === 295 /* SyntaxKind.CatchClause */; + } + ts.isCatchClauseVariableDeclarationOrBindingElement = isCatchClauseVariableDeclarationOrBindingElement; + function isAmbientModule(node) { + return ts.isModuleDeclaration(node) && (node.name.kind === 10 /* SyntaxKind.StringLiteral */ || isGlobalScopeAugmentation(node)); + } + ts.isAmbientModule = isAmbientModule; + function isModuleWithStringLiteralName(node) { + return ts.isModuleDeclaration(node) && node.name.kind === 10 /* SyntaxKind.StringLiteral */; + } + ts.isModuleWithStringLiteralName = isModuleWithStringLiteralName; + function isNonGlobalAmbientModule(node) { + return ts.isModuleDeclaration(node) && ts.isStringLiteral(node.name); + } + ts.isNonGlobalAmbientModule = isNonGlobalAmbientModule; + /** + * An effective module (namespace) declaration is either + * 1. An actual declaration: namespace X { ... } + * 2. A Javascript declaration, which is: + * An identifier in a nested property access expression: Y in `X.Y.Z = { ... }` + */ + function isEffectiveModuleDeclaration(node) { + return ts.isModuleDeclaration(node) || ts.isIdentifier(node); + } + ts.isEffectiveModuleDeclaration = isEffectiveModuleDeclaration; + /** Given a symbol for a module, checks that it is a shorthand ambient module. */ + function isShorthandAmbientModuleSymbol(moduleSymbol) { + return isShorthandAmbientModule(moduleSymbol.valueDeclaration); + } + ts.isShorthandAmbientModuleSymbol = isShorthandAmbientModuleSymbol; + function isShorthandAmbientModule(node) { + // The only kind of module that can be missing a body is a shorthand ambient module. + return !!node && node.kind === 264 /* SyntaxKind.ModuleDeclaration */ && (!node.body); + } + function isBlockScopedContainerTopLevel(node) { + return node.kind === 308 /* SyntaxKind.SourceFile */ || + node.kind === 264 /* SyntaxKind.ModuleDeclaration */ || + ts.isFunctionLikeOrClassStaticBlockDeclaration(node); + } + ts.isBlockScopedContainerTopLevel = isBlockScopedContainerTopLevel; + function isGlobalScopeAugmentation(module) { + return !!(module.flags & 1024 /* NodeFlags.GlobalAugmentation */); + } + ts.isGlobalScopeAugmentation = isGlobalScopeAugmentation; + function isExternalModuleAugmentation(node) { + return isAmbientModule(node) && isModuleAugmentationExternal(node); + } + ts.isExternalModuleAugmentation = isExternalModuleAugmentation; + function isModuleAugmentationExternal(node) { + // external module augmentation is a ambient module declaration that is either: + // - defined in the top level scope and source file is an external module + // - defined inside ambient module declaration located in the top level scope and source file not an external module + switch (node.parent.kind) { + case 308 /* SyntaxKind.SourceFile */: + return ts.isExternalModule(node.parent); + case 265 /* SyntaxKind.ModuleBlock */: + return isAmbientModule(node.parent.parent) && ts.isSourceFile(node.parent.parent.parent) && !ts.isExternalModule(node.parent.parent.parent); + } + return false; + } + ts.isModuleAugmentationExternal = isModuleAugmentationExternal; + function getNonAugmentationDeclaration(symbol) { + var _a; + return (_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.find(function (d) { return !isExternalModuleAugmentation(d) && !(ts.isModuleDeclaration(d) && isGlobalScopeAugmentation(d)); }); + } + ts.getNonAugmentationDeclaration = getNonAugmentationDeclaration; + function isCommonJSContainingModuleKind(kind) { + return kind === ts.ModuleKind.CommonJS || kind === ts.ModuleKind.Node16 || kind === ts.ModuleKind.NodeNext; + } + function isEffectiveExternalModule(node, compilerOptions) { + return ts.isExternalModule(node) || compilerOptions.isolatedModules || (isCommonJSContainingModuleKind(getEmitModuleKind(compilerOptions)) && !!node.commonJsModuleIndicator); + } + ts.isEffectiveExternalModule = isEffectiveExternalModule; + /** + * Returns whether the source file will be treated as if it were in strict mode at runtime. + */ + function isEffectiveStrictModeSourceFile(node, compilerOptions) { + // We can only verify strict mode for JS/TS files + switch (node.scriptKind) { + case 1 /* ScriptKind.JS */: + case 3 /* ScriptKind.TS */: + case 2 /* ScriptKind.JSX */: + case 4 /* ScriptKind.TSX */: + break; + default: + return false; + } + // Strict mode does not matter for declaration files. + if (node.isDeclarationFile) { + return false; + } + // If `alwaysStrict` is set, then treat the file as strict. + if (getStrictOptionValue(compilerOptions, "alwaysStrict")) { + return true; + } + // Starting with a "use strict" directive indicates the file is strict. + if (ts.startsWithUseStrict(node.statements)) { + return true; + } + if (ts.isExternalModule(node) || compilerOptions.isolatedModules) { + // ECMAScript Modules are always strict. + if (getEmitModuleKind(compilerOptions) >= ts.ModuleKind.ES2015) { + return true; + } + // Other modules are strict unless otherwise specified. + return !compilerOptions.noImplicitUseStrict; + } + return false; + } + ts.isEffectiveStrictModeSourceFile = isEffectiveStrictModeSourceFile; + function isAmbientPropertyDeclaration(node) { + return !!(node.flags & 16777216 /* NodeFlags.Ambient */) || hasSyntacticModifier(node, 2 /* ModifierFlags.Ambient */); + } + ts.isAmbientPropertyDeclaration = isAmbientPropertyDeclaration; + function isBlockScope(node, parentNode) { + switch (node.kind) { + case 308 /* SyntaxKind.SourceFile */: + case 266 /* SyntaxKind.CaseBlock */: + case 295 /* SyntaxKind.CatchClause */: + case 264 /* SyntaxKind.ModuleDeclaration */: + case 245 /* SyntaxKind.ForStatement */: + case 246 /* SyntaxKind.ForInStatement */: + case 247 /* SyntaxKind.ForOfStatement */: + case 173 /* SyntaxKind.Constructor */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 172 /* SyntaxKind.ClassStaticBlockDeclaration */: + return true; + case 238 /* SyntaxKind.Block */: + // function block is not considered block-scope container + // see comment in binder.ts: bind(...), case for SyntaxKind.Block + return !ts.isFunctionLikeOrClassStaticBlockDeclaration(parentNode); + } + return false; + } + ts.isBlockScope = isBlockScope; + function isDeclarationWithTypeParameters(node) { + switch (node.kind) { + case 341 /* SyntaxKind.JSDocCallbackTag */: + case 348 /* SyntaxKind.JSDocTypedefTag */: + case 326 /* SyntaxKind.JSDocSignature */: + return true; + default: + ts.assertType(node); + return isDeclarationWithTypeParameterChildren(node); + } + } + ts.isDeclarationWithTypeParameters = isDeclarationWithTypeParameters; + function isDeclarationWithTypeParameterChildren(node) { + switch (node.kind) { + case 176 /* SyntaxKind.CallSignature */: + case 177 /* SyntaxKind.ConstructSignature */: + case 170 /* SyntaxKind.MethodSignature */: + case 178 /* SyntaxKind.IndexSignature */: + case 181 /* SyntaxKind.FunctionType */: + case 182 /* SyntaxKind.ConstructorType */: + case 320 /* SyntaxKind.JSDocFunctionType */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 347 /* SyntaxKind.JSDocTemplateTag */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 173 /* SyntaxKind.Constructor */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + return true; + default: + ts.assertType(node); + return false; + } + } + ts.isDeclarationWithTypeParameterChildren = isDeclarationWithTypeParameterChildren; + function isAnyImportSyntax(node) { + switch (node.kind) { + case 269 /* SyntaxKind.ImportDeclaration */: + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return true; + default: + return false; + } + } + ts.isAnyImportSyntax = isAnyImportSyntax; + function isAnyImportOrBareOrAccessedRequire(node) { + return isAnyImportSyntax(node) || isVariableDeclarationInitializedToBareOrAccessedRequire(node); + } + ts.isAnyImportOrBareOrAccessedRequire = isAnyImportOrBareOrAccessedRequire; + function isLateVisibilityPaintedStatement(node) { + switch (node.kind) { + case 269 /* SyntaxKind.ImportDeclaration */: + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + case 240 /* SyntaxKind.VariableStatement */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 264 /* SyntaxKind.ModuleDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + return true; + default: + return false; + } + } + ts.isLateVisibilityPaintedStatement = isLateVisibilityPaintedStatement; + function hasPossibleExternalModuleReference(node) { + return isAnyImportOrReExport(node) || ts.isModuleDeclaration(node) || ts.isImportTypeNode(node) || isImportCall(node); + } + ts.hasPossibleExternalModuleReference = hasPossibleExternalModuleReference; + function isAnyImportOrReExport(node) { + return isAnyImportSyntax(node) || ts.isExportDeclaration(node); + } + ts.isAnyImportOrReExport = isAnyImportOrReExport; + // Gets the nearest enclosing block scope container that has the provided node + // as a descendant, that is not the provided node. + function getEnclosingBlockScopeContainer(node) { + return ts.findAncestor(node.parent, function (current) { return isBlockScope(current, current.parent); }); + } + ts.getEnclosingBlockScopeContainer = getEnclosingBlockScopeContainer; + function forEachEnclosingBlockScopeContainer(node, cb) { + var container = getEnclosingBlockScopeContainer(node); + while (container) { + cb(container); + container = getEnclosingBlockScopeContainer(container); + } + } + ts.forEachEnclosingBlockScopeContainer = forEachEnclosingBlockScopeContainer; + // Return display name of an identifier + // Computed property names will just be emitted as "[]", where is the source + // text of the expression in the computed property. + function declarationNameToString(name) { + return !name || getFullWidth(name) === 0 ? "(Missing)" : getTextOfNode(name); + } + ts.declarationNameToString = declarationNameToString; + function getNameFromIndexInfo(info) { + return info.declaration ? declarationNameToString(info.declaration.parameters[0].name) : undefined; + } + ts.getNameFromIndexInfo = getNameFromIndexInfo; + function isComputedNonLiteralName(name) { + return name.kind === 164 /* SyntaxKind.ComputedPropertyName */ && !isStringOrNumericLiteralLike(name.expression); + } + ts.isComputedNonLiteralName = isComputedNonLiteralName; + function tryGetTextOfPropertyName(name) { + switch (name.kind) { + case 79 /* SyntaxKind.Identifier */: + case 80 /* SyntaxKind.PrivateIdentifier */: + return name.autoGenerateFlags ? undefined : name.escapedText; + case 10 /* SyntaxKind.StringLiteral */: + case 8 /* SyntaxKind.NumericLiteral */: + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + return ts.escapeLeadingUnderscores(name.text); + case 164 /* SyntaxKind.ComputedPropertyName */: + if (isStringOrNumericLiteralLike(name.expression)) + return ts.escapeLeadingUnderscores(name.expression.text); + return undefined; + default: + return ts.Debug.assertNever(name); + } + } + ts.tryGetTextOfPropertyName = tryGetTextOfPropertyName; + function getTextOfPropertyName(name) { + return ts.Debug.checkDefined(tryGetTextOfPropertyName(name)); + } + ts.getTextOfPropertyName = getTextOfPropertyName; + function entityNameToString(name) { + switch (name.kind) { + case 108 /* SyntaxKind.ThisKeyword */: + return "this"; + case 80 /* SyntaxKind.PrivateIdentifier */: + case 79 /* SyntaxKind.Identifier */: + return getFullWidth(name) === 0 ? ts.idText(name) : getTextOfNode(name); + case 163 /* SyntaxKind.QualifiedName */: + return entityNameToString(name.left) + "." + entityNameToString(name.right); + case 208 /* SyntaxKind.PropertyAccessExpression */: + if (ts.isIdentifier(name.name) || ts.isPrivateIdentifier(name.name)) { + return entityNameToString(name.expression) + "." + entityNameToString(name.name); + } + else { + return ts.Debug.assertNever(name.name); + } + case 314 /* SyntaxKind.JSDocMemberName */: + return entityNameToString(name.left) + entityNameToString(name.right); + default: + return ts.Debug.assertNever(name); + } + } + ts.entityNameToString = entityNameToString; + function createDiagnosticForNode(node, message, arg0, arg1, arg2, arg3) { + var sourceFile = getSourceFileOfNode(node); + return createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2, arg3); + } + ts.createDiagnosticForNode = createDiagnosticForNode; + function createDiagnosticForNodeArray(sourceFile, nodes, message, arg0, arg1, arg2, arg3) { + var start = ts.skipTrivia(sourceFile.text, nodes.pos); + return createFileDiagnostic(sourceFile, start, nodes.end - start, message, arg0, arg1, arg2, arg3); + } + ts.createDiagnosticForNodeArray = createDiagnosticForNodeArray; + function createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2, arg3) { + var span = getErrorSpanForNode(sourceFile, node); + return createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2, arg3); + } + ts.createDiagnosticForNodeInSourceFile = createDiagnosticForNodeInSourceFile; + function createDiagnosticForNodeFromMessageChain(node, messageChain, relatedInformation) { + var sourceFile = getSourceFileOfNode(node); + var span = getErrorSpanForNode(sourceFile, node); + return createFileDiagnosticFromMessageChain(sourceFile, span.start, span.length, messageChain, relatedInformation); + } + ts.createDiagnosticForNodeFromMessageChain = createDiagnosticForNodeFromMessageChain; + function assertDiagnosticLocation(file, start, length) { + ts.Debug.assertGreaterThanOrEqual(start, 0); + ts.Debug.assertGreaterThanOrEqual(length, 0); + if (file) { + ts.Debug.assertLessThanOrEqual(start, file.text.length); + ts.Debug.assertLessThanOrEqual(start + length, file.text.length); + } + } + function createFileDiagnosticFromMessageChain(file, start, length, messageChain, relatedInformation) { + assertDiagnosticLocation(file, start, length); + return { + file: file, + start: start, + length: length, + code: messageChain.code, + category: messageChain.category, + messageText: messageChain.next ? messageChain : messageChain.messageText, + relatedInformation: relatedInformation + }; + } + ts.createFileDiagnosticFromMessageChain = createFileDiagnosticFromMessageChain; + function createDiagnosticForFileFromMessageChain(sourceFile, messageChain, relatedInformation) { + return { + file: sourceFile, + start: 0, + length: 0, + code: messageChain.code, + category: messageChain.category, + messageText: messageChain.next ? messageChain : messageChain.messageText, + relatedInformation: relatedInformation + }; + } + ts.createDiagnosticForFileFromMessageChain = createDiagnosticForFileFromMessageChain; + function createDiagnosticMessageChainFromDiagnostic(diagnostic) { + return typeof diagnostic.messageText === "string" ? { + code: diagnostic.code, + category: diagnostic.category, + messageText: diagnostic.messageText, + next: diagnostic.next, + } : diagnostic.messageText; + } + ts.createDiagnosticMessageChainFromDiagnostic = createDiagnosticMessageChainFromDiagnostic; + function createDiagnosticForRange(sourceFile, range, message) { + return { + file: sourceFile, + start: range.pos, + length: range.end - range.pos, + code: message.code, + category: message.category, + messageText: message.message, + }; + } + ts.createDiagnosticForRange = createDiagnosticForRange; + function getSpanOfTokenAtPosition(sourceFile, pos) { + var scanner = ts.createScanner(sourceFile.languageVersion, /*skipTrivia*/ true, sourceFile.languageVariant, sourceFile.text, /*onError:*/ undefined, pos); + scanner.scan(); + var start = scanner.getTokenPos(); + return ts.createTextSpanFromBounds(start, scanner.getTextPos()); + } + ts.getSpanOfTokenAtPosition = getSpanOfTokenAtPosition; + function getErrorSpanForArrowFunction(sourceFile, node) { + var pos = ts.skipTrivia(sourceFile.text, node.pos); + if (node.body && node.body.kind === 238 /* SyntaxKind.Block */) { + var startLine = ts.getLineAndCharacterOfPosition(sourceFile, node.body.pos).line; + var endLine = ts.getLineAndCharacterOfPosition(sourceFile, node.body.end).line; + if (startLine < endLine) { + // The arrow function spans multiple lines, + // make the error span be the first line, inclusive. + return ts.createTextSpan(pos, getEndLinePosition(startLine, sourceFile) - pos + 1); + } + } + return ts.createTextSpanFromBounds(pos, node.end); + } + function getErrorSpanForNode(sourceFile, node) { + var errorNode = node; + switch (node.kind) { + case 308 /* SyntaxKind.SourceFile */: + var pos_1 = ts.skipTrivia(sourceFile.text, 0, /*stopAfterLineBreak*/ false); + if (pos_1 === sourceFile.text.length) { + // file is empty - return span for the beginning of the file + return ts.createTextSpan(0, 0); + } + return getSpanOfTokenAtPosition(sourceFile, pos_1); + // This list is a work in progress. Add missing node kinds to improve their error + // spans. + case 257 /* SyntaxKind.VariableDeclaration */: + case 205 /* SyntaxKind.BindingElement */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 264 /* SyntaxKind.ModuleDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 302 /* SyntaxKind.EnumMember */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 168 /* SyntaxKind.PropertySignature */: + case 271 /* SyntaxKind.NamespaceImport */: + errorNode = node.name; + break; + case 216 /* SyntaxKind.ArrowFunction */: + return getErrorSpanForArrowFunction(sourceFile, node); + case 292 /* SyntaxKind.CaseClause */: + case 293 /* SyntaxKind.DefaultClause */: + var start = ts.skipTrivia(sourceFile.text, node.pos); + var end = node.statements.length > 0 ? node.statements[0].pos : node.end; + return ts.createTextSpanFromBounds(start, end); + } + if (errorNode === undefined) { + // If we don't have a better node, then just set the error on the first token of + // construct. + return getSpanOfTokenAtPosition(sourceFile, node.pos); + } + ts.Debug.assert(!ts.isJSDoc(errorNode)); + var isMissing = nodeIsMissing(errorNode); + var pos = isMissing || ts.isJsxText(node) + ? errorNode.pos + : ts.skipTrivia(sourceFile.text, errorNode.pos); + // These asserts should all be satisfied for a properly constructed `errorNode`. + if (isMissing) { + ts.Debug.assert(pos === errorNode.pos, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809"); + ts.Debug.assert(pos === errorNode.end, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809"); + } + else { + ts.Debug.assert(pos >= errorNode.pos, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809"); + ts.Debug.assert(pos <= errorNode.end, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809"); + } + return ts.createTextSpanFromBounds(pos, errorNode.end); + } + ts.getErrorSpanForNode = getErrorSpanForNode; + function isExternalOrCommonJsModule(file) { + return (file.externalModuleIndicator || file.commonJsModuleIndicator) !== undefined; + } + ts.isExternalOrCommonJsModule = isExternalOrCommonJsModule; + function isJsonSourceFile(file) { + return file.scriptKind === 6 /* ScriptKind.JSON */; + } + ts.isJsonSourceFile = isJsonSourceFile; + function isEnumConst(node) { + return !!(ts.getCombinedModifierFlags(node) & 2048 /* ModifierFlags.Const */); + } + ts.isEnumConst = isEnumConst; + function isDeclarationReadonly(declaration) { + return !!(ts.getCombinedModifierFlags(declaration) & 64 /* ModifierFlags.Readonly */ && !ts.isParameterPropertyDeclaration(declaration, declaration.parent)); + } + ts.isDeclarationReadonly = isDeclarationReadonly; + function isVarConst(node) { + return !!(ts.getCombinedNodeFlags(node) & 2 /* NodeFlags.Const */); + } + ts.isVarConst = isVarConst; + function isLet(node) { + return !!(ts.getCombinedNodeFlags(node) & 1 /* NodeFlags.Let */); + } + ts.isLet = isLet; + function isSuperCall(n) { + return n.kind === 210 /* SyntaxKind.CallExpression */ && n.expression.kind === 106 /* SyntaxKind.SuperKeyword */; + } + ts.isSuperCall = isSuperCall; + function isImportCall(n) { + return n.kind === 210 /* SyntaxKind.CallExpression */ && n.expression.kind === 100 /* SyntaxKind.ImportKeyword */; + } + ts.isImportCall = isImportCall; + function isImportMeta(n) { + return ts.isMetaProperty(n) + && n.keywordToken === 100 /* SyntaxKind.ImportKeyword */ + && n.name.escapedText === "meta"; + } + ts.isImportMeta = isImportMeta; + function isLiteralImportTypeNode(n) { + return ts.isImportTypeNode(n) && ts.isLiteralTypeNode(n.argument) && ts.isStringLiteral(n.argument.literal); + } + ts.isLiteralImportTypeNode = isLiteralImportTypeNode; + function isPrologueDirective(node) { + return node.kind === 241 /* SyntaxKind.ExpressionStatement */ + && node.expression.kind === 10 /* SyntaxKind.StringLiteral */; + } + ts.isPrologueDirective = isPrologueDirective; + function isCustomPrologue(node) { + return !!(getEmitFlags(node) & 1048576 /* EmitFlags.CustomPrologue */); + } + ts.isCustomPrologue = isCustomPrologue; + function isHoistedFunction(node) { + return isCustomPrologue(node) + && ts.isFunctionDeclaration(node); + } + ts.isHoistedFunction = isHoistedFunction; + function isHoistedVariable(node) { + return ts.isIdentifier(node.name) + && !node.initializer; + } + function isHoistedVariableStatement(node) { + return isCustomPrologue(node) + && ts.isVariableStatement(node) + && ts.every(node.declarationList.declarations, isHoistedVariable); + } + ts.isHoistedVariableStatement = isHoistedVariableStatement; + function getLeadingCommentRangesOfNode(node, sourceFileOfNode) { + return node.kind !== 11 /* SyntaxKind.JsxText */ ? ts.getLeadingCommentRanges(sourceFileOfNode.text, node.pos) : undefined; + } + ts.getLeadingCommentRangesOfNode = getLeadingCommentRangesOfNode; + function getJSDocCommentRanges(node, text) { + var commentRanges = (node.kind === 166 /* SyntaxKind.Parameter */ || + node.kind === 165 /* SyntaxKind.TypeParameter */ || + node.kind === 215 /* SyntaxKind.FunctionExpression */ || + node.kind === 216 /* SyntaxKind.ArrowFunction */ || + node.kind === 214 /* SyntaxKind.ParenthesizedExpression */ || + node.kind === 257 /* SyntaxKind.VariableDeclaration */ || + node.kind === 278 /* SyntaxKind.ExportSpecifier */) ? + ts.concatenate(ts.getTrailingCommentRanges(text, node.pos), ts.getLeadingCommentRanges(text, node.pos)) : + ts.getLeadingCommentRanges(text, node.pos); + // True if the comment starts with '/**' but not if it is '/**/' + return ts.filter(commentRanges, function (comment) { + return text.charCodeAt(comment.pos + 1) === 42 /* CharacterCodes.asterisk */ && + text.charCodeAt(comment.pos + 2) === 42 /* CharacterCodes.asterisk */ && + text.charCodeAt(comment.pos + 3) !== 47 /* CharacterCodes.slash */; + }); + } + ts.getJSDocCommentRanges = getJSDocCommentRanges; + ts.fullTripleSlashReferencePathRegEx = /^(\/\/\/\s*/; + var fullTripleSlashReferenceTypeReferenceDirectiveRegEx = /^(\/\/\/\s*/; + ts.fullTripleSlashAMDReferencePathRegEx = /^(\/\/\/\s*/; + var defaultLibReferenceRegEx = /^(\/\/\/\s*/; + function isPartOfTypeNode(node) { + if (179 /* SyntaxKind.FirstTypeNode */ <= node.kind && node.kind <= 202 /* SyntaxKind.LastTypeNode */) { + return true; + } + switch (node.kind) { + case 131 /* SyntaxKind.AnyKeyword */: + case 157 /* SyntaxKind.UnknownKeyword */: + case 148 /* SyntaxKind.NumberKeyword */: + case 160 /* SyntaxKind.BigIntKeyword */: + case 152 /* SyntaxKind.StringKeyword */: + case 134 /* SyntaxKind.BooleanKeyword */: + case 153 /* SyntaxKind.SymbolKeyword */: + case 149 /* SyntaxKind.ObjectKeyword */: + case 155 /* SyntaxKind.UndefinedKeyword */: + case 144 /* SyntaxKind.NeverKeyword */: + return true; + case 114 /* SyntaxKind.VoidKeyword */: + return node.parent.kind !== 219 /* SyntaxKind.VoidExpression */; + case 230 /* SyntaxKind.ExpressionWithTypeArguments */: + return ts.isHeritageClause(node.parent) && !isExpressionWithTypeArgumentsInClassExtendsClause(node); + case 165 /* SyntaxKind.TypeParameter */: + return node.parent.kind === 197 /* SyntaxKind.MappedType */ || node.parent.kind === 192 /* SyntaxKind.InferType */; + // Identifiers and qualified names may be type nodes, depending on their context. Climb + // above them to find the lowest container + case 79 /* SyntaxKind.Identifier */: + // If the identifier is the RHS of a qualified name, then it's a type iff its parent is. + if (node.parent.kind === 163 /* SyntaxKind.QualifiedName */ && node.parent.right === node) { + node = node.parent; + } + else if (node.parent.kind === 208 /* SyntaxKind.PropertyAccessExpression */ && node.parent.name === node) { + node = node.parent; + } + // At this point, node is either a qualified name or an identifier + ts.Debug.assert(node.kind === 79 /* SyntaxKind.Identifier */ || node.kind === 163 /* SyntaxKind.QualifiedName */ || node.kind === 208 /* SyntaxKind.PropertyAccessExpression */, "'node' was expected to be a qualified name, identifier or property access in 'isPartOfTypeNode'."); + // falls through + case 163 /* SyntaxKind.QualifiedName */: + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 108 /* SyntaxKind.ThisKeyword */: { + var parent = node.parent; + if (parent.kind === 183 /* SyntaxKind.TypeQuery */) { + return false; + } + if (parent.kind === 202 /* SyntaxKind.ImportType */) { + return !parent.isTypeOf; + } + // Do not recursively call isPartOfTypeNode on the parent. In the example: + // + // let a: A.B.C; + // + // Calling isPartOfTypeNode would consider the qualified name A.B a type node. + // Only C and A.B.C are type nodes. + if (179 /* SyntaxKind.FirstTypeNode */ <= parent.kind && parent.kind <= 202 /* SyntaxKind.LastTypeNode */) { + return true; + } + switch (parent.kind) { + case 230 /* SyntaxKind.ExpressionWithTypeArguments */: + return ts.isHeritageClause(parent.parent) && !isExpressionWithTypeArgumentsInClassExtendsClause(parent); + case 165 /* SyntaxKind.TypeParameter */: + return node === parent.constraint; + case 347 /* SyntaxKind.JSDocTemplateTag */: + return node === parent.constraint; + case 169 /* SyntaxKind.PropertyDeclaration */: + case 168 /* SyntaxKind.PropertySignature */: + case 166 /* SyntaxKind.Parameter */: + case 257 /* SyntaxKind.VariableDeclaration */: + return node === parent.type; + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + case 173 /* SyntaxKind.Constructor */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + return node === parent.type; + case 176 /* SyntaxKind.CallSignature */: + case 177 /* SyntaxKind.ConstructSignature */: + case 178 /* SyntaxKind.IndexSignature */: + return node === parent.type; + case 213 /* SyntaxKind.TypeAssertionExpression */: + return node === parent.type; + case 210 /* SyntaxKind.CallExpression */: + case 211 /* SyntaxKind.NewExpression */: + return ts.contains(parent.typeArguments, node); + case 212 /* SyntaxKind.TaggedTemplateExpression */: + // TODO (drosen): TaggedTemplateExpressions may eventually support type arguments. + return false; + } + } + } + return false; + } + ts.isPartOfTypeNode = isPartOfTypeNode; + function isChildOfNodeWithKind(node, kind) { + while (node) { + if (node.kind === kind) { + return true; + } + node = node.parent; + } + return false; + } + ts.isChildOfNodeWithKind = isChildOfNodeWithKind; + // Warning: This has the same semantics as the forEach family of functions, + // in that traversal terminates in the event that 'visitor' supplies a truthy value. + function forEachReturnStatement(body, visitor) { + return traverse(body); + function traverse(node) { + switch (node.kind) { + case 250 /* SyntaxKind.ReturnStatement */: + return visitor(node); + case 266 /* SyntaxKind.CaseBlock */: + case 238 /* SyntaxKind.Block */: + case 242 /* SyntaxKind.IfStatement */: + case 243 /* SyntaxKind.DoStatement */: + case 244 /* SyntaxKind.WhileStatement */: + case 245 /* SyntaxKind.ForStatement */: + case 246 /* SyntaxKind.ForInStatement */: + case 247 /* SyntaxKind.ForOfStatement */: + case 251 /* SyntaxKind.WithStatement */: + case 252 /* SyntaxKind.SwitchStatement */: + case 292 /* SyntaxKind.CaseClause */: + case 293 /* SyntaxKind.DefaultClause */: + case 253 /* SyntaxKind.LabeledStatement */: + case 255 /* SyntaxKind.TryStatement */: + case 295 /* SyntaxKind.CatchClause */: + return ts.forEachChild(node, traverse); + } + } + } + ts.forEachReturnStatement = forEachReturnStatement; + function forEachYieldExpression(body, visitor) { + return traverse(body); + function traverse(node) { + switch (node.kind) { + case 226 /* SyntaxKind.YieldExpression */: + visitor(node); + var operand = node.expression; + if (operand) { + traverse(operand); + } + return; + case 263 /* SyntaxKind.EnumDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 264 /* SyntaxKind.ModuleDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + // These are not allowed inside a generator now, but eventually they may be allowed + // as local types. Regardless, skip them to avoid the work. + return; + default: + if (ts.isFunctionLike(node)) { + if (node.name && node.name.kind === 164 /* SyntaxKind.ComputedPropertyName */) { + // Note that we will not include methods/accessors of a class because they would require + // first descending into the class. This is by design. + traverse(node.name.expression); + return; + } + } + else if (!isPartOfTypeNode(node)) { + // This is the general case, which should include mostly expressions and statements. + // Also includes NodeArrays. + ts.forEachChild(node, traverse); + } + } + } + } + ts.forEachYieldExpression = forEachYieldExpression; + /** + * Gets the most likely element type for a TypeNode. This is not an exhaustive test + * as it assumes a rest argument can only be an array type (either T[], or Array). + * + * @param node The type node. + */ + function getRestParameterElementType(node) { + if (node && node.kind === 185 /* SyntaxKind.ArrayType */) { + return node.elementType; + } + else if (node && node.kind === 180 /* SyntaxKind.TypeReference */) { + return ts.singleOrUndefined(node.typeArguments); + } + else { + return undefined; + } + } + ts.getRestParameterElementType = getRestParameterElementType; + function getMembersOfDeclaration(node) { + switch (node.kind) { + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + case 184 /* SyntaxKind.TypeLiteral */: + return node.members; + case 207 /* SyntaxKind.ObjectLiteralExpression */: + return node.properties; + } + } + ts.getMembersOfDeclaration = getMembersOfDeclaration; + function isVariableLike(node) { + if (node) { + switch (node.kind) { + case 205 /* SyntaxKind.BindingElement */: + case 302 /* SyntaxKind.EnumMember */: + case 166 /* SyntaxKind.Parameter */: + case 299 /* SyntaxKind.PropertyAssignment */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 168 /* SyntaxKind.PropertySignature */: + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + case 257 /* SyntaxKind.VariableDeclaration */: + return true; + } + } + return false; + } + ts.isVariableLike = isVariableLike; + function isVariableLikeOrAccessor(node) { + return isVariableLike(node) || ts.isAccessor(node); + } + ts.isVariableLikeOrAccessor = isVariableLikeOrAccessor; + function isVariableDeclarationInVariableStatement(node) { + return node.parent.kind === 258 /* SyntaxKind.VariableDeclarationList */ + && node.parent.parent.kind === 240 /* SyntaxKind.VariableStatement */; + } + ts.isVariableDeclarationInVariableStatement = isVariableDeclarationInVariableStatement; + function isCommonJsExportedExpression(node) { + if (!isInJSFile(node)) + return false; + return (ts.isObjectLiteralExpression(node.parent) && ts.isBinaryExpression(node.parent.parent) && getAssignmentDeclarationKind(node.parent.parent) === 2 /* AssignmentDeclarationKind.ModuleExports */) || + isCommonJsExportPropertyAssignment(node.parent); + } + ts.isCommonJsExportedExpression = isCommonJsExportedExpression; + function isCommonJsExportPropertyAssignment(node) { + if (!isInJSFile(node)) + return false; + return (ts.isBinaryExpression(node) && getAssignmentDeclarationKind(node) === 1 /* AssignmentDeclarationKind.ExportsProperty */); + } + ts.isCommonJsExportPropertyAssignment = isCommonJsExportPropertyAssignment; + function isValidESSymbolDeclaration(node) { + return (ts.isVariableDeclaration(node) ? isVarConst(node) && ts.isIdentifier(node.name) && isVariableDeclarationInVariableStatement(node) : + ts.isPropertyDeclaration(node) ? hasEffectiveReadonlyModifier(node) && hasStaticModifier(node) : + ts.isPropertySignature(node) && hasEffectiveReadonlyModifier(node)) || isCommonJsExportPropertyAssignment(node); + } + ts.isValidESSymbolDeclaration = isValidESSymbolDeclaration; + function introducesArgumentsExoticObject(node) { + switch (node.kind) { + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + case 173 /* SyntaxKind.Constructor */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + return true; + } + return false; + } + ts.introducesArgumentsExoticObject = introducesArgumentsExoticObject; + function unwrapInnermostStatementOfLabel(node, beforeUnwrapLabelCallback) { + while (true) { + if (beforeUnwrapLabelCallback) { + beforeUnwrapLabelCallback(node); + } + if (node.statement.kind !== 253 /* SyntaxKind.LabeledStatement */) { + return node.statement; + } + node = node.statement; + } + } + ts.unwrapInnermostStatementOfLabel = unwrapInnermostStatementOfLabel; + function isFunctionBlock(node) { + return node && node.kind === 238 /* SyntaxKind.Block */ && ts.isFunctionLike(node.parent); + } + ts.isFunctionBlock = isFunctionBlock; + function isObjectLiteralMethod(node) { + return node && node.kind === 171 /* SyntaxKind.MethodDeclaration */ && node.parent.kind === 207 /* SyntaxKind.ObjectLiteralExpression */; + } + ts.isObjectLiteralMethod = isObjectLiteralMethod; + function isObjectLiteralOrClassExpressionMethodOrAccessor(node) { + return (node.kind === 171 /* SyntaxKind.MethodDeclaration */ || node.kind === 174 /* SyntaxKind.GetAccessor */ || node.kind === 175 /* SyntaxKind.SetAccessor */) && + (node.parent.kind === 207 /* SyntaxKind.ObjectLiteralExpression */ || + node.parent.kind === 228 /* SyntaxKind.ClassExpression */); + } + ts.isObjectLiteralOrClassExpressionMethodOrAccessor = isObjectLiteralOrClassExpressionMethodOrAccessor; + function isIdentifierTypePredicate(predicate) { + return predicate && predicate.kind === 1 /* TypePredicateKind.Identifier */; + } + ts.isIdentifierTypePredicate = isIdentifierTypePredicate; + function isThisTypePredicate(predicate) { + return predicate && predicate.kind === 0 /* TypePredicateKind.This */; + } + ts.isThisTypePredicate = isThisTypePredicate; + function getPropertyAssignment(objectLiteral, key, key2) { + return objectLiteral.properties.filter(function (property) { + if (property.kind === 299 /* SyntaxKind.PropertyAssignment */) { + var propName = tryGetTextOfPropertyName(property.name); + return key === propName || (!!key2 && key2 === propName); + } + return false; + }); + } + ts.getPropertyAssignment = getPropertyAssignment; + function getPropertyArrayElementValue(objectLiteral, propKey, elementValue) { + return ts.firstDefined(getPropertyAssignment(objectLiteral, propKey), function (property) { + return ts.isArrayLiteralExpression(property.initializer) ? + ts.find(property.initializer.elements, function (element) { return ts.isStringLiteral(element) && element.text === elementValue; }) : + undefined; + }); + } + ts.getPropertyArrayElementValue = getPropertyArrayElementValue; + function getTsConfigObjectLiteralExpression(tsConfigSourceFile) { + if (tsConfigSourceFile && tsConfigSourceFile.statements.length) { + var expression = tsConfigSourceFile.statements[0].expression; + return ts.tryCast(expression, ts.isObjectLiteralExpression); + } + } + ts.getTsConfigObjectLiteralExpression = getTsConfigObjectLiteralExpression; + function getTsConfigPropArrayElementValue(tsConfigSourceFile, propKey, elementValue) { + return ts.firstDefined(getTsConfigPropArray(tsConfigSourceFile, propKey), function (property) { + return ts.isArrayLiteralExpression(property.initializer) ? + ts.find(property.initializer.elements, function (element) { return ts.isStringLiteral(element) && element.text === elementValue; }) : + undefined; + }); + } + ts.getTsConfigPropArrayElementValue = getTsConfigPropArrayElementValue; + function getTsConfigPropArray(tsConfigSourceFile, propKey) { + var jsonObjectLiteral = getTsConfigObjectLiteralExpression(tsConfigSourceFile); + return jsonObjectLiteral ? getPropertyAssignment(jsonObjectLiteral, propKey) : ts.emptyArray; + } + ts.getTsConfigPropArray = getTsConfigPropArray; + function getContainingFunction(node) { + return ts.findAncestor(node.parent, ts.isFunctionLike); + } + ts.getContainingFunction = getContainingFunction; + function getContainingFunctionDeclaration(node) { + return ts.findAncestor(node.parent, ts.isFunctionLikeDeclaration); + } + ts.getContainingFunctionDeclaration = getContainingFunctionDeclaration; + function getContainingClass(node) { + return ts.findAncestor(node.parent, ts.isClassLike); + } + ts.getContainingClass = getContainingClass; + function getContainingClassStaticBlock(node) { + return ts.findAncestor(node.parent, function (n) { + if (ts.isClassLike(n) || ts.isFunctionLike(n)) { + return "quit"; + } + return ts.isClassStaticBlockDeclaration(n); + }); + } + ts.getContainingClassStaticBlock = getContainingClassStaticBlock; + function getContainingFunctionOrClassStaticBlock(node) { + return ts.findAncestor(node.parent, ts.isFunctionLikeOrClassStaticBlockDeclaration); + } + ts.getContainingFunctionOrClassStaticBlock = getContainingFunctionOrClassStaticBlock; + function getThisContainer(node, includeArrowFunctions) { + ts.Debug.assert(node.kind !== 308 /* SyntaxKind.SourceFile */); + while (true) { + node = node.parent; + if (!node) { + return ts.Debug.fail(); // If we never pass in a SourceFile, this should be unreachable, since we'll stop when we reach that. + } + switch (node.kind) { + case 164 /* SyntaxKind.ComputedPropertyName */: + // If the grandparent node is an object literal (as opposed to a class), + // then the computed property is not a 'this' container. + // A computed property name in a class needs to be a this container + // so that we can error on it. + if (ts.isClassLike(node.parent.parent)) { + return node; + } + // If this is a computed property, then the parent should not + // make it a this container. The parent might be a property + // in an object literal, like a method or accessor. But in order for + // such a parent to be a this container, the reference must be in + // the *body* of the container. + node = node.parent; + break; + case 167 /* SyntaxKind.Decorator */: + // Decorators are always applied outside of the body of a class or method. + if (node.parent.kind === 166 /* SyntaxKind.Parameter */ && ts.isClassElement(node.parent.parent)) { + // If the decorator's parent is a Parameter, we resolve the this container from + // the grandparent class declaration. + node = node.parent.parent; + } + else if (ts.isClassElement(node.parent)) { + // If the decorator's parent is a class element, we resolve the 'this' container + // from the parent class declaration. + node = node.parent; + } + break; + case 216 /* SyntaxKind.ArrowFunction */: + if (!includeArrowFunctions) { + continue; + } + // falls through + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 264 /* SyntaxKind.ModuleDeclaration */: + case 172 /* SyntaxKind.ClassStaticBlockDeclaration */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 168 /* SyntaxKind.PropertySignature */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + case 173 /* SyntaxKind.Constructor */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 176 /* SyntaxKind.CallSignature */: + case 177 /* SyntaxKind.ConstructSignature */: + case 178 /* SyntaxKind.IndexSignature */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 308 /* SyntaxKind.SourceFile */: + return node; + } + } + } + ts.getThisContainer = getThisContainer; + /** + * @returns Whether the node creates a new 'this' scope for its children. + */ + function isThisContainerOrFunctionBlock(node) { + switch (node.kind) { + // Arrow functions use the same scope, but may do so in a "delayed" manner + // For example, `const getThis = () => this` may be before a super() call in a derived constructor + case 216 /* SyntaxKind.ArrowFunction */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 169 /* SyntaxKind.PropertyDeclaration */: + return true; + case 238 /* SyntaxKind.Block */: + switch (node.parent.kind) { + case 173 /* SyntaxKind.Constructor */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + // Object properties can have computed names; only method-like bodies start a new scope + return true; + default: + return false; + } + default: + return false; + } + } + ts.isThisContainerOrFunctionBlock = isThisContainerOrFunctionBlock; + function isInTopLevelContext(node) { + // The name of a class or function declaration is a BindingIdentifier in its surrounding scope. + if (ts.isIdentifier(node) && (ts.isClassDeclaration(node.parent) || ts.isFunctionDeclaration(node.parent)) && node.parent.name === node) { + node = node.parent; + } + var container = getThisContainer(node, /*includeArrowFunctions*/ true); + return ts.isSourceFile(container); + } + ts.isInTopLevelContext = isInTopLevelContext; + function getNewTargetContainer(node) { + var container = getThisContainer(node, /*includeArrowFunctions*/ false); + if (container) { + switch (container.kind) { + case 173 /* SyntaxKind.Constructor */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + return container; + } + } + return undefined; + } + ts.getNewTargetContainer = getNewTargetContainer; + /** + * Given an super call/property node, returns the closest node where + * - a super call/property access is legal in the node and not legal in the parent node the node. + * i.e. super call is legal in constructor but not legal in the class body. + * - the container is an arrow function (so caller might need to call getSuperContainer again in case it needs to climb higher) + * - a super call/property is definitely illegal in the container (but might be legal in some subnode) + * i.e. super property access is illegal in function declaration but can be legal in the statement list + */ + function getSuperContainer(node, stopOnFunctions) { + while (true) { + node = node.parent; + if (!node) { + return node; + } + switch (node.kind) { + case 164 /* SyntaxKind.ComputedPropertyName */: + node = node.parent; + break; + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + if (!stopOnFunctions) { + continue; + } + // falls through + case 169 /* SyntaxKind.PropertyDeclaration */: + case 168 /* SyntaxKind.PropertySignature */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + case 173 /* SyntaxKind.Constructor */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 172 /* SyntaxKind.ClassStaticBlockDeclaration */: + return node; + case 167 /* SyntaxKind.Decorator */: + // Decorators are always applied outside of the body of a class or method. + if (node.parent.kind === 166 /* SyntaxKind.Parameter */ && ts.isClassElement(node.parent.parent)) { + // If the decorator's parent is a Parameter, we resolve the this container from + // the grandparent class declaration. + node = node.parent.parent; + } + else if (ts.isClassElement(node.parent)) { + // If the decorator's parent is a class element, we resolve the 'this' container + // from the parent class declaration. + node = node.parent; + } + break; + } + } + } + ts.getSuperContainer = getSuperContainer; + function getImmediatelyInvokedFunctionExpression(func) { + if (func.kind === 215 /* SyntaxKind.FunctionExpression */ || func.kind === 216 /* SyntaxKind.ArrowFunction */) { + var prev = func; + var parent = func.parent; + while (parent.kind === 214 /* SyntaxKind.ParenthesizedExpression */) { + prev = parent; + parent = parent.parent; + } + if (parent.kind === 210 /* SyntaxKind.CallExpression */ && parent.expression === prev) { + return parent; + } + } + } + ts.getImmediatelyInvokedFunctionExpression = getImmediatelyInvokedFunctionExpression; + function isSuperOrSuperProperty(node) { + return node.kind === 106 /* SyntaxKind.SuperKeyword */ + || isSuperProperty(node); + } + ts.isSuperOrSuperProperty = isSuperOrSuperProperty; + /** + * Determines whether a node is a property or element access expression for `super`. + */ + function isSuperProperty(node) { + var kind = node.kind; + return (kind === 208 /* SyntaxKind.PropertyAccessExpression */ || kind === 209 /* SyntaxKind.ElementAccessExpression */) + && node.expression.kind === 106 /* SyntaxKind.SuperKeyword */; + } + ts.isSuperProperty = isSuperProperty; + /** + * Determines whether a node is a property or element access expression for `this`. + */ + function isThisProperty(node) { + var kind = node.kind; + return (kind === 208 /* SyntaxKind.PropertyAccessExpression */ || kind === 209 /* SyntaxKind.ElementAccessExpression */) + && node.expression.kind === 108 /* SyntaxKind.ThisKeyword */; + } + ts.isThisProperty = isThisProperty; + function isThisInitializedDeclaration(node) { + var _a; + return !!node && ts.isVariableDeclaration(node) && ((_a = node.initializer) === null || _a === void 0 ? void 0 : _a.kind) === 108 /* SyntaxKind.ThisKeyword */; + } + ts.isThisInitializedDeclaration = isThisInitializedDeclaration; + function isThisInitializedObjectBindingExpression(node) { + return !!node + && (ts.isShorthandPropertyAssignment(node) || ts.isPropertyAssignment(node)) + && ts.isBinaryExpression(node.parent.parent) + && node.parent.parent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ + && node.parent.parent.right.kind === 108 /* SyntaxKind.ThisKeyword */; + } + ts.isThisInitializedObjectBindingExpression = isThisInitializedObjectBindingExpression; + function getEntityNameFromTypeNode(node) { + switch (node.kind) { + case 180 /* SyntaxKind.TypeReference */: + return node.typeName; + case 230 /* SyntaxKind.ExpressionWithTypeArguments */: + return isEntityNameExpression(node.expression) + ? node.expression + : undefined; + // TODO(rbuckton): These aren't valid TypeNodes, but we treat them as such because of `isPartOfTypeNode`, which returns `true` for things that aren't `TypeNode`s. + case 79 /* SyntaxKind.Identifier */: + case 163 /* SyntaxKind.QualifiedName */: + return node; + } + return undefined; + } + ts.getEntityNameFromTypeNode = getEntityNameFromTypeNode; + function getInvokedExpression(node) { + switch (node.kind) { + case 212 /* SyntaxKind.TaggedTemplateExpression */: + return node.tag; + case 283 /* SyntaxKind.JsxOpeningElement */: + case 282 /* SyntaxKind.JsxSelfClosingElement */: + return node.tagName; + default: + return node.expression; + } + } + ts.getInvokedExpression = getInvokedExpression; + function nodeCanBeDecorated(node, parent, grandparent) { + // private names cannot be used with decorators yet + if (ts.isNamedDeclaration(node) && ts.isPrivateIdentifier(node.name)) { + return false; + } + switch (node.kind) { + case 260 /* SyntaxKind.ClassDeclaration */: + // classes are valid targets + return true; + case 169 /* SyntaxKind.PropertyDeclaration */: + // property declarations are valid if their parent is a class declaration. + return parent.kind === 260 /* SyntaxKind.ClassDeclaration */; + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 171 /* SyntaxKind.MethodDeclaration */: + // if this method has a body and its parent is a class declaration, this is a valid target. + return node.body !== undefined + && parent.kind === 260 /* SyntaxKind.ClassDeclaration */; + case 166 /* SyntaxKind.Parameter */: + // if the parameter's parent has a body and its grandparent is a class declaration, this is a valid target; + return parent.body !== undefined + && (parent.kind === 173 /* SyntaxKind.Constructor */ + || parent.kind === 171 /* SyntaxKind.MethodDeclaration */ + || parent.kind === 175 /* SyntaxKind.SetAccessor */) + && grandparent.kind === 260 /* SyntaxKind.ClassDeclaration */; + } + return false; + } + ts.nodeCanBeDecorated = nodeCanBeDecorated; + function nodeIsDecorated(node, parent, grandparent) { + return hasDecorators(node) + && nodeCanBeDecorated(node, parent, grandparent); // TODO: GH#18217 + } + ts.nodeIsDecorated = nodeIsDecorated; + function nodeOrChildIsDecorated(node, parent, grandparent) { + return nodeIsDecorated(node, parent, grandparent) || childIsDecorated(node, parent); // TODO: GH#18217 + } + ts.nodeOrChildIsDecorated = nodeOrChildIsDecorated; + function childIsDecorated(node, parent) { + switch (node.kind) { + case 260 /* SyntaxKind.ClassDeclaration */: + return ts.some(node.members, function (m) { return nodeOrChildIsDecorated(m, node, parent); }); // TODO: GH#18217 + case 171 /* SyntaxKind.MethodDeclaration */: + case 175 /* SyntaxKind.SetAccessor */: + case 173 /* SyntaxKind.Constructor */: + return ts.some(node.parameters, function (p) { return nodeIsDecorated(p, node, parent); }); // TODO: GH#18217 + default: + return false; + } + } + ts.childIsDecorated = childIsDecorated; + function classOrConstructorParameterIsDecorated(node) { + if (nodeIsDecorated(node)) + return true; + var constructor = getFirstConstructorWithBody(node); + return !!constructor && childIsDecorated(constructor, node); + } + ts.classOrConstructorParameterIsDecorated = classOrConstructorParameterIsDecorated; + function isJSXTagName(node) { + var parent = node.parent; + if (parent.kind === 283 /* SyntaxKind.JsxOpeningElement */ || + parent.kind === 282 /* SyntaxKind.JsxSelfClosingElement */ || + parent.kind === 284 /* SyntaxKind.JsxClosingElement */) { + return parent.tagName === node; + } + return false; + } + ts.isJSXTagName = isJSXTagName; + function isExpressionNode(node) { + switch (node.kind) { + case 106 /* SyntaxKind.SuperKeyword */: + case 104 /* SyntaxKind.NullKeyword */: + case 110 /* SyntaxKind.TrueKeyword */: + case 95 /* SyntaxKind.FalseKeyword */: + case 13 /* SyntaxKind.RegularExpressionLiteral */: + case 206 /* SyntaxKind.ArrayLiteralExpression */: + case 207 /* SyntaxKind.ObjectLiteralExpression */: + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 209 /* SyntaxKind.ElementAccessExpression */: + case 210 /* SyntaxKind.CallExpression */: + case 211 /* SyntaxKind.NewExpression */: + case 212 /* SyntaxKind.TaggedTemplateExpression */: + case 231 /* SyntaxKind.AsExpression */: + case 213 /* SyntaxKind.TypeAssertionExpression */: + case 235 /* SyntaxKind.SatisfiesExpression */: + case 232 /* SyntaxKind.NonNullExpression */: + case 214 /* SyntaxKind.ParenthesizedExpression */: + case 215 /* SyntaxKind.FunctionExpression */: + case 228 /* SyntaxKind.ClassExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + case 219 /* SyntaxKind.VoidExpression */: + case 217 /* SyntaxKind.DeleteExpression */: + case 218 /* SyntaxKind.TypeOfExpression */: + case 221 /* SyntaxKind.PrefixUnaryExpression */: + case 222 /* SyntaxKind.PostfixUnaryExpression */: + case 223 /* SyntaxKind.BinaryExpression */: + case 224 /* SyntaxKind.ConditionalExpression */: + case 227 /* SyntaxKind.SpreadElement */: + case 225 /* SyntaxKind.TemplateExpression */: + case 229 /* SyntaxKind.OmittedExpression */: + case 281 /* SyntaxKind.JsxElement */: + case 282 /* SyntaxKind.JsxSelfClosingElement */: + case 285 /* SyntaxKind.JsxFragment */: + case 226 /* SyntaxKind.YieldExpression */: + case 220 /* SyntaxKind.AwaitExpression */: + case 233 /* SyntaxKind.MetaProperty */: + return true; + case 230 /* SyntaxKind.ExpressionWithTypeArguments */: + return !ts.isHeritageClause(node.parent); + case 163 /* SyntaxKind.QualifiedName */: + while (node.parent.kind === 163 /* SyntaxKind.QualifiedName */) { + node = node.parent; + } + return node.parent.kind === 183 /* SyntaxKind.TypeQuery */ || ts.isJSDocLinkLike(node.parent) || ts.isJSDocNameReference(node.parent) || ts.isJSDocMemberName(node.parent) || isJSXTagName(node); + case 314 /* SyntaxKind.JSDocMemberName */: + while (ts.isJSDocMemberName(node.parent)) { + node = node.parent; + } + return node.parent.kind === 183 /* SyntaxKind.TypeQuery */ || ts.isJSDocLinkLike(node.parent) || ts.isJSDocNameReference(node.parent) || ts.isJSDocMemberName(node.parent) || isJSXTagName(node); + case 80 /* SyntaxKind.PrivateIdentifier */: + return ts.isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind === 101 /* SyntaxKind.InKeyword */; + case 79 /* SyntaxKind.Identifier */: + if (node.parent.kind === 183 /* SyntaxKind.TypeQuery */ || ts.isJSDocLinkLike(node.parent) || ts.isJSDocNameReference(node.parent) || ts.isJSDocMemberName(node.parent) || isJSXTagName(node)) { + return true; + } + // falls through + case 8 /* SyntaxKind.NumericLiteral */: + case 9 /* SyntaxKind.BigIntLiteral */: + case 10 /* SyntaxKind.StringLiteral */: + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + case 108 /* SyntaxKind.ThisKeyword */: + return isInExpressionContext(node); + default: + return false; + } + } + ts.isExpressionNode = isExpressionNode; + function isInExpressionContext(node) { + var parent = node.parent; + switch (parent.kind) { + case 257 /* SyntaxKind.VariableDeclaration */: + case 166 /* SyntaxKind.Parameter */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 168 /* SyntaxKind.PropertySignature */: + case 302 /* SyntaxKind.EnumMember */: + case 299 /* SyntaxKind.PropertyAssignment */: + case 205 /* SyntaxKind.BindingElement */: + return parent.initializer === node; + case 241 /* SyntaxKind.ExpressionStatement */: + case 242 /* SyntaxKind.IfStatement */: + case 243 /* SyntaxKind.DoStatement */: + case 244 /* SyntaxKind.WhileStatement */: + case 250 /* SyntaxKind.ReturnStatement */: + case 251 /* SyntaxKind.WithStatement */: + case 252 /* SyntaxKind.SwitchStatement */: + case 292 /* SyntaxKind.CaseClause */: + case 254 /* SyntaxKind.ThrowStatement */: + return parent.expression === node; + case 245 /* SyntaxKind.ForStatement */: + var forStatement = parent; + return (forStatement.initializer === node && forStatement.initializer.kind !== 258 /* SyntaxKind.VariableDeclarationList */) || + forStatement.condition === node || + forStatement.incrementor === node; + case 246 /* SyntaxKind.ForInStatement */: + case 247 /* SyntaxKind.ForOfStatement */: + var forInStatement = parent; + return (forInStatement.initializer === node && forInStatement.initializer.kind !== 258 /* SyntaxKind.VariableDeclarationList */) || + forInStatement.expression === node; + case 213 /* SyntaxKind.TypeAssertionExpression */: + case 231 /* SyntaxKind.AsExpression */: + return node === parent.expression; + case 236 /* SyntaxKind.TemplateSpan */: + return node === parent.expression; + case 164 /* SyntaxKind.ComputedPropertyName */: + return node === parent.expression; + case 167 /* SyntaxKind.Decorator */: + case 291 /* SyntaxKind.JsxExpression */: + case 290 /* SyntaxKind.JsxSpreadAttribute */: + case 301 /* SyntaxKind.SpreadAssignment */: + return true; + case 230 /* SyntaxKind.ExpressionWithTypeArguments */: + return parent.expression === node && !isPartOfTypeNode(parent); + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + return parent.objectAssignmentInitializer === node; + case 235 /* SyntaxKind.SatisfiesExpression */: + return node === parent.expression; + default: + return isExpressionNode(parent); + } + } + ts.isInExpressionContext = isInExpressionContext; + function isPartOfTypeQuery(node) { + while (node.kind === 163 /* SyntaxKind.QualifiedName */ || node.kind === 79 /* SyntaxKind.Identifier */) { + node = node.parent; + } + return node.kind === 183 /* SyntaxKind.TypeQuery */; + } + ts.isPartOfTypeQuery = isPartOfTypeQuery; + function isNamespaceReexportDeclaration(node) { + return ts.isNamespaceExport(node) && !!node.parent.moduleSpecifier; + } + ts.isNamespaceReexportDeclaration = isNamespaceReexportDeclaration; + function isExternalModuleImportEqualsDeclaration(node) { + return node.kind === 268 /* SyntaxKind.ImportEqualsDeclaration */ && node.moduleReference.kind === 280 /* SyntaxKind.ExternalModuleReference */; + } + ts.isExternalModuleImportEqualsDeclaration = isExternalModuleImportEqualsDeclaration; + function getExternalModuleImportEqualsDeclarationExpression(node) { + ts.Debug.assert(isExternalModuleImportEqualsDeclaration(node)); + return node.moduleReference.expression; + } + ts.getExternalModuleImportEqualsDeclarationExpression = getExternalModuleImportEqualsDeclarationExpression; + function getExternalModuleRequireArgument(node) { + return isVariableDeclarationInitializedToBareOrAccessedRequire(node) && getLeftmostAccessExpression(node.initializer).arguments[0]; + } + ts.getExternalModuleRequireArgument = getExternalModuleRequireArgument; + function isInternalModuleImportEqualsDeclaration(node) { + return node.kind === 268 /* SyntaxKind.ImportEqualsDeclaration */ && node.moduleReference.kind !== 280 /* SyntaxKind.ExternalModuleReference */; + } + ts.isInternalModuleImportEqualsDeclaration = isInternalModuleImportEqualsDeclaration; + function isSourceFileJS(file) { + return isInJSFile(file); + } + ts.isSourceFileJS = isSourceFileJS; + function isSourceFileNotJS(file) { + return !isInJSFile(file); + } + ts.isSourceFileNotJS = isSourceFileNotJS; + function isInJSFile(node) { + return !!node && !!(node.flags & 262144 /* NodeFlags.JavaScriptFile */); + } + ts.isInJSFile = isInJSFile; + function isInJsonFile(node) { + return !!node && !!(node.flags & 67108864 /* NodeFlags.JsonFile */); + } + ts.isInJsonFile = isInJsonFile; + function isSourceFileNotJson(file) { + return !isJsonSourceFile(file); + } + ts.isSourceFileNotJson = isSourceFileNotJson; + function isInJSDoc(node) { + return !!node && !!(node.flags & 8388608 /* NodeFlags.JSDoc */); + } + ts.isInJSDoc = isInJSDoc; + function isJSDocIndexSignature(node) { + return ts.isTypeReferenceNode(node) && + ts.isIdentifier(node.typeName) && + node.typeName.escapedText === "Object" && + node.typeArguments && node.typeArguments.length === 2 && + (node.typeArguments[0].kind === 152 /* SyntaxKind.StringKeyword */ || node.typeArguments[0].kind === 148 /* SyntaxKind.NumberKeyword */); + } + ts.isJSDocIndexSignature = isJSDocIndexSignature; + function isRequireCall(callExpression, requireStringLiteralLikeArgument) { + if (callExpression.kind !== 210 /* SyntaxKind.CallExpression */) { + return false; + } + var _a = callExpression, expression = _a.expression, args = _a.arguments; + if (expression.kind !== 79 /* SyntaxKind.Identifier */ || expression.escapedText !== "require") { + return false; + } + if (args.length !== 1) { + return false; + } + var arg = args[0]; + return !requireStringLiteralLikeArgument || ts.isStringLiteralLike(arg); + } + ts.isRequireCall = isRequireCall; + /** + * Returns true if the node is a VariableDeclaration initialized to a require call (see `isRequireCall`). + * This function does not test if the node is in a JavaScript file or not. + */ + function isVariableDeclarationInitializedToRequire(node) { + return isVariableDeclarationInitializedWithRequireHelper(node, /*allowAccessedRequire*/ false); + } + ts.isVariableDeclarationInitializedToRequire = isVariableDeclarationInitializedToRequire; + /** + * Like {@link isVariableDeclarationInitializedToRequire} but allows things like `require("...").foo.bar` or `require("...")["baz"]`. + */ + function isVariableDeclarationInitializedToBareOrAccessedRequire(node) { + return isVariableDeclarationInitializedWithRequireHelper(node, /*allowAccessedRequire*/ true); + } + ts.isVariableDeclarationInitializedToBareOrAccessedRequire = isVariableDeclarationInitializedToBareOrAccessedRequire; + function isVariableDeclarationInitializedWithRequireHelper(node, allowAccessedRequire) { + return ts.isVariableDeclaration(node) && + !!node.initializer && + isRequireCall(allowAccessedRequire ? getLeftmostAccessExpression(node.initializer) : node.initializer, /*requireStringLiteralLikeArgument*/ true); + } + function isRequireVariableStatement(node) { + return ts.isVariableStatement(node) + && node.declarationList.declarations.length > 0 + && ts.every(node.declarationList.declarations, function (decl) { return isVariableDeclarationInitializedToRequire(decl); }); + } + ts.isRequireVariableStatement = isRequireVariableStatement; + function isSingleOrDoubleQuote(charCode) { + return charCode === 39 /* CharacterCodes.singleQuote */ || charCode === 34 /* CharacterCodes.doubleQuote */; + } + ts.isSingleOrDoubleQuote = isSingleOrDoubleQuote; + function isStringDoubleQuoted(str, sourceFile) { + return getSourceTextOfNodeFromSourceFile(sourceFile, str).charCodeAt(0) === 34 /* CharacterCodes.doubleQuote */; + } + ts.isStringDoubleQuoted = isStringDoubleQuoted; + function isAssignmentDeclaration(decl) { + return ts.isBinaryExpression(decl) || isAccessExpression(decl) || ts.isIdentifier(decl) || ts.isCallExpression(decl); + } + ts.isAssignmentDeclaration = isAssignmentDeclaration; + /** Get the initializer, taking into account defaulted Javascript initializers */ + function getEffectiveInitializer(node) { + if (isInJSFile(node) && node.initializer && + ts.isBinaryExpression(node.initializer) && + (node.initializer.operatorToken.kind === 56 /* SyntaxKind.BarBarToken */ || node.initializer.operatorToken.kind === 60 /* SyntaxKind.QuestionQuestionToken */) && + node.name && isEntityNameExpression(node.name) && isSameEntityName(node.name, node.initializer.left)) { + return node.initializer.right; + } + return node.initializer; + } + ts.getEffectiveInitializer = getEffectiveInitializer; + /** Get the declaration initializer when it is container-like (See getExpandoInitializer). */ + function getDeclaredExpandoInitializer(node) { + var init = getEffectiveInitializer(node); + return init && getExpandoInitializer(init, isPrototypeAccess(node.name)); + } + ts.getDeclaredExpandoInitializer = getDeclaredExpandoInitializer; + function hasExpandoValueProperty(node, isPrototypeAssignment) { + return ts.forEach(node.properties, function (p) { + return ts.isPropertyAssignment(p) && + ts.isIdentifier(p.name) && + p.name.escapedText === "value" && + p.initializer && + getExpandoInitializer(p.initializer, isPrototypeAssignment); + }); + } + /** + * Get the assignment 'initializer' -- the righthand side-- when the initializer is container-like (See getExpandoInitializer). + * We treat the right hand side of assignments with container-like initializers as declarations. + */ + function getAssignedExpandoInitializer(node) { + if (node && node.parent && ts.isBinaryExpression(node.parent) && node.parent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */) { + var isPrototypeAssignment = isPrototypeAccess(node.parent.left); + return getExpandoInitializer(node.parent.right, isPrototypeAssignment) || + getDefaultedExpandoInitializer(node.parent.left, node.parent.right, isPrototypeAssignment); + } + if (node && ts.isCallExpression(node) && isBindableObjectDefinePropertyCall(node)) { + var result = hasExpandoValueProperty(node.arguments[2], node.arguments[1].text === "prototype"); + if (result) { + return result; + } + } + } + ts.getAssignedExpandoInitializer = getAssignedExpandoInitializer; + /** + * Recognized expando initializers are: + * 1. (function() {})() -- IIFEs + * 2. function() { } -- Function expressions + * 3. class { } -- Class expressions + * 4. {} -- Empty object literals + * 5. { ... } -- Non-empty object literals, when used to initialize a prototype, like `C.prototype = { m() { } }` + * + * This function returns the provided initializer, or undefined if it is not valid. + */ + function getExpandoInitializer(initializer, isPrototypeAssignment) { + if (ts.isCallExpression(initializer)) { + var e = skipParentheses(initializer.expression); + return e.kind === 215 /* SyntaxKind.FunctionExpression */ || e.kind === 216 /* SyntaxKind.ArrowFunction */ ? initializer : undefined; + } + if (initializer.kind === 215 /* SyntaxKind.FunctionExpression */ || + initializer.kind === 228 /* SyntaxKind.ClassExpression */ || + initializer.kind === 216 /* SyntaxKind.ArrowFunction */) { + return initializer; + } + if (ts.isObjectLiteralExpression(initializer) && (initializer.properties.length === 0 || isPrototypeAssignment)) { + return initializer; + } + } + ts.getExpandoInitializer = getExpandoInitializer; + /** + * A defaulted expando initializer matches the pattern + * `Lhs = Lhs || ExpandoInitializer` + * or `var Lhs = Lhs || ExpandoInitializer` + * + * The second Lhs is required to be the same as the first except that it may be prefixed with + * 'window.', 'global.' or 'self.' The second Lhs is otherwise ignored by the binder and checker. + */ + function getDefaultedExpandoInitializer(name, initializer, isPrototypeAssignment) { + var e = ts.isBinaryExpression(initializer) + && (initializer.operatorToken.kind === 56 /* SyntaxKind.BarBarToken */ || initializer.operatorToken.kind === 60 /* SyntaxKind.QuestionQuestionToken */) + && getExpandoInitializer(initializer.right, isPrototypeAssignment); + if (e && isSameEntityName(name, initializer.left)) { + return e; + } + } + function isDefaultedExpandoInitializer(node) { + var name = ts.isVariableDeclaration(node.parent) ? node.parent.name : + ts.isBinaryExpression(node.parent) && node.parent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ ? node.parent.left : + undefined; + return name && getExpandoInitializer(node.right, isPrototypeAccess(name)) && isEntityNameExpression(name) && isSameEntityName(name, node.left); + } + ts.isDefaultedExpandoInitializer = isDefaultedExpandoInitializer; + /** Given an expando initializer, return its declaration name, or the left-hand side of the assignment if it's part of an assignment declaration. */ + function getNameOfExpando(node) { + if (ts.isBinaryExpression(node.parent)) { + var parent = ((node.parent.operatorToken.kind === 56 /* SyntaxKind.BarBarToken */ || node.parent.operatorToken.kind === 60 /* SyntaxKind.QuestionQuestionToken */) && ts.isBinaryExpression(node.parent.parent)) ? node.parent.parent : node.parent; + if (parent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ && ts.isIdentifier(parent.left)) { + return parent.left; + } + } + else if (ts.isVariableDeclaration(node.parent)) { + return node.parent.name; + } + } + ts.getNameOfExpando = getNameOfExpando; + /** + * Is the 'declared' name the same as the one in the initializer? + * @return true for identical entity names, as well as ones where the initializer is prefixed with + * 'window', 'self' or 'global'. For example: + * + * var my = my || {} + * var min = window.min || {} + * my.app = self.my.app || class { } + */ + function isSameEntityName(name, initializer) { + if (isPropertyNameLiteral(name) && isPropertyNameLiteral(initializer)) { + return getTextOfIdentifierOrLiteral(name) === getTextOfIdentifierOrLiteral(initializer); + } + if (ts.isMemberName(name) && isLiteralLikeAccess(initializer) && + (initializer.expression.kind === 108 /* SyntaxKind.ThisKeyword */ || + ts.isIdentifier(initializer.expression) && + (initializer.expression.escapedText === "window" || + initializer.expression.escapedText === "self" || + initializer.expression.escapedText === "global"))) { + return isSameEntityName(name, getNameOrArgument(initializer)); + } + if (isLiteralLikeAccess(name) && isLiteralLikeAccess(initializer)) { + return getElementOrPropertyAccessName(name) === getElementOrPropertyAccessName(initializer) + && isSameEntityName(name.expression, initializer.expression); + } + return false; + } + ts.isSameEntityName = isSameEntityName; + function getRightMostAssignedExpression(node) { + while (isAssignmentExpression(node, /*excludeCompoundAssignments*/ true)) { + node = node.right; + } + return node; + } + ts.getRightMostAssignedExpression = getRightMostAssignedExpression; + function isExportsIdentifier(node) { + return ts.isIdentifier(node) && node.escapedText === "exports"; + } + ts.isExportsIdentifier = isExportsIdentifier; + function isModuleIdentifier(node) { + return ts.isIdentifier(node) && node.escapedText === "module"; + } + ts.isModuleIdentifier = isModuleIdentifier; + function isModuleExportsAccessExpression(node) { + return (ts.isPropertyAccessExpression(node) || isLiteralLikeElementAccess(node)) + && isModuleIdentifier(node.expression) + && getElementOrPropertyAccessName(node) === "exports"; + } + ts.isModuleExportsAccessExpression = isModuleExportsAccessExpression; + /// Given a BinaryExpression, returns SpecialPropertyAssignmentKind for the various kinds of property + /// assignments we treat as special in the binder + function getAssignmentDeclarationKind(expr) { + var special = getAssignmentDeclarationKindWorker(expr); + return special === 5 /* AssignmentDeclarationKind.Property */ || isInJSFile(expr) ? special : 0 /* AssignmentDeclarationKind.None */; + } + ts.getAssignmentDeclarationKind = getAssignmentDeclarationKind; + function isBindableObjectDefinePropertyCall(expr) { + return ts.length(expr.arguments) === 3 && + ts.isPropertyAccessExpression(expr.expression) && + ts.isIdentifier(expr.expression.expression) && + ts.idText(expr.expression.expression) === "Object" && + ts.idText(expr.expression.name) === "defineProperty" && + isStringOrNumericLiteralLike(expr.arguments[1]) && + isBindableStaticNameExpression(expr.arguments[0], /*excludeThisKeyword*/ true); + } + ts.isBindableObjectDefinePropertyCall = isBindableObjectDefinePropertyCall; + /** x.y OR x[0] */ + function isLiteralLikeAccess(node) { + return ts.isPropertyAccessExpression(node) || isLiteralLikeElementAccess(node); + } + ts.isLiteralLikeAccess = isLiteralLikeAccess; + /** x[0] OR x['a'] OR x[Symbol.y] */ + function isLiteralLikeElementAccess(node) { + return ts.isElementAccessExpression(node) && isStringOrNumericLiteralLike(node.argumentExpression); + } + ts.isLiteralLikeElementAccess = isLiteralLikeElementAccess; + /** Any series of property and element accesses. */ + function isBindableStaticAccessExpression(node, excludeThisKeyword) { + return ts.isPropertyAccessExpression(node) && (!excludeThisKeyword && node.expression.kind === 108 /* SyntaxKind.ThisKeyword */ || ts.isIdentifier(node.name) && isBindableStaticNameExpression(node.expression, /*excludeThisKeyword*/ true)) + || isBindableStaticElementAccessExpression(node, excludeThisKeyword); + } + ts.isBindableStaticAccessExpression = isBindableStaticAccessExpression; + /** Any series of property and element accesses, ending in a literal element access */ + function isBindableStaticElementAccessExpression(node, excludeThisKeyword) { + return isLiteralLikeElementAccess(node) + && ((!excludeThisKeyword && node.expression.kind === 108 /* SyntaxKind.ThisKeyword */) || + isEntityNameExpression(node.expression) || + isBindableStaticAccessExpression(node.expression, /*excludeThisKeyword*/ true)); + } + ts.isBindableStaticElementAccessExpression = isBindableStaticElementAccessExpression; + function isBindableStaticNameExpression(node, excludeThisKeyword) { + return isEntityNameExpression(node) || isBindableStaticAccessExpression(node, excludeThisKeyword); + } + ts.isBindableStaticNameExpression = isBindableStaticNameExpression; + function getNameOrArgument(expr) { + if (ts.isPropertyAccessExpression(expr)) { + return expr.name; + } + return expr.argumentExpression; + } + ts.getNameOrArgument = getNameOrArgument; + function getAssignmentDeclarationKindWorker(expr) { + if (ts.isCallExpression(expr)) { + if (!isBindableObjectDefinePropertyCall(expr)) { + return 0 /* AssignmentDeclarationKind.None */; + } + var entityName = expr.arguments[0]; + if (isExportsIdentifier(entityName) || isModuleExportsAccessExpression(entityName)) { + return 8 /* AssignmentDeclarationKind.ObjectDefinePropertyExports */; + } + if (isBindableStaticAccessExpression(entityName) && getElementOrPropertyAccessName(entityName) === "prototype") { + return 9 /* AssignmentDeclarationKind.ObjectDefinePrototypeProperty */; + } + return 7 /* AssignmentDeclarationKind.ObjectDefinePropertyValue */; + } + if (expr.operatorToken.kind !== 63 /* SyntaxKind.EqualsToken */ || !isAccessExpression(expr.left) || isVoidZero(getRightMostAssignedExpression(expr))) { + return 0 /* AssignmentDeclarationKind.None */; + } + if (isBindableStaticNameExpression(expr.left.expression, /*excludeThisKeyword*/ true) && getElementOrPropertyAccessName(expr.left) === "prototype" && ts.isObjectLiteralExpression(getInitializerOfBinaryExpression(expr))) { + // F.prototype = { ... } + return 6 /* AssignmentDeclarationKind.Prototype */; + } + return getAssignmentDeclarationPropertyAccessKind(expr.left); + } + function isVoidZero(node) { + return ts.isVoidExpression(node) && ts.isNumericLiteral(node.expression) && node.expression.text === "0"; + } + /** + * Does not handle signed numeric names like `a[+0]` - handling those would require handling prefix unary expressions + * throughout late binding handling as well, which is awkward (but ultimately probably doable if there is demand) + */ + /* @internal */ + function getElementOrPropertyAccessArgumentExpressionOrName(node) { + if (ts.isPropertyAccessExpression(node)) { + return node.name; + } + var arg = skipParentheses(node.argumentExpression); + if (ts.isNumericLiteral(arg) || ts.isStringLiteralLike(arg)) { + return arg; + } + return node; + } + ts.getElementOrPropertyAccessArgumentExpressionOrName = getElementOrPropertyAccessArgumentExpressionOrName; + function getElementOrPropertyAccessName(node) { + var name = getElementOrPropertyAccessArgumentExpressionOrName(node); + if (name) { + if (ts.isIdentifier(name)) { + return name.escapedText; + } + if (ts.isStringLiteralLike(name) || ts.isNumericLiteral(name)) { + return ts.escapeLeadingUnderscores(name.text); + } + } + return undefined; + } + ts.getElementOrPropertyAccessName = getElementOrPropertyAccessName; + function getAssignmentDeclarationPropertyAccessKind(lhs) { + if (lhs.expression.kind === 108 /* SyntaxKind.ThisKeyword */) { + return 4 /* AssignmentDeclarationKind.ThisProperty */; + } + else if (isModuleExportsAccessExpression(lhs)) { + // module.exports = expr + return 2 /* AssignmentDeclarationKind.ModuleExports */; + } + else if (isBindableStaticNameExpression(lhs.expression, /*excludeThisKeyword*/ true)) { + if (isPrototypeAccess(lhs.expression)) { + // F.G....prototype.x = expr + return 3 /* AssignmentDeclarationKind.PrototypeProperty */; + } + var nextToLast = lhs; + while (!ts.isIdentifier(nextToLast.expression)) { + nextToLast = nextToLast.expression; + } + var id = nextToLast.expression; + if ((id.escapedText === "exports" || + id.escapedText === "module" && getElementOrPropertyAccessName(nextToLast) === "exports") && + // ExportsProperty does not support binding with computed names + isBindableStaticAccessExpression(lhs)) { + // exports.name = expr OR module.exports.name = expr OR exports["name"] = expr ... + return 1 /* AssignmentDeclarationKind.ExportsProperty */; + } + if (isBindableStaticNameExpression(lhs, /*excludeThisKeyword*/ true) || (ts.isElementAccessExpression(lhs) && isDynamicName(lhs))) { + // F.G...x = expr + return 5 /* AssignmentDeclarationKind.Property */; + } + } + return 0 /* AssignmentDeclarationKind.None */; + } + ts.getAssignmentDeclarationPropertyAccessKind = getAssignmentDeclarationPropertyAccessKind; + function getInitializerOfBinaryExpression(expr) { + while (ts.isBinaryExpression(expr.right)) { + expr = expr.right; + } + return expr.right; + } + ts.getInitializerOfBinaryExpression = getInitializerOfBinaryExpression; + function isPrototypePropertyAssignment(node) { + return ts.isBinaryExpression(node) && getAssignmentDeclarationKind(node) === 3 /* AssignmentDeclarationKind.PrototypeProperty */; + } + ts.isPrototypePropertyAssignment = isPrototypePropertyAssignment; + function isSpecialPropertyDeclaration(expr) { + return isInJSFile(expr) && + expr.parent && expr.parent.kind === 241 /* SyntaxKind.ExpressionStatement */ && + (!ts.isElementAccessExpression(expr) || isLiteralLikeElementAccess(expr)) && + !!ts.getJSDocTypeTag(expr.parent); + } + ts.isSpecialPropertyDeclaration = isSpecialPropertyDeclaration; + function setValueDeclaration(symbol, node) { + var valueDeclaration = symbol.valueDeclaration; + if (!valueDeclaration || + !(node.flags & 16777216 /* NodeFlags.Ambient */ && !(valueDeclaration.flags & 16777216 /* NodeFlags.Ambient */)) && + (isAssignmentDeclaration(valueDeclaration) && !isAssignmentDeclaration(node)) || + (valueDeclaration.kind !== node.kind && isEffectiveModuleDeclaration(valueDeclaration))) { + // other kinds of value declarations take precedence over modules and assignment declarations + symbol.valueDeclaration = node; + } + } + ts.setValueDeclaration = setValueDeclaration; + function isFunctionSymbol(symbol) { + if (!symbol || !symbol.valueDeclaration) { + return false; + } + var decl = symbol.valueDeclaration; + return decl.kind === 259 /* SyntaxKind.FunctionDeclaration */ || ts.isVariableDeclaration(decl) && decl.initializer && ts.isFunctionLike(decl.initializer); + } + ts.isFunctionSymbol = isFunctionSymbol; + function tryGetModuleSpecifierFromDeclaration(node) { + var _a, _b; + switch (node.kind) { + case 257 /* SyntaxKind.VariableDeclaration */: + return (_a = ts.findAncestor(node.initializer, function (node) { return isRequireCall(node, /*requireStringLiteralLikeArgument*/ true); })) === null || _a === void 0 ? void 0 : _a.arguments[0]; + case 269 /* SyntaxKind.ImportDeclaration */: + return ts.tryCast(node.moduleSpecifier, ts.isStringLiteralLike); + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return ts.tryCast((_b = ts.tryCast(node.moduleReference, ts.isExternalModuleReference)) === null || _b === void 0 ? void 0 : _b.expression, ts.isStringLiteralLike); + default: + ts.Debug.assertNever(node); + } + } + ts.tryGetModuleSpecifierFromDeclaration = tryGetModuleSpecifierFromDeclaration; + function importFromModuleSpecifier(node) { + return tryGetImportFromModuleSpecifier(node) || ts.Debug.failBadSyntaxKind(node.parent); + } + ts.importFromModuleSpecifier = importFromModuleSpecifier; + function tryGetImportFromModuleSpecifier(node) { + switch (node.parent.kind) { + case 269 /* SyntaxKind.ImportDeclaration */: + case 275 /* SyntaxKind.ExportDeclaration */: + return node.parent; + case 280 /* SyntaxKind.ExternalModuleReference */: + return node.parent.parent; + case 210 /* SyntaxKind.CallExpression */: + return isImportCall(node.parent) || isRequireCall(node.parent, /*checkArg*/ false) ? node.parent : undefined; + case 198 /* SyntaxKind.LiteralType */: + ts.Debug.assert(ts.isStringLiteral(node)); + return ts.tryCast(node.parent.parent, ts.isImportTypeNode); + default: + return undefined; + } + } + ts.tryGetImportFromModuleSpecifier = tryGetImportFromModuleSpecifier; + function getExternalModuleName(node) { + switch (node.kind) { + case 269 /* SyntaxKind.ImportDeclaration */: + case 275 /* SyntaxKind.ExportDeclaration */: + return node.moduleSpecifier; + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return node.moduleReference.kind === 280 /* SyntaxKind.ExternalModuleReference */ ? node.moduleReference.expression : undefined; + case 202 /* SyntaxKind.ImportType */: + return isLiteralImportTypeNode(node) ? node.argument.literal : undefined; + case 210 /* SyntaxKind.CallExpression */: + return node.arguments[0]; + case 264 /* SyntaxKind.ModuleDeclaration */: + return node.name.kind === 10 /* SyntaxKind.StringLiteral */ ? node.name : undefined; + default: + return ts.Debug.assertNever(node); + } + } + ts.getExternalModuleName = getExternalModuleName; + function getNamespaceDeclarationNode(node) { + switch (node.kind) { + case 269 /* SyntaxKind.ImportDeclaration */: + return node.importClause && ts.tryCast(node.importClause.namedBindings, ts.isNamespaceImport); + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return node; + case 275 /* SyntaxKind.ExportDeclaration */: + return node.exportClause && ts.tryCast(node.exportClause, ts.isNamespaceExport); + default: + return ts.Debug.assertNever(node); + } + } + ts.getNamespaceDeclarationNode = getNamespaceDeclarationNode; + function isDefaultImport(node) { + return node.kind === 269 /* SyntaxKind.ImportDeclaration */ && !!node.importClause && !!node.importClause.name; + } + ts.isDefaultImport = isDefaultImport; + function forEachImportClauseDeclaration(node, action) { + if (node.name) { + var result = action(node); + if (result) + return result; + } + if (node.namedBindings) { + var result = ts.isNamespaceImport(node.namedBindings) + ? action(node.namedBindings) + : ts.forEach(node.namedBindings.elements, action); + if (result) + return result; + } + } + ts.forEachImportClauseDeclaration = forEachImportClauseDeclaration; + function hasQuestionToken(node) { + if (node) { + switch (node.kind) { + case 166 /* SyntaxKind.Parameter */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + case 299 /* SyntaxKind.PropertyAssignment */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 168 /* SyntaxKind.PropertySignature */: + return node.questionToken !== undefined; + } + } + return false; + } + ts.hasQuestionToken = hasQuestionToken; + function isJSDocConstructSignature(node) { + var param = ts.isJSDocFunctionType(node) ? ts.firstOrUndefined(node.parameters) : undefined; + var name = ts.tryCast(param && param.name, ts.isIdentifier); + return !!name && name.escapedText === "new"; + } + ts.isJSDocConstructSignature = isJSDocConstructSignature; + function isJSDocTypeAlias(node) { + return node.kind === 348 /* SyntaxKind.JSDocTypedefTag */ || node.kind === 341 /* SyntaxKind.JSDocCallbackTag */ || node.kind === 342 /* SyntaxKind.JSDocEnumTag */; + } + ts.isJSDocTypeAlias = isJSDocTypeAlias; + function isTypeAlias(node) { + return isJSDocTypeAlias(node) || ts.isTypeAliasDeclaration(node); + } + ts.isTypeAlias = isTypeAlias; + function getSourceOfAssignment(node) { + return ts.isExpressionStatement(node) && + ts.isBinaryExpression(node.expression) && + node.expression.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ + ? getRightMostAssignedExpression(node.expression) + : undefined; + } + function getSourceOfDefaultedAssignment(node) { + return ts.isExpressionStatement(node) && + ts.isBinaryExpression(node.expression) && + getAssignmentDeclarationKind(node.expression) !== 0 /* AssignmentDeclarationKind.None */ && + ts.isBinaryExpression(node.expression.right) && + (node.expression.right.operatorToken.kind === 56 /* SyntaxKind.BarBarToken */ || node.expression.right.operatorToken.kind === 60 /* SyntaxKind.QuestionQuestionToken */) + ? node.expression.right.right + : undefined; + } + function getSingleInitializerOfVariableStatementOrPropertyDeclaration(node) { + switch (node.kind) { + case 240 /* SyntaxKind.VariableStatement */: + var v = getSingleVariableOfVariableStatement(node); + return v && v.initializer; + case 169 /* SyntaxKind.PropertyDeclaration */: + return node.initializer; + case 299 /* SyntaxKind.PropertyAssignment */: + return node.initializer; + } + } + ts.getSingleInitializerOfVariableStatementOrPropertyDeclaration = getSingleInitializerOfVariableStatementOrPropertyDeclaration; + function getSingleVariableOfVariableStatement(node) { + return ts.isVariableStatement(node) ? ts.firstOrUndefined(node.declarationList.declarations) : undefined; + } + ts.getSingleVariableOfVariableStatement = getSingleVariableOfVariableStatement; + function getNestedModuleDeclaration(node) { + return ts.isModuleDeclaration(node) && + node.body && + node.body.kind === 264 /* SyntaxKind.ModuleDeclaration */ + ? node.body + : undefined; + } + function getJSDocCommentsAndTags(hostNode, noCache) { + var result; + // Pull parameter comments from declaring function as well + if (isVariableLike(hostNode) && ts.hasInitializer(hostNode) && ts.hasJSDocNodes(hostNode.initializer)) { + result = ts.addRange(result, filterOwnedJSDocTags(hostNode, ts.last(hostNode.initializer.jsDoc))); + } + var node = hostNode; + while (node && node.parent) { + if (ts.hasJSDocNodes(node)) { + result = ts.addRange(result, filterOwnedJSDocTags(hostNode, ts.last(node.jsDoc))); + } + if (node.kind === 166 /* SyntaxKind.Parameter */) { + result = ts.addRange(result, (noCache ? ts.getJSDocParameterTagsNoCache : ts.getJSDocParameterTags)(node)); + break; + } + if (node.kind === 165 /* SyntaxKind.TypeParameter */) { + result = ts.addRange(result, (noCache ? ts.getJSDocTypeParameterTagsNoCache : ts.getJSDocTypeParameterTags)(node)); + break; + } + node = getNextJSDocCommentLocation(node); + } + return result || ts.emptyArray; + } + ts.getJSDocCommentsAndTags = getJSDocCommentsAndTags; + function filterOwnedJSDocTags(hostNode, jsDoc) { + if (ts.isJSDoc(jsDoc)) { + var ownedTags = ts.filter(jsDoc.tags, function (tag) { return ownsJSDocTag(hostNode, tag); }); + return jsDoc.tags === ownedTags ? [jsDoc] : ownedTags; + } + return ownsJSDocTag(hostNode, jsDoc) ? [jsDoc] : undefined; + } + /** + * Determines whether a host node owns a jsDoc tag. A `@type` tag attached to a + * a ParenthesizedExpression belongs only to the ParenthesizedExpression. + */ + function ownsJSDocTag(hostNode, tag) { + return !ts.isJSDocTypeTag(tag) + || !tag.parent + || !ts.isJSDoc(tag.parent) + || !ts.isParenthesizedExpression(tag.parent.parent) + || tag.parent.parent === hostNode; + } + function getNextJSDocCommentLocation(node) { + var parent = node.parent; + if (parent.kind === 299 /* SyntaxKind.PropertyAssignment */ || + parent.kind === 274 /* SyntaxKind.ExportAssignment */ || + parent.kind === 169 /* SyntaxKind.PropertyDeclaration */ || + parent.kind === 241 /* SyntaxKind.ExpressionStatement */ && node.kind === 208 /* SyntaxKind.PropertyAccessExpression */ || + parent.kind === 250 /* SyntaxKind.ReturnStatement */ || + getNestedModuleDeclaration(parent) || + ts.isBinaryExpression(node) && node.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */) { + return parent; + } + // Try to recognize this pattern when node is initializer of variable declaration and JSDoc comments are on containing variable statement. + // /** + // * @param {number} name + // * @returns {number} + // */ + // var x = function(name) { return name.length; } + else if (parent.parent && + (getSingleVariableOfVariableStatement(parent.parent) === node || + ts.isBinaryExpression(parent) && parent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */)) { + return parent.parent; + } + else if (parent.parent && parent.parent.parent && + (getSingleVariableOfVariableStatement(parent.parent.parent) || + getSingleInitializerOfVariableStatementOrPropertyDeclaration(parent.parent.parent) === node || + getSourceOfDefaultedAssignment(parent.parent.parent))) { + return parent.parent.parent; + } + } + ts.getNextJSDocCommentLocation = getNextJSDocCommentLocation; + /** Does the opposite of `getJSDocParameterTags`: given a JSDoc parameter, finds the parameter corresponding to it. */ + function getParameterSymbolFromJSDoc(node) { + if (node.symbol) { + return node.symbol; + } + if (!ts.isIdentifier(node.name)) { + return undefined; + } + var name = node.name.escapedText; + var decl = getHostSignatureFromJSDoc(node); + if (!decl) { + return undefined; + } + var parameter = ts.find(decl.parameters, function (p) { return p.name.kind === 79 /* SyntaxKind.Identifier */ && p.name.escapedText === name; }); + return parameter && parameter.symbol; + } + ts.getParameterSymbolFromJSDoc = getParameterSymbolFromJSDoc; + function getEffectiveContainerForJSDocTemplateTag(node) { + if (ts.isJSDoc(node.parent) && node.parent.tags) { + // A @template tag belongs to any @typedef, @callback, or @enum tags in the same comment block, if they exist. + var typeAlias = ts.find(node.parent.tags, isJSDocTypeAlias); + if (typeAlias) { + return typeAlias; + } + } + // otherwise it belongs to the host it annotates + return getHostSignatureFromJSDoc(node); + } + ts.getEffectiveContainerForJSDocTemplateTag = getEffectiveContainerForJSDocTemplateTag; + function getHostSignatureFromJSDoc(node) { + var host = getEffectiveJSDocHost(node); + if (host) { + return ts.isPropertySignature(host) && host.type && ts.isFunctionLike(host.type) ? host.type : + ts.isFunctionLike(host) ? host : undefined; + } + return undefined; + } + ts.getHostSignatureFromJSDoc = getHostSignatureFromJSDoc; + function getEffectiveJSDocHost(node) { + var host = getJSDocHost(node); + if (host) { + return getSourceOfDefaultedAssignment(host) + || getSourceOfAssignment(host) + || getSingleInitializerOfVariableStatementOrPropertyDeclaration(host) + || getSingleVariableOfVariableStatement(host) + || getNestedModuleDeclaration(host) + || host; + } + } + ts.getEffectiveJSDocHost = getEffectiveJSDocHost; + /** Use getEffectiveJSDocHost if you additionally need to look for jsdoc on parent nodes, like assignments. */ + function getJSDocHost(node) { + var jsDoc = getJSDocRoot(node); + if (!jsDoc) { + return undefined; + } + var host = jsDoc.parent; + if (host && host.jsDoc && jsDoc === ts.lastOrUndefined(host.jsDoc)) { + return host; + } + } + ts.getJSDocHost = getJSDocHost; + function getJSDocRoot(node) { + return ts.findAncestor(node.parent, ts.isJSDoc); + } + ts.getJSDocRoot = getJSDocRoot; + function getTypeParameterFromJsDoc(node) { + var name = node.name.escapedText; + var typeParameters = node.parent.parent.parent.typeParameters; + return typeParameters && ts.find(typeParameters, function (p) { return p.name.escapedText === name; }); + } + ts.getTypeParameterFromJsDoc = getTypeParameterFromJsDoc; + function hasTypeArguments(node) { + return !!node.typeArguments; + } + ts.hasTypeArguments = hasTypeArguments; + var AssignmentKind; + (function (AssignmentKind) { + AssignmentKind[AssignmentKind["None"] = 0] = "None"; + AssignmentKind[AssignmentKind["Definite"] = 1] = "Definite"; + AssignmentKind[AssignmentKind["Compound"] = 2] = "Compound"; + })(AssignmentKind = ts.AssignmentKind || (ts.AssignmentKind = {})); + function getAssignmentTargetKind(node) { + var parent = node.parent; + while (true) { + switch (parent.kind) { + case 223 /* SyntaxKind.BinaryExpression */: + var binaryOperator = parent.operatorToken.kind; + return isAssignmentOperator(binaryOperator) && parent.left === node ? + binaryOperator === 63 /* SyntaxKind.EqualsToken */ || isLogicalOrCoalescingAssignmentOperator(binaryOperator) ? 1 /* AssignmentKind.Definite */ : 2 /* AssignmentKind.Compound */ : + 0 /* AssignmentKind.None */; + case 221 /* SyntaxKind.PrefixUnaryExpression */: + case 222 /* SyntaxKind.PostfixUnaryExpression */: + var unaryOperator = parent.operator; + return unaryOperator === 45 /* SyntaxKind.PlusPlusToken */ || unaryOperator === 46 /* SyntaxKind.MinusMinusToken */ ? 2 /* AssignmentKind.Compound */ : 0 /* AssignmentKind.None */; + case 246 /* SyntaxKind.ForInStatement */: + case 247 /* SyntaxKind.ForOfStatement */: + return parent.initializer === node ? 1 /* AssignmentKind.Definite */ : 0 /* AssignmentKind.None */; + case 214 /* SyntaxKind.ParenthesizedExpression */: + case 206 /* SyntaxKind.ArrayLiteralExpression */: + case 227 /* SyntaxKind.SpreadElement */: + case 232 /* SyntaxKind.NonNullExpression */: + node = parent; + break; + case 301 /* SyntaxKind.SpreadAssignment */: + node = parent.parent; + break; + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + if (parent.name !== node) { + return 0 /* AssignmentKind.None */; + } + node = parent.parent; + break; + case 299 /* SyntaxKind.PropertyAssignment */: + if (parent.name === node) { + return 0 /* AssignmentKind.None */; + } + node = parent.parent; + break; + default: + return 0 /* AssignmentKind.None */; + } + parent = node.parent; + } + } + ts.getAssignmentTargetKind = getAssignmentTargetKind; + // A node is an assignment target if it is on the left hand side of an '=' token, if it is parented by a property + // assignment in an object literal that is an assignment target, or if it is parented by an array literal that is + // an assignment target. Examples include 'a = xxx', '{ p: a } = xxx', '[{ a }] = xxx'. + // (Note that `p` is not a target in the above examples, only `a`.) + function isAssignmentTarget(node) { + return getAssignmentTargetKind(node) !== 0 /* AssignmentKind.None */; + } + ts.isAssignmentTarget = isAssignmentTarget; + /** + * Indicates whether a node could contain a `var` VariableDeclarationList that contributes to + * the same `var` declaration scope as the node's parent. + */ + function isNodeWithPossibleHoistedDeclaration(node) { + switch (node.kind) { + case 238 /* SyntaxKind.Block */: + case 240 /* SyntaxKind.VariableStatement */: + case 251 /* SyntaxKind.WithStatement */: + case 242 /* SyntaxKind.IfStatement */: + case 252 /* SyntaxKind.SwitchStatement */: + case 266 /* SyntaxKind.CaseBlock */: + case 292 /* SyntaxKind.CaseClause */: + case 293 /* SyntaxKind.DefaultClause */: + case 253 /* SyntaxKind.LabeledStatement */: + case 245 /* SyntaxKind.ForStatement */: + case 246 /* SyntaxKind.ForInStatement */: + case 247 /* SyntaxKind.ForOfStatement */: + case 243 /* SyntaxKind.DoStatement */: + case 244 /* SyntaxKind.WhileStatement */: + case 255 /* SyntaxKind.TryStatement */: + case 295 /* SyntaxKind.CatchClause */: + return true; + } + return false; + } + ts.isNodeWithPossibleHoistedDeclaration = isNodeWithPossibleHoistedDeclaration; + function isValueSignatureDeclaration(node) { + return ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodOrAccessor(node) || ts.isFunctionDeclaration(node) || ts.isConstructorDeclaration(node); + } + ts.isValueSignatureDeclaration = isValueSignatureDeclaration; + function walkUp(node, kind) { + while (node && node.kind === kind) { + node = node.parent; + } + return node; + } + function walkUpParenthesizedTypes(node) { + return walkUp(node, 193 /* SyntaxKind.ParenthesizedType */); + } + ts.walkUpParenthesizedTypes = walkUpParenthesizedTypes; + function walkUpParenthesizedExpressions(node) { + return walkUp(node, 214 /* SyntaxKind.ParenthesizedExpression */); + } + ts.walkUpParenthesizedExpressions = walkUpParenthesizedExpressions; + /** + * Walks up parenthesized types. + * It returns both the outermost parenthesized type and its parent. + * If given node is not a parenthesiezd type, undefined is return as the former. + */ + function walkUpParenthesizedTypesAndGetParentAndChild(node) { + var child; + while (node && node.kind === 193 /* SyntaxKind.ParenthesizedType */) { + child = node; + node = node.parent; + } + return [child, node]; + } + ts.walkUpParenthesizedTypesAndGetParentAndChild = walkUpParenthesizedTypesAndGetParentAndChild; + function skipTypeParentheses(node) { + while (ts.isParenthesizedTypeNode(node)) + node = node.type; + return node; + } + ts.skipTypeParentheses = skipTypeParentheses; + function skipParentheses(node, excludeJSDocTypeAssertions) { + var flags = excludeJSDocTypeAssertions ? + 1 /* OuterExpressionKinds.Parentheses */ | 16 /* OuterExpressionKinds.ExcludeJSDocTypeAssertion */ : + 1 /* OuterExpressionKinds.Parentheses */; + return ts.skipOuterExpressions(node, flags); + } + ts.skipParentheses = skipParentheses; + // a node is delete target iff. it is PropertyAccessExpression/ElementAccessExpression with parentheses skipped + function isDeleteTarget(node) { + if (node.kind !== 208 /* SyntaxKind.PropertyAccessExpression */ && node.kind !== 209 /* SyntaxKind.ElementAccessExpression */) { + return false; + } + node = walkUpParenthesizedExpressions(node.parent); + return node && node.kind === 217 /* SyntaxKind.DeleteExpression */; + } + ts.isDeleteTarget = isDeleteTarget; + function isNodeDescendantOf(node, ancestor) { + while (node) { + if (node === ancestor) + return true; + node = node.parent; + } + return false; + } + ts.isNodeDescendantOf = isNodeDescendantOf; + // True if `name` is the name of a declaration node + function isDeclarationName(name) { + return !ts.isSourceFile(name) && !ts.isBindingPattern(name) && ts.isDeclaration(name.parent) && name.parent.name === name; + } + ts.isDeclarationName = isDeclarationName; + // See GH#16030 + function getDeclarationFromName(name) { + var parent = name.parent; + switch (name.kind) { + case 10 /* SyntaxKind.StringLiteral */: + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + case 8 /* SyntaxKind.NumericLiteral */: + if (ts.isComputedPropertyName(parent)) + return parent.parent; + // falls through + case 79 /* SyntaxKind.Identifier */: + if (ts.isDeclaration(parent)) { + return parent.name === name ? parent : undefined; + } + else if (ts.isQualifiedName(parent)) { + var tag = parent.parent; + return ts.isJSDocParameterTag(tag) && tag.name === parent ? tag : undefined; + } + else { + var binExp = parent.parent; + return ts.isBinaryExpression(binExp) && + getAssignmentDeclarationKind(binExp) !== 0 /* AssignmentDeclarationKind.None */ && + (binExp.left.symbol || binExp.symbol) && + ts.getNameOfDeclaration(binExp) === name + ? binExp + : undefined; + } + case 80 /* SyntaxKind.PrivateIdentifier */: + return ts.isDeclaration(parent) && parent.name === name ? parent : undefined; + default: + return undefined; + } + } + ts.getDeclarationFromName = getDeclarationFromName; + function isLiteralComputedPropertyDeclarationName(node) { + return isStringOrNumericLiteralLike(node) && + node.parent.kind === 164 /* SyntaxKind.ComputedPropertyName */ && + ts.isDeclaration(node.parent.parent); + } + ts.isLiteralComputedPropertyDeclarationName = isLiteralComputedPropertyDeclarationName; + // Return true if the given identifier is classified as an IdentifierName + function isIdentifierName(node) { + var parent = node.parent; + switch (parent.kind) { + case 169 /* SyntaxKind.PropertyDeclaration */: + case 168 /* SyntaxKind.PropertySignature */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 302 /* SyntaxKind.EnumMember */: + case 299 /* SyntaxKind.PropertyAssignment */: + case 208 /* SyntaxKind.PropertyAccessExpression */: + // Name in member declaration or property name in property access + return parent.name === node; + case 163 /* SyntaxKind.QualifiedName */: + // Name on right hand side of dot in a type query or type reference + return parent.right === node; + case 205 /* SyntaxKind.BindingElement */: + case 273 /* SyntaxKind.ImportSpecifier */: + // Property name in binding element or import specifier + return parent.propertyName === node; + case 278 /* SyntaxKind.ExportSpecifier */: + case 288 /* SyntaxKind.JsxAttribute */: + case 282 /* SyntaxKind.JsxSelfClosingElement */: + case 283 /* SyntaxKind.JsxOpeningElement */: + case 284 /* SyntaxKind.JsxClosingElement */: + // Any name in an export specifier or JSX Attribute or Jsx Element + return true; + } + return false; + } + ts.isIdentifierName = isIdentifierName; + // An alias symbol is created by one of the following declarations: + // import = ... + // import from ... + // import * as from ... + // import { x as } from ... + // export { x as } from ... + // export * as ns from ... + // export = + // export default + // module.exports = + // module.exports.x = + // const x = require("...") + // const { x } = require("...") + // const x = require("...").y + // const { x } = require("...").y + function isAliasSymbolDeclaration(node) { + if (node.kind === 268 /* SyntaxKind.ImportEqualsDeclaration */ || + node.kind === 267 /* SyntaxKind.NamespaceExportDeclaration */ || + node.kind === 270 /* SyntaxKind.ImportClause */ && !!node.name || + node.kind === 271 /* SyntaxKind.NamespaceImport */ || + node.kind === 277 /* SyntaxKind.NamespaceExport */ || + node.kind === 273 /* SyntaxKind.ImportSpecifier */ || + node.kind === 278 /* SyntaxKind.ExportSpecifier */ || + node.kind === 274 /* SyntaxKind.ExportAssignment */ && exportAssignmentIsAlias(node)) { + return true; + } + return isInJSFile(node) && (ts.isBinaryExpression(node) && getAssignmentDeclarationKind(node) === 2 /* AssignmentDeclarationKind.ModuleExports */ && exportAssignmentIsAlias(node) || + ts.isPropertyAccessExpression(node) + && ts.isBinaryExpression(node.parent) + && node.parent.left === node + && node.parent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ + && isAliasableExpression(node.parent.right)); + } + ts.isAliasSymbolDeclaration = isAliasSymbolDeclaration; + function getAliasDeclarationFromName(node) { + switch (node.parent.kind) { + case 270 /* SyntaxKind.ImportClause */: + case 273 /* SyntaxKind.ImportSpecifier */: + case 271 /* SyntaxKind.NamespaceImport */: + case 278 /* SyntaxKind.ExportSpecifier */: + case 274 /* SyntaxKind.ExportAssignment */: + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + case 277 /* SyntaxKind.NamespaceExport */: + return node.parent; + case 163 /* SyntaxKind.QualifiedName */: + do { + node = node.parent; + } while (node.parent.kind === 163 /* SyntaxKind.QualifiedName */); + return getAliasDeclarationFromName(node); + } + } + ts.getAliasDeclarationFromName = getAliasDeclarationFromName; + function isAliasableExpression(e) { + return isEntityNameExpression(e) || ts.isClassExpression(e); + } + ts.isAliasableExpression = isAliasableExpression; + function exportAssignmentIsAlias(node) { + var e = getExportAssignmentExpression(node); + return isAliasableExpression(e); + } + ts.exportAssignmentIsAlias = exportAssignmentIsAlias; + function getExportAssignmentExpression(node) { + return ts.isExportAssignment(node) ? node.expression : node.right; + } + ts.getExportAssignmentExpression = getExportAssignmentExpression; + function getPropertyAssignmentAliasLikeExpression(node) { + return node.kind === 300 /* SyntaxKind.ShorthandPropertyAssignment */ ? node.name : node.kind === 299 /* SyntaxKind.PropertyAssignment */ ? node.initializer : + node.parent.right; + } + ts.getPropertyAssignmentAliasLikeExpression = getPropertyAssignmentAliasLikeExpression; + function getEffectiveBaseTypeNode(node) { + var baseType = getClassExtendsHeritageElement(node); + if (baseType && isInJSFile(node)) { + // Prefer an @augments tag because it may have type parameters. + var tag = ts.getJSDocAugmentsTag(node); + if (tag) { + return tag.class; + } + } + return baseType; + } + ts.getEffectiveBaseTypeNode = getEffectiveBaseTypeNode; + function getClassExtendsHeritageElement(node) { + var heritageClause = getHeritageClause(node.heritageClauses, 94 /* SyntaxKind.ExtendsKeyword */); + return heritageClause && heritageClause.types.length > 0 ? heritageClause.types[0] : undefined; + } + ts.getClassExtendsHeritageElement = getClassExtendsHeritageElement; + function getEffectiveImplementsTypeNodes(node) { + if (isInJSFile(node)) { + return ts.getJSDocImplementsTags(node).map(function (n) { return n.class; }); + } + else { + var heritageClause = getHeritageClause(node.heritageClauses, 117 /* SyntaxKind.ImplementsKeyword */); + return heritageClause === null || heritageClause === void 0 ? void 0 : heritageClause.types; + } + } + ts.getEffectiveImplementsTypeNodes = getEffectiveImplementsTypeNodes; + /** Returns the node in an `extends` or `implements` clause of a class or interface. */ + function getAllSuperTypeNodes(node) { + return ts.isInterfaceDeclaration(node) ? getInterfaceBaseTypeNodes(node) || ts.emptyArray : + ts.isClassLike(node) ? ts.concatenate(ts.singleElementArray(getEffectiveBaseTypeNode(node)), getEffectiveImplementsTypeNodes(node)) || ts.emptyArray : + ts.emptyArray; + } + ts.getAllSuperTypeNodes = getAllSuperTypeNodes; + function getInterfaceBaseTypeNodes(node) { + var heritageClause = getHeritageClause(node.heritageClauses, 94 /* SyntaxKind.ExtendsKeyword */); + return heritageClause ? heritageClause.types : undefined; + } + ts.getInterfaceBaseTypeNodes = getInterfaceBaseTypeNodes; + function getHeritageClause(clauses, kind) { + if (clauses) { + for (var _i = 0, clauses_1 = clauses; _i < clauses_1.length; _i++) { + var clause = clauses_1[_i]; + if (clause.token === kind) { + return clause; + } + } + } + return undefined; + } + ts.getHeritageClause = getHeritageClause; + function getAncestor(node, kind) { + while (node) { + if (node.kind === kind) { + return node; + } + node = node.parent; + } + return undefined; + } + ts.getAncestor = getAncestor; + function isKeyword(token) { + return 81 /* SyntaxKind.FirstKeyword */ <= token && token <= 162 /* SyntaxKind.LastKeyword */; + } + ts.isKeyword = isKeyword; + function isContextualKeyword(token) { + return 126 /* SyntaxKind.FirstContextualKeyword */ <= token && token <= 162 /* SyntaxKind.LastContextualKeyword */; + } + ts.isContextualKeyword = isContextualKeyword; + function isNonContextualKeyword(token) { + return isKeyword(token) && !isContextualKeyword(token); + } + ts.isNonContextualKeyword = isNonContextualKeyword; + function isFutureReservedKeyword(token) { + return 117 /* SyntaxKind.FirstFutureReservedWord */ <= token && token <= 125 /* SyntaxKind.LastFutureReservedWord */; + } + ts.isFutureReservedKeyword = isFutureReservedKeyword; + function isStringANonContextualKeyword(name) { + var token = ts.stringToToken(name); + return token !== undefined && isNonContextualKeyword(token); + } + ts.isStringANonContextualKeyword = isStringANonContextualKeyword; + function isStringAKeyword(name) { + var token = ts.stringToToken(name); + return token !== undefined && isKeyword(token); + } + ts.isStringAKeyword = isStringAKeyword; + function isIdentifierANonContextualKeyword(_a) { + var originalKeywordKind = _a.originalKeywordKind; + return !!originalKeywordKind && !isContextualKeyword(originalKeywordKind); + } + ts.isIdentifierANonContextualKeyword = isIdentifierANonContextualKeyword; + function isTrivia(token) { + return 2 /* SyntaxKind.FirstTriviaToken */ <= token && token <= 7 /* SyntaxKind.LastTriviaToken */; + } + ts.isTrivia = isTrivia; + var FunctionFlags; + (function (FunctionFlags) { + FunctionFlags[FunctionFlags["Normal"] = 0] = "Normal"; + FunctionFlags[FunctionFlags["Generator"] = 1] = "Generator"; + FunctionFlags[FunctionFlags["Async"] = 2] = "Async"; + FunctionFlags[FunctionFlags["Invalid"] = 4] = "Invalid"; + FunctionFlags[FunctionFlags["AsyncGenerator"] = 3] = "AsyncGenerator"; + })(FunctionFlags = ts.FunctionFlags || (ts.FunctionFlags = {})); + function getFunctionFlags(node) { + if (!node) { + return 4 /* FunctionFlags.Invalid */; + } + var flags = 0 /* FunctionFlags.Normal */; + switch (node.kind) { + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 171 /* SyntaxKind.MethodDeclaration */: + if (node.asteriskToken) { + flags |= 1 /* FunctionFlags.Generator */; + } + // falls through + case 216 /* SyntaxKind.ArrowFunction */: + if (hasSyntacticModifier(node, 512 /* ModifierFlags.Async */)) { + flags |= 2 /* FunctionFlags.Async */; + } + break; + } + if (!node.body) { + flags |= 4 /* FunctionFlags.Invalid */; + } + return flags; + } + ts.getFunctionFlags = getFunctionFlags; + function isAsyncFunction(node) { + switch (node.kind) { + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + case 171 /* SyntaxKind.MethodDeclaration */: + return node.body !== undefined + && node.asteriskToken === undefined + && hasSyntacticModifier(node, 512 /* ModifierFlags.Async */); + } + return false; + } + ts.isAsyncFunction = isAsyncFunction; + function isStringOrNumericLiteralLike(node) { + return ts.isStringLiteralLike(node) || ts.isNumericLiteral(node); + } + ts.isStringOrNumericLiteralLike = isStringOrNumericLiteralLike; + function isSignedNumericLiteral(node) { + return ts.isPrefixUnaryExpression(node) && (node.operator === 39 /* SyntaxKind.PlusToken */ || node.operator === 40 /* SyntaxKind.MinusToken */) && ts.isNumericLiteral(node.operand); + } + ts.isSignedNumericLiteral = isSignedNumericLiteral; + /** + * A declaration has a dynamic name if all of the following are true: + * 1. The declaration has a computed property name. + * 2. The computed name is *not* expressed as a StringLiteral. + * 3. The computed name is *not* expressed as a NumericLiteral. + * 4. The computed name is *not* expressed as a PlusToken or MinusToken + * immediately followed by a NumericLiteral. + */ + function hasDynamicName(declaration) { + var name = ts.getNameOfDeclaration(declaration); + return !!name && isDynamicName(name); + } + ts.hasDynamicName = hasDynamicName; + function isDynamicName(name) { + if (!(name.kind === 164 /* SyntaxKind.ComputedPropertyName */ || name.kind === 209 /* SyntaxKind.ElementAccessExpression */)) { + return false; + } + var expr = ts.isElementAccessExpression(name) ? skipParentheses(name.argumentExpression) : name.expression; + return !isStringOrNumericLiteralLike(expr) && + !isSignedNumericLiteral(expr); + } + ts.isDynamicName = isDynamicName; + function getPropertyNameForPropertyNameNode(name) { + switch (name.kind) { + case 79 /* SyntaxKind.Identifier */: + case 80 /* SyntaxKind.PrivateIdentifier */: + return name.escapedText; + case 10 /* SyntaxKind.StringLiteral */: + case 8 /* SyntaxKind.NumericLiteral */: + return ts.escapeLeadingUnderscores(name.text); + case 164 /* SyntaxKind.ComputedPropertyName */: + var nameExpression = name.expression; + if (isStringOrNumericLiteralLike(nameExpression)) { + return ts.escapeLeadingUnderscores(nameExpression.text); + } + else if (isSignedNumericLiteral(nameExpression)) { + if (nameExpression.operator === 40 /* SyntaxKind.MinusToken */) { + return ts.tokenToString(nameExpression.operator) + nameExpression.operand.text; + } + return nameExpression.operand.text; + } + return undefined; + default: + return ts.Debug.assertNever(name); + } + } + ts.getPropertyNameForPropertyNameNode = getPropertyNameForPropertyNameNode; + function isPropertyNameLiteral(node) { + switch (node.kind) { + case 79 /* SyntaxKind.Identifier */: + case 10 /* SyntaxKind.StringLiteral */: + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + case 8 /* SyntaxKind.NumericLiteral */: + return true; + default: + return false; + } + } + ts.isPropertyNameLiteral = isPropertyNameLiteral; + function getTextOfIdentifierOrLiteral(node) { + return ts.isMemberName(node) ? ts.idText(node) : node.text; + } + ts.getTextOfIdentifierOrLiteral = getTextOfIdentifierOrLiteral; + function getEscapedTextOfIdentifierOrLiteral(node) { + return ts.isMemberName(node) ? node.escapedText : ts.escapeLeadingUnderscores(node.text); + } + ts.getEscapedTextOfIdentifierOrLiteral = getEscapedTextOfIdentifierOrLiteral; + function getPropertyNameForUniqueESSymbol(symbol) { + return "__@".concat(ts.getSymbolId(symbol), "@").concat(symbol.escapedName); + } + ts.getPropertyNameForUniqueESSymbol = getPropertyNameForUniqueESSymbol; + function getSymbolNameForPrivateIdentifier(containingClassSymbol, description) { + return "__#".concat(ts.getSymbolId(containingClassSymbol), "@").concat(description); + } + ts.getSymbolNameForPrivateIdentifier = getSymbolNameForPrivateIdentifier; + function isKnownSymbol(symbol) { + return ts.startsWith(symbol.escapedName, "__@"); + } + ts.isKnownSymbol = isKnownSymbol; + function isPrivateIdentifierSymbol(symbol) { + return ts.startsWith(symbol.escapedName, "__#"); + } + ts.isPrivateIdentifierSymbol = isPrivateIdentifierSymbol; + /** + * Includes the word "Symbol" with unicode escapes + */ + function isESSymbolIdentifier(node) { + return node.kind === 79 /* SyntaxKind.Identifier */ && node.escapedText === "Symbol"; + } + ts.isESSymbolIdentifier = isESSymbolIdentifier; + function isPushOrUnshiftIdentifier(node) { + return node.escapedText === "push" || node.escapedText === "unshift"; + } + ts.isPushOrUnshiftIdentifier = isPushOrUnshiftIdentifier; + function isParameterDeclaration(node) { + var root = getRootDeclaration(node); + return root.kind === 166 /* SyntaxKind.Parameter */; + } + ts.isParameterDeclaration = isParameterDeclaration; + function getRootDeclaration(node) { + while (node.kind === 205 /* SyntaxKind.BindingElement */) { + node = node.parent.parent; + } + return node; + } + ts.getRootDeclaration = getRootDeclaration; + function nodeStartsNewLexicalEnvironment(node) { + var kind = node.kind; + return kind === 173 /* SyntaxKind.Constructor */ + || kind === 215 /* SyntaxKind.FunctionExpression */ + || kind === 259 /* SyntaxKind.FunctionDeclaration */ + || kind === 216 /* SyntaxKind.ArrowFunction */ + || kind === 171 /* SyntaxKind.MethodDeclaration */ + || kind === 174 /* SyntaxKind.GetAccessor */ + || kind === 175 /* SyntaxKind.SetAccessor */ + || kind === 264 /* SyntaxKind.ModuleDeclaration */ + || kind === 308 /* SyntaxKind.SourceFile */; + } + ts.nodeStartsNewLexicalEnvironment = nodeStartsNewLexicalEnvironment; + function nodeIsSynthesized(range) { + return positionIsSynthesized(range.pos) + || positionIsSynthesized(range.end); + } + ts.nodeIsSynthesized = nodeIsSynthesized; + function getOriginalSourceFile(sourceFile) { + return ts.getParseTreeNode(sourceFile, ts.isSourceFile) || sourceFile; + } + ts.getOriginalSourceFile = getOriginalSourceFile; + var Associativity; + (function (Associativity) { + Associativity[Associativity["Left"] = 0] = "Left"; + Associativity[Associativity["Right"] = 1] = "Right"; + })(Associativity = ts.Associativity || (ts.Associativity = {})); + function getExpressionAssociativity(expression) { + var operator = getOperator(expression); + var hasArguments = expression.kind === 211 /* SyntaxKind.NewExpression */ && expression.arguments !== undefined; + return getOperatorAssociativity(expression.kind, operator, hasArguments); + } + ts.getExpressionAssociativity = getExpressionAssociativity; + function getOperatorAssociativity(kind, operator, hasArguments) { + switch (kind) { + case 211 /* SyntaxKind.NewExpression */: + return hasArguments ? 0 /* Associativity.Left */ : 1 /* Associativity.Right */; + case 221 /* SyntaxKind.PrefixUnaryExpression */: + case 218 /* SyntaxKind.TypeOfExpression */: + case 219 /* SyntaxKind.VoidExpression */: + case 217 /* SyntaxKind.DeleteExpression */: + case 220 /* SyntaxKind.AwaitExpression */: + case 224 /* SyntaxKind.ConditionalExpression */: + case 226 /* SyntaxKind.YieldExpression */: + return 1 /* Associativity.Right */; + case 223 /* SyntaxKind.BinaryExpression */: + switch (operator) { + case 42 /* SyntaxKind.AsteriskAsteriskToken */: + case 63 /* SyntaxKind.EqualsToken */: + case 64 /* SyntaxKind.PlusEqualsToken */: + case 65 /* SyntaxKind.MinusEqualsToken */: + case 67 /* SyntaxKind.AsteriskAsteriskEqualsToken */: + case 66 /* SyntaxKind.AsteriskEqualsToken */: + case 68 /* SyntaxKind.SlashEqualsToken */: + case 69 /* SyntaxKind.PercentEqualsToken */: + case 70 /* SyntaxKind.LessThanLessThanEqualsToken */: + case 71 /* SyntaxKind.GreaterThanGreaterThanEqualsToken */: + case 72 /* SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken */: + case 73 /* SyntaxKind.AmpersandEqualsToken */: + case 78 /* SyntaxKind.CaretEqualsToken */: + case 74 /* SyntaxKind.BarEqualsToken */: + case 75 /* SyntaxKind.BarBarEqualsToken */: + case 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */: + case 77 /* SyntaxKind.QuestionQuestionEqualsToken */: + return 1 /* Associativity.Right */; + } + } + return 0 /* Associativity.Left */; + } + ts.getOperatorAssociativity = getOperatorAssociativity; + function getExpressionPrecedence(expression) { + var operator = getOperator(expression); + var hasArguments = expression.kind === 211 /* SyntaxKind.NewExpression */ && expression.arguments !== undefined; + return getOperatorPrecedence(expression.kind, operator, hasArguments); + } + ts.getExpressionPrecedence = getExpressionPrecedence; + function getOperator(expression) { + if (expression.kind === 223 /* SyntaxKind.BinaryExpression */) { + return expression.operatorToken.kind; + } + else if (expression.kind === 221 /* SyntaxKind.PrefixUnaryExpression */ || expression.kind === 222 /* SyntaxKind.PostfixUnaryExpression */) { + return expression.operator; + } + else { + return expression.kind; + } + } + ts.getOperator = getOperator; + var OperatorPrecedence; + (function (OperatorPrecedence) { + // Expression: + // AssignmentExpression + // Expression `,` AssignmentExpression + OperatorPrecedence[OperatorPrecedence["Comma"] = 0] = "Comma"; + // NOTE: `Spread` is higher than `Comma` due to how it is parsed in |ElementList| + // SpreadElement: + // `...` AssignmentExpression + OperatorPrecedence[OperatorPrecedence["Spread"] = 1] = "Spread"; + // AssignmentExpression: + // ConditionalExpression + // YieldExpression + // ArrowFunction + // AsyncArrowFunction + // LeftHandSideExpression `=` AssignmentExpression + // LeftHandSideExpression AssignmentOperator AssignmentExpression + // + // NOTE: AssignmentExpression is broken down into several precedences due to the requirements + // of the parenthesizer rules. + // AssignmentExpression: YieldExpression + // YieldExpression: + // `yield` + // `yield` AssignmentExpression + // `yield` `*` AssignmentExpression + OperatorPrecedence[OperatorPrecedence["Yield"] = 2] = "Yield"; + // AssignmentExpression: LeftHandSideExpression `=` AssignmentExpression + // AssignmentExpression: LeftHandSideExpression AssignmentOperator AssignmentExpression + // AssignmentOperator: one of + // `*=` `/=` `%=` `+=` `-=` `<<=` `>>=` `>>>=` `&=` `^=` `|=` `**=` + OperatorPrecedence[OperatorPrecedence["Assignment"] = 3] = "Assignment"; + // NOTE: `Conditional` is considered higher than `Assignment` here, but in reality they have + // the same precedence. + // AssignmentExpression: ConditionalExpression + // ConditionalExpression: + // ShortCircuitExpression + // ShortCircuitExpression `?` AssignmentExpression `:` AssignmentExpression + // ShortCircuitExpression: + // LogicalORExpression + // CoalesceExpression + OperatorPrecedence[OperatorPrecedence["Conditional"] = 4] = "Conditional"; + // CoalesceExpression: + // CoalesceExpressionHead `??` BitwiseORExpression + // CoalesceExpressionHead: + // CoalesceExpression + // BitwiseORExpression + OperatorPrecedence[OperatorPrecedence["Coalesce"] = 4] = "Coalesce"; + // LogicalORExpression: + // LogicalANDExpression + // LogicalORExpression `||` LogicalANDExpression + OperatorPrecedence[OperatorPrecedence["LogicalOR"] = 5] = "LogicalOR"; + // LogicalANDExpression: + // BitwiseORExpression + // LogicalANDExprerssion `&&` BitwiseORExpression + OperatorPrecedence[OperatorPrecedence["LogicalAND"] = 6] = "LogicalAND"; + // BitwiseORExpression: + // BitwiseXORExpression + // BitwiseORExpression `^` BitwiseXORExpression + OperatorPrecedence[OperatorPrecedence["BitwiseOR"] = 7] = "BitwiseOR"; + // BitwiseXORExpression: + // BitwiseANDExpression + // BitwiseXORExpression `^` BitwiseANDExpression + OperatorPrecedence[OperatorPrecedence["BitwiseXOR"] = 8] = "BitwiseXOR"; + // BitwiseANDExpression: + // EqualityExpression + // BitwiseANDExpression `^` EqualityExpression + OperatorPrecedence[OperatorPrecedence["BitwiseAND"] = 9] = "BitwiseAND"; + // EqualityExpression: + // RelationalExpression + // EqualityExpression `==` RelationalExpression + // EqualityExpression `!=` RelationalExpression + // EqualityExpression `===` RelationalExpression + // EqualityExpression `!==` RelationalExpression + OperatorPrecedence[OperatorPrecedence["Equality"] = 10] = "Equality"; + // RelationalExpression: + // ShiftExpression + // RelationalExpression `<` ShiftExpression + // RelationalExpression `>` ShiftExpression + // RelationalExpression `<=` ShiftExpression + // RelationalExpression `>=` ShiftExpression + // RelationalExpression `instanceof` ShiftExpression + // RelationalExpression `in` ShiftExpression + // [+TypeScript] RelationalExpression `as` Type + OperatorPrecedence[OperatorPrecedence["Relational"] = 11] = "Relational"; + // ShiftExpression: + // AdditiveExpression + // ShiftExpression `<<` AdditiveExpression + // ShiftExpression `>>` AdditiveExpression + // ShiftExpression `>>>` AdditiveExpression + OperatorPrecedence[OperatorPrecedence["Shift"] = 12] = "Shift"; + // AdditiveExpression: + // MultiplicativeExpression + // AdditiveExpression `+` MultiplicativeExpression + // AdditiveExpression `-` MultiplicativeExpression + OperatorPrecedence[OperatorPrecedence["Additive"] = 13] = "Additive"; + // MultiplicativeExpression: + // ExponentiationExpression + // MultiplicativeExpression MultiplicativeOperator ExponentiationExpression + // MultiplicativeOperator: one of `*`, `/`, `%` + OperatorPrecedence[OperatorPrecedence["Multiplicative"] = 14] = "Multiplicative"; + // ExponentiationExpression: + // UnaryExpression + // UpdateExpression `**` ExponentiationExpression + OperatorPrecedence[OperatorPrecedence["Exponentiation"] = 15] = "Exponentiation"; + // UnaryExpression: + // UpdateExpression + // `delete` UnaryExpression + // `void` UnaryExpression + // `typeof` UnaryExpression + // `+` UnaryExpression + // `-` UnaryExpression + // `~` UnaryExpression + // `!` UnaryExpression + // AwaitExpression + // UpdateExpression: // TODO: Do we need to investigate the precedence here? + // `++` UnaryExpression + // `--` UnaryExpression + OperatorPrecedence[OperatorPrecedence["Unary"] = 16] = "Unary"; + // UpdateExpression: + // LeftHandSideExpression + // LeftHandSideExpression `++` + // LeftHandSideExpression `--` + OperatorPrecedence[OperatorPrecedence["Update"] = 17] = "Update"; + // LeftHandSideExpression: + // NewExpression + // CallExpression + // NewExpression: + // MemberExpression + // `new` NewExpression + OperatorPrecedence[OperatorPrecedence["LeftHandSide"] = 18] = "LeftHandSide"; + // CallExpression: + // CoverCallExpressionAndAsyncArrowHead + // SuperCall + // ImportCall + // CallExpression Arguments + // CallExpression `[` Expression `]` + // CallExpression `.` IdentifierName + // CallExpression TemplateLiteral + // MemberExpression: + // PrimaryExpression + // MemberExpression `[` Expression `]` + // MemberExpression `.` IdentifierName + // MemberExpression TemplateLiteral + // SuperProperty + // MetaProperty + // `new` MemberExpression Arguments + OperatorPrecedence[OperatorPrecedence["Member"] = 19] = "Member"; + // TODO: JSXElement? + // PrimaryExpression: + // `this` + // IdentifierReference + // Literal + // ArrayLiteral + // ObjectLiteral + // FunctionExpression + // ClassExpression + // GeneratorExpression + // AsyncFunctionExpression + // AsyncGeneratorExpression + // RegularExpressionLiteral + // TemplateLiteral + // CoverParenthesizedExpressionAndArrowParameterList + OperatorPrecedence[OperatorPrecedence["Primary"] = 20] = "Primary"; + OperatorPrecedence[OperatorPrecedence["Highest"] = 20] = "Highest"; + OperatorPrecedence[OperatorPrecedence["Lowest"] = 0] = "Lowest"; + // -1 is lower than all other precedences. Returning it will cause binary expression + // parsing to stop. + OperatorPrecedence[OperatorPrecedence["Invalid"] = -1] = "Invalid"; + })(OperatorPrecedence = ts.OperatorPrecedence || (ts.OperatorPrecedence = {})); + function getOperatorPrecedence(nodeKind, operatorKind, hasArguments) { + switch (nodeKind) { + case 354 /* SyntaxKind.CommaListExpression */: + return 0 /* OperatorPrecedence.Comma */; + case 227 /* SyntaxKind.SpreadElement */: + return 1 /* OperatorPrecedence.Spread */; + case 226 /* SyntaxKind.YieldExpression */: + return 2 /* OperatorPrecedence.Yield */; + case 224 /* SyntaxKind.ConditionalExpression */: + return 4 /* OperatorPrecedence.Conditional */; + case 223 /* SyntaxKind.BinaryExpression */: + switch (operatorKind) { + case 27 /* SyntaxKind.CommaToken */: + return 0 /* OperatorPrecedence.Comma */; + case 63 /* SyntaxKind.EqualsToken */: + case 64 /* SyntaxKind.PlusEqualsToken */: + case 65 /* SyntaxKind.MinusEqualsToken */: + case 67 /* SyntaxKind.AsteriskAsteriskEqualsToken */: + case 66 /* SyntaxKind.AsteriskEqualsToken */: + case 68 /* SyntaxKind.SlashEqualsToken */: + case 69 /* SyntaxKind.PercentEqualsToken */: + case 70 /* SyntaxKind.LessThanLessThanEqualsToken */: + case 71 /* SyntaxKind.GreaterThanGreaterThanEqualsToken */: + case 72 /* SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken */: + case 73 /* SyntaxKind.AmpersandEqualsToken */: + case 78 /* SyntaxKind.CaretEqualsToken */: + case 74 /* SyntaxKind.BarEqualsToken */: + case 75 /* SyntaxKind.BarBarEqualsToken */: + case 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */: + case 77 /* SyntaxKind.QuestionQuestionEqualsToken */: + return 3 /* OperatorPrecedence.Assignment */; + default: + return getBinaryOperatorPrecedence(operatorKind); + } + // TODO: Should prefix `++` and `--` be moved to the `Update` precedence? + case 213 /* SyntaxKind.TypeAssertionExpression */: + case 232 /* SyntaxKind.NonNullExpression */: + case 221 /* SyntaxKind.PrefixUnaryExpression */: + case 218 /* SyntaxKind.TypeOfExpression */: + case 219 /* SyntaxKind.VoidExpression */: + case 217 /* SyntaxKind.DeleteExpression */: + case 220 /* SyntaxKind.AwaitExpression */: + return 16 /* OperatorPrecedence.Unary */; + case 222 /* SyntaxKind.PostfixUnaryExpression */: + return 17 /* OperatorPrecedence.Update */; + case 210 /* SyntaxKind.CallExpression */: + return 18 /* OperatorPrecedence.LeftHandSide */; + case 211 /* SyntaxKind.NewExpression */: + return hasArguments ? 19 /* OperatorPrecedence.Member */ : 18 /* OperatorPrecedence.LeftHandSide */; + case 212 /* SyntaxKind.TaggedTemplateExpression */: + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 209 /* SyntaxKind.ElementAccessExpression */: + case 233 /* SyntaxKind.MetaProperty */: + return 19 /* OperatorPrecedence.Member */; + case 231 /* SyntaxKind.AsExpression */: + case 235 /* SyntaxKind.SatisfiesExpression */: + return 11 /* OperatorPrecedence.Relational */; + case 108 /* SyntaxKind.ThisKeyword */: + case 106 /* SyntaxKind.SuperKeyword */: + case 79 /* SyntaxKind.Identifier */: + case 80 /* SyntaxKind.PrivateIdentifier */: + case 104 /* SyntaxKind.NullKeyword */: + case 110 /* SyntaxKind.TrueKeyword */: + case 95 /* SyntaxKind.FalseKeyword */: + case 8 /* SyntaxKind.NumericLiteral */: + case 9 /* SyntaxKind.BigIntLiteral */: + case 10 /* SyntaxKind.StringLiteral */: + case 206 /* SyntaxKind.ArrayLiteralExpression */: + case 207 /* SyntaxKind.ObjectLiteralExpression */: + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + case 228 /* SyntaxKind.ClassExpression */: + case 13 /* SyntaxKind.RegularExpressionLiteral */: + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + case 225 /* SyntaxKind.TemplateExpression */: + case 214 /* SyntaxKind.ParenthesizedExpression */: + case 229 /* SyntaxKind.OmittedExpression */: + case 281 /* SyntaxKind.JsxElement */: + case 282 /* SyntaxKind.JsxSelfClosingElement */: + case 285 /* SyntaxKind.JsxFragment */: + return 20 /* OperatorPrecedence.Primary */; + default: + return -1 /* OperatorPrecedence.Invalid */; + } + } + ts.getOperatorPrecedence = getOperatorPrecedence; + function getBinaryOperatorPrecedence(kind) { + switch (kind) { + case 60 /* SyntaxKind.QuestionQuestionToken */: + return 4 /* OperatorPrecedence.Coalesce */; + case 56 /* SyntaxKind.BarBarToken */: + return 5 /* OperatorPrecedence.LogicalOR */; + case 55 /* SyntaxKind.AmpersandAmpersandToken */: + return 6 /* OperatorPrecedence.LogicalAND */; + case 51 /* SyntaxKind.BarToken */: + return 7 /* OperatorPrecedence.BitwiseOR */; + case 52 /* SyntaxKind.CaretToken */: + return 8 /* OperatorPrecedence.BitwiseXOR */; + case 50 /* SyntaxKind.AmpersandToken */: + return 9 /* OperatorPrecedence.BitwiseAND */; + case 34 /* SyntaxKind.EqualsEqualsToken */: + case 35 /* SyntaxKind.ExclamationEqualsToken */: + case 36 /* SyntaxKind.EqualsEqualsEqualsToken */: + case 37 /* SyntaxKind.ExclamationEqualsEqualsToken */: + return 10 /* OperatorPrecedence.Equality */; + case 29 /* SyntaxKind.LessThanToken */: + case 31 /* SyntaxKind.GreaterThanToken */: + case 32 /* SyntaxKind.LessThanEqualsToken */: + case 33 /* SyntaxKind.GreaterThanEqualsToken */: + case 102 /* SyntaxKind.InstanceOfKeyword */: + case 101 /* SyntaxKind.InKeyword */: + case 128 /* SyntaxKind.AsKeyword */: + case 150 /* SyntaxKind.SatisfiesKeyword */: + return 11 /* OperatorPrecedence.Relational */; + case 47 /* SyntaxKind.LessThanLessThanToken */: + case 48 /* SyntaxKind.GreaterThanGreaterThanToken */: + case 49 /* SyntaxKind.GreaterThanGreaterThanGreaterThanToken */: + return 12 /* OperatorPrecedence.Shift */; + case 39 /* SyntaxKind.PlusToken */: + case 40 /* SyntaxKind.MinusToken */: + return 13 /* OperatorPrecedence.Additive */; + case 41 /* SyntaxKind.AsteriskToken */: + case 43 /* SyntaxKind.SlashToken */: + case 44 /* SyntaxKind.PercentToken */: + return 14 /* OperatorPrecedence.Multiplicative */; + case 42 /* SyntaxKind.AsteriskAsteriskToken */: + return 15 /* OperatorPrecedence.Exponentiation */; + } + // -1 is lower than all other precedences. Returning it will cause binary expression + // parsing to stop. + return -1; + } + ts.getBinaryOperatorPrecedence = getBinaryOperatorPrecedence; + function getSemanticJsxChildren(children) { + return ts.filter(children, function (i) { + switch (i.kind) { + case 291 /* SyntaxKind.JsxExpression */: + return !!i.expression; + case 11 /* SyntaxKind.JsxText */: + return !i.containsOnlyTriviaWhiteSpaces; + default: + return true; + } + }); + } + ts.getSemanticJsxChildren = getSemanticJsxChildren; + function createDiagnosticCollection() { + var nonFileDiagnostics = []; // See GH#19873 + var filesWithDiagnostics = []; + var fileDiagnostics = new ts.Map(); + var hasReadNonFileDiagnostics = false; + return { + add: add, + lookup: lookup, + getGlobalDiagnostics: getGlobalDiagnostics, + getDiagnostics: getDiagnostics, + }; + function lookup(diagnostic) { + var diagnostics; + if (diagnostic.file) { + diagnostics = fileDiagnostics.get(diagnostic.file.fileName); + } + else { + diagnostics = nonFileDiagnostics; + } + if (!diagnostics) { + return undefined; + } + var result = ts.binarySearch(diagnostics, diagnostic, ts.identity, compareDiagnosticsSkipRelatedInformation); + if (result >= 0) { + return diagnostics[result]; + } + return undefined; + } + function add(diagnostic) { + var diagnostics; + if (diagnostic.file) { + diagnostics = fileDiagnostics.get(diagnostic.file.fileName); + if (!diagnostics) { + diagnostics = []; // See GH#19873 + fileDiagnostics.set(diagnostic.file.fileName, diagnostics); + ts.insertSorted(filesWithDiagnostics, diagnostic.file.fileName, ts.compareStringsCaseSensitive); + } + } + else { + // If we've already read the non-file diagnostics, do not modify the existing array. + if (hasReadNonFileDiagnostics) { + hasReadNonFileDiagnostics = false; + nonFileDiagnostics = nonFileDiagnostics.slice(); + } + diagnostics = nonFileDiagnostics; + } + ts.insertSorted(diagnostics, diagnostic, compareDiagnosticsSkipRelatedInformation); + } + function getGlobalDiagnostics() { + hasReadNonFileDiagnostics = true; + return nonFileDiagnostics; + } + function getDiagnostics(fileName) { + if (fileName) { + return fileDiagnostics.get(fileName) || []; + } + var fileDiags = ts.flatMapToMutable(filesWithDiagnostics, function (f) { return fileDiagnostics.get(f); }); + if (!nonFileDiagnostics.length) { + return fileDiags; + } + fileDiags.unshift.apply(fileDiags, nonFileDiagnostics); + return fileDiags; + } + } + ts.createDiagnosticCollection = createDiagnosticCollection; + var templateSubstitutionRegExp = /\$\{/g; + function escapeTemplateSubstitution(str) { + return str.replace(templateSubstitutionRegExp, "\\${"); + } + /** @internal */ + function hasInvalidEscape(template) { + return template && !!(ts.isNoSubstitutionTemplateLiteral(template) + ? template.templateFlags + : (template.head.templateFlags || ts.some(template.templateSpans, function (span) { return !!span.literal.templateFlags; }))); + } + ts.hasInvalidEscape = hasInvalidEscape; + // This consists of the first 19 unprintable ASCII characters, canonical escapes, lineSeparator, + // paragraphSeparator, and nextLine. The latter three are just desirable to suppress new lines in + // the language service. These characters should be escaped when printing, and if any characters are added, + // the map below must be updated. Note that this regexp *does not* include the 'delete' character. + // There is no reason for this other than that JSON.stringify does not handle it either. + var doubleQuoteEscapedCharsRegExp = /[\\\"\u0000-\u001f\t\v\f\b\r\n\u2028\u2029\u0085]/g; + var singleQuoteEscapedCharsRegExp = /[\\\'\u0000-\u001f\t\v\f\b\r\n\u2028\u2029\u0085]/g; + // Template strings preserve simple LF newlines, still encode CRLF (or CR) + var backtickQuoteEscapedCharsRegExp = /\r\n|[\\\`\u0000-\u001f\t\v\f\b\r\u2028\u2029\u0085]/g; + var escapedCharsMap = new ts.Map(ts.getEntries({ + "\t": "\\t", + "\v": "\\v", + "\f": "\\f", + "\b": "\\b", + "\r": "\\r", + "\n": "\\n", + "\\": "\\\\", + "\"": "\\\"", + "\'": "\\\'", + "\`": "\\\`", + "\u2028": "\\u2028", + "\u2029": "\\u2029", + "\u0085": "\\u0085", + "\r\n": "\\r\\n", // special case for CRLFs in backticks + })); + function encodeUtf16EscapeSequence(charCode) { + var hexCharCode = charCode.toString(16).toUpperCase(); + var paddedHexCode = ("0000" + hexCharCode).slice(-4); + return "\\u" + paddedHexCode; + } + function getReplacement(c, offset, input) { + if (c.charCodeAt(0) === 0 /* CharacterCodes.nullCharacter */) { + var lookAhead = input.charCodeAt(offset + c.length); + if (lookAhead >= 48 /* CharacterCodes._0 */ && lookAhead <= 57 /* CharacterCodes._9 */) { + // If the null character is followed by digits, print as a hex escape to prevent the result from parsing as an octal (which is forbidden in strict mode) + return "\\x00"; + } + // Otherwise, keep printing a literal \0 for the null character + return "\\0"; + } + return escapedCharsMap.get(c) || encodeUtf16EscapeSequence(c.charCodeAt(0)); + } + /** + * Based heavily on the abstract 'Quote'/'QuoteJSONString' operation from ECMA-262 (24.3.2.2), + * but augmented for a few select characters (e.g. lineSeparator, paragraphSeparator, nextLine) + * Note that this doesn't actually wrap the input in double quotes. + */ + function escapeString(s, quoteChar) { + var escapedCharsRegExp = quoteChar === 96 /* CharacterCodes.backtick */ ? backtickQuoteEscapedCharsRegExp : + quoteChar === 39 /* CharacterCodes.singleQuote */ ? singleQuoteEscapedCharsRegExp : + doubleQuoteEscapedCharsRegExp; + return s.replace(escapedCharsRegExp, getReplacement); + } + ts.escapeString = escapeString; + var nonAsciiCharacters = /[^\u0000-\u007F]/g; + function escapeNonAsciiString(s, quoteChar) { + s = escapeString(s, quoteChar); + // Replace non-ASCII characters with '\uNNNN' escapes if any exist. + // Otherwise just return the original string. + return nonAsciiCharacters.test(s) ? + s.replace(nonAsciiCharacters, function (c) { return encodeUtf16EscapeSequence(c.charCodeAt(0)); }) : + s; + } + ts.escapeNonAsciiString = escapeNonAsciiString; + // This consists of the first 19 unprintable ASCII characters, JSX canonical escapes, lineSeparator, + // paragraphSeparator, and nextLine. The latter three are just desirable to suppress new lines in + // the language service. These characters should be escaped when printing, and if any characters are added, + // the map below must be updated. + var jsxDoubleQuoteEscapedCharsRegExp = /[\"\u0000-\u001f\u2028\u2029\u0085]/g; + var jsxSingleQuoteEscapedCharsRegExp = /[\'\u0000-\u001f\u2028\u2029\u0085]/g; + var jsxEscapedCharsMap = new ts.Map(ts.getEntries({ + "\"": """, + "\'": "'" + })); + function encodeJsxCharacterEntity(charCode) { + var hexCharCode = charCode.toString(16).toUpperCase(); + return "&#x" + hexCharCode + ";"; + } + function getJsxAttributeStringReplacement(c) { + if (c.charCodeAt(0) === 0 /* CharacterCodes.nullCharacter */) { + return "�"; + } + return jsxEscapedCharsMap.get(c) || encodeJsxCharacterEntity(c.charCodeAt(0)); + } + function escapeJsxAttributeString(s, quoteChar) { + var escapedCharsRegExp = quoteChar === 39 /* CharacterCodes.singleQuote */ ? jsxSingleQuoteEscapedCharsRegExp : + jsxDoubleQuoteEscapedCharsRegExp; + return s.replace(escapedCharsRegExp, getJsxAttributeStringReplacement); + } + ts.escapeJsxAttributeString = escapeJsxAttributeString; + /** + * Strip off existed surrounding single quotes, double quotes, or backticks from a given string + * + * @return non-quoted string + */ + function stripQuotes(name) { + var length = name.length; + if (length >= 2 && name.charCodeAt(0) === name.charCodeAt(length - 1) && isQuoteOrBacktick(name.charCodeAt(0))) { + return name.substring(1, length - 1); + } + return name; + } + ts.stripQuotes = stripQuotes; + function isQuoteOrBacktick(charCode) { + return charCode === 39 /* CharacterCodes.singleQuote */ || + charCode === 34 /* CharacterCodes.doubleQuote */ || + charCode === 96 /* CharacterCodes.backtick */; + } + function isIntrinsicJsxName(name) { + var ch = name.charCodeAt(0); + return (ch >= 97 /* CharacterCodes.a */ && ch <= 122 /* CharacterCodes.z */) || ts.stringContains(name, "-") || ts.stringContains(name, ":"); + } + ts.isIntrinsicJsxName = isIntrinsicJsxName; + var indentStrings = ["", " "]; + function getIndentString(level) { + // prepopulate cache + var singleLevel = indentStrings[1]; + for (var current = indentStrings.length; current <= level; current++) { + indentStrings.push(indentStrings[current - 1] + singleLevel); + } + return indentStrings[level]; + } + ts.getIndentString = getIndentString; + function getIndentSize() { + return indentStrings[1].length; + } + ts.getIndentSize = getIndentSize; + function isNightly() { + return ts.stringContains(ts.version, "-dev") || ts.stringContains(ts.version, "-insiders"); + } + ts.isNightly = isNightly; + function createTextWriter(newLine) { + var output; + var indent; + var lineStart; + var lineCount; + var linePos; + var hasTrailingComment = false; + function updateLineCountAndPosFor(s) { + var lineStartsOfS = ts.computeLineStarts(s); + if (lineStartsOfS.length > 1) { + lineCount = lineCount + lineStartsOfS.length - 1; + linePos = output.length - s.length + ts.last(lineStartsOfS); + lineStart = (linePos - output.length) === 0; + } + else { + lineStart = false; + } + } + function writeText(s) { + if (s && s.length) { + if (lineStart) { + s = getIndentString(indent) + s; + lineStart = false; + } + output += s; + updateLineCountAndPosFor(s); + } + } + function write(s) { + if (s) + hasTrailingComment = false; + writeText(s); + } + function writeComment(s) { + if (s) + hasTrailingComment = true; + writeText(s); + } + function reset() { + output = ""; + indent = 0; + lineStart = true; + lineCount = 0; + linePos = 0; + hasTrailingComment = false; + } + function rawWrite(s) { + if (s !== undefined) { + output += s; + updateLineCountAndPosFor(s); + hasTrailingComment = false; + } + } + function writeLiteral(s) { + if (s && s.length) { + write(s); + } + } + function writeLine(force) { + if (!lineStart || force) { + output += newLine; + lineCount++; + linePos = output.length; + lineStart = true; + hasTrailingComment = false; + } + } + function getTextPosWithWriteLine() { + return lineStart ? output.length : (output.length + newLine.length); + } + reset(); + return { + write: write, + rawWrite: rawWrite, + writeLiteral: writeLiteral, + writeLine: writeLine, + increaseIndent: function () { indent++; }, + decreaseIndent: function () { indent--; }, + getIndent: function () { return indent; }, + getTextPos: function () { return output.length; }, + getLine: function () { return lineCount; }, + getColumn: function () { return lineStart ? indent * getIndentSize() : output.length - linePos; }, + getText: function () { return output; }, + isAtStartOfLine: function () { return lineStart; }, + hasTrailingComment: function () { return hasTrailingComment; }, + hasTrailingWhitespace: function () { return !!output.length && ts.isWhiteSpaceLike(output.charCodeAt(output.length - 1)); }, + clear: reset, + reportInaccessibleThisError: ts.noop, + reportPrivateInBaseOfClassExpression: ts.noop, + reportInaccessibleUniqueSymbolError: ts.noop, + trackSymbol: function () { return false; }, + writeKeyword: write, + writeOperator: write, + writeParameter: write, + writeProperty: write, + writePunctuation: write, + writeSpace: write, + writeStringLiteral: write, + writeSymbol: function (s, _) { return write(s); }, + writeTrailingSemicolon: write, + writeComment: writeComment, + getTextPosWithWriteLine: getTextPosWithWriteLine + }; + } + ts.createTextWriter = createTextWriter; + function getTrailingSemicolonDeferringWriter(writer) { + var pendingTrailingSemicolon = false; + function commitPendingTrailingSemicolon() { + if (pendingTrailingSemicolon) { + writer.writeTrailingSemicolon(";"); + pendingTrailingSemicolon = false; + } + } + return __assign(__assign({}, writer), { writeTrailingSemicolon: function () { + pendingTrailingSemicolon = true; + }, writeLiteral: function (s) { + commitPendingTrailingSemicolon(); + writer.writeLiteral(s); + }, writeStringLiteral: function (s) { + commitPendingTrailingSemicolon(); + writer.writeStringLiteral(s); + }, writeSymbol: function (s, sym) { + commitPendingTrailingSemicolon(); + writer.writeSymbol(s, sym); + }, writePunctuation: function (s) { + commitPendingTrailingSemicolon(); + writer.writePunctuation(s); + }, writeKeyword: function (s) { + commitPendingTrailingSemicolon(); + writer.writeKeyword(s); + }, writeOperator: function (s) { + commitPendingTrailingSemicolon(); + writer.writeOperator(s); + }, writeParameter: function (s) { + commitPendingTrailingSemicolon(); + writer.writeParameter(s); + }, writeSpace: function (s) { + commitPendingTrailingSemicolon(); + writer.writeSpace(s); + }, writeProperty: function (s) { + commitPendingTrailingSemicolon(); + writer.writeProperty(s); + }, writeComment: function (s) { + commitPendingTrailingSemicolon(); + writer.writeComment(s); + }, writeLine: function () { + commitPendingTrailingSemicolon(); + writer.writeLine(); + }, increaseIndent: function () { + commitPendingTrailingSemicolon(); + writer.increaseIndent(); + }, decreaseIndent: function () { + commitPendingTrailingSemicolon(); + writer.decreaseIndent(); + } }); + } + ts.getTrailingSemicolonDeferringWriter = getTrailingSemicolonDeferringWriter; + function hostUsesCaseSensitiveFileNames(host) { + return host.useCaseSensitiveFileNames ? host.useCaseSensitiveFileNames() : false; + } + ts.hostUsesCaseSensitiveFileNames = hostUsesCaseSensitiveFileNames; + function hostGetCanonicalFileName(host) { + return ts.createGetCanonicalFileName(hostUsesCaseSensitiveFileNames(host)); + } + ts.hostGetCanonicalFileName = hostGetCanonicalFileName; + function getResolvedExternalModuleName(host, file, referenceFile) { + return file.moduleName || getExternalModuleNameFromPath(host, file.fileName, referenceFile && referenceFile.fileName); + } + ts.getResolvedExternalModuleName = getResolvedExternalModuleName; + function getCanonicalAbsolutePath(host, path) { + return host.getCanonicalFileName(ts.getNormalizedAbsolutePath(path, host.getCurrentDirectory())); + } + function getExternalModuleNameFromDeclaration(host, resolver, declaration) { + var file = resolver.getExternalModuleFileFromDeclaration(declaration); + if (!file || file.isDeclarationFile) { + return undefined; + } + // If the declaration already uses a non-relative name, and is outside the common source directory, continue to use it + var specifier = getExternalModuleName(declaration); + if (specifier && ts.isStringLiteralLike(specifier) && !ts.pathIsRelative(specifier.text) && + getCanonicalAbsolutePath(host, file.path).indexOf(getCanonicalAbsolutePath(host, ts.ensureTrailingDirectorySeparator(host.getCommonSourceDirectory()))) === -1) { + return undefined; + } + return getResolvedExternalModuleName(host, file); + } + ts.getExternalModuleNameFromDeclaration = getExternalModuleNameFromDeclaration; + /** + * Resolves a local path to a path which is absolute to the base of the emit + */ + function getExternalModuleNameFromPath(host, fileName, referencePath) { + var getCanonicalFileName = function (f) { return host.getCanonicalFileName(f); }; + var dir = ts.toPath(referencePath ? ts.getDirectoryPath(referencePath) : host.getCommonSourceDirectory(), host.getCurrentDirectory(), getCanonicalFileName); + var filePath = ts.getNormalizedAbsolutePath(fileName, host.getCurrentDirectory()); + var relativePath = ts.getRelativePathToDirectoryOrUrl(dir, filePath, dir, getCanonicalFileName, /*isAbsolutePathAnUrl*/ false); + var extensionless = removeFileExtension(relativePath); + return referencePath ? ts.ensurePathIsNonModuleName(extensionless) : extensionless; + } + ts.getExternalModuleNameFromPath = getExternalModuleNameFromPath; + function getOwnEmitOutputFilePath(fileName, host, extension) { + var compilerOptions = host.getCompilerOptions(); + var emitOutputFilePathWithoutExtension; + if (compilerOptions.outDir) { + emitOutputFilePathWithoutExtension = removeFileExtension(getSourceFilePathInNewDir(fileName, host, compilerOptions.outDir)); + } + else { + emitOutputFilePathWithoutExtension = removeFileExtension(fileName); + } + return emitOutputFilePathWithoutExtension + extension; + } + ts.getOwnEmitOutputFilePath = getOwnEmitOutputFilePath; + function getDeclarationEmitOutputFilePath(fileName, host) { + return getDeclarationEmitOutputFilePathWorker(fileName, host.getCompilerOptions(), host.getCurrentDirectory(), host.getCommonSourceDirectory(), function (f) { return host.getCanonicalFileName(f); }); + } + ts.getDeclarationEmitOutputFilePath = getDeclarationEmitOutputFilePath; + function getDeclarationEmitOutputFilePathWorker(fileName, options, currentDirectory, commonSourceDirectory, getCanonicalFileName) { + var outputDir = options.declarationDir || options.outDir; // Prefer declaration folder if specified + var path = outputDir + ? getSourceFilePathInNewDirWorker(fileName, outputDir, currentDirectory, commonSourceDirectory, getCanonicalFileName) + : fileName; + var declarationExtension = getDeclarationEmitExtensionForPath(path); + return removeFileExtension(path) + declarationExtension; + } + ts.getDeclarationEmitOutputFilePathWorker = getDeclarationEmitOutputFilePathWorker; + function getDeclarationEmitExtensionForPath(path) { + return ts.fileExtensionIsOneOf(path, [".mjs" /* Extension.Mjs */, ".mts" /* Extension.Mts */]) ? ".d.mts" /* Extension.Dmts */ : + ts.fileExtensionIsOneOf(path, [".cjs" /* Extension.Cjs */, ".cts" /* Extension.Cts */]) ? ".d.cts" /* Extension.Dcts */ : + ts.fileExtensionIsOneOf(path, [".json" /* Extension.Json */]) ? ".json.d.ts" : // Drive-by redefinition of json declaration file output name so if it's ever enabled, it behaves well + ".d.ts" /* Extension.Dts */; + } + ts.getDeclarationEmitExtensionForPath = getDeclarationEmitExtensionForPath; + /** + * This function is an inverse of `getDeclarationEmitExtensionForPath`. + */ + function getPossibleOriginalInputExtensionForExtension(path) { + return ts.fileExtensionIsOneOf(path, [".d.mts" /* Extension.Dmts */, ".mjs" /* Extension.Mjs */, ".mts" /* Extension.Mts */]) ? [".mts" /* Extension.Mts */, ".mjs" /* Extension.Mjs */] : + ts.fileExtensionIsOneOf(path, [".d.cts" /* Extension.Dcts */, ".cjs" /* Extension.Cjs */, ".cts" /* Extension.Cts */]) ? [".cts" /* Extension.Cts */, ".cjs" /* Extension.Cjs */] : + ts.fileExtensionIsOneOf(path, [".json.d.ts"]) ? [".json" /* Extension.Json */] : + [".tsx" /* Extension.Tsx */, ".ts" /* Extension.Ts */, ".jsx" /* Extension.Jsx */, ".js" /* Extension.Js */]; + } + ts.getPossibleOriginalInputExtensionForExtension = getPossibleOriginalInputExtensionForExtension; + function outFile(options) { + return options.outFile || options.out; + } + ts.outFile = outFile; + /** Returns 'undefined' if and only if 'options.paths' is undefined. */ + function getPathsBasePath(options, host) { + var _a, _b; + if (!options.paths) + return undefined; + return (_a = options.baseUrl) !== null && _a !== void 0 ? _a : ts.Debug.checkDefined(options.pathsBasePath || ((_b = host.getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(host)), "Encountered 'paths' without a 'baseUrl', config file, or host 'getCurrentDirectory'."); + } + ts.getPathsBasePath = getPathsBasePath; + /** + * Gets the source files that are expected to have an emit output. + * + * Originally part of `forEachExpectedEmitFile`, this functionality was extracted to support + * transformations. + * + * @param host An EmitHost. + * @param targetSourceFile An optional target source file to emit. + */ + function getSourceFilesToEmit(host, targetSourceFile, forceDtsEmit) { + var options = host.getCompilerOptions(); + if (outFile(options)) { + var moduleKind = getEmitModuleKind(options); + var moduleEmitEnabled_1 = options.emitDeclarationOnly || moduleKind === ts.ModuleKind.AMD || moduleKind === ts.ModuleKind.System; + // Can emit only sources that are not declaration file and are either non module code or module with --module or --target es6 specified + return ts.filter(host.getSourceFiles(), function (sourceFile) { + return (moduleEmitEnabled_1 || !ts.isExternalModule(sourceFile)) && + sourceFileMayBeEmitted(sourceFile, host, forceDtsEmit); + }); + } + else { + var sourceFiles = targetSourceFile === undefined ? host.getSourceFiles() : [targetSourceFile]; + return ts.filter(sourceFiles, function (sourceFile) { return sourceFileMayBeEmitted(sourceFile, host, forceDtsEmit); }); + } + } + ts.getSourceFilesToEmit = getSourceFilesToEmit; + /** Don't call this for `--outFile`, just for `--outDir` or plain emit. `--outFile` needs additional checks. */ + function sourceFileMayBeEmitted(sourceFile, host, forceDtsEmit) { + var options = host.getCompilerOptions(); + return !(options.noEmitForJsFiles && isSourceFileJS(sourceFile)) && + !sourceFile.isDeclarationFile && + !host.isSourceFileFromExternalLibrary(sourceFile) && + (forceDtsEmit || (!(isJsonSourceFile(sourceFile) && host.getResolvedProjectReferenceToRedirect(sourceFile.fileName)) && + !host.isSourceOfProjectReferenceRedirect(sourceFile.fileName))); + } + ts.sourceFileMayBeEmitted = sourceFileMayBeEmitted; + function getSourceFilePathInNewDir(fileName, host, newDirPath) { + return getSourceFilePathInNewDirWorker(fileName, newDirPath, host.getCurrentDirectory(), host.getCommonSourceDirectory(), function (f) { return host.getCanonicalFileName(f); }); + } + ts.getSourceFilePathInNewDir = getSourceFilePathInNewDir; + function getSourceFilePathInNewDirWorker(fileName, newDirPath, currentDirectory, commonSourceDirectory, getCanonicalFileName) { + var sourceFilePath = ts.getNormalizedAbsolutePath(fileName, currentDirectory); + var isSourceFileInCommonSourceDirectory = getCanonicalFileName(sourceFilePath).indexOf(getCanonicalFileName(commonSourceDirectory)) === 0; + sourceFilePath = isSourceFileInCommonSourceDirectory ? sourceFilePath.substring(commonSourceDirectory.length) : sourceFilePath; + return ts.combinePaths(newDirPath, sourceFilePath); + } + ts.getSourceFilePathInNewDirWorker = getSourceFilePathInNewDirWorker; + function writeFile(host, diagnostics, fileName, text, writeByteOrderMark, sourceFiles, data) { + host.writeFile(fileName, text, writeByteOrderMark, function (hostErrorMessage) { + diagnostics.add(createCompilerDiagnostic(ts.Diagnostics.Could_not_write_file_0_Colon_1, fileName, hostErrorMessage)); + }, sourceFiles, data); + } + ts.writeFile = writeFile; + function ensureDirectoriesExist(directoryPath, createDirectory, directoryExists) { + if (directoryPath.length > ts.getRootLength(directoryPath) && !directoryExists(directoryPath)) { + var parentDirectory = ts.getDirectoryPath(directoryPath); + ensureDirectoriesExist(parentDirectory, createDirectory, directoryExists); + createDirectory(directoryPath); + } + } + function writeFileEnsuringDirectories(path, data, writeByteOrderMark, writeFile, createDirectory, directoryExists) { + // PERF: Checking for directory existence is expensive. Instead, assume the directory exists + // and fall back to creating it if the file write fails. + try { + writeFile(path, data, writeByteOrderMark); + } + catch (_a) { + ensureDirectoriesExist(ts.getDirectoryPath(ts.normalizePath(path)), createDirectory, directoryExists); + writeFile(path, data, writeByteOrderMark); + } + } + ts.writeFileEnsuringDirectories = writeFileEnsuringDirectories; + function getLineOfLocalPosition(sourceFile, pos) { + var lineStarts = ts.getLineStarts(sourceFile); + return ts.computeLineOfPosition(lineStarts, pos); + } + ts.getLineOfLocalPosition = getLineOfLocalPosition; + function getLineOfLocalPositionFromLineMap(lineMap, pos) { + return ts.computeLineOfPosition(lineMap, pos); + } + ts.getLineOfLocalPositionFromLineMap = getLineOfLocalPositionFromLineMap; + function getFirstConstructorWithBody(node) { + return ts.find(node.members, function (member) { return ts.isConstructorDeclaration(member) && nodeIsPresent(member.body); }); + } + ts.getFirstConstructorWithBody = getFirstConstructorWithBody; + function getSetAccessorValueParameter(accessor) { + if (accessor && accessor.parameters.length > 0) { + var hasThis = accessor.parameters.length === 2 && parameterIsThisKeyword(accessor.parameters[0]); + return accessor.parameters[hasThis ? 1 : 0]; + } + } + ts.getSetAccessorValueParameter = getSetAccessorValueParameter; + /** Get the type annotation for the value parameter. */ + function getSetAccessorTypeAnnotationNode(accessor) { + var parameter = getSetAccessorValueParameter(accessor); + return parameter && parameter.type; + } + ts.getSetAccessorTypeAnnotationNode = getSetAccessorTypeAnnotationNode; + function getThisParameter(signature) { + // callback tags do not currently support this parameters + if (signature.parameters.length && !ts.isJSDocSignature(signature)) { + var thisParameter = signature.parameters[0]; + if (parameterIsThisKeyword(thisParameter)) { + return thisParameter; + } + } + } + ts.getThisParameter = getThisParameter; + function parameterIsThisKeyword(parameter) { + return isThisIdentifier(parameter.name); + } + ts.parameterIsThisKeyword = parameterIsThisKeyword; + function isThisIdentifier(node) { + return !!node && node.kind === 79 /* SyntaxKind.Identifier */ && identifierIsThisKeyword(node); + } + ts.isThisIdentifier = isThisIdentifier; + function isThisInTypeQuery(node) { + if (!isThisIdentifier(node)) { + return false; + } + while (ts.isQualifiedName(node.parent) && node.parent.left === node) { + node = node.parent; + } + return node.parent.kind === 183 /* SyntaxKind.TypeQuery */; + } + ts.isThisInTypeQuery = isThisInTypeQuery; + function identifierIsThisKeyword(id) { + return id.originalKeywordKind === 108 /* SyntaxKind.ThisKeyword */; + } + ts.identifierIsThisKeyword = identifierIsThisKeyword; + function getAllAccessorDeclarations(declarations, accessor) { + // TODO: GH#18217 + var firstAccessor; + var secondAccessor; + var getAccessor; + var setAccessor; + if (hasDynamicName(accessor)) { + firstAccessor = accessor; + if (accessor.kind === 174 /* SyntaxKind.GetAccessor */) { + getAccessor = accessor; + } + else if (accessor.kind === 175 /* SyntaxKind.SetAccessor */) { + setAccessor = accessor; + } + else { + ts.Debug.fail("Accessor has wrong kind"); + } + } + else { + ts.forEach(declarations, function (member) { + if (ts.isAccessor(member) + && isStatic(member) === isStatic(accessor)) { + var memberName = getPropertyNameForPropertyNameNode(member.name); + var accessorName = getPropertyNameForPropertyNameNode(accessor.name); + if (memberName === accessorName) { + if (!firstAccessor) { + firstAccessor = member; + } + else if (!secondAccessor) { + secondAccessor = member; + } + if (member.kind === 174 /* SyntaxKind.GetAccessor */ && !getAccessor) { + getAccessor = member; + } + if (member.kind === 175 /* SyntaxKind.SetAccessor */ && !setAccessor) { + setAccessor = member; + } + } + } + }); + } + return { + firstAccessor: firstAccessor, + secondAccessor: secondAccessor, + getAccessor: getAccessor, + setAccessor: setAccessor + }; + } + ts.getAllAccessorDeclarations = getAllAccessorDeclarations; + /** + * Gets the effective type annotation of a variable, parameter, or property. If the node was + * parsed in a JavaScript file, gets the type annotation from JSDoc. Also gets the type of + * functions only the JSDoc case. + */ + function getEffectiveTypeAnnotationNode(node) { + if (!isInJSFile(node) && ts.isFunctionDeclaration(node)) + return undefined; + var type = node.type; + if (type || !isInJSFile(node)) + return type; + return ts.isJSDocPropertyLikeTag(node) ? node.typeExpression && node.typeExpression.type : ts.getJSDocType(node); + } + ts.getEffectiveTypeAnnotationNode = getEffectiveTypeAnnotationNode; + function getTypeAnnotationNode(node) { + return node.type; + } + ts.getTypeAnnotationNode = getTypeAnnotationNode; + /** + * Gets the effective return type annotation of a signature. If the node was parsed in a + * JavaScript file, gets the return type annotation from JSDoc. + */ + function getEffectiveReturnTypeNode(node) { + return ts.isJSDocSignature(node) ? + node.type && node.type.typeExpression && node.type.typeExpression.type : + node.type || (isInJSFile(node) ? ts.getJSDocReturnType(node) : undefined); + } + ts.getEffectiveReturnTypeNode = getEffectiveReturnTypeNode; + function getJSDocTypeParameterDeclarations(node) { + return ts.flatMap(ts.getJSDocTags(node), function (tag) { return isNonTypeAliasTemplate(tag) ? tag.typeParameters : undefined; }); + } + ts.getJSDocTypeParameterDeclarations = getJSDocTypeParameterDeclarations; + /** template tags are only available when a typedef isn't already using them */ + function isNonTypeAliasTemplate(tag) { + return ts.isJSDocTemplateTag(tag) && !(tag.parent.kind === 323 /* SyntaxKind.JSDoc */ && tag.parent.tags.some(isJSDocTypeAlias)); + } + /** + * Gets the effective type annotation of the value parameter of a set accessor. If the node + * was parsed in a JavaScript file, gets the type annotation from JSDoc. + */ + function getEffectiveSetAccessorTypeAnnotationNode(node) { + var parameter = getSetAccessorValueParameter(node); + return parameter && getEffectiveTypeAnnotationNode(parameter); + } + ts.getEffectiveSetAccessorTypeAnnotationNode = getEffectiveSetAccessorTypeAnnotationNode; + function emitNewLineBeforeLeadingComments(lineMap, writer, node, leadingComments) { + emitNewLineBeforeLeadingCommentsOfPosition(lineMap, writer, node.pos, leadingComments); + } + ts.emitNewLineBeforeLeadingComments = emitNewLineBeforeLeadingComments; + function emitNewLineBeforeLeadingCommentsOfPosition(lineMap, writer, pos, leadingComments) { + // If the leading comments start on different line than the start of node, write new line + if (leadingComments && leadingComments.length && pos !== leadingComments[0].pos && + getLineOfLocalPositionFromLineMap(lineMap, pos) !== getLineOfLocalPositionFromLineMap(lineMap, leadingComments[0].pos)) { + writer.writeLine(); + } + } + ts.emitNewLineBeforeLeadingCommentsOfPosition = emitNewLineBeforeLeadingCommentsOfPosition; + function emitNewLineBeforeLeadingCommentOfPosition(lineMap, writer, pos, commentPos) { + // If the leading comments start on different line than the start of node, write new line + if (pos !== commentPos && + getLineOfLocalPositionFromLineMap(lineMap, pos) !== getLineOfLocalPositionFromLineMap(lineMap, commentPos)) { + writer.writeLine(); + } + } + ts.emitNewLineBeforeLeadingCommentOfPosition = emitNewLineBeforeLeadingCommentOfPosition; + function emitComments(text, lineMap, writer, comments, leadingSeparator, trailingSeparator, newLine, writeComment) { + if (comments && comments.length > 0) { + if (leadingSeparator) { + writer.writeSpace(" "); + } + var emitInterveningSeparator = false; + for (var _i = 0, comments_1 = comments; _i < comments_1.length; _i++) { + var comment = comments_1[_i]; + if (emitInterveningSeparator) { + writer.writeSpace(" "); + emitInterveningSeparator = false; + } + writeComment(text, lineMap, writer, comment.pos, comment.end, newLine); + if (comment.hasTrailingNewLine) { + writer.writeLine(); + } + else { + emitInterveningSeparator = true; + } + } + if (emitInterveningSeparator && trailingSeparator) { + writer.writeSpace(" "); + } + } + } + ts.emitComments = emitComments; + /** + * Detached comment is a comment at the top of file or function body that is separated from + * the next statement by space. + */ + function emitDetachedComments(text, lineMap, writer, writeComment, node, newLine, removeComments) { + var leadingComments; + var currentDetachedCommentInfo; + if (removeComments) { + // removeComments is true, only reserve pinned comment at the top of file + // For example: + // /*! Pinned Comment */ + // + // var x = 10; + if (node.pos === 0) { + leadingComments = ts.filter(ts.getLeadingCommentRanges(text, node.pos), isPinnedCommentLocal); + } + } + else { + // removeComments is false, just get detached as normal and bypass the process to filter comment + leadingComments = ts.getLeadingCommentRanges(text, node.pos); + } + if (leadingComments) { + var detachedComments = []; + var lastComment = void 0; + for (var _i = 0, leadingComments_1 = leadingComments; _i < leadingComments_1.length; _i++) { + var comment = leadingComments_1[_i]; + if (lastComment) { + var lastCommentLine = getLineOfLocalPositionFromLineMap(lineMap, lastComment.end); + var commentLine = getLineOfLocalPositionFromLineMap(lineMap, comment.pos); + if (commentLine >= lastCommentLine + 2) { + // There was a blank line between the last comment and this comment. This + // comment is not part of the copyright comments. Return what we have so + // far. + break; + } + } + detachedComments.push(comment); + lastComment = comment; + } + if (detachedComments.length) { + // All comments look like they could have been part of the copyright header. Make + // sure there is at least one blank line between it and the node. If not, it's not + // a copyright header. + var lastCommentLine = getLineOfLocalPositionFromLineMap(lineMap, ts.last(detachedComments).end); + var nodeLine = getLineOfLocalPositionFromLineMap(lineMap, ts.skipTrivia(text, node.pos)); + if (nodeLine >= lastCommentLine + 2) { + // Valid detachedComments + emitNewLineBeforeLeadingComments(lineMap, writer, node, leadingComments); + emitComments(text, lineMap, writer, detachedComments, /*leadingSeparator*/ false, /*trailingSeparator*/ true, newLine, writeComment); + currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: ts.last(detachedComments).end }; + } + } + } + return currentDetachedCommentInfo; + function isPinnedCommentLocal(comment) { + return isPinnedComment(text, comment.pos); + } + } + ts.emitDetachedComments = emitDetachedComments; + function writeCommentRange(text, lineMap, writer, commentPos, commentEnd, newLine) { + if (text.charCodeAt(commentPos + 1) === 42 /* CharacterCodes.asterisk */) { + var firstCommentLineAndCharacter = ts.computeLineAndCharacterOfPosition(lineMap, commentPos); + var lineCount = lineMap.length; + var firstCommentLineIndent = void 0; + for (var pos = commentPos, currentLine = firstCommentLineAndCharacter.line; pos < commentEnd; currentLine++) { + var nextLineStart = (currentLine + 1) === lineCount + ? text.length + 1 + : lineMap[currentLine + 1]; + if (pos !== commentPos) { + // If we are not emitting first line, we need to write the spaces to adjust the alignment + if (firstCommentLineIndent === undefined) { + firstCommentLineIndent = calculateIndent(text, lineMap[firstCommentLineAndCharacter.line], commentPos); + } + // These are number of spaces writer is going to write at current indent + var currentWriterIndentSpacing = writer.getIndent() * getIndentSize(); + // Number of spaces we want to be writing + // eg: Assume writer indent + // module m { + // /* starts at character 9 this is line 1 + // * starts at character pos 4 line --1 = 8 - 8 + 3 + // More left indented comment */ --2 = 8 - 8 + 2 + // class c { } + // } + // module m { + // /* this is line 1 -- Assume current writer indent 8 + // * line --3 = 8 - 4 + 5 + // More right indented comment */ --4 = 8 - 4 + 11 + // class c { } + // } + var spacesToEmit = currentWriterIndentSpacing - firstCommentLineIndent + calculateIndent(text, pos, nextLineStart); + if (spacesToEmit > 0) { + var numberOfSingleSpacesToEmit = spacesToEmit % getIndentSize(); + var indentSizeSpaceString = getIndentString((spacesToEmit - numberOfSingleSpacesToEmit) / getIndentSize()); + // Write indent size string ( in eg 1: = "", 2: "" , 3: string with 8 spaces 4: string with 12 spaces + writer.rawWrite(indentSizeSpaceString); + // Emit the single spaces (in eg: 1: 3 spaces, 2: 2 spaces, 3: 1 space, 4: 3 spaces) + while (numberOfSingleSpacesToEmit) { + writer.rawWrite(" "); + numberOfSingleSpacesToEmit--; + } + } + else { + // No spaces to emit write empty string + writer.rawWrite(""); + } + } + // Write the comment line text + writeTrimmedCurrentLine(text, commentEnd, writer, newLine, pos, nextLineStart); + pos = nextLineStart; + } + } + else { + // Single line comment of style //.... + writer.writeComment(text.substring(commentPos, commentEnd)); + } + } + ts.writeCommentRange = writeCommentRange; + function writeTrimmedCurrentLine(text, commentEnd, writer, newLine, pos, nextLineStart) { + var end = Math.min(commentEnd, nextLineStart - 1); + var currentLineText = ts.trimString(text.substring(pos, end)); + if (currentLineText) { + // trimmed forward and ending spaces text + writer.writeComment(currentLineText); + if (end !== commentEnd) { + writer.writeLine(); + } + } + else { + // Empty string - make sure we write empty line + writer.rawWrite(newLine); + } + } + function calculateIndent(text, pos, end) { + var currentLineIndent = 0; + for (; pos < end && ts.isWhiteSpaceSingleLine(text.charCodeAt(pos)); pos++) { + if (text.charCodeAt(pos) === 9 /* CharacterCodes.tab */) { + // Tabs = TabSize = indent size and go to next tabStop + currentLineIndent += getIndentSize() - (currentLineIndent % getIndentSize()); + } + else { + // Single space + currentLineIndent++; + } + } + return currentLineIndent; + } + function hasEffectiveModifiers(node) { + return getEffectiveModifierFlags(node) !== 0 /* ModifierFlags.None */; + } + ts.hasEffectiveModifiers = hasEffectiveModifiers; + function hasSyntacticModifiers(node) { + return getSyntacticModifierFlags(node) !== 0 /* ModifierFlags.None */; + } + ts.hasSyntacticModifiers = hasSyntacticModifiers; + function hasEffectiveModifier(node, flags) { + return !!getSelectedEffectiveModifierFlags(node, flags); + } + ts.hasEffectiveModifier = hasEffectiveModifier; + function hasSyntacticModifier(node, flags) { + return !!getSelectedSyntacticModifierFlags(node, flags); + } + ts.hasSyntacticModifier = hasSyntacticModifier; + function isStatic(node) { + // https://tc39.es/ecma262/#sec-static-semantics-isstatic + return ts.isClassElement(node) && hasStaticModifier(node) || ts.isClassStaticBlockDeclaration(node); + } + ts.isStatic = isStatic; + function hasStaticModifier(node) { + return hasSyntacticModifier(node, 32 /* ModifierFlags.Static */); + } + ts.hasStaticModifier = hasStaticModifier; + function hasOverrideModifier(node) { + return hasEffectiveModifier(node, 16384 /* ModifierFlags.Override */); + } + ts.hasOverrideModifier = hasOverrideModifier; + function hasAbstractModifier(node) { + return hasSyntacticModifier(node, 256 /* ModifierFlags.Abstract */); + } + ts.hasAbstractModifier = hasAbstractModifier; + function hasAmbientModifier(node) { + return hasSyntacticModifier(node, 2 /* ModifierFlags.Ambient */); + } + ts.hasAmbientModifier = hasAmbientModifier; + function hasAccessorModifier(node) { + return hasSyntacticModifier(node, 128 /* ModifierFlags.Accessor */); + } + ts.hasAccessorModifier = hasAccessorModifier; + function hasEffectiveReadonlyModifier(node) { + return hasEffectiveModifier(node, 64 /* ModifierFlags.Readonly */); + } + ts.hasEffectiveReadonlyModifier = hasEffectiveReadonlyModifier; + function hasDecorators(node) { + return hasSyntacticModifier(node, 131072 /* ModifierFlags.Decorator */); + } + ts.hasDecorators = hasDecorators; + function getSelectedEffectiveModifierFlags(node, flags) { + return getEffectiveModifierFlags(node) & flags; + } + ts.getSelectedEffectiveModifierFlags = getSelectedEffectiveModifierFlags; + function getSelectedSyntacticModifierFlags(node, flags) { + return getSyntacticModifierFlags(node) & flags; + } + ts.getSelectedSyntacticModifierFlags = getSelectedSyntacticModifierFlags; + function getModifierFlagsWorker(node, includeJSDoc, alwaysIncludeJSDoc) { + if (node.kind >= 0 /* SyntaxKind.FirstToken */ && node.kind <= 162 /* SyntaxKind.LastToken */) { + return 0 /* ModifierFlags.None */; + } + if (!(node.modifierFlagsCache & 536870912 /* ModifierFlags.HasComputedFlags */)) { + node.modifierFlagsCache = getSyntacticModifierFlagsNoCache(node) | 536870912 /* ModifierFlags.HasComputedFlags */; + } + if (includeJSDoc && !(node.modifierFlagsCache & 4096 /* ModifierFlags.HasComputedJSDocModifiers */) && (alwaysIncludeJSDoc || isInJSFile(node)) && node.parent) { + node.modifierFlagsCache |= getJSDocModifierFlagsNoCache(node) | 4096 /* ModifierFlags.HasComputedJSDocModifiers */; + } + return node.modifierFlagsCache & ~(536870912 /* ModifierFlags.HasComputedFlags */ | 4096 /* ModifierFlags.HasComputedJSDocModifiers */); + } + /** + * Gets the effective ModifierFlags for the provided node, including JSDoc modifiers. The modifiers will be cached on the node to improve performance. + * + * NOTE: This function may use `parent` pointers. + */ + function getEffectiveModifierFlags(node) { + return getModifierFlagsWorker(node, /*includeJSDoc*/ true); + } + ts.getEffectiveModifierFlags = getEffectiveModifierFlags; + function getEffectiveModifierFlagsAlwaysIncludeJSDoc(node) { + return getModifierFlagsWorker(node, /*includeJSDOc*/ true, /*alwaysIncludeJSDOc*/ true); + } + ts.getEffectiveModifierFlagsAlwaysIncludeJSDoc = getEffectiveModifierFlagsAlwaysIncludeJSDoc; + /** + * Gets the ModifierFlags for syntactic modifiers on the provided node. The modifiers will be cached on the node to improve performance. + * + * NOTE: This function does not use `parent` pointers and will not include modifiers from JSDoc. + */ + function getSyntacticModifierFlags(node) { + return getModifierFlagsWorker(node, /*includeJSDoc*/ false); + } + ts.getSyntacticModifierFlags = getSyntacticModifierFlags; + function getJSDocModifierFlagsNoCache(node) { + var flags = 0 /* ModifierFlags.None */; + if (!!node.parent && !ts.isParameter(node)) { + if (isInJSFile(node)) { + if (ts.getJSDocPublicTagNoCache(node)) + flags |= 4 /* ModifierFlags.Public */; + if (ts.getJSDocPrivateTagNoCache(node)) + flags |= 8 /* ModifierFlags.Private */; + if (ts.getJSDocProtectedTagNoCache(node)) + flags |= 16 /* ModifierFlags.Protected */; + if (ts.getJSDocReadonlyTagNoCache(node)) + flags |= 64 /* ModifierFlags.Readonly */; + if (ts.getJSDocOverrideTagNoCache(node)) + flags |= 16384 /* ModifierFlags.Override */; + } + if (ts.getJSDocDeprecatedTagNoCache(node)) + flags |= 8192 /* ModifierFlags.Deprecated */; + } + return flags; + } + /** + * Gets the effective ModifierFlags for the provided node, including JSDoc modifiers. The modifier flags cache on the node is ignored. + * + * NOTE: This function may use `parent` pointers. + */ + function getEffectiveModifierFlagsNoCache(node) { + return getSyntacticModifierFlagsNoCache(node) | getJSDocModifierFlagsNoCache(node); + } + ts.getEffectiveModifierFlagsNoCache = getEffectiveModifierFlagsNoCache; + /** + * Gets the ModifierFlags for syntactic modifiers on the provided node. The modifier flags cache on the node is ignored. + * + * NOTE: This function does not use `parent` pointers and will not include modifiers from JSDoc. + */ + function getSyntacticModifierFlagsNoCache(node) { + var flags = ts.canHaveModifiers(node) ? modifiersToFlags(node.modifiers) : 0 /* ModifierFlags.None */; + if (node.flags & 4 /* NodeFlags.NestedNamespace */ || (node.kind === 79 /* SyntaxKind.Identifier */ && node.isInJSDocNamespace)) { + flags |= 1 /* ModifierFlags.Export */; + } + return flags; + } + ts.getSyntacticModifierFlagsNoCache = getSyntacticModifierFlagsNoCache; + function modifiersToFlags(modifiers) { + var flags = 0 /* ModifierFlags.None */; + if (modifiers) { + for (var _i = 0, modifiers_1 = modifiers; _i < modifiers_1.length; _i++) { + var modifier = modifiers_1[_i]; + flags |= modifierToFlag(modifier.kind); + } + } + return flags; + } + ts.modifiersToFlags = modifiersToFlags; + function modifierToFlag(token) { + switch (token) { + case 124 /* SyntaxKind.StaticKeyword */: return 32 /* ModifierFlags.Static */; + case 123 /* SyntaxKind.PublicKeyword */: return 4 /* ModifierFlags.Public */; + case 122 /* SyntaxKind.ProtectedKeyword */: return 16 /* ModifierFlags.Protected */; + case 121 /* SyntaxKind.PrivateKeyword */: return 8 /* ModifierFlags.Private */; + case 126 /* SyntaxKind.AbstractKeyword */: return 256 /* ModifierFlags.Abstract */; + case 127 /* SyntaxKind.AccessorKeyword */: return 128 /* ModifierFlags.Accessor */; + case 93 /* SyntaxKind.ExportKeyword */: return 1 /* ModifierFlags.Export */; + case 136 /* SyntaxKind.DeclareKeyword */: return 2 /* ModifierFlags.Ambient */; + case 85 /* SyntaxKind.ConstKeyword */: return 2048 /* ModifierFlags.Const */; + case 88 /* SyntaxKind.DefaultKeyword */: return 1024 /* ModifierFlags.Default */; + case 132 /* SyntaxKind.AsyncKeyword */: return 512 /* ModifierFlags.Async */; + case 146 /* SyntaxKind.ReadonlyKeyword */: return 64 /* ModifierFlags.Readonly */; + case 161 /* SyntaxKind.OverrideKeyword */: return 16384 /* ModifierFlags.Override */; + case 101 /* SyntaxKind.InKeyword */: return 32768 /* ModifierFlags.In */; + case 145 /* SyntaxKind.OutKeyword */: return 65536 /* ModifierFlags.Out */; + case 167 /* SyntaxKind.Decorator */: return 131072 /* ModifierFlags.Decorator */; + } + return 0 /* ModifierFlags.None */; + } + ts.modifierToFlag = modifierToFlag; + function isLogicalOperator(token) { + return token === 56 /* SyntaxKind.BarBarToken */ + || token === 55 /* SyntaxKind.AmpersandAmpersandToken */ + || token === 53 /* SyntaxKind.ExclamationToken */; + } + ts.isLogicalOperator = isLogicalOperator; + function isLogicalOrCoalescingAssignmentOperator(token) { + return token === 75 /* SyntaxKind.BarBarEqualsToken */ + || token === 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */ + || token === 77 /* SyntaxKind.QuestionQuestionEqualsToken */; + } + ts.isLogicalOrCoalescingAssignmentOperator = isLogicalOrCoalescingAssignmentOperator; + function isLogicalOrCoalescingAssignmentExpression(expr) { + return isLogicalOrCoalescingAssignmentOperator(expr.operatorToken.kind); + } + ts.isLogicalOrCoalescingAssignmentExpression = isLogicalOrCoalescingAssignmentExpression; + function isAssignmentOperator(token) { + return token >= 63 /* SyntaxKind.FirstAssignment */ && token <= 78 /* SyntaxKind.LastAssignment */; + } + ts.isAssignmentOperator = isAssignmentOperator; + /** Get `C` given `N` if `N` is in the position `class C extends N` where `N` is an ExpressionWithTypeArguments. */ + function tryGetClassExtendingExpressionWithTypeArguments(node) { + var cls = tryGetClassImplementingOrExtendingExpressionWithTypeArguments(node); + return cls && !cls.isImplements ? cls.class : undefined; + } + ts.tryGetClassExtendingExpressionWithTypeArguments = tryGetClassExtendingExpressionWithTypeArguments; + function tryGetClassImplementingOrExtendingExpressionWithTypeArguments(node) { + return ts.isExpressionWithTypeArguments(node) + && ts.isHeritageClause(node.parent) + && ts.isClassLike(node.parent.parent) + ? { class: node.parent.parent, isImplements: node.parent.token === 117 /* SyntaxKind.ImplementsKeyword */ } + : undefined; + } + ts.tryGetClassImplementingOrExtendingExpressionWithTypeArguments = tryGetClassImplementingOrExtendingExpressionWithTypeArguments; + function isAssignmentExpression(node, excludeCompoundAssignment) { + return ts.isBinaryExpression(node) + && (excludeCompoundAssignment + ? node.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ + : isAssignmentOperator(node.operatorToken.kind)) + && ts.isLeftHandSideExpression(node.left); + } + ts.isAssignmentExpression = isAssignmentExpression; + function isLeftHandSideOfAssignment(node) { + return isAssignmentExpression(node.parent) && node.parent.left === node; + } + ts.isLeftHandSideOfAssignment = isLeftHandSideOfAssignment; + function isDestructuringAssignment(node) { + if (isAssignmentExpression(node, /*excludeCompoundAssignment*/ true)) { + var kind = node.left.kind; + return kind === 207 /* SyntaxKind.ObjectLiteralExpression */ + || kind === 206 /* SyntaxKind.ArrayLiteralExpression */; + } + return false; + } + ts.isDestructuringAssignment = isDestructuringAssignment; + function isExpressionWithTypeArgumentsInClassExtendsClause(node) { + return tryGetClassExtendingExpressionWithTypeArguments(node) !== undefined; + } + ts.isExpressionWithTypeArgumentsInClassExtendsClause = isExpressionWithTypeArgumentsInClassExtendsClause; + function isEntityNameExpression(node) { + return node.kind === 79 /* SyntaxKind.Identifier */ || isPropertyAccessEntityNameExpression(node); + } + ts.isEntityNameExpression = isEntityNameExpression; + function getFirstIdentifier(node) { + switch (node.kind) { + case 79 /* SyntaxKind.Identifier */: + return node; + case 163 /* SyntaxKind.QualifiedName */: + do { + node = node.left; + } while (node.kind !== 79 /* SyntaxKind.Identifier */); + return node; + case 208 /* SyntaxKind.PropertyAccessExpression */: + do { + node = node.expression; + } while (node.kind !== 79 /* SyntaxKind.Identifier */); + return node; + } + } + ts.getFirstIdentifier = getFirstIdentifier; + function isDottedName(node) { + return node.kind === 79 /* SyntaxKind.Identifier */ + || node.kind === 108 /* SyntaxKind.ThisKeyword */ + || node.kind === 106 /* SyntaxKind.SuperKeyword */ + || node.kind === 233 /* SyntaxKind.MetaProperty */ + || node.kind === 208 /* SyntaxKind.PropertyAccessExpression */ && isDottedName(node.expression) + || node.kind === 214 /* SyntaxKind.ParenthesizedExpression */ && isDottedName(node.expression); + } + ts.isDottedName = isDottedName; + function isPropertyAccessEntityNameExpression(node) { + return ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.name) && isEntityNameExpression(node.expression); + } + ts.isPropertyAccessEntityNameExpression = isPropertyAccessEntityNameExpression; + function tryGetPropertyAccessOrIdentifierToString(expr) { + if (ts.isPropertyAccessExpression(expr)) { + var baseStr = tryGetPropertyAccessOrIdentifierToString(expr.expression); + if (baseStr !== undefined) { + return baseStr + "." + entityNameToString(expr.name); + } + } + else if (ts.isElementAccessExpression(expr)) { + var baseStr = tryGetPropertyAccessOrIdentifierToString(expr.expression); + if (baseStr !== undefined && ts.isPropertyName(expr.argumentExpression)) { + return baseStr + "." + getPropertyNameForPropertyNameNode(expr.argumentExpression); + } + } + else if (ts.isIdentifier(expr)) { + return ts.unescapeLeadingUnderscores(expr.escapedText); + } + return undefined; + } + ts.tryGetPropertyAccessOrIdentifierToString = tryGetPropertyAccessOrIdentifierToString; + function isPrototypeAccess(node) { + return isBindableStaticAccessExpression(node) && getElementOrPropertyAccessName(node) === "prototype"; + } + ts.isPrototypeAccess = isPrototypeAccess; + function isRightSideOfQualifiedNameOrPropertyAccess(node) { + return (node.parent.kind === 163 /* SyntaxKind.QualifiedName */ && node.parent.right === node) || + (node.parent.kind === 208 /* SyntaxKind.PropertyAccessExpression */ && node.parent.name === node); + } + ts.isRightSideOfQualifiedNameOrPropertyAccess = isRightSideOfQualifiedNameOrPropertyAccess; + function isRightSideOfAccessExpression(node) { + return ts.isPropertyAccessExpression(node.parent) && node.parent.name === node + || ts.isElementAccessExpression(node.parent) && node.parent.argumentExpression === node; + } + ts.isRightSideOfAccessExpression = isRightSideOfAccessExpression; + function isRightSideOfQualifiedNameOrPropertyAccessOrJSDocMemberName(node) { + return ts.isQualifiedName(node.parent) && node.parent.right === node + || ts.isPropertyAccessExpression(node.parent) && node.parent.name === node + || ts.isJSDocMemberName(node.parent) && node.parent.right === node; + } + ts.isRightSideOfQualifiedNameOrPropertyAccessOrJSDocMemberName = isRightSideOfQualifiedNameOrPropertyAccessOrJSDocMemberName; + function isEmptyObjectLiteral(expression) { + return expression.kind === 207 /* SyntaxKind.ObjectLiteralExpression */ && + expression.properties.length === 0; + } + ts.isEmptyObjectLiteral = isEmptyObjectLiteral; + function isEmptyArrayLiteral(expression) { + return expression.kind === 206 /* SyntaxKind.ArrayLiteralExpression */ && + expression.elements.length === 0; + } + ts.isEmptyArrayLiteral = isEmptyArrayLiteral; + function getLocalSymbolForExportDefault(symbol) { + if (!isExportDefaultSymbol(symbol) || !symbol.declarations) + return undefined; + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + if (decl.localSymbol) + return decl.localSymbol; + } + return undefined; + } + ts.getLocalSymbolForExportDefault = getLocalSymbolForExportDefault; + function isExportDefaultSymbol(symbol) { + return symbol && ts.length(symbol.declarations) > 0 && hasSyntacticModifier(symbol.declarations[0], 1024 /* ModifierFlags.Default */); + } + /** Return ".ts", ".d.ts", or ".tsx", if that is the extension. */ + function tryExtractTSExtension(fileName) { + return ts.find(supportedTSExtensionsForExtractExtension, function (extension) { return ts.fileExtensionIs(fileName, extension); }); + } + ts.tryExtractTSExtension = tryExtractTSExtension; + /** + * Replace each instance of non-ascii characters by one, two, three, or four escape sequences + * representing the UTF-8 encoding of the character, and return the expanded char code list. + */ + function getExpandedCharCodes(input) { + var output = []; + var length = input.length; + for (var i = 0; i < length; i++) { + var charCode = input.charCodeAt(i); + // handle utf8 + if (charCode < 0x80) { + output.push(charCode); + } + else if (charCode < 0x800) { + output.push((charCode >> 6) | 192); + output.push((charCode & 63) | 128); + } + else if (charCode < 0x10000) { + output.push((charCode >> 12) | 224); + output.push(((charCode >> 6) & 63) | 128); + output.push((charCode & 63) | 128); + } + else if (charCode < 0x20000) { + output.push((charCode >> 18) | 240); + output.push(((charCode >> 12) & 63) | 128); + output.push(((charCode >> 6) & 63) | 128); + output.push((charCode & 63) | 128); + } + else { + ts.Debug.assert(false, "Unexpected code point"); + } + } + return output; + } + var base64Digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; + /** + * Converts a string to a base-64 encoded ASCII string. + */ + function convertToBase64(input) { + var result = ""; + var charCodes = getExpandedCharCodes(input); + var i = 0; + var length = charCodes.length; + var byte1, byte2, byte3, byte4; + while (i < length) { + // Convert every 6-bits in the input 3 character points + // into a base64 digit + byte1 = charCodes[i] >> 2; + byte2 = (charCodes[i] & 3) << 4 | charCodes[i + 1] >> 4; + byte3 = (charCodes[i + 1] & 15) << 2 | charCodes[i + 2] >> 6; + byte4 = charCodes[i + 2] & 63; + // We are out of characters in the input, set the extra + // digits to 64 (padding character). + if (i + 1 >= length) { + byte3 = byte4 = 64; + } + else if (i + 2 >= length) { + byte4 = 64; + } + // Write to the output + result += base64Digits.charAt(byte1) + base64Digits.charAt(byte2) + base64Digits.charAt(byte3) + base64Digits.charAt(byte4); + i += 3; + } + return result; + } + ts.convertToBase64 = convertToBase64; + function getStringFromExpandedCharCodes(codes) { + var output = ""; + var i = 0; + var length = codes.length; + while (i < length) { + var charCode = codes[i]; + if (charCode < 0x80) { + output += String.fromCharCode(charCode); + i++; + } + else if ((charCode & 192) === 192) { + var value = charCode & 63; + i++; + var nextCode = codes[i]; + while ((nextCode & 192) === 128) { + value = (value << 6) | (nextCode & 63); + i++; + nextCode = codes[i]; + } + // `value` may be greater than 10FFFF (the maximum unicode codepoint) - JS will just make this into an invalid character for us + output += String.fromCharCode(value); + } + else { + // We don't want to kill the process when decoding fails (due to a following char byte not + // following a leading char), so we just print the (bad) value + output += String.fromCharCode(charCode); + i++; + } + } + return output; + } + function base64encode(host, input) { + if (host && host.base64encode) { + return host.base64encode(input); + } + return convertToBase64(input); + } + ts.base64encode = base64encode; + function base64decode(host, input) { + if (host && host.base64decode) { + return host.base64decode(input); + } + var length = input.length; + var expandedCharCodes = []; + var i = 0; + while (i < length) { + // Stop decoding once padding characters are present + if (input.charCodeAt(i) === base64Digits.charCodeAt(64)) { + break; + } + // convert 4 input digits into three characters, ignoring padding characters at the end + var ch1 = base64Digits.indexOf(input[i]); + var ch2 = base64Digits.indexOf(input[i + 1]); + var ch3 = base64Digits.indexOf(input[i + 2]); + var ch4 = base64Digits.indexOf(input[i + 3]); + var code1 = ((ch1 & 63) << 2) | ((ch2 >> 4) & 3); + var code2 = ((ch2 & 15) << 4) | ((ch3 >> 2) & 15); + var code3 = ((ch3 & 3) << 6) | (ch4 & 63); + if (code2 === 0 && ch3 !== 0) { // code2 decoded to zero, but ch3 was padding - elide code2 and code3 + expandedCharCodes.push(code1); + } + else if (code3 === 0 && ch4 !== 0) { // code3 decoded to zero, but ch4 was padding, elide code3 + expandedCharCodes.push(code1, code2); + } + else { + expandedCharCodes.push(code1, code2, code3); + } + i += 4; + } + return getStringFromExpandedCharCodes(expandedCharCodes); + } + ts.base64decode = base64decode; + function readJsonOrUndefined(path, hostOrText) { + var jsonText = ts.isString(hostOrText) ? hostOrText : hostOrText.readFile(path); + if (!jsonText) + return undefined; + // gracefully handle if readFile fails or returns not JSON + var result = ts.parseConfigFileTextToJson(path, jsonText); + return !result.error ? result.config : undefined; + } + ts.readJsonOrUndefined = readJsonOrUndefined; + function readJson(path, host) { + return readJsonOrUndefined(path, host) || {}; + } + ts.readJson = readJson; + function directoryProbablyExists(directoryName, host) { + // if host does not support 'directoryExists' assume that directory will exist + return !host.directoryExists || host.directoryExists(directoryName); + } + ts.directoryProbablyExists = directoryProbablyExists; + var carriageReturnLineFeed = "\r\n"; + var lineFeed = "\n"; + function getNewLineCharacter(options, getNewLine) { + switch (options.newLine) { + case 0 /* NewLineKind.CarriageReturnLineFeed */: + return carriageReturnLineFeed; + case 1 /* NewLineKind.LineFeed */: + return lineFeed; + } + return getNewLine ? getNewLine() : ts.sys ? ts.sys.newLine : carriageReturnLineFeed; + } + ts.getNewLineCharacter = getNewLineCharacter; + /** + * Creates a new TextRange from the provided pos and end. + * + * @param pos The start position. + * @param end The end position. + */ + function createRange(pos, end) { + if (end === void 0) { end = pos; } + ts.Debug.assert(end >= pos || end === -1); + return { pos: pos, end: end }; + } + ts.createRange = createRange; + /** + * Creates a new TextRange from a provided range with a new end position. + * + * @param range A TextRange. + * @param end The new end position. + */ + function moveRangeEnd(range, end) { + return createRange(range.pos, end); + } + ts.moveRangeEnd = moveRangeEnd; + /** + * Creates a new TextRange from a provided range with a new start position. + * + * @param range A TextRange. + * @param pos The new Start position. + */ + function moveRangePos(range, pos) { + return createRange(pos, range.end); + } + ts.moveRangePos = moveRangePos; + /** + * Moves the start position of a range past any decorators. + */ + function moveRangePastDecorators(node) { + var lastDecorator = ts.canHaveModifiers(node) ? ts.findLast(node.modifiers, ts.isDecorator) : undefined; + return lastDecorator && !positionIsSynthesized(lastDecorator.end) + ? moveRangePos(node, lastDecorator.end) + : node; + } + ts.moveRangePastDecorators = moveRangePastDecorators; + /** + * Moves the start position of a range past any decorators or modifiers. + */ + function moveRangePastModifiers(node) { + var lastModifier = ts.canHaveModifiers(node) ? ts.lastOrUndefined(node.modifiers) : undefined; + return lastModifier && !positionIsSynthesized(lastModifier.end) + ? moveRangePos(node, lastModifier.end) + : moveRangePastDecorators(node); + } + ts.moveRangePastModifiers = moveRangePastModifiers; + /** + * Determines whether a TextRange has the same start and end positions. + * + * @param range A TextRange. + */ + function isCollapsedRange(range) { + return range.pos === range.end; + } + ts.isCollapsedRange = isCollapsedRange; + /** + * Creates a new TextRange for a token at the provides start position. + * + * @param pos The start position. + * @param token The token. + */ + function createTokenRange(pos, token) { + return createRange(pos, pos + ts.tokenToString(token).length); + } + ts.createTokenRange = createTokenRange; + function rangeIsOnSingleLine(range, sourceFile) { + return rangeStartIsOnSameLineAsRangeEnd(range, range, sourceFile); + } + ts.rangeIsOnSingleLine = rangeIsOnSingleLine; + function rangeStartPositionsAreOnSameLine(range1, range2, sourceFile) { + return positionsAreOnSameLine(getStartPositionOfRange(range1, sourceFile, /*includeComments*/ false), getStartPositionOfRange(range2, sourceFile, /*includeComments*/ false), sourceFile); + } + ts.rangeStartPositionsAreOnSameLine = rangeStartPositionsAreOnSameLine; + function rangeEndPositionsAreOnSameLine(range1, range2, sourceFile) { + return positionsAreOnSameLine(range1.end, range2.end, sourceFile); + } + ts.rangeEndPositionsAreOnSameLine = rangeEndPositionsAreOnSameLine; + function rangeStartIsOnSameLineAsRangeEnd(range1, range2, sourceFile) { + return positionsAreOnSameLine(getStartPositionOfRange(range1, sourceFile, /*includeComments*/ false), range2.end, sourceFile); + } + ts.rangeStartIsOnSameLineAsRangeEnd = rangeStartIsOnSameLineAsRangeEnd; + function rangeEndIsOnSameLineAsRangeStart(range1, range2, sourceFile) { + return positionsAreOnSameLine(range1.end, getStartPositionOfRange(range2, sourceFile, /*includeComments*/ false), sourceFile); + } + ts.rangeEndIsOnSameLineAsRangeStart = rangeEndIsOnSameLineAsRangeStart; + function getLinesBetweenRangeEndAndRangeStart(range1, range2, sourceFile, includeSecondRangeComments) { + var range2Start = getStartPositionOfRange(range2, sourceFile, includeSecondRangeComments); + return ts.getLinesBetweenPositions(sourceFile, range1.end, range2Start); + } + ts.getLinesBetweenRangeEndAndRangeStart = getLinesBetweenRangeEndAndRangeStart; + function getLinesBetweenRangeEndPositions(range1, range2, sourceFile) { + return ts.getLinesBetweenPositions(sourceFile, range1.end, range2.end); + } + ts.getLinesBetweenRangeEndPositions = getLinesBetweenRangeEndPositions; + function isNodeArrayMultiLine(list, sourceFile) { + return !positionsAreOnSameLine(list.pos, list.end, sourceFile); + } + ts.isNodeArrayMultiLine = isNodeArrayMultiLine; + function positionsAreOnSameLine(pos1, pos2, sourceFile) { + return ts.getLinesBetweenPositions(sourceFile, pos1, pos2) === 0; + } + ts.positionsAreOnSameLine = positionsAreOnSameLine; + function getStartPositionOfRange(range, sourceFile, includeComments) { + return positionIsSynthesized(range.pos) ? -1 : ts.skipTrivia(sourceFile.text, range.pos, /*stopAfterLineBreak*/ false, includeComments); + } + ts.getStartPositionOfRange = getStartPositionOfRange; + function getLinesBetweenPositionAndPrecedingNonWhitespaceCharacter(pos, stopPos, sourceFile, includeComments) { + var startPos = ts.skipTrivia(sourceFile.text, pos, /*stopAfterLineBreak*/ false, includeComments); + var prevPos = getPreviousNonWhitespacePosition(startPos, stopPos, sourceFile); + return ts.getLinesBetweenPositions(sourceFile, prevPos !== null && prevPos !== void 0 ? prevPos : stopPos, startPos); + } + ts.getLinesBetweenPositionAndPrecedingNonWhitespaceCharacter = getLinesBetweenPositionAndPrecedingNonWhitespaceCharacter; + function getLinesBetweenPositionAndNextNonWhitespaceCharacter(pos, stopPos, sourceFile, includeComments) { + var nextPos = ts.skipTrivia(sourceFile.text, pos, /*stopAfterLineBreak*/ false, includeComments); + return ts.getLinesBetweenPositions(sourceFile, pos, Math.min(stopPos, nextPos)); + } + ts.getLinesBetweenPositionAndNextNonWhitespaceCharacter = getLinesBetweenPositionAndNextNonWhitespaceCharacter; + function getPreviousNonWhitespacePosition(pos, stopPos, sourceFile) { + if (stopPos === void 0) { stopPos = 0; } + while (pos-- > stopPos) { + if (!ts.isWhiteSpaceLike(sourceFile.text.charCodeAt(pos))) { + return pos; + } + } + } + /** + * Determines whether a name was originally the declaration name of an enum or namespace + * declaration. + */ + function isDeclarationNameOfEnumOrNamespace(node) { + var parseNode = ts.getParseTreeNode(node); + if (parseNode) { + switch (parseNode.parent.kind) { + case 263 /* SyntaxKind.EnumDeclaration */: + case 264 /* SyntaxKind.ModuleDeclaration */: + return parseNode === parseNode.parent.name; + } + } + return false; + } + ts.isDeclarationNameOfEnumOrNamespace = isDeclarationNameOfEnumOrNamespace; + function getInitializedVariables(node) { + return ts.filter(node.declarations, isInitializedVariable); + } + ts.getInitializedVariables = getInitializedVariables; + function isInitializedVariable(node) { + return node.initializer !== undefined; + } + function isWatchSet(options) { + // Firefox has Object.prototype.watch + return options.watch && ts.hasProperty(options, "watch"); + } + ts.isWatchSet = isWatchSet; + function closeFileWatcher(watcher) { + watcher.close(); + } + ts.closeFileWatcher = closeFileWatcher; + function getCheckFlags(symbol) { + return symbol.flags & 33554432 /* SymbolFlags.Transient */ ? symbol.checkFlags : 0; + } + ts.getCheckFlags = getCheckFlags; + function getDeclarationModifierFlagsFromSymbol(s, isWrite) { + if (isWrite === void 0) { isWrite = false; } + if (s.valueDeclaration) { + var declaration = (isWrite && s.declarations && ts.find(s.declarations, ts.isSetAccessorDeclaration)) + || (s.flags & 32768 /* SymbolFlags.GetAccessor */ && ts.find(s.declarations, ts.isGetAccessorDeclaration)) || s.valueDeclaration; + var flags = ts.getCombinedModifierFlags(declaration); + return s.parent && s.parent.flags & 32 /* SymbolFlags.Class */ ? flags : flags & ~28 /* ModifierFlags.AccessibilityModifier */; + } + if (getCheckFlags(s) & 6 /* CheckFlags.Synthetic */) { + var checkFlags = s.checkFlags; + var accessModifier = checkFlags & 1024 /* CheckFlags.ContainsPrivate */ ? 8 /* ModifierFlags.Private */ : + checkFlags & 256 /* CheckFlags.ContainsPublic */ ? 4 /* ModifierFlags.Public */ : + 16 /* ModifierFlags.Protected */; + var staticModifier = checkFlags & 2048 /* CheckFlags.ContainsStatic */ ? 32 /* ModifierFlags.Static */ : 0; + return accessModifier | staticModifier; + } + if (s.flags & 4194304 /* SymbolFlags.Prototype */) { + return 4 /* ModifierFlags.Public */ | 32 /* ModifierFlags.Static */; + } + return 0; + } + ts.getDeclarationModifierFlagsFromSymbol = getDeclarationModifierFlagsFromSymbol; + function skipAlias(symbol, checker) { + return symbol.flags & 2097152 /* SymbolFlags.Alias */ ? checker.getAliasedSymbol(symbol) : symbol; + } + ts.skipAlias = skipAlias; + /** See comment on `declareModuleMember` in `binder.ts`. */ + function getCombinedLocalAndExportSymbolFlags(symbol) { + return symbol.exportSymbol ? symbol.exportSymbol.flags | symbol.flags : symbol.flags; + } + ts.getCombinedLocalAndExportSymbolFlags = getCombinedLocalAndExportSymbolFlags; + function isWriteOnlyAccess(node) { + return accessKind(node) === 1 /* AccessKind.Write */; + } + ts.isWriteOnlyAccess = isWriteOnlyAccess; + function isWriteAccess(node) { + return accessKind(node) !== 0 /* AccessKind.Read */; + } + ts.isWriteAccess = isWriteAccess; + var AccessKind; + (function (AccessKind) { + /** Only reads from a variable. */ + AccessKind[AccessKind["Read"] = 0] = "Read"; + /** Only writes to a variable without using the result. E.g.: `x++;`. */ + AccessKind[AccessKind["Write"] = 1] = "Write"; + /** Writes to a variable and uses the result as an expression. E.g.: `f(x++);`. */ + AccessKind[AccessKind["ReadWrite"] = 2] = "ReadWrite"; + })(AccessKind || (AccessKind = {})); + function accessKind(node) { + var parent = node.parent; + if (!parent) + return 0 /* AccessKind.Read */; + switch (parent.kind) { + case 214 /* SyntaxKind.ParenthesizedExpression */: + return accessKind(parent); + case 222 /* SyntaxKind.PostfixUnaryExpression */: + case 221 /* SyntaxKind.PrefixUnaryExpression */: + var operator = parent.operator; + return operator === 45 /* SyntaxKind.PlusPlusToken */ || operator === 46 /* SyntaxKind.MinusMinusToken */ ? writeOrReadWrite() : 0 /* AccessKind.Read */; + case 223 /* SyntaxKind.BinaryExpression */: + var _a = parent, left = _a.left, operatorToken = _a.operatorToken; + return left === node && isAssignmentOperator(operatorToken.kind) ? + operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ ? 1 /* AccessKind.Write */ : writeOrReadWrite() + : 0 /* AccessKind.Read */; + case 208 /* SyntaxKind.PropertyAccessExpression */: + return parent.name !== node ? 0 /* AccessKind.Read */ : accessKind(parent); + case 299 /* SyntaxKind.PropertyAssignment */: { + var parentAccess = accessKind(parent.parent); + // In `({ x: varname }) = { x: 1 }`, the left `x` is a read, the right `x` is a write. + return node === parent.name ? reverseAccessKind(parentAccess) : parentAccess; + } + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + // Assume it's the local variable being accessed, since we don't check public properties for --noUnusedLocals. + return node === parent.objectAssignmentInitializer ? 0 /* AccessKind.Read */ : accessKind(parent.parent); + case 206 /* SyntaxKind.ArrayLiteralExpression */: + return accessKind(parent); + default: + return 0 /* AccessKind.Read */; + } + function writeOrReadWrite() { + // If grandparent is not an ExpressionStatement, this is used as an expression in addition to having a side effect. + return parent.parent && walkUpParenthesizedExpressions(parent.parent).kind === 241 /* SyntaxKind.ExpressionStatement */ ? 1 /* AccessKind.Write */ : 2 /* AccessKind.ReadWrite */; + } + } + function reverseAccessKind(a) { + switch (a) { + case 0 /* AccessKind.Read */: + return 1 /* AccessKind.Write */; + case 1 /* AccessKind.Write */: + return 0 /* AccessKind.Read */; + case 2 /* AccessKind.ReadWrite */: + return 2 /* AccessKind.ReadWrite */; + default: + return ts.Debug.assertNever(a); + } + } + function compareDataObjects(dst, src) { + if (!dst || !src || Object.keys(dst).length !== Object.keys(src).length) { + return false; + } + for (var e in dst) { + if (typeof dst[e] === "object") { + if (!compareDataObjects(dst[e], src[e])) { + return false; + } + } + else if (typeof dst[e] !== "function") { + if (dst[e] !== src[e]) { + return false; + } + } + } + return true; + } + ts.compareDataObjects = compareDataObjects; + /** + * clears already present map by calling onDeleteExistingValue callback before deleting that key/value + */ + function clearMap(map, onDeleteValue) { + // Remove all + map.forEach(onDeleteValue); + map.clear(); + } + ts.clearMap = clearMap; + /** + * Mutates the map with newMap such that keys in map will be same as newMap. + */ + function mutateMapSkippingNewValues(map, newMap, options) { + var onDeleteValue = options.onDeleteValue, onExistingValue = options.onExistingValue; + // Needs update + map.forEach(function (existingValue, key) { + var valueInNewMap = newMap.get(key); + // Not present any more in new map, remove it + if (valueInNewMap === undefined) { + map.delete(key); + onDeleteValue(existingValue, key); + } + // If present notify about existing values + else if (onExistingValue) { + onExistingValue(existingValue, valueInNewMap, key); + } + }); + } + ts.mutateMapSkippingNewValues = mutateMapSkippingNewValues; + /** + * Mutates the map with newMap such that keys in map will be same as newMap. + */ + function mutateMap(map, newMap, options) { + // Needs update + mutateMapSkippingNewValues(map, newMap, options); + var createNewValue = options.createNewValue; + // Add new values that are not already present + newMap.forEach(function (valueInNewMap, key) { + if (!map.has(key)) { + // New values + map.set(key, createNewValue(key, valueInNewMap)); + } + }); + } + ts.mutateMap = mutateMap; + function isAbstractConstructorSymbol(symbol) { + if (symbol.flags & 32 /* SymbolFlags.Class */) { + var declaration = getClassLikeDeclarationOfSymbol(symbol); + return !!declaration && hasSyntacticModifier(declaration, 256 /* ModifierFlags.Abstract */); + } + return false; + } + ts.isAbstractConstructorSymbol = isAbstractConstructorSymbol; + function getClassLikeDeclarationOfSymbol(symbol) { + var _a; + return (_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isClassLike); + } + ts.getClassLikeDeclarationOfSymbol = getClassLikeDeclarationOfSymbol; + function getObjectFlags(type) { + return type.flags & 3899393 /* TypeFlags.ObjectFlagsType */ ? type.objectFlags : 0; + } + ts.getObjectFlags = getObjectFlags; + function typeHasCallOrConstructSignatures(type, checker) { + return checker.getSignaturesOfType(type, 0 /* SignatureKind.Call */).length !== 0 || checker.getSignaturesOfType(type, 1 /* SignatureKind.Construct */).length !== 0; + } + ts.typeHasCallOrConstructSignatures = typeHasCallOrConstructSignatures; + function forSomeAncestorDirectory(directory, callback) { + return !!ts.forEachAncestorDirectory(directory, function (d) { return callback(d) ? true : undefined; }); + } + ts.forSomeAncestorDirectory = forSomeAncestorDirectory; + function isUMDExportSymbol(symbol) { + return !!symbol && !!symbol.declarations && !!symbol.declarations[0] && ts.isNamespaceExportDeclaration(symbol.declarations[0]); + } + ts.isUMDExportSymbol = isUMDExportSymbol; + function showModuleSpecifier(_a) { + var moduleSpecifier = _a.moduleSpecifier; + return ts.isStringLiteral(moduleSpecifier) ? moduleSpecifier.text : getTextOfNode(moduleSpecifier); + } + ts.showModuleSpecifier = showModuleSpecifier; + function getLastChild(node) { + var lastChild; + ts.forEachChild(node, function (child) { + if (nodeIsPresent(child)) + lastChild = child; + }, function (children) { + // As an optimization, jump straight to the end of the list. + for (var i = children.length - 1; i >= 0; i--) { + if (nodeIsPresent(children[i])) { + lastChild = children[i]; + break; + } + } + }); + return lastChild; + } + ts.getLastChild = getLastChild; + function addToSeen(seen, key, value) { + if (value === void 0) { value = true; } + if (seen.has(key)) { + return false; + } + seen.set(key, value); + return true; + } + ts.addToSeen = addToSeen; + function isObjectTypeDeclaration(node) { + return ts.isClassLike(node) || ts.isInterfaceDeclaration(node) || ts.isTypeLiteralNode(node); + } + ts.isObjectTypeDeclaration = isObjectTypeDeclaration; + function isTypeNodeKind(kind) { + return (kind >= 179 /* SyntaxKind.FirstTypeNode */ && kind <= 202 /* SyntaxKind.LastTypeNode */) + || kind === 131 /* SyntaxKind.AnyKeyword */ + || kind === 157 /* SyntaxKind.UnknownKeyword */ + || kind === 148 /* SyntaxKind.NumberKeyword */ + || kind === 160 /* SyntaxKind.BigIntKeyword */ + || kind === 149 /* SyntaxKind.ObjectKeyword */ + || kind === 134 /* SyntaxKind.BooleanKeyword */ + || kind === 152 /* SyntaxKind.StringKeyword */ + || kind === 153 /* SyntaxKind.SymbolKeyword */ + || kind === 114 /* SyntaxKind.VoidKeyword */ + || kind === 155 /* SyntaxKind.UndefinedKeyword */ + || kind === 144 /* SyntaxKind.NeverKeyword */ + || kind === 230 /* SyntaxKind.ExpressionWithTypeArguments */ + || kind === 315 /* SyntaxKind.JSDocAllType */ + || kind === 316 /* SyntaxKind.JSDocUnknownType */ + || kind === 317 /* SyntaxKind.JSDocNullableType */ + || kind === 318 /* SyntaxKind.JSDocNonNullableType */ + || kind === 319 /* SyntaxKind.JSDocOptionalType */ + || kind === 320 /* SyntaxKind.JSDocFunctionType */ + || kind === 321 /* SyntaxKind.JSDocVariadicType */; + } + ts.isTypeNodeKind = isTypeNodeKind; + function isAccessExpression(node) { + return node.kind === 208 /* SyntaxKind.PropertyAccessExpression */ || node.kind === 209 /* SyntaxKind.ElementAccessExpression */; + } + ts.isAccessExpression = isAccessExpression; + function getNameOfAccessExpression(node) { + if (node.kind === 208 /* SyntaxKind.PropertyAccessExpression */) { + return node.name; + } + ts.Debug.assert(node.kind === 209 /* SyntaxKind.ElementAccessExpression */); + return node.argumentExpression; + } + ts.getNameOfAccessExpression = getNameOfAccessExpression; + function isBundleFileTextLike(section) { + switch (section.kind) { + case "text" /* BundleFileSectionKind.Text */: + case "internal" /* BundleFileSectionKind.Internal */: + return true; + default: + return false; + } + } + ts.isBundleFileTextLike = isBundleFileTextLike; + function isNamedImportsOrExports(node) { + return node.kind === 272 /* SyntaxKind.NamedImports */ || node.kind === 276 /* SyntaxKind.NamedExports */; + } + ts.isNamedImportsOrExports = isNamedImportsOrExports; + function getLeftmostAccessExpression(expr) { + while (isAccessExpression(expr)) { + expr = expr.expression; + } + return expr; + } + ts.getLeftmostAccessExpression = getLeftmostAccessExpression; + function forEachNameInAccessChainWalkingLeft(name, action) { + if (isAccessExpression(name.parent) && isRightSideOfAccessExpression(name)) { + return walkAccessExpression(name.parent); + } + function walkAccessExpression(access) { + if (access.kind === 208 /* SyntaxKind.PropertyAccessExpression */) { + var res = action(access.name); + if (res !== undefined) { + return res; + } + } + else if (access.kind === 209 /* SyntaxKind.ElementAccessExpression */) { + if (ts.isIdentifier(access.argumentExpression) || ts.isStringLiteralLike(access.argumentExpression)) { + var res = action(access.argumentExpression); + if (res !== undefined) { + return res; + } + } + else { + // Chain interrupted by non-static-name access 'x[expr()].y.z' + return undefined; + } + } + if (isAccessExpression(access.expression)) { + return walkAccessExpression(access.expression); + } + if (ts.isIdentifier(access.expression)) { + // End of chain at Identifier 'x.y.z' + return action(access.expression); + } + // End of chain at non-Identifier 'x().y.z' + return undefined; + } + } + ts.forEachNameInAccessChainWalkingLeft = forEachNameInAccessChainWalkingLeft; + function getLeftmostExpression(node, stopAtCallExpressions) { + while (true) { + switch (node.kind) { + case 222 /* SyntaxKind.PostfixUnaryExpression */: + node = node.operand; + continue; + case 223 /* SyntaxKind.BinaryExpression */: + node = node.left; + continue; + case 224 /* SyntaxKind.ConditionalExpression */: + node = node.condition; + continue; + case 212 /* SyntaxKind.TaggedTemplateExpression */: + node = node.tag; + continue; + case 210 /* SyntaxKind.CallExpression */: + if (stopAtCallExpressions) { + return node; + } + // falls through + case 231 /* SyntaxKind.AsExpression */: + case 209 /* SyntaxKind.ElementAccessExpression */: + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 232 /* SyntaxKind.NonNullExpression */: + case 353 /* SyntaxKind.PartiallyEmittedExpression */: + case 235 /* SyntaxKind.SatisfiesExpression */: + node = node.expression; + continue; + } + return node; + } + } + ts.getLeftmostExpression = getLeftmostExpression; + function Symbol(flags, name) { + this.flags = flags; + this.escapedName = name; + this.declarations = undefined; + this.valueDeclaration = undefined; + this.id = undefined; + this.mergeId = undefined; + this.parent = undefined; + } + function Type(checker, flags) { + this.flags = flags; + if (ts.Debug.isDebugging || ts.tracing) { + this.checker = checker; + } + } + function Signature(checker, flags) { + this.flags = flags; + if (ts.Debug.isDebugging) { + this.checker = checker; + } + } + function Node(kind, pos, end) { + this.pos = pos; + this.end = end; + this.kind = kind; + this.id = 0; + this.flags = 0 /* NodeFlags.None */; + this.modifierFlagsCache = 0 /* ModifierFlags.None */; + this.transformFlags = 0 /* TransformFlags.None */; + this.parent = undefined; + this.original = undefined; + } + function Token(kind, pos, end) { + this.pos = pos; + this.end = end; + this.kind = kind; + this.id = 0; + this.flags = 0 /* NodeFlags.None */; + this.transformFlags = 0 /* TransformFlags.None */; + this.parent = undefined; + } + function Identifier(kind, pos, end) { + this.pos = pos; + this.end = end; + this.kind = kind; + this.id = 0; + this.flags = 0 /* NodeFlags.None */; + this.transformFlags = 0 /* TransformFlags.None */; + this.parent = undefined; + this.original = undefined; + this.flowNode = undefined; + } + function SourceMapSource(fileName, text, skipTrivia) { + this.fileName = fileName; + this.text = text; + this.skipTrivia = skipTrivia || (function (pos) { return pos; }); + } + // eslint-disable-next-line prefer-const + ts.objectAllocator = { + getNodeConstructor: function () { return Node; }, + getTokenConstructor: function () { return Token; }, + getIdentifierConstructor: function () { return Identifier; }, + getPrivateIdentifierConstructor: function () { return Node; }, + getSourceFileConstructor: function () { return Node; }, + getSymbolConstructor: function () { return Symbol; }, + getTypeConstructor: function () { return Type; }, + getSignatureConstructor: function () { return Signature; }, + getSourceMapSourceConstructor: function () { return SourceMapSource; }, + }; + function setObjectAllocator(alloc) { + Object.assign(ts.objectAllocator, alloc); + } + ts.setObjectAllocator = setObjectAllocator; + function formatStringFromArgs(text, args, baseIndex) { + if (baseIndex === void 0) { baseIndex = 0; } + return text.replace(/{(\d+)}/g, function (_match, index) { return "" + ts.Debug.checkDefined(args[+index + baseIndex]); }); + } + ts.formatStringFromArgs = formatStringFromArgs; + var localizedDiagnosticMessages; + /* @internal */ + function setLocalizedDiagnosticMessages(messages) { + localizedDiagnosticMessages = messages; + } + ts.setLocalizedDiagnosticMessages = setLocalizedDiagnosticMessages; + /* @internal */ + // If the localized messages json is unset, and if given function use it to set the json + function maybeSetLocalizedDiagnosticMessages(getMessages) { + if (!localizedDiagnosticMessages && getMessages) { + localizedDiagnosticMessages = getMessages(); + } + } + ts.maybeSetLocalizedDiagnosticMessages = maybeSetLocalizedDiagnosticMessages; + function getLocaleSpecificMessage(message) { + return localizedDiagnosticMessages && localizedDiagnosticMessages[message.key] || message.message; + } + ts.getLocaleSpecificMessage = getLocaleSpecificMessage; + function createDetachedDiagnostic(fileName, start, length, message) { + assertDiagnosticLocation(/*file*/ undefined, start, length); + var text = getLocaleSpecificMessage(message); + if (arguments.length > 4) { + text = formatStringFromArgs(text, arguments, 4); + } + return { + file: undefined, + start: start, + length: length, + messageText: text, + category: message.category, + code: message.code, + reportsUnnecessary: message.reportsUnnecessary, + fileName: fileName, + }; + } + ts.createDetachedDiagnostic = createDetachedDiagnostic; + function isDiagnosticWithDetachedLocation(diagnostic) { + return diagnostic.file === undefined + && diagnostic.start !== undefined + && diagnostic.length !== undefined + && typeof diagnostic.fileName === "string"; + } + function attachFileToDiagnostic(diagnostic, file) { + var fileName = file.fileName || ""; + var length = file.text.length; + ts.Debug.assertEqual(diagnostic.fileName, fileName); + ts.Debug.assertLessThanOrEqual(diagnostic.start, length); + ts.Debug.assertLessThanOrEqual(diagnostic.start + diagnostic.length, length); + var diagnosticWithLocation = { + file: file, + start: diagnostic.start, + length: diagnostic.length, + messageText: diagnostic.messageText, + category: diagnostic.category, + code: diagnostic.code, + reportsUnnecessary: diagnostic.reportsUnnecessary + }; + if (diagnostic.relatedInformation) { + diagnosticWithLocation.relatedInformation = []; + for (var _i = 0, _a = diagnostic.relatedInformation; _i < _a.length; _i++) { + var related = _a[_i]; + if (isDiagnosticWithDetachedLocation(related) && related.fileName === fileName) { + ts.Debug.assertLessThanOrEqual(related.start, length); + ts.Debug.assertLessThanOrEqual(related.start + related.length, length); + diagnosticWithLocation.relatedInformation.push(attachFileToDiagnostic(related, file)); + } + else { + diagnosticWithLocation.relatedInformation.push(related); + } + } + } + return diagnosticWithLocation; + } + function attachFileToDiagnostics(diagnostics, file) { + var diagnosticsWithLocation = []; + for (var _i = 0, diagnostics_1 = diagnostics; _i < diagnostics_1.length; _i++) { + var diagnostic = diagnostics_1[_i]; + diagnosticsWithLocation.push(attachFileToDiagnostic(diagnostic, file)); + } + return diagnosticsWithLocation; + } + ts.attachFileToDiagnostics = attachFileToDiagnostics; + function createFileDiagnostic(file, start, length, message) { + assertDiagnosticLocation(file, start, length); + var text = getLocaleSpecificMessage(message); + if (arguments.length > 4) { + text = formatStringFromArgs(text, arguments, 4); + } + return { + file: file, + start: start, + length: length, + messageText: text, + category: message.category, + code: message.code, + reportsUnnecessary: message.reportsUnnecessary, + reportsDeprecated: message.reportsDeprecated + }; + } + ts.createFileDiagnostic = createFileDiagnostic; + function formatMessage(_dummy, message) { + var text = getLocaleSpecificMessage(message); + if (arguments.length > 2) { + text = formatStringFromArgs(text, arguments, 2); + } + return text; + } + ts.formatMessage = formatMessage; + function createCompilerDiagnostic(message) { + var text = getLocaleSpecificMessage(message); + if (arguments.length > 1) { + text = formatStringFromArgs(text, arguments, 1); + } + return { + file: undefined, + start: undefined, + length: undefined, + messageText: text, + category: message.category, + code: message.code, + reportsUnnecessary: message.reportsUnnecessary, + reportsDeprecated: message.reportsDeprecated + }; + } + ts.createCompilerDiagnostic = createCompilerDiagnostic; + function createCompilerDiagnosticFromMessageChain(chain, relatedInformation) { + return { + file: undefined, + start: undefined, + length: undefined, + code: chain.code, + category: chain.category, + messageText: chain.next ? chain : chain.messageText, + relatedInformation: relatedInformation + }; + } + ts.createCompilerDiagnosticFromMessageChain = createCompilerDiagnosticFromMessageChain; + function chainDiagnosticMessages(details, message) { + var text = getLocaleSpecificMessage(message); + if (arguments.length > 2) { + text = formatStringFromArgs(text, arguments, 2); + } + return { + messageText: text, + category: message.category, + code: message.code, + next: details === undefined || Array.isArray(details) ? details : [details] + }; + } + ts.chainDiagnosticMessages = chainDiagnosticMessages; + function concatenateDiagnosticMessageChains(headChain, tailChain) { + var lastChain = headChain; + while (lastChain.next) { + lastChain = lastChain.next[0]; + } + lastChain.next = [tailChain]; + } + ts.concatenateDiagnosticMessageChains = concatenateDiagnosticMessageChains; + function getDiagnosticFilePath(diagnostic) { + return diagnostic.file ? diagnostic.file.path : undefined; + } + function compareDiagnostics(d1, d2) { + return compareDiagnosticsSkipRelatedInformation(d1, d2) || + compareRelatedInformation(d1, d2) || + 0 /* Comparison.EqualTo */; + } + ts.compareDiagnostics = compareDiagnostics; + function compareDiagnosticsSkipRelatedInformation(d1, d2) { + return ts.compareStringsCaseSensitive(getDiagnosticFilePath(d1), getDiagnosticFilePath(d2)) || + ts.compareValues(d1.start, d2.start) || + ts.compareValues(d1.length, d2.length) || + ts.compareValues(d1.code, d2.code) || + compareMessageText(d1.messageText, d2.messageText) || + 0 /* Comparison.EqualTo */; + } + ts.compareDiagnosticsSkipRelatedInformation = compareDiagnosticsSkipRelatedInformation; + function compareRelatedInformation(d1, d2) { + if (!d1.relatedInformation && !d2.relatedInformation) { + return 0 /* Comparison.EqualTo */; + } + if (d1.relatedInformation && d2.relatedInformation) { + return ts.compareValues(d1.relatedInformation.length, d2.relatedInformation.length) || ts.forEach(d1.relatedInformation, function (d1i, index) { + var d2i = d2.relatedInformation[index]; + return compareDiagnostics(d1i, d2i); // EqualTo is 0, so falsy, and will cause the next item to be compared + }) || 0 /* Comparison.EqualTo */; + } + return d1.relatedInformation ? -1 /* Comparison.LessThan */ : 1 /* Comparison.GreaterThan */; + } + function compareMessageText(t1, t2) { + if (typeof t1 === "string" && typeof t2 === "string") { + return ts.compareStringsCaseSensitive(t1, t2); + } + else if (typeof t1 === "string") { + return -1 /* Comparison.LessThan */; + } + else if (typeof t2 === "string") { + return 1 /* Comparison.GreaterThan */; + } + var res = ts.compareStringsCaseSensitive(t1.messageText, t2.messageText); + if (res) { + return res; + } + if (!t1.next && !t2.next) { + return 0 /* Comparison.EqualTo */; + } + if (!t1.next) { + return -1 /* Comparison.LessThan */; + } + if (!t2.next) { + return 1 /* Comparison.GreaterThan */; + } + var len = Math.min(t1.next.length, t2.next.length); + for (var i = 0; i < len; i++) { + res = compareMessageText(t1.next[i], t2.next[i]); + if (res) { + return res; + } + } + if (t1.next.length < t2.next.length) { + return -1 /* Comparison.LessThan */; + } + else if (t1.next.length > t2.next.length) { + return 1 /* Comparison.GreaterThan */; + } + return 0 /* Comparison.EqualTo */; + } + function getLanguageVariant(scriptKind) { + // .tsx and .jsx files are treated as jsx language variant. + return scriptKind === 4 /* ScriptKind.TSX */ || scriptKind === 2 /* ScriptKind.JSX */ || scriptKind === 1 /* ScriptKind.JS */ || scriptKind === 6 /* ScriptKind.JSON */ ? 1 /* LanguageVariant.JSX */ : 0 /* LanguageVariant.Standard */; + } + ts.getLanguageVariant = getLanguageVariant; + /** + * This is a somewhat unavoidable full tree walk to locate a JSX tag - `import.meta` requires the same, + * but we avoid that walk (or parts of it) if at all possible using the `PossiblyContainsImportMeta` node flag. + * Unfortunately, there's no `NodeFlag` space to do the same for JSX. + */ + function walkTreeForJSXTags(node) { + if (!(node.transformFlags & 2 /* TransformFlags.ContainsJsx */)) + return undefined; + return ts.isJsxOpeningLikeElement(node) || ts.isJsxFragment(node) ? node : ts.forEachChild(node, walkTreeForJSXTags); + } + function isFileModuleFromUsingJSXTag(file) { + // Excludes declaration files - they still require an explicit `export {}` or the like + // for back compat purposes. (not that declaration files should contain JSX tags!) + return !file.isDeclarationFile ? walkTreeForJSXTags(file) : undefined; + } + /** + * Note that this requires file.impliedNodeFormat be set already; meaning it must be set very early on + * in SourceFile construction. + */ + function isFileForcedToBeModuleByFormat(file) { + // Excludes declaration files - they still require an explicit `export {}` or the like + // for back compat purposes. The only non-declaration files _not_ forced to be a module are `.js` files + // that aren't esm-mode (meaning not in a `type: module` scope). + return (file.impliedNodeFormat === ts.ModuleKind.ESNext || (ts.fileExtensionIsOneOf(file.fileName, [".cjs" /* Extension.Cjs */, ".cts" /* Extension.Cts */, ".mjs" /* Extension.Mjs */, ".mts" /* Extension.Mts */]))) && !file.isDeclarationFile ? true : undefined; + } + function getSetExternalModuleIndicator(options) { + // TODO: Should this callback be cached? + switch (getEmitModuleDetectionKind(options)) { + case ts.ModuleDetectionKind.Force: + // All non-declaration files are modules, declaration files still do the usual isFileProbablyExternalModule + return function (file) { + file.externalModuleIndicator = ts.isFileProbablyExternalModule(file) || !file.isDeclarationFile || undefined; + }; + case ts.ModuleDetectionKind.Legacy: + // Files are modules if they have imports, exports, or import.meta + return function (file) { + file.externalModuleIndicator = ts.isFileProbablyExternalModule(file); + }; + case ts.ModuleDetectionKind.Auto: + // If module is nodenext or node16, all esm format files are modules + // If jsx is react-jsx or react-jsxdev then jsx tags force module-ness + // otherwise, the presence of import or export statments (or import.meta) implies module-ness + var checks = [ts.isFileProbablyExternalModule]; + if (options.jsx === 4 /* JsxEmit.ReactJSX */ || options.jsx === 5 /* JsxEmit.ReactJSXDev */) { + checks.push(isFileModuleFromUsingJSXTag); + } + checks.push(isFileForcedToBeModuleByFormat); + var combined_1 = ts.or.apply(void 0, checks); + var callback = function (file) { return void (file.externalModuleIndicator = combined_1(file)); }; + return callback; + } + } + ts.getSetExternalModuleIndicator = getSetExternalModuleIndicator; + function getEmitScriptTarget(compilerOptions) { + return compilerOptions.target || + (compilerOptions.module === ts.ModuleKind.Node16 && 9 /* ScriptTarget.ES2022 */) || + (compilerOptions.module === ts.ModuleKind.NodeNext && 99 /* ScriptTarget.ESNext */) || + 0 /* ScriptTarget.ES3 */; + } + ts.getEmitScriptTarget = getEmitScriptTarget; + function getEmitModuleKind(compilerOptions) { + return typeof compilerOptions.module === "number" ? + compilerOptions.module : + getEmitScriptTarget(compilerOptions) >= 2 /* ScriptTarget.ES2015 */ ? ts.ModuleKind.ES2015 : ts.ModuleKind.CommonJS; + } + ts.getEmitModuleKind = getEmitModuleKind; + function getEmitModuleResolutionKind(compilerOptions) { + var moduleResolution = compilerOptions.moduleResolution; + if (moduleResolution === undefined) { + switch (getEmitModuleKind(compilerOptions)) { + case ts.ModuleKind.CommonJS: + moduleResolution = ts.ModuleResolutionKind.NodeJs; + break; + case ts.ModuleKind.Node16: + moduleResolution = ts.ModuleResolutionKind.Node16; + break; + case ts.ModuleKind.NodeNext: + moduleResolution = ts.ModuleResolutionKind.NodeNext; + break; + default: + moduleResolution = ts.ModuleResolutionKind.Classic; + break; + } + } + return moduleResolution; + } + ts.getEmitModuleResolutionKind = getEmitModuleResolutionKind; + function getEmitModuleDetectionKind(options) { + return options.moduleDetection || + (getEmitModuleKind(options) === ts.ModuleKind.Node16 || getEmitModuleKind(options) === ts.ModuleKind.NodeNext ? ts.ModuleDetectionKind.Force : ts.ModuleDetectionKind.Auto); + } + ts.getEmitModuleDetectionKind = getEmitModuleDetectionKind; + function hasJsonModuleEmitEnabled(options) { + switch (getEmitModuleKind(options)) { + case ts.ModuleKind.CommonJS: + case ts.ModuleKind.AMD: + case ts.ModuleKind.ES2015: + case ts.ModuleKind.ES2020: + case ts.ModuleKind.ES2022: + case ts.ModuleKind.ESNext: + case ts.ModuleKind.Node16: + case ts.ModuleKind.NodeNext: + return true; + default: + return false; + } + } + ts.hasJsonModuleEmitEnabled = hasJsonModuleEmitEnabled; + function unreachableCodeIsError(options) { + return options.allowUnreachableCode === false; + } + ts.unreachableCodeIsError = unreachableCodeIsError; + function unusedLabelIsError(options) { + return options.allowUnusedLabels === false; + } + ts.unusedLabelIsError = unusedLabelIsError; + function getAreDeclarationMapsEnabled(options) { + return !!(getEmitDeclarations(options) && options.declarationMap); + } + ts.getAreDeclarationMapsEnabled = getAreDeclarationMapsEnabled; + function getESModuleInterop(compilerOptions) { + if (compilerOptions.esModuleInterop !== undefined) { + return compilerOptions.esModuleInterop; + } + switch (getEmitModuleKind(compilerOptions)) { + case ts.ModuleKind.Node16: + case ts.ModuleKind.NodeNext: + return true; + } + return undefined; + } + ts.getESModuleInterop = getESModuleInterop; + function getAllowSyntheticDefaultImports(compilerOptions) { + var moduleKind = getEmitModuleKind(compilerOptions); + return compilerOptions.allowSyntheticDefaultImports !== undefined + ? compilerOptions.allowSyntheticDefaultImports + : getESModuleInterop(compilerOptions) || + moduleKind === ts.ModuleKind.System; + } + ts.getAllowSyntheticDefaultImports = getAllowSyntheticDefaultImports; + function getEmitDeclarations(compilerOptions) { + return !!(compilerOptions.declaration || compilerOptions.composite); + } + ts.getEmitDeclarations = getEmitDeclarations; + function shouldPreserveConstEnums(compilerOptions) { + return !!(compilerOptions.preserveConstEnums || compilerOptions.isolatedModules); + } + ts.shouldPreserveConstEnums = shouldPreserveConstEnums; + function isIncrementalCompilation(options) { + return !!(options.incremental || options.composite); + } + ts.isIncrementalCompilation = isIncrementalCompilation; + function getStrictOptionValue(compilerOptions, flag) { + return compilerOptions[flag] === undefined ? !!compilerOptions.strict : !!compilerOptions[flag]; + } + ts.getStrictOptionValue = getStrictOptionValue; + function getAllowJSCompilerOption(compilerOptions) { + return compilerOptions.allowJs === undefined ? !!compilerOptions.checkJs : compilerOptions.allowJs; + } + ts.getAllowJSCompilerOption = getAllowJSCompilerOption; + function getUseDefineForClassFields(compilerOptions) { + return compilerOptions.useDefineForClassFields === undefined ? getEmitScriptTarget(compilerOptions) >= 9 /* ScriptTarget.ES2022 */ : compilerOptions.useDefineForClassFields; + } + ts.getUseDefineForClassFields = getUseDefineForClassFields; + function compilerOptionsAffectSemanticDiagnostics(newOptions, oldOptions) { + return optionsHaveChanges(oldOptions, newOptions, ts.semanticDiagnosticsOptionDeclarations); + } + ts.compilerOptionsAffectSemanticDiagnostics = compilerOptionsAffectSemanticDiagnostics; + function compilerOptionsAffectEmit(newOptions, oldOptions) { + return optionsHaveChanges(oldOptions, newOptions, ts.affectsEmitOptionDeclarations); + } + ts.compilerOptionsAffectEmit = compilerOptionsAffectEmit; + function compilerOptionsAffectDeclarationPath(newOptions, oldOptions) { + return optionsHaveChanges(oldOptions, newOptions, ts.affectsDeclarationPathOptionDeclarations); + } + ts.compilerOptionsAffectDeclarationPath = compilerOptionsAffectDeclarationPath; + function getCompilerOptionValue(options, option) { + return option.strictFlag ? getStrictOptionValue(options, option.name) : options[option.name]; + } + ts.getCompilerOptionValue = getCompilerOptionValue; + function getJSXTransformEnabled(options) { + var jsx = options.jsx; + return jsx === 2 /* JsxEmit.React */ || jsx === 4 /* JsxEmit.ReactJSX */ || jsx === 5 /* JsxEmit.ReactJSXDev */; + } + ts.getJSXTransformEnabled = getJSXTransformEnabled; + function getJSXImplicitImportBase(compilerOptions, file) { + var jsxImportSourcePragmas = file === null || file === void 0 ? void 0 : file.pragmas.get("jsximportsource"); + var jsxImportSourcePragma = ts.isArray(jsxImportSourcePragmas) ? jsxImportSourcePragmas[jsxImportSourcePragmas.length - 1] : jsxImportSourcePragmas; + return compilerOptions.jsx === 4 /* JsxEmit.ReactJSX */ || + compilerOptions.jsx === 5 /* JsxEmit.ReactJSXDev */ || + compilerOptions.jsxImportSource || + jsxImportSourcePragma ? + (jsxImportSourcePragma === null || jsxImportSourcePragma === void 0 ? void 0 : jsxImportSourcePragma.arguments.factory) || compilerOptions.jsxImportSource || "react" : + undefined; + } + ts.getJSXImplicitImportBase = getJSXImplicitImportBase; + function getJSXRuntimeImport(base, options) { + return base ? "".concat(base, "/").concat(options.jsx === 5 /* JsxEmit.ReactJSXDev */ ? "jsx-dev-runtime" : "jsx-runtime") : undefined; + } + ts.getJSXRuntimeImport = getJSXRuntimeImport; + function hasZeroOrOneAsteriskCharacter(str) { + var seenAsterisk = false; + for (var i = 0; i < str.length; i++) { + if (str.charCodeAt(i) === 42 /* CharacterCodes.asterisk */) { + if (!seenAsterisk) { + seenAsterisk = true; + } + else { + // have already seen asterisk + return false; + } + } + } + return true; + } + ts.hasZeroOrOneAsteriskCharacter = hasZeroOrOneAsteriskCharacter; + function createSymlinkCache(cwd, getCanonicalFileName) { + var symlinkedDirectories; + var symlinkedDirectoriesByRealpath; + var symlinkedFiles; + var hasProcessedResolutions = false; + return { + getSymlinkedFiles: function () { return symlinkedFiles; }, + getSymlinkedDirectories: function () { return symlinkedDirectories; }, + getSymlinkedDirectoriesByRealpath: function () { return symlinkedDirectoriesByRealpath; }, + setSymlinkedFile: function (path, real) { return (symlinkedFiles || (symlinkedFiles = new ts.Map())).set(path, real); }, + setSymlinkedDirectory: function (symlink, real) { + // Large, interconnected dependency graphs in pnpm will have a huge number of symlinks + // where both the realpath and the symlink path are inside node_modules/.pnpm. Since + // this path is never a candidate for a module specifier, we can ignore it entirely. + var symlinkPath = ts.toPath(symlink, cwd, getCanonicalFileName); + if (!containsIgnoredPath(symlinkPath)) { + symlinkPath = ts.ensureTrailingDirectorySeparator(symlinkPath); + if (real !== false && !(symlinkedDirectories === null || symlinkedDirectories === void 0 ? void 0 : symlinkedDirectories.has(symlinkPath))) { + (symlinkedDirectoriesByRealpath || (symlinkedDirectoriesByRealpath = ts.createMultiMap())).add(ts.ensureTrailingDirectorySeparator(real.realPath), symlink); + } + (symlinkedDirectories || (symlinkedDirectories = new ts.Map())).set(symlinkPath, real); + } + }, + setSymlinksFromResolutions: function (files, typeReferenceDirectives) { + var _this = this; + var _a; + ts.Debug.assert(!hasProcessedResolutions); + hasProcessedResolutions = true; + for (var _i = 0, files_1 = files; _i < files_1.length; _i++) { + var file = files_1[_i]; + (_a = file.resolvedModules) === null || _a === void 0 ? void 0 : _a.forEach(function (resolution) { return processResolution(_this, resolution); }); + } + typeReferenceDirectives === null || typeReferenceDirectives === void 0 ? void 0 : typeReferenceDirectives.forEach(function (resolution) { return processResolution(_this, resolution); }); + }, + hasProcessedResolutions: function () { return hasProcessedResolutions; }, + }; + function processResolution(cache, resolution) { + if (!resolution || !resolution.originalPath || !resolution.resolvedFileName) + return; + var resolvedFileName = resolution.resolvedFileName, originalPath = resolution.originalPath; + cache.setSymlinkedFile(ts.toPath(originalPath, cwd, getCanonicalFileName), resolvedFileName); + var _a = guessDirectorySymlink(resolvedFileName, originalPath, cwd, getCanonicalFileName) || ts.emptyArray, commonResolved = _a[0], commonOriginal = _a[1]; + if (commonResolved && commonOriginal) { + cache.setSymlinkedDirectory(commonOriginal, { real: commonResolved, realPath: ts.toPath(commonResolved, cwd, getCanonicalFileName) }); + } + } + } + ts.createSymlinkCache = createSymlinkCache; + function guessDirectorySymlink(a, b, cwd, getCanonicalFileName) { + var aParts = ts.getPathComponents(ts.getNormalizedAbsolutePath(a, cwd)); + var bParts = ts.getPathComponents(ts.getNormalizedAbsolutePath(b, cwd)); + var isDirectory = false; + while (aParts.length >= 2 && bParts.length >= 2 && + !isNodeModulesOrScopedPackageDirectory(aParts[aParts.length - 2], getCanonicalFileName) && + !isNodeModulesOrScopedPackageDirectory(bParts[bParts.length - 2], getCanonicalFileName) && + getCanonicalFileName(aParts[aParts.length - 1]) === getCanonicalFileName(bParts[bParts.length - 1])) { + aParts.pop(); + bParts.pop(); + isDirectory = true; + } + return isDirectory ? [ts.getPathFromPathComponents(aParts), ts.getPathFromPathComponents(bParts)] : undefined; + } + // KLUDGE: Don't assume one 'node_modules' links to another. More likely a single directory inside the node_modules is the symlink. + // ALso, don't assume that an `@foo` directory is linked. More likely the contents of that are linked. + function isNodeModulesOrScopedPackageDirectory(s, getCanonicalFileName) { + return s !== undefined && (getCanonicalFileName(s) === "node_modules" || ts.startsWith(s, "@")); + } + function stripLeadingDirectorySeparator(s) { + return ts.isAnyDirectorySeparator(s.charCodeAt(0)) ? s.slice(1) : undefined; + } + function tryRemoveDirectoryPrefix(path, dirPath, getCanonicalFileName) { + var withoutPrefix = ts.tryRemovePrefix(path, dirPath, getCanonicalFileName); + return withoutPrefix === undefined ? undefined : stripLeadingDirectorySeparator(withoutPrefix); + } + ts.tryRemoveDirectoryPrefix = tryRemoveDirectoryPrefix; + // Reserved characters, forces escaping of any non-word (or digit), non-whitespace character. + // It may be inefficient (we could just match (/[-[\]{}()*+?.,\\^$|#\s]/g), but this is future + // proof. + var reservedCharacterPattern = /[^\w\s\/]/g; + function regExpEscape(text) { + return text.replace(reservedCharacterPattern, escapeRegExpCharacter); + } + ts.regExpEscape = regExpEscape; + function escapeRegExpCharacter(match) { + return "\\" + match; + } + var wildcardCharCodes = [42 /* CharacterCodes.asterisk */, 63 /* CharacterCodes.question */]; + ts.commonPackageFolders = ["node_modules", "bower_components", "jspm_packages"]; + var implicitExcludePathRegexPattern = "(?!(".concat(ts.commonPackageFolders.join("|"), ")(/|$))"); + var filesMatcher = { + /** + * Matches any single directory segment unless it is the last segment and a .min.js file + * Breakdown: + * [^./] # matches everything up to the first . character (excluding directory separators) + * (\\.(?!min\\.js$))? # matches . characters but not if they are part of the .min.js file extension + */ + singleAsteriskRegexFragment: "([^./]|(\\.(?!min\\.js$))?)*", + /** + * Regex for the ** wildcard. Matches any number of subdirectories. When used for including + * files or directories, does not match subdirectories that start with a . character + */ + doubleAsteriskRegexFragment: "(/".concat(implicitExcludePathRegexPattern, "[^/.][^/]*)*?"), + replaceWildcardCharacter: function (match) { return replaceWildcardCharacter(match, filesMatcher.singleAsteriskRegexFragment); } + }; + var directoriesMatcher = { + singleAsteriskRegexFragment: "[^/]*", + /** + * Regex for the ** wildcard. Matches any number of subdirectories. When used for including + * files or directories, does not match subdirectories that start with a . character + */ + doubleAsteriskRegexFragment: "(/".concat(implicitExcludePathRegexPattern, "[^/.][^/]*)*?"), + replaceWildcardCharacter: function (match) { return replaceWildcardCharacter(match, directoriesMatcher.singleAsteriskRegexFragment); } + }; + var excludeMatcher = { + singleAsteriskRegexFragment: "[^/]*", + doubleAsteriskRegexFragment: "(/.+?)?", + replaceWildcardCharacter: function (match) { return replaceWildcardCharacter(match, excludeMatcher.singleAsteriskRegexFragment); } + }; + var wildcardMatchers = { + files: filesMatcher, + directories: directoriesMatcher, + exclude: excludeMatcher + }; + function getRegularExpressionForWildcard(specs, basePath, usage) { + var patterns = getRegularExpressionsForWildcards(specs, basePath, usage); + if (!patterns || !patterns.length) { + return undefined; + } + var pattern = patterns.map(function (pattern) { return "(".concat(pattern, ")"); }).join("|"); + // If excluding, match "foo/bar/baz...", but if including, only allow "foo". + var terminator = usage === "exclude" ? "($|/)" : "$"; + return "^(".concat(pattern, ")").concat(terminator); + } + ts.getRegularExpressionForWildcard = getRegularExpressionForWildcard; + function getRegularExpressionsForWildcards(specs, basePath, usage) { + if (specs === undefined || specs.length === 0) { + return undefined; + } + return ts.flatMap(specs, function (spec) { + return spec && getSubPatternFromSpec(spec, basePath, usage, wildcardMatchers[usage]); + }); + } + ts.getRegularExpressionsForWildcards = getRegularExpressionsForWildcards; + /** + * An "includes" path "foo" is implicitly a glob "foo/** /*" (without the space) if its last component has no extension, + * and does not contain any glob characters itself. + */ + function isImplicitGlob(lastPathComponent) { + return !/[.*?]/.test(lastPathComponent); + } + ts.isImplicitGlob = isImplicitGlob; + function getPatternFromSpec(spec, basePath, usage) { + var pattern = spec && getSubPatternFromSpec(spec, basePath, usage, wildcardMatchers[usage]); + return pattern && "^(".concat(pattern, ")").concat(usage === "exclude" ? "($|/)" : "$"); + } + ts.getPatternFromSpec = getPatternFromSpec; + function getSubPatternFromSpec(spec, basePath, usage, _a) { + var singleAsteriskRegexFragment = _a.singleAsteriskRegexFragment, doubleAsteriskRegexFragment = _a.doubleAsteriskRegexFragment, replaceWildcardCharacter = _a.replaceWildcardCharacter; + var subpattern = ""; + var hasWrittenComponent = false; + var components = ts.getNormalizedPathComponents(spec, basePath); + var lastComponent = ts.last(components); + if (usage !== "exclude" && lastComponent === "**") { + return undefined; + } + // getNormalizedPathComponents includes the separator for the root component. + // We need to remove to create our regex correctly. + components[0] = ts.removeTrailingDirectorySeparator(components[0]); + if (isImplicitGlob(lastComponent)) { + components.push("**", "*"); + } + var optionalCount = 0; + for (var _i = 0, components_1 = components; _i < components_1.length; _i++) { + var component = components_1[_i]; + if (component === "**") { + subpattern += doubleAsteriskRegexFragment; + } + else { + if (usage === "directories") { + subpattern += "("; + optionalCount++; + } + if (hasWrittenComponent) { + subpattern += ts.directorySeparator; + } + if (usage !== "exclude") { + var componentPattern = ""; + // The * and ? wildcards should not match directories or files that start with . if they + // appear first in a component. Dotted directories and files can be included explicitly + // like so: **/.*/.* + if (component.charCodeAt(0) === 42 /* CharacterCodes.asterisk */) { + componentPattern += "([^./]" + singleAsteriskRegexFragment + ")?"; + component = component.substr(1); + } + else if (component.charCodeAt(0) === 63 /* CharacterCodes.question */) { + componentPattern += "[^./]"; + component = component.substr(1); + } + componentPattern += component.replace(reservedCharacterPattern, replaceWildcardCharacter); + // Patterns should not include subfolders like node_modules unless they are + // explicitly included as part of the path. + // + // As an optimization, if the component pattern is the same as the component, + // then there definitely were no wildcard characters and we do not need to + // add the exclusion pattern. + if (componentPattern !== component) { + subpattern += implicitExcludePathRegexPattern; + } + subpattern += componentPattern; + } + else { + subpattern += component.replace(reservedCharacterPattern, replaceWildcardCharacter); + } + } + hasWrittenComponent = true; + } + while (optionalCount > 0) { + subpattern += ")?"; + optionalCount--; + } + return subpattern; + } + function replaceWildcardCharacter(match, singleAsteriskRegexFragment) { + return match === "*" ? singleAsteriskRegexFragment : match === "?" ? "[^/]" : "\\" + match; + } + /** @param path directory of the tsconfig.json */ + function getFileMatcherPatterns(path, excludes, includes, useCaseSensitiveFileNames, currentDirectory) { + path = ts.normalizePath(path); + currentDirectory = ts.normalizePath(currentDirectory); + var absolutePath = ts.combinePaths(currentDirectory, path); + return { + includeFilePatterns: ts.map(getRegularExpressionsForWildcards(includes, absolutePath, "files"), function (pattern) { return "^".concat(pattern, "$"); }), + includeFilePattern: getRegularExpressionForWildcard(includes, absolutePath, "files"), + includeDirectoryPattern: getRegularExpressionForWildcard(includes, absolutePath, "directories"), + excludePattern: getRegularExpressionForWildcard(excludes, absolutePath, "exclude"), + basePaths: getBasePaths(path, includes, useCaseSensitiveFileNames) + }; + } + ts.getFileMatcherPatterns = getFileMatcherPatterns; + function getRegexFromPattern(pattern, useCaseSensitiveFileNames) { + return new RegExp(pattern, useCaseSensitiveFileNames ? "" : "i"); + } + ts.getRegexFromPattern = getRegexFromPattern; + /** @param path directory of the tsconfig.json */ + function matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames, currentDirectory, depth, getFileSystemEntries, realpath) { + path = ts.normalizePath(path); + currentDirectory = ts.normalizePath(currentDirectory); + var patterns = getFileMatcherPatterns(path, excludes, includes, useCaseSensitiveFileNames, currentDirectory); + var includeFileRegexes = patterns.includeFilePatterns && patterns.includeFilePatterns.map(function (pattern) { return getRegexFromPattern(pattern, useCaseSensitiveFileNames); }); + var includeDirectoryRegex = patterns.includeDirectoryPattern && getRegexFromPattern(patterns.includeDirectoryPattern, useCaseSensitiveFileNames); + var excludeRegex = patterns.excludePattern && getRegexFromPattern(patterns.excludePattern, useCaseSensitiveFileNames); + // Associate an array of results with each include regex. This keeps results in order of the "include" order. + // If there are no "includes", then just put everything in results[0]. + var results = includeFileRegexes ? includeFileRegexes.map(function () { return []; }) : [[]]; + var visited = new ts.Map(); + var toCanonical = ts.createGetCanonicalFileName(useCaseSensitiveFileNames); + for (var _i = 0, _a = patterns.basePaths; _i < _a.length; _i++) { + var basePath = _a[_i]; + visitDirectory(basePath, ts.combinePaths(currentDirectory, basePath), depth); + } + return ts.flatten(results); + function visitDirectory(path, absolutePath, depth) { + var canonicalPath = toCanonical(realpath(absolutePath)); + if (visited.has(canonicalPath)) + return; + visited.set(canonicalPath, true); + var _a = getFileSystemEntries(path), files = _a.files, directories = _a.directories; + var _loop_1 = function (current) { + var name = ts.combinePaths(path, current); + var absoluteName = ts.combinePaths(absolutePath, current); + if (extensions && !ts.fileExtensionIsOneOf(name, extensions)) + return "continue"; + if (excludeRegex && excludeRegex.test(absoluteName)) + return "continue"; + if (!includeFileRegexes) { + results[0].push(name); + } + else { + var includeIndex = ts.findIndex(includeFileRegexes, function (re) { return re.test(absoluteName); }); + if (includeIndex !== -1) { + results[includeIndex].push(name); + } + } + }; + for (var _i = 0, _b = ts.sort(files, ts.compareStringsCaseSensitive); _i < _b.length; _i++) { + var current = _b[_i]; + _loop_1(current); + } + if (depth !== undefined) { + depth--; + if (depth === 0) { + return; + } + } + for (var _c = 0, _d = ts.sort(directories, ts.compareStringsCaseSensitive); _c < _d.length; _c++) { + var current = _d[_c]; + var name = ts.combinePaths(path, current); + var absoluteName = ts.combinePaths(absolutePath, current); + if ((!includeDirectoryRegex || includeDirectoryRegex.test(absoluteName)) && + (!excludeRegex || !excludeRegex.test(absoluteName))) { + visitDirectory(name, absoluteName, depth); + } + } + } + } + ts.matchFiles = matchFiles; + /** + * Computes the unique non-wildcard base paths amongst the provided include patterns. + */ + function getBasePaths(path, includes, useCaseSensitiveFileNames) { + // Storage for our results in the form of literal paths (e.g. the paths as written by the user). + var basePaths = [path]; + if (includes) { + // Storage for literal base paths amongst the include patterns. + var includeBasePaths = []; + for (var _i = 0, includes_1 = includes; _i < includes_1.length; _i++) { + var include = includes_1[_i]; + // We also need to check the relative paths by converting them to absolute and normalizing + // in case they escape the base path (e.g "..\somedirectory") + var absolute = ts.isRootedDiskPath(include) ? include : ts.normalizePath(ts.combinePaths(path, include)); + // Append the literal and canonical candidate base paths. + includeBasePaths.push(getIncludeBasePath(absolute)); + } + // Sort the offsets array using either the literal or canonical path representations. + includeBasePaths.sort(ts.getStringComparer(!useCaseSensitiveFileNames)); + var _loop_2 = function (includeBasePath) { + if (ts.every(basePaths, function (basePath) { return !ts.containsPath(basePath, includeBasePath, path, !useCaseSensitiveFileNames); })) { + basePaths.push(includeBasePath); + } + }; + // Iterate over each include base path and include unique base paths that are not a + // subpath of an existing base path + for (var _a = 0, includeBasePaths_1 = includeBasePaths; _a < includeBasePaths_1.length; _a++) { + var includeBasePath = includeBasePaths_1[_a]; + _loop_2(includeBasePath); + } + } + return basePaths; + } + function getIncludeBasePath(absolute) { + var wildcardOffset = ts.indexOfAnyCharCode(absolute, wildcardCharCodes); + if (wildcardOffset < 0) { + // No "*" or "?" in the path + return !ts.hasExtension(absolute) + ? absolute + : ts.removeTrailingDirectorySeparator(ts.getDirectoryPath(absolute)); + } + return absolute.substring(0, absolute.lastIndexOf(ts.directorySeparator, wildcardOffset)); + } + function ensureScriptKind(fileName, scriptKind) { + // Using scriptKind as a condition handles both: + // - 'scriptKind' is unspecified and thus it is `undefined` + // - 'scriptKind' is set and it is `Unknown` (0) + // If the 'scriptKind' is 'undefined' or 'Unknown' then we attempt + // to get the ScriptKind from the file name. If it cannot be resolved + // from the file name then the default 'TS' script kind is returned. + return scriptKind || getScriptKindFromFileName(fileName) || 3 /* ScriptKind.TS */; + } + ts.ensureScriptKind = ensureScriptKind; + function getScriptKindFromFileName(fileName) { + var ext = fileName.substr(fileName.lastIndexOf(".")); + switch (ext.toLowerCase()) { + case ".js" /* Extension.Js */: + case ".cjs" /* Extension.Cjs */: + case ".mjs" /* Extension.Mjs */: + return 1 /* ScriptKind.JS */; + case ".jsx" /* Extension.Jsx */: + return 2 /* ScriptKind.JSX */; + case ".ts" /* Extension.Ts */: + case ".cts" /* Extension.Cts */: + case ".mts" /* Extension.Mts */: + return 3 /* ScriptKind.TS */; + case ".tsx" /* Extension.Tsx */: + return 4 /* ScriptKind.TSX */; + case ".json" /* Extension.Json */: + return 6 /* ScriptKind.JSON */; + default: + return 0 /* ScriptKind.Unknown */; + } + } + ts.getScriptKindFromFileName = getScriptKindFromFileName; + /** + * Groups of supported extensions in order of file resolution precedence. (eg, TS > TSX > DTS and seperately, CTS > DCTS) + */ + ts.supportedTSExtensions = [[".ts" /* Extension.Ts */, ".tsx" /* Extension.Tsx */, ".d.ts" /* Extension.Dts */], [".cts" /* Extension.Cts */, ".d.cts" /* Extension.Dcts */], [".mts" /* Extension.Mts */, ".d.mts" /* Extension.Dmts */]]; + ts.supportedTSExtensionsFlat = ts.flatten(ts.supportedTSExtensions); + var supportedTSExtensionsWithJson = __spreadArray(__spreadArray([], ts.supportedTSExtensions, true), [[".json" /* Extension.Json */]], false); + /** Must have ".d.ts" first because if ".ts" goes first, that will be detected as the extension instead of ".d.ts". */ + var supportedTSExtensionsForExtractExtension = [".d.ts" /* Extension.Dts */, ".d.cts" /* Extension.Dcts */, ".d.mts" /* Extension.Dmts */, ".cts" /* Extension.Cts */, ".mts" /* Extension.Mts */, ".ts" /* Extension.Ts */, ".tsx" /* Extension.Tsx */, ".cts" /* Extension.Cts */, ".mts" /* Extension.Mts */]; + ts.supportedJSExtensions = [[".js" /* Extension.Js */, ".jsx" /* Extension.Jsx */], [".mjs" /* Extension.Mjs */], [".cjs" /* Extension.Cjs */]]; + ts.supportedJSExtensionsFlat = ts.flatten(ts.supportedJSExtensions); + var allSupportedExtensions = [[".ts" /* Extension.Ts */, ".tsx" /* Extension.Tsx */, ".d.ts" /* Extension.Dts */, ".js" /* Extension.Js */, ".jsx" /* Extension.Jsx */], [".cts" /* Extension.Cts */, ".d.cts" /* Extension.Dcts */, ".cjs" /* Extension.Cjs */], [".mts" /* Extension.Mts */, ".d.mts" /* Extension.Dmts */, ".mjs" /* Extension.Mjs */]]; + var allSupportedExtensionsWithJson = __spreadArray(__spreadArray([], allSupportedExtensions, true), [[".json" /* Extension.Json */]], false); + ts.supportedDeclarationExtensions = [".d.ts" /* Extension.Dts */, ".d.cts" /* Extension.Dcts */, ".d.mts" /* Extension.Dmts */]; + function getSupportedExtensions(options, extraFileExtensions) { + var needJsExtensions = options && getAllowJSCompilerOption(options); + if (!extraFileExtensions || extraFileExtensions.length === 0) { + return needJsExtensions ? allSupportedExtensions : ts.supportedTSExtensions; + } + var builtins = needJsExtensions ? allSupportedExtensions : ts.supportedTSExtensions; + var flatBuiltins = ts.flatten(builtins); + var extensions = __spreadArray(__spreadArray([], builtins, true), ts.mapDefined(extraFileExtensions, function (x) { return x.scriptKind === 7 /* ScriptKind.Deferred */ || needJsExtensions && isJSLike(x.scriptKind) && flatBuiltins.indexOf(x.extension) === -1 ? [x.extension] : undefined; }), true); + return extensions; + } + ts.getSupportedExtensions = getSupportedExtensions; + function getSupportedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions) { + if (!options || !options.resolveJsonModule) + return supportedExtensions; + if (supportedExtensions === allSupportedExtensions) + return allSupportedExtensionsWithJson; + if (supportedExtensions === ts.supportedTSExtensions) + return supportedTSExtensionsWithJson; + return __spreadArray(__spreadArray([], supportedExtensions, true), [[".json" /* Extension.Json */]], false); + } + ts.getSupportedExtensionsWithJsonIfResolveJsonModule = getSupportedExtensionsWithJsonIfResolveJsonModule; + function isJSLike(scriptKind) { + return scriptKind === 1 /* ScriptKind.JS */ || scriptKind === 2 /* ScriptKind.JSX */; + } + function hasJSFileExtension(fileName) { + return ts.some(ts.supportedJSExtensionsFlat, function (extension) { return ts.fileExtensionIs(fileName, extension); }); + } + ts.hasJSFileExtension = hasJSFileExtension; + function hasTSFileExtension(fileName) { + return ts.some(ts.supportedTSExtensionsFlat, function (extension) { return ts.fileExtensionIs(fileName, extension); }); + } + ts.hasTSFileExtension = hasTSFileExtension; + function isSupportedSourceFileName(fileName, compilerOptions, extraFileExtensions) { + if (!fileName) + return false; + var supportedExtensions = getSupportedExtensions(compilerOptions, extraFileExtensions); + for (var _i = 0, _a = ts.flatten(getSupportedExtensionsWithJsonIfResolveJsonModule(compilerOptions, supportedExtensions)); _i < _a.length; _i++) { + var extension = _a[_i]; + if (ts.fileExtensionIs(fileName, extension)) { + return true; + } + } + return false; + } + ts.isSupportedSourceFileName = isSupportedSourceFileName; + function numberOfDirectorySeparators(str) { + var match = str.match(/\//g); + return match ? match.length : 0; + } + function compareNumberOfDirectorySeparators(path1, path2) { + return ts.compareValues(numberOfDirectorySeparators(path1), numberOfDirectorySeparators(path2)); + } + ts.compareNumberOfDirectorySeparators = compareNumberOfDirectorySeparators; + var extensionsToRemove = [".d.ts" /* Extension.Dts */, ".d.mts" /* Extension.Dmts */, ".d.cts" /* Extension.Dcts */, ".mjs" /* Extension.Mjs */, ".mts" /* Extension.Mts */, ".cjs" /* Extension.Cjs */, ".cts" /* Extension.Cts */, ".ts" /* Extension.Ts */, ".js" /* Extension.Js */, ".tsx" /* Extension.Tsx */, ".jsx" /* Extension.Jsx */, ".json" /* Extension.Json */]; + function removeFileExtension(path) { + for (var _i = 0, extensionsToRemove_1 = extensionsToRemove; _i < extensionsToRemove_1.length; _i++) { + var ext = extensionsToRemove_1[_i]; + var extensionless = tryRemoveExtension(path, ext); + if (extensionless !== undefined) { + return extensionless; + } + } + return path; + } + ts.removeFileExtension = removeFileExtension; + function tryRemoveExtension(path, extension) { + return ts.fileExtensionIs(path, extension) ? removeExtension(path, extension) : undefined; + } + ts.tryRemoveExtension = tryRemoveExtension; + function removeExtension(path, extension) { + return path.substring(0, path.length - extension.length); + } + ts.removeExtension = removeExtension; + function changeExtension(path, newExtension) { + return ts.changeAnyExtension(path, newExtension, extensionsToRemove, /*ignoreCase*/ false); + } + ts.changeExtension = changeExtension; + /** + * Returns the input if there are no stars, a pattern if there is exactly one, + * and undefined if there are more. + */ + function tryParsePattern(pattern) { + var indexOfStar = pattern.indexOf("*"); + if (indexOfStar === -1) { + return pattern; + } + return pattern.indexOf("*", indexOfStar + 1) !== -1 + ? undefined + : { + prefix: pattern.substr(0, indexOfStar), + suffix: pattern.substr(indexOfStar + 1) + }; + } + ts.tryParsePattern = tryParsePattern; + function tryParsePatterns(paths) { + return ts.mapDefined(ts.getOwnKeys(paths), function (path) { return tryParsePattern(path); }); + } + ts.tryParsePatterns = tryParsePatterns; + function positionIsSynthesized(pos) { + // This is a fast way of testing the following conditions: + // pos === undefined || pos === null || isNaN(pos) || pos < 0; + return !(pos >= 0); + } + ts.positionIsSynthesized = positionIsSynthesized; + /** True if an extension is one of the supported TypeScript extensions. */ + function extensionIsTS(ext) { + return ext === ".ts" /* Extension.Ts */ || ext === ".tsx" /* Extension.Tsx */ || ext === ".d.ts" /* Extension.Dts */ || ext === ".cts" /* Extension.Cts */ || ext === ".mts" /* Extension.Mts */ || ext === ".d.mts" /* Extension.Dmts */ || ext === ".d.cts" /* Extension.Dcts */; + } + ts.extensionIsTS = extensionIsTS; + function resolutionExtensionIsTSOrJson(ext) { + return extensionIsTS(ext) || ext === ".json" /* Extension.Json */; + } + ts.resolutionExtensionIsTSOrJson = resolutionExtensionIsTSOrJson; + /** + * Gets the extension from a path. + * Path must have a valid extension. + */ + function extensionFromPath(path) { + var ext = tryGetExtensionFromPath(path); + return ext !== undefined ? ext : ts.Debug.fail("File ".concat(path, " has unknown extension.")); + } + ts.extensionFromPath = extensionFromPath; + function isAnySupportedFileExtension(path) { + return tryGetExtensionFromPath(path) !== undefined; + } + ts.isAnySupportedFileExtension = isAnySupportedFileExtension; + function tryGetExtensionFromPath(path) { + return ts.find(extensionsToRemove, function (e) { return ts.fileExtensionIs(path, e); }); + } + ts.tryGetExtensionFromPath = tryGetExtensionFromPath; + function isCheckJsEnabledForFile(sourceFile, compilerOptions) { + return sourceFile.checkJsDirective ? sourceFile.checkJsDirective.enabled : compilerOptions.checkJs; + } + ts.isCheckJsEnabledForFile = isCheckJsEnabledForFile; + ts.emptyFileSystemEntries = { + files: ts.emptyArray, + directories: ts.emptyArray + }; + /** + * patternOrStrings contains both patterns (containing "*") and regular strings. + * Return an exact match if possible, or a pattern match, or undefined. + * (These are verified by verifyCompilerOptions to have 0 or 1 "*" characters.) + */ + function matchPatternOrExact(patternOrStrings, candidate) { + var patterns = []; + for (var _i = 0, patternOrStrings_1 = patternOrStrings; _i < patternOrStrings_1.length; _i++) { + var patternOrString = patternOrStrings_1[_i]; + if (patternOrString === candidate) { + return candidate; + } + if (!ts.isString(patternOrString)) { + patterns.push(patternOrString); + } + } + return ts.findBestPatternMatch(patterns, function (_) { return _; }, candidate); + } + ts.matchPatternOrExact = matchPatternOrExact; + function sliceAfter(arr, value) { + var index = arr.indexOf(value); + ts.Debug.assert(index !== -1); + return arr.slice(index); + } + ts.sliceAfter = sliceAfter; + function addRelatedInfo(diagnostic) { + var _a; + var relatedInformation = []; + for (var _i = 1; _i < arguments.length; _i++) { + relatedInformation[_i - 1] = arguments[_i]; + } + if (!relatedInformation.length) { + return diagnostic; + } + if (!diagnostic.relatedInformation) { + diagnostic.relatedInformation = []; + } + ts.Debug.assert(diagnostic.relatedInformation !== ts.emptyArray, "Diagnostic had empty array singleton for related info, but is still being constructed!"); + (_a = diagnostic.relatedInformation).push.apply(_a, relatedInformation); + return diagnostic; + } + ts.addRelatedInfo = addRelatedInfo; + function minAndMax(arr, getValue) { + ts.Debug.assert(arr.length !== 0); + var min = getValue(arr[0]); + var max = min; + for (var i = 1; i < arr.length; i++) { + var value = getValue(arr[i]); + if (value < min) { + min = value; + } + else if (value > max) { + max = value; + } + } + return { min: min, max: max }; + } + ts.minAndMax = minAndMax; + function rangeOfNode(node) { + return { pos: getTokenPosOfNode(node), end: node.end }; + } + ts.rangeOfNode = rangeOfNode; + function rangeOfTypeParameters(sourceFile, typeParameters) { + // Include the `<>` + var pos = typeParameters.pos - 1; + var end = ts.skipTrivia(sourceFile.text, typeParameters.end) + 1; + return { pos: pos, end: end }; + } + ts.rangeOfTypeParameters = rangeOfTypeParameters; + function skipTypeChecking(sourceFile, options, host) { + // If skipLibCheck is enabled, skip reporting errors if file is a declaration file. + // If skipDefaultLibCheck is enabled, skip reporting errors if file contains a + // '/// ' directive. + return (options.skipLibCheck && sourceFile.isDeclarationFile || + options.skipDefaultLibCheck && sourceFile.hasNoDefaultLib) || + host.isSourceOfProjectReferenceRedirect(sourceFile.fileName); + } + ts.skipTypeChecking = skipTypeChecking; + function isJsonEqual(a, b) { + // eslint-disable-next-line no-null/no-null + return a === b || typeof a === "object" && a !== null && typeof b === "object" && b !== null && ts.equalOwnProperties(a, b, isJsonEqual); + } + ts.isJsonEqual = isJsonEqual; + /** + * Converts a bigint literal string, e.g. `0x1234n`, + * to its decimal string representation, e.g. `4660`. + */ + function parsePseudoBigInt(stringValue) { + var log2Base; + switch (stringValue.charCodeAt(1)) { // "x" in "0x123" + case 98 /* CharacterCodes.b */: + case 66 /* CharacterCodes.B */: // 0b or 0B + log2Base = 1; + break; + case 111 /* CharacterCodes.o */: + case 79 /* CharacterCodes.O */: // 0o or 0O + log2Base = 3; + break; + case 120 /* CharacterCodes.x */: + case 88 /* CharacterCodes.X */: // 0x or 0X + log2Base = 4; + break; + default: // already in decimal; omit trailing "n" + var nIndex = stringValue.length - 1; + // Skip leading 0s + var nonZeroStart = 0; + while (stringValue.charCodeAt(nonZeroStart) === 48 /* CharacterCodes._0 */) { + nonZeroStart++; + } + return stringValue.slice(nonZeroStart, nIndex) || "0"; + } + // Omit leading "0b", "0o", or "0x", and trailing "n" + var startIndex = 2, endIndex = stringValue.length - 1; + var bitsNeeded = (endIndex - startIndex) * log2Base; + // Stores the value specified by the string as a LE array of 16-bit integers + // using Uint16 instead of Uint32 so combining steps can use bitwise operators + var segments = new Uint16Array((bitsNeeded >>> 4) + (bitsNeeded & 15 ? 1 : 0)); + // Add the digits, one at a time + for (var i = endIndex - 1, bitOffset = 0; i >= startIndex; i--, bitOffset += log2Base) { + var segment = bitOffset >>> 4; + var digitChar = stringValue.charCodeAt(i); + // Find character range: 0-9 < A-F < a-f + var digit = digitChar <= 57 /* CharacterCodes._9 */ + ? digitChar - 48 /* CharacterCodes._0 */ + : 10 + digitChar - + (digitChar <= 70 /* CharacterCodes.F */ ? 65 /* CharacterCodes.A */ : 97 /* CharacterCodes.a */); + var shiftedDigit = digit << (bitOffset & 15); + segments[segment] |= shiftedDigit; + var residual = shiftedDigit >>> 16; + if (residual) + segments[segment + 1] |= residual; // overflows segment + } + // Repeatedly divide segments by 10 and add remainder to base10Value + var base10Value = ""; + var firstNonzeroSegment = segments.length - 1; + var segmentsRemaining = true; + while (segmentsRemaining) { + var mod10 = 0; + segmentsRemaining = false; + for (var segment = firstNonzeroSegment; segment >= 0; segment--) { + var newSegment = mod10 << 16 | segments[segment]; + var segmentValue = (newSegment / 10) | 0; + segments[segment] = segmentValue; + mod10 = newSegment - segmentValue * 10; + if (segmentValue && !segmentsRemaining) { + firstNonzeroSegment = segment; + segmentsRemaining = true; + } + } + base10Value = mod10 + base10Value; + } + return base10Value; + } + ts.parsePseudoBigInt = parsePseudoBigInt; + function pseudoBigIntToString(_a) { + var negative = _a.negative, base10Value = _a.base10Value; + return (negative && base10Value !== "0" ? "-" : "") + base10Value; + } + ts.pseudoBigIntToString = pseudoBigIntToString; + function isValidTypeOnlyAliasUseSite(useSite) { + return !!(useSite.flags & 16777216 /* NodeFlags.Ambient */) + || isPartOfTypeQuery(useSite) + || isIdentifierInNonEmittingHeritageClause(useSite) + || isPartOfPossiblyValidTypeOrAbstractComputedPropertyName(useSite) + || !(isExpressionNode(useSite) || isShorthandPropertyNameUseSite(useSite)); + } + ts.isValidTypeOnlyAliasUseSite = isValidTypeOnlyAliasUseSite; + function isShorthandPropertyNameUseSite(useSite) { + return ts.isIdentifier(useSite) && ts.isShorthandPropertyAssignment(useSite.parent) && useSite.parent.name === useSite; + } + function isPartOfPossiblyValidTypeOrAbstractComputedPropertyName(node) { + while (node.kind === 79 /* SyntaxKind.Identifier */ || node.kind === 208 /* SyntaxKind.PropertyAccessExpression */) { + node = node.parent; + } + if (node.kind !== 164 /* SyntaxKind.ComputedPropertyName */) { + return false; + } + if (hasSyntacticModifier(node.parent, 256 /* ModifierFlags.Abstract */)) { + return true; + } + var containerKind = node.parent.parent.kind; + return containerKind === 261 /* SyntaxKind.InterfaceDeclaration */ || containerKind === 184 /* SyntaxKind.TypeLiteral */; + } + /** Returns true for an identifier in 1) an `implements` clause, and 2) an `extends` clause of an interface. */ + function isIdentifierInNonEmittingHeritageClause(node) { + if (node.kind !== 79 /* SyntaxKind.Identifier */) + return false; + var heritageClause = ts.findAncestor(node.parent, function (parent) { + switch (parent.kind) { + case 294 /* SyntaxKind.HeritageClause */: + return true; + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 230 /* SyntaxKind.ExpressionWithTypeArguments */: + return false; + default: + return "quit"; + } + }); + return (heritageClause === null || heritageClause === void 0 ? void 0 : heritageClause.token) === 117 /* SyntaxKind.ImplementsKeyword */ || (heritageClause === null || heritageClause === void 0 ? void 0 : heritageClause.parent.kind) === 261 /* SyntaxKind.InterfaceDeclaration */; + } + function isIdentifierTypeReference(node) { + return ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName); + } + ts.isIdentifierTypeReference = isIdentifierTypeReference; + function arrayIsHomogeneous(array, comparer) { + if (comparer === void 0) { comparer = ts.equateValues; } + if (array.length < 2) + return true; + var first = array[0]; + for (var i = 1, length_1 = array.length; i < length_1; i++) { + var target = array[i]; + if (!comparer(first, target)) + return false; + } + return true; + } + ts.arrayIsHomogeneous = arrayIsHomogeneous; + /** + * Bypasses immutability and directly sets the `pos` property of a `TextRange` or `Node`. + */ + /* @internal */ + function setTextRangePos(range, pos) { + range.pos = pos; + return range; + } + ts.setTextRangePos = setTextRangePos; + /** + * Bypasses immutability and directly sets the `end` property of a `TextRange` or `Node`. + */ + /* @internal */ + function setTextRangeEnd(range, end) { + range.end = end; + return range; + } + ts.setTextRangeEnd = setTextRangeEnd; + /** + * Bypasses immutability and directly sets the `pos` and `end` properties of a `TextRange` or `Node`. + */ + /* @internal */ + function setTextRangePosEnd(range, pos, end) { + return setTextRangeEnd(setTextRangePos(range, pos), end); + } + ts.setTextRangePosEnd = setTextRangePosEnd; + /** + * Bypasses immutability and directly sets the `pos` and `end` properties of a `TextRange` or `Node` from the + * provided position and width. + */ + /* @internal */ + function setTextRangePosWidth(range, pos, width) { + return setTextRangePosEnd(range, pos, pos + width); + } + ts.setTextRangePosWidth = setTextRangePosWidth; + function setNodeFlags(node, newFlags) { + if (node) { + node.flags = newFlags; + } + return node; + } + ts.setNodeFlags = setNodeFlags; + function setParent(child, parent) { + if (child && parent) { + child.parent = parent; + } + return child; + } + ts.setParent = setParent; + function setEachParent(children, parent) { + if (children) { + for (var _i = 0, children_1 = children; _i < children_1.length; _i++) { + var child = children_1[_i]; + setParent(child, parent); + } + } + return children; + } + ts.setEachParent = setEachParent; + function setParentRecursive(rootNode, incremental) { + if (!rootNode) + return rootNode; + ts.forEachChildRecursively(rootNode, ts.isJSDocNode(rootNode) ? bindParentToChildIgnoringJSDoc : bindParentToChild); + return rootNode; + function bindParentToChildIgnoringJSDoc(child, parent) { + if (incremental && child.parent === parent) { + return "skip"; + } + setParent(child, parent); + } + function bindJSDoc(child) { + if (ts.hasJSDocNodes(child)) { + for (var _i = 0, _a = child.jsDoc; _i < _a.length; _i++) { + var doc = _a[_i]; + bindParentToChildIgnoringJSDoc(doc, child); + ts.forEachChildRecursively(doc, bindParentToChildIgnoringJSDoc); + } + } + } + function bindParentToChild(child, parent) { + return bindParentToChildIgnoringJSDoc(child, parent) || bindJSDoc(child); + } + } + ts.setParentRecursive = setParentRecursive; + function isPackedElement(node) { + return !ts.isOmittedExpression(node); + } + /** + * Determines whether the provided node is an ArrayLiteralExpression that contains no missing elements. + */ + function isPackedArrayLiteral(node) { + return ts.isArrayLiteralExpression(node) && ts.every(node.elements, isPackedElement); + } + ts.isPackedArrayLiteral = isPackedArrayLiteral; + /** + * Indicates whether the result of an `Expression` will be unused. + * + * NOTE: This requires a node with a valid `parent` pointer. + */ + function expressionResultIsUnused(node) { + ts.Debug.assertIsDefined(node.parent); + while (true) { + var parent = node.parent; + // walk up parenthesized expressions, but keep a pointer to the top-most parenthesized expression + if (ts.isParenthesizedExpression(parent)) { + node = parent; + continue; + } + // result is unused in an expression statement, `void` expression, or the initializer or incrementer of a `for` loop + if (ts.isExpressionStatement(parent) || + ts.isVoidExpression(parent) || + ts.isForStatement(parent) && (parent.initializer === node || parent.incrementor === node)) { + return true; + } + if (ts.isCommaListExpression(parent)) { + // left side of comma is always unused + if (node !== ts.last(parent.elements)) + return true; + // right side of comma is unused if parent is unused + node = parent; + continue; + } + if (ts.isBinaryExpression(parent) && parent.operatorToken.kind === 27 /* SyntaxKind.CommaToken */) { + // left side of comma is always unused + if (node === parent.left) + return true; + // right side of comma is unused if parent is unused + node = parent; + continue; + } + return false; + } + } + ts.expressionResultIsUnused = expressionResultIsUnused; + function containsIgnoredPath(path) { + return ts.some(ts.ignoredPaths, function (p) { return ts.stringContains(path, p); }); + } + ts.containsIgnoredPath = containsIgnoredPath; + function getContainingNodeArray(node) { + if (!node.parent) + return undefined; + switch (node.kind) { + case 165 /* SyntaxKind.TypeParameter */: + var parent_1 = node.parent; + return parent_1.kind === 192 /* SyntaxKind.InferType */ ? undefined : parent_1.typeParameters; + case 166 /* SyntaxKind.Parameter */: + return node.parent.parameters; + case 201 /* SyntaxKind.TemplateLiteralTypeSpan */: + return node.parent.templateSpans; + case 236 /* SyntaxKind.TemplateSpan */: + return node.parent.templateSpans; + case 167 /* SyntaxKind.Decorator */: { + var parent_2 = node.parent; + return ts.canHaveDecorators(parent_2) ? parent_2.modifiers : + ts.canHaveIllegalDecorators(parent_2) ? parent_2.illegalDecorators : + undefined; + } + case 294 /* SyntaxKind.HeritageClause */: + return node.parent.heritageClauses; + } + var parent = node.parent; + if (ts.isJSDocTag(node)) { + return ts.isJSDocTypeLiteral(node.parent) ? undefined : node.parent.tags; + } + switch (parent.kind) { + case 184 /* SyntaxKind.TypeLiteral */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + return ts.isTypeElement(node) ? parent.members : undefined; + case 189 /* SyntaxKind.UnionType */: + case 190 /* SyntaxKind.IntersectionType */: + return parent.types; + case 186 /* SyntaxKind.TupleType */: + case 206 /* SyntaxKind.ArrayLiteralExpression */: + case 354 /* SyntaxKind.CommaListExpression */: + case 272 /* SyntaxKind.NamedImports */: + case 276 /* SyntaxKind.NamedExports */: + return parent.elements; + case 207 /* SyntaxKind.ObjectLiteralExpression */: + case 289 /* SyntaxKind.JsxAttributes */: + return parent.properties; + case 210 /* SyntaxKind.CallExpression */: + case 211 /* SyntaxKind.NewExpression */: + return ts.isTypeNode(node) ? parent.typeArguments : + parent.expression === node ? undefined : + parent.arguments; + case 281 /* SyntaxKind.JsxElement */: + case 285 /* SyntaxKind.JsxFragment */: + return ts.isJsxChild(node) ? parent.children : undefined; + case 283 /* SyntaxKind.JsxOpeningElement */: + case 282 /* SyntaxKind.JsxSelfClosingElement */: + return ts.isTypeNode(node) ? parent.typeArguments : undefined; + case 238 /* SyntaxKind.Block */: + case 292 /* SyntaxKind.CaseClause */: + case 293 /* SyntaxKind.DefaultClause */: + case 265 /* SyntaxKind.ModuleBlock */: + return parent.statements; + case 266 /* SyntaxKind.CaseBlock */: + return parent.clauses; + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + return ts.isClassElement(node) ? parent.members : undefined; + case 263 /* SyntaxKind.EnumDeclaration */: + return ts.isEnumMember(node) ? parent.members : undefined; + case 308 /* SyntaxKind.SourceFile */: + return parent.statements; + } + } + ts.getContainingNodeArray = getContainingNodeArray; + function hasContextSensitiveParameters(node) { + // Functions with type parameters are not context sensitive. + if (!node.typeParameters) { + // Functions with any parameters that lack type annotations are context sensitive. + if (ts.some(node.parameters, function (p) { return !getEffectiveTypeAnnotationNode(p); })) { + return true; + } + if (node.kind !== 216 /* SyntaxKind.ArrowFunction */) { + // If the first parameter is not an explicit 'this' parameter, then the function has + // an implicit 'this' parameter which is subject to contextual typing. + var parameter = ts.firstOrUndefined(node.parameters); + if (!(parameter && parameterIsThisKeyword(parameter))) { + return true; + } + } + } + return false; + } + ts.hasContextSensitiveParameters = hasContextSensitiveParameters; + /* @internal */ + function isInfinityOrNaNString(name) { + return name === "Infinity" || name === "-Infinity" || name === "NaN"; + } + ts.isInfinityOrNaNString = isInfinityOrNaNString; + function isCatchClauseVariableDeclaration(node) { + return node.kind === 257 /* SyntaxKind.VariableDeclaration */ && node.parent.kind === 295 /* SyntaxKind.CatchClause */; + } + ts.isCatchClauseVariableDeclaration = isCatchClauseVariableDeclaration; + function isParameterOrCatchClauseVariable(symbol) { + var declaration = symbol.valueDeclaration && getRootDeclaration(symbol.valueDeclaration); + return !!declaration && (ts.isParameter(declaration) || isCatchClauseVariableDeclaration(declaration)); + } + ts.isParameterOrCatchClauseVariable = isParameterOrCatchClauseVariable; + function isFunctionExpressionOrArrowFunction(node) { + return node.kind === 215 /* SyntaxKind.FunctionExpression */ || node.kind === 216 /* SyntaxKind.ArrowFunction */; + } + ts.isFunctionExpressionOrArrowFunction = isFunctionExpressionOrArrowFunction; + function escapeSnippetText(text) { + return text.replace(/\$/gm, function () { return "\\$"; }); + } + ts.escapeSnippetText = escapeSnippetText; + function isNumericLiteralName(name) { + // The intent of numeric names is that + // - they are names with text in a numeric form, and that + // - setting properties/indexing with them is always equivalent to doing so with the numeric literal 'numLit', + // acquired by applying the abstract 'ToNumber' operation on the name's text. + // + // The subtlety is in the latter portion, as we cannot reliably say that anything that looks like a numeric literal is a numeric name. + // In fact, it is the case that the text of the name must be equal to 'ToString(numLit)' for this to hold. + // + // Consider the property name '"0xF00D"'. When one indexes with '0xF00D', they are actually indexing with the value of 'ToString(0xF00D)' + // according to the ECMAScript specification, so it is actually as if the user indexed with the string '"61453"'. + // Thus, the text of all numeric literals equivalent to '61543' such as '0xF00D', '0xf00D', '0170015', etc. are not valid numeric names + // because their 'ToString' representation is not equal to their original text. + // This is motivated by ECMA-262 sections 9.3.1, 9.8.1, 11.1.5, and 11.2.1. + // + // Here, we test whether 'ToString(ToNumber(name))' is exactly equal to 'name'. + // The '+' prefix operator is equivalent here to applying the abstract ToNumber operation. + // Applying the 'toString()' method on a number gives us the abstract ToString operation on a number. + // + // Note that this accepts the values 'Infinity', '-Infinity', and 'NaN', and that this is intentional. + // This is desired behavior, because when indexing with them as numeric entities, you are indexing + // with the strings '"Infinity"', '"-Infinity"', and '"NaN"' respectively. + return (+name).toString() === name; + } + ts.isNumericLiteralName = isNumericLiteralName; + function createPropertyNameNodeForIdentifierOrLiteral(name, target, singleQuote, stringNamed) { + return ts.isIdentifierText(name, target) ? ts.factory.createIdentifier(name) : + !stringNamed && isNumericLiteralName(name) && +name >= 0 ? ts.factory.createNumericLiteral(+name) : + ts.factory.createStringLiteral(name, !!singleQuote); + } + ts.createPropertyNameNodeForIdentifierOrLiteral = createPropertyNameNodeForIdentifierOrLiteral; + function isThisTypeParameter(type) { + return !!(type.flags & 262144 /* TypeFlags.TypeParameter */ && type.isThisType); + } + ts.isThisTypeParameter = isThisTypeParameter; + function getNodeModulePathParts(fullPath) { + // If fullPath can't be valid module file within node_modules, returns undefined. + // Example of expected pattern: /base/path/node_modules/[@scope/otherpackage/@otherscope/node_modules/]package/[subdirectory/]file.js + // Returns indices: ^ ^ ^ ^ + var topLevelNodeModulesIndex = 0; + var topLevelPackageNameIndex = 0; + var packageRootIndex = 0; + var fileNameIndex = 0; + var States; + (function (States) { + States[States["BeforeNodeModules"] = 0] = "BeforeNodeModules"; + States[States["NodeModules"] = 1] = "NodeModules"; + States[States["Scope"] = 2] = "Scope"; + States[States["PackageContent"] = 3] = "PackageContent"; + })(States || (States = {})); + var partStart = 0; + var partEnd = 0; + var state = 0 /* States.BeforeNodeModules */; + while (partEnd >= 0) { + partStart = partEnd; + partEnd = fullPath.indexOf("/", partStart + 1); + switch (state) { + case 0 /* States.BeforeNodeModules */: + if (fullPath.indexOf(ts.nodeModulesPathPart, partStart) === partStart) { + topLevelNodeModulesIndex = partStart; + topLevelPackageNameIndex = partEnd; + state = 1 /* States.NodeModules */; + } + break; + case 1 /* States.NodeModules */: + case 2 /* States.Scope */: + if (state === 1 /* States.NodeModules */ && fullPath.charAt(partStart + 1) === "@") { + state = 2 /* States.Scope */; + } + else { + packageRootIndex = partEnd; + state = 3 /* States.PackageContent */; + } + break; + case 3 /* States.PackageContent */: + if (fullPath.indexOf(ts.nodeModulesPathPart, partStart) === partStart) { + state = 1 /* States.NodeModules */; + } + else { + state = 3 /* States.PackageContent */; + } + break; + } + } + fileNameIndex = partStart; + return state > 1 /* States.NodeModules */ ? { topLevelNodeModulesIndex: topLevelNodeModulesIndex, topLevelPackageNameIndex: topLevelPackageNameIndex, packageRootIndex: packageRootIndex, fileNameIndex: fileNameIndex } : undefined; + } + ts.getNodeModulePathParts = getNodeModulePathParts; + function getParameterTypeNode(parameter) { + var _a; + return parameter.kind === 343 /* SyntaxKind.JSDocParameterTag */ ? (_a = parameter.typeExpression) === null || _a === void 0 ? void 0 : _a.type : parameter.type; + } + ts.getParameterTypeNode = getParameterTypeNode; + function isTypeDeclaration(node) { + switch (node.kind) { + case 165 /* SyntaxKind.TypeParameter */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 348 /* SyntaxKind.JSDocTypedefTag */: + case 341 /* SyntaxKind.JSDocCallbackTag */: + case 342 /* SyntaxKind.JSDocEnumTag */: + return true; + case 270 /* SyntaxKind.ImportClause */: + return node.isTypeOnly; + case 273 /* SyntaxKind.ImportSpecifier */: + case 278 /* SyntaxKind.ExportSpecifier */: + return node.parent.parent.isTypeOnly; + default: + return false; + } + } + ts.isTypeDeclaration = isTypeDeclaration; + function canHaveExportModifier(node) { + return ts.isEnumDeclaration(node) || ts.isVariableStatement(node) || ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) + || ts.isInterfaceDeclaration(node) || isTypeDeclaration(node) || (ts.isModuleDeclaration(node) && !isExternalModuleAugmentation(node) && !isGlobalScopeAugmentation(node)); + } + ts.canHaveExportModifier = canHaveExportModifier; +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + /** + * Creates a `BaseNodeFactory` which can be used to create `Node` instances from the constructors provided by the object allocator. + */ + function createBaseNodeFactory() { + var NodeConstructor; + var TokenConstructor; + var IdentifierConstructor; + var PrivateIdentifierConstructor; + var SourceFileConstructor; + return { + createBaseSourceFileNode: createBaseSourceFileNode, + createBaseIdentifierNode: createBaseIdentifierNode, + createBasePrivateIdentifierNode: createBasePrivateIdentifierNode, + createBaseTokenNode: createBaseTokenNode, + createBaseNode: createBaseNode + }; + function createBaseSourceFileNode(kind) { + return new (SourceFileConstructor || (SourceFileConstructor = ts.objectAllocator.getSourceFileConstructor()))(kind, /*pos*/ -1, /*end*/ -1); + } + function createBaseIdentifierNode(kind) { + return new (IdentifierConstructor || (IdentifierConstructor = ts.objectAllocator.getIdentifierConstructor()))(kind, /*pos*/ -1, /*end*/ -1); + } + function createBasePrivateIdentifierNode(kind) { + return new (PrivateIdentifierConstructor || (PrivateIdentifierConstructor = ts.objectAllocator.getPrivateIdentifierConstructor()))(kind, /*pos*/ -1, /*end*/ -1); + } + function createBaseTokenNode(kind) { + return new (TokenConstructor || (TokenConstructor = ts.objectAllocator.getTokenConstructor()))(kind, /*pos*/ -1, /*end*/ -1); + } + function createBaseNode(kind) { + return new (NodeConstructor || (NodeConstructor = ts.objectAllocator.getNodeConstructor()))(kind, /*pos*/ -1, /*end*/ -1); + } + } + ts.createBaseNodeFactory = createBaseNodeFactory; +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + function createParenthesizerRules(factory) { + var binaryLeftOperandParenthesizerCache; + var binaryRightOperandParenthesizerCache; + return { + getParenthesizeLeftSideOfBinaryForOperator: getParenthesizeLeftSideOfBinaryForOperator, + getParenthesizeRightSideOfBinaryForOperator: getParenthesizeRightSideOfBinaryForOperator, + parenthesizeLeftSideOfBinary: parenthesizeLeftSideOfBinary, + parenthesizeRightSideOfBinary: parenthesizeRightSideOfBinary, + parenthesizeExpressionOfComputedPropertyName: parenthesizeExpressionOfComputedPropertyName, + parenthesizeConditionOfConditionalExpression: parenthesizeConditionOfConditionalExpression, + parenthesizeBranchOfConditionalExpression: parenthesizeBranchOfConditionalExpression, + parenthesizeExpressionOfExportDefault: parenthesizeExpressionOfExportDefault, + parenthesizeExpressionOfNew: parenthesizeExpressionOfNew, + parenthesizeLeftSideOfAccess: parenthesizeLeftSideOfAccess, + parenthesizeOperandOfPostfixUnary: parenthesizeOperandOfPostfixUnary, + parenthesizeOperandOfPrefixUnary: parenthesizeOperandOfPrefixUnary, + parenthesizeExpressionsOfCommaDelimitedList: parenthesizeExpressionsOfCommaDelimitedList, + parenthesizeExpressionForDisallowedComma: parenthesizeExpressionForDisallowedComma, + parenthesizeExpressionOfExpressionStatement: parenthesizeExpressionOfExpressionStatement, + parenthesizeConciseBodyOfArrowFunction: parenthesizeConciseBodyOfArrowFunction, + parenthesizeCheckTypeOfConditionalType: parenthesizeCheckTypeOfConditionalType, + parenthesizeExtendsTypeOfConditionalType: parenthesizeExtendsTypeOfConditionalType, + parenthesizeConstituentTypesOfUnionType: parenthesizeConstituentTypesOfUnionType, + parenthesizeConstituentTypeOfUnionType: parenthesizeConstituentTypeOfUnionType, + parenthesizeConstituentTypesOfIntersectionType: parenthesizeConstituentTypesOfIntersectionType, + parenthesizeConstituentTypeOfIntersectionType: parenthesizeConstituentTypeOfIntersectionType, + parenthesizeOperandOfTypeOperator: parenthesizeOperandOfTypeOperator, + parenthesizeOperandOfReadonlyTypeOperator: parenthesizeOperandOfReadonlyTypeOperator, + parenthesizeNonArrayTypeOfPostfixType: parenthesizeNonArrayTypeOfPostfixType, + parenthesizeElementTypesOfTupleType: parenthesizeElementTypesOfTupleType, + parenthesizeElementTypeOfTupleType: parenthesizeElementTypeOfTupleType, + parenthesizeTypeOfOptionalType: parenthesizeTypeOfOptionalType, + parenthesizeTypeArguments: parenthesizeTypeArguments, + parenthesizeLeadingTypeArgument: parenthesizeLeadingTypeArgument, + }; + function getParenthesizeLeftSideOfBinaryForOperator(operatorKind) { + binaryLeftOperandParenthesizerCache || (binaryLeftOperandParenthesizerCache = new ts.Map()); + var parenthesizerRule = binaryLeftOperandParenthesizerCache.get(operatorKind); + if (!parenthesizerRule) { + parenthesizerRule = function (node) { return parenthesizeLeftSideOfBinary(operatorKind, node); }; + binaryLeftOperandParenthesizerCache.set(operatorKind, parenthesizerRule); + } + return parenthesizerRule; + } + function getParenthesizeRightSideOfBinaryForOperator(operatorKind) { + binaryRightOperandParenthesizerCache || (binaryRightOperandParenthesizerCache = new ts.Map()); + var parenthesizerRule = binaryRightOperandParenthesizerCache.get(operatorKind); + if (!parenthesizerRule) { + parenthesizerRule = function (node) { return parenthesizeRightSideOfBinary(operatorKind, /*leftSide*/ undefined, node); }; + binaryRightOperandParenthesizerCache.set(operatorKind, parenthesizerRule); + } + return parenthesizerRule; + } + /** + * Determines whether the operand to a BinaryExpression needs to be parenthesized. + * + * @param binaryOperator The operator for the BinaryExpression. + * @param operand The operand for the BinaryExpression. + * @param isLeftSideOfBinary A value indicating whether the operand is the left side of the + * BinaryExpression. + */ + function binaryOperandNeedsParentheses(binaryOperator, operand, isLeftSideOfBinary, leftOperand) { + // If the operand has lower precedence, then it needs to be parenthesized to preserve the + // intent of the expression. For example, if the operand is `a + b` and the operator is + // `*`, then we need to parenthesize the operand to preserve the intended order of + // operations: `(a + b) * x`. + // + // If the operand has higher precedence, then it does not need to be parenthesized. For + // example, if the operand is `a * b` and the operator is `+`, then we do not need to + // parenthesize to preserve the intended order of operations: `a * b + x`. + // + // If the operand has the same precedence, then we need to check the associativity of + // the operator based on whether this is the left or right operand of the expression. + // + // For example, if `a / d` is on the right of operator `*`, we need to parenthesize + // to preserve the intended order of operations: `x * (a / d)` + // + // If `a ** d` is on the left of operator `**`, we need to parenthesize to preserve + // the intended order of operations: `(a ** b) ** c` + var binaryOperatorPrecedence = ts.getOperatorPrecedence(223 /* SyntaxKind.BinaryExpression */, binaryOperator); + var binaryOperatorAssociativity = ts.getOperatorAssociativity(223 /* SyntaxKind.BinaryExpression */, binaryOperator); + var emittedOperand = ts.skipPartiallyEmittedExpressions(operand); + if (!isLeftSideOfBinary && operand.kind === 216 /* SyntaxKind.ArrowFunction */ && binaryOperatorPrecedence > 3 /* OperatorPrecedence.Assignment */) { + // We need to parenthesize arrow functions on the right side to avoid it being + // parsed as parenthesized expression: `a && (() => {})` + return true; + } + var operandPrecedence = ts.getExpressionPrecedence(emittedOperand); + switch (ts.compareValues(operandPrecedence, binaryOperatorPrecedence)) { + case -1 /* Comparison.LessThan */: + // If the operand is the right side of a right-associative binary operation + // and is a yield expression, then we do not need parentheses. + if (!isLeftSideOfBinary + && binaryOperatorAssociativity === 1 /* Associativity.Right */ + && operand.kind === 226 /* SyntaxKind.YieldExpression */) { + return false; + } + return true; + case 1 /* Comparison.GreaterThan */: + return false; + case 0 /* Comparison.EqualTo */: + if (isLeftSideOfBinary) { + // No need to parenthesize the left operand when the binary operator is + // left associative: + // (a*b)/x -> a*b/x + // (a**b)/x -> a**b/x + // + // Parentheses are needed for the left operand when the binary operator is + // right associative: + // (a/b)**x -> (a/b)**x + // (a**b)**x -> (a**b)**x + return binaryOperatorAssociativity === 1 /* Associativity.Right */; + } + else { + if (ts.isBinaryExpression(emittedOperand) + && emittedOperand.operatorToken.kind === binaryOperator) { + // No need to parenthesize the right operand when the binary operator and + // operand are the same and one of the following: + // x*(a*b) => x*a*b + // x|(a|b) => x|a|b + // x&(a&b) => x&a&b + // x^(a^b) => x^a^b + if (operatorHasAssociativeProperty(binaryOperator)) { + return false; + } + // No need to parenthesize the right operand when the binary operator + // is plus (+) if both the left and right operands consist solely of either + // literals of the same kind or binary plus (+) expressions for literals of + // the same kind (recursively). + // "a"+(1+2) => "a"+(1+2) + // "a"+("b"+"c") => "a"+"b"+"c" + if (binaryOperator === 39 /* SyntaxKind.PlusToken */) { + var leftKind = leftOperand ? getLiteralKindOfBinaryPlusOperand(leftOperand) : 0 /* SyntaxKind.Unknown */; + if (ts.isLiteralKind(leftKind) && leftKind === getLiteralKindOfBinaryPlusOperand(emittedOperand)) { + return false; + } + } + } + // No need to parenthesize the right operand when the operand is right + // associative: + // x/(a**b) -> x/a**b + // x**(a**b) -> x**a**b + // + // Parentheses are needed for the right operand when the operand is left + // associative: + // x/(a*b) -> x/(a*b) + // x**(a/b) -> x**(a/b) + var operandAssociativity = ts.getExpressionAssociativity(emittedOperand); + return operandAssociativity === 0 /* Associativity.Left */; + } + } + } + /** + * Determines whether a binary operator is mathematically associative. + * + * @param binaryOperator The binary operator. + */ + function operatorHasAssociativeProperty(binaryOperator) { + // The following operators are associative in JavaScript: + // (a*b)*c -> a*(b*c) -> a*b*c + // (a|b)|c -> a|(b|c) -> a|b|c + // (a&b)&c -> a&(b&c) -> a&b&c + // (a^b)^c -> a^(b^c) -> a^b^c + // (a,b),c -> a,(b,c) -> a,b,c + // + // While addition is associative in mathematics, JavaScript's `+` is not + // guaranteed to be associative as it is overloaded with string concatenation. + return binaryOperator === 41 /* SyntaxKind.AsteriskToken */ + || binaryOperator === 51 /* SyntaxKind.BarToken */ + || binaryOperator === 50 /* SyntaxKind.AmpersandToken */ + || binaryOperator === 52 /* SyntaxKind.CaretToken */ + || binaryOperator === 27 /* SyntaxKind.CommaToken */; + } + /** + * This function determines whether an expression consists of a homogeneous set of + * literal expressions or binary plus expressions that all share the same literal kind. + * It is used to determine whether the right-hand operand of a binary plus expression can be + * emitted without parentheses. + */ + function getLiteralKindOfBinaryPlusOperand(node) { + node = ts.skipPartiallyEmittedExpressions(node); + if (ts.isLiteralKind(node.kind)) { + return node.kind; + } + if (node.kind === 223 /* SyntaxKind.BinaryExpression */ && node.operatorToken.kind === 39 /* SyntaxKind.PlusToken */) { + if (node.cachedLiteralKind !== undefined) { + return node.cachedLiteralKind; + } + var leftKind = getLiteralKindOfBinaryPlusOperand(node.left); + var literalKind = ts.isLiteralKind(leftKind) + && leftKind === getLiteralKindOfBinaryPlusOperand(node.right) + ? leftKind + : 0 /* SyntaxKind.Unknown */; + node.cachedLiteralKind = literalKind; + return literalKind; + } + return 0 /* SyntaxKind.Unknown */; + } + /** + * Wraps the operand to a BinaryExpression in parentheses if they are needed to preserve the intended + * order of operations. + * + * @param binaryOperator The operator for the BinaryExpression. + * @param operand The operand for the BinaryExpression. + * @param isLeftSideOfBinary A value indicating whether the operand is the left side of the + * BinaryExpression. + */ + function parenthesizeBinaryOperand(binaryOperator, operand, isLeftSideOfBinary, leftOperand) { + var skipped = ts.skipPartiallyEmittedExpressions(operand); + // If the resulting expression is already parenthesized, we do not need to do any further processing. + if (skipped.kind === 214 /* SyntaxKind.ParenthesizedExpression */) { + return operand; + } + return binaryOperandNeedsParentheses(binaryOperator, operand, isLeftSideOfBinary, leftOperand) + ? factory.createParenthesizedExpression(operand) + : operand; + } + function parenthesizeLeftSideOfBinary(binaryOperator, leftSide) { + return parenthesizeBinaryOperand(binaryOperator, leftSide, /*isLeftSideOfBinary*/ true); + } + function parenthesizeRightSideOfBinary(binaryOperator, leftSide, rightSide) { + return parenthesizeBinaryOperand(binaryOperator, rightSide, /*isLeftSideOfBinary*/ false, leftSide); + } + function parenthesizeExpressionOfComputedPropertyName(expression) { + return ts.isCommaSequence(expression) ? factory.createParenthesizedExpression(expression) : expression; + } + function parenthesizeConditionOfConditionalExpression(condition) { + var conditionalPrecedence = ts.getOperatorPrecedence(224 /* SyntaxKind.ConditionalExpression */, 57 /* SyntaxKind.QuestionToken */); + var emittedCondition = ts.skipPartiallyEmittedExpressions(condition); + var conditionPrecedence = ts.getExpressionPrecedence(emittedCondition); + if (ts.compareValues(conditionPrecedence, conditionalPrecedence) !== 1 /* Comparison.GreaterThan */) { + return factory.createParenthesizedExpression(condition); + } + return condition; + } + function parenthesizeBranchOfConditionalExpression(branch) { + // per ES grammar both 'whenTrue' and 'whenFalse' parts of conditional expression are assignment expressions + // so in case when comma expression is introduced as a part of previous transformations + // if should be wrapped in parens since comma operator has the lowest precedence + var emittedExpression = ts.skipPartiallyEmittedExpressions(branch); + return ts.isCommaSequence(emittedExpression) + ? factory.createParenthesizedExpression(branch) + : branch; + } + /** + * [Per the spec](https://tc39.github.io/ecma262/#prod-ExportDeclaration), `export default` accepts _AssigmentExpression_ but + * has a lookahead restriction for `function`, `async function`, and `class`. + * + * Basically, that means we need to parenthesize in the following cases: + * + * - BinaryExpression of CommaToken + * - CommaList (synthetic list of multiple comma expressions) + * - FunctionExpression + * - ClassExpression + */ + function parenthesizeExpressionOfExportDefault(expression) { + var check = ts.skipPartiallyEmittedExpressions(expression); + var needsParens = ts.isCommaSequence(check); + if (!needsParens) { + switch (ts.getLeftmostExpression(check, /*stopAtCallExpression*/ false).kind) { + case 228 /* SyntaxKind.ClassExpression */: + case 215 /* SyntaxKind.FunctionExpression */: + needsParens = true; + } + } + return needsParens ? factory.createParenthesizedExpression(expression) : expression; + } + /** + * Wraps an expression in parentheses if it is needed in order to use the expression + * as the expression of a `NewExpression` node. + */ + function parenthesizeExpressionOfNew(expression) { + var leftmostExpr = ts.getLeftmostExpression(expression, /*stopAtCallExpressions*/ true); + switch (leftmostExpr.kind) { + case 210 /* SyntaxKind.CallExpression */: + return factory.createParenthesizedExpression(expression); + case 211 /* SyntaxKind.NewExpression */: + return !leftmostExpr.arguments + ? factory.createParenthesizedExpression(expression) + : expression; // TODO(rbuckton): Verify this assertion holds + } + return parenthesizeLeftSideOfAccess(expression); + } + /** + * Wraps an expression in parentheses if it is needed in order to use the expression for + * property or element access. + */ + function parenthesizeLeftSideOfAccess(expression, optionalChain) { + // isLeftHandSideExpression is almost the correct criterion for when it is not necessary + // to parenthesize the expression before a dot. The known exception is: + // + // NewExpression: + // new C.x -> not the same as (new C).x + // + var emittedExpression = ts.skipPartiallyEmittedExpressions(expression); + if (ts.isLeftHandSideExpression(emittedExpression) + && (emittedExpression.kind !== 211 /* SyntaxKind.NewExpression */ || emittedExpression.arguments) + && (optionalChain || !ts.isOptionalChain(emittedExpression))) { + // TODO(rbuckton): Verify whether this assertion holds. + return expression; + } + // TODO(rbuckton): Verifiy whether `setTextRange` is needed. + return ts.setTextRange(factory.createParenthesizedExpression(expression), expression); + } + function parenthesizeOperandOfPostfixUnary(operand) { + // TODO(rbuckton): Verifiy whether `setTextRange` is needed. + return ts.isLeftHandSideExpression(operand) ? operand : ts.setTextRange(factory.createParenthesizedExpression(operand), operand); + } + function parenthesizeOperandOfPrefixUnary(operand) { + // TODO(rbuckton): Verifiy whether `setTextRange` is needed. + return ts.isUnaryExpression(operand) ? operand : ts.setTextRange(factory.createParenthesizedExpression(operand), operand); + } + function parenthesizeExpressionsOfCommaDelimitedList(elements) { + var result = ts.sameMap(elements, parenthesizeExpressionForDisallowedComma); + return ts.setTextRange(factory.createNodeArray(result, elements.hasTrailingComma), elements); + } + function parenthesizeExpressionForDisallowedComma(expression) { + var emittedExpression = ts.skipPartiallyEmittedExpressions(expression); + var expressionPrecedence = ts.getExpressionPrecedence(emittedExpression); + var commaPrecedence = ts.getOperatorPrecedence(223 /* SyntaxKind.BinaryExpression */, 27 /* SyntaxKind.CommaToken */); + // TODO(rbuckton): Verifiy whether `setTextRange` is needed. + return expressionPrecedence > commaPrecedence ? expression : ts.setTextRange(factory.createParenthesizedExpression(expression), expression); + } + function parenthesizeExpressionOfExpressionStatement(expression) { + var emittedExpression = ts.skipPartiallyEmittedExpressions(expression); + if (ts.isCallExpression(emittedExpression)) { + var callee = emittedExpression.expression; + var kind = ts.skipPartiallyEmittedExpressions(callee).kind; + if (kind === 215 /* SyntaxKind.FunctionExpression */ || kind === 216 /* SyntaxKind.ArrowFunction */) { + // TODO(rbuckton): Verifiy whether `setTextRange` is needed. + var updated = factory.updateCallExpression(emittedExpression, ts.setTextRange(factory.createParenthesizedExpression(callee), callee), emittedExpression.typeArguments, emittedExpression.arguments); + return factory.restoreOuterExpressions(expression, updated, 8 /* OuterExpressionKinds.PartiallyEmittedExpressions */); + } + } + var leftmostExpressionKind = ts.getLeftmostExpression(emittedExpression, /*stopAtCallExpressions*/ false).kind; + if (leftmostExpressionKind === 207 /* SyntaxKind.ObjectLiteralExpression */ || leftmostExpressionKind === 215 /* SyntaxKind.FunctionExpression */) { + // TODO(rbuckton): Verifiy whether `setTextRange` is needed. + return ts.setTextRange(factory.createParenthesizedExpression(expression), expression); + } + return expression; + } + function parenthesizeConciseBodyOfArrowFunction(body) { + if (!ts.isBlock(body) && (ts.isCommaSequence(body) || ts.getLeftmostExpression(body, /*stopAtCallExpressions*/ false).kind === 207 /* SyntaxKind.ObjectLiteralExpression */)) { + // TODO(rbuckton): Verifiy whether `setTextRange` is needed. + return ts.setTextRange(factory.createParenthesizedExpression(body), body); + } + return body; + } + // Type[Extends] : + // FunctionOrConstructorType + // ConditionalType[?Extends] + // ConditionalType[Extends] : + // UnionType[?Extends] + // [~Extends] UnionType[~Extends] `extends` Type[+Extends] `?` Type[~Extends] `:` Type[~Extends] + // + // - The check type (the `UnionType`, above) does not allow function, constructor, or conditional types (they must be parenthesized) + // - The extends type (the first `Type`, above) does not allow conditional types (they must be parenthesized). Function and constructor types are fine. + // - The true and false branch types (the second and third `Type` non-terminals, above) allow any type + function parenthesizeCheckTypeOfConditionalType(checkType) { + switch (checkType.kind) { + case 181 /* SyntaxKind.FunctionType */: + case 182 /* SyntaxKind.ConstructorType */: + case 191 /* SyntaxKind.ConditionalType */: + return factory.createParenthesizedType(checkType); + } + return checkType; + } + function parenthesizeExtendsTypeOfConditionalType(extendsType) { + switch (extendsType.kind) { + case 191 /* SyntaxKind.ConditionalType */: + return factory.createParenthesizedType(extendsType); + } + return extendsType; + } + // UnionType[Extends] : + // `|`? IntersectionType[?Extends] + // UnionType[?Extends] `|` IntersectionType[?Extends] + // + // - A union type constituent has the same precedence as the check type of a conditional type + function parenthesizeConstituentTypeOfUnionType(type) { + switch (type.kind) { + case 189 /* SyntaxKind.UnionType */: // Not strictly necessary, but a union containing a union should have been flattened + case 190 /* SyntaxKind.IntersectionType */: // Not strictly necessary, but makes generated output more readable and avoids breaks in DT tests + return factory.createParenthesizedType(type); + } + return parenthesizeCheckTypeOfConditionalType(type); + } + function parenthesizeConstituentTypesOfUnionType(members) { + return factory.createNodeArray(ts.sameMap(members, parenthesizeConstituentTypeOfUnionType)); + } + // IntersectionType[Extends] : + // `&`? TypeOperator[?Extends] + // IntersectionType[?Extends] `&` TypeOperator[?Extends] + // + // - An intersection type constituent does not allow function, constructor, conditional, or union types (they must be parenthesized) + function parenthesizeConstituentTypeOfIntersectionType(type) { + switch (type.kind) { + case 189 /* SyntaxKind.UnionType */: + case 190 /* SyntaxKind.IntersectionType */: // Not strictly necessary, but an intersection containing an intersection should have been flattened + return factory.createParenthesizedType(type); + } + return parenthesizeConstituentTypeOfUnionType(type); + } + function parenthesizeConstituentTypesOfIntersectionType(members) { + return factory.createNodeArray(ts.sameMap(members, parenthesizeConstituentTypeOfIntersectionType)); + } + // TypeOperator[Extends] : + // PostfixType + // InferType[?Extends] + // `keyof` TypeOperator[?Extends] + // `unique` TypeOperator[?Extends] + // `readonly` TypeOperator[?Extends] + // + function parenthesizeOperandOfTypeOperator(type) { + switch (type.kind) { + case 190 /* SyntaxKind.IntersectionType */: + return factory.createParenthesizedType(type); + } + return parenthesizeConstituentTypeOfIntersectionType(type); + } + function parenthesizeOperandOfReadonlyTypeOperator(type) { + switch (type.kind) { + case 195 /* SyntaxKind.TypeOperator */: + return factory.createParenthesizedType(type); + } + return parenthesizeOperandOfTypeOperator(type); + } + // PostfixType : + // NonArrayType + // NonArrayType [no LineTerminator here] `!` // JSDoc + // NonArrayType [no LineTerminator here] `?` // JSDoc + // IndexedAccessType + // ArrayType + // + // IndexedAccessType : + // NonArrayType `[` Type[~Extends] `]` + // + // ArrayType : + // NonArrayType `[` `]` + // + function parenthesizeNonArrayTypeOfPostfixType(type) { + switch (type.kind) { + case 192 /* SyntaxKind.InferType */: + case 195 /* SyntaxKind.TypeOperator */: + case 183 /* SyntaxKind.TypeQuery */: // Not strictly necessary, but makes generated output more readable and avoids breaks in DT tests + return factory.createParenthesizedType(type); + } + return parenthesizeOperandOfTypeOperator(type); + } + // TupleType : + // `[` Elision? `]` + // `[` NamedTupleElementTypes `]` + // `[` NamedTupleElementTypes `,` Elision? `]` + // `[` TupleElementTypes `]` + // `[` TupleElementTypes `,` Elision? `]` + // + // NamedTupleElementTypes : + // Elision? NamedTupleMember + // NamedTupleElementTypes `,` Elision? NamedTupleMember + // + // NamedTupleMember : + // Identifier `?`? `:` Type[~Extends] + // `...` Identifier `:` Type[~Extends] + // + // TupleElementTypes : + // Elision? TupleElementType + // TupleElementTypes `,` Elision? TupleElementType + // + // TupleElementType : + // Type[~Extends] // NOTE: Needs cover grammar to disallow JSDoc postfix-optional + // OptionalType + // RestType + // + // OptionalType : + // Type[~Extends] `?` // NOTE: Needs cover grammar to disallow JSDoc postfix-optional + // + // RestType : + // `...` Type[~Extends] + // + function parenthesizeElementTypesOfTupleType(types) { + return factory.createNodeArray(ts.sameMap(types, parenthesizeElementTypeOfTupleType)); + } + function parenthesizeElementTypeOfTupleType(type) { + if (hasJSDocPostfixQuestion(type)) + return factory.createParenthesizedType(type); + return type; + } + function hasJSDocPostfixQuestion(type) { + if (ts.isJSDocNullableType(type)) + return type.postfix; + if (ts.isNamedTupleMember(type)) + return hasJSDocPostfixQuestion(type.type); + if (ts.isFunctionTypeNode(type) || ts.isConstructorTypeNode(type) || ts.isTypeOperatorNode(type)) + return hasJSDocPostfixQuestion(type.type); + if (ts.isConditionalTypeNode(type)) + return hasJSDocPostfixQuestion(type.falseType); + if (ts.isUnionTypeNode(type)) + return hasJSDocPostfixQuestion(ts.last(type.types)); + if (ts.isIntersectionTypeNode(type)) + return hasJSDocPostfixQuestion(ts.last(type.types)); + if (ts.isInferTypeNode(type)) + return !!type.typeParameter.constraint && hasJSDocPostfixQuestion(type.typeParameter.constraint); + return false; + } + function parenthesizeTypeOfOptionalType(type) { + if (hasJSDocPostfixQuestion(type)) + return factory.createParenthesizedType(type); + return parenthesizeNonArrayTypeOfPostfixType(type); + } + // function parenthesizeMemberOfElementType(member: TypeNode): TypeNode { + // switch (member.kind) { + // case SyntaxKind.UnionType: + // case SyntaxKind.IntersectionType: + // case SyntaxKind.FunctionType: + // case SyntaxKind.ConstructorType: + // return factory.createParenthesizedType(member); + // } + // return parenthesizeMemberOfConditionalType(member); + // } + // function parenthesizeElementTypeOfArrayType(member: TypeNode): TypeNode { + // switch (member.kind) { + // case SyntaxKind.TypeQuery: + // case SyntaxKind.TypeOperator: + // case SyntaxKind.InferType: + // return factory.createParenthesizedType(member); + // } + // return parenthesizeMemberOfElementType(member); + // } + function parenthesizeLeadingTypeArgument(node) { + return ts.isFunctionOrConstructorTypeNode(node) && node.typeParameters ? factory.createParenthesizedType(node) : node; + } + function parenthesizeOrdinalTypeArgument(node, i) { + return i === 0 ? parenthesizeLeadingTypeArgument(node) : node; + } + function parenthesizeTypeArguments(typeArguments) { + if (ts.some(typeArguments)) { + return factory.createNodeArray(ts.sameMap(typeArguments, parenthesizeOrdinalTypeArgument)); + } + } + } + ts.createParenthesizerRules = createParenthesizerRules; + ts.nullParenthesizerRules = { + getParenthesizeLeftSideOfBinaryForOperator: function (_) { return ts.identity; }, + getParenthesizeRightSideOfBinaryForOperator: function (_) { return ts.identity; }, + parenthesizeLeftSideOfBinary: function (_binaryOperator, leftSide) { return leftSide; }, + parenthesizeRightSideOfBinary: function (_binaryOperator, _leftSide, rightSide) { return rightSide; }, + parenthesizeExpressionOfComputedPropertyName: ts.identity, + parenthesizeConditionOfConditionalExpression: ts.identity, + parenthesizeBranchOfConditionalExpression: ts.identity, + parenthesizeExpressionOfExportDefault: ts.identity, + parenthesizeExpressionOfNew: function (expression) { return ts.cast(expression, ts.isLeftHandSideExpression); }, + parenthesizeLeftSideOfAccess: function (expression) { return ts.cast(expression, ts.isLeftHandSideExpression); }, + parenthesizeOperandOfPostfixUnary: function (operand) { return ts.cast(operand, ts.isLeftHandSideExpression); }, + parenthesizeOperandOfPrefixUnary: function (operand) { return ts.cast(operand, ts.isUnaryExpression); }, + parenthesizeExpressionsOfCommaDelimitedList: function (nodes) { return ts.cast(nodes, ts.isNodeArray); }, + parenthesizeExpressionForDisallowedComma: ts.identity, + parenthesizeExpressionOfExpressionStatement: ts.identity, + parenthesizeConciseBodyOfArrowFunction: ts.identity, + parenthesizeCheckTypeOfConditionalType: ts.identity, + parenthesizeExtendsTypeOfConditionalType: ts.identity, + parenthesizeConstituentTypesOfUnionType: function (nodes) { return ts.cast(nodes, ts.isNodeArray); }, + parenthesizeConstituentTypeOfUnionType: ts.identity, + parenthesizeConstituentTypesOfIntersectionType: function (nodes) { return ts.cast(nodes, ts.isNodeArray); }, + parenthesizeConstituentTypeOfIntersectionType: ts.identity, + parenthesizeOperandOfTypeOperator: ts.identity, + parenthesizeOperandOfReadonlyTypeOperator: ts.identity, + parenthesizeNonArrayTypeOfPostfixType: ts.identity, + parenthesizeElementTypesOfTupleType: function (nodes) { return ts.cast(nodes, ts.isNodeArray); }, + parenthesizeElementTypeOfTupleType: ts.identity, + parenthesizeTypeOfOptionalType: ts.identity, + parenthesizeTypeArguments: function (nodes) { return nodes && ts.cast(nodes, ts.isNodeArray); }, + parenthesizeLeadingTypeArgument: ts.identity, + }; +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + function createNodeConverters(factory) { + return { + convertToFunctionBlock: convertToFunctionBlock, + convertToFunctionExpression: convertToFunctionExpression, + convertToArrayAssignmentElement: convertToArrayAssignmentElement, + convertToObjectAssignmentElement: convertToObjectAssignmentElement, + convertToAssignmentPattern: convertToAssignmentPattern, + convertToObjectAssignmentPattern: convertToObjectAssignmentPattern, + convertToArrayAssignmentPattern: convertToArrayAssignmentPattern, + convertToAssignmentElementTarget: convertToAssignmentElementTarget, + }; + function convertToFunctionBlock(node, multiLine) { + if (ts.isBlock(node)) + return node; + var returnStatement = factory.createReturnStatement(node); + ts.setTextRange(returnStatement, node); + var body = factory.createBlock([returnStatement], multiLine); + ts.setTextRange(body, node); + return body; + } + function convertToFunctionExpression(node) { + if (!node.body) + return ts.Debug.fail("Cannot convert a FunctionDeclaration without a body"); + var updated = factory.createFunctionExpression(node.modifiers, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body); + ts.setOriginalNode(updated, node); + ts.setTextRange(updated, node); + if (ts.getStartsOnNewLine(node)) { + ts.setStartsOnNewLine(updated, /*newLine*/ true); + } + return updated; + } + function convertToArrayAssignmentElement(element) { + if (ts.isBindingElement(element)) { + if (element.dotDotDotToken) { + ts.Debug.assertNode(element.name, ts.isIdentifier); + return ts.setOriginalNode(ts.setTextRange(factory.createSpreadElement(element.name), element), element); + } + var expression = convertToAssignmentElementTarget(element.name); + return element.initializer + ? ts.setOriginalNode(ts.setTextRange(factory.createAssignment(expression, element.initializer), element), element) + : expression; + } + return ts.cast(element, ts.isExpression); + } + function convertToObjectAssignmentElement(element) { + if (ts.isBindingElement(element)) { + if (element.dotDotDotToken) { + ts.Debug.assertNode(element.name, ts.isIdentifier); + return ts.setOriginalNode(ts.setTextRange(factory.createSpreadAssignment(element.name), element), element); + } + if (element.propertyName) { + var expression = convertToAssignmentElementTarget(element.name); + return ts.setOriginalNode(ts.setTextRange(factory.createPropertyAssignment(element.propertyName, element.initializer ? factory.createAssignment(expression, element.initializer) : expression), element), element); + } + ts.Debug.assertNode(element.name, ts.isIdentifier); + return ts.setOriginalNode(ts.setTextRange(factory.createShorthandPropertyAssignment(element.name, element.initializer), element), element); + } + return ts.cast(element, ts.isObjectLiteralElementLike); + } + function convertToAssignmentPattern(node) { + switch (node.kind) { + case 204 /* SyntaxKind.ArrayBindingPattern */: + case 206 /* SyntaxKind.ArrayLiteralExpression */: + return convertToArrayAssignmentPattern(node); + case 203 /* SyntaxKind.ObjectBindingPattern */: + case 207 /* SyntaxKind.ObjectLiteralExpression */: + return convertToObjectAssignmentPattern(node); + } + } + function convertToObjectAssignmentPattern(node) { + if (ts.isObjectBindingPattern(node)) { + return ts.setOriginalNode(ts.setTextRange(factory.createObjectLiteralExpression(ts.map(node.elements, convertToObjectAssignmentElement)), node), node); + } + return ts.cast(node, ts.isObjectLiteralExpression); + } + function convertToArrayAssignmentPattern(node) { + if (ts.isArrayBindingPattern(node)) { + return ts.setOriginalNode(ts.setTextRange(factory.createArrayLiteralExpression(ts.map(node.elements, convertToArrayAssignmentElement)), node), node); + } + return ts.cast(node, ts.isArrayLiteralExpression); + } + function convertToAssignmentElementTarget(node) { + if (ts.isBindingPattern(node)) { + return convertToAssignmentPattern(node); + } + return ts.cast(node, ts.isExpression); + } + } + ts.createNodeConverters = createNodeConverters; + ts.nullNodeConverters = { + convertToFunctionBlock: ts.notImplemented, + convertToFunctionExpression: ts.notImplemented, + convertToArrayAssignmentElement: ts.notImplemented, + convertToObjectAssignmentElement: ts.notImplemented, + convertToAssignmentPattern: ts.notImplemented, + convertToObjectAssignmentPattern: ts.notImplemented, + convertToArrayAssignmentPattern: ts.notImplemented, + convertToAssignmentElementTarget: ts.notImplemented, + }; +})(ts || (ts = {})); +var ts; +(function (ts) { + var nextAutoGenerateId = 0; + /* @internal */ + var NodeFactoryFlags; + (function (NodeFactoryFlags) { + NodeFactoryFlags[NodeFactoryFlags["None"] = 0] = "None"; + // Disables the parenthesizer rules for the factory. + NodeFactoryFlags[NodeFactoryFlags["NoParenthesizerRules"] = 1] = "NoParenthesizerRules"; + // Disables the node converters for the factory. + NodeFactoryFlags[NodeFactoryFlags["NoNodeConverters"] = 2] = "NoNodeConverters"; + // Ensures new `PropertyAccessExpression` nodes are created with the `NoIndentation` emit flag set. + NodeFactoryFlags[NodeFactoryFlags["NoIndentationOnFreshPropertyAccess"] = 4] = "NoIndentationOnFreshPropertyAccess"; + // Do not set an `original` pointer when updating a node. + NodeFactoryFlags[NodeFactoryFlags["NoOriginalNode"] = 8] = "NoOriginalNode"; + })(NodeFactoryFlags = ts.NodeFactoryFlags || (ts.NodeFactoryFlags = {})); + /** + * Creates a `NodeFactory` that can be used to create and update a syntax tree. + * @param flags Flags that control factory behavior. + * @param baseFactory A `BaseNodeFactory` used to create the base `Node` objects. + */ + /* @internal */ + function createNodeFactory(flags, baseFactory) { + var update = flags & 8 /* NodeFactoryFlags.NoOriginalNode */ ? updateWithoutOriginal : updateWithOriginal; + // Lazily load the parenthesizer, node converters, and some factory methods until they are used. + var parenthesizerRules = ts.memoize(function () { return flags & 1 /* NodeFactoryFlags.NoParenthesizerRules */ ? ts.nullParenthesizerRules : ts.createParenthesizerRules(factory); }); + var converters = ts.memoize(function () { return flags & 2 /* NodeFactoryFlags.NoNodeConverters */ ? ts.nullNodeConverters : ts.createNodeConverters(factory); }); + // lazy initializaton of common operator factories + var getBinaryCreateFunction = ts.memoizeOne(function (operator) { return function (left, right) { return createBinaryExpression(left, operator, right); }; }); + var getPrefixUnaryCreateFunction = ts.memoizeOne(function (operator) { return function (operand) { return createPrefixUnaryExpression(operator, operand); }; }); + var getPostfixUnaryCreateFunction = ts.memoizeOne(function (operator) { return function (operand) { return createPostfixUnaryExpression(operand, operator); }; }); + var getJSDocPrimaryTypeCreateFunction = ts.memoizeOne(function (kind) { return function () { return createJSDocPrimaryTypeWorker(kind); }; }); + var getJSDocUnaryTypeCreateFunction = ts.memoizeOne(function (kind) { return function (type) { return createJSDocUnaryTypeWorker(kind, type); }; }); + var getJSDocUnaryTypeUpdateFunction = ts.memoizeOne(function (kind) { return function (node, type) { return updateJSDocUnaryTypeWorker(kind, node, type); }; }); + var getJSDocPrePostfixUnaryTypeCreateFunction = ts.memoizeOne(function (kind) { return function (type, postfix) { return createJSDocPrePostfixUnaryTypeWorker(kind, type, postfix); }; }); + var getJSDocPrePostfixUnaryTypeUpdateFunction = ts.memoizeOne(function (kind) { return function (node, type) { return updateJSDocPrePostfixUnaryTypeWorker(kind, node, type); }; }); + var getJSDocSimpleTagCreateFunction = ts.memoizeOne(function (kind) { return function (tagName, comment) { return createJSDocSimpleTagWorker(kind, tagName, comment); }; }); + var getJSDocSimpleTagUpdateFunction = ts.memoizeOne(function (kind) { return function (node, tagName, comment) { return updateJSDocSimpleTagWorker(kind, node, tagName, comment); }; }); + var getJSDocTypeLikeTagCreateFunction = ts.memoizeOne(function (kind) { return function (tagName, typeExpression, comment) { return createJSDocTypeLikeTagWorker(kind, tagName, typeExpression, comment); }; }); + var getJSDocTypeLikeTagUpdateFunction = ts.memoizeOne(function (kind) { return function (node, tagName, typeExpression, comment) { return updateJSDocTypeLikeTagWorker(kind, node, tagName, typeExpression, comment); }; }); + var factory = { + get parenthesizer() { return parenthesizerRules(); }, + get converters() { return converters(); }, + baseFactory: baseFactory, + flags: flags, + createNodeArray: createNodeArray, + createNumericLiteral: createNumericLiteral, + createBigIntLiteral: createBigIntLiteral, + createStringLiteral: createStringLiteral, + createStringLiteralFromNode: createStringLiteralFromNode, + createRegularExpressionLiteral: createRegularExpressionLiteral, + createLiteralLikeNode: createLiteralLikeNode, + createIdentifier: createIdentifier, + updateIdentifier: updateIdentifier, + createTempVariable: createTempVariable, + createLoopVariable: createLoopVariable, + createUniqueName: createUniqueName, + getGeneratedNameForNode: getGeneratedNameForNode, + createPrivateIdentifier: createPrivateIdentifier, + createUniquePrivateName: createUniquePrivateName, + getGeneratedPrivateNameForNode: getGeneratedPrivateNameForNode, + createToken: createToken, + createSuper: createSuper, + createThis: createThis, + createNull: createNull, + createTrue: createTrue, + createFalse: createFalse, + createModifier: createModifier, + createModifiersFromModifierFlags: createModifiersFromModifierFlags, + createQualifiedName: createQualifiedName, + updateQualifiedName: updateQualifiedName, + createComputedPropertyName: createComputedPropertyName, + updateComputedPropertyName: updateComputedPropertyName, + createTypeParameterDeclaration: createTypeParameterDeclaration, + updateTypeParameterDeclaration: updateTypeParameterDeclaration, + createParameterDeclaration: createParameterDeclaration, + updateParameterDeclaration: updateParameterDeclaration, + createDecorator: createDecorator, + updateDecorator: updateDecorator, + createPropertySignature: createPropertySignature, + updatePropertySignature: updatePropertySignature, + createPropertyDeclaration: createPropertyDeclaration, + updatePropertyDeclaration: updatePropertyDeclaration, + createMethodSignature: createMethodSignature, + updateMethodSignature: updateMethodSignature, + createMethodDeclaration: createMethodDeclaration, + updateMethodDeclaration: updateMethodDeclaration, + createConstructorDeclaration: createConstructorDeclaration, + updateConstructorDeclaration: updateConstructorDeclaration, + createGetAccessorDeclaration: createGetAccessorDeclaration, + updateGetAccessorDeclaration: updateGetAccessorDeclaration, + createSetAccessorDeclaration: createSetAccessorDeclaration, + updateSetAccessorDeclaration: updateSetAccessorDeclaration, + createCallSignature: createCallSignature, + updateCallSignature: updateCallSignature, + createConstructSignature: createConstructSignature, + updateConstructSignature: updateConstructSignature, + createIndexSignature: createIndexSignature, + updateIndexSignature: updateIndexSignature, + createClassStaticBlockDeclaration: createClassStaticBlockDeclaration, + updateClassStaticBlockDeclaration: updateClassStaticBlockDeclaration, + createTemplateLiteralTypeSpan: createTemplateLiteralTypeSpan, + updateTemplateLiteralTypeSpan: updateTemplateLiteralTypeSpan, + createKeywordTypeNode: createKeywordTypeNode, + createTypePredicateNode: createTypePredicateNode, + updateTypePredicateNode: updateTypePredicateNode, + createTypeReferenceNode: createTypeReferenceNode, + updateTypeReferenceNode: updateTypeReferenceNode, + createFunctionTypeNode: createFunctionTypeNode, + updateFunctionTypeNode: updateFunctionTypeNode, + createConstructorTypeNode: createConstructorTypeNode, + updateConstructorTypeNode: updateConstructorTypeNode, + createTypeQueryNode: createTypeQueryNode, + updateTypeQueryNode: updateTypeQueryNode, + createTypeLiteralNode: createTypeLiteralNode, + updateTypeLiteralNode: updateTypeLiteralNode, + createArrayTypeNode: createArrayTypeNode, + updateArrayTypeNode: updateArrayTypeNode, + createTupleTypeNode: createTupleTypeNode, + updateTupleTypeNode: updateTupleTypeNode, + createNamedTupleMember: createNamedTupleMember, + updateNamedTupleMember: updateNamedTupleMember, + createOptionalTypeNode: createOptionalTypeNode, + updateOptionalTypeNode: updateOptionalTypeNode, + createRestTypeNode: createRestTypeNode, + updateRestTypeNode: updateRestTypeNode, + createUnionTypeNode: createUnionTypeNode, + updateUnionTypeNode: updateUnionTypeNode, + createIntersectionTypeNode: createIntersectionTypeNode, + updateIntersectionTypeNode: updateIntersectionTypeNode, + createConditionalTypeNode: createConditionalTypeNode, + updateConditionalTypeNode: updateConditionalTypeNode, + createInferTypeNode: createInferTypeNode, + updateInferTypeNode: updateInferTypeNode, + createImportTypeNode: createImportTypeNode, + updateImportTypeNode: updateImportTypeNode, + createParenthesizedType: createParenthesizedType, + updateParenthesizedType: updateParenthesizedType, + createThisTypeNode: createThisTypeNode, + createTypeOperatorNode: createTypeOperatorNode, + updateTypeOperatorNode: updateTypeOperatorNode, + createIndexedAccessTypeNode: createIndexedAccessTypeNode, + updateIndexedAccessTypeNode: updateIndexedAccessTypeNode, + createMappedTypeNode: createMappedTypeNode, + updateMappedTypeNode: updateMappedTypeNode, + createLiteralTypeNode: createLiteralTypeNode, + updateLiteralTypeNode: updateLiteralTypeNode, + createTemplateLiteralType: createTemplateLiteralType, + updateTemplateLiteralType: updateTemplateLiteralType, + createObjectBindingPattern: createObjectBindingPattern, + updateObjectBindingPattern: updateObjectBindingPattern, + createArrayBindingPattern: createArrayBindingPattern, + updateArrayBindingPattern: updateArrayBindingPattern, + createBindingElement: createBindingElement, + updateBindingElement: updateBindingElement, + createArrayLiteralExpression: createArrayLiteralExpression, + updateArrayLiteralExpression: updateArrayLiteralExpression, + createObjectLiteralExpression: createObjectLiteralExpression, + updateObjectLiteralExpression: updateObjectLiteralExpression, + createPropertyAccessExpression: flags & 4 /* NodeFactoryFlags.NoIndentationOnFreshPropertyAccess */ ? + function (expression, name) { return ts.setEmitFlags(createPropertyAccessExpression(expression, name), 131072 /* EmitFlags.NoIndentation */); } : + createPropertyAccessExpression, + updatePropertyAccessExpression: updatePropertyAccessExpression, + createPropertyAccessChain: flags & 4 /* NodeFactoryFlags.NoIndentationOnFreshPropertyAccess */ ? + function (expression, questionDotToken, name) { return ts.setEmitFlags(createPropertyAccessChain(expression, questionDotToken, name), 131072 /* EmitFlags.NoIndentation */); } : + createPropertyAccessChain, + updatePropertyAccessChain: updatePropertyAccessChain, + createElementAccessExpression: createElementAccessExpression, + updateElementAccessExpression: updateElementAccessExpression, + createElementAccessChain: createElementAccessChain, + updateElementAccessChain: updateElementAccessChain, + createCallExpression: createCallExpression, + updateCallExpression: updateCallExpression, + createCallChain: createCallChain, + updateCallChain: updateCallChain, + createNewExpression: createNewExpression, + updateNewExpression: updateNewExpression, + createTaggedTemplateExpression: createTaggedTemplateExpression, + updateTaggedTemplateExpression: updateTaggedTemplateExpression, + createTypeAssertion: createTypeAssertion, + updateTypeAssertion: updateTypeAssertion, + createParenthesizedExpression: createParenthesizedExpression, + updateParenthesizedExpression: updateParenthesizedExpression, + createFunctionExpression: createFunctionExpression, + updateFunctionExpression: updateFunctionExpression, + createArrowFunction: createArrowFunction, + updateArrowFunction: updateArrowFunction, + createDeleteExpression: createDeleteExpression, + updateDeleteExpression: updateDeleteExpression, + createTypeOfExpression: createTypeOfExpression, + updateTypeOfExpression: updateTypeOfExpression, + createVoidExpression: createVoidExpression, + updateVoidExpression: updateVoidExpression, + createAwaitExpression: createAwaitExpression, + updateAwaitExpression: updateAwaitExpression, + createPrefixUnaryExpression: createPrefixUnaryExpression, + updatePrefixUnaryExpression: updatePrefixUnaryExpression, + createPostfixUnaryExpression: createPostfixUnaryExpression, + updatePostfixUnaryExpression: updatePostfixUnaryExpression, + createBinaryExpression: createBinaryExpression, + updateBinaryExpression: updateBinaryExpression, + createConditionalExpression: createConditionalExpression, + updateConditionalExpression: updateConditionalExpression, + createTemplateExpression: createTemplateExpression, + updateTemplateExpression: updateTemplateExpression, + createTemplateHead: createTemplateHead, + createTemplateMiddle: createTemplateMiddle, + createTemplateTail: createTemplateTail, + createNoSubstitutionTemplateLiteral: createNoSubstitutionTemplateLiteral, + createTemplateLiteralLikeNode: createTemplateLiteralLikeNode, + createYieldExpression: createYieldExpression, + updateYieldExpression: updateYieldExpression, + createSpreadElement: createSpreadElement, + updateSpreadElement: updateSpreadElement, + createClassExpression: createClassExpression, + updateClassExpression: updateClassExpression, + createOmittedExpression: createOmittedExpression, + createExpressionWithTypeArguments: createExpressionWithTypeArguments, + updateExpressionWithTypeArguments: updateExpressionWithTypeArguments, + createAsExpression: createAsExpression, + updateAsExpression: updateAsExpression, + createNonNullExpression: createNonNullExpression, + updateNonNullExpression: updateNonNullExpression, + createSatisfiesExpression: createSatisfiesExpression, + updateSatisfiesExpression: updateSatisfiesExpression, + createNonNullChain: createNonNullChain, + updateNonNullChain: updateNonNullChain, + createMetaProperty: createMetaProperty, + updateMetaProperty: updateMetaProperty, + createTemplateSpan: createTemplateSpan, + updateTemplateSpan: updateTemplateSpan, + createSemicolonClassElement: createSemicolonClassElement, + createBlock: createBlock, + updateBlock: updateBlock, + createVariableStatement: createVariableStatement, + updateVariableStatement: updateVariableStatement, + createEmptyStatement: createEmptyStatement, + createExpressionStatement: createExpressionStatement, + updateExpressionStatement: updateExpressionStatement, + createIfStatement: createIfStatement, + updateIfStatement: updateIfStatement, + createDoStatement: createDoStatement, + updateDoStatement: updateDoStatement, + createWhileStatement: createWhileStatement, + updateWhileStatement: updateWhileStatement, + createForStatement: createForStatement, + updateForStatement: updateForStatement, + createForInStatement: createForInStatement, + updateForInStatement: updateForInStatement, + createForOfStatement: createForOfStatement, + updateForOfStatement: updateForOfStatement, + createContinueStatement: createContinueStatement, + updateContinueStatement: updateContinueStatement, + createBreakStatement: createBreakStatement, + updateBreakStatement: updateBreakStatement, + createReturnStatement: createReturnStatement, + updateReturnStatement: updateReturnStatement, + createWithStatement: createWithStatement, + updateWithStatement: updateWithStatement, + createSwitchStatement: createSwitchStatement, + updateSwitchStatement: updateSwitchStatement, + createLabeledStatement: createLabeledStatement, + updateLabeledStatement: updateLabeledStatement, + createThrowStatement: createThrowStatement, + updateThrowStatement: updateThrowStatement, + createTryStatement: createTryStatement, + updateTryStatement: updateTryStatement, + createDebuggerStatement: createDebuggerStatement, + createVariableDeclaration: createVariableDeclaration, + updateVariableDeclaration: updateVariableDeclaration, + createVariableDeclarationList: createVariableDeclarationList, + updateVariableDeclarationList: updateVariableDeclarationList, + createFunctionDeclaration: createFunctionDeclaration, + updateFunctionDeclaration: updateFunctionDeclaration, + createClassDeclaration: createClassDeclaration, + updateClassDeclaration: updateClassDeclaration, + createInterfaceDeclaration: createInterfaceDeclaration, + updateInterfaceDeclaration: updateInterfaceDeclaration, + createTypeAliasDeclaration: createTypeAliasDeclaration, + updateTypeAliasDeclaration: updateTypeAliasDeclaration, + createEnumDeclaration: createEnumDeclaration, + updateEnumDeclaration: updateEnumDeclaration, + createModuleDeclaration: createModuleDeclaration, + updateModuleDeclaration: updateModuleDeclaration, + createModuleBlock: createModuleBlock, + updateModuleBlock: updateModuleBlock, + createCaseBlock: createCaseBlock, + updateCaseBlock: updateCaseBlock, + createNamespaceExportDeclaration: createNamespaceExportDeclaration, + updateNamespaceExportDeclaration: updateNamespaceExportDeclaration, + createImportEqualsDeclaration: createImportEqualsDeclaration, + updateImportEqualsDeclaration: updateImportEqualsDeclaration, + createImportDeclaration: createImportDeclaration, + updateImportDeclaration: updateImportDeclaration, + createImportClause: createImportClause, + updateImportClause: updateImportClause, + createAssertClause: createAssertClause, + updateAssertClause: updateAssertClause, + createAssertEntry: createAssertEntry, + updateAssertEntry: updateAssertEntry, + createImportTypeAssertionContainer: createImportTypeAssertionContainer, + updateImportTypeAssertionContainer: updateImportTypeAssertionContainer, + createNamespaceImport: createNamespaceImport, + updateNamespaceImport: updateNamespaceImport, + createNamespaceExport: createNamespaceExport, + updateNamespaceExport: updateNamespaceExport, + createNamedImports: createNamedImports, + updateNamedImports: updateNamedImports, + createImportSpecifier: createImportSpecifier, + updateImportSpecifier: updateImportSpecifier, + createExportAssignment: createExportAssignment, + updateExportAssignment: updateExportAssignment, + createExportDeclaration: createExportDeclaration, + updateExportDeclaration: updateExportDeclaration, + createNamedExports: createNamedExports, + updateNamedExports: updateNamedExports, + createExportSpecifier: createExportSpecifier, + updateExportSpecifier: updateExportSpecifier, + createMissingDeclaration: createMissingDeclaration, + createExternalModuleReference: createExternalModuleReference, + updateExternalModuleReference: updateExternalModuleReference, + // lazily load factory members for JSDoc types with similar structure + get createJSDocAllType() { return getJSDocPrimaryTypeCreateFunction(315 /* SyntaxKind.JSDocAllType */); }, + get createJSDocUnknownType() { return getJSDocPrimaryTypeCreateFunction(316 /* SyntaxKind.JSDocUnknownType */); }, + get createJSDocNonNullableType() { return getJSDocPrePostfixUnaryTypeCreateFunction(318 /* SyntaxKind.JSDocNonNullableType */); }, + get updateJSDocNonNullableType() { return getJSDocPrePostfixUnaryTypeUpdateFunction(318 /* SyntaxKind.JSDocNonNullableType */); }, + get createJSDocNullableType() { return getJSDocPrePostfixUnaryTypeCreateFunction(317 /* SyntaxKind.JSDocNullableType */); }, + get updateJSDocNullableType() { return getJSDocPrePostfixUnaryTypeUpdateFunction(317 /* SyntaxKind.JSDocNullableType */); }, + get createJSDocOptionalType() { return getJSDocUnaryTypeCreateFunction(319 /* SyntaxKind.JSDocOptionalType */); }, + get updateJSDocOptionalType() { return getJSDocUnaryTypeUpdateFunction(319 /* SyntaxKind.JSDocOptionalType */); }, + get createJSDocVariadicType() { return getJSDocUnaryTypeCreateFunction(321 /* SyntaxKind.JSDocVariadicType */); }, + get updateJSDocVariadicType() { return getJSDocUnaryTypeUpdateFunction(321 /* SyntaxKind.JSDocVariadicType */); }, + get createJSDocNamepathType() { return getJSDocUnaryTypeCreateFunction(322 /* SyntaxKind.JSDocNamepathType */); }, + get updateJSDocNamepathType() { return getJSDocUnaryTypeUpdateFunction(322 /* SyntaxKind.JSDocNamepathType */); }, + createJSDocFunctionType: createJSDocFunctionType, + updateJSDocFunctionType: updateJSDocFunctionType, + createJSDocTypeLiteral: createJSDocTypeLiteral, + updateJSDocTypeLiteral: updateJSDocTypeLiteral, + createJSDocTypeExpression: createJSDocTypeExpression, + updateJSDocTypeExpression: updateJSDocTypeExpression, + createJSDocSignature: createJSDocSignature, + updateJSDocSignature: updateJSDocSignature, + createJSDocTemplateTag: createJSDocTemplateTag, + updateJSDocTemplateTag: updateJSDocTemplateTag, + createJSDocTypedefTag: createJSDocTypedefTag, + updateJSDocTypedefTag: updateJSDocTypedefTag, + createJSDocParameterTag: createJSDocParameterTag, + updateJSDocParameterTag: updateJSDocParameterTag, + createJSDocPropertyTag: createJSDocPropertyTag, + updateJSDocPropertyTag: updateJSDocPropertyTag, + createJSDocCallbackTag: createJSDocCallbackTag, + updateJSDocCallbackTag: updateJSDocCallbackTag, + createJSDocAugmentsTag: createJSDocAugmentsTag, + updateJSDocAugmentsTag: updateJSDocAugmentsTag, + createJSDocImplementsTag: createJSDocImplementsTag, + updateJSDocImplementsTag: updateJSDocImplementsTag, + createJSDocSeeTag: createJSDocSeeTag, + updateJSDocSeeTag: updateJSDocSeeTag, + createJSDocNameReference: createJSDocNameReference, + updateJSDocNameReference: updateJSDocNameReference, + createJSDocMemberName: createJSDocMemberName, + updateJSDocMemberName: updateJSDocMemberName, + createJSDocLink: createJSDocLink, + updateJSDocLink: updateJSDocLink, + createJSDocLinkCode: createJSDocLinkCode, + updateJSDocLinkCode: updateJSDocLinkCode, + createJSDocLinkPlain: createJSDocLinkPlain, + updateJSDocLinkPlain: updateJSDocLinkPlain, + // lazily load factory members for JSDoc tags with similar structure + get createJSDocTypeTag() { return getJSDocTypeLikeTagCreateFunction(346 /* SyntaxKind.JSDocTypeTag */); }, + get updateJSDocTypeTag() { return getJSDocTypeLikeTagUpdateFunction(346 /* SyntaxKind.JSDocTypeTag */); }, + get createJSDocReturnTag() { return getJSDocTypeLikeTagCreateFunction(344 /* SyntaxKind.JSDocReturnTag */); }, + get updateJSDocReturnTag() { return getJSDocTypeLikeTagUpdateFunction(344 /* SyntaxKind.JSDocReturnTag */); }, + get createJSDocThisTag() { return getJSDocTypeLikeTagCreateFunction(345 /* SyntaxKind.JSDocThisTag */); }, + get updateJSDocThisTag() { return getJSDocTypeLikeTagUpdateFunction(345 /* SyntaxKind.JSDocThisTag */); }, + get createJSDocEnumTag() { return getJSDocTypeLikeTagCreateFunction(342 /* SyntaxKind.JSDocEnumTag */); }, + get updateJSDocEnumTag() { return getJSDocTypeLikeTagUpdateFunction(342 /* SyntaxKind.JSDocEnumTag */); }, + get createJSDocAuthorTag() { return getJSDocSimpleTagCreateFunction(333 /* SyntaxKind.JSDocAuthorTag */); }, + get updateJSDocAuthorTag() { return getJSDocSimpleTagUpdateFunction(333 /* SyntaxKind.JSDocAuthorTag */); }, + get createJSDocClassTag() { return getJSDocSimpleTagCreateFunction(335 /* SyntaxKind.JSDocClassTag */); }, + get updateJSDocClassTag() { return getJSDocSimpleTagUpdateFunction(335 /* SyntaxKind.JSDocClassTag */); }, + get createJSDocPublicTag() { return getJSDocSimpleTagCreateFunction(336 /* SyntaxKind.JSDocPublicTag */); }, + get updateJSDocPublicTag() { return getJSDocSimpleTagUpdateFunction(336 /* SyntaxKind.JSDocPublicTag */); }, + get createJSDocPrivateTag() { return getJSDocSimpleTagCreateFunction(337 /* SyntaxKind.JSDocPrivateTag */); }, + get updateJSDocPrivateTag() { return getJSDocSimpleTagUpdateFunction(337 /* SyntaxKind.JSDocPrivateTag */); }, + get createJSDocProtectedTag() { return getJSDocSimpleTagCreateFunction(338 /* SyntaxKind.JSDocProtectedTag */); }, + get updateJSDocProtectedTag() { return getJSDocSimpleTagUpdateFunction(338 /* SyntaxKind.JSDocProtectedTag */); }, + get createJSDocReadonlyTag() { return getJSDocSimpleTagCreateFunction(339 /* SyntaxKind.JSDocReadonlyTag */); }, + get updateJSDocReadonlyTag() { return getJSDocSimpleTagUpdateFunction(339 /* SyntaxKind.JSDocReadonlyTag */); }, + get createJSDocOverrideTag() { return getJSDocSimpleTagCreateFunction(340 /* SyntaxKind.JSDocOverrideTag */); }, + get updateJSDocOverrideTag() { return getJSDocSimpleTagUpdateFunction(340 /* SyntaxKind.JSDocOverrideTag */); }, + get createJSDocDeprecatedTag() { return getJSDocSimpleTagCreateFunction(334 /* SyntaxKind.JSDocDeprecatedTag */); }, + get updateJSDocDeprecatedTag() { return getJSDocSimpleTagUpdateFunction(334 /* SyntaxKind.JSDocDeprecatedTag */); }, + createJSDocUnknownTag: createJSDocUnknownTag, + updateJSDocUnknownTag: updateJSDocUnknownTag, + createJSDocText: createJSDocText, + updateJSDocText: updateJSDocText, + createJSDocComment: createJSDocComment, + updateJSDocComment: updateJSDocComment, + createJsxElement: createJsxElement, + updateJsxElement: updateJsxElement, + createJsxSelfClosingElement: createJsxSelfClosingElement, + updateJsxSelfClosingElement: updateJsxSelfClosingElement, + createJsxOpeningElement: createJsxOpeningElement, + updateJsxOpeningElement: updateJsxOpeningElement, + createJsxClosingElement: createJsxClosingElement, + updateJsxClosingElement: updateJsxClosingElement, + createJsxFragment: createJsxFragment, + createJsxText: createJsxText, + updateJsxText: updateJsxText, + createJsxOpeningFragment: createJsxOpeningFragment, + createJsxJsxClosingFragment: createJsxJsxClosingFragment, + updateJsxFragment: updateJsxFragment, + createJsxAttribute: createJsxAttribute, + updateJsxAttribute: updateJsxAttribute, + createJsxAttributes: createJsxAttributes, + updateJsxAttributes: updateJsxAttributes, + createJsxSpreadAttribute: createJsxSpreadAttribute, + updateJsxSpreadAttribute: updateJsxSpreadAttribute, + createJsxExpression: createJsxExpression, + updateJsxExpression: updateJsxExpression, + createCaseClause: createCaseClause, + updateCaseClause: updateCaseClause, + createDefaultClause: createDefaultClause, + updateDefaultClause: updateDefaultClause, + createHeritageClause: createHeritageClause, + updateHeritageClause: updateHeritageClause, + createCatchClause: createCatchClause, + updateCatchClause: updateCatchClause, + createPropertyAssignment: createPropertyAssignment, + updatePropertyAssignment: updatePropertyAssignment, + createShorthandPropertyAssignment: createShorthandPropertyAssignment, + updateShorthandPropertyAssignment: updateShorthandPropertyAssignment, + createSpreadAssignment: createSpreadAssignment, + updateSpreadAssignment: updateSpreadAssignment, + createEnumMember: createEnumMember, + updateEnumMember: updateEnumMember, + createSourceFile: createSourceFile, + updateSourceFile: updateSourceFile, + createBundle: createBundle, + updateBundle: updateBundle, + createUnparsedSource: createUnparsedSource, + createUnparsedPrologue: createUnparsedPrologue, + createUnparsedPrepend: createUnparsedPrepend, + createUnparsedTextLike: createUnparsedTextLike, + createUnparsedSyntheticReference: createUnparsedSyntheticReference, + createInputFiles: createInputFiles, + createSyntheticExpression: createSyntheticExpression, + createSyntaxList: createSyntaxList, + createNotEmittedStatement: createNotEmittedStatement, + createPartiallyEmittedExpression: createPartiallyEmittedExpression, + updatePartiallyEmittedExpression: updatePartiallyEmittedExpression, + createCommaListExpression: createCommaListExpression, + updateCommaListExpression: updateCommaListExpression, + createEndOfDeclarationMarker: createEndOfDeclarationMarker, + createMergeDeclarationMarker: createMergeDeclarationMarker, + createSyntheticReferenceExpression: createSyntheticReferenceExpression, + updateSyntheticReferenceExpression: updateSyntheticReferenceExpression, + cloneNode: cloneNode, + // Lazily load factory methods for common operator factories and utilities + get createComma() { return getBinaryCreateFunction(27 /* SyntaxKind.CommaToken */); }, + get createAssignment() { return getBinaryCreateFunction(63 /* SyntaxKind.EqualsToken */); }, + get createLogicalOr() { return getBinaryCreateFunction(56 /* SyntaxKind.BarBarToken */); }, + get createLogicalAnd() { return getBinaryCreateFunction(55 /* SyntaxKind.AmpersandAmpersandToken */); }, + get createBitwiseOr() { return getBinaryCreateFunction(51 /* SyntaxKind.BarToken */); }, + get createBitwiseXor() { return getBinaryCreateFunction(52 /* SyntaxKind.CaretToken */); }, + get createBitwiseAnd() { return getBinaryCreateFunction(50 /* SyntaxKind.AmpersandToken */); }, + get createStrictEquality() { return getBinaryCreateFunction(36 /* SyntaxKind.EqualsEqualsEqualsToken */); }, + get createStrictInequality() { return getBinaryCreateFunction(37 /* SyntaxKind.ExclamationEqualsEqualsToken */); }, + get createEquality() { return getBinaryCreateFunction(34 /* SyntaxKind.EqualsEqualsToken */); }, + get createInequality() { return getBinaryCreateFunction(35 /* SyntaxKind.ExclamationEqualsToken */); }, + get createLessThan() { return getBinaryCreateFunction(29 /* SyntaxKind.LessThanToken */); }, + get createLessThanEquals() { return getBinaryCreateFunction(32 /* SyntaxKind.LessThanEqualsToken */); }, + get createGreaterThan() { return getBinaryCreateFunction(31 /* SyntaxKind.GreaterThanToken */); }, + get createGreaterThanEquals() { return getBinaryCreateFunction(33 /* SyntaxKind.GreaterThanEqualsToken */); }, + get createLeftShift() { return getBinaryCreateFunction(47 /* SyntaxKind.LessThanLessThanToken */); }, + get createRightShift() { return getBinaryCreateFunction(48 /* SyntaxKind.GreaterThanGreaterThanToken */); }, + get createUnsignedRightShift() { return getBinaryCreateFunction(49 /* SyntaxKind.GreaterThanGreaterThanGreaterThanToken */); }, + get createAdd() { return getBinaryCreateFunction(39 /* SyntaxKind.PlusToken */); }, + get createSubtract() { return getBinaryCreateFunction(40 /* SyntaxKind.MinusToken */); }, + get createMultiply() { return getBinaryCreateFunction(41 /* SyntaxKind.AsteriskToken */); }, + get createDivide() { return getBinaryCreateFunction(43 /* SyntaxKind.SlashToken */); }, + get createModulo() { return getBinaryCreateFunction(44 /* SyntaxKind.PercentToken */); }, + get createExponent() { return getBinaryCreateFunction(42 /* SyntaxKind.AsteriskAsteriskToken */); }, + get createPrefixPlus() { return getPrefixUnaryCreateFunction(39 /* SyntaxKind.PlusToken */); }, + get createPrefixMinus() { return getPrefixUnaryCreateFunction(40 /* SyntaxKind.MinusToken */); }, + get createPrefixIncrement() { return getPrefixUnaryCreateFunction(45 /* SyntaxKind.PlusPlusToken */); }, + get createPrefixDecrement() { return getPrefixUnaryCreateFunction(46 /* SyntaxKind.MinusMinusToken */); }, + get createBitwiseNot() { return getPrefixUnaryCreateFunction(54 /* SyntaxKind.TildeToken */); }, + get createLogicalNot() { return getPrefixUnaryCreateFunction(53 /* SyntaxKind.ExclamationToken */); }, + get createPostfixIncrement() { return getPostfixUnaryCreateFunction(45 /* SyntaxKind.PlusPlusToken */); }, + get createPostfixDecrement() { return getPostfixUnaryCreateFunction(46 /* SyntaxKind.MinusMinusToken */); }, + // Compound nodes + createImmediatelyInvokedFunctionExpression: createImmediatelyInvokedFunctionExpression, + createImmediatelyInvokedArrowFunction: createImmediatelyInvokedArrowFunction, + createVoidZero: createVoidZero, + createExportDefault: createExportDefault, + createExternalModuleExport: createExternalModuleExport, + createTypeCheck: createTypeCheck, + createMethodCall: createMethodCall, + createGlobalMethodCall: createGlobalMethodCall, + createFunctionBindCall: createFunctionBindCall, + createFunctionCallCall: createFunctionCallCall, + createFunctionApplyCall: createFunctionApplyCall, + createArraySliceCall: createArraySliceCall, + createArrayConcatCall: createArrayConcatCall, + createObjectDefinePropertyCall: createObjectDefinePropertyCall, + createReflectGetCall: createReflectGetCall, + createReflectSetCall: createReflectSetCall, + createPropertyDescriptor: createPropertyDescriptor, + createCallBinding: createCallBinding, + createAssignmentTargetWrapper: createAssignmentTargetWrapper, + // Utilities + inlineExpressions: inlineExpressions, + getInternalName: getInternalName, + getLocalName: getLocalName, + getExportName: getExportName, + getDeclarationName: getDeclarationName, + getNamespaceMemberName: getNamespaceMemberName, + getExternalModuleOrNamespaceExportName: getExternalModuleOrNamespaceExportName, + restoreOuterExpressions: restoreOuterExpressions, + restoreEnclosingLabel: restoreEnclosingLabel, + createUseStrictPrologue: createUseStrictPrologue, + copyPrologue: copyPrologue, + copyStandardPrologue: copyStandardPrologue, + copyCustomPrologue: copyCustomPrologue, + ensureUseStrict: ensureUseStrict, + liftToBlock: liftToBlock, + mergeLexicalEnvironment: mergeLexicalEnvironment, + updateModifiers: updateModifiers, + }; + return factory; + // @api + function createNodeArray(elements, hasTrailingComma) { + if (elements === undefined || elements === ts.emptyArray) { + elements = []; + } + else if (ts.isNodeArray(elements)) { + if (hasTrailingComma === undefined || elements.hasTrailingComma === hasTrailingComma) { + // Ensure the transform flags have been aggregated for this NodeArray + if (elements.transformFlags === undefined) { + aggregateChildrenFlags(elements); + } + ts.Debug.attachNodeArrayDebugInfo(elements); + return elements; + } + // This *was* a `NodeArray`, but the `hasTrailingComma` option differs. Recreate the + // array with the same elements, text range, and transform flags but with the updated + // value for `hasTrailingComma` + var array_8 = elements.slice(); + array_8.pos = elements.pos; + array_8.end = elements.end; + array_8.hasTrailingComma = hasTrailingComma; + array_8.transformFlags = elements.transformFlags; + ts.Debug.attachNodeArrayDebugInfo(array_8); + return array_8; + } + // Since the element list of a node array is typically created by starting with an empty array and + // repeatedly calling push(), the list may not have the optimal memory layout. We invoke slice() for + // small arrays (1 to 4 elements) to give the VM a chance to allocate an optimal representation. + var length = elements.length; + var array = (length >= 1 && length <= 4 ? elements.slice() : elements); + ts.setTextRangePosEnd(array, -1, -1); + array.hasTrailingComma = !!hasTrailingComma; + aggregateChildrenFlags(array); + ts.Debug.attachNodeArrayDebugInfo(array); + return array; + } + function createBaseNode(kind) { + return baseFactory.createBaseNode(kind); + } + function createBaseDeclaration(kind) { + var node = createBaseNode(kind); + // NOTE: The following properties are commonly set by the binder and are added here to + // ensure declarations have a stable shape. + node.symbol = undefined; // initialized by binder + node.localSymbol = undefined; // initialized by binder + node.locals = undefined; // initialized by binder + node.nextContainer = undefined; // initialized by binder + return node; + } + function createBaseNamedDeclaration(kind, modifiers, name) { + var node = createBaseDeclaration(kind); + name = asName(name); + node.name = name; + if (ts.canHaveModifiers(node)) { + node.modifiers = asNodeArray(modifiers); + node.transformFlags |= propagateChildrenFlags(node.modifiers); + // node.decorators = filter(node.modifiers, isDecorator); + } + // The PropertyName of a member is allowed to be `await`. + // We don't need to exclude `await` for type signatures since types + // don't propagate child flags. + if (name) { + switch (node.kind) { + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 299 /* SyntaxKind.PropertyAssignment */: + if (ts.isIdentifier(name)) { + node.transformFlags |= propagateIdentifierNameFlags(name); + break; + } + // fall through + default: + node.transformFlags |= propagateChildFlags(name); + break; + } + } + return node; + } + function createBaseGenericNamedDeclaration(kind, modifiers, name, typeParameters) { + var node = createBaseNamedDeclaration(kind, modifiers, name); + node.typeParameters = asNodeArray(typeParameters); + node.transformFlags |= propagateChildrenFlags(node.typeParameters); + if (typeParameters) + node.transformFlags |= 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + function createBaseSignatureDeclaration(kind, modifiers, name, typeParameters, parameters, type) { + var node = createBaseGenericNamedDeclaration(kind, modifiers, name, typeParameters); + node.parameters = createNodeArray(parameters); + node.type = type; + node.transformFlags |= + propagateChildrenFlags(node.parameters) | + propagateChildFlags(node.type); + if (type) + node.transformFlags |= 1 /* TransformFlags.ContainsTypeScript */; + // The following properties are used for quick info + node.typeArguments = undefined; + return node; + } + function finishUpdateBaseSignatureDeclaration(updated, original) { + if (updated !== original) { + // copy children used for quick info + updated.typeArguments = original.typeArguments; + } + return update(updated, original); + } + function createBaseFunctionLikeDeclaration(kind, modifiers, name, typeParameters, parameters, type, body) { + var node = createBaseSignatureDeclaration(kind, modifiers, name, typeParameters, parameters, type); + node.body = body; + node.transformFlags |= propagateChildFlags(node.body) & ~67108864 /* TransformFlags.ContainsPossibleTopLevelAwait */; + if (!body) + node.transformFlags |= 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + function createBaseInterfaceOrClassLikeDeclaration(kind, modifiers, name, typeParameters, heritageClauses) { + var node = createBaseGenericNamedDeclaration(kind, modifiers, name, typeParameters); + node.heritageClauses = asNodeArray(heritageClauses); + node.transformFlags |= propagateChildrenFlags(node.heritageClauses); + return node; + } + function createBaseClassLikeDeclaration(kind, modifiers, name, typeParameters, heritageClauses, members) { + var node = createBaseInterfaceOrClassLikeDeclaration(kind, modifiers, name, typeParameters, heritageClauses); + node.members = createNodeArray(members); + node.transformFlags |= propagateChildrenFlags(node.members); + return node; + } + function createBaseBindingLikeDeclaration(kind, modifiers, name, initializer) { + var node = createBaseNamedDeclaration(kind, modifiers, name); + node.initializer = initializer; + node.transformFlags |= propagateChildFlags(node.initializer); + return node; + } + function createBaseVariableLikeDeclaration(kind, modifiers, name, type, initializer) { + var node = createBaseBindingLikeDeclaration(kind, modifiers, name, initializer); + node.type = type; + node.transformFlags |= propagateChildFlags(type); + if (type) + node.transformFlags |= 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // + // Literals + // + function createBaseLiteral(kind, text) { + var node = createBaseToken(kind); + node.text = text; + return node; + } + // @api + function createNumericLiteral(value, numericLiteralFlags) { + if (numericLiteralFlags === void 0) { numericLiteralFlags = 0 /* TokenFlags.None */; } + var node = createBaseLiteral(8 /* SyntaxKind.NumericLiteral */, typeof value === "number" ? value + "" : value); + node.numericLiteralFlags = numericLiteralFlags; + if (numericLiteralFlags & 384 /* TokenFlags.BinaryOrOctalSpecifier */) + node.transformFlags |= 1024 /* TransformFlags.ContainsES2015 */; + return node; + } + // @api + function createBigIntLiteral(value) { + var node = createBaseLiteral(9 /* SyntaxKind.BigIntLiteral */, typeof value === "string" ? value : ts.pseudoBigIntToString(value) + "n"); + node.transformFlags |= 4 /* TransformFlags.ContainsESNext */; + return node; + } + function createBaseStringLiteral(text, isSingleQuote) { + var node = createBaseLiteral(10 /* SyntaxKind.StringLiteral */, text); + node.singleQuote = isSingleQuote; + return node; + } + // @api + function createStringLiteral(text, isSingleQuote, hasExtendedUnicodeEscape) { + var node = createBaseStringLiteral(text, isSingleQuote); + node.hasExtendedUnicodeEscape = hasExtendedUnicodeEscape; + if (hasExtendedUnicodeEscape) + node.transformFlags |= 1024 /* TransformFlags.ContainsES2015 */; + return node; + } + // @api + function createStringLiteralFromNode(sourceNode) { + var node = createBaseStringLiteral(ts.getTextOfIdentifierOrLiteral(sourceNode), /*isSingleQuote*/ undefined); + node.textSourceNode = sourceNode; + return node; + } + // @api + function createRegularExpressionLiteral(text) { + var node = createBaseLiteral(13 /* SyntaxKind.RegularExpressionLiteral */, text); + return node; + } + // @api + function createLiteralLikeNode(kind, text) { + switch (kind) { + case 8 /* SyntaxKind.NumericLiteral */: return createNumericLiteral(text, /*numericLiteralFlags*/ 0); + case 9 /* SyntaxKind.BigIntLiteral */: return createBigIntLiteral(text); + case 10 /* SyntaxKind.StringLiteral */: return createStringLiteral(text, /*isSingleQuote*/ undefined); + case 11 /* SyntaxKind.JsxText */: return createJsxText(text, /*containsOnlyTriviaWhiteSpaces*/ false); + case 12 /* SyntaxKind.JsxTextAllWhiteSpaces */: return createJsxText(text, /*containsOnlyTriviaWhiteSpaces*/ true); + case 13 /* SyntaxKind.RegularExpressionLiteral */: return createRegularExpressionLiteral(text); + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: return createTemplateLiteralLikeNode(kind, text, /*rawText*/ undefined, /*templateFlags*/ 0); + } + } + // + // Identifiers + // + function createBaseIdentifier(text, originalKeywordKind) { + if (originalKeywordKind === undefined && text) { + originalKeywordKind = ts.stringToToken(text); + } + if (originalKeywordKind === 79 /* SyntaxKind.Identifier */) { + originalKeywordKind = undefined; + } + var node = baseFactory.createBaseIdentifierNode(79 /* SyntaxKind.Identifier */); + node.originalKeywordKind = originalKeywordKind; + node.escapedText = ts.escapeLeadingUnderscores(text); + return node; + } + function createBaseGeneratedIdentifier(text, autoGenerateFlags, prefix, suffix) { + var node = createBaseIdentifier(text, /*originalKeywordKind*/ undefined); + node.autoGenerateFlags = autoGenerateFlags; + node.autoGenerateId = nextAutoGenerateId; + node.autoGeneratePrefix = prefix; + node.autoGenerateSuffix = suffix; + nextAutoGenerateId++; + return node; + } + // @api + function createIdentifier(text, typeArguments, originalKeywordKind, hasExtendedUnicodeEscape) { + var node = createBaseIdentifier(text, originalKeywordKind); + if (typeArguments) { + // NOTE: we do not use `setChildren` here because typeArguments in an identifier do not contribute to transformations + node.typeArguments = createNodeArray(typeArguments); + } + if (node.originalKeywordKind === 133 /* SyntaxKind.AwaitKeyword */) { + node.transformFlags |= 67108864 /* TransformFlags.ContainsPossibleTopLevelAwait */; + } + if (hasExtendedUnicodeEscape) { + node.hasExtendedUnicodeEscape = hasExtendedUnicodeEscape; + node.transformFlags |= 1024 /* TransformFlags.ContainsES2015 */; + } + return node; + } + // @api + function updateIdentifier(node, typeArguments) { + return node.typeArguments !== typeArguments + ? update(createIdentifier(ts.idText(node), typeArguments), node) + : node; + } + // @api + function createTempVariable(recordTempVariable, reservedInNestedScopes, prefix, suffix) { + var flags = 1 /* GeneratedIdentifierFlags.Auto */; + if (reservedInNestedScopes) + flags |= 8 /* GeneratedIdentifierFlags.ReservedInNestedScopes */; + var name = createBaseGeneratedIdentifier("", flags, prefix, suffix); + if (recordTempVariable) { + recordTempVariable(name); + } + return name; + } + /** Create a unique temporary variable for use in a loop. */ + // @api + function createLoopVariable(reservedInNestedScopes) { + var flags = 2 /* GeneratedIdentifierFlags.Loop */; + if (reservedInNestedScopes) + flags |= 8 /* GeneratedIdentifierFlags.ReservedInNestedScopes */; + return createBaseGeneratedIdentifier("", flags, /*prefix*/ undefined, /*suffix*/ undefined); + } + /** Create a unique name based on the supplied text. */ + // @api + function createUniqueName(text, flags, prefix, suffix) { + if (flags === void 0) { flags = 0 /* GeneratedIdentifierFlags.None */; } + ts.Debug.assert(!(flags & 7 /* GeneratedIdentifierFlags.KindMask */), "Argument out of range: flags"); + ts.Debug.assert((flags & (16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */)) !== 32 /* GeneratedIdentifierFlags.FileLevel */, "GeneratedIdentifierFlags.FileLevel cannot be set without also setting GeneratedIdentifierFlags.Optimistic"); + return createBaseGeneratedIdentifier(text, 3 /* GeneratedIdentifierFlags.Unique */ | flags, prefix, suffix); + } + /** Create a unique name generated for a node. */ + // @api + function getGeneratedNameForNode(node, flags, prefix, suffix) { + if (flags === void 0) { flags = 0; } + ts.Debug.assert(!(flags & 7 /* GeneratedIdentifierFlags.KindMask */), "Argument out of range: flags"); + var text = !node ? "" : + ts.isMemberName(node) ? ts.formatGeneratedName(/*privateName*/ false, prefix, node, suffix, ts.idText) : + "generated@".concat(ts.getNodeId(node)); + if (prefix || suffix) + flags |= 16 /* GeneratedIdentifierFlags.Optimistic */; + var name = createBaseGeneratedIdentifier(text, 4 /* GeneratedIdentifierFlags.Node */ | flags, prefix, suffix); + name.original = node; + return name; + } + function createBasePrivateIdentifier(text) { + var node = baseFactory.createBasePrivateIdentifierNode(80 /* SyntaxKind.PrivateIdentifier */); + node.escapedText = ts.escapeLeadingUnderscores(text); + node.transformFlags |= 16777216 /* TransformFlags.ContainsClassFields */; + return node; + } + // @api + function createPrivateIdentifier(text) { + if (!ts.startsWith(text, "#")) + ts.Debug.fail("First character of private identifier must be #: " + text); + return createBasePrivateIdentifier(text); + } + function createBaseGeneratedPrivateIdentifier(text, autoGenerateFlags, prefix, suffix) { + var node = createBasePrivateIdentifier(text); + node.autoGenerateFlags = autoGenerateFlags; + node.autoGenerateId = nextAutoGenerateId; + node.autoGeneratePrefix = prefix; + node.autoGenerateSuffix = suffix; + nextAutoGenerateId++; + return node; + } + /** Create a unique name based on the supplied text. */ + // @api + function createUniquePrivateName(text, prefix, suffix) { + if (text && !ts.startsWith(text, "#")) + ts.Debug.fail("First character of private identifier must be #: " + text); + var autoGenerateFlags = 8 /* GeneratedIdentifierFlags.ReservedInNestedScopes */ | + (text ? 3 /* GeneratedIdentifierFlags.Unique */ : 1 /* GeneratedIdentifierFlags.Auto */); + return createBaseGeneratedPrivateIdentifier(text !== null && text !== void 0 ? text : "", autoGenerateFlags, prefix, suffix); + } + // @api + function getGeneratedPrivateNameForNode(node, prefix, suffix) { + var text = ts.isMemberName(node) ? ts.formatGeneratedName(/*privateName*/ true, prefix, node, suffix, ts.idText) : + "#generated@".concat(ts.getNodeId(node)); + var flags = prefix || suffix ? 16 /* GeneratedIdentifierFlags.Optimistic */ : 0 /* GeneratedIdentifierFlags.None */; + var name = createBaseGeneratedPrivateIdentifier(text, 4 /* GeneratedIdentifierFlags.Node */ | flags, prefix, suffix); + name.original = node; + return name; + } + // + // Punctuation + // + function createBaseToken(kind) { + return baseFactory.createBaseTokenNode(kind); + } + function createToken(token) { + ts.Debug.assert(token >= 0 /* SyntaxKind.FirstToken */ && token <= 162 /* SyntaxKind.LastToken */, "Invalid token"); + ts.Debug.assert(token <= 14 /* SyntaxKind.FirstTemplateToken */ || token >= 17 /* SyntaxKind.LastTemplateToken */, "Invalid token. Use 'createTemplateLiteralLikeNode' to create template literals."); + ts.Debug.assert(token <= 8 /* SyntaxKind.FirstLiteralToken */ || token >= 14 /* SyntaxKind.LastLiteralToken */, "Invalid token. Use 'createLiteralLikeNode' to create literals."); + ts.Debug.assert(token !== 79 /* SyntaxKind.Identifier */, "Invalid token. Use 'createIdentifier' to create identifiers"); + var node = createBaseToken(token); + var transformFlags = 0 /* TransformFlags.None */; + switch (token) { + case 132 /* SyntaxKind.AsyncKeyword */: + // 'async' modifier is ES2017 (async functions) or ES2018 (async generators) + transformFlags = + 256 /* TransformFlags.ContainsES2017 */ | + 128 /* TransformFlags.ContainsES2018 */; + break; + case 123 /* SyntaxKind.PublicKeyword */: + case 121 /* SyntaxKind.PrivateKeyword */: + case 122 /* SyntaxKind.ProtectedKeyword */: + case 146 /* SyntaxKind.ReadonlyKeyword */: + case 126 /* SyntaxKind.AbstractKeyword */: + case 136 /* SyntaxKind.DeclareKeyword */: + case 85 /* SyntaxKind.ConstKeyword */: + case 131 /* SyntaxKind.AnyKeyword */: + case 148 /* SyntaxKind.NumberKeyword */: + case 160 /* SyntaxKind.BigIntKeyword */: + case 144 /* SyntaxKind.NeverKeyword */: + case 149 /* SyntaxKind.ObjectKeyword */: + case 101 /* SyntaxKind.InKeyword */: + case 145 /* SyntaxKind.OutKeyword */: + case 161 /* SyntaxKind.OverrideKeyword */: + case 152 /* SyntaxKind.StringKeyword */: + case 134 /* SyntaxKind.BooleanKeyword */: + case 153 /* SyntaxKind.SymbolKeyword */: + case 114 /* SyntaxKind.VoidKeyword */: + case 157 /* SyntaxKind.UnknownKeyword */: + case 155 /* SyntaxKind.UndefinedKeyword */: // `undefined` is an Identifier in the expression case. + transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + break; + case 106 /* SyntaxKind.SuperKeyword */: + transformFlags = 1024 /* TransformFlags.ContainsES2015 */ | 134217728 /* TransformFlags.ContainsLexicalSuper */; + break; + case 124 /* SyntaxKind.StaticKeyword */: + transformFlags = 1024 /* TransformFlags.ContainsES2015 */; + break; + case 127 /* SyntaxKind.AccessorKeyword */: + transformFlags = 16777216 /* TransformFlags.ContainsClassFields */; + break; + case 108 /* SyntaxKind.ThisKeyword */: + // 'this' indicates a lexical 'this' + transformFlags = 16384 /* TransformFlags.ContainsLexicalThis */; + break; + } + if (transformFlags) { + node.transformFlags |= transformFlags; + } + return node; + } + // + // Reserved words + // + // @api + function createSuper() { + return createToken(106 /* SyntaxKind.SuperKeyword */); + } + // @api + function createThis() { + return createToken(108 /* SyntaxKind.ThisKeyword */); + } + // @api + function createNull() { + return createToken(104 /* SyntaxKind.NullKeyword */); + } + // @api + function createTrue() { + return createToken(110 /* SyntaxKind.TrueKeyword */); + } + // @api + function createFalse() { + return createToken(95 /* SyntaxKind.FalseKeyword */); + } + // + // Modifiers + // + // @api + function createModifier(kind) { + return createToken(kind); + } + // @api + function createModifiersFromModifierFlags(flags) { + var result = []; + if (flags & 1 /* ModifierFlags.Export */) + result.push(createModifier(93 /* SyntaxKind.ExportKeyword */)); + if (flags & 2 /* ModifierFlags.Ambient */) + result.push(createModifier(136 /* SyntaxKind.DeclareKeyword */)); + if (flags & 1024 /* ModifierFlags.Default */) + result.push(createModifier(88 /* SyntaxKind.DefaultKeyword */)); + if (flags & 2048 /* ModifierFlags.Const */) + result.push(createModifier(85 /* SyntaxKind.ConstKeyword */)); + if (flags & 4 /* ModifierFlags.Public */) + result.push(createModifier(123 /* SyntaxKind.PublicKeyword */)); + if (flags & 8 /* ModifierFlags.Private */) + result.push(createModifier(121 /* SyntaxKind.PrivateKeyword */)); + if (flags & 16 /* ModifierFlags.Protected */) + result.push(createModifier(122 /* SyntaxKind.ProtectedKeyword */)); + if (flags & 256 /* ModifierFlags.Abstract */) + result.push(createModifier(126 /* SyntaxKind.AbstractKeyword */)); + if (flags & 32 /* ModifierFlags.Static */) + result.push(createModifier(124 /* SyntaxKind.StaticKeyword */)); + if (flags & 16384 /* ModifierFlags.Override */) + result.push(createModifier(161 /* SyntaxKind.OverrideKeyword */)); + if (flags & 64 /* ModifierFlags.Readonly */) + result.push(createModifier(146 /* SyntaxKind.ReadonlyKeyword */)); + if (flags & 128 /* ModifierFlags.Accessor */) + result.push(createModifier(127 /* SyntaxKind.AccessorKeyword */)); + if (flags & 512 /* ModifierFlags.Async */) + result.push(createModifier(132 /* SyntaxKind.AsyncKeyword */)); + if (flags & 32768 /* ModifierFlags.In */) + result.push(createModifier(101 /* SyntaxKind.InKeyword */)); + if (flags & 65536 /* ModifierFlags.Out */) + result.push(createModifier(145 /* SyntaxKind.OutKeyword */)); + return result.length ? result : undefined; + } + // + // Names + // + // @api + function createQualifiedName(left, right) { + var node = createBaseNode(163 /* SyntaxKind.QualifiedName */); + node.left = left; + node.right = asName(right); + node.transformFlags |= + propagateChildFlags(node.left) | + propagateIdentifierNameFlags(node.right); + return node; + } + // @api + function updateQualifiedName(node, left, right) { + return node.left !== left + || node.right !== right + ? update(createQualifiedName(left, right), node) + : node; + } + // @api + function createComputedPropertyName(expression) { + var node = createBaseNode(164 /* SyntaxKind.ComputedPropertyName */); + node.expression = parenthesizerRules().parenthesizeExpressionOfComputedPropertyName(expression); + node.transformFlags |= + propagateChildFlags(node.expression) | + 1024 /* TransformFlags.ContainsES2015 */ | + 131072 /* TransformFlags.ContainsComputedPropertyName */; + return node; + } + // @api + function updateComputedPropertyName(node, expression) { + return node.expression !== expression + ? update(createComputedPropertyName(expression), node) + : node; + } + // + // Signature elements + // + // @api + function createTypeParameterDeclaration(modifiers, name, constraint, defaultType) { + var node = createBaseNamedDeclaration(165 /* SyntaxKind.TypeParameter */, modifiers, name); + node.constraint = constraint; + node.default = defaultType; + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateTypeParameterDeclaration(node, modifiers, name, constraint, defaultType) { + return node.modifiers !== modifiers + || node.name !== name + || node.constraint !== constraint + || node.default !== defaultType + ? update(createTypeParameterDeclaration(modifiers, name, constraint, defaultType), node) + : node; + } + // @api + function createParameterDeclaration(modifiers, dotDotDotToken, name, questionToken, type, initializer) { + var node = createBaseVariableLikeDeclaration(166 /* SyntaxKind.Parameter */, modifiers, name, type, initializer && parenthesizerRules().parenthesizeExpressionForDisallowedComma(initializer)); + node.dotDotDotToken = dotDotDotToken; + node.questionToken = questionToken; + if (ts.isThisIdentifier(node.name)) { + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + } + else { + node.transformFlags |= + propagateChildFlags(node.dotDotDotToken) | + propagateChildFlags(node.questionToken); + if (questionToken) + node.transformFlags |= 1 /* TransformFlags.ContainsTypeScript */; + if (ts.modifiersToFlags(node.modifiers) & 16476 /* ModifierFlags.ParameterPropertyModifier */) + node.transformFlags |= 8192 /* TransformFlags.ContainsTypeScriptClassSyntax */; + if (initializer || dotDotDotToken) + node.transformFlags |= 1024 /* TransformFlags.ContainsES2015 */; + } + return node; + } + // @api + function updateParameterDeclaration(node, modifiers, dotDotDotToken, name, questionToken, type, initializer) { + return node.modifiers !== modifiers + || node.dotDotDotToken !== dotDotDotToken + || node.name !== name + || node.questionToken !== questionToken + || node.type !== type + || node.initializer !== initializer + ? update(createParameterDeclaration(modifiers, dotDotDotToken, name, questionToken, type, initializer), node) + : node; + } + // @api + function createDecorator(expression) { + var node = createBaseNode(167 /* SyntaxKind.Decorator */); + node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, /*optionalChain*/ false); + node.transformFlags |= + propagateChildFlags(node.expression) | + 1 /* TransformFlags.ContainsTypeScript */ | + 8192 /* TransformFlags.ContainsTypeScriptClassSyntax */ | + 33554432 /* TransformFlags.ContainsDecorators */; + return node; + } + // @api + function updateDecorator(node, expression) { + return node.expression !== expression + ? update(createDecorator(expression), node) + : node; + } + // + // Type Elements + // + // @api + function createPropertySignature(modifiers, name, questionToken, type) { + var node = createBaseNamedDeclaration(168 /* SyntaxKind.PropertySignature */, modifiers, name); + node.type = type; + node.questionToken = questionToken; + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + // The following properties are used only to report grammar errors + node.initializer = undefined; + return node; + } + // @api + function updatePropertySignature(node, modifiers, name, questionToken, type) { + return node.modifiers !== modifiers + || node.name !== name + || node.questionToken !== questionToken + || node.type !== type + ? finishUpdatePropertySignature(createPropertySignature(modifiers, name, questionToken, type), node) + : node; + } + function finishUpdatePropertySignature(updated, original) { + if (updated !== original) { + // copy children used only for error reporting + updated.initializer = original.initializer; + } + return update(updated, original); + } + // @api + function createPropertyDeclaration(modifiers, name, questionOrExclamationToken, type, initializer) { + var node = createBaseVariableLikeDeclaration(169 /* SyntaxKind.PropertyDeclaration */, modifiers, name, type, initializer); + node.questionToken = questionOrExclamationToken && ts.isQuestionToken(questionOrExclamationToken) ? questionOrExclamationToken : undefined; + node.exclamationToken = questionOrExclamationToken && ts.isExclamationToken(questionOrExclamationToken) ? questionOrExclamationToken : undefined; + node.transformFlags |= + propagateChildFlags(node.questionToken) | + propagateChildFlags(node.exclamationToken) | + 16777216 /* TransformFlags.ContainsClassFields */; + if (ts.isComputedPropertyName(node.name) || (ts.hasStaticModifier(node) && node.initializer)) { + node.transformFlags |= 8192 /* TransformFlags.ContainsTypeScriptClassSyntax */; + } + if (questionOrExclamationToken || ts.modifiersToFlags(node.modifiers) & 2 /* ModifierFlags.Ambient */) { + node.transformFlags |= 1 /* TransformFlags.ContainsTypeScript */; + } + return node; + } + // @api + function updatePropertyDeclaration(node, modifiers, name, questionOrExclamationToken, type, initializer) { + return node.modifiers !== modifiers + || node.name !== name + || node.questionToken !== (questionOrExclamationToken !== undefined && ts.isQuestionToken(questionOrExclamationToken) ? questionOrExclamationToken : undefined) + || node.exclamationToken !== (questionOrExclamationToken !== undefined && ts.isExclamationToken(questionOrExclamationToken) ? questionOrExclamationToken : undefined) + || node.type !== type + || node.initializer !== initializer + ? update(createPropertyDeclaration(modifiers, name, questionOrExclamationToken, type, initializer), node) + : node; + } + // @api + function createMethodSignature(modifiers, name, questionToken, typeParameters, parameters, type) { + var node = createBaseSignatureDeclaration(170 /* SyntaxKind.MethodSignature */, modifiers, name, typeParameters, parameters, type); + node.questionToken = questionToken; + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateMethodSignature(node, modifiers, name, questionToken, typeParameters, parameters, type) { + return node.modifiers !== modifiers + || node.name !== name + || node.questionToken !== questionToken + || node.typeParameters !== typeParameters + || node.parameters !== parameters + || node.type !== type + ? finishUpdateBaseSignatureDeclaration(createMethodSignature(modifiers, name, questionToken, typeParameters, parameters, type), node) + : node; + } + // @api + function createMethodDeclaration(modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body) { + var node = createBaseFunctionLikeDeclaration(171 /* SyntaxKind.MethodDeclaration */, modifiers, name, typeParameters, parameters, type, body); + node.asteriskToken = asteriskToken; + node.questionToken = questionToken; + node.transformFlags |= + propagateChildFlags(node.asteriskToken) | + propagateChildFlags(node.questionToken) | + 1024 /* TransformFlags.ContainsES2015 */; + if (questionToken) { + node.transformFlags |= 1 /* TransformFlags.ContainsTypeScript */; + } + if (ts.modifiersToFlags(node.modifiers) & 512 /* ModifierFlags.Async */) { + if (asteriskToken) { + node.transformFlags |= 128 /* TransformFlags.ContainsES2018 */; + } + else { + node.transformFlags |= 256 /* TransformFlags.ContainsES2017 */; + } + } + else if (asteriskToken) { + node.transformFlags |= 2048 /* TransformFlags.ContainsGenerator */; + } + // The following properties are used only to report grammar errors + node.exclamationToken = undefined; + return node; + } + // @api + function updateMethodDeclaration(node, modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body) { + return node.modifiers !== modifiers + || node.asteriskToken !== asteriskToken + || node.name !== name + || node.questionToken !== questionToken + || node.typeParameters !== typeParameters + || node.parameters !== parameters + || node.type !== type + || node.body !== body + ? finishUpdateMethodDeclaration(createMethodDeclaration(modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body), node) + : node; + } + function finishUpdateMethodDeclaration(updated, original) { + if (updated !== original) { + updated.exclamationToken = original.exclamationToken; + } + return update(updated, original); + } + // @api + function createClassStaticBlockDeclaration(body) { + var node = createBaseGenericNamedDeclaration(172 /* SyntaxKind.ClassStaticBlockDeclaration */, + /*modifiers*/ undefined, + /*name*/ undefined, + /*typeParameters*/ undefined); + node.body = body; + node.transformFlags = propagateChildFlags(body) | 16777216 /* TransformFlags.ContainsClassFields */; + // The following properties are used only to report grammar errors + node.illegalDecorators = undefined; + node.modifiers = undefined; + return node; + } + // @api + function updateClassStaticBlockDeclaration(node, body) { + return node.body !== body + ? finishUpdateClassStaticBlockDeclaration(createClassStaticBlockDeclaration(body), node) + : node; + } + function finishUpdateClassStaticBlockDeclaration(updated, original) { + if (updated !== original) { + updated.illegalDecorators = original.illegalDecorators; + updated.modifiers = original.modifiers; + } + return update(updated, original); + } + // @api + function createConstructorDeclaration(modifiers, parameters, body) { + var node = createBaseFunctionLikeDeclaration(173 /* SyntaxKind.Constructor */, modifiers, + /*name*/ undefined, + /*typeParameters*/ undefined, parameters, + /*type*/ undefined, body); + node.transformFlags |= 1024 /* TransformFlags.ContainsES2015 */; + // The following properties are used only to report grammar errors + node.illegalDecorators = undefined; + node.typeParameters = undefined; + node.type = undefined; + return node; + } + // @api + function updateConstructorDeclaration(node, modifiers, parameters, body) { + return node.modifiers !== modifiers + || node.parameters !== parameters + || node.body !== body + ? finishUpdateConstructorDeclaration(createConstructorDeclaration(modifiers, parameters, body), node) + : node; + } + function finishUpdateConstructorDeclaration(updated, original) { + if (updated !== original) { + updated.illegalDecorators = original.illegalDecorators; + updated.typeParameters = original.typeParameters; + updated.type = original.type; + } + return finishUpdateBaseSignatureDeclaration(updated, original); + } + // @api + function createGetAccessorDeclaration(modifiers, name, parameters, type, body) { + var node = createBaseFunctionLikeDeclaration(174 /* SyntaxKind.GetAccessor */, modifiers, name, + /*typeParameters*/ undefined, parameters, type, body); + // The following properties are used only to report grammar errors + node.typeParameters = undefined; + return node; + } + // @api + function updateGetAccessorDeclaration(node, modifiers, name, parameters, type, body) { + return node.modifiers !== modifiers + || node.name !== name + || node.parameters !== parameters + || node.type !== type + || node.body !== body + ? finishUpdateGetAccessorDeclaration(createGetAccessorDeclaration(modifiers, name, parameters, type, body), node) + : node; + } + function finishUpdateGetAccessorDeclaration(updated, original) { + if (updated !== original) { + updated.typeParameters = original.typeParameters; + } + return finishUpdateBaseSignatureDeclaration(updated, original); + } + // @api + function createSetAccessorDeclaration(modifiers, name, parameters, body) { + var node = createBaseFunctionLikeDeclaration(175 /* SyntaxKind.SetAccessor */, modifiers, name, + /*typeParameters*/ undefined, parameters, + /*type*/ undefined, body); + // The following properties are used only to report grammar errors + node.typeParameters = undefined; + node.type = undefined; + return node; + } + // @api + function updateSetAccessorDeclaration(node, modifiers, name, parameters, body) { + return node.modifiers !== modifiers + || node.name !== name + || node.parameters !== parameters + || node.body !== body + ? finishUpdateSetAccessorDeclaration(createSetAccessorDeclaration(modifiers, name, parameters, body), node) + : node; + } + function finishUpdateSetAccessorDeclaration(updated, original) { + if (updated !== original) { + updated.typeParameters = original.typeParameters; + updated.type = original.type; + } + return finishUpdateBaseSignatureDeclaration(updated, original); + } + // @api + function createCallSignature(typeParameters, parameters, type) { + var node = createBaseSignatureDeclaration(176 /* SyntaxKind.CallSignature */, + /*modifiers*/ undefined, + /*name*/ undefined, typeParameters, parameters, type); + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateCallSignature(node, typeParameters, parameters, type) { + return node.typeParameters !== typeParameters + || node.parameters !== parameters + || node.type !== type + ? finishUpdateBaseSignatureDeclaration(createCallSignature(typeParameters, parameters, type), node) + : node; + } + // @api + function createConstructSignature(typeParameters, parameters, type) { + var node = createBaseSignatureDeclaration(177 /* SyntaxKind.ConstructSignature */, + /*modifiers*/ undefined, + /*name*/ undefined, typeParameters, parameters, type); + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateConstructSignature(node, typeParameters, parameters, type) { + return node.typeParameters !== typeParameters + || node.parameters !== parameters + || node.type !== type + ? finishUpdateBaseSignatureDeclaration(createConstructSignature(typeParameters, parameters, type), node) + : node; + } + // @api + function createIndexSignature(modifiers, parameters, type) { + var node = createBaseSignatureDeclaration(178 /* SyntaxKind.IndexSignature */, modifiers, + /*name*/ undefined, + /*typeParameters*/ undefined, parameters, type); + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateIndexSignature(node, modifiers, parameters, type) { + return node.parameters !== parameters + || node.type !== type + || node.modifiers !== modifiers + ? finishUpdateBaseSignatureDeclaration(createIndexSignature(modifiers, parameters, type), node) + : node; + } + // @api + function createTemplateLiteralTypeSpan(type, literal) { + var node = createBaseNode(201 /* SyntaxKind.TemplateLiteralTypeSpan */); + node.type = type; + node.literal = literal; + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateTemplateLiteralTypeSpan(node, type, literal) { + return node.type !== type + || node.literal !== literal + ? update(createTemplateLiteralTypeSpan(type, literal), node) + : node; + } + // + // Types + // + // @api + function createKeywordTypeNode(kind) { + return createToken(kind); + } + // @api + function createTypePredicateNode(assertsModifier, parameterName, type) { + var node = createBaseNode(179 /* SyntaxKind.TypePredicate */); + node.assertsModifier = assertsModifier; + node.parameterName = asName(parameterName); + node.type = type; + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateTypePredicateNode(node, assertsModifier, parameterName, type) { + return node.assertsModifier !== assertsModifier + || node.parameterName !== parameterName + || node.type !== type + ? update(createTypePredicateNode(assertsModifier, parameterName, type), node) + : node; + } + // @api + function createTypeReferenceNode(typeName, typeArguments) { + var node = createBaseNode(180 /* SyntaxKind.TypeReference */); + node.typeName = asName(typeName); + node.typeArguments = typeArguments && parenthesizerRules().parenthesizeTypeArguments(createNodeArray(typeArguments)); + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateTypeReferenceNode(node, typeName, typeArguments) { + return node.typeName !== typeName + || node.typeArguments !== typeArguments + ? update(createTypeReferenceNode(typeName, typeArguments), node) + : node; + } + // @api + function createFunctionTypeNode(typeParameters, parameters, type) { + var node = createBaseSignatureDeclaration(181 /* SyntaxKind.FunctionType */, + /*modifiers*/ undefined, + /*name*/ undefined, typeParameters, parameters, type); + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + // The following properties are used only to report grammar errors + node.modifiers = undefined; + return node; + } + // @api + function updateFunctionTypeNode(node, typeParameters, parameters, type) { + return node.typeParameters !== typeParameters + || node.parameters !== parameters + || node.type !== type + ? finishUpdateFunctionTypeNode(createFunctionTypeNode(typeParameters, parameters, type), node) + : node; + } + function finishUpdateFunctionTypeNode(updated, original) { + if (updated !== original) { + updated.modifiers = original.modifiers; + } + return finishUpdateBaseSignatureDeclaration(updated, original); + } + // @api + function createConstructorTypeNode() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + return args.length === 4 ? createConstructorTypeNode1.apply(void 0, args) : + args.length === 3 ? createConstructorTypeNode2.apply(void 0, args) : + ts.Debug.fail("Incorrect number of arguments specified."); + } + function createConstructorTypeNode1(modifiers, typeParameters, parameters, type) { + var node = createBaseSignatureDeclaration(182 /* SyntaxKind.ConstructorType */, modifiers, + /*name*/ undefined, typeParameters, parameters, type); + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + /** @deprecated */ + function createConstructorTypeNode2(typeParameters, parameters, type) { + return createConstructorTypeNode1(/*modifiers*/ undefined, typeParameters, parameters, type); + } + // @api + function updateConstructorTypeNode() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + return args.length === 5 ? updateConstructorTypeNode1.apply(void 0, args) : + args.length === 4 ? updateConstructorTypeNode2.apply(void 0, args) : + ts.Debug.fail("Incorrect number of arguments specified."); + } + function updateConstructorTypeNode1(node, modifiers, typeParameters, parameters, type) { + return node.modifiers !== modifiers + || node.typeParameters !== typeParameters + || node.parameters !== parameters + || node.type !== type + ? finishUpdateBaseSignatureDeclaration(createConstructorTypeNode(modifiers, typeParameters, parameters, type), node) + : node; + } + /** @deprecated */ + function updateConstructorTypeNode2(node, typeParameters, parameters, type) { + return updateConstructorTypeNode1(node, node.modifiers, typeParameters, parameters, type); + } + // @api + function createTypeQueryNode(exprName, typeArguments) { + var node = createBaseNode(183 /* SyntaxKind.TypeQuery */); + node.exprName = exprName; + node.typeArguments = typeArguments && parenthesizerRules().parenthesizeTypeArguments(typeArguments); + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateTypeQueryNode(node, exprName, typeArguments) { + return node.exprName !== exprName + || node.typeArguments !== typeArguments + ? update(createTypeQueryNode(exprName, typeArguments), node) + : node; + } + // @api + function createTypeLiteralNode(members) { + var node = createBaseNode(184 /* SyntaxKind.TypeLiteral */); + node.members = createNodeArray(members); + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateTypeLiteralNode(node, members) { + return node.members !== members + ? update(createTypeLiteralNode(members), node) + : node; + } + // @api + function createArrayTypeNode(elementType) { + var node = createBaseNode(185 /* SyntaxKind.ArrayType */); + node.elementType = parenthesizerRules().parenthesizeNonArrayTypeOfPostfixType(elementType); + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateArrayTypeNode(node, elementType) { + return node.elementType !== elementType + ? update(createArrayTypeNode(elementType), node) + : node; + } + // @api + function createTupleTypeNode(elements) { + var node = createBaseNode(186 /* SyntaxKind.TupleType */); + node.elements = createNodeArray(parenthesizerRules().parenthesizeElementTypesOfTupleType(elements)); + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateTupleTypeNode(node, elements) { + return node.elements !== elements + ? update(createTupleTypeNode(elements), node) + : node; + } + // @api + function createNamedTupleMember(dotDotDotToken, name, questionToken, type) { + var node = createBaseNode(199 /* SyntaxKind.NamedTupleMember */); + node.dotDotDotToken = dotDotDotToken; + node.name = name; + node.questionToken = questionToken; + node.type = type; + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateNamedTupleMember(node, dotDotDotToken, name, questionToken, type) { + return node.dotDotDotToken !== dotDotDotToken + || node.name !== name + || node.questionToken !== questionToken + || node.type !== type + ? update(createNamedTupleMember(dotDotDotToken, name, questionToken, type), node) + : node; + } + // @api + function createOptionalTypeNode(type) { + var node = createBaseNode(187 /* SyntaxKind.OptionalType */); + node.type = parenthesizerRules().parenthesizeTypeOfOptionalType(type); + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateOptionalTypeNode(node, type) { + return node.type !== type + ? update(createOptionalTypeNode(type), node) + : node; + } + // @api + function createRestTypeNode(type) { + var node = createBaseNode(188 /* SyntaxKind.RestType */); + node.type = type; + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateRestTypeNode(node, type) { + return node.type !== type + ? update(createRestTypeNode(type), node) + : node; + } + function createUnionOrIntersectionTypeNode(kind, types, parenthesize) { + var node = createBaseNode(kind); + node.types = factory.createNodeArray(parenthesize(types)); + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + function updateUnionOrIntersectionTypeNode(node, types, parenthesize) { + return node.types !== types + ? update(createUnionOrIntersectionTypeNode(node.kind, types, parenthesize), node) + : node; + } + // @api + function createUnionTypeNode(types) { + return createUnionOrIntersectionTypeNode(189 /* SyntaxKind.UnionType */, types, parenthesizerRules().parenthesizeConstituentTypesOfUnionType); + } + // @api + function updateUnionTypeNode(node, types) { + return updateUnionOrIntersectionTypeNode(node, types, parenthesizerRules().parenthesizeConstituentTypesOfUnionType); + } + // @api + function createIntersectionTypeNode(types) { + return createUnionOrIntersectionTypeNode(190 /* SyntaxKind.IntersectionType */, types, parenthesizerRules().parenthesizeConstituentTypesOfIntersectionType); + } + // @api + function updateIntersectionTypeNode(node, types) { + return updateUnionOrIntersectionTypeNode(node, types, parenthesizerRules().parenthesizeConstituentTypesOfIntersectionType); + } + // @api + function createConditionalTypeNode(checkType, extendsType, trueType, falseType) { + var node = createBaseNode(191 /* SyntaxKind.ConditionalType */); + node.checkType = parenthesizerRules().parenthesizeCheckTypeOfConditionalType(checkType); + node.extendsType = parenthesizerRules().parenthesizeExtendsTypeOfConditionalType(extendsType); + node.trueType = trueType; + node.falseType = falseType; + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateConditionalTypeNode(node, checkType, extendsType, trueType, falseType) { + return node.checkType !== checkType + || node.extendsType !== extendsType + || node.trueType !== trueType + || node.falseType !== falseType + ? update(createConditionalTypeNode(checkType, extendsType, trueType, falseType), node) + : node; + } + // @api + function createInferTypeNode(typeParameter) { + var node = createBaseNode(192 /* SyntaxKind.InferType */); + node.typeParameter = typeParameter; + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateInferTypeNode(node, typeParameter) { + return node.typeParameter !== typeParameter + ? update(createInferTypeNode(typeParameter), node) + : node; + } + // @api + function createTemplateLiteralType(head, templateSpans) { + var node = createBaseNode(200 /* SyntaxKind.TemplateLiteralType */); + node.head = head; + node.templateSpans = createNodeArray(templateSpans); + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateTemplateLiteralType(node, head, templateSpans) { + return node.head !== head + || node.templateSpans !== templateSpans + ? update(createTemplateLiteralType(head, templateSpans), node) + : node; + } + // @api + function createImportTypeNode(argument, assertions, qualifier, typeArguments, isTypeOf) { + if (isTypeOf === void 0) { isTypeOf = false; } + var node = createBaseNode(202 /* SyntaxKind.ImportType */); + node.argument = argument; + node.assertions = assertions; + node.qualifier = qualifier; + node.typeArguments = typeArguments && parenthesizerRules().parenthesizeTypeArguments(typeArguments); + node.isTypeOf = isTypeOf; + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateImportTypeNode(node, argument, assertions, qualifier, typeArguments, isTypeOf) { + if (isTypeOf === void 0) { isTypeOf = node.isTypeOf; } + return node.argument !== argument + || node.assertions !== assertions + || node.qualifier !== qualifier + || node.typeArguments !== typeArguments + || node.isTypeOf !== isTypeOf + ? update(createImportTypeNode(argument, assertions, qualifier, typeArguments, isTypeOf), node) + : node; + } + // @api + function createParenthesizedType(type) { + var node = createBaseNode(193 /* SyntaxKind.ParenthesizedType */); + node.type = type; + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateParenthesizedType(node, type) { + return node.type !== type + ? update(createParenthesizedType(type), node) + : node; + } + // @api + function createThisTypeNode() { + var node = createBaseNode(194 /* SyntaxKind.ThisType */); + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function createTypeOperatorNode(operator, type) { + var node = createBaseNode(195 /* SyntaxKind.TypeOperator */); + node.operator = operator; + node.type = operator === 146 /* SyntaxKind.ReadonlyKeyword */ ? + parenthesizerRules().parenthesizeOperandOfReadonlyTypeOperator(type) : + parenthesizerRules().parenthesizeOperandOfTypeOperator(type); + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateTypeOperatorNode(node, type) { + return node.type !== type + ? update(createTypeOperatorNode(node.operator, type), node) + : node; + } + // @api + function createIndexedAccessTypeNode(objectType, indexType) { + var node = createBaseNode(196 /* SyntaxKind.IndexedAccessType */); + node.objectType = parenthesizerRules().parenthesizeNonArrayTypeOfPostfixType(objectType); + node.indexType = indexType; + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateIndexedAccessTypeNode(node, objectType, indexType) { + return node.objectType !== objectType + || node.indexType !== indexType + ? update(createIndexedAccessTypeNode(objectType, indexType), node) + : node; + } + // @api + function createMappedTypeNode(readonlyToken, typeParameter, nameType, questionToken, type, members) { + var node = createBaseNode(197 /* SyntaxKind.MappedType */); + node.readonlyToken = readonlyToken; + node.typeParameter = typeParameter; + node.nameType = nameType; + node.questionToken = questionToken; + node.type = type; + node.members = members && createNodeArray(members); + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateMappedTypeNode(node, readonlyToken, typeParameter, nameType, questionToken, type, members) { + return node.readonlyToken !== readonlyToken + || node.typeParameter !== typeParameter + || node.nameType !== nameType + || node.questionToken !== questionToken + || node.type !== type + || node.members !== members + ? update(createMappedTypeNode(readonlyToken, typeParameter, nameType, questionToken, type, members), node) + : node; + } + // @api + function createLiteralTypeNode(literal) { + var node = createBaseNode(198 /* SyntaxKind.LiteralType */); + node.literal = literal; + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateLiteralTypeNode(node, literal) { + return node.literal !== literal + ? update(createLiteralTypeNode(literal), node) + : node; + } + // + // Binding Patterns + // + // @api + function createObjectBindingPattern(elements) { + var node = createBaseNode(203 /* SyntaxKind.ObjectBindingPattern */); + node.elements = createNodeArray(elements); + node.transformFlags |= + propagateChildrenFlags(node.elements) | + 1024 /* TransformFlags.ContainsES2015 */ | + 524288 /* TransformFlags.ContainsBindingPattern */; + if (node.transformFlags & 32768 /* TransformFlags.ContainsRestOrSpread */) { + node.transformFlags |= + 128 /* TransformFlags.ContainsES2018 */ | + 65536 /* TransformFlags.ContainsObjectRestOrSpread */; + } + return node; + } + // @api + function updateObjectBindingPattern(node, elements) { + return node.elements !== elements + ? update(createObjectBindingPattern(elements), node) + : node; + } + // @api + function createArrayBindingPattern(elements) { + var node = createBaseNode(204 /* SyntaxKind.ArrayBindingPattern */); + node.elements = createNodeArray(elements); + node.transformFlags |= + propagateChildrenFlags(node.elements) | + 1024 /* TransformFlags.ContainsES2015 */ | + 524288 /* TransformFlags.ContainsBindingPattern */; + return node; + } + // @api + function updateArrayBindingPattern(node, elements) { + return node.elements !== elements + ? update(createArrayBindingPattern(elements), node) + : node; + } + // @api + function createBindingElement(dotDotDotToken, propertyName, name, initializer) { + var node = createBaseBindingLikeDeclaration(205 /* SyntaxKind.BindingElement */, + /*modifiers*/ undefined, name, initializer && parenthesizerRules().parenthesizeExpressionForDisallowedComma(initializer)); + node.propertyName = asName(propertyName); + node.dotDotDotToken = dotDotDotToken; + node.transformFlags |= + propagateChildFlags(node.dotDotDotToken) | + 1024 /* TransformFlags.ContainsES2015 */; + if (node.propertyName) { + node.transformFlags |= ts.isIdentifier(node.propertyName) ? + propagateIdentifierNameFlags(node.propertyName) : + propagateChildFlags(node.propertyName); + } + if (dotDotDotToken) + node.transformFlags |= 32768 /* TransformFlags.ContainsRestOrSpread */; + return node; + } + // @api + function updateBindingElement(node, dotDotDotToken, propertyName, name, initializer) { + return node.propertyName !== propertyName + || node.dotDotDotToken !== dotDotDotToken + || node.name !== name + || node.initializer !== initializer + ? update(createBindingElement(dotDotDotToken, propertyName, name, initializer), node) + : node; + } + // + // Expression + // + function createBaseExpression(kind) { + var node = createBaseNode(kind); + // the following properties are commonly set by the checker/binder + return node; + } + // @api + function createArrayLiteralExpression(elements, multiLine) { + var node = createBaseExpression(206 /* SyntaxKind.ArrayLiteralExpression */); + // Ensure we add a trailing comma for something like `[NumericLiteral(1), NumericLiteral(2), OmittedExpresion]` so that + // we end up with `[1, 2, ,]` instead of `[1, 2, ]` otherwise the `OmittedExpression` will just end up being treated like + // a trailing comma. + var lastElement = elements && ts.lastOrUndefined(elements); + var elementsArray = createNodeArray(elements, lastElement && ts.isOmittedExpression(lastElement) ? true : undefined); + node.elements = parenthesizerRules().parenthesizeExpressionsOfCommaDelimitedList(elementsArray); + node.multiLine = multiLine; + node.transformFlags |= propagateChildrenFlags(node.elements); + return node; + } + // @api + function updateArrayLiteralExpression(node, elements) { + return node.elements !== elements + ? update(createArrayLiteralExpression(elements, node.multiLine), node) + : node; + } + // @api + function createObjectLiteralExpression(properties, multiLine) { + var node = createBaseExpression(207 /* SyntaxKind.ObjectLiteralExpression */); + node.properties = createNodeArray(properties); + node.multiLine = multiLine; + node.transformFlags |= propagateChildrenFlags(node.properties); + return node; + } + // @api + function updateObjectLiteralExpression(node, properties) { + return node.properties !== properties + ? update(createObjectLiteralExpression(properties, node.multiLine), node) + : node; + } + // @api + function createPropertyAccessExpression(expression, name) { + var node = createBaseExpression(208 /* SyntaxKind.PropertyAccessExpression */); + node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, /*optionalChain*/ false); + node.name = asName(name); + node.transformFlags = + propagateChildFlags(node.expression) | + (ts.isIdentifier(node.name) ? + propagateIdentifierNameFlags(node.name) : + propagateChildFlags(node.name) | 536870912 /* TransformFlags.ContainsPrivateIdentifierInExpression */); + if (ts.isSuperKeyword(expression)) { + // super method calls require a lexical 'this' + // super method calls require 'super' hoisting in ES2017 and ES2018 async functions and async generators + node.transformFlags |= + 256 /* TransformFlags.ContainsES2017 */ | + 128 /* TransformFlags.ContainsES2018 */; + } + return node; + } + // @api + function updatePropertyAccessExpression(node, expression, name) { + if (ts.isPropertyAccessChain(node)) { + return updatePropertyAccessChain(node, expression, node.questionDotToken, ts.cast(name, ts.isIdentifier)); + } + return node.expression !== expression + || node.name !== name + ? update(createPropertyAccessExpression(expression, name), node) + : node; + } + // @api + function createPropertyAccessChain(expression, questionDotToken, name) { + var node = createBaseExpression(208 /* SyntaxKind.PropertyAccessExpression */); + node.flags |= 32 /* NodeFlags.OptionalChain */; + node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, /*optionalChain*/ true); + node.questionDotToken = questionDotToken; + node.name = asName(name); + node.transformFlags |= + 32 /* TransformFlags.ContainsES2020 */ | + propagateChildFlags(node.expression) | + propagateChildFlags(node.questionDotToken) | + (ts.isIdentifier(node.name) ? + propagateIdentifierNameFlags(node.name) : + propagateChildFlags(node.name) | 536870912 /* TransformFlags.ContainsPrivateIdentifierInExpression */); + return node; + } + // @api + function updatePropertyAccessChain(node, expression, questionDotToken, name) { + ts.Debug.assert(!!(node.flags & 32 /* NodeFlags.OptionalChain */), "Cannot update a PropertyAccessExpression using updatePropertyAccessChain. Use updatePropertyAccess instead."); + // Because we are updating an existing PropertyAccessChain we want to inherit its emitFlags + // instead of using the default from createPropertyAccess + return node.expression !== expression + || node.questionDotToken !== questionDotToken + || node.name !== name + ? update(createPropertyAccessChain(expression, questionDotToken, name), node) + : node; + } + // @api + function createElementAccessExpression(expression, index) { + var node = createBaseExpression(209 /* SyntaxKind.ElementAccessExpression */); + node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, /*optionalChain*/ false); + node.argumentExpression = asExpression(index); + node.transformFlags |= + propagateChildFlags(node.expression) | + propagateChildFlags(node.argumentExpression); + if (ts.isSuperKeyword(expression)) { + // super method calls require a lexical 'this' + // super method calls require 'super' hoisting in ES2017 and ES2018 async functions and async generators + node.transformFlags |= + 256 /* TransformFlags.ContainsES2017 */ | + 128 /* TransformFlags.ContainsES2018 */; + } + return node; + } + // @api + function updateElementAccessExpression(node, expression, argumentExpression) { + if (ts.isElementAccessChain(node)) { + return updateElementAccessChain(node, expression, node.questionDotToken, argumentExpression); + } + return node.expression !== expression + || node.argumentExpression !== argumentExpression + ? update(createElementAccessExpression(expression, argumentExpression), node) + : node; + } + // @api + function createElementAccessChain(expression, questionDotToken, index) { + var node = createBaseExpression(209 /* SyntaxKind.ElementAccessExpression */); + node.flags |= 32 /* NodeFlags.OptionalChain */; + node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, /*optionalChain*/ true); + node.questionDotToken = questionDotToken; + node.argumentExpression = asExpression(index); + node.transformFlags |= + propagateChildFlags(node.expression) | + propagateChildFlags(node.questionDotToken) | + propagateChildFlags(node.argumentExpression) | + 32 /* TransformFlags.ContainsES2020 */; + return node; + } + // @api + function updateElementAccessChain(node, expression, questionDotToken, argumentExpression) { + ts.Debug.assert(!!(node.flags & 32 /* NodeFlags.OptionalChain */), "Cannot update a ElementAccessExpression using updateElementAccessChain. Use updateElementAccess instead."); + // Because we are updating an existing ElementAccessChain we want to inherit its emitFlags + // instead of using the default from createElementAccess + return node.expression !== expression + || node.questionDotToken !== questionDotToken + || node.argumentExpression !== argumentExpression + ? update(createElementAccessChain(expression, questionDotToken, argumentExpression), node) + : node; + } + // @api + function createCallExpression(expression, typeArguments, argumentsArray) { + var node = createBaseExpression(210 /* SyntaxKind.CallExpression */); + node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, /*optionalChain*/ false); + node.typeArguments = asNodeArray(typeArguments); + node.arguments = parenthesizerRules().parenthesizeExpressionsOfCommaDelimitedList(createNodeArray(argumentsArray)); + node.transformFlags |= + propagateChildFlags(node.expression) | + propagateChildrenFlags(node.typeArguments) | + propagateChildrenFlags(node.arguments); + if (node.typeArguments) { + node.transformFlags |= 1 /* TransformFlags.ContainsTypeScript */; + } + if (ts.isImportKeyword(node.expression)) { + node.transformFlags |= 8388608 /* TransformFlags.ContainsDynamicImport */; + } + else if (ts.isSuperProperty(node.expression)) { + node.transformFlags |= 16384 /* TransformFlags.ContainsLexicalThis */; + } + return node; + } + // @api + function updateCallExpression(node, expression, typeArguments, argumentsArray) { + if (ts.isCallChain(node)) { + return updateCallChain(node, expression, node.questionDotToken, typeArguments, argumentsArray); + } + return node.expression !== expression + || node.typeArguments !== typeArguments + || node.arguments !== argumentsArray + ? update(createCallExpression(expression, typeArguments, argumentsArray), node) + : node; + } + // @api + function createCallChain(expression, questionDotToken, typeArguments, argumentsArray) { + var node = createBaseExpression(210 /* SyntaxKind.CallExpression */); + node.flags |= 32 /* NodeFlags.OptionalChain */; + node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, /*optionalChain*/ true); + node.questionDotToken = questionDotToken; + node.typeArguments = asNodeArray(typeArguments); + node.arguments = parenthesizerRules().parenthesizeExpressionsOfCommaDelimitedList(createNodeArray(argumentsArray)); + node.transformFlags |= + propagateChildFlags(node.expression) | + propagateChildFlags(node.questionDotToken) | + propagateChildrenFlags(node.typeArguments) | + propagateChildrenFlags(node.arguments) | + 32 /* TransformFlags.ContainsES2020 */; + if (node.typeArguments) { + node.transformFlags |= 1 /* TransformFlags.ContainsTypeScript */; + } + if (ts.isSuperProperty(node.expression)) { + node.transformFlags |= 16384 /* TransformFlags.ContainsLexicalThis */; + } + return node; + } + // @api + function updateCallChain(node, expression, questionDotToken, typeArguments, argumentsArray) { + ts.Debug.assert(!!(node.flags & 32 /* NodeFlags.OptionalChain */), "Cannot update a CallExpression using updateCallChain. Use updateCall instead."); + return node.expression !== expression + || node.questionDotToken !== questionDotToken + || node.typeArguments !== typeArguments + || node.arguments !== argumentsArray + ? update(createCallChain(expression, questionDotToken, typeArguments, argumentsArray), node) + : node; + } + // @api + function createNewExpression(expression, typeArguments, argumentsArray) { + var node = createBaseExpression(211 /* SyntaxKind.NewExpression */); + node.expression = parenthesizerRules().parenthesizeExpressionOfNew(expression); + node.typeArguments = asNodeArray(typeArguments); + node.arguments = argumentsArray ? parenthesizerRules().parenthesizeExpressionsOfCommaDelimitedList(argumentsArray) : undefined; + node.transformFlags |= + propagateChildFlags(node.expression) | + propagateChildrenFlags(node.typeArguments) | + propagateChildrenFlags(node.arguments) | + 32 /* TransformFlags.ContainsES2020 */; + if (node.typeArguments) { + node.transformFlags |= 1 /* TransformFlags.ContainsTypeScript */; + } + return node; + } + // @api + function updateNewExpression(node, expression, typeArguments, argumentsArray) { + return node.expression !== expression + || node.typeArguments !== typeArguments + || node.arguments !== argumentsArray + ? update(createNewExpression(expression, typeArguments, argumentsArray), node) + : node; + } + // @api + function createTaggedTemplateExpression(tag, typeArguments, template) { + var node = createBaseExpression(212 /* SyntaxKind.TaggedTemplateExpression */); + node.tag = parenthesizerRules().parenthesizeLeftSideOfAccess(tag, /*optionalChain*/ false); + node.typeArguments = asNodeArray(typeArguments); + node.template = template; + node.transformFlags |= + propagateChildFlags(node.tag) | + propagateChildrenFlags(node.typeArguments) | + propagateChildFlags(node.template) | + 1024 /* TransformFlags.ContainsES2015 */; + if (node.typeArguments) { + node.transformFlags |= 1 /* TransformFlags.ContainsTypeScript */; + } + if (ts.hasInvalidEscape(node.template)) { + node.transformFlags |= 128 /* TransformFlags.ContainsES2018 */; + } + return node; + } + // @api + function updateTaggedTemplateExpression(node, tag, typeArguments, template) { + return node.tag !== tag + || node.typeArguments !== typeArguments + || node.template !== template + ? update(createTaggedTemplateExpression(tag, typeArguments, template), node) + : node; + } + // @api + function createTypeAssertion(type, expression) { + var node = createBaseExpression(213 /* SyntaxKind.TypeAssertionExpression */); + node.expression = parenthesizerRules().parenthesizeOperandOfPrefixUnary(expression); + node.type = type; + node.transformFlags |= + propagateChildFlags(node.expression) | + propagateChildFlags(node.type) | + 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateTypeAssertion(node, type, expression) { + return node.type !== type + || node.expression !== expression + ? update(createTypeAssertion(type, expression), node) + : node; + } + // @api + function createParenthesizedExpression(expression) { + var node = createBaseExpression(214 /* SyntaxKind.ParenthesizedExpression */); + node.expression = expression; + node.transformFlags = propagateChildFlags(node.expression); + return node; + } + // @api + function updateParenthesizedExpression(node, expression) { + return node.expression !== expression + ? update(createParenthesizedExpression(expression), node) + : node; + } + // @api + function createFunctionExpression(modifiers, asteriskToken, name, typeParameters, parameters, type, body) { + var node = createBaseFunctionLikeDeclaration(215 /* SyntaxKind.FunctionExpression */, modifiers, name, typeParameters, parameters, type, body); + node.asteriskToken = asteriskToken; + node.transformFlags |= propagateChildFlags(node.asteriskToken); + if (node.typeParameters) { + node.transformFlags |= 1 /* TransformFlags.ContainsTypeScript */; + } + if (ts.modifiersToFlags(node.modifiers) & 512 /* ModifierFlags.Async */) { + if (node.asteriskToken) { + node.transformFlags |= 128 /* TransformFlags.ContainsES2018 */; + } + else { + node.transformFlags |= 256 /* TransformFlags.ContainsES2017 */; + } + } + else if (node.asteriskToken) { + node.transformFlags |= 2048 /* TransformFlags.ContainsGenerator */; + } + return node; + } + // @api + function updateFunctionExpression(node, modifiers, asteriskToken, name, typeParameters, parameters, type, body) { + return node.name !== name + || node.modifiers !== modifiers + || node.asteriskToken !== asteriskToken + || node.typeParameters !== typeParameters + || node.parameters !== parameters + || node.type !== type + || node.body !== body + ? finishUpdateBaseSignatureDeclaration(createFunctionExpression(modifiers, asteriskToken, name, typeParameters, parameters, type, body), node) + : node; + } + // @api + function createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body) { + var node = createBaseFunctionLikeDeclaration(216 /* SyntaxKind.ArrowFunction */, modifiers, + /*name*/ undefined, typeParameters, parameters, type, parenthesizerRules().parenthesizeConciseBodyOfArrowFunction(body)); + node.equalsGreaterThanToken = equalsGreaterThanToken !== null && equalsGreaterThanToken !== void 0 ? equalsGreaterThanToken : createToken(38 /* SyntaxKind.EqualsGreaterThanToken */); + node.transformFlags |= + propagateChildFlags(node.equalsGreaterThanToken) | + 1024 /* TransformFlags.ContainsES2015 */; + if (ts.modifiersToFlags(node.modifiers) & 512 /* ModifierFlags.Async */) { + node.transformFlags |= 256 /* TransformFlags.ContainsES2017 */ | 16384 /* TransformFlags.ContainsLexicalThis */; + } + return node; + } + // @api + function updateArrowFunction(node, modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body) { + return node.modifiers !== modifiers + || node.typeParameters !== typeParameters + || node.parameters !== parameters + || node.type !== type + || node.equalsGreaterThanToken !== equalsGreaterThanToken + || node.body !== body + ? finishUpdateBaseSignatureDeclaration(createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body), node) + : node; + } + // @api + function createDeleteExpression(expression) { + var node = createBaseExpression(217 /* SyntaxKind.DeleteExpression */); + node.expression = parenthesizerRules().parenthesizeOperandOfPrefixUnary(expression); + node.transformFlags |= propagateChildFlags(node.expression); + return node; + } + // @api + function updateDeleteExpression(node, expression) { + return node.expression !== expression + ? update(createDeleteExpression(expression), node) + : node; + } + // @api + function createTypeOfExpression(expression) { + var node = createBaseExpression(218 /* SyntaxKind.TypeOfExpression */); + node.expression = parenthesizerRules().parenthesizeOperandOfPrefixUnary(expression); + node.transformFlags |= propagateChildFlags(node.expression); + return node; + } + // @api + function updateTypeOfExpression(node, expression) { + return node.expression !== expression + ? update(createTypeOfExpression(expression), node) + : node; + } + // @api + function createVoidExpression(expression) { + var node = createBaseExpression(219 /* SyntaxKind.VoidExpression */); + node.expression = parenthesizerRules().parenthesizeOperandOfPrefixUnary(expression); + node.transformFlags |= propagateChildFlags(node.expression); + return node; + } + // @api + function updateVoidExpression(node, expression) { + return node.expression !== expression + ? update(createVoidExpression(expression), node) + : node; + } + // @api + function createAwaitExpression(expression) { + var node = createBaseExpression(220 /* SyntaxKind.AwaitExpression */); + node.expression = parenthesizerRules().parenthesizeOperandOfPrefixUnary(expression); + node.transformFlags |= + propagateChildFlags(node.expression) | + 256 /* TransformFlags.ContainsES2017 */ | + 128 /* TransformFlags.ContainsES2018 */ | + 2097152 /* TransformFlags.ContainsAwait */; + return node; + } + // @api + function updateAwaitExpression(node, expression) { + return node.expression !== expression + ? update(createAwaitExpression(expression), node) + : node; + } + // @api + function createPrefixUnaryExpression(operator, operand) { + var node = createBaseExpression(221 /* SyntaxKind.PrefixUnaryExpression */); + node.operator = operator; + node.operand = parenthesizerRules().parenthesizeOperandOfPrefixUnary(operand); + node.transformFlags |= propagateChildFlags(node.operand); + // Only set this flag for non-generated identifiers and non-"local" names. See the + // comment in `visitPreOrPostfixUnaryExpression` in module.ts + if ((operator === 45 /* SyntaxKind.PlusPlusToken */ || operator === 46 /* SyntaxKind.MinusMinusToken */) && + ts.isIdentifier(node.operand) && + !ts.isGeneratedIdentifier(node.operand) && + !ts.isLocalName(node.operand)) { + node.transformFlags |= 268435456 /* TransformFlags.ContainsUpdateExpressionForIdentifier */; + } + return node; + } + // @api + function updatePrefixUnaryExpression(node, operand) { + return node.operand !== operand + ? update(createPrefixUnaryExpression(node.operator, operand), node) + : node; + } + // @api + function createPostfixUnaryExpression(operand, operator) { + var node = createBaseExpression(222 /* SyntaxKind.PostfixUnaryExpression */); + node.operator = operator; + node.operand = parenthesizerRules().parenthesizeOperandOfPostfixUnary(operand); + node.transformFlags |= propagateChildFlags(node.operand); + // Only set this flag for non-generated identifiers and non-"local" names. See the + // comment in `visitPreOrPostfixUnaryExpression` in module.ts + if (ts.isIdentifier(node.operand) && + !ts.isGeneratedIdentifier(node.operand) && + !ts.isLocalName(node.operand)) { + node.transformFlags |= 268435456 /* TransformFlags.ContainsUpdateExpressionForIdentifier */; + } + return node; + } + // @api + function updatePostfixUnaryExpression(node, operand) { + return node.operand !== operand + ? update(createPostfixUnaryExpression(operand, node.operator), node) + : node; + } + // @api + function createBinaryExpression(left, operator, right) { + var node = createBaseExpression(223 /* SyntaxKind.BinaryExpression */); + var operatorToken = asToken(operator); + var operatorKind = operatorToken.kind; + node.left = parenthesizerRules().parenthesizeLeftSideOfBinary(operatorKind, left); + node.operatorToken = operatorToken; + node.right = parenthesizerRules().parenthesizeRightSideOfBinary(operatorKind, node.left, right); + node.transformFlags |= + propagateChildFlags(node.left) | + propagateChildFlags(node.operatorToken) | + propagateChildFlags(node.right); + if (operatorKind === 60 /* SyntaxKind.QuestionQuestionToken */) { + node.transformFlags |= 32 /* TransformFlags.ContainsES2020 */; + } + else if (operatorKind === 63 /* SyntaxKind.EqualsToken */) { + if (ts.isObjectLiteralExpression(node.left)) { + node.transformFlags |= + 1024 /* TransformFlags.ContainsES2015 */ | + 128 /* TransformFlags.ContainsES2018 */ | + 4096 /* TransformFlags.ContainsDestructuringAssignment */ | + propagateAssignmentPatternFlags(node.left); + } + else if (ts.isArrayLiteralExpression(node.left)) { + node.transformFlags |= + 1024 /* TransformFlags.ContainsES2015 */ | + 4096 /* TransformFlags.ContainsDestructuringAssignment */ | + propagateAssignmentPatternFlags(node.left); + } + } + else if (operatorKind === 42 /* SyntaxKind.AsteriskAsteriskToken */ || operatorKind === 67 /* SyntaxKind.AsteriskAsteriskEqualsToken */) { + node.transformFlags |= 512 /* TransformFlags.ContainsES2016 */; + } + else if (ts.isLogicalOrCoalescingAssignmentOperator(operatorKind)) { + node.transformFlags |= 16 /* TransformFlags.ContainsES2021 */; + } + if (operatorKind === 101 /* SyntaxKind.InKeyword */ && ts.isPrivateIdentifier(node.left)) { + node.transformFlags |= 536870912 /* TransformFlags.ContainsPrivateIdentifierInExpression */; + } + return node; + } + function propagateAssignmentPatternFlags(node) { + if (node.transformFlags & 65536 /* TransformFlags.ContainsObjectRestOrSpread */) + return 65536 /* TransformFlags.ContainsObjectRestOrSpread */; + if (node.transformFlags & 128 /* TransformFlags.ContainsES2018 */) { + // check for nested spread assignments, otherwise '{ x: { a, ...b } = foo } = c' + // will not be correctly interpreted by the ES2018 transformer + for (var _i = 0, _a = ts.getElementsOfBindingOrAssignmentPattern(node); _i < _a.length; _i++) { + var element = _a[_i]; + var target = ts.getTargetOfBindingOrAssignmentElement(element); + if (target && ts.isAssignmentPattern(target)) { + if (target.transformFlags & 65536 /* TransformFlags.ContainsObjectRestOrSpread */) { + return 65536 /* TransformFlags.ContainsObjectRestOrSpread */; + } + if (target.transformFlags & 128 /* TransformFlags.ContainsES2018 */) { + var flags_1 = propagateAssignmentPatternFlags(target); + if (flags_1) + return flags_1; + } + } + } + } + return 0 /* TransformFlags.None */; + } + // @api + function updateBinaryExpression(node, left, operator, right) { + return node.left !== left + || node.operatorToken !== operator + || node.right !== right + ? update(createBinaryExpression(left, operator, right), node) + : node; + } + // @api + function createConditionalExpression(condition, questionToken, whenTrue, colonToken, whenFalse) { + var node = createBaseExpression(224 /* SyntaxKind.ConditionalExpression */); + node.condition = parenthesizerRules().parenthesizeConditionOfConditionalExpression(condition); + node.questionToken = questionToken !== null && questionToken !== void 0 ? questionToken : createToken(57 /* SyntaxKind.QuestionToken */); + node.whenTrue = parenthesizerRules().parenthesizeBranchOfConditionalExpression(whenTrue); + node.colonToken = colonToken !== null && colonToken !== void 0 ? colonToken : createToken(58 /* SyntaxKind.ColonToken */); + node.whenFalse = parenthesizerRules().parenthesizeBranchOfConditionalExpression(whenFalse); + node.transformFlags |= + propagateChildFlags(node.condition) | + propagateChildFlags(node.questionToken) | + propagateChildFlags(node.whenTrue) | + propagateChildFlags(node.colonToken) | + propagateChildFlags(node.whenFalse); + return node; + } + // @api + function updateConditionalExpression(node, condition, questionToken, whenTrue, colonToken, whenFalse) { + return node.condition !== condition + || node.questionToken !== questionToken + || node.whenTrue !== whenTrue + || node.colonToken !== colonToken + || node.whenFalse !== whenFalse + ? update(createConditionalExpression(condition, questionToken, whenTrue, colonToken, whenFalse), node) + : node; + } + // @api + function createTemplateExpression(head, templateSpans) { + var node = createBaseExpression(225 /* SyntaxKind.TemplateExpression */); + node.head = head; + node.templateSpans = createNodeArray(templateSpans); + node.transformFlags |= + propagateChildFlags(node.head) | + propagateChildrenFlags(node.templateSpans) | + 1024 /* TransformFlags.ContainsES2015 */; + return node; + } + // @api + function updateTemplateExpression(node, head, templateSpans) { + return node.head !== head + || node.templateSpans !== templateSpans + ? update(createTemplateExpression(head, templateSpans), node) + : node; + } + function createTemplateLiteralLikeNodeChecked(kind, text, rawText, templateFlags) { + if (templateFlags === void 0) { templateFlags = 0 /* TokenFlags.None */; } + ts.Debug.assert(!(templateFlags & ~2048 /* TokenFlags.TemplateLiteralLikeFlags */), "Unsupported template flags."); + // NOTE: without the assignment to `undefined`, we don't narrow the initial type of `cooked`. + // eslint-disable-next-line no-undef-init + var cooked = undefined; + if (rawText !== undefined && rawText !== text) { + cooked = getCookedText(kind, rawText); + if (typeof cooked === "object") { + return ts.Debug.fail("Invalid raw text"); + } + } + if (text === undefined) { + if (cooked === undefined) { + return ts.Debug.fail("Arguments 'text' and 'rawText' may not both be undefined."); + } + text = cooked; + } + else if (cooked !== undefined) { + ts.Debug.assert(text === cooked, "Expected argument 'text' to be the normalized (i.e. 'cooked') version of argument 'rawText'."); + } + return createTemplateLiteralLikeNode(kind, text, rawText, templateFlags); + } + // @api + function createTemplateLiteralLikeNode(kind, text, rawText, templateFlags) { + var node = createBaseToken(kind); + node.text = text; + node.rawText = rawText; + node.templateFlags = templateFlags & 2048 /* TokenFlags.TemplateLiteralLikeFlags */; + node.transformFlags |= 1024 /* TransformFlags.ContainsES2015 */; + if (node.templateFlags) { + node.transformFlags |= 128 /* TransformFlags.ContainsES2018 */; + } + return node; + } + // @api + function createTemplateHead(text, rawText, templateFlags) { + return createTemplateLiteralLikeNodeChecked(15 /* SyntaxKind.TemplateHead */, text, rawText, templateFlags); + } + // @api + function createTemplateMiddle(text, rawText, templateFlags) { + return createTemplateLiteralLikeNodeChecked(16 /* SyntaxKind.TemplateMiddle */, text, rawText, templateFlags); + } + // @api + function createTemplateTail(text, rawText, templateFlags) { + return createTemplateLiteralLikeNodeChecked(17 /* SyntaxKind.TemplateTail */, text, rawText, templateFlags); + } + // @api + function createNoSubstitutionTemplateLiteral(text, rawText, templateFlags) { + return createTemplateLiteralLikeNodeChecked(14 /* SyntaxKind.NoSubstitutionTemplateLiteral */, text, rawText, templateFlags); + } + // @api + function createYieldExpression(asteriskToken, expression) { + ts.Debug.assert(!asteriskToken || !!expression, "A `YieldExpression` with an asteriskToken must have an expression."); + var node = createBaseExpression(226 /* SyntaxKind.YieldExpression */); + node.expression = expression && parenthesizerRules().parenthesizeExpressionForDisallowedComma(expression); + node.asteriskToken = asteriskToken; + node.transformFlags |= + propagateChildFlags(node.expression) | + propagateChildFlags(node.asteriskToken) | + 1024 /* TransformFlags.ContainsES2015 */ | + 128 /* TransformFlags.ContainsES2018 */ | + 1048576 /* TransformFlags.ContainsYield */; + return node; + } + // @api + function updateYieldExpression(node, asteriskToken, expression) { + return node.expression !== expression + || node.asteriskToken !== asteriskToken + ? update(createYieldExpression(asteriskToken, expression), node) + : node; + } + // @api + function createSpreadElement(expression) { + var node = createBaseExpression(227 /* SyntaxKind.SpreadElement */); + node.expression = parenthesizerRules().parenthesizeExpressionForDisallowedComma(expression); + node.transformFlags |= + propagateChildFlags(node.expression) | + 1024 /* TransformFlags.ContainsES2015 */ | + 32768 /* TransformFlags.ContainsRestOrSpread */; + return node; + } + // @api + function updateSpreadElement(node, expression) { + return node.expression !== expression + ? update(createSpreadElement(expression), node) + : node; + } + // @api + function createClassExpression(modifiers, name, typeParameters, heritageClauses, members) { + var node = createBaseClassLikeDeclaration(228 /* SyntaxKind.ClassExpression */, modifiers, name, typeParameters, heritageClauses, members); + node.transformFlags |= 1024 /* TransformFlags.ContainsES2015 */; + return node; + } + // @api + function updateClassExpression(node, modifiers, name, typeParameters, heritageClauses, members) { + return node.modifiers !== modifiers + || node.name !== name + || node.typeParameters !== typeParameters + || node.heritageClauses !== heritageClauses + || node.members !== members + ? update(createClassExpression(modifiers, name, typeParameters, heritageClauses, members), node) + : node; + } + // @api + function createOmittedExpression() { + return createBaseExpression(229 /* SyntaxKind.OmittedExpression */); + } + // @api + function createExpressionWithTypeArguments(expression, typeArguments) { + var node = createBaseNode(230 /* SyntaxKind.ExpressionWithTypeArguments */); + node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, /*optionalChain*/ false); + node.typeArguments = typeArguments && parenthesizerRules().parenthesizeTypeArguments(typeArguments); + node.transformFlags |= + propagateChildFlags(node.expression) | + propagateChildrenFlags(node.typeArguments) | + 1024 /* TransformFlags.ContainsES2015 */; + return node; + } + // @api + function updateExpressionWithTypeArguments(node, expression, typeArguments) { + return node.expression !== expression + || node.typeArguments !== typeArguments + ? update(createExpressionWithTypeArguments(expression, typeArguments), node) + : node; + } + // @api + function createAsExpression(expression, type) { + var node = createBaseExpression(231 /* SyntaxKind.AsExpression */); + node.expression = expression; + node.type = type; + node.transformFlags |= + propagateChildFlags(node.expression) | + propagateChildFlags(node.type) | + 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateAsExpression(node, expression, type) { + return node.expression !== expression + || node.type !== type + ? update(createAsExpression(expression, type), node) + : node; + } + // @api + function createNonNullExpression(expression) { + var node = createBaseExpression(232 /* SyntaxKind.NonNullExpression */); + node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, /*optionalChain*/ false); + node.transformFlags |= + propagateChildFlags(node.expression) | + 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateNonNullExpression(node, expression) { + if (ts.isNonNullChain(node)) { + return updateNonNullChain(node, expression); + } + return node.expression !== expression + ? update(createNonNullExpression(expression), node) + : node; + } + // @api + function createSatisfiesExpression(expression, type) { + var node = createBaseExpression(235 /* SyntaxKind.SatisfiesExpression */); + node.expression = expression; + node.type = type; + node.transformFlags |= + propagateChildFlags(node.expression) | + propagateChildFlags(node.type) | + 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateSatisfiesExpression(node, expression, type) { + return node.expression !== expression + || node.type !== type + ? update(createSatisfiesExpression(expression, type), node) + : node; + } + // @api + function createNonNullChain(expression) { + var node = createBaseExpression(232 /* SyntaxKind.NonNullExpression */); + node.flags |= 32 /* NodeFlags.OptionalChain */; + node.expression = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, /*optionalChain*/ true); + node.transformFlags |= + propagateChildFlags(node.expression) | + 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateNonNullChain(node, expression) { + ts.Debug.assert(!!(node.flags & 32 /* NodeFlags.OptionalChain */), "Cannot update a NonNullExpression using updateNonNullChain. Use updateNonNullExpression instead."); + return node.expression !== expression + ? update(createNonNullChain(expression), node) + : node; + } + // @api + function createMetaProperty(keywordToken, name) { + var node = createBaseExpression(233 /* SyntaxKind.MetaProperty */); + node.keywordToken = keywordToken; + node.name = name; + node.transformFlags |= propagateChildFlags(node.name); + switch (keywordToken) { + case 103 /* SyntaxKind.NewKeyword */: + node.transformFlags |= 1024 /* TransformFlags.ContainsES2015 */; + break; + case 100 /* SyntaxKind.ImportKeyword */: + node.transformFlags |= 4 /* TransformFlags.ContainsESNext */; + break; + default: + return ts.Debug.assertNever(keywordToken); + } + return node; + } + // @api + function updateMetaProperty(node, name) { + return node.name !== name + ? update(createMetaProperty(node.keywordToken, name), node) + : node; + } + // + // Misc + // + // @api + function createTemplateSpan(expression, literal) { + var node = createBaseNode(236 /* SyntaxKind.TemplateSpan */); + node.expression = expression; + node.literal = literal; + node.transformFlags |= + propagateChildFlags(node.expression) | + propagateChildFlags(node.literal) | + 1024 /* TransformFlags.ContainsES2015 */; + return node; + } + // @api + function updateTemplateSpan(node, expression, literal) { + return node.expression !== expression + || node.literal !== literal + ? update(createTemplateSpan(expression, literal), node) + : node; + } + // @api + function createSemicolonClassElement() { + var node = createBaseNode(237 /* SyntaxKind.SemicolonClassElement */); + node.transformFlags |= 1024 /* TransformFlags.ContainsES2015 */; + return node; + } + // + // Element + // + // @api + function createBlock(statements, multiLine) { + var node = createBaseNode(238 /* SyntaxKind.Block */); + node.statements = createNodeArray(statements); + node.multiLine = multiLine; + node.transformFlags |= propagateChildrenFlags(node.statements); + return node; + } + // @api + function updateBlock(node, statements) { + return node.statements !== statements + ? update(createBlock(statements, node.multiLine), node) + : node; + } + // @api + function createVariableStatement(modifiers, declarationList) { + var node = createBaseDeclaration(240 /* SyntaxKind.VariableStatement */); + node.modifiers = asNodeArray(modifiers); + node.declarationList = ts.isArray(declarationList) ? createVariableDeclarationList(declarationList) : declarationList; + node.transformFlags |= + propagateChildrenFlags(node.modifiers) | + propagateChildFlags(node.declarationList); + if (ts.modifiersToFlags(node.modifiers) & 2 /* ModifierFlags.Ambient */) { + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + } + return node; + } + // @api + function updateVariableStatement(node, modifiers, declarationList) { + return node.modifiers !== modifiers + || node.declarationList !== declarationList + ? update(createVariableStatement(modifiers, declarationList), node) + : node; + } + // @api + function createEmptyStatement() { + return createBaseNode(239 /* SyntaxKind.EmptyStatement */); + } + // @api + function createExpressionStatement(expression) { + var node = createBaseNode(241 /* SyntaxKind.ExpressionStatement */); + node.expression = parenthesizerRules().parenthesizeExpressionOfExpressionStatement(expression); + node.transformFlags |= propagateChildFlags(node.expression); + return node; + } + // @api + function updateExpressionStatement(node, expression) { + return node.expression !== expression + ? update(createExpressionStatement(expression), node) + : node; + } + // @api + function createIfStatement(expression, thenStatement, elseStatement) { + var node = createBaseNode(242 /* SyntaxKind.IfStatement */); + node.expression = expression; + node.thenStatement = asEmbeddedStatement(thenStatement); + node.elseStatement = asEmbeddedStatement(elseStatement); + node.transformFlags |= + propagateChildFlags(node.expression) | + propagateChildFlags(node.thenStatement) | + propagateChildFlags(node.elseStatement); + return node; + } + // @api + function updateIfStatement(node, expression, thenStatement, elseStatement) { + return node.expression !== expression + || node.thenStatement !== thenStatement + || node.elseStatement !== elseStatement + ? update(createIfStatement(expression, thenStatement, elseStatement), node) + : node; + } + // @api + function createDoStatement(statement, expression) { + var node = createBaseNode(243 /* SyntaxKind.DoStatement */); + node.statement = asEmbeddedStatement(statement); + node.expression = expression; + node.transformFlags |= + propagateChildFlags(node.statement) | + propagateChildFlags(node.expression); + return node; + } + // @api + function updateDoStatement(node, statement, expression) { + return node.statement !== statement + || node.expression !== expression + ? update(createDoStatement(statement, expression), node) + : node; + } + // @api + function createWhileStatement(expression, statement) { + var node = createBaseNode(244 /* SyntaxKind.WhileStatement */); + node.expression = expression; + node.statement = asEmbeddedStatement(statement); + node.transformFlags |= + propagateChildFlags(node.expression) | + propagateChildFlags(node.statement); + return node; + } + // @api + function updateWhileStatement(node, expression, statement) { + return node.expression !== expression + || node.statement !== statement + ? update(createWhileStatement(expression, statement), node) + : node; + } + // @api + function createForStatement(initializer, condition, incrementor, statement) { + var node = createBaseNode(245 /* SyntaxKind.ForStatement */); + node.initializer = initializer; + node.condition = condition; + node.incrementor = incrementor; + node.statement = asEmbeddedStatement(statement); + node.transformFlags |= + propagateChildFlags(node.initializer) | + propagateChildFlags(node.condition) | + propagateChildFlags(node.incrementor) | + propagateChildFlags(node.statement); + return node; + } + // @api + function updateForStatement(node, initializer, condition, incrementor, statement) { + return node.initializer !== initializer + || node.condition !== condition + || node.incrementor !== incrementor + || node.statement !== statement + ? update(createForStatement(initializer, condition, incrementor, statement), node) + : node; + } + // @api + function createForInStatement(initializer, expression, statement) { + var node = createBaseNode(246 /* SyntaxKind.ForInStatement */); + node.initializer = initializer; + node.expression = expression; + node.statement = asEmbeddedStatement(statement); + node.transformFlags |= + propagateChildFlags(node.initializer) | + propagateChildFlags(node.expression) | + propagateChildFlags(node.statement); + return node; + } + // @api + function updateForInStatement(node, initializer, expression, statement) { + return node.initializer !== initializer + || node.expression !== expression + || node.statement !== statement + ? update(createForInStatement(initializer, expression, statement), node) + : node; + } + // @api + function createForOfStatement(awaitModifier, initializer, expression, statement) { + var node = createBaseNode(247 /* SyntaxKind.ForOfStatement */); + node.awaitModifier = awaitModifier; + node.initializer = initializer; + node.expression = parenthesizerRules().parenthesizeExpressionForDisallowedComma(expression); + node.statement = asEmbeddedStatement(statement); + node.transformFlags |= + propagateChildFlags(node.awaitModifier) | + propagateChildFlags(node.initializer) | + propagateChildFlags(node.expression) | + propagateChildFlags(node.statement) | + 1024 /* TransformFlags.ContainsES2015 */; + if (awaitModifier) + node.transformFlags |= 128 /* TransformFlags.ContainsES2018 */; + return node; + } + // @api + function updateForOfStatement(node, awaitModifier, initializer, expression, statement) { + return node.awaitModifier !== awaitModifier + || node.initializer !== initializer + || node.expression !== expression + || node.statement !== statement + ? update(createForOfStatement(awaitModifier, initializer, expression, statement), node) + : node; + } + // @api + function createContinueStatement(label) { + var node = createBaseNode(248 /* SyntaxKind.ContinueStatement */); + node.label = asName(label); + node.transformFlags |= + propagateChildFlags(node.label) | + 4194304 /* TransformFlags.ContainsHoistedDeclarationOrCompletion */; + return node; + } + // @api + function updateContinueStatement(node, label) { + return node.label !== label + ? update(createContinueStatement(label), node) + : node; + } + // @api + function createBreakStatement(label) { + var node = createBaseNode(249 /* SyntaxKind.BreakStatement */); + node.label = asName(label); + node.transformFlags |= + propagateChildFlags(node.label) | + 4194304 /* TransformFlags.ContainsHoistedDeclarationOrCompletion */; + return node; + } + // @api + function updateBreakStatement(node, label) { + return node.label !== label + ? update(createBreakStatement(label), node) + : node; + } + // @api + function createReturnStatement(expression) { + var node = createBaseNode(250 /* SyntaxKind.ReturnStatement */); + node.expression = expression; + // return in an ES2018 async generator must be awaited + node.transformFlags |= + propagateChildFlags(node.expression) | + 128 /* TransformFlags.ContainsES2018 */ | + 4194304 /* TransformFlags.ContainsHoistedDeclarationOrCompletion */; + return node; + } + // @api + function updateReturnStatement(node, expression) { + return node.expression !== expression + ? update(createReturnStatement(expression), node) + : node; + } + // @api + function createWithStatement(expression, statement) { + var node = createBaseNode(251 /* SyntaxKind.WithStatement */); + node.expression = expression; + node.statement = asEmbeddedStatement(statement); + node.transformFlags |= + propagateChildFlags(node.expression) | + propagateChildFlags(node.statement); + return node; + } + // @api + function updateWithStatement(node, expression, statement) { + return node.expression !== expression + || node.statement !== statement + ? update(createWithStatement(expression, statement), node) + : node; + } + // @api + function createSwitchStatement(expression, caseBlock) { + var node = createBaseNode(252 /* SyntaxKind.SwitchStatement */); + node.expression = parenthesizerRules().parenthesizeExpressionForDisallowedComma(expression); + node.caseBlock = caseBlock; + node.transformFlags |= + propagateChildFlags(node.expression) | + propagateChildFlags(node.caseBlock); + return node; + } + // @api + function updateSwitchStatement(node, expression, caseBlock) { + return node.expression !== expression + || node.caseBlock !== caseBlock + ? update(createSwitchStatement(expression, caseBlock), node) + : node; + } + // @api + function createLabeledStatement(label, statement) { + var node = createBaseNode(253 /* SyntaxKind.LabeledStatement */); + node.label = asName(label); + node.statement = asEmbeddedStatement(statement); + node.transformFlags |= + propagateChildFlags(node.label) | + propagateChildFlags(node.statement); + return node; + } + // @api + function updateLabeledStatement(node, label, statement) { + return node.label !== label + || node.statement !== statement + ? update(createLabeledStatement(label, statement), node) + : node; + } + // @api + function createThrowStatement(expression) { + var node = createBaseNode(254 /* SyntaxKind.ThrowStatement */); + node.expression = expression; + node.transformFlags |= propagateChildFlags(node.expression); + return node; + } + // @api + function updateThrowStatement(node, expression) { + return node.expression !== expression + ? update(createThrowStatement(expression), node) + : node; + } + // @api + function createTryStatement(tryBlock, catchClause, finallyBlock) { + var node = createBaseNode(255 /* SyntaxKind.TryStatement */); + node.tryBlock = tryBlock; + node.catchClause = catchClause; + node.finallyBlock = finallyBlock; + node.transformFlags |= + propagateChildFlags(node.tryBlock) | + propagateChildFlags(node.catchClause) | + propagateChildFlags(node.finallyBlock); + return node; + } + // @api + function updateTryStatement(node, tryBlock, catchClause, finallyBlock) { + return node.tryBlock !== tryBlock + || node.catchClause !== catchClause + || node.finallyBlock !== finallyBlock + ? update(createTryStatement(tryBlock, catchClause, finallyBlock), node) + : node; + } + // @api + function createDebuggerStatement() { + return createBaseNode(256 /* SyntaxKind.DebuggerStatement */); + } + // @api + function createVariableDeclaration(name, exclamationToken, type, initializer) { + var node = createBaseVariableLikeDeclaration(257 /* SyntaxKind.VariableDeclaration */, + /*modifiers*/ undefined, name, type, initializer && parenthesizerRules().parenthesizeExpressionForDisallowedComma(initializer)); + node.exclamationToken = exclamationToken; + node.transformFlags |= propagateChildFlags(node.exclamationToken); + if (exclamationToken) { + node.transformFlags |= 1 /* TransformFlags.ContainsTypeScript */; + } + return node; + } + // @api + function updateVariableDeclaration(node, name, exclamationToken, type, initializer) { + return node.name !== name + || node.type !== type + || node.exclamationToken !== exclamationToken + || node.initializer !== initializer + ? update(createVariableDeclaration(name, exclamationToken, type, initializer), node) + : node; + } + // @api + function createVariableDeclarationList(declarations, flags) { + if (flags === void 0) { flags = 0 /* NodeFlags.None */; } + var node = createBaseNode(258 /* SyntaxKind.VariableDeclarationList */); + node.flags |= flags & 3 /* NodeFlags.BlockScoped */; + node.declarations = createNodeArray(declarations); + node.transformFlags |= + propagateChildrenFlags(node.declarations) | + 4194304 /* TransformFlags.ContainsHoistedDeclarationOrCompletion */; + if (flags & 3 /* NodeFlags.BlockScoped */) { + node.transformFlags |= + 1024 /* TransformFlags.ContainsES2015 */ | + 262144 /* TransformFlags.ContainsBlockScopedBinding */; + } + return node; + } + // @api + function updateVariableDeclarationList(node, declarations) { + return node.declarations !== declarations + ? update(createVariableDeclarationList(declarations, node.flags), node) + : node; + } + // @api + function createFunctionDeclaration(modifiers, asteriskToken, name, typeParameters, parameters, type, body) { + var node = createBaseFunctionLikeDeclaration(259 /* SyntaxKind.FunctionDeclaration */, modifiers, name, typeParameters, parameters, type, body); + node.asteriskToken = asteriskToken; + if (!node.body || ts.modifiersToFlags(node.modifiers) & 2 /* ModifierFlags.Ambient */) { + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + } + else { + node.transformFlags |= + propagateChildFlags(node.asteriskToken) | + 4194304 /* TransformFlags.ContainsHoistedDeclarationOrCompletion */; + if (ts.modifiersToFlags(node.modifiers) & 512 /* ModifierFlags.Async */) { + if (node.asteriskToken) { + node.transformFlags |= 128 /* TransformFlags.ContainsES2018 */; + } + else { + node.transformFlags |= 256 /* TransformFlags.ContainsES2017 */; + } + } + else if (node.asteriskToken) { + node.transformFlags |= 2048 /* TransformFlags.ContainsGenerator */; + } + } + // The following properties are used only to report grammar errors + node.illegalDecorators = undefined; + return node; + } + // @api + function updateFunctionDeclaration(node, modifiers, asteriskToken, name, typeParameters, parameters, type, body) { + return node.modifiers !== modifiers + || node.asteriskToken !== asteriskToken + || node.name !== name + || node.typeParameters !== typeParameters + || node.parameters !== parameters + || node.type !== type + || node.body !== body + ? finishUpdateFunctionDeclaration(createFunctionDeclaration(modifiers, asteriskToken, name, typeParameters, parameters, type, body), node) + : node; + } + function finishUpdateFunctionDeclaration(updated, original) { + if (updated !== original) { + // copy children used only for error reporting + updated.illegalDecorators = original.illegalDecorators; + } + return finishUpdateBaseSignatureDeclaration(updated, original); + } + // @api + function createClassDeclaration(modifiers, name, typeParameters, heritageClauses, members) { + var node = createBaseClassLikeDeclaration(260 /* SyntaxKind.ClassDeclaration */, modifiers, name, typeParameters, heritageClauses, members); + if (ts.modifiersToFlags(node.modifiers) & 2 /* ModifierFlags.Ambient */) { + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + } + else { + node.transformFlags |= 1024 /* TransformFlags.ContainsES2015 */; + if (node.transformFlags & 8192 /* TransformFlags.ContainsTypeScriptClassSyntax */) { + node.transformFlags |= 1 /* TransformFlags.ContainsTypeScript */; + } + } + return node; + } + // @api + function updateClassDeclaration(node, modifiers, name, typeParameters, heritageClauses, members) { + return node.modifiers !== modifiers + || node.name !== name + || node.typeParameters !== typeParameters + || node.heritageClauses !== heritageClauses + || node.members !== members + ? update(createClassDeclaration(modifiers, name, typeParameters, heritageClauses, members), node) + : node; + } + // @api + function createInterfaceDeclaration(modifiers, name, typeParameters, heritageClauses, members) { + var node = createBaseInterfaceOrClassLikeDeclaration(261 /* SyntaxKind.InterfaceDeclaration */, modifiers, name, typeParameters, heritageClauses); + node.members = createNodeArray(members); + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + // The following properties are used only to report grammar errors + node.illegalDecorators = undefined; + return node; + } + // @api + function updateInterfaceDeclaration(node, modifiers, name, typeParameters, heritageClauses, members) { + return node.modifiers !== modifiers + || node.name !== name + || node.typeParameters !== typeParameters + || node.heritageClauses !== heritageClauses + || node.members !== members + ? finishUpdateInterfaceDeclaration(createInterfaceDeclaration(modifiers, name, typeParameters, heritageClauses, members), node) + : node; + } + function finishUpdateInterfaceDeclaration(updated, original) { + if (updated !== original) { + updated.illegalDecorators = original.illegalDecorators; + } + return update(updated, original); + } + // @api + function createTypeAliasDeclaration(modifiers, name, typeParameters, type) { + var node = createBaseGenericNamedDeclaration(262 /* SyntaxKind.TypeAliasDeclaration */, modifiers, name, typeParameters); + node.type = type; + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + // The following properties are used only to report grammar errors + node.illegalDecorators = undefined; + return node; + } + // @api + function updateTypeAliasDeclaration(node, modifiers, name, typeParameters, type) { + return node.modifiers !== modifiers + || node.name !== name + || node.typeParameters !== typeParameters + || node.type !== type + ? finishUpdateTypeAliasDeclaration(createTypeAliasDeclaration(modifiers, name, typeParameters, type), node) + : node; + } + function finishUpdateTypeAliasDeclaration(updated, original) { + if (updated !== original) { + updated.illegalDecorators = original.illegalDecorators; + } + return update(updated, original); + } + // @api + function createEnumDeclaration(modifiers, name, members) { + var node = createBaseNamedDeclaration(263 /* SyntaxKind.EnumDeclaration */, modifiers, name); + node.members = createNodeArray(members); + node.transformFlags |= + propagateChildrenFlags(node.members) | + 1 /* TransformFlags.ContainsTypeScript */; + node.transformFlags &= ~67108864 /* TransformFlags.ContainsPossibleTopLevelAwait */; // Enum declarations cannot contain `await` + // The following properties are used only to report grammar errors + node.illegalDecorators = undefined; + return node; + } + // @api + function updateEnumDeclaration(node, modifiers, name, members) { + return node.modifiers !== modifiers + || node.name !== name + || node.members !== members + ? finishUpdateEnumDeclaration(createEnumDeclaration(modifiers, name, members), node) + : node; + } + function finishUpdateEnumDeclaration(updated, original) { + if (updated !== original) { + updated.illegalDecorators = original.illegalDecorators; + } + return update(updated, original); + } + // @api + function createModuleDeclaration(modifiers, name, body, flags) { + if (flags === void 0) { flags = 0 /* NodeFlags.None */; } + var node = createBaseDeclaration(264 /* SyntaxKind.ModuleDeclaration */); + node.modifiers = asNodeArray(modifiers); + node.flags |= flags & (16 /* NodeFlags.Namespace */ | 4 /* NodeFlags.NestedNamespace */ | 1024 /* NodeFlags.GlobalAugmentation */); + node.name = name; + node.body = body; + if (ts.modifiersToFlags(node.modifiers) & 2 /* ModifierFlags.Ambient */) { + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + } + else { + node.transformFlags |= + propagateChildrenFlags(node.modifiers) | + propagateChildFlags(node.name) | + propagateChildFlags(node.body) | + 1 /* TransformFlags.ContainsTypeScript */; + } + node.transformFlags &= ~67108864 /* TransformFlags.ContainsPossibleTopLevelAwait */; // Module declarations cannot contain `await`. + // The following properties are used only to report grammar errors + node.illegalDecorators = undefined; + return node; + } + // @api + function updateModuleDeclaration(node, modifiers, name, body) { + return node.modifiers !== modifiers + || node.name !== name + || node.body !== body + ? finishUpdateModuleDeclaration(createModuleDeclaration(modifiers, name, body, node.flags), node) + : node; + } + function finishUpdateModuleDeclaration(updated, original) { + if (updated !== original) { + updated.illegalDecorators = original.illegalDecorators; + } + return update(updated, original); + } + // @api + function createModuleBlock(statements) { + var node = createBaseNode(265 /* SyntaxKind.ModuleBlock */); + node.statements = createNodeArray(statements); + node.transformFlags |= propagateChildrenFlags(node.statements); + return node; + } + // @api + function updateModuleBlock(node, statements) { + return node.statements !== statements + ? update(createModuleBlock(statements), node) + : node; + } + // @api + function createCaseBlock(clauses) { + var node = createBaseNode(266 /* SyntaxKind.CaseBlock */); + node.clauses = createNodeArray(clauses); + node.transformFlags |= propagateChildrenFlags(node.clauses); + return node; + } + // @api + function updateCaseBlock(node, clauses) { + return node.clauses !== clauses + ? update(createCaseBlock(clauses), node) + : node; + } + // @api + function createNamespaceExportDeclaration(name) { + var node = createBaseNamedDeclaration(267 /* SyntaxKind.NamespaceExportDeclaration */, + /*modifiers*/ undefined, name); + node.transformFlags = 1 /* TransformFlags.ContainsTypeScript */; + // The following properties are used only to report grammar errors + node.illegalDecorators = undefined; + node.modifiers = undefined; + return node; + } + // @api + function updateNamespaceExportDeclaration(node, name) { + return node.name !== name + ? finishUpdateNamespaceExportDeclaration(createNamespaceExportDeclaration(name), node) + : node; + } + function finishUpdateNamespaceExportDeclaration(updated, original) { + if (updated !== original) { + updated.illegalDecorators = original.illegalDecorators; + updated.modifiers = original.modifiers; + } + return update(updated, original); + } + // @api + function createImportEqualsDeclaration(modifiers, isTypeOnly, name, moduleReference) { + var node = createBaseNamedDeclaration(268 /* SyntaxKind.ImportEqualsDeclaration */, modifiers, name); + node.isTypeOnly = isTypeOnly; + node.moduleReference = moduleReference; + node.transformFlags |= propagateChildFlags(node.moduleReference); + if (!ts.isExternalModuleReference(node.moduleReference)) + node.transformFlags |= 1 /* TransformFlags.ContainsTypeScript */; + node.transformFlags &= ~67108864 /* TransformFlags.ContainsPossibleTopLevelAwait */; // Import= declaration is always parsed in an Await context + // The following properties are used only to report grammar errors + node.illegalDecorators = undefined; + return node; + } + // @api + function updateImportEqualsDeclaration(node, modifiers, isTypeOnly, name, moduleReference) { + return node.modifiers !== modifiers + || node.isTypeOnly !== isTypeOnly + || node.name !== name + || node.moduleReference !== moduleReference + ? finishUpdateImportEqualsDeclaration(createImportEqualsDeclaration(modifiers, isTypeOnly, name, moduleReference), node) + : node; + } + function finishUpdateImportEqualsDeclaration(updated, original) { + if (updated !== original) { + updated.illegalDecorators = original.illegalDecorators; + } + return update(updated, original); + } + // @api + function createImportDeclaration(modifiers, importClause, moduleSpecifier, assertClause) { + var node = createBaseDeclaration(269 /* SyntaxKind.ImportDeclaration */); + node.modifiers = asNodeArray(modifiers); + node.importClause = importClause; + node.moduleSpecifier = moduleSpecifier; + node.assertClause = assertClause; + node.transformFlags |= + propagateChildFlags(node.importClause) | + propagateChildFlags(node.moduleSpecifier); + node.transformFlags &= ~67108864 /* TransformFlags.ContainsPossibleTopLevelAwait */; // always parsed in an Await context + // The following properties are used only to report grammar errors + node.illegalDecorators = undefined; + return node; + } + // @api + function updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause) { + return node.modifiers !== modifiers + || node.importClause !== importClause + || node.moduleSpecifier !== moduleSpecifier + || node.assertClause !== assertClause + ? finishUpdateImportDeclaration(createImportDeclaration(modifiers, importClause, moduleSpecifier, assertClause), node) + : node; + } + function finishUpdateImportDeclaration(updated, original) { + if (updated !== original) { + updated.illegalDecorators = original.illegalDecorators; + } + return update(updated, original); + } + // @api + function createImportClause(isTypeOnly, name, namedBindings) { + var node = createBaseNode(270 /* SyntaxKind.ImportClause */); + node.isTypeOnly = isTypeOnly; + node.name = name; + node.namedBindings = namedBindings; + node.transformFlags |= + propagateChildFlags(node.name) | + propagateChildFlags(node.namedBindings); + if (isTypeOnly) { + node.transformFlags |= 1 /* TransformFlags.ContainsTypeScript */; + } + node.transformFlags &= ~67108864 /* TransformFlags.ContainsPossibleTopLevelAwait */; // always parsed in an Await context + return node; + } + // @api + function updateImportClause(node, isTypeOnly, name, namedBindings) { + return node.isTypeOnly !== isTypeOnly + || node.name !== name + || node.namedBindings !== namedBindings + ? update(createImportClause(isTypeOnly, name, namedBindings), node) + : node; + } + // @api + function createAssertClause(elements, multiLine) { + var node = createBaseNode(296 /* SyntaxKind.AssertClause */); + node.elements = createNodeArray(elements); + node.multiLine = multiLine; + node.transformFlags |= 4 /* TransformFlags.ContainsESNext */; + return node; + } + // @api + function updateAssertClause(node, elements, multiLine) { + return node.elements !== elements + || node.multiLine !== multiLine + ? update(createAssertClause(elements, multiLine), node) + : node; + } + // @api + function createAssertEntry(name, value) { + var node = createBaseNode(297 /* SyntaxKind.AssertEntry */); + node.name = name; + node.value = value; + node.transformFlags |= 4 /* TransformFlags.ContainsESNext */; + return node; + } + // @api + function updateAssertEntry(node, name, value) { + return node.name !== name + || node.value !== value + ? update(createAssertEntry(name, value), node) + : node; + } + // @api + function createImportTypeAssertionContainer(clause, multiLine) { + var node = createBaseNode(298 /* SyntaxKind.ImportTypeAssertionContainer */); + node.assertClause = clause; + node.multiLine = multiLine; + return node; + } + // @api + function updateImportTypeAssertionContainer(node, clause, multiLine) { + return node.assertClause !== clause + || node.multiLine !== multiLine + ? update(createImportTypeAssertionContainer(clause, multiLine), node) + : node; + } + // @api + function createNamespaceImport(name) { + var node = createBaseNode(271 /* SyntaxKind.NamespaceImport */); + node.name = name; + node.transformFlags |= propagateChildFlags(node.name); + node.transformFlags &= ~67108864 /* TransformFlags.ContainsPossibleTopLevelAwait */; // always parsed in an Await context + return node; + } + // @api + function updateNamespaceImport(node, name) { + return node.name !== name + ? update(createNamespaceImport(name), node) + : node; + } + // @api + function createNamespaceExport(name) { + var node = createBaseNode(277 /* SyntaxKind.NamespaceExport */); + node.name = name; + node.transformFlags |= + propagateChildFlags(node.name) | + 4 /* TransformFlags.ContainsESNext */; + node.transformFlags &= ~67108864 /* TransformFlags.ContainsPossibleTopLevelAwait */; // always parsed in an Await context + return node; + } + // @api + function updateNamespaceExport(node, name) { + return node.name !== name + ? update(createNamespaceExport(name), node) + : node; + } + // @api + function createNamedImports(elements) { + var node = createBaseNode(272 /* SyntaxKind.NamedImports */); + node.elements = createNodeArray(elements); + node.transformFlags |= propagateChildrenFlags(node.elements); + node.transformFlags &= ~67108864 /* TransformFlags.ContainsPossibleTopLevelAwait */; // always parsed in an Await context + return node; + } + // @api + function updateNamedImports(node, elements) { + return node.elements !== elements + ? update(createNamedImports(elements), node) + : node; + } + // @api + function createImportSpecifier(isTypeOnly, propertyName, name) { + var node = createBaseNode(273 /* SyntaxKind.ImportSpecifier */); + node.isTypeOnly = isTypeOnly; + node.propertyName = propertyName; + node.name = name; + node.transformFlags |= + propagateChildFlags(node.propertyName) | + propagateChildFlags(node.name); + node.transformFlags &= ~67108864 /* TransformFlags.ContainsPossibleTopLevelAwait */; // always parsed in an Await context + return node; + } + // @api + function updateImportSpecifier(node, isTypeOnly, propertyName, name) { + return node.isTypeOnly !== isTypeOnly + || node.propertyName !== propertyName + || node.name !== name + ? update(createImportSpecifier(isTypeOnly, propertyName, name), node) + : node; + } + // @api + function createExportAssignment(modifiers, isExportEquals, expression) { + var node = createBaseDeclaration(274 /* SyntaxKind.ExportAssignment */); + node.modifiers = asNodeArray(modifiers); + node.isExportEquals = isExportEquals; + node.expression = isExportEquals + ? parenthesizerRules().parenthesizeRightSideOfBinary(63 /* SyntaxKind.EqualsToken */, /*leftSide*/ undefined, expression) + : parenthesizerRules().parenthesizeExpressionOfExportDefault(expression); + node.transformFlags |= propagateChildrenFlags(node.modifiers) | propagateChildFlags(node.expression); + node.transformFlags &= ~67108864 /* TransformFlags.ContainsPossibleTopLevelAwait */; // always parsed in an Await context + // The following properties are used only to report grammar errors + node.illegalDecorators = undefined; + return node; + } + // @api + function updateExportAssignment(node, modifiers, expression) { + return node.modifiers !== modifiers + || node.expression !== expression + ? finishUpdateExportAssignment(createExportAssignment(modifiers, node.isExportEquals, expression), node) + : node; + } + function finishUpdateExportAssignment(updated, original) { + if (updated !== original) { + updated.illegalDecorators = original.illegalDecorators; + } + return update(updated, original); + } + // @api + function createExportDeclaration(modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause) { + var node = createBaseDeclaration(275 /* SyntaxKind.ExportDeclaration */); + node.modifiers = asNodeArray(modifiers); + node.isTypeOnly = isTypeOnly; + node.exportClause = exportClause; + node.moduleSpecifier = moduleSpecifier; + node.assertClause = assertClause; + node.transformFlags |= + propagateChildrenFlags(node.modifiers) | + propagateChildFlags(node.exportClause) | + propagateChildFlags(node.moduleSpecifier); + node.transformFlags &= ~67108864 /* TransformFlags.ContainsPossibleTopLevelAwait */; // always parsed in an Await context + // The following properties are used only to report grammar errors + node.illegalDecorators = undefined; + return node; + } + // @api + function updateExportDeclaration(node, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause) { + return node.modifiers !== modifiers + || node.isTypeOnly !== isTypeOnly + || node.exportClause !== exportClause + || node.moduleSpecifier !== moduleSpecifier + || node.assertClause !== assertClause + ? finishUpdateExportDeclaration(createExportDeclaration(modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause), node) + : node; + } + function finishUpdateExportDeclaration(updated, original) { + if (updated !== original) { + updated.illegalDecorators = original.illegalDecorators; + } + return update(updated, original); + } + // @api + function createNamedExports(elements) { + var node = createBaseNode(276 /* SyntaxKind.NamedExports */); + node.elements = createNodeArray(elements); + node.transformFlags |= propagateChildrenFlags(node.elements); + node.transformFlags &= ~67108864 /* TransformFlags.ContainsPossibleTopLevelAwait */; // always parsed in an Await context + return node; + } + // @api + function updateNamedExports(node, elements) { + return node.elements !== elements + ? update(createNamedExports(elements), node) + : node; + } + // @api + function createExportSpecifier(isTypeOnly, propertyName, name) { + var node = createBaseNode(278 /* SyntaxKind.ExportSpecifier */); + node.isTypeOnly = isTypeOnly; + node.propertyName = asName(propertyName); + node.name = asName(name); + node.transformFlags |= + propagateChildFlags(node.propertyName) | + propagateChildFlags(node.name); + node.transformFlags &= ~67108864 /* TransformFlags.ContainsPossibleTopLevelAwait */; // always parsed in an Await context + return node; + } + // @api + function updateExportSpecifier(node, isTypeOnly, propertyName, name) { + return node.isTypeOnly !== isTypeOnly + || node.propertyName !== propertyName + || node.name !== name + ? update(createExportSpecifier(isTypeOnly, propertyName, name), node) + : node; + } + // @api + function createMissingDeclaration() { + var node = createBaseDeclaration(279 /* SyntaxKind.MissingDeclaration */); + return node; + } + // + // Module references + // + // @api + function createExternalModuleReference(expression) { + var node = createBaseNode(280 /* SyntaxKind.ExternalModuleReference */); + node.expression = expression; + node.transformFlags |= propagateChildFlags(node.expression); + node.transformFlags &= ~67108864 /* TransformFlags.ContainsPossibleTopLevelAwait */; // always parsed in an Await context + return node; + } + // @api + function updateExternalModuleReference(node, expression) { + return node.expression !== expression + ? update(createExternalModuleReference(expression), node) + : node; + } + // + // JSDoc + // + // @api + // createJSDocAllType + // createJSDocUnknownType + function createJSDocPrimaryTypeWorker(kind) { + return createBaseNode(kind); + } + // @api + // createJSDocNullableType + // createJSDocNonNullableType + function createJSDocPrePostfixUnaryTypeWorker(kind, type, postfix) { + if (postfix === void 0) { postfix = false; } + var node = createJSDocUnaryTypeWorker(kind, postfix ? type && parenthesizerRules().parenthesizeNonArrayTypeOfPostfixType(type) : type); + node.postfix = postfix; + return node; + } + // @api + // createJSDocOptionalType + // createJSDocVariadicType + // createJSDocNamepathType + function createJSDocUnaryTypeWorker(kind, type) { + var node = createBaseNode(kind); + node.type = type; + return node; + } + // @api + // updateJSDocNonNullableType + // updateJSDocNullableType + function updateJSDocPrePostfixUnaryTypeWorker(kind, node, type) { + return node.type !== type + ? update(createJSDocPrePostfixUnaryTypeWorker(kind, type, node.postfix), node) + : node; + } + // @api + // updateJSDocOptionalType + // updateJSDocVariadicType + // updateJSDocNamepathType + function updateJSDocUnaryTypeWorker(kind, node, type) { + return node.type !== type + ? update(createJSDocUnaryTypeWorker(kind, type), node) + : node; + } + // @api + function createJSDocFunctionType(parameters, type) { + var node = createBaseSignatureDeclaration(320 /* SyntaxKind.JSDocFunctionType */, + /*modifiers*/ undefined, + /*name*/ undefined, + /*typeParameters*/ undefined, parameters, type); + return node; + } + // @api + function updateJSDocFunctionType(node, parameters, type) { + return node.parameters !== parameters + || node.type !== type + ? update(createJSDocFunctionType(parameters, type), node) + : node; + } + // @api + function createJSDocTypeLiteral(propertyTags, isArrayType) { + if (isArrayType === void 0) { isArrayType = false; } + var node = createBaseNode(325 /* SyntaxKind.JSDocTypeLiteral */); + node.jsDocPropertyTags = asNodeArray(propertyTags); + node.isArrayType = isArrayType; + return node; + } + // @api + function updateJSDocTypeLiteral(node, propertyTags, isArrayType) { + return node.jsDocPropertyTags !== propertyTags + || node.isArrayType !== isArrayType + ? update(createJSDocTypeLiteral(propertyTags, isArrayType), node) + : node; + } + // @api + function createJSDocTypeExpression(type) { + var node = createBaseNode(312 /* SyntaxKind.JSDocTypeExpression */); + node.type = type; + return node; + } + // @api + function updateJSDocTypeExpression(node, type) { + return node.type !== type + ? update(createJSDocTypeExpression(type), node) + : node; + } + // @api + function createJSDocSignature(typeParameters, parameters, type) { + var node = createBaseNode(326 /* SyntaxKind.JSDocSignature */); + node.typeParameters = asNodeArray(typeParameters); + node.parameters = createNodeArray(parameters); + node.type = type; + return node; + } + // @api + function updateJSDocSignature(node, typeParameters, parameters, type) { + return node.typeParameters !== typeParameters + || node.parameters !== parameters + || node.type !== type + ? update(createJSDocSignature(typeParameters, parameters, type), node) + : node; + } + function getDefaultTagName(node) { + var defaultTagName = getDefaultTagNameForKind(node.kind); + return node.tagName.escapedText === ts.escapeLeadingUnderscores(defaultTagName) + ? node.tagName + : createIdentifier(defaultTagName); + } + // @api + function createBaseJSDocTag(kind, tagName, comment) { + var node = createBaseNode(kind); + node.tagName = tagName; + node.comment = comment; + return node; + } + // @api + function createJSDocTemplateTag(tagName, constraint, typeParameters, comment) { + var node = createBaseJSDocTag(347 /* SyntaxKind.JSDocTemplateTag */, tagName !== null && tagName !== void 0 ? tagName : createIdentifier("template"), comment); + node.constraint = constraint; + node.typeParameters = createNodeArray(typeParameters); + return node; + } + // @api + function updateJSDocTemplateTag(node, tagName, constraint, typeParameters, comment) { + if (tagName === void 0) { tagName = getDefaultTagName(node); } + return node.tagName !== tagName + || node.constraint !== constraint + || node.typeParameters !== typeParameters + || node.comment !== comment + ? update(createJSDocTemplateTag(tagName, constraint, typeParameters, comment), node) + : node; + } + // @api + function createJSDocTypedefTag(tagName, typeExpression, fullName, comment) { + var node = createBaseJSDocTag(348 /* SyntaxKind.JSDocTypedefTag */, tagName !== null && tagName !== void 0 ? tagName : createIdentifier("typedef"), comment); + node.typeExpression = typeExpression; + node.fullName = fullName; + node.name = ts.getJSDocTypeAliasName(fullName); + return node; + } + // @api + function updateJSDocTypedefTag(node, tagName, typeExpression, fullName, comment) { + if (tagName === void 0) { tagName = getDefaultTagName(node); } + return node.tagName !== tagName + || node.typeExpression !== typeExpression + || node.fullName !== fullName + || node.comment !== comment + ? update(createJSDocTypedefTag(tagName, typeExpression, fullName, comment), node) + : node; + } + // @api + function createJSDocParameterTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment) { + var node = createBaseJSDocTag(343 /* SyntaxKind.JSDocParameterTag */, tagName !== null && tagName !== void 0 ? tagName : createIdentifier("param"), comment); + node.typeExpression = typeExpression; + node.name = name; + node.isNameFirst = !!isNameFirst; + node.isBracketed = isBracketed; + return node; + } + // @api + function updateJSDocParameterTag(node, tagName, name, isBracketed, typeExpression, isNameFirst, comment) { + if (tagName === void 0) { tagName = getDefaultTagName(node); } + return node.tagName !== tagName + || node.name !== name + || node.isBracketed !== isBracketed + || node.typeExpression !== typeExpression + || node.isNameFirst !== isNameFirst + || node.comment !== comment + ? update(createJSDocParameterTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment), node) + : node; + } + // @api + function createJSDocPropertyTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment) { + var node = createBaseJSDocTag(350 /* SyntaxKind.JSDocPropertyTag */, tagName !== null && tagName !== void 0 ? tagName : createIdentifier("prop"), comment); + node.typeExpression = typeExpression; + node.name = name; + node.isNameFirst = !!isNameFirst; + node.isBracketed = isBracketed; + return node; + } + // @api + function updateJSDocPropertyTag(node, tagName, name, isBracketed, typeExpression, isNameFirst, comment) { + if (tagName === void 0) { tagName = getDefaultTagName(node); } + return node.tagName !== tagName + || node.name !== name + || node.isBracketed !== isBracketed + || node.typeExpression !== typeExpression + || node.isNameFirst !== isNameFirst + || node.comment !== comment + ? update(createJSDocPropertyTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment), node) + : node; + } + // @api + function createJSDocCallbackTag(tagName, typeExpression, fullName, comment) { + var node = createBaseJSDocTag(341 /* SyntaxKind.JSDocCallbackTag */, tagName !== null && tagName !== void 0 ? tagName : createIdentifier("callback"), comment); + node.typeExpression = typeExpression; + node.fullName = fullName; + node.name = ts.getJSDocTypeAliasName(fullName); + return node; + } + // @api + function updateJSDocCallbackTag(node, tagName, typeExpression, fullName, comment) { + if (tagName === void 0) { tagName = getDefaultTagName(node); } + return node.tagName !== tagName + || node.typeExpression !== typeExpression + || node.fullName !== fullName + || node.comment !== comment + ? update(createJSDocCallbackTag(tagName, typeExpression, fullName, comment), node) + : node; + } + // @api + function createJSDocAugmentsTag(tagName, className, comment) { + var node = createBaseJSDocTag(331 /* SyntaxKind.JSDocAugmentsTag */, tagName !== null && tagName !== void 0 ? tagName : createIdentifier("augments"), comment); + node.class = className; + return node; + } + // @api + function updateJSDocAugmentsTag(node, tagName, className, comment) { + if (tagName === void 0) { tagName = getDefaultTagName(node); } + return node.tagName !== tagName + || node.class !== className + || node.comment !== comment + ? update(createJSDocAugmentsTag(tagName, className, comment), node) + : node; + } + // @api + function createJSDocImplementsTag(tagName, className, comment) { + var node = createBaseJSDocTag(332 /* SyntaxKind.JSDocImplementsTag */, tagName !== null && tagName !== void 0 ? tagName : createIdentifier("implements"), comment); + node.class = className; + return node; + } + // @api + function createJSDocSeeTag(tagName, name, comment) { + var node = createBaseJSDocTag(349 /* SyntaxKind.JSDocSeeTag */, tagName !== null && tagName !== void 0 ? tagName : createIdentifier("see"), comment); + node.name = name; + return node; + } + // @api + function updateJSDocSeeTag(node, tagName, name, comment) { + return node.tagName !== tagName + || node.name !== name + || node.comment !== comment + ? update(createJSDocSeeTag(tagName, name, comment), node) + : node; + } + // @api + function createJSDocNameReference(name) { + var node = createBaseNode(313 /* SyntaxKind.JSDocNameReference */); + node.name = name; + return node; + } + // @api + function updateJSDocNameReference(node, name) { + return node.name !== name + ? update(createJSDocNameReference(name), node) + : node; + } + // @api + function createJSDocMemberName(left, right) { + var node = createBaseNode(314 /* SyntaxKind.JSDocMemberName */); + node.left = left; + node.right = right; + node.transformFlags |= + propagateChildFlags(node.left) | + propagateChildFlags(node.right); + return node; + } + // @api + function updateJSDocMemberName(node, left, right) { + return node.left !== left + || node.right !== right + ? update(createJSDocMemberName(left, right), node) + : node; + } + // @api + function createJSDocLink(name, text) { + var node = createBaseNode(327 /* SyntaxKind.JSDocLink */); + node.name = name; + node.text = text; + return node; + } + // @api + function updateJSDocLink(node, name, text) { + return node.name !== name + ? update(createJSDocLink(name, text), node) + : node; + } + // @api + function createJSDocLinkCode(name, text) { + var node = createBaseNode(328 /* SyntaxKind.JSDocLinkCode */); + node.name = name; + node.text = text; + return node; + } + // @api + function updateJSDocLinkCode(node, name, text) { + return node.name !== name + ? update(createJSDocLinkCode(name, text), node) + : node; + } + // @api + function createJSDocLinkPlain(name, text) { + var node = createBaseNode(329 /* SyntaxKind.JSDocLinkPlain */); + node.name = name; + node.text = text; + return node; + } + // @api + function updateJSDocLinkPlain(node, name, text) { + return node.name !== name + ? update(createJSDocLinkPlain(name, text), node) + : node; + } + // @api + function updateJSDocImplementsTag(node, tagName, className, comment) { + if (tagName === void 0) { tagName = getDefaultTagName(node); } + return node.tagName !== tagName + || node.class !== className + || node.comment !== comment + ? update(createJSDocImplementsTag(tagName, className, comment), node) + : node; + } + // @api + // createJSDocAuthorTag + // createJSDocClassTag + // createJSDocPublicTag + // createJSDocPrivateTag + // createJSDocProtectedTag + // createJSDocReadonlyTag + // createJSDocDeprecatedTag + function createJSDocSimpleTagWorker(kind, tagName, comment) { + var node = createBaseJSDocTag(kind, tagName !== null && tagName !== void 0 ? tagName : createIdentifier(getDefaultTagNameForKind(kind)), comment); + return node; + } + // @api + // updateJSDocAuthorTag + // updateJSDocClassTag + // updateJSDocPublicTag + // updateJSDocPrivateTag + // updateJSDocProtectedTag + // updateJSDocReadonlyTag + // updateJSDocDeprecatedTag + function updateJSDocSimpleTagWorker(kind, node, tagName, comment) { + if (tagName === void 0) { tagName = getDefaultTagName(node); } + return node.tagName !== tagName + || node.comment !== comment + ? update(createJSDocSimpleTagWorker(kind, tagName, comment), node) : + node; + } + // @api + // createJSDocTypeTag + // createJSDocReturnTag + // createJSDocThisTag + // createJSDocEnumTag + function createJSDocTypeLikeTagWorker(kind, tagName, typeExpression, comment) { + var node = createBaseJSDocTag(kind, tagName !== null && tagName !== void 0 ? tagName : createIdentifier(getDefaultTagNameForKind(kind)), comment); + node.typeExpression = typeExpression; + return node; + } + // @api + // updateJSDocTypeTag + // updateJSDocReturnTag + // updateJSDocThisTag + // updateJSDocEnumTag + function updateJSDocTypeLikeTagWorker(kind, node, tagName, typeExpression, comment) { + if (tagName === void 0) { tagName = getDefaultTagName(node); } + return node.tagName !== tagName + || node.typeExpression !== typeExpression + || node.comment !== comment + ? update(createJSDocTypeLikeTagWorker(kind, tagName, typeExpression, comment), node) + : node; + } + // @api + function createJSDocUnknownTag(tagName, comment) { + var node = createBaseJSDocTag(330 /* SyntaxKind.JSDocTag */, tagName, comment); + return node; + } + // @api + function updateJSDocUnknownTag(node, tagName, comment) { + return node.tagName !== tagName + || node.comment !== comment + ? update(createJSDocUnknownTag(tagName, comment), node) + : node; + } + // @api + function createJSDocText(text) { + var node = createBaseNode(324 /* SyntaxKind.JSDocText */); + node.text = text; + return node; + } + // @api + function updateJSDocText(node, text) { + return node.text !== text + ? update(createJSDocText(text), node) + : node; + } + // @api + function createJSDocComment(comment, tags) { + var node = createBaseNode(323 /* SyntaxKind.JSDoc */); + node.comment = comment; + node.tags = asNodeArray(tags); + return node; + } + // @api + function updateJSDocComment(node, comment, tags) { + return node.comment !== comment + || node.tags !== tags + ? update(createJSDocComment(comment, tags), node) + : node; + } + // + // JSX + // + // @api + function createJsxElement(openingElement, children, closingElement) { + var node = createBaseNode(281 /* SyntaxKind.JsxElement */); + node.openingElement = openingElement; + node.children = createNodeArray(children); + node.closingElement = closingElement; + node.transformFlags |= + propagateChildFlags(node.openingElement) | + propagateChildrenFlags(node.children) | + propagateChildFlags(node.closingElement) | + 2 /* TransformFlags.ContainsJsx */; + return node; + } + // @api + function updateJsxElement(node, openingElement, children, closingElement) { + return node.openingElement !== openingElement + || node.children !== children + || node.closingElement !== closingElement + ? update(createJsxElement(openingElement, children, closingElement), node) + : node; + } + // @api + function createJsxSelfClosingElement(tagName, typeArguments, attributes) { + var node = createBaseNode(282 /* SyntaxKind.JsxSelfClosingElement */); + node.tagName = tagName; + node.typeArguments = asNodeArray(typeArguments); + node.attributes = attributes; + node.transformFlags |= + propagateChildFlags(node.tagName) | + propagateChildrenFlags(node.typeArguments) | + propagateChildFlags(node.attributes) | + 2 /* TransformFlags.ContainsJsx */; + if (node.typeArguments) { + node.transformFlags |= 1 /* TransformFlags.ContainsTypeScript */; + } + return node; + } + // @api + function updateJsxSelfClosingElement(node, tagName, typeArguments, attributes) { + return node.tagName !== tagName + || node.typeArguments !== typeArguments + || node.attributes !== attributes + ? update(createJsxSelfClosingElement(tagName, typeArguments, attributes), node) + : node; + } + // @api + function createJsxOpeningElement(tagName, typeArguments, attributes) { + var node = createBaseNode(283 /* SyntaxKind.JsxOpeningElement */); + node.tagName = tagName; + node.typeArguments = asNodeArray(typeArguments); + node.attributes = attributes; + node.transformFlags |= + propagateChildFlags(node.tagName) | + propagateChildrenFlags(node.typeArguments) | + propagateChildFlags(node.attributes) | + 2 /* TransformFlags.ContainsJsx */; + if (typeArguments) { + node.transformFlags |= 1 /* TransformFlags.ContainsTypeScript */; + } + return node; + } + // @api + function updateJsxOpeningElement(node, tagName, typeArguments, attributes) { + return node.tagName !== tagName + || node.typeArguments !== typeArguments + || node.attributes !== attributes + ? update(createJsxOpeningElement(tagName, typeArguments, attributes), node) + : node; + } + // @api + function createJsxClosingElement(tagName) { + var node = createBaseNode(284 /* SyntaxKind.JsxClosingElement */); + node.tagName = tagName; + node.transformFlags |= + propagateChildFlags(node.tagName) | + 2 /* TransformFlags.ContainsJsx */; + return node; + } + // @api + function updateJsxClosingElement(node, tagName) { + return node.tagName !== tagName + ? update(createJsxClosingElement(tagName), node) + : node; + } + // @api + function createJsxFragment(openingFragment, children, closingFragment) { + var node = createBaseNode(285 /* SyntaxKind.JsxFragment */); + node.openingFragment = openingFragment; + node.children = createNodeArray(children); + node.closingFragment = closingFragment; + node.transformFlags |= + propagateChildFlags(node.openingFragment) | + propagateChildrenFlags(node.children) | + propagateChildFlags(node.closingFragment) | + 2 /* TransformFlags.ContainsJsx */; + return node; + } + // @api + function updateJsxFragment(node, openingFragment, children, closingFragment) { + return node.openingFragment !== openingFragment + || node.children !== children + || node.closingFragment !== closingFragment + ? update(createJsxFragment(openingFragment, children, closingFragment), node) + : node; + } + // @api + function createJsxText(text, containsOnlyTriviaWhiteSpaces) { + var node = createBaseNode(11 /* SyntaxKind.JsxText */); + node.text = text; + node.containsOnlyTriviaWhiteSpaces = !!containsOnlyTriviaWhiteSpaces; + node.transformFlags |= 2 /* TransformFlags.ContainsJsx */; + return node; + } + // @api + function updateJsxText(node, text, containsOnlyTriviaWhiteSpaces) { + return node.text !== text + || node.containsOnlyTriviaWhiteSpaces !== containsOnlyTriviaWhiteSpaces + ? update(createJsxText(text, containsOnlyTriviaWhiteSpaces), node) + : node; + } + // @api + function createJsxOpeningFragment() { + var node = createBaseNode(286 /* SyntaxKind.JsxOpeningFragment */); + node.transformFlags |= 2 /* TransformFlags.ContainsJsx */; + return node; + } + // @api + function createJsxJsxClosingFragment() { + var node = createBaseNode(287 /* SyntaxKind.JsxClosingFragment */); + node.transformFlags |= 2 /* TransformFlags.ContainsJsx */; + return node; + } + // @api + function createJsxAttribute(name, initializer) { + var node = createBaseNode(288 /* SyntaxKind.JsxAttribute */); + node.name = name; + node.initializer = initializer; + node.transformFlags |= + propagateChildFlags(node.name) | + propagateChildFlags(node.initializer) | + 2 /* TransformFlags.ContainsJsx */; + return node; + } + // @api + function updateJsxAttribute(node, name, initializer) { + return node.name !== name + || node.initializer !== initializer + ? update(createJsxAttribute(name, initializer), node) + : node; + } + // @api + function createJsxAttributes(properties) { + var node = createBaseNode(289 /* SyntaxKind.JsxAttributes */); + node.properties = createNodeArray(properties); + node.transformFlags |= + propagateChildrenFlags(node.properties) | + 2 /* TransformFlags.ContainsJsx */; + return node; + } + // @api + function updateJsxAttributes(node, properties) { + return node.properties !== properties + ? update(createJsxAttributes(properties), node) + : node; + } + // @api + function createJsxSpreadAttribute(expression) { + var node = createBaseNode(290 /* SyntaxKind.JsxSpreadAttribute */); + node.expression = expression; + node.transformFlags |= + propagateChildFlags(node.expression) | + 2 /* TransformFlags.ContainsJsx */; + return node; + } + // @api + function updateJsxSpreadAttribute(node, expression) { + return node.expression !== expression + ? update(createJsxSpreadAttribute(expression), node) + : node; + } + // @api + function createJsxExpression(dotDotDotToken, expression) { + var node = createBaseNode(291 /* SyntaxKind.JsxExpression */); + node.dotDotDotToken = dotDotDotToken; + node.expression = expression; + node.transformFlags |= + propagateChildFlags(node.dotDotDotToken) | + propagateChildFlags(node.expression) | + 2 /* TransformFlags.ContainsJsx */; + return node; + } + // @api + function updateJsxExpression(node, expression) { + return node.expression !== expression + ? update(createJsxExpression(node.dotDotDotToken, expression), node) + : node; + } + // + // Clauses + // + // @api + function createCaseClause(expression, statements) { + var node = createBaseNode(292 /* SyntaxKind.CaseClause */); + node.expression = parenthesizerRules().parenthesizeExpressionForDisallowedComma(expression); + node.statements = createNodeArray(statements); + node.transformFlags |= + propagateChildFlags(node.expression) | + propagateChildrenFlags(node.statements); + return node; + } + // @api + function updateCaseClause(node, expression, statements) { + return node.expression !== expression + || node.statements !== statements + ? update(createCaseClause(expression, statements), node) + : node; + } + // @api + function createDefaultClause(statements) { + var node = createBaseNode(293 /* SyntaxKind.DefaultClause */); + node.statements = createNodeArray(statements); + node.transformFlags = propagateChildrenFlags(node.statements); + return node; + } + // @api + function updateDefaultClause(node, statements) { + return node.statements !== statements + ? update(createDefaultClause(statements), node) + : node; + } + // @api + function createHeritageClause(token, types) { + var node = createBaseNode(294 /* SyntaxKind.HeritageClause */); + node.token = token; + node.types = createNodeArray(types); + node.transformFlags |= propagateChildrenFlags(node.types); + switch (token) { + case 94 /* SyntaxKind.ExtendsKeyword */: + node.transformFlags |= 1024 /* TransformFlags.ContainsES2015 */; + break; + case 117 /* SyntaxKind.ImplementsKeyword */: + node.transformFlags |= 1 /* TransformFlags.ContainsTypeScript */; + break; + default: + return ts.Debug.assertNever(token); + } + return node; + } + // @api + function updateHeritageClause(node, types) { + return node.types !== types + ? update(createHeritageClause(node.token, types), node) + : node; + } + // @api + function createCatchClause(variableDeclaration, block) { + var node = createBaseNode(295 /* SyntaxKind.CatchClause */); + if (typeof variableDeclaration === "string" || variableDeclaration && !ts.isVariableDeclaration(variableDeclaration)) { + variableDeclaration = createVariableDeclaration(variableDeclaration, + /*exclamationToken*/ undefined, + /*type*/ undefined, + /*initializer*/ undefined); + } + node.variableDeclaration = variableDeclaration; + node.block = block; + node.transformFlags |= + propagateChildFlags(node.variableDeclaration) | + propagateChildFlags(node.block); + if (!variableDeclaration) + node.transformFlags |= 64 /* TransformFlags.ContainsES2019 */; + return node; + } + // @api + function updateCatchClause(node, variableDeclaration, block) { + return node.variableDeclaration !== variableDeclaration + || node.block !== block + ? update(createCatchClause(variableDeclaration, block), node) + : node; + } + // + // Property assignments + // + // @api + function createPropertyAssignment(name, initializer) { + var node = createBaseNamedDeclaration(299 /* SyntaxKind.PropertyAssignment */, + /*modifiers*/ undefined, name); + node.initializer = parenthesizerRules().parenthesizeExpressionForDisallowedComma(initializer); + node.transformFlags |= + propagateChildFlags(node.name) | + propagateChildFlags(node.initializer); + // The following properties are used only to report grammar errors + node.illegalDecorators = undefined; + node.modifiers = undefined; + node.questionToken = undefined; + node.exclamationToken = undefined; + return node; + } + // @api + function updatePropertyAssignment(node, name, initializer) { + return node.name !== name + || node.initializer !== initializer + ? finishUpdatePropertyAssignment(createPropertyAssignment(name, initializer), node) + : node; + } + function finishUpdatePropertyAssignment(updated, original) { + // copy children used only for error reporting + if (updated !== original) { + updated.illegalDecorators = original.illegalDecorators; + updated.modifiers = original.modifiers; + updated.questionToken = original.questionToken; + updated.exclamationToken = original.exclamationToken; + } + return update(updated, original); + } + // @api + function createShorthandPropertyAssignment(name, objectAssignmentInitializer) { + var node = createBaseNamedDeclaration(300 /* SyntaxKind.ShorthandPropertyAssignment */, + /*modifiers*/ undefined, name); + node.objectAssignmentInitializer = objectAssignmentInitializer && parenthesizerRules().parenthesizeExpressionForDisallowedComma(objectAssignmentInitializer); + node.transformFlags |= + propagateChildFlags(node.objectAssignmentInitializer) | + 1024 /* TransformFlags.ContainsES2015 */; + // The following properties are used only to report grammar errors + node.equalsToken = undefined; + node.illegalDecorators = undefined; + node.modifiers = undefined; + node.questionToken = undefined; + node.exclamationToken = undefined; + return node; + } + // @api + function updateShorthandPropertyAssignment(node, name, objectAssignmentInitializer) { + return node.name !== name + || node.objectAssignmentInitializer !== objectAssignmentInitializer + ? finishUpdateShorthandPropertyAssignment(createShorthandPropertyAssignment(name, objectAssignmentInitializer), node) + : node; + } + function finishUpdateShorthandPropertyAssignment(updated, original) { + if (updated !== original) { + // copy children used only for error reporting + updated.equalsToken = original.equalsToken; + updated.illegalDecorators = original.illegalDecorators; + updated.modifiers = original.modifiers; + updated.questionToken = original.questionToken; + updated.exclamationToken = original.exclamationToken; + } + return update(updated, original); + } + // @api + function createSpreadAssignment(expression) { + var node = createBaseNode(301 /* SyntaxKind.SpreadAssignment */); + node.expression = parenthesizerRules().parenthesizeExpressionForDisallowedComma(expression); + node.transformFlags |= + propagateChildFlags(node.expression) | + 128 /* TransformFlags.ContainsES2018 */ | + 65536 /* TransformFlags.ContainsObjectRestOrSpread */; + return node; + } + // @api + function updateSpreadAssignment(node, expression) { + return node.expression !== expression + ? update(createSpreadAssignment(expression), node) + : node; + } + // + // Enum + // + // @api + function createEnumMember(name, initializer) { + var node = createBaseNode(302 /* SyntaxKind.EnumMember */); + node.name = asName(name); + node.initializer = initializer && parenthesizerRules().parenthesizeExpressionForDisallowedComma(initializer); + node.transformFlags |= + propagateChildFlags(node.name) | + propagateChildFlags(node.initializer) | + 1 /* TransformFlags.ContainsTypeScript */; + return node; + } + // @api + function updateEnumMember(node, name, initializer) { + return node.name !== name + || node.initializer !== initializer + ? update(createEnumMember(name, initializer), node) + : node; + } + // + // Top-level nodes + // + // @api + function createSourceFile(statements, endOfFileToken, flags) { + var node = baseFactory.createBaseSourceFileNode(308 /* SyntaxKind.SourceFile */); + node.statements = createNodeArray(statements); + node.endOfFileToken = endOfFileToken; + node.flags |= flags; + node.fileName = ""; + node.text = ""; + node.languageVersion = 0; + node.languageVariant = 0; + node.scriptKind = 0; + node.isDeclarationFile = false; + node.hasNoDefaultLib = false; + node.transformFlags |= + propagateChildrenFlags(node.statements) | + propagateChildFlags(node.endOfFileToken); + return node; + } + function cloneSourceFileWithChanges(source, statements, isDeclarationFile, referencedFiles, typeReferences, hasNoDefaultLib, libReferences) { + var node = (source.redirectInfo ? Object.create(source.redirectInfo.redirectTarget) : baseFactory.createBaseSourceFileNode(308 /* SyntaxKind.SourceFile */)); + for (var p in source) { + if (p === "emitNode" || ts.hasProperty(node, p) || !ts.hasProperty(source, p)) + continue; + node[p] = source[p]; + } + node.flags |= source.flags; + node.statements = createNodeArray(statements); + node.endOfFileToken = source.endOfFileToken; + node.isDeclarationFile = isDeclarationFile; + node.referencedFiles = referencedFiles; + node.typeReferenceDirectives = typeReferences; + node.hasNoDefaultLib = hasNoDefaultLib; + node.libReferenceDirectives = libReferences; + node.transformFlags = + propagateChildrenFlags(node.statements) | + propagateChildFlags(node.endOfFileToken); + node.impliedNodeFormat = source.impliedNodeFormat; + return node; + } + // @api + function updateSourceFile(node, statements, isDeclarationFile, referencedFiles, typeReferenceDirectives, hasNoDefaultLib, libReferenceDirectives) { + if (isDeclarationFile === void 0) { isDeclarationFile = node.isDeclarationFile; } + if (referencedFiles === void 0) { referencedFiles = node.referencedFiles; } + if (typeReferenceDirectives === void 0) { typeReferenceDirectives = node.typeReferenceDirectives; } + if (hasNoDefaultLib === void 0) { hasNoDefaultLib = node.hasNoDefaultLib; } + if (libReferenceDirectives === void 0) { libReferenceDirectives = node.libReferenceDirectives; } + return node.statements !== statements + || node.isDeclarationFile !== isDeclarationFile + || node.referencedFiles !== referencedFiles + || node.typeReferenceDirectives !== typeReferenceDirectives + || node.hasNoDefaultLib !== hasNoDefaultLib + || node.libReferenceDirectives !== libReferenceDirectives + ? update(cloneSourceFileWithChanges(node, statements, isDeclarationFile, referencedFiles, typeReferenceDirectives, hasNoDefaultLib, libReferenceDirectives), node) + : node; + } + // @api + function createBundle(sourceFiles, prepends) { + if (prepends === void 0) { prepends = ts.emptyArray; } + var node = createBaseNode(309 /* SyntaxKind.Bundle */); + node.prepends = prepends; + node.sourceFiles = sourceFiles; + return node; + } + // @api + function updateBundle(node, sourceFiles, prepends) { + if (prepends === void 0) { prepends = ts.emptyArray; } + return node.sourceFiles !== sourceFiles + || node.prepends !== prepends + ? update(createBundle(sourceFiles, prepends), node) + : node; + } + // @api + function createUnparsedSource(prologues, syntheticReferences, texts) { + var node = createBaseNode(310 /* SyntaxKind.UnparsedSource */); + node.prologues = prologues; + node.syntheticReferences = syntheticReferences; + node.texts = texts; + node.fileName = ""; + node.text = ""; + node.referencedFiles = ts.emptyArray; + node.libReferenceDirectives = ts.emptyArray; + node.getLineAndCharacterOfPosition = function (pos) { return ts.getLineAndCharacterOfPosition(node, pos); }; + return node; + } + function createBaseUnparsedNode(kind, data) { + var node = createBaseNode(kind); + node.data = data; + return node; + } + // @api + function createUnparsedPrologue(data) { + return createBaseUnparsedNode(303 /* SyntaxKind.UnparsedPrologue */, data); + } + // @api + function createUnparsedPrepend(data, texts) { + var node = createBaseUnparsedNode(304 /* SyntaxKind.UnparsedPrepend */, data); + node.texts = texts; + return node; + } + // @api + function createUnparsedTextLike(data, internal) { + return createBaseUnparsedNode(internal ? 306 /* SyntaxKind.UnparsedInternalText */ : 305 /* SyntaxKind.UnparsedText */, data); + } + // @api + function createUnparsedSyntheticReference(section) { + var node = createBaseNode(307 /* SyntaxKind.UnparsedSyntheticReference */); + node.data = section.data; + node.section = section; + return node; + } + // @api + function createInputFiles() { + var node = createBaseNode(311 /* SyntaxKind.InputFiles */); + node.javascriptText = ""; + node.declarationText = ""; + return node; + } + // + // Synthetic Nodes (used by checker) + // + // @api + function createSyntheticExpression(type, isSpread, tupleNameSource) { + if (isSpread === void 0) { isSpread = false; } + var node = createBaseNode(234 /* SyntaxKind.SyntheticExpression */); + node.type = type; + node.isSpread = isSpread; + node.tupleNameSource = tupleNameSource; + return node; + } + // @api + function createSyntaxList(children) { + var node = createBaseNode(351 /* SyntaxKind.SyntaxList */); + node._children = children; + return node; + } + // + // Transformation nodes + // + /** + * Creates a synthetic statement to act as a placeholder for a not-emitted statement in + * order to preserve comments. + * + * @param original The original statement. + */ + // @api + function createNotEmittedStatement(original) { + var node = createBaseNode(352 /* SyntaxKind.NotEmittedStatement */); + node.original = original; + ts.setTextRange(node, original); + return node; + } + /** + * Creates a synthetic expression to act as a placeholder for a not-emitted expression in + * order to preserve comments or sourcemap positions. + * + * @param expression The inner expression to emit. + * @param original The original outer expression. + */ + // @api + function createPartiallyEmittedExpression(expression, original) { + var node = createBaseNode(353 /* SyntaxKind.PartiallyEmittedExpression */); + node.expression = expression; + node.original = original; + node.transformFlags |= + propagateChildFlags(node.expression) | + 1 /* TransformFlags.ContainsTypeScript */; + ts.setTextRange(node, original); + return node; + } + // @api + function updatePartiallyEmittedExpression(node, expression) { + return node.expression !== expression + ? update(createPartiallyEmittedExpression(expression, node.original), node) + : node; + } + function flattenCommaElements(node) { + if (ts.nodeIsSynthesized(node) && !ts.isParseTreeNode(node) && !node.original && !node.emitNode && !node.id) { + if (ts.isCommaListExpression(node)) { + return node.elements; + } + if (ts.isBinaryExpression(node) && ts.isCommaToken(node.operatorToken)) { + return [node.left, node.right]; + } + } + return node; + } + // @api + function createCommaListExpression(elements) { + var node = createBaseNode(354 /* SyntaxKind.CommaListExpression */); + node.elements = createNodeArray(ts.sameFlatMap(elements, flattenCommaElements)); + node.transformFlags |= propagateChildrenFlags(node.elements); + return node; + } + // @api + function updateCommaListExpression(node, elements) { + return node.elements !== elements + ? update(createCommaListExpression(elements), node) + : node; + } + /** + * Creates a synthetic element to act as a placeholder for the end of an emitted declaration in + * order to properly emit exports. + */ + // @api + function createEndOfDeclarationMarker(original) { + var node = createBaseNode(356 /* SyntaxKind.EndOfDeclarationMarker */); + node.emitNode = {}; + node.original = original; + return node; + } + /** + * Creates a synthetic element to act as a placeholder for the beginning of a merged declaration in + * order to properly emit exports. + */ + // @api + function createMergeDeclarationMarker(original) { + var node = createBaseNode(355 /* SyntaxKind.MergeDeclarationMarker */); + node.emitNode = {}; + node.original = original; + return node; + } + // @api + function createSyntheticReferenceExpression(expression, thisArg) { + var node = createBaseNode(357 /* SyntaxKind.SyntheticReferenceExpression */); + node.expression = expression; + node.thisArg = thisArg; + node.transformFlags |= + propagateChildFlags(node.expression) | + propagateChildFlags(node.thisArg); + return node; + } + // @api + function updateSyntheticReferenceExpression(node, expression, thisArg) { + return node.expression !== expression + || node.thisArg !== thisArg + ? update(createSyntheticReferenceExpression(expression, thisArg), node) + : node; + } + function cloneNode(node) { + // We don't use "clone" from core.ts here, as we need to preserve the prototype chain of + // the original node. We also need to exclude specific properties and only include own- + // properties (to skip members already defined on the shared prototype). + if (node === undefined) { + return node; + } + var clone = ts.isSourceFile(node) ? baseFactory.createBaseSourceFileNode(308 /* SyntaxKind.SourceFile */) : + ts.isIdentifier(node) ? baseFactory.createBaseIdentifierNode(79 /* SyntaxKind.Identifier */) : + ts.isPrivateIdentifier(node) ? baseFactory.createBasePrivateIdentifierNode(80 /* SyntaxKind.PrivateIdentifier */) : + !ts.isNodeKind(node.kind) ? baseFactory.createBaseTokenNode(node.kind) : + baseFactory.createBaseNode(node.kind); + clone.flags |= (node.flags & ~8 /* NodeFlags.Synthesized */); + clone.transformFlags = node.transformFlags; + setOriginalNode(clone, node); + for (var key in node) { + if (ts.hasProperty(clone, key) || !ts.hasProperty(node, key)) { + continue; + } + clone[key] = node[key]; + } + return clone; + } + function createImmediatelyInvokedFunctionExpression(statements, param, paramValue) { + return createCallExpression(createFunctionExpression( + /*modifiers*/ undefined, + /*asteriskToken*/ undefined, + /*name*/ undefined, + /*typeParameters*/ undefined, + /*parameters*/ param ? [param] : [], + /*type*/ undefined, createBlock(statements, /*multiLine*/ true)), + /*typeArguments*/ undefined, + /*argumentsArray*/ paramValue ? [paramValue] : []); + } + function createImmediatelyInvokedArrowFunction(statements, param, paramValue) { + return createCallExpression(createArrowFunction( + /*modifiers*/ undefined, + /*typeParameters*/ undefined, + /*parameters*/ param ? [param] : [], + /*type*/ undefined, + /*equalsGreaterThanToken*/ undefined, createBlock(statements, /*multiLine*/ true)), + /*typeArguments*/ undefined, + /*argumentsArray*/ paramValue ? [paramValue] : []); + } + function createVoidZero() { + return createVoidExpression(createNumericLiteral("0")); + } + function createExportDefault(expression) { + return createExportAssignment( + /*modifiers*/ undefined, + /*isExportEquals*/ false, expression); + } + function createExternalModuleExport(exportName) { + return createExportDeclaration( + /*modifiers*/ undefined, + /*isTypeOnly*/ false, createNamedExports([ + createExportSpecifier(/*isTypeOnly*/ false, /*propertyName*/ undefined, exportName) + ])); + } + // + // Utilities + // + function createTypeCheck(value, tag) { + return tag === "undefined" + ? factory.createStrictEquality(value, createVoidZero()) + : factory.createStrictEquality(createTypeOfExpression(value), createStringLiteral(tag)); + } + function createMethodCall(object, methodName, argumentsList) { + // Preserve the optionality of `object`. + if (ts.isCallChain(object)) { + return createCallChain(createPropertyAccessChain(object, /*questionDotToken*/ undefined, methodName), + /*questionDotToken*/ undefined, + /*typeArguments*/ undefined, argumentsList); + } + return createCallExpression(createPropertyAccessExpression(object, methodName), + /*typeArguments*/ undefined, argumentsList); + } + function createFunctionBindCall(target, thisArg, argumentsList) { + return createMethodCall(target, "bind", __spreadArray([thisArg], argumentsList, true)); + } + function createFunctionCallCall(target, thisArg, argumentsList) { + return createMethodCall(target, "call", __spreadArray([thisArg], argumentsList, true)); + } + function createFunctionApplyCall(target, thisArg, argumentsExpression) { + return createMethodCall(target, "apply", [thisArg, argumentsExpression]); + } + function createGlobalMethodCall(globalObjectName, methodName, argumentsList) { + return createMethodCall(createIdentifier(globalObjectName), methodName, argumentsList); + } + function createArraySliceCall(array, start) { + return createMethodCall(array, "slice", start === undefined ? [] : [asExpression(start)]); + } + function createArrayConcatCall(array, argumentsList) { + return createMethodCall(array, "concat", argumentsList); + } + function createObjectDefinePropertyCall(target, propertyName, attributes) { + return createGlobalMethodCall("Object", "defineProperty", [target, asExpression(propertyName), attributes]); + } + function createReflectGetCall(target, propertyKey, receiver) { + return createGlobalMethodCall("Reflect", "get", receiver ? [target, propertyKey, receiver] : [target, propertyKey]); + } + function createReflectSetCall(target, propertyKey, value, receiver) { + return createGlobalMethodCall("Reflect", "set", receiver ? [target, propertyKey, value, receiver] : [target, propertyKey, value]); + } + function tryAddPropertyAssignment(properties, propertyName, expression) { + if (expression) { + properties.push(createPropertyAssignment(propertyName, expression)); + return true; + } + return false; + } + function createPropertyDescriptor(attributes, singleLine) { + var properties = []; + tryAddPropertyAssignment(properties, "enumerable", asExpression(attributes.enumerable)); + tryAddPropertyAssignment(properties, "configurable", asExpression(attributes.configurable)); + var isData = tryAddPropertyAssignment(properties, "writable", asExpression(attributes.writable)); + isData = tryAddPropertyAssignment(properties, "value", attributes.value) || isData; + var isAccessor = tryAddPropertyAssignment(properties, "get", attributes.get); + isAccessor = tryAddPropertyAssignment(properties, "set", attributes.set) || isAccessor; + ts.Debug.assert(!(isData && isAccessor), "A PropertyDescriptor may not be both an accessor descriptor and a data descriptor."); + return createObjectLiteralExpression(properties, !singleLine); + } + function updateOuterExpression(outerExpression, expression) { + switch (outerExpression.kind) { + case 214 /* SyntaxKind.ParenthesizedExpression */: return updateParenthesizedExpression(outerExpression, expression); + case 213 /* SyntaxKind.TypeAssertionExpression */: return updateTypeAssertion(outerExpression, outerExpression.type, expression); + case 231 /* SyntaxKind.AsExpression */: return updateAsExpression(outerExpression, expression, outerExpression.type); + case 235 /* SyntaxKind.SatisfiesExpression */: return updateSatisfiesExpression(outerExpression, expression, outerExpression.type); + case 232 /* SyntaxKind.NonNullExpression */: return updateNonNullExpression(outerExpression, expression); + case 353 /* SyntaxKind.PartiallyEmittedExpression */: return updatePartiallyEmittedExpression(outerExpression, expression); + } + } + /** + * Determines whether a node is a parenthesized expression that can be ignored when recreating outer expressions. + * + * A parenthesized expression can be ignored when all of the following are true: + * + * - It's `pos` and `end` are not -1 + * - It does not have a custom source map range + * - It does not have a custom comment range + * - It does not have synthetic leading or trailing comments + * + * If an outermost parenthesized expression is ignored, but the containing expression requires a parentheses around + * the expression to maintain precedence, a new parenthesized expression should be created automatically when + * the containing expression is created/updated. + */ + function isIgnorableParen(node) { + return ts.isParenthesizedExpression(node) + && ts.nodeIsSynthesized(node) + && ts.nodeIsSynthesized(ts.getSourceMapRange(node)) + && ts.nodeIsSynthesized(ts.getCommentRange(node)) + && !ts.some(ts.getSyntheticLeadingComments(node)) + && !ts.some(ts.getSyntheticTrailingComments(node)); + } + function restoreOuterExpressions(outerExpression, innerExpression, kinds) { + if (kinds === void 0) { kinds = 15 /* OuterExpressionKinds.All */; } + if (outerExpression && ts.isOuterExpression(outerExpression, kinds) && !isIgnorableParen(outerExpression)) { + return updateOuterExpression(outerExpression, restoreOuterExpressions(outerExpression.expression, innerExpression)); + } + return innerExpression; + } + function restoreEnclosingLabel(node, outermostLabeledStatement, afterRestoreLabelCallback) { + if (!outermostLabeledStatement) { + return node; + } + var updated = updateLabeledStatement(outermostLabeledStatement, outermostLabeledStatement.label, ts.isLabeledStatement(outermostLabeledStatement.statement) + ? restoreEnclosingLabel(node, outermostLabeledStatement.statement) + : node); + if (afterRestoreLabelCallback) { + afterRestoreLabelCallback(outermostLabeledStatement); + } + return updated; + } + function shouldBeCapturedInTempVariable(node, cacheIdentifiers) { + var target = ts.skipParentheses(node); + switch (target.kind) { + case 79 /* SyntaxKind.Identifier */: + return cacheIdentifiers; + case 108 /* SyntaxKind.ThisKeyword */: + case 8 /* SyntaxKind.NumericLiteral */: + case 9 /* SyntaxKind.BigIntLiteral */: + case 10 /* SyntaxKind.StringLiteral */: + return false; + case 206 /* SyntaxKind.ArrayLiteralExpression */: + var elements = target.elements; + if (elements.length === 0) { + return false; + } + return true; + case 207 /* SyntaxKind.ObjectLiteralExpression */: + return target.properties.length > 0; + default: + return true; + } + } + function createCallBinding(expression, recordTempVariable, languageVersion, cacheIdentifiers) { + if (cacheIdentifiers === void 0) { cacheIdentifiers = false; } + var callee = ts.skipOuterExpressions(expression, 15 /* OuterExpressionKinds.All */); + var thisArg; + var target; + if (ts.isSuperProperty(callee)) { + thisArg = createThis(); + target = callee; + } + else if (ts.isSuperKeyword(callee)) { + thisArg = createThis(); + target = languageVersion !== undefined && languageVersion < 2 /* ScriptTarget.ES2015 */ + ? ts.setTextRange(createIdentifier("_super"), callee) + : callee; + } + else if (ts.getEmitFlags(callee) & 4096 /* EmitFlags.HelperName */) { + thisArg = createVoidZero(); + target = parenthesizerRules().parenthesizeLeftSideOfAccess(callee, /*optionalChain*/ false); + } + else if (ts.isPropertyAccessExpression(callee)) { + if (shouldBeCapturedInTempVariable(callee.expression, cacheIdentifiers)) { + // for `a.b()` target is `(_a = a).b` and thisArg is `_a` + thisArg = createTempVariable(recordTempVariable); + target = createPropertyAccessExpression(ts.setTextRange(factory.createAssignment(thisArg, callee.expression), callee.expression), callee.name); + ts.setTextRange(target, callee); + } + else { + thisArg = callee.expression; + target = callee; + } + } + else if (ts.isElementAccessExpression(callee)) { + if (shouldBeCapturedInTempVariable(callee.expression, cacheIdentifiers)) { + // for `a[b]()` target is `(_a = a)[b]` and thisArg is `_a` + thisArg = createTempVariable(recordTempVariable); + target = createElementAccessExpression(ts.setTextRange(factory.createAssignment(thisArg, callee.expression), callee.expression), callee.argumentExpression); + ts.setTextRange(target, callee); + } + else { + thisArg = callee.expression; + target = callee; + } + } + else { + // for `a()` target is `a` and thisArg is `void 0` + thisArg = createVoidZero(); + target = parenthesizerRules().parenthesizeLeftSideOfAccess(expression, /*optionalChain*/ false); + } + return { target: target, thisArg: thisArg }; + } + function createAssignmentTargetWrapper(paramName, expression) { + return createPropertyAccessExpression( + // Explicit parens required because of v8 regression (https://bugs.chromium.org/p/v8/issues/detail?id=9560) + createParenthesizedExpression(createObjectLiteralExpression([ + createSetAccessorDeclaration( + /*modifiers*/ undefined, "value", [createParameterDeclaration( + /*modifiers*/ undefined, + /*dotDotDotToken*/ undefined, paramName, + /*questionToken*/ undefined, + /*type*/ undefined, + /*initializer*/ undefined)], createBlock([ + createExpressionStatement(expression) + ])) + ])), "value"); + } + function inlineExpressions(expressions) { + // Avoid deeply nested comma expressions as traversing them during emit can result in "Maximum call + // stack size exceeded" errors. + return expressions.length > 10 + ? createCommaListExpression(expressions) + : ts.reduceLeft(expressions, factory.createComma); + } + function getName(node, allowComments, allowSourceMaps, emitFlags) { + if (emitFlags === void 0) { emitFlags = 0; } + var nodeName = ts.getNameOfDeclaration(node); + if (nodeName && ts.isIdentifier(nodeName) && !ts.isGeneratedIdentifier(nodeName)) { + // TODO(rbuckton): Does this need to be parented? + var name = ts.setParent(ts.setTextRange(cloneNode(nodeName), nodeName), nodeName.parent); + emitFlags |= ts.getEmitFlags(nodeName); + if (!allowSourceMaps) + emitFlags |= 48 /* EmitFlags.NoSourceMap */; + if (!allowComments) + emitFlags |= 1536 /* EmitFlags.NoComments */; + if (emitFlags) + ts.setEmitFlags(name, emitFlags); + return name; + } + return getGeneratedNameForNode(node); + } + /** + * Gets the internal name of a declaration. This is primarily used for declarations that can be + * referred to by name in the body of an ES5 class function body. An internal name will *never* + * be prefixed with an module or namespace export modifier like "exports." when emitted as an + * expression. An internal name will also *never* be renamed due to a collision with a block + * scoped variable. + * + * @param node The declaration. + * @param allowComments A value indicating whether comments may be emitted for the name. + * @param allowSourceMaps A value indicating whether source maps may be emitted for the name. + */ + function getInternalName(node, allowComments, allowSourceMaps) { + return getName(node, allowComments, allowSourceMaps, 16384 /* EmitFlags.LocalName */ | 32768 /* EmitFlags.InternalName */); + } + /** + * Gets the local name of a declaration. This is primarily used for declarations that can be + * referred to by name in the declaration's immediate scope (classes, enums, namespaces). A + * local name will *never* be prefixed with an module or namespace export modifier like + * "exports." when emitted as an expression. + * + * @param node The declaration. + * @param allowComments A value indicating whether comments may be emitted for the name. + * @param allowSourceMaps A value indicating whether source maps may be emitted for the name. + */ + function getLocalName(node, allowComments, allowSourceMaps) { + return getName(node, allowComments, allowSourceMaps, 16384 /* EmitFlags.LocalName */); + } + /** + * Gets the export name of a declaration. This is primarily used for declarations that can be + * referred to by name in the declaration's immediate scope (classes, enums, namespaces). An + * export name will *always* be prefixed with an module or namespace export modifier like + * `"exports."` when emitted as an expression if the name points to an exported symbol. + * + * @param node The declaration. + * @param allowComments A value indicating whether comments may be emitted for the name. + * @param allowSourceMaps A value indicating whether source maps may be emitted for the name. + */ + function getExportName(node, allowComments, allowSourceMaps) { + return getName(node, allowComments, allowSourceMaps, 8192 /* EmitFlags.ExportName */); + } + /** + * Gets the name of a declaration for use in declarations. + * + * @param node The declaration. + * @param allowComments A value indicating whether comments may be emitted for the name. + * @param allowSourceMaps A value indicating whether source maps may be emitted for the name. + */ + function getDeclarationName(node, allowComments, allowSourceMaps) { + return getName(node, allowComments, allowSourceMaps); + } + /** + * Gets a namespace-qualified name for use in expressions. + * + * @param ns The namespace identifier. + * @param name The name. + * @param allowComments A value indicating whether comments may be emitted for the name. + * @param allowSourceMaps A value indicating whether source maps may be emitted for the name. + */ + function getNamespaceMemberName(ns, name, allowComments, allowSourceMaps) { + var qualifiedName = createPropertyAccessExpression(ns, ts.nodeIsSynthesized(name) ? name : cloneNode(name)); + ts.setTextRange(qualifiedName, name); + var emitFlags = 0; + if (!allowSourceMaps) + emitFlags |= 48 /* EmitFlags.NoSourceMap */; + if (!allowComments) + emitFlags |= 1536 /* EmitFlags.NoComments */; + if (emitFlags) + ts.setEmitFlags(qualifiedName, emitFlags); + return qualifiedName; + } + /** + * Gets the exported name of a declaration for use in expressions. + * + * An exported name will *always* be prefixed with an module or namespace export modifier like + * "exports." if the name points to an exported symbol. + * + * @param ns The namespace identifier. + * @param node The declaration. + * @param allowComments A value indicating whether comments may be emitted for the name. + * @param allowSourceMaps A value indicating whether source maps may be emitted for the name. + */ + function getExternalModuleOrNamespaceExportName(ns, node, allowComments, allowSourceMaps) { + if (ns && ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */)) { + return getNamespaceMemberName(ns, getName(node), allowComments, allowSourceMaps); + } + return getExportName(node, allowComments, allowSourceMaps); + } + /** + * Copies any necessary standard and custom prologue-directives into target array. + * @param source origin statements array + * @param target result statements array + * @param ensureUseStrict boolean determining whether the function need to add prologue-directives + * @param visitor Optional callback used to visit any custom prologue directives. + */ + function copyPrologue(source, target, ensureUseStrict, visitor) { + var offset = copyStandardPrologue(source, target, 0, ensureUseStrict); + return copyCustomPrologue(source, target, offset, visitor); + } + function isUseStrictPrologue(node) { + return ts.isStringLiteral(node.expression) && node.expression.text === "use strict"; + } + function createUseStrictPrologue() { + return ts.startOnNewLine(createExpressionStatement(createStringLiteral("use strict"))); + } + /** + * Copies only the standard (string-expression) prologue-directives into the target statement-array. + * @param source origin statements array + * @param target result statements array + * @param statementOffset The offset at which to begin the copy. + * @param ensureUseStrict boolean determining whether the function need to add prologue-directives + * @returns Count of how many directive statements were copied. + */ + function copyStandardPrologue(source, target, statementOffset, ensureUseStrict) { + if (statementOffset === void 0) { statementOffset = 0; } + ts.Debug.assert(target.length === 0, "Prologue directives should be at the first statement in the target statements array"); + var foundUseStrict = false; + var numStatements = source.length; + while (statementOffset < numStatements) { + var statement = source[statementOffset]; + if (ts.isPrologueDirective(statement)) { + if (isUseStrictPrologue(statement)) { + foundUseStrict = true; + } + target.push(statement); + } + else { + break; + } + statementOffset++; + } + if (ensureUseStrict && !foundUseStrict) { + target.push(createUseStrictPrologue()); + } + return statementOffset; + } + function copyCustomPrologue(source, target, statementOffset, visitor, filter) { + if (filter === void 0) { filter = ts.returnTrue; } + var numStatements = source.length; + while (statementOffset !== undefined && statementOffset < numStatements) { + var statement = source[statementOffset]; + if (ts.getEmitFlags(statement) & 1048576 /* EmitFlags.CustomPrologue */ && filter(statement)) { + ts.append(target, visitor ? ts.visitNode(statement, visitor, ts.isStatement) : statement); + } + else { + break; + } + statementOffset++; + } + return statementOffset; + } + /** + * Ensures "use strict" directive is added + * + * @param statements An array of statements + */ + function ensureUseStrict(statements) { + var foundUseStrict = ts.findUseStrictPrologue(statements); + if (!foundUseStrict) { + return ts.setTextRange(createNodeArray(__spreadArray([createUseStrictPrologue()], statements, true)), statements); + } + return statements; + } + /** + * Lifts a NodeArray containing only Statement nodes to a block. + * + * @param nodes The NodeArray. + */ + function liftToBlock(nodes) { + ts.Debug.assert(ts.every(nodes, ts.isStatementOrBlock), "Cannot lift nodes to a Block."); + return ts.singleOrUndefined(nodes) || createBlock(nodes); + } + function findSpanEnd(array, test, start) { + var i = start; + while (i < array.length && test(array[i])) { + i++; + } + return i; + } + function mergeLexicalEnvironment(statements, declarations) { + if (!ts.some(declarations)) { + return statements; + } + // When we merge new lexical statements into an existing statement list, we merge them in the following manner: + // + // Given: + // + // | Left | Right | + // |------------------------------------|-------------------------------------| + // | [standard prologues (left)] | [standard prologues (right)] | + // | [hoisted functions (left)] | [hoisted functions (right)] | + // | [hoisted variables (left)] | [hoisted variables (right)] | + // | [lexical init statements (left)] | [lexical init statements (right)] | + // | [other statements (left)] | | + // + // The resulting statement list will be: + // + // | Result | + // |-------------------------------------| + // | [standard prologues (right)] | + // | [standard prologues (left)] | + // | [hoisted functions (right)] | + // | [hoisted functions (left)] | + // | [hoisted variables (right)] | + // | [hoisted variables (left)] | + // | [lexical init statements (right)] | + // | [lexical init statements (left)] | + // | [other statements (left)] | + // + // NOTE: It is expected that new lexical init statements must be evaluated before existing lexical init statements, + // as the prior transformation may depend on the evaluation of the lexical init statements to be in the correct state. + // find standard prologues on left in the following order: standard directives, hoisted functions, hoisted variables, other custom + var leftStandardPrologueEnd = findSpanEnd(statements, ts.isPrologueDirective, 0); + var leftHoistedFunctionsEnd = findSpanEnd(statements, ts.isHoistedFunction, leftStandardPrologueEnd); + var leftHoistedVariablesEnd = findSpanEnd(statements, ts.isHoistedVariableStatement, leftHoistedFunctionsEnd); + // find standard prologues on right in the following order: standard directives, hoisted functions, hoisted variables, other custom + var rightStandardPrologueEnd = findSpanEnd(declarations, ts.isPrologueDirective, 0); + var rightHoistedFunctionsEnd = findSpanEnd(declarations, ts.isHoistedFunction, rightStandardPrologueEnd); + var rightHoistedVariablesEnd = findSpanEnd(declarations, ts.isHoistedVariableStatement, rightHoistedFunctionsEnd); + var rightCustomPrologueEnd = findSpanEnd(declarations, ts.isCustomPrologue, rightHoistedVariablesEnd); + ts.Debug.assert(rightCustomPrologueEnd === declarations.length, "Expected declarations to be valid standard or custom prologues"); + // splice prologues from the right into the left. We do this in reverse order + // so that we don't need to recompute the index on the left when we insert items. + var left = ts.isNodeArray(statements) ? statements.slice() : statements; + // splice other custom prologues from right into left + if (rightCustomPrologueEnd > rightHoistedVariablesEnd) { + left.splice.apply(left, __spreadArray([leftHoistedVariablesEnd, 0], declarations.slice(rightHoistedVariablesEnd, rightCustomPrologueEnd), false)); + } + // splice hoisted variables from right into left + if (rightHoistedVariablesEnd > rightHoistedFunctionsEnd) { + left.splice.apply(left, __spreadArray([leftHoistedFunctionsEnd, 0], declarations.slice(rightHoistedFunctionsEnd, rightHoistedVariablesEnd), false)); + } + // splice hoisted functions from right into left + if (rightHoistedFunctionsEnd > rightStandardPrologueEnd) { + left.splice.apply(left, __spreadArray([leftStandardPrologueEnd, 0], declarations.slice(rightStandardPrologueEnd, rightHoistedFunctionsEnd), false)); + } + // splice standard prologues from right into left (that are not already in left) + if (rightStandardPrologueEnd > 0) { + if (leftStandardPrologueEnd === 0) { + left.splice.apply(left, __spreadArray([0, 0], declarations.slice(0, rightStandardPrologueEnd), false)); + } + else { + var leftPrologues = new ts.Map(); + for (var i = 0; i < leftStandardPrologueEnd; i++) { + var leftPrologue = statements[i]; + leftPrologues.set(leftPrologue.expression.text, true); + } + for (var i = rightStandardPrologueEnd - 1; i >= 0; i--) { + var rightPrologue = declarations[i]; + if (!leftPrologues.has(rightPrologue.expression.text)) { + left.unshift(rightPrologue); + } + } + } + } + if (ts.isNodeArray(statements)) { + return ts.setTextRange(createNodeArray(left, statements.hasTrailingComma), statements); + } + return statements; + } + function updateModifiers(node, modifiers) { + var _a; + var modifierArray; + if (typeof modifiers === "number") { + modifierArray = createModifiersFromModifierFlags(modifiers); + } + else { + modifierArray = modifiers; + } + return ts.isTypeParameterDeclaration(node) ? updateTypeParameterDeclaration(node, modifierArray, node.name, node.constraint, node.default) : + ts.isParameter(node) ? updateParameterDeclaration(node, modifierArray, node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer) : + ts.isConstructorTypeNode(node) ? updateConstructorTypeNode1(node, modifierArray, node.typeParameters, node.parameters, node.type) : + ts.isPropertySignature(node) ? updatePropertySignature(node, modifierArray, node.name, node.questionToken, node.type) : + ts.isPropertyDeclaration(node) ? updatePropertyDeclaration(node, modifierArray, node.name, (_a = node.questionToken) !== null && _a !== void 0 ? _a : node.exclamationToken, node.type, node.initializer) : + ts.isMethodSignature(node) ? updateMethodSignature(node, modifierArray, node.name, node.questionToken, node.typeParameters, node.parameters, node.type) : + ts.isMethodDeclaration(node) ? updateMethodDeclaration(node, modifierArray, node.asteriskToken, node.name, node.questionToken, node.typeParameters, node.parameters, node.type, node.body) : + ts.isConstructorDeclaration(node) ? updateConstructorDeclaration(node, modifierArray, node.parameters, node.body) : + ts.isGetAccessorDeclaration(node) ? updateGetAccessorDeclaration(node, modifierArray, node.name, node.parameters, node.type, node.body) : + ts.isSetAccessorDeclaration(node) ? updateSetAccessorDeclaration(node, modifierArray, node.name, node.parameters, node.body) : + ts.isIndexSignatureDeclaration(node) ? updateIndexSignature(node, modifierArray, node.parameters, node.type) : + ts.isFunctionExpression(node) ? updateFunctionExpression(node, modifierArray, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body) : + ts.isArrowFunction(node) ? updateArrowFunction(node, modifierArray, node.typeParameters, node.parameters, node.type, node.equalsGreaterThanToken, node.body) : + ts.isClassExpression(node) ? updateClassExpression(node, modifierArray, node.name, node.typeParameters, node.heritageClauses, node.members) : + ts.isVariableStatement(node) ? updateVariableStatement(node, modifierArray, node.declarationList) : + ts.isFunctionDeclaration(node) ? updateFunctionDeclaration(node, modifierArray, node.asteriskToken, node.name, node.typeParameters, node.parameters, node.type, node.body) : + ts.isClassDeclaration(node) ? updateClassDeclaration(node, modifierArray, node.name, node.typeParameters, node.heritageClauses, node.members) : + ts.isInterfaceDeclaration(node) ? updateInterfaceDeclaration(node, modifierArray, node.name, node.typeParameters, node.heritageClauses, node.members) : + ts.isTypeAliasDeclaration(node) ? updateTypeAliasDeclaration(node, modifierArray, node.name, node.typeParameters, node.type) : + ts.isEnumDeclaration(node) ? updateEnumDeclaration(node, modifierArray, node.name, node.members) : + ts.isModuleDeclaration(node) ? updateModuleDeclaration(node, modifierArray, node.name, node.body) : + ts.isImportEqualsDeclaration(node) ? updateImportEqualsDeclaration(node, modifierArray, node.isTypeOnly, node.name, node.moduleReference) : + ts.isImportDeclaration(node) ? updateImportDeclaration(node, modifierArray, node.importClause, node.moduleSpecifier, node.assertClause) : + ts.isExportAssignment(node) ? updateExportAssignment(node, modifierArray, node.expression) : + ts.isExportDeclaration(node) ? updateExportDeclaration(node, modifierArray, node.isTypeOnly, node.exportClause, node.moduleSpecifier, node.assertClause) : + ts.Debug.assertNever(node); + } + function asNodeArray(array) { + return array ? createNodeArray(array) : undefined; + } + function asName(name) { + return typeof name === "string" ? createIdentifier(name) : + name; + } + function asExpression(value) { + return typeof value === "string" ? createStringLiteral(value) : + typeof value === "number" ? createNumericLiteral(value) : + typeof value === "boolean" ? value ? createTrue() : createFalse() : + value; + } + function asToken(value) { + return typeof value === "number" ? createToken(value) : value; + } + function asEmbeddedStatement(statement) { + return statement && ts.isNotEmittedStatement(statement) ? ts.setTextRange(setOriginalNode(createEmptyStatement(), statement), statement) : statement; + } + } + ts.createNodeFactory = createNodeFactory; + function updateWithoutOriginal(updated, original) { + if (updated !== original) { + ts.setTextRange(updated, original); + } + return updated; + } + function updateWithOriginal(updated, original) { + if (updated !== original) { + setOriginalNode(updated, original); + ts.setTextRange(updated, original); + } + return updated; + } + function getDefaultTagNameForKind(kind) { + switch (kind) { + case 346 /* SyntaxKind.JSDocTypeTag */: return "type"; + case 344 /* SyntaxKind.JSDocReturnTag */: return "returns"; + case 345 /* SyntaxKind.JSDocThisTag */: return "this"; + case 342 /* SyntaxKind.JSDocEnumTag */: return "enum"; + case 333 /* SyntaxKind.JSDocAuthorTag */: return "author"; + case 335 /* SyntaxKind.JSDocClassTag */: return "class"; + case 336 /* SyntaxKind.JSDocPublicTag */: return "public"; + case 337 /* SyntaxKind.JSDocPrivateTag */: return "private"; + case 338 /* SyntaxKind.JSDocProtectedTag */: return "protected"; + case 339 /* SyntaxKind.JSDocReadonlyTag */: return "readonly"; + case 340 /* SyntaxKind.JSDocOverrideTag */: return "override"; + case 347 /* SyntaxKind.JSDocTemplateTag */: return "template"; + case 348 /* SyntaxKind.JSDocTypedefTag */: return "typedef"; + case 343 /* SyntaxKind.JSDocParameterTag */: return "param"; + case 350 /* SyntaxKind.JSDocPropertyTag */: return "prop"; + case 341 /* SyntaxKind.JSDocCallbackTag */: return "callback"; + case 331 /* SyntaxKind.JSDocAugmentsTag */: return "augments"; + case 332 /* SyntaxKind.JSDocImplementsTag */: return "implements"; + default: + return ts.Debug.fail("Unsupported kind: ".concat(ts.Debug.formatSyntaxKind(kind))); + } + } + var rawTextScanner; + var invalidValueSentinel = {}; + function getCookedText(kind, rawText) { + if (!rawTextScanner) { + rawTextScanner = ts.createScanner(99 /* ScriptTarget.Latest */, /*skipTrivia*/ false, 0 /* LanguageVariant.Standard */); + } + switch (kind) { + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + rawTextScanner.setText("`" + rawText + "`"); + break; + case 15 /* SyntaxKind.TemplateHead */: + rawTextScanner.setText("`" + rawText + "${"); + break; + case 16 /* SyntaxKind.TemplateMiddle */: + rawTextScanner.setText("}" + rawText + "${"); + break; + case 17 /* SyntaxKind.TemplateTail */: + rawTextScanner.setText("}" + rawText + "`"); + break; + } + var token = rawTextScanner.scan(); + if (token === 19 /* SyntaxKind.CloseBraceToken */) { + token = rawTextScanner.reScanTemplateToken(/*isTaggedTemplate*/ false); + } + if (rawTextScanner.isUnterminated()) { + rawTextScanner.setText(undefined); + return invalidValueSentinel; + } + var tokenValue; + switch (token) { + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + case 15 /* SyntaxKind.TemplateHead */: + case 16 /* SyntaxKind.TemplateMiddle */: + case 17 /* SyntaxKind.TemplateTail */: + tokenValue = rawTextScanner.getTokenValue(); + break; + } + if (tokenValue === undefined || rawTextScanner.scan() !== 1 /* SyntaxKind.EndOfFileToken */) { + rawTextScanner.setText(undefined); + return invalidValueSentinel; + } + rawTextScanner.setText(undefined); + return tokenValue; + } + function propagateIdentifierNameFlags(node) { + // An IdentifierName is allowed to be `await` + return propagateChildFlags(node) & ~67108864 /* TransformFlags.ContainsPossibleTopLevelAwait */; + } + function propagatePropertyNameFlagsOfChild(node, transformFlags) { + return transformFlags | (node.transformFlags & 134234112 /* TransformFlags.PropertyNamePropagatingFlags */); + } + function propagateChildFlags(child) { + if (!child) + return 0 /* TransformFlags.None */; + var childFlags = child.transformFlags & ~getTransformFlagsSubtreeExclusions(child.kind); + return ts.isNamedDeclaration(child) && ts.isPropertyName(child.name) ? propagatePropertyNameFlagsOfChild(child.name, childFlags) : childFlags; + } + function propagateChildrenFlags(children) { + return children ? children.transformFlags : 0 /* TransformFlags.None */; + } + function aggregateChildrenFlags(children) { + var subtreeFlags = 0 /* TransformFlags.None */; + for (var _i = 0, children_2 = children; _i < children_2.length; _i++) { + var child = children_2[_i]; + subtreeFlags |= propagateChildFlags(child); + } + children.transformFlags = subtreeFlags; + } + /** + * Gets the transform flags to exclude when unioning the transform flags of a subtree. + */ + /* @internal */ + function getTransformFlagsSubtreeExclusions(kind) { + if (kind >= 179 /* SyntaxKind.FirstTypeNode */ && kind <= 202 /* SyntaxKind.LastTypeNode */) { + return -2 /* TransformFlags.TypeExcludes */; + } + switch (kind) { + case 210 /* SyntaxKind.CallExpression */: + case 211 /* SyntaxKind.NewExpression */: + case 206 /* SyntaxKind.ArrayLiteralExpression */: + return -2147450880 /* TransformFlags.ArrayLiteralOrCallOrNewExcludes */; + case 264 /* SyntaxKind.ModuleDeclaration */: + return -1941676032 /* TransformFlags.ModuleExcludes */; + case 166 /* SyntaxKind.Parameter */: + return -2147483648 /* TransformFlags.ParameterExcludes */; + case 216 /* SyntaxKind.ArrowFunction */: + return -2072174592 /* TransformFlags.ArrowFunctionExcludes */; + case 215 /* SyntaxKind.FunctionExpression */: + case 259 /* SyntaxKind.FunctionDeclaration */: + return -1937940480 /* TransformFlags.FunctionExcludes */; + case 258 /* SyntaxKind.VariableDeclarationList */: + return -2146893824 /* TransformFlags.VariableDeclarationListExcludes */; + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + return -2147344384 /* TransformFlags.ClassExcludes */; + case 173 /* SyntaxKind.Constructor */: + return -1937948672 /* TransformFlags.ConstructorExcludes */; + case 169 /* SyntaxKind.PropertyDeclaration */: + return -2013249536 /* TransformFlags.PropertyExcludes */; + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + return -2005057536 /* TransformFlags.MethodOrAccessorExcludes */; + case 131 /* SyntaxKind.AnyKeyword */: + case 148 /* SyntaxKind.NumberKeyword */: + case 160 /* SyntaxKind.BigIntKeyword */: + case 144 /* SyntaxKind.NeverKeyword */: + case 152 /* SyntaxKind.StringKeyword */: + case 149 /* SyntaxKind.ObjectKeyword */: + case 134 /* SyntaxKind.BooleanKeyword */: + case 153 /* SyntaxKind.SymbolKeyword */: + case 114 /* SyntaxKind.VoidKeyword */: + case 165 /* SyntaxKind.TypeParameter */: + case 168 /* SyntaxKind.PropertySignature */: + case 170 /* SyntaxKind.MethodSignature */: + case 176 /* SyntaxKind.CallSignature */: + case 177 /* SyntaxKind.ConstructSignature */: + case 178 /* SyntaxKind.IndexSignature */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + return -2 /* TransformFlags.TypeExcludes */; + case 207 /* SyntaxKind.ObjectLiteralExpression */: + return -2147278848 /* TransformFlags.ObjectLiteralExcludes */; + case 295 /* SyntaxKind.CatchClause */: + return -2147418112 /* TransformFlags.CatchClauseExcludes */; + case 203 /* SyntaxKind.ObjectBindingPattern */: + case 204 /* SyntaxKind.ArrayBindingPattern */: + return -2147450880 /* TransformFlags.BindingPatternExcludes */; + case 213 /* SyntaxKind.TypeAssertionExpression */: + case 235 /* SyntaxKind.SatisfiesExpression */: + case 231 /* SyntaxKind.AsExpression */: + case 353 /* SyntaxKind.PartiallyEmittedExpression */: + case 214 /* SyntaxKind.ParenthesizedExpression */: + case 106 /* SyntaxKind.SuperKeyword */: + return -2147483648 /* TransformFlags.OuterExpressionExcludes */; + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 209 /* SyntaxKind.ElementAccessExpression */: + return -2147483648 /* TransformFlags.PropertyAccessExcludes */; + default: + return -2147483648 /* TransformFlags.NodeExcludes */; + } + } + ts.getTransformFlagsSubtreeExclusions = getTransformFlagsSubtreeExclusions; + var baseFactory = ts.createBaseNodeFactory(); + function makeSynthetic(node) { + node.flags |= 8 /* NodeFlags.Synthesized */; + return node; + } + var syntheticFactory = { + createBaseSourceFileNode: function (kind) { return makeSynthetic(baseFactory.createBaseSourceFileNode(kind)); }, + createBaseIdentifierNode: function (kind) { return makeSynthetic(baseFactory.createBaseIdentifierNode(kind)); }, + createBasePrivateIdentifierNode: function (kind) { return makeSynthetic(baseFactory.createBasePrivateIdentifierNode(kind)); }, + createBaseTokenNode: function (kind) { return makeSynthetic(baseFactory.createBaseTokenNode(kind)); }, + createBaseNode: function (kind) { return makeSynthetic(baseFactory.createBaseNode(kind)); }, + }; + ts.factory = createNodeFactory(4 /* NodeFactoryFlags.NoIndentationOnFreshPropertyAccess */, syntheticFactory); + function createUnparsedSourceFile(textOrInputFiles, mapPathOrType, mapTextOrStripInternal) { + var stripInternal; + var bundleFileInfo; + var fileName; + var text; + var length; + var sourceMapPath; + var sourceMapText; + var getText; + var getSourceMapText; + var oldFileOfCurrentEmit; + if (!ts.isString(textOrInputFiles)) { + ts.Debug.assert(mapPathOrType === "js" || mapPathOrType === "dts"); + fileName = (mapPathOrType === "js" ? textOrInputFiles.javascriptPath : textOrInputFiles.declarationPath) || ""; + sourceMapPath = mapPathOrType === "js" ? textOrInputFiles.javascriptMapPath : textOrInputFiles.declarationMapPath; + getText = function () { return mapPathOrType === "js" ? textOrInputFiles.javascriptText : textOrInputFiles.declarationText; }; + getSourceMapText = function () { return mapPathOrType === "js" ? textOrInputFiles.javascriptMapText : textOrInputFiles.declarationMapText; }; + length = function () { return getText().length; }; + if (textOrInputFiles.buildInfo && textOrInputFiles.buildInfo.bundle) { + ts.Debug.assert(mapTextOrStripInternal === undefined || typeof mapTextOrStripInternal === "boolean"); + stripInternal = mapTextOrStripInternal; + bundleFileInfo = mapPathOrType === "js" ? textOrInputFiles.buildInfo.bundle.js : textOrInputFiles.buildInfo.bundle.dts; + oldFileOfCurrentEmit = textOrInputFiles.oldFileOfCurrentEmit; + } + } + else { + fileName = ""; + text = textOrInputFiles; + length = textOrInputFiles.length; + sourceMapPath = mapPathOrType; + sourceMapText = mapTextOrStripInternal; + } + var node = oldFileOfCurrentEmit ? + parseOldFileOfCurrentEmit(ts.Debug.checkDefined(bundleFileInfo)) : + parseUnparsedSourceFile(bundleFileInfo, stripInternal, length); + node.fileName = fileName; + node.sourceMapPath = sourceMapPath; + node.oldFileOfCurrentEmit = oldFileOfCurrentEmit; + if (getText && getSourceMapText) { + Object.defineProperty(node, "text", { get: getText }); + Object.defineProperty(node, "sourceMapText", { get: getSourceMapText }); + } + else { + ts.Debug.assert(!oldFileOfCurrentEmit); + node.text = text !== null && text !== void 0 ? text : ""; + node.sourceMapText = sourceMapText; + } + return node; + } + ts.createUnparsedSourceFile = createUnparsedSourceFile; + function parseUnparsedSourceFile(bundleFileInfo, stripInternal, length) { + var prologues; + var helpers; + var referencedFiles; + var typeReferenceDirectives; + var libReferenceDirectives; + var prependChildren; + var texts; + var hasNoDefaultLib; + for (var _i = 0, _a = bundleFileInfo ? bundleFileInfo.sections : ts.emptyArray; _i < _a.length; _i++) { + var section = _a[_i]; + switch (section.kind) { + case "prologue" /* BundleFileSectionKind.Prologue */: + prologues = ts.append(prologues, ts.setTextRange(ts.factory.createUnparsedPrologue(section.data), section)); + break; + case "emitHelpers" /* BundleFileSectionKind.EmitHelpers */: + helpers = ts.append(helpers, ts.getAllUnscopedEmitHelpers().get(section.data)); + break; + case "no-default-lib" /* BundleFileSectionKind.NoDefaultLib */: + hasNoDefaultLib = true; + break; + case "reference" /* BundleFileSectionKind.Reference */: + referencedFiles = ts.append(referencedFiles, { pos: -1, end: -1, fileName: section.data }); + break; + case "type" /* BundleFileSectionKind.Type */: + typeReferenceDirectives = ts.append(typeReferenceDirectives, { pos: -1, end: -1, fileName: section.data }); + break; + case "type-import" /* BundleFileSectionKind.TypeResolutionModeImport */: + typeReferenceDirectives = ts.append(typeReferenceDirectives, { pos: -1, end: -1, fileName: section.data, resolutionMode: ts.ModuleKind.ESNext }); + break; + case "type-require" /* BundleFileSectionKind.TypeResolutionModeRequire */: + typeReferenceDirectives = ts.append(typeReferenceDirectives, { pos: -1, end: -1, fileName: section.data, resolutionMode: ts.ModuleKind.CommonJS }); + break; + case "lib" /* BundleFileSectionKind.Lib */: + libReferenceDirectives = ts.append(libReferenceDirectives, { pos: -1, end: -1, fileName: section.data }); + break; + case "prepend" /* BundleFileSectionKind.Prepend */: + var prependTexts = void 0; + for (var _b = 0, _c = section.texts; _b < _c.length; _b++) { + var text = _c[_b]; + if (!stripInternal || text.kind !== "internal" /* BundleFileSectionKind.Internal */) { + prependTexts = ts.append(prependTexts, ts.setTextRange(ts.factory.createUnparsedTextLike(text.data, text.kind === "internal" /* BundleFileSectionKind.Internal */), text)); + } + } + prependChildren = ts.addRange(prependChildren, prependTexts); + texts = ts.append(texts, ts.factory.createUnparsedPrepend(section.data, prependTexts !== null && prependTexts !== void 0 ? prependTexts : ts.emptyArray)); + break; + case "internal" /* BundleFileSectionKind.Internal */: + if (stripInternal) { + if (!texts) + texts = []; + break; + } + // falls through + case "text" /* BundleFileSectionKind.Text */: + texts = ts.append(texts, ts.setTextRange(ts.factory.createUnparsedTextLike(section.data, section.kind === "internal" /* BundleFileSectionKind.Internal */), section)); + break; + default: + ts.Debug.assertNever(section); + } + } + if (!texts) { + var textNode = ts.factory.createUnparsedTextLike(/*data*/ undefined, /*internal*/ false); + ts.setTextRangePosWidth(textNode, 0, typeof length === "function" ? length() : length); + texts = [textNode]; + } + var node = ts.parseNodeFactory.createUnparsedSource(prologues !== null && prologues !== void 0 ? prologues : ts.emptyArray, /*syntheticReferences*/ undefined, texts); + ts.setEachParent(prologues, node); + ts.setEachParent(texts, node); + ts.setEachParent(prependChildren, node); + node.hasNoDefaultLib = hasNoDefaultLib; + node.helpers = helpers; + node.referencedFiles = referencedFiles || ts.emptyArray; + node.typeReferenceDirectives = typeReferenceDirectives; + node.libReferenceDirectives = libReferenceDirectives || ts.emptyArray; + return node; + } + function parseOldFileOfCurrentEmit(bundleFileInfo) { + var texts; + var syntheticReferences; + for (var _i = 0, _a = bundleFileInfo.sections; _i < _a.length; _i++) { + var section = _a[_i]; + switch (section.kind) { + case "internal" /* BundleFileSectionKind.Internal */: + case "text" /* BundleFileSectionKind.Text */: + texts = ts.append(texts, ts.setTextRange(ts.factory.createUnparsedTextLike(section.data, section.kind === "internal" /* BundleFileSectionKind.Internal */), section)); + break; + case "no-default-lib" /* BundleFileSectionKind.NoDefaultLib */: + case "reference" /* BundleFileSectionKind.Reference */: + case "type" /* BundleFileSectionKind.Type */: + case "type-import" /* BundleFileSectionKind.TypeResolutionModeImport */: + case "type-require" /* BundleFileSectionKind.TypeResolutionModeRequire */: + case "lib" /* BundleFileSectionKind.Lib */: + syntheticReferences = ts.append(syntheticReferences, ts.setTextRange(ts.factory.createUnparsedSyntheticReference(section), section)); + break; + // Ignore + case "prologue" /* BundleFileSectionKind.Prologue */: + case "emitHelpers" /* BundleFileSectionKind.EmitHelpers */: + case "prepend" /* BundleFileSectionKind.Prepend */: + break; + default: + ts.Debug.assertNever(section); + } + } + var node = ts.factory.createUnparsedSource(ts.emptyArray, syntheticReferences, texts !== null && texts !== void 0 ? texts : ts.emptyArray); + ts.setEachParent(syntheticReferences, node); + ts.setEachParent(texts, node); + node.helpers = ts.map(bundleFileInfo.sources && bundleFileInfo.sources.helpers, function (name) { return ts.getAllUnscopedEmitHelpers().get(name); }); + return node; + } + function createInputFiles(javascriptTextOrReadFileText, declarationTextOrJavascriptPath, javascriptMapPath, javascriptMapTextOrDeclarationPath, declarationMapPath, declarationMapTextOrBuildInfoPath, javascriptPath, declarationPath, buildInfoPath, buildInfo, oldFileOfCurrentEmit) { + var node = ts.parseNodeFactory.createInputFiles(); + if (!ts.isString(javascriptTextOrReadFileText)) { + var cache_1 = new ts.Map(); + var textGetter_1 = function (path) { + if (path === undefined) + return undefined; + var value = cache_1.get(path); + if (value === undefined) { + value = javascriptTextOrReadFileText(path); + cache_1.set(path, value !== undefined ? value : false); + } + return value !== false ? value : undefined; + }; + var definedTextGetter_1 = function (path) { + var result = textGetter_1(path); + return result !== undefined ? result : "/* Input file ".concat(path, " was missing */\r\n"); + }; + var buildInfo_1; + var getAndCacheBuildInfo_1 = function (getText) { + var _a; + if (buildInfo_1 === undefined) { + var result = getText(); + buildInfo_1 = result !== undefined ? (_a = ts.getBuildInfo(node.buildInfoPath, result)) !== null && _a !== void 0 ? _a : false : false; + } + return buildInfo_1 || undefined; + }; + node.javascriptPath = declarationTextOrJavascriptPath; + node.javascriptMapPath = javascriptMapPath; + node.declarationPath = ts.Debug.checkDefined(javascriptMapTextOrDeclarationPath); + node.declarationMapPath = declarationMapPath; + node.buildInfoPath = declarationMapTextOrBuildInfoPath; + Object.defineProperties(node, { + javascriptText: { get: function () { return definedTextGetter_1(declarationTextOrJavascriptPath); } }, + javascriptMapText: { get: function () { return textGetter_1(javascriptMapPath); } }, + declarationText: { get: function () { return definedTextGetter_1(ts.Debug.checkDefined(javascriptMapTextOrDeclarationPath)); } }, + declarationMapText: { get: function () { return textGetter_1(declarationMapPath); } }, + buildInfo: { get: function () { return getAndCacheBuildInfo_1(function () { return textGetter_1(declarationMapTextOrBuildInfoPath); }); } } + }); + } + else { + node.javascriptText = javascriptTextOrReadFileText; + node.javascriptMapPath = javascriptMapPath; + node.javascriptMapText = javascriptMapTextOrDeclarationPath; + node.declarationText = declarationTextOrJavascriptPath; + node.declarationMapPath = declarationMapPath; + node.declarationMapText = declarationMapTextOrBuildInfoPath; + node.javascriptPath = javascriptPath; + node.declarationPath = declarationPath; + node.buildInfoPath = buildInfoPath; + node.buildInfo = buildInfo; + node.oldFileOfCurrentEmit = oldFileOfCurrentEmit; + } + return node; + } + ts.createInputFiles = createInputFiles; + var SourceMapSource; + /** + * Create an external source map source file reference + */ + function createSourceMapSource(fileName, text, skipTrivia) { + return new (SourceMapSource || (SourceMapSource = ts.objectAllocator.getSourceMapSourceConstructor()))(fileName, text, skipTrivia); + } + ts.createSourceMapSource = createSourceMapSource; + // Utilities + function setOriginalNode(node, original) { + node.original = original; + if (original) { + var emitNode = original.emitNode; + if (emitNode) + node.emitNode = mergeEmitNode(emitNode, node.emitNode); + } + return node; + } + ts.setOriginalNode = setOriginalNode; + function mergeEmitNode(sourceEmitNode, destEmitNode) { + var flags = sourceEmitNode.flags, leadingComments = sourceEmitNode.leadingComments, trailingComments = sourceEmitNode.trailingComments, commentRange = sourceEmitNode.commentRange, sourceMapRange = sourceEmitNode.sourceMapRange, tokenSourceMapRanges = sourceEmitNode.tokenSourceMapRanges, constantValue = sourceEmitNode.constantValue, helpers = sourceEmitNode.helpers, startsOnNewLine = sourceEmitNode.startsOnNewLine, snippetElement = sourceEmitNode.snippetElement; + if (!destEmitNode) + destEmitNode = {}; + // We are using `.slice()` here in case `destEmitNode.leadingComments` is pushed to later. + if (leadingComments) + destEmitNode.leadingComments = ts.addRange(leadingComments.slice(), destEmitNode.leadingComments); + if (trailingComments) + destEmitNode.trailingComments = ts.addRange(trailingComments.slice(), destEmitNode.trailingComments); + if (flags) + destEmitNode.flags = flags & ~268435456 /* EmitFlags.Immutable */; + if (commentRange) + destEmitNode.commentRange = commentRange; + if (sourceMapRange) + destEmitNode.sourceMapRange = sourceMapRange; + if (tokenSourceMapRanges) + destEmitNode.tokenSourceMapRanges = mergeTokenSourceMapRanges(tokenSourceMapRanges, destEmitNode.tokenSourceMapRanges); + if (constantValue !== undefined) + destEmitNode.constantValue = constantValue; + if (helpers) { + for (var _i = 0, helpers_1 = helpers; _i < helpers_1.length; _i++) { + var helper = helpers_1[_i]; + destEmitNode.helpers = ts.appendIfUnique(destEmitNode.helpers, helper); + } + } + if (startsOnNewLine !== undefined) + destEmitNode.startsOnNewLine = startsOnNewLine; + if (snippetElement !== undefined) + destEmitNode.snippetElement = snippetElement; + return destEmitNode; + } + function mergeTokenSourceMapRanges(sourceRanges, destRanges) { + if (!destRanges) + destRanges = []; + for (var key in sourceRanges) { + destRanges[key] = sourceRanges[key]; + } + return destRanges; + } +})(ts || (ts = {})); +var ts; +(function (ts) { + /** + * Associates a node with the current transformation, initializing + * various transient transformation properties. + * @internal + */ + function getOrCreateEmitNode(node) { + var _a; + if (!node.emitNode) { + if (ts.isParseTreeNode(node)) { + // To avoid holding onto transformation artifacts, we keep track of any + // parse tree node we are annotating. This allows us to clean them up after + // all transformations have completed. + if (node.kind === 308 /* SyntaxKind.SourceFile */) { + return node.emitNode = { annotatedNodes: [node] }; + } + var sourceFile = (_a = ts.getSourceFileOfNode(ts.getParseTreeNode(ts.getSourceFileOfNode(node)))) !== null && _a !== void 0 ? _a : ts.Debug.fail("Could not determine parsed source file."); + getOrCreateEmitNode(sourceFile).annotatedNodes.push(node); + } + node.emitNode = {}; + } + else { + ts.Debug.assert(!(node.emitNode.flags & 268435456 /* EmitFlags.Immutable */), "Invalid attempt to mutate an immutable node."); + } + return node.emitNode; + } + ts.getOrCreateEmitNode = getOrCreateEmitNode; + /** + * Clears any `EmitNode` entries from parse-tree nodes. + * @param sourceFile A source file. + */ + function disposeEmitNodes(sourceFile) { + var _a, _b; + // During transformation we may need to annotate a parse tree node with transient + // transformation properties. As parse tree nodes live longer than transformation + // nodes, we need to make sure we reclaim any memory allocated for custom ranges + // from these nodes to ensure we do not hold onto entire subtrees just for position + // information. We also need to reset these nodes to a pre-transformation state + // for incremental parsing scenarios so that we do not impact later emit. + var annotatedNodes = (_b = (_a = ts.getSourceFileOfNode(ts.getParseTreeNode(sourceFile))) === null || _a === void 0 ? void 0 : _a.emitNode) === null || _b === void 0 ? void 0 : _b.annotatedNodes; + if (annotatedNodes) { + for (var _i = 0, annotatedNodes_1 = annotatedNodes; _i < annotatedNodes_1.length; _i++) { + var node = annotatedNodes_1[_i]; + node.emitNode = undefined; + } + } + } + ts.disposeEmitNodes = disposeEmitNodes; + /** + * Sets `EmitFlags.NoComments` on a node and removes any leading and trailing synthetic comments. + * @internal + */ + function removeAllComments(node) { + var emitNode = getOrCreateEmitNode(node); + emitNode.flags |= 1536 /* EmitFlags.NoComments */; + emitNode.leadingComments = undefined; + emitNode.trailingComments = undefined; + return node; + } + ts.removeAllComments = removeAllComments; + /** + * Sets flags that control emit behavior of a node. + */ + function setEmitFlags(node, emitFlags) { + getOrCreateEmitNode(node).flags = emitFlags; + return node; + } + ts.setEmitFlags = setEmitFlags; + /** + * Sets flags that control emit behavior of a node. + */ + /* @internal */ + function addEmitFlags(node, emitFlags) { + var emitNode = getOrCreateEmitNode(node); + emitNode.flags = emitNode.flags | emitFlags; + return node; + } + ts.addEmitFlags = addEmitFlags; + /** + * Gets a custom text range to use when emitting source maps. + */ + function getSourceMapRange(node) { + var _a, _b; + return (_b = (_a = node.emitNode) === null || _a === void 0 ? void 0 : _a.sourceMapRange) !== null && _b !== void 0 ? _b : node; + } + ts.getSourceMapRange = getSourceMapRange; + /** + * Sets a custom text range to use when emitting source maps. + */ + function setSourceMapRange(node, range) { + getOrCreateEmitNode(node).sourceMapRange = range; + return node; + } + ts.setSourceMapRange = setSourceMapRange; + /** + * Gets the TextRange to use for source maps for a token of a node. + */ + function getTokenSourceMapRange(node, token) { + var _a, _b; + return (_b = (_a = node.emitNode) === null || _a === void 0 ? void 0 : _a.tokenSourceMapRanges) === null || _b === void 0 ? void 0 : _b[token]; + } + ts.getTokenSourceMapRange = getTokenSourceMapRange; + /** + * Sets the TextRange to use for source maps for a token of a node. + */ + function setTokenSourceMapRange(node, token, range) { + var _a; + var emitNode = getOrCreateEmitNode(node); + var tokenSourceMapRanges = (_a = emitNode.tokenSourceMapRanges) !== null && _a !== void 0 ? _a : (emitNode.tokenSourceMapRanges = []); + tokenSourceMapRanges[token] = range; + return node; + } + ts.setTokenSourceMapRange = setTokenSourceMapRange; + /** + * Gets a custom text range to use when emitting comments. + */ + /*@internal*/ + function getStartsOnNewLine(node) { + var _a; + return (_a = node.emitNode) === null || _a === void 0 ? void 0 : _a.startsOnNewLine; + } + ts.getStartsOnNewLine = getStartsOnNewLine; + /** + * Sets a custom text range to use when emitting comments. + */ + /*@internal*/ + function setStartsOnNewLine(node, newLine) { + getOrCreateEmitNode(node).startsOnNewLine = newLine; + return node; + } + ts.setStartsOnNewLine = setStartsOnNewLine; + /** + * Gets a custom text range to use when emitting comments. + */ + function getCommentRange(node) { + var _a, _b; + return (_b = (_a = node.emitNode) === null || _a === void 0 ? void 0 : _a.commentRange) !== null && _b !== void 0 ? _b : node; + } + ts.getCommentRange = getCommentRange; + /** + * Sets a custom text range to use when emitting comments. + */ + function setCommentRange(node, range) { + getOrCreateEmitNode(node).commentRange = range; + return node; + } + ts.setCommentRange = setCommentRange; + function getSyntheticLeadingComments(node) { + var _a; + return (_a = node.emitNode) === null || _a === void 0 ? void 0 : _a.leadingComments; + } + ts.getSyntheticLeadingComments = getSyntheticLeadingComments; + function setSyntheticLeadingComments(node, comments) { + getOrCreateEmitNode(node).leadingComments = comments; + return node; + } + ts.setSyntheticLeadingComments = setSyntheticLeadingComments; + function addSyntheticLeadingComment(node, kind, text, hasTrailingNewLine) { + return setSyntheticLeadingComments(node, ts.append(getSyntheticLeadingComments(node), { kind: kind, pos: -1, end: -1, hasTrailingNewLine: hasTrailingNewLine, text: text })); + } + ts.addSyntheticLeadingComment = addSyntheticLeadingComment; + function getSyntheticTrailingComments(node) { + var _a; + return (_a = node.emitNode) === null || _a === void 0 ? void 0 : _a.trailingComments; + } + ts.getSyntheticTrailingComments = getSyntheticTrailingComments; + function setSyntheticTrailingComments(node, comments) { + getOrCreateEmitNode(node).trailingComments = comments; + return node; + } + ts.setSyntheticTrailingComments = setSyntheticTrailingComments; + function addSyntheticTrailingComment(node, kind, text, hasTrailingNewLine) { + return setSyntheticTrailingComments(node, ts.append(getSyntheticTrailingComments(node), { kind: kind, pos: -1, end: -1, hasTrailingNewLine: hasTrailingNewLine, text: text })); + } + ts.addSyntheticTrailingComment = addSyntheticTrailingComment; + function moveSyntheticComments(node, original) { + setSyntheticLeadingComments(node, getSyntheticLeadingComments(original)); + setSyntheticTrailingComments(node, getSyntheticTrailingComments(original)); + var emit = getOrCreateEmitNode(original); + emit.leadingComments = undefined; + emit.trailingComments = undefined; + return node; + } + ts.moveSyntheticComments = moveSyntheticComments; + /** + * Gets the constant value to emit for an expression representing an enum. + */ + function getConstantValue(node) { + var _a; + return (_a = node.emitNode) === null || _a === void 0 ? void 0 : _a.constantValue; + } + ts.getConstantValue = getConstantValue; + /** + * Sets the constant value to emit for an expression. + */ + function setConstantValue(node, value) { + var emitNode = getOrCreateEmitNode(node); + emitNode.constantValue = value; + return node; + } + ts.setConstantValue = setConstantValue; + /** + * Adds an EmitHelper to a node. + */ + function addEmitHelper(node, helper) { + var emitNode = getOrCreateEmitNode(node); + emitNode.helpers = ts.append(emitNode.helpers, helper); + return node; + } + ts.addEmitHelper = addEmitHelper; + /** + * Add EmitHelpers to a node. + */ + function addEmitHelpers(node, helpers) { + if (ts.some(helpers)) { + var emitNode = getOrCreateEmitNode(node); + for (var _i = 0, helpers_2 = helpers; _i < helpers_2.length; _i++) { + var helper = helpers_2[_i]; + emitNode.helpers = ts.appendIfUnique(emitNode.helpers, helper); + } + } + return node; + } + ts.addEmitHelpers = addEmitHelpers; + /** + * Removes an EmitHelper from a node. + */ + function removeEmitHelper(node, helper) { + var _a; + var helpers = (_a = node.emitNode) === null || _a === void 0 ? void 0 : _a.helpers; + if (helpers) { + return ts.orderedRemoveItem(helpers, helper); + } + return false; + } + ts.removeEmitHelper = removeEmitHelper; + /** + * Gets the EmitHelpers of a node. + */ + function getEmitHelpers(node) { + var _a; + return (_a = node.emitNode) === null || _a === void 0 ? void 0 : _a.helpers; + } + ts.getEmitHelpers = getEmitHelpers; + /** + * Moves matching emit helpers from a source node to a target node. + */ + function moveEmitHelpers(source, target, predicate) { + var sourceEmitNode = source.emitNode; + var sourceEmitHelpers = sourceEmitNode && sourceEmitNode.helpers; + if (!ts.some(sourceEmitHelpers)) + return; + var targetEmitNode = getOrCreateEmitNode(target); + var helpersRemoved = 0; + for (var i = 0; i < sourceEmitHelpers.length; i++) { + var helper = sourceEmitHelpers[i]; + if (predicate(helper)) { + helpersRemoved++; + targetEmitNode.helpers = ts.appendIfUnique(targetEmitNode.helpers, helper); + } + else if (helpersRemoved > 0) { + sourceEmitHelpers[i - helpersRemoved] = helper; + } + } + if (helpersRemoved > 0) { + sourceEmitHelpers.length -= helpersRemoved; + } + } + ts.moveEmitHelpers = moveEmitHelpers; + /** + * Gets the SnippetElement of a node. + */ + /* @internal */ + function getSnippetElement(node) { + var _a; + return (_a = node.emitNode) === null || _a === void 0 ? void 0 : _a.snippetElement; + } + ts.getSnippetElement = getSnippetElement; + /** + * Sets the SnippetElement of a node. + */ + /* @internal */ + function setSnippetElement(node, snippet) { + var emitNode = getOrCreateEmitNode(node); + emitNode.snippetElement = snippet; + return node; + } + ts.setSnippetElement = setSnippetElement; + /* @internal */ + function ignoreSourceNewlines(node) { + getOrCreateEmitNode(node).flags |= 134217728 /* EmitFlags.IgnoreSourceNewlines */; + return node; + } + ts.ignoreSourceNewlines = ignoreSourceNewlines; + /* @internal */ + function setTypeNode(node, type) { + var emitNode = getOrCreateEmitNode(node); + emitNode.typeNode = type; + return node; + } + ts.setTypeNode = setTypeNode; + /* @internal */ + function getTypeNode(node) { + var _a; + return (_a = node.emitNode) === null || _a === void 0 ? void 0 : _a.typeNode; + } + ts.getTypeNode = getTypeNode; +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + function createEmitHelperFactory(context) { + var factory = context.factory; + var immutableTrue = ts.memoize(function () { return ts.setEmitFlags(factory.createTrue(), 268435456 /* EmitFlags.Immutable */); }); + var immutableFalse = ts.memoize(function () { return ts.setEmitFlags(factory.createFalse(), 268435456 /* EmitFlags.Immutable */); }); + return { + getUnscopedHelperName: getUnscopedHelperName, + // TypeScript Helpers + createDecorateHelper: createDecorateHelper, + createMetadataHelper: createMetadataHelper, + createParamHelper: createParamHelper, + // ES2018 Helpers + createAssignHelper: createAssignHelper, + createAwaitHelper: createAwaitHelper, + createAsyncGeneratorHelper: createAsyncGeneratorHelper, + createAsyncDelegatorHelper: createAsyncDelegatorHelper, + createAsyncValuesHelper: createAsyncValuesHelper, + // ES2018 Destructuring Helpers + createRestHelper: createRestHelper, + // ES2017 Helpers + createAwaiterHelper: createAwaiterHelper, + // ES2015 Helpers + createExtendsHelper: createExtendsHelper, + createTemplateObjectHelper: createTemplateObjectHelper, + createSpreadArrayHelper: createSpreadArrayHelper, + // ES2015 Destructuring Helpers + createValuesHelper: createValuesHelper, + createReadHelper: createReadHelper, + // ES2015 Generator Helpers + createGeneratorHelper: createGeneratorHelper, + // ES Module Helpers + createCreateBindingHelper: createCreateBindingHelper, + createImportStarHelper: createImportStarHelper, + createImportStarCallbackHelper: createImportStarCallbackHelper, + createImportDefaultHelper: createImportDefaultHelper, + createExportStarHelper: createExportStarHelper, + // Class Fields Helpers + createClassPrivateFieldGetHelper: createClassPrivateFieldGetHelper, + createClassPrivateFieldSetHelper: createClassPrivateFieldSetHelper, + createClassPrivateFieldInHelper: createClassPrivateFieldInHelper + }; + /** + * Gets an identifier for the name of an *unscoped* emit helper. + */ + function getUnscopedHelperName(name) { + return ts.setEmitFlags(factory.createIdentifier(name), 4096 /* EmitFlags.HelperName */ | 2 /* EmitFlags.AdviseOnEmitNode */); + } + // TypeScript Helpers + function createDecorateHelper(decoratorExpressions, target, memberName, descriptor) { + context.requestEmitHelper(ts.decorateHelper); + var argumentsArray = []; + argumentsArray.push(factory.createArrayLiteralExpression(decoratorExpressions, /*multiLine*/ true)); + argumentsArray.push(target); + if (memberName) { + argumentsArray.push(memberName); + if (descriptor) { + argumentsArray.push(descriptor); + } + } + return factory.createCallExpression(getUnscopedHelperName("__decorate"), + /*typeArguments*/ undefined, argumentsArray); + } + function createMetadataHelper(metadataKey, metadataValue) { + context.requestEmitHelper(ts.metadataHelper); + return factory.createCallExpression(getUnscopedHelperName("__metadata"), + /*typeArguments*/ undefined, [ + factory.createStringLiteral(metadataKey), + metadataValue + ]); + } + function createParamHelper(expression, parameterOffset, location) { + context.requestEmitHelper(ts.paramHelper); + return ts.setTextRange(factory.createCallExpression(getUnscopedHelperName("__param"), + /*typeArguments*/ undefined, [ + factory.createNumericLiteral(parameterOffset + ""), + expression + ]), location); + } + // ES2018 Helpers + function createAssignHelper(attributesSegments) { + if (ts.getEmitScriptTarget(context.getCompilerOptions()) >= 2 /* ScriptTarget.ES2015 */) { + return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Object"), "assign"), + /*typeArguments*/ undefined, attributesSegments); + } + context.requestEmitHelper(ts.assignHelper); + return factory.createCallExpression(getUnscopedHelperName("__assign"), + /*typeArguments*/ undefined, attributesSegments); + } + function createAwaitHelper(expression) { + context.requestEmitHelper(ts.awaitHelper); + return factory.createCallExpression(getUnscopedHelperName("__await"), /*typeArguments*/ undefined, [expression]); + } + function createAsyncGeneratorHelper(generatorFunc, hasLexicalThis) { + context.requestEmitHelper(ts.awaitHelper); + context.requestEmitHelper(ts.asyncGeneratorHelper); + // Mark this node as originally an async function + (generatorFunc.emitNode || (generatorFunc.emitNode = {})).flags |= 262144 /* EmitFlags.AsyncFunctionBody */ | 524288 /* EmitFlags.ReuseTempVariableScope */; + return factory.createCallExpression(getUnscopedHelperName("__asyncGenerator"), + /*typeArguments*/ undefined, [ + hasLexicalThis ? factory.createThis() : factory.createVoidZero(), + factory.createIdentifier("arguments"), + generatorFunc + ]); + } + function createAsyncDelegatorHelper(expression) { + context.requestEmitHelper(ts.awaitHelper); + context.requestEmitHelper(ts.asyncDelegator); + return factory.createCallExpression(getUnscopedHelperName("__asyncDelegator"), + /*typeArguments*/ undefined, [expression]); + } + function createAsyncValuesHelper(expression) { + context.requestEmitHelper(ts.asyncValues); + return factory.createCallExpression(getUnscopedHelperName("__asyncValues"), + /*typeArguments*/ undefined, [expression]); + } + // ES2018 Destructuring Helpers + /** Given value: o, propName: p, pattern: { a, b, ...p } from the original statement + * `{ a, b, ...p } = o`, create `p = __rest(o, ["a", "b"]);` + */ + function createRestHelper(value, elements, computedTempVariables, location) { + context.requestEmitHelper(ts.restHelper); + var propertyNames = []; + var computedTempVariableOffset = 0; + for (var i = 0; i < elements.length - 1; i++) { + var propertyName = ts.getPropertyNameOfBindingOrAssignmentElement(elements[i]); + if (propertyName) { + if (ts.isComputedPropertyName(propertyName)) { + ts.Debug.assertIsDefined(computedTempVariables, "Encountered computed property name but 'computedTempVariables' argument was not provided."); + var temp = computedTempVariables[computedTempVariableOffset]; + computedTempVariableOffset++; + // typeof _tmp === "symbol" ? _tmp : _tmp + "" + propertyNames.push(factory.createConditionalExpression(factory.createTypeCheck(temp, "symbol"), + /*questionToken*/ undefined, temp, + /*colonToken*/ undefined, factory.createAdd(temp, factory.createStringLiteral("")))); + } + else { + propertyNames.push(factory.createStringLiteralFromNode(propertyName)); + } + } + } + return factory.createCallExpression(getUnscopedHelperName("__rest"), + /*typeArguments*/ undefined, [ + value, + ts.setTextRange(factory.createArrayLiteralExpression(propertyNames), location) + ]); + } + // ES2017 Helpers + function createAwaiterHelper(hasLexicalThis, hasLexicalArguments, promiseConstructor, body) { + context.requestEmitHelper(ts.awaiterHelper); + var generatorFunc = factory.createFunctionExpression( + /*modifiers*/ undefined, factory.createToken(41 /* SyntaxKind.AsteriskToken */), + /*name*/ undefined, + /*typeParameters*/ undefined, + /*parameters*/ [], + /*type*/ undefined, body); + // Mark this node as originally an async function + (generatorFunc.emitNode || (generatorFunc.emitNode = {})).flags |= 262144 /* EmitFlags.AsyncFunctionBody */ | 524288 /* EmitFlags.ReuseTempVariableScope */; + return factory.createCallExpression(getUnscopedHelperName("__awaiter"), + /*typeArguments*/ undefined, [ + hasLexicalThis ? factory.createThis() : factory.createVoidZero(), + hasLexicalArguments ? factory.createIdentifier("arguments") : factory.createVoidZero(), + promiseConstructor ? ts.createExpressionFromEntityName(factory, promiseConstructor) : factory.createVoidZero(), + generatorFunc + ]); + } + // ES2015 Helpers + function createExtendsHelper(name) { + context.requestEmitHelper(ts.extendsHelper); + return factory.createCallExpression(getUnscopedHelperName("__extends"), + /*typeArguments*/ undefined, [name, factory.createUniqueName("_super", 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */)]); + } + function createTemplateObjectHelper(cooked, raw) { + context.requestEmitHelper(ts.templateObjectHelper); + return factory.createCallExpression(getUnscopedHelperName("__makeTemplateObject"), + /*typeArguments*/ undefined, [cooked, raw]); + } + function createSpreadArrayHelper(to, from, packFrom) { + context.requestEmitHelper(ts.spreadArrayHelper); + return factory.createCallExpression(getUnscopedHelperName("__spreadArray"), + /*typeArguments*/ undefined, [to, from, packFrom ? immutableTrue() : immutableFalse()]); + } + // ES2015 Destructuring Helpers + function createValuesHelper(expression) { + context.requestEmitHelper(ts.valuesHelper); + return factory.createCallExpression(getUnscopedHelperName("__values"), + /*typeArguments*/ undefined, [expression]); + } + function createReadHelper(iteratorRecord, count) { + context.requestEmitHelper(ts.readHelper); + return factory.createCallExpression(getUnscopedHelperName("__read"), + /*typeArguments*/ undefined, count !== undefined + ? [iteratorRecord, factory.createNumericLiteral(count + "")] + : [iteratorRecord]); + } + // ES2015 Generator Helpers + function createGeneratorHelper(body) { + context.requestEmitHelper(ts.generatorHelper); + return factory.createCallExpression(getUnscopedHelperName("__generator"), + /*typeArguments*/ undefined, [factory.createThis(), body]); + } + // ES Module Helpers + function createCreateBindingHelper(module, inputName, outputName) { + context.requestEmitHelper(ts.createBindingHelper); + return factory.createCallExpression(getUnscopedHelperName("__createBinding"), + /*typeArguments*/ undefined, __spreadArray([factory.createIdentifier("exports"), module, inputName], (outputName ? [outputName] : []), true)); + } + function createImportStarHelper(expression) { + context.requestEmitHelper(ts.importStarHelper); + return factory.createCallExpression(getUnscopedHelperName("__importStar"), + /*typeArguments*/ undefined, [expression]); + } + function createImportStarCallbackHelper() { + context.requestEmitHelper(ts.importStarHelper); + return getUnscopedHelperName("__importStar"); + } + function createImportDefaultHelper(expression) { + context.requestEmitHelper(ts.importDefaultHelper); + return factory.createCallExpression(getUnscopedHelperName("__importDefault"), + /*typeArguments*/ undefined, [expression]); + } + function createExportStarHelper(moduleExpression, exportsExpression) { + if (exportsExpression === void 0) { exportsExpression = factory.createIdentifier("exports"); } + context.requestEmitHelper(ts.exportStarHelper); + context.requestEmitHelper(ts.createBindingHelper); + return factory.createCallExpression(getUnscopedHelperName("__exportStar"), + /*typeArguments*/ undefined, [moduleExpression, exportsExpression]); + } + // Class Fields Helpers + function createClassPrivateFieldGetHelper(receiver, state, kind, f) { + context.requestEmitHelper(ts.classPrivateFieldGetHelper); + var args; + if (!f) { + args = [receiver, state, factory.createStringLiteral(kind)]; + } + else { + args = [receiver, state, factory.createStringLiteral(kind), f]; + } + return factory.createCallExpression(getUnscopedHelperName("__classPrivateFieldGet"), /*typeArguments*/ undefined, args); + } + function createClassPrivateFieldSetHelper(receiver, state, value, kind, f) { + context.requestEmitHelper(ts.classPrivateFieldSetHelper); + var args; + if (!f) { + args = [receiver, state, value, factory.createStringLiteral(kind)]; + } + else { + args = [receiver, state, value, factory.createStringLiteral(kind), f]; + } + return factory.createCallExpression(getUnscopedHelperName("__classPrivateFieldSet"), /*typeArguments*/ undefined, args); + } + function createClassPrivateFieldInHelper(state, receiver) { + context.requestEmitHelper(ts.classPrivateFieldInHelper); + return factory.createCallExpression(getUnscopedHelperName("__classPrivateFieldIn"), /* typeArguments*/ undefined, [state, receiver]); + } + } + ts.createEmitHelperFactory = createEmitHelperFactory; + /* @internal */ + function compareEmitHelpers(x, y) { + if (x === y) + return 0 /* Comparison.EqualTo */; + if (x.priority === y.priority) + return 0 /* Comparison.EqualTo */; + if (x.priority === undefined) + return 1 /* Comparison.GreaterThan */; + if (y.priority === undefined) + return -1 /* Comparison.LessThan */; + return ts.compareValues(x.priority, y.priority); + } + ts.compareEmitHelpers = compareEmitHelpers; + /** + * @param input Template string input strings + * @param args Names which need to be made file-level unique + */ + function helperString(input) { + var args = []; + for (var _i = 1; _i < arguments.length; _i++) { + args[_i - 1] = arguments[_i]; + } + return function (uniqueName) { + var result = ""; + for (var i = 0; i < args.length; i++) { + result += input[i]; + result += uniqueName(args[i]); + } + result += input[input.length - 1]; + return result; + }; + } + ts.helperString = helperString; + // TypeScript Helpers + ts.decorateHelper = { + name: "typescript:decorate", + importName: "__decorate", + scoped: false, + priority: 2, + text: "\n var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\n return c > 3 && r && Object.defineProperty(target, key, r), r;\n };" + }; + ts.metadataHelper = { + name: "typescript:metadata", + importName: "__metadata", + scoped: false, + priority: 3, + text: "\n var __metadata = (this && this.__metadata) || function (k, v) {\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(k, v);\n };" + }; + ts.paramHelper = { + name: "typescript:param", + importName: "__param", + scoped: false, + priority: 4, + text: "\n var __param = (this && this.__param) || function (paramIndex, decorator) {\n return function (target, key) { decorator(target, key, paramIndex); }\n };" + }; + // ES2018 Helpers + ts.assignHelper = { + name: "typescript:assign", + importName: "__assign", + scoped: false, + priority: 1, + text: "\n var __assign = (this && this.__assign) || function () {\n __assign = Object.assign || function(t) {\n for (var s, i = 1, n = arguments.length; i < n; i++) {\n s = arguments[i];\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n t[p] = s[p];\n }\n return t;\n };\n return __assign.apply(this, arguments);\n };" + }; + ts.awaitHelper = { + name: "typescript:await", + importName: "__await", + scoped: false, + text: "\n var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }" + }; + ts.asyncGeneratorHelper = { + name: "typescript:asyncGenerator", + importName: "__asyncGenerator", + scoped: false, + dependencies: [ts.awaitHelper], + text: "\n var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n var g = generator.apply(thisArg, _arguments || []), i, q = [];\n return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\n function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\n function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\n function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\n function fulfill(value) { resume(\"next\", value); }\n function reject(value) { resume(\"throw\", value); }\n function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\n };" + }; + ts.asyncDelegator = { + name: "typescript:asyncDelegator", + importName: "__asyncDelegator", + scoped: false, + dependencies: [ts.awaitHelper], + text: "\n var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {\n var i, p;\n return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\n function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\n };" + }; + ts.asyncValues = { + name: "typescript:asyncValues", + importName: "__asyncValues", + scoped: false, + text: "\n var __asyncValues = (this && this.__asyncValues) || function (o) {\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\n var m = o[Symbol.asyncIterator], i;\n return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\n function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\n function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\n };" + }; + // ES2018 Destructuring Helpers + ts.restHelper = { + name: "typescript:rest", + importName: "__rest", + scoped: false, + text: "\n var __rest = (this && this.__rest) || function (s, e) {\n var t = {};\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n t[p] = s[p];\n if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n t[p[i]] = s[p[i]];\n }\n return t;\n };" + }; + // ES2017 Helpers + ts.awaiterHelper = { + name: "typescript:awaiter", + importName: "__awaiter", + scoped: false, + priority: 5, + text: "\n var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n };" + }; + // ES2015 Helpers + ts.extendsHelper = { + name: "typescript:extends", + importName: "__extends", + scoped: false, + priority: 0, + text: "\n var __extends = (this && this.__extends) || (function () {\n var extendStatics = function (d, b) {\n extendStatics = Object.setPrototypeOf ||\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n return extendStatics(d, b);\n };\n\n return function (d, b) {\n if (typeof b !== \"function\" && b !== null)\n throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n extendStatics(d, b);\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n };\n })();" + }; + ts.templateObjectHelper = { + name: "typescript:makeTemplateObject", + importName: "__makeTemplateObject", + scoped: false, + priority: 0, + text: "\n var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) {\n if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\n return cooked;\n };" + }; + ts.readHelper = { + name: "typescript:read", + importName: "__read", + scoped: false, + text: "\n var __read = (this && this.__read) || function (o, n) {\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n if (!m) return o;\n var i = m.call(o), r, ar = [], e;\n try {\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n }\n catch (error) { e = { error: error }; }\n finally {\n try {\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\n }\n finally { if (e) throw e.error; }\n }\n return ar;\n };" + }; + ts.spreadArrayHelper = { + name: "typescript:spreadArray", + importName: "__spreadArray", + scoped: false, + text: "\n var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n if (ar || !(i in from)) {\n if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n ar[i] = from[i];\n }\n }\n return to.concat(ar || Array.prototype.slice.call(from));\n };" + }; + // ES2015 Destructuring Helpers + ts.valuesHelper = { + name: "typescript:values", + importName: "__values", + scoped: false, + text: "\n var __values = (this && this.__values) || function(o) {\n var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n if (m) return m.call(o);\n if (o && typeof o.length === \"number\") return {\n next: function () {\n if (o && i >= o.length) o = void 0;\n return { value: o && o[i++], done: !o };\n }\n };\n throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n };" + }; + // ES2015 Generator Helpers + // The __generator helper is used by down-level transformations to emulate the runtime + // semantics of an ES2015 generator function. When called, this helper returns an + // object that implements the Iterator protocol, in that it has `next`, `return`, and + // `throw` methods that step through the generator when invoked. + // + // parameters: + // @param thisArg The value to use as the `this` binding for the transformed generator body. + // @param body A function that acts as the transformed generator body. + // + // variables: + // _ Persistent state for the generator that is shared between the helper and the + // generator body. The state object has the following members: + // sent() - A method that returns or throws the current completion value. + // label - The next point at which to resume evaluation of the generator body. + // trys - A stack of protected regions (try/catch/finally blocks). + // ops - A stack of pending instructions when inside of a finally block. + // f A value indicating whether the generator is executing. + // y An iterator to delegate for a yield*. + // t A temporary variable that holds one of the following values (note that these + // cases do not overlap): + // - The completion value when resuming from a `yield` or `yield*`. + // - The error value for a catch block. + // - The current protected region (array of try/catch/finally/end labels). + // - The verb (`next`, `throw`, or `return` method) to delegate to the expression + // of a `yield*`. + // - The result of evaluating the verb delegated to the expression of a `yield*`. + // g A temporary variable that holds onto the generator object until the generator + // is started, allowing it to also act as the `suspendedStart` state. + // + // functions: + // verb(n) Creates a bound callback to the `step` function for opcode `n`. + // step(op) Evaluates opcodes in a generator body until execution is suspended or + // completed. + // + // The __generator helper understands a limited set of instructions: + // 0: next(value?) - Start or resume the generator with the specified value. + // 1: throw(error) - Resume the generator with an exception. If the generator is + // suspended inside of one or more protected regions, evaluates + // any intervening finally blocks between the current label and + // the nearest catch block or function boundary. If uncaught, the + // exception is thrown to the caller. + // 2: return(value?) - Resume the generator as if with a return. If the generator is + // suspended inside of one or more protected regions, evaluates any + // intervening finally blocks. + // 3: break(label) - Jump to the specified label. If the label is outside of the + // current protected region, evaluates any intervening finally + // blocks. + // 4: yield(value?) - Yield execution to the caller with an optional value. When + // resumed, the generator will continue at the next label. + // 5: yield*(value) - Delegates evaluation to the supplied iterator. When + // delegation completes, the generator will continue at the next + // label. + // 6: catch(error) - Handles an exception thrown from within the generator body. If + // the current label is inside of one or more protected regions, + // evaluates any intervening finally blocks between the current + // label and the nearest catch block or function boundary. If + // uncaught, the exception is thrown to the caller. + // 7: endfinally - Ends a finally block, resuming the last instruction prior to + // entering a finally block. + // + // For examples of how these are used, see the comments in ./transformers/generators.ts + ts.generatorHelper = { + name: "typescript:generator", + importName: "__generator", + scoped: false, + priority: 6, + text: "\n var __generator = (this && this.__generator) || function (thisArg, body) {\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n function verb(n) { return function (v) { return step([n, v]); }; }\n function step(op) {\n if (f) throw new TypeError(\"Generator is already executing.\");\n while (g && (g = 0, op[0] && (_ = 0)), _) try {\n if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n if (y = 0, t) op = [op[0] & 2, t.value];\n switch (op[0]) {\n case 0: case 1: t = op; break;\n case 4: _.label++; return { value: op[1], done: false };\n case 5: _.label++; y = op[1]; op = [0]; continue;\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\n default:\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n if (t[2]) _.ops.pop();\n _.trys.pop(); continue;\n }\n op = body.call(thisArg, _);\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n }\n };" + }; + // ES Module Helpers + ts.createBindingHelper = { + name: "typescript:commonjscreatebinding", + importName: "__createBinding", + scoped: false, + priority: 1, + text: "\n var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n var desc = Object.getOwnPropertyDescriptor(m, k);\n if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n desc = { enumerable: true, get: function() { return m[k]; } };\n }\n Object.defineProperty(o, k2, desc);\n }) : (function(o, m, k, k2) {\n if (k2 === undefined) k2 = k;\n o[k2] = m[k];\n }));" + }; + ts.setModuleDefaultHelper = { + name: "typescript:commonjscreatevalue", + importName: "__setModuleDefault", + scoped: false, + priority: 1, + text: "\n var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n }) : function(o, v) {\n o[\"default\"] = v;\n });" + }; + // emit helper for `import * as Name from "foo"` + ts.importStarHelper = { + name: "typescript:commonjsimportstar", + importName: "__importStar", + scoped: false, + dependencies: [ts.createBindingHelper, ts.setModuleDefaultHelper], + priority: 2, + text: "\n var __importStar = (this && this.__importStar) || function (mod) {\n if (mod && mod.__esModule) return mod;\n var result = {};\n if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n __setModuleDefault(result, mod);\n return result;\n };" + }; + // emit helper for `import Name from "foo"` + ts.importDefaultHelper = { + name: "typescript:commonjsimportdefault", + importName: "__importDefault", + scoped: false, + text: "\n var __importDefault = (this && this.__importDefault) || function (mod) {\n return (mod && mod.__esModule) ? mod : { \"default\": mod };\n };" + }; + ts.exportStarHelper = { + name: "typescript:export-star", + importName: "__exportStar", + scoped: false, + dependencies: [ts.createBindingHelper], + priority: 2, + text: "\n var __exportStar = (this && this.__exportStar) || function(m, exports) {\n for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n };" + }; + /** + * Parameters: + * @param receiver — The object from which the private member will be read. + * @param state — One of the following: + * - A WeakMap used to read a private instance field. + * - A WeakSet used as an instance brand for private instance methods and accessors. + * - A function value that should be the undecorated class constructor used to brand check private static fields, methods, and accessors. + * @param kind — (optional pre TS 4.3, required for TS 4.3+) One of the following values: + * - undefined — Indicates a private instance field (pre TS 4.3). + * - "f" — Indicates a private field (instance or static). + * - "m" — Indicates a private method (instance or static). + * - "a" — Indicates a private accessor (instance or static). + * @param f — (optional pre TS 4.3) Depends on the arguments for state and kind: + * - If kind is "m", this should be the function corresponding to the static or instance method. + * - If kind is "a", this should be the function corresponding to the getter method, or undefined if the getter was not defined. + * - If kind is "f" and state is a function, this should be an object holding the value of a static field, or undefined if the static field declaration has not yet been evaluated. + * Usage: + * This helper will only ever be used by the compiler in the following ways: + * + * Reading from a private instance field (pre TS 4.3): + * __classPrivateFieldGet(, ) + * + * Reading from a private instance field (TS 4.3+): + * __classPrivateFieldGet(, , "f") + * + * Reading from a private instance get accessor (when defined, TS 4.3+): + * __classPrivateFieldGet(, , "a", ) + * + * Reading from a private instance get accessor (when not defined, TS 4.3+): + * __classPrivateFieldGet(, , "a", void 0) + * NOTE: This always results in a runtime error. + * + * Reading from a private instance method (TS 4.3+): + * __classPrivateFieldGet(, , "m", ) + * + * Reading from a private static field (TS 4.3+): + * __classPrivateFieldGet(, , "f", <{ value: any }>) + * + * Reading from a private static get accessor (when defined, TS 4.3+): + * __classPrivateFieldGet(, , "a", ) + * + * Reading from a private static get accessor (when not defined, TS 4.3+): + * __classPrivateFieldGet(, , "a", void 0) + * NOTE: This always results in a runtime error. + * + * Reading from a private static method (TS 4.3+): + * __classPrivateFieldGet(, , "m", ) + */ + ts.classPrivateFieldGetHelper = { + name: "typescript:classPrivateFieldGet", + importName: "__classPrivateFieldGet", + scoped: false, + text: "\n var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\n return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\n };" + }; + /** + * Parameters: + * @param receiver — The object on which the private member will be set. + * @param state — One of the following: + * - A WeakMap used to store a private instance field. + * - A WeakSet used as an instance brand for private instance methods and accessors. + * - A function value that should be the undecorated class constructor used to brand check private static fields, methods, and accessors. + * @param value — The value to set. + * @param kind — (optional pre TS 4.3, required for TS 4.3+) One of the following values: + * - undefined — Indicates a private instance field (pre TS 4.3). + * - "f" — Indicates a private field (instance or static). + * - "m" — Indicates a private method (instance or static). + * - "a" — Indicates a private accessor (instance or static). + * @param f — (optional pre TS 4.3) Depends on the arguments for state and kind: + * - If kind is "m", this should be the function corresponding to the static or instance method. + * - If kind is "a", this should be the function corresponding to the setter method, or undefined if the setter was not defined. + * - If kind is "f" and state is a function, this should be an object holding the value of a static field, or undefined if the static field declaration has not yet been evaluated. + * Usage: + * This helper will only ever be used by the compiler in the following ways: + * + * Writing to a private instance field (pre TS 4.3): + * __classPrivateFieldSet(, , ) + * + * Writing to a private instance field (TS 4.3+): + * __classPrivateFieldSet(, , , "f") + * + * Writing to a private instance set accessor (when defined, TS 4.3+): + * __classPrivateFieldSet(, , , "a", ) + * + * Writing to a private instance set accessor (when not defined, TS 4.3+): + * __classPrivateFieldSet(, , , "a", void 0) + * NOTE: This always results in a runtime error. + * + * Writing to a private instance method (TS 4.3+): + * __classPrivateFieldSet(, , , "m", ) + * NOTE: This always results in a runtime error. + * + * Writing to a private static field (TS 4.3+): + * __classPrivateFieldSet(, , , "f", <{ value: any }>) + * + * Writing to a private static set accessor (when defined, TS 4.3+): + * __classPrivateFieldSet(, , , "a", ) + * + * Writing to a private static set accessor (when not defined, TS 4.3+): + * __classPrivateFieldSet(, , , "a", void 0) + * NOTE: This always results in a runtime error. + * + * Writing to a private static method (TS 4.3+): + * __classPrivateFieldSet(, , , "m", ) + * NOTE: This always results in a runtime error. + */ + ts.classPrivateFieldSetHelper = { + name: "typescript:classPrivateFieldSet", + importName: "__classPrivateFieldSet", + scoped: false, + text: "\n var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {\n if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\n return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\n };" + }; + /** + * Parameters: + * @param state — One of the following: + * - A WeakMap when the member is a private instance field. + * - A WeakSet when the member is a private instance method or accessor. + * - A function value that should be the undecorated class constructor when the member is a private static field, method, or accessor. + * @param receiver — The object being checked if it has the private member. + * + * Usage: + * This helper is used to transform `#field in expression` to + * `__classPrivateFieldIn(, expression)` + */ + ts.classPrivateFieldInHelper = { + name: "typescript:classPrivateFieldIn", + importName: "__classPrivateFieldIn", + scoped: false, + text: "\n var __classPrivateFieldIn = (this && this.__classPrivateFieldIn) || function(state, receiver) {\n if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\n return typeof state === \"function\" ? receiver === state : state.has(receiver);\n };" + }; + var allUnscopedEmitHelpers; + function getAllUnscopedEmitHelpers() { + return allUnscopedEmitHelpers || (allUnscopedEmitHelpers = ts.arrayToMap([ + ts.decorateHelper, + ts.metadataHelper, + ts.paramHelper, + ts.assignHelper, + ts.awaitHelper, + ts.asyncGeneratorHelper, + ts.asyncDelegator, + ts.asyncValues, + ts.restHelper, + ts.awaiterHelper, + ts.extendsHelper, + ts.templateObjectHelper, + ts.spreadArrayHelper, + ts.valuesHelper, + ts.readHelper, + ts.generatorHelper, + ts.importStarHelper, + ts.importDefaultHelper, + ts.exportStarHelper, + ts.classPrivateFieldGetHelper, + ts.classPrivateFieldSetHelper, + ts.classPrivateFieldInHelper, + ts.createBindingHelper, + ts.setModuleDefaultHelper + ], function (helper) { return helper.name; })); + } + ts.getAllUnscopedEmitHelpers = getAllUnscopedEmitHelpers; + ts.asyncSuperHelper = { + name: "typescript:async-super", + scoped: true, + text: helperString(__makeTemplateObject(["\n const ", " = name => super[name];"], ["\n const ", " = name => super[name];"]), "_superIndex") + }; + ts.advancedAsyncSuperHelper = { + name: "typescript:advanced-async-super", + scoped: true, + text: helperString(__makeTemplateObject(["\n const ", " = (function (geti, seti) {\n const cache = Object.create(null);\n return name => cache[name] || (cache[name] = { get value() { return geti(name); }, set value(v) { seti(name, v); } });\n })(name => super[name], (name, value) => super[name] = value);"], ["\n const ", " = (function (geti, seti) {\n const cache = Object.create(null);\n return name => cache[name] || (cache[name] = { get value() { return geti(name); }, set value(v) { seti(name, v); } });\n })(name => super[name], (name, value) => super[name] = value);"]), "_superIndex") + }; + function isCallToHelper(firstSegment, helperName) { + return ts.isCallExpression(firstSegment) + && ts.isIdentifier(firstSegment.expression) + && (ts.getEmitFlags(firstSegment.expression) & 4096 /* EmitFlags.HelperName */) !== 0 + && firstSegment.expression.escapedText === helperName; + } + ts.isCallToHelper = isCallToHelper; +})(ts || (ts = {})); +var ts; +(function (ts) { + // Literals + function isNumericLiteral(node) { + return node.kind === 8 /* SyntaxKind.NumericLiteral */; + } + ts.isNumericLiteral = isNumericLiteral; + function isBigIntLiteral(node) { + return node.kind === 9 /* SyntaxKind.BigIntLiteral */; + } + ts.isBigIntLiteral = isBigIntLiteral; + function isStringLiteral(node) { + return node.kind === 10 /* SyntaxKind.StringLiteral */; + } + ts.isStringLiteral = isStringLiteral; + function isJsxText(node) { + return node.kind === 11 /* SyntaxKind.JsxText */; + } + ts.isJsxText = isJsxText; + function isRegularExpressionLiteral(node) { + return node.kind === 13 /* SyntaxKind.RegularExpressionLiteral */; + } + ts.isRegularExpressionLiteral = isRegularExpressionLiteral; + function isNoSubstitutionTemplateLiteral(node) { + return node.kind === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */; + } + ts.isNoSubstitutionTemplateLiteral = isNoSubstitutionTemplateLiteral; + // Pseudo-literals + function isTemplateHead(node) { + return node.kind === 15 /* SyntaxKind.TemplateHead */; + } + ts.isTemplateHead = isTemplateHead; + function isTemplateMiddle(node) { + return node.kind === 16 /* SyntaxKind.TemplateMiddle */; + } + ts.isTemplateMiddle = isTemplateMiddle; + function isTemplateTail(node) { + return node.kind === 17 /* SyntaxKind.TemplateTail */; + } + ts.isTemplateTail = isTemplateTail; + // Punctuation + function isDotDotDotToken(node) { + return node.kind === 25 /* SyntaxKind.DotDotDotToken */; + } + ts.isDotDotDotToken = isDotDotDotToken; + /*@internal*/ + function isCommaToken(node) { + return node.kind === 27 /* SyntaxKind.CommaToken */; + } + ts.isCommaToken = isCommaToken; + function isPlusToken(node) { + return node.kind === 39 /* SyntaxKind.PlusToken */; + } + ts.isPlusToken = isPlusToken; + function isMinusToken(node) { + return node.kind === 40 /* SyntaxKind.MinusToken */; + } + ts.isMinusToken = isMinusToken; + function isAsteriskToken(node) { + return node.kind === 41 /* SyntaxKind.AsteriskToken */; + } + ts.isAsteriskToken = isAsteriskToken; + /*@internal*/ + function isExclamationToken(node) { + return node.kind === 53 /* SyntaxKind.ExclamationToken */; + } + ts.isExclamationToken = isExclamationToken; + /*@internal*/ + function isQuestionToken(node) { + return node.kind === 57 /* SyntaxKind.QuestionToken */; + } + ts.isQuestionToken = isQuestionToken; + /*@internal*/ + function isColonToken(node) { + return node.kind === 58 /* SyntaxKind.ColonToken */; + } + ts.isColonToken = isColonToken; + /*@internal*/ + function isQuestionDotToken(node) { + return node.kind === 28 /* SyntaxKind.QuestionDotToken */; + } + ts.isQuestionDotToken = isQuestionDotToken; + /*@internal*/ + function isEqualsGreaterThanToken(node) { + return node.kind === 38 /* SyntaxKind.EqualsGreaterThanToken */; + } + ts.isEqualsGreaterThanToken = isEqualsGreaterThanToken; + // Identifiers + function isIdentifier(node) { + return node.kind === 79 /* SyntaxKind.Identifier */; + } + ts.isIdentifier = isIdentifier; + function isPrivateIdentifier(node) { + return node.kind === 80 /* SyntaxKind.PrivateIdentifier */; + } + ts.isPrivateIdentifier = isPrivateIdentifier; + // Reserved Words + /* @internal */ + function isExportModifier(node) { + return node.kind === 93 /* SyntaxKind.ExportKeyword */; + } + ts.isExportModifier = isExportModifier; + /* @internal */ + function isAsyncModifier(node) { + return node.kind === 132 /* SyntaxKind.AsyncKeyword */; + } + ts.isAsyncModifier = isAsyncModifier; + /* @internal */ + function isAssertsKeyword(node) { + return node.kind === 129 /* SyntaxKind.AssertsKeyword */; + } + ts.isAssertsKeyword = isAssertsKeyword; + /* @internal */ + function isAwaitKeyword(node) { + return node.kind === 133 /* SyntaxKind.AwaitKeyword */; + } + ts.isAwaitKeyword = isAwaitKeyword; + /* @internal */ + function isReadonlyKeyword(node) { + return node.kind === 146 /* SyntaxKind.ReadonlyKeyword */; + } + ts.isReadonlyKeyword = isReadonlyKeyword; + /* @internal */ + function isStaticModifier(node) { + return node.kind === 124 /* SyntaxKind.StaticKeyword */; + } + ts.isStaticModifier = isStaticModifier; + /* @internal */ + function isAbstractModifier(node) { + return node.kind === 126 /* SyntaxKind.AbstractKeyword */; + } + ts.isAbstractModifier = isAbstractModifier; + /* @internal */ + function isOverrideModifier(node) { + return node.kind === 161 /* SyntaxKind.OverrideKeyword */; + } + ts.isOverrideModifier = isOverrideModifier; + /* @internal */ + function isAccessorModifier(node) { + return node.kind === 127 /* SyntaxKind.AccessorKeyword */; + } + ts.isAccessorModifier = isAccessorModifier; + /*@internal*/ + function isSuperKeyword(node) { + return node.kind === 106 /* SyntaxKind.SuperKeyword */; + } + ts.isSuperKeyword = isSuperKeyword; + /*@internal*/ + function isImportKeyword(node) { + return node.kind === 100 /* SyntaxKind.ImportKeyword */; + } + ts.isImportKeyword = isImportKeyword; + // Names + function isQualifiedName(node) { + return node.kind === 163 /* SyntaxKind.QualifiedName */; + } + ts.isQualifiedName = isQualifiedName; + function isComputedPropertyName(node) { + return node.kind === 164 /* SyntaxKind.ComputedPropertyName */; + } + ts.isComputedPropertyName = isComputedPropertyName; + // Signature elements + function isTypeParameterDeclaration(node) { + return node.kind === 165 /* SyntaxKind.TypeParameter */; + } + ts.isTypeParameterDeclaration = isTypeParameterDeclaration; + // TODO(rbuckton): Rename to 'isParameterDeclaration' + function isParameter(node) { + return node.kind === 166 /* SyntaxKind.Parameter */; + } + ts.isParameter = isParameter; + function isDecorator(node) { + return node.kind === 167 /* SyntaxKind.Decorator */; + } + ts.isDecorator = isDecorator; + // TypeMember + function isPropertySignature(node) { + return node.kind === 168 /* SyntaxKind.PropertySignature */; + } + ts.isPropertySignature = isPropertySignature; + function isPropertyDeclaration(node) { + return node.kind === 169 /* SyntaxKind.PropertyDeclaration */; + } + ts.isPropertyDeclaration = isPropertyDeclaration; + function isMethodSignature(node) { + return node.kind === 170 /* SyntaxKind.MethodSignature */; + } + ts.isMethodSignature = isMethodSignature; + function isMethodDeclaration(node) { + return node.kind === 171 /* SyntaxKind.MethodDeclaration */; + } + ts.isMethodDeclaration = isMethodDeclaration; + function isClassStaticBlockDeclaration(node) { + return node.kind === 172 /* SyntaxKind.ClassStaticBlockDeclaration */; + } + ts.isClassStaticBlockDeclaration = isClassStaticBlockDeclaration; + function isConstructorDeclaration(node) { + return node.kind === 173 /* SyntaxKind.Constructor */; + } + ts.isConstructorDeclaration = isConstructorDeclaration; + function isGetAccessorDeclaration(node) { + return node.kind === 174 /* SyntaxKind.GetAccessor */; + } + ts.isGetAccessorDeclaration = isGetAccessorDeclaration; + function isSetAccessorDeclaration(node) { + return node.kind === 175 /* SyntaxKind.SetAccessor */; + } + ts.isSetAccessorDeclaration = isSetAccessorDeclaration; + function isCallSignatureDeclaration(node) { + return node.kind === 176 /* SyntaxKind.CallSignature */; + } + ts.isCallSignatureDeclaration = isCallSignatureDeclaration; + function isConstructSignatureDeclaration(node) { + return node.kind === 177 /* SyntaxKind.ConstructSignature */; + } + ts.isConstructSignatureDeclaration = isConstructSignatureDeclaration; + function isIndexSignatureDeclaration(node) { + return node.kind === 178 /* SyntaxKind.IndexSignature */; + } + ts.isIndexSignatureDeclaration = isIndexSignatureDeclaration; + // Type + function isTypePredicateNode(node) { + return node.kind === 179 /* SyntaxKind.TypePredicate */; + } + ts.isTypePredicateNode = isTypePredicateNode; + function isTypeReferenceNode(node) { + return node.kind === 180 /* SyntaxKind.TypeReference */; + } + ts.isTypeReferenceNode = isTypeReferenceNode; + function isFunctionTypeNode(node) { + return node.kind === 181 /* SyntaxKind.FunctionType */; + } + ts.isFunctionTypeNode = isFunctionTypeNode; + function isConstructorTypeNode(node) { + return node.kind === 182 /* SyntaxKind.ConstructorType */; + } + ts.isConstructorTypeNode = isConstructorTypeNode; + function isTypeQueryNode(node) { + return node.kind === 183 /* SyntaxKind.TypeQuery */; + } + ts.isTypeQueryNode = isTypeQueryNode; + function isTypeLiteralNode(node) { + return node.kind === 184 /* SyntaxKind.TypeLiteral */; + } + ts.isTypeLiteralNode = isTypeLiteralNode; + function isArrayTypeNode(node) { + return node.kind === 185 /* SyntaxKind.ArrayType */; + } + ts.isArrayTypeNode = isArrayTypeNode; + function isTupleTypeNode(node) { + return node.kind === 186 /* SyntaxKind.TupleType */; + } + ts.isTupleTypeNode = isTupleTypeNode; + function isNamedTupleMember(node) { + return node.kind === 199 /* SyntaxKind.NamedTupleMember */; + } + ts.isNamedTupleMember = isNamedTupleMember; + function isOptionalTypeNode(node) { + return node.kind === 187 /* SyntaxKind.OptionalType */; + } + ts.isOptionalTypeNode = isOptionalTypeNode; + function isRestTypeNode(node) { + return node.kind === 188 /* SyntaxKind.RestType */; + } + ts.isRestTypeNode = isRestTypeNode; + function isUnionTypeNode(node) { + return node.kind === 189 /* SyntaxKind.UnionType */; + } + ts.isUnionTypeNode = isUnionTypeNode; + function isIntersectionTypeNode(node) { + return node.kind === 190 /* SyntaxKind.IntersectionType */; + } + ts.isIntersectionTypeNode = isIntersectionTypeNode; + function isConditionalTypeNode(node) { + return node.kind === 191 /* SyntaxKind.ConditionalType */; + } + ts.isConditionalTypeNode = isConditionalTypeNode; + function isInferTypeNode(node) { + return node.kind === 192 /* SyntaxKind.InferType */; + } + ts.isInferTypeNode = isInferTypeNode; + function isParenthesizedTypeNode(node) { + return node.kind === 193 /* SyntaxKind.ParenthesizedType */; + } + ts.isParenthesizedTypeNode = isParenthesizedTypeNode; + function isThisTypeNode(node) { + return node.kind === 194 /* SyntaxKind.ThisType */; + } + ts.isThisTypeNode = isThisTypeNode; + function isTypeOperatorNode(node) { + return node.kind === 195 /* SyntaxKind.TypeOperator */; + } + ts.isTypeOperatorNode = isTypeOperatorNode; + function isIndexedAccessTypeNode(node) { + return node.kind === 196 /* SyntaxKind.IndexedAccessType */; + } + ts.isIndexedAccessTypeNode = isIndexedAccessTypeNode; + function isMappedTypeNode(node) { + return node.kind === 197 /* SyntaxKind.MappedType */; + } + ts.isMappedTypeNode = isMappedTypeNode; + function isLiteralTypeNode(node) { + return node.kind === 198 /* SyntaxKind.LiteralType */; + } + ts.isLiteralTypeNode = isLiteralTypeNode; + function isImportTypeNode(node) { + return node.kind === 202 /* SyntaxKind.ImportType */; + } + ts.isImportTypeNode = isImportTypeNode; + function isTemplateLiteralTypeSpan(node) { + return node.kind === 201 /* SyntaxKind.TemplateLiteralTypeSpan */; + } + ts.isTemplateLiteralTypeSpan = isTemplateLiteralTypeSpan; + function isTemplateLiteralTypeNode(node) { + return node.kind === 200 /* SyntaxKind.TemplateLiteralType */; + } + ts.isTemplateLiteralTypeNode = isTemplateLiteralTypeNode; + // Binding patterns + function isObjectBindingPattern(node) { + return node.kind === 203 /* SyntaxKind.ObjectBindingPattern */; + } + ts.isObjectBindingPattern = isObjectBindingPattern; + function isArrayBindingPattern(node) { + return node.kind === 204 /* SyntaxKind.ArrayBindingPattern */; + } + ts.isArrayBindingPattern = isArrayBindingPattern; + function isBindingElement(node) { + return node.kind === 205 /* SyntaxKind.BindingElement */; + } + ts.isBindingElement = isBindingElement; + // Expression + function isArrayLiteralExpression(node) { + return node.kind === 206 /* SyntaxKind.ArrayLiteralExpression */; + } + ts.isArrayLiteralExpression = isArrayLiteralExpression; + function isObjectLiteralExpression(node) { + return node.kind === 207 /* SyntaxKind.ObjectLiteralExpression */; + } + ts.isObjectLiteralExpression = isObjectLiteralExpression; + function isPropertyAccessExpression(node) { + return node.kind === 208 /* SyntaxKind.PropertyAccessExpression */; + } + ts.isPropertyAccessExpression = isPropertyAccessExpression; + function isElementAccessExpression(node) { + return node.kind === 209 /* SyntaxKind.ElementAccessExpression */; + } + ts.isElementAccessExpression = isElementAccessExpression; + function isCallExpression(node) { + return node.kind === 210 /* SyntaxKind.CallExpression */; + } + ts.isCallExpression = isCallExpression; + function isNewExpression(node) { + return node.kind === 211 /* SyntaxKind.NewExpression */; + } + ts.isNewExpression = isNewExpression; + function isTaggedTemplateExpression(node) { + return node.kind === 212 /* SyntaxKind.TaggedTemplateExpression */; + } + ts.isTaggedTemplateExpression = isTaggedTemplateExpression; + function isTypeAssertionExpression(node) { + return node.kind === 213 /* SyntaxKind.TypeAssertionExpression */; + } + ts.isTypeAssertionExpression = isTypeAssertionExpression; + function isParenthesizedExpression(node) { + return node.kind === 214 /* SyntaxKind.ParenthesizedExpression */; + } + ts.isParenthesizedExpression = isParenthesizedExpression; + function isFunctionExpression(node) { + return node.kind === 215 /* SyntaxKind.FunctionExpression */; + } + ts.isFunctionExpression = isFunctionExpression; + function isArrowFunction(node) { + return node.kind === 216 /* SyntaxKind.ArrowFunction */; + } + ts.isArrowFunction = isArrowFunction; + function isDeleteExpression(node) { + return node.kind === 217 /* SyntaxKind.DeleteExpression */; + } + ts.isDeleteExpression = isDeleteExpression; + function isTypeOfExpression(node) { + return node.kind === 218 /* SyntaxKind.TypeOfExpression */; + } + ts.isTypeOfExpression = isTypeOfExpression; + function isVoidExpression(node) { + return node.kind === 219 /* SyntaxKind.VoidExpression */; + } + ts.isVoidExpression = isVoidExpression; + function isAwaitExpression(node) { + return node.kind === 220 /* SyntaxKind.AwaitExpression */; + } + ts.isAwaitExpression = isAwaitExpression; + function isPrefixUnaryExpression(node) { + return node.kind === 221 /* SyntaxKind.PrefixUnaryExpression */; + } + ts.isPrefixUnaryExpression = isPrefixUnaryExpression; + function isPostfixUnaryExpression(node) { + return node.kind === 222 /* SyntaxKind.PostfixUnaryExpression */; + } + ts.isPostfixUnaryExpression = isPostfixUnaryExpression; + function isBinaryExpression(node) { + return node.kind === 223 /* SyntaxKind.BinaryExpression */; + } + ts.isBinaryExpression = isBinaryExpression; + function isConditionalExpression(node) { + return node.kind === 224 /* SyntaxKind.ConditionalExpression */; + } + ts.isConditionalExpression = isConditionalExpression; + function isTemplateExpression(node) { + return node.kind === 225 /* SyntaxKind.TemplateExpression */; + } + ts.isTemplateExpression = isTemplateExpression; + function isYieldExpression(node) { + return node.kind === 226 /* SyntaxKind.YieldExpression */; + } + ts.isYieldExpression = isYieldExpression; + function isSpreadElement(node) { + return node.kind === 227 /* SyntaxKind.SpreadElement */; + } + ts.isSpreadElement = isSpreadElement; + function isClassExpression(node) { + return node.kind === 228 /* SyntaxKind.ClassExpression */; + } + ts.isClassExpression = isClassExpression; + function isOmittedExpression(node) { + return node.kind === 229 /* SyntaxKind.OmittedExpression */; + } + ts.isOmittedExpression = isOmittedExpression; + function isExpressionWithTypeArguments(node) { + return node.kind === 230 /* SyntaxKind.ExpressionWithTypeArguments */; + } + ts.isExpressionWithTypeArguments = isExpressionWithTypeArguments; + function isAsExpression(node) { + return node.kind === 231 /* SyntaxKind.AsExpression */; + } + ts.isAsExpression = isAsExpression; + function isSatisfiesExpression(node) { + return node.kind === 235 /* SyntaxKind.SatisfiesExpression */; + } + ts.isSatisfiesExpression = isSatisfiesExpression; + function isNonNullExpression(node) { + return node.kind === 232 /* SyntaxKind.NonNullExpression */; + } + ts.isNonNullExpression = isNonNullExpression; + function isMetaProperty(node) { + return node.kind === 233 /* SyntaxKind.MetaProperty */; + } + ts.isMetaProperty = isMetaProperty; + function isSyntheticExpression(node) { + return node.kind === 234 /* SyntaxKind.SyntheticExpression */; + } + ts.isSyntheticExpression = isSyntheticExpression; + function isPartiallyEmittedExpression(node) { + return node.kind === 353 /* SyntaxKind.PartiallyEmittedExpression */; + } + ts.isPartiallyEmittedExpression = isPartiallyEmittedExpression; + function isCommaListExpression(node) { + return node.kind === 354 /* SyntaxKind.CommaListExpression */; + } + ts.isCommaListExpression = isCommaListExpression; + // Misc + function isTemplateSpan(node) { + return node.kind === 236 /* SyntaxKind.TemplateSpan */; + } + ts.isTemplateSpan = isTemplateSpan; + function isSemicolonClassElement(node) { + return node.kind === 237 /* SyntaxKind.SemicolonClassElement */; + } + ts.isSemicolonClassElement = isSemicolonClassElement; + // Elements + function isBlock(node) { + return node.kind === 238 /* SyntaxKind.Block */; + } + ts.isBlock = isBlock; + function isVariableStatement(node) { + return node.kind === 240 /* SyntaxKind.VariableStatement */; + } + ts.isVariableStatement = isVariableStatement; + function isEmptyStatement(node) { + return node.kind === 239 /* SyntaxKind.EmptyStatement */; + } + ts.isEmptyStatement = isEmptyStatement; + function isExpressionStatement(node) { + return node.kind === 241 /* SyntaxKind.ExpressionStatement */; + } + ts.isExpressionStatement = isExpressionStatement; + function isIfStatement(node) { + return node.kind === 242 /* SyntaxKind.IfStatement */; + } + ts.isIfStatement = isIfStatement; + function isDoStatement(node) { + return node.kind === 243 /* SyntaxKind.DoStatement */; + } + ts.isDoStatement = isDoStatement; + function isWhileStatement(node) { + return node.kind === 244 /* SyntaxKind.WhileStatement */; + } + ts.isWhileStatement = isWhileStatement; + function isForStatement(node) { + return node.kind === 245 /* SyntaxKind.ForStatement */; + } + ts.isForStatement = isForStatement; + function isForInStatement(node) { + return node.kind === 246 /* SyntaxKind.ForInStatement */; + } + ts.isForInStatement = isForInStatement; + function isForOfStatement(node) { + return node.kind === 247 /* SyntaxKind.ForOfStatement */; + } + ts.isForOfStatement = isForOfStatement; + function isContinueStatement(node) { + return node.kind === 248 /* SyntaxKind.ContinueStatement */; + } + ts.isContinueStatement = isContinueStatement; + function isBreakStatement(node) { + return node.kind === 249 /* SyntaxKind.BreakStatement */; + } + ts.isBreakStatement = isBreakStatement; + function isReturnStatement(node) { + return node.kind === 250 /* SyntaxKind.ReturnStatement */; + } + ts.isReturnStatement = isReturnStatement; + function isWithStatement(node) { + return node.kind === 251 /* SyntaxKind.WithStatement */; + } + ts.isWithStatement = isWithStatement; + function isSwitchStatement(node) { + return node.kind === 252 /* SyntaxKind.SwitchStatement */; + } + ts.isSwitchStatement = isSwitchStatement; + function isLabeledStatement(node) { + return node.kind === 253 /* SyntaxKind.LabeledStatement */; + } + ts.isLabeledStatement = isLabeledStatement; + function isThrowStatement(node) { + return node.kind === 254 /* SyntaxKind.ThrowStatement */; + } + ts.isThrowStatement = isThrowStatement; + function isTryStatement(node) { + return node.kind === 255 /* SyntaxKind.TryStatement */; + } + ts.isTryStatement = isTryStatement; + function isDebuggerStatement(node) { + return node.kind === 256 /* SyntaxKind.DebuggerStatement */; + } + ts.isDebuggerStatement = isDebuggerStatement; + function isVariableDeclaration(node) { + return node.kind === 257 /* SyntaxKind.VariableDeclaration */; + } + ts.isVariableDeclaration = isVariableDeclaration; + function isVariableDeclarationList(node) { + return node.kind === 258 /* SyntaxKind.VariableDeclarationList */; + } + ts.isVariableDeclarationList = isVariableDeclarationList; + function isFunctionDeclaration(node) { + return node.kind === 259 /* SyntaxKind.FunctionDeclaration */; + } + ts.isFunctionDeclaration = isFunctionDeclaration; + function isClassDeclaration(node) { + return node.kind === 260 /* SyntaxKind.ClassDeclaration */; + } + ts.isClassDeclaration = isClassDeclaration; + function isInterfaceDeclaration(node) { + return node.kind === 261 /* SyntaxKind.InterfaceDeclaration */; + } + ts.isInterfaceDeclaration = isInterfaceDeclaration; + function isTypeAliasDeclaration(node) { + return node.kind === 262 /* SyntaxKind.TypeAliasDeclaration */; + } + ts.isTypeAliasDeclaration = isTypeAliasDeclaration; + function isEnumDeclaration(node) { + return node.kind === 263 /* SyntaxKind.EnumDeclaration */; + } + ts.isEnumDeclaration = isEnumDeclaration; + function isModuleDeclaration(node) { + return node.kind === 264 /* SyntaxKind.ModuleDeclaration */; + } + ts.isModuleDeclaration = isModuleDeclaration; + function isModuleBlock(node) { + return node.kind === 265 /* SyntaxKind.ModuleBlock */; + } + ts.isModuleBlock = isModuleBlock; + function isCaseBlock(node) { + return node.kind === 266 /* SyntaxKind.CaseBlock */; + } + ts.isCaseBlock = isCaseBlock; + function isNamespaceExportDeclaration(node) { + return node.kind === 267 /* SyntaxKind.NamespaceExportDeclaration */; + } + ts.isNamespaceExportDeclaration = isNamespaceExportDeclaration; + function isImportEqualsDeclaration(node) { + return node.kind === 268 /* SyntaxKind.ImportEqualsDeclaration */; + } + ts.isImportEqualsDeclaration = isImportEqualsDeclaration; + function isImportDeclaration(node) { + return node.kind === 269 /* SyntaxKind.ImportDeclaration */; + } + ts.isImportDeclaration = isImportDeclaration; + function isImportClause(node) { + return node.kind === 270 /* SyntaxKind.ImportClause */; + } + ts.isImportClause = isImportClause; + function isImportTypeAssertionContainer(node) { + return node.kind === 298 /* SyntaxKind.ImportTypeAssertionContainer */; + } + ts.isImportTypeAssertionContainer = isImportTypeAssertionContainer; + function isAssertClause(node) { + return node.kind === 296 /* SyntaxKind.AssertClause */; + } + ts.isAssertClause = isAssertClause; + function isAssertEntry(node) { + return node.kind === 297 /* SyntaxKind.AssertEntry */; + } + ts.isAssertEntry = isAssertEntry; + function isNamespaceImport(node) { + return node.kind === 271 /* SyntaxKind.NamespaceImport */; + } + ts.isNamespaceImport = isNamespaceImport; + function isNamespaceExport(node) { + return node.kind === 277 /* SyntaxKind.NamespaceExport */; + } + ts.isNamespaceExport = isNamespaceExport; + function isNamedImports(node) { + return node.kind === 272 /* SyntaxKind.NamedImports */; + } + ts.isNamedImports = isNamedImports; + function isImportSpecifier(node) { + return node.kind === 273 /* SyntaxKind.ImportSpecifier */; + } + ts.isImportSpecifier = isImportSpecifier; + function isExportAssignment(node) { + return node.kind === 274 /* SyntaxKind.ExportAssignment */; + } + ts.isExportAssignment = isExportAssignment; + function isExportDeclaration(node) { + return node.kind === 275 /* SyntaxKind.ExportDeclaration */; + } + ts.isExportDeclaration = isExportDeclaration; + function isNamedExports(node) { + return node.kind === 276 /* SyntaxKind.NamedExports */; + } + ts.isNamedExports = isNamedExports; + function isExportSpecifier(node) { + return node.kind === 278 /* SyntaxKind.ExportSpecifier */; + } + ts.isExportSpecifier = isExportSpecifier; + function isMissingDeclaration(node) { + return node.kind === 279 /* SyntaxKind.MissingDeclaration */; + } + ts.isMissingDeclaration = isMissingDeclaration; + function isNotEmittedStatement(node) { + return node.kind === 352 /* SyntaxKind.NotEmittedStatement */; + } + ts.isNotEmittedStatement = isNotEmittedStatement; + /* @internal */ + function isSyntheticReference(node) { + return node.kind === 357 /* SyntaxKind.SyntheticReferenceExpression */; + } + ts.isSyntheticReference = isSyntheticReference; + /* @internal */ + function isMergeDeclarationMarker(node) { + return node.kind === 355 /* SyntaxKind.MergeDeclarationMarker */; + } + ts.isMergeDeclarationMarker = isMergeDeclarationMarker; + /* @internal */ + function isEndOfDeclarationMarker(node) { + return node.kind === 356 /* SyntaxKind.EndOfDeclarationMarker */; + } + ts.isEndOfDeclarationMarker = isEndOfDeclarationMarker; + // Module References + function isExternalModuleReference(node) { + return node.kind === 280 /* SyntaxKind.ExternalModuleReference */; + } + ts.isExternalModuleReference = isExternalModuleReference; + // JSX + function isJsxElement(node) { + return node.kind === 281 /* SyntaxKind.JsxElement */; + } + ts.isJsxElement = isJsxElement; + function isJsxSelfClosingElement(node) { + return node.kind === 282 /* SyntaxKind.JsxSelfClosingElement */; + } + ts.isJsxSelfClosingElement = isJsxSelfClosingElement; + function isJsxOpeningElement(node) { + return node.kind === 283 /* SyntaxKind.JsxOpeningElement */; + } + ts.isJsxOpeningElement = isJsxOpeningElement; + function isJsxClosingElement(node) { + return node.kind === 284 /* SyntaxKind.JsxClosingElement */; + } + ts.isJsxClosingElement = isJsxClosingElement; + function isJsxFragment(node) { + return node.kind === 285 /* SyntaxKind.JsxFragment */; + } + ts.isJsxFragment = isJsxFragment; + function isJsxOpeningFragment(node) { + return node.kind === 286 /* SyntaxKind.JsxOpeningFragment */; + } + ts.isJsxOpeningFragment = isJsxOpeningFragment; + function isJsxClosingFragment(node) { + return node.kind === 287 /* SyntaxKind.JsxClosingFragment */; + } + ts.isJsxClosingFragment = isJsxClosingFragment; + function isJsxAttribute(node) { + return node.kind === 288 /* SyntaxKind.JsxAttribute */; + } + ts.isJsxAttribute = isJsxAttribute; + function isJsxAttributes(node) { + return node.kind === 289 /* SyntaxKind.JsxAttributes */; + } + ts.isJsxAttributes = isJsxAttributes; + function isJsxSpreadAttribute(node) { + return node.kind === 290 /* SyntaxKind.JsxSpreadAttribute */; + } + ts.isJsxSpreadAttribute = isJsxSpreadAttribute; + function isJsxExpression(node) { + return node.kind === 291 /* SyntaxKind.JsxExpression */; + } + ts.isJsxExpression = isJsxExpression; + // Clauses + function isCaseClause(node) { + return node.kind === 292 /* SyntaxKind.CaseClause */; + } + ts.isCaseClause = isCaseClause; + function isDefaultClause(node) { + return node.kind === 293 /* SyntaxKind.DefaultClause */; + } + ts.isDefaultClause = isDefaultClause; + function isHeritageClause(node) { + return node.kind === 294 /* SyntaxKind.HeritageClause */; + } + ts.isHeritageClause = isHeritageClause; + function isCatchClause(node) { + return node.kind === 295 /* SyntaxKind.CatchClause */; + } + ts.isCatchClause = isCatchClause; + // Property assignments + function isPropertyAssignment(node) { + return node.kind === 299 /* SyntaxKind.PropertyAssignment */; + } + ts.isPropertyAssignment = isPropertyAssignment; + function isShorthandPropertyAssignment(node) { + return node.kind === 300 /* SyntaxKind.ShorthandPropertyAssignment */; + } + ts.isShorthandPropertyAssignment = isShorthandPropertyAssignment; + function isSpreadAssignment(node) { + return node.kind === 301 /* SyntaxKind.SpreadAssignment */; + } + ts.isSpreadAssignment = isSpreadAssignment; + // Enum + function isEnumMember(node) { + return node.kind === 302 /* SyntaxKind.EnumMember */; + } + ts.isEnumMember = isEnumMember; + // Unparsed + // TODO(rbuckton): isUnparsedPrologue + function isUnparsedPrepend(node) { + return node.kind === 304 /* SyntaxKind.UnparsedPrepend */; + } + ts.isUnparsedPrepend = isUnparsedPrepend; + // TODO(rbuckton): isUnparsedText + // TODO(rbuckton): isUnparsedInternalText + // TODO(rbuckton): isUnparsedSyntheticReference + // Top-level nodes + function isSourceFile(node) { + return node.kind === 308 /* SyntaxKind.SourceFile */; + } + ts.isSourceFile = isSourceFile; + function isBundle(node) { + return node.kind === 309 /* SyntaxKind.Bundle */; + } + ts.isBundle = isBundle; + function isUnparsedSource(node) { + return node.kind === 310 /* SyntaxKind.UnparsedSource */; + } + ts.isUnparsedSource = isUnparsedSource; + // TODO(rbuckton): isInputFiles + // JSDoc Elements + function isJSDocTypeExpression(node) { + return node.kind === 312 /* SyntaxKind.JSDocTypeExpression */; + } + ts.isJSDocTypeExpression = isJSDocTypeExpression; + function isJSDocNameReference(node) { + return node.kind === 313 /* SyntaxKind.JSDocNameReference */; + } + ts.isJSDocNameReference = isJSDocNameReference; + function isJSDocMemberName(node) { + return node.kind === 314 /* SyntaxKind.JSDocMemberName */; + } + ts.isJSDocMemberName = isJSDocMemberName; + function isJSDocLink(node) { + return node.kind === 327 /* SyntaxKind.JSDocLink */; + } + ts.isJSDocLink = isJSDocLink; + function isJSDocLinkCode(node) { + return node.kind === 328 /* SyntaxKind.JSDocLinkCode */; + } + ts.isJSDocLinkCode = isJSDocLinkCode; + function isJSDocLinkPlain(node) { + return node.kind === 329 /* SyntaxKind.JSDocLinkPlain */; + } + ts.isJSDocLinkPlain = isJSDocLinkPlain; + function isJSDocAllType(node) { + return node.kind === 315 /* SyntaxKind.JSDocAllType */; + } + ts.isJSDocAllType = isJSDocAllType; + function isJSDocUnknownType(node) { + return node.kind === 316 /* SyntaxKind.JSDocUnknownType */; + } + ts.isJSDocUnknownType = isJSDocUnknownType; + function isJSDocNullableType(node) { + return node.kind === 317 /* SyntaxKind.JSDocNullableType */; + } + ts.isJSDocNullableType = isJSDocNullableType; + function isJSDocNonNullableType(node) { + return node.kind === 318 /* SyntaxKind.JSDocNonNullableType */; + } + ts.isJSDocNonNullableType = isJSDocNonNullableType; + function isJSDocOptionalType(node) { + return node.kind === 319 /* SyntaxKind.JSDocOptionalType */; + } + ts.isJSDocOptionalType = isJSDocOptionalType; + function isJSDocFunctionType(node) { + return node.kind === 320 /* SyntaxKind.JSDocFunctionType */; + } + ts.isJSDocFunctionType = isJSDocFunctionType; + function isJSDocVariadicType(node) { + return node.kind === 321 /* SyntaxKind.JSDocVariadicType */; + } + ts.isJSDocVariadicType = isJSDocVariadicType; + function isJSDocNamepathType(node) { + return node.kind === 322 /* SyntaxKind.JSDocNamepathType */; + } + ts.isJSDocNamepathType = isJSDocNamepathType; + function isJSDoc(node) { + return node.kind === 323 /* SyntaxKind.JSDoc */; + } + ts.isJSDoc = isJSDoc; + function isJSDocTypeLiteral(node) { + return node.kind === 325 /* SyntaxKind.JSDocTypeLiteral */; + } + ts.isJSDocTypeLiteral = isJSDocTypeLiteral; + function isJSDocSignature(node) { + return node.kind === 326 /* SyntaxKind.JSDocSignature */; + } + ts.isJSDocSignature = isJSDocSignature; + // JSDoc Tags + function isJSDocAugmentsTag(node) { + return node.kind === 331 /* SyntaxKind.JSDocAugmentsTag */; + } + ts.isJSDocAugmentsTag = isJSDocAugmentsTag; + function isJSDocAuthorTag(node) { + return node.kind === 333 /* SyntaxKind.JSDocAuthorTag */; + } + ts.isJSDocAuthorTag = isJSDocAuthorTag; + function isJSDocClassTag(node) { + return node.kind === 335 /* SyntaxKind.JSDocClassTag */; + } + ts.isJSDocClassTag = isJSDocClassTag; + function isJSDocCallbackTag(node) { + return node.kind === 341 /* SyntaxKind.JSDocCallbackTag */; + } + ts.isJSDocCallbackTag = isJSDocCallbackTag; + function isJSDocPublicTag(node) { + return node.kind === 336 /* SyntaxKind.JSDocPublicTag */; + } + ts.isJSDocPublicTag = isJSDocPublicTag; + function isJSDocPrivateTag(node) { + return node.kind === 337 /* SyntaxKind.JSDocPrivateTag */; + } + ts.isJSDocPrivateTag = isJSDocPrivateTag; + function isJSDocProtectedTag(node) { + return node.kind === 338 /* SyntaxKind.JSDocProtectedTag */; + } + ts.isJSDocProtectedTag = isJSDocProtectedTag; + function isJSDocReadonlyTag(node) { + return node.kind === 339 /* SyntaxKind.JSDocReadonlyTag */; + } + ts.isJSDocReadonlyTag = isJSDocReadonlyTag; + function isJSDocOverrideTag(node) { + return node.kind === 340 /* SyntaxKind.JSDocOverrideTag */; + } + ts.isJSDocOverrideTag = isJSDocOverrideTag; + function isJSDocDeprecatedTag(node) { + return node.kind === 334 /* SyntaxKind.JSDocDeprecatedTag */; + } + ts.isJSDocDeprecatedTag = isJSDocDeprecatedTag; + function isJSDocSeeTag(node) { + return node.kind === 349 /* SyntaxKind.JSDocSeeTag */; + } + ts.isJSDocSeeTag = isJSDocSeeTag; + function isJSDocEnumTag(node) { + return node.kind === 342 /* SyntaxKind.JSDocEnumTag */; + } + ts.isJSDocEnumTag = isJSDocEnumTag; + function isJSDocParameterTag(node) { + return node.kind === 343 /* SyntaxKind.JSDocParameterTag */; + } + ts.isJSDocParameterTag = isJSDocParameterTag; + function isJSDocReturnTag(node) { + return node.kind === 344 /* SyntaxKind.JSDocReturnTag */; + } + ts.isJSDocReturnTag = isJSDocReturnTag; + function isJSDocThisTag(node) { + return node.kind === 345 /* SyntaxKind.JSDocThisTag */; + } + ts.isJSDocThisTag = isJSDocThisTag; + function isJSDocTypeTag(node) { + return node.kind === 346 /* SyntaxKind.JSDocTypeTag */; + } + ts.isJSDocTypeTag = isJSDocTypeTag; + function isJSDocTemplateTag(node) { + return node.kind === 347 /* SyntaxKind.JSDocTemplateTag */; + } + ts.isJSDocTemplateTag = isJSDocTemplateTag; + function isJSDocTypedefTag(node) { + return node.kind === 348 /* SyntaxKind.JSDocTypedefTag */; + } + ts.isJSDocTypedefTag = isJSDocTypedefTag; + function isJSDocUnknownTag(node) { + return node.kind === 330 /* SyntaxKind.JSDocTag */; + } + ts.isJSDocUnknownTag = isJSDocUnknownTag; + function isJSDocPropertyTag(node) { + return node.kind === 350 /* SyntaxKind.JSDocPropertyTag */; + } + ts.isJSDocPropertyTag = isJSDocPropertyTag; + function isJSDocImplementsTag(node) { + return node.kind === 332 /* SyntaxKind.JSDocImplementsTag */; + } + ts.isJSDocImplementsTag = isJSDocImplementsTag; + // Synthesized list + /* @internal */ + function isSyntaxList(n) { + return n.kind === 351 /* SyntaxKind.SyntaxList */; + } + ts.isSyntaxList = isSyntaxList; +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + // Compound nodes + function createEmptyExports(factory) { + return factory.createExportDeclaration(/*modifiers*/ undefined, /*isTypeOnly*/ false, factory.createNamedExports([]), /*moduleSpecifier*/ undefined); + } + ts.createEmptyExports = createEmptyExports; + function createMemberAccessForPropertyName(factory, target, memberName, location) { + if (ts.isComputedPropertyName(memberName)) { + return ts.setTextRange(factory.createElementAccessExpression(target, memberName.expression), location); + } + else { + var expression = ts.setTextRange(ts.isMemberName(memberName) + ? factory.createPropertyAccessExpression(target, memberName) + : factory.createElementAccessExpression(target, memberName), memberName); + ts.getOrCreateEmitNode(expression).flags |= 64 /* EmitFlags.NoNestedSourceMaps */; + return expression; + } + } + ts.createMemberAccessForPropertyName = createMemberAccessForPropertyName; + function createReactNamespace(reactNamespace, parent) { + // To ensure the emit resolver can properly resolve the namespace, we need to + // treat this identifier as if it were a source tree node by clearing the `Synthesized` + // flag and setting a parent node. + var react = ts.parseNodeFactory.createIdentifier(reactNamespace || "React"); + // Set the parent that is in parse tree + // this makes sure that parent chain is intact for checker to traverse complete scope tree + ts.setParent(react, ts.getParseTreeNode(parent)); + return react; + } + function createJsxFactoryExpressionFromEntityName(factory, jsxFactory, parent) { + if (ts.isQualifiedName(jsxFactory)) { + var left = createJsxFactoryExpressionFromEntityName(factory, jsxFactory.left, parent); + var right = factory.createIdentifier(ts.idText(jsxFactory.right)); + right.escapedText = jsxFactory.right.escapedText; + return factory.createPropertyAccessExpression(left, right); + } + else { + return createReactNamespace(ts.idText(jsxFactory), parent); + } + } + function createJsxFactoryExpression(factory, jsxFactoryEntity, reactNamespace, parent) { + return jsxFactoryEntity ? + createJsxFactoryExpressionFromEntityName(factory, jsxFactoryEntity, parent) : + factory.createPropertyAccessExpression(createReactNamespace(reactNamespace, parent), "createElement"); + } + ts.createJsxFactoryExpression = createJsxFactoryExpression; + function createJsxFragmentFactoryExpression(factory, jsxFragmentFactoryEntity, reactNamespace, parent) { + return jsxFragmentFactoryEntity ? + createJsxFactoryExpressionFromEntityName(factory, jsxFragmentFactoryEntity, parent) : + factory.createPropertyAccessExpression(createReactNamespace(reactNamespace, parent), "Fragment"); + } + function createExpressionForJsxElement(factory, callee, tagName, props, children, location) { + var argumentsList = [tagName]; + if (props) { + argumentsList.push(props); + } + if (children && children.length > 0) { + if (!props) { + argumentsList.push(factory.createNull()); + } + if (children.length > 1) { + for (var _i = 0, children_3 = children; _i < children_3.length; _i++) { + var child = children_3[_i]; + startOnNewLine(child); + argumentsList.push(child); + } + } + else { + argumentsList.push(children[0]); + } + } + return ts.setTextRange(factory.createCallExpression(callee, + /*typeArguments*/ undefined, argumentsList), location); + } + ts.createExpressionForJsxElement = createExpressionForJsxElement; + function createExpressionForJsxFragment(factory, jsxFactoryEntity, jsxFragmentFactoryEntity, reactNamespace, children, parentElement, location) { + var tagName = createJsxFragmentFactoryExpression(factory, jsxFragmentFactoryEntity, reactNamespace, parentElement); + var argumentsList = [tagName, factory.createNull()]; + if (children && children.length > 0) { + if (children.length > 1) { + for (var _i = 0, children_4 = children; _i < children_4.length; _i++) { + var child = children_4[_i]; + startOnNewLine(child); + argumentsList.push(child); + } + } + else { + argumentsList.push(children[0]); + } + } + return ts.setTextRange(factory.createCallExpression(createJsxFactoryExpression(factory, jsxFactoryEntity, reactNamespace, parentElement), + /*typeArguments*/ undefined, argumentsList), location); + } + ts.createExpressionForJsxFragment = createExpressionForJsxFragment; + // Utilities + function createForOfBindingStatement(factory, node, boundValue) { + if (ts.isVariableDeclarationList(node)) { + var firstDeclaration = ts.first(node.declarations); + var updatedDeclaration = factory.updateVariableDeclaration(firstDeclaration, firstDeclaration.name, + /*exclamationToken*/ undefined, + /*type*/ undefined, boundValue); + return ts.setTextRange(factory.createVariableStatement( + /*modifiers*/ undefined, factory.updateVariableDeclarationList(node, [updatedDeclaration])), + /*location*/ node); + } + else { + var updatedExpression = ts.setTextRange(factory.createAssignment(node, boundValue), /*location*/ node); + return ts.setTextRange(factory.createExpressionStatement(updatedExpression), /*location*/ node); + } + } + ts.createForOfBindingStatement = createForOfBindingStatement; + function insertLeadingStatement(factory, dest, source) { + if (ts.isBlock(dest)) { + return factory.updateBlock(dest, ts.setTextRange(factory.createNodeArray(__spreadArray([source], dest.statements, true)), dest.statements)); + } + else { + return factory.createBlock(factory.createNodeArray([dest, source]), /*multiLine*/ true); + } + } + ts.insertLeadingStatement = insertLeadingStatement; + function createExpressionFromEntityName(factory, node) { + if (ts.isQualifiedName(node)) { + var left = createExpressionFromEntityName(factory, node.left); + // TODO(rbuckton): Does this need to be parented? + var right = ts.setParent(ts.setTextRange(factory.cloneNode(node.right), node.right), node.right.parent); + return ts.setTextRange(factory.createPropertyAccessExpression(left, right), node); + } + else { + // TODO(rbuckton): Does this need to be parented? + return ts.setParent(ts.setTextRange(factory.cloneNode(node), node), node.parent); + } + } + ts.createExpressionFromEntityName = createExpressionFromEntityName; + function createExpressionForPropertyName(factory, memberName) { + if (ts.isIdentifier(memberName)) { + return factory.createStringLiteralFromNode(memberName); + } + else if (ts.isComputedPropertyName(memberName)) { + // TODO(rbuckton): Does this need to be parented? + return ts.setParent(ts.setTextRange(factory.cloneNode(memberName.expression), memberName.expression), memberName.expression.parent); + } + else { + // TODO(rbuckton): Does this need to be parented? + return ts.setParent(ts.setTextRange(factory.cloneNode(memberName), memberName), memberName.parent); + } + } + ts.createExpressionForPropertyName = createExpressionForPropertyName; + function createExpressionForAccessorDeclaration(factory, properties, property, receiver, multiLine) { + var _a = ts.getAllAccessorDeclarations(properties, property), firstAccessor = _a.firstAccessor, getAccessor = _a.getAccessor, setAccessor = _a.setAccessor; + if (property === firstAccessor) { + return ts.setTextRange(factory.createObjectDefinePropertyCall(receiver, createExpressionForPropertyName(factory, property.name), factory.createPropertyDescriptor({ + enumerable: factory.createFalse(), + configurable: true, + get: getAccessor && ts.setTextRange(ts.setOriginalNode(factory.createFunctionExpression(ts.getModifiers(getAccessor), + /*asteriskToken*/ undefined, + /*name*/ undefined, + /*typeParameters*/ undefined, getAccessor.parameters, + /*type*/ undefined, getAccessor.body // TODO: GH#18217 + ), getAccessor), getAccessor), + set: setAccessor && ts.setTextRange(ts.setOriginalNode(factory.createFunctionExpression(ts.getModifiers(setAccessor), + /*asteriskToken*/ undefined, + /*name*/ undefined, + /*typeParameters*/ undefined, setAccessor.parameters, + /*type*/ undefined, setAccessor.body // TODO: GH#18217 + ), setAccessor), setAccessor) + }, !multiLine)), firstAccessor); + } + return undefined; + } + function createExpressionForPropertyAssignment(factory, property, receiver) { + return ts.setOriginalNode(ts.setTextRange(factory.createAssignment(createMemberAccessForPropertyName(factory, receiver, property.name, /*location*/ property.name), property.initializer), property), property); + } + function createExpressionForShorthandPropertyAssignment(factory, property, receiver) { + return ts.setOriginalNode(ts.setTextRange(factory.createAssignment(createMemberAccessForPropertyName(factory, receiver, property.name, /*location*/ property.name), factory.cloneNode(property.name)), + /*location*/ property), + /*original*/ property); + } + function createExpressionForMethodDeclaration(factory, method, receiver) { + return ts.setOriginalNode(ts.setTextRange(factory.createAssignment(createMemberAccessForPropertyName(factory, receiver, method.name, /*location*/ method.name), ts.setOriginalNode(ts.setTextRange(factory.createFunctionExpression(ts.getModifiers(method), method.asteriskToken, + /*name*/ undefined, + /*typeParameters*/ undefined, method.parameters, + /*type*/ undefined, method.body // TODO: GH#18217 + ), + /*location*/ method), + /*original*/ method)), + /*location*/ method), + /*original*/ method); + } + function createExpressionForObjectLiteralElementLike(factory, node, property, receiver) { + if (property.name && ts.isPrivateIdentifier(property.name)) { + ts.Debug.failBadSyntaxKind(property.name, "Private identifiers are not allowed in object literals."); + } + switch (property.kind) { + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + return createExpressionForAccessorDeclaration(factory, node.properties, property, receiver, !!node.multiLine); + case 299 /* SyntaxKind.PropertyAssignment */: + return createExpressionForPropertyAssignment(factory, property, receiver); + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + return createExpressionForShorthandPropertyAssignment(factory, property, receiver); + case 171 /* SyntaxKind.MethodDeclaration */: + return createExpressionForMethodDeclaration(factory, property, receiver); + } + } + ts.createExpressionForObjectLiteralElementLike = createExpressionForObjectLiteralElementLike; + /** + * Expand the read and increment/decrement operations a pre- or post-increment or pre- or post-decrement expression. + * + * ```ts + * // input + * ++ + * // output (if result is not discarded) + * var ; + * ( = , = ++, ) + * // output (if result is discarded) + * var ; + * ( = , ++, ) + * + * // input + * ++ + * // output (if result is not discarded) + * var ; + * ( = , = ++) + * // output (if result is discarded) + * var ; + * ( = , ++) + * ``` + * + * It is up to the caller to supply a temporary variable for `` if one is needed. + * The temporary variable `` is injected so that `++` and `--` work uniformly with `number` and `bigint`. + * The result of the expression is always the final result of incrementing or decrementing the expression, so that it can be used for storage. + * + * @param factory {@link NodeFactory} used to create the expanded representation. + * @param node The original prefix or postfix unary node. + * @param expression The expression to use as the value to increment or decrement + * @param resultVariable A temporary variable in which to store the result. Pass `undefined` if the result is discarded, or if the value of `` is the expected result. + */ + function expandPreOrPostfixIncrementOrDecrementExpression(factory, node, expression, recordTempVariable, resultVariable) { + var operator = node.operator; + ts.Debug.assert(operator === 45 /* SyntaxKind.PlusPlusToken */ || operator === 46 /* SyntaxKind.MinusMinusToken */, "Expected 'node' to be a pre- or post-increment or pre- or post-decrement expression"); + var temp = factory.createTempVariable(recordTempVariable); + expression = factory.createAssignment(temp, expression); + ts.setTextRange(expression, node.operand); + var operation = ts.isPrefixUnaryExpression(node) ? + factory.createPrefixUnaryExpression(operator, temp) : + factory.createPostfixUnaryExpression(temp, operator); + ts.setTextRange(operation, node); + if (resultVariable) { + operation = factory.createAssignment(resultVariable, operation); + ts.setTextRange(operation, node); + } + expression = factory.createComma(expression, operation); + ts.setTextRange(expression, node); + if (ts.isPostfixUnaryExpression(node)) { + expression = factory.createComma(expression, temp); + ts.setTextRange(expression, node); + } + return expression; + } + ts.expandPreOrPostfixIncrementOrDecrementExpression = expandPreOrPostfixIncrementOrDecrementExpression; + /** + * Gets whether an identifier should only be referred to by its internal name. + */ + function isInternalName(node) { + return (ts.getEmitFlags(node) & 32768 /* EmitFlags.InternalName */) !== 0; + } + ts.isInternalName = isInternalName; + /** + * Gets whether an identifier should only be referred to by its local name. + */ + function isLocalName(node) { + return (ts.getEmitFlags(node) & 16384 /* EmitFlags.LocalName */) !== 0; + } + ts.isLocalName = isLocalName; + /** + * Gets whether an identifier should only be referred to by its export representation if the + * name points to an exported symbol. + */ + function isExportName(node) { + return (ts.getEmitFlags(node) & 8192 /* EmitFlags.ExportName */) !== 0; + } + ts.isExportName = isExportName; + function isUseStrictPrologue(node) { + return ts.isStringLiteral(node.expression) && node.expression.text === "use strict"; + } + function findUseStrictPrologue(statements) { + for (var _i = 0, statements_1 = statements; _i < statements_1.length; _i++) { + var statement = statements_1[_i]; + if (ts.isPrologueDirective(statement)) { + if (isUseStrictPrologue(statement)) { + return statement; + } + } + else { + break; + } + } + return undefined; + } + ts.findUseStrictPrologue = findUseStrictPrologue; + function startsWithUseStrict(statements) { + var firstStatement = ts.firstOrUndefined(statements); + return firstStatement !== undefined + && ts.isPrologueDirective(firstStatement) + && isUseStrictPrologue(firstStatement); + } + ts.startsWithUseStrict = startsWithUseStrict; + function isCommaSequence(node) { + return node.kind === 223 /* SyntaxKind.BinaryExpression */ && node.operatorToken.kind === 27 /* SyntaxKind.CommaToken */ || + node.kind === 354 /* SyntaxKind.CommaListExpression */; + } + ts.isCommaSequence = isCommaSequence; + function isJSDocTypeAssertion(node) { + return ts.isParenthesizedExpression(node) + && ts.isInJSFile(node) + && !!ts.getJSDocTypeTag(node); + } + ts.isJSDocTypeAssertion = isJSDocTypeAssertion; + function getJSDocTypeAssertionType(node) { + var type = ts.getJSDocType(node); + ts.Debug.assertIsDefined(type); + return type; + } + ts.getJSDocTypeAssertionType = getJSDocTypeAssertionType; + function isOuterExpression(node, kinds) { + if (kinds === void 0) { kinds = 15 /* OuterExpressionKinds.All */; } + switch (node.kind) { + case 214 /* SyntaxKind.ParenthesizedExpression */: + if (kinds & 16 /* OuterExpressionKinds.ExcludeJSDocTypeAssertion */ && isJSDocTypeAssertion(node)) { + return false; + } + return (kinds & 1 /* OuterExpressionKinds.Parentheses */) !== 0; + case 213 /* SyntaxKind.TypeAssertionExpression */: + case 231 /* SyntaxKind.AsExpression */: + case 235 /* SyntaxKind.SatisfiesExpression */: + return (kinds & 2 /* OuterExpressionKinds.TypeAssertions */) !== 0; + case 232 /* SyntaxKind.NonNullExpression */: + return (kinds & 4 /* OuterExpressionKinds.NonNullAssertions */) !== 0; + case 353 /* SyntaxKind.PartiallyEmittedExpression */: + return (kinds & 8 /* OuterExpressionKinds.PartiallyEmittedExpressions */) !== 0; + } + return false; + } + ts.isOuterExpression = isOuterExpression; + function skipOuterExpressions(node, kinds) { + if (kinds === void 0) { kinds = 15 /* OuterExpressionKinds.All */; } + while (isOuterExpression(node, kinds)) { + node = node.expression; + } + return node; + } + ts.skipOuterExpressions = skipOuterExpressions; + function skipAssertions(node) { + return skipOuterExpressions(node, 6 /* OuterExpressionKinds.Assertions */); + } + ts.skipAssertions = skipAssertions; + function startOnNewLine(node) { + return ts.setStartsOnNewLine(node, /*newLine*/ true); + } + ts.startOnNewLine = startOnNewLine; + function getExternalHelpersModuleName(node) { + var parseNode = ts.getOriginalNode(node, ts.isSourceFile); + var emitNode = parseNode && parseNode.emitNode; + return emitNode && emitNode.externalHelpersModuleName; + } + ts.getExternalHelpersModuleName = getExternalHelpersModuleName; + function hasRecordedExternalHelpers(sourceFile) { + var parseNode = ts.getOriginalNode(sourceFile, ts.isSourceFile); + var emitNode = parseNode && parseNode.emitNode; + return !!emitNode && (!!emitNode.externalHelpersModuleName || !!emitNode.externalHelpers); + } + ts.hasRecordedExternalHelpers = hasRecordedExternalHelpers; + function createExternalHelpersImportDeclarationIfNeeded(nodeFactory, helperFactory, sourceFile, compilerOptions, hasExportStarsToExportValues, hasImportStar, hasImportDefault) { + if (compilerOptions.importHelpers && ts.isEffectiveExternalModule(sourceFile, compilerOptions)) { + var namedBindings = void 0; + var moduleKind = ts.getEmitModuleKind(compilerOptions); + if ((moduleKind >= ts.ModuleKind.ES2015 && moduleKind <= ts.ModuleKind.ESNext) || sourceFile.impliedNodeFormat === ts.ModuleKind.ESNext) { + // use named imports + var helpers = ts.getEmitHelpers(sourceFile); + if (helpers) { + var helperNames = []; + for (var _i = 0, helpers_3 = helpers; _i < helpers_3.length; _i++) { + var helper = helpers_3[_i]; + if (!helper.scoped) { + var importName = helper.importName; + if (importName) { + ts.pushIfUnique(helperNames, importName); + } + } + } + if (ts.some(helperNames)) { + helperNames.sort(ts.compareStringsCaseSensitive); + // Alias the imports if the names are used somewhere in the file. + // NOTE: We don't need to care about global import collisions as this is a module. + namedBindings = nodeFactory.createNamedImports(ts.map(helperNames, function (name) { return ts.isFileLevelUniqueName(sourceFile, name) + ? nodeFactory.createImportSpecifier(/*isTypeOnly*/ false, /*propertyName*/ undefined, nodeFactory.createIdentifier(name)) + : nodeFactory.createImportSpecifier(/*isTypeOnly*/ false, nodeFactory.createIdentifier(name), helperFactory.getUnscopedHelperName(name)); })); + var parseNode = ts.getOriginalNode(sourceFile, ts.isSourceFile); + var emitNode = ts.getOrCreateEmitNode(parseNode); + emitNode.externalHelpers = true; + } + } + } + else { + // use a namespace import + var externalHelpersModuleName = getOrCreateExternalHelpersModuleNameIfNeeded(nodeFactory, sourceFile, compilerOptions, hasExportStarsToExportValues, hasImportStar || hasImportDefault); + if (externalHelpersModuleName) { + namedBindings = nodeFactory.createNamespaceImport(externalHelpersModuleName); + } + } + if (namedBindings) { + var externalHelpersImportDeclaration = nodeFactory.createImportDeclaration( + /*modifiers*/ undefined, nodeFactory.createImportClause(/*isTypeOnly*/ false, /*name*/ undefined, namedBindings), nodeFactory.createStringLiteral(ts.externalHelpersModuleNameText), + /*assertClause*/ undefined); + ts.addEmitFlags(externalHelpersImportDeclaration, 67108864 /* EmitFlags.NeverApplyImportHelper */); + return externalHelpersImportDeclaration; + } + } + } + ts.createExternalHelpersImportDeclarationIfNeeded = createExternalHelpersImportDeclarationIfNeeded; + function getOrCreateExternalHelpersModuleNameIfNeeded(factory, node, compilerOptions, hasExportStarsToExportValues, hasImportStarOrImportDefault) { + if (compilerOptions.importHelpers && ts.isEffectiveExternalModule(node, compilerOptions)) { + var externalHelpersModuleName = getExternalHelpersModuleName(node); + if (externalHelpersModuleName) { + return externalHelpersModuleName; + } + var moduleKind = ts.getEmitModuleKind(compilerOptions); + var create = (hasExportStarsToExportValues || (ts.getESModuleInterop(compilerOptions) && hasImportStarOrImportDefault)) + && moduleKind !== ts.ModuleKind.System + && (moduleKind < ts.ModuleKind.ES2015 || node.impliedNodeFormat === ts.ModuleKind.CommonJS); + if (!create) { + var helpers = ts.getEmitHelpers(node); + if (helpers) { + for (var _i = 0, helpers_4 = helpers; _i < helpers_4.length; _i++) { + var helper = helpers_4[_i]; + if (!helper.scoped) { + create = true; + break; + } + } + } + } + if (create) { + var parseNode = ts.getOriginalNode(node, ts.isSourceFile); + var emitNode = ts.getOrCreateEmitNode(parseNode); + return emitNode.externalHelpersModuleName || (emitNode.externalHelpersModuleName = factory.createUniqueName(ts.externalHelpersModuleNameText)); + } + } + } + ts.getOrCreateExternalHelpersModuleNameIfNeeded = getOrCreateExternalHelpersModuleNameIfNeeded; + /** + * Get the name of that target module from an import or export declaration + */ + function getLocalNameForExternalImport(factory, node, sourceFile) { + var namespaceDeclaration = ts.getNamespaceDeclarationNode(node); + if (namespaceDeclaration && !ts.isDefaultImport(node) && !ts.isExportNamespaceAsDefaultDeclaration(node)) { + var name = namespaceDeclaration.name; + return ts.isGeneratedIdentifier(name) ? name : factory.createIdentifier(ts.getSourceTextOfNodeFromSourceFile(sourceFile, name) || ts.idText(name)); + } + if (node.kind === 269 /* SyntaxKind.ImportDeclaration */ && node.importClause) { + return factory.getGeneratedNameForNode(node); + } + if (node.kind === 275 /* SyntaxKind.ExportDeclaration */ && node.moduleSpecifier) { + return factory.getGeneratedNameForNode(node); + } + return undefined; + } + ts.getLocalNameForExternalImport = getLocalNameForExternalImport; + /** + * Get the name of a target module from an import/export declaration as should be written in the emitted output. + * The emitted output name can be different from the input if: + * 1. The module has a /// + * 2. --out or --outFile is used, making the name relative to the rootDir + * 3- The containing SourceFile has an entry in renamedDependencies for the import as requested by some module loaders (e.g. System). + * Otherwise, a new StringLiteral node representing the module name will be returned. + */ + function getExternalModuleNameLiteral(factory, importNode, sourceFile, host, resolver, compilerOptions) { + var moduleName = ts.getExternalModuleName(importNode); + if (moduleName && ts.isStringLiteral(moduleName)) { + return tryGetModuleNameFromDeclaration(importNode, host, factory, resolver, compilerOptions) + || tryRenameExternalModule(factory, moduleName, sourceFile) + || factory.cloneNode(moduleName); + } + return undefined; + } + ts.getExternalModuleNameLiteral = getExternalModuleNameLiteral; + /** + * Some bundlers (SystemJS builder) sometimes want to rename dependencies. + * Here we check if alternative name was provided for a given moduleName and return it if possible. + */ + function tryRenameExternalModule(factory, moduleName, sourceFile) { + var rename = sourceFile.renamedDependencies && sourceFile.renamedDependencies.get(moduleName.text); + return rename ? factory.createStringLiteral(rename) : undefined; + } + /** + * Get the name of a module as should be written in the emitted output. + * The emitted output name can be different from the input if: + * 1. The module has a /// + * 2. --out or --outFile is used, making the name relative to the rootDir + * Otherwise, a new StringLiteral node representing the module name will be returned. + */ + function tryGetModuleNameFromFile(factory, file, host, options) { + if (!file) { + return undefined; + } + if (file.moduleName) { + return factory.createStringLiteral(file.moduleName); + } + if (!file.isDeclarationFile && ts.outFile(options)) { + return factory.createStringLiteral(ts.getExternalModuleNameFromPath(host, file.fileName)); + } + return undefined; + } + ts.tryGetModuleNameFromFile = tryGetModuleNameFromFile; + function tryGetModuleNameFromDeclaration(declaration, host, factory, resolver, compilerOptions) { + return tryGetModuleNameFromFile(factory, resolver.getExternalModuleFileFromDeclaration(declaration), host, compilerOptions); + } + /** + * Gets the initializer of an BindingOrAssignmentElement. + */ + function getInitializerOfBindingOrAssignmentElement(bindingElement) { + if (ts.isDeclarationBindingElement(bindingElement)) { + // `1` in `let { a = 1 } = ...` + // `1` in `let { a: b = 1 } = ...` + // `1` in `let { a: {b} = 1 } = ...` + // `1` in `let { a: [b] = 1 } = ...` + // `1` in `let [a = 1] = ...` + // `1` in `let [{a} = 1] = ...` + // `1` in `let [[a] = 1] = ...` + return bindingElement.initializer; + } + if (ts.isPropertyAssignment(bindingElement)) { + // `1` in `({ a: b = 1 } = ...)` + // `1` in `({ a: {b} = 1 } = ...)` + // `1` in `({ a: [b] = 1 } = ...)` + var initializer = bindingElement.initializer; + return ts.isAssignmentExpression(initializer, /*excludeCompoundAssignment*/ true) + ? initializer.right + : undefined; + } + if (ts.isShorthandPropertyAssignment(bindingElement)) { + // `1` in `({ a = 1 } = ...)` + return bindingElement.objectAssignmentInitializer; + } + if (ts.isAssignmentExpression(bindingElement, /*excludeCompoundAssignment*/ true)) { + // `1` in `[a = 1] = ...` + // `1` in `[{a} = 1] = ...` + // `1` in `[[a] = 1] = ...` + return bindingElement.right; + } + if (ts.isSpreadElement(bindingElement)) { + // Recovery consistent with existing emit. + return getInitializerOfBindingOrAssignmentElement(bindingElement.expression); + } + } + ts.getInitializerOfBindingOrAssignmentElement = getInitializerOfBindingOrAssignmentElement; + /** + * Gets the name of an BindingOrAssignmentElement. + */ + function getTargetOfBindingOrAssignmentElement(bindingElement) { + if (ts.isDeclarationBindingElement(bindingElement)) { + // `a` in `let { a } = ...` + // `a` in `let { a = 1 } = ...` + // `b` in `let { a: b } = ...` + // `b` in `let { a: b = 1 } = ...` + // `a` in `let { ...a } = ...` + // `{b}` in `let { a: {b} } = ...` + // `{b}` in `let { a: {b} = 1 } = ...` + // `[b]` in `let { a: [b] } = ...` + // `[b]` in `let { a: [b] = 1 } = ...` + // `a` in `let [a] = ...` + // `a` in `let [a = 1] = ...` + // `a` in `let [...a] = ...` + // `{a}` in `let [{a}] = ...` + // `{a}` in `let [{a} = 1] = ...` + // `[a]` in `let [[a]] = ...` + // `[a]` in `let [[a] = 1] = ...` + return bindingElement.name; + } + if (ts.isObjectLiteralElementLike(bindingElement)) { + switch (bindingElement.kind) { + case 299 /* SyntaxKind.PropertyAssignment */: + // `b` in `({ a: b } = ...)` + // `b` in `({ a: b = 1 } = ...)` + // `{b}` in `({ a: {b} } = ...)` + // `{b}` in `({ a: {b} = 1 } = ...)` + // `[b]` in `({ a: [b] } = ...)` + // `[b]` in `({ a: [b] = 1 } = ...)` + // `b.c` in `({ a: b.c } = ...)` + // `b.c` in `({ a: b.c = 1 } = ...)` + // `b[0]` in `({ a: b[0] } = ...)` + // `b[0]` in `({ a: b[0] = 1 } = ...)` + return getTargetOfBindingOrAssignmentElement(bindingElement.initializer); + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + // `a` in `({ a } = ...)` + // `a` in `({ a = 1 } = ...)` + return bindingElement.name; + case 301 /* SyntaxKind.SpreadAssignment */: + // `a` in `({ ...a } = ...)` + return getTargetOfBindingOrAssignmentElement(bindingElement.expression); + } + // no target + return undefined; + } + if (ts.isAssignmentExpression(bindingElement, /*excludeCompoundAssignment*/ true)) { + // `a` in `[a = 1] = ...` + // `{a}` in `[{a} = 1] = ...` + // `[a]` in `[[a] = 1] = ...` + // `a.b` in `[a.b = 1] = ...` + // `a[0]` in `[a[0] = 1] = ...` + return getTargetOfBindingOrAssignmentElement(bindingElement.left); + } + if (ts.isSpreadElement(bindingElement)) { + // `a` in `[...a] = ...` + return getTargetOfBindingOrAssignmentElement(bindingElement.expression); + } + // `a` in `[a] = ...` + // `{a}` in `[{a}] = ...` + // `[a]` in `[[a]] = ...` + // `a.b` in `[a.b] = ...` + // `a[0]` in `[a[0]] = ...` + return bindingElement; + } + ts.getTargetOfBindingOrAssignmentElement = getTargetOfBindingOrAssignmentElement; + /** + * Determines whether an BindingOrAssignmentElement is a rest element. + */ + function getRestIndicatorOfBindingOrAssignmentElement(bindingElement) { + switch (bindingElement.kind) { + case 166 /* SyntaxKind.Parameter */: + case 205 /* SyntaxKind.BindingElement */: + // `...` in `let [...a] = ...` + return bindingElement.dotDotDotToken; + case 227 /* SyntaxKind.SpreadElement */: + case 301 /* SyntaxKind.SpreadAssignment */: + // `...` in `[...a] = ...` + return bindingElement; + } + return undefined; + } + ts.getRestIndicatorOfBindingOrAssignmentElement = getRestIndicatorOfBindingOrAssignmentElement; + /** + * Gets the property name of a BindingOrAssignmentElement + */ + function getPropertyNameOfBindingOrAssignmentElement(bindingElement) { + var propertyName = tryGetPropertyNameOfBindingOrAssignmentElement(bindingElement); + ts.Debug.assert(!!propertyName || ts.isSpreadAssignment(bindingElement), "Invalid property name for binding element."); + return propertyName; + } + ts.getPropertyNameOfBindingOrAssignmentElement = getPropertyNameOfBindingOrAssignmentElement; + function tryGetPropertyNameOfBindingOrAssignmentElement(bindingElement) { + switch (bindingElement.kind) { + case 205 /* SyntaxKind.BindingElement */: + // `a` in `let { a: b } = ...` + // `[a]` in `let { [a]: b } = ...` + // `"a"` in `let { "a": b } = ...` + // `1` in `let { 1: b } = ...` + if (bindingElement.propertyName) { + var propertyName = bindingElement.propertyName; + if (ts.isPrivateIdentifier(propertyName)) { + return ts.Debug.failBadSyntaxKind(propertyName); + } + return ts.isComputedPropertyName(propertyName) && isStringOrNumericLiteral(propertyName.expression) + ? propertyName.expression + : propertyName; + } + break; + case 299 /* SyntaxKind.PropertyAssignment */: + // `a` in `({ a: b } = ...)` + // `[a]` in `({ [a]: b } = ...)` + // `"a"` in `({ "a": b } = ...)` + // `1` in `({ 1: b } = ...)` + if (bindingElement.name) { + var propertyName = bindingElement.name; + if (ts.isPrivateIdentifier(propertyName)) { + return ts.Debug.failBadSyntaxKind(propertyName); + } + return ts.isComputedPropertyName(propertyName) && isStringOrNumericLiteral(propertyName.expression) + ? propertyName.expression + : propertyName; + } + break; + case 301 /* SyntaxKind.SpreadAssignment */: + // `a` in `({ ...a } = ...)` + if (bindingElement.name && ts.isPrivateIdentifier(bindingElement.name)) { + return ts.Debug.failBadSyntaxKind(bindingElement.name); + } + return bindingElement.name; + } + var target = getTargetOfBindingOrAssignmentElement(bindingElement); + if (target && ts.isPropertyName(target)) { + return target; + } + } + ts.tryGetPropertyNameOfBindingOrAssignmentElement = tryGetPropertyNameOfBindingOrAssignmentElement; + function isStringOrNumericLiteral(node) { + var kind = node.kind; + return kind === 10 /* SyntaxKind.StringLiteral */ + || kind === 8 /* SyntaxKind.NumericLiteral */; + } + /** + * Gets the elements of a BindingOrAssignmentPattern + */ + function getElementsOfBindingOrAssignmentPattern(name) { + switch (name.kind) { + case 203 /* SyntaxKind.ObjectBindingPattern */: + case 204 /* SyntaxKind.ArrayBindingPattern */: + case 206 /* SyntaxKind.ArrayLiteralExpression */: + // `a` in `{a}` + // `a` in `[a]` + return name.elements; + case 207 /* SyntaxKind.ObjectLiteralExpression */: + // `a` in `{a}` + return name.properties; + } + } + ts.getElementsOfBindingOrAssignmentPattern = getElementsOfBindingOrAssignmentPattern; + /* @internal */ + function getJSDocTypeAliasName(fullName) { + if (fullName) { + var rightNode = fullName; + while (true) { + if (ts.isIdentifier(rightNode) || !rightNode.body) { + return ts.isIdentifier(rightNode) ? rightNode : rightNode.name; + } + rightNode = rightNode.body; + } + } + } + ts.getJSDocTypeAliasName = getJSDocTypeAliasName; + function canHaveIllegalType(node) { + var kind = node.kind; + return kind === 173 /* SyntaxKind.Constructor */ + || kind === 175 /* SyntaxKind.SetAccessor */; + } + ts.canHaveIllegalType = canHaveIllegalType; + function canHaveIllegalTypeParameters(node) { + var kind = node.kind; + return kind === 173 /* SyntaxKind.Constructor */ + || kind === 174 /* SyntaxKind.GetAccessor */ + || kind === 175 /* SyntaxKind.SetAccessor */; + } + ts.canHaveIllegalTypeParameters = canHaveIllegalTypeParameters; + function canHaveIllegalDecorators(node) { + var kind = node.kind; + return kind === 299 /* SyntaxKind.PropertyAssignment */ + || kind === 300 /* SyntaxKind.ShorthandPropertyAssignment */ + || kind === 259 /* SyntaxKind.FunctionDeclaration */ + || kind === 173 /* SyntaxKind.Constructor */ + || kind === 178 /* SyntaxKind.IndexSignature */ + || kind === 172 /* SyntaxKind.ClassStaticBlockDeclaration */ + || kind === 279 /* SyntaxKind.MissingDeclaration */ + || kind === 240 /* SyntaxKind.VariableStatement */ + || kind === 261 /* SyntaxKind.InterfaceDeclaration */ + || kind === 262 /* SyntaxKind.TypeAliasDeclaration */ + || kind === 263 /* SyntaxKind.EnumDeclaration */ + || kind === 264 /* SyntaxKind.ModuleDeclaration */ + || kind === 268 /* SyntaxKind.ImportEqualsDeclaration */ + || kind === 269 /* SyntaxKind.ImportDeclaration */ + || kind === 267 /* SyntaxKind.NamespaceExportDeclaration */ + || kind === 275 /* SyntaxKind.ExportDeclaration */ + || kind === 274 /* SyntaxKind.ExportAssignment */; + } + ts.canHaveIllegalDecorators = canHaveIllegalDecorators; + function canHaveIllegalModifiers(node) { + var kind = node.kind; + return kind === 172 /* SyntaxKind.ClassStaticBlockDeclaration */ + || kind === 299 /* SyntaxKind.PropertyAssignment */ + || kind === 300 /* SyntaxKind.ShorthandPropertyAssignment */ + || kind === 181 /* SyntaxKind.FunctionType */ + || kind === 279 /* SyntaxKind.MissingDeclaration */ + || kind === 267 /* SyntaxKind.NamespaceExportDeclaration */; + } + ts.canHaveIllegalModifiers = canHaveIllegalModifiers; + ts.isTypeNodeOrTypeParameterDeclaration = ts.or(ts.isTypeNode, ts.isTypeParameterDeclaration); + ts.isQuestionOrExclamationToken = ts.or(ts.isQuestionToken, ts.isExclamationToken); + ts.isIdentifierOrThisTypeNode = ts.or(ts.isIdentifier, ts.isThisTypeNode); + ts.isReadonlyKeywordOrPlusOrMinusToken = ts.or(ts.isReadonlyKeyword, ts.isPlusToken, ts.isMinusToken); + ts.isQuestionOrPlusOrMinusToken = ts.or(ts.isQuestionToken, ts.isPlusToken, ts.isMinusToken); + ts.isModuleName = ts.or(ts.isIdentifier, ts.isStringLiteral); + function isLiteralTypeLikeExpression(node) { + var kind = node.kind; + return kind === 104 /* SyntaxKind.NullKeyword */ + || kind === 110 /* SyntaxKind.TrueKeyword */ + || kind === 95 /* SyntaxKind.FalseKeyword */ + || ts.isLiteralExpression(node) + || ts.isPrefixUnaryExpression(node); + } + ts.isLiteralTypeLikeExpression = isLiteralTypeLikeExpression; + function isExponentiationOperator(kind) { + return kind === 42 /* SyntaxKind.AsteriskAsteriskToken */; + } + function isMultiplicativeOperator(kind) { + return kind === 41 /* SyntaxKind.AsteriskToken */ + || kind === 43 /* SyntaxKind.SlashToken */ + || kind === 44 /* SyntaxKind.PercentToken */; + } + function isMultiplicativeOperatorOrHigher(kind) { + return isExponentiationOperator(kind) + || isMultiplicativeOperator(kind); + } + function isAdditiveOperator(kind) { + return kind === 39 /* SyntaxKind.PlusToken */ + || kind === 40 /* SyntaxKind.MinusToken */; + } + function isAdditiveOperatorOrHigher(kind) { + return isAdditiveOperator(kind) + || isMultiplicativeOperatorOrHigher(kind); + } + function isShiftOperator(kind) { + return kind === 47 /* SyntaxKind.LessThanLessThanToken */ + || kind === 48 /* SyntaxKind.GreaterThanGreaterThanToken */ + || kind === 49 /* SyntaxKind.GreaterThanGreaterThanGreaterThanToken */; + } + function isShiftOperatorOrHigher(kind) { + return isShiftOperator(kind) + || isAdditiveOperatorOrHigher(kind); + } + function isRelationalOperator(kind) { + return kind === 29 /* SyntaxKind.LessThanToken */ + || kind === 32 /* SyntaxKind.LessThanEqualsToken */ + || kind === 31 /* SyntaxKind.GreaterThanToken */ + || kind === 33 /* SyntaxKind.GreaterThanEqualsToken */ + || kind === 102 /* SyntaxKind.InstanceOfKeyword */ + || kind === 101 /* SyntaxKind.InKeyword */; + } + function isRelationalOperatorOrHigher(kind) { + return isRelationalOperator(kind) + || isShiftOperatorOrHigher(kind); + } + function isEqualityOperator(kind) { + return kind === 34 /* SyntaxKind.EqualsEqualsToken */ + || kind === 36 /* SyntaxKind.EqualsEqualsEqualsToken */ + || kind === 35 /* SyntaxKind.ExclamationEqualsToken */ + || kind === 37 /* SyntaxKind.ExclamationEqualsEqualsToken */; + } + function isEqualityOperatorOrHigher(kind) { + return isEqualityOperator(kind) + || isRelationalOperatorOrHigher(kind); + } + function isBitwiseOperator(kind) { + return kind === 50 /* SyntaxKind.AmpersandToken */ + || kind === 51 /* SyntaxKind.BarToken */ + || kind === 52 /* SyntaxKind.CaretToken */; + } + function isBitwiseOperatorOrHigher(kind) { + return isBitwiseOperator(kind) + || isEqualityOperatorOrHigher(kind); + } + // NOTE: The version in utilities includes ExclamationToken, which is not a binary operator. + function isLogicalOperator(kind) { + return kind === 55 /* SyntaxKind.AmpersandAmpersandToken */ + || kind === 56 /* SyntaxKind.BarBarToken */; + } + function isLogicalOperatorOrHigher(kind) { + return isLogicalOperator(kind) + || isBitwiseOperatorOrHigher(kind); + } + function isAssignmentOperatorOrHigher(kind) { + return kind === 60 /* SyntaxKind.QuestionQuestionToken */ + || isLogicalOperatorOrHigher(kind) + || ts.isAssignmentOperator(kind); + } + function isBinaryOperator(kind) { + return isAssignmentOperatorOrHigher(kind) + || kind === 27 /* SyntaxKind.CommaToken */; + } + function isBinaryOperatorToken(node) { + return isBinaryOperator(node.kind); + } + ts.isBinaryOperatorToken = isBinaryOperatorToken; + var BinaryExpressionState; + (function (BinaryExpressionState) { + /** + * Handles walking into a `BinaryExpression`. + * @param machine State machine handler functions + * @param frame The current frame + * @returns The new frame + */ + function enter(machine, stackIndex, stateStack, nodeStack, userStateStack, _resultHolder, outerState) { + var prevUserState = stackIndex > 0 ? userStateStack[stackIndex - 1] : undefined; + ts.Debug.assertEqual(stateStack[stackIndex], enter); + userStateStack[stackIndex] = machine.onEnter(nodeStack[stackIndex], prevUserState, outerState); + stateStack[stackIndex] = nextState(machine, enter); + return stackIndex; + } + BinaryExpressionState.enter = enter; + /** + * Handles walking the `left` side of a `BinaryExpression`. + * @param machine State machine handler functions + * @param frame The current frame + * @returns The new frame + */ + function left(machine, stackIndex, stateStack, nodeStack, userStateStack, _resultHolder, _outerState) { + ts.Debug.assertEqual(stateStack[stackIndex], left); + ts.Debug.assertIsDefined(machine.onLeft); + stateStack[stackIndex] = nextState(machine, left); + var nextNode = machine.onLeft(nodeStack[stackIndex].left, userStateStack[stackIndex], nodeStack[stackIndex]); + if (nextNode) { + checkCircularity(stackIndex, nodeStack, nextNode); + return pushStack(stackIndex, stateStack, nodeStack, userStateStack, nextNode); + } + return stackIndex; + } + BinaryExpressionState.left = left; + /** + * Handles walking the `operatorToken` of a `BinaryExpression`. + * @param machine State machine handler functions + * @param frame The current frame + * @returns The new frame + */ + function operator(machine, stackIndex, stateStack, nodeStack, userStateStack, _resultHolder, _outerState) { + ts.Debug.assertEqual(stateStack[stackIndex], operator); + ts.Debug.assertIsDefined(machine.onOperator); + stateStack[stackIndex] = nextState(machine, operator); + machine.onOperator(nodeStack[stackIndex].operatorToken, userStateStack[stackIndex], nodeStack[stackIndex]); + return stackIndex; + } + BinaryExpressionState.operator = operator; + /** + * Handles walking the `right` side of a `BinaryExpression`. + * @param machine State machine handler functions + * @param frame The current frame + * @returns The new frame + */ + function right(machine, stackIndex, stateStack, nodeStack, userStateStack, _resultHolder, _outerState) { + ts.Debug.assertEqual(stateStack[stackIndex], right); + ts.Debug.assertIsDefined(machine.onRight); + stateStack[stackIndex] = nextState(machine, right); + var nextNode = machine.onRight(nodeStack[stackIndex].right, userStateStack[stackIndex], nodeStack[stackIndex]); + if (nextNode) { + checkCircularity(stackIndex, nodeStack, nextNode); + return pushStack(stackIndex, stateStack, nodeStack, userStateStack, nextNode); + } + return stackIndex; + } + BinaryExpressionState.right = right; + /** + * Handles walking out of a `BinaryExpression`. + * @param machine State machine handler functions + * @param frame The current frame + * @returns The new frame + */ + function exit(machine, stackIndex, stateStack, nodeStack, userStateStack, resultHolder, _outerState) { + ts.Debug.assertEqual(stateStack[stackIndex], exit); + stateStack[stackIndex] = nextState(machine, exit); + var result = machine.onExit(nodeStack[stackIndex], userStateStack[stackIndex]); + if (stackIndex > 0) { + stackIndex--; + if (machine.foldState) { + var side = stateStack[stackIndex] === exit ? "right" : "left"; + userStateStack[stackIndex] = machine.foldState(userStateStack[stackIndex], result, side); + } + } + else { + resultHolder.value = result; + } + return stackIndex; + } + BinaryExpressionState.exit = exit; + /** + * Handles a frame that is already done. + * @returns The `done` state. + */ + function done(_machine, stackIndex, stateStack, _nodeStack, _userStateStack, _resultHolder, _outerState) { + ts.Debug.assertEqual(stateStack[stackIndex], done); + return stackIndex; + } + BinaryExpressionState.done = done; + function nextState(machine, currentState) { + switch (currentState) { + case enter: + if (machine.onLeft) + return left; + // falls through + case left: + if (machine.onOperator) + return operator; + // falls through + case operator: + if (machine.onRight) + return right; + // falls through + case right: return exit; + case exit: return done; + case done: return done; + default: ts.Debug.fail("Invalid state"); + } + } + BinaryExpressionState.nextState = nextState; + function pushStack(stackIndex, stateStack, nodeStack, userStateStack, node) { + stackIndex++; + stateStack[stackIndex] = enter; + nodeStack[stackIndex] = node; + userStateStack[stackIndex] = undefined; + return stackIndex; + } + function checkCircularity(stackIndex, nodeStack, node) { + if (ts.Debug.shouldAssert(2 /* AssertionLevel.Aggressive */)) { + while (stackIndex >= 0) { + ts.Debug.assert(nodeStack[stackIndex] !== node, "Circular traversal detected."); + stackIndex--; + } + } + } + })(BinaryExpressionState || (BinaryExpressionState = {})); + /** + * Holds state machine handler functions + */ + var BinaryExpressionStateMachine = /** @class */ (function () { + function BinaryExpressionStateMachine(onEnter, onLeft, onOperator, onRight, onExit, foldState) { + this.onEnter = onEnter; + this.onLeft = onLeft; + this.onOperator = onOperator; + this.onRight = onRight; + this.onExit = onExit; + this.foldState = foldState; + } + return BinaryExpressionStateMachine; + }()); + function createBinaryExpressionTrampoline(onEnter, onLeft, onOperator, onRight, onExit, foldState) { + var machine = new BinaryExpressionStateMachine(onEnter, onLeft, onOperator, onRight, onExit, foldState); + return trampoline; + function trampoline(node, outerState) { + var resultHolder = { value: undefined }; + var stateStack = [BinaryExpressionState.enter]; + var nodeStack = [node]; + var userStateStack = [undefined]; + var stackIndex = 0; + while (stateStack[stackIndex] !== BinaryExpressionState.done) { + stackIndex = stateStack[stackIndex](machine, stackIndex, stateStack, nodeStack, userStateStack, resultHolder, outerState); + } + ts.Debug.assertEqual(stackIndex, 0); + return resultHolder.value; + } + } + ts.createBinaryExpressionTrampoline = createBinaryExpressionTrampoline; + function elideNodes(factory, nodes) { + if (nodes === undefined) + return undefined; + if (nodes.length === 0) + return nodes; + return ts.setTextRange(factory.createNodeArray([], nodes.hasTrailingComma), nodes); + } + ts.elideNodes = elideNodes; + /** + * Gets the node from which a name should be generated. + */ + function getNodeForGeneratedName(name) { + if (name.autoGenerateFlags & 4 /* GeneratedIdentifierFlags.Node */) { + var autoGenerateId = name.autoGenerateId; + var node = name; + var original = node.original; + while (original) { + node = original; + // if "node" is a different generated name (having a different "autoGenerateId"), use it and stop traversing. + if (ts.isMemberName(node) + && !!(node.autoGenerateFlags & 4 /* GeneratedIdentifierFlags.Node */) + && node.autoGenerateId !== autoGenerateId) { + break; + } + original = node.original; + } + // otherwise, return the original node for the source + return node; + } + return name; + } + ts.getNodeForGeneratedName = getNodeForGeneratedName; + function formatGeneratedNamePart(part, generateName) { + return typeof part === "object" ? formatGeneratedName(/*privateName*/ false, part.prefix, part.node, part.suffix, generateName) : + typeof part === "string" ? part.length > 0 && part.charCodeAt(0) === 35 /* CharacterCodes.hash */ ? part.slice(1) : part : + ""; + } + ts.formatGeneratedNamePart = formatGeneratedNamePart; + function formatIdentifier(name, generateName) { + return typeof name === "string" ? name : + formatIdentifierWorker(name, ts.Debug.checkDefined(generateName)); + } + function formatIdentifierWorker(node, generateName) { + return ts.isGeneratedPrivateIdentifier(node) ? generateName(node).slice(1) : + ts.isGeneratedIdentifier(node) ? generateName(node) : + ts.isPrivateIdentifier(node) ? node.escapedText.slice(1) : + ts.idText(node); + } + function formatGeneratedName(privateName, prefix, baseName, suffix, generateName) { + prefix = formatGeneratedNamePart(prefix, generateName); + suffix = formatGeneratedNamePart(suffix, generateName); + baseName = formatIdentifier(baseName, generateName); + return "".concat(privateName ? "#" : "").concat(prefix).concat(baseName).concat(suffix); + } + ts.formatGeneratedName = formatGeneratedName; + /** + * Creates a private backing field for an `accessor` {@link PropertyDeclaration}. + */ + function createAccessorPropertyBackingField(factory, node, modifiers, initializer) { + return factory.updatePropertyDeclaration(node, modifiers, factory.getGeneratedPrivateNameForNode(node.name, /*prefix*/ undefined, "_accessor_storage"), + /*questionOrExclamationToken*/ undefined, + /*type*/ undefined, initializer); + } + ts.createAccessorPropertyBackingField = createAccessorPropertyBackingField; + /** + * Creates a {@link GetAccessorDeclaration} that reads from a private backing field. + */ + function createAccessorPropertyGetRedirector(factory, node, modifiers, name) { + return factory.createGetAccessorDeclaration(modifiers, name, [], + /*type*/ undefined, factory.createBlock([ + factory.createReturnStatement(factory.createPropertyAccessExpression(factory.createThis(), factory.getGeneratedPrivateNameForNode(node.name, /*prefix*/ undefined, "_accessor_storage"))) + ])); + } + ts.createAccessorPropertyGetRedirector = createAccessorPropertyGetRedirector; + /** + * Creates a {@link SetAccessorDeclaration} that writes to a private backing field. + */ + function createAccessorPropertySetRedirector(factory, node, modifiers, name) { + return factory.createSetAccessorDeclaration(modifiers, name, [factory.createParameterDeclaration( + /*modifiers*/ undefined, + /*dotdotDotToken*/ undefined, "value")], factory.createBlock([ + factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression(factory.createThis(), factory.getGeneratedPrivateNameForNode(node.name, /*prefix*/ undefined, "_accessor_storage")), factory.createIdentifier("value"))) + ])); + } + ts.createAccessorPropertySetRedirector = createAccessorPropertySetRedirector; +})(ts || (ts = {})); +var ts; +(function (ts) { + function setTextRange(range, location) { + return location ? ts.setTextRangePosEnd(range, location.pos, location.end) : range; + } + ts.setTextRange = setTextRange; + function canHaveModifiers(node) { + var kind = node.kind; + return kind === 165 /* SyntaxKind.TypeParameter */ + || kind === 166 /* SyntaxKind.Parameter */ + || kind === 168 /* SyntaxKind.PropertySignature */ + || kind === 169 /* SyntaxKind.PropertyDeclaration */ + || kind === 170 /* SyntaxKind.MethodSignature */ + || kind === 171 /* SyntaxKind.MethodDeclaration */ + || kind === 173 /* SyntaxKind.Constructor */ + || kind === 174 /* SyntaxKind.GetAccessor */ + || kind === 175 /* SyntaxKind.SetAccessor */ + || kind === 178 /* SyntaxKind.IndexSignature */ + || kind === 182 /* SyntaxKind.ConstructorType */ + || kind === 215 /* SyntaxKind.FunctionExpression */ + || kind === 216 /* SyntaxKind.ArrowFunction */ + || kind === 228 /* SyntaxKind.ClassExpression */ + || kind === 240 /* SyntaxKind.VariableStatement */ + || kind === 259 /* SyntaxKind.FunctionDeclaration */ + || kind === 260 /* SyntaxKind.ClassDeclaration */ + || kind === 261 /* SyntaxKind.InterfaceDeclaration */ + || kind === 262 /* SyntaxKind.TypeAliasDeclaration */ + || kind === 263 /* SyntaxKind.EnumDeclaration */ + || kind === 264 /* SyntaxKind.ModuleDeclaration */ + || kind === 268 /* SyntaxKind.ImportEqualsDeclaration */ + || kind === 269 /* SyntaxKind.ImportDeclaration */ + || kind === 274 /* SyntaxKind.ExportAssignment */ + || kind === 275 /* SyntaxKind.ExportDeclaration */; + } + ts.canHaveModifiers = canHaveModifiers; + function canHaveDecorators(node) { + var kind = node.kind; + return kind === 166 /* SyntaxKind.Parameter */ + || kind === 169 /* SyntaxKind.PropertyDeclaration */ + || kind === 171 /* SyntaxKind.MethodDeclaration */ + || kind === 174 /* SyntaxKind.GetAccessor */ + || kind === 175 /* SyntaxKind.SetAccessor */ + || kind === 228 /* SyntaxKind.ClassExpression */ + || kind === 260 /* SyntaxKind.ClassDeclaration */; + } + ts.canHaveDecorators = canHaveDecorators; +})(ts || (ts = {})); +var ts; +(function (ts) { + var _a; + var SignatureFlags; + (function (SignatureFlags) { + SignatureFlags[SignatureFlags["None"] = 0] = "None"; + SignatureFlags[SignatureFlags["Yield"] = 1] = "Yield"; + SignatureFlags[SignatureFlags["Await"] = 2] = "Await"; + SignatureFlags[SignatureFlags["Type"] = 4] = "Type"; + SignatureFlags[SignatureFlags["IgnoreMissingOpenBrace"] = 16] = "IgnoreMissingOpenBrace"; + SignatureFlags[SignatureFlags["JSDoc"] = 32] = "JSDoc"; + })(SignatureFlags || (SignatureFlags = {})); + var SpeculationKind; + (function (SpeculationKind) { + SpeculationKind[SpeculationKind["TryParse"] = 0] = "TryParse"; + SpeculationKind[SpeculationKind["Lookahead"] = 1] = "Lookahead"; + SpeculationKind[SpeculationKind["Reparse"] = 2] = "Reparse"; + })(SpeculationKind || (SpeculationKind = {})); + var NodeConstructor; + var TokenConstructor; + var IdentifierConstructor; + var PrivateIdentifierConstructor; + var SourceFileConstructor; + /** + * NOTE: You should not use this, it is only exported to support `createNode` in `~/src/deprecatedCompat/deprecations.ts`. + */ + /* @internal */ + ts.parseBaseNodeFactory = { + createBaseSourceFileNode: function (kind) { return new (SourceFileConstructor || (SourceFileConstructor = ts.objectAllocator.getSourceFileConstructor()))(kind, -1, -1); }, + createBaseIdentifierNode: function (kind) { return new (IdentifierConstructor || (IdentifierConstructor = ts.objectAllocator.getIdentifierConstructor()))(kind, -1, -1); }, + createBasePrivateIdentifierNode: function (kind) { return new (PrivateIdentifierConstructor || (PrivateIdentifierConstructor = ts.objectAllocator.getPrivateIdentifierConstructor()))(kind, -1, -1); }, + createBaseTokenNode: function (kind) { return new (TokenConstructor || (TokenConstructor = ts.objectAllocator.getTokenConstructor()))(kind, -1, -1); }, + createBaseNode: function (kind) { return new (NodeConstructor || (NodeConstructor = ts.objectAllocator.getNodeConstructor()))(kind, -1, -1); }, + }; + /* @internal */ + ts.parseNodeFactory = ts.createNodeFactory(1 /* NodeFactoryFlags.NoParenthesizerRules */, ts.parseBaseNodeFactory); + function visitNode(cbNode, node) { + return node && cbNode(node); + } + function visitNodes(cbNode, cbNodes, nodes) { + if (nodes) { + if (cbNodes) { + return cbNodes(nodes); + } + for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) { + var node = nodes_1[_i]; + var result = cbNode(node); + if (result) { + return result; + } + } + } + } + /*@internal*/ + function isJSDocLikeText(text, start) { + return text.charCodeAt(start + 1) === 42 /* CharacterCodes.asterisk */ && + text.charCodeAt(start + 2) === 42 /* CharacterCodes.asterisk */ && + text.charCodeAt(start + 3) !== 47 /* CharacterCodes.slash */; + } + ts.isJSDocLikeText = isJSDocLikeText; + /*@internal*/ + function isFileProbablyExternalModule(sourceFile) { + // Try to use the first top-level import/export when available, then + // fall back to looking for an 'import.meta' somewhere in the tree if necessary. + return ts.forEach(sourceFile.statements, isAnExternalModuleIndicatorNode) || + getImportMetaIfNecessary(sourceFile); + } + ts.isFileProbablyExternalModule = isFileProbablyExternalModule; + function isAnExternalModuleIndicatorNode(node) { + return ts.canHaveModifiers(node) && hasModifierOfKind(node, 93 /* SyntaxKind.ExportKeyword */) + || ts.isImportEqualsDeclaration(node) && ts.isExternalModuleReference(node.moduleReference) + || ts.isImportDeclaration(node) + || ts.isExportAssignment(node) + || ts.isExportDeclaration(node) ? node : undefined; + } + function getImportMetaIfNecessary(sourceFile) { + return sourceFile.flags & 4194304 /* NodeFlags.PossiblyContainsImportMeta */ ? + walkTreeForImportMeta(sourceFile) : + undefined; + } + function walkTreeForImportMeta(node) { + return isImportMeta(node) ? node : forEachChild(node, walkTreeForImportMeta); + } + /** Do not use hasModifier inside the parser; it relies on parent pointers. Use this instead. */ + function hasModifierOfKind(node, kind) { + return ts.some(node.modifiers, function (m) { return m.kind === kind; }); + } + function isImportMeta(node) { + return ts.isMetaProperty(node) && node.keywordToken === 100 /* SyntaxKind.ImportKeyword */ && node.name.escapedText === "meta"; + } + var forEachChildTable = (_a = {}, + _a[163 /* SyntaxKind.QualifiedName */] = function forEachChildInQualifiedName(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.left) || + visitNode(cbNode, node.right); + }, + _a[165 /* SyntaxKind.TypeParameter */] = function forEachChildInTypeParameter(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.constraint) || + visitNode(cbNode, node.default) || + visitNode(cbNode, node.expression); + }, + _a[300 /* SyntaxKind.ShorthandPropertyAssignment */] = function forEachChildInShorthandPropertyAssignment(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.exclamationToken) || + visitNode(cbNode, node.equalsToken) || + visitNode(cbNode, node.objectAssignmentInitializer); + }, + _a[301 /* SyntaxKind.SpreadAssignment */] = function forEachChildInSpreadAssignment(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.expression); + }, + _a[166 /* SyntaxKind.Parameter */] = function forEachChildInParameter(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.dotDotDotToken) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.initializer); + }, + _a[169 /* SyntaxKind.PropertyDeclaration */] = function forEachChildInPropertyDeclaration(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.exclamationToken) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.initializer); + }, + _a[168 /* SyntaxKind.PropertySignature */] = function forEachChildInPropertySignature(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.initializer); + }, + _a[299 /* SyntaxKind.PropertyAssignment */] = function forEachChildInPropertyAssignment(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.exclamationToken) || + visitNode(cbNode, node.initializer); + }, + _a[257 /* SyntaxKind.VariableDeclaration */] = function forEachChildInVariableDeclaration(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.exclamationToken) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.initializer); + }, + _a[205 /* SyntaxKind.BindingElement */] = function forEachChildInBindingElement(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.dotDotDotToken) || + visitNode(cbNode, node.propertyName) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.initializer); + }, + _a[178 /* SyntaxKind.IndexSignature */] = function forEachChildInIndexSignature(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type); + }, + _a[182 /* SyntaxKind.ConstructorType */] = function forEachChildInConstructorType(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type); + }, + _a[181 /* SyntaxKind.FunctionType */] = function forEachChildInFunctionType(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type); + }, + _a[176 /* SyntaxKind.CallSignature */] = forEachChildInCallOrConstructSignature, + _a[177 /* SyntaxKind.ConstructSignature */] = forEachChildInCallOrConstructSignature, + _a[171 /* SyntaxKind.MethodDeclaration */] = function forEachChildInMethodDeclaration(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.asteriskToken) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.exclamationToken) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.body); + }, + _a[170 /* SyntaxKind.MethodSignature */] = function forEachChildInMethodSignature(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type); + }, + _a[173 /* SyntaxKind.Constructor */] = function forEachChildInConstructor(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.body); + }, + _a[174 /* SyntaxKind.GetAccessor */] = function forEachChildInGetAccessor(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.body); + }, + _a[175 /* SyntaxKind.SetAccessor */] = function forEachChildInSetAccessor(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.body); + }, + _a[259 /* SyntaxKind.FunctionDeclaration */] = function forEachChildInFunctionDeclaration(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.asteriskToken) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.body); + }, + _a[215 /* SyntaxKind.FunctionExpression */] = function forEachChildInFunctionExpression(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.asteriskToken) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.body); + }, + _a[216 /* SyntaxKind.ArrowFunction */] = function forEachChildInArrowFunction(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type) || + visitNode(cbNode, node.equalsGreaterThanToken) || + visitNode(cbNode, node.body); + }, + _a[172 /* SyntaxKind.ClassStaticBlockDeclaration */] = function forEachChildInClassStaticBlockDeclaration(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.body); + }, + _a[180 /* SyntaxKind.TypeReference */] = function forEachChildInTypeReference(node, cbNode, cbNodes) { + return visitNode(cbNode, node.typeName) || + visitNodes(cbNode, cbNodes, node.typeArguments); + }, + _a[179 /* SyntaxKind.TypePredicate */] = function forEachChildInTypePredicate(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.assertsModifier) || + visitNode(cbNode, node.parameterName) || + visitNode(cbNode, node.type); + }, + _a[183 /* SyntaxKind.TypeQuery */] = function forEachChildInTypeQuery(node, cbNode, cbNodes) { + return visitNode(cbNode, node.exprName) || + visitNodes(cbNode, cbNodes, node.typeArguments); + }, + _a[184 /* SyntaxKind.TypeLiteral */] = function forEachChildInTypeLiteral(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.members); + }, + _a[185 /* SyntaxKind.ArrayType */] = function forEachChildInArrayType(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.elementType); + }, + _a[186 /* SyntaxKind.TupleType */] = function forEachChildInTupleType(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.elements); + }, + _a[189 /* SyntaxKind.UnionType */] = forEachChildInUnionOrIntersectionType, + _a[190 /* SyntaxKind.IntersectionType */] = forEachChildInUnionOrIntersectionType, + _a[191 /* SyntaxKind.ConditionalType */] = function forEachChildInConditionalType(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.checkType) || + visitNode(cbNode, node.extendsType) || + visitNode(cbNode, node.trueType) || + visitNode(cbNode, node.falseType); + }, + _a[192 /* SyntaxKind.InferType */] = function forEachChildInInferType(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.typeParameter); + }, + _a[202 /* SyntaxKind.ImportType */] = function forEachChildInImportType(node, cbNode, cbNodes) { + return visitNode(cbNode, node.argument) || + visitNode(cbNode, node.assertions) || + visitNode(cbNode, node.qualifier) || + visitNodes(cbNode, cbNodes, node.typeArguments); + }, + _a[298 /* SyntaxKind.ImportTypeAssertionContainer */] = function forEachChildInImportTypeAssertionContainer(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.assertClause); + }, + _a[193 /* SyntaxKind.ParenthesizedType */] = forEachChildInParenthesizedTypeOrTypeOperator, + _a[195 /* SyntaxKind.TypeOperator */] = forEachChildInParenthesizedTypeOrTypeOperator, + _a[196 /* SyntaxKind.IndexedAccessType */] = function forEachChildInIndexedAccessType(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.objectType) || + visitNode(cbNode, node.indexType); + }, + _a[197 /* SyntaxKind.MappedType */] = function forEachChildInMappedType(node, cbNode, cbNodes) { + return visitNode(cbNode, node.readonlyToken) || + visitNode(cbNode, node.typeParameter) || + visitNode(cbNode, node.nameType) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.type) || + visitNodes(cbNode, cbNodes, node.members); + }, + _a[198 /* SyntaxKind.LiteralType */] = function forEachChildInLiteralType(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.literal); + }, + _a[199 /* SyntaxKind.NamedTupleMember */] = function forEachChildInNamedTupleMember(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.dotDotDotToken) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.type); + }, + _a[203 /* SyntaxKind.ObjectBindingPattern */] = forEachChildInObjectOrArrayBindingPattern, + _a[204 /* SyntaxKind.ArrayBindingPattern */] = forEachChildInObjectOrArrayBindingPattern, + _a[206 /* SyntaxKind.ArrayLiteralExpression */] = function forEachChildInArrayLiteralExpression(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.elements); + }, + _a[207 /* SyntaxKind.ObjectLiteralExpression */] = function forEachChildInObjectLiteralExpression(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.properties); + }, + _a[208 /* SyntaxKind.PropertyAccessExpression */] = function forEachChildInPropertyAccessExpression(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.questionDotToken) || + visitNode(cbNode, node.name); + }, + _a[209 /* SyntaxKind.ElementAccessExpression */] = function forEachChildInElementAccessExpression(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.questionDotToken) || + visitNode(cbNode, node.argumentExpression); + }, + _a[210 /* SyntaxKind.CallExpression */] = forEachChildInCallOrNewExpression, + _a[211 /* SyntaxKind.NewExpression */] = forEachChildInCallOrNewExpression, + _a[212 /* SyntaxKind.TaggedTemplateExpression */] = function forEachChildInTaggedTemplateExpression(node, cbNode, cbNodes) { + return visitNode(cbNode, node.tag) || + visitNode(cbNode, node.questionDotToken) || + visitNodes(cbNode, cbNodes, node.typeArguments) || + visitNode(cbNode, node.template); + }, + _a[213 /* SyntaxKind.TypeAssertionExpression */] = function forEachChildInTypeAssertionExpression(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.type) || + visitNode(cbNode, node.expression); + }, + _a[214 /* SyntaxKind.ParenthesizedExpression */] = function forEachChildInParenthesizedExpression(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.expression); + }, + _a[217 /* SyntaxKind.DeleteExpression */] = function forEachChildInDeleteExpression(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.expression); + }, + _a[218 /* SyntaxKind.TypeOfExpression */] = function forEachChildInTypeOfExpression(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.expression); + }, + _a[219 /* SyntaxKind.VoidExpression */] = function forEachChildInVoidExpression(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.expression); + }, + _a[221 /* SyntaxKind.PrefixUnaryExpression */] = function forEachChildInPrefixUnaryExpression(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.operand); + }, + _a[226 /* SyntaxKind.YieldExpression */] = function forEachChildInYieldExpression(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.asteriskToken) || + visitNode(cbNode, node.expression); + }, + _a[220 /* SyntaxKind.AwaitExpression */] = function forEachChildInAwaitExpression(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.expression); + }, + _a[222 /* SyntaxKind.PostfixUnaryExpression */] = function forEachChildInPostfixUnaryExpression(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.operand); + }, + _a[223 /* SyntaxKind.BinaryExpression */] = function forEachChildInBinaryExpression(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.left) || + visitNode(cbNode, node.operatorToken) || + visitNode(cbNode, node.right); + }, + _a[231 /* SyntaxKind.AsExpression */] = function forEachChildInAsExpression(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.type); + }, + _a[232 /* SyntaxKind.NonNullExpression */] = function forEachChildInNonNullExpression(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.expression); + }, + _a[235 /* SyntaxKind.SatisfiesExpression */] = function forEachChildInSatisfiesExpression(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.expression) || visitNode(cbNode, node.type); + }, + _a[233 /* SyntaxKind.MetaProperty */] = function forEachChildInMetaProperty(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.name); + }, + _a[224 /* SyntaxKind.ConditionalExpression */] = function forEachChildInConditionalExpression(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.condition) || + visitNode(cbNode, node.questionToken) || + visitNode(cbNode, node.whenTrue) || + visitNode(cbNode, node.colonToken) || + visitNode(cbNode, node.whenFalse); + }, + _a[227 /* SyntaxKind.SpreadElement */] = function forEachChildInSpreadElement(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.expression); + }, + _a[238 /* SyntaxKind.Block */] = forEachChildInBlock, + _a[265 /* SyntaxKind.ModuleBlock */] = forEachChildInBlock, + _a[308 /* SyntaxKind.SourceFile */] = function forEachChildInSourceFile(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.statements) || + visitNode(cbNode, node.endOfFileToken); + }, + _a[240 /* SyntaxKind.VariableStatement */] = function forEachChildInVariableStatement(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.declarationList); + }, + _a[258 /* SyntaxKind.VariableDeclarationList */] = function forEachChildInVariableDeclarationList(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.declarations); + }, + _a[241 /* SyntaxKind.ExpressionStatement */] = function forEachChildInExpressionStatement(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.expression); + }, + _a[242 /* SyntaxKind.IfStatement */] = function forEachChildInIfStatement(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.thenStatement) || + visitNode(cbNode, node.elseStatement); + }, + _a[243 /* SyntaxKind.DoStatement */] = function forEachChildInDoStatement(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.statement) || + visitNode(cbNode, node.expression); + }, + _a[244 /* SyntaxKind.WhileStatement */] = function forEachChildInWhileStatement(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.statement); + }, + _a[245 /* SyntaxKind.ForStatement */] = function forEachChildInForStatement(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.initializer) || + visitNode(cbNode, node.condition) || + visitNode(cbNode, node.incrementor) || + visitNode(cbNode, node.statement); + }, + _a[246 /* SyntaxKind.ForInStatement */] = function forEachChildInForInStatement(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.initializer) || + visitNode(cbNode, node.expression) || + visitNode(cbNode, node.statement); + }, + _a[247 /* SyntaxKind.ForOfStatement */] = function forEachChildInForOfStatement(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.awaitModifier) || + visitNode(cbNode, node.initializer) || + visitNode(cbNode, node.expression) || + visitNode(cbNode, node.statement); + }, + _a[248 /* SyntaxKind.ContinueStatement */] = forEachChildInContinueOrBreakStatement, + _a[249 /* SyntaxKind.BreakStatement */] = forEachChildInContinueOrBreakStatement, + _a[250 /* SyntaxKind.ReturnStatement */] = function forEachChildInReturnStatement(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.expression); + }, + _a[251 /* SyntaxKind.WithStatement */] = function forEachChildInWithStatement(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.statement); + }, + _a[252 /* SyntaxKind.SwitchStatement */] = function forEachChildInSwitchStatement(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.caseBlock); + }, + _a[266 /* SyntaxKind.CaseBlock */] = function forEachChildInCaseBlock(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.clauses); + }, + _a[292 /* SyntaxKind.CaseClause */] = function forEachChildInCaseClause(node, cbNode, cbNodes) { + return visitNode(cbNode, node.expression) || + visitNodes(cbNode, cbNodes, node.statements); + }, + _a[293 /* SyntaxKind.DefaultClause */] = function forEachChildInDefaultClause(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.statements); + }, + _a[253 /* SyntaxKind.LabeledStatement */] = function forEachChildInLabeledStatement(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.label) || + visitNode(cbNode, node.statement); + }, + _a[254 /* SyntaxKind.ThrowStatement */] = function forEachChildInThrowStatement(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.expression); + }, + _a[255 /* SyntaxKind.TryStatement */] = function forEachChildInTryStatement(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.tryBlock) || + visitNode(cbNode, node.catchClause) || + visitNode(cbNode, node.finallyBlock); + }, + _a[295 /* SyntaxKind.CatchClause */] = function forEachChildInCatchClause(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.variableDeclaration) || + visitNode(cbNode, node.block); + }, + _a[167 /* SyntaxKind.Decorator */] = function forEachChildInDecorator(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.expression); + }, + _a[260 /* SyntaxKind.ClassDeclaration */] = forEachChildInClassDeclarationOrExpression, + _a[228 /* SyntaxKind.ClassExpression */] = forEachChildInClassDeclarationOrExpression, + _a[261 /* SyntaxKind.InterfaceDeclaration */] = function forEachChildInInterfaceDeclaration(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.heritageClauses) || + visitNodes(cbNode, cbNodes, node.members); + }, + _a[262 /* SyntaxKind.TypeAliasDeclaration */] = function forEachChildInTypeAliasDeclaration(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNode(cbNode, node.type); + }, + _a[263 /* SyntaxKind.EnumDeclaration */] = function forEachChildInEnumDeclaration(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.members); + }, + _a[302 /* SyntaxKind.EnumMember */] = function forEachChildInEnumMember(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.initializer); + }, + _a[264 /* SyntaxKind.ModuleDeclaration */] = function forEachChildInModuleDeclaration(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.body); + }, + _a[268 /* SyntaxKind.ImportEqualsDeclaration */] = function forEachChildInImportEqualsDeclaration(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNode(cbNode, node.moduleReference); + }, + _a[269 /* SyntaxKind.ImportDeclaration */] = function forEachChildInImportDeclaration(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.importClause) || + visitNode(cbNode, node.moduleSpecifier) || + visitNode(cbNode, node.assertClause); + }, + _a[270 /* SyntaxKind.ImportClause */] = function forEachChildInImportClause(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.namedBindings); + }, + _a[296 /* SyntaxKind.AssertClause */] = function forEachChildInAssertClause(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.elements); + }, + _a[297 /* SyntaxKind.AssertEntry */] = function forEachChildInAssertEntry(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.value); + }, + _a[267 /* SyntaxKind.NamespaceExportDeclaration */] = function forEachChildInNamespaceExportDeclaration(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNode(cbNode, node.name); + }, + _a[271 /* SyntaxKind.NamespaceImport */] = function forEachChildInNamespaceImport(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.name); + }, + _a[277 /* SyntaxKind.NamespaceExport */] = function forEachChildInNamespaceExport(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.name); + }, + _a[272 /* SyntaxKind.NamedImports */] = forEachChildInNamedImportsOrExports, + _a[276 /* SyntaxKind.NamedExports */] = forEachChildInNamedImportsOrExports, + _a[275 /* SyntaxKind.ExportDeclaration */] = function forEachChildInExportDeclaration(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.exportClause) || + visitNode(cbNode, node.moduleSpecifier) || + visitNode(cbNode, node.assertClause); + }, + _a[273 /* SyntaxKind.ImportSpecifier */] = forEachChildInImportOrExportSpecifier, + _a[278 /* SyntaxKind.ExportSpecifier */] = forEachChildInImportOrExportSpecifier, + _a[274 /* SyntaxKind.ExportAssignment */] = function forEachChildInExportAssignment(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.expression); + }, + _a[225 /* SyntaxKind.TemplateExpression */] = function forEachChildInTemplateExpression(node, cbNode, cbNodes) { + return visitNode(cbNode, node.head) || + visitNodes(cbNode, cbNodes, node.templateSpans); + }, + _a[236 /* SyntaxKind.TemplateSpan */] = function forEachChildInTemplateSpan(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.expression) || + visitNode(cbNode, node.literal); + }, + _a[200 /* SyntaxKind.TemplateLiteralType */] = function forEachChildInTemplateLiteralType(node, cbNode, cbNodes) { + return visitNode(cbNode, node.head) || + visitNodes(cbNode, cbNodes, node.templateSpans); + }, + _a[201 /* SyntaxKind.TemplateLiteralTypeSpan */] = function forEachChildInTemplateLiteralTypeSpan(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.type) || + visitNode(cbNode, node.literal); + }, + _a[164 /* SyntaxKind.ComputedPropertyName */] = function forEachChildInComputedPropertyName(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.expression); + }, + _a[294 /* SyntaxKind.HeritageClause */] = function forEachChildInHeritageClause(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.types); + }, + _a[230 /* SyntaxKind.ExpressionWithTypeArguments */] = function forEachChildInExpressionWithTypeArguments(node, cbNode, cbNodes) { + return visitNode(cbNode, node.expression) || + visitNodes(cbNode, cbNodes, node.typeArguments); + }, + _a[280 /* SyntaxKind.ExternalModuleReference */] = function forEachChildInExternalModuleReference(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.expression); + }, + _a[279 /* SyntaxKind.MissingDeclaration */] = function forEachChildInMissingDeclaration(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.illegalDecorators) || + visitNodes(cbNode, cbNodes, node.modifiers); + }, + _a[354 /* SyntaxKind.CommaListExpression */] = function forEachChildInCommaListExpression(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.elements); + }, + _a[281 /* SyntaxKind.JsxElement */] = function forEachChildInJsxElement(node, cbNode, cbNodes) { + return visitNode(cbNode, node.openingElement) || + visitNodes(cbNode, cbNodes, node.children) || + visitNode(cbNode, node.closingElement); + }, + _a[285 /* SyntaxKind.JsxFragment */] = function forEachChildInJsxFragment(node, cbNode, cbNodes) { + return visitNode(cbNode, node.openingFragment) || + visitNodes(cbNode, cbNodes, node.children) || + visitNode(cbNode, node.closingFragment); + }, + _a[282 /* SyntaxKind.JsxSelfClosingElement */] = forEachChildInJsxOpeningOrSelfClosingElement, + _a[283 /* SyntaxKind.JsxOpeningElement */] = forEachChildInJsxOpeningOrSelfClosingElement, + _a[289 /* SyntaxKind.JsxAttributes */] = function forEachChildInJsxAttributes(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.properties); + }, + _a[288 /* SyntaxKind.JsxAttribute */] = function forEachChildInJsxAttribute(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.name) || + visitNode(cbNode, node.initializer); + }, + _a[290 /* SyntaxKind.JsxSpreadAttribute */] = function forEachChildInJsxSpreadAttribute(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.expression); + }, + _a[291 /* SyntaxKind.JsxExpression */] = function forEachChildInJsxExpression(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.dotDotDotToken) || + visitNode(cbNode, node.expression); + }, + _a[284 /* SyntaxKind.JsxClosingElement */] = function forEachChildInJsxClosingElement(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.tagName); + }, + _a[187 /* SyntaxKind.OptionalType */] = forEachChildInOptionalRestOrJSDocParameterModifier, + _a[188 /* SyntaxKind.RestType */] = forEachChildInOptionalRestOrJSDocParameterModifier, + _a[312 /* SyntaxKind.JSDocTypeExpression */] = forEachChildInOptionalRestOrJSDocParameterModifier, + _a[318 /* SyntaxKind.JSDocNonNullableType */] = forEachChildInOptionalRestOrJSDocParameterModifier, + _a[317 /* SyntaxKind.JSDocNullableType */] = forEachChildInOptionalRestOrJSDocParameterModifier, + _a[319 /* SyntaxKind.JSDocOptionalType */] = forEachChildInOptionalRestOrJSDocParameterModifier, + _a[321 /* SyntaxKind.JSDocVariadicType */] = forEachChildInOptionalRestOrJSDocParameterModifier, + _a[320 /* SyntaxKind.JSDocFunctionType */] = function forEachChildInJSDocFunctionType(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type); + }, + _a[323 /* SyntaxKind.JSDoc */] = function forEachChildInJSDoc(node, cbNode, cbNodes) { + return (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)) + || visitNodes(cbNode, cbNodes, node.tags); + }, + _a[349 /* SyntaxKind.JSDocSeeTag */] = function forEachChildInJSDocSeeTag(node, cbNode, cbNodes) { + return visitNode(cbNode, node.tagName) || + visitNode(cbNode, node.name) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + }, + _a[313 /* SyntaxKind.JSDocNameReference */] = function forEachChildInJSDocNameReference(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.name); + }, + _a[314 /* SyntaxKind.JSDocMemberName */] = function forEachChildInJSDocMemberName(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.left) || + visitNode(cbNode, node.right); + }, + _a[343 /* SyntaxKind.JSDocParameterTag */] = forEachChildInJSDocParameterOrPropertyTag, + _a[350 /* SyntaxKind.JSDocPropertyTag */] = forEachChildInJSDocParameterOrPropertyTag, + _a[333 /* SyntaxKind.JSDocAuthorTag */] = function forEachChildInJSDocAuthorTag(node, cbNode, cbNodes) { + return visitNode(cbNode, node.tagName) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + }, + _a[332 /* SyntaxKind.JSDocImplementsTag */] = function forEachChildInJSDocImplementsTag(node, cbNode, cbNodes) { + return visitNode(cbNode, node.tagName) || + visitNode(cbNode, node.class) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + }, + _a[331 /* SyntaxKind.JSDocAugmentsTag */] = function forEachChildInJSDocAugmentsTag(node, cbNode, cbNodes) { + return visitNode(cbNode, node.tagName) || + visitNode(cbNode, node.class) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + }, + _a[347 /* SyntaxKind.JSDocTemplateTag */] = function forEachChildInJSDocTemplateTag(node, cbNode, cbNodes) { + return visitNode(cbNode, node.tagName) || + visitNode(cbNode, node.constraint) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + }, + _a[348 /* SyntaxKind.JSDocTypedefTag */] = function forEachChildInJSDocTypedefTag(node, cbNode, cbNodes) { + return visitNode(cbNode, node.tagName) || + (node.typeExpression && + node.typeExpression.kind === 312 /* SyntaxKind.JSDocTypeExpression */ + ? visitNode(cbNode, node.typeExpression) || + visitNode(cbNode, node.fullName) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)) + : visitNode(cbNode, node.fullName) || + visitNode(cbNode, node.typeExpression) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment))); + }, + _a[341 /* SyntaxKind.JSDocCallbackTag */] = function forEachChildInJSDocCallbackTag(node, cbNode, cbNodes) { + return visitNode(cbNode, node.tagName) || + visitNode(cbNode, node.fullName) || + visitNode(cbNode, node.typeExpression) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + }, + _a[344 /* SyntaxKind.JSDocReturnTag */] = forEachChildInJSDocReturnTag, + _a[346 /* SyntaxKind.JSDocTypeTag */] = forEachChildInJSDocReturnTag, + _a[345 /* SyntaxKind.JSDocThisTag */] = forEachChildInJSDocReturnTag, + _a[342 /* SyntaxKind.JSDocEnumTag */] = forEachChildInJSDocReturnTag, + _a[326 /* SyntaxKind.JSDocSignature */] = function forEachChildInJSDocSignature(node, cbNode, _cbNodes) { + return ts.forEach(node.typeParameters, cbNode) || + ts.forEach(node.parameters, cbNode) || + visitNode(cbNode, node.type); + }, + _a[327 /* SyntaxKind.JSDocLink */] = forEachChildInJSDocLinkCodeOrPlain, + _a[328 /* SyntaxKind.JSDocLinkCode */] = forEachChildInJSDocLinkCodeOrPlain, + _a[329 /* SyntaxKind.JSDocLinkPlain */] = forEachChildInJSDocLinkCodeOrPlain, + _a[325 /* SyntaxKind.JSDocTypeLiteral */] = function forEachChildInJSDocTypeLiteral(node, cbNode, _cbNodes) { + return ts.forEach(node.jsDocPropertyTags, cbNode); + }, + _a[330 /* SyntaxKind.JSDocTag */] = forEachChildInJSDocTag, + _a[335 /* SyntaxKind.JSDocClassTag */] = forEachChildInJSDocTag, + _a[336 /* SyntaxKind.JSDocPublicTag */] = forEachChildInJSDocTag, + _a[337 /* SyntaxKind.JSDocPrivateTag */] = forEachChildInJSDocTag, + _a[338 /* SyntaxKind.JSDocProtectedTag */] = forEachChildInJSDocTag, + _a[339 /* SyntaxKind.JSDocReadonlyTag */] = forEachChildInJSDocTag, + _a[334 /* SyntaxKind.JSDocDeprecatedTag */] = forEachChildInJSDocTag, + _a[340 /* SyntaxKind.JSDocOverrideTag */] = forEachChildInJSDocTag, + _a[353 /* SyntaxKind.PartiallyEmittedExpression */] = forEachChildInPartiallyEmittedExpression, + _a); + // shared + function forEachChildInCallOrConstructSignature(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.parameters) || + visitNode(cbNode, node.type); + } + function forEachChildInUnionOrIntersectionType(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.types); + } + function forEachChildInParenthesizedTypeOrTypeOperator(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.type); + } + function forEachChildInObjectOrArrayBindingPattern(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.elements); + } + function forEachChildInCallOrNewExpression(node, cbNode, cbNodes) { + return visitNode(cbNode, node.expression) || + // TODO: should we separate these branches out? + visitNode(cbNode, node.questionDotToken) || + visitNodes(cbNode, cbNodes, node.typeArguments) || + visitNodes(cbNode, cbNodes, node.arguments); + } + function forEachChildInBlock(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.statements); + } + function forEachChildInContinueOrBreakStatement(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.label); + } + function forEachChildInClassDeclarationOrExpression(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.modifiers) || + visitNode(cbNode, node.name) || + visitNodes(cbNode, cbNodes, node.typeParameters) || + visitNodes(cbNode, cbNodes, node.heritageClauses) || + visitNodes(cbNode, cbNodes, node.members); + } + function forEachChildInNamedImportsOrExports(node, cbNode, cbNodes) { + return visitNodes(cbNode, cbNodes, node.elements); + } + function forEachChildInImportOrExportSpecifier(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.propertyName) || + visitNode(cbNode, node.name); + } + function forEachChildInJsxOpeningOrSelfClosingElement(node, cbNode, cbNodes) { + return visitNode(cbNode, node.tagName) || + visitNodes(cbNode, cbNodes, node.typeArguments) || + visitNode(cbNode, node.attributes); + } + function forEachChildInOptionalRestOrJSDocParameterModifier(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.type); + } + function forEachChildInJSDocParameterOrPropertyTag(node, cbNode, cbNodes) { + return visitNode(cbNode, node.tagName) || + (node.isNameFirst + ? visitNode(cbNode, node.name) || visitNode(cbNode, node.typeExpression) + : visitNode(cbNode, node.typeExpression) || visitNode(cbNode, node.name)) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + } + function forEachChildInJSDocReturnTag(node, cbNode, cbNodes) { + return visitNode(cbNode, node.tagName) || + visitNode(cbNode, node.typeExpression) || + (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + } + function forEachChildInJSDocLinkCodeOrPlain(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.name); + } + function forEachChildInJSDocTag(node, cbNode, cbNodes) { + return visitNode(cbNode, node.tagName) + || (typeof node.comment === "string" ? undefined : visitNodes(cbNode, cbNodes, node.comment)); + } + function forEachChildInPartiallyEmittedExpression(node, cbNode, _cbNodes) { + return visitNode(cbNode, node.expression); + } + /** + * Invokes a callback for each child of the given node. The 'cbNode' callback is invoked for all child nodes + * stored in properties. If a 'cbNodes' callback is specified, it is invoked for embedded arrays; otherwise, + * embedded arrays are flattened and the 'cbNode' callback is invoked for each element. If a callback returns + * a truthy value, iteration stops and that value is returned. Otherwise, undefined is returned. + * + * @param node a given node to visit its children + * @param cbNode a callback to be invoked for all child nodes + * @param cbNodes a callback to be invoked for embedded array + * + * @remarks `forEachChild` must visit the children of a node in the order + * that they appear in the source code. The language service depends on this property to locate nodes by position. + */ + function forEachChild(node, cbNode, cbNodes) { + if (node === undefined || node.kind <= 162 /* SyntaxKind.LastToken */) { + return; + } + var fn = forEachChildTable[node.kind]; + return fn === undefined ? undefined : fn(node, cbNode, cbNodes); + } + ts.forEachChild = forEachChild; + /** @internal */ + /** + * Invokes a callback for each child of the given node. The 'cbNode' callback is invoked for all child nodes + * stored in properties. If a 'cbNodes' callback is specified, it is invoked for embedded arrays; additionally, + * unlike `forEachChild`, embedded arrays are flattened and the 'cbNode' callback is invoked for each element. + * If a callback returns a truthy value, iteration stops and that value is returned. Otherwise, undefined is returned. + * + * @param node a given node to visit its children + * @param cbNode a callback to be invoked for all child nodes + * @param cbNodes a callback to be invoked for embedded array + * + * @remarks Unlike `forEachChild`, `forEachChildRecursively` handles recursively invoking the traversal on each child node found, + * and while doing so, handles traversing the structure without relying on the callstack to encode the tree structure. + */ + function forEachChildRecursively(rootNode, cbNode, cbNodes) { + var queue = gatherPossibleChildren(rootNode); + var parents = []; // tracks parent references for elements in queue + while (parents.length < queue.length) { + parents.push(rootNode); + } + while (queue.length !== 0) { + var current = queue.pop(); + var parent = parents.pop(); + if (ts.isArray(current)) { + if (cbNodes) { + var res = cbNodes(current, parent); + if (res) { + if (res === "skip") + continue; + return res; + } + } + for (var i = current.length - 1; i >= 0; --i) { + queue.push(current[i]); + parents.push(parent); + } + } + else { + var res = cbNode(current, parent); + if (res) { + if (res === "skip") + continue; + return res; + } + if (current.kind >= 163 /* SyntaxKind.FirstNode */) { + // add children in reverse order to the queue, so popping gives the first child + for (var _i = 0, _a = gatherPossibleChildren(current); _i < _a.length; _i++) { + var child = _a[_i]; + queue.push(child); + parents.push(current); + } + } + } + } + } + ts.forEachChildRecursively = forEachChildRecursively; + function gatherPossibleChildren(node) { + var children = []; + forEachChild(node, addWorkItem, addWorkItem); // By using a stack above and `unshift` here, we emulate a depth-first preorder traversal + return children; + function addWorkItem(n) { + children.unshift(n); + } + } + function setExternalModuleIndicator(sourceFile) { + sourceFile.externalModuleIndicator = isFileProbablyExternalModule(sourceFile); + } + function createSourceFile(fileName, sourceText, languageVersionOrOptions, setParentNodes, scriptKind) { + if (setParentNodes === void 0) { setParentNodes = false; } + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("parse" /* tracing.Phase.Parse */, "createSourceFile", { path: fileName }, /*separateBeginAndEnd*/ true); + ts.performance.mark("beforeParse"); + var result; + ts.perfLogger.logStartParseSourceFile(fileName); + var _a = typeof languageVersionOrOptions === "object" ? languageVersionOrOptions : { languageVersion: languageVersionOrOptions }, languageVersion = _a.languageVersion, overrideSetExternalModuleIndicator = _a.setExternalModuleIndicator, format = _a.impliedNodeFormat; + if (languageVersion === 100 /* ScriptTarget.JSON */) { + result = Parser.parseSourceFile(fileName, sourceText, languageVersion, /*syntaxCursor*/ undefined, setParentNodes, 6 /* ScriptKind.JSON */, ts.noop); + } + else { + var setIndicator = format === undefined ? overrideSetExternalModuleIndicator : function (file) { + file.impliedNodeFormat = format; + return (overrideSetExternalModuleIndicator || setExternalModuleIndicator)(file); + }; + result = Parser.parseSourceFile(fileName, sourceText, languageVersion, /*syntaxCursor*/ undefined, setParentNodes, scriptKind, setIndicator); + } + ts.perfLogger.logStopParseSourceFile(); + ts.performance.mark("afterParse"); + ts.performance.measure("Parse", "beforeParse", "afterParse"); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + return result; + } + ts.createSourceFile = createSourceFile; + function parseIsolatedEntityName(text, languageVersion) { + return Parser.parseIsolatedEntityName(text, languageVersion); + } + ts.parseIsolatedEntityName = parseIsolatedEntityName; + /** + * Parse json text into SyntaxTree and return node and parse errors if any + * @param fileName + * @param sourceText + */ + function parseJsonText(fileName, sourceText) { + return Parser.parseJsonText(fileName, sourceText); + } + ts.parseJsonText = parseJsonText; + // See also `isExternalOrCommonJsModule` in utilities.ts + function isExternalModule(file) { + return file.externalModuleIndicator !== undefined; + } + ts.isExternalModule = isExternalModule; + // Produces a new SourceFile for the 'newText' provided. The 'textChangeRange' parameter + // indicates what changed between the 'text' that this SourceFile has and the 'newText'. + // The SourceFile will be created with the compiler attempting to reuse as many nodes from + // this file as possible. + // + // Note: this function mutates nodes from this SourceFile. That means any existing nodes + // from this SourceFile that are being held onto may change as a result (including + // becoming detached from any SourceFile). It is recommended that this SourceFile not + // be used once 'update' is called on it. + function updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks) { + if (aggressiveChecks === void 0) { aggressiveChecks = false; } + var newSourceFile = IncrementalParser.updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks); + // Because new source file node is created, it may not have the flag PossiblyContainDynamicImport. This is the case if there is no new edit to add dynamic import. + // We will manually port the flag to the new source file. + newSourceFile.flags |= (sourceFile.flags & 6291456 /* NodeFlags.PermanentlySetIncrementalFlags */); + return newSourceFile; + } + ts.updateSourceFile = updateSourceFile; + /* @internal */ + function parseIsolatedJSDocComment(content, start, length) { + var result = Parser.JSDocParser.parseIsolatedJSDocComment(content, start, length); + if (result && result.jsDoc) { + // because the jsDocComment was parsed out of the source file, it might + // not be covered by the fixupParentReferences. + Parser.fixupParentReferences(result.jsDoc); + } + return result; + } + ts.parseIsolatedJSDocComment = parseIsolatedJSDocComment; + /* @internal */ + // Exposed only for testing. + function parseJSDocTypeExpressionForTests(content, start, length) { + return Parser.JSDocParser.parseJSDocTypeExpressionForTests(content, start, length); + } + ts.parseJSDocTypeExpressionForTests = parseJSDocTypeExpressionForTests; + // Implement the parser as a singleton module. We do this for perf reasons because creating + // parser instances can actually be expensive enough to impact us on projects with many source + // files. + var Parser; + (function (Parser) { + // Share a single scanner across all calls to parse a source file. This helps speed things + // up by avoiding the cost of creating/compiling scanners over and over again. + var scanner = ts.createScanner(99 /* ScriptTarget.Latest */, /*skipTrivia*/ true); + var disallowInAndDecoratorContext = 4096 /* NodeFlags.DisallowInContext */ | 16384 /* NodeFlags.DecoratorContext */; + // capture constructors in 'initializeState' to avoid null checks + var NodeConstructor; + var TokenConstructor; + var IdentifierConstructor; + var PrivateIdentifierConstructor; + var SourceFileConstructor; + function countNode(node) { + nodeCount++; + return node; + } + // Rather than using `createBaseNodeFactory` here, we establish a `BaseNodeFactory` that closes over the + // constructors above, which are reset each time `initializeState` is called. + var baseNodeFactory = { + createBaseSourceFileNode: function (kind) { return countNode(new SourceFileConstructor(kind, /*pos*/ 0, /*end*/ 0)); }, + createBaseIdentifierNode: function (kind) { return countNode(new IdentifierConstructor(kind, /*pos*/ 0, /*end*/ 0)); }, + createBasePrivateIdentifierNode: function (kind) { return countNode(new PrivateIdentifierConstructor(kind, /*pos*/ 0, /*end*/ 0)); }, + createBaseTokenNode: function (kind) { return countNode(new TokenConstructor(kind, /*pos*/ 0, /*end*/ 0)); }, + createBaseNode: function (kind) { return countNode(new NodeConstructor(kind, /*pos*/ 0, /*end*/ 0)); } + }; + var factory = ts.createNodeFactory(1 /* NodeFactoryFlags.NoParenthesizerRules */ | 2 /* NodeFactoryFlags.NoNodeConverters */ | 8 /* NodeFactoryFlags.NoOriginalNode */, baseNodeFactory); + var fileName; + var sourceFlags; + var sourceText; + var languageVersion; + var scriptKind; + var languageVariant; + var parseDiagnostics; + var jsDocDiagnostics; + var syntaxCursor; + var currentToken; + var nodeCount; + var identifiers; + var privateIdentifiers; + var identifierCount; + var parsingContext; + var notParenthesizedArrow; + // Flags that dictate what parsing context we're in. For example: + // Whether or not we are in strict parsing mode. All that changes in strict parsing mode is + // that some tokens that would be considered identifiers may be considered keywords. + // + // When adding more parser context flags, consider which is the more common case that the + // flag will be in. This should be the 'false' state for that flag. The reason for this is + // that we don't store data in our nodes unless the value is in the *non-default* state. So, + // for example, more often than code 'allows-in' (or doesn't 'disallow-in'). We opt for + // 'disallow-in' set to 'false'. Otherwise, if we had 'allowsIn' set to 'true', then almost + // all nodes would need extra state on them to store this info. + // + // Note: 'allowIn' and 'allowYield' track 1:1 with the [in] and [yield] concepts in the ES6 + // grammar specification. + // + // An important thing about these context concepts. By default they are effectively inherited + // while parsing through every grammar production. i.e. if you don't change them, then when + // you parse a sub-production, it will have the same context values as the parent production. + // This is great most of the time. After all, consider all the 'expression' grammar productions + // and how nearly all of them pass along the 'in' and 'yield' context values: + // + // EqualityExpression[In, Yield] : + // RelationalExpression[?In, ?Yield] + // EqualityExpression[?In, ?Yield] == RelationalExpression[?In, ?Yield] + // EqualityExpression[?In, ?Yield] != RelationalExpression[?In, ?Yield] + // EqualityExpression[?In, ?Yield] === RelationalExpression[?In, ?Yield] + // EqualityExpression[?In, ?Yield] !== RelationalExpression[?In, ?Yield] + // + // Where you have to be careful is then understanding what the points are in the grammar + // where the values are *not* passed along. For example: + // + // SingleNameBinding[Yield,GeneratorParameter] + // [+GeneratorParameter]BindingIdentifier[Yield] Initializer[In]opt + // [~GeneratorParameter]BindingIdentifier[?Yield]Initializer[In, ?Yield]opt + // + // Here this is saying that if the GeneratorParameter context flag is set, that we should + // explicitly set the 'yield' context flag to false before calling into the BindingIdentifier + // and we should explicitly unset the 'yield' context flag before calling into the Initializer. + // production. Conversely, if the GeneratorParameter context flag is not set, then we + // should leave the 'yield' context flag alone. + // + // Getting this all correct is tricky and requires careful reading of the grammar to + // understand when these values should be changed versus when they should be inherited. + // + // Note: it should not be necessary to save/restore these flags during speculative/lookahead + // parsing. These context flags are naturally stored and restored through normal recursive + // descent parsing and unwinding. + var contextFlags; + // Indicates whether we are currently parsing top-level statements. + var topLevel = true; + // Whether or not we've had a parse error since creating the last AST node. If we have + // encountered an error, it will be stored on the next AST node we create. Parse errors + // can be broken down into three categories: + // + // 1) An error that occurred during scanning. For example, an unterminated literal, or a + // character that was completely not understood. + // + // 2) A token was expected, but was not present. This type of error is commonly produced + // by the 'parseExpected' function. + // + // 3) A token was present that no parsing function was able to consume. This type of error + // only occurs in the 'abortParsingListOrMoveToNextToken' function when the parser + // decides to skip the token. + // + // In all of these cases, we want to mark the next node as having had an error before it. + // With this mark, we can know in incremental settings if this node can be reused, or if + // we have to reparse it. If we don't keep this information around, we may just reuse the + // node. in that event we would then not produce the same errors as we did before, causing + // significant confusion problems. + // + // Note: it is necessary that this value be saved/restored during speculative/lookahead + // parsing. During lookahead parsing, we will often create a node. That node will have + // this value attached, and then this value will be set back to 'false'. If we decide to + // rewind, we must get back to the same value we had prior to the lookahead. + // + // Note: any errors at the end of the file that do not precede a regular node, should get + // attached to the EOF token. + var parseErrorBeforeNextFinishedNode = false; + function parseSourceFile(fileName, sourceText, languageVersion, syntaxCursor, setParentNodes, scriptKind, setExternalModuleIndicatorOverride) { + var _a; + if (setParentNodes === void 0) { setParentNodes = false; } + scriptKind = ts.ensureScriptKind(fileName, scriptKind); + if (scriptKind === 6 /* ScriptKind.JSON */) { + var result_3 = parseJsonText(fileName, sourceText, languageVersion, syntaxCursor, setParentNodes); + ts.convertToObjectWorker(result_3, (_a = result_3.statements[0]) === null || _a === void 0 ? void 0 : _a.expression, result_3.parseDiagnostics, /*returnValue*/ false, /*knownRootOptions*/ undefined, /*jsonConversionNotifier*/ undefined); + result_3.referencedFiles = ts.emptyArray; + result_3.typeReferenceDirectives = ts.emptyArray; + result_3.libReferenceDirectives = ts.emptyArray; + result_3.amdDependencies = ts.emptyArray; + result_3.hasNoDefaultLib = false; + result_3.pragmas = ts.emptyMap; + return result_3; + } + initializeState(fileName, sourceText, languageVersion, syntaxCursor, scriptKind); + var result = parseSourceFileWorker(languageVersion, setParentNodes, scriptKind, setExternalModuleIndicatorOverride || setExternalModuleIndicator); + clearState(); + return result; + } + Parser.parseSourceFile = parseSourceFile; + function parseIsolatedEntityName(content, languageVersion) { + // Choice of `isDeclarationFile` should be arbitrary + initializeState("", content, languageVersion, /*syntaxCursor*/ undefined, 1 /* ScriptKind.JS */); + // Prime the scanner. + nextToken(); + var entityName = parseEntityName(/*allowReservedWords*/ true); + var isInvalid = token() === 1 /* SyntaxKind.EndOfFileToken */ && !parseDiagnostics.length; + clearState(); + return isInvalid ? entityName : undefined; + } + Parser.parseIsolatedEntityName = parseIsolatedEntityName; + function parseJsonText(fileName, sourceText, languageVersion, syntaxCursor, setParentNodes) { + if (languageVersion === void 0) { languageVersion = 2 /* ScriptTarget.ES2015 */; } + if (setParentNodes === void 0) { setParentNodes = false; } + initializeState(fileName, sourceText, languageVersion, syntaxCursor, 6 /* ScriptKind.JSON */); + sourceFlags = contextFlags; + // Prime the scanner. + nextToken(); + var pos = getNodePos(); + var statements, endOfFileToken; + if (token() === 1 /* SyntaxKind.EndOfFileToken */) { + statements = createNodeArray([], pos, pos); + endOfFileToken = parseTokenNode(); + } + else { + // Loop and synthesize an ArrayLiteralExpression if there are more than + // one top-level expressions to ensure all input text is consumed. + var expressions = void 0; + while (token() !== 1 /* SyntaxKind.EndOfFileToken */) { + var expression_1 = void 0; + switch (token()) { + case 22 /* SyntaxKind.OpenBracketToken */: + expression_1 = parseArrayLiteralExpression(); + break; + case 110 /* SyntaxKind.TrueKeyword */: + case 95 /* SyntaxKind.FalseKeyword */: + case 104 /* SyntaxKind.NullKeyword */: + expression_1 = parseTokenNode(); + break; + case 40 /* SyntaxKind.MinusToken */: + if (lookAhead(function () { return nextToken() === 8 /* SyntaxKind.NumericLiteral */ && nextToken() !== 58 /* SyntaxKind.ColonToken */; })) { + expression_1 = parsePrefixUnaryExpression(); + } + else { + expression_1 = parseObjectLiteralExpression(); + } + break; + case 8 /* SyntaxKind.NumericLiteral */: + case 10 /* SyntaxKind.StringLiteral */: + if (lookAhead(function () { return nextToken() !== 58 /* SyntaxKind.ColonToken */; })) { + expression_1 = parseLiteralNode(); + break; + } + // falls through + default: + expression_1 = parseObjectLiteralExpression(); + break; + } + // Error recovery: collect multiple top-level expressions + if (expressions && ts.isArray(expressions)) { + expressions.push(expression_1); + } + else if (expressions) { + expressions = [expressions, expression_1]; + } + else { + expressions = expression_1; + if (token() !== 1 /* SyntaxKind.EndOfFileToken */) { + parseErrorAtCurrentToken(ts.Diagnostics.Unexpected_token); + } + } + } + var expression = ts.isArray(expressions) ? finishNode(factory.createArrayLiteralExpression(expressions), pos) : ts.Debug.checkDefined(expressions); + var statement = factory.createExpressionStatement(expression); + finishNode(statement, pos); + statements = createNodeArray([statement], pos); + endOfFileToken = parseExpectedToken(1 /* SyntaxKind.EndOfFileToken */, ts.Diagnostics.Unexpected_token); + } + // Set source file so that errors will be reported with this file name + var sourceFile = createSourceFile(fileName, 2 /* ScriptTarget.ES2015 */, 6 /* ScriptKind.JSON */, /*isDeclaration*/ false, statements, endOfFileToken, sourceFlags, ts.noop); + if (setParentNodes) { + fixupParentReferences(sourceFile); + } + sourceFile.nodeCount = nodeCount; + sourceFile.identifierCount = identifierCount; + sourceFile.identifiers = identifiers; + sourceFile.parseDiagnostics = ts.attachFileToDiagnostics(parseDiagnostics, sourceFile); + if (jsDocDiagnostics) { + sourceFile.jsDocDiagnostics = ts.attachFileToDiagnostics(jsDocDiagnostics, sourceFile); + } + var result = sourceFile; + clearState(); + return result; + } + Parser.parseJsonText = parseJsonText; + function initializeState(_fileName, _sourceText, _languageVersion, _syntaxCursor, _scriptKind) { + NodeConstructor = ts.objectAllocator.getNodeConstructor(); + TokenConstructor = ts.objectAllocator.getTokenConstructor(); + IdentifierConstructor = ts.objectAllocator.getIdentifierConstructor(); + PrivateIdentifierConstructor = ts.objectAllocator.getPrivateIdentifierConstructor(); + SourceFileConstructor = ts.objectAllocator.getSourceFileConstructor(); + fileName = ts.normalizePath(_fileName); + sourceText = _sourceText; + languageVersion = _languageVersion; + syntaxCursor = _syntaxCursor; + scriptKind = _scriptKind; + languageVariant = ts.getLanguageVariant(_scriptKind); + parseDiagnostics = []; + parsingContext = 0; + identifiers = new ts.Map(); + privateIdentifiers = new ts.Map(); + identifierCount = 0; + nodeCount = 0; + sourceFlags = 0; + topLevel = true; + switch (scriptKind) { + case 1 /* ScriptKind.JS */: + case 2 /* ScriptKind.JSX */: + contextFlags = 262144 /* NodeFlags.JavaScriptFile */; + break; + case 6 /* ScriptKind.JSON */: + contextFlags = 262144 /* NodeFlags.JavaScriptFile */ | 67108864 /* NodeFlags.JsonFile */; + break; + default: + contextFlags = 0 /* NodeFlags.None */; + break; + } + parseErrorBeforeNextFinishedNode = false; + // Initialize and prime the scanner before parsing the source elements. + scanner.setText(sourceText); + scanner.setOnError(scanError); + scanner.setScriptTarget(languageVersion); + scanner.setLanguageVariant(languageVariant); + } + function clearState() { + // Clear out the text the scanner is pointing at, so it doesn't keep anything alive unnecessarily. + scanner.clearCommentDirectives(); + scanner.setText(""); + scanner.setOnError(undefined); + // Clear any data. We don't want to accidentally hold onto it for too long. + sourceText = undefined; + languageVersion = undefined; + syntaxCursor = undefined; + scriptKind = undefined; + languageVariant = undefined; + sourceFlags = 0; + parseDiagnostics = undefined; + jsDocDiagnostics = undefined; + parsingContext = 0; + identifiers = undefined; + notParenthesizedArrow = undefined; + topLevel = true; + } + function parseSourceFileWorker(languageVersion, setParentNodes, scriptKind, setExternalModuleIndicator) { + var isDeclarationFile = isDeclarationFileName(fileName); + if (isDeclarationFile) { + contextFlags |= 16777216 /* NodeFlags.Ambient */; + } + sourceFlags = contextFlags; + // Prime the scanner. + nextToken(); + var statements = parseList(0 /* ParsingContext.SourceElements */, parseStatement); + ts.Debug.assert(token() === 1 /* SyntaxKind.EndOfFileToken */); + var endOfFileToken = addJSDocComment(parseTokenNode()); + var sourceFile = createSourceFile(fileName, languageVersion, scriptKind, isDeclarationFile, statements, endOfFileToken, sourceFlags, setExternalModuleIndicator); + // A member of ReadonlyArray isn't assignable to a member of T[] (and prevents a direct cast) - but this is where we set up those members so they can be readonly in the future + processCommentPragmas(sourceFile, sourceText); + processPragmasIntoFields(sourceFile, reportPragmaDiagnostic); + sourceFile.commentDirectives = scanner.getCommentDirectives(); + sourceFile.nodeCount = nodeCount; + sourceFile.identifierCount = identifierCount; + sourceFile.identifiers = identifiers; + sourceFile.parseDiagnostics = ts.attachFileToDiagnostics(parseDiagnostics, sourceFile); + if (jsDocDiagnostics) { + sourceFile.jsDocDiagnostics = ts.attachFileToDiagnostics(jsDocDiagnostics, sourceFile); + } + if (setParentNodes) { + fixupParentReferences(sourceFile); + } + return sourceFile; + function reportPragmaDiagnostic(pos, end, diagnostic) { + parseDiagnostics.push(ts.createDetachedDiagnostic(fileName, pos, end, diagnostic)); + } + } + function withJSDoc(node, hasJSDoc) { + return hasJSDoc ? addJSDocComment(node) : node; + } + var hasDeprecatedTag = false; + function addJSDocComment(node) { + ts.Debug.assert(!node.jsDoc); // Should only be called once per node + var jsDoc = ts.mapDefined(ts.getJSDocCommentRanges(node, sourceText), function (comment) { return JSDocParser.parseJSDocComment(node, comment.pos, comment.end - comment.pos); }); + if (jsDoc.length) + node.jsDoc = jsDoc; + if (hasDeprecatedTag) { + hasDeprecatedTag = false; + node.flags |= 268435456 /* NodeFlags.Deprecated */; + } + return node; + } + function reparseTopLevelAwait(sourceFile) { + var savedSyntaxCursor = syntaxCursor; + var baseSyntaxCursor = IncrementalParser.createSyntaxCursor(sourceFile); + syntaxCursor = { currentNode: currentNode }; + var statements = []; + var savedParseDiagnostics = parseDiagnostics; + parseDiagnostics = []; + var pos = 0; + var start = findNextStatementWithAwait(sourceFile.statements, 0); + var _loop_3 = function () { + // append all statements between pos and start + var prevStatement = sourceFile.statements[pos]; + var nextStatement = sourceFile.statements[start]; + ts.addRange(statements, sourceFile.statements, pos, start); + pos = findNextStatementWithoutAwait(sourceFile.statements, start); + // append all diagnostics associated with the copied range + var diagnosticStart = ts.findIndex(savedParseDiagnostics, function (diagnostic) { return diagnostic.start >= prevStatement.pos; }); + var diagnosticEnd = diagnosticStart >= 0 ? ts.findIndex(savedParseDiagnostics, function (diagnostic) { return diagnostic.start >= nextStatement.pos; }, diagnosticStart) : -1; + if (diagnosticStart >= 0) { + ts.addRange(parseDiagnostics, savedParseDiagnostics, diagnosticStart, diagnosticEnd >= 0 ? diagnosticEnd : undefined); + } + // reparse all statements between start and pos. We skip existing diagnostics for the same range and allow the parser to generate new ones. + speculationHelper(function () { + var savedContextFlags = contextFlags; + contextFlags |= 32768 /* NodeFlags.AwaitContext */; + scanner.setTextPos(nextStatement.pos); + nextToken(); + while (token() !== 1 /* SyntaxKind.EndOfFileToken */) { + var startPos = scanner.getStartPos(); + var statement = parseListElement(0 /* ParsingContext.SourceElements */, parseStatement); + statements.push(statement); + if (startPos === scanner.getStartPos()) { + nextToken(); + } + if (pos >= 0) { + var nonAwaitStatement = sourceFile.statements[pos]; + if (statement.end === nonAwaitStatement.pos) { + // done reparsing this section + break; + } + if (statement.end > nonAwaitStatement.pos) { + // we ate into the next statement, so we must reparse it. + pos = findNextStatementWithoutAwait(sourceFile.statements, pos + 1); + } + } + } + contextFlags = savedContextFlags; + }, 2 /* SpeculationKind.Reparse */); + // find the next statement containing an `await` + start = pos >= 0 ? findNextStatementWithAwait(sourceFile.statements, pos) : -1; + }; + while (start !== -1) { + _loop_3(); + } + // append all statements between pos and the end of the list + if (pos >= 0) { + var prevStatement_1 = sourceFile.statements[pos]; + ts.addRange(statements, sourceFile.statements, pos); + // append all diagnostics associated with the copied range + var diagnosticStart = ts.findIndex(savedParseDiagnostics, function (diagnostic) { return diagnostic.start >= prevStatement_1.pos; }); + if (diagnosticStart >= 0) { + ts.addRange(parseDiagnostics, savedParseDiagnostics, diagnosticStart); + } + } + syntaxCursor = savedSyntaxCursor; + return factory.updateSourceFile(sourceFile, ts.setTextRange(factory.createNodeArray(statements), sourceFile.statements)); + function containsPossibleTopLevelAwait(node) { + return !(node.flags & 32768 /* NodeFlags.AwaitContext */) + && !!(node.transformFlags & 67108864 /* TransformFlags.ContainsPossibleTopLevelAwait */); + } + function findNextStatementWithAwait(statements, start) { + for (var i = start; i < statements.length; i++) { + if (containsPossibleTopLevelAwait(statements[i])) { + return i; + } + } + return -1; + } + function findNextStatementWithoutAwait(statements, start) { + for (var i = start; i < statements.length; i++) { + if (!containsPossibleTopLevelAwait(statements[i])) { + return i; + } + } + return -1; + } + function currentNode(position) { + var node = baseSyntaxCursor.currentNode(position); + if (topLevel && node && containsPossibleTopLevelAwait(node)) { + node.intersectsChange = true; + } + return node; + } + } + function fixupParentReferences(rootNode) { + // normally parent references are set during binding. However, for clients that only need + // a syntax tree, and no semantic features, then the binding process is an unnecessary + // overhead. This functions allows us to set all the parents, without all the expense of + // binding. + ts.setParentRecursive(rootNode, /*incremental*/ true); + } + Parser.fixupParentReferences = fixupParentReferences; + function createSourceFile(fileName, languageVersion, scriptKind, isDeclarationFile, statements, endOfFileToken, flags, setExternalModuleIndicator) { + // code from createNode is inlined here so createNode won't have to deal with special case of creating source files + // this is quite rare comparing to other nodes and createNode should be as fast as possible + var sourceFile = factory.createSourceFile(statements, endOfFileToken, flags); + ts.setTextRangePosWidth(sourceFile, 0, sourceText.length); + setFields(sourceFile); + // If we parsed this as an external module, it may contain top-level await + if (!isDeclarationFile && isExternalModule(sourceFile) && sourceFile.transformFlags & 67108864 /* TransformFlags.ContainsPossibleTopLevelAwait */) { + sourceFile = reparseTopLevelAwait(sourceFile); + setFields(sourceFile); + } + return sourceFile; + function setFields(sourceFile) { + sourceFile.text = sourceText; + sourceFile.bindDiagnostics = []; + sourceFile.bindSuggestionDiagnostics = undefined; + sourceFile.languageVersion = languageVersion; + sourceFile.fileName = fileName; + sourceFile.languageVariant = ts.getLanguageVariant(scriptKind); + sourceFile.isDeclarationFile = isDeclarationFile; + sourceFile.scriptKind = scriptKind; + setExternalModuleIndicator(sourceFile); + sourceFile.setExternalModuleIndicator = setExternalModuleIndicator; + } + } + function setContextFlag(val, flag) { + if (val) { + contextFlags |= flag; + } + else { + contextFlags &= ~flag; + } + } + function setDisallowInContext(val) { + setContextFlag(val, 4096 /* NodeFlags.DisallowInContext */); + } + function setYieldContext(val) { + setContextFlag(val, 8192 /* NodeFlags.YieldContext */); + } + function setDecoratorContext(val) { + setContextFlag(val, 16384 /* NodeFlags.DecoratorContext */); + } + function setAwaitContext(val) { + setContextFlag(val, 32768 /* NodeFlags.AwaitContext */); + } + function doOutsideOfContext(context, func) { + // contextFlagsToClear will contain only the context flags that are + // currently set that we need to temporarily clear + // We don't just blindly reset to the previous flags to ensure + // that we do not mutate cached flags for the incremental + // parser (ThisNodeHasError, ThisNodeOrAnySubNodesHasError, and + // HasAggregatedChildData). + var contextFlagsToClear = context & contextFlags; + if (contextFlagsToClear) { + // clear the requested context flags + setContextFlag(/*val*/ false, contextFlagsToClear); + var result = func(); + // restore the context flags we just cleared + setContextFlag(/*val*/ true, contextFlagsToClear); + return result; + } + // no need to do anything special as we are not in any of the requested contexts + return func(); + } + function doInsideOfContext(context, func) { + // contextFlagsToSet will contain only the context flags that + // are not currently set that we need to temporarily enable. + // We don't just blindly reset to the previous flags to ensure + // that we do not mutate cached flags for the incremental + // parser (ThisNodeHasError, ThisNodeOrAnySubNodesHasError, and + // HasAggregatedChildData). + var contextFlagsToSet = context & ~contextFlags; + if (contextFlagsToSet) { + // set the requested context flags + setContextFlag(/*val*/ true, contextFlagsToSet); + var result = func(); + // reset the context flags we just set + setContextFlag(/*val*/ false, contextFlagsToSet); + return result; + } + // no need to do anything special as we are already in all of the requested contexts + return func(); + } + function allowInAnd(func) { + return doOutsideOfContext(4096 /* NodeFlags.DisallowInContext */, func); + } + function disallowInAnd(func) { + return doInsideOfContext(4096 /* NodeFlags.DisallowInContext */, func); + } + function allowConditionalTypesAnd(func) { + return doOutsideOfContext(65536 /* NodeFlags.DisallowConditionalTypesContext */, func); + } + function disallowConditionalTypesAnd(func) { + return doInsideOfContext(65536 /* NodeFlags.DisallowConditionalTypesContext */, func); + } + function doInYieldContext(func) { + return doInsideOfContext(8192 /* NodeFlags.YieldContext */, func); + } + function doInDecoratorContext(func) { + return doInsideOfContext(16384 /* NodeFlags.DecoratorContext */, func); + } + function doInAwaitContext(func) { + return doInsideOfContext(32768 /* NodeFlags.AwaitContext */, func); + } + function doOutsideOfAwaitContext(func) { + return doOutsideOfContext(32768 /* NodeFlags.AwaitContext */, func); + } + function doInYieldAndAwaitContext(func) { + return doInsideOfContext(8192 /* NodeFlags.YieldContext */ | 32768 /* NodeFlags.AwaitContext */, func); + } + function doOutsideOfYieldAndAwaitContext(func) { + return doOutsideOfContext(8192 /* NodeFlags.YieldContext */ | 32768 /* NodeFlags.AwaitContext */, func); + } + function inContext(flags) { + return (contextFlags & flags) !== 0; + } + function inYieldContext() { + return inContext(8192 /* NodeFlags.YieldContext */); + } + function inDisallowInContext() { + return inContext(4096 /* NodeFlags.DisallowInContext */); + } + function inDisallowConditionalTypesContext() { + return inContext(65536 /* NodeFlags.DisallowConditionalTypesContext */); + } + function inDecoratorContext() { + return inContext(16384 /* NodeFlags.DecoratorContext */); + } + function inAwaitContext() { + return inContext(32768 /* NodeFlags.AwaitContext */); + } + function parseErrorAtCurrentToken(message, arg0) { + return parseErrorAt(scanner.getTokenPos(), scanner.getTextPos(), message, arg0); + } + function parseErrorAtPosition(start, length, message, arg0) { + // Don't report another error if it would just be at the same position as the last error. + var lastError = ts.lastOrUndefined(parseDiagnostics); + var result; + if (!lastError || start !== lastError.start) { + result = ts.createDetachedDiagnostic(fileName, start, length, message, arg0); + parseDiagnostics.push(result); + } + // Mark that we've encountered an error. We'll set an appropriate bit on the next + // node we finish so that it can't be reused incrementally. + parseErrorBeforeNextFinishedNode = true; + return result; + } + function parseErrorAt(start, end, message, arg0) { + return parseErrorAtPosition(start, end - start, message, arg0); + } + function parseErrorAtRange(range, message, arg0) { + parseErrorAt(range.pos, range.end, message, arg0); + } + function scanError(message, length) { + parseErrorAtPosition(scanner.getTextPos(), length, message); + } + function getNodePos() { + return scanner.getStartPos(); + } + function hasPrecedingJSDocComment() { + return scanner.hasPrecedingJSDocComment(); + } + // Use this function to access the current token instead of reading the currentToken + // variable. Since function results aren't narrowed in control flow analysis, this ensures + // that the type checker doesn't make wrong assumptions about the type of the current + // token (e.g. a call to nextToken() changes the current token but the checker doesn't + // reason about this side effect). Mainstream VMs inline simple functions like this, so + // there is no performance penalty. + function token() { + return currentToken; + } + function nextTokenWithoutCheck() { + return currentToken = scanner.scan(); + } + function nextTokenAnd(func) { + nextToken(); + return func(); + } + function nextToken() { + // if the keyword had an escape + if (ts.isKeyword(currentToken) && (scanner.hasUnicodeEscape() || scanner.hasExtendedUnicodeEscape())) { + // issue a parse error for the escape + parseErrorAt(scanner.getTokenPos(), scanner.getTextPos(), ts.Diagnostics.Keywords_cannot_contain_escape_characters); + } + return nextTokenWithoutCheck(); + } + function nextTokenJSDoc() { + return currentToken = scanner.scanJsDocToken(); + } + function reScanGreaterToken() { + return currentToken = scanner.reScanGreaterToken(); + } + function reScanSlashToken() { + return currentToken = scanner.reScanSlashToken(); + } + function reScanTemplateToken(isTaggedTemplate) { + return currentToken = scanner.reScanTemplateToken(isTaggedTemplate); + } + function reScanTemplateHeadOrNoSubstitutionTemplate() { + return currentToken = scanner.reScanTemplateHeadOrNoSubstitutionTemplate(); + } + function reScanLessThanToken() { + return currentToken = scanner.reScanLessThanToken(); + } + function reScanHashToken() { + return currentToken = scanner.reScanHashToken(); + } + function scanJsxIdentifier() { + return currentToken = scanner.scanJsxIdentifier(); + } + function scanJsxText() { + return currentToken = scanner.scanJsxToken(); + } + function scanJsxAttributeValue() { + return currentToken = scanner.scanJsxAttributeValue(); + } + function speculationHelper(callback, speculationKind) { + // Keep track of the state we'll need to rollback to if lookahead fails (or if the + // caller asked us to always reset our state). + var saveToken = currentToken; + var saveParseDiagnosticsLength = parseDiagnostics.length; + var saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode; + // Note: it is not actually necessary to save/restore the context flags here. That's + // because the saving/restoring of these flags happens naturally through the recursive + // descent nature of our parser. However, we still store this here just so we can + // assert that invariant holds. + var saveContextFlags = contextFlags; + // If we're only looking ahead, then tell the scanner to only lookahead as well. + // Otherwise, if we're actually speculatively parsing, then tell the scanner to do the + // same. + var result = speculationKind !== 0 /* SpeculationKind.TryParse */ + ? scanner.lookAhead(callback) + : scanner.tryScan(callback); + ts.Debug.assert(saveContextFlags === contextFlags); + // If our callback returned something 'falsy' or we're just looking ahead, + // then unconditionally restore us to where we were. + if (!result || speculationKind !== 0 /* SpeculationKind.TryParse */) { + currentToken = saveToken; + if (speculationKind !== 2 /* SpeculationKind.Reparse */) { + parseDiagnostics.length = saveParseDiagnosticsLength; + } + parseErrorBeforeNextFinishedNode = saveParseErrorBeforeNextFinishedNode; + } + return result; + } + /** Invokes the provided callback then unconditionally restores the parser to the state it + * was in immediately prior to invoking the callback. The result of invoking the callback + * is returned from this function. + */ + function lookAhead(callback) { + return speculationHelper(callback, 1 /* SpeculationKind.Lookahead */); + } + /** Invokes the provided callback. If the callback returns something falsy, then it restores + * the parser to the state it was in immediately prior to invoking the callback. If the + * callback returns something truthy, then the parser state is not rolled back. The result + * of invoking the callback is returned from this function. + */ + function tryParse(callback) { + return speculationHelper(callback, 0 /* SpeculationKind.TryParse */); + } + function isBindingIdentifier() { + if (token() === 79 /* SyntaxKind.Identifier */) { + return true; + } + // `let await`/`let yield` in [Yield] or [Await] are allowed here and disallowed in the binder. + return token() > 116 /* SyntaxKind.LastReservedWord */; + } + // Ignore strict mode flag because we will report an error in type checker instead. + function isIdentifier() { + if (token() === 79 /* SyntaxKind.Identifier */) { + return true; + } + // If we have a 'yield' keyword, and we're in the [yield] context, then 'yield' is + // considered a keyword and is not an identifier. + if (token() === 125 /* SyntaxKind.YieldKeyword */ && inYieldContext()) { + return false; + } + // If we have a 'await' keyword, and we're in the [Await] context, then 'await' is + // considered a keyword and is not an identifier. + if (token() === 133 /* SyntaxKind.AwaitKeyword */ && inAwaitContext()) { + return false; + } + return token() > 116 /* SyntaxKind.LastReservedWord */; + } + function parseExpected(kind, diagnosticMessage, shouldAdvance) { + if (shouldAdvance === void 0) { shouldAdvance = true; } + if (token() === kind) { + if (shouldAdvance) { + nextToken(); + } + return true; + } + // Report specific message if provided with one. Otherwise, report generic fallback message. + if (diagnosticMessage) { + parseErrorAtCurrentToken(diagnosticMessage); + } + else { + parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.tokenToString(kind)); + } + return false; + } + var viableKeywordSuggestions = Object.keys(ts.textToKeywordObj).filter(function (keyword) { return keyword.length > 2; }); + /** + * Provides a better error message than the generic "';' expected" if possible for + * known common variants of a missing semicolon, such as from a mispelled names. + * + * @param node Node preceding the expected semicolon location. + */ + function parseErrorForMissingSemicolonAfter(node) { + var _a; + // Tagged template literals are sometimes used in places where only simple strings are allowed, i.e.: + // module `M1` { + // ^^^^^^^^^^^ This block is parsed as a template literal like module`M1`. + if (ts.isTaggedTemplateExpression(node)) { + parseErrorAt(ts.skipTrivia(sourceText, node.template.pos), node.template.end, ts.Diagnostics.Module_declaration_names_may_only_use_or_quoted_strings); + return; + } + // Otherwise, if this isn't a well-known keyword-like identifier, give the generic fallback message. + var expressionText = ts.isIdentifier(node) ? ts.idText(node) : undefined; + if (!expressionText || !ts.isIdentifierText(expressionText, languageVersion)) { + parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.tokenToString(26 /* SyntaxKind.SemicolonToken */)); + return; + } + var pos = ts.skipTrivia(sourceText, node.pos); + // Some known keywords are likely signs of syntax being used improperly. + switch (expressionText) { + case "const": + case "let": + case "var": + parseErrorAt(pos, node.end, ts.Diagnostics.Variable_declaration_not_allowed_at_this_location); + return; + case "declare": + // If a declared node failed to parse, it would have emitted a diagnostic already. + return; + case "interface": + parseErrorForInvalidName(ts.Diagnostics.Interface_name_cannot_be_0, ts.Diagnostics.Interface_must_be_given_a_name, 18 /* SyntaxKind.OpenBraceToken */); + return; + case "is": + parseErrorAt(pos, scanner.getTextPos(), ts.Diagnostics.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods); + return; + case "module": + case "namespace": + parseErrorForInvalidName(ts.Diagnostics.Namespace_name_cannot_be_0, ts.Diagnostics.Namespace_must_be_given_a_name, 18 /* SyntaxKind.OpenBraceToken */); + return; + case "type": + parseErrorForInvalidName(ts.Diagnostics.Type_alias_name_cannot_be_0, ts.Diagnostics.Type_alias_must_be_given_a_name, 63 /* SyntaxKind.EqualsToken */); + return; + } + // The user alternatively might have misspelled or forgotten to add a space after a common keyword. + var suggestion = (_a = ts.getSpellingSuggestion(expressionText, viableKeywordSuggestions, function (n) { return n; })) !== null && _a !== void 0 ? _a : getSpaceSuggestion(expressionText); + if (suggestion) { + parseErrorAt(pos, node.end, ts.Diagnostics.Unknown_keyword_or_identifier_Did_you_mean_0, suggestion); + return; + } + // Unknown tokens are handled with their own errors in the scanner + if (token() === 0 /* SyntaxKind.Unknown */) { + return; + } + // Otherwise, we know this some kind of unknown word, not just a missing expected semicolon. + parseErrorAt(pos, node.end, ts.Diagnostics.Unexpected_keyword_or_identifier); + } + /** + * Reports a diagnostic error for the current token being an invalid name. + * + * @param blankDiagnostic Diagnostic to report for the case of the name being blank (matched tokenIfBlankName). + * @param nameDiagnostic Diagnostic to report for all other cases. + * @param tokenIfBlankName Current token if the name was invalid for being blank (not provided / skipped). + */ + function parseErrorForInvalidName(nameDiagnostic, blankDiagnostic, tokenIfBlankName) { + if (token() === tokenIfBlankName) { + parseErrorAtCurrentToken(blankDiagnostic); + } + else { + parseErrorAtCurrentToken(nameDiagnostic, scanner.getTokenValue()); + } + } + function getSpaceSuggestion(expressionText) { + for (var _i = 0, viableKeywordSuggestions_1 = viableKeywordSuggestions; _i < viableKeywordSuggestions_1.length; _i++) { + var keyword = viableKeywordSuggestions_1[_i]; + if (expressionText.length > keyword.length + 2 && ts.startsWith(expressionText, keyword)) { + return "".concat(keyword, " ").concat(expressionText.slice(keyword.length)); + } + } + return undefined; + } + function parseSemicolonAfterPropertyName(name, type, initializer) { + if (token() === 59 /* SyntaxKind.AtToken */ && !scanner.hasPrecedingLineBreak()) { + parseErrorAtCurrentToken(ts.Diagnostics.Decorators_must_precede_the_name_and_all_keywords_of_property_declarations); + return; + } + if (token() === 20 /* SyntaxKind.OpenParenToken */) { + parseErrorAtCurrentToken(ts.Diagnostics.Cannot_start_a_function_call_in_a_type_annotation); + nextToken(); + return; + } + if (type && !canParseSemicolon()) { + if (initializer) { + parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.tokenToString(26 /* SyntaxKind.SemicolonToken */)); + } + else { + parseErrorAtCurrentToken(ts.Diagnostics.Expected_for_property_initializer); + } + return; + } + if (tryParseSemicolon()) { + return; + } + if (initializer) { + parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.tokenToString(26 /* SyntaxKind.SemicolonToken */)); + return; + } + parseErrorForMissingSemicolonAfter(name); + } + function parseExpectedJSDoc(kind) { + if (token() === kind) { + nextTokenJSDoc(); + return true; + } + parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.tokenToString(kind)); + return false; + } + function parseExpectedMatchingBrackets(openKind, closeKind, openParsed, openPosition) { + if (token() === closeKind) { + nextToken(); + return; + } + var lastError = parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.tokenToString(closeKind)); + if (!openParsed) { + return; + } + if (lastError) { + ts.addRelatedInfo(lastError, ts.createDetachedDiagnostic(fileName, openPosition, 1, ts.Diagnostics.The_parser_expected_to_find_a_1_to_match_the_0_token_here, ts.tokenToString(openKind), ts.tokenToString(closeKind))); + } + } + function parseOptional(t) { + if (token() === t) { + nextToken(); + return true; + } + return false; + } + function parseOptionalToken(t) { + if (token() === t) { + return parseTokenNode(); + } + return undefined; + } + function parseOptionalTokenJSDoc(t) { + if (token() === t) { + return parseTokenNodeJSDoc(); + } + return undefined; + } + function parseExpectedToken(t, diagnosticMessage, arg0) { + return parseOptionalToken(t) || + createMissingNode(t, /*reportAtCurrentPosition*/ false, diagnosticMessage || ts.Diagnostics._0_expected, arg0 || ts.tokenToString(t)); + } + function parseExpectedTokenJSDoc(t) { + return parseOptionalTokenJSDoc(t) || + createMissingNode(t, /*reportAtCurrentPosition*/ false, ts.Diagnostics._0_expected, ts.tokenToString(t)); + } + function parseTokenNode() { + var pos = getNodePos(); + var kind = token(); + nextToken(); + return finishNode(factory.createToken(kind), pos); + } + function parseTokenNodeJSDoc() { + var pos = getNodePos(); + var kind = token(); + nextTokenJSDoc(); + return finishNode(factory.createToken(kind), pos); + } + function canParseSemicolon() { + // If there's a real semicolon, then we can always parse it out. + if (token() === 26 /* SyntaxKind.SemicolonToken */) { + return true; + } + // We can parse out an optional semicolon in ASI cases in the following cases. + return token() === 19 /* SyntaxKind.CloseBraceToken */ || token() === 1 /* SyntaxKind.EndOfFileToken */ || scanner.hasPrecedingLineBreak(); + } + function tryParseSemicolon() { + if (!canParseSemicolon()) { + return false; + } + if (token() === 26 /* SyntaxKind.SemicolonToken */) { + // consume the semicolon if it was explicitly provided. + nextToken(); + } + return true; + } + function parseSemicolon() { + return tryParseSemicolon() || parseExpected(26 /* SyntaxKind.SemicolonToken */); + } + function createNodeArray(elements, pos, end, hasTrailingComma) { + var array = factory.createNodeArray(elements, hasTrailingComma); + ts.setTextRangePosEnd(array, pos, end !== null && end !== void 0 ? end : scanner.getStartPos()); + return array; + } + function finishNode(node, pos, end) { + ts.setTextRangePosEnd(node, pos, end !== null && end !== void 0 ? end : scanner.getStartPos()); + if (contextFlags) { + node.flags |= contextFlags; + } + // Keep track on the node if we encountered an error while parsing it. If we did, then + // we cannot reuse the node incrementally. Once we've marked this node, clear out the + // flag so that we don't mark any subsequent nodes. + if (parseErrorBeforeNextFinishedNode) { + parseErrorBeforeNextFinishedNode = false; + node.flags |= 131072 /* NodeFlags.ThisNodeHasError */; + } + return node; + } + function createMissingNode(kind, reportAtCurrentPosition, diagnosticMessage, arg0) { + if (reportAtCurrentPosition) { + parseErrorAtPosition(scanner.getStartPos(), 0, diagnosticMessage, arg0); + } + else if (diagnosticMessage) { + parseErrorAtCurrentToken(diagnosticMessage, arg0); + } + var pos = getNodePos(); + var result = kind === 79 /* SyntaxKind.Identifier */ ? factory.createIdentifier("", /*typeArguments*/ undefined, /*originalKeywordKind*/ undefined) : + ts.isTemplateLiteralKind(kind) ? factory.createTemplateLiteralLikeNode(kind, "", "", /*templateFlags*/ undefined) : + kind === 8 /* SyntaxKind.NumericLiteral */ ? factory.createNumericLiteral("", /*numericLiteralFlags*/ undefined) : + kind === 10 /* SyntaxKind.StringLiteral */ ? factory.createStringLiteral("", /*isSingleQuote*/ undefined) : + kind === 279 /* SyntaxKind.MissingDeclaration */ ? factory.createMissingDeclaration() : + factory.createToken(kind); + return finishNode(result, pos); + } + function internIdentifier(text) { + var identifier = identifiers.get(text); + if (identifier === undefined) { + identifiers.set(text, identifier = text); + } + return identifier; + } + // An identifier that starts with two underscores has an extra underscore character prepended to it to avoid issues + // with magic property names like '__proto__'. The 'identifiers' object is used to share a single string instance for + // each identifier in order to reduce memory consumption. + function createIdentifier(isIdentifier, diagnosticMessage, privateIdentifierDiagnosticMessage) { + if (isIdentifier) { + identifierCount++; + var pos = getNodePos(); + // Store original token kind if it is not just an Identifier so we can report appropriate error later in type checker + var originalKeywordKind = token(); + var text = internIdentifier(scanner.getTokenValue()); + var hasExtendedUnicodeEscape = scanner.hasExtendedUnicodeEscape(); + nextTokenWithoutCheck(); + return finishNode(factory.createIdentifier(text, /*typeArguments*/ undefined, originalKeywordKind, hasExtendedUnicodeEscape), pos); + } + if (token() === 80 /* SyntaxKind.PrivateIdentifier */) { + parseErrorAtCurrentToken(privateIdentifierDiagnosticMessage || ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies); + return createIdentifier(/*isIdentifier*/ true); + } + if (token() === 0 /* SyntaxKind.Unknown */ && scanner.tryScan(function () { return scanner.reScanInvalidIdentifier() === 79 /* SyntaxKind.Identifier */; })) { + // Scanner has already recorded an 'Invalid character' error, so no need to add another from the parser. + return createIdentifier(/*isIdentifier*/ true); + } + identifierCount++; + // Only for end of file because the error gets reported incorrectly on embedded script tags. + var reportAtCurrentPosition = token() === 1 /* SyntaxKind.EndOfFileToken */; + var isReservedWord = scanner.isReservedWord(); + var msgArg = scanner.getTokenText(); + var defaultMessage = isReservedWord ? + ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here : + ts.Diagnostics.Identifier_expected; + return createMissingNode(79 /* SyntaxKind.Identifier */, reportAtCurrentPosition, diagnosticMessage || defaultMessage, msgArg); + } + function parseBindingIdentifier(privateIdentifierDiagnosticMessage) { + return createIdentifier(isBindingIdentifier(), /*diagnosticMessage*/ undefined, privateIdentifierDiagnosticMessage); + } + function parseIdentifier(diagnosticMessage, privateIdentifierDiagnosticMessage) { + return createIdentifier(isIdentifier(), diagnosticMessage, privateIdentifierDiagnosticMessage); + } + function parseIdentifierName(diagnosticMessage) { + return createIdentifier(ts.tokenIsIdentifierOrKeyword(token()), diagnosticMessage); + } + function isLiteralPropertyName() { + return ts.tokenIsIdentifierOrKeyword(token()) || + token() === 10 /* SyntaxKind.StringLiteral */ || + token() === 8 /* SyntaxKind.NumericLiteral */; + } + function isAssertionKey() { + return ts.tokenIsIdentifierOrKeyword(token()) || + token() === 10 /* SyntaxKind.StringLiteral */; + } + function parsePropertyNameWorker(allowComputedPropertyNames) { + if (token() === 10 /* SyntaxKind.StringLiteral */ || token() === 8 /* SyntaxKind.NumericLiteral */) { + var node = parseLiteralNode(); + node.text = internIdentifier(node.text); + return node; + } + if (allowComputedPropertyNames && token() === 22 /* SyntaxKind.OpenBracketToken */) { + return parseComputedPropertyName(); + } + if (token() === 80 /* SyntaxKind.PrivateIdentifier */) { + return parsePrivateIdentifier(); + } + return parseIdentifierName(); + } + function parsePropertyName() { + return parsePropertyNameWorker(/*allowComputedPropertyNames*/ true); + } + function parseComputedPropertyName() { + // PropertyName [Yield]: + // LiteralPropertyName + // ComputedPropertyName[?Yield] + var pos = getNodePos(); + parseExpected(22 /* SyntaxKind.OpenBracketToken */); + // We parse any expression (including a comma expression). But the grammar + // says that only an assignment expression is allowed, so the grammar checker + // will error if it sees a comma expression. + var expression = allowInAnd(parseExpression); + parseExpected(23 /* SyntaxKind.CloseBracketToken */); + return finishNode(factory.createComputedPropertyName(expression), pos); + } + function internPrivateIdentifier(text) { + var privateIdentifier = privateIdentifiers.get(text); + if (privateIdentifier === undefined) { + privateIdentifiers.set(text, privateIdentifier = text); + } + return privateIdentifier; + } + function parsePrivateIdentifier() { + var pos = getNodePos(); + var node = factory.createPrivateIdentifier(internPrivateIdentifier(scanner.getTokenValue())); + nextToken(); + return finishNode(node, pos); + } + function parseContextualModifier(t) { + return token() === t && tryParse(nextTokenCanFollowModifier); + } + function nextTokenIsOnSameLineAndCanFollowModifier() { + nextToken(); + if (scanner.hasPrecedingLineBreak()) { + return false; + } + return canFollowModifier(); + } + function nextTokenCanFollowModifier() { + switch (token()) { + case 85 /* SyntaxKind.ConstKeyword */: + // 'const' is only a modifier if followed by 'enum'. + return nextToken() === 92 /* SyntaxKind.EnumKeyword */; + case 93 /* SyntaxKind.ExportKeyword */: + nextToken(); + if (token() === 88 /* SyntaxKind.DefaultKeyword */) { + return lookAhead(nextTokenCanFollowDefaultKeyword); + } + if (token() === 154 /* SyntaxKind.TypeKeyword */) { + return lookAhead(nextTokenCanFollowExportModifier); + } + return canFollowExportModifier(); + case 88 /* SyntaxKind.DefaultKeyword */: + return nextTokenCanFollowDefaultKeyword(); + case 127 /* SyntaxKind.AccessorKeyword */: + case 124 /* SyntaxKind.StaticKeyword */: + case 137 /* SyntaxKind.GetKeyword */: + case 151 /* SyntaxKind.SetKeyword */: + nextToken(); + return canFollowModifier(); + default: + return nextTokenIsOnSameLineAndCanFollowModifier(); + } + } + function canFollowExportModifier() { + return token() !== 41 /* SyntaxKind.AsteriskToken */ + && token() !== 128 /* SyntaxKind.AsKeyword */ + && token() !== 18 /* SyntaxKind.OpenBraceToken */ + && canFollowModifier(); + } + function nextTokenCanFollowExportModifier() { + nextToken(); + return canFollowExportModifier(); + } + function parseAnyContextualModifier() { + return ts.isModifierKind(token()) && tryParse(nextTokenCanFollowModifier); + } + function canFollowModifier() { + return token() === 22 /* SyntaxKind.OpenBracketToken */ + || token() === 18 /* SyntaxKind.OpenBraceToken */ + || token() === 41 /* SyntaxKind.AsteriskToken */ + || token() === 25 /* SyntaxKind.DotDotDotToken */ + || isLiteralPropertyName(); + } + function nextTokenCanFollowDefaultKeyword() { + nextToken(); + return token() === 84 /* SyntaxKind.ClassKeyword */ || token() === 98 /* SyntaxKind.FunctionKeyword */ || + token() === 118 /* SyntaxKind.InterfaceKeyword */ || + (token() === 126 /* SyntaxKind.AbstractKeyword */ && lookAhead(nextTokenIsClassKeywordOnSameLine)) || + (token() === 132 /* SyntaxKind.AsyncKeyword */ && lookAhead(nextTokenIsFunctionKeywordOnSameLine)); + } + // True if positioned at the start of a list element + function isListElement(parsingContext, inErrorRecovery) { + var node = currentNode(parsingContext); + if (node) { + return true; + } + switch (parsingContext) { + case 0 /* ParsingContext.SourceElements */: + case 1 /* ParsingContext.BlockStatements */: + case 3 /* ParsingContext.SwitchClauseStatements */: + // If we're in error recovery, then we don't want to treat ';' as an empty statement. + // The problem is that ';' can show up in far too many contexts, and if we see one + // and assume it's a statement, then we may bail out inappropriately from whatever + // we're parsing. For example, if we have a semicolon in the middle of a class, then + // we really don't want to assume the class is over and we're on a statement in the + // outer module. We just want to consume and move on. + return !(token() === 26 /* SyntaxKind.SemicolonToken */ && inErrorRecovery) && isStartOfStatement(); + case 2 /* ParsingContext.SwitchClauses */: + return token() === 82 /* SyntaxKind.CaseKeyword */ || token() === 88 /* SyntaxKind.DefaultKeyword */; + case 4 /* ParsingContext.TypeMembers */: + return lookAhead(isTypeMemberStart); + case 5 /* ParsingContext.ClassMembers */: + // We allow semicolons as class elements (as specified by ES6) as long as we're + // not in error recovery. If we're in error recovery, we don't want an errant + // semicolon to be treated as a class member (since they're almost always used + // for statements. + return lookAhead(isClassMemberStart) || (token() === 26 /* SyntaxKind.SemicolonToken */ && !inErrorRecovery); + case 6 /* ParsingContext.EnumMembers */: + // Include open bracket computed properties. This technically also lets in indexers, + // which would be a candidate for improved error reporting. + return token() === 22 /* SyntaxKind.OpenBracketToken */ || isLiteralPropertyName(); + case 12 /* ParsingContext.ObjectLiteralMembers */: + switch (token()) { + case 22 /* SyntaxKind.OpenBracketToken */: + case 41 /* SyntaxKind.AsteriskToken */: + case 25 /* SyntaxKind.DotDotDotToken */: + case 24 /* SyntaxKind.DotToken */: // Not an object literal member, but don't want to close the object (see `tests/cases/fourslash/completionsDotInObjectLiteral.ts`) + return true; + default: + return isLiteralPropertyName(); + } + case 18 /* ParsingContext.RestProperties */: + return isLiteralPropertyName(); + case 9 /* ParsingContext.ObjectBindingElements */: + return token() === 22 /* SyntaxKind.OpenBracketToken */ || token() === 25 /* SyntaxKind.DotDotDotToken */ || isLiteralPropertyName(); + case 24 /* ParsingContext.AssertEntries */: + return isAssertionKey(); + case 7 /* ParsingContext.HeritageClauseElement */: + // If we see `{ ... }` then only consume it as an expression if it is followed by `,` or `{` + // That way we won't consume the body of a class in its heritage clause. + if (token() === 18 /* SyntaxKind.OpenBraceToken */) { + return lookAhead(isValidHeritageClauseObjectLiteral); + } + if (!inErrorRecovery) { + return isStartOfLeftHandSideExpression() && !isHeritageClauseExtendsOrImplementsKeyword(); + } + else { + // If we're in error recovery we tighten up what we're willing to match. + // That way we don't treat something like "this" as a valid heritage clause + // element during recovery. + return isIdentifier() && !isHeritageClauseExtendsOrImplementsKeyword(); + } + case 8 /* ParsingContext.VariableDeclarations */: + return isBindingIdentifierOrPrivateIdentifierOrPattern(); + case 10 /* ParsingContext.ArrayBindingElements */: + return token() === 27 /* SyntaxKind.CommaToken */ || token() === 25 /* SyntaxKind.DotDotDotToken */ || isBindingIdentifierOrPrivateIdentifierOrPattern(); + case 19 /* ParsingContext.TypeParameters */: + return token() === 101 /* SyntaxKind.InKeyword */ || isIdentifier(); + case 15 /* ParsingContext.ArrayLiteralMembers */: + switch (token()) { + case 27 /* SyntaxKind.CommaToken */: + case 24 /* SyntaxKind.DotToken */: // Not an array literal member, but don't want to close the array (see `tests/cases/fourslash/completionsDotInArrayLiteralInObjectLiteral.ts`) + return true; + } + // falls through + case 11 /* ParsingContext.ArgumentExpressions */: + return token() === 25 /* SyntaxKind.DotDotDotToken */ || isStartOfExpression(); + case 16 /* ParsingContext.Parameters */: + return isStartOfParameter(/*isJSDocParameter*/ false); + case 17 /* ParsingContext.JSDocParameters */: + return isStartOfParameter(/*isJSDocParameter*/ true); + case 20 /* ParsingContext.TypeArguments */: + case 21 /* ParsingContext.TupleElementTypes */: + return token() === 27 /* SyntaxKind.CommaToken */ || isStartOfType(); + case 22 /* ParsingContext.HeritageClauses */: + return isHeritageClause(); + case 23 /* ParsingContext.ImportOrExportSpecifiers */: + return ts.tokenIsIdentifierOrKeyword(token()); + case 13 /* ParsingContext.JsxAttributes */: + return ts.tokenIsIdentifierOrKeyword(token()) || token() === 18 /* SyntaxKind.OpenBraceToken */; + case 14 /* ParsingContext.JsxChildren */: + return true; + } + return ts.Debug.fail("Non-exhaustive case in 'isListElement'."); + } + function isValidHeritageClauseObjectLiteral() { + ts.Debug.assert(token() === 18 /* SyntaxKind.OpenBraceToken */); + if (nextToken() === 19 /* SyntaxKind.CloseBraceToken */) { + // if we see "extends {}" then only treat the {} as what we're extending (and not + // the class body) if we have: + // + // extends {} { + // extends {}, + // extends {} extends + // extends {} implements + var next = nextToken(); + return next === 27 /* SyntaxKind.CommaToken */ || next === 18 /* SyntaxKind.OpenBraceToken */ || next === 94 /* SyntaxKind.ExtendsKeyword */ || next === 117 /* SyntaxKind.ImplementsKeyword */; + } + return true; + } + function nextTokenIsIdentifier() { + nextToken(); + return isIdentifier(); + } + function nextTokenIsIdentifierOrKeyword() { + nextToken(); + return ts.tokenIsIdentifierOrKeyword(token()); + } + function nextTokenIsIdentifierOrKeywordOrGreaterThan() { + nextToken(); + return ts.tokenIsIdentifierOrKeywordOrGreaterThan(token()); + } + function isHeritageClauseExtendsOrImplementsKeyword() { + if (token() === 117 /* SyntaxKind.ImplementsKeyword */ || + token() === 94 /* SyntaxKind.ExtendsKeyword */) { + return lookAhead(nextTokenIsStartOfExpression); + } + return false; + } + function nextTokenIsStartOfExpression() { + nextToken(); + return isStartOfExpression(); + } + function nextTokenIsStartOfType() { + nextToken(); + return isStartOfType(); + } + // True if positioned at a list terminator + function isListTerminator(kind) { + if (token() === 1 /* SyntaxKind.EndOfFileToken */) { + // Being at the end of the file ends all lists. + return true; + } + switch (kind) { + case 1 /* ParsingContext.BlockStatements */: + case 2 /* ParsingContext.SwitchClauses */: + case 4 /* ParsingContext.TypeMembers */: + case 5 /* ParsingContext.ClassMembers */: + case 6 /* ParsingContext.EnumMembers */: + case 12 /* ParsingContext.ObjectLiteralMembers */: + case 9 /* ParsingContext.ObjectBindingElements */: + case 23 /* ParsingContext.ImportOrExportSpecifiers */: + case 24 /* ParsingContext.AssertEntries */: + return token() === 19 /* SyntaxKind.CloseBraceToken */; + case 3 /* ParsingContext.SwitchClauseStatements */: + return token() === 19 /* SyntaxKind.CloseBraceToken */ || token() === 82 /* SyntaxKind.CaseKeyword */ || token() === 88 /* SyntaxKind.DefaultKeyword */; + case 7 /* ParsingContext.HeritageClauseElement */: + return token() === 18 /* SyntaxKind.OpenBraceToken */ || token() === 94 /* SyntaxKind.ExtendsKeyword */ || token() === 117 /* SyntaxKind.ImplementsKeyword */; + case 8 /* ParsingContext.VariableDeclarations */: + return isVariableDeclaratorListTerminator(); + case 19 /* ParsingContext.TypeParameters */: + // Tokens other than '>' are here for better error recovery + return token() === 31 /* SyntaxKind.GreaterThanToken */ || token() === 20 /* SyntaxKind.OpenParenToken */ || token() === 18 /* SyntaxKind.OpenBraceToken */ || token() === 94 /* SyntaxKind.ExtendsKeyword */ || token() === 117 /* SyntaxKind.ImplementsKeyword */; + case 11 /* ParsingContext.ArgumentExpressions */: + // Tokens other than ')' are here for better error recovery + return token() === 21 /* SyntaxKind.CloseParenToken */ || token() === 26 /* SyntaxKind.SemicolonToken */; + case 15 /* ParsingContext.ArrayLiteralMembers */: + case 21 /* ParsingContext.TupleElementTypes */: + case 10 /* ParsingContext.ArrayBindingElements */: + return token() === 23 /* SyntaxKind.CloseBracketToken */; + case 17 /* ParsingContext.JSDocParameters */: + case 16 /* ParsingContext.Parameters */: + case 18 /* ParsingContext.RestProperties */: + // Tokens other than ')' and ']' (the latter for index signatures) are here for better error recovery + return token() === 21 /* SyntaxKind.CloseParenToken */ || token() === 23 /* SyntaxKind.CloseBracketToken */ /*|| token === SyntaxKind.OpenBraceToken*/; + case 20 /* ParsingContext.TypeArguments */: + // All other tokens should cause the type-argument to terminate except comma token + return token() !== 27 /* SyntaxKind.CommaToken */; + case 22 /* ParsingContext.HeritageClauses */: + return token() === 18 /* SyntaxKind.OpenBraceToken */ || token() === 19 /* SyntaxKind.CloseBraceToken */; + case 13 /* ParsingContext.JsxAttributes */: + return token() === 31 /* SyntaxKind.GreaterThanToken */ || token() === 43 /* SyntaxKind.SlashToken */; + case 14 /* ParsingContext.JsxChildren */: + return token() === 29 /* SyntaxKind.LessThanToken */ && lookAhead(nextTokenIsSlash); + default: + return false; + } + } + function isVariableDeclaratorListTerminator() { + // If we can consume a semicolon (either explicitly, or with ASI), then consider us done + // with parsing the list of variable declarators. + if (canParseSemicolon()) { + return true; + } + // in the case where we're parsing the variable declarator of a 'for-in' statement, we + // are done if we see an 'in' keyword in front of us. Same with for-of + if (isInOrOfKeyword(token())) { + return true; + } + // ERROR RECOVERY TWEAK: + // For better error recovery, if we see an '=>' then we just stop immediately. We've got an + // arrow function here and it's going to be very unlikely that we'll resynchronize and get + // another variable declaration. + if (token() === 38 /* SyntaxKind.EqualsGreaterThanToken */) { + return true; + } + // Keep trying to parse out variable declarators. + return false; + } + // True if positioned at element or terminator of the current list or any enclosing list + function isInSomeParsingContext() { + for (var kind = 0; kind < 25 /* ParsingContext.Count */; kind++) { + if (parsingContext & (1 << kind)) { + if (isListElement(kind, /*inErrorRecovery*/ true) || isListTerminator(kind)) { + return true; + } + } + } + return false; + } + // Parses a list of elements + function parseList(kind, parseElement) { + var saveParsingContext = parsingContext; + parsingContext |= 1 << kind; + var list = []; + var listPos = getNodePos(); + while (!isListTerminator(kind)) { + if (isListElement(kind, /*inErrorRecovery*/ false)) { + list.push(parseListElement(kind, parseElement)); + continue; + } + if (abortParsingListOrMoveToNextToken(kind)) { + break; + } + } + parsingContext = saveParsingContext; + return createNodeArray(list, listPos); + } + function parseListElement(parsingContext, parseElement) { + var node = currentNode(parsingContext); + if (node) { + return consumeNode(node); + } + return parseElement(); + } + function currentNode(parsingContext, pos) { + // If we don't have a cursor or the parsing context isn't reusable, there's nothing to reuse. + // + // If there is an outstanding parse error that we've encountered, but not attached to + // some node, then we cannot get a node from the old source tree. This is because we + // want to mark the next node we encounter as being unusable. + // + // Note: This may be too conservative. Perhaps we could reuse the node and set the bit + // on it (or its leftmost child) as having the error. For now though, being conservative + // is nice and likely won't ever affect perf. + if (!syntaxCursor || !isReusableParsingContext(parsingContext) || parseErrorBeforeNextFinishedNode) { + return undefined; + } + var node = syntaxCursor.currentNode(pos !== null && pos !== void 0 ? pos : scanner.getStartPos()); + // Can't reuse a missing node. + // Can't reuse a node that intersected the change range. + // Can't reuse a node that contains a parse error. This is necessary so that we + // produce the same set of errors again. + if (ts.nodeIsMissing(node) || node.intersectsChange || ts.containsParseError(node)) { + return undefined; + } + // We can only reuse a node if it was parsed under the same strict mode that we're + // currently in. i.e. if we originally parsed a node in non-strict mode, but then + // the user added 'using strict' at the top of the file, then we can't use that node + // again as the presence of strict mode may cause us to parse the tokens in the file + // differently. + // + // Note: we *can* reuse tokens when the strict mode changes. That's because tokens + // are unaffected by strict mode. It's just the parser will decide what to do with it + // differently depending on what mode it is in. + // + // This also applies to all our other context flags as well. + var nodeContextFlags = node.flags & 50720768 /* NodeFlags.ContextFlags */; + if (nodeContextFlags !== contextFlags) { + return undefined; + } + // Ok, we have a node that looks like it could be reused. Now verify that it is valid + // in the current list parsing context that we're currently at. + if (!canReuseNode(node, parsingContext)) { + return undefined; + } + if (node.jsDocCache) { + // jsDocCache may include tags from parent nodes, which might have been modified. + node.jsDocCache = undefined; + } + return node; + } + function consumeNode(node) { + // Move the scanner so it is after the node we just consumed. + scanner.setTextPos(node.end); + nextToken(); + return node; + } + function isReusableParsingContext(parsingContext) { + switch (parsingContext) { + case 5 /* ParsingContext.ClassMembers */: + case 2 /* ParsingContext.SwitchClauses */: + case 0 /* ParsingContext.SourceElements */: + case 1 /* ParsingContext.BlockStatements */: + case 3 /* ParsingContext.SwitchClauseStatements */: + case 6 /* ParsingContext.EnumMembers */: + case 4 /* ParsingContext.TypeMembers */: + case 8 /* ParsingContext.VariableDeclarations */: + case 17 /* ParsingContext.JSDocParameters */: + case 16 /* ParsingContext.Parameters */: + return true; + } + return false; + } + function canReuseNode(node, parsingContext) { + switch (parsingContext) { + case 5 /* ParsingContext.ClassMembers */: + return isReusableClassMember(node); + case 2 /* ParsingContext.SwitchClauses */: + return isReusableSwitchClause(node); + case 0 /* ParsingContext.SourceElements */: + case 1 /* ParsingContext.BlockStatements */: + case 3 /* ParsingContext.SwitchClauseStatements */: + return isReusableStatement(node); + case 6 /* ParsingContext.EnumMembers */: + return isReusableEnumMember(node); + case 4 /* ParsingContext.TypeMembers */: + return isReusableTypeMember(node); + case 8 /* ParsingContext.VariableDeclarations */: + return isReusableVariableDeclaration(node); + case 17 /* ParsingContext.JSDocParameters */: + case 16 /* ParsingContext.Parameters */: + return isReusableParameter(node); + // Any other lists we do not care about reusing nodes in. But feel free to add if + // you can do so safely. Danger areas involve nodes that may involve speculative + // parsing. If speculative parsing is involved with the node, then the range the + // parser reached while looking ahead might be in the edited range (see the example + // in canReuseVariableDeclaratorNode for a good case of this). + // case ParsingContext.HeritageClauses: + // This would probably be safe to reuse. There is no speculative parsing with + // heritage clauses. + // case ParsingContext.TypeParameters: + // This would probably be safe to reuse. There is no speculative parsing with + // type parameters. Note that that's because type *parameters* only occur in + // unambiguous *type* contexts. While type *arguments* occur in very ambiguous + // *expression* contexts. + // case ParsingContext.TupleElementTypes: + // This would probably be safe to reuse. There is no speculative parsing with + // tuple types. + // Technically, type argument list types are probably safe to reuse. While + // speculative parsing is involved with them (since type argument lists are only + // produced from speculative parsing a < as a type argument list), we only have + // the types because speculative parsing succeeded. Thus, the lookahead never + // went past the end of the list and rewound. + // case ParsingContext.TypeArguments: + // Note: these are almost certainly not safe to ever reuse. Expressions commonly + // need a large amount of lookahead, and we should not reuse them as they may + // have actually intersected the edit. + // case ParsingContext.ArgumentExpressions: + // This is not safe to reuse for the same reason as the 'AssignmentExpression' + // cases. i.e. a property assignment may end with an expression, and thus might + // have lookahead far beyond it's old node. + // case ParsingContext.ObjectLiteralMembers: + // This is probably not safe to reuse. There can be speculative parsing with + // type names in a heritage clause. There can be generic names in the type + // name list, and there can be left hand side expressions (which can have type + // arguments.) + // case ParsingContext.HeritageClauseElement: + // Perhaps safe to reuse, but it's unlikely we'd see more than a dozen attributes + // on any given element. Same for children. + // case ParsingContext.JsxAttributes: + // case ParsingContext.JsxChildren: + } + return false; + } + function isReusableClassMember(node) { + if (node) { + switch (node.kind) { + case 173 /* SyntaxKind.Constructor */: + case 178 /* SyntaxKind.IndexSignature */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 237 /* SyntaxKind.SemicolonClassElement */: + return true; + case 171 /* SyntaxKind.MethodDeclaration */: + // Method declarations are not necessarily reusable. An object-literal + // may have a method calls "constructor(...)" and we must reparse that + // into an actual .ConstructorDeclaration. + var methodDeclaration = node; + var nameIsConstructor = methodDeclaration.name.kind === 79 /* SyntaxKind.Identifier */ && + methodDeclaration.name.originalKeywordKind === 135 /* SyntaxKind.ConstructorKeyword */; + return !nameIsConstructor; + } + } + return false; + } + function isReusableSwitchClause(node) { + if (node) { + switch (node.kind) { + case 292 /* SyntaxKind.CaseClause */: + case 293 /* SyntaxKind.DefaultClause */: + return true; + } + } + return false; + } + function isReusableStatement(node) { + if (node) { + switch (node.kind) { + case 259 /* SyntaxKind.FunctionDeclaration */: + case 240 /* SyntaxKind.VariableStatement */: + case 238 /* SyntaxKind.Block */: + case 242 /* SyntaxKind.IfStatement */: + case 241 /* SyntaxKind.ExpressionStatement */: + case 254 /* SyntaxKind.ThrowStatement */: + case 250 /* SyntaxKind.ReturnStatement */: + case 252 /* SyntaxKind.SwitchStatement */: + case 249 /* SyntaxKind.BreakStatement */: + case 248 /* SyntaxKind.ContinueStatement */: + case 246 /* SyntaxKind.ForInStatement */: + case 247 /* SyntaxKind.ForOfStatement */: + case 245 /* SyntaxKind.ForStatement */: + case 244 /* SyntaxKind.WhileStatement */: + case 251 /* SyntaxKind.WithStatement */: + case 239 /* SyntaxKind.EmptyStatement */: + case 255 /* SyntaxKind.TryStatement */: + case 253 /* SyntaxKind.LabeledStatement */: + case 243 /* SyntaxKind.DoStatement */: + case 256 /* SyntaxKind.DebuggerStatement */: + case 269 /* SyntaxKind.ImportDeclaration */: + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + case 275 /* SyntaxKind.ExportDeclaration */: + case 274 /* SyntaxKind.ExportAssignment */: + case 264 /* SyntaxKind.ModuleDeclaration */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + return true; + } + } + return false; + } + function isReusableEnumMember(node) { + return node.kind === 302 /* SyntaxKind.EnumMember */; + } + function isReusableTypeMember(node) { + if (node) { + switch (node.kind) { + case 177 /* SyntaxKind.ConstructSignature */: + case 170 /* SyntaxKind.MethodSignature */: + case 178 /* SyntaxKind.IndexSignature */: + case 168 /* SyntaxKind.PropertySignature */: + case 176 /* SyntaxKind.CallSignature */: + return true; + } + } + return false; + } + function isReusableVariableDeclaration(node) { + if (node.kind !== 257 /* SyntaxKind.VariableDeclaration */) { + return false; + } + // Very subtle incremental parsing bug. Consider the following code: + // + // let v = new List < A, B + // + // This is actually legal code. It's a list of variable declarators "v = new List() + // + // then we have a problem. "v = new List= 0); + } + function getExpectedCommaDiagnostic(kind) { + return kind === 6 /* ParsingContext.EnumMembers */ ? ts.Diagnostics.An_enum_member_name_must_be_followed_by_a_or : undefined; + } + function createMissingList() { + var list = createNodeArray([], getNodePos()); + list.isMissingList = true; + return list; + } + function isMissingList(arr) { + return !!arr.isMissingList; + } + function parseBracketedList(kind, parseElement, open, close) { + if (parseExpected(open)) { + var result = parseDelimitedList(kind, parseElement); + parseExpected(close); + return result; + } + return createMissingList(); + } + function parseEntityName(allowReservedWords, diagnosticMessage) { + var pos = getNodePos(); + var entity = allowReservedWords ? parseIdentifierName(diagnosticMessage) : parseIdentifier(diagnosticMessage); + var dotPos = getNodePos(); + while (parseOptional(24 /* SyntaxKind.DotToken */)) { + if (token() === 29 /* SyntaxKind.LessThanToken */) { + // the entity is part of a JSDoc-style generic, so record the trailing dot for later error reporting + entity.jsdocDotPos = dotPos; + break; + } + dotPos = getNodePos(); + entity = finishNode(factory.createQualifiedName(entity, parseRightSideOfDot(allowReservedWords, /* allowPrivateIdentifiers */ false)), pos); + } + return entity; + } + function createQualifiedName(entity, name) { + return finishNode(factory.createQualifiedName(entity, name), entity.pos); + } + function parseRightSideOfDot(allowIdentifierNames, allowPrivateIdentifiers) { + // Technically a keyword is valid here as all identifiers and keywords are identifier names. + // However, often we'll encounter this in error situations when the identifier or keyword + // is actually starting another valid construct. + // + // So, we check for the following specific case: + // + // name. + // identifierOrKeyword identifierNameOrKeyword + // + // Note: the newlines are important here. For example, if that above code + // were rewritten into: + // + // name.identifierOrKeyword + // identifierNameOrKeyword + // + // Then we would consider it valid. That's because ASI would take effect and + // the code would be implicitly: "name.identifierOrKeyword; identifierNameOrKeyword". + // In the first case though, ASI will not take effect because there is not a + // line terminator after the identifier or keyword. + if (scanner.hasPrecedingLineBreak() && ts.tokenIsIdentifierOrKeyword(token())) { + var matchesPattern = lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine); + if (matchesPattern) { + // Report that we need an identifier. However, report it right after the dot, + // and not on the next token. This is because the next token might actually + // be an identifier and the error would be quite confusing. + return createMissingNode(79 /* SyntaxKind.Identifier */, /*reportAtCurrentPosition*/ true, ts.Diagnostics.Identifier_expected); + } + } + if (token() === 80 /* SyntaxKind.PrivateIdentifier */) { + var node = parsePrivateIdentifier(); + return allowPrivateIdentifiers ? node : createMissingNode(79 /* SyntaxKind.Identifier */, /*reportAtCurrentPosition*/ true, ts.Diagnostics.Identifier_expected); + } + return allowIdentifierNames ? parseIdentifierName() : parseIdentifier(); + } + function parseTemplateSpans(isTaggedTemplate) { + var pos = getNodePos(); + var list = []; + var node; + do { + node = parseTemplateSpan(isTaggedTemplate); + list.push(node); + } while (node.literal.kind === 16 /* SyntaxKind.TemplateMiddle */); + return createNodeArray(list, pos); + } + function parseTemplateExpression(isTaggedTemplate) { + var pos = getNodePos(); + return finishNode(factory.createTemplateExpression(parseTemplateHead(isTaggedTemplate), parseTemplateSpans(isTaggedTemplate)), pos); + } + function parseTemplateType() { + var pos = getNodePos(); + return finishNode(factory.createTemplateLiteralType(parseTemplateHead(/*isTaggedTemplate*/ false), parseTemplateTypeSpans()), pos); + } + function parseTemplateTypeSpans() { + var pos = getNodePos(); + var list = []; + var node; + do { + node = parseTemplateTypeSpan(); + list.push(node); + } while (node.literal.kind === 16 /* SyntaxKind.TemplateMiddle */); + return createNodeArray(list, pos); + } + function parseTemplateTypeSpan() { + var pos = getNodePos(); + return finishNode(factory.createTemplateLiteralTypeSpan(parseType(), parseLiteralOfTemplateSpan(/*isTaggedTemplate*/ false)), pos); + } + function parseLiteralOfTemplateSpan(isTaggedTemplate) { + if (token() === 19 /* SyntaxKind.CloseBraceToken */) { + reScanTemplateToken(isTaggedTemplate); + return parseTemplateMiddleOrTemplateTail(); + } + else { + // TODO(rbuckton): Do we need to call `parseExpectedToken` or can we just call `createMissingNode` directly? + return parseExpectedToken(17 /* SyntaxKind.TemplateTail */, ts.Diagnostics._0_expected, ts.tokenToString(19 /* SyntaxKind.CloseBraceToken */)); + } + } + function parseTemplateSpan(isTaggedTemplate) { + var pos = getNodePos(); + return finishNode(factory.createTemplateSpan(allowInAnd(parseExpression), parseLiteralOfTemplateSpan(isTaggedTemplate)), pos); + } + function parseLiteralNode() { + return parseLiteralLikeNode(token()); + } + function parseTemplateHead(isTaggedTemplate) { + if (isTaggedTemplate) { + reScanTemplateHeadOrNoSubstitutionTemplate(); + } + var fragment = parseLiteralLikeNode(token()); + ts.Debug.assert(fragment.kind === 15 /* SyntaxKind.TemplateHead */, "Template head has wrong token kind"); + return fragment; + } + function parseTemplateMiddleOrTemplateTail() { + var fragment = parseLiteralLikeNode(token()); + ts.Debug.assert(fragment.kind === 16 /* SyntaxKind.TemplateMiddle */ || fragment.kind === 17 /* SyntaxKind.TemplateTail */, "Template fragment has wrong token kind"); + return fragment; + } + function getTemplateLiteralRawText(kind) { + var isLast = kind === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */ || kind === 17 /* SyntaxKind.TemplateTail */; + var tokenText = scanner.getTokenText(); + return tokenText.substring(1, tokenText.length - (scanner.isUnterminated() ? 0 : isLast ? 1 : 2)); + } + function parseLiteralLikeNode(kind) { + var pos = getNodePos(); + var node = ts.isTemplateLiteralKind(kind) ? factory.createTemplateLiteralLikeNode(kind, scanner.getTokenValue(), getTemplateLiteralRawText(kind), scanner.getTokenFlags() & 2048 /* TokenFlags.TemplateLiteralLikeFlags */) : + // Octal literals are not allowed in strict mode or ES5 + // Note that theoretically the following condition would hold true literals like 009, + // which is not octal. But because of how the scanner separates the tokens, we would + // never get a token like this. Instead, we would get 00 and 9 as two separate tokens. + // We also do not need to check for negatives because any prefix operator would be part of a + // parent unary expression. + kind === 8 /* SyntaxKind.NumericLiteral */ ? factory.createNumericLiteral(scanner.getTokenValue(), scanner.getNumericLiteralFlags()) : + kind === 10 /* SyntaxKind.StringLiteral */ ? factory.createStringLiteral(scanner.getTokenValue(), /*isSingleQuote*/ undefined, scanner.hasExtendedUnicodeEscape()) : + ts.isLiteralKind(kind) ? factory.createLiteralLikeNode(kind, scanner.getTokenValue()) : + ts.Debug.fail(); + if (scanner.hasExtendedUnicodeEscape()) { + node.hasExtendedUnicodeEscape = true; + } + if (scanner.isUnterminated()) { + node.isUnterminated = true; + } + nextToken(); + return finishNode(node, pos); + } + // TYPES + function parseEntityNameOfTypeReference() { + return parseEntityName(/*allowReservedWords*/ true, ts.Diagnostics.Type_expected); + } + function parseTypeArgumentsOfTypeReference() { + if (!scanner.hasPrecedingLineBreak() && reScanLessThanToken() === 29 /* SyntaxKind.LessThanToken */) { + return parseBracketedList(20 /* ParsingContext.TypeArguments */, parseType, 29 /* SyntaxKind.LessThanToken */, 31 /* SyntaxKind.GreaterThanToken */); + } + } + function parseTypeReference() { + var pos = getNodePos(); + return finishNode(factory.createTypeReferenceNode(parseEntityNameOfTypeReference(), parseTypeArgumentsOfTypeReference()), pos); + } + // If true, we should abort parsing an error function. + function typeHasArrowFunctionBlockingParseError(node) { + switch (node.kind) { + case 180 /* SyntaxKind.TypeReference */: + return ts.nodeIsMissing(node.typeName); + case 181 /* SyntaxKind.FunctionType */: + case 182 /* SyntaxKind.ConstructorType */: { + var _a = node, parameters = _a.parameters, type = _a.type; + return isMissingList(parameters) || typeHasArrowFunctionBlockingParseError(type); + } + case 193 /* SyntaxKind.ParenthesizedType */: + return typeHasArrowFunctionBlockingParseError(node.type); + default: + return false; + } + } + function parseThisTypePredicate(lhs) { + nextToken(); + return finishNode(factory.createTypePredicateNode(/*assertsModifier*/ undefined, lhs, parseType()), lhs.pos); + } + function parseThisTypeNode() { + var pos = getNodePos(); + nextToken(); + return finishNode(factory.createThisTypeNode(), pos); + } + function parseJSDocAllType() { + var pos = getNodePos(); + nextToken(); + return finishNode(factory.createJSDocAllType(), pos); + } + function parseJSDocNonNullableType() { + var pos = getNodePos(); + nextToken(); + return finishNode(factory.createJSDocNonNullableType(parseNonArrayType(), /*postfix*/ false), pos); + } + function parseJSDocUnknownOrNullableType() { + var pos = getNodePos(); + // skip the ? + nextToken(); + // Need to lookahead to decide if this is a nullable or unknown type. + // Here are cases where we'll pick the unknown type: + // + // Foo(?, + // { a: ? } + // Foo(?) + // Foo + // Foo(?= + // (?| + if (token() === 27 /* SyntaxKind.CommaToken */ || + token() === 19 /* SyntaxKind.CloseBraceToken */ || + token() === 21 /* SyntaxKind.CloseParenToken */ || + token() === 31 /* SyntaxKind.GreaterThanToken */ || + token() === 63 /* SyntaxKind.EqualsToken */ || + token() === 51 /* SyntaxKind.BarToken */) { + return finishNode(factory.createJSDocUnknownType(), pos); + } + else { + return finishNode(factory.createJSDocNullableType(parseType(), /*postfix*/ false), pos); + } + } + function parseJSDocFunctionType() { + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + if (lookAhead(nextTokenIsOpenParen)) { + nextToken(); + var parameters = parseParameters(4 /* SignatureFlags.Type */ | 32 /* SignatureFlags.JSDoc */); + var type = parseReturnType(58 /* SyntaxKind.ColonToken */, /*isType*/ false); + return withJSDoc(finishNode(factory.createJSDocFunctionType(parameters, type), pos), hasJSDoc); + } + return finishNode(factory.createTypeReferenceNode(parseIdentifierName(), /*typeArguments*/ undefined), pos); + } + function parseJSDocParameter() { + var pos = getNodePos(); + var name; + if (token() === 108 /* SyntaxKind.ThisKeyword */ || token() === 103 /* SyntaxKind.NewKeyword */) { + name = parseIdentifierName(); + parseExpected(58 /* SyntaxKind.ColonToken */); + } + return finishNode(factory.createParameterDeclaration( + /*modifiers*/ undefined, + /*dotDotDotToken*/ undefined, + // TODO(rbuckton): JSDoc parameters don't have names (except `this`/`new`), should we manufacture an empty identifier? + name, + /*questionToken*/ undefined, parseJSDocType(), + /*initializer*/ undefined), pos); + } + function parseJSDocType() { + scanner.setInJSDocType(true); + var pos = getNodePos(); + if (parseOptional(142 /* SyntaxKind.ModuleKeyword */)) { + // TODO(rbuckton): We never set the type for a JSDocNamepathType. What should we put here? + var moduleTag = factory.createJSDocNamepathType(/*type*/ undefined); + terminate: while (true) { + switch (token()) { + case 19 /* SyntaxKind.CloseBraceToken */: + case 1 /* SyntaxKind.EndOfFileToken */: + case 27 /* SyntaxKind.CommaToken */: + case 5 /* SyntaxKind.WhitespaceTrivia */: + break terminate; + default: + nextTokenJSDoc(); + } + } + scanner.setInJSDocType(false); + return finishNode(moduleTag, pos); + } + var hasDotDotDot = parseOptional(25 /* SyntaxKind.DotDotDotToken */); + var type = parseTypeOrTypePredicate(); + scanner.setInJSDocType(false); + if (hasDotDotDot) { + type = finishNode(factory.createJSDocVariadicType(type), pos); + } + if (token() === 63 /* SyntaxKind.EqualsToken */) { + nextToken(); + return finishNode(factory.createJSDocOptionalType(type), pos); + } + return type; + } + function parseTypeQuery() { + var pos = getNodePos(); + parseExpected(112 /* SyntaxKind.TypeOfKeyword */); + var entityName = parseEntityName(/*allowReservedWords*/ true); + // Make sure we perform ASI to prevent parsing the next line's type arguments as part of an instantiation expression. + var typeArguments = !scanner.hasPrecedingLineBreak() ? tryParseTypeArguments() : undefined; + return finishNode(factory.createTypeQueryNode(entityName, typeArguments), pos); + } + function parseTypeParameter() { + var pos = getNodePos(); + var modifiers = parseModifiers(); + var name = parseIdentifier(); + var constraint; + var expression; + if (parseOptional(94 /* SyntaxKind.ExtendsKeyword */)) { + // It's not uncommon for people to write improper constraints to a generic. If the + // user writes a constraint that is an expression and not an actual type, then parse + // it out as an expression (so we can recover well), but report that a type is needed + // instead. + if (isStartOfType() || !isStartOfExpression()) { + constraint = parseType(); + } + else { + // It was not a type, and it looked like an expression. Parse out an expression + // here so we recover well. Note: it is important that we call parseUnaryExpression + // and not parseExpression here. If the user has: + // + // + // + // We do *not* want to consume the `>` as we're consuming the expression for "". + expression = parseUnaryExpressionOrHigher(); + } + } + var defaultType = parseOptional(63 /* SyntaxKind.EqualsToken */) ? parseType() : undefined; + var node = factory.createTypeParameterDeclaration(modifiers, name, constraint, defaultType); + node.expression = expression; + return finishNode(node, pos); + } + function parseTypeParameters() { + if (token() === 29 /* SyntaxKind.LessThanToken */) { + return parseBracketedList(19 /* ParsingContext.TypeParameters */, parseTypeParameter, 29 /* SyntaxKind.LessThanToken */, 31 /* SyntaxKind.GreaterThanToken */); + } + } + function isStartOfParameter(isJSDocParameter) { + return token() === 25 /* SyntaxKind.DotDotDotToken */ || + isBindingIdentifierOrPrivateIdentifierOrPattern() || + ts.isModifierKind(token()) || + token() === 59 /* SyntaxKind.AtToken */ || + isStartOfType(/*inStartOfParameter*/ !isJSDocParameter); + } + function parseNameOfParameter(modifiers) { + // FormalParameter [Yield,Await]: + // BindingElement[?Yield,?Await] + var name = parseIdentifierOrPattern(ts.Diagnostics.Private_identifiers_cannot_be_used_as_parameters); + if (ts.getFullWidth(name) === 0 && !ts.some(modifiers) && ts.isModifierKind(token())) { + // in cases like + // 'use strict' + // function foo(static) + // isParameter('static') === true, because of isModifier('static') + // however 'static' is not a legal identifier in a strict mode. + // so result of this function will be ParameterDeclaration (flags = 0, name = missing, type = undefined, initializer = undefined) + // and current token will not change => parsing of the enclosing parameter list will last till the end of time (or OOM) + // to avoid this we'll advance cursor to the next token. + nextToken(); + } + return name; + } + function isParameterNameStart() { + // Be permissive about await and yield by calling isBindingIdentifier instead of isIdentifier; disallowing + // them during a speculative parse leads to many more follow-on errors than allowing the function to parse then later + // complaining about the use of the keywords. + return isBindingIdentifier() || token() === 22 /* SyntaxKind.OpenBracketToken */ || token() === 18 /* SyntaxKind.OpenBraceToken */; + } + function parseParameter(inOuterAwaitContext) { + return parseParameterWorker(inOuterAwaitContext); + } + function parseParameterForSpeculation(inOuterAwaitContext) { + return parseParameterWorker(inOuterAwaitContext, /*allowAmbiguity*/ false); + } + function parseParameterWorker(inOuterAwaitContext, allowAmbiguity) { + if (allowAmbiguity === void 0) { allowAmbiguity = true; } + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + // FormalParameter [Yield,Await]: + // BindingElement[?Yield,?Await] + // Decorators are parsed in the outer [Await] context, the rest of the parameter is parsed in the function's [Await] context. + var decorators = inOuterAwaitContext ? doInAwaitContext(parseDecorators) : doOutsideOfAwaitContext(parseDecorators); + if (token() === 108 /* SyntaxKind.ThisKeyword */) { + var node_1 = factory.createParameterDeclaration(decorators, + /*dotDotDotToken*/ undefined, createIdentifier(/*isIdentifier*/ true), + /*questionToken*/ undefined, parseTypeAnnotation(), + /*initializer*/ undefined); + if (decorators) { + parseErrorAtRange(decorators[0], ts.Diagnostics.Decorators_may_not_be_applied_to_this_parameters); + } + return withJSDoc(finishNode(node_1, pos), hasJSDoc); + } + var savedTopLevel = topLevel; + topLevel = false; + var modifiers = combineDecoratorsAndModifiers(decorators, parseModifiers()); + var dotDotDotToken = parseOptionalToken(25 /* SyntaxKind.DotDotDotToken */); + if (!allowAmbiguity && !isParameterNameStart()) { + return undefined; + } + var node = withJSDoc(finishNode(factory.createParameterDeclaration(modifiers, dotDotDotToken, parseNameOfParameter(modifiers), parseOptionalToken(57 /* SyntaxKind.QuestionToken */), parseTypeAnnotation(), parseInitializer()), pos), hasJSDoc); + topLevel = savedTopLevel; + return node; + } + function parseReturnType(returnToken, isType) { + if (shouldParseReturnType(returnToken, isType)) { + return allowConditionalTypesAnd(parseTypeOrTypePredicate); + } + } + function shouldParseReturnType(returnToken, isType) { + if (returnToken === 38 /* SyntaxKind.EqualsGreaterThanToken */) { + parseExpected(returnToken); + return true; + } + else if (parseOptional(58 /* SyntaxKind.ColonToken */)) { + return true; + } + else if (isType && token() === 38 /* SyntaxKind.EqualsGreaterThanToken */) { + // This is easy to get backward, especially in type contexts, so parse the type anyway + parseErrorAtCurrentToken(ts.Diagnostics._0_expected, ts.tokenToString(58 /* SyntaxKind.ColonToken */)); + nextToken(); + return true; + } + return false; + } + function parseParametersWorker(flags, allowAmbiguity) { + // FormalParameters [Yield,Await]: (modified) + // [empty] + // FormalParameterList[?Yield,Await] + // + // FormalParameter[Yield,Await]: (modified) + // BindingElement[?Yield,Await] + // + // BindingElement [Yield,Await]: (modified) + // SingleNameBinding[?Yield,?Await] + // BindingPattern[?Yield,?Await]Initializer [In, ?Yield,?Await] opt + // + // SingleNameBinding [Yield,Await]: + // BindingIdentifier[?Yield,?Await]Initializer [In, ?Yield,?Await] opt + var savedYieldContext = inYieldContext(); + var savedAwaitContext = inAwaitContext(); + setYieldContext(!!(flags & 1 /* SignatureFlags.Yield */)); + setAwaitContext(!!(flags & 2 /* SignatureFlags.Await */)); + var parameters = flags & 32 /* SignatureFlags.JSDoc */ ? + parseDelimitedList(17 /* ParsingContext.JSDocParameters */, parseJSDocParameter) : + parseDelimitedList(16 /* ParsingContext.Parameters */, function () { return allowAmbiguity ? parseParameter(savedAwaitContext) : parseParameterForSpeculation(savedAwaitContext); }); + setYieldContext(savedYieldContext); + setAwaitContext(savedAwaitContext); + return parameters; + } + function parseParameters(flags) { + // FormalParameters [Yield,Await]: (modified) + // [empty] + // FormalParameterList[?Yield,Await] + // + // FormalParameter[Yield,Await]: (modified) + // BindingElement[?Yield,Await] + // + // BindingElement [Yield,Await]: (modified) + // SingleNameBinding[?Yield,?Await] + // BindingPattern[?Yield,?Await]Initializer [In, ?Yield,?Await] opt + // + // SingleNameBinding [Yield,Await]: + // BindingIdentifier[?Yield,?Await]Initializer [In, ?Yield,?Await] opt + if (!parseExpected(20 /* SyntaxKind.OpenParenToken */)) { + return createMissingList(); + } + var parameters = parseParametersWorker(flags, /*allowAmbiguity*/ true); + parseExpected(21 /* SyntaxKind.CloseParenToken */); + return parameters; + } + function parseTypeMemberSemicolon() { + // We allow type members to be separated by commas or (possibly ASI) semicolons. + // First check if it was a comma. If so, we're done with the member. + if (parseOptional(27 /* SyntaxKind.CommaToken */)) { + return; + } + // Didn't have a comma. We must have a (possible ASI) semicolon. + parseSemicolon(); + } + function parseSignatureMember(kind) { + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + if (kind === 177 /* SyntaxKind.ConstructSignature */) { + parseExpected(103 /* SyntaxKind.NewKeyword */); + } + var typeParameters = parseTypeParameters(); + var parameters = parseParameters(4 /* SignatureFlags.Type */); + var type = parseReturnType(58 /* SyntaxKind.ColonToken */, /*isType*/ true); + parseTypeMemberSemicolon(); + var node = kind === 176 /* SyntaxKind.CallSignature */ + ? factory.createCallSignature(typeParameters, parameters, type) + : factory.createConstructSignature(typeParameters, parameters, type); + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + function isIndexSignature() { + return token() === 22 /* SyntaxKind.OpenBracketToken */ && lookAhead(isUnambiguouslyIndexSignature); + } + function isUnambiguouslyIndexSignature() { + // The only allowed sequence is: + // + // [id: + // + // However, for error recovery, we also check the following cases: + // + // [... + // [id, + // [id?, + // [id?: + // [id?] + // [public id + // [private id + // [protected id + // [] + // + nextToken(); + if (token() === 25 /* SyntaxKind.DotDotDotToken */ || token() === 23 /* SyntaxKind.CloseBracketToken */) { + return true; + } + if (ts.isModifierKind(token())) { + nextToken(); + if (isIdentifier()) { + return true; + } + } + else if (!isIdentifier()) { + return false; + } + else { + // Skip the identifier + nextToken(); + } + // A colon signifies a well formed indexer + // A comma should be a badly formed indexer because comma expressions are not allowed + // in computed properties. + if (token() === 58 /* SyntaxKind.ColonToken */ || token() === 27 /* SyntaxKind.CommaToken */) { + return true; + } + // Question mark could be an indexer with an optional property, + // or it could be a conditional expression in a computed property. + if (token() !== 57 /* SyntaxKind.QuestionToken */) { + return false; + } + // If any of the following tokens are after the question mark, it cannot + // be a conditional expression, so treat it as an indexer. + nextToken(); + return token() === 58 /* SyntaxKind.ColonToken */ || token() === 27 /* SyntaxKind.CommaToken */ || token() === 23 /* SyntaxKind.CloseBracketToken */; + } + function parseIndexSignatureDeclaration(pos, hasJSDoc, decorators, modifiers) { + var parameters = parseBracketedList(16 /* ParsingContext.Parameters */, function () { return parseParameter(/*inOuterAwaitContext*/ false); }, 22 /* SyntaxKind.OpenBracketToken */, 23 /* SyntaxKind.CloseBracketToken */); + var type = parseTypeAnnotation(); + parseTypeMemberSemicolon(); + var node = factory.createIndexSignature(modifiers, parameters, type); + node.illegalDecorators = decorators; + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + function parsePropertyOrMethodSignature(pos, hasJSDoc, modifiers) { + var name = parsePropertyName(); + var questionToken = parseOptionalToken(57 /* SyntaxKind.QuestionToken */); + var node; + if (token() === 20 /* SyntaxKind.OpenParenToken */ || token() === 29 /* SyntaxKind.LessThanToken */) { + // Method signatures don't exist in expression contexts. So they have neither + // [Yield] nor [Await] + var typeParameters = parseTypeParameters(); + var parameters = parseParameters(4 /* SignatureFlags.Type */); + var type = parseReturnType(58 /* SyntaxKind.ColonToken */, /*isType*/ true); + node = factory.createMethodSignature(modifiers, name, questionToken, typeParameters, parameters, type); + } + else { + var type = parseTypeAnnotation(); + node = factory.createPropertySignature(modifiers, name, questionToken, type); + // Although type literal properties cannot not have initializers, we attempt + // to parse an initializer so we can report in the checker that an interface + // property or type literal property cannot have an initializer. + if (token() === 63 /* SyntaxKind.EqualsToken */) + node.initializer = parseInitializer(); + } + parseTypeMemberSemicolon(); + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + function isTypeMemberStart() { + // Return true if we have the start of a signature member + if (token() === 20 /* SyntaxKind.OpenParenToken */ || + token() === 29 /* SyntaxKind.LessThanToken */ || + token() === 137 /* SyntaxKind.GetKeyword */ || + token() === 151 /* SyntaxKind.SetKeyword */) { + return true; + } + var idToken = false; + // Eat up all modifiers, but hold on to the last one in case it is actually an identifier + while (ts.isModifierKind(token())) { + idToken = true; + nextToken(); + } + // Index signatures and computed property names are type members + if (token() === 22 /* SyntaxKind.OpenBracketToken */) { + return true; + } + // Try to get the first property-like token following all modifiers + if (isLiteralPropertyName()) { + idToken = true; + nextToken(); + } + // If we were able to get any potential identifier, check that it is + // the start of a member declaration + if (idToken) { + return token() === 20 /* SyntaxKind.OpenParenToken */ || + token() === 29 /* SyntaxKind.LessThanToken */ || + token() === 57 /* SyntaxKind.QuestionToken */ || + token() === 58 /* SyntaxKind.ColonToken */ || + token() === 27 /* SyntaxKind.CommaToken */ || + canParseSemicolon(); + } + return false; + } + function parseTypeMember() { + if (token() === 20 /* SyntaxKind.OpenParenToken */ || token() === 29 /* SyntaxKind.LessThanToken */) { + return parseSignatureMember(176 /* SyntaxKind.CallSignature */); + } + if (token() === 103 /* SyntaxKind.NewKeyword */ && lookAhead(nextTokenIsOpenParenOrLessThan)) { + return parseSignatureMember(177 /* SyntaxKind.ConstructSignature */); + } + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + var modifiers = parseModifiers(); + if (parseContextualModifier(137 /* SyntaxKind.GetKeyword */)) { + return parseAccessorDeclaration(pos, hasJSDoc, /*decorators*/ undefined, modifiers, 174 /* SyntaxKind.GetAccessor */, 4 /* SignatureFlags.Type */); + } + if (parseContextualModifier(151 /* SyntaxKind.SetKeyword */)) { + return parseAccessorDeclaration(pos, hasJSDoc, /*decorators*/ undefined, modifiers, 175 /* SyntaxKind.SetAccessor */, 4 /* SignatureFlags.Type */); + } + if (isIndexSignature()) { + return parseIndexSignatureDeclaration(pos, hasJSDoc, /*decorators*/ undefined, modifiers); + } + return parsePropertyOrMethodSignature(pos, hasJSDoc, modifiers); + } + function nextTokenIsOpenParenOrLessThan() { + nextToken(); + return token() === 20 /* SyntaxKind.OpenParenToken */ || token() === 29 /* SyntaxKind.LessThanToken */; + } + function nextTokenIsDot() { + return nextToken() === 24 /* SyntaxKind.DotToken */; + } + function nextTokenIsOpenParenOrLessThanOrDot() { + switch (nextToken()) { + case 20 /* SyntaxKind.OpenParenToken */: + case 29 /* SyntaxKind.LessThanToken */: + case 24 /* SyntaxKind.DotToken */: + return true; + } + return false; + } + function parseTypeLiteral() { + var pos = getNodePos(); + return finishNode(factory.createTypeLiteralNode(parseObjectTypeMembers()), pos); + } + function parseObjectTypeMembers() { + var members; + if (parseExpected(18 /* SyntaxKind.OpenBraceToken */)) { + members = parseList(4 /* ParsingContext.TypeMembers */, parseTypeMember); + parseExpected(19 /* SyntaxKind.CloseBraceToken */); + } + else { + members = createMissingList(); + } + return members; + } + function isStartOfMappedType() { + nextToken(); + if (token() === 39 /* SyntaxKind.PlusToken */ || token() === 40 /* SyntaxKind.MinusToken */) { + return nextToken() === 146 /* SyntaxKind.ReadonlyKeyword */; + } + if (token() === 146 /* SyntaxKind.ReadonlyKeyword */) { + nextToken(); + } + return token() === 22 /* SyntaxKind.OpenBracketToken */ && nextTokenIsIdentifier() && nextToken() === 101 /* SyntaxKind.InKeyword */; + } + function parseMappedTypeParameter() { + var pos = getNodePos(); + var name = parseIdentifierName(); + parseExpected(101 /* SyntaxKind.InKeyword */); + var type = parseType(); + return finishNode(factory.createTypeParameterDeclaration(/*modifiers*/ undefined, name, type, /*defaultType*/ undefined), pos); + } + function parseMappedType() { + var pos = getNodePos(); + parseExpected(18 /* SyntaxKind.OpenBraceToken */); + var readonlyToken; + if (token() === 146 /* SyntaxKind.ReadonlyKeyword */ || token() === 39 /* SyntaxKind.PlusToken */ || token() === 40 /* SyntaxKind.MinusToken */) { + readonlyToken = parseTokenNode(); + if (readonlyToken.kind !== 146 /* SyntaxKind.ReadonlyKeyword */) { + parseExpected(146 /* SyntaxKind.ReadonlyKeyword */); + } + } + parseExpected(22 /* SyntaxKind.OpenBracketToken */); + var typeParameter = parseMappedTypeParameter(); + var nameType = parseOptional(128 /* SyntaxKind.AsKeyword */) ? parseType() : undefined; + parseExpected(23 /* SyntaxKind.CloseBracketToken */); + var questionToken; + if (token() === 57 /* SyntaxKind.QuestionToken */ || token() === 39 /* SyntaxKind.PlusToken */ || token() === 40 /* SyntaxKind.MinusToken */) { + questionToken = parseTokenNode(); + if (questionToken.kind !== 57 /* SyntaxKind.QuestionToken */) { + parseExpected(57 /* SyntaxKind.QuestionToken */); + } + } + var type = parseTypeAnnotation(); + parseSemicolon(); + var members = parseList(4 /* ParsingContext.TypeMembers */, parseTypeMember); + parseExpected(19 /* SyntaxKind.CloseBraceToken */); + return finishNode(factory.createMappedTypeNode(readonlyToken, typeParameter, nameType, questionToken, type, members), pos); + } + function parseTupleElementType() { + var pos = getNodePos(); + if (parseOptional(25 /* SyntaxKind.DotDotDotToken */)) { + return finishNode(factory.createRestTypeNode(parseType()), pos); + } + var type = parseType(); + if (ts.isJSDocNullableType(type) && type.pos === type.type.pos) { + var node = factory.createOptionalTypeNode(type.type); + ts.setTextRange(node, type); + node.flags = type.flags; + return node; + } + return type; + } + function isNextTokenColonOrQuestionColon() { + return nextToken() === 58 /* SyntaxKind.ColonToken */ || (token() === 57 /* SyntaxKind.QuestionToken */ && nextToken() === 58 /* SyntaxKind.ColonToken */); + } + function isTupleElementName() { + if (token() === 25 /* SyntaxKind.DotDotDotToken */) { + return ts.tokenIsIdentifierOrKeyword(nextToken()) && isNextTokenColonOrQuestionColon(); + } + return ts.tokenIsIdentifierOrKeyword(token()) && isNextTokenColonOrQuestionColon(); + } + function parseTupleElementNameOrTupleElementType() { + if (lookAhead(isTupleElementName)) { + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + var dotDotDotToken = parseOptionalToken(25 /* SyntaxKind.DotDotDotToken */); + var name = parseIdentifierName(); + var questionToken = parseOptionalToken(57 /* SyntaxKind.QuestionToken */); + parseExpected(58 /* SyntaxKind.ColonToken */); + var type = parseTupleElementType(); + var node = factory.createNamedTupleMember(dotDotDotToken, name, questionToken, type); + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + return parseTupleElementType(); + } + function parseTupleType() { + var pos = getNodePos(); + return finishNode(factory.createTupleTypeNode(parseBracketedList(21 /* ParsingContext.TupleElementTypes */, parseTupleElementNameOrTupleElementType, 22 /* SyntaxKind.OpenBracketToken */, 23 /* SyntaxKind.CloseBracketToken */)), pos); + } + function parseParenthesizedType() { + var pos = getNodePos(); + parseExpected(20 /* SyntaxKind.OpenParenToken */); + var type = parseType(); + parseExpected(21 /* SyntaxKind.CloseParenToken */); + return finishNode(factory.createParenthesizedType(type), pos); + } + function parseModifiersForConstructorType() { + var modifiers; + if (token() === 126 /* SyntaxKind.AbstractKeyword */) { + var pos = getNodePos(); + nextToken(); + var modifier = finishNode(factory.createToken(126 /* SyntaxKind.AbstractKeyword */), pos); + modifiers = createNodeArray([modifier], pos); + } + return modifiers; + } + function parseFunctionOrConstructorType() { + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + var modifiers = parseModifiersForConstructorType(); + var isConstructorType = parseOptional(103 /* SyntaxKind.NewKeyword */); + var typeParameters = parseTypeParameters(); + var parameters = parseParameters(4 /* SignatureFlags.Type */); + var type = parseReturnType(38 /* SyntaxKind.EqualsGreaterThanToken */, /*isType*/ false); + var node = isConstructorType + ? factory.createConstructorTypeNode(modifiers, typeParameters, parameters, type) + : factory.createFunctionTypeNode(typeParameters, parameters, type); + if (!isConstructorType) + node.modifiers = modifiers; + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + function parseKeywordAndNoDot() { + var node = parseTokenNode(); + return token() === 24 /* SyntaxKind.DotToken */ ? undefined : node; + } + function parseLiteralTypeNode(negative) { + var pos = getNodePos(); + if (negative) { + nextToken(); + } + var expression = token() === 110 /* SyntaxKind.TrueKeyword */ || token() === 95 /* SyntaxKind.FalseKeyword */ || token() === 104 /* SyntaxKind.NullKeyword */ ? + parseTokenNode() : + parseLiteralLikeNode(token()); + if (negative) { + expression = finishNode(factory.createPrefixUnaryExpression(40 /* SyntaxKind.MinusToken */, expression), pos); + } + return finishNode(factory.createLiteralTypeNode(expression), pos); + } + function isStartOfTypeOfImportType() { + nextToken(); + return token() === 100 /* SyntaxKind.ImportKeyword */; + } + function parseImportTypeAssertions() { + var pos = getNodePos(); + var openBracePosition = scanner.getTokenPos(); + parseExpected(18 /* SyntaxKind.OpenBraceToken */); + var multiLine = scanner.hasPrecedingLineBreak(); + parseExpected(130 /* SyntaxKind.AssertKeyword */); + parseExpected(58 /* SyntaxKind.ColonToken */); + var clause = parseAssertClause(/*skipAssertKeyword*/ true); + if (!parseExpected(19 /* SyntaxKind.CloseBraceToken */)) { + var lastError = ts.lastOrUndefined(parseDiagnostics); + if (lastError && lastError.code === ts.Diagnostics._0_expected.code) { + ts.addRelatedInfo(lastError, ts.createDetachedDiagnostic(fileName, openBracePosition, 1, ts.Diagnostics.The_parser_expected_to_find_a_1_to_match_the_0_token_here, "{", "}")); + } + } + return finishNode(factory.createImportTypeAssertionContainer(clause, multiLine), pos); + } + function parseImportType() { + sourceFlags |= 2097152 /* NodeFlags.PossiblyContainsDynamicImport */; + var pos = getNodePos(); + var isTypeOf = parseOptional(112 /* SyntaxKind.TypeOfKeyword */); + parseExpected(100 /* SyntaxKind.ImportKeyword */); + parseExpected(20 /* SyntaxKind.OpenParenToken */); + var type = parseType(); + var assertions; + if (parseOptional(27 /* SyntaxKind.CommaToken */)) { + assertions = parseImportTypeAssertions(); + } + parseExpected(21 /* SyntaxKind.CloseParenToken */); + var qualifier = parseOptional(24 /* SyntaxKind.DotToken */) ? parseEntityNameOfTypeReference() : undefined; + var typeArguments = parseTypeArgumentsOfTypeReference(); + return finishNode(factory.createImportTypeNode(type, assertions, qualifier, typeArguments, isTypeOf), pos); + } + function nextTokenIsNumericOrBigIntLiteral() { + nextToken(); + return token() === 8 /* SyntaxKind.NumericLiteral */ || token() === 9 /* SyntaxKind.BigIntLiteral */; + } + function parseNonArrayType() { + switch (token()) { + case 131 /* SyntaxKind.AnyKeyword */: + case 157 /* SyntaxKind.UnknownKeyword */: + case 152 /* SyntaxKind.StringKeyword */: + case 148 /* SyntaxKind.NumberKeyword */: + case 160 /* SyntaxKind.BigIntKeyword */: + case 153 /* SyntaxKind.SymbolKeyword */: + case 134 /* SyntaxKind.BooleanKeyword */: + case 155 /* SyntaxKind.UndefinedKeyword */: + case 144 /* SyntaxKind.NeverKeyword */: + case 149 /* SyntaxKind.ObjectKeyword */: + // If these are followed by a dot, then parse these out as a dotted type reference instead. + return tryParse(parseKeywordAndNoDot) || parseTypeReference(); + case 66 /* SyntaxKind.AsteriskEqualsToken */: + // If there is '*=', treat it as * followed by postfix = + scanner.reScanAsteriskEqualsToken(); + // falls through + case 41 /* SyntaxKind.AsteriskToken */: + return parseJSDocAllType(); + case 60 /* SyntaxKind.QuestionQuestionToken */: + // If there is '??', treat it as prefix-'?' in JSDoc type. + scanner.reScanQuestionToken(); + // falls through + case 57 /* SyntaxKind.QuestionToken */: + return parseJSDocUnknownOrNullableType(); + case 98 /* SyntaxKind.FunctionKeyword */: + return parseJSDocFunctionType(); + case 53 /* SyntaxKind.ExclamationToken */: + return parseJSDocNonNullableType(); + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + case 10 /* SyntaxKind.StringLiteral */: + case 8 /* SyntaxKind.NumericLiteral */: + case 9 /* SyntaxKind.BigIntLiteral */: + case 110 /* SyntaxKind.TrueKeyword */: + case 95 /* SyntaxKind.FalseKeyword */: + case 104 /* SyntaxKind.NullKeyword */: + return parseLiteralTypeNode(); + case 40 /* SyntaxKind.MinusToken */: + return lookAhead(nextTokenIsNumericOrBigIntLiteral) ? parseLiteralTypeNode(/*negative*/ true) : parseTypeReference(); + case 114 /* SyntaxKind.VoidKeyword */: + return parseTokenNode(); + case 108 /* SyntaxKind.ThisKeyword */: { + var thisKeyword = parseThisTypeNode(); + if (token() === 140 /* SyntaxKind.IsKeyword */ && !scanner.hasPrecedingLineBreak()) { + return parseThisTypePredicate(thisKeyword); + } + else { + return thisKeyword; + } + } + case 112 /* SyntaxKind.TypeOfKeyword */: + return lookAhead(isStartOfTypeOfImportType) ? parseImportType() : parseTypeQuery(); + case 18 /* SyntaxKind.OpenBraceToken */: + return lookAhead(isStartOfMappedType) ? parseMappedType() : parseTypeLiteral(); + case 22 /* SyntaxKind.OpenBracketToken */: + return parseTupleType(); + case 20 /* SyntaxKind.OpenParenToken */: + return parseParenthesizedType(); + case 100 /* SyntaxKind.ImportKeyword */: + return parseImportType(); + case 129 /* SyntaxKind.AssertsKeyword */: + return lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine) ? parseAssertsTypePredicate() : parseTypeReference(); + case 15 /* SyntaxKind.TemplateHead */: + return parseTemplateType(); + default: + return parseTypeReference(); + } + } + function isStartOfType(inStartOfParameter) { + switch (token()) { + case 131 /* SyntaxKind.AnyKeyword */: + case 157 /* SyntaxKind.UnknownKeyword */: + case 152 /* SyntaxKind.StringKeyword */: + case 148 /* SyntaxKind.NumberKeyword */: + case 160 /* SyntaxKind.BigIntKeyword */: + case 134 /* SyntaxKind.BooleanKeyword */: + case 146 /* SyntaxKind.ReadonlyKeyword */: + case 153 /* SyntaxKind.SymbolKeyword */: + case 156 /* SyntaxKind.UniqueKeyword */: + case 114 /* SyntaxKind.VoidKeyword */: + case 155 /* SyntaxKind.UndefinedKeyword */: + case 104 /* SyntaxKind.NullKeyword */: + case 108 /* SyntaxKind.ThisKeyword */: + case 112 /* SyntaxKind.TypeOfKeyword */: + case 144 /* SyntaxKind.NeverKeyword */: + case 18 /* SyntaxKind.OpenBraceToken */: + case 22 /* SyntaxKind.OpenBracketToken */: + case 29 /* SyntaxKind.LessThanToken */: + case 51 /* SyntaxKind.BarToken */: + case 50 /* SyntaxKind.AmpersandToken */: + case 103 /* SyntaxKind.NewKeyword */: + case 10 /* SyntaxKind.StringLiteral */: + case 8 /* SyntaxKind.NumericLiteral */: + case 9 /* SyntaxKind.BigIntLiteral */: + case 110 /* SyntaxKind.TrueKeyword */: + case 95 /* SyntaxKind.FalseKeyword */: + case 149 /* SyntaxKind.ObjectKeyword */: + case 41 /* SyntaxKind.AsteriskToken */: + case 57 /* SyntaxKind.QuestionToken */: + case 53 /* SyntaxKind.ExclamationToken */: + case 25 /* SyntaxKind.DotDotDotToken */: + case 138 /* SyntaxKind.InferKeyword */: + case 100 /* SyntaxKind.ImportKeyword */: + case 129 /* SyntaxKind.AssertsKeyword */: + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + case 15 /* SyntaxKind.TemplateHead */: + return true; + case 98 /* SyntaxKind.FunctionKeyword */: + return !inStartOfParameter; + case 40 /* SyntaxKind.MinusToken */: + return !inStartOfParameter && lookAhead(nextTokenIsNumericOrBigIntLiteral); + case 20 /* SyntaxKind.OpenParenToken */: + // Only consider '(' the start of a type if followed by ')', '...', an identifier, a modifier, + // or something that starts a type. We don't want to consider things like '(1)' a type. + return !inStartOfParameter && lookAhead(isStartOfParenthesizedOrFunctionType); + default: + return isIdentifier(); + } + } + function isStartOfParenthesizedOrFunctionType() { + nextToken(); + return token() === 21 /* SyntaxKind.CloseParenToken */ || isStartOfParameter(/*isJSDocParameter*/ false) || isStartOfType(); + } + function parsePostfixTypeOrHigher() { + var pos = getNodePos(); + var type = parseNonArrayType(); + while (!scanner.hasPrecedingLineBreak()) { + switch (token()) { + case 53 /* SyntaxKind.ExclamationToken */: + nextToken(); + type = finishNode(factory.createJSDocNonNullableType(type, /*postfix*/ true), pos); + break; + case 57 /* SyntaxKind.QuestionToken */: + // If next token is start of a type we have a conditional type + if (lookAhead(nextTokenIsStartOfType)) { + return type; + } + nextToken(); + type = finishNode(factory.createJSDocNullableType(type, /*postfix*/ true), pos); + break; + case 22 /* SyntaxKind.OpenBracketToken */: + parseExpected(22 /* SyntaxKind.OpenBracketToken */); + if (isStartOfType()) { + var indexType = parseType(); + parseExpected(23 /* SyntaxKind.CloseBracketToken */); + type = finishNode(factory.createIndexedAccessTypeNode(type, indexType), pos); + } + else { + parseExpected(23 /* SyntaxKind.CloseBracketToken */); + type = finishNode(factory.createArrayTypeNode(type), pos); + } + break; + default: + return type; + } + } + return type; + } + function parseTypeOperator(operator) { + var pos = getNodePos(); + parseExpected(operator); + return finishNode(factory.createTypeOperatorNode(operator, parseTypeOperatorOrHigher()), pos); + } + function tryParseConstraintOfInferType() { + if (parseOptional(94 /* SyntaxKind.ExtendsKeyword */)) { + var constraint = disallowConditionalTypesAnd(parseType); + if (inDisallowConditionalTypesContext() || token() !== 57 /* SyntaxKind.QuestionToken */) { + return constraint; + } + } + } + function parseTypeParameterOfInferType() { + var pos = getNodePos(); + var name = parseIdentifier(); + var constraint = tryParse(tryParseConstraintOfInferType); + var node = factory.createTypeParameterDeclaration(/*modifiers*/ undefined, name, constraint); + return finishNode(node, pos); + } + function parseInferType() { + var pos = getNodePos(); + parseExpected(138 /* SyntaxKind.InferKeyword */); + return finishNode(factory.createInferTypeNode(parseTypeParameterOfInferType()), pos); + } + function parseTypeOperatorOrHigher() { + var operator = token(); + switch (operator) { + case 141 /* SyntaxKind.KeyOfKeyword */: + case 156 /* SyntaxKind.UniqueKeyword */: + case 146 /* SyntaxKind.ReadonlyKeyword */: + return parseTypeOperator(operator); + case 138 /* SyntaxKind.InferKeyword */: + return parseInferType(); + } + return allowConditionalTypesAnd(parsePostfixTypeOrHigher); + } + function parseFunctionOrConstructorTypeToError(isInUnionType) { + // the function type and constructor type shorthand notation + // are not allowed directly in unions and intersections, but we'll + // try to parse them gracefully and issue a helpful message. + if (isStartOfFunctionTypeOrConstructorType()) { + var type = parseFunctionOrConstructorType(); + var diagnostic = void 0; + if (ts.isFunctionTypeNode(type)) { + diagnostic = isInUnionType + ? ts.Diagnostics.Function_type_notation_must_be_parenthesized_when_used_in_a_union_type + : ts.Diagnostics.Function_type_notation_must_be_parenthesized_when_used_in_an_intersection_type; + } + else { + diagnostic = isInUnionType + ? ts.Diagnostics.Constructor_type_notation_must_be_parenthesized_when_used_in_a_union_type + : ts.Diagnostics.Constructor_type_notation_must_be_parenthesized_when_used_in_an_intersection_type; + } + parseErrorAtRange(type, diagnostic); + return type; + } + return undefined; + } + function parseUnionOrIntersectionType(operator, parseConstituentType, createTypeNode) { + var pos = getNodePos(); + var isUnionType = operator === 51 /* SyntaxKind.BarToken */; + var hasLeadingOperator = parseOptional(operator); + var type = hasLeadingOperator && parseFunctionOrConstructorTypeToError(isUnionType) + || parseConstituentType(); + if (token() === operator || hasLeadingOperator) { + var types = [type]; + while (parseOptional(operator)) { + types.push(parseFunctionOrConstructorTypeToError(isUnionType) || parseConstituentType()); + } + type = finishNode(createTypeNode(createNodeArray(types, pos)), pos); + } + return type; + } + function parseIntersectionTypeOrHigher() { + return parseUnionOrIntersectionType(50 /* SyntaxKind.AmpersandToken */, parseTypeOperatorOrHigher, factory.createIntersectionTypeNode); + } + function parseUnionTypeOrHigher() { + return parseUnionOrIntersectionType(51 /* SyntaxKind.BarToken */, parseIntersectionTypeOrHigher, factory.createUnionTypeNode); + } + function nextTokenIsNewKeyword() { + nextToken(); + return token() === 103 /* SyntaxKind.NewKeyword */; + } + function isStartOfFunctionTypeOrConstructorType() { + if (token() === 29 /* SyntaxKind.LessThanToken */) { + return true; + } + if (token() === 20 /* SyntaxKind.OpenParenToken */ && lookAhead(isUnambiguouslyStartOfFunctionType)) { + return true; + } + return token() === 103 /* SyntaxKind.NewKeyword */ || + token() === 126 /* SyntaxKind.AbstractKeyword */ && lookAhead(nextTokenIsNewKeyword); + } + function skipParameterStart() { + if (ts.isModifierKind(token())) { + // Skip modifiers + parseModifiers(); + } + if (isIdentifier() || token() === 108 /* SyntaxKind.ThisKeyword */) { + nextToken(); + return true; + } + if (token() === 22 /* SyntaxKind.OpenBracketToken */ || token() === 18 /* SyntaxKind.OpenBraceToken */) { + // Return true if we can parse an array or object binding pattern with no errors + var previousErrorCount = parseDiagnostics.length; + parseIdentifierOrPattern(); + return previousErrorCount === parseDiagnostics.length; + } + return false; + } + function isUnambiguouslyStartOfFunctionType() { + nextToken(); + if (token() === 21 /* SyntaxKind.CloseParenToken */ || token() === 25 /* SyntaxKind.DotDotDotToken */) { + // ( ) + // ( ... + return true; + } + if (skipParameterStart()) { + // We successfully skipped modifiers (if any) and an identifier or binding pattern, + // now see if we have something that indicates a parameter declaration + if (token() === 58 /* SyntaxKind.ColonToken */ || token() === 27 /* SyntaxKind.CommaToken */ || + token() === 57 /* SyntaxKind.QuestionToken */ || token() === 63 /* SyntaxKind.EqualsToken */) { + // ( xxx : + // ( xxx , + // ( xxx ? + // ( xxx = + return true; + } + if (token() === 21 /* SyntaxKind.CloseParenToken */) { + nextToken(); + if (token() === 38 /* SyntaxKind.EqualsGreaterThanToken */) { + // ( xxx ) => + return true; + } + } + } + return false; + } + function parseTypeOrTypePredicate() { + var pos = getNodePos(); + var typePredicateVariable = isIdentifier() && tryParse(parseTypePredicatePrefix); + var type = parseType(); + if (typePredicateVariable) { + return finishNode(factory.createTypePredicateNode(/*assertsModifier*/ undefined, typePredicateVariable, type), pos); + } + else { + return type; + } + } + function parseTypePredicatePrefix() { + var id = parseIdentifier(); + if (token() === 140 /* SyntaxKind.IsKeyword */ && !scanner.hasPrecedingLineBreak()) { + nextToken(); + return id; + } + } + function parseAssertsTypePredicate() { + var pos = getNodePos(); + var assertsModifier = parseExpectedToken(129 /* SyntaxKind.AssertsKeyword */); + var parameterName = token() === 108 /* SyntaxKind.ThisKeyword */ ? parseThisTypeNode() : parseIdentifier(); + var type = parseOptional(140 /* SyntaxKind.IsKeyword */) ? parseType() : undefined; + return finishNode(factory.createTypePredicateNode(assertsModifier, parameterName, type), pos); + } + function parseType() { + if (contextFlags & 40960 /* NodeFlags.TypeExcludesFlags */) { + return doOutsideOfContext(40960 /* NodeFlags.TypeExcludesFlags */, parseType); + } + if (isStartOfFunctionTypeOrConstructorType()) { + return parseFunctionOrConstructorType(); + } + var pos = getNodePos(); + var type = parseUnionTypeOrHigher(); + if (!inDisallowConditionalTypesContext() && !scanner.hasPrecedingLineBreak() && parseOptional(94 /* SyntaxKind.ExtendsKeyword */)) { + // The type following 'extends' is not permitted to be another conditional type + var extendsType = disallowConditionalTypesAnd(parseType); + parseExpected(57 /* SyntaxKind.QuestionToken */); + var trueType = allowConditionalTypesAnd(parseType); + parseExpected(58 /* SyntaxKind.ColonToken */); + var falseType = allowConditionalTypesAnd(parseType); + return finishNode(factory.createConditionalTypeNode(type, extendsType, trueType, falseType), pos); + } + return type; + } + function parseTypeAnnotation() { + return parseOptional(58 /* SyntaxKind.ColonToken */) ? parseType() : undefined; + } + // EXPRESSIONS + function isStartOfLeftHandSideExpression() { + switch (token()) { + case 108 /* SyntaxKind.ThisKeyword */: + case 106 /* SyntaxKind.SuperKeyword */: + case 104 /* SyntaxKind.NullKeyword */: + case 110 /* SyntaxKind.TrueKeyword */: + case 95 /* SyntaxKind.FalseKeyword */: + case 8 /* SyntaxKind.NumericLiteral */: + case 9 /* SyntaxKind.BigIntLiteral */: + case 10 /* SyntaxKind.StringLiteral */: + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + case 15 /* SyntaxKind.TemplateHead */: + case 20 /* SyntaxKind.OpenParenToken */: + case 22 /* SyntaxKind.OpenBracketToken */: + case 18 /* SyntaxKind.OpenBraceToken */: + case 98 /* SyntaxKind.FunctionKeyword */: + case 84 /* SyntaxKind.ClassKeyword */: + case 103 /* SyntaxKind.NewKeyword */: + case 43 /* SyntaxKind.SlashToken */: + case 68 /* SyntaxKind.SlashEqualsToken */: + case 79 /* SyntaxKind.Identifier */: + return true; + case 100 /* SyntaxKind.ImportKeyword */: + return lookAhead(nextTokenIsOpenParenOrLessThanOrDot); + default: + return isIdentifier(); + } + } + function isStartOfExpression() { + if (isStartOfLeftHandSideExpression()) { + return true; + } + switch (token()) { + case 39 /* SyntaxKind.PlusToken */: + case 40 /* SyntaxKind.MinusToken */: + case 54 /* SyntaxKind.TildeToken */: + case 53 /* SyntaxKind.ExclamationToken */: + case 89 /* SyntaxKind.DeleteKeyword */: + case 112 /* SyntaxKind.TypeOfKeyword */: + case 114 /* SyntaxKind.VoidKeyword */: + case 45 /* SyntaxKind.PlusPlusToken */: + case 46 /* SyntaxKind.MinusMinusToken */: + case 29 /* SyntaxKind.LessThanToken */: + case 133 /* SyntaxKind.AwaitKeyword */: + case 125 /* SyntaxKind.YieldKeyword */: + case 80 /* SyntaxKind.PrivateIdentifier */: + // Yield/await always starts an expression. Either it is an identifier (in which case + // it is definitely an expression). Or it's a keyword (either because we're in + // a generator or async function, or in strict mode (or both)) and it started a yield or await expression. + return true; + default: + // Error tolerance. If we see the start of some binary operator, we consider + // that the start of an expression. That way we'll parse out a missing identifier, + // give a good message about an identifier being missing, and then consume the + // rest of the binary expression. + if (isBinaryOperator()) { + return true; + } + return isIdentifier(); + } + } + function isStartOfExpressionStatement() { + // As per the grammar, none of '{' or 'function' or 'class' can start an expression statement. + return token() !== 18 /* SyntaxKind.OpenBraceToken */ && + token() !== 98 /* SyntaxKind.FunctionKeyword */ && + token() !== 84 /* SyntaxKind.ClassKeyword */ && + token() !== 59 /* SyntaxKind.AtToken */ && + isStartOfExpression(); + } + function parseExpression() { + // Expression[in]: + // AssignmentExpression[in] + // Expression[in] , AssignmentExpression[in] + // clear the decorator context when parsing Expression, as it should be unambiguous when parsing a decorator + var saveDecoratorContext = inDecoratorContext(); + if (saveDecoratorContext) { + setDecoratorContext(/*val*/ false); + } + var pos = getNodePos(); + var expr = parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true); + var operatorToken; + while ((operatorToken = parseOptionalToken(27 /* SyntaxKind.CommaToken */))) { + expr = makeBinaryExpression(expr, operatorToken, parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true), pos); + } + if (saveDecoratorContext) { + setDecoratorContext(/*val*/ true); + } + return expr; + } + function parseInitializer() { + return parseOptional(63 /* SyntaxKind.EqualsToken */) ? parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true) : undefined; + } + function parseAssignmentExpressionOrHigher(allowReturnTypeInArrowFunction) { + // AssignmentExpression[in,yield]: + // 1) ConditionalExpression[?in,?yield] + // 2) LeftHandSideExpression = AssignmentExpression[?in,?yield] + // 3) LeftHandSideExpression AssignmentOperator AssignmentExpression[?in,?yield] + // 4) ArrowFunctionExpression[?in,?yield] + // 5) AsyncArrowFunctionExpression[in,yield,await] + // 6) [+Yield] YieldExpression[?In] + // + // Note: for ease of implementation we treat productions '2' and '3' as the same thing. + // (i.e. they're both BinaryExpressions with an assignment operator in it). + // First, do the simple check if we have a YieldExpression (production '6'). + if (isYieldExpression()) { + return parseYieldExpression(); + } + // Then, check if we have an arrow function (production '4' and '5') that starts with a parenthesized + // parameter list or is an async arrow function. + // AsyncArrowFunctionExpression: + // 1) async[no LineTerminator here]AsyncArrowBindingIdentifier[?Yield][no LineTerminator here]=>AsyncConciseBody[?In] + // 2) CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await][no LineTerminator here]=>AsyncConciseBody[?In] + // Production (1) of AsyncArrowFunctionExpression is parsed in "tryParseAsyncSimpleArrowFunctionExpression". + // And production (2) is parsed in "tryParseParenthesizedArrowFunctionExpression". + // + // If we do successfully parse arrow-function, we must *not* recurse for productions 1, 2 or 3. An ArrowFunction is + // not a LeftHandSideExpression, nor does it start a ConditionalExpression. So we are done + // with AssignmentExpression if we see one. + var arrowExpression = tryParseParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction) || tryParseAsyncSimpleArrowFunctionExpression(allowReturnTypeInArrowFunction); + if (arrowExpression) { + return arrowExpression; + } + // Now try to see if we're in production '1', '2' or '3'. A conditional expression can + // start with a LogicalOrExpression, while the assignment productions can only start with + // LeftHandSideExpressions. + // + // So, first, we try to just parse out a BinaryExpression. If we get something that is a + // LeftHandSide or higher, then we can try to parse out the assignment expression part. + // Otherwise, we try to parse out the conditional expression bit. We want to allow any + // binary expression here, so we pass in the 'lowest' precedence here so that it matches + // and consumes anything. + var pos = getNodePos(); + var expr = parseBinaryExpressionOrHigher(0 /* OperatorPrecedence.Lowest */); + // To avoid a look-ahead, we did not handle the case of an arrow function with a single un-parenthesized + // parameter ('x => ...') above. We handle it here by checking if the parsed expression was a single + // identifier and the current token is an arrow. + if (expr.kind === 79 /* SyntaxKind.Identifier */ && token() === 38 /* SyntaxKind.EqualsGreaterThanToken */) { + return parseSimpleArrowFunctionExpression(pos, expr, allowReturnTypeInArrowFunction, /*asyncModifier*/ undefined); + } + // Now see if we might be in cases '2' or '3'. + // If the expression was a LHS expression, and we have an assignment operator, then + // we're in '2' or '3'. Consume the assignment and return. + // + // Note: we call reScanGreaterToken so that we get an appropriately merged token + // for cases like `> > =` becoming `>>=` + if (ts.isLeftHandSideExpression(expr) && ts.isAssignmentOperator(reScanGreaterToken())) { + return makeBinaryExpression(expr, parseTokenNode(), parseAssignmentExpressionOrHigher(allowReturnTypeInArrowFunction), pos); + } + // It wasn't an assignment or a lambda. This is a conditional expression: + return parseConditionalExpressionRest(expr, pos, allowReturnTypeInArrowFunction); + } + function isYieldExpression() { + if (token() === 125 /* SyntaxKind.YieldKeyword */) { + // If we have a 'yield' keyword, and this is a context where yield expressions are + // allowed, then definitely parse out a yield expression. + if (inYieldContext()) { + return true; + } + // We're in a context where 'yield expr' is not allowed. However, if we can + // definitely tell that the user was trying to parse a 'yield expr' and not + // just a normal expr that start with a 'yield' identifier, then parse out + // a 'yield expr'. We can then report an error later that they are only + // allowed in generator expressions. + // + // for example, if we see 'yield(foo)', then we'll have to treat that as an + // invocation expression of something called 'yield'. However, if we have + // 'yield foo' then that is not legal as a normal expression, so we can + // definitely recognize this as a yield expression. + // + // for now we just check if the next token is an identifier. More heuristics + // can be added here later as necessary. We just need to make sure that we + // don't accidentally consume something legal. + return lookAhead(nextTokenIsIdentifierOrKeywordOrLiteralOnSameLine); + } + return false; + } + function nextTokenIsIdentifierOnSameLine() { + nextToken(); + return !scanner.hasPrecedingLineBreak() && isIdentifier(); + } + function parseYieldExpression() { + var pos = getNodePos(); + // YieldExpression[In] : + // yield + // yield [no LineTerminator here] [Lexical goal InputElementRegExp]AssignmentExpression[?In, Yield] + // yield [no LineTerminator here] * [Lexical goal InputElementRegExp]AssignmentExpression[?In, Yield] + nextToken(); + if (!scanner.hasPrecedingLineBreak() && + (token() === 41 /* SyntaxKind.AsteriskToken */ || isStartOfExpression())) { + return finishNode(factory.createYieldExpression(parseOptionalToken(41 /* SyntaxKind.AsteriskToken */), parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true)), pos); + } + else { + // if the next token is not on the same line as yield. or we don't have an '*' or + // the start of an expression, then this is just a simple "yield" expression. + return finishNode(factory.createYieldExpression(/*asteriskToken*/ undefined, /*expression*/ undefined), pos); + } + } + function parseSimpleArrowFunctionExpression(pos, identifier, allowReturnTypeInArrowFunction, asyncModifier) { + ts.Debug.assert(token() === 38 /* SyntaxKind.EqualsGreaterThanToken */, "parseSimpleArrowFunctionExpression should only have been called if we had a =>"); + var parameter = factory.createParameterDeclaration( + /*modifiers*/ undefined, + /*dotDotDotToken*/ undefined, identifier, + /*questionToken*/ undefined, + /*type*/ undefined, + /*initializer*/ undefined); + finishNode(parameter, identifier.pos); + var parameters = createNodeArray([parameter], parameter.pos, parameter.end); + var equalsGreaterThanToken = parseExpectedToken(38 /* SyntaxKind.EqualsGreaterThanToken */); + var body = parseArrowFunctionExpressionBody(/*isAsync*/ !!asyncModifier, allowReturnTypeInArrowFunction); + var node = factory.createArrowFunction(asyncModifier, /*typeParameters*/ undefined, parameters, /*type*/ undefined, equalsGreaterThanToken, body); + return addJSDocComment(finishNode(node, pos)); + } + function tryParseParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction) { + var triState = isParenthesizedArrowFunctionExpression(); + if (triState === 0 /* Tristate.False */) { + // It's definitely not a parenthesized arrow function expression. + return undefined; + } + // If we definitely have an arrow function, then we can just parse one, not requiring a + // following => or { token. Otherwise, we *might* have an arrow function. Try to parse + // it out, but don't allow any ambiguity, and return 'undefined' if this could be an + // expression instead. + return triState === 1 /* Tristate.True */ ? + parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ true, /*allowReturnTypeInArrowFunction*/ true) : + tryParse(function () { return parsePossibleParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction); }); + } + // True -> We definitely expect a parenthesized arrow function here. + // False -> There *cannot* be a parenthesized arrow function here. + // Unknown -> There *might* be a parenthesized arrow function here. + // Speculatively look ahead to be sure, and rollback if not. + function isParenthesizedArrowFunctionExpression() { + if (token() === 20 /* SyntaxKind.OpenParenToken */ || token() === 29 /* SyntaxKind.LessThanToken */ || token() === 132 /* SyntaxKind.AsyncKeyword */) { + return lookAhead(isParenthesizedArrowFunctionExpressionWorker); + } + if (token() === 38 /* SyntaxKind.EqualsGreaterThanToken */) { + // ERROR RECOVERY TWEAK: + // If we see a standalone => try to parse it as an arrow function expression as that's + // likely what the user intended to write. + return 1 /* Tristate.True */; + } + // Definitely not a parenthesized arrow function. + return 0 /* Tristate.False */; + } + function isParenthesizedArrowFunctionExpressionWorker() { + if (token() === 132 /* SyntaxKind.AsyncKeyword */) { + nextToken(); + if (scanner.hasPrecedingLineBreak()) { + return 0 /* Tristate.False */; + } + if (token() !== 20 /* SyntaxKind.OpenParenToken */ && token() !== 29 /* SyntaxKind.LessThanToken */) { + return 0 /* Tristate.False */; + } + } + var first = token(); + var second = nextToken(); + if (first === 20 /* SyntaxKind.OpenParenToken */) { + if (second === 21 /* SyntaxKind.CloseParenToken */) { + // Simple cases: "() =>", "(): ", and "() {". + // This is an arrow function with no parameters. + // The last one is not actually an arrow function, + // but this is probably what the user intended. + var third = nextToken(); + switch (third) { + case 38 /* SyntaxKind.EqualsGreaterThanToken */: + case 58 /* SyntaxKind.ColonToken */: + case 18 /* SyntaxKind.OpenBraceToken */: + return 1 /* Tristate.True */; + default: + return 0 /* Tristate.False */; + } + } + // If encounter "([" or "({", this could be the start of a binding pattern. + // Examples: + // ([ x ]) => { } + // ({ x }) => { } + // ([ x ]) + // ({ x }) + if (second === 22 /* SyntaxKind.OpenBracketToken */ || second === 18 /* SyntaxKind.OpenBraceToken */) { + return 2 /* Tristate.Unknown */; + } + // Simple case: "(..." + // This is an arrow function with a rest parameter. + if (second === 25 /* SyntaxKind.DotDotDotToken */) { + return 1 /* Tristate.True */; + } + // Check for "(xxx yyy", where xxx is a modifier and yyy is an identifier. This + // isn't actually allowed, but we want to treat it as a lambda so we can provide + // a good error message. + if (ts.isModifierKind(second) && second !== 132 /* SyntaxKind.AsyncKeyword */ && lookAhead(nextTokenIsIdentifier)) { + if (nextToken() === 128 /* SyntaxKind.AsKeyword */) { + // https://github.com/microsoft/TypeScript/issues/44466 + return 0 /* Tristate.False */; + } + return 1 /* Tristate.True */; + } + // If we had "(" followed by something that's not an identifier, + // then this definitely doesn't look like a lambda. "this" is not + // valid, but we want to parse it and then give a semantic error. + if (!isIdentifier() && second !== 108 /* SyntaxKind.ThisKeyword */) { + return 0 /* Tristate.False */; + } + switch (nextToken()) { + case 58 /* SyntaxKind.ColonToken */: + // If we have something like "(a:", then we must have a + // type-annotated parameter in an arrow function expression. + return 1 /* Tristate.True */; + case 57 /* SyntaxKind.QuestionToken */: + nextToken(); + // If we have "(a?:" or "(a?," or "(a?=" or "(a?)" then it is definitely a lambda. + if (token() === 58 /* SyntaxKind.ColonToken */ || token() === 27 /* SyntaxKind.CommaToken */ || token() === 63 /* SyntaxKind.EqualsToken */ || token() === 21 /* SyntaxKind.CloseParenToken */) { + return 1 /* Tristate.True */; + } + // Otherwise it is definitely not a lambda. + return 0 /* Tristate.False */; + case 27 /* SyntaxKind.CommaToken */: + case 63 /* SyntaxKind.EqualsToken */: + case 21 /* SyntaxKind.CloseParenToken */: + // If we have "(a," or "(a=" or "(a)" this *could* be an arrow function + return 2 /* Tristate.Unknown */; + } + // It is definitely not an arrow function + return 0 /* Tristate.False */; + } + else { + ts.Debug.assert(first === 29 /* SyntaxKind.LessThanToken */); + // If we have "<" not followed by an identifier, + // then this definitely is not an arrow function. + if (!isIdentifier()) { + return 0 /* Tristate.False */; + } + // JSX overrides + if (languageVariant === 1 /* LanguageVariant.JSX */) { + var isArrowFunctionInJsx = lookAhead(function () { + var third = nextToken(); + if (third === 94 /* SyntaxKind.ExtendsKeyword */) { + var fourth = nextToken(); + switch (fourth) { + case 63 /* SyntaxKind.EqualsToken */: + case 31 /* SyntaxKind.GreaterThanToken */: + return false; + default: + return true; + } + } + else if (third === 27 /* SyntaxKind.CommaToken */ || third === 63 /* SyntaxKind.EqualsToken */) { + return true; + } + return false; + }); + if (isArrowFunctionInJsx) { + return 1 /* Tristate.True */; + } + return 0 /* Tristate.False */; + } + // This *could* be a parenthesized arrow function. + return 2 /* Tristate.Unknown */; + } + } + function parsePossibleParenthesizedArrowFunctionExpression(allowReturnTypeInArrowFunction) { + var tokenPos = scanner.getTokenPos(); + if (notParenthesizedArrow === null || notParenthesizedArrow === void 0 ? void 0 : notParenthesizedArrow.has(tokenPos)) { + return undefined; + } + var result = parseParenthesizedArrowFunctionExpression(/*allowAmbiguity*/ false, allowReturnTypeInArrowFunction); + if (!result) { + (notParenthesizedArrow || (notParenthesizedArrow = new ts.Set())).add(tokenPos); + } + return result; + } + function tryParseAsyncSimpleArrowFunctionExpression(allowReturnTypeInArrowFunction) { + // We do a check here so that we won't be doing unnecessarily call to "lookAhead" + if (token() === 132 /* SyntaxKind.AsyncKeyword */) { + if (lookAhead(isUnParenthesizedAsyncArrowFunctionWorker) === 1 /* Tristate.True */) { + var pos = getNodePos(); + var asyncModifier = parseModifiersForArrowFunction(); + var expr = parseBinaryExpressionOrHigher(0 /* OperatorPrecedence.Lowest */); + return parseSimpleArrowFunctionExpression(pos, expr, allowReturnTypeInArrowFunction, asyncModifier); + } + } + return undefined; + } + function isUnParenthesizedAsyncArrowFunctionWorker() { + // AsyncArrowFunctionExpression: + // 1) async[no LineTerminator here]AsyncArrowBindingIdentifier[?Yield][no LineTerminator here]=>AsyncConciseBody[?In] + // 2) CoverCallExpressionAndAsyncArrowHead[?Yield, ?Await][no LineTerminator here]=>AsyncConciseBody[?In] + if (token() === 132 /* SyntaxKind.AsyncKeyword */) { + nextToken(); + // If the "async" is followed by "=>" token then it is not a beginning of an async arrow-function + // but instead a simple arrow-function which will be parsed inside "parseAssignmentExpressionOrHigher" + if (scanner.hasPrecedingLineBreak() || token() === 38 /* SyntaxKind.EqualsGreaterThanToken */) { + return 0 /* Tristate.False */; + } + // Check for un-parenthesized AsyncArrowFunction + var expr = parseBinaryExpressionOrHigher(0 /* OperatorPrecedence.Lowest */); + if (!scanner.hasPrecedingLineBreak() && expr.kind === 79 /* SyntaxKind.Identifier */ && token() === 38 /* SyntaxKind.EqualsGreaterThanToken */) { + return 1 /* Tristate.True */; + } + } + return 0 /* Tristate.False */; + } + function parseParenthesizedArrowFunctionExpression(allowAmbiguity, allowReturnTypeInArrowFunction) { + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + var modifiers = parseModifiersForArrowFunction(); + var isAsync = ts.some(modifiers, ts.isAsyncModifier) ? 2 /* SignatureFlags.Await */ : 0 /* SignatureFlags.None */; + // Arrow functions are never generators. + // + // If we're speculatively parsing a signature for a parenthesized arrow function, then + // we have to have a complete parameter list. Otherwise we might see something like + // a => (b => c) + // And think that "(b =>" was actually a parenthesized arrow function with a missing + // close paren. + var typeParameters = parseTypeParameters(); + var parameters; + if (!parseExpected(20 /* SyntaxKind.OpenParenToken */)) { + if (!allowAmbiguity) { + return undefined; + } + parameters = createMissingList(); + } + else { + if (!allowAmbiguity) { + var maybeParameters = parseParametersWorker(isAsync, allowAmbiguity); + if (!maybeParameters) { + return undefined; + } + parameters = maybeParameters; + } + else { + parameters = parseParametersWorker(isAsync, allowAmbiguity); + } + if (!parseExpected(21 /* SyntaxKind.CloseParenToken */) && !allowAmbiguity) { + return undefined; + } + } + var hasReturnColon = token() === 58 /* SyntaxKind.ColonToken */; + var type = parseReturnType(58 /* SyntaxKind.ColonToken */, /*isType*/ false); + if (type && !allowAmbiguity && typeHasArrowFunctionBlockingParseError(type)) { + return undefined; + } + // Parsing a signature isn't enough. + // Parenthesized arrow signatures often look like other valid expressions. + // For instance: + // - "(x = 10)" is an assignment expression parsed as a signature with a default parameter value. + // - "(x,y)" is a comma expression parsed as a signature with two parameters. + // - "a ? (b): c" will have "(b):" parsed as a signature with a return type annotation. + // - "a ? (b): function() {}" will too, since function() is a valid JSDoc function type. + // - "a ? (b): (function() {})" as well, but inside of a parenthesized type with an arbitrary amount of nesting. + // + // So we need just a bit of lookahead to ensure that it can only be a signature. + var unwrappedType = type; + while ((unwrappedType === null || unwrappedType === void 0 ? void 0 : unwrappedType.kind) === 193 /* SyntaxKind.ParenthesizedType */) { + unwrappedType = unwrappedType.type; // Skip parens if need be + } + var hasJSDocFunctionType = unwrappedType && ts.isJSDocFunctionType(unwrappedType); + if (!allowAmbiguity && token() !== 38 /* SyntaxKind.EqualsGreaterThanToken */ && (hasJSDocFunctionType || token() !== 18 /* SyntaxKind.OpenBraceToken */)) { + // Returning undefined here will cause our caller to rewind to where we started from. + return undefined; + } + // If we have an arrow, then try to parse the body. Even if not, try to parse if we + // have an opening brace, just in case we're in an error state. + var lastToken = token(); + var equalsGreaterThanToken = parseExpectedToken(38 /* SyntaxKind.EqualsGreaterThanToken */); + var body = (lastToken === 38 /* SyntaxKind.EqualsGreaterThanToken */ || lastToken === 18 /* SyntaxKind.OpenBraceToken */) + ? parseArrowFunctionExpressionBody(ts.some(modifiers, ts.isAsyncModifier), allowReturnTypeInArrowFunction) + : parseIdentifier(); + // Given: + // x ? y => ({ y }) : z => ({ z }) + // We try to parse the body of the first arrow function by looking at: + // ({ y }) : z => ({ z }) + // This is a valid arrow function with "z" as the return type. + // + // But, if we're in the true side of a conditional expression, this colon + // terminates the expression, so we cannot allow a return type if we aren't + // certain whether or not the preceding text was parsed as a parameter list. + // + // For example, + // a() ? (b: number, c?: string): void => d() : e + // is determined by isParenthesizedArrowFunctionExpression to unambiguously + // be an arrow expression, so we allow a return type. + if (!allowReturnTypeInArrowFunction && hasReturnColon) { + // However, if the arrow function we were able to parse is followed by another colon + // as in: + // a ? (x): string => x : null + // Then allow the arrow function, and treat the second colon as terminating + // the conditional expression. It's okay to do this because this code would + // be a syntax error in JavaScript (as the second colon shouldn't be there). + if (token() !== 58 /* SyntaxKind.ColonToken */) { + return undefined; + } + } + var node = factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanToken, body); + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + function parseArrowFunctionExpressionBody(isAsync, allowReturnTypeInArrowFunction) { + if (token() === 18 /* SyntaxKind.OpenBraceToken */) { + return parseFunctionBlock(isAsync ? 2 /* SignatureFlags.Await */ : 0 /* SignatureFlags.None */); + } + if (token() !== 26 /* SyntaxKind.SemicolonToken */ && + token() !== 98 /* SyntaxKind.FunctionKeyword */ && + token() !== 84 /* SyntaxKind.ClassKeyword */ && + isStartOfStatement() && + !isStartOfExpressionStatement()) { + // Check if we got a plain statement (i.e. no expression-statements, no function/class expressions/declarations) + // + // Here we try to recover from a potential error situation in the case where the + // user meant to supply a block. For example, if the user wrote: + // + // a => + // let v = 0; + // } + // + // they may be missing an open brace. Check to see if that's the case so we can + // try to recover better. If we don't do this, then the next close curly we see may end + // up preemptively closing the containing construct. + // + // Note: even when 'IgnoreMissingOpenBrace' is passed, parseBody will still error. + return parseFunctionBlock(16 /* SignatureFlags.IgnoreMissingOpenBrace */ | (isAsync ? 2 /* SignatureFlags.Await */ : 0 /* SignatureFlags.None */)); + } + var savedTopLevel = topLevel; + topLevel = false; + var node = isAsync + ? doInAwaitContext(function () { return parseAssignmentExpressionOrHigher(allowReturnTypeInArrowFunction); }) + : doOutsideOfAwaitContext(function () { return parseAssignmentExpressionOrHigher(allowReturnTypeInArrowFunction); }); + topLevel = savedTopLevel; + return node; + } + function parseConditionalExpressionRest(leftOperand, pos, allowReturnTypeInArrowFunction) { + // Note: we are passed in an expression which was produced from parseBinaryExpressionOrHigher. + var questionToken = parseOptionalToken(57 /* SyntaxKind.QuestionToken */); + if (!questionToken) { + return leftOperand; + } + // Note: we explicitly 'allowIn' in the whenTrue part of the condition expression, and + // we do not that for the 'whenFalse' part. + var colonToken; + return finishNode(factory.createConditionalExpression(leftOperand, questionToken, doOutsideOfContext(disallowInAndDecoratorContext, function () { return parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ false); }), colonToken = parseExpectedToken(58 /* SyntaxKind.ColonToken */), ts.nodeIsPresent(colonToken) + ? parseAssignmentExpressionOrHigher(allowReturnTypeInArrowFunction) + : createMissingNode(79 /* SyntaxKind.Identifier */, /*reportAtCurrentPosition*/ false, ts.Diagnostics._0_expected, ts.tokenToString(58 /* SyntaxKind.ColonToken */))), pos); + } + function parseBinaryExpressionOrHigher(precedence) { + var pos = getNodePos(); + var leftOperand = parseUnaryExpressionOrHigher(); + return parseBinaryExpressionRest(precedence, leftOperand, pos); + } + function isInOrOfKeyword(t) { + return t === 101 /* SyntaxKind.InKeyword */ || t === 162 /* SyntaxKind.OfKeyword */; + } + function parseBinaryExpressionRest(precedence, leftOperand, pos) { + while (true) { + // We either have a binary operator here, or we're finished. We call + // reScanGreaterToken so that we merge token sequences like > and = into >= + reScanGreaterToken(); + var newPrecedence = ts.getBinaryOperatorPrecedence(token()); + // Check the precedence to see if we should "take" this operator + // - For left associative operator (all operator but **), consume the operator, + // recursively call the function below, and parse binaryExpression as a rightOperand + // of the caller if the new precedence of the operator is greater then or equal to the current precedence. + // For example: + // a - b - c; + // ^token; leftOperand = b. Return b to the caller as a rightOperand + // a * b - c + // ^token; leftOperand = b. Return b to the caller as a rightOperand + // a - b * c; + // ^token; leftOperand = b. Return b * c to the caller as a rightOperand + // - For right associative operator (**), consume the operator, recursively call the function + // and parse binaryExpression as a rightOperand of the caller if the new precedence of + // the operator is strictly grater than the current precedence + // For example: + // a ** b ** c; + // ^^token; leftOperand = b. Return b ** c to the caller as a rightOperand + // a - b ** c; + // ^^token; leftOperand = b. Return b ** c to the caller as a rightOperand + // a ** b - c + // ^token; leftOperand = b. Return b to the caller as a rightOperand + var consumeCurrentOperator = token() === 42 /* SyntaxKind.AsteriskAsteriskToken */ ? + newPrecedence >= precedence : + newPrecedence > precedence; + if (!consumeCurrentOperator) { + break; + } + if (token() === 101 /* SyntaxKind.InKeyword */ && inDisallowInContext()) { + break; + } + if (token() === 128 /* SyntaxKind.AsKeyword */ || token() === 150 /* SyntaxKind.SatisfiesKeyword */) { + // Make sure we *do* perform ASI for constructs like this: + // var x = foo + // as (Bar) + // This should be parsed as an initialized variable, followed + // by a function call to 'as' with the argument 'Bar' + if (scanner.hasPrecedingLineBreak()) { + break; + } + else { + var keywordKind = token(); + nextToken(); + leftOperand = keywordKind === 150 /* SyntaxKind.SatisfiesKeyword */ ? makeSatisfiesExpression(leftOperand, parseType()) : + makeAsExpression(leftOperand, parseType()); + } + } + else { + leftOperand = makeBinaryExpression(leftOperand, parseTokenNode(), parseBinaryExpressionOrHigher(newPrecedence), pos); + } + } + return leftOperand; + } + function isBinaryOperator() { + if (inDisallowInContext() && token() === 101 /* SyntaxKind.InKeyword */) { + return false; + } + return ts.getBinaryOperatorPrecedence(token()) > 0; + } + function makeSatisfiesExpression(left, right) { + return finishNode(factory.createSatisfiesExpression(left, right), left.pos); + } + function makeBinaryExpression(left, operatorToken, right, pos) { + return finishNode(factory.createBinaryExpression(left, operatorToken, right), pos); + } + function makeAsExpression(left, right) { + return finishNode(factory.createAsExpression(left, right), left.pos); + } + function parsePrefixUnaryExpression() { + var pos = getNodePos(); + return finishNode(factory.createPrefixUnaryExpression(token(), nextTokenAnd(parseSimpleUnaryExpression)), pos); + } + function parseDeleteExpression() { + var pos = getNodePos(); + return finishNode(factory.createDeleteExpression(nextTokenAnd(parseSimpleUnaryExpression)), pos); + } + function parseTypeOfExpression() { + var pos = getNodePos(); + return finishNode(factory.createTypeOfExpression(nextTokenAnd(parseSimpleUnaryExpression)), pos); + } + function parseVoidExpression() { + var pos = getNodePos(); + return finishNode(factory.createVoidExpression(nextTokenAnd(parseSimpleUnaryExpression)), pos); + } + function isAwaitExpression() { + if (token() === 133 /* SyntaxKind.AwaitKeyword */) { + if (inAwaitContext()) { + return true; + } + // here we are using similar heuristics as 'isYieldExpression' + return lookAhead(nextTokenIsIdentifierOrKeywordOrLiteralOnSameLine); + } + return false; + } + function parseAwaitExpression() { + var pos = getNodePos(); + return finishNode(factory.createAwaitExpression(nextTokenAnd(parseSimpleUnaryExpression)), pos); + } + /** + * Parse ES7 exponential expression and await expression + * + * ES7 ExponentiationExpression: + * 1) UnaryExpression[?Yield] + * 2) UpdateExpression[?Yield] ** ExponentiationExpression[?Yield] + * + */ + function parseUnaryExpressionOrHigher() { + /** + * ES7 UpdateExpression: + * 1) LeftHandSideExpression[?Yield] + * 2) LeftHandSideExpression[?Yield][no LineTerminator here]++ + * 3) LeftHandSideExpression[?Yield][no LineTerminator here]-- + * 4) ++UnaryExpression[?Yield] + * 5) --UnaryExpression[?Yield] + */ + if (isUpdateExpression()) { + var pos = getNodePos(); + var updateExpression = parseUpdateExpression(); + return token() === 42 /* SyntaxKind.AsteriskAsteriskToken */ ? + parseBinaryExpressionRest(ts.getBinaryOperatorPrecedence(token()), updateExpression, pos) : + updateExpression; + } + /** + * ES7 UnaryExpression: + * 1) UpdateExpression[?yield] + * 2) delete UpdateExpression[?yield] + * 3) void UpdateExpression[?yield] + * 4) typeof UpdateExpression[?yield] + * 5) + UpdateExpression[?yield] + * 6) - UpdateExpression[?yield] + * 7) ~ UpdateExpression[?yield] + * 8) ! UpdateExpression[?yield] + */ + var unaryOperator = token(); + var simpleUnaryExpression = parseSimpleUnaryExpression(); + if (token() === 42 /* SyntaxKind.AsteriskAsteriskToken */) { + var pos = ts.skipTrivia(sourceText, simpleUnaryExpression.pos); + var end = simpleUnaryExpression.end; + if (simpleUnaryExpression.kind === 213 /* SyntaxKind.TypeAssertionExpression */) { + parseErrorAt(pos, end, ts.Diagnostics.A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses); + } + else { + parseErrorAt(pos, end, ts.Diagnostics.An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses, ts.tokenToString(unaryOperator)); + } + } + return simpleUnaryExpression; + } + /** + * Parse ES7 simple-unary expression or higher: + * + * ES7 UnaryExpression: + * 1) UpdateExpression[?yield] + * 2) delete UnaryExpression[?yield] + * 3) void UnaryExpression[?yield] + * 4) typeof UnaryExpression[?yield] + * 5) + UnaryExpression[?yield] + * 6) - UnaryExpression[?yield] + * 7) ~ UnaryExpression[?yield] + * 8) ! UnaryExpression[?yield] + * 9) [+Await] await UnaryExpression[?yield] + */ + function parseSimpleUnaryExpression() { + switch (token()) { + case 39 /* SyntaxKind.PlusToken */: + case 40 /* SyntaxKind.MinusToken */: + case 54 /* SyntaxKind.TildeToken */: + case 53 /* SyntaxKind.ExclamationToken */: + return parsePrefixUnaryExpression(); + case 89 /* SyntaxKind.DeleteKeyword */: + return parseDeleteExpression(); + case 112 /* SyntaxKind.TypeOfKeyword */: + return parseTypeOfExpression(); + case 114 /* SyntaxKind.VoidKeyword */: + return parseVoidExpression(); + case 29 /* SyntaxKind.LessThanToken */: + // This is modified UnaryExpression grammar in TypeScript + // UnaryExpression (modified): + // < type > UnaryExpression + return parseTypeAssertion(); + case 133 /* SyntaxKind.AwaitKeyword */: + if (isAwaitExpression()) { + return parseAwaitExpression(); + } + // falls through + default: + return parseUpdateExpression(); + } + } + /** + * Check if the current token can possibly be an ES7 increment expression. + * + * ES7 UpdateExpression: + * LeftHandSideExpression[?Yield] + * LeftHandSideExpression[?Yield][no LineTerminator here]++ + * LeftHandSideExpression[?Yield][no LineTerminator here]-- + * ++LeftHandSideExpression[?Yield] + * --LeftHandSideExpression[?Yield] + */ + function isUpdateExpression() { + // This function is called inside parseUnaryExpression to decide + // whether to call parseSimpleUnaryExpression or call parseUpdateExpression directly + switch (token()) { + case 39 /* SyntaxKind.PlusToken */: + case 40 /* SyntaxKind.MinusToken */: + case 54 /* SyntaxKind.TildeToken */: + case 53 /* SyntaxKind.ExclamationToken */: + case 89 /* SyntaxKind.DeleteKeyword */: + case 112 /* SyntaxKind.TypeOfKeyword */: + case 114 /* SyntaxKind.VoidKeyword */: + case 133 /* SyntaxKind.AwaitKeyword */: + return false; + case 29 /* SyntaxKind.LessThanToken */: + // If we are not in JSX context, we are parsing TypeAssertion which is an UnaryExpression + if (languageVariant !== 1 /* LanguageVariant.JSX */) { + return false; + } + // We are in JSX context and the token is part of JSXElement. + // falls through + default: + return true; + } + } + /** + * Parse ES7 UpdateExpression. UpdateExpression is used instead of ES6's PostFixExpression. + * + * ES7 UpdateExpression[yield]: + * 1) LeftHandSideExpression[?yield] + * 2) LeftHandSideExpression[?yield] [[no LineTerminator here]]++ + * 3) LeftHandSideExpression[?yield] [[no LineTerminator here]]-- + * 4) ++LeftHandSideExpression[?yield] + * 5) --LeftHandSideExpression[?yield] + * In TypeScript (2), (3) are parsed as PostfixUnaryExpression. (4), (5) are parsed as PrefixUnaryExpression + */ + function parseUpdateExpression() { + if (token() === 45 /* SyntaxKind.PlusPlusToken */ || token() === 46 /* SyntaxKind.MinusMinusToken */) { + var pos = getNodePos(); + return finishNode(factory.createPrefixUnaryExpression(token(), nextTokenAnd(parseLeftHandSideExpressionOrHigher)), pos); + } + else if (languageVariant === 1 /* LanguageVariant.JSX */ && token() === 29 /* SyntaxKind.LessThanToken */ && lookAhead(nextTokenIsIdentifierOrKeywordOrGreaterThan)) { + // JSXElement is part of primaryExpression + return parseJsxElementOrSelfClosingElementOrFragment(/*inExpressionContext*/ true); + } + var expression = parseLeftHandSideExpressionOrHigher(); + ts.Debug.assert(ts.isLeftHandSideExpression(expression)); + if ((token() === 45 /* SyntaxKind.PlusPlusToken */ || token() === 46 /* SyntaxKind.MinusMinusToken */) && !scanner.hasPrecedingLineBreak()) { + var operator = token(); + nextToken(); + return finishNode(factory.createPostfixUnaryExpression(expression, operator), expression.pos); + } + return expression; + } + function parseLeftHandSideExpressionOrHigher() { + // Original Ecma: + // LeftHandSideExpression: See 11.2 + // NewExpression + // CallExpression + // + // Our simplification: + // + // LeftHandSideExpression: See 11.2 + // MemberExpression + // CallExpression + // + // See comment in parseMemberExpressionOrHigher on how we replaced NewExpression with + // MemberExpression to make our lives easier. + // + // to best understand the below code, it's important to see how CallExpression expands + // out into its own productions: + // + // CallExpression: + // MemberExpression Arguments + // CallExpression Arguments + // CallExpression[Expression] + // CallExpression.IdentifierName + // import (AssignmentExpression) + // super Arguments + // super.IdentifierName + // + // Because of the recursion in these calls, we need to bottom out first. There are three + // bottom out states we can run into: 1) We see 'super' which must start either of + // the last two CallExpression productions. 2) We see 'import' which must start import call. + // 3)we have a MemberExpression which either completes the LeftHandSideExpression, + // or starts the beginning of the first four CallExpression productions. + var pos = getNodePos(); + var expression; + if (token() === 100 /* SyntaxKind.ImportKeyword */) { + if (lookAhead(nextTokenIsOpenParenOrLessThan)) { + // We don't want to eagerly consume all import keyword as import call expression so we look ahead to find "(" + // For example: + // var foo3 = require("subfolder + // import * as foo1 from "module-from-node + // We want this import to be a statement rather than import call expression + sourceFlags |= 2097152 /* NodeFlags.PossiblyContainsDynamicImport */; + expression = parseTokenNode(); + } + else if (lookAhead(nextTokenIsDot)) { + // This is an 'import.*' metaproperty (i.e. 'import.meta') + nextToken(); // advance past the 'import' + nextToken(); // advance past the dot + expression = finishNode(factory.createMetaProperty(100 /* SyntaxKind.ImportKeyword */, parseIdentifierName()), pos); + sourceFlags |= 4194304 /* NodeFlags.PossiblyContainsImportMeta */; + } + else { + expression = parseMemberExpressionOrHigher(); + } + } + else { + expression = token() === 106 /* SyntaxKind.SuperKeyword */ ? parseSuperExpression() : parseMemberExpressionOrHigher(); + } + // Now, we *may* be complete. However, we might have consumed the start of a + // CallExpression or OptionalExpression. As such, we need to consume the rest + // of it here to be complete. + return parseCallExpressionRest(pos, expression); + } + function parseMemberExpressionOrHigher() { + // Note: to make our lives simpler, we decompose the NewExpression productions and + // place ObjectCreationExpression and FunctionExpression into PrimaryExpression. + // like so: + // + // PrimaryExpression : See 11.1 + // this + // Identifier + // Literal + // ArrayLiteral + // ObjectLiteral + // (Expression) + // FunctionExpression + // new MemberExpression Arguments? + // + // MemberExpression : See 11.2 + // PrimaryExpression + // MemberExpression[Expression] + // MemberExpression.IdentifierName + // + // CallExpression : See 11.2 + // MemberExpression + // CallExpression Arguments + // CallExpression[Expression] + // CallExpression.IdentifierName + // + // Technically this is ambiguous. i.e. CallExpression defines: + // + // CallExpression: + // CallExpression Arguments + // + // If you see: "new Foo()" + // + // Then that could be treated as a single ObjectCreationExpression, or it could be + // treated as the invocation of "new Foo". We disambiguate that in code (to match + // the original grammar) by making sure that if we see an ObjectCreationExpression + // we always consume arguments if they are there. So we treat "new Foo()" as an + // object creation only, and not at all as an invocation. Another way to think + // about this is that for every "new" that we see, we will consume an argument list if + // it is there as part of the *associated* object creation node. Any additional + // argument lists we see, will become invocation expressions. + // + // Because there are no other places in the grammar now that refer to FunctionExpression + // or ObjectCreationExpression, it is safe to push down into the PrimaryExpression + // production. + // + // Because CallExpression and MemberExpression are left recursive, we need to bottom out + // of the recursion immediately. So we parse out a primary expression to start with. + var pos = getNodePos(); + var expression = parsePrimaryExpression(); + return parseMemberExpressionRest(pos, expression, /*allowOptionalChain*/ true); + } + function parseSuperExpression() { + var pos = getNodePos(); + var expression = parseTokenNode(); + if (token() === 29 /* SyntaxKind.LessThanToken */) { + var startPos = getNodePos(); + var typeArguments = tryParse(parseTypeArgumentsInExpression); + if (typeArguments !== undefined) { + parseErrorAt(startPos, getNodePos(), ts.Diagnostics.super_may_not_use_type_arguments); + if (!isTemplateStartOfTaggedTemplate()) { + expression = factory.createExpressionWithTypeArguments(expression, typeArguments); + } + } + } + if (token() === 20 /* SyntaxKind.OpenParenToken */ || token() === 24 /* SyntaxKind.DotToken */ || token() === 22 /* SyntaxKind.OpenBracketToken */) { + return expression; + } + // If we have seen "super" it must be followed by '(' or '.'. + // If it wasn't then just try to parse out a '.' and report an error. + parseExpectedToken(24 /* SyntaxKind.DotToken */, ts.Diagnostics.super_must_be_followed_by_an_argument_list_or_member_access); + // private names will never work with `super` (`super.#foo`), but that's a semantic error, not syntactic + return finishNode(factory.createPropertyAccessExpression(expression, parseRightSideOfDot(/*allowIdentifierNames*/ true, /*allowPrivateIdentifiers*/ true)), pos); + } + function parseJsxElementOrSelfClosingElementOrFragment(inExpressionContext, topInvalidNodePosition, openingTag) { + var pos = getNodePos(); + var opening = parseJsxOpeningOrSelfClosingElementOrOpeningFragment(inExpressionContext); + var result; + if (opening.kind === 283 /* SyntaxKind.JsxOpeningElement */) { + var children = parseJsxChildren(opening); + var closingElement = void 0; + var lastChild = children[children.length - 1]; + if ((lastChild === null || lastChild === void 0 ? void 0 : lastChild.kind) === 281 /* SyntaxKind.JsxElement */ + && !tagNamesAreEquivalent(lastChild.openingElement.tagName, lastChild.closingElement.tagName) + && tagNamesAreEquivalent(opening.tagName, lastChild.closingElement.tagName)) { + // when an unclosed JsxOpeningElement incorrectly parses its parent's JsxClosingElement, + // restructure (
(......
)) --> (
(......)
) + // (no need to error; the parent will error) + var end = lastChild.children.end; + var newLast = finishNode(factory.createJsxElement(lastChild.openingElement, lastChild.children, finishNode(factory.createJsxClosingElement(finishNode(factory.createIdentifier(""), end, end)), end, end)), lastChild.openingElement.pos, end); + children = createNodeArray(__spreadArray(__spreadArray([], children.slice(0, children.length - 1), true), [newLast], false), children.pos, end); + closingElement = lastChild.closingElement; + } + else { + closingElement = parseJsxClosingElement(opening, inExpressionContext); + if (!tagNamesAreEquivalent(opening.tagName, closingElement.tagName)) { + if (openingTag && ts.isJsxOpeningElement(openingTag) && tagNamesAreEquivalent(closingElement.tagName, openingTag.tagName)) { + // opening incorrectly matched with its parent's closing -- put error on opening + parseErrorAtRange(opening.tagName, ts.Diagnostics.JSX_element_0_has_no_corresponding_closing_tag, ts.getTextOfNodeFromSourceText(sourceText, opening.tagName)); + } + else { + // other opening/closing mismatches -- put error on closing + parseErrorAtRange(closingElement.tagName, ts.Diagnostics.Expected_corresponding_JSX_closing_tag_for_0, ts.getTextOfNodeFromSourceText(sourceText, opening.tagName)); + } + } + } + result = finishNode(factory.createJsxElement(opening, children, closingElement), pos); + } + else if (opening.kind === 286 /* SyntaxKind.JsxOpeningFragment */) { + result = finishNode(factory.createJsxFragment(opening, parseJsxChildren(opening), parseJsxClosingFragment(inExpressionContext)), pos); + } + else { + ts.Debug.assert(opening.kind === 282 /* SyntaxKind.JsxSelfClosingElement */); + // Nothing else to do for self-closing elements + result = opening; + } + // If the user writes the invalid code '
' in an expression context (i.e. not wrapped in + // an enclosing tag), we'll naively try to parse ^ this as a 'less than' operator and the remainder of the tag + // as garbage, which will cause the formatter to badly mangle the JSX. Perform a speculative parse of a JSX + // element if we see a < token so that we can wrap it in a synthetic binary expression so the formatter + // does less damage and we can report a better error. + // Since JSX elements are invalid < operands anyway, this lookahead parse will only occur in error scenarios + // of one sort or another. + if (inExpressionContext && token() === 29 /* SyntaxKind.LessThanToken */) { + var topBadPos_1 = typeof topInvalidNodePosition === "undefined" ? result.pos : topInvalidNodePosition; + var invalidElement = tryParse(function () { return parseJsxElementOrSelfClosingElementOrFragment(/*inExpressionContext*/ true, topBadPos_1); }); + if (invalidElement) { + var operatorToken = createMissingNode(27 /* SyntaxKind.CommaToken */, /*reportAtCurrentPosition*/ false); + ts.setTextRangePosWidth(operatorToken, invalidElement.pos, 0); + parseErrorAt(ts.skipTrivia(sourceText, topBadPos_1), invalidElement.end, ts.Diagnostics.JSX_expressions_must_have_one_parent_element); + return finishNode(factory.createBinaryExpression(result, operatorToken, invalidElement), pos); + } + } + return result; + } + function parseJsxText() { + var pos = getNodePos(); + var node = factory.createJsxText(scanner.getTokenValue(), currentToken === 12 /* SyntaxKind.JsxTextAllWhiteSpaces */); + currentToken = scanner.scanJsxToken(); + return finishNode(node, pos); + } + function parseJsxChild(openingTag, token) { + switch (token) { + case 1 /* SyntaxKind.EndOfFileToken */: + // If we hit EOF, issue the error at the tag that lacks the closing element + // rather than at the end of the file (which is useless) + if (ts.isJsxOpeningFragment(openingTag)) { + parseErrorAtRange(openingTag, ts.Diagnostics.JSX_fragment_has_no_corresponding_closing_tag); + } + else { + // We want the error span to cover only 'Foo.Bar' in < Foo.Bar > + // or to cover only 'Foo' in < Foo > + var tag = openingTag.tagName; + var start = ts.skipTrivia(sourceText, tag.pos); + parseErrorAt(start, tag.end, ts.Diagnostics.JSX_element_0_has_no_corresponding_closing_tag, ts.getTextOfNodeFromSourceText(sourceText, openingTag.tagName)); + } + return undefined; + case 30 /* SyntaxKind.LessThanSlashToken */: + case 7 /* SyntaxKind.ConflictMarkerTrivia */: + return undefined; + case 11 /* SyntaxKind.JsxText */: + case 12 /* SyntaxKind.JsxTextAllWhiteSpaces */: + return parseJsxText(); + case 18 /* SyntaxKind.OpenBraceToken */: + return parseJsxExpression(/*inExpressionContext*/ false); + case 29 /* SyntaxKind.LessThanToken */: + return parseJsxElementOrSelfClosingElementOrFragment(/*inExpressionContext*/ false, /*topInvalidNodePosition*/ undefined, openingTag); + default: + return ts.Debug.assertNever(token); + } + } + function parseJsxChildren(openingTag) { + var list = []; + var listPos = getNodePos(); + var saveParsingContext = parsingContext; + parsingContext |= 1 << 14 /* ParsingContext.JsxChildren */; + while (true) { + var child = parseJsxChild(openingTag, currentToken = scanner.reScanJsxToken()); + if (!child) + break; + list.push(child); + if (ts.isJsxOpeningElement(openingTag) + && (child === null || child === void 0 ? void 0 : child.kind) === 281 /* SyntaxKind.JsxElement */ + && !tagNamesAreEquivalent(child.openingElement.tagName, child.closingElement.tagName) + && tagNamesAreEquivalent(openingTag.tagName, child.closingElement.tagName)) { + // stop after parsing a mismatched child like
...(
) in order to reattach the higher + break; + } + } + parsingContext = saveParsingContext; + return createNodeArray(list, listPos); + } + function parseJsxAttributes() { + var pos = getNodePos(); + return finishNode(factory.createJsxAttributes(parseList(13 /* ParsingContext.JsxAttributes */, parseJsxAttribute)), pos); + } + function parseJsxOpeningOrSelfClosingElementOrOpeningFragment(inExpressionContext) { + var pos = getNodePos(); + parseExpected(29 /* SyntaxKind.LessThanToken */); + if (token() === 31 /* SyntaxKind.GreaterThanToken */) { + // See below for explanation of scanJsxText + scanJsxText(); + return finishNode(factory.createJsxOpeningFragment(), pos); + } + var tagName = parseJsxElementName(); + var typeArguments = (contextFlags & 262144 /* NodeFlags.JavaScriptFile */) === 0 ? tryParseTypeArguments() : undefined; + var attributes = parseJsxAttributes(); + var node; + if (token() === 31 /* SyntaxKind.GreaterThanToken */) { + // Closing tag, so scan the immediately-following text with the JSX scanning instead + // of regular scanning to avoid treating illegal characters (e.g. '#') as immediate + // scanning errors + scanJsxText(); + node = factory.createJsxOpeningElement(tagName, typeArguments, attributes); + } + else { + parseExpected(43 /* SyntaxKind.SlashToken */); + if (parseExpected(31 /* SyntaxKind.GreaterThanToken */, /*diagnostic*/ undefined, /*shouldAdvance*/ false)) { + // manually advance the scanner in order to look for jsx text inside jsx + if (inExpressionContext) { + nextToken(); + } + else { + scanJsxText(); + } + } + node = factory.createJsxSelfClosingElement(tagName, typeArguments, attributes); + } + return finishNode(node, pos); + } + function parseJsxElementName() { + var pos = getNodePos(); + scanJsxIdentifier(); + // JsxElement can have name in the form of + // propertyAccessExpression + // primaryExpression in the form of an identifier and "this" keyword + // We can't just simply use parseLeftHandSideExpressionOrHigher because then we will start consider class,function etc as a keyword + // We only want to consider "this" as a primaryExpression + var expression = token() === 108 /* SyntaxKind.ThisKeyword */ ? + parseTokenNode() : parseIdentifierName(); + while (parseOptional(24 /* SyntaxKind.DotToken */)) { + expression = finishNode(factory.createPropertyAccessExpression(expression, parseRightSideOfDot(/*allowIdentifierNames*/ true, /*allowPrivateIdentifiers*/ false)), pos); + } + return expression; + } + function parseJsxExpression(inExpressionContext) { + var pos = getNodePos(); + if (!parseExpected(18 /* SyntaxKind.OpenBraceToken */)) { + return undefined; + } + var dotDotDotToken; + var expression; + if (token() !== 19 /* SyntaxKind.CloseBraceToken */) { + dotDotDotToken = parseOptionalToken(25 /* SyntaxKind.DotDotDotToken */); + // Only an AssignmentExpression is valid here per the JSX spec, + // but we can unambiguously parse a comma sequence and provide + // a better error message in grammar checking. + expression = parseExpression(); + } + if (inExpressionContext) { + parseExpected(19 /* SyntaxKind.CloseBraceToken */); + } + else { + if (parseExpected(19 /* SyntaxKind.CloseBraceToken */, /*message*/ undefined, /*shouldAdvance*/ false)) { + scanJsxText(); + } + } + return finishNode(factory.createJsxExpression(dotDotDotToken, expression), pos); + } + function parseJsxAttribute() { + if (token() === 18 /* SyntaxKind.OpenBraceToken */) { + return parseJsxSpreadAttribute(); + } + scanJsxIdentifier(); + var pos = getNodePos(); + return finishNode(factory.createJsxAttribute(parseIdentifierName(), parseJsxAttributeValue()), pos); + } + function parseJsxAttributeValue() { + if (token() === 63 /* SyntaxKind.EqualsToken */) { + if (scanJsxAttributeValue() === 10 /* SyntaxKind.StringLiteral */) { + return parseLiteralNode(); + } + if (token() === 18 /* SyntaxKind.OpenBraceToken */) { + return parseJsxExpression(/*inExpressionContext*/ true); + } + if (token() === 29 /* SyntaxKind.LessThanToken */) { + return parseJsxElementOrSelfClosingElementOrFragment(/*inExpressionContext*/ true); + } + parseErrorAtCurrentToken(ts.Diagnostics.or_JSX_element_expected); + } + return undefined; + } + function parseJsxSpreadAttribute() { + var pos = getNodePos(); + parseExpected(18 /* SyntaxKind.OpenBraceToken */); + parseExpected(25 /* SyntaxKind.DotDotDotToken */); + var expression = parseExpression(); + parseExpected(19 /* SyntaxKind.CloseBraceToken */); + return finishNode(factory.createJsxSpreadAttribute(expression), pos); + } + function parseJsxClosingElement(open, inExpressionContext) { + var pos = getNodePos(); + parseExpected(30 /* SyntaxKind.LessThanSlashToken */); + var tagName = parseJsxElementName(); + if (parseExpected(31 /* SyntaxKind.GreaterThanToken */, /*diagnostic*/ undefined, /*shouldAdvance*/ false)) { + // manually advance the scanner in order to look for jsx text inside jsx + if (inExpressionContext || !tagNamesAreEquivalent(open.tagName, tagName)) { + nextToken(); + } + else { + scanJsxText(); + } + } + return finishNode(factory.createJsxClosingElement(tagName), pos); + } + function parseJsxClosingFragment(inExpressionContext) { + var pos = getNodePos(); + parseExpected(30 /* SyntaxKind.LessThanSlashToken */); + if (ts.tokenIsIdentifierOrKeyword(token())) { + parseErrorAtRange(parseJsxElementName(), ts.Diagnostics.Expected_corresponding_closing_tag_for_JSX_fragment); + } + if (parseExpected(31 /* SyntaxKind.GreaterThanToken */, /*diagnostic*/ undefined, /*shouldAdvance*/ false)) { + // manually advance the scanner in order to look for jsx text inside jsx + if (inExpressionContext) { + nextToken(); + } + else { + scanJsxText(); + } + } + return finishNode(factory.createJsxJsxClosingFragment(), pos); + } + function parseTypeAssertion() { + var pos = getNodePos(); + parseExpected(29 /* SyntaxKind.LessThanToken */); + var type = parseType(); + parseExpected(31 /* SyntaxKind.GreaterThanToken */); + var expression = parseSimpleUnaryExpression(); + return finishNode(factory.createTypeAssertion(type, expression), pos); + } + function nextTokenIsIdentifierOrKeywordOrOpenBracketOrTemplate() { + nextToken(); + return ts.tokenIsIdentifierOrKeyword(token()) + || token() === 22 /* SyntaxKind.OpenBracketToken */ + || isTemplateStartOfTaggedTemplate(); + } + function isStartOfOptionalPropertyOrElementAccessChain() { + return token() === 28 /* SyntaxKind.QuestionDotToken */ + && lookAhead(nextTokenIsIdentifierOrKeywordOrOpenBracketOrTemplate); + } + function tryReparseOptionalChain(node) { + if (node.flags & 32 /* NodeFlags.OptionalChain */) { + return true; + } + // check for an optional chain in a non-null expression + if (ts.isNonNullExpression(node)) { + var expr = node.expression; + while (ts.isNonNullExpression(expr) && !(expr.flags & 32 /* NodeFlags.OptionalChain */)) { + expr = expr.expression; + } + if (expr.flags & 32 /* NodeFlags.OptionalChain */) { + // this is part of an optional chain. Walk down from `node` to `expression` and set the flag. + while (ts.isNonNullExpression(node)) { + node.flags |= 32 /* NodeFlags.OptionalChain */; + node = node.expression; + } + return true; + } + } + return false; + } + function parsePropertyAccessExpressionRest(pos, expression, questionDotToken) { + var name = parseRightSideOfDot(/*allowIdentifierNames*/ true, /*allowPrivateIdentifiers*/ true); + var isOptionalChain = questionDotToken || tryReparseOptionalChain(expression); + var propertyAccess = isOptionalChain ? + factory.createPropertyAccessChain(expression, questionDotToken, name) : + factory.createPropertyAccessExpression(expression, name); + if (isOptionalChain && ts.isPrivateIdentifier(propertyAccess.name)) { + parseErrorAtRange(propertyAccess.name, ts.Diagnostics.An_optional_chain_cannot_contain_private_identifiers); + } + if (ts.isExpressionWithTypeArguments(expression) && expression.typeArguments) { + var pos_2 = expression.typeArguments.pos - 1; + var end = ts.skipTrivia(sourceText, expression.typeArguments.end) + 1; + parseErrorAt(pos_2, end, ts.Diagnostics.An_instantiation_expression_cannot_be_followed_by_a_property_access); + } + return finishNode(propertyAccess, pos); + } + function parseElementAccessExpressionRest(pos, expression, questionDotToken) { + var argumentExpression; + if (token() === 23 /* SyntaxKind.CloseBracketToken */) { + argumentExpression = createMissingNode(79 /* SyntaxKind.Identifier */, /*reportAtCurrentPosition*/ true, ts.Diagnostics.An_element_access_expression_should_take_an_argument); + } + else { + var argument = allowInAnd(parseExpression); + if (ts.isStringOrNumericLiteralLike(argument)) { + argument.text = internIdentifier(argument.text); + } + argumentExpression = argument; + } + parseExpected(23 /* SyntaxKind.CloseBracketToken */); + var indexedAccess = questionDotToken || tryReparseOptionalChain(expression) ? + factory.createElementAccessChain(expression, questionDotToken, argumentExpression) : + factory.createElementAccessExpression(expression, argumentExpression); + return finishNode(indexedAccess, pos); + } + function parseMemberExpressionRest(pos, expression, allowOptionalChain) { + while (true) { + var questionDotToken = void 0; + var isPropertyAccess = false; + if (allowOptionalChain && isStartOfOptionalPropertyOrElementAccessChain()) { + questionDotToken = parseExpectedToken(28 /* SyntaxKind.QuestionDotToken */); + isPropertyAccess = ts.tokenIsIdentifierOrKeyword(token()); + } + else { + isPropertyAccess = parseOptional(24 /* SyntaxKind.DotToken */); + } + if (isPropertyAccess) { + expression = parsePropertyAccessExpressionRest(pos, expression, questionDotToken); + continue; + } + // when in the [Decorator] context, we do not parse ElementAccess as it could be part of a ComputedPropertyName + if ((questionDotToken || !inDecoratorContext()) && parseOptional(22 /* SyntaxKind.OpenBracketToken */)) { + expression = parseElementAccessExpressionRest(pos, expression, questionDotToken); + continue; + } + if (isTemplateStartOfTaggedTemplate()) { + // Absorb type arguments into TemplateExpression when preceding expression is ExpressionWithTypeArguments + expression = !questionDotToken && expression.kind === 230 /* SyntaxKind.ExpressionWithTypeArguments */ ? + parseTaggedTemplateRest(pos, expression.expression, questionDotToken, expression.typeArguments) : + parseTaggedTemplateRest(pos, expression, questionDotToken, /*typeArguments*/ undefined); + continue; + } + if (!questionDotToken) { + if (token() === 53 /* SyntaxKind.ExclamationToken */ && !scanner.hasPrecedingLineBreak()) { + nextToken(); + expression = finishNode(factory.createNonNullExpression(expression), pos); + continue; + } + var typeArguments = tryParse(parseTypeArgumentsInExpression); + if (typeArguments) { + expression = finishNode(factory.createExpressionWithTypeArguments(expression, typeArguments), pos); + continue; + } + } + return expression; + } + } + function isTemplateStartOfTaggedTemplate() { + return token() === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */ || token() === 15 /* SyntaxKind.TemplateHead */; + } + function parseTaggedTemplateRest(pos, tag, questionDotToken, typeArguments) { + var tagExpression = factory.createTaggedTemplateExpression(tag, typeArguments, token() === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */ ? + (reScanTemplateHeadOrNoSubstitutionTemplate(), parseLiteralNode()) : + parseTemplateExpression(/*isTaggedTemplate*/ true)); + if (questionDotToken || tag.flags & 32 /* NodeFlags.OptionalChain */) { + tagExpression.flags |= 32 /* NodeFlags.OptionalChain */; + } + tagExpression.questionDotToken = questionDotToken; + return finishNode(tagExpression, pos); + } + function parseCallExpressionRest(pos, expression) { + while (true) { + expression = parseMemberExpressionRest(pos, expression, /*allowOptionalChain*/ true); + var typeArguments = void 0; + var questionDotToken = parseOptionalToken(28 /* SyntaxKind.QuestionDotToken */); + if (questionDotToken) { + typeArguments = tryParse(parseTypeArgumentsInExpression); + if (isTemplateStartOfTaggedTemplate()) { + expression = parseTaggedTemplateRest(pos, expression, questionDotToken, typeArguments); + continue; + } + } + if (typeArguments || token() === 20 /* SyntaxKind.OpenParenToken */) { + // Absorb type arguments into CallExpression when preceding expression is ExpressionWithTypeArguments + if (!questionDotToken && expression.kind === 230 /* SyntaxKind.ExpressionWithTypeArguments */) { + typeArguments = expression.typeArguments; + expression = expression.expression; + } + var argumentList = parseArgumentList(); + var callExpr = questionDotToken || tryReparseOptionalChain(expression) ? + factory.createCallChain(expression, questionDotToken, typeArguments, argumentList) : + factory.createCallExpression(expression, typeArguments, argumentList); + expression = finishNode(callExpr, pos); + continue; + } + if (questionDotToken) { + // We parsed `?.` but then failed to parse anything, so report a missing identifier here. + var name = createMissingNode(79 /* SyntaxKind.Identifier */, /*reportAtCurrentPosition*/ false, ts.Diagnostics.Identifier_expected); + expression = finishNode(factory.createPropertyAccessChain(expression, questionDotToken, name), pos); + } + break; + } + return expression; + } + function parseArgumentList() { + parseExpected(20 /* SyntaxKind.OpenParenToken */); + var result = parseDelimitedList(11 /* ParsingContext.ArgumentExpressions */, parseArgumentExpression); + parseExpected(21 /* SyntaxKind.CloseParenToken */); + return result; + } + function parseTypeArgumentsInExpression() { + if ((contextFlags & 262144 /* NodeFlags.JavaScriptFile */) !== 0) { + // TypeArguments must not be parsed in JavaScript files to avoid ambiguity with binary operators. + return undefined; + } + if (reScanLessThanToken() !== 29 /* SyntaxKind.LessThanToken */) { + return undefined; + } + nextToken(); + var typeArguments = parseDelimitedList(20 /* ParsingContext.TypeArguments */, parseType); + if (reScanGreaterToken() !== 31 /* SyntaxKind.GreaterThanToken */) { + // If it doesn't have the closing `>` then it's definitely not an type argument list. + return undefined; + } + nextToken(); + // We successfully parsed a type argument list. The next token determines whether we want to + // treat it as such. If the type argument list is followed by `(` or a template literal, as in + // `f(42)`, we favor the type argument interpretation even though JavaScript would view + // it as a relational expression. + return typeArguments && canFollowTypeArgumentsInExpression() ? typeArguments : undefined; + } + function canFollowTypeArgumentsInExpression() { + switch (token()) { + // These tokens can follow a type argument list in a call expression. + case 20 /* SyntaxKind.OpenParenToken */: // foo( + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: // foo `...` + case 15 /* SyntaxKind.TemplateHead */: // foo `...${100}...` + return true; + // A type argument list followed by `<` never makes sense, and a type argument list followed + // by `>` is ambiguous with a (re-scanned) `>>` operator, so we disqualify both. Also, in + // this context, `+` and `-` are unary operators, not binary operators. + case 29 /* SyntaxKind.LessThanToken */: + case 31 /* SyntaxKind.GreaterThanToken */: + case 39 /* SyntaxKind.PlusToken */: + case 40 /* SyntaxKind.MinusToken */: + return false; + } + // We favor the type argument list interpretation when it is immediately followed by + // a line break, a binary operator, or something that can't start an expression. + return scanner.hasPrecedingLineBreak() || isBinaryOperator() || !isStartOfExpression(); + } + function parsePrimaryExpression() { + switch (token()) { + case 8 /* SyntaxKind.NumericLiteral */: + case 9 /* SyntaxKind.BigIntLiteral */: + case 10 /* SyntaxKind.StringLiteral */: + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + return parseLiteralNode(); + case 108 /* SyntaxKind.ThisKeyword */: + case 106 /* SyntaxKind.SuperKeyword */: + case 104 /* SyntaxKind.NullKeyword */: + case 110 /* SyntaxKind.TrueKeyword */: + case 95 /* SyntaxKind.FalseKeyword */: + return parseTokenNode(); + case 20 /* SyntaxKind.OpenParenToken */: + return parseParenthesizedExpression(); + case 22 /* SyntaxKind.OpenBracketToken */: + return parseArrayLiteralExpression(); + case 18 /* SyntaxKind.OpenBraceToken */: + return parseObjectLiteralExpression(); + case 132 /* SyntaxKind.AsyncKeyword */: + // Async arrow functions are parsed earlier in parseAssignmentExpressionOrHigher. + // If we encounter `async [no LineTerminator here] function` then this is an async + // function; otherwise, its an identifier. + if (!lookAhead(nextTokenIsFunctionKeywordOnSameLine)) { + break; + } + return parseFunctionExpression(); + case 84 /* SyntaxKind.ClassKeyword */: + return parseClassExpression(); + case 98 /* SyntaxKind.FunctionKeyword */: + return parseFunctionExpression(); + case 103 /* SyntaxKind.NewKeyword */: + return parseNewExpressionOrNewDotTarget(); + case 43 /* SyntaxKind.SlashToken */: + case 68 /* SyntaxKind.SlashEqualsToken */: + if (reScanSlashToken() === 13 /* SyntaxKind.RegularExpressionLiteral */) { + return parseLiteralNode(); + } + break; + case 15 /* SyntaxKind.TemplateHead */: + return parseTemplateExpression(/* isTaggedTemplate */ false); + case 80 /* SyntaxKind.PrivateIdentifier */: + return parsePrivateIdentifier(); + } + return parseIdentifier(ts.Diagnostics.Expression_expected); + } + function parseParenthesizedExpression() { + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + parseExpected(20 /* SyntaxKind.OpenParenToken */); + var expression = allowInAnd(parseExpression); + parseExpected(21 /* SyntaxKind.CloseParenToken */); + return withJSDoc(finishNode(factory.createParenthesizedExpression(expression), pos), hasJSDoc); + } + function parseSpreadElement() { + var pos = getNodePos(); + parseExpected(25 /* SyntaxKind.DotDotDotToken */); + var expression = parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true); + return finishNode(factory.createSpreadElement(expression), pos); + } + function parseArgumentOrArrayLiteralElement() { + return token() === 25 /* SyntaxKind.DotDotDotToken */ ? parseSpreadElement() : + token() === 27 /* SyntaxKind.CommaToken */ ? finishNode(factory.createOmittedExpression(), getNodePos()) : + parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true); + } + function parseArgumentExpression() { + return doOutsideOfContext(disallowInAndDecoratorContext, parseArgumentOrArrayLiteralElement); + } + function parseArrayLiteralExpression() { + var pos = getNodePos(); + var openBracketPosition = scanner.getTokenPos(); + var openBracketParsed = parseExpected(22 /* SyntaxKind.OpenBracketToken */); + var multiLine = scanner.hasPrecedingLineBreak(); + var elements = parseDelimitedList(15 /* ParsingContext.ArrayLiteralMembers */, parseArgumentOrArrayLiteralElement); + parseExpectedMatchingBrackets(22 /* SyntaxKind.OpenBracketToken */, 23 /* SyntaxKind.CloseBracketToken */, openBracketParsed, openBracketPosition); + return finishNode(factory.createArrayLiteralExpression(elements, multiLine), pos); + } + function parseObjectLiteralElement() { + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + if (parseOptionalToken(25 /* SyntaxKind.DotDotDotToken */)) { + var expression = parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true); + return withJSDoc(finishNode(factory.createSpreadAssignment(expression), pos), hasJSDoc); + } + var decorators = parseDecorators(); + var modifiers = parseModifiers(); + if (parseContextualModifier(137 /* SyntaxKind.GetKeyword */)) { + return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 174 /* SyntaxKind.GetAccessor */, 0 /* SignatureFlags.None */); + } + if (parseContextualModifier(151 /* SyntaxKind.SetKeyword */)) { + return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 175 /* SyntaxKind.SetAccessor */, 0 /* SignatureFlags.None */); + } + var asteriskToken = parseOptionalToken(41 /* SyntaxKind.AsteriskToken */); + var tokenIsIdentifier = isIdentifier(); + var name = parsePropertyName(); + // Disallowing of optional property assignments and definite assignment assertion happens in the grammar checker. + var questionToken = parseOptionalToken(57 /* SyntaxKind.QuestionToken */); + var exclamationToken = parseOptionalToken(53 /* SyntaxKind.ExclamationToken */); + if (asteriskToken || token() === 20 /* SyntaxKind.OpenParenToken */ || token() === 29 /* SyntaxKind.LessThanToken */) { + return parseMethodDeclaration(pos, hasJSDoc, decorators, modifiers, asteriskToken, name, questionToken, exclamationToken); + } + // check if it is short-hand property assignment or normal property assignment + // NOTE: if token is EqualsToken it is interpreted as CoverInitializedName production + // CoverInitializedName[Yield] : + // IdentifierReference[?Yield] Initializer[In, ?Yield] + // this is necessary because ObjectLiteral productions are also used to cover grammar for ObjectAssignmentPattern + var node; + var isShorthandPropertyAssignment = tokenIsIdentifier && (token() !== 58 /* SyntaxKind.ColonToken */); + if (isShorthandPropertyAssignment) { + var equalsToken = parseOptionalToken(63 /* SyntaxKind.EqualsToken */); + var objectAssignmentInitializer = equalsToken ? allowInAnd(function () { return parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true); }) : undefined; + node = factory.createShorthandPropertyAssignment(name, objectAssignmentInitializer); + // Save equals token for error reporting. + // TODO(rbuckton): Consider manufacturing this when we need to report an error as it is otherwise not useful. + node.equalsToken = equalsToken; + } + else { + parseExpected(58 /* SyntaxKind.ColonToken */); + var initializer = allowInAnd(function () { return parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true); }); + node = factory.createPropertyAssignment(name, initializer); + } + // Decorators, Modifiers, questionToken, and exclamationToken are not supported by property assignments and are reported in the grammar checker + node.illegalDecorators = decorators; + node.modifiers = modifiers; + node.questionToken = questionToken; + node.exclamationToken = exclamationToken; + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + function parseObjectLiteralExpression() { + var pos = getNodePos(); + var openBracePosition = scanner.getTokenPos(); + var openBraceParsed = parseExpected(18 /* SyntaxKind.OpenBraceToken */); + var multiLine = scanner.hasPrecedingLineBreak(); + var properties = parseDelimitedList(12 /* ParsingContext.ObjectLiteralMembers */, parseObjectLiteralElement, /*considerSemicolonAsDelimiter*/ true); + parseExpectedMatchingBrackets(18 /* SyntaxKind.OpenBraceToken */, 19 /* SyntaxKind.CloseBraceToken */, openBraceParsed, openBracePosition); + return finishNode(factory.createObjectLiteralExpression(properties, multiLine), pos); + } + function parseFunctionExpression() { + // GeneratorExpression: + // function* BindingIdentifier [Yield][opt](FormalParameters[Yield]){ GeneratorBody } + // + // FunctionExpression: + // function BindingIdentifier[opt](FormalParameters){ FunctionBody } + var savedDecoratorContext = inDecoratorContext(); + setDecoratorContext(/*val*/ false); + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + var modifiers = parseModifiers(); + parseExpected(98 /* SyntaxKind.FunctionKeyword */); + var asteriskToken = parseOptionalToken(41 /* SyntaxKind.AsteriskToken */); + var isGenerator = asteriskToken ? 1 /* SignatureFlags.Yield */ : 0 /* SignatureFlags.None */; + var isAsync = ts.some(modifiers, ts.isAsyncModifier) ? 2 /* SignatureFlags.Await */ : 0 /* SignatureFlags.None */; + var name = isGenerator && isAsync ? doInYieldAndAwaitContext(parseOptionalBindingIdentifier) : + isGenerator ? doInYieldContext(parseOptionalBindingIdentifier) : + isAsync ? doInAwaitContext(parseOptionalBindingIdentifier) : + parseOptionalBindingIdentifier(); + var typeParameters = parseTypeParameters(); + var parameters = parseParameters(isGenerator | isAsync); + var type = parseReturnType(58 /* SyntaxKind.ColonToken */, /*isType*/ false); + var body = parseFunctionBlock(isGenerator | isAsync); + setDecoratorContext(savedDecoratorContext); + var node = factory.createFunctionExpression(modifiers, asteriskToken, name, typeParameters, parameters, type, body); + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + function parseOptionalBindingIdentifier() { + return isBindingIdentifier() ? parseBindingIdentifier() : undefined; + } + function parseNewExpressionOrNewDotTarget() { + var pos = getNodePos(); + parseExpected(103 /* SyntaxKind.NewKeyword */); + if (parseOptional(24 /* SyntaxKind.DotToken */)) { + var name = parseIdentifierName(); + return finishNode(factory.createMetaProperty(103 /* SyntaxKind.NewKeyword */, name), pos); + } + var expressionPos = getNodePos(); + var expression = parseMemberExpressionRest(expressionPos, parsePrimaryExpression(), /*allowOptionalChain*/ false); + var typeArguments; + // Absorb type arguments into NewExpression when preceding expression is ExpressionWithTypeArguments + if (expression.kind === 230 /* SyntaxKind.ExpressionWithTypeArguments */) { + typeArguments = expression.typeArguments; + expression = expression.expression; + } + if (token() === 28 /* SyntaxKind.QuestionDotToken */) { + parseErrorAtCurrentToken(ts.Diagnostics.Invalid_optional_chain_from_new_expression_Did_you_mean_to_call_0, ts.getTextOfNodeFromSourceText(sourceText, expression)); + } + var argumentList = token() === 20 /* SyntaxKind.OpenParenToken */ ? parseArgumentList() : undefined; + return finishNode(factory.createNewExpression(expression, typeArguments, argumentList), pos); + } + // STATEMENTS + function parseBlock(ignoreMissingOpenBrace, diagnosticMessage) { + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + var openBracePosition = scanner.getTokenPos(); + var openBraceParsed = parseExpected(18 /* SyntaxKind.OpenBraceToken */, diagnosticMessage); + if (openBraceParsed || ignoreMissingOpenBrace) { + var multiLine = scanner.hasPrecedingLineBreak(); + var statements = parseList(1 /* ParsingContext.BlockStatements */, parseStatement); + parseExpectedMatchingBrackets(18 /* SyntaxKind.OpenBraceToken */, 19 /* SyntaxKind.CloseBraceToken */, openBraceParsed, openBracePosition); + var result = withJSDoc(finishNode(factory.createBlock(statements, multiLine), pos), hasJSDoc); + if (token() === 63 /* SyntaxKind.EqualsToken */) { + parseErrorAtCurrentToken(ts.Diagnostics.Declaration_or_statement_expected_This_follows_a_block_of_statements_so_if_you_intended_to_write_a_destructuring_assignment_you_might_need_to_wrap_the_the_whole_assignment_in_parentheses); + nextToken(); + } + return result; + } + else { + var statements = createMissingList(); + return withJSDoc(finishNode(factory.createBlock(statements, /*multiLine*/ undefined), pos), hasJSDoc); + } + } + function parseFunctionBlock(flags, diagnosticMessage) { + var savedYieldContext = inYieldContext(); + setYieldContext(!!(flags & 1 /* SignatureFlags.Yield */)); + var savedAwaitContext = inAwaitContext(); + setAwaitContext(!!(flags & 2 /* SignatureFlags.Await */)); + var savedTopLevel = topLevel; + topLevel = false; + // We may be in a [Decorator] context when parsing a function expression or + // arrow function. The body of the function is not in [Decorator] context. + var saveDecoratorContext = inDecoratorContext(); + if (saveDecoratorContext) { + setDecoratorContext(/*val*/ false); + } + var block = parseBlock(!!(flags & 16 /* SignatureFlags.IgnoreMissingOpenBrace */), diagnosticMessage); + if (saveDecoratorContext) { + setDecoratorContext(/*val*/ true); + } + topLevel = savedTopLevel; + setYieldContext(savedYieldContext); + setAwaitContext(savedAwaitContext); + return block; + } + function parseEmptyStatement() { + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + parseExpected(26 /* SyntaxKind.SemicolonToken */); + return withJSDoc(finishNode(factory.createEmptyStatement(), pos), hasJSDoc); + } + function parseIfStatement() { + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + parseExpected(99 /* SyntaxKind.IfKeyword */); + var openParenPosition = scanner.getTokenPos(); + var openParenParsed = parseExpected(20 /* SyntaxKind.OpenParenToken */); + var expression = allowInAnd(parseExpression); + parseExpectedMatchingBrackets(20 /* SyntaxKind.OpenParenToken */, 21 /* SyntaxKind.CloseParenToken */, openParenParsed, openParenPosition); + var thenStatement = parseStatement(); + var elseStatement = parseOptional(91 /* SyntaxKind.ElseKeyword */) ? parseStatement() : undefined; + return withJSDoc(finishNode(factory.createIfStatement(expression, thenStatement, elseStatement), pos), hasJSDoc); + } + function parseDoStatement() { + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + parseExpected(90 /* SyntaxKind.DoKeyword */); + var statement = parseStatement(); + parseExpected(115 /* SyntaxKind.WhileKeyword */); + var openParenPosition = scanner.getTokenPos(); + var openParenParsed = parseExpected(20 /* SyntaxKind.OpenParenToken */); + var expression = allowInAnd(parseExpression); + parseExpectedMatchingBrackets(20 /* SyntaxKind.OpenParenToken */, 21 /* SyntaxKind.CloseParenToken */, openParenParsed, openParenPosition); + // From: https://mail.mozilla.org/pipermail/es-discuss/2011-August/016188.html + // 157 min --- All allen at wirfs-brock.com CONF --- "do{;}while(false)false" prohibited in + // spec but allowed in consensus reality. Approved -- this is the de-facto standard whereby + // do;while(0)x will have a semicolon inserted before x. + parseOptional(26 /* SyntaxKind.SemicolonToken */); + return withJSDoc(finishNode(factory.createDoStatement(statement, expression), pos), hasJSDoc); + } + function parseWhileStatement() { + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + parseExpected(115 /* SyntaxKind.WhileKeyword */); + var openParenPosition = scanner.getTokenPos(); + var openParenParsed = parseExpected(20 /* SyntaxKind.OpenParenToken */); + var expression = allowInAnd(parseExpression); + parseExpectedMatchingBrackets(20 /* SyntaxKind.OpenParenToken */, 21 /* SyntaxKind.CloseParenToken */, openParenParsed, openParenPosition); + var statement = parseStatement(); + return withJSDoc(finishNode(factory.createWhileStatement(expression, statement), pos), hasJSDoc); + } + function parseForOrForInOrForOfStatement() { + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + parseExpected(97 /* SyntaxKind.ForKeyword */); + var awaitToken = parseOptionalToken(133 /* SyntaxKind.AwaitKeyword */); + parseExpected(20 /* SyntaxKind.OpenParenToken */); + var initializer; + if (token() !== 26 /* SyntaxKind.SemicolonToken */) { + if (token() === 113 /* SyntaxKind.VarKeyword */ || token() === 119 /* SyntaxKind.LetKeyword */ || token() === 85 /* SyntaxKind.ConstKeyword */) { + initializer = parseVariableDeclarationList(/*inForStatementInitializer*/ true); + } + else { + initializer = disallowInAnd(parseExpression); + } + } + var node; + if (awaitToken ? parseExpected(162 /* SyntaxKind.OfKeyword */) : parseOptional(162 /* SyntaxKind.OfKeyword */)) { + var expression = allowInAnd(function () { return parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true); }); + parseExpected(21 /* SyntaxKind.CloseParenToken */); + node = factory.createForOfStatement(awaitToken, initializer, expression, parseStatement()); + } + else if (parseOptional(101 /* SyntaxKind.InKeyword */)) { + var expression = allowInAnd(parseExpression); + parseExpected(21 /* SyntaxKind.CloseParenToken */); + node = factory.createForInStatement(initializer, expression, parseStatement()); + } + else { + parseExpected(26 /* SyntaxKind.SemicolonToken */); + var condition = token() !== 26 /* SyntaxKind.SemicolonToken */ && token() !== 21 /* SyntaxKind.CloseParenToken */ + ? allowInAnd(parseExpression) + : undefined; + parseExpected(26 /* SyntaxKind.SemicolonToken */); + var incrementor = token() !== 21 /* SyntaxKind.CloseParenToken */ + ? allowInAnd(parseExpression) + : undefined; + parseExpected(21 /* SyntaxKind.CloseParenToken */); + node = factory.createForStatement(initializer, condition, incrementor, parseStatement()); + } + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + function parseBreakOrContinueStatement(kind) { + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + parseExpected(kind === 249 /* SyntaxKind.BreakStatement */ ? 81 /* SyntaxKind.BreakKeyword */ : 86 /* SyntaxKind.ContinueKeyword */); + var label = canParseSemicolon() ? undefined : parseIdentifier(); + parseSemicolon(); + var node = kind === 249 /* SyntaxKind.BreakStatement */ + ? factory.createBreakStatement(label) + : factory.createContinueStatement(label); + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + function parseReturnStatement() { + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + parseExpected(105 /* SyntaxKind.ReturnKeyword */); + var expression = canParseSemicolon() ? undefined : allowInAnd(parseExpression); + parseSemicolon(); + return withJSDoc(finishNode(factory.createReturnStatement(expression), pos), hasJSDoc); + } + function parseWithStatement() { + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + parseExpected(116 /* SyntaxKind.WithKeyword */); + var openParenPosition = scanner.getTokenPos(); + var openParenParsed = parseExpected(20 /* SyntaxKind.OpenParenToken */); + var expression = allowInAnd(parseExpression); + parseExpectedMatchingBrackets(20 /* SyntaxKind.OpenParenToken */, 21 /* SyntaxKind.CloseParenToken */, openParenParsed, openParenPosition); + var statement = doInsideOfContext(33554432 /* NodeFlags.InWithStatement */, parseStatement); + return withJSDoc(finishNode(factory.createWithStatement(expression, statement), pos), hasJSDoc); + } + function parseCaseClause() { + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + parseExpected(82 /* SyntaxKind.CaseKeyword */); + var expression = allowInAnd(parseExpression); + parseExpected(58 /* SyntaxKind.ColonToken */); + var statements = parseList(3 /* ParsingContext.SwitchClauseStatements */, parseStatement); + return withJSDoc(finishNode(factory.createCaseClause(expression, statements), pos), hasJSDoc); + } + function parseDefaultClause() { + var pos = getNodePos(); + parseExpected(88 /* SyntaxKind.DefaultKeyword */); + parseExpected(58 /* SyntaxKind.ColonToken */); + var statements = parseList(3 /* ParsingContext.SwitchClauseStatements */, parseStatement); + return finishNode(factory.createDefaultClause(statements), pos); + } + function parseCaseOrDefaultClause() { + return token() === 82 /* SyntaxKind.CaseKeyword */ ? parseCaseClause() : parseDefaultClause(); + } + function parseCaseBlock() { + var pos = getNodePos(); + parseExpected(18 /* SyntaxKind.OpenBraceToken */); + var clauses = parseList(2 /* ParsingContext.SwitchClauses */, parseCaseOrDefaultClause); + parseExpected(19 /* SyntaxKind.CloseBraceToken */); + return finishNode(factory.createCaseBlock(clauses), pos); + } + function parseSwitchStatement() { + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + parseExpected(107 /* SyntaxKind.SwitchKeyword */); + parseExpected(20 /* SyntaxKind.OpenParenToken */); + var expression = allowInAnd(parseExpression); + parseExpected(21 /* SyntaxKind.CloseParenToken */); + var caseBlock = parseCaseBlock(); + return withJSDoc(finishNode(factory.createSwitchStatement(expression, caseBlock), pos), hasJSDoc); + } + function parseThrowStatement() { + // ThrowStatement[Yield] : + // throw [no LineTerminator here]Expression[In, ?Yield]; + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + parseExpected(109 /* SyntaxKind.ThrowKeyword */); + // Because of automatic semicolon insertion, we need to report error if this + // throw could be terminated with a semicolon. Note: we can't call 'parseExpression' + // directly as that might consume an expression on the following line. + // Instead, we create a "missing" identifier, but don't report an error. The actual error + // will be reported in the grammar walker. + var expression = scanner.hasPrecedingLineBreak() ? undefined : allowInAnd(parseExpression); + if (expression === undefined) { + identifierCount++; + expression = finishNode(factory.createIdentifier(""), getNodePos()); + } + if (!tryParseSemicolon()) { + parseErrorForMissingSemicolonAfter(expression); + } + return withJSDoc(finishNode(factory.createThrowStatement(expression), pos), hasJSDoc); + } + // TODO: Review for error recovery + function parseTryStatement() { + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + parseExpected(111 /* SyntaxKind.TryKeyword */); + var tryBlock = parseBlock(/*ignoreMissingOpenBrace*/ false); + var catchClause = token() === 83 /* SyntaxKind.CatchKeyword */ ? parseCatchClause() : undefined; + // If we don't have a catch clause, then we must have a finally clause. Try to parse + // one out no matter what. + var finallyBlock; + if (!catchClause || token() === 96 /* SyntaxKind.FinallyKeyword */) { + parseExpected(96 /* SyntaxKind.FinallyKeyword */, ts.Diagnostics.catch_or_finally_expected); + finallyBlock = parseBlock(/*ignoreMissingOpenBrace*/ false); + } + return withJSDoc(finishNode(factory.createTryStatement(tryBlock, catchClause, finallyBlock), pos), hasJSDoc); + } + function parseCatchClause() { + var pos = getNodePos(); + parseExpected(83 /* SyntaxKind.CatchKeyword */); + var variableDeclaration; + if (parseOptional(20 /* SyntaxKind.OpenParenToken */)) { + variableDeclaration = parseVariableDeclaration(); + parseExpected(21 /* SyntaxKind.CloseParenToken */); + } + else { + // Keep shape of node to avoid degrading performance. + variableDeclaration = undefined; + } + var block = parseBlock(/*ignoreMissingOpenBrace*/ false); + return finishNode(factory.createCatchClause(variableDeclaration, block), pos); + } + function parseDebuggerStatement() { + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + parseExpected(87 /* SyntaxKind.DebuggerKeyword */); + parseSemicolon(); + return withJSDoc(finishNode(factory.createDebuggerStatement(), pos), hasJSDoc); + } + function parseExpressionOrLabeledStatement() { + // Avoiding having to do the lookahead for a labeled statement by just trying to parse + // out an expression, seeing if it is identifier and then seeing if it is followed by + // a colon. + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + var node; + var hasParen = token() === 20 /* SyntaxKind.OpenParenToken */; + var expression = allowInAnd(parseExpression); + if (ts.isIdentifier(expression) && parseOptional(58 /* SyntaxKind.ColonToken */)) { + node = factory.createLabeledStatement(expression, parseStatement()); + } + else { + if (!tryParseSemicolon()) { + parseErrorForMissingSemicolonAfter(expression); + } + node = factory.createExpressionStatement(expression); + if (hasParen) { + // do not parse the same jsdoc twice + hasJSDoc = false; + } + } + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + function nextTokenIsIdentifierOrKeywordOnSameLine() { + nextToken(); + return ts.tokenIsIdentifierOrKeyword(token()) && !scanner.hasPrecedingLineBreak(); + } + function nextTokenIsClassKeywordOnSameLine() { + nextToken(); + return token() === 84 /* SyntaxKind.ClassKeyword */ && !scanner.hasPrecedingLineBreak(); + } + function nextTokenIsFunctionKeywordOnSameLine() { + nextToken(); + return token() === 98 /* SyntaxKind.FunctionKeyword */ && !scanner.hasPrecedingLineBreak(); + } + function nextTokenIsIdentifierOrKeywordOrLiteralOnSameLine() { + nextToken(); + return (ts.tokenIsIdentifierOrKeyword(token()) || token() === 8 /* SyntaxKind.NumericLiteral */ || token() === 9 /* SyntaxKind.BigIntLiteral */ || token() === 10 /* SyntaxKind.StringLiteral */) && !scanner.hasPrecedingLineBreak(); + } + function isDeclaration() { + while (true) { + switch (token()) { + case 113 /* SyntaxKind.VarKeyword */: + case 119 /* SyntaxKind.LetKeyword */: + case 85 /* SyntaxKind.ConstKeyword */: + case 98 /* SyntaxKind.FunctionKeyword */: + case 84 /* SyntaxKind.ClassKeyword */: + case 92 /* SyntaxKind.EnumKeyword */: + return true; + // 'declare', 'module', 'namespace', 'interface'* and 'type' are all legal JavaScript identifiers; + // however, an identifier cannot be followed by another identifier on the same line. This is what we + // count on to parse out the respective declarations. For instance, we exploit this to say that + // + // namespace n + // + // can be none other than the beginning of a namespace declaration, but need to respect that JavaScript sees + // + // namespace + // n + // + // as the identifier 'namespace' on one line followed by the identifier 'n' on another. + // We need to look one token ahead to see if it permissible to try parsing a declaration. + // + // *Note*: 'interface' is actually a strict mode reserved word. So while + // + // "use strict" + // interface + // I {} + // + // could be legal, it would add complexity for very little gain. + case 118 /* SyntaxKind.InterfaceKeyword */: + case 154 /* SyntaxKind.TypeKeyword */: + return nextTokenIsIdentifierOnSameLine(); + case 142 /* SyntaxKind.ModuleKeyword */: + case 143 /* SyntaxKind.NamespaceKeyword */: + return nextTokenIsIdentifierOrStringLiteralOnSameLine(); + case 126 /* SyntaxKind.AbstractKeyword */: + case 127 /* SyntaxKind.AccessorKeyword */: + case 132 /* SyntaxKind.AsyncKeyword */: + case 136 /* SyntaxKind.DeclareKeyword */: + case 121 /* SyntaxKind.PrivateKeyword */: + case 122 /* SyntaxKind.ProtectedKeyword */: + case 123 /* SyntaxKind.PublicKeyword */: + case 146 /* SyntaxKind.ReadonlyKeyword */: + nextToken(); + // ASI takes effect for this modifier. + if (scanner.hasPrecedingLineBreak()) { + return false; + } + continue; + case 159 /* SyntaxKind.GlobalKeyword */: + nextToken(); + return token() === 18 /* SyntaxKind.OpenBraceToken */ || token() === 79 /* SyntaxKind.Identifier */ || token() === 93 /* SyntaxKind.ExportKeyword */; + case 100 /* SyntaxKind.ImportKeyword */: + nextToken(); + return token() === 10 /* SyntaxKind.StringLiteral */ || token() === 41 /* SyntaxKind.AsteriskToken */ || + token() === 18 /* SyntaxKind.OpenBraceToken */ || ts.tokenIsIdentifierOrKeyword(token()); + case 93 /* SyntaxKind.ExportKeyword */: + var currentToken_1 = nextToken(); + if (currentToken_1 === 154 /* SyntaxKind.TypeKeyword */) { + currentToken_1 = lookAhead(nextToken); + } + if (currentToken_1 === 63 /* SyntaxKind.EqualsToken */ || currentToken_1 === 41 /* SyntaxKind.AsteriskToken */ || + currentToken_1 === 18 /* SyntaxKind.OpenBraceToken */ || currentToken_1 === 88 /* SyntaxKind.DefaultKeyword */ || + currentToken_1 === 128 /* SyntaxKind.AsKeyword */) { + return true; + } + continue; + case 124 /* SyntaxKind.StaticKeyword */: + nextToken(); + continue; + default: + return false; + } + } + } + function isStartOfDeclaration() { + return lookAhead(isDeclaration); + } + function isStartOfStatement() { + switch (token()) { + case 59 /* SyntaxKind.AtToken */: + case 26 /* SyntaxKind.SemicolonToken */: + case 18 /* SyntaxKind.OpenBraceToken */: + case 113 /* SyntaxKind.VarKeyword */: + case 119 /* SyntaxKind.LetKeyword */: + case 98 /* SyntaxKind.FunctionKeyword */: + case 84 /* SyntaxKind.ClassKeyword */: + case 92 /* SyntaxKind.EnumKeyword */: + case 99 /* SyntaxKind.IfKeyword */: + case 90 /* SyntaxKind.DoKeyword */: + case 115 /* SyntaxKind.WhileKeyword */: + case 97 /* SyntaxKind.ForKeyword */: + case 86 /* SyntaxKind.ContinueKeyword */: + case 81 /* SyntaxKind.BreakKeyword */: + case 105 /* SyntaxKind.ReturnKeyword */: + case 116 /* SyntaxKind.WithKeyword */: + case 107 /* SyntaxKind.SwitchKeyword */: + case 109 /* SyntaxKind.ThrowKeyword */: + case 111 /* SyntaxKind.TryKeyword */: + case 87 /* SyntaxKind.DebuggerKeyword */: + // 'catch' and 'finally' do not actually indicate that the code is part of a statement, + // however, we say they are here so that we may gracefully parse them and error later. + // falls through + case 83 /* SyntaxKind.CatchKeyword */: + case 96 /* SyntaxKind.FinallyKeyword */: + return true; + case 100 /* SyntaxKind.ImportKeyword */: + return isStartOfDeclaration() || lookAhead(nextTokenIsOpenParenOrLessThanOrDot); + case 85 /* SyntaxKind.ConstKeyword */: + case 93 /* SyntaxKind.ExportKeyword */: + return isStartOfDeclaration(); + case 132 /* SyntaxKind.AsyncKeyword */: + case 136 /* SyntaxKind.DeclareKeyword */: + case 118 /* SyntaxKind.InterfaceKeyword */: + case 142 /* SyntaxKind.ModuleKeyword */: + case 143 /* SyntaxKind.NamespaceKeyword */: + case 154 /* SyntaxKind.TypeKeyword */: + case 159 /* SyntaxKind.GlobalKeyword */: + // When these don't start a declaration, they're an identifier in an expression statement + return true; + case 127 /* SyntaxKind.AccessorKeyword */: + case 123 /* SyntaxKind.PublicKeyword */: + case 121 /* SyntaxKind.PrivateKeyword */: + case 122 /* SyntaxKind.ProtectedKeyword */: + case 124 /* SyntaxKind.StaticKeyword */: + case 146 /* SyntaxKind.ReadonlyKeyword */: + // When these don't start a declaration, they may be the start of a class member if an identifier + // immediately follows. Otherwise they're an identifier in an expression statement. + return isStartOfDeclaration() || !lookAhead(nextTokenIsIdentifierOrKeywordOnSameLine); + default: + return isStartOfExpression(); + } + } + function nextTokenIsBindingIdentifierOrStartOfDestructuring() { + nextToken(); + return isBindingIdentifier() || token() === 18 /* SyntaxKind.OpenBraceToken */ || token() === 22 /* SyntaxKind.OpenBracketToken */; + } + function isLetDeclaration() { + // In ES6 'let' always starts a lexical declaration if followed by an identifier or { + // or [. + return lookAhead(nextTokenIsBindingIdentifierOrStartOfDestructuring); + } + function parseStatement() { + switch (token()) { + case 26 /* SyntaxKind.SemicolonToken */: + return parseEmptyStatement(); + case 18 /* SyntaxKind.OpenBraceToken */: + return parseBlock(/*ignoreMissingOpenBrace*/ false); + case 113 /* SyntaxKind.VarKeyword */: + return parseVariableStatement(getNodePos(), hasPrecedingJSDocComment(), /*decorators*/ undefined, /*modifiers*/ undefined); + case 119 /* SyntaxKind.LetKeyword */: + if (isLetDeclaration()) { + return parseVariableStatement(getNodePos(), hasPrecedingJSDocComment(), /*decorators*/ undefined, /*modifiers*/ undefined); + } + break; + case 98 /* SyntaxKind.FunctionKeyword */: + return parseFunctionDeclaration(getNodePos(), hasPrecedingJSDocComment(), /*decorators*/ undefined, /*modifiers*/ undefined); + case 84 /* SyntaxKind.ClassKeyword */: + return parseClassDeclaration(getNodePos(), hasPrecedingJSDocComment(), /*decorators*/ undefined, /*modifiers*/ undefined); + case 99 /* SyntaxKind.IfKeyword */: + return parseIfStatement(); + case 90 /* SyntaxKind.DoKeyword */: + return parseDoStatement(); + case 115 /* SyntaxKind.WhileKeyword */: + return parseWhileStatement(); + case 97 /* SyntaxKind.ForKeyword */: + return parseForOrForInOrForOfStatement(); + case 86 /* SyntaxKind.ContinueKeyword */: + return parseBreakOrContinueStatement(248 /* SyntaxKind.ContinueStatement */); + case 81 /* SyntaxKind.BreakKeyword */: + return parseBreakOrContinueStatement(249 /* SyntaxKind.BreakStatement */); + case 105 /* SyntaxKind.ReturnKeyword */: + return parseReturnStatement(); + case 116 /* SyntaxKind.WithKeyword */: + return parseWithStatement(); + case 107 /* SyntaxKind.SwitchKeyword */: + return parseSwitchStatement(); + case 109 /* SyntaxKind.ThrowKeyword */: + return parseThrowStatement(); + case 111 /* SyntaxKind.TryKeyword */: + // Include 'catch' and 'finally' for error recovery. + // falls through + case 83 /* SyntaxKind.CatchKeyword */: + case 96 /* SyntaxKind.FinallyKeyword */: + return parseTryStatement(); + case 87 /* SyntaxKind.DebuggerKeyword */: + return parseDebuggerStatement(); + case 59 /* SyntaxKind.AtToken */: + return parseDeclaration(); + case 132 /* SyntaxKind.AsyncKeyword */: + case 118 /* SyntaxKind.InterfaceKeyword */: + case 154 /* SyntaxKind.TypeKeyword */: + case 142 /* SyntaxKind.ModuleKeyword */: + case 143 /* SyntaxKind.NamespaceKeyword */: + case 136 /* SyntaxKind.DeclareKeyword */: + case 85 /* SyntaxKind.ConstKeyword */: + case 92 /* SyntaxKind.EnumKeyword */: + case 93 /* SyntaxKind.ExportKeyword */: + case 100 /* SyntaxKind.ImportKeyword */: + case 121 /* SyntaxKind.PrivateKeyword */: + case 122 /* SyntaxKind.ProtectedKeyword */: + case 123 /* SyntaxKind.PublicKeyword */: + case 126 /* SyntaxKind.AbstractKeyword */: + case 127 /* SyntaxKind.AccessorKeyword */: + case 124 /* SyntaxKind.StaticKeyword */: + case 146 /* SyntaxKind.ReadonlyKeyword */: + case 159 /* SyntaxKind.GlobalKeyword */: + if (isStartOfDeclaration()) { + return parseDeclaration(); + } + break; + } + return parseExpressionOrLabeledStatement(); + } + function isDeclareModifier(modifier) { + return modifier.kind === 136 /* SyntaxKind.DeclareKeyword */; + } + function parseDeclaration() { + // `parseListElement` attempted to get the reused node at this position, + // but the ambient context flag was not yet set, so the node appeared + // not reusable in that context. + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + var decorators = parseDecorators(); + var modifiers = parseModifiers(); + var isAmbient = ts.some(modifiers, isDeclareModifier); + if (isAmbient) { + var node = tryReuseAmbientDeclaration(pos); + if (node) { + return node; + } + for (var _i = 0, _a = modifiers; _i < _a.length; _i++) { + var m = _a[_i]; + m.flags |= 16777216 /* NodeFlags.Ambient */; + } + return doInsideOfContext(16777216 /* NodeFlags.Ambient */, function () { return parseDeclarationWorker(pos, hasJSDoc, decorators, modifiers); }); + } + else { + return parseDeclarationWorker(pos, hasJSDoc, decorators, modifiers); + } + } + function tryReuseAmbientDeclaration(pos) { + return doInsideOfContext(16777216 /* NodeFlags.Ambient */, function () { + var node = currentNode(parsingContext, pos); + if (node) { + return consumeNode(node); + } + }); + } + function parseDeclarationWorker(pos, hasJSDoc, decorators, modifiers) { + switch (token()) { + case 113 /* SyntaxKind.VarKeyword */: + case 119 /* SyntaxKind.LetKeyword */: + case 85 /* SyntaxKind.ConstKeyword */: + return parseVariableStatement(pos, hasJSDoc, decorators, modifiers); + case 98 /* SyntaxKind.FunctionKeyword */: + return parseFunctionDeclaration(pos, hasJSDoc, decorators, modifiers); + case 84 /* SyntaxKind.ClassKeyword */: + return parseClassDeclaration(pos, hasJSDoc, decorators, modifiers); + case 118 /* SyntaxKind.InterfaceKeyword */: + return parseInterfaceDeclaration(pos, hasJSDoc, decorators, modifiers); + case 154 /* SyntaxKind.TypeKeyword */: + return parseTypeAliasDeclaration(pos, hasJSDoc, decorators, modifiers); + case 92 /* SyntaxKind.EnumKeyword */: + return parseEnumDeclaration(pos, hasJSDoc, decorators, modifiers); + case 159 /* SyntaxKind.GlobalKeyword */: + case 142 /* SyntaxKind.ModuleKeyword */: + case 143 /* SyntaxKind.NamespaceKeyword */: + return parseModuleDeclaration(pos, hasJSDoc, decorators, modifiers); + case 100 /* SyntaxKind.ImportKeyword */: + return parseImportDeclarationOrImportEqualsDeclaration(pos, hasJSDoc, decorators, modifiers); + case 93 /* SyntaxKind.ExportKeyword */: + nextToken(); + switch (token()) { + case 88 /* SyntaxKind.DefaultKeyword */: + case 63 /* SyntaxKind.EqualsToken */: + return parseExportAssignment(pos, hasJSDoc, decorators, modifiers); + case 128 /* SyntaxKind.AsKeyword */: + return parseNamespaceExportDeclaration(pos, hasJSDoc, decorators, modifiers); + default: + return parseExportDeclaration(pos, hasJSDoc, decorators, modifiers); + } + default: + if (decorators || modifiers) { + // We reached this point because we encountered decorators and/or modifiers and assumed a declaration + // would follow. For recovery and error reporting purposes, return an incomplete declaration. + var missing = createMissingNode(279 /* SyntaxKind.MissingDeclaration */, /*reportAtCurrentPosition*/ true, ts.Diagnostics.Declaration_expected); + ts.setTextRangePos(missing, pos); + missing.illegalDecorators = decorators; + missing.modifiers = modifiers; + return missing; + } + return undefined; // TODO: GH#18217 + } + } + function nextTokenIsIdentifierOrStringLiteralOnSameLine() { + nextToken(); + return !scanner.hasPrecedingLineBreak() && (isIdentifier() || token() === 10 /* SyntaxKind.StringLiteral */); + } + function parseFunctionBlockOrSemicolon(flags, diagnosticMessage) { + if (token() !== 18 /* SyntaxKind.OpenBraceToken */) { + if (flags & 4 /* SignatureFlags.Type */) { + parseTypeMemberSemicolon(); + return; + } + if (canParseSemicolon()) { + parseSemicolon(); + return; + } + } + return parseFunctionBlock(flags, diagnosticMessage); + } + // DECLARATIONS + function parseArrayBindingElement() { + var pos = getNodePos(); + if (token() === 27 /* SyntaxKind.CommaToken */) { + return finishNode(factory.createOmittedExpression(), pos); + } + var dotDotDotToken = parseOptionalToken(25 /* SyntaxKind.DotDotDotToken */); + var name = parseIdentifierOrPattern(); + var initializer = parseInitializer(); + return finishNode(factory.createBindingElement(dotDotDotToken, /*propertyName*/ undefined, name, initializer), pos); + } + function parseObjectBindingElement() { + var pos = getNodePos(); + var dotDotDotToken = parseOptionalToken(25 /* SyntaxKind.DotDotDotToken */); + var tokenIsIdentifier = isBindingIdentifier(); + var propertyName = parsePropertyName(); + var name; + if (tokenIsIdentifier && token() !== 58 /* SyntaxKind.ColonToken */) { + name = propertyName; + propertyName = undefined; + } + else { + parseExpected(58 /* SyntaxKind.ColonToken */); + name = parseIdentifierOrPattern(); + } + var initializer = parseInitializer(); + return finishNode(factory.createBindingElement(dotDotDotToken, propertyName, name, initializer), pos); + } + function parseObjectBindingPattern() { + var pos = getNodePos(); + parseExpected(18 /* SyntaxKind.OpenBraceToken */); + var elements = parseDelimitedList(9 /* ParsingContext.ObjectBindingElements */, parseObjectBindingElement); + parseExpected(19 /* SyntaxKind.CloseBraceToken */); + return finishNode(factory.createObjectBindingPattern(elements), pos); + } + function parseArrayBindingPattern() { + var pos = getNodePos(); + parseExpected(22 /* SyntaxKind.OpenBracketToken */); + var elements = parseDelimitedList(10 /* ParsingContext.ArrayBindingElements */, parseArrayBindingElement); + parseExpected(23 /* SyntaxKind.CloseBracketToken */); + return finishNode(factory.createArrayBindingPattern(elements), pos); + } + function isBindingIdentifierOrPrivateIdentifierOrPattern() { + return token() === 18 /* SyntaxKind.OpenBraceToken */ + || token() === 22 /* SyntaxKind.OpenBracketToken */ + || token() === 80 /* SyntaxKind.PrivateIdentifier */ + || isBindingIdentifier(); + } + function parseIdentifierOrPattern(privateIdentifierDiagnosticMessage) { + if (token() === 22 /* SyntaxKind.OpenBracketToken */) { + return parseArrayBindingPattern(); + } + if (token() === 18 /* SyntaxKind.OpenBraceToken */) { + return parseObjectBindingPattern(); + } + return parseBindingIdentifier(privateIdentifierDiagnosticMessage); + } + function parseVariableDeclarationAllowExclamation() { + return parseVariableDeclaration(/*allowExclamation*/ true); + } + function parseVariableDeclaration(allowExclamation) { + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + var name = parseIdentifierOrPattern(ts.Diagnostics.Private_identifiers_are_not_allowed_in_variable_declarations); + var exclamationToken; + if (allowExclamation && name.kind === 79 /* SyntaxKind.Identifier */ && + token() === 53 /* SyntaxKind.ExclamationToken */ && !scanner.hasPrecedingLineBreak()) { + exclamationToken = parseTokenNode(); + } + var type = parseTypeAnnotation(); + var initializer = isInOrOfKeyword(token()) ? undefined : parseInitializer(); + var node = factory.createVariableDeclaration(name, exclamationToken, type, initializer); + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + function parseVariableDeclarationList(inForStatementInitializer) { + var pos = getNodePos(); + var flags = 0; + switch (token()) { + case 113 /* SyntaxKind.VarKeyword */: + break; + case 119 /* SyntaxKind.LetKeyword */: + flags |= 1 /* NodeFlags.Let */; + break; + case 85 /* SyntaxKind.ConstKeyword */: + flags |= 2 /* NodeFlags.Const */; + break; + default: + ts.Debug.fail(); + } + nextToken(); + // The user may have written the following: + // + // for (let of X) { } + // + // In this case, we want to parse an empty declaration list, and then parse 'of' + // as a keyword. The reason this is not automatic is that 'of' is a valid identifier. + // So we need to look ahead to determine if 'of' should be treated as a keyword in + // this context. + // The checker will then give an error that there is an empty declaration list. + var declarations; + if (token() === 162 /* SyntaxKind.OfKeyword */ && lookAhead(canFollowContextualOfKeyword)) { + declarations = createMissingList(); + } + else { + var savedDisallowIn = inDisallowInContext(); + setDisallowInContext(inForStatementInitializer); + declarations = parseDelimitedList(8 /* ParsingContext.VariableDeclarations */, inForStatementInitializer ? parseVariableDeclaration : parseVariableDeclarationAllowExclamation); + setDisallowInContext(savedDisallowIn); + } + return finishNode(factory.createVariableDeclarationList(declarations, flags), pos); + } + function canFollowContextualOfKeyword() { + return nextTokenIsIdentifier() && nextToken() === 21 /* SyntaxKind.CloseParenToken */; + } + function parseVariableStatement(pos, hasJSDoc, decorators, modifiers) { + var declarationList = parseVariableDeclarationList(/*inForStatementInitializer*/ false); + parseSemicolon(); + var node = factory.createVariableStatement(modifiers, declarationList); + // Decorators are not allowed on a variable statement, so we keep track of them to report them in the grammar checker. + node.illegalDecorators = decorators; + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + function parseFunctionDeclaration(pos, hasJSDoc, decorators, modifiers) { + var savedAwaitContext = inAwaitContext(); + var modifierFlags = ts.modifiersToFlags(modifiers); + parseExpected(98 /* SyntaxKind.FunctionKeyword */); + var asteriskToken = parseOptionalToken(41 /* SyntaxKind.AsteriskToken */); + // We don't parse the name here in await context, instead we will report a grammar error in the checker. + var name = modifierFlags & 1024 /* ModifierFlags.Default */ ? parseOptionalBindingIdentifier() : parseBindingIdentifier(); + var isGenerator = asteriskToken ? 1 /* SignatureFlags.Yield */ : 0 /* SignatureFlags.None */; + var isAsync = modifierFlags & 512 /* ModifierFlags.Async */ ? 2 /* SignatureFlags.Await */ : 0 /* SignatureFlags.None */; + var typeParameters = parseTypeParameters(); + if (modifierFlags & 1 /* ModifierFlags.Export */) + setAwaitContext(/*value*/ true); + var parameters = parseParameters(isGenerator | isAsync); + var type = parseReturnType(58 /* SyntaxKind.ColonToken */, /*isType*/ false); + var body = parseFunctionBlockOrSemicolon(isGenerator | isAsync, ts.Diagnostics.or_expected); + setAwaitContext(savedAwaitContext); + var node = factory.createFunctionDeclaration(modifiers, asteriskToken, name, typeParameters, parameters, type, body); + node.illegalDecorators = decorators; + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + function parseConstructorName() { + if (token() === 135 /* SyntaxKind.ConstructorKeyword */) { + return parseExpected(135 /* SyntaxKind.ConstructorKeyword */); + } + if (token() === 10 /* SyntaxKind.StringLiteral */ && lookAhead(nextToken) === 20 /* SyntaxKind.OpenParenToken */) { + return tryParse(function () { + var literalNode = parseLiteralNode(); + return literalNode.text === "constructor" ? literalNode : undefined; + }); + } + } + function tryParseConstructorDeclaration(pos, hasJSDoc, decorators, modifiers) { + return tryParse(function () { + if (parseConstructorName()) { + var typeParameters = parseTypeParameters(); + var parameters = parseParameters(0 /* SignatureFlags.None */); + var type = parseReturnType(58 /* SyntaxKind.ColonToken */, /*isType*/ false); + var body = parseFunctionBlockOrSemicolon(0 /* SignatureFlags.None */, ts.Diagnostics.or_expected); + var node = factory.createConstructorDeclaration(modifiers, parameters, body); + // Attach invalid nodes if they exist so that we can report them in the grammar checker. + node.illegalDecorators = decorators; + node.typeParameters = typeParameters; + node.type = type; + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + }); + } + function parseMethodDeclaration(pos, hasJSDoc, decorators, modifiers, asteriskToken, name, questionToken, exclamationToken, diagnosticMessage) { + var isGenerator = asteriskToken ? 1 /* SignatureFlags.Yield */ : 0 /* SignatureFlags.None */; + var isAsync = ts.some(modifiers, ts.isAsyncModifier) ? 2 /* SignatureFlags.Await */ : 0 /* SignatureFlags.None */; + var typeParameters = parseTypeParameters(); + var parameters = parseParameters(isGenerator | isAsync); + var type = parseReturnType(58 /* SyntaxKind.ColonToken */, /*isType*/ false); + var body = parseFunctionBlockOrSemicolon(isGenerator | isAsync, diagnosticMessage); + var node = factory.createMethodDeclaration(combineDecoratorsAndModifiers(decorators, modifiers), asteriskToken, name, questionToken, typeParameters, parameters, type, body); + // An exclamation token on a method is invalid syntax and will be handled by the grammar checker + node.exclamationToken = exclamationToken; + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + function parsePropertyDeclaration(pos, hasJSDoc, decorators, modifiers, name, questionToken) { + var exclamationToken = !questionToken && !scanner.hasPrecedingLineBreak() ? parseOptionalToken(53 /* SyntaxKind.ExclamationToken */) : undefined; + var type = parseTypeAnnotation(); + var initializer = doOutsideOfContext(8192 /* NodeFlags.YieldContext */ | 32768 /* NodeFlags.AwaitContext */ | 4096 /* NodeFlags.DisallowInContext */, parseInitializer); + parseSemicolonAfterPropertyName(name, type, initializer); + var node = factory.createPropertyDeclaration(combineDecoratorsAndModifiers(decorators, modifiers), name, questionToken || exclamationToken, type, initializer); + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + function parsePropertyOrMethodDeclaration(pos, hasJSDoc, decorators, modifiers) { + var asteriskToken = parseOptionalToken(41 /* SyntaxKind.AsteriskToken */); + var name = parsePropertyName(); + // Note: this is not legal as per the grammar. But we allow it in the parser and + // report an error in the grammar checker. + var questionToken = parseOptionalToken(57 /* SyntaxKind.QuestionToken */); + if (asteriskToken || token() === 20 /* SyntaxKind.OpenParenToken */ || token() === 29 /* SyntaxKind.LessThanToken */) { + return parseMethodDeclaration(pos, hasJSDoc, decorators, modifiers, asteriskToken, name, questionToken, /*exclamationToken*/ undefined, ts.Diagnostics.or_expected); + } + return parsePropertyDeclaration(pos, hasJSDoc, decorators, modifiers, name, questionToken); + } + function parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, kind, flags) { + var name = parsePropertyName(); + var typeParameters = parseTypeParameters(); + var parameters = parseParameters(0 /* SignatureFlags.None */); + var type = parseReturnType(58 /* SyntaxKind.ColonToken */, /*isType*/ false); + var body = parseFunctionBlockOrSemicolon(flags); + var node = kind === 174 /* SyntaxKind.GetAccessor */ + ? factory.createGetAccessorDeclaration(combineDecoratorsAndModifiers(decorators, modifiers), name, parameters, type, body) + : factory.createSetAccessorDeclaration(combineDecoratorsAndModifiers(decorators, modifiers), name, parameters, body); + // Keep track of `typeParameters` (for both) and `type` (for setters) if they were parsed those indicate grammar errors + node.typeParameters = typeParameters; + if (ts.isSetAccessorDeclaration(node)) + node.type = type; + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + function isClassMemberStart() { + var idToken; + if (token() === 59 /* SyntaxKind.AtToken */) { + return true; + } + // Eat up all modifiers, but hold on to the last one in case it is actually an identifier. + while (ts.isModifierKind(token())) { + idToken = token(); + // If the idToken is a class modifier (protected, private, public, and static), it is + // certain that we are starting to parse class member. This allows better error recovery + // Example: + // public foo() ... // true + // public @dec blah ... // true; we will then report an error later + // export public ... // true; we will then report an error later + if (ts.isClassMemberModifier(idToken)) { + return true; + } + nextToken(); + } + if (token() === 41 /* SyntaxKind.AsteriskToken */) { + return true; + } + // Try to get the first property-like token following all modifiers. + // This can either be an identifier or the 'get' or 'set' keywords. + if (isLiteralPropertyName()) { + idToken = token(); + nextToken(); + } + // Index signatures and computed properties are class members; we can parse. + if (token() === 22 /* SyntaxKind.OpenBracketToken */) { + return true; + } + // If we were able to get any potential identifier... + if (idToken !== undefined) { + // If we have a non-keyword identifier, or if we have an accessor, then it's safe to parse. + if (!ts.isKeyword(idToken) || idToken === 151 /* SyntaxKind.SetKeyword */ || idToken === 137 /* SyntaxKind.GetKeyword */) { + return true; + } + // If it *is* a keyword, but not an accessor, check a little farther along + // to see if it should actually be parsed as a class member. + switch (token()) { + case 20 /* SyntaxKind.OpenParenToken */: // Method declaration + case 29 /* SyntaxKind.LessThanToken */: // Generic Method declaration + case 53 /* SyntaxKind.ExclamationToken */: // Non-null assertion on property name + case 58 /* SyntaxKind.ColonToken */: // Type Annotation for declaration + case 63 /* SyntaxKind.EqualsToken */: // Initializer for declaration + case 57 /* SyntaxKind.QuestionToken */: // Not valid, but permitted so that it gets caught later on. + return true; + default: + // Covers + // - Semicolons (declaration termination) + // - Closing braces (end-of-class, must be declaration) + // - End-of-files (not valid, but permitted so that it gets caught later on) + // - Line-breaks (enabling *automatic semicolon insertion*) + return canParseSemicolon(); + } + } + return false; + } + function parseClassStaticBlockDeclaration(pos, hasJSDoc, decorators, modifiers) { + parseExpectedToken(124 /* SyntaxKind.StaticKeyword */); + var body = parseClassStaticBlockBody(); + var node = withJSDoc(finishNode(factory.createClassStaticBlockDeclaration(body), pos), hasJSDoc); + node.illegalDecorators = decorators; + node.modifiers = modifiers; + return node; + } + function parseClassStaticBlockBody() { + var savedYieldContext = inYieldContext(); + var savedAwaitContext = inAwaitContext(); + setYieldContext(false); + setAwaitContext(true); + var body = parseBlock(/*ignoreMissingOpenBrace*/ false); + setYieldContext(savedYieldContext); + setAwaitContext(savedAwaitContext); + return body; + } + function parseDecoratorExpression() { + if (inAwaitContext() && token() === 133 /* SyntaxKind.AwaitKeyword */) { + // `@await` is is disallowed in an [Await] context, but can cause parsing to go off the rails + // This simply parses the missing identifier and moves on. + var pos = getNodePos(); + var awaitExpression = parseIdentifier(ts.Diagnostics.Expression_expected); + nextToken(); + var memberExpression = parseMemberExpressionRest(pos, awaitExpression, /*allowOptionalChain*/ true); + return parseCallExpressionRest(pos, memberExpression); + } + return parseLeftHandSideExpressionOrHigher(); + } + function tryParseDecorator() { + var pos = getNodePos(); + if (!parseOptional(59 /* SyntaxKind.AtToken */)) { + return undefined; + } + var expression = doInDecoratorContext(parseDecoratorExpression); + return finishNode(factory.createDecorator(expression), pos); + } + function parseDecorators() { + var pos = getNodePos(); + var list, decorator; + while (decorator = tryParseDecorator()) { + list = ts.append(list, decorator); + } + return list && createNodeArray(list, pos); + } + function tryParseModifier(permitInvalidConstAsModifier, stopOnStartOfClassStaticBlock, hasSeenStaticModifier) { + var pos = getNodePos(); + var kind = token(); + if (token() === 85 /* SyntaxKind.ConstKeyword */ && permitInvalidConstAsModifier) { + // We need to ensure that any subsequent modifiers appear on the same line + // so that when 'const' is a standalone declaration, we don't issue an error. + if (!tryParse(nextTokenIsOnSameLineAndCanFollowModifier)) { + return undefined; + } + } + else if (stopOnStartOfClassStaticBlock && token() === 124 /* SyntaxKind.StaticKeyword */ && lookAhead(nextTokenIsOpenBrace)) { + return undefined; + } + else if (hasSeenStaticModifier && token() === 124 /* SyntaxKind.StaticKeyword */) { + return undefined; + } + else { + if (!parseAnyContextualModifier()) { + return undefined; + } + } + return finishNode(factory.createToken(kind), pos); + } + function combineDecoratorsAndModifiers(decorators, modifiers) { + if (!decorators) + return modifiers; + if (!modifiers) + return decorators; + var decoratorsAndModifiers = factory.createNodeArray(ts.concatenate(decorators, modifiers)); + ts.setTextRangePosEnd(decoratorsAndModifiers, decorators.pos, modifiers.end); + return decoratorsAndModifiers; + } + /* + * There are situations in which a modifier like 'const' will appear unexpectedly, such as on a class member. + * In those situations, if we are entirely sure that 'const' is not valid on its own (such as when ASI takes effect + * and turns it into a standalone declaration), then it is better to parse it and report an error later. + * + * In such situations, 'permitInvalidConstAsModifier' should be set to true. + */ + function parseModifiers(permitInvalidConstAsModifier, stopOnStartOfClassStaticBlock) { + var pos = getNodePos(); + var list, modifier, hasSeenStatic = false; + while (modifier = tryParseModifier(permitInvalidConstAsModifier, stopOnStartOfClassStaticBlock, hasSeenStatic)) { + if (modifier.kind === 124 /* SyntaxKind.StaticKeyword */) + hasSeenStatic = true; + list = ts.append(list, modifier); + } + return list && createNodeArray(list, pos); + } + function parseModifiersForArrowFunction() { + var modifiers; + if (token() === 132 /* SyntaxKind.AsyncKeyword */) { + var pos = getNodePos(); + nextToken(); + var modifier = finishNode(factory.createToken(132 /* SyntaxKind.AsyncKeyword */), pos); + modifiers = createNodeArray([modifier], pos); + } + return modifiers; + } + function parseClassElement() { + var pos = getNodePos(); + if (token() === 26 /* SyntaxKind.SemicolonToken */) { + nextToken(); + return finishNode(factory.createSemicolonClassElement(), pos); + } + var hasJSDoc = hasPrecedingJSDocComment(); + var decorators = parseDecorators(); + var modifiers = parseModifiers(/*permitInvalidConstAsModifier*/ true, /*stopOnStartOfClassStaticBlock*/ true); + if (token() === 124 /* SyntaxKind.StaticKeyword */ && lookAhead(nextTokenIsOpenBrace)) { + return parseClassStaticBlockDeclaration(pos, hasJSDoc, decorators, modifiers); + } + if (parseContextualModifier(137 /* SyntaxKind.GetKeyword */)) { + return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 174 /* SyntaxKind.GetAccessor */, 0 /* SignatureFlags.None */); + } + if (parseContextualModifier(151 /* SyntaxKind.SetKeyword */)) { + return parseAccessorDeclaration(pos, hasJSDoc, decorators, modifiers, 175 /* SyntaxKind.SetAccessor */, 0 /* SignatureFlags.None */); + } + if (token() === 135 /* SyntaxKind.ConstructorKeyword */ || token() === 10 /* SyntaxKind.StringLiteral */) { + var constructorDeclaration = tryParseConstructorDeclaration(pos, hasJSDoc, decorators, modifiers); + if (constructorDeclaration) { + return constructorDeclaration; + } + } + if (isIndexSignature()) { + return parseIndexSignatureDeclaration(pos, hasJSDoc, decorators, modifiers); + } + // It is very important that we check this *after* checking indexers because + // the [ token can start an index signature or a computed property name + if (ts.tokenIsIdentifierOrKeyword(token()) || + token() === 10 /* SyntaxKind.StringLiteral */ || + token() === 8 /* SyntaxKind.NumericLiteral */ || + token() === 41 /* SyntaxKind.AsteriskToken */ || + token() === 22 /* SyntaxKind.OpenBracketToken */) { + var isAmbient = ts.some(modifiers, isDeclareModifier); + if (isAmbient) { + for (var _i = 0, _a = modifiers; _i < _a.length; _i++) { + var m = _a[_i]; + m.flags |= 16777216 /* NodeFlags.Ambient */; + } + return doInsideOfContext(16777216 /* NodeFlags.Ambient */, function () { return parsePropertyOrMethodDeclaration(pos, hasJSDoc, decorators, modifiers); }); + } + else { + return parsePropertyOrMethodDeclaration(pos, hasJSDoc, decorators, modifiers); + } + } + if (decorators || modifiers) { + // treat this as a property declaration with a missing name. + var name = createMissingNode(79 /* SyntaxKind.Identifier */, /*reportAtCurrentPosition*/ true, ts.Diagnostics.Declaration_expected); + return parsePropertyDeclaration(pos, hasJSDoc, decorators, modifiers, name, /*questionToken*/ undefined); + } + // 'isClassMemberStart' should have hinted not to attempt parsing. + return ts.Debug.fail("Should not have attempted to parse class member declaration."); + } + function parseClassExpression() { + return parseClassDeclarationOrExpression(getNodePos(), hasPrecedingJSDocComment(), /*decorators*/ undefined, /*modifiers*/ undefined, 228 /* SyntaxKind.ClassExpression */); + } + function parseClassDeclaration(pos, hasJSDoc, decorators, modifiers) { + return parseClassDeclarationOrExpression(pos, hasJSDoc, decorators, modifiers, 260 /* SyntaxKind.ClassDeclaration */); + } + function parseClassDeclarationOrExpression(pos, hasJSDoc, decorators, modifiers, kind) { + var savedAwaitContext = inAwaitContext(); + parseExpected(84 /* SyntaxKind.ClassKeyword */); + // We don't parse the name here in await context, instead we will report a grammar error in the checker. + var name = parseNameOfClassDeclarationOrExpression(); + var typeParameters = parseTypeParameters(); + if (ts.some(modifiers, ts.isExportModifier)) + setAwaitContext(/*value*/ true); + var heritageClauses = parseHeritageClauses(); + var members; + if (parseExpected(18 /* SyntaxKind.OpenBraceToken */)) { + // ClassTail[Yield,Await] : (Modified) See 14.5 + // ClassHeritage[?Yield,?Await]opt { ClassBody[?Yield,?Await]opt } + members = parseClassMembers(); + parseExpected(19 /* SyntaxKind.CloseBraceToken */); + } + else { + members = createMissingList(); + } + setAwaitContext(savedAwaitContext); + var node = kind === 260 /* SyntaxKind.ClassDeclaration */ + ? factory.createClassDeclaration(combineDecoratorsAndModifiers(decorators, modifiers), name, typeParameters, heritageClauses, members) + : factory.createClassExpression(combineDecoratorsAndModifiers(decorators, modifiers), name, typeParameters, heritageClauses, members); + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + function parseNameOfClassDeclarationOrExpression() { + // implements is a future reserved word so + // 'class implements' might mean either + // - class expression with omitted name, 'implements' starts heritage clause + // - class with name 'implements' + // 'isImplementsClause' helps to disambiguate between these two cases + return isBindingIdentifier() && !isImplementsClause() + ? createIdentifier(isBindingIdentifier()) + : undefined; + } + function isImplementsClause() { + return token() === 117 /* SyntaxKind.ImplementsKeyword */ && lookAhead(nextTokenIsIdentifierOrKeyword); + } + function parseHeritageClauses() { + // ClassTail[Yield,Await] : (Modified) See 14.5 + // ClassHeritage[?Yield,?Await]opt { ClassBody[?Yield,?Await]opt } + if (isHeritageClause()) { + return parseList(22 /* ParsingContext.HeritageClauses */, parseHeritageClause); + } + return undefined; + } + function parseHeritageClause() { + var pos = getNodePos(); + var tok = token(); + ts.Debug.assert(tok === 94 /* SyntaxKind.ExtendsKeyword */ || tok === 117 /* SyntaxKind.ImplementsKeyword */); // isListElement() should ensure this. + nextToken(); + var types = parseDelimitedList(7 /* ParsingContext.HeritageClauseElement */, parseExpressionWithTypeArguments); + return finishNode(factory.createHeritageClause(tok, types), pos); + } + function parseExpressionWithTypeArguments() { + var pos = getNodePos(); + var expression = parseLeftHandSideExpressionOrHigher(); + if (expression.kind === 230 /* SyntaxKind.ExpressionWithTypeArguments */) { + return expression; + } + var typeArguments = tryParseTypeArguments(); + return finishNode(factory.createExpressionWithTypeArguments(expression, typeArguments), pos); + } + function tryParseTypeArguments() { + return token() === 29 /* SyntaxKind.LessThanToken */ ? + parseBracketedList(20 /* ParsingContext.TypeArguments */, parseType, 29 /* SyntaxKind.LessThanToken */, 31 /* SyntaxKind.GreaterThanToken */) : undefined; + } + function isHeritageClause() { + return token() === 94 /* SyntaxKind.ExtendsKeyword */ || token() === 117 /* SyntaxKind.ImplementsKeyword */; + } + function parseClassMembers() { + return parseList(5 /* ParsingContext.ClassMembers */, parseClassElement); + } + function parseInterfaceDeclaration(pos, hasJSDoc, decorators, modifiers) { + parseExpected(118 /* SyntaxKind.InterfaceKeyword */); + var name = parseIdentifier(); + var typeParameters = parseTypeParameters(); + var heritageClauses = parseHeritageClauses(); + var members = parseObjectTypeMembers(); + var node = factory.createInterfaceDeclaration(modifiers, name, typeParameters, heritageClauses, members); + node.illegalDecorators = decorators; + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + function parseTypeAliasDeclaration(pos, hasJSDoc, decorators, modifiers) { + parseExpected(154 /* SyntaxKind.TypeKeyword */); + var name = parseIdentifier(); + var typeParameters = parseTypeParameters(); + parseExpected(63 /* SyntaxKind.EqualsToken */); + var type = token() === 139 /* SyntaxKind.IntrinsicKeyword */ && tryParse(parseKeywordAndNoDot) || parseType(); + parseSemicolon(); + var node = factory.createTypeAliasDeclaration(modifiers, name, typeParameters, type); + node.illegalDecorators = decorators; + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + // In an ambient declaration, the grammar only allows integer literals as initializers. + // In a non-ambient declaration, the grammar allows uninitialized members only in a + // ConstantEnumMemberSection, which starts at the beginning of an enum declaration + // or any time an integer literal initializer is encountered. + function parseEnumMember() { + var pos = getNodePos(); + var hasJSDoc = hasPrecedingJSDocComment(); + var name = parsePropertyName(); + var initializer = allowInAnd(parseInitializer); + return withJSDoc(finishNode(factory.createEnumMember(name, initializer), pos), hasJSDoc); + } + function parseEnumDeclaration(pos, hasJSDoc, decorators, modifiers) { + parseExpected(92 /* SyntaxKind.EnumKeyword */); + var name = parseIdentifier(); + var members; + if (parseExpected(18 /* SyntaxKind.OpenBraceToken */)) { + members = doOutsideOfYieldAndAwaitContext(function () { return parseDelimitedList(6 /* ParsingContext.EnumMembers */, parseEnumMember); }); + parseExpected(19 /* SyntaxKind.CloseBraceToken */); + } + else { + members = createMissingList(); + } + var node = factory.createEnumDeclaration(modifiers, name, members); + node.illegalDecorators = decorators; + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + function parseModuleBlock() { + var pos = getNodePos(); + var statements; + if (parseExpected(18 /* SyntaxKind.OpenBraceToken */)) { + statements = parseList(1 /* ParsingContext.BlockStatements */, parseStatement); + parseExpected(19 /* SyntaxKind.CloseBraceToken */); + } + else { + statements = createMissingList(); + } + return finishNode(factory.createModuleBlock(statements), pos); + } + function parseModuleOrNamespaceDeclaration(pos, hasJSDoc, decorators, modifiers, flags) { + // If we are parsing a dotted namespace name, we want to + // propagate the 'Namespace' flag across the names if set. + var namespaceFlag = flags & 16 /* NodeFlags.Namespace */; + var name = parseIdentifier(); + var body = parseOptional(24 /* SyntaxKind.DotToken */) + ? parseModuleOrNamespaceDeclaration(getNodePos(), /*hasJSDoc*/ false, /*decorators*/ undefined, /*modifiers*/ undefined, 4 /* NodeFlags.NestedNamespace */ | namespaceFlag) + : parseModuleBlock(); + var node = factory.createModuleDeclaration(modifiers, name, body, flags); + node.illegalDecorators = decorators; + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + function parseAmbientExternalModuleDeclaration(pos, hasJSDoc, decorators, modifiers) { + var flags = 0; + var name; + if (token() === 159 /* SyntaxKind.GlobalKeyword */) { + // parse 'global' as name of global scope augmentation + name = parseIdentifier(); + flags |= 1024 /* NodeFlags.GlobalAugmentation */; + } + else { + name = parseLiteralNode(); + name.text = internIdentifier(name.text); + } + var body; + if (token() === 18 /* SyntaxKind.OpenBraceToken */) { + body = parseModuleBlock(); + } + else { + parseSemicolon(); + } + var node = factory.createModuleDeclaration(modifiers, name, body, flags); + node.illegalDecorators = decorators; + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + function parseModuleDeclaration(pos, hasJSDoc, decorators, modifiers) { + var flags = 0; + if (token() === 159 /* SyntaxKind.GlobalKeyword */) { + // global augmentation + return parseAmbientExternalModuleDeclaration(pos, hasJSDoc, decorators, modifiers); + } + else if (parseOptional(143 /* SyntaxKind.NamespaceKeyword */)) { + flags |= 16 /* NodeFlags.Namespace */; + } + else { + parseExpected(142 /* SyntaxKind.ModuleKeyword */); + if (token() === 10 /* SyntaxKind.StringLiteral */) { + return parseAmbientExternalModuleDeclaration(pos, hasJSDoc, decorators, modifiers); + } + } + return parseModuleOrNamespaceDeclaration(pos, hasJSDoc, decorators, modifiers, flags); + } + function isExternalModuleReference() { + return token() === 147 /* SyntaxKind.RequireKeyword */ && + lookAhead(nextTokenIsOpenParen); + } + function nextTokenIsOpenParen() { + return nextToken() === 20 /* SyntaxKind.OpenParenToken */; + } + function nextTokenIsOpenBrace() { + return nextToken() === 18 /* SyntaxKind.OpenBraceToken */; + } + function nextTokenIsSlash() { + return nextToken() === 43 /* SyntaxKind.SlashToken */; + } + function parseNamespaceExportDeclaration(pos, hasJSDoc, decorators, modifiers) { + parseExpected(128 /* SyntaxKind.AsKeyword */); + parseExpected(143 /* SyntaxKind.NamespaceKeyword */); + var name = parseIdentifier(); + parseSemicolon(); + var node = factory.createNamespaceExportDeclaration(name); + // NamespaceExportDeclaration nodes cannot have decorators or modifiers, so we attach them here so we can report them in the grammar checker + node.illegalDecorators = decorators; + node.modifiers = modifiers; + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + function parseImportDeclarationOrImportEqualsDeclaration(pos, hasJSDoc, decorators, modifiers) { + parseExpected(100 /* SyntaxKind.ImportKeyword */); + var afterImportPos = scanner.getStartPos(); + // We don't parse the identifier here in await context, instead we will report a grammar error in the checker. + var identifier; + if (isIdentifier()) { + identifier = parseIdentifier(); + } + var isTypeOnly = false; + if (token() !== 158 /* SyntaxKind.FromKeyword */ && + (identifier === null || identifier === void 0 ? void 0 : identifier.escapedText) === "type" && + (isIdentifier() || tokenAfterImportDefinitelyProducesImportDeclaration())) { + isTypeOnly = true; + identifier = isIdentifier() ? parseIdentifier() : undefined; + } + if (identifier && !tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration()) { + return parseImportEqualsDeclaration(pos, hasJSDoc, decorators, modifiers, identifier, isTypeOnly); + } + // ImportDeclaration: + // import ImportClause from ModuleSpecifier ; + // import ModuleSpecifier; + var importClause; + if (identifier || // import id + token() === 41 /* SyntaxKind.AsteriskToken */ || // import * + token() === 18 /* SyntaxKind.OpenBraceToken */ // import { + ) { + importClause = parseImportClause(identifier, afterImportPos, isTypeOnly); + parseExpected(158 /* SyntaxKind.FromKeyword */); + } + var moduleSpecifier = parseModuleSpecifier(); + var assertClause; + if (token() === 130 /* SyntaxKind.AssertKeyword */ && !scanner.hasPrecedingLineBreak()) { + assertClause = parseAssertClause(); + } + parseSemicolon(); + var node = factory.createImportDeclaration(modifiers, importClause, moduleSpecifier, assertClause); + node.illegalDecorators = decorators; + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + function parseAssertEntry() { + var pos = getNodePos(); + var name = ts.tokenIsIdentifierOrKeyword(token()) ? parseIdentifierName() : parseLiteralLikeNode(10 /* SyntaxKind.StringLiteral */); + parseExpected(58 /* SyntaxKind.ColonToken */); + var value = parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true); + return finishNode(factory.createAssertEntry(name, value), pos); + } + function parseAssertClause(skipAssertKeyword) { + var pos = getNodePos(); + if (!skipAssertKeyword) { + parseExpected(130 /* SyntaxKind.AssertKeyword */); + } + var openBracePosition = scanner.getTokenPos(); + if (parseExpected(18 /* SyntaxKind.OpenBraceToken */)) { + var multiLine = scanner.hasPrecedingLineBreak(); + var elements = parseDelimitedList(24 /* ParsingContext.AssertEntries */, parseAssertEntry, /*considerSemicolonAsDelimiter*/ true); + if (!parseExpected(19 /* SyntaxKind.CloseBraceToken */)) { + var lastError = ts.lastOrUndefined(parseDiagnostics); + if (lastError && lastError.code === ts.Diagnostics._0_expected.code) { + ts.addRelatedInfo(lastError, ts.createDetachedDiagnostic(fileName, openBracePosition, 1, ts.Diagnostics.The_parser_expected_to_find_a_1_to_match_the_0_token_here, "{", "}")); + } + } + return finishNode(factory.createAssertClause(elements, multiLine), pos); + } + else { + var elements = createNodeArray([], getNodePos(), /*end*/ undefined, /*hasTrailingComma*/ false); + return finishNode(factory.createAssertClause(elements, /*multiLine*/ false), pos); + } + } + function tokenAfterImportDefinitelyProducesImportDeclaration() { + return token() === 41 /* SyntaxKind.AsteriskToken */ || token() === 18 /* SyntaxKind.OpenBraceToken */; + } + function tokenAfterImportedIdentifierDefinitelyProducesImportDeclaration() { + // In `import id ___`, the current token decides whether to produce + // an ImportDeclaration or ImportEqualsDeclaration. + return token() === 27 /* SyntaxKind.CommaToken */ || token() === 158 /* SyntaxKind.FromKeyword */; + } + function parseImportEqualsDeclaration(pos, hasJSDoc, decorators, modifiers, identifier, isTypeOnly) { + parseExpected(63 /* SyntaxKind.EqualsToken */); + var moduleReference = parseModuleReference(); + parseSemicolon(); + var node = factory.createImportEqualsDeclaration(modifiers, isTypeOnly, identifier, moduleReference); + node.illegalDecorators = decorators; + var finished = withJSDoc(finishNode(node, pos), hasJSDoc); + return finished; + } + function parseImportClause(identifier, pos, isTypeOnly) { + // ImportClause: + // ImportedDefaultBinding + // NameSpaceImport + // NamedImports + // ImportedDefaultBinding, NameSpaceImport + // ImportedDefaultBinding, NamedImports + // If there was no default import or if there is comma token after default import + // parse namespace or named imports + var namedBindings; + if (!identifier || + parseOptional(27 /* SyntaxKind.CommaToken */)) { + namedBindings = token() === 41 /* SyntaxKind.AsteriskToken */ ? parseNamespaceImport() : parseNamedImportsOrExports(272 /* SyntaxKind.NamedImports */); + } + return finishNode(factory.createImportClause(isTypeOnly, identifier, namedBindings), pos); + } + function parseModuleReference() { + return isExternalModuleReference() + ? parseExternalModuleReference() + : parseEntityName(/*allowReservedWords*/ false); + } + function parseExternalModuleReference() { + var pos = getNodePos(); + parseExpected(147 /* SyntaxKind.RequireKeyword */); + parseExpected(20 /* SyntaxKind.OpenParenToken */); + var expression = parseModuleSpecifier(); + parseExpected(21 /* SyntaxKind.CloseParenToken */); + return finishNode(factory.createExternalModuleReference(expression), pos); + } + function parseModuleSpecifier() { + if (token() === 10 /* SyntaxKind.StringLiteral */) { + var result = parseLiteralNode(); + result.text = internIdentifier(result.text); + return result; + } + else { + // We allow arbitrary expressions here, even though the grammar only allows string + // literals. We check to ensure that it is only a string literal later in the grammar + // check pass. + return parseExpression(); + } + } + function parseNamespaceImport() { + // NameSpaceImport: + // * as ImportedBinding + var pos = getNodePos(); + parseExpected(41 /* SyntaxKind.AsteriskToken */); + parseExpected(128 /* SyntaxKind.AsKeyword */); + var name = parseIdentifier(); + return finishNode(factory.createNamespaceImport(name), pos); + } + function parseNamedImportsOrExports(kind) { + var pos = getNodePos(); + // NamedImports: + // { } + // { ImportsList } + // { ImportsList, } + // ImportsList: + // ImportSpecifier + // ImportsList, ImportSpecifier + var node = kind === 272 /* SyntaxKind.NamedImports */ + ? factory.createNamedImports(parseBracketedList(23 /* ParsingContext.ImportOrExportSpecifiers */, parseImportSpecifier, 18 /* SyntaxKind.OpenBraceToken */, 19 /* SyntaxKind.CloseBraceToken */)) + : factory.createNamedExports(parseBracketedList(23 /* ParsingContext.ImportOrExportSpecifiers */, parseExportSpecifier, 18 /* SyntaxKind.OpenBraceToken */, 19 /* SyntaxKind.CloseBraceToken */)); + return finishNode(node, pos); + } + function parseExportSpecifier() { + var hasJSDoc = hasPrecedingJSDocComment(); + return withJSDoc(parseImportOrExportSpecifier(278 /* SyntaxKind.ExportSpecifier */), hasJSDoc); + } + function parseImportSpecifier() { + return parseImportOrExportSpecifier(273 /* SyntaxKind.ImportSpecifier */); + } + function parseImportOrExportSpecifier(kind) { + var pos = getNodePos(); + // ImportSpecifier: + // BindingIdentifier + // IdentifierName as BindingIdentifier + // ExportSpecifier: + // IdentifierName + // IdentifierName as IdentifierName + var checkIdentifierIsKeyword = ts.isKeyword(token()) && !isIdentifier(); + var checkIdentifierStart = scanner.getTokenPos(); + var checkIdentifierEnd = scanner.getTextPos(); + var isTypeOnly = false; + var propertyName; + var canParseAsKeyword = true; + var name = parseIdentifierName(); + if (name.escapedText === "type") { + // If the first token of an import specifier is 'type', there are a lot of possibilities, + // especially if we see 'as' afterwards: + // + // import { type } from "mod"; - isTypeOnly: false, name: type + // import { type as } from "mod"; - isTypeOnly: true, name: as + // import { type as as } from "mod"; - isTypeOnly: false, name: as, propertyName: type + // import { type as as as } from "mod"; - isTypeOnly: true, name: as, propertyName: as + if (token() === 128 /* SyntaxKind.AsKeyword */) { + // { type as ...? } + var firstAs = parseIdentifierName(); + if (token() === 128 /* SyntaxKind.AsKeyword */) { + // { type as as ...? } + var secondAs = parseIdentifierName(); + if (ts.tokenIsIdentifierOrKeyword(token())) { + // { type as as something } + isTypeOnly = true; + propertyName = firstAs; + name = parseNameWithKeywordCheck(); + canParseAsKeyword = false; + } + else { + // { type as as } + propertyName = name; + name = secondAs; + canParseAsKeyword = false; + } + } + else if (ts.tokenIsIdentifierOrKeyword(token())) { + // { type as something } + propertyName = name; + canParseAsKeyword = false; + name = parseNameWithKeywordCheck(); + } + else { + // { type as } + isTypeOnly = true; + name = firstAs; + } + } + else if (ts.tokenIsIdentifierOrKeyword(token())) { + // { type something ...? } + isTypeOnly = true; + name = parseNameWithKeywordCheck(); + } + } + if (canParseAsKeyword && token() === 128 /* SyntaxKind.AsKeyword */) { + propertyName = name; + parseExpected(128 /* SyntaxKind.AsKeyword */); + name = parseNameWithKeywordCheck(); + } + if (kind === 273 /* SyntaxKind.ImportSpecifier */ && checkIdentifierIsKeyword) { + parseErrorAt(checkIdentifierStart, checkIdentifierEnd, ts.Diagnostics.Identifier_expected); + } + var node = kind === 273 /* SyntaxKind.ImportSpecifier */ + ? factory.createImportSpecifier(isTypeOnly, propertyName, name) + : factory.createExportSpecifier(isTypeOnly, propertyName, name); + return finishNode(node, pos); + function parseNameWithKeywordCheck() { + checkIdentifierIsKeyword = ts.isKeyword(token()) && !isIdentifier(); + checkIdentifierStart = scanner.getTokenPos(); + checkIdentifierEnd = scanner.getTextPos(); + return parseIdentifierName(); + } + } + function parseNamespaceExport(pos) { + return finishNode(factory.createNamespaceExport(parseIdentifierName()), pos); + } + function parseExportDeclaration(pos, hasJSDoc, decorators, modifiers) { + var savedAwaitContext = inAwaitContext(); + setAwaitContext(/*value*/ true); + var exportClause; + var moduleSpecifier; + var assertClause; + var isTypeOnly = parseOptional(154 /* SyntaxKind.TypeKeyword */); + var namespaceExportPos = getNodePos(); + if (parseOptional(41 /* SyntaxKind.AsteriskToken */)) { + if (parseOptional(128 /* SyntaxKind.AsKeyword */)) { + exportClause = parseNamespaceExport(namespaceExportPos); + } + parseExpected(158 /* SyntaxKind.FromKeyword */); + moduleSpecifier = parseModuleSpecifier(); + } + else { + exportClause = parseNamedImportsOrExports(276 /* SyntaxKind.NamedExports */); + // It is not uncommon to accidentally omit the 'from' keyword. Additionally, in editing scenarios, + // the 'from' keyword can be parsed as a named export when the export clause is unterminated (i.e. `export { from "moduleName";`) + // If we don't have a 'from' keyword, see if we have a string literal such that ASI won't take effect. + if (token() === 158 /* SyntaxKind.FromKeyword */ || (token() === 10 /* SyntaxKind.StringLiteral */ && !scanner.hasPrecedingLineBreak())) { + parseExpected(158 /* SyntaxKind.FromKeyword */); + moduleSpecifier = parseModuleSpecifier(); + } + } + if (moduleSpecifier && token() === 130 /* SyntaxKind.AssertKeyword */ && !scanner.hasPrecedingLineBreak()) { + assertClause = parseAssertClause(); + } + parseSemicolon(); + setAwaitContext(savedAwaitContext); + var node = factory.createExportDeclaration(modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause); + node.illegalDecorators = decorators; + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + function parseExportAssignment(pos, hasJSDoc, decorators, modifiers) { + var savedAwaitContext = inAwaitContext(); + setAwaitContext(/*value*/ true); + var isExportEquals; + if (parseOptional(63 /* SyntaxKind.EqualsToken */)) { + isExportEquals = true; + } + else { + parseExpected(88 /* SyntaxKind.DefaultKeyword */); + } + var expression = parseAssignmentExpressionOrHigher(/*allowReturnTypeInArrowFunction*/ true); + parseSemicolon(); + setAwaitContext(savedAwaitContext); + var node = factory.createExportAssignment(modifiers, isExportEquals, expression); + node.illegalDecorators = decorators; + return withJSDoc(finishNode(node, pos), hasJSDoc); + } + var ParsingContext; + (function (ParsingContext) { + ParsingContext[ParsingContext["SourceElements"] = 0] = "SourceElements"; + ParsingContext[ParsingContext["BlockStatements"] = 1] = "BlockStatements"; + ParsingContext[ParsingContext["SwitchClauses"] = 2] = "SwitchClauses"; + ParsingContext[ParsingContext["SwitchClauseStatements"] = 3] = "SwitchClauseStatements"; + ParsingContext[ParsingContext["TypeMembers"] = 4] = "TypeMembers"; + ParsingContext[ParsingContext["ClassMembers"] = 5] = "ClassMembers"; + ParsingContext[ParsingContext["EnumMembers"] = 6] = "EnumMembers"; + ParsingContext[ParsingContext["HeritageClauseElement"] = 7] = "HeritageClauseElement"; + ParsingContext[ParsingContext["VariableDeclarations"] = 8] = "VariableDeclarations"; + ParsingContext[ParsingContext["ObjectBindingElements"] = 9] = "ObjectBindingElements"; + ParsingContext[ParsingContext["ArrayBindingElements"] = 10] = "ArrayBindingElements"; + ParsingContext[ParsingContext["ArgumentExpressions"] = 11] = "ArgumentExpressions"; + ParsingContext[ParsingContext["ObjectLiteralMembers"] = 12] = "ObjectLiteralMembers"; + ParsingContext[ParsingContext["JsxAttributes"] = 13] = "JsxAttributes"; + ParsingContext[ParsingContext["JsxChildren"] = 14] = "JsxChildren"; + ParsingContext[ParsingContext["ArrayLiteralMembers"] = 15] = "ArrayLiteralMembers"; + ParsingContext[ParsingContext["Parameters"] = 16] = "Parameters"; + ParsingContext[ParsingContext["JSDocParameters"] = 17] = "JSDocParameters"; + ParsingContext[ParsingContext["RestProperties"] = 18] = "RestProperties"; + ParsingContext[ParsingContext["TypeParameters"] = 19] = "TypeParameters"; + ParsingContext[ParsingContext["TypeArguments"] = 20] = "TypeArguments"; + ParsingContext[ParsingContext["TupleElementTypes"] = 21] = "TupleElementTypes"; + ParsingContext[ParsingContext["HeritageClauses"] = 22] = "HeritageClauses"; + ParsingContext[ParsingContext["ImportOrExportSpecifiers"] = 23] = "ImportOrExportSpecifiers"; + ParsingContext[ParsingContext["AssertEntries"] = 24] = "AssertEntries"; + ParsingContext[ParsingContext["Count"] = 25] = "Count"; // Number of parsing contexts + })(ParsingContext || (ParsingContext = {})); + var Tristate; + (function (Tristate) { + Tristate[Tristate["False"] = 0] = "False"; + Tristate[Tristate["True"] = 1] = "True"; + Tristate[Tristate["Unknown"] = 2] = "Unknown"; + })(Tristate || (Tristate = {})); + var JSDocParser; + (function (JSDocParser) { + function parseJSDocTypeExpressionForTests(content, start, length) { + initializeState("file.js", content, 99 /* ScriptTarget.Latest */, /*_syntaxCursor:*/ undefined, 1 /* ScriptKind.JS */); + scanner.setText(content, start, length); + currentToken = scanner.scan(); + var jsDocTypeExpression = parseJSDocTypeExpression(); + var sourceFile = createSourceFile("file.js", 99 /* ScriptTarget.Latest */, 1 /* ScriptKind.JS */, /*isDeclarationFile*/ false, [], factory.createToken(1 /* SyntaxKind.EndOfFileToken */), 0 /* NodeFlags.None */, ts.noop); + var diagnostics = ts.attachFileToDiagnostics(parseDiagnostics, sourceFile); + if (jsDocDiagnostics) { + sourceFile.jsDocDiagnostics = ts.attachFileToDiagnostics(jsDocDiagnostics, sourceFile); + } + clearState(); + return jsDocTypeExpression ? { jsDocTypeExpression: jsDocTypeExpression, diagnostics: diagnostics } : undefined; + } + JSDocParser.parseJSDocTypeExpressionForTests = parseJSDocTypeExpressionForTests; + // Parses out a JSDoc type expression. + function parseJSDocTypeExpression(mayOmitBraces) { + var pos = getNodePos(); + var hasBrace = (mayOmitBraces ? parseOptional : parseExpected)(18 /* SyntaxKind.OpenBraceToken */); + var type = doInsideOfContext(8388608 /* NodeFlags.JSDoc */, parseJSDocType); + if (!mayOmitBraces || hasBrace) { + parseExpectedJSDoc(19 /* SyntaxKind.CloseBraceToken */); + } + var result = factory.createJSDocTypeExpression(type); + fixupParentReferences(result); + return finishNode(result, pos); + } + JSDocParser.parseJSDocTypeExpression = parseJSDocTypeExpression; + function parseJSDocNameReference() { + var pos = getNodePos(); + var hasBrace = parseOptional(18 /* SyntaxKind.OpenBraceToken */); + var p2 = getNodePos(); + var entityName = parseEntityName(/* allowReservedWords*/ false); + while (token() === 80 /* SyntaxKind.PrivateIdentifier */) { + reScanHashToken(); // rescan #id as # id + nextTokenJSDoc(); // then skip the # + entityName = finishNode(factory.createJSDocMemberName(entityName, parseIdentifier()), p2); + } + if (hasBrace) { + parseExpectedJSDoc(19 /* SyntaxKind.CloseBraceToken */); + } + var result = factory.createJSDocNameReference(entityName); + fixupParentReferences(result); + return finishNode(result, pos); + } + JSDocParser.parseJSDocNameReference = parseJSDocNameReference; + function parseIsolatedJSDocComment(content, start, length) { + initializeState("", content, 99 /* ScriptTarget.Latest */, /*_syntaxCursor:*/ undefined, 1 /* ScriptKind.JS */); + var jsDoc = doInsideOfContext(8388608 /* NodeFlags.JSDoc */, function () { return parseJSDocCommentWorker(start, length); }); + var sourceFile = { languageVariant: 0 /* LanguageVariant.Standard */, text: content }; + var diagnostics = ts.attachFileToDiagnostics(parseDiagnostics, sourceFile); + clearState(); + return jsDoc ? { jsDoc: jsDoc, diagnostics: diagnostics } : undefined; + } + JSDocParser.parseIsolatedJSDocComment = parseIsolatedJSDocComment; + function parseJSDocComment(parent, start, length) { + var saveToken = currentToken; + var saveParseDiagnosticsLength = parseDiagnostics.length; + var saveParseErrorBeforeNextFinishedNode = parseErrorBeforeNextFinishedNode; + var comment = doInsideOfContext(8388608 /* NodeFlags.JSDoc */, function () { return parseJSDocCommentWorker(start, length); }); + ts.setParent(comment, parent); + if (contextFlags & 262144 /* NodeFlags.JavaScriptFile */) { + if (!jsDocDiagnostics) { + jsDocDiagnostics = []; + } + jsDocDiagnostics.push.apply(jsDocDiagnostics, parseDiagnostics); + } + currentToken = saveToken; + parseDiagnostics.length = saveParseDiagnosticsLength; + parseErrorBeforeNextFinishedNode = saveParseErrorBeforeNextFinishedNode; + return comment; + } + JSDocParser.parseJSDocComment = parseJSDocComment; + var JSDocState; + (function (JSDocState) { + JSDocState[JSDocState["BeginningOfLine"] = 0] = "BeginningOfLine"; + JSDocState[JSDocState["SawAsterisk"] = 1] = "SawAsterisk"; + JSDocState[JSDocState["SavingComments"] = 2] = "SavingComments"; + JSDocState[JSDocState["SavingBackticks"] = 3] = "SavingBackticks"; + })(JSDocState || (JSDocState = {})); + var PropertyLikeParse; + (function (PropertyLikeParse) { + PropertyLikeParse[PropertyLikeParse["Property"] = 1] = "Property"; + PropertyLikeParse[PropertyLikeParse["Parameter"] = 2] = "Parameter"; + PropertyLikeParse[PropertyLikeParse["CallbackParameter"] = 4] = "CallbackParameter"; + })(PropertyLikeParse || (PropertyLikeParse = {})); + function parseJSDocCommentWorker(start, length) { + if (start === void 0) { start = 0; } + var content = sourceText; + var end = length === undefined ? content.length : start + length; + length = end - start; + ts.Debug.assert(start >= 0); + ts.Debug.assert(start <= end); + ts.Debug.assert(end <= content.length); + // Check for /** (JSDoc opening part) + if (!isJSDocLikeText(content, start)) { + return undefined; + } + var tags; + var tagsPos; + var tagsEnd; + var linkEnd; + var commentsPos; + var comments = []; + var parts = []; + // + 3 for leading /**, - 5 in total for /** */ + return scanner.scanRange(start + 3, length - 5, function () { + // Initially we can parse out a tag. We also have seen a starting asterisk. + // This is so that /** * @type */ doesn't parse. + var state = 1 /* JSDocState.SawAsterisk */; + var margin; + // + 4 for leading '/** ' + // + 1 because the last index of \n is always one index before the first character in the line and coincidentally, if there is no \n before start, it is -1, which is also one index before the first character + var indent = start - (content.lastIndexOf("\n", start) + 1) + 4; + function pushComment(text) { + if (!margin) { + margin = indent; + } + comments.push(text); + indent += text.length; + } + nextTokenJSDoc(); + while (parseOptionalJsdoc(5 /* SyntaxKind.WhitespaceTrivia */)) + ; + if (parseOptionalJsdoc(4 /* SyntaxKind.NewLineTrivia */)) { + state = 0 /* JSDocState.BeginningOfLine */; + indent = 0; + } + loop: while (true) { + switch (token()) { + case 59 /* SyntaxKind.AtToken */: + if (state === 0 /* JSDocState.BeginningOfLine */ || state === 1 /* JSDocState.SawAsterisk */) { + removeTrailingWhitespace(comments); + if (!commentsPos) + commentsPos = getNodePos(); + addTag(parseTag(indent)); + // NOTE: According to usejsdoc.org, a tag goes to end of line, except the last tag. + // Real-world comments may break this rule, so "BeginningOfLine" will not be a real line beginning + // for malformed examples like `/** @param {string} x @returns {number} the length */` + state = 0 /* JSDocState.BeginningOfLine */; + margin = undefined; + } + else { + pushComment(scanner.getTokenText()); + } + break; + case 4 /* SyntaxKind.NewLineTrivia */: + comments.push(scanner.getTokenText()); + state = 0 /* JSDocState.BeginningOfLine */; + indent = 0; + break; + case 41 /* SyntaxKind.AsteriskToken */: + var asterisk = scanner.getTokenText(); + if (state === 1 /* JSDocState.SawAsterisk */ || state === 2 /* JSDocState.SavingComments */) { + // If we've already seen an asterisk, then we can no longer parse a tag on this line + state = 2 /* JSDocState.SavingComments */; + pushComment(asterisk); + } + else { + // Ignore the first asterisk on a line + state = 1 /* JSDocState.SawAsterisk */; + indent += asterisk.length; + } + break; + case 5 /* SyntaxKind.WhitespaceTrivia */: + // only collect whitespace if we're already saving comments or have just crossed the comment indent margin + var whitespace = scanner.getTokenText(); + if (state === 2 /* JSDocState.SavingComments */) { + comments.push(whitespace); + } + else if (margin !== undefined && indent + whitespace.length > margin) { + comments.push(whitespace.slice(margin - indent)); + } + indent += whitespace.length; + break; + case 1 /* SyntaxKind.EndOfFileToken */: + break loop; + case 18 /* SyntaxKind.OpenBraceToken */: + state = 2 /* JSDocState.SavingComments */; + var commentEnd = scanner.getStartPos(); + var linkStart = scanner.getTextPos() - 1; + var link = parseJSDocLink(linkStart); + if (link) { + if (!linkEnd) { + removeLeadingNewlines(comments); + } + parts.push(finishNode(factory.createJSDocText(comments.join("")), linkEnd !== null && linkEnd !== void 0 ? linkEnd : start, commentEnd)); + parts.push(link); + comments = []; + linkEnd = scanner.getTextPos(); + break; + } + // fallthrough if it's not a {@link sequence + default: + // Anything else is doc comment text. We just save it. Because it + // wasn't a tag, we can no longer parse a tag on this line until we hit the next + // line break. + state = 2 /* JSDocState.SavingComments */; + pushComment(scanner.getTokenText()); + break; + } + nextTokenJSDoc(); + } + removeTrailingWhitespace(comments); + if (parts.length && comments.length) { + parts.push(finishNode(factory.createJSDocText(comments.join("")), linkEnd !== null && linkEnd !== void 0 ? linkEnd : start, commentsPos)); + } + if (parts.length && tags) + ts.Debug.assertIsDefined(commentsPos, "having parsed tags implies that the end of the comment span should be set"); + var tagsArray = tags && createNodeArray(tags, tagsPos, tagsEnd); + return finishNode(factory.createJSDocComment(parts.length ? createNodeArray(parts, start, commentsPos) : comments.length ? comments.join("") : undefined, tagsArray), start, end); + }); + function removeLeadingNewlines(comments) { + while (comments.length && (comments[0] === "\n" || comments[0] === "\r")) { + comments.shift(); + } + } + function removeTrailingWhitespace(comments) { + while (comments.length && comments[comments.length - 1].trim() === "") { + comments.pop(); + } + } + function isNextNonwhitespaceTokenEndOfFile() { + // We must use infinite lookahead, as there could be any number of newlines :( + while (true) { + nextTokenJSDoc(); + if (token() === 1 /* SyntaxKind.EndOfFileToken */) { + return true; + } + if (!(token() === 5 /* SyntaxKind.WhitespaceTrivia */ || token() === 4 /* SyntaxKind.NewLineTrivia */)) { + return false; + } + } + } + function skipWhitespace() { + if (token() === 5 /* SyntaxKind.WhitespaceTrivia */ || token() === 4 /* SyntaxKind.NewLineTrivia */) { + if (lookAhead(isNextNonwhitespaceTokenEndOfFile)) { + return; // Don't skip whitespace prior to EoF (or end of comment) - that shouldn't be included in any node's range + } + } + while (token() === 5 /* SyntaxKind.WhitespaceTrivia */ || token() === 4 /* SyntaxKind.NewLineTrivia */) { + nextTokenJSDoc(); + } + } + function skipWhitespaceOrAsterisk() { + if (token() === 5 /* SyntaxKind.WhitespaceTrivia */ || token() === 4 /* SyntaxKind.NewLineTrivia */) { + if (lookAhead(isNextNonwhitespaceTokenEndOfFile)) { + return ""; // Don't skip whitespace prior to EoF (or end of comment) - that shouldn't be included in any node's range + } + } + var precedingLineBreak = scanner.hasPrecedingLineBreak(); + var seenLineBreak = false; + var indentText = ""; + while ((precedingLineBreak && token() === 41 /* SyntaxKind.AsteriskToken */) || token() === 5 /* SyntaxKind.WhitespaceTrivia */ || token() === 4 /* SyntaxKind.NewLineTrivia */) { + indentText += scanner.getTokenText(); + if (token() === 4 /* SyntaxKind.NewLineTrivia */) { + precedingLineBreak = true; + seenLineBreak = true; + indentText = ""; + } + else if (token() === 41 /* SyntaxKind.AsteriskToken */) { + precedingLineBreak = false; + } + nextTokenJSDoc(); + } + return seenLineBreak ? indentText : ""; + } + function parseTag(margin) { + ts.Debug.assert(token() === 59 /* SyntaxKind.AtToken */); + var start = scanner.getTokenPos(); + nextTokenJSDoc(); + var tagName = parseJSDocIdentifierName(/*message*/ undefined); + var indentText = skipWhitespaceOrAsterisk(); + var tag; + switch (tagName.escapedText) { + case "author": + tag = parseAuthorTag(start, tagName, margin, indentText); + break; + case "implements": + tag = parseImplementsTag(start, tagName, margin, indentText); + break; + case "augments": + case "extends": + tag = parseAugmentsTag(start, tagName, margin, indentText); + break; + case "class": + case "constructor": + tag = parseSimpleTag(start, factory.createJSDocClassTag, tagName, margin, indentText); + break; + case "public": + tag = parseSimpleTag(start, factory.createJSDocPublicTag, tagName, margin, indentText); + break; + case "private": + tag = parseSimpleTag(start, factory.createJSDocPrivateTag, tagName, margin, indentText); + break; + case "protected": + tag = parseSimpleTag(start, factory.createJSDocProtectedTag, tagName, margin, indentText); + break; + case "readonly": + tag = parseSimpleTag(start, factory.createJSDocReadonlyTag, tagName, margin, indentText); + break; + case "override": + tag = parseSimpleTag(start, factory.createJSDocOverrideTag, tagName, margin, indentText); + break; + case "deprecated": + hasDeprecatedTag = true; + tag = parseSimpleTag(start, factory.createJSDocDeprecatedTag, tagName, margin, indentText); + break; + case "this": + tag = parseThisTag(start, tagName, margin, indentText); + break; + case "enum": + tag = parseEnumTag(start, tagName, margin, indentText); + break; + case "arg": + case "argument": + case "param": + return parseParameterOrPropertyTag(start, tagName, 2 /* PropertyLikeParse.Parameter */, margin); + case "return": + case "returns": + tag = parseReturnTag(start, tagName, margin, indentText); + break; + case "template": + tag = parseTemplateTag(start, tagName, margin, indentText); + break; + case "type": + tag = parseTypeTag(start, tagName, margin, indentText); + break; + case "typedef": + tag = parseTypedefTag(start, tagName, margin, indentText); + break; + case "callback": + tag = parseCallbackTag(start, tagName, margin, indentText); + break; + case "see": + tag = parseSeeTag(start, tagName, margin, indentText); + break; + default: + tag = parseUnknownTag(start, tagName, margin, indentText); + break; + } + return tag; + } + function parseTrailingTagComments(pos, end, margin, indentText) { + // some tags, like typedef and callback, have already parsed their comments earlier + if (!indentText) { + margin += end - pos; + } + return parseTagComments(margin, indentText.slice(margin)); + } + function parseTagComments(indent, initialMargin) { + var commentsPos = getNodePos(); + var comments = []; + var parts = []; + var linkEnd; + var state = 0 /* JSDocState.BeginningOfLine */; + var previousWhitespace = true; + var margin; + function pushComment(text) { + if (!margin) { + margin = indent; + } + comments.push(text); + indent += text.length; + } + if (initialMargin !== undefined) { + // jump straight to saving comments if there is some initial indentation + if (initialMargin !== "") { + pushComment(initialMargin); + } + state = 1 /* JSDocState.SawAsterisk */; + } + var tok = token(); + loop: while (true) { + switch (tok) { + case 4 /* SyntaxKind.NewLineTrivia */: + state = 0 /* JSDocState.BeginningOfLine */; + // don't use pushComment here because we want to keep the margin unchanged + comments.push(scanner.getTokenText()); + indent = 0; + break; + case 59 /* SyntaxKind.AtToken */: + if (state === 3 /* JSDocState.SavingBackticks */ + || state === 2 /* JSDocState.SavingComments */ && (!previousWhitespace || lookAhead(isNextJSDocTokenWhitespace))) { + // @ doesn't start a new tag inside ``, and inside a comment, only after whitespace or not before whitespace + comments.push(scanner.getTokenText()); + break; + } + scanner.setTextPos(scanner.getTextPos() - 1); + // falls through + case 1 /* SyntaxKind.EndOfFileToken */: + // Done + break loop; + case 5 /* SyntaxKind.WhitespaceTrivia */: + if (state === 2 /* JSDocState.SavingComments */ || state === 3 /* JSDocState.SavingBackticks */) { + pushComment(scanner.getTokenText()); + } + else { + var whitespace = scanner.getTokenText(); + // if the whitespace crosses the margin, take only the whitespace that passes the margin + if (margin !== undefined && indent + whitespace.length > margin) { + comments.push(whitespace.slice(margin - indent)); + } + indent += whitespace.length; + } + break; + case 18 /* SyntaxKind.OpenBraceToken */: + state = 2 /* JSDocState.SavingComments */; + var commentEnd = scanner.getStartPos(); + var linkStart = scanner.getTextPos() - 1; + var link = parseJSDocLink(linkStart); + if (link) { + parts.push(finishNode(factory.createJSDocText(comments.join("")), linkEnd !== null && linkEnd !== void 0 ? linkEnd : commentsPos, commentEnd)); + parts.push(link); + comments = []; + linkEnd = scanner.getTextPos(); + } + else { + pushComment(scanner.getTokenText()); + } + break; + case 61 /* SyntaxKind.BacktickToken */: + if (state === 3 /* JSDocState.SavingBackticks */) { + state = 2 /* JSDocState.SavingComments */; + } + else { + state = 3 /* JSDocState.SavingBackticks */; + } + pushComment(scanner.getTokenText()); + break; + case 41 /* SyntaxKind.AsteriskToken */: + if (state === 0 /* JSDocState.BeginningOfLine */) { + // leading asterisks start recording on the *next* (non-whitespace) token + state = 1 /* JSDocState.SawAsterisk */; + indent += 1; + break; + } + // record the * as a comment + // falls through + default: + if (state !== 3 /* JSDocState.SavingBackticks */) { + state = 2 /* JSDocState.SavingComments */; // leading identifiers start recording as well + } + pushComment(scanner.getTokenText()); + break; + } + previousWhitespace = token() === 5 /* SyntaxKind.WhitespaceTrivia */; + tok = nextTokenJSDoc(); + } + removeLeadingNewlines(comments); + removeTrailingWhitespace(comments); + if (parts.length) { + if (comments.length) { + parts.push(finishNode(factory.createJSDocText(comments.join("")), linkEnd !== null && linkEnd !== void 0 ? linkEnd : commentsPos)); + } + return createNodeArray(parts, commentsPos, scanner.getTextPos()); + } + else if (comments.length) { + return comments.join(""); + } + } + function isNextJSDocTokenWhitespace() { + var next = nextTokenJSDoc(); + return next === 5 /* SyntaxKind.WhitespaceTrivia */ || next === 4 /* SyntaxKind.NewLineTrivia */; + } + function parseJSDocLink(start) { + var linkType = tryParse(parseJSDocLinkPrefix); + if (!linkType) { + return undefined; + } + nextTokenJSDoc(); // start at token after link, then skip any whitespace + skipWhitespace(); + // parseEntityName logs an error for non-identifier, so create a MissingNode ourselves to avoid the error + var p2 = getNodePos(); + var name = ts.tokenIsIdentifierOrKeyword(token()) + ? parseEntityName(/*allowReservedWords*/ true) + : undefined; + if (name) { + while (token() === 80 /* SyntaxKind.PrivateIdentifier */) { + reScanHashToken(); // rescan #id as # id + nextTokenJSDoc(); // then skip the # + name = finishNode(factory.createJSDocMemberName(name, parseIdentifier()), p2); + } + } + var text = []; + while (token() !== 19 /* SyntaxKind.CloseBraceToken */ && token() !== 4 /* SyntaxKind.NewLineTrivia */ && token() !== 1 /* SyntaxKind.EndOfFileToken */) { + text.push(scanner.getTokenText()); + nextTokenJSDoc(); + } + var create = linkType === "link" ? factory.createJSDocLink + : linkType === "linkcode" ? factory.createJSDocLinkCode + : factory.createJSDocLinkPlain; + return finishNode(create(name, text.join("")), start, scanner.getTextPos()); + } + function parseJSDocLinkPrefix() { + skipWhitespaceOrAsterisk(); + if (token() === 18 /* SyntaxKind.OpenBraceToken */ + && nextTokenJSDoc() === 59 /* SyntaxKind.AtToken */ + && ts.tokenIsIdentifierOrKeyword(nextTokenJSDoc())) { + var kind = scanner.getTokenValue(); + if (isJSDocLinkTag(kind)) + return kind; + } + } + function isJSDocLinkTag(kind) { + return kind === "link" || kind === "linkcode" || kind === "linkplain"; + } + function parseUnknownTag(start, tagName, indent, indentText) { + return finishNode(factory.createJSDocUnknownTag(tagName, parseTrailingTagComments(start, getNodePos(), indent, indentText)), start); + } + function addTag(tag) { + if (!tag) { + return; + } + if (!tags) { + tags = [tag]; + tagsPos = tag.pos; + } + else { + tags.push(tag); + } + tagsEnd = tag.end; + } + function tryParseTypeExpression() { + skipWhitespaceOrAsterisk(); + return token() === 18 /* SyntaxKind.OpenBraceToken */ ? parseJSDocTypeExpression() : undefined; + } + function parseBracketNameInPropertyAndParamTag() { + // Looking for something like '[foo]', 'foo', '[foo.bar]' or 'foo.bar' + var isBracketed = parseOptionalJsdoc(22 /* SyntaxKind.OpenBracketToken */); + if (isBracketed) { + skipWhitespace(); + } + // a markdown-quoted name: `arg` is not legal jsdoc, but occurs in the wild + var isBackquoted = parseOptionalJsdoc(61 /* SyntaxKind.BacktickToken */); + var name = parseJSDocEntityName(); + if (isBackquoted) { + parseExpectedTokenJSDoc(61 /* SyntaxKind.BacktickToken */); + } + if (isBracketed) { + skipWhitespace(); + // May have an optional default, e.g. '[foo = 42]' + if (parseOptionalToken(63 /* SyntaxKind.EqualsToken */)) { + parseExpression(); + } + parseExpected(23 /* SyntaxKind.CloseBracketToken */); + } + return { name: name, isBracketed: isBracketed }; + } + function isObjectOrObjectArrayTypeReference(node) { + switch (node.kind) { + case 149 /* SyntaxKind.ObjectKeyword */: + return true; + case 185 /* SyntaxKind.ArrayType */: + return isObjectOrObjectArrayTypeReference(node.elementType); + default: + return ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName) && node.typeName.escapedText === "Object" && !node.typeArguments; + } + } + function parseParameterOrPropertyTag(start, tagName, target, indent) { + var typeExpression = tryParseTypeExpression(); + var isNameFirst = !typeExpression; + skipWhitespaceOrAsterisk(); + var _a = parseBracketNameInPropertyAndParamTag(), name = _a.name, isBracketed = _a.isBracketed; + var indentText = skipWhitespaceOrAsterisk(); + if (isNameFirst && !lookAhead(parseJSDocLinkPrefix)) { + typeExpression = tryParseTypeExpression(); + } + var comment = parseTrailingTagComments(start, getNodePos(), indent, indentText); + var nestedTypeLiteral = target !== 4 /* PropertyLikeParse.CallbackParameter */ && parseNestedTypeLiteral(typeExpression, name, target, indent); + if (nestedTypeLiteral) { + typeExpression = nestedTypeLiteral; + isNameFirst = true; + } + var result = target === 1 /* PropertyLikeParse.Property */ + ? factory.createJSDocPropertyTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment) + : factory.createJSDocParameterTag(tagName, name, isBracketed, typeExpression, isNameFirst, comment); + return finishNode(result, start); + } + function parseNestedTypeLiteral(typeExpression, name, target, indent) { + if (typeExpression && isObjectOrObjectArrayTypeReference(typeExpression.type)) { + var pos = getNodePos(); + var child = void 0; + var children = void 0; + while (child = tryParse(function () { return parseChildParameterOrPropertyTag(target, indent, name); })) { + if (child.kind === 343 /* SyntaxKind.JSDocParameterTag */ || child.kind === 350 /* SyntaxKind.JSDocPropertyTag */) { + children = ts.append(children, child); + } + } + if (children) { + var literal = finishNode(factory.createJSDocTypeLiteral(children, typeExpression.type.kind === 185 /* SyntaxKind.ArrayType */), pos); + return finishNode(factory.createJSDocTypeExpression(literal), pos); + } + } + } + function parseReturnTag(start, tagName, indent, indentText) { + if (ts.some(tags, ts.isJSDocReturnTag)) { + parseErrorAt(tagName.pos, scanner.getTokenPos(), ts.Diagnostics._0_tag_already_specified, tagName.escapedText); + } + var typeExpression = tryParseTypeExpression(); + return finishNode(factory.createJSDocReturnTag(tagName, typeExpression, parseTrailingTagComments(start, getNodePos(), indent, indentText)), start); + } + function parseTypeTag(start, tagName, indent, indentText) { + if (ts.some(tags, ts.isJSDocTypeTag)) { + parseErrorAt(tagName.pos, scanner.getTokenPos(), ts.Diagnostics._0_tag_already_specified, tagName.escapedText); + } + var typeExpression = parseJSDocTypeExpression(/*mayOmitBraces*/ true); + var comments = indent !== undefined && indentText !== undefined ? parseTrailingTagComments(start, getNodePos(), indent, indentText) : undefined; + return finishNode(factory.createJSDocTypeTag(tagName, typeExpression, comments), start); + } + function parseSeeTag(start, tagName, indent, indentText) { + var isMarkdownOrJSDocLink = token() === 22 /* SyntaxKind.OpenBracketToken */ + || lookAhead(function () { return nextTokenJSDoc() === 59 /* SyntaxKind.AtToken */ && ts.tokenIsIdentifierOrKeyword(nextTokenJSDoc()) && isJSDocLinkTag(scanner.getTokenValue()); }); + var nameExpression = isMarkdownOrJSDocLink ? undefined : parseJSDocNameReference(); + var comments = indent !== undefined && indentText !== undefined ? parseTrailingTagComments(start, getNodePos(), indent, indentText) : undefined; + return finishNode(factory.createJSDocSeeTag(tagName, nameExpression, comments), start); + } + function parseAuthorTag(start, tagName, indent, indentText) { + var commentStart = getNodePos(); + var textOnly = parseAuthorNameAndEmail(); + var commentEnd = scanner.getStartPos(); + var comments = parseTrailingTagComments(start, commentEnd, indent, indentText); + if (!comments) { + commentEnd = scanner.getStartPos(); + } + var allParts = typeof comments !== "string" + ? createNodeArray(ts.concatenate([finishNode(textOnly, commentStart, commentEnd)], comments), commentStart) // cast away readonly + : textOnly.text + comments; + return finishNode(factory.createJSDocAuthorTag(tagName, allParts), start); + } + function parseAuthorNameAndEmail() { + var comments = []; + var inEmail = false; + var token = scanner.getToken(); + while (token !== 1 /* SyntaxKind.EndOfFileToken */ && token !== 4 /* SyntaxKind.NewLineTrivia */) { + if (token === 29 /* SyntaxKind.LessThanToken */) { + inEmail = true; + } + else if (token === 59 /* SyntaxKind.AtToken */ && !inEmail) { + break; + } + else if (token === 31 /* SyntaxKind.GreaterThanToken */ && inEmail) { + comments.push(scanner.getTokenText()); + scanner.setTextPos(scanner.getTokenPos() + 1); + break; + } + comments.push(scanner.getTokenText()); + token = nextTokenJSDoc(); + } + return factory.createJSDocText(comments.join("")); + } + function parseImplementsTag(start, tagName, margin, indentText) { + var className = parseExpressionWithTypeArgumentsForAugments(); + return finishNode(factory.createJSDocImplementsTag(tagName, className, parseTrailingTagComments(start, getNodePos(), margin, indentText)), start); + } + function parseAugmentsTag(start, tagName, margin, indentText) { + var className = parseExpressionWithTypeArgumentsForAugments(); + return finishNode(factory.createJSDocAugmentsTag(tagName, className, parseTrailingTagComments(start, getNodePos(), margin, indentText)), start); + } + function parseExpressionWithTypeArgumentsForAugments() { + var usedBrace = parseOptional(18 /* SyntaxKind.OpenBraceToken */); + var pos = getNodePos(); + var expression = parsePropertyAccessEntityNameExpression(); + var typeArguments = tryParseTypeArguments(); + var node = factory.createExpressionWithTypeArguments(expression, typeArguments); + var res = finishNode(node, pos); + if (usedBrace) { + parseExpected(19 /* SyntaxKind.CloseBraceToken */); + } + return res; + } + function parsePropertyAccessEntityNameExpression() { + var pos = getNodePos(); + var node = parseJSDocIdentifierName(); + while (parseOptional(24 /* SyntaxKind.DotToken */)) { + var name = parseJSDocIdentifierName(); + node = finishNode(factory.createPropertyAccessExpression(node, name), pos); + } + return node; + } + function parseSimpleTag(start, createTag, tagName, margin, indentText) { + return finishNode(createTag(tagName, parseTrailingTagComments(start, getNodePos(), margin, indentText)), start); + } + function parseThisTag(start, tagName, margin, indentText) { + var typeExpression = parseJSDocTypeExpression(/*mayOmitBraces*/ true); + skipWhitespace(); + return finishNode(factory.createJSDocThisTag(tagName, typeExpression, parseTrailingTagComments(start, getNodePos(), margin, indentText)), start); + } + function parseEnumTag(start, tagName, margin, indentText) { + var typeExpression = parseJSDocTypeExpression(/*mayOmitBraces*/ true); + skipWhitespace(); + return finishNode(factory.createJSDocEnumTag(tagName, typeExpression, parseTrailingTagComments(start, getNodePos(), margin, indentText)), start); + } + function parseTypedefTag(start, tagName, indent, indentText) { + var _a; + var typeExpression = tryParseTypeExpression(); + skipWhitespaceOrAsterisk(); + var fullName = parseJSDocTypeNameWithNamespace(); + skipWhitespace(); + var comment = parseTagComments(indent); + var end; + if (!typeExpression || isObjectOrObjectArrayTypeReference(typeExpression.type)) { + var child = void 0; + var childTypeTag = void 0; + var jsDocPropertyTags = void 0; + var hasChildren = false; + while (child = tryParse(function () { return parseChildPropertyTag(indent); })) { + hasChildren = true; + if (child.kind === 346 /* SyntaxKind.JSDocTypeTag */) { + if (childTypeTag) { + var lastError = parseErrorAtCurrentToken(ts.Diagnostics.A_JSDoc_typedef_comment_may_not_contain_multiple_type_tags); + if (lastError) { + ts.addRelatedInfo(lastError, ts.createDetachedDiagnostic(fileName, 0, 0, ts.Diagnostics.The_tag_was_first_specified_here)); + } + break; + } + else { + childTypeTag = child; + } + } + else { + jsDocPropertyTags = ts.append(jsDocPropertyTags, child); + } + } + if (hasChildren) { + var isArrayType = typeExpression && typeExpression.type.kind === 185 /* SyntaxKind.ArrayType */; + var jsdocTypeLiteral = factory.createJSDocTypeLiteral(jsDocPropertyTags, isArrayType); + typeExpression = childTypeTag && childTypeTag.typeExpression && !isObjectOrObjectArrayTypeReference(childTypeTag.typeExpression.type) ? + childTypeTag.typeExpression : + finishNode(jsdocTypeLiteral, start); + end = typeExpression.end; + } + } + // Only include the characters between the name end and the next token if a comment was actually parsed out - otherwise it's just whitespace + end = end || comment !== undefined ? + getNodePos() : + ((_a = fullName !== null && fullName !== void 0 ? fullName : typeExpression) !== null && _a !== void 0 ? _a : tagName).end; + if (!comment) { + comment = parseTrailingTagComments(start, end, indent, indentText); + } + var typedefTag = factory.createJSDocTypedefTag(tagName, typeExpression, fullName, comment); + return finishNode(typedefTag, start, end); + } + function parseJSDocTypeNameWithNamespace(nested) { + var pos = scanner.getTokenPos(); + if (!ts.tokenIsIdentifierOrKeyword(token())) { + return undefined; + } + var typeNameOrNamespaceName = parseJSDocIdentifierName(); + if (parseOptional(24 /* SyntaxKind.DotToken */)) { + var body = parseJSDocTypeNameWithNamespace(/*nested*/ true); + var jsDocNamespaceNode = factory.createModuleDeclaration( + /*modifiers*/ undefined, typeNameOrNamespaceName, body, nested ? 4 /* NodeFlags.NestedNamespace */ : undefined); + return finishNode(jsDocNamespaceNode, pos); + } + if (nested) { + typeNameOrNamespaceName.isInJSDocNamespace = true; + } + return typeNameOrNamespaceName; + } + function parseCallbackTagParameters(indent) { + var pos = getNodePos(); + var child; + var parameters; + while (child = tryParse(function () { return parseChildParameterOrPropertyTag(4 /* PropertyLikeParse.CallbackParameter */, indent); })) { + parameters = ts.append(parameters, child); + } + return createNodeArray(parameters || [], pos); + } + function parseCallbackTag(start, tagName, indent, indentText) { + var fullName = parseJSDocTypeNameWithNamespace(); + skipWhitespace(); + var comment = parseTagComments(indent); + var parameters = parseCallbackTagParameters(indent); + var returnTag = tryParse(function () { + if (parseOptionalJsdoc(59 /* SyntaxKind.AtToken */)) { + var tag = parseTag(indent); + if (tag && tag.kind === 344 /* SyntaxKind.JSDocReturnTag */) { + return tag; + } + } + }); + var typeExpression = finishNode(factory.createJSDocSignature(/*typeParameters*/ undefined, parameters, returnTag), start); + if (!comment) { + comment = parseTrailingTagComments(start, getNodePos(), indent, indentText); + } + var end = comment !== undefined ? getNodePos() : typeExpression.end; + return finishNode(factory.createJSDocCallbackTag(tagName, typeExpression, fullName, comment), start, end); + } + function escapedTextsEqual(a, b) { + while (!ts.isIdentifier(a) || !ts.isIdentifier(b)) { + if (!ts.isIdentifier(a) && !ts.isIdentifier(b) && a.right.escapedText === b.right.escapedText) { + a = a.left; + b = b.left; + } + else { + return false; + } + } + return a.escapedText === b.escapedText; + } + function parseChildPropertyTag(indent) { + return parseChildParameterOrPropertyTag(1 /* PropertyLikeParse.Property */, indent); + } + function parseChildParameterOrPropertyTag(target, indent, name) { + var canParseTag = true; + var seenAsterisk = false; + while (true) { + switch (nextTokenJSDoc()) { + case 59 /* SyntaxKind.AtToken */: + if (canParseTag) { + var child = tryParseChildTag(target, indent); + if (child && (child.kind === 343 /* SyntaxKind.JSDocParameterTag */ || child.kind === 350 /* SyntaxKind.JSDocPropertyTag */) && + target !== 4 /* PropertyLikeParse.CallbackParameter */ && + name && (ts.isIdentifier(child.name) || !escapedTextsEqual(name, child.name.left))) { + return false; + } + return child; + } + seenAsterisk = false; + break; + case 4 /* SyntaxKind.NewLineTrivia */: + canParseTag = true; + seenAsterisk = false; + break; + case 41 /* SyntaxKind.AsteriskToken */: + if (seenAsterisk) { + canParseTag = false; + } + seenAsterisk = true; + break; + case 79 /* SyntaxKind.Identifier */: + canParseTag = false; + break; + case 1 /* SyntaxKind.EndOfFileToken */: + return false; + } + } + } + function tryParseChildTag(target, indent) { + ts.Debug.assert(token() === 59 /* SyntaxKind.AtToken */); + var start = scanner.getStartPos(); + nextTokenJSDoc(); + var tagName = parseJSDocIdentifierName(); + skipWhitespace(); + var t; + switch (tagName.escapedText) { + case "type": + return target === 1 /* PropertyLikeParse.Property */ && parseTypeTag(start, tagName); + case "prop": + case "property": + t = 1 /* PropertyLikeParse.Property */; + break; + case "arg": + case "argument": + case "param": + t = 2 /* PropertyLikeParse.Parameter */ | 4 /* PropertyLikeParse.CallbackParameter */; + break; + default: + return false; + } + if (!(target & t)) { + return false; + } + return parseParameterOrPropertyTag(start, tagName, target, indent); + } + function parseTemplateTagTypeParameter() { + var typeParameterPos = getNodePos(); + var isBracketed = parseOptionalJsdoc(22 /* SyntaxKind.OpenBracketToken */); + if (isBracketed) { + skipWhitespace(); + } + var name = parseJSDocIdentifierName(ts.Diagnostics.Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces); + var defaultType; + if (isBracketed) { + skipWhitespace(); + parseExpected(63 /* SyntaxKind.EqualsToken */); + defaultType = doInsideOfContext(8388608 /* NodeFlags.JSDoc */, parseJSDocType); + parseExpected(23 /* SyntaxKind.CloseBracketToken */); + } + if (ts.nodeIsMissing(name)) { + return undefined; + } + return finishNode(factory.createTypeParameterDeclaration(/*modifiers*/ undefined, name, /*constraint*/ undefined, defaultType), typeParameterPos); + } + function parseTemplateTagTypeParameters() { + var pos = getNodePos(); + var typeParameters = []; + do { + skipWhitespace(); + var node = parseTemplateTagTypeParameter(); + if (node !== undefined) { + typeParameters.push(node); + } + skipWhitespaceOrAsterisk(); + } while (parseOptionalJsdoc(27 /* SyntaxKind.CommaToken */)); + return createNodeArray(typeParameters, pos); + } + function parseTemplateTag(start, tagName, indent, indentText) { + // The template tag looks like one of the following: + // @template T,U,V + // @template {Constraint} T + // + // According to the [closure docs](https://github.com/google/closure-compiler/wiki/Generic-Types#multiple-bounded-template-types): + // > Multiple bounded generics cannot be declared on the same line. For the sake of clarity, if multiple templates share the same + // > type bound they must be declared on separate lines. + // + // TODO: Determine whether we should enforce this in the checker. + // TODO: Consider moving the `constraint` to the first type parameter as we could then remove `getEffectiveConstraintOfTypeParameter`. + // TODO: Consider only parsing a single type parameter if there is a constraint. + var constraint = token() === 18 /* SyntaxKind.OpenBraceToken */ ? parseJSDocTypeExpression() : undefined; + var typeParameters = parseTemplateTagTypeParameters(); + return finishNode(factory.createJSDocTemplateTag(tagName, constraint, typeParameters, parseTrailingTagComments(start, getNodePos(), indent, indentText)), start); + } + function parseOptionalJsdoc(t) { + if (token() === t) { + nextTokenJSDoc(); + return true; + } + return false; + } + function parseJSDocEntityName() { + var entity = parseJSDocIdentifierName(); + if (parseOptional(22 /* SyntaxKind.OpenBracketToken */)) { + parseExpected(23 /* SyntaxKind.CloseBracketToken */); + // Note that y[] is accepted as an entity name, but the postfix brackets are not saved for checking. + // Technically usejsdoc.org requires them for specifying a property of a type equivalent to Array<{ x: ...}> + // but it's not worth it to enforce that restriction. + } + while (parseOptional(24 /* SyntaxKind.DotToken */)) { + var name = parseJSDocIdentifierName(); + if (parseOptional(22 /* SyntaxKind.OpenBracketToken */)) { + parseExpected(23 /* SyntaxKind.CloseBracketToken */); + } + entity = createQualifiedName(entity, name); + } + return entity; + } + function parseJSDocIdentifierName(message) { + if (!ts.tokenIsIdentifierOrKeyword(token())) { + return createMissingNode(79 /* SyntaxKind.Identifier */, /*reportAtCurrentPosition*/ !message, message || ts.Diagnostics.Identifier_expected); + } + identifierCount++; + var pos = scanner.getTokenPos(); + var end = scanner.getTextPos(); + var originalKeywordKind = token(); + var text = internIdentifier(scanner.getTokenValue()); + var result = finishNode(factory.createIdentifier(text, /*typeArguments*/ undefined, originalKeywordKind), pos, end); + nextTokenJSDoc(); + return result; + } + } + })(JSDocParser = Parser.JSDocParser || (Parser.JSDocParser = {})); + })(Parser || (Parser = {})); + var IncrementalParser; + (function (IncrementalParser) { + function updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks) { + aggressiveChecks = aggressiveChecks || ts.Debug.shouldAssert(2 /* AssertionLevel.Aggressive */); + checkChangeRange(sourceFile, newText, textChangeRange, aggressiveChecks); + if (ts.textChangeRangeIsUnchanged(textChangeRange)) { + // if the text didn't change, then we can just return our current source file as-is. + return sourceFile; + } + if (sourceFile.statements.length === 0) { + // If we don't have any statements in the current source file, then there's no real + // way to incrementally parse. So just do a full parse instead. + return Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, /*syntaxCursor*/ undefined, /*setParentNodes*/ true, sourceFile.scriptKind, sourceFile.setExternalModuleIndicator); + } + // Make sure we're not trying to incrementally update a source file more than once. Once + // we do an update the original source file is considered unusable from that point onwards. + // + // This is because we do incremental parsing in-place. i.e. we take nodes from the old + // tree and give them new positions and parents. From that point on, trusting the old + // tree at all is not possible as far too much of it may violate invariants. + var incrementalSourceFile = sourceFile; + ts.Debug.assert(!incrementalSourceFile.hasBeenIncrementallyParsed); + incrementalSourceFile.hasBeenIncrementallyParsed = true; + Parser.fixupParentReferences(incrementalSourceFile); + var oldText = sourceFile.text; + var syntaxCursor = createSyntaxCursor(sourceFile); + // Make the actual change larger so that we know to reparse anything whose lookahead + // might have intersected the change. + var changeRange = extendToAffectedRange(sourceFile, textChangeRange); + checkChangeRange(sourceFile, newText, changeRange, aggressiveChecks); + // Ensure that extending the affected range only moved the start of the change range + // earlier in the file. + ts.Debug.assert(changeRange.span.start <= textChangeRange.span.start); + ts.Debug.assert(ts.textSpanEnd(changeRange.span) === ts.textSpanEnd(textChangeRange.span)); + ts.Debug.assert(ts.textSpanEnd(ts.textChangeRangeNewSpan(changeRange)) === ts.textSpanEnd(ts.textChangeRangeNewSpan(textChangeRange))); + // The is the amount the nodes after the edit range need to be adjusted. It can be + // positive (if the edit added characters), negative (if the edit deleted characters) + // or zero (if this was a pure overwrite with nothing added/removed). + var delta = ts.textChangeRangeNewSpan(changeRange).length - changeRange.span.length; + // If we added or removed characters during the edit, then we need to go and adjust all + // the nodes after the edit. Those nodes may move forward (if we inserted chars) or they + // may move backward (if we deleted chars). + // + // Doing this helps us out in two ways. First, it means that any nodes/tokens we want + // to reuse are already at the appropriate position in the new text. That way when we + // reuse them, we don't have to figure out if they need to be adjusted. Second, it makes + // it very easy to determine if we can reuse a node. If the node's position is at where + // we are in the text, then we can reuse it. Otherwise we can't. If the node's position + // is ahead of us, then we'll need to rescan tokens. If the node's position is behind + // us, then we'll need to skip it or crumble it as appropriate + // + // We will also adjust the positions of nodes that intersect the change range as well. + // By doing this, we ensure that all the positions in the old tree are consistent, not + // just the positions of nodes entirely before/after the change range. By being + // consistent, we can then easily map from positions to nodes in the old tree easily. + // + // Also, mark any syntax elements that intersect the changed span. We know, up front, + // that we cannot reuse these elements. + updateTokenPositionsAndMarkElements(incrementalSourceFile, changeRange.span.start, ts.textSpanEnd(changeRange.span), ts.textSpanEnd(ts.textChangeRangeNewSpan(changeRange)), delta, oldText, newText, aggressiveChecks); + // Now that we've set up our internal incremental state just proceed and parse the + // source file in the normal fashion. When possible the parser will retrieve and + // reuse nodes from the old tree. + // + // Note: passing in 'true' for setNodeParents is very important. When incrementally + // parsing, we will be reusing nodes from the old tree, and placing it into new + // parents. If we don't set the parents now, we'll end up with an observably + // inconsistent tree. Setting the parents on the new tree should be very fast. We + // will immediately bail out of walking any subtrees when we can see that their parents + // are already correct. + var result = Parser.parseSourceFile(sourceFile.fileName, newText, sourceFile.languageVersion, syntaxCursor, /*setParentNodes*/ true, sourceFile.scriptKind, sourceFile.setExternalModuleIndicator); + result.commentDirectives = getNewCommentDirectives(sourceFile.commentDirectives, result.commentDirectives, changeRange.span.start, ts.textSpanEnd(changeRange.span), delta, oldText, newText, aggressiveChecks); + result.impliedNodeFormat = sourceFile.impliedNodeFormat; + return result; + } + IncrementalParser.updateSourceFile = updateSourceFile; + function getNewCommentDirectives(oldDirectives, newDirectives, changeStart, changeRangeOldEnd, delta, oldText, newText, aggressiveChecks) { + if (!oldDirectives) + return newDirectives; + var commentDirectives; + var addedNewlyScannedDirectives = false; + for (var _i = 0, oldDirectives_1 = oldDirectives; _i < oldDirectives_1.length; _i++) { + var directive = oldDirectives_1[_i]; + var range = directive.range, type = directive.type; + // Range before the change + if (range.end < changeStart) { + commentDirectives = ts.append(commentDirectives, directive); + } + else if (range.pos > changeRangeOldEnd) { + addNewlyScannedDirectives(); + // Node is entirely past the change range. We need to move both its pos and + // end, forward or backward appropriately. + var updatedDirective = { + range: { pos: range.pos + delta, end: range.end + delta }, + type: type + }; + commentDirectives = ts.append(commentDirectives, updatedDirective); + if (aggressiveChecks) { + ts.Debug.assert(oldText.substring(range.pos, range.end) === newText.substring(updatedDirective.range.pos, updatedDirective.range.end)); + } + } + // Ignore ranges that fall in change range + } + addNewlyScannedDirectives(); + return commentDirectives; + function addNewlyScannedDirectives() { + if (addedNewlyScannedDirectives) + return; + addedNewlyScannedDirectives = true; + if (!commentDirectives) { + commentDirectives = newDirectives; + } + else if (newDirectives) { + commentDirectives.push.apply(commentDirectives, newDirectives); + } + } + } + function moveElementEntirelyPastChangeRange(element, isArray, delta, oldText, newText, aggressiveChecks) { + if (isArray) { + visitArray(element); + } + else { + visitNode(element); + } + return; + function visitNode(node) { + var text = ""; + if (aggressiveChecks && shouldCheckNode(node)) { + text = oldText.substring(node.pos, node.end); + } + // Ditch any existing LS children we may have created. This way we can avoid + // moving them forward. + if (node._children) { + node._children = undefined; + } + ts.setTextRangePosEnd(node, node.pos + delta, node.end + delta); + if (aggressiveChecks && shouldCheckNode(node)) { + ts.Debug.assert(text === newText.substring(node.pos, node.end)); + } + forEachChild(node, visitNode, visitArray); + if (ts.hasJSDocNodes(node)) { + for (var _i = 0, _a = node.jsDoc; _i < _a.length; _i++) { + var jsDocComment = _a[_i]; + visitNode(jsDocComment); + } + } + checkNodePositions(node, aggressiveChecks); + } + function visitArray(array) { + array._children = undefined; + ts.setTextRangePosEnd(array, array.pos + delta, array.end + delta); + for (var _i = 0, array_9 = array; _i < array_9.length; _i++) { + var node = array_9[_i]; + visitNode(node); + } + } + } + function shouldCheckNode(node) { + switch (node.kind) { + case 10 /* SyntaxKind.StringLiteral */: + case 8 /* SyntaxKind.NumericLiteral */: + case 79 /* SyntaxKind.Identifier */: + return true; + } + return false; + } + function adjustIntersectingElement(element, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta) { + ts.Debug.assert(element.end >= changeStart, "Adjusting an element that was entirely before the change range"); + ts.Debug.assert(element.pos <= changeRangeOldEnd, "Adjusting an element that was entirely after the change range"); + ts.Debug.assert(element.pos <= element.end); + // We have an element that intersects the change range in some way. It may have its + // start, or its end (or both) in the changed range. We want to adjust any part + // that intersects such that the final tree is in a consistent state. i.e. all + // children have spans within the span of their parent, and all siblings are ordered + // properly. + // We may need to update both the 'pos' and the 'end' of the element. + // If the 'pos' is before the start of the change, then we don't need to touch it. + // If it isn't, then the 'pos' must be inside the change. How we update it will + // depend if delta is positive or negative. If delta is positive then we have + // something like: + // + // -------------------AAA----------------- + // -------------------BBBCCCCCCC----------------- + // + // In this case, we consider any node that started in the change range to still be + // starting at the same position. + // + // however, if the delta is negative, then we instead have something like this: + // + // -------------------XXXYYYYYYY----------------- + // -------------------ZZZ----------------- + // + // In this case, any element that started in the 'X' range will keep its position. + // However any element that started after that will have their pos adjusted to be + // at the end of the new range. i.e. any node that started in the 'Y' range will + // be adjusted to have their start at the end of the 'Z' range. + // + // The element will keep its position if possible. Or Move backward to the new-end + // if it's in the 'Y' range. + var pos = Math.min(element.pos, changeRangeNewEnd); + // If the 'end' is after the change range, then we always adjust it by the delta + // amount. However, if the end is in the change range, then how we adjust it + // will depend on if delta is positive or negative. If delta is positive then we + // have something like: + // + // -------------------AAA----------------- + // -------------------BBBCCCCCCC----------------- + // + // In this case, we consider any node that ended inside the change range to keep its + // end position. + // + // however, if the delta is negative, then we instead have something like this: + // + // -------------------XXXYYYYYYY----------------- + // -------------------ZZZ----------------- + // + // In this case, any element that ended in the 'X' range will keep its position. + // However any element that ended after that will have their pos adjusted to be + // at the end of the new range. i.e. any node that ended in the 'Y' range will + // be adjusted to have their end at the end of the 'Z' range. + var end = element.end >= changeRangeOldEnd ? + // Element ends after the change range. Always adjust the end pos. + element.end + delta : + // Element ends in the change range. The element will keep its position if + // possible. Or Move backward to the new-end if it's in the 'Y' range. + Math.min(element.end, changeRangeNewEnd); + ts.Debug.assert(pos <= end); + if (element.parent) { + ts.Debug.assertGreaterThanOrEqual(pos, element.parent.pos); + ts.Debug.assertLessThanOrEqual(end, element.parent.end); + } + ts.setTextRangePosEnd(element, pos, end); + } + function checkNodePositions(node, aggressiveChecks) { + if (aggressiveChecks) { + var pos_3 = node.pos; + var visitNode_1 = function (child) { + ts.Debug.assert(child.pos >= pos_3); + pos_3 = child.end; + }; + if (ts.hasJSDocNodes(node)) { + for (var _i = 0, _a = node.jsDoc; _i < _a.length; _i++) { + var jsDocComment = _a[_i]; + visitNode_1(jsDocComment); + } + } + forEachChild(node, visitNode_1); + ts.Debug.assert(pos_3 <= node.end); + } + } + function updateTokenPositionsAndMarkElements(sourceFile, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta, oldText, newText, aggressiveChecks) { + visitNode(sourceFile); + return; + function visitNode(child) { + ts.Debug.assert(child.pos <= child.end); + if (child.pos > changeRangeOldEnd) { + // Node is entirely past the change range. We need to move both its pos and + // end, forward or backward appropriately. + moveElementEntirelyPastChangeRange(child, /*isArray*/ false, delta, oldText, newText, aggressiveChecks); + return; + } + // Check if the element intersects the change range. If it does, then it is not + // reusable. Also, we'll need to recurse to see what constituent portions we may + // be able to use. + var fullEnd = child.end; + if (fullEnd >= changeStart) { + child.intersectsChange = true; + child._children = undefined; + // Adjust the pos or end (or both) of the intersecting element accordingly. + adjustIntersectingElement(child, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta); + forEachChild(child, visitNode, visitArray); + if (ts.hasJSDocNodes(child)) { + for (var _i = 0, _a = child.jsDoc; _i < _a.length; _i++) { + var jsDocComment = _a[_i]; + visitNode(jsDocComment); + } + } + checkNodePositions(child, aggressiveChecks); + return; + } + // Otherwise, the node is entirely before the change range. No need to do anything with it. + ts.Debug.assert(fullEnd < changeStart); + } + function visitArray(array) { + ts.Debug.assert(array.pos <= array.end); + if (array.pos > changeRangeOldEnd) { + // Array is entirely after the change range. We need to move it, and move any of + // its children. + moveElementEntirelyPastChangeRange(array, /*isArray*/ true, delta, oldText, newText, aggressiveChecks); + return; + } + // Check if the element intersects the change range. If it does, then it is not + // reusable. Also, we'll need to recurse to see what constituent portions we may + // be able to use. + var fullEnd = array.end; + if (fullEnd >= changeStart) { + array.intersectsChange = true; + array._children = undefined; + // Adjust the pos or end (or both) of the intersecting array accordingly. + adjustIntersectingElement(array, changeStart, changeRangeOldEnd, changeRangeNewEnd, delta); + for (var _i = 0, array_10 = array; _i < array_10.length; _i++) { + var node = array_10[_i]; + visitNode(node); + } + return; + } + // Otherwise, the array is entirely before the change range. No need to do anything with it. + ts.Debug.assert(fullEnd < changeStart); + } + } + function extendToAffectedRange(sourceFile, changeRange) { + // Consider the following code: + // void foo() { /; } + // + // If the text changes with an insertion of / just before the semicolon then we end up with: + // void foo() { //; } + // + // If we were to just use the changeRange a is, then we would not rescan the { token + // (as it does not intersect the actual original change range). Because an edit may + // change the token touching it, we actually need to look back *at least* one token so + // that the prior token sees that change. + var maxLookahead = 1; + var start = changeRange.span.start; + // the first iteration aligns us with the change start. subsequent iteration move us to + // the left by maxLookahead tokens. We only need to do this as long as we're not at the + // start of the tree. + for (var i = 0; start > 0 && i <= maxLookahead; i++) { + var nearestNode = findNearestNodeStartingBeforeOrAtPosition(sourceFile, start); + ts.Debug.assert(nearestNode.pos <= start); + var position = nearestNode.pos; + start = Math.max(0, position - 1); + } + var finalSpan = ts.createTextSpanFromBounds(start, ts.textSpanEnd(changeRange.span)); + var finalLength = changeRange.newLength + (changeRange.span.start - start); + return ts.createTextChangeRange(finalSpan, finalLength); + } + function findNearestNodeStartingBeforeOrAtPosition(sourceFile, position) { + var bestResult = sourceFile; + var lastNodeEntirelyBeforePosition; + forEachChild(sourceFile, visit); + if (lastNodeEntirelyBeforePosition) { + var lastChildOfLastEntireNodeBeforePosition = getLastDescendant(lastNodeEntirelyBeforePosition); + if (lastChildOfLastEntireNodeBeforePosition.pos > bestResult.pos) { + bestResult = lastChildOfLastEntireNodeBeforePosition; + } + } + return bestResult; + function getLastDescendant(node) { + while (true) { + var lastChild = ts.getLastChild(node); + if (lastChild) { + node = lastChild; + } + else { + return node; + } + } + } + function visit(child) { + if (ts.nodeIsMissing(child)) { + // Missing nodes are effectively invisible to us. We never even consider them + // When trying to find the nearest node before us. + return; + } + // If the child intersects this position, then this node is currently the nearest + // node that starts before the position. + if (child.pos <= position) { + if (child.pos >= bestResult.pos) { + // This node starts before the position, and is closer to the position than + // the previous best node we found. It is now the new best node. + bestResult = child; + } + // Now, the node may overlap the position, or it may end entirely before the + // position. If it overlaps with the position, then either it, or one of its + // children must be the nearest node before the position. So we can just + // recurse into this child to see if we can find something better. + if (position < child.end) { + // The nearest node is either this child, or one of the children inside + // of it. We've already marked this child as the best so far. Recurse + // in case one of the children is better. + forEachChild(child, visit); + // Once we look at the children of this node, then there's no need to + // continue any further. + return true; + } + else { + ts.Debug.assert(child.end <= position); + // The child ends entirely before this position. Say you have the following + // (where $ is the position) + // + // ? $ : <...> <...> + // + // We would want to find the nearest preceding node in "complex expr 2". + // To support that, we keep track of this node, and once we're done searching + // for a best node, we recurse down this node to see if we can find a good + // result in it. + // + // This approach allows us to quickly skip over nodes that are entirely + // before the position, while still allowing us to find any nodes in the + // last one that might be what we want. + lastNodeEntirelyBeforePosition = child; + } + } + else { + ts.Debug.assert(child.pos > position); + // We're now at a node that is entirely past the position we're searching for. + // This node (and all following nodes) could never contribute to the result, + // so just skip them by returning 'true' here. + return true; + } + } + } + function checkChangeRange(sourceFile, newText, textChangeRange, aggressiveChecks) { + var oldText = sourceFile.text; + if (textChangeRange) { + ts.Debug.assert((oldText.length - textChangeRange.span.length + textChangeRange.newLength) === newText.length); + if (aggressiveChecks || ts.Debug.shouldAssert(3 /* AssertionLevel.VeryAggressive */)) { + var oldTextPrefix = oldText.substr(0, textChangeRange.span.start); + var newTextPrefix = newText.substr(0, textChangeRange.span.start); + ts.Debug.assert(oldTextPrefix === newTextPrefix); + var oldTextSuffix = oldText.substring(ts.textSpanEnd(textChangeRange.span), oldText.length); + var newTextSuffix = newText.substring(ts.textSpanEnd(ts.textChangeRangeNewSpan(textChangeRange)), newText.length); + ts.Debug.assert(oldTextSuffix === newTextSuffix); + } + } + } + function createSyntaxCursor(sourceFile) { + var currentArray = sourceFile.statements; + var currentArrayIndex = 0; + ts.Debug.assert(currentArrayIndex < currentArray.length); + var current = currentArray[currentArrayIndex]; + var lastQueriedPosition = -1 /* InvalidPosition.Value */; + return { + currentNode: function (position) { + // Only compute the current node if the position is different than the last time + // we were asked. The parser commonly asks for the node at the same position + // twice. Once to know if can read an appropriate list element at a certain point, + // and then to actually read and consume the node. + if (position !== lastQueriedPosition) { + // Much of the time the parser will need the very next node in the array that + // we just returned a node from.So just simply check for that case and move + // forward in the array instead of searching for the node again. + if (current && current.end === position && currentArrayIndex < (currentArray.length - 1)) { + currentArrayIndex++; + current = currentArray[currentArrayIndex]; + } + // If we don't have a node, or the node we have isn't in the right position, + // then try to find a viable node at the position requested. + if (!current || current.pos !== position) { + findHighestListElementThatStartsAtPosition(position); + } + } + // Cache this query so that we don't do any extra work if the parser calls back + // into us. Note: this is very common as the parser will make pairs of calls like + // 'isListElement -> parseListElement'. If we were unable to find a node when + // called with 'isListElement', we don't want to redo the work when parseListElement + // is called immediately after. + lastQueriedPosition = position; + // Either we don'd have a node, or we have a node at the position being asked for. + ts.Debug.assert(!current || current.pos === position); + return current; + } + }; + // Finds the highest element in the tree we can find that starts at the provided position. + // The element must be a direct child of some node list in the tree. This way after we + // return it, we can easily return its next sibling in the list. + function findHighestListElementThatStartsAtPosition(position) { + // Clear out any cached state about the last node we found. + currentArray = undefined; + currentArrayIndex = -1 /* InvalidPosition.Value */; + current = undefined; + // Recurse into the source file to find the highest node at this position. + forEachChild(sourceFile, visitNode, visitArray); + return; + function visitNode(node) { + if (position >= node.pos && position < node.end) { + // Position was within this node. Keep searching deeper to find the node. + forEachChild(node, visitNode, visitArray); + // don't proceed any further in the search. + return true; + } + // position wasn't in this node, have to keep searching. + return false; + } + function visitArray(array) { + if (position >= array.pos && position < array.end) { + // position was in this array. Search through this array to see if we find a + // viable element. + for (var i = 0; i < array.length; i++) { + var child = array[i]; + if (child) { + if (child.pos === position) { + // Found the right node. We're done. + currentArray = array; + currentArrayIndex = i; + current = child; + return true; + } + else { + if (child.pos < position && position < child.end) { + // Position in somewhere within this child. Search in it and + // stop searching in this array. + forEachChild(child, visitNode, visitArray); + return true; + } + } + } + } + } + // position wasn't in this array, have to keep searching. + return false; + } + } + } + IncrementalParser.createSyntaxCursor = createSyntaxCursor; + var InvalidPosition; + (function (InvalidPosition) { + InvalidPosition[InvalidPosition["Value"] = -1] = "Value"; + })(InvalidPosition || (InvalidPosition = {})); + })(IncrementalParser || (IncrementalParser = {})); + /** @internal */ + function isDeclarationFileName(fileName) { + return ts.fileExtensionIsOneOf(fileName, ts.supportedDeclarationExtensions); + } + ts.isDeclarationFileName = isDeclarationFileName; + function parseResolutionMode(mode, pos, end, reportDiagnostic) { + if (!mode) { + return undefined; + } + if (mode === "import") { + return ts.ModuleKind.ESNext; + } + if (mode === "require") { + return ts.ModuleKind.CommonJS; + } + reportDiagnostic(pos, end - pos, ts.Diagnostics.resolution_mode_should_be_either_require_or_import); + return undefined; + } + /*@internal*/ + function processCommentPragmas(context, sourceText) { + var pragmas = []; + for (var _i = 0, _a = ts.getLeadingCommentRanges(sourceText, 0) || ts.emptyArray; _i < _a.length; _i++) { + var range = _a[_i]; + var comment = sourceText.substring(range.pos, range.end); + extractPragmas(pragmas, range, comment); + } + context.pragmas = new ts.Map(); + for (var _b = 0, pragmas_1 = pragmas; _b < pragmas_1.length; _b++) { + var pragma = pragmas_1[_b]; + if (context.pragmas.has(pragma.name)) { + var currentValue = context.pragmas.get(pragma.name); + if (currentValue instanceof Array) { + currentValue.push(pragma.args); + } + else { + context.pragmas.set(pragma.name, [currentValue, pragma.args]); + } + continue; + } + context.pragmas.set(pragma.name, pragma.args); + } + } + ts.processCommentPragmas = processCommentPragmas; + /*@internal*/ + function processPragmasIntoFields(context, reportDiagnostic) { + context.checkJsDirective = undefined; + context.referencedFiles = []; + context.typeReferenceDirectives = []; + context.libReferenceDirectives = []; + context.amdDependencies = []; + context.hasNoDefaultLib = false; + context.pragmas.forEach(function (entryOrList, key) { + // TODO: The below should be strongly type-guarded and not need casts/explicit annotations, since entryOrList is related to + // key and key is constrained to a union; but it's not (see GH#21483 for at least partial fix) :( + switch (key) { + case "reference": { + var referencedFiles_1 = context.referencedFiles; + var typeReferenceDirectives_1 = context.typeReferenceDirectives; + var libReferenceDirectives_1 = context.libReferenceDirectives; + ts.forEach(ts.toArray(entryOrList), function (arg) { + var _a = arg.arguments, types = _a.types, lib = _a.lib, path = _a.path, res = _a["resolution-mode"]; + if (arg.arguments["no-default-lib"]) { + context.hasNoDefaultLib = true; + } + else if (types) { + var parsed = parseResolutionMode(res, types.pos, types.end, reportDiagnostic); + typeReferenceDirectives_1.push(__assign({ pos: types.pos, end: types.end, fileName: types.value }, (parsed ? { resolutionMode: parsed } : {}))); + } + else if (lib) { + libReferenceDirectives_1.push({ pos: lib.pos, end: lib.end, fileName: lib.value }); + } + else if (path) { + referencedFiles_1.push({ pos: path.pos, end: path.end, fileName: path.value }); + } + else { + reportDiagnostic(arg.range.pos, arg.range.end - arg.range.pos, ts.Diagnostics.Invalid_reference_directive_syntax); + } + }); + break; + } + case "amd-dependency": { + context.amdDependencies = ts.map(ts.toArray(entryOrList), function (x) { return ({ name: x.arguments.name, path: x.arguments.path }); }); + break; + } + case "amd-module": { + if (entryOrList instanceof Array) { + for (var _i = 0, entryOrList_1 = entryOrList; _i < entryOrList_1.length; _i++) { + var entry = entryOrList_1[_i]; + if (context.moduleName) { + // TODO: It's probably fine to issue this diagnostic on all instances of the pragma + reportDiagnostic(entry.range.pos, entry.range.end - entry.range.pos, ts.Diagnostics.An_AMD_module_cannot_have_multiple_name_assignments); + } + context.moduleName = entry.arguments.name; + } + } + else { + context.moduleName = entryOrList.arguments.name; + } + break; + } + case "ts-nocheck": + case "ts-check": { + // _last_ of either nocheck or check in a file is the "winner" + ts.forEach(ts.toArray(entryOrList), function (entry) { + if (!context.checkJsDirective || entry.range.pos > context.checkJsDirective.pos) { + context.checkJsDirective = { + enabled: key === "ts-check", + end: entry.range.end, + pos: entry.range.pos + }; + } + }); + break; + } + case "jsx": + case "jsxfrag": + case "jsximportsource": + case "jsxruntime": + return; // Accessed directly + default: ts.Debug.fail("Unhandled pragma kind"); // Can this be made into an assertNever in the future? + } + }); + } + ts.processPragmasIntoFields = processPragmasIntoFields; + var namedArgRegExCache = new ts.Map(); + function getNamedArgRegEx(name) { + if (namedArgRegExCache.has(name)) { + return namedArgRegExCache.get(name); + } + var result = new RegExp("(\\s".concat(name, "\\s*=\\s*)(?:(?:'([^']*)')|(?:\"([^\"]*)\"))"), "im"); + namedArgRegExCache.set(name, result); + return result; + } + var tripleSlashXMLCommentStartRegEx = /^\/\/\/\s*<(\S+)\s.*?\/>/im; + var singleLinePragmaRegEx = /^\/\/\/?\s*@(\S+)\s*(.*)\s*$/im; + function extractPragmas(pragmas, range, text) { + var tripleSlash = range.kind === 2 /* SyntaxKind.SingleLineCommentTrivia */ && tripleSlashXMLCommentStartRegEx.exec(text); + if (tripleSlash) { + var name = tripleSlash[1].toLowerCase(); // Technically unsafe cast, but we do it so the below check to make it safe typechecks + var pragma = ts.commentPragmas[name]; + if (!pragma || !(pragma.kind & 1 /* PragmaKindFlags.TripleSlashXML */)) { + return; + } + if (pragma.args) { + var argument = {}; + for (var _i = 0, _a = pragma.args; _i < _a.length; _i++) { + var arg = _a[_i]; + var matcher = getNamedArgRegEx(arg.name); + var matchResult = matcher.exec(text); + if (!matchResult && !arg.optional) { + return; // Missing required argument, don't parse + } + else if (matchResult) { + var value = matchResult[2] || matchResult[3]; + if (arg.captureSpan) { + var startPos = range.pos + matchResult.index + matchResult[1].length + 1; + argument[arg.name] = { + value: value, + pos: startPos, + end: startPos + value.length + }; + } + else { + argument[arg.name] = value; + } + } + } + pragmas.push({ name: name, args: { arguments: argument, range: range } }); + } + else { + pragmas.push({ name: name, args: { arguments: {}, range: range } }); + } + return; + } + var singleLine = range.kind === 2 /* SyntaxKind.SingleLineCommentTrivia */ && singleLinePragmaRegEx.exec(text); + if (singleLine) { + return addPragmaForMatch(pragmas, range, 2 /* PragmaKindFlags.SingleLine */, singleLine); + } + if (range.kind === 3 /* SyntaxKind.MultiLineCommentTrivia */) { + var multiLinePragmaRegEx = /@(\S+)(\s+.*)?$/gim; // Defined inline since it uses the "g" flag, which keeps a persistent index (for iterating) + var multiLineMatch = void 0; + while (multiLineMatch = multiLinePragmaRegEx.exec(text)) { + addPragmaForMatch(pragmas, range, 4 /* PragmaKindFlags.MultiLine */, multiLineMatch); + } + } + } + function addPragmaForMatch(pragmas, range, kind, match) { + if (!match) + return; + var name = match[1].toLowerCase(); // Technically unsafe cast, but we do it so they below check to make it safe typechecks + var pragma = ts.commentPragmas[name]; + if (!pragma || !(pragma.kind & kind)) { + return; + } + var args = match[2]; // Split on spaces and match up positionally with definition + var argument = getNamedPragmaArguments(pragma, args); + if (argument === "fail") + return; // Missing required argument, fail to parse it + pragmas.push({ name: name, args: { arguments: argument, range: range } }); + return; + } + function getNamedPragmaArguments(pragma, text) { + if (!text) + return {}; + if (!pragma.args) + return {}; + var args = ts.trimString(text).split(/\s+/); + var argMap = {}; + for (var i = 0; i < pragma.args.length; i++) { + var argument = pragma.args[i]; + if (!args[i] && !argument.optional) { + return "fail"; + } + if (argument.captureSpan) { + return ts.Debug.fail("Capture spans not yet implemented for non-xml pragmas"); + } + argMap[argument.name] = args[i]; + } + return argMap; + } + /** @internal */ + function tagNamesAreEquivalent(lhs, rhs) { + if (lhs.kind !== rhs.kind) { + return false; + } + if (lhs.kind === 79 /* SyntaxKind.Identifier */) { + return lhs.escapedText === rhs.escapedText; + } + if (lhs.kind === 108 /* SyntaxKind.ThisKeyword */) { + return true; + } + // If we are at this statement then we must have PropertyAccessExpression and because tag name in Jsx element can only + // take forms of JsxTagNameExpression which includes an identifier, "this" expression, or another propertyAccessExpression + // it is safe to case the expression property as such. See parseJsxElementName for how we parse tag name in Jsx element + return lhs.name.escapedText === rhs.name.escapedText && + tagNamesAreEquivalent(lhs.expression, rhs.expression); + } + ts.tagNamesAreEquivalent = tagNamesAreEquivalent; +})(ts || (ts = {})); +var ts; +(function (ts) { + /* @internal */ + ts.compileOnSaveCommandLineOption = { + name: "compileOnSave", + type: "boolean", + defaultValueDescription: false, + }; + var jsxOptionMap = new ts.Map(ts.getEntries({ + "preserve": 1 /* JsxEmit.Preserve */, + "react-native": 3 /* JsxEmit.ReactNative */, + "react": 2 /* JsxEmit.React */, + "react-jsx": 4 /* JsxEmit.ReactJSX */, + "react-jsxdev": 5 /* JsxEmit.ReactJSXDev */, + })); + /* @internal */ + ts.inverseJsxOptionMap = new ts.Map(ts.arrayFrom(ts.mapIterator(jsxOptionMap.entries(), function (_a) { + var key = _a[0], value = _a[1]; + return ["" + value, key]; + }))); + // NOTE: The order here is important to default lib ordering as entries will have the same + // order in the generated program (see `getDefaultLibPriority` in program.ts). This + // order also affects overload resolution when a type declared in one lib is + // augmented in another lib. + var libEntries = [ + // JavaScript only + ["es5", "lib.es5.d.ts"], + ["es6", "lib.es2015.d.ts"], + ["es2015", "lib.es2015.d.ts"], + ["es7", "lib.es2016.d.ts"], + ["es2016", "lib.es2016.d.ts"], + ["es2017", "lib.es2017.d.ts"], + ["es2018", "lib.es2018.d.ts"], + ["es2019", "lib.es2019.d.ts"], + ["es2020", "lib.es2020.d.ts"], + ["es2021", "lib.es2021.d.ts"], + ["es2022", "lib.es2022.d.ts"], + ["esnext", "lib.esnext.d.ts"], + // Host only + ["dom", "lib.dom.d.ts"], + ["dom.iterable", "lib.dom.iterable.d.ts"], + ["webworker", "lib.webworker.d.ts"], + ["webworker.importscripts", "lib.webworker.importscripts.d.ts"], + ["webworker.iterable", "lib.webworker.iterable.d.ts"], + ["scripthost", "lib.scripthost.d.ts"], + // ES2015 Or ESNext By-feature options + ["es2015.core", "lib.es2015.core.d.ts"], + ["es2015.collection", "lib.es2015.collection.d.ts"], + ["es2015.generator", "lib.es2015.generator.d.ts"], + ["es2015.iterable", "lib.es2015.iterable.d.ts"], + ["es2015.promise", "lib.es2015.promise.d.ts"], + ["es2015.proxy", "lib.es2015.proxy.d.ts"], + ["es2015.reflect", "lib.es2015.reflect.d.ts"], + ["es2015.symbol", "lib.es2015.symbol.d.ts"], + ["es2015.symbol.wellknown", "lib.es2015.symbol.wellknown.d.ts"], + ["es2016.array.include", "lib.es2016.array.include.d.ts"], + ["es2017.object", "lib.es2017.object.d.ts"], + ["es2017.sharedmemory", "lib.es2017.sharedmemory.d.ts"], + ["es2017.string", "lib.es2017.string.d.ts"], + ["es2017.intl", "lib.es2017.intl.d.ts"], + ["es2017.typedarrays", "lib.es2017.typedarrays.d.ts"], + ["es2018.asyncgenerator", "lib.es2018.asyncgenerator.d.ts"], + ["es2018.asynciterable", "lib.es2018.asynciterable.d.ts"], + ["es2018.intl", "lib.es2018.intl.d.ts"], + ["es2018.promise", "lib.es2018.promise.d.ts"], + ["es2018.regexp", "lib.es2018.regexp.d.ts"], + ["es2019.array", "lib.es2019.array.d.ts"], + ["es2019.object", "lib.es2019.object.d.ts"], + ["es2019.string", "lib.es2019.string.d.ts"], + ["es2019.symbol", "lib.es2019.symbol.d.ts"], + ["es2019.intl", "lib.es2019.intl.d.ts"], + ["es2020.bigint", "lib.es2020.bigint.d.ts"], + ["es2020.date", "lib.es2020.date.d.ts"], + ["es2020.promise", "lib.es2020.promise.d.ts"], + ["es2020.sharedmemory", "lib.es2020.sharedmemory.d.ts"], + ["es2020.string", "lib.es2020.string.d.ts"], + ["es2020.symbol.wellknown", "lib.es2020.symbol.wellknown.d.ts"], + ["es2020.intl", "lib.es2020.intl.d.ts"], + ["es2020.number", "lib.es2020.number.d.ts"], + ["es2021.promise", "lib.es2021.promise.d.ts"], + ["es2021.string", "lib.es2021.string.d.ts"], + ["es2021.weakref", "lib.es2021.weakref.d.ts"], + ["es2021.intl", "lib.es2021.intl.d.ts"], + ["es2022.array", "lib.es2022.array.d.ts"], + ["es2022.error", "lib.es2022.error.d.ts"], + ["es2022.intl", "lib.es2022.intl.d.ts"], + ["es2022.object", "lib.es2022.object.d.ts"], + ["es2022.sharedmemory", "lib.es2022.sharedmemory.d.ts"], + ["es2022.string", "lib.es2022.string.d.ts"], + ["esnext.array", "lib.es2022.array.d.ts"], + ["esnext.symbol", "lib.es2019.symbol.d.ts"], + ["esnext.asynciterable", "lib.es2018.asynciterable.d.ts"], + ["esnext.intl", "lib.esnext.intl.d.ts"], + ["esnext.bigint", "lib.es2020.bigint.d.ts"], + ["esnext.string", "lib.es2022.string.d.ts"], + ["esnext.promise", "lib.es2021.promise.d.ts"], + ["esnext.weakref", "lib.es2021.weakref.d.ts"] + ]; + /** + * An array of supported "lib" reference file names used to determine the order for inclusion + * when referenced, as well as for spelling suggestions. This ensures the correct ordering for + * overload resolution when a type declared in one lib is extended by another. + */ + /* @internal */ + ts.libs = libEntries.map(function (entry) { return entry[0]; }); + /** + * A map of lib names to lib files. This map is used both for parsing the "lib" command line + * option as well as for resolving lib reference directives. + */ + /* @internal */ + ts.libMap = new ts.Map(libEntries); + // Watch related options + /* @internal */ + ts.optionsForWatch = [ + { + name: "watchFile", + type: new ts.Map(ts.getEntries({ + fixedpollinginterval: ts.WatchFileKind.FixedPollingInterval, + prioritypollinginterval: ts.WatchFileKind.PriorityPollingInterval, + dynamicprioritypolling: ts.WatchFileKind.DynamicPriorityPolling, + fixedchunksizepolling: ts.WatchFileKind.FixedChunkSizePolling, + usefsevents: ts.WatchFileKind.UseFsEvents, + usefseventsonparentdirectory: ts.WatchFileKind.UseFsEventsOnParentDirectory, + })), + category: ts.Diagnostics.Watch_and_Build_Modes, + description: ts.Diagnostics.Specify_how_the_TypeScript_watch_mode_works, + defaultValueDescription: ts.WatchFileKind.UseFsEvents, + }, + { + name: "watchDirectory", + type: new ts.Map(ts.getEntries({ + usefsevents: ts.WatchDirectoryKind.UseFsEvents, + fixedpollinginterval: ts.WatchDirectoryKind.FixedPollingInterval, + dynamicprioritypolling: ts.WatchDirectoryKind.DynamicPriorityPolling, + fixedchunksizepolling: ts.WatchDirectoryKind.FixedChunkSizePolling, + })), + category: ts.Diagnostics.Watch_and_Build_Modes, + description: ts.Diagnostics.Specify_how_directories_are_watched_on_systems_that_lack_recursive_file_watching_functionality, + defaultValueDescription: ts.WatchDirectoryKind.UseFsEvents, + }, + { + name: "fallbackPolling", + type: new ts.Map(ts.getEntries({ + fixedinterval: ts.PollingWatchKind.FixedInterval, + priorityinterval: ts.PollingWatchKind.PriorityInterval, + dynamicpriority: ts.PollingWatchKind.DynamicPriority, + fixedchunksize: ts.PollingWatchKind.FixedChunkSize, + })), + category: ts.Diagnostics.Watch_and_Build_Modes, + description: ts.Diagnostics.Specify_what_approach_the_watcher_should_use_if_the_system_runs_out_of_native_file_watchers, + defaultValueDescription: ts.PollingWatchKind.PriorityInterval, + }, + { + name: "synchronousWatchDirectory", + type: "boolean", + category: ts.Diagnostics.Watch_and_Build_Modes, + description: ts.Diagnostics.Synchronously_call_callbacks_and_update_the_state_of_directory_watchers_on_platforms_that_don_t_support_recursive_watching_natively, + defaultValueDescription: false, + }, + { + name: "excludeDirectories", + type: "list", + element: { + name: "excludeDirectory", + type: "string", + isFilePath: true, + extraValidation: specToDiagnostic + }, + category: ts.Diagnostics.Watch_and_Build_Modes, + description: ts.Diagnostics.Remove_a_list_of_directories_from_the_watch_process, + }, + { + name: "excludeFiles", + type: "list", + element: { + name: "excludeFile", + type: "string", + isFilePath: true, + extraValidation: specToDiagnostic + }, + category: ts.Diagnostics.Watch_and_Build_Modes, + description: ts.Diagnostics.Remove_a_list_of_files_from_the_watch_mode_s_processing, + }, + ]; + /* @internal */ + ts.commonOptionsWithBuild = [ + { + name: "help", + shortName: "h", + type: "boolean", + showInSimplifiedHelpView: true, + isCommandLineOnly: true, + category: ts.Diagnostics.Command_line_Options, + description: ts.Diagnostics.Print_this_message, + defaultValueDescription: false, + }, + { + name: "help", + shortName: "?", + type: "boolean", + isCommandLineOnly: true, + category: ts.Diagnostics.Command_line_Options, + defaultValueDescription: false, + }, + { + name: "watch", + shortName: "w", + type: "boolean", + showInSimplifiedHelpView: true, + isCommandLineOnly: true, + category: ts.Diagnostics.Command_line_Options, + description: ts.Diagnostics.Watch_input_files, + defaultValueDescription: false, + }, + { + name: "preserveWatchOutput", + type: "boolean", + showInSimplifiedHelpView: false, + category: ts.Diagnostics.Output_Formatting, + description: ts.Diagnostics.Disable_wiping_the_console_in_watch_mode, + defaultValueDescription: false, + }, + { + name: "listFiles", + type: "boolean", + category: ts.Diagnostics.Compiler_Diagnostics, + description: ts.Diagnostics.Print_all_of_the_files_read_during_the_compilation, + defaultValueDescription: false, + }, + { + name: "explainFiles", + type: "boolean", + category: ts.Diagnostics.Compiler_Diagnostics, + description: ts.Diagnostics.Print_files_read_during_the_compilation_including_why_it_was_included, + defaultValueDescription: false, + }, + { + name: "listEmittedFiles", + type: "boolean", + category: ts.Diagnostics.Compiler_Diagnostics, + description: ts.Diagnostics.Print_the_names_of_emitted_files_after_a_compilation, + defaultValueDescription: false, + }, + { + name: "pretty", + type: "boolean", + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Output_Formatting, + description: ts.Diagnostics.Enable_color_and_formatting_in_TypeScript_s_output_to_make_compiler_errors_easier_to_read, + defaultValueDescription: true, + }, + { + name: "traceResolution", + type: "boolean", + category: ts.Diagnostics.Compiler_Diagnostics, + description: ts.Diagnostics.Log_paths_used_during_the_moduleResolution_process, + defaultValueDescription: false, + }, + { + name: "diagnostics", + type: "boolean", + category: ts.Diagnostics.Compiler_Diagnostics, + description: ts.Diagnostics.Output_compiler_performance_information_after_building, + defaultValueDescription: false, + }, + { + name: "extendedDiagnostics", + type: "boolean", + category: ts.Diagnostics.Compiler_Diagnostics, + description: ts.Diagnostics.Output_more_detailed_compiler_performance_information_after_building, + defaultValueDescription: false, + }, + { + name: "generateCpuProfile", + type: "string", + isFilePath: true, + paramType: ts.Diagnostics.FILE_OR_DIRECTORY, + category: ts.Diagnostics.Compiler_Diagnostics, + description: ts.Diagnostics.Emit_a_v8_CPU_profile_of_the_compiler_run_for_debugging, + defaultValueDescription: "profile.cpuprofile" + }, + { + name: "generateTrace", + type: "string", + isFilePath: true, + isCommandLineOnly: true, + paramType: ts.Diagnostics.DIRECTORY, + category: ts.Diagnostics.Compiler_Diagnostics, + description: ts.Diagnostics.Generates_an_event_trace_and_a_list_of_types + }, + { + name: "incremental", + shortName: "i", + type: "boolean", + category: ts.Diagnostics.Projects, + description: ts.Diagnostics.Save_tsbuildinfo_files_to_allow_for_incremental_compilation_of_projects, + transpileOptionValue: undefined, + defaultValueDescription: ts.Diagnostics.false_unless_composite_is_set + }, + { + name: "assumeChangesOnlyAffectDirectDependencies", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Watch_and_Build_Modes, + description: ts.Diagnostics.Have_recompiles_in_projects_that_use_incremental_and_watch_mode_assume_that_changes_within_a_file_will_only_affect_files_directly_depending_on_it, + defaultValueDescription: false, + }, + { + name: "locale", + type: "string", + category: ts.Diagnostics.Command_line_Options, + isCommandLineOnly: true, + description: ts.Diagnostics.Set_the_language_of_the_messaging_from_TypeScript_This_does_not_affect_emit, + defaultValueDescription: ts.Diagnostics.Platform_specific + }, + ]; + /* @internal */ + ts.targetOptionDeclaration = { + name: "target", + shortName: "t", + type: new ts.Map(ts.getEntries({ + es3: 0 /* ScriptTarget.ES3 */, + es5: 1 /* ScriptTarget.ES5 */, + es6: 2 /* ScriptTarget.ES2015 */, + es2015: 2 /* ScriptTarget.ES2015 */, + es2016: 3 /* ScriptTarget.ES2016 */, + es2017: 4 /* ScriptTarget.ES2017 */, + es2018: 5 /* ScriptTarget.ES2018 */, + es2019: 6 /* ScriptTarget.ES2019 */, + es2020: 7 /* ScriptTarget.ES2020 */, + es2021: 8 /* ScriptTarget.ES2021 */, + es2022: 9 /* ScriptTarget.ES2022 */, + esnext: 99 /* ScriptTarget.ESNext */, + })), + affectsSourceFile: true, + affectsModuleResolution: true, + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + paramType: ts.Diagnostics.VERSION, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Language_and_Environment, + description: ts.Diagnostics.Set_the_JavaScript_language_version_for_emitted_JavaScript_and_include_compatible_library_declarations, + defaultValueDescription: 0 /* ScriptTarget.ES3 */, + }; + /*@internal*/ + ts.moduleOptionDeclaration = { + name: "module", + shortName: "m", + type: new ts.Map(ts.getEntries({ + none: ts.ModuleKind.None, + commonjs: ts.ModuleKind.CommonJS, + amd: ts.ModuleKind.AMD, + system: ts.ModuleKind.System, + umd: ts.ModuleKind.UMD, + es6: ts.ModuleKind.ES2015, + es2015: ts.ModuleKind.ES2015, + es2020: ts.ModuleKind.ES2020, + es2022: ts.ModuleKind.ES2022, + esnext: ts.ModuleKind.ESNext, + node16: ts.ModuleKind.Node16, + nodenext: ts.ModuleKind.NodeNext, + })), + affectsModuleResolution: true, + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + paramType: ts.Diagnostics.KIND, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Modules, + description: ts.Diagnostics.Specify_what_module_code_is_generated, + defaultValueDescription: undefined, + }; + var commandOptionsWithoutBuild = [ + // CommandLine only options + { + name: "all", + type: "boolean", + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Command_line_Options, + description: ts.Diagnostics.Show_all_compiler_options, + defaultValueDescription: false, + }, + { + name: "version", + shortName: "v", + type: "boolean", + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Command_line_Options, + description: ts.Diagnostics.Print_the_compiler_s_version, + defaultValueDescription: false, + }, + { + name: "init", + type: "boolean", + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Command_line_Options, + description: ts.Diagnostics.Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file, + defaultValueDescription: false, + }, + { + name: "project", + shortName: "p", + type: "string", + isFilePath: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Command_line_Options, + paramType: ts.Diagnostics.FILE_OR_DIRECTORY, + description: ts.Diagnostics.Compile_the_project_given_the_path_to_its_configuration_file_or_to_a_folder_with_a_tsconfig_json, + }, + { + name: "build", + type: "boolean", + shortName: "b", + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Command_line_Options, + description: ts.Diagnostics.Build_one_or_more_projects_and_their_dependencies_if_out_of_date, + defaultValueDescription: false, + }, + { + name: "showConfig", + type: "boolean", + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Command_line_Options, + isCommandLineOnly: true, + description: ts.Diagnostics.Print_the_final_configuration_instead_of_building, + defaultValueDescription: false, + }, + { + name: "listFilesOnly", + type: "boolean", + category: ts.Diagnostics.Command_line_Options, + affectsSemanticDiagnostics: true, + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + isCommandLineOnly: true, + description: ts.Diagnostics.Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing, + defaultValueDescription: false, + }, + // Basic + ts.targetOptionDeclaration, + ts.moduleOptionDeclaration, + { + name: "lib", + type: "list", + element: { + name: "lib", + type: ts.libMap, + defaultValueDescription: undefined, + }, + affectsProgramStructure: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Language_and_Environment, + description: ts.Diagnostics.Specify_a_set_of_bundled_library_declaration_files_that_describe_the_target_runtime_environment, + transpileOptionValue: undefined + }, + { + name: "allowJs", + type: "boolean", + affectsModuleResolution: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.JavaScript_Support, + description: ts.Diagnostics.Allow_JavaScript_files_to_be_a_part_of_your_program_Use_the_checkJS_option_to_get_errors_from_these_files, + defaultValueDescription: false, + }, + { + name: "checkJs", + type: "boolean", + showInSimplifiedHelpView: true, + category: ts.Diagnostics.JavaScript_Support, + description: ts.Diagnostics.Enable_error_reporting_in_type_checked_JavaScript_files, + defaultValueDescription: false, + }, + { + name: "jsx", + type: jsxOptionMap, + affectsSourceFile: true, + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + affectsModuleResolution: true, + paramType: ts.Diagnostics.KIND, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Language_and_Environment, + description: ts.Diagnostics.Specify_what_JSX_code_is_generated, + defaultValueDescription: undefined, + }, + { + name: "declaration", + shortName: "d", + type: "boolean", + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Emit, + transpileOptionValue: undefined, + description: ts.Diagnostics.Generate_d_ts_files_from_TypeScript_and_JavaScript_files_in_your_project, + defaultValueDescription: ts.Diagnostics.false_unless_composite_is_set, + }, + { + name: "declarationMap", + type: "boolean", + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Emit, + transpileOptionValue: undefined, + defaultValueDescription: false, + description: ts.Diagnostics.Create_sourcemaps_for_d_ts_files + }, + { + name: "emitDeclarationOnly", + type: "boolean", + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Emit, + description: ts.Diagnostics.Only_output_d_ts_files_and_not_JavaScript_files, + transpileOptionValue: undefined, + defaultValueDescription: false, + }, + { + name: "sourceMap", + type: "boolean", + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Emit, + defaultValueDescription: false, + description: ts.Diagnostics.Create_source_map_files_for_emitted_JavaScript_files, + }, + { + name: "outFile", + type: "string", + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + affectsDeclarationPath: true, + affectsBundleEmitBuildInfo: true, + isFilePath: true, + paramType: ts.Diagnostics.FILE, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Emit, + description: ts.Diagnostics.Specify_a_file_that_bundles_all_outputs_into_one_JavaScript_file_If_declaration_is_true_also_designates_a_file_that_bundles_all_d_ts_output, + transpileOptionValue: undefined, + }, + { + name: "outDir", + type: "string", + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + affectsDeclarationPath: true, + isFilePath: true, + paramType: ts.Diagnostics.DIRECTORY, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Emit, + description: ts.Diagnostics.Specify_an_output_folder_for_all_emitted_files, + }, + { + name: "rootDir", + type: "string", + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + affectsDeclarationPath: true, + isFilePath: true, + paramType: ts.Diagnostics.LOCATION, + category: ts.Diagnostics.Modules, + description: ts.Diagnostics.Specify_the_root_folder_within_your_source_files, + defaultValueDescription: ts.Diagnostics.Computed_from_the_list_of_input_files + }, + { + name: "composite", + type: "boolean", + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + affectsBundleEmitBuildInfo: true, + isTSConfigOnly: true, + category: ts.Diagnostics.Projects, + transpileOptionValue: undefined, + defaultValueDescription: false, + description: ts.Diagnostics.Enable_constraints_that_allow_a_TypeScript_project_to_be_used_with_project_references, + }, + { + name: "tsBuildInfoFile", + type: "string", + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + affectsBundleEmitBuildInfo: true, + isFilePath: true, + paramType: ts.Diagnostics.FILE, + category: ts.Diagnostics.Projects, + transpileOptionValue: undefined, + defaultValueDescription: ".tsbuildinfo", + description: ts.Diagnostics.Specify_the_path_to_tsbuildinfo_incremental_compilation_file, + }, + { + name: "removeComments", + type: "boolean", + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Emit, + defaultValueDescription: false, + description: ts.Diagnostics.Disable_emitting_comments, + }, + { + name: "noEmit", + type: "boolean", + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Emit, + description: ts.Diagnostics.Disable_emitting_files_from_a_compilation, + transpileOptionValue: undefined, + defaultValueDescription: false, + }, + { + name: "importHelpers", + type: "boolean", + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Emit, + description: ts.Diagnostics.Allow_importing_helper_functions_from_tslib_once_per_project_instead_of_including_them_per_file, + defaultValueDescription: false, + }, + { + name: "importsNotUsedAsValues", + type: new ts.Map(ts.getEntries({ + remove: 0 /* ImportsNotUsedAsValues.Remove */, + preserve: 1 /* ImportsNotUsedAsValues.Preserve */, + error: 2 /* ImportsNotUsedAsValues.Error */, + })), + affectsEmit: true, + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Emit, + description: ts.Diagnostics.Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types, + defaultValueDescription: 0 /* ImportsNotUsedAsValues.Remove */, + }, + { + name: "downlevelIteration", + type: "boolean", + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Emit, + description: ts.Diagnostics.Emit_more_compliant_but_verbose_and_less_performant_JavaScript_for_iteration, + defaultValueDescription: false, + }, + { + name: "isolatedModules", + type: "boolean", + category: ts.Diagnostics.Interop_Constraints, + description: ts.Diagnostics.Ensure_that_each_file_can_be_safely_transpiled_without_relying_on_other_imports, + transpileOptionValue: true, + defaultValueDescription: false, + }, + // Strict Type Checks + { + name: "strict", + type: "boolean", + // Though this affects semantic diagnostics, affectsSemanticDiagnostics is not set here + // The value of each strictFlag depends on own strictFlag value or this and never accessed directly. + // But we need to store `strict` in builf info, even though it won't be examined directly, so that the + // flags it controls (e.g. `strictNullChecks`) will be retrieved correctly + affectsMultiFileEmitBuildInfo: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Type_Checking, + description: ts.Diagnostics.Enable_all_strict_type_checking_options, + defaultValueDescription: false, + }, + { + name: "noImplicitAny", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + strictFlag: true, + category: ts.Diagnostics.Type_Checking, + description: ts.Diagnostics.Enable_error_reporting_for_expressions_and_declarations_with_an_implied_any_type, + defaultValueDescription: ts.Diagnostics.false_unless_strict_is_set + }, + { + name: "strictNullChecks", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + strictFlag: true, + category: ts.Diagnostics.Type_Checking, + description: ts.Diagnostics.When_type_checking_take_into_account_null_and_undefined, + defaultValueDescription: ts.Diagnostics.false_unless_strict_is_set + }, + { + name: "strictFunctionTypes", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + strictFlag: true, + category: ts.Diagnostics.Type_Checking, + description: ts.Diagnostics.When_assigning_functions_check_to_ensure_parameters_and_the_return_values_are_subtype_compatible, + defaultValueDescription: ts.Diagnostics.false_unless_strict_is_set + }, + { + name: "strictBindCallApply", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + strictFlag: true, + category: ts.Diagnostics.Type_Checking, + description: ts.Diagnostics.Check_that_the_arguments_for_bind_call_and_apply_methods_match_the_original_function, + defaultValueDescription: ts.Diagnostics.false_unless_strict_is_set + }, + { + name: "strictPropertyInitialization", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + strictFlag: true, + category: ts.Diagnostics.Type_Checking, + description: ts.Diagnostics.Check_for_class_properties_that_are_declared_but_not_set_in_the_constructor, + defaultValueDescription: ts.Diagnostics.false_unless_strict_is_set + }, + { + name: "noImplicitThis", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + strictFlag: true, + category: ts.Diagnostics.Type_Checking, + description: ts.Diagnostics.Enable_error_reporting_when_this_is_given_the_type_any, + defaultValueDescription: ts.Diagnostics.false_unless_strict_is_set + }, + { + name: "useUnknownInCatchVariables", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + strictFlag: true, + category: ts.Diagnostics.Type_Checking, + description: ts.Diagnostics.Default_catch_clause_variables_as_unknown_instead_of_any, + defaultValueDescription: false, + }, + { + name: "alwaysStrict", + type: "boolean", + affectsSourceFile: true, + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + strictFlag: true, + category: ts.Diagnostics.Type_Checking, + description: ts.Diagnostics.Ensure_use_strict_is_always_emitted, + defaultValueDescription: ts.Diagnostics.false_unless_strict_is_set + }, + // Additional Checks + { + name: "noUnusedLocals", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Type_Checking, + description: ts.Diagnostics.Enable_error_reporting_when_local_variables_aren_t_read, + defaultValueDescription: false, + }, + { + name: "noUnusedParameters", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Type_Checking, + description: ts.Diagnostics.Raise_an_error_when_a_function_parameter_isn_t_read, + defaultValueDescription: false, + }, + { + name: "exactOptionalPropertyTypes", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Type_Checking, + description: ts.Diagnostics.Interpret_optional_property_types_as_written_rather_than_adding_undefined, + defaultValueDescription: false, + }, + { + name: "noImplicitReturns", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Type_Checking, + description: ts.Diagnostics.Enable_error_reporting_for_codepaths_that_do_not_explicitly_return_in_a_function, + defaultValueDescription: false, + }, + { + name: "noFallthroughCasesInSwitch", + type: "boolean", + affectsBindDiagnostics: true, + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Type_Checking, + description: ts.Diagnostics.Enable_error_reporting_for_fallthrough_cases_in_switch_statements, + defaultValueDescription: false, + }, + { + name: "noUncheckedIndexedAccess", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Type_Checking, + description: ts.Diagnostics.Add_undefined_to_a_type_when_accessed_using_an_index, + defaultValueDescription: false, + }, + { + name: "noImplicitOverride", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Type_Checking, + description: ts.Diagnostics.Ensure_overriding_members_in_derived_classes_are_marked_with_an_override_modifier, + defaultValueDescription: false, + }, + { + name: "noPropertyAccessFromIndexSignature", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + showInSimplifiedHelpView: false, + category: ts.Diagnostics.Type_Checking, + description: ts.Diagnostics.Enforces_using_indexed_accessors_for_keys_declared_using_an_indexed_type, + defaultValueDescription: false, + }, + // Module Resolution + { + name: "moduleResolution", + type: new ts.Map(ts.getEntries({ + node: ts.ModuleResolutionKind.NodeJs, + classic: ts.ModuleResolutionKind.Classic, + node16: ts.ModuleResolutionKind.Node16, + nodenext: ts.ModuleResolutionKind.NodeNext, + })), + affectsModuleResolution: true, + paramType: ts.Diagnostics.STRATEGY, + category: ts.Diagnostics.Modules, + description: ts.Diagnostics.Specify_how_TypeScript_looks_up_a_file_from_a_given_module_specifier, + defaultValueDescription: ts.Diagnostics.module_AMD_or_UMD_or_System_or_ES6_then_Classic_Otherwise_Node + }, + { + name: "baseUrl", + type: "string", + affectsModuleResolution: true, + isFilePath: true, + category: ts.Diagnostics.Modules, + description: ts.Diagnostics.Specify_the_base_directory_to_resolve_non_relative_module_names + }, + { + // this option can only be specified in tsconfig.json + // use type = object to copy the value as-is + name: "paths", + type: "object", + affectsModuleResolution: true, + isTSConfigOnly: true, + category: ts.Diagnostics.Modules, + description: ts.Diagnostics.Specify_a_set_of_entries_that_re_map_imports_to_additional_lookup_locations, + transpileOptionValue: undefined + }, + { + // this option can only be specified in tsconfig.json + // use type = object to copy the value as-is + name: "rootDirs", + type: "list", + isTSConfigOnly: true, + element: { + name: "rootDirs", + type: "string", + isFilePath: true + }, + affectsModuleResolution: true, + category: ts.Diagnostics.Modules, + description: ts.Diagnostics.Allow_multiple_folders_to_be_treated_as_one_when_resolving_modules, + transpileOptionValue: undefined, + defaultValueDescription: ts.Diagnostics.Computed_from_the_list_of_input_files + }, + { + name: "typeRoots", + type: "list", + element: { + name: "typeRoots", + type: "string", + isFilePath: true + }, + affectsModuleResolution: true, + category: ts.Diagnostics.Modules, + description: ts.Diagnostics.Specify_multiple_folders_that_act_like_Slashnode_modules_Slash_types + }, + { + name: "types", + type: "list", + element: { + name: "types", + type: "string" + }, + affectsProgramStructure: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Modules, + description: ts.Diagnostics.Specify_type_package_names_to_be_included_without_being_referenced_in_a_source_file, + transpileOptionValue: undefined + }, + { + name: "allowSyntheticDefaultImports", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Interop_Constraints, + description: ts.Diagnostics.Allow_import_x_from_y_when_a_module_doesn_t_have_a_default_export, + defaultValueDescription: ts.Diagnostics.module_system_or_esModuleInterop + }, + { + name: "esModuleInterop", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + showInSimplifiedHelpView: true, + category: ts.Diagnostics.Interop_Constraints, + description: ts.Diagnostics.Emit_additional_JavaScript_to_ease_support_for_importing_CommonJS_modules_This_enables_allowSyntheticDefaultImports_for_type_compatibility, + defaultValueDescription: false, + }, + { + name: "preserveSymlinks", + type: "boolean", + category: ts.Diagnostics.Interop_Constraints, + description: ts.Diagnostics.Disable_resolving_symlinks_to_their_realpath_This_correlates_to_the_same_flag_in_node, + defaultValueDescription: false, + }, + { + name: "allowUmdGlobalAccess", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Modules, + description: ts.Diagnostics.Allow_accessing_UMD_globals_from_modules, + defaultValueDescription: false, + }, + { + name: "moduleSuffixes", + type: "list", + element: { + name: "suffix", + type: "string", + }, + listPreserveFalsyValues: true, + affectsModuleResolution: true, + category: ts.Diagnostics.Modules, + description: ts.Diagnostics.List_of_file_name_suffixes_to_search_when_resolving_a_module, + }, + // Source Maps + { + name: "sourceRoot", + type: "string", + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + paramType: ts.Diagnostics.LOCATION, + category: ts.Diagnostics.Emit, + description: ts.Diagnostics.Specify_the_root_path_for_debuggers_to_find_the_reference_source_code, + }, + { + name: "mapRoot", + type: "string", + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + paramType: ts.Diagnostics.LOCATION, + category: ts.Diagnostics.Emit, + description: ts.Diagnostics.Specify_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations, + }, + { + name: "inlineSourceMap", + type: "boolean", + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Emit, + description: ts.Diagnostics.Include_sourcemap_files_inside_the_emitted_JavaScript, + defaultValueDescription: false, + }, + { + name: "inlineSources", + type: "boolean", + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Emit, + description: ts.Diagnostics.Include_source_code_in_the_sourcemaps_inside_the_emitted_JavaScript, + defaultValueDescription: false, + }, + // Experimental + { + name: "experimentalDecorators", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Language_and_Environment, + description: ts.Diagnostics.Enable_experimental_support_for_TC39_stage_2_draft_decorators, + defaultValueDescription: false, + }, + { + name: "emitDecoratorMetadata", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Language_and_Environment, + description: ts.Diagnostics.Emit_design_type_metadata_for_decorated_declarations_in_source_files, + defaultValueDescription: false, + }, + // Advanced + { + name: "jsxFactory", + type: "string", + category: ts.Diagnostics.Language_and_Environment, + description: ts.Diagnostics.Specify_the_JSX_factory_function_used_when_targeting_React_JSX_emit_e_g_React_createElement_or_h, + defaultValueDescription: "`React.createElement`" + }, + { + name: "jsxFragmentFactory", + type: "string", + category: ts.Diagnostics.Language_and_Environment, + description: ts.Diagnostics.Specify_the_JSX_Fragment_reference_used_for_fragments_when_targeting_React_JSX_emit_e_g_React_Fragment_or_Fragment, + defaultValueDescription: "React.Fragment", + }, + { + name: "jsxImportSource", + type: "string", + affectsSemanticDiagnostics: true, + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + affectsModuleResolution: true, + category: ts.Diagnostics.Language_and_Environment, + description: ts.Diagnostics.Specify_module_specifier_used_to_import_the_JSX_factory_functions_when_using_jsx_Colon_react_jsx_Asterisk, + defaultValueDescription: "react" + }, + { + name: "resolveJsonModule", + type: "boolean", + affectsModuleResolution: true, + category: ts.Diagnostics.Modules, + description: ts.Diagnostics.Enable_importing_json_files, + defaultValueDescription: false, + }, + { + name: "out", + type: "string", + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + affectsDeclarationPath: true, + affectsBundleEmitBuildInfo: true, + isFilePath: false, + // for correct behaviour, please use outFile + category: ts.Diagnostics.Backwards_Compatibility, + paramType: ts.Diagnostics.FILE, + transpileOptionValue: undefined, + description: ts.Diagnostics.Deprecated_setting_Use_outFile_instead, + }, + { + name: "reactNamespace", + type: "string", + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Language_and_Environment, + description: ts.Diagnostics.Specify_the_object_invoked_for_createElement_This_only_applies_when_targeting_react_JSX_emit, + defaultValueDescription: "`React`", + }, + { + name: "skipDefaultLibCheck", + type: "boolean", + // We need to store these to determine whether `lib` files need to be rechecked + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Completeness, + description: ts.Diagnostics.Skip_type_checking_d_ts_files_that_are_included_with_TypeScript, + defaultValueDescription: false, + }, + { + name: "charset", + type: "string", + category: ts.Diagnostics.Backwards_Compatibility, + description: ts.Diagnostics.No_longer_supported_In_early_versions_manually_set_the_text_encoding_for_reading_files, + defaultValueDescription: "utf8" + }, + { + name: "emitBOM", + type: "boolean", + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Emit, + description: ts.Diagnostics.Emit_a_UTF_8_Byte_Order_Mark_BOM_in_the_beginning_of_output_files, + defaultValueDescription: false, + }, + { + name: "newLine", + type: new ts.Map(ts.getEntries({ + crlf: 0 /* NewLineKind.CarriageReturnLineFeed */, + lf: 1 /* NewLineKind.LineFeed */ + })), + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + paramType: ts.Diagnostics.NEWLINE, + category: ts.Diagnostics.Emit, + description: ts.Diagnostics.Set_the_newline_character_for_emitting_files, + defaultValueDescription: ts.Diagnostics.Platform_specific + }, + { + name: "noErrorTruncation", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Output_Formatting, + description: ts.Diagnostics.Disable_truncating_types_in_error_messages, + defaultValueDescription: false, + }, + { + name: "noLib", + type: "boolean", + category: ts.Diagnostics.Language_and_Environment, + affectsProgramStructure: true, + description: ts.Diagnostics.Disable_including_any_library_files_including_the_default_lib_d_ts, + // We are not returning a sourceFile for lib file when asked by the program, + // so pass --noLib to avoid reporting a file not found error. + transpileOptionValue: true, + defaultValueDescription: false, + }, + { + name: "noResolve", + type: "boolean", + affectsModuleResolution: true, + category: ts.Diagnostics.Modules, + description: ts.Diagnostics.Disallow_import_s_require_s_or_reference_s_from_expanding_the_number_of_files_TypeScript_should_add_to_a_project, + // We are not doing a full typecheck, we are not resolving the whole context, + // so pass --noResolve to avoid reporting missing file errors. + transpileOptionValue: true, + defaultValueDescription: false, + }, + { + name: "stripInternal", + type: "boolean", + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Emit, + description: ts.Diagnostics.Disable_emitting_declarations_that_have_internal_in_their_JSDoc_comments, + defaultValueDescription: false, + }, + { + name: "disableSizeLimit", + type: "boolean", + affectsProgramStructure: true, + category: ts.Diagnostics.Editor_Support, + description: ts.Diagnostics.Remove_the_20mb_cap_on_total_source_code_size_for_JavaScript_files_in_the_TypeScript_language_server, + defaultValueDescription: false, + }, + { + name: "disableSourceOfProjectReferenceRedirect", + type: "boolean", + isTSConfigOnly: true, + category: ts.Diagnostics.Projects, + description: ts.Diagnostics.Disable_preferring_source_files_instead_of_declaration_files_when_referencing_composite_projects, + defaultValueDescription: false, + }, + { + name: "disableSolutionSearching", + type: "boolean", + isTSConfigOnly: true, + category: ts.Diagnostics.Projects, + description: ts.Diagnostics.Opt_a_project_out_of_multi_project_reference_checking_when_editing, + defaultValueDescription: false, + }, + { + name: "disableReferencedProjectLoad", + type: "boolean", + isTSConfigOnly: true, + category: ts.Diagnostics.Projects, + description: ts.Diagnostics.Reduce_the_number_of_projects_loaded_automatically_by_TypeScript, + defaultValueDescription: false, + }, + { + name: "noImplicitUseStrict", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Backwards_Compatibility, + description: ts.Diagnostics.Disable_adding_use_strict_directives_in_emitted_JavaScript_files, + defaultValueDescription: false, + }, + { + name: "noEmitHelpers", + type: "boolean", + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Emit, + description: ts.Diagnostics.Disable_generating_custom_helper_functions_like_extends_in_compiled_output, + defaultValueDescription: false, + }, + { + name: "noEmitOnError", + type: "boolean", + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Emit, + transpileOptionValue: undefined, + description: ts.Diagnostics.Disable_emitting_files_if_any_type_checking_errors_are_reported, + defaultValueDescription: false, + }, + { + name: "preserveConstEnums", + type: "boolean", + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Emit, + description: ts.Diagnostics.Disable_erasing_const_enum_declarations_in_generated_code, + defaultValueDescription: false, + }, + { + name: "declarationDir", + type: "string", + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + affectsDeclarationPath: true, + isFilePath: true, + paramType: ts.Diagnostics.DIRECTORY, + category: ts.Diagnostics.Emit, + transpileOptionValue: undefined, + description: ts.Diagnostics.Specify_the_output_directory_for_generated_declaration_files, + }, + { + name: "skipLibCheck", + type: "boolean", + // We need to store these to determine whether `lib` files need to be rechecked + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Completeness, + description: ts.Diagnostics.Skip_type_checking_all_d_ts_files, + defaultValueDescription: false, + }, + { + name: "allowUnusedLabels", + type: "boolean", + affectsBindDiagnostics: true, + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Type_Checking, + description: ts.Diagnostics.Disable_error_reporting_for_unused_labels, + defaultValueDescription: undefined, + }, + { + name: "allowUnreachableCode", + type: "boolean", + affectsBindDiagnostics: true, + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Type_Checking, + description: ts.Diagnostics.Disable_error_reporting_for_unreachable_code, + defaultValueDescription: undefined, + }, + { + name: "suppressExcessPropertyErrors", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Backwards_Compatibility, + description: ts.Diagnostics.Disable_reporting_of_excess_property_errors_during_the_creation_of_object_literals, + defaultValueDescription: false, + }, + { + name: "suppressImplicitAnyIndexErrors", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Backwards_Compatibility, + description: ts.Diagnostics.Suppress_noImplicitAny_errors_when_indexing_objects_that_lack_index_signatures, + defaultValueDescription: false, + }, + { + name: "forceConsistentCasingInFileNames", + type: "boolean", + affectsModuleResolution: true, + category: ts.Diagnostics.Interop_Constraints, + description: ts.Diagnostics.Ensure_that_casing_is_correct_in_imports, + defaultValueDescription: false, + }, + { + name: "maxNodeModuleJsDepth", + type: "number", + affectsModuleResolution: true, + category: ts.Diagnostics.JavaScript_Support, + description: ts.Diagnostics.Specify_the_maximum_folder_depth_used_for_checking_JavaScript_files_from_node_modules_Only_applicable_with_allowJs, + defaultValueDescription: 0, + }, + { + name: "noStrictGenericChecks", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Backwards_Compatibility, + description: ts.Diagnostics.Disable_strict_checking_of_generic_signatures_in_function_types, + defaultValueDescription: false, + }, + { + name: "useDefineForClassFields", + type: "boolean", + affectsSemanticDiagnostics: true, + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Language_and_Environment, + description: ts.Diagnostics.Emit_ECMAScript_standard_compliant_class_fields, + defaultValueDescription: ts.Diagnostics.true_for_ES2022_and_above_including_ESNext + }, + { + name: "preserveValueImports", + type: "boolean", + affectsEmit: true, + affectsMultiFileEmitBuildInfo: true, + category: ts.Diagnostics.Emit, + description: ts.Diagnostics.Preserve_unused_imported_values_in_the_JavaScript_output_that_would_otherwise_be_removed, + defaultValueDescription: false, + }, + { + name: "keyofStringsOnly", + type: "boolean", + category: ts.Diagnostics.Backwards_Compatibility, + description: ts.Diagnostics.Make_keyof_only_return_strings_instead_of_string_numbers_or_symbols_Legacy_option, + defaultValueDescription: false, + }, + { + // A list of plugins to load in the language service + name: "plugins", + type: "list", + isTSConfigOnly: true, + element: { + name: "plugin", + type: "object" + }, + description: ts.Diagnostics.Specify_a_list_of_language_service_plugins_to_include, + category: ts.Diagnostics.Editor_Support, + }, + { + name: "moduleDetection", + type: new ts.Map(ts.getEntries({ + auto: ts.ModuleDetectionKind.Auto, + legacy: ts.ModuleDetectionKind.Legacy, + force: ts.ModuleDetectionKind.Force, + })), + affectsModuleResolution: true, + description: ts.Diagnostics.Control_what_method_is_used_to_detect_module_format_JS_files, + category: ts.Diagnostics.Language_and_Environment, + defaultValueDescription: ts.Diagnostics.auto_Colon_Treat_files_with_imports_exports_import_meta_jsx_with_jsx_Colon_react_jsx_or_esm_format_with_module_Colon_node16_as_modules, + } + ]; + /* @internal */ + ts.optionDeclarations = __spreadArray(__spreadArray([], ts.commonOptionsWithBuild, true), commandOptionsWithoutBuild, true); + /* @internal */ + ts.semanticDiagnosticsOptionDeclarations = ts.optionDeclarations.filter(function (option) { return !!option.affectsSemanticDiagnostics; }); + /* @internal */ + ts.affectsEmitOptionDeclarations = ts.optionDeclarations.filter(function (option) { return !!option.affectsEmit; }); + /* @internal */ + ts.affectsDeclarationPathOptionDeclarations = ts.optionDeclarations.filter(function (option) { return !!option.affectsDeclarationPath; }); + /* @internal */ + ts.moduleResolutionOptionDeclarations = ts.optionDeclarations.filter(function (option) { return !!option.affectsModuleResolution; }); + /* @internal */ + ts.sourceFileAffectingCompilerOptions = ts.optionDeclarations.filter(function (option) { + return !!option.affectsSourceFile || !!option.affectsModuleResolution || !!option.affectsBindDiagnostics; + }); + /* @internal */ + ts.optionsAffectingProgramStructure = ts.optionDeclarations.filter(function (option) { return !!option.affectsProgramStructure; }); + /* @internal */ + ts.transpileOptionValueCompilerOptions = ts.optionDeclarations.filter(function (option) { + return ts.hasProperty(option, "transpileOptionValue"); + }); + // Build related options + /* @internal */ + ts.optionsForBuild = [ + { + name: "verbose", + shortName: "v", + category: ts.Diagnostics.Command_line_Options, + description: ts.Diagnostics.Enable_verbose_logging, + type: "boolean", + defaultValueDescription: false, + }, + { + name: "dry", + shortName: "d", + category: ts.Diagnostics.Command_line_Options, + description: ts.Diagnostics.Show_what_would_be_built_or_deleted_if_specified_with_clean, + type: "boolean", + defaultValueDescription: false, + }, + { + name: "force", + shortName: "f", + category: ts.Diagnostics.Command_line_Options, + description: ts.Diagnostics.Build_all_projects_including_those_that_appear_to_be_up_to_date, + type: "boolean", + defaultValueDescription: false, + }, + { + name: "clean", + category: ts.Diagnostics.Command_line_Options, + description: ts.Diagnostics.Delete_the_outputs_of_all_projects, + type: "boolean", + defaultValueDescription: false, + } + ]; + /* @internal */ + ts.buildOpts = __spreadArray(__spreadArray([], ts.commonOptionsWithBuild, true), ts.optionsForBuild, true); + /* @internal */ + ts.typeAcquisitionDeclarations = [ + { + /* @deprecated typingOptions.enableAutoDiscovery + * Use typeAcquisition.enable instead. + */ + name: "enableAutoDiscovery", + type: "boolean", + defaultValueDescription: false, + }, + { + name: "enable", + type: "boolean", + defaultValueDescription: false, + }, + { + name: "include", + type: "list", + element: { + name: "include", + type: "string" + } + }, + { + name: "exclude", + type: "list", + element: { + name: "exclude", + type: "string" + } + }, + { + name: "disableFilenameBasedTypeAcquisition", + type: "boolean", + defaultValueDescription: false, + }, + ]; + /*@internal*/ + function createOptionNameMap(optionDeclarations) { + var optionsNameMap = new ts.Map(); + var shortOptionNames = new ts.Map(); + ts.forEach(optionDeclarations, function (option) { + optionsNameMap.set(option.name.toLowerCase(), option); + if (option.shortName) { + shortOptionNames.set(option.shortName, option.name); + } + }); + return { optionsNameMap: optionsNameMap, shortOptionNames: shortOptionNames }; + } + ts.createOptionNameMap = createOptionNameMap; + var optionsNameMapCache; + /* @internal */ + function getOptionsNameMap() { + return optionsNameMapCache || (optionsNameMapCache = createOptionNameMap(ts.optionDeclarations)); + } + ts.getOptionsNameMap = getOptionsNameMap; + var compilerOptionsAlternateMode = { + diagnostic: ts.Diagnostics.Compiler_option_0_may_only_be_used_with_build, + getOptionsNameMap: getBuildOptionsNameMap + }; + /* @internal */ + ts.defaultInitCompilerOptions = { + module: ts.ModuleKind.CommonJS, + target: 3 /* ScriptTarget.ES2016 */, + strict: true, + esModuleInterop: true, + forceConsistentCasingInFileNames: true, + skipLibCheck: true + }; + /* @internal */ + function convertEnableAutoDiscoveryToEnable(typeAcquisition) { + // Convert deprecated typingOptions.enableAutoDiscovery to typeAcquisition.enable + if (typeAcquisition && typeAcquisition.enableAutoDiscovery !== undefined && typeAcquisition.enable === undefined) { + return { + enable: typeAcquisition.enableAutoDiscovery, + include: typeAcquisition.include || [], + exclude: typeAcquisition.exclude || [] + }; + } + return typeAcquisition; + } + ts.convertEnableAutoDiscoveryToEnable = convertEnableAutoDiscoveryToEnable; + /* @internal */ + function createCompilerDiagnosticForInvalidCustomType(opt) { + return createDiagnosticForInvalidCustomType(opt, ts.createCompilerDiagnostic); + } + ts.createCompilerDiagnosticForInvalidCustomType = createCompilerDiagnosticForInvalidCustomType; + function createDiagnosticForInvalidCustomType(opt, createDiagnostic) { + var namesOfType = ts.arrayFrom(opt.type.keys()).map(function (key) { return "'".concat(key, "'"); }).join(", "); + return createDiagnostic(ts.Diagnostics.Argument_for_0_option_must_be_Colon_1, "--".concat(opt.name), namesOfType); + } + /* @internal */ + function parseCustomTypeOption(opt, value, errors) { + return convertJsonOptionOfCustomType(opt, ts.trimString(value || ""), errors); + } + ts.parseCustomTypeOption = parseCustomTypeOption; + /* @internal */ + function parseListTypeOption(opt, value, errors) { + if (value === void 0) { value = ""; } + value = ts.trimString(value); + if (ts.startsWith(value, "-")) { + return undefined; + } + if (value === "") { + return []; + } + var values = value.split(","); + switch (opt.element.type) { + case "number": + return ts.mapDefined(values, function (v) { return validateJsonOptionValue(opt.element, parseInt(v), errors); }); + case "string": + return ts.mapDefined(values, function (v) { return validateJsonOptionValue(opt.element, v || "", errors); }); + default: + return ts.mapDefined(values, function (v) { return parseCustomTypeOption(opt.element, v, errors); }); + } + } + ts.parseListTypeOption = parseListTypeOption; + function getOptionName(option) { + return option.name; + } + function createUnknownOptionError(unknownOption, diagnostics, createDiagnostics, unknownOptionErrorText) { + var _a; + if ((_a = diagnostics.alternateMode) === null || _a === void 0 ? void 0 : _a.getOptionsNameMap().optionsNameMap.has(unknownOption.toLowerCase())) { + return createDiagnostics(diagnostics.alternateMode.diagnostic, unknownOption); + } + var possibleOption = ts.getSpellingSuggestion(unknownOption, diagnostics.optionDeclarations, getOptionName); + return possibleOption ? + createDiagnostics(diagnostics.unknownDidYouMeanDiagnostic, unknownOptionErrorText || unknownOption, possibleOption.name) : + createDiagnostics(diagnostics.unknownOptionDiagnostic, unknownOptionErrorText || unknownOption); + } + /*@internal*/ + function parseCommandLineWorker(diagnostics, commandLine, readFile) { + var options = {}; + var watchOptions; + var fileNames = []; + var errors = []; + parseStrings(commandLine); + return { + options: options, + watchOptions: watchOptions, + fileNames: fileNames, + errors: errors + }; + function parseStrings(args) { + var i = 0; + while (i < args.length) { + var s = args[i]; + i++; + if (s.charCodeAt(0) === 64 /* CharacterCodes.at */) { + parseResponseFile(s.slice(1)); + } + else if (s.charCodeAt(0) === 45 /* CharacterCodes.minus */) { + var inputOptionName = s.slice(s.charCodeAt(1) === 45 /* CharacterCodes.minus */ ? 2 : 1); + var opt = getOptionDeclarationFromName(diagnostics.getOptionsNameMap, inputOptionName, /*allowShort*/ true); + if (opt) { + i = parseOptionValue(args, i, diagnostics, opt, options, errors); + } + else { + var watchOpt = getOptionDeclarationFromName(watchOptionsDidYouMeanDiagnostics.getOptionsNameMap, inputOptionName, /*allowShort*/ true); + if (watchOpt) { + i = parseOptionValue(args, i, watchOptionsDidYouMeanDiagnostics, watchOpt, watchOptions || (watchOptions = {}), errors); + } + else { + errors.push(createUnknownOptionError(inputOptionName, diagnostics, ts.createCompilerDiagnostic, s)); + } + } + } + else { + fileNames.push(s); + } + } + } + function parseResponseFile(fileName) { + var text = tryReadFile(fileName, readFile || (function (fileName) { return ts.sys.readFile(fileName); })); + if (!ts.isString(text)) { + errors.push(text); + return; + } + var args = []; + var pos = 0; + while (true) { + while (pos < text.length && text.charCodeAt(pos) <= 32 /* CharacterCodes.space */) + pos++; + if (pos >= text.length) + break; + var start = pos; + if (text.charCodeAt(start) === 34 /* CharacterCodes.doubleQuote */) { + pos++; + while (pos < text.length && text.charCodeAt(pos) !== 34 /* CharacterCodes.doubleQuote */) + pos++; + if (pos < text.length) { + args.push(text.substring(start + 1, pos)); + pos++; + } + else { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Unterminated_quoted_string_in_response_file_0, fileName)); + } + } + else { + while (text.charCodeAt(pos) > 32 /* CharacterCodes.space */) + pos++; + args.push(text.substring(start, pos)); + } + } + parseStrings(args); + } + } + ts.parseCommandLineWorker = parseCommandLineWorker; + function parseOptionValue(args, i, diagnostics, opt, options, errors) { + if (opt.isTSConfigOnly) { + var optValue = args[i]; + if (optValue === "null") { + options[opt.name] = undefined; + i++; + } + else if (opt.type === "boolean") { + if (optValue === "false") { + options[opt.name] = validateJsonOptionValue(opt, /*value*/ false, errors); + i++; + } + else { + if (optValue === "true") + i++; + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_false_or_null_on_command_line, opt.name)); + } + } + else { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_null_on_command_line, opt.name)); + if (optValue && !ts.startsWith(optValue, "-")) + i++; + } + } + 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(ts.createCompilerDiagnostic(diagnostics.optionTypeMismatchDiagnostic, opt.name, getCompilerOptionValueTypeString(opt))); + } + if (args[i] !== "null") { + switch (opt.type) { + case "number": + options[opt.name] = validateJsonOptionValue(opt, parseInt(args[i]), errors); + i++; + break; + case "boolean": + // boolean flag has optional value true, false, others + var optValue = args[i]; + options[opt.name] = validateJsonOptionValue(opt, optValue !== "false", errors); + // consume next argument as boolean flag value + if (optValue === "false" || optValue === "true") { + i++; + } + break; + case "string": + options[opt.name] = validateJsonOptionValue(opt, args[i] || "", errors); + i++; + break; + case "list": + var result = parseListTypeOption(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(opt, args[i], errors); + i++; + break; + } + } + else { + options[opt.name] = undefined; + i++; + } + } + return i; + } + /*@internal*/ + ts.compilerOptionsDidYouMeanDiagnostics = { + alternateMode: compilerOptionsAlternateMode, + getOptionsNameMap: getOptionsNameMap, + optionDeclarations: ts.optionDeclarations, + unknownOptionDiagnostic: ts.Diagnostics.Unknown_compiler_option_0, + unknownDidYouMeanDiagnostic: ts.Diagnostics.Unknown_compiler_option_0_Did_you_mean_1, + optionTypeMismatchDiagnostic: ts.Diagnostics.Compiler_option_0_expects_an_argument + }; + function parseCommandLine(commandLine, readFile) { + return parseCommandLineWorker(ts.compilerOptionsDidYouMeanDiagnostics, commandLine, readFile); + } + ts.parseCommandLine = parseCommandLine; + /** @internal */ + function getOptionFromName(optionName, allowShort) { + return getOptionDeclarationFromName(getOptionsNameMap, optionName, allowShort); + } + ts.getOptionFromName = getOptionFromName; + function getOptionDeclarationFromName(getOptionNameMap, optionName, allowShort) { + if (allowShort === void 0) { allowShort = false; } + optionName = optionName.toLowerCase(); + var _a = getOptionNameMap(), optionsNameMap = _a.optionsNameMap, shortOptionNames = _a.shortOptionNames; + // Try to translate short option names to their full equivalents. + if (allowShort) { + var short = shortOptionNames.get(optionName); + if (short !== undefined) { + optionName = short; + } + } + return optionsNameMap.get(optionName); + } + var buildOptionsNameMapCache; + function getBuildOptionsNameMap() { + return buildOptionsNameMapCache || (buildOptionsNameMapCache = createOptionNameMap(ts.buildOpts)); + } + var buildOptionsAlternateMode = { + diagnostic: ts.Diagnostics.Compiler_option_0_may_not_be_used_with_build, + getOptionsNameMap: getOptionsNameMap + }; + var buildOptionsDidYouMeanDiagnostics = { + alternateMode: buildOptionsAlternateMode, + getOptionsNameMap: getBuildOptionsNameMap, + optionDeclarations: ts.buildOpts, + unknownOptionDiagnostic: ts.Diagnostics.Unknown_build_option_0, + unknownDidYouMeanDiagnostic: ts.Diagnostics.Unknown_build_option_0_Did_you_mean_1, + optionTypeMismatchDiagnostic: ts.Diagnostics.Build_option_0_requires_a_value_of_type_1 + }; + /*@internal*/ + function parseBuildCommand(args) { + var _a = parseCommandLineWorker(buildOptionsDidYouMeanDiagnostics, args), options = _a.options, watchOptions = _a.watchOptions, projects = _a.fileNames, errors = _a.errors; + var buildOptions = options; + if (projects.length === 0) { + // tsc -b invoked with no extra arguments; act as if invoked with "tsc -b ." + projects.push("."); + } + // Nonsensical combinations + if (buildOptions.clean && buildOptions.force) { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Options_0_and_1_cannot_be_combined, "clean", "force")); + } + if (buildOptions.clean && buildOptions.verbose) { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Options_0_and_1_cannot_be_combined, "clean", "verbose")); + } + if (buildOptions.clean && buildOptions.watch) { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Options_0_and_1_cannot_be_combined, "clean", "watch")); + } + if (buildOptions.watch && buildOptions.dry) { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Options_0_and_1_cannot_be_combined, "watch", "dry")); + } + return { buildOptions: buildOptions, watchOptions: watchOptions, projects: projects, errors: errors }; + } + ts.parseBuildCommand = parseBuildCommand; + /* @internal */ + function getDiagnosticText(_message) { + var _args = []; + for (var _i = 1; _i < arguments.length; _i++) { + _args[_i - 1] = arguments[_i]; + } + var diagnostic = ts.createCompilerDiagnostic.apply(undefined, arguments); + return diagnostic.messageText; + } + ts.getDiagnosticText = getDiagnosticText; + /** + * Reads the config file, reports errors if any and exits if the config file cannot be found + */ + function getParsedCommandLineOfConfigFile(configFileName, optionsToExtend, host, extendedConfigCache, watchOptionsToExtend, extraFileExtensions) { + var configFileText = tryReadFile(configFileName, function (fileName) { return host.readFile(fileName); }); + if (!ts.isString(configFileText)) { + host.onUnRecoverableConfigFileDiagnostic(configFileText); + return undefined; + } + var result = ts.parseJsonText(configFileName, configFileText); + var cwd = host.getCurrentDirectory(); + result.path = ts.toPath(configFileName, cwd, ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames)); + result.resolvedPath = result.path; + result.originalFileName = result.fileName; + return parseJsonSourceFileConfigFileContent(result, host, ts.getNormalizedAbsolutePath(ts.getDirectoryPath(configFileName), cwd), optionsToExtend, ts.getNormalizedAbsolutePath(configFileName, cwd), + /*resolutionStack*/ undefined, extraFileExtensions, extendedConfigCache, watchOptionsToExtend); + } + ts.getParsedCommandLineOfConfigFile = getParsedCommandLineOfConfigFile; + /** + * Read tsconfig.json file + * @param fileName The path to the config file + */ + function readConfigFile(fileName, readFile) { + var textOrDiagnostic = tryReadFile(fileName, readFile); + return ts.isString(textOrDiagnostic) ? parseConfigFileTextToJson(fileName, textOrDiagnostic) : { config: {}, error: textOrDiagnostic }; + } + ts.readConfigFile = readConfigFile; + /** + * Parse the text of the tsconfig.json file + * @param fileName The path to the config file + * @param jsonText The text of the config file + */ + function parseConfigFileTextToJson(fileName, jsonText) { + var jsonSourceFile = ts.parseJsonText(fileName, jsonText); + return { + config: convertConfigFileToObject(jsonSourceFile, jsonSourceFile.parseDiagnostics, /*reportOptionsErrors*/ false, /*optionsIterator*/ undefined), + error: jsonSourceFile.parseDiagnostics.length ? jsonSourceFile.parseDiagnostics[0] : undefined + }; + } + ts.parseConfigFileTextToJson = parseConfigFileTextToJson; + /** + * Read tsconfig.json file + * @param fileName The path to the config file + */ + function readJsonConfigFile(fileName, readFile) { + var textOrDiagnostic = tryReadFile(fileName, readFile); + return ts.isString(textOrDiagnostic) ? ts.parseJsonText(fileName, textOrDiagnostic) : { fileName: fileName, parseDiagnostics: [textOrDiagnostic] }; + } + ts.readJsonConfigFile = readJsonConfigFile; + /*@internal*/ + function tryReadFile(fileName, readFile) { + var text; + try { + text = readFile(fileName); + } + catch (e) { + return ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_read_file_0_Colon_1, fileName, e.message); + } + return text === undefined ? ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_read_file_0, fileName) : text; + } + ts.tryReadFile = tryReadFile; + function commandLineOptionsToMap(options) { + return ts.arrayToMap(options, getOptionName); + } + var typeAcquisitionDidYouMeanDiagnostics = { + optionDeclarations: ts.typeAcquisitionDeclarations, + unknownOptionDiagnostic: ts.Diagnostics.Unknown_type_acquisition_option_0, + unknownDidYouMeanDiagnostic: ts.Diagnostics.Unknown_type_acquisition_option_0_Did_you_mean_1, + }; + var watchOptionsNameMapCache; + function getWatchOptionsNameMap() { + return watchOptionsNameMapCache || (watchOptionsNameMapCache = createOptionNameMap(ts.optionsForWatch)); + } + var watchOptionsDidYouMeanDiagnostics = { + getOptionsNameMap: getWatchOptionsNameMap, + optionDeclarations: ts.optionsForWatch, + unknownOptionDiagnostic: ts.Diagnostics.Unknown_watch_option_0, + unknownDidYouMeanDiagnostic: ts.Diagnostics.Unknown_watch_option_0_Did_you_mean_1, + optionTypeMismatchDiagnostic: ts.Diagnostics.Watch_option_0_requires_a_value_of_type_1 + }; + var commandLineCompilerOptionsMapCache; + function getCommandLineCompilerOptionsMap() { + return commandLineCompilerOptionsMapCache || (commandLineCompilerOptionsMapCache = commandLineOptionsToMap(ts.optionDeclarations)); + } + var commandLineWatchOptionsMapCache; + function getCommandLineWatchOptionsMap() { + return commandLineWatchOptionsMapCache || (commandLineWatchOptionsMapCache = commandLineOptionsToMap(ts.optionsForWatch)); + } + var commandLineTypeAcquisitionMapCache; + function getCommandLineTypeAcquisitionMap() { + return commandLineTypeAcquisitionMapCache || (commandLineTypeAcquisitionMapCache = commandLineOptionsToMap(ts.typeAcquisitionDeclarations)); + } + var _tsconfigRootOptions; + function getTsconfigRootOptionsMap() { + if (_tsconfigRootOptions === undefined) { + _tsconfigRootOptions = { + name: undefined, + type: "object", + elementOptions: commandLineOptionsToMap([ + { + name: "compilerOptions", + type: "object", + elementOptions: getCommandLineCompilerOptionsMap(), + extraKeyDiagnostics: ts.compilerOptionsDidYouMeanDiagnostics, + }, + { + name: "watchOptions", + type: "object", + elementOptions: getCommandLineWatchOptionsMap(), + extraKeyDiagnostics: watchOptionsDidYouMeanDiagnostics, + }, + { + name: "typingOptions", + type: "object", + elementOptions: getCommandLineTypeAcquisitionMap(), + extraKeyDiagnostics: typeAcquisitionDidYouMeanDiagnostics, + }, + { + name: "typeAcquisition", + type: "object", + elementOptions: getCommandLineTypeAcquisitionMap(), + extraKeyDiagnostics: typeAcquisitionDidYouMeanDiagnostics + }, + { + name: "extends", + type: "string", + category: ts.Diagnostics.File_Management, + }, + { + name: "references", + type: "list", + element: { + name: "references", + type: "object" + }, + category: ts.Diagnostics.Projects, + }, + { + name: "files", + type: "list", + element: { + name: "files", + type: "string" + }, + category: ts.Diagnostics.File_Management, + }, + { + name: "include", + type: "list", + element: { + name: "include", + type: "string" + }, + category: ts.Diagnostics.File_Management, + defaultValueDescription: ts.Diagnostics.if_files_is_specified_otherwise_Asterisk_Asterisk_Slash_Asterisk + }, + { + name: "exclude", + type: "list", + element: { + name: "exclude", + type: "string" + }, + category: ts.Diagnostics.File_Management, + defaultValueDescription: ts.Diagnostics.node_modules_bower_components_jspm_packages_plus_the_value_of_outDir_if_one_is_specified + }, + ts.compileOnSaveCommandLineOption + ]) + }; + } + return _tsconfigRootOptions; + } + function convertConfigFileToObject(sourceFile, errors, reportOptionsErrors, optionsIterator) { + var _a; + var rootExpression = (_a = sourceFile.statements[0]) === null || _a === void 0 ? void 0 : _a.expression; + var knownRootOptions = reportOptionsErrors ? getTsconfigRootOptionsMap() : undefined; + if (rootExpression && rootExpression.kind !== 207 /* SyntaxKind.ObjectLiteralExpression */) { + errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, rootExpression, ts.Diagnostics.The_root_value_of_a_0_file_must_be_an_object, ts.getBaseFileName(sourceFile.fileName) === "jsconfig.json" ? "jsconfig.json" : "tsconfig.json")); + // Last-ditch error recovery. Somewhat useful because the JSON parser will recover from some parse errors by + // synthesizing a top-level array literal expression. There's a reasonable chance the first element of that + // array is a well-formed configuration object, made into an array element by stray characters. + if (ts.isArrayLiteralExpression(rootExpression)) { + var firstObject = ts.find(rootExpression.elements, ts.isObjectLiteralExpression); + if (firstObject) { + return convertToObjectWorker(sourceFile, firstObject, errors, /*returnValue*/ true, knownRootOptions, optionsIterator); + } + } + return {}; + } + return convertToObjectWorker(sourceFile, rootExpression, errors, /*returnValue*/ true, knownRootOptions, optionsIterator); + } + /** + * Convert the json syntax tree into the json value + */ + function convertToObject(sourceFile, errors) { + var _a; + return convertToObjectWorker(sourceFile, (_a = sourceFile.statements[0]) === null || _a === void 0 ? void 0 : _a.expression, errors, /*returnValue*/ true, /*knownRootOptions*/ undefined, /*jsonConversionNotifier*/ undefined); + } + ts.convertToObject = convertToObject; + /** + * Convert the json syntax tree into the json value and report errors + * This returns the json value (apart from checking errors) only if returnValue provided is true. + * Otherwise it just checks the errors and returns undefined + */ + /*@internal*/ + function convertToObjectWorker(sourceFile, rootExpression, errors, returnValue, knownRootOptions, jsonConversionNotifier) { + if (!rootExpression) { + return returnValue ? {} : undefined; + } + return convertPropertyValueToJson(rootExpression, knownRootOptions); + function isRootOptionMap(knownOptions) { + return knownRootOptions && knownRootOptions.elementOptions === knownOptions; + } + function convertObjectLiteralExpressionToJson(node, knownOptions, extraKeyDiagnostics, parentOption) { + var result = returnValue ? {} : undefined; + var _loop_4 = function (element) { + if (element.kind !== 299 /* SyntaxKind.PropertyAssignment */) { + errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, element, ts.Diagnostics.Property_assignment_expected)); + return "continue"; + } + if (element.questionToken) { + errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, element.questionToken, ts.Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, "?")); + } + if (!isDoubleQuotedString(element.name)) { + errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, element.name, ts.Diagnostics.String_literal_with_double_quotes_expected)); + } + var textOfKey = ts.isComputedNonLiteralName(element.name) ? undefined : ts.getTextOfPropertyName(element.name); + var keyText = textOfKey && ts.unescapeLeadingUnderscores(textOfKey); + var option = keyText && knownOptions ? knownOptions.get(keyText) : undefined; + if (keyText && extraKeyDiagnostics && !option) { + if (knownOptions) { + errors.push(createUnknownOptionError(keyText, extraKeyDiagnostics, function (message, arg0, arg1) { return ts.createDiagnosticForNodeInSourceFile(sourceFile, element.name, message, arg0, arg1); })); + } + else { + errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, element.name, extraKeyDiagnostics.unknownOptionDiagnostic, keyText)); + } + } + var value = convertPropertyValueToJson(element.initializer, option); + if (typeof keyText !== "undefined") { + if (returnValue) { + result[keyText] = value; + } + // Notify key value set, if user asked for it + if (jsonConversionNotifier && + // Current callbacks are only on known parent option or if we are setting values in the root + (parentOption || isRootOptionMap(knownOptions))) { + var isValidOptionValue = isCompilerOptionsValue(option, value); + if (parentOption) { + if (isValidOptionValue) { + // Notify option set in the parent if its a valid option value + jsonConversionNotifier.onSetValidOptionKeyValueInParent(parentOption, option, value); + } + } + else if (isRootOptionMap(knownOptions)) { + if (isValidOptionValue) { + // Notify about the valid root key value being set + jsonConversionNotifier.onSetValidOptionKeyValueInRoot(keyText, element.name, value, element.initializer); + } + else if (!option) { + // Notify about the unknown root key value being set + jsonConversionNotifier.onSetUnknownOptionKeyValueInRoot(keyText, element.name, value, element.initializer); + } + } + } + } + }; + for (var _i = 0, _a = node.properties; _i < _a.length; _i++) { + var element = _a[_i]; + _loop_4(element); + } + return result; + } + function convertArrayLiteralExpressionToJson(elements, elementOption) { + if (!returnValue) { + elements.forEach(function (element) { return convertPropertyValueToJson(element, elementOption); }); + return undefined; + } + // Filter out invalid values + return ts.filter(elements.map(function (element) { return convertPropertyValueToJson(element, elementOption); }), function (v) { return v !== undefined; }); + } + function convertPropertyValueToJson(valueExpression, option) { + var invalidReported; + switch (valueExpression.kind) { + case 110 /* SyntaxKind.TrueKeyword */: + reportInvalidOptionValue(option && option.type !== "boolean"); + return validateValue(/*value*/ true); + case 95 /* SyntaxKind.FalseKeyword */: + reportInvalidOptionValue(option && option.type !== "boolean"); + return validateValue(/*value*/ false); + case 104 /* SyntaxKind.NullKeyword */: + reportInvalidOptionValue(option && option.name === "extends"); // "extends" is the only option we don't allow null/undefined for + return validateValue(/*value*/ null); // eslint-disable-line no-null/no-null + case 10 /* SyntaxKind.StringLiteral */: + if (!isDoubleQuotedString(valueExpression)) { + errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, ts.Diagnostics.String_literal_with_double_quotes_expected)); + } + reportInvalidOptionValue(option && (ts.isString(option.type) && option.type !== "string")); + var text = valueExpression.text; + if (option && !ts.isString(option.type)) { + var customOption = option; + // Validate custom option type + if (!customOption.type.has(text.toLowerCase())) { + errors.push(createDiagnosticForInvalidCustomType(customOption, function (message, arg0, arg1) { return ts.createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, message, arg0, arg1); })); + invalidReported = true; + } + } + return validateValue(text); + case 8 /* SyntaxKind.NumericLiteral */: + reportInvalidOptionValue(option && option.type !== "number"); + return validateValue(Number(valueExpression.text)); + case 221 /* SyntaxKind.PrefixUnaryExpression */: + if (valueExpression.operator !== 40 /* SyntaxKind.MinusToken */ || valueExpression.operand.kind !== 8 /* SyntaxKind.NumericLiteral */) { + break; // not valid JSON syntax + } + reportInvalidOptionValue(option && option.type !== "number"); + return validateValue(-Number(valueExpression.operand.text)); + case 207 /* SyntaxKind.ObjectLiteralExpression */: + reportInvalidOptionValue(option && option.type !== "object"); + var objectLiteralExpression = valueExpression; + // Currently having element option declaration in the tsconfig with type "object" + // determines if it needs onSetValidOptionKeyValueInParent callback or not + // At moment there are only "compilerOptions", "typeAcquisition" and "typingOptions" + // that satifies it and need it to modify options set in them (for normalizing file paths) + // vs what we set in the json + // If need arises, we can modify this interface and callbacks as needed + if (option) { + var _a = option, elementOptions = _a.elementOptions, extraKeyDiagnostics = _a.extraKeyDiagnostics, optionName = _a.name; + return validateValue(convertObjectLiteralExpressionToJson(objectLiteralExpression, elementOptions, extraKeyDiagnostics, optionName)); + } + else { + return validateValue(convertObjectLiteralExpressionToJson(objectLiteralExpression, /* knownOptions*/ undefined, + /*extraKeyDiagnosticMessage */ undefined, /*parentOption*/ undefined)); + } + case 206 /* SyntaxKind.ArrayLiteralExpression */: + reportInvalidOptionValue(option && option.type !== "list"); + return validateValue(convertArrayLiteralExpressionToJson(valueExpression.elements, option && option.element)); + } + // Not in expected format + if (option) { + reportInvalidOptionValue(/*isError*/ true); + } + else { + errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, ts.Diagnostics.Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_literal)); + } + return undefined; + function validateValue(value) { + var _a; + if (!invalidReported) { + var diagnostic = (_a = option === null || option === void 0 ? void 0 : option.extraValidation) === null || _a === void 0 ? void 0 : _a.call(option, value); + if (diagnostic) { + errors.push(ts.createDiagnosticForNodeInSourceFile.apply(void 0, __spreadArray([sourceFile, valueExpression], diagnostic, false))); + return undefined; + } + } + return value; + } + function reportInvalidOptionValue(isError) { + if (isError) { + errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, option.name, getCompilerOptionValueTypeString(option))); + invalidReported = true; + } + } + } + function isDoubleQuotedString(node) { + return ts.isStringLiteral(node) && ts.isStringDoubleQuoted(node, sourceFile); + } + } + ts.convertToObjectWorker = convertToObjectWorker; + function getCompilerOptionValueTypeString(option) { + return option.type === "list" ? + "Array" : + ts.isString(option.type) ? option.type : "string"; + } + function isCompilerOptionsValue(option, value) { + if (option) { + if (isNullOrUndefined(value)) + return true; // All options are undefinable/nullable + if (option.type === "list") { + return ts.isArray(value); + } + var expectedType = ts.isString(option.type) ? option.type : "string"; + return typeof value === expectedType; + } + return false; + } + /** + * Generate an uncommented, complete tsconfig for use with "--showConfig" + * @param configParseResult options to be generated into tsconfig.json + * @param configFileName name of the parsed config file - output paths will be generated relative to this + * @param host provides current directory and case sensitivity services + */ + /** @internal */ + function convertToTSConfig(configParseResult, configFileName, host) { + var _a, _b, _c; + var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames); + var files = ts.map(ts.filter(configParseResult.fileNames, !((_b = (_a = configParseResult.options.configFile) === null || _a === void 0 ? void 0 : _a.configFileSpecs) === null || _b === void 0 ? void 0 : _b.validatedIncludeSpecs) ? ts.returnTrue : matchesSpecs(configFileName, configParseResult.options.configFile.configFileSpecs.validatedIncludeSpecs, configParseResult.options.configFile.configFileSpecs.validatedExcludeSpecs, host)), function (f) { return ts.getRelativePathFromFile(ts.getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), ts.getNormalizedAbsolutePath(f, host.getCurrentDirectory()), getCanonicalFileName); }); + var optionMap = serializeCompilerOptions(configParseResult.options, { configFilePath: ts.getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), useCaseSensitiveFileNames: host.useCaseSensitiveFileNames }); + var watchOptionMap = configParseResult.watchOptions && serializeWatchOptions(configParseResult.watchOptions); + var config = __assign(__assign({ compilerOptions: __assign(__assign({}, optionMapToObject(optionMap)), { showConfig: undefined, configFile: undefined, configFilePath: undefined, help: undefined, init: undefined, listFiles: undefined, listEmittedFiles: undefined, project: undefined, build: undefined, version: undefined }), watchOptions: watchOptionMap && optionMapToObject(watchOptionMap), references: ts.map(configParseResult.projectReferences, function (r) { return (__assign(__assign({}, r), { path: r.originalPath ? r.originalPath : "", originalPath: undefined })); }), files: ts.length(files) ? files : undefined }, (((_c = configParseResult.options.configFile) === null || _c === void 0 ? void 0 : _c.configFileSpecs) ? { + include: filterSameAsDefaultInclude(configParseResult.options.configFile.configFileSpecs.validatedIncludeSpecs), + exclude: configParseResult.options.configFile.configFileSpecs.validatedExcludeSpecs + } : {})), { compileOnSave: !!configParseResult.compileOnSave ? true : undefined }); + return config; + } + ts.convertToTSConfig = convertToTSConfig; + function optionMapToObject(optionMap) { + return __assign({}, ts.arrayFrom(optionMap.entries()).reduce(function (prev, cur) { + var _a; + return (__assign(__assign({}, prev), (_a = {}, _a[cur[0]] = cur[1], _a))); + }, {})); + } + function filterSameAsDefaultInclude(specs) { + if (!ts.length(specs)) + return undefined; + if (ts.length(specs) !== 1) + return specs; + if (specs[0] === ts.defaultIncludeSpec) + return undefined; + return specs; + } + function matchesSpecs(path, includeSpecs, excludeSpecs, host) { + if (!includeSpecs) + return ts.returnTrue; + var patterns = ts.getFileMatcherPatterns(path, excludeSpecs, includeSpecs, host.useCaseSensitiveFileNames, host.getCurrentDirectory()); + var excludeRe = patterns.excludePattern && ts.getRegexFromPattern(patterns.excludePattern, host.useCaseSensitiveFileNames); + var includeRe = patterns.includeFilePattern && ts.getRegexFromPattern(patterns.includeFilePattern, host.useCaseSensitiveFileNames); + if (includeRe) { + if (excludeRe) { + return function (path) { return !(includeRe.test(path) && !excludeRe.test(path)); }; + } + return function (path) { return !includeRe.test(path); }; + } + if (excludeRe) { + return function (path) { return excludeRe.test(path); }; + } + return ts.returnTrue; + } + function getCustomTypeMapOfCommandLineOption(optionDefinition) { + if (optionDefinition.type === "string" || optionDefinition.type === "number" || optionDefinition.type === "boolean" || optionDefinition.type === "object") { + // this is of a type CommandLineOptionOfPrimitiveType + return undefined; + } + else if (optionDefinition.type === "list") { + return getCustomTypeMapOfCommandLineOption(optionDefinition.element); + } + else { + return optionDefinition.type; + } + } + /* @internal */ + function getNameOfCompilerOptionValue(value, customTypeMap) { + // There is a typeMap associated with this command-line option so use it to map value back to its name + return ts.forEachEntry(customTypeMap, function (mapValue, key) { + if (mapValue === value) { + return key; + } + }); + } + ts.getNameOfCompilerOptionValue = getNameOfCompilerOptionValue; + function serializeCompilerOptions(options, pathOptions) { + return serializeOptionBaseObject(options, getOptionsNameMap(), pathOptions); + } + function serializeWatchOptions(options) { + return serializeOptionBaseObject(options, getWatchOptionsNameMap()); + } + function serializeOptionBaseObject(options, _a, pathOptions) { + var optionsNameMap = _a.optionsNameMap; + var result = new ts.Map(); + var getCanonicalFileName = pathOptions && ts.createGetCanonicalFileName(pathOptions.useCaseSensitiveFileNames); + var _loop_5 = function (name) { + if (ts.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 + if (optionsNameMap.has(name) && (optionsNameMap.get(name).category === ts.Diagnostics.Command_line_Options || optionsNameMap.get(name).category === ts.Diagnostics.Output_Formatting)) { + return "continue"; + } + var value = options[name]; + var optionDefinition = optionsNameMap.get(name.toLowerCase()); + if (optionDefinition) { + var customTypeMap_1 = getCustomTypeMapOfCommandLineOption(optionDefinition); + if (!customTypeMap_1) { + // 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 + if (pathOptions && optionDefinition.isFilePath) { + result.set(name, ts.getRelativePathFromFile(pathOptions.configFilePath, ts.getNormalizedAbsolutePath(value, ts.getDirectoryPath(pathOptions.configFilePath)), getCanonicalFileName)); + } + else { + result.set(name, value); + } + } + else { + if (optionDefinition.type === "list") { + result.set(name, value.map(function (element) { return getNameOfCompilerOptionValue(element, customTypeMap_1); })); // TODO: GH#18217 + } + else { + // There is a typeMap associated with this command-line option so use it to map value back to its name + result.set(name, getNameOfCompilerOptionValue(value, customTypeMap_1)); + } + } + } + } + }; + for (var name in options) { + _loop_5(name); + } + return result; + } + /** + * Generate a list of the compiler options whose value is not the default. + * @param options compilerOptions to be evaluated. + /** @internal */ + function getCompilerOptionsDiffValue(options, newLine) { + var compilerOptionsMap = getSerializedCompilerOption(options); + return getOverwrittenDefaultOptions(); + function makePadding(paddingLength) { + return Array(paddingLength + 1).join(" "); + } + function getOverwrittenDefaultOptions() { + var result = []; + var tab = makePadding(2); + commandOptionsWithoutBuild.forEach(function (cmd) { + if (!compilerOptionsMap.has(cmd.name)) { + return; + } + var newValue = compilerOptionsMap.get(cmd.name); + var defaultValue = getDefaultValueForOption(cmd); + if (newValue !== defaultValue) { + result.push("".concat(tab).concat(cmd.name, ": ").concat(newValue)); + } + else if (ts.hasProperty(ts.defaultInitCompilerOptions, cmd.name)) { + result.push("".concat(tab).concat(cmd.name, ": ").concat(defaultValue)); + } + }); + return result.join(newLine) + newLine; + } + } + ts.getCompilerOptionsDiffValue = getCompilerOptionsDiffValue; + /** + * Get the compiler options to be written into the tsconfig.json. + * @param options commandlineOptions to be included in the compileOptions. + */ + function getSerializedCompilerOption(options) { + var compilerOptions = ts.extend(options, ts.defaultInitCompilerOptions); + return serializeCompilerOptions(compilerOptions); + } + /** + * Generate tsconfig configuration when running command line "--init" + * @param options commandlineOptions to be generated into tsconfig.json + * @param fileNames array of filenames to be generated into tsconfig.json + */ + /* @internal */ + function generateTSConfig(options, fileNames, newLine) { + var compilerOptionsMap = getSerializedCompilerOption(options); + return writeConfigurations(); + function makePadding(paddingLength) { + return Array(paddingLength + 1).join(" "); + } + function isAllowedOptionForOutput(_a) { + var category = _a.category, name = _a.name, isCommandLineOnly = _a.isCommandLineOnly; + // Skip options which do not have a category or have categories which are more niche + var categoriesToSkip = [ts.Diagnostics.Command_line_Options, ts.Diagnostics.Editor_Support, ts.Diagnostics.Compiler_Diagnostics, ts.Diagnostics.Backwards_Compatibility, ts.Diagnostics.Watch_and_Build_Modes, ts.Diagnostics.Output_Formatting]; + return !isCommandLineOnly && category !== undefined && (!categoriesToSkip.includes(category) || compilerOptionsMap.has(name)); + } + function writeConfigurations() { + // Filter applicable options to place in the file + var categorizedOptions = new ts.Map(); + // Set allowed categories in order + categorizedOptions.set(ts.Diagnostics.Projects, []); + categorizedOptions.set(ts.Diagnostics.Language_and_Environment, []); + categorizedOptions.set(ts.Diagnostics.Modules, []); + categorizedOptions.set(ts.Diagnostics.JavaScript_Support, []); + categorizedOptions.set(ts.Diagnostics.Emit, []); + categorizedOptions.set(ts.Diagnostics.Interop_Constraints, []); + categorizedOptions.set(ts.Diagnostics.Type_Checking, []); + categorizedOptions.set(ts.Diagnostics.Completeness, []); + for (var _i = 0, optionDeclarations_1 = ts.optionDeclarations; _i < optionDeclarations_1.length; _i++) { + var option = optionDeclarations_1[_i]; + if (isAllowedOptionForOutput(option)) { + var listForCategory = categorizedOptions.get(option.category); + if (!listForCategory) + categorizedOptions.set(option.category, listForCategory = []); + listForCategory.push(option); + } + } + // Serialize all options and their descriptions + var marginLength = 0; + var seenKnownKeys = 0; + var entries = []; + categorizedOptions.forEach(function (options, category) { + if (entries.length !== 0) { + entries.push({ value: "" }); + } + entries.push({ value: "/* ".concat(ts.getLocaleSpecificMessage(category), " */") }); + for (var _i = 0, options_1 = options; _i < options_1.length; _i++) { + var option = options_1[_i]; + var optionName = void 0; + if (compilerOptionsMap.has(option.name)) { + optionName = "\"".concat(option.name, "\": ").concat(JSON.stringify(compilerOptionsMap.get(option.name))).concat((seenKnownKeys += 1) === compilerOptionsMap.size ? "" : ","); + } + else { + optionName = "// \"".concat(option.name, "\": ").concat(JSON.stringify(getDefaultValueForOption(option)), ","); + } + entries.push({ + value: optionName, + description: "/* ".concat(option.description && ts.getLocaleSpecificMessage(option.description) || option.name, " */") + }); + marginLength = Math.max(optionName.length, marginLength); + } + }); + // Write the output + var tab = makePadding(2); + var result = []; + result.push("{"); + result.push("".concat(tab, "\"compilerOptions\": {")); + result.push("".concat(tab).concat(tab, "/* ").concat(ts.getLocaleSpecificMessage(ts.Diagnostics.Visit_https_Colon_Slash_Slashaka_ms_Slashtsconfig_to_read_more_about_this_file), " */")); + result.push(""); + // Print out each row, aligning all the descriptions on the same column. + for (var _a = 0, entries_2 = entries; _a < entries_2.length; _a++) { + var entry = entries_2[_a]; + var value = entry.value, _b = entry.description, description = _b === void 0 ? "" : _b; + result.push(value && "".concat(tab).concat(tab).concat(value).concat(description && (makePadding(marginLength - value.length + 2) + description))); + } + if (fileNames.length) { + result.push("".concat(tab, "},")); + result.push("".concat(tab, "\"files\": [")); + for (var i = 0; i < fileNames.length; i++) { + result.push("".concat(tab).concat(tab).concat(JSON.stringify(fileNames[i])).concat(i === fileNames.length - 1 ? "" : ",")); + } + result.push("".concat(tab, "]")); + } + else { + result.push("".concat(tab, "}")); + } + result.push("}"); + return result.join(newLine) + newLine; + } + } + ts.generateTSConfig = generateTSConfig; + /* @internal */ + function convertToOptionsWithAbsolutePaths(options, toAbsolutePath) { + var result = {}; + var optionsNameMap = getOptionsNameMap().optionsNameMap; + for (var name in options) { + if (ts.hasProperty(options, name)) { + result[name] = convertToOptionValueWithAbsolutePaths(optionsNameMap.get(name.toLowerCase()), options[name], toAbsolutePath); + } + } + if (result.configFilePath) { + result.configFilePath = toAbsolutePath(result.configFilePath); + } + return result; + } + ts.convertToOptionsWithAbsolutePaths = convertToOptionsWithAbsolutePaths; + function convertToOptionValueWithAbsolutePaths(option, value, toAbsolutePath) { + if (option && !isNullOrUndefined(value)) { + if (option.type === "list") { + var values = value; + if (option.element.isFilePath && values.length) { + return values.map(toAbsolutePath); + } + } + else if (option.isFilePath) { + return toAbsolutePath(value); + } + } + return value; + } + /** + * Parse the contents of a config file (tsconfig.json). + * @param json The contents of the config file to parse + * @param host Instance of ParseConfigHost used to enumerate files in folder. + * @param basePath A root directory to resolve relative path entries in the config + * file to. e.g. outDir + */ + function parseJsonConfigFileContent(json, host, basePath, existingOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache, existingWatchOptions) { + return parseJsonConfigFileContentWorker(json, /*sourceFile*/ undefined, host, basePath, existingOptions, existingWatchOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache); + } + ts.parseJsonConfigFileContent = parseJsonConfigFileContent; + /** + * Parse the contents of a config file (tsconfig.json). + * @param jsonNode The contents of the config file to parse + * @param host Instance of ParseConfigHost used to enumerate files in folder. + * @param basePath A root directory to resolve relative path entries in the config + * file to. e.g. outDir + */ + function parseJsonSourceFileConfigFileContent(sourceFile, host, basePath, existingOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache, existingWatchOptions) { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("parse" /* tracing.Phase.Parse */, "parseJsonSourceFileConfigFileContent", { path: sourceFile.fileName }); + var result = parseJsonConfigFileContentWorker(/*json*/ undefined, sourceFile, host, basePath, existingOptions, existingWatchOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + return result; + } + ts.parseJsonSourceFileConfigFileContent = parseJsonSourceFileConfigFileContent; + /*@internal*/ + function setConfigFileInOptions(options, configFile) { + if (configFile) { + Object.defineProperty(options, "configFile", { enumerable: false, writable: false, value: configFile }); + } + } + ts.setConfigFileInOptions = setConfigFileInOptions; + function isNullOrUndefined(x) { + return x === undefined || x === null; // eslint-disable-line no-null/no-null + } + function directoryOfCombinedPath(fileName, basePath) { + // Use the `getNormalizedAbsolutePath` function to avoid canonicalizing the path, as it must remain noncanonical + // until consistent casing errors are reported + return ts.getDirectoryPath(ts.getNormalizedAbsolutePath(fileName, basePath)); + } + /*@internal*/ + ts.defaultIncludeSpec = "**/*"; + /** + * Parse the contents of a config file from json or json source file (tsconfig.json). + * @param json The contents of the config file to parse + * @param sourceFile sourceFile corresponding to the Json + * @param host Instance of ParseConfigHost used to enumerate files in folder. + * @param basePath A root directory to resolve relative path entries in the config + * file to. e.g. outDir + * @param resolutionStack Only present for backwards-compatibility. Should be empty. + */ + function parseJsonConfigFileContentWorker(json, sourceFile, host, basePath, existingOptions, existingWatchOptions, configFileName, resolutionStack, extraFileExtensions, extendedConfigCache) { + if (existingOptions === void 0) { existingOptions = {}; } + if (resolutionStack === void 0) { resolutionStack = []; } + if (extraFileExtensions === void 0) { extraFileExtensions = []; } + ts.Debug.assert((json === undefined && sourceFile !== undefined) || (json !== undefined && sourceFile === undefined)); + var errors = []; + var parsedConfig = parseConfig(json, sourceFile, host, basePath, configFileName, resolutionStack, errors, extendedConfigCache); + var raw = parsedConfig.raw; + var options = ts.extend(existingOptions, parsedConfig.options || {}); + var watchOptions = existingWatchOptions && parsedConfig.watchOptions ? + ts.extend(existingWatchOptions, parsedConfig.watchOptions) : + parsedConfig.watchOptions || existingWatchOptions; + options.configFilePath = configFileName && ts.normalizeSlashes(configFileName); + var configFileSpecs = getConfigFileSpecs(); + if (sourceFile) + sourceFile.configFileSpecs = configFileSpecs; + setConfigFileInOptions(options, sourceFile); + var basePathForFileNames = ts.normalizePath(configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath); + return { + options: options, + watchOptions: watchOptions, + fileNames: getFileNames(basePathForFileNames), + projectReferences: getProjectReferences(basePathForFileNames), + typeAcquisition: parsedConfig.typeAcquisition || getDefaultTypeAcquisition(), + raw: raw, + errors: errors, + // Wildcard directories (provided as part of a wildcard path) are stored in a + // file map that marks whether it was a regular wildcard match (with a `*` or `?` token), + // or a recursive directory. This information is used by filesystem watchers to monitor for + // new entries in these paths. + wildcardDirectories: getWildcardDirectories(configFileSpecs, basePathForFileNames, host.useCaseSensitiveFileNames), + compileOnSave: !!raw.compileOnSave, + }; + function getConfigFileSpecs() { + var referencesOfRaw = getPropFromRaw("references", function (element) { return typeof element === "object"; }, "object"); + var filesSpecs = toPropValue(getSpecsFromRaw("files")); + if (filesSpecs) { + var hasZeroOrNoReferences = referencesOfRaw === "no-prop" || ts.isArray(referencesOfRaw) && referencesOfRaw.length === 0; + var hasExtends = ts.hasProperty(raw, "extends"); + if (filesSpecs.length === 0 && hasZeroOrNoReferences && !hasExtends) { + if (sourceFile) { + var fileName = configFileName || "tsconfig.json"; + var diagnosticMessage = ts.Diagnostics.The_files_list_in_config_file_0_is_empty; + var nodeValue = ts.firstDefined(ts.getTsConfigPropArray(sourceFile, "files"), function (property) { return property.initializer; }); + var error = nodeValue + ? ts.createDiagnosticForNodeInSourceFile(sourceFile, nodeValue, diagnosticMessage, fileName) + : ts.createCompilerDiagnostic(diagnosticMessage, fileName); + errors.push(error); + } + else { + createCompilerDiagnosticOnlyIfJson(ts.Diagnostics.The_files_list_in_config_file_0_is_empty, configFileName || "tsconfig.json"); + } + } + } + var includeSpecs = toPropValue(getSpecsFromRaw("include")); + var excludeOfRaw = getSpecsFromRaw("exclude"); + var isDefaultIncludeSpec = false; + var excludeSpecs = toPropValue(excludeOfRaw); + if (excludeOfRaw === "no-prop" && raw.compilerOptions) { + var outDir = raw.compilerOptions.outDir; + var declarationDir = raw.compilerOptions.declarationDir; + if (outDir || declarationDir) { + excludeSpecs = [outDir, declarationDir].filter(function (d) { return !!d; }); + } + } + if (filesSpecs === undefined && includeSpecs === undefined) { + includeSpecs = [ts.defaultIncludeSpec]; + isDefaultIncludeSpec = true; + } + var validatedIncludeSpecs, validatedExcludeSpecs; + // The exclude spec list is converted into a regular expression, which allows us to quickly + // test whether a file or directory should be excluded before recursively traversing the + // file system. + if (includeSpecs) { + validatedIncludeSpecs = validateSpecs(includeSpecs, errors, /*disallowTrailingRecursion*/ true, sourceFile, "include"); + } + if (excludeSpecs) { + validatedExcludeSpecs = validateSpecs(excludeSpecs, errors, /*disallowTrailingRecursion*/ false, sourceFile, "exclude"); + } + return { + filesSpecs: filesSpecs, + includeSpecs: includeSpecs, + excludeSpecs: excludeSpecs, + validatedFilesSpec: ts.filter(filesSpecs, ts.isString), + validatedIncludeSpecs: validatedIncludeSpecs, + validatedExcludeSpecs: validatedExcludeSpecs, + pathPatterns: undefined, + isDefaultIncludeSpec: isDefaultIncludeSpec, + }; + } + function getFileNames(basePath) { + var fileNames = getFileNamesFromConfigSpecs(configFileSpecs, basePath, options, host, extraFileExtensions); + if (shouldReportNoInputFiles(fileNames, canJsonReportNoInputFiles(raw), resolutionStack)) { + errors.push(getErrorForNoInputFiles(configFileSpecs, configFileName)); + } + return fileNames; + } + function getProjectReferences(basePath) { + var projectReferences; + var referencesOfRaw = getPropFromRaw("references", function (element) { return typeof element === "object"; }, "object"); + if (ts.isArray(referencesOfRaw)) { + for (var _i = 0, referencesOfRaw_1 = referencesOfRaw; _i < referencesOfRaw_1.length; _i++) { + var ref = referencesOfRaw_1[_i]; + if (typeof ref.path !== "string") { + createCompilerDiagnosticOnlyIfJson(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "reference.path", "string"); + } + else { + (projectReferences || (projectReferences = [])).push({ + path: ts.getNormalizedAbsolutePath(ref.path, basePath), + originalPath: ref.path, + prepend: ref.prepend, + circular: ref.circular + }); + } + } + } + return projectReferences; + } + function toPropValue(specResult) { + return ts.isArray(specResult) ? specResult : undefined; + } + function getSpecsFromRaw(prop) { + return getPropFromRaw(prop, ts.isString, "string"); + } + function getPropFromRaw(prop, validateElement, elementTypeName) { + if (ts.hasProperty(raw, prop) && !isNullOrUndefined(raw[prop])) { + if (ts.isArray(raw[prop])) { + var result = raw[prop]; + if (!sourceFile && !ts.every(result, validateElement)) { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, prop, elementTypeName)); + } + return result; + } + else { + createCompilerDiagnosticOnlyIfJson(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, prop, "Array"); + return "not-array"; + } + } + return "no-prop"; + } + function createCompilerDiagnosticOnlyIfJson(message, arg0, arg1) { + if (!sourceFile) { + errors.push(ts.createCompilerDiagnostic(message, arg0, arg1)); + } + } + } + function isErrorNoInputFiles(error) { + return error.code === ts.Diagnostics.No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2.code; + } + function getErrorForNoInputFiles(_a, configFileName) { + var includeSpecs = _a.includeSpecs, excludeSpecs = _a.excludeSpecs; + return ts.createCompilerDiagnostic(ts.Diagnostics.No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2, configFileName || "tsconfig.json", JSON.stringify(includeSpecs || []), JSON.stringify(excludeSpecs || [])); + } + function shouldReportNoInputFiles(fileNames, canJsonReportNoInutFiles, resolutionStack) { + return fileNames.length === 0 && canJsonReportNoInutFiles && (!resolutionStack || resolutionStack.length === 0); + } + /*@internal*/ + function canJsonReportNoInputFiles(raw) { + return !ts.hasProperty(raw, "files") && !ts.hasProperty(raw, "references"); + } + ts.canJsonReportNoInputFiles = canJsonReportNoInputFiles; + /*@internal*/ + function updateErrorForNoInputFiles(fileNames, configFileName, configFileSpecs, configParseDiagnostics, canJsonReportNoInutFiles) { + var existingErrors = configParseDiagnostics.length; + if (shouldReportNoInputFiles(fileNames, canJsonReportNoInutFiles)) { + configParseDiagnostics.push(getErrorForNoInputFiles(configFileSpecs, configFileName)); + } + else { + ts.filterMutate(configParseDiagnostics, function (error) { return !isErrorNoInputFiles(error); }); + } + return existingErrors !== configParseDiagnostics.length; + } + ts.updateErrorForNoInputFiles = updateErrorForNoInputFiles; + function isSuccessfulParsedTsconfig(value) { + return !!value.options; + } + /** + * This *just* extracts options/include/exclude/files out of a config file. + * It does *not* resolve the included files. + */ + function parseConfig(json, sourceFile, host, basePath, configFileName, resolutionStack, errors, extendedConfigCache) { + var _a; + basePath = ts.normalizeSlashes(basePath); + var resolvedPath = ts.getNormalizedAbsolutePath(configFileName || "", basePath); + if (resolutionStack.indexOf(resolvedPath) >= 0) { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Circularity_detected_while_resolving_configuration_Colon_0, __spreadArray(__spreadArray([], resolutionStack, true), [resolvedPath], false).join(" -> "))); + return { raw: json || convertToObject(sourceFile, errors) }; + } + var ownConfig = json ? + parseOwnConfigOfJson(json, host, basePath, configFileName, errors) : + parseOwnConfigOfJsonSourceFile(sourceFile, host, basePath, configFileName, errors); + if ((_a = ownConfig.options) === null || _a === void 0 ? void 0 : _a.paths) { + // If we end up needing to resolve relative paths from 'paths' relative to + // the config file location, we'll need to know where that config file was. + // Since 'paths' can be inherited from an extended config in another directory, + // we wouldn't know which directory to use unless we store it here. + ownConfig.options.pathsBasePath = basePath; + } + if (ownConfig.extendedConfigPath) { + // copy the resolution stack so it is never reused between branches in potential diamond-problem scenarios. + resolutionStack = resolutionStack.concat([resolvedPath]); + var extendedConfig = getExtendedConfig(sourceFile, ownConfig.extendedConfigPath, host, resolutionStack, errors, extendedConfigCache); + if (extendedConfig && isSuccessfulParsedTsconfig(extendedConfig)) { + var baseRaw_1 = extendedConfig.raw; + var raw_1 = ownConfig.raw; + var relativeDifference_1; + var setPropertyInRawIfNotUndefined = function (propertyName) { + if (!raw_1[propertyName] && baseRaw_1[propertyName]) { + raw_1[propertyName] = ts.map(baseRaw_1[propertyName], function (path) { return ts.isRootedDiskPath(path) ? path : ts.combinePaths(relativeDifference_1 || (relativeDifference_1 = ts.convertToRelativePath(ts.getDirectoryPath(ownConfig.extendedConfigPath), basePath, ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames))), path); }); + } + }; + setPropertyInRawIfNotUndefined("include"); + setPropertyInRawIfNotUndefined("exclude"); + setPropertyInRawIfNotUndefined("files"); + if (raw_1.compileOnSave === undefined) { + raw_1.compileOnSave = baseRaw_1.compileOnSave; + } + ownConfig.options = ts.assign({}, extendedConfig.options, ownConfig.options); + ownConfig.watchOptions = ownConfig.watchOptions && extendedConfig.watchOptions ? + ts.assign({}, extendedConfig.watchOptions, ownConfig.watchOptions) : + ownConfig.watchOptions || extendedConfig.watchOptions; + // TODO extend type typeAcquisition + } + } + return ownConfig; + } + function parseOwnConfigOfJson(json, host, basePath, configFileName, errors) { + if (ts.hasProperty(json, "excludes")) { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Unknown_option_excludes_Did_you_mean_exclude)); + } + var options = 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. + var typeAcquisition = convertTypeAcquisitionFromJsonWorker(json.typeAcquisition || json.typingOptions, basePath, errors, configFileName); + var watchOptions = convertWatchOptionsFromJsonWorker(json.watchOptions, basePath, errors); + json.compileOnSave = convertCompileOnSaveOptionFromJson(json, basePath, errors); + var extendedConfigPath; + if (json.extends) { + if (!ts.isString(json.extends)) { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "extends", "string")); + } + else { + var newBase = configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath; + extendedConfigPath = getExtendsConfigPath(json.extends, host, newBase, errors, ts.createCompilerDiagnostic); + } + } + return { raw: json, options: options, watchOptions: watchOptions, typeAcquisition: typeAcquisition, extendedConfigPath: extendedConfigPath }; + } + function parseOwnConfigOfJsonSourceFile(sourceFile, host, basePath, configFileName, errors) { + var options = getDefaultCompilerOptions(configFileName); + var typeAcquisition, typingOptionstypeAcquisition; + var watchOptions; + var extendedConfigPath; + var rootCompilerOptions; + var optionsIterator = { + onSetValidOptionKeyValueInParent: function (parentOption, option, value) { + var currentOption; + switch (parentOption) { + case "compilerOptions": + currentOption = options; + break; + case "watchOptions": + currentOption = (watchOptions || (watchOptions = {})); + break; + case "typeAcquisition": + currentOption = (typeAcquisition || (typeAcquisition = getDefaultTypeAcquisition(configFileName))); + break; + case "typingOptions": + currentOption = (typingOptionstypeAcquisition || (typingOptionstypeAcquisition = getDefaultTypeAcquisition(configFileName))); + break; + default: + ts.Debug.fail("Unknown option"); + } + currentOption[option.name] = normalizeOptionValue(option, basePath, value); + }, + onSetValidOptionKeyValueInRoot: function (key, _keyNode, value, valueNode) { + switch (key) { + case "extends": + var newBase = configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath; + extendedConfigPath = getExtendsConfigPath(value, host, newBase, errors, function (message, arg0) { + return ts.createDiagnosticForNodeInSourceFile(sourceFile, valueNode, message, arg0); + }); + return; + } + }, + onSetUnknownOptionKeyValueInRoot: function (key, keyNode, _value, _valueNode) { + if (key === "excludes") { + errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, keyNode, ts.Diagnostics.Unknown_option_excludes_Did_you_mean_exclude)); + } + if (ts.find(commandOptionsWithoutBuild, function (opt) { return opt.name === key; })) { + rootCompilerOptions = ts.append(rootCompilerOptions, keyNode); + } + } + }; + var json = convertConfigFileToObject(sourceFile, errors, /*reportOptionsErrors*/ true, optionsIterator); + if (!typeAcquisition) { + if (typingOptionstypeAcquisition) { + typeAcquisition = (typingOptionstypeAcquisition.enableAutoDiscovery !== undefined) ? + { + enable: typingOptionstypeAcquisition.enableAutoDiscovery, + include: typingOptionstypeAcquisition.include, + exclude: typingOptionstypeAcquisition.exclude + } : + typingOptionstypeAcquisition; + } + else { + typeAcquisition = getDefaultTypeAcquisition(configFileName); + } + } + if (rootCompilerOptions && json && json.compilerOptions === undefined) { + errors.push(ts.createDiagnosticForNodeInSourceFile(sourceFile, rootCompilerOptions[0], ts.Diagnostics._0_should_be_set_inside_the_compilerOptions_object_of_the_config_json_file, ts.getTextOfPropertyName(rootCompilerOptions[0]))); + } + return { raw: json, options: options, watchOptions: watchOptions, typeAcquisition: typeAcquisition, extendedConfigPath: extendedConfigPath }; + } + function getExtendsConfigPath(extendedConfig, host, basePath, errors, createDiagnostic) { + extendedConfig = ts.normalizeSlashes(extendedConfig); + if (ts.isRootedDiskPath(extendedConfig) || ts.startsWith(extendedConfig, "./") || ts.startsWith(extendedConfig, "../")) { + var extendedConfigPath = ts.getNormalizedAbsolutePath(extendedConfig, basePath); + if (!host.fileExists(extendedConfigPath) && !ts.endsWith(extendedConfigPath, ".json" /* Extension.Json */)) { + extendedConfigPath = "".concat(extendedConfigPath, ".json"); + if (!host.fileExists(extendedConfigPath)) { + errors.push(createDiagnostic(ts.Diagnostics.File_0_not_found, extendedConfig)); + return undefined; + } + } + return extendedConfigPath; + } + // If the path isn't a rooted or relative path, resolve like a module + var resolved = ts.nodeModuleNameResolver(extendedConfig, ts.combinePaths(basePath, "tsconfig.json"), { moduleResolution: ts.ModuleResolutionKind.NodeJs }, host, /*cache*/ undefined, /*projectRefs*/ undefined, /*lookupConfig*/ true); + if (resolved.resolvedModule) { + return resolved.resolvedModule.resolvedFileName; + } + errors.push(createDiagnostic(ts.Diagnostics.File_0_not_found, extendedConfig)); + return undefined; + } + function getExtendedConfig(sourceFile, extendedConfigPath, host, resolutionStack, errors, extendedConfigCache) { + var _a; + var path = host.useCaseSensitiveFileNames ? extendedConfigPath : ts.toFileNameLowerCase(extendedConfigPath); + var value; + var extendedResult; + var extendedConfig; + if (extendedConfigCache && (value = extendedConfigCache.get(path))) { + (extendedResult = value.extendedResult, extendedConfig = value.extendedConfig); + } + else { + extendedResult = readJsonConfigFile(extendedConfigPath, function (path) { return host.readFile(path); }); + if (!extendedResult.parseDiagnostics.length) { + extendedConfig = parseConfig(/*json*/ undefined, extendedResult, host, ts.getDirectoryPath(extendedConfigPath), ts.getBaseFileName(extendedConfigPath), resolutionStack, errors, extendedConfigCache); + } + if (extendedConfigCache) { + extendedConfigCache.set(path, { extendedResult: extendedResult, extendedConfig: extendedConfig }); + } + } + if (sourceFile) { + sourceFile.extendedSourceFiles = [extendedResult.fileName]; + if (extendedResult.extendedSourceFiles) { + (_a = sourceFile.extendedSourceFiles).push.apply(_a, extendedResult.extendedSourceFiles); + } + } + if (extendedResult.parseDiagnostics.length) { + errors.push.apply(errors, extendedResult.parseDiagnostics); + return undefined; + } + return extendedConfig; + } + function convertCompileOnSaveOptionFromJson(jsonOption, basePath, errors) { + if (!ts.hasProperty(jsonOption, ts.compileOnSaveCommandLineOption.name)) { + return false; + } + var result = convertJsonOption(ts.compileOnSaveCommandLineOption, jsonOption.compileOnSave, basePath, errors); + return typeof result === "boolean" && result; + } + function convertCompilerOptionsFromJson(jsonOptions, basePath, configFileName) { + var errors = []; + var options = convertCompilerOptionsFromJsonWorker(jsonOptions, basePath, errors, configFileName); + return { options: options, errors: errors }; + } + ts.convertCompilerOptionsFromJson = convertCompilerOptionsFromJson; + function convertTypeAcquisitionFromJson(jsonOptions, basePath, configFileName) { + var errors = []; + var options = convertTypeAcquisitionFromJsonWorker(jsonOptions, basePath, errors, configFileName); + return { options: options, errors: errors }; + } + ts.convertTypeAcquisitionFromJson = convertTypeAcquisitionFromJson; + function getDefaultCompilerOptions(configFileName) { + var options = configFileName && ts.getBaseFileName(configFileName) === "jsconfig.json" + ? { allowJs: true, maxNodeModuleJsDepth: 2, allowSyntheticDefaultImports: true, skipLibCheck: true, noEmit: true } + : {}; + return options; + } + function convertCompilerOptionsFromJsonWorker(jsonOptions, basePath, errors, configFileName) { + var options = getDefaultCompilerOptions(configFileName); + convertOptionsFromJson(getCommandLineCompilerOptionsMap(), jsonOptions, basePath, options, ts.compilerOptionsDidYouMeanDiagnostics, errors); + if (configFileName) { + options.configFilePath = ts.normalizeSlashes(configFileName); + } + return options; + } + function getDefaultTypeAcquisition(configFileName) { + return { enable: !!configFileName && ts.getBaseFileName(configFileName) === "jsconfig.json", include: [], exclude: [] }; + } + function convertTypeAcquisitionFromJsonWorker(jsonOptions, basePath, errors, configFileName) { + var options = getDefaultTypeAcquisition(configFileName); + var typeAcquisition = convertEnableAutoDiscoveryToEnable(jsonOptions); + convertOptionsFromJson(getCommandLineTypeAcquisitionMap(), typeAcquisition, basePath, options, typeAcquisitionDidYouMeanDiagnostics, errors); + return options; + } + function convertWatchOptionsFromJsonWorker(jsonOptions, basePath, errors) { + return convertOptionsFromJson(getCommandLineWatchOptionsMap(), jsonOptions, basePath, /*defaultOptions*/ undefined, watchOptionsDidYouMeanDiagnostics, errors); + } + function convertOptionsFromJson(optionsNameMap, jsonOptions, basePath, defaultOptions, diagnostics, errors) { + if (!jsonOptions) { + return; + } + for (var id in jsonOptions) { + var opt = optionsNameMap.get(id); + if (opt) { + (defaultOptions || (defaultOptions = {}))[opt.name] = convertJsonOption(opt, jsonOptions[id], basePath, errors); + } + else { + errors.push(createUnknownOptionError(id, diagnostics, ts.createCompilerDiagnostic)); + } + } + return defaultOptions; + } + /*@internal*/ + function convertJsonOption(opt, value, basePath, errors) { + if (isCompilerOptionsValue(opt, value)) { + var optType = opt.type; + if (optType === "list" && ts.isArray(value)) { + return convertJsonOptionOfListType(opt, value, basePath, errors); + } + else if (!ts.isString(optType)) { + return convertJsonOptionOfCustomType(opt, value, errors); + } + var validatedValue = validateJsonOptionValue(opt, value, errors); + return isNullOrUndefined(validatedValue) ? validatedValue : normalizeNonListOptionValue(opt, basePath, validatedValue); + } + else { + errors.push(ts.createCompilerDiagnostic(ts.Diagnostics.Compiler_option_0_requires_a_value_of_type_1, opt.name, getCompilerOptionValueTypeString(opt))); + } + } + ts.convertJsonOption = convertJsonOption; + function normalizeOptionValue(option, basePath, value) { + if (isNullOrUndefined(value)) + return undefined; + if (option.type === "list") { + var listOption_1 = option; + if (listOption_1.element.isFilePath || !ts.isString(listOption_1.element.type)) { + return ts.filter(ts.map(value, function (v) { return normalizeOptionValue(listOption_1.element, basePath, v); }), function (v) { return listOption_1.listPreserveFalsyValues ? true : !!v; }); + } + return value; + } + else if (!ts.isString(option.type)) { + return option.type.get(ts.isString(value) ? value.toLowerCase() : value); + } + return normalizeNonListOptionValue(option, basePath, value); + } + function normalizeNonListOptionValue(option, basePath, value) { + if (option.isFilePath) { + value = ts.getNormalizedAbsolutePath(value, basePath); + if (value === "") { + value = "."; + } + } + return value; + } + function validateJsonOptionValue(opt, value, errors) { + var _a; + if (isNullOrUndefined(value)) + return undefined; + var d = (_a = opt.extraValidation) === null || _a === void 0 ? void 0 : _a.call(opt, value); + if (!d) + return value; + errors.push(ts.createCompilerDiagnostic.apply(void 0, d)); + return undefined; + } + function convertJsonOptionOfCustomType(opt, value, errors) { + if (isNullOrUndefined(value)) + return undefined; + var key = value.toLowerCase(); + var val = opt.type.get(key); + if (val !== undefined) { + return validateJsonOptionValue(opt, val, errors); + } + else { + errors.push(createCompilerDiagnosticForInvalidCustomType(opt)); + } + } + function convertJsonOptionOfListType(option, values, basePath, errors) { + return ts.filter(ts.map(values, function (v) { return convertJsonOption(option.element, v, basePath, errors); }), function (v) { return option.listPreserveFalsyValues ? true : !!v; }); + } + /** + * Tests for a path that ends in a recursive directory wildcard. + * Matches **, \**, **\, and \**\, but not a**b. + * + * NOTE: used \ in place of / above to avoid issues with multiline comments. + * + * Breakdown: + * (^|\/) # matches either the beginning of the string or a directory separator. + * \*\* # matches the recursive directory wildcard "**". + * \/?$ # matches an optional trailing directory separator at the end of the string. + */ + var invalidTrailingRecursionPattern = /(^|\/)\*\*\/?$/; + /** + * Matches the portion of a wildcard path that does not contain wildcards. + * Matches \a of \a\*, or \a\b\c of \a\b\c\?\d. + * + * NOTE: used \ in place of / above to avoid issues with multiline comments. + * + * Breakdown: + * ^ # matches the beginning of the string + * [^*?]* # matches any number of non-wildcard characters + * (?=\/[^/]*[*?]) # lookahead that matches a directory separator followed by + * # a path component that contains at least one wildcard character (* or ?). + */ + var wildcardDirectoryPattern = /^[^*?]*(?=\/[^/]*[*?])/; + /** + * Gets the file names from the provided config file specs that contain, files, include, exclude and + * other properties needed to resolve the file names + * @param configFileSpecs The config file specs extracted with file names to include, wildcards to include/exclude and other details + * @param basePath The base path for any relative file specifications. + * @param options Compiler options. + * @param host The host used to resolve files and directories. + * @param extraFileExtensions optionaly file extra file extension information from host + */ + /* @internal */ + function getFileNamesFromConfigSpecs(configFileSpecs, basePath, options, host, extraFileExtensions) { + if (extraFileExtensions === void 0) { extraFileExtensions = ts.emptyArray; } + basePath = ts.normalizePath(basePath); + var keyMapper = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames); + // Literal file names (provided via the "files" array in tsconfig.json) are stored in a + // file map with a possibly case insensitive key. We use this map later when when including + // wildcard paths. + var literalFileMap = new ts.Map(); + // Wildcard paths (provided via the "includes" array in tsconfig.json) are stored in a + // file map with a possibly case insensitive key. We use this map to store paths matched + // via wildcard, and to handle extension priority. + var wildcardFileMap = new ts.Map(); + // Wildcard paths of json files (provided via the "includes" array in tsconfig.json) are stored in a + // file map with a possibly case insensitive key. We use this map to store paths matched + // via wildcard of *.json kind + var wildCardJsonFileMap = new ts.Map(); + var validatedFilesSpec = configFileSpecs.validatedFilesSpec, validatedIncludeSpecs = configFileSpecs.validatedIncludeSpecs, validatedExcludeSpecs = configFileSpecs.validatedExcludeSpecs; + // Rather than re-query this for each file and filespec, we query the supported extensions + // once and store it on the expansion context. + var supportedExtensions = ts.getSupportedExtensions(options, extraFileExtensions); + var supportedExtensionsWithJsonIfResolveJsonModule = ts.getSupportedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions); + // Literal files are always included verbatim. An "include" or "exclude" specification cannot + // remove a literal file. + if (validatedFilesSpec) { + for (var _i = 0, validatedFilesSpec_1 = validatedFilesSpec; _i < validatedFilesSpec_1.length; _i++) { + var fileName = validatedFilesSpec_1[_i]; + var file = ts.getNormalizedAbsolutePath(fileName, basePath); + literalFileMap.set(keyMapper(file), file); + } + } + var jsonOnlyIncludeRegexes; + if (validatedIncludeSpecs && validatedIncludeSpecs.length > 0) { + var _loop_6 = function (file) { + if (ts.fileExtensionIs(file, ".json" /* Extension.Json */)) { + // Valid only if *.json specified + if (!jsonOnlyIncludeRegexes) { + var includes = validatedIncludeSpecs.filter(function (s) { return ts.endsWith(s, ".json" /* Extension.Json */); }); + var includeFilePatterns = ts.map(ts.getRegularExpressionsForWildcards(includes, basePath, "files"), function (pattern) { return "^".concat(pattern, "$"); }); + jsonOnlyIncludeRegexes = includeFilePatterns ? includeFilePatterns.map(function (pattern) { return ts.getRegexFromPattern(pattern, host.useCaseSensitiveFileNames); }) : ts.emptyArray; + } + var includeIndex = ts.findIndex(jsonOnlyIncludeRegexes, function (re) { return re.test(file); }); + if (includeIndex !== -1) { + var key_1 = keyMapper(file); + if (!literalFileMap.has(key_1) && !wildCardJsonFileMap.has(key_1)) { + wildCardJsonFileMap.set(key_1, file); + } + } + return "continue"; + } + // If we have already included a literal or wildcard path with a + // higher priority extension, we should skip this file. + // + // This handles cases where we may encounter both .ts and + // .d.ts (or .js if "allowJs" is enabled) in the same + // directory when they are compilation outputs. + if (hasFileWithHigherPriorityExtension(file, literalFileMap, wildcardFileMap, supportedExtensions, keyMapper)) { + return "continue"; + } + // We may have included a wildcard path with a lower priority + // extension due to the user-defined order of entries in the + // "include" array. If there is a lower priority extension in the + // same directory, we should remove it. + removeWildcardFilesWithLowerPriorityExtension(file, wildcardFileMap, supportedExtensions, keyMapper); + var key = keyMapper(file); + if (!literalFileMap.has(key) && !wildcardFileMap.has(key)) { + wildcardFileMap.set(key, file); + } + }; + for (var _a = 0, _b = host.readDirectory(basePath, ts.flatten(supportedExtensionsWithJsonIfResolveJsonModule), validatedExcludeSpecs, validatedIncludeSpecs, /*depth*/ undefined); _a < _b.length; _a++) { + var file = _b[_a]; + _loop_6(file); + } + } + var literalFiles = ts.arrayFrom(literalFileMap.values()); + var wildcardFiles = ts.arrayFrom(wildcardFileMap.values()); + return literalFiles.concat(wildcardFiles, ts.arrayFrom(wildCardJsonFileMap.values())); + } + ts.getFileNamesFromConfigSpecs = getFileNamesFromConfigSpecs; + /* @internal */ + function isExcludedFile(pathToCheck, spec, basePath, useCaseSensitiveFileNames, currentDirectory) { + var validatedFilesSpec = spec.validatedFilesSpec, validatedIncludeSpecs = spec.validatedIncludeSpecs, validatedExcludeSpecs = spec.validatedExcludeSpecs; + if (!ts.length(validatedIncludeSpecs) || !ts.length(validatedExcludeSpecs)) + return false; + basePath = ts.normalizePath(basePath); + var keyMapper = ts.createGetCanonicalFileName(useCaseSensitiveFileNames); + if (validatedFilesSpec) { + for (var _i = 0, validatedFilesSpec_2 = validatedFilesSpec; _i < validatedFilesSpec_2.length; _i++) { + var fileName = validatedFilesSpec_2[_i]; + if (keyMapper(ts.getNormalizedAbsolutePath(fileName, basePath)) === pathToCheck) + return false; + } + } + return matchesExcludeWorker(pathToCheck, validatedExcludeSpecs, useCaseSensitiveFileNames, currentDirectory, basePath); + } + ts.isExcludedFile = isExcludedFile; + function invalidDotDotAfterRecursiveWildcard(s) { + // We used to use the regex /(^|\/)\*\*\/(.*\/)?\.\.($|\/)/ to check for this case, but + // in v8, that has polynomial performance because the recursive wildcard match - **/ - + // can be matched in many arbitrary positions when multiple are present, resulting + // in bad backtracking (and we don't care which is matched - just that some /.. segment + // comes after some **/ segment). + var wildcardIndex = ts.startsWith(s, "**/") ? 0 : s.indexOf("/**/"); + if (wildcardIndex === -1) { + return false; + } + var lastDotIndex = ts.endsWith(s, "/..") ? s.length : s.lastIndexOf("/../"); + return lastDotIndex > wildcardIndex; + } + /* @internal */ + function matchesExclude(pathToCheck, excludeSpecs, useCaseSensitiveFileNames, currentDirectory) { + return matchesExcludeWorker(pathToCheck, ts.filter(excludeSpecs, function (spec) { return !invalidDotDotAfterRecursiveWildcard(spec); }), useCaseSensitiveFileNames, currentDirectory); + } + ts.matchesExclude = matchesExclude; + function matchesExcludeWorker(pathToCheck, excludeSpecs, useCaseSensitiveFileNames, currentDirectory, basePath) { + var excludePattern = ts.getRegularExpressionForWildcard(excludeSpecs, ts.combinePaths(ts.normalizePath(currentDirectory), basePath), "exclude"); + var excludeRegex = excludePattern && ts.getRegexFromPattern(excludePattern, useCaseSensitiveFileNames); + if (!excludeRegex) + return false; + if (excludeRegex.test(pathToCheck)) + return true; + return !ts.hasExtension(pathToCheck) && excludeRegex.test(ts.ensureTrailingDirectorySeparator(pathToCheck)); + } + function validateSpecs(specs, errors, disallowTrailingRecursion, jsonSourceFile, specKey) { + return specs.filter(function (spec) { + if (!ts.isString(spec)) + return false; + var diag = specToDiagnostic(spec, disallowTrailingRecursion); + if (diag !== undefined) { + errors.push(createDiagnostic.apply(void 0, diag)); + } + return diag === undefined; + }); + function createDiagnostic(message, spec) { + var element = ts.getTsConfigPropArrayElementValue(jsonSourceFile, specKey, spec); + return element ? + ts.createDiagnosticForNodeInSourceFile(jsonSourceFile, element, message, spec) : + ts.createCompilerDiagnostic(message, spec); + } + } + function specToDiagnostic(spec, disallowTrailingRecursion) { + if (disallowTrailingRecursion && invalidTrailingRecursionPattern.test(spec)) { + return [ts.Diagnostics.File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0, spec]; + } + else if (invalidDotDotAfterRecursiveWildcard(spec)) { + return [ts.Diagnostics.File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0, spec]; + } + } + /** + * Gets directories in a set of include patterns that should be watched for changes. + */ + function getWildcardDirectories(_a, path, useCaseSensitiveFileNames) { + var include = _a.validatedIncludeSpecs, exclude = _a.validatedExcludeSpecs; + // We watch a directory recursively if it contains a wildcard anywhere in a directory segment + // of the pattern: + // + // /a/b/**/d - Watch /a/b recursively to catch changes to any d in any subfolder recursively + // /a/b/*/d - Watch /a/b recursively to catch any d in any immediate subfolder, even if a new subfolder is added + // /a/b - Watch /a/b recursively to catch changes to anything in any recursive subfoler + // + // We watch a directory without recursion if it contains a wildcard in the file segment of + // the pattern: + // + // /a/b/* - Watch /a/b directly to catch any new file + // /a/b/a?z - Watch /a/b directly to catch any new file matching a?z + var rawExcludeRegex = ts.getRegularExpressionForWildcard(exclude, path, "exclude"); + var excludeRegex = rawExcludeRegex && new RegExp(rawExcludeRegex, useCaseSensitiveFileNames ? "" : "i"); + var wildcardDirectories = {}; + if (include !== undefined) { + var recursiveKeys = []; + for (var _i = 0, include_1 = include; _i < include_1.length; _i++) { + var file = include_1[_i]; + var spec = ts.normalizePath(ts.combinePaths(path, file)); + if (excludeRegex && excludeRegex.test(spec)) { + continue; + } + var match = getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames); + if (match) { + var key = match.key, flags = match.flags; + var existingFlags = wildcardDirectories[key]; + if (existingFlags === undefined || existingFlags < flags) { + wildcardDirectories[key] = flags; + if (flags === 1 /* WatchDirectoryFlags.Recursive */) { + recursiveKeys.push(key); + } + } + } + } + // Remove any subpaths under an existing recursively watched directory. + for (var key in wildcardDirectories) { + if (ts.hasProperty(wildcardDirectories, key)) { + for (var _b = 0, recursiveKeys_1 = recursiveKeys; _b < recursiveKeys_1.length; _b++) { + var recursiveKey = recursiveKeys_1[_b]; + if (key !== recursiveKey && ts.containsPath(recursiveKey, key, path, !useCaseSensitiveFileNames)) { + delete wildcardDirectories[key]; + } + } + } + } + } + return wildcardDirectories; + } + function getWildcardDirectoryFromSpec(spec, useCaseSensitiveFileNames) { + var match = wildcardDirectoryPattern.exec(spec); + if (match) { + // We check this with a few `indexOf` calls because 3 `indexOf`/`lastIndexOf` calls is + // less algorithmically complex (roughly O(3n) worst-case) than the regex we used to use, + // \/[^/]*?[*?][^/]*\/ which was polynominal in v8, since arbitrary sequences of wildcard + // characters could match any of the central patterns, resulting in bad backtracking. + var questionWildcardIndex = spec.indexOf("?"); + var starWildcardIndex = spec.indexOf("*"); + var lastDirectorySeperatorIndex = spec.lastIndexOf(ts.directorySeparator); + return { + key: useCaseSensitiveFileNames ? match[0] : ts.toFileNameLowerCase(match[0]), + flags: (questionWildcardIndex !== -1 && questionWildcardIndex < lastDirectorySeperatorIndex) + || (starWildcardIndex !== -1 && starWildcardIndex < lastDirectorySeperatorIndex) + ? 1 /* WatchDirectoryFlags.Recursive */ : 0 /* WatchDirectoryFlags.None */ + }; + } + if (ts.isImplicitGlob(spec.substring(spec.lastIndexOf(ts.directorySeparator) + 1))) { + return { + key: ts.removeTrailingDirectorySeparator(useCaseSensitiveFileNames ? spec : ts.toFileNameLowerCase(spec)), + flags: 1 /* WatchDirectoryFlags.Recursive */ + }; + } + return undefined; + } + /** + * Determines whether a literal or wildcard file has already been included that has a higher + * extension priority. + * + * @param file The path to the file. + */ + function hasFileWithHigherPriorityExtension(file, literalFiles, wildcardFiles, extensions, keyMapper) { + var extensionGroup = ts.forEach(extensions, function (group) { return ts.fileExtensionIsOneOf(file, group) ? group : undefined; }); + if (!extensionGroup) { + return false; + } + for (var _i = 0, extensionGroup_1 = extensionGroup; _i < extensionGroup_1.length; _i++) { + var ext = extensionGroup_1[_i]; + if (ts.fileExtensionIs(file, ext)) { + return false; + } + var higherPriorityPath = keyMapper(ts.changeExtension(file, ext)); + if (literalFiles.has(higherPriorityPath) || wildcardFiles.has(higherPriorityPath)) { + if (ext === ".d.ts" /* Extension.Dts */ && (ts.fileExtensionIs(file, ".js" /* Extension.Js */) || ts.fileExtensionIs(file, ".jsx" /* Extension.Jsx */))) { + // LEGACY BEHAVIOR: An off-by-one bug somewhere in the extension priority system for wildcard module loading allowed declaration + // files to be loaded alongside their js(x) counterparts. We regard this as generally undesirable, but retain the behavior to + // prevent breakage. + continue; + } + return true; + } + } + return false; + } + /** + * Removes files included via wildcard expansion with a lower extension priority that have + * already been included. + * + * @param file The path to the file. + */ + function removeWildcardFilesWithLowerPriorityExtension(file, wildcardFiles, extensions, keyMapper) { + var extensionGroup = ts.forEach(extensions, function (group) { return ts.fileExtensionIsOneOf(file, group) ? group : undefined; }); + if (!extensionGroup) { + return; + } + for (var i = extensionGroup.length - 1; i >= 0; i--) { + var ext = extensionGroup[i]; + if (ts.fileExtensionIs(file, ext)) { + return; + } + var lowerPriorityPath = keyMapper(ts.changeExtension(file, ext)); + wildcardFiles.delete(lowerPriorityPath); + } + } + /** + * Produces a cleaned version of compiler options with personally identifying info (aka, paths) removed. + * Also converts enum values back to strings. + */ + /* @internal */ + function convertCompilerOptionsForTelemetry(opts) { + var out = {}; + for (var key in opts) { + if (ts.hasProperty(opts, key)) { + var type = getOptionFromName(key); + if (type !== undefined) { // Ignore unknown options + out[key] = getOptionValueWithEmptyStrings(opts[key], type); + } + } + } + return out; + } + ts.convertCompilerOptionsForTelemetry = convertCompilerOptionsForTelemetry; + function getOptionValueWithEmptyStrings(value, option) { + switch (option.type) { + case "object": // "paths". Can't get any useful information from the value since we blank out strings, so just return "". + return ""; + case "string": // Could be any arbitrary string -- use empty string instead. + return ""; + case "number": // Allow numbers, but be sure to check it's actually a number. + return typeof value === "number" ? value : ""; + case "boolean": + return typeof value === "boolean" ? value : ""; + case "list": + var elementType_1 = option.element; + return ts.isArray(value) ? value.map(function (v) { return getOptionValueWithEmptyStrings(v, elementType_1); }) : ""; + default: + return ts.forEachEntry(option.type, function (optionEnumValue, optionStringValue) { + if (optionEnumValue === value) { + return optionStringValue; + } + }); // TODO: GH#18217 + } + } + function getDefaultValueForOption(option) { + switch (option.type) { + case "number": + return 1; + case "boolean": + return true; + case "string": + var defaultValue = option.defaultValueDescription; + return option.isFilePath ? "./".concat(defaultValue && typeof defaultValue === "string" ? defaultValue : "") : ""; + case "list": + return []; + case "object": + return {}; + default: + var iterResult = option.type.keys().next(); + if (!iterResult.done) + return iterResult.value; + return ts.Debug.fail("Expected 'option.type' to have entries."); + } + } +})(ts || (ts = {})); +var ts; +(function (ts) { + function trace(host) { + host.trace(ts.formatMessage.apply(undefined, arguments)); + } + ts.trace = trace; + /* @internal */ + function isTraceEnabled(compilerOptions, host) { + return !!compilerOptions.traceResolution && host.trace !== undefined; + } + ts.isTraceEnabled = isTraceEnabled; + function withPackageId(packageInfo, r) { + var packageId; + if (r && packageInfo) { + var packageJsonContent = packageInfo.contents.packageJsonContent; + if (typeof packageJsonContent.name === "string" && typeof packageJsonContent.version === "string") { + packageId = { + name: packageJsonContent.name, + subModuleName: r.path.slice(packageInfo.packageDirectory.length + ts.directorySeparator.length), + version: packageJsonContent.version + }; + } + } + return r && { path: r.path, extension: r.ext, packageId: packageId }; + } + function noPackageId(r) { + return withPackageId(/*packageInfo*/ undefined, r); + } + function removeIgnoredPackageId(r) { + if (r) { + ts.Debug.assert(r.packageId === undefined); + return { path: r.path, ext: r.extension }; + } + } + /** + * Kinds of file that we are currently looking for. + * Typically there is one pass with Extensions.TypeScript, then a second pass with Extensions.JavaScript. + */ + var Extensions; + (function (Extensions) { + Extensions[Extensions["TypeScript"] = 0] = "TypeScript"; + Extensions[Extensions["JavaScript"] = 1] = "JavaScript"; + Extensions[Extensions["Json"] = 2] = "Json"; + Extensions[Extensions["TSConfig"] = 3] = "TSConfig"; + Extensions[Extensions["DtsOnly"] = 4] = "DtsOnly"; + Extensions[Extensions["TsOnly"] = 5] = "TsOnly"; + })(Extensions || (Extensions = {})); + /** Used with `Extensions.DtsOnly` to extract the path from TypeScript results. */ + function resolvedTypeScriptOnly(resolved) { + if (!resolved) { + return undefined; + } + ts.Debug.assert(ts.extensionIsTS(resolved.extension)); + return { fileName: resolved.path, packageId: resolved.packageId }; + } + function createResolvedModuleWithFailedLookupLocations(resolved, isExternalLibraryImport, failedLookupLocations, affectingLocations, diagnostics, resultFromCache) { + var _a, _b; + if (resultFromCache) { + (_a = resultFromCache.failedLookupLocations).push.apply(_a, failedLookupLocations); + (_b = resultFromCache.affectingLocations).push.apply(_b, affectingLocations); + return resultFromCache; + } + return { + resolvedModule: resolved && { resolvedFileName: resolved.path, originalPath: resolved.originalPath === true ? undefined : resolved.originalPath, extension: resolved.extension, isExternalLibraryImport: isExternalLibraryImport, packageId: resolved.packageId }, + failedLookupLocations: failedLookupLocations, + affectingLocations: affectingLocations, + resolutionDiagnostics: diagnostics, + }; + } + function readPackageJsonField(jsonContent, fieldName, typeOfTag, state) { + if (!ts.hasProperty(jsonContent, fieldName)) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.package_json_does_not_have_a_0_field, fieldName); + } + return; + } + var value = jsonContent[fieldName]; + if (typeof value !== typeOfTag || value === null) { // eslint-disable-line no-null/no-null + if (state.traceEnabled) { + // eslint-disable-next-line no-null/no-null + trace(state.host, ts.Diagnostics.Expected_type_of_0_field_in_package_json_to_be_1_got_2, fieldName, typeOfTag, value === null ? "null" : typeof value); + } + return; + } + return value; + } + function readPackageJsonPathField(jsonContent, fieldName, baseDirectory, state) { + var fileName = readPackageJsonField(jsonContent, fieldName, "string", state); + if (fileName === undefined) { + return; + } + if (!fileName) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.package_json_had_a_falsy_0_field, fieldName); + } + return; + } + var path = ts.normalizePath(ts.combinePaths(baseDirectory, fileName)); + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.package_json_has_0_field_1_that_references_2, fieldName, fileName, path); + } + return path; + } + function readPackageJsonTypesFields(jsonContent, baseDirectory, state) { + return readPackageJsonPathField(jsonContent, "typings", baseDirectory, state) + || readPackageJsonPathField(jsonContent, "types", baseDirectory, state); + } + function readPackageJsonTSConfigField(jsonContent, baseDirectory, state) { + return readPackageJsonPathField(jsonContent, "tsconfig", baseDirectory, state); + } + function readPackageJsonMainField(jsonContent, baseDirectory, state) { + return readPackageJsonPathField(jsonContent, "main", baseDirectory, state); + } + function readPackageJsonTypesVersionsField(jsonContent, state) { + var typesVersions = readPackageJsonField(jsonContent, "typesVersions", "object", state); + if (typesVersions === undefined) + return; + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.package_json_has_a_typesVersions_field_with_version_specific_path_mappings); + } + return typesVersions; + } + function readPackageJsonTypesVersionPaths(jsonContent, state) { + var typesVersions = readPackageJsonTypesVersionsField(jsonContent, state); + if (typesVersions === undefined) + return; + if (state.traceEnabled) { + for (var key in typesVersions) { + if (ts.hasProperty(typesVersions, key) && !ts.VersionRange.tryParse(key)) { + trace(state.host, ts.Diagnostics.package_json_has_a_typesVersions_entry_0_that_is_not_a_valid_semver_range, key); + } + } + } + var result = getPackageJsonTypesVersionsPaths(typesVersions); + if (!result) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.package_json_does_not_have_a_typesVersions_entry_that_matches_version_0, ts.versionMajorMinor); + } + return; + } + var bestVersionKey = result.version, bestVersionPaths = result.paths; + if (typeof bestVersionPaths !== "object") { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Expected_type_of_0_field_in_package_json_to_be_1_got_2, "typesVersions['".concat(bestVersionKey, "']"), "object", typeof bestVersionPaths); + } + return; + } + return result; + } + var typeScriptVersion; + /* @internal */ + function getPackageJsonTypesVersionsPaths(typesVersions) { + if (!typeScriptVersion) + typeScriptVersion = new ts.Version(ts.version); + for (var key in typesVersions) { + if (!ts.hasProperty(typesVersions, key)) + continue; + var keyRange = ts.VersionRange.tryParse(key); + if (keyRange === undefined) { + continue; + } + // return the first entry whose range matches the current compiler version. + if (keyRange.test(typeScriptVersion)) { + return { version: key, paths: typesVersions[key] }; + } + } + } + ts.getPackageJsonTypesVersionsPaths = getPackageJsonTypesVersionsPaths; + function getEffectiveTypeRoots(options, host) { + if (options.typeRoots) { + return options.typeRoots; + } + var currentDirectory; + if (options.configFilePath) { + currentDirectory = ts.getDirectoryPath(options.configFilePath); + } + else if (host.getCurrentDirectory) { + currentDirectory = host.getCurrentDirectory(); + } + if (currentDirectory !== undefined) { + return getDefaultTypeRoots(currentDirectory, host); + } + } + ts.getEffectiveTypeRoots = getEffectiveTypeRoots; + /** + * Returns the path to every node_modules/@types directory from some ancestor directory. + * Returns undefined if there are none. + */ + function getDefaultTypeRoots(currentDirectory, host) { + if (!host.directoryExists) { + return [ts.combinePaths(currentDirectory, nodeModulesAtTypes)]; + // And if it doesn't exist, tough. + } + var typeRoots; + ts.forEachAncestorDirectory(ts.normalizePath(currentDirectory), function (directory) { + var atTypes = ts.combinePaths(directory, nodeModulesAtTypes); + if (host.directoryExists(atTypes)) { + (typeRoots || (typeRoots = [])).push(atTypes); + } + return undefined; + }); + return typeRoots; + } + var nodeModulesAtTypes = ts.combinePaths("node_modules", "@types"); + function arePathsEqual(path1, path2, host) { + var useCaseSensitiveFileNames = typeof host.useCaseSensitiveFileNames === "function" ? host.useCaseSensitiveFileNames() : host.useCaseSensitiveFileNames; + return ts.comparePaths(path1, path2, !useCaseSensitiveFileNames) === 0 /* Comparison.EqualTo */; + } + /** + * @param {string | undefined} containingFile - file that contains type reference directive, can be undefined if containing file is unknown. + * This is possible in case if resolution is performed for directives specified via 'types' parameter. In this case initial path for secondary lookups + * is assumed to be the same as root directory of the project. + */ + function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, cache, resolutionMode) { + ts.Debug.assert(typeof typeReferenceDirectiveName === "string", "Non-string value passed to `ts.resolveTypeReferenceDirective`, likely by a wrapping package working with an outdated `resolveTypeReferenceDirectives` signature. This is probably not a problem in TS itself."); + var traceEnabled = isTraceEnabled(options, host); + if (redirectedReference) { + options = redirectedReference.commandLine.options; + } + var containingDirectory = containingFile ? ts.getDirectoryPath(containingFile) : undefined; + var perFolderCache = containingDirectory ? cache && cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference) : undefined; + var result = perFolderCache && perFolderCache.get(typeReferenceDirectiveName, /*mode*/ resolutionMode); + if (result) { + if (traceEnabled) { + trace(host, ts.Diagnostics.Resolving_type_reference_directive_0_containing_file_1, typeReferenceDirectiveName, containingFile); + if (redirectedReference) + trace(host, ts.Diagnostics.Using_compiler_options_of_project_reference_redirect_0, redirectedReference.sourceFile.fileName); + trace(host, ts.Diagnostics.Resolution_for_type_reference_directive_0_was_found_in_cache_from_location_1, typeReferenceDirectiveName, containingDirectory); + traceResult(result); + } + return result; + } + var typeRoots = getEffectiveTypeRoots(options, host); + if (traceEnabled) { + if (containingFile === undefined) { + if (typeRoots === undefined) { + trace(host, ts.Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set, typeReferenceDirectiveName); + } + else { + trace(host, ts.Diagnostics.Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1, typeReferenceDirectiveName, typeRoots); + } + } + else { + if (typeRoots === undefined) { + trace(host, ts.Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set, typeReferenceDirectiveName, containingFile); + } + else { + trace(host, ts.Diagnostics.Resolving_type_reference_directive_0_containing_file_1_root_directory_2, typeReferenceDirectiveName, containingFile, typeRoots); + } + } + if (redirectedReference) { + trace(host, ts.Diagnostics.Using_compiler_options_of_project_reference_redirect_0, redirectedReference.sourceFile.fileName); + } + } + var failedLookupLocations = []; + var affectingLocations = []; + var features = getDefaultNodeResolutionFeatures(options); + // Unlike `import` statements, whose mode-calculating APIs are all guaranteed to return `undefined` if we're in an un-mode-ed module resolution + // setting, type references will return their target mode regardless of options because of how the parser works, so we guard against the mode being + // set in a non-modal module resolution setting here. Do note that our behavior is not particularly well defined when these mode-overriding imports + // are present in a non-modal project; while in theory we'd like to either ignore the mode or provide faithful modern resolution, depending on what we feel is best, + // in practice, not every cache has the options available to intelligently make the choice to ignore the mode request, and it's unclear how modern "faithful modern + // resolution" should be (`node16`? `nodenext`?). As such, witnessing a mode-overriding triple-slash reference in a non-modal module resolution + // context should _probably_ be an error - and that should likely be handled by the `Program` (which is what we do). + if (resolutionMode === ts.ModuleKind.ESNext && (ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Node16 || ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.NodeNext)) { + features |= NodeResolutionFeatures.EsmMode; + } + var conditions = features & NodeResolutionFeatures.Exports ? features & NodeResolutionFeatures.EsmMode ? ["node", "import", "types"] : ["node", "require", "types"] : []; + var diagnostics = []; + var moduleResolutionState = { + compilerOptions: options, + host: host, + traceEnabled: traceEnabled, + failedLookupLocations: failedLookupLocations, + affectingLocations: affectingLocations, + packageJsonInfoCache: cache, + features: features, + conditions: conditions, + requestContainingDirectory: containingDirectory, + reportDiagnostic: function (diag) { return void diagnostics.push(diag); }, + }; + var resolved = primaryLookup(); + var primary = true; + if (!resolved) { + resolved = secondaryLookup(); + primary = false; + } + var resolvedTypeReferenceDirective; + if (resolved) { + var fileName = resolved.fileName, packageId = resolved.packageId; + var resolvedFileName = options.preserveSymlinks ? fileName : realPath(fileName, host, traceEnabled); + var pathsAreEqual = arePathsEqual(fileName, resolvedFileName, host); + resolvedTypeReferenceDirective = { + primary: primary, + // If the fileName and realpath are differing only in casing prefer fileName so that we can issue correct errors for casing under forceConsistentCasingInFileNames + resolvedFileName: pathsAreEqual ? fileName : resolvedFileName, + originalPath: pathsAreEqual ? undefined : fileName, + packageId: packageId, + isExternalLibraryImport: pathContainsNodeModules(fileName), + }; + } + result = { resolvedTypeReferenceDirective: resolvedTypeReferenceDirective, failedLookupLocations: failedLookupLocations, affectingLocations: affectingLocations, resolutionDiagnostics: diagnostics }; + perFolderCache === null || perFolderCache === void 0 ? void 0 : perFolderCache.set(typeReferenceDirectiveName, /*mode*/ resolutionMode, result); + if (traceEnabled) + traceResult(result); + return result; + function traceResult(result) { + var _a; + if (!((_a = result.resolvedTypeReferenceDirective) === null || _a === void 0 ? void 0 : _a.resolvedFileName)) { + trace(host, ts.Diagnostics.Type_reference_directive_0_was_not_resolved, typeReferenceDirectiveName); + } + else if (result.resolvedTypeReferenceDirective.packageId) { + trace(host, ts.Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_with_Package_ID_2_primary_Colon_3, typeReferenceDirectiveName, result.resolvedTypeReferenceDirective.resolvedFileName, ts.packageIdToString(result.resolvedTypeReferenceDirective.packageId), result.resolvedTypeReferenceDirective.primary); + } + else { + trace(host, ts.Diagnostics.Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2, typeReferenceDirectiveName, result.resolvedTypeReferenceDirective.resolvedFileName, result.resolvedTypeReferenceDirective.primary); + } + } + function primaryLookup() { + // Check primary library paths + if (typeRoots && typeRoots.length) { + if (traceEnabled) { + trace(host, ts.Diagnostics.Resolving_with_primary_search_path_0, typeRoots.join(", ")); + } + return ts.firstDefined(typeRoots, function (typeRoot) { + var candidate = ts.combinePaths(typeRoot, typeReferenceDirectiveName); + var candidateDirectory = ts.getDirectoryPath(candidate); + var directoryExists = ts.directoryProbablyExists(candidateDirectory, host); + if (!directoryExists && traceEnabled) { + trace(host, ts.Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, candidateDirectory); + } + return resolvedTypeScriptOnly(loadNodeModuleFromDirectory(Extensions.DtsOnly, candidate, !directoryExists, moduleResolutionState)); + }); + } + else { + if (traceEnabled) { + trace(host, ts.Diagnostics.Root_directory_cannot_be_determined_skipping_primary_search_paths); + } + } + } + function secondaryLookup() { + var initialLocationForSecondaryLookup = containingFile && ts.getDirectoryPath(containingFile); + if (initialLocationForSecondaryLookup !== undefined) { + // check secondary locations + if (traceEnabled) { + trace(host, ts.Diagnostics.Looking_up_in_node_modules_folder_initial_location_0, initialLocationForSecondaryLookup); + } + var result_4; + if (!ts.isExternalModuleNameRelative(typeReferenceDirectiveName)) { + var searchResult = loadModuleFromNearestNodeModulesDirectory(Extensions.DtsOnly, typeReferenceDirectiveName, initialLocationForSecondaryLookup, moduleResolutionState, /*cache*/ undefined, /*redirectedReference*/ undefined); + result_4 = searchResult && searchResult.value; + } + else { + var candidate = normalizePathForCJSResolution(initialLocationForSecondaryLookup, typeReferenceDirectiveName).path; + result_4 = nodeLoadModuleByRelativeName(Extensions.DtsOnly, candidate, /*onlyRecordFailures*/ false, moduleResolutionState, /*considerPackageJson*/ true); + } + return resolvedTypeScriptOnly(result_4); + } + else { + if (traceEnabled) { + trace(host, ts.Diagnostics.Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_modules_folder); + } + } + } + } + ts.resolveTypeReferenceDirective = resolveTypeReferenceDirective; + function getDefaultNodeResolutionFeatures(options) { + return ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Node16 ? NodeResolutionFeatures.Node16Default : + ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.NodeNext ? NodeResolutionFeatures.NodeNextDefault : + NodeResolutionFeatures.None; + } + /** + * @internal + * Does not try `@types/${packageName}` - use a second pass if needed. + */ + function resolvePackageNameToPackageJson(packageName, containingDirectory, options, host, cache) { + var moduleResolutionState = getTemporaryModuleResolutionState(cache === null || cache === void 0 ? void 0 : cache.getPackageJsonInfoCache(), host, options); + return ts.forEachAncestorDirectory(containingDirectory, function (ancestorDirectory) { + if (ts.getBaseFileName(ancestorDirectory) !== "node_modules") { + var nodeModulesFolder = ts.combinePaths(ancestorDirectory, "node_modules"); + var candidate = ts.combinePaths(nodeModulesFolder, packageName); + return getPackageJsonInfo(candidate, /*onlyRecordFailures*/ false, moduleResolutionState); + } + }); + } + ts.resolvePackageNameToPackageJson = resolvePackageNameToPackageJson; + /** + * Given a set of options, returns the set of type directive names + * that should be included for this program automatically. + * This list could either come from the config file, + * or from enumerating the types root + initial secondary types lookup location. + * More type directives might appear in the program later as a result of loading actual source files; + * this list is only the set of defaults that are implicitly included. + */ + function getAutomaticTypeDirectiveNames(options, host) { + // Use explicit type list from tsconfig.json + if (options.types) { + return options.types; + } + // Walk the primary type lookup locations + var result = []; + if (host.directoryExists && host.getDirectories) { + var typeRoots = getEffectiveTypeRoots(options, host); + if (typeRoots) { + for (var _i = 0, typeRoots_1 = typeRoots; _i < typeRoots_1.length; _i++) { + var root = typeRoots_1[_i]; + if (host.directoryExists(root)) { + for (var _a = 0, _b = host.getDirectories(root); _a < _b.length; _a++) { + var typeDirectivePath = _b[_a]; + var normalized = ts.normalizePath(typeDirectivePath); + var packageJsonPath = ts.combinePaths(root, normalized, "package.json"); + // `types-publisher` sometimes creates packages with `"typings": null` for packages that don't provide their own types. + // See `createNotNeededPackageJSON` in the types-publisher` repo. + // eslint-disable-next-line no-null/no-null + var isNotNeededPackage = host.fileExists(packageJsonPath) && ts.readJson(packageJsonPath, host).typings === null; + if (!isNotNeededPackage) { + var baseFileName = ts.getBaseFileName(normalized); + // At this stage, skip results with leading dot. + if (baseFileName.charCodeAt(0) !== 46 /* CharacterCodes.dot */) { + // Return just the type directive names + result.push(baseFileName); + } + } + } + } + } + } + } + return result; + } + ts.getAutomaticTypeDirectiveNames = getAutomaticTypeDirectiveNames; + /*@internal*/ + function createCacheWithRedirects(options) { + var ownMap = new ts.Map(); + var redirectsMap = new ts.Map(); + return { + getOwnMap: getOwnMap, + redirectsMap: redirectsMap, + getOrCreateMapOfCacheRedirects: getOrCreateMapOfCacheRedirects, + clear: clear, + setOwnOptions: setOwnOptions, + setOwnMap: setOwnMap + }; + function getOwnMap() { + return ownMap; + } + function setOwnOptions(newOptions) { + options = newOptions; + } + function setOwnMap(newOwnMap) { + ownMap = newOwnMap; + } + function getOrCreateMapOfCacheRedirects(redirectedReference) { + if (!redirectedReference) { + return ownMap; + } + var path = redirectedReference.sourceFile.path; + var redirects = redirectsMap.get(path); + if (!redirects) { + // Reuse map if redirected reference map uses same resolution + redirects = !options || ts.optionsHaveModuleResolutionChanges(options, redirectedReference.commandLine.options) ? new ts.Map() : ownMap; + redirectsMap.set(path, redirects); + } + return redirects; + } + function clear() { + ownMap.clear(); + redirectsMap.clear(); + } + } + ts.createCacheWithRedirects = createCacheWithRedirects; + function createPackageJsonInfoCache(currentDirectory, getCanonicalFileName) { + var cache; + return { getPackageJsonInfo: getPackageJsonInfo, setPackageJsonInfo: setPackageJsonInfo, clear: clear, entries: entries, getInternalMap: getInternalMap }; + function getPackageJsonInfo(packageJsonPath) { + return cache === null || cache === void 0 ? void 0 : cache.get(ts.toPath(packageJsonPath, currentDirectory, getCanonicalFileName)); + } + function setPackageJsonInfo(packageJsonPath, info) { + (cache || (cache = new ts.Map())).set(ts.toPath(packageJsonPath, currentDirectory, getCanonicalFileName), info); + } + function clear() { + cache = undefined; + } + function entries() { + var iter = cache === null || cache === void 0 ? void 0 : cache.entries(); + return iter ? ts.arrayFrom(iter) : []; + } + function getInternalMap() { + return cache; + } + } + function getOrCreateCache(cacheWithRedirects, redirectedReference, key, create) { + var cache = cacheWithRedirects.getOrCreateMapOfCacheRedirects(redirectedReference); + var result = cache.get(key); + if (!result) { + result = create(); + cache.set(key, result); + } + return result; + } + function updateRedirectsMap(options, directoryToModuleNameMap, moduleNameToDirectoryMap) { + if (!options.configFile) + return; + if (directoryToModuleNameMap.redirectsMap.size === 0) { + // The own map will be for projectCompilerOptions + ts.Debug.assert(!moduleNameToDirectoryMap || moduleNameToDirectoryMap.redirectsMap.size === 0); + ts.Debug.assert(directoryToModuleNameMap.getOwnMap().size === 0); + ts.Debug.assert(!moduleNameToDirectoryMap || moduleNameToDirectoryMap.getOwnMap().size === 0); + directoryToModuleNameMap.redirectsMap.set(options.configFile.path, directoryToModuleNameMap.getOwnMap()); + moduleNameToDirectoryMap === null || moduleNameToDirectoryMap === void 0 ? void 0 : moduleNameToDirectoryMap.redirectsMap.set(options.configFile.path, moduleNameToDirectoryMap.getOwnMap()); + } + else { + // Set correct own map + ts.Debug.assert(!moduleNameToDirectoryMap || moduleNameToDirectoryMap.redirectsMap.size > 0); + var ref = { + sourceFile: options.configFile, + commandLine: { options: options } + }; + directoryToModuleNameMap.setOwnMap(directoryToModuleNameMap.getOrCreateMapOfCacheRedirects(ref)); + moduleNameToDirectoryMap === null || moduleNameToDirectoryMap === void 0 ? void 0 : moduleNameToDirectoryMap.setOwnMap(moduleNameToDirectoryMap.getOrCreateMapOfCacheRedirects(ref)); + } + directoryToModuleNameMap.setOwnOptions(options); + moduleNameToDirectoryMap === null || moduleNameToDirectoryMap === void 0 ? void 0 : moduleNameToDirectoryMap.setOwnOptions(options); + } + function createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap) { + return { + getOrCreateCacheForDirectory: getOrCreateCacheForDirectory, + clear: clear, + update: update, + }; + function clear() { + directoryToModuleNameMap.clear(); + } + function update(options) { + updateRedirectsMap(options, directoryToModuleNameMap); + } + function getOrCreateCacheForDirectory(directoryName, redirectedReference) { + var path = ts.toPath(directoryName, currentDirectory, getCanonicalFileName); + return getOrCreateCache(directoryToModuleNameMap, redirectedReference, path, function () { return createModeAwareCache(); }); + } + } + /* @internal */ + function createModeAwareCache() { + var underlying = new ts.Map(); + var memoizedReverseKeys = new ts.Map(); + var cache = { + get: function (specifier, mode) { + return underlying.get(getUnderlyingCacheKey(specifier, mode)); + }, + set: function (specifier, mode, value) { + underlying.set(getUnderlyingCacheKey(specifier, mode), value); + return cache; + }, + delete: function (specifier, mode) { + underlying.delete(getUnderlyingCacheKey(specifier, mode)); + return cache; + }, + has: function (specifier, mode) { + return underlying.has(getUnderlyingCacheKey(specifier, mode)); + }, + forEach: function (cb) { + return underlying.forEach(function (elem, key) { + var _a = memoizedReverseKeys.get(key), specifier = _a[0], mode = _a[1]; + return cb(elem, specifier, mode); + }); + }, + size: function () { + return underlying.size; + } + }; + return cache; + function getUnderlyingCacheKey(specifier, mode) { + var result = mode === undefined ? specifier : "".concat(mode, "|").concat(specifier); + memoizedReverseKeys.set(result, [specifier, mode]); + return result; + } + } + ts.createModeAwareCache = createModeAwareCache; + /* @internal */ + function zipToModeAwareCache(file, keys, values) { + ts.Debug.assert(keys.length === values.length); + var map = createModeAwareCache(); + for (var i = 0; i < keys.length; ++i) { + var entry = keys[i]; + // We lower-case all type references because npm automatically lowercases all packages. See GH#9824. + var name = !ts.isString(entry) ? entry.fileName.toLowerCase() : entry; + var mode = !ts.isString(entry) ? entry.resolutionMode || file.impliedNodeFormat : ts.getModeForResolutionAtIndex(file, i); + map.set(name, mode, values[i]); + } + return map; + } + ts.zipToModeAwareCache = zipToModeAwareCache; + function createModuleResolutionCache(currentDirectory, getCanonicalFileName, options, directoryToModuleNameMap, moduleNameToDirectoryMap) { + var perDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap || (directoryToModuleNameMap = createCacheWithRedirects(options))); + moduleNameToDirectoryMap || (moduleNameToDirectoryMap = createCacheWithRedirects(options)); + var packageJsonInfoCache = createPackageJsonInfoCache(currentDirectory, getCanonicalFileName); + return __assign(__assign(__assign({}, packageJsonInfoCache), perDirectoryResolutionCache), { getOrCreateCacheForModuleName: getOrCreateCacheForModuleName, clear: clear, update: update, getPackageJsonInfoCache: function () { return packageJsonInfoCache; }, clearAllExceptPackageJsonInfoCache: clearAllExceptPackageJsonInfoCache }); + function clear() { + clearAllExceptPackageJsonInfoCache(); + packageJsonInfoCache.clear(); + } + function clearAllExceptPackageJsonInfoCache() { + perDirectoryResolutionCache.clear(); + moduleNameToDirectoryMap.clear(); + } + function update(options) { + updateRedirectsMap(options, directoryToModuleNameMap, moduleNameToDirectoryMap); + } + function getOrCreateCacheForModuleName(nonRelativeModuleName, mode, redirectedReference) { + ts.Debug.assert(!ts.isExternalModuleNameRelative(nonRelativeModuleName)); + return getOrCreateCache(moduleNameToDirectoryMap, redirectedReference, mode === undefined ? nonRelativeModuleName : "".concat(mode, "|").concat(nonRelativeModuleName), createPerModuleNameCache); + } + function createPerModuleNameCache() { + var directoryPathMap = new ts.Map(); + return { get: get, set: set }; + function get(directory) { + return directoryPathMap.get(ts.toPath(directory, currentDirectory, getCanonicalFileName)); + } + /** + * At first this function add entry directory -> module resolution result to the table. + * Then it computes the set of parent folders for 'directory' that should have the same module resolution result + * and for every parent folder in set it adds entry: parent -> module resolution. . + * Lets say we first directory name: /a/b/c/d/e and resolution result is: /a/b/bar.ts. + * Set of parent folders that should have the same result will be: + * [ + * /a/b/c/d, /a/b/c, /a/b + * ] + * this means that request for module resolution from file in any of these folder will be immediately found in cache. + */ + function set(directory, result) { + var path = ts.toPath(directory, currentDirectory, getCanonicalFileName); + // if entry is already in cache do nothing + if (directoryPathMap.has(path)) { + return; + } + directoryPathMap.set(path, result); + var resolvedFileName = result.resolvedModule && + (result.resolvedModule.originalPath || result.resolvedModule.resolvedFileName); + // find common prefix between directory and resolved file name + // this common prefix should be the shortest path that has the same resolution + // directory: /a/b/c/d/e + // resolvedFileName: /a/b/foo.d.ts + // commonPrefix: /a/b + // for failed lookups cache the result for every directory up to root + var commonPrefix = resolvedFileName && getCommonPrefix(path, resolvedFileName); + var current = path; + while (current !== commonPrefix) { + var parent = ts.getDirectoryPath(current); + if (parent === current || directoryPathMap.has(parent)) { + break; + } + directoryPathMap.set(parent, result); + current = parent; + } + } + function getCommonPrefix(directory, resolution) { + var resolutionDirectory = ts.toPath(ts.getDirectoryPath(resolution), currentDirectory, getCanonicalFileName); + // find first position where directory and resolution differs + var i = 0; + var limit = Math.min(directory.length, resolutionDirectory.length); + while (i < limit && directory.charCodeAt(i) === resolutionDirectory.charCodeAt(i)) { + i++; + } + if (i === directory.length && (resolutionDirectory.length === i || resolutionDirectory[i] === ts.directorySeparator)) { + return directory; + } + var rootLength = ts.getRootLength(directory); + if (i < rootLength) { + return undefined; + } + var sep = directory.lastIndexOf(ts.directorySeparator, i - 1); + if (sep === -1) { + return undefined; + } + return directory.substr(0, Math.max(sep, rootLength)); + } + } + } + ts.createModuleResolutionCache = createModuleResolutionCache; + function createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, options, packageJsonInfoCache, directoryToModuleNameMap) { + var perDirectoryResolutionCache = createPerDirectoryResolutionCache(currentDirectory, getCanonicalFileName, directoryToModuleNameMap || (directoryToModuleNameMap = createCacheWithRedirects(options))); + packageJsonInfoCache || (packageJsonInfoCache = createPackageJsonInfoCache(currentDirectory, getCanonicalFileName)); + return __assign(__assign(__assign({}, packageJsonInfoCache), perDirectoryResolutionCache), { clear: clear, clearAllExceptPackageJsonInfoCache: clearAllExceptPackageJsonInfoCache }); + function clear() { + clearAllExceptPackageJsonInfoCache(); + packageJsonInfoCache.clear(); + } + function clearAllExceptPackageJsonInfoCache() { + perDirectoryResolutionCache.clear(); + } + } + ts.createTypeReferenceDirectiveResolutionCache = createTypeReferenceDirectiveResolutionCache; + function resolveModuleNameFromCache(moduleName, containingFile, cache, mode) { + var containingDirectory = ts.getDirectoryPath(containingFile); + var perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory); + if (!perFolderCache) + return undefined; + return perFolderCache.get(moduleName, mode); + } + ts.resolveModuleNameFromCache = resolveModuleNameFromCache; + function resolveModuleName(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) { + var traceEnabled = isTraceEnabled(compilerOptions, host); + if (redirectedReference) { + compilerOptions = redirectedReference.commandLine.options; + } + if (traceEnabled) { + trace(host, ts.Diagnostics.Resolving_module_0_from_1, moduleName, containingFile); + if (redirectedReference) { + trace(host, ts.Diagnostics.Using_compiler_options_of_project_reference_redirect_0, redirectedReference.sourceFile.fileName); + } + } + var containingDirectory = ts.getDirectoryPath(containingFile); + var perFolderCache = cache && cache.getOrCreateCacheForDirectory(containingDirectory, redirectedReference); + var result = perFolderCache && perFolderCache.get(moduleName, resolutionMode); + if (result) { + if (traceEnabled) { + trace(host, ts.Diagnostics.Resolution_for_module_0_was_found_in_cache_from_location_1, moduleName, containingDirectory); + } + } + else { + var moduleResolution = compilerOptions.moduleResolution; + if (moduleResolution === undefined) { + switch (ts.getEmitModuleKind(compilerOptions)) { + case ts.ModuleKind.CommonJS: + moduleResolution = ts.ModuleResolutionKind.NodeJs; + break; + case ts.ModuleKind.Node16: + moduleResolution = ts.ModuleResolutionKind.Node16; + break; + case ts.ModuleKind.NodeNext: + moduleResolution = ts.ModuleResolutionKind.NodeNext; + break; + default: + moduleResolution = ts.ModuleResolutionKind.Classic; + break; + } + if (traceEnabled) { + trace(host, ts.Diagnostics.Module_resolution_kind_is_not_specified_using_0, ts.ModuleResolutionKind[moduleResolution]); + } + } + else { + if (traceEnabled) { + trace(host, ts.Diagnostics.Explicitly_specified_module_resolution_kind_Colon_0, ts.ModuleResolutionKind[moduleResolution]); + } + } + ts.perfLogger.logStartResolveModule(moduleName /* , containingFile, ModuleResolutionKind[moduleResolution]*/); + switch (moduleResolution) { + case ts.ModuleResolutionKind.Node16: + result = node16ModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode); + break; + case ts.ModuleResolutionKind.NodeNext: + result = nodeNextModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode); + break; + case ts.ModuleResolutionKind.NodeJs: + result = nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference); + break; + case ts.ModuleResolutionKind.Classic: + result = classicNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference); + break; + default: + return ts.Debug.fail("Unexpected moduleResolution: ".concat(moduleResolution)); + } + if (result && result.resolvedModule) + ts.perfLogger.logInfoEvent("Module \"".concat(moduleName, "\" resolved to \"").concat(result.resolvedModule.resolvedFileName, "\"")); + ts.perfLogger.logStopResolveModule((result && result.resolvedModule) ? "" + result.resolvedModule.resolvedFileName : "null"); + if (perFolderCache) { + perFolderCache.set(moduleName, resolutionMode, result); + if (!ts.isExternalModuleNameRelative(moduleName)) { + // put result in per-module name cache + cache.getOrCreateCacheForModuleName(moduleName, resolutionMode, redirectedReference).set(containingDirectory, result); + } + } + } + if (traceEnabled) { + if (result.resolvedModule) { + if (result.resolvedModule.packageId) { + trace(host, ts.Diagnostics.Module_name_0_was_successfully_resolved_to_1_with_Package_ID_2, moduleName, result.resolvedModule.resolvedFileName, ts.packageIdToString(result.resolvedModule.packageId)); + } + else { + trace(host, ts.Diagnostics.Module_name_0_was_successfully_resolved_to_1, moduleName, result.resolvedModule.resolvedFileName); + } + } + else { + trace(host, ts.Diagnostics.Module_name_0_was_not_resolved, moduleName); + } + } + return result; + } + ts.resolveModuleName = resolveModuleName; + /** + * Any module resolution kind can be augmented with optional settings: 'baseUrl', 'paths' and 'rootDirs' - they are used to + * mitigate differences between design time structure of the project and its runtime counterpart so the same import name + * can be resolved successfully by TypeScript compiler and runtime module loader. + * If these settings are set then loading procedure will try to use them to resolve module name and it can of failure it will + * fallback to standard resolution routine. + * + * - baseUrl - this setting controls how non-relative module names are resolved. If this setting is specified then non-relative + * names will be resolved relative to baseUrl: i.e. if baseUrl is '/a/b' then candidate location to resolve module name 'c/d' will + * be '/a/b/c/d' + * - paths - this setting can only be used when baseUrl is specified. allows to tune how non-relative module names + * will be resolved based on the content of the module name. + * Structure of 'paths' compiler options + * 'paths': { + * pattern-1: [...substitutions], + * pattern-2: [...substitutions], + * ... + * pattern-n: [...substitutions] + * } + * Pattern here is a string that can contain zero or one '*' character. During module resolution module name will be matched against + * all patterns in the list. Matching for patterns that don't contain '*' means that module name must be equal to pattern respecting the case. + * If pattern contains '*' then to match pattern "*" module name must start with the and end with . + * denotes part of the module name between and . + * If module name can be matches with multiple patterns then pattern with the longest prefix will be picked. + * After selecting pattern we'll use list of substitutions to get candidate locations of the module and the try to load module + * from the candidate location. + * Substitution is a string that can contain zero or one '*'. To get candidate location from substitution we'll pick every + * substitution in the list and replace '*' with string. If candidate location is not rooted it + * will be converted to absolute using baseUrl. + * For example: + * baseUrl: /a/b/c + * "paths": { + * // match all module names + * "*": [ + * "*", // use matched name as is, + * // will be looked as /a/b/c/ + * + * "folder1/*" // substitution will convert matched name to 'folder1/', + * // since it is not rooted then final candidate location will be /a/b/c/folder1/ + * ], + * // match module names that start with 'components/' + * "components/*": [ "/root/components/*" ] // substitution will convert /components/folder1/ to '/root/components/folder1/', + * // it is rooted so it will be final candidate location + * } + * + * 'rootDirs' allows the project to be spreaded across multiple locations and resolve modules with relative names as if + * they were in the same location. For example lets say there are two files + * '/local/src/content/file1.ts' + * '/shared/components/contracts/src/content/protocols/file2.ts' + * After bundling content of '/shared/components/contracts/src' will be merged with '/local/src' so + * if file1 has the following import 'import {x} from "./protocols/file2"' it will be resolved successfully in runtime. + * 'rootDirs' provides the way to tell compiler that in order to get the whole project it should behave as if content of all + * root dirs were merged together. + * I.e. for the example above 'rootDirs' will have two entries: [ '/local/src', '/shared/components/contracts/src' ]. + * Compiler will first convert './protocols/file2' into absolute path relative to the location of containing file: + * '/local/src/content/protocols/file2' and try to load it - failure. + * Then it will search 'rootDirs' looking for a longest matching prefix of this absolute path and if such prefix is found - absolute path will + * be converted to a path relative to found rootDir entry './content/protocols/file2' (*). As a last step compiler will check all remaining + * entries in 'rootDirs', use them to build absolute path out of (*) and try to resolve module from this location. + */ + function tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loader, state) { + var resolved = tryLoadModuleUsingPathsIfEligible(extensions, moduleName, loader, state); + if (resolved) + return resolved.value; + if (!ts.isExternalModuleNameRelative(moduleName)) { + return tryLoadModuleUsingBaseUrl(extensions, moduleName, loader, state); + } + else { + return tryLoadModuleUsingRootDirs(extensions, moduleName, containingDirectory, loader, state); + } + } + function tryLoadModuleUsingPathsIfEligible(extensions, moduleName, loader, state) { + var _a; + var _b = state.compilerOptions, baseUrl = _b.baseUrl, paths = _b.paths, configFile = _b.configFile; + if (paths && !ts.pathIsRelative(moduleName)) { + if (state.traceEnabled) { + if (baseUrl) { + trace(state.host, ts.Diagnostics.baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1, baseUrl, moduleName); + } + trace(state.host, ts.Diagnostics.paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0, moduleName); + } + var baseDirectory = ts.getPathsBasePath(state.compilerOptions, state.host); // Always defined when 'paths' is defined + var pathPatterns = (configFile === null || configFile === void 0 ? void 0 : configFile.configFileSpecs) ? (_a = configFile.configFileSpecs).pathPatterns || (_a.pathPatterns = ts.tryParsePatterns(paths)) : undefined; + return tryLoadModuleUsingPaths(extensions, moduleName, baseDirectory, paths, pathPatterns, loader, /*onlyRecordFailures*/ false, state); + } + } + function tryLoadModuleUsingRootDirs(extensions, moduleName, containingDirectory, loader, state) { + if (!state.compilerOptions.rootDirs) { + return undefined; + } + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0, moduleName); + } + var candidate = ts.normalizePath(ts.combinePaths(containingDirectory, moduleName)); + var matchedRootDir; + var matchedNormalizedPrefix; + for (var _i = 0, _a = state.compilerOptions.rootDirs; _i < _a.length; _i++) { + var rootDir = _a[_i]; + // rootDirs are expected to be absolute + // in case of tsconfig.json this will happen automatically - compiler will expand relative names + // using location of tsconfig.json as base location + var normalizedRoot = ts.normalizePath(rootDir); + if (!ts.endsWith(normalizedRoot, ts.directorySeparator)) { + normalizedRoot += ts.directorySeparator; + } + var isLongestMatchingPrefix = ts.startsWith(candidate, normalizedRoot) && + (matchedNormalizedPrefix === undefined || matchedNormalizedPrefix.length < normalizedRoot.length); + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Checking_if_0_is_the_longest_matching_prefix_for_1_2, normalizedRoot, candidate, isLongestMatchingPrefix); + } + if (isLongestMatchingPrefix) { + matchedNormalizedPrefix = normalizedRoot; + matchedRootDir = rootDir; + } + } + if (matchedNormalizedPrefix) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Longest_matching_prefix_for_0_is_1, candidate, matchedNormalizedPrefix); + } + var suffix = candidate.substr(matchedNormalizedPrefix.length); + // first - try to load from a initial location + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Loading_0_from_the_root_dir_1_candidate_location_2, suffix, matchedNormalizedPrefix, candidate); + } + var resolvedFileName = loader(extensions, candidate, !ts.directoryProbablyExists(containingDirectory, state.host), state); + if (resolvedFileName) { + return resolvedFileName; + } + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Trying_other_entries_in_rootDirs); + } + // then try to resolve using remaining entries in rootDirs + for (var _b = 0, _c = state.compilerOptions.rootDirs; _b < _c.length; _b++) { + var rootDir = _c[_b]; + if (rootDir === matchedRootDir) { + // skip the initially matched entry + continue; + } + var candidate_1 = ts.combinePaths(ts.normalizePath(rootDir), suffix); + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Loading_0_from_the_root_dir_1_candidate_location_2, suffix, rootDir, candidate_1); + } + var baseDirectory = ts.getDirectoryPath(candidate_1); + var resolvedFileName_1 = loader(extensions, candidate_1, !ts.directoryProbablyExists(baseDirectory, state.host), state); + if (resolvedFileName_1) { + return resolvedFileName_1; + } + } + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Module_resolution_using_rootDirs_has_failed); + } + } + return undefined; + } + function tryLoadModuleUsingBaseUrl(extensions, moduleName, loader, state) { + var baseUrl = state.compilerOptions.baseUrl; + if (!baseUrl) { + return undefined; + } + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1, baseUrl, moduleName); + } + var candidate = ts.normalizePath(ts.combinePaths(baseUrl, moduleName)); + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Resolving_module_name_0_relative_to_base_url_1_2, moduleName, baseUrl, candidate); + } + return loader(extensions, candidate, !ts.directoryProbablyExists(ts.getDirectoryPath(candidate), state.host), state); + } + /** + * Expose resolution logic to allow us to use Node module resolution logic from arbitrary locations. + * No way to do this with `require()`: https://github.com/nodejs/node/issues/5963 + * Throws an error if the module can't be resolved. + */ + /* @internal */ + function resolveJSModule(moduleName, initialDir, host) { + var _a = tryResolveJSModuleWorker(moduleName, initialDir, host), resolvedModule = _a.resolvedModule, failedLookupLocations = _a.failedLookupLocations; + if (!resolvedModule) { + throw new Error("Could not resolve JS module '".concat(moduleName, "' starting at '").concat(initialDir, "'. Looked in: ").concat(failedLookupLocations.join(", "))); + } + return resolvedModule.resolvedFileName; + } + ts.resolveJSModule = resolveJSModule; + /* @internal */ + var NodeResolutionFeatures; + (function (NodeResolutionFeatures) { + NodeResolutionFeatures[NodeResolutionFeatures["None"] = 0] = "None"; + // resolving `#local` names in your own package.json + NodeResolutionFeatures[NodeResolutionFeatures["Imports"] = 2] = "Imports"; + // resolving `your-own-name` from your own package.json + NodeResolutionFeatures[NodeResolutionFeatures["SelfName"] = 4] = "SelfName"; + // respecting the `.exports` member of packages' package.json files and its (conditional) mappings of export names + NodeResolutionFeatures[NodeResolutionFeatures["Exports"] = 8] = "Exports"; + // allowing `*` in the LHS of an export to be followed by more content, eg `"./whatever/*.js"` + // not supported in node 12 - https://github.com/nodejs/Release/issues/690 + NodeResolutionFeatures[NodeResolutionFeatures["ExportsPatternTrailers"] = 16] = "ExportsPatternTrailers"; + NodeResolutionFeatures[NodeResolutionFeatures["AllFeatures"] = 30] = "AllFeatures"; + NodeResolutionFeatures[NodeResolutionFeatures["Node16Default"] = 30] = "Node16Default"; + NodeResolutionFeatures[NodeResolutionFeatures["NodeNextDefault"] = 30] = "NodeNextDefault"; + NodeResolutionFeatures[NodeResolutionFeatures["EsmMode"] = 32] = "EsmMode"; + })(NodeResolutionFeatures || (NodeResolutionFeatures = {})); + function node16ModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) { + return nodeNextModuleNameResolverWorker(NodeResolutionFeatures.Node16Default, moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode); + } + function nodeNextModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) { + return nodeNextModuleNameResolverWorker(NodeResolutionFeatures.NodeNextDefault, moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode); + } + var jsOnlyExtensions = [Extensions.JavaScript]; + var tsExtensions = [Extensions.TypeScript, Extensions.JavaScript]; + var tsPlusJsonExtensions = __spreadArray(__spreadArray([], tsExtensions, true), [Extensions.Json], false); + var tsconfigExtensions = [Extensions.TSConfig]; + function nodeNextModuleNameResolverWorker(features, moduleName, containingFile, compilerOptions, host, cache, redirectedReference, resolutionMode) { + var containingDirectory = ts.getDirectoryPath(containingFile); + // es module file or cjs-like input file, use a variant of the legacy cjs resolver that supports the selected modern features + var esmMode = resolutionMode === ts.ModuleKind.ESNext ? NodeResolutionFeatures.EsmMode : 0; + var extensions = compilerOptions.noDtsResolution ? [Extensions.TsOnly, Extensions.JavaScript] : tsExtensions; + if (compilerOptions.resolveJsonModule) { + extensions = __spreadArray(__spreadArray([], extensions, true), [Extensions.Json], false); + } + return nodeModuleNameResolverWorker(features | esmMode, moduleName, containingDirectory, compilerOptions, host, cache, extensions, redirectedReference); + } + function tryResolveJSModuleWorker(moduleName, initialDir, host) { + return nodeModuleNameResolverWorker(NodeResolutionFeatures.None, moduleName, initialDir, { moduleResolution: ts.ModuleResolutionKind.NodeJs, allowJs: true }, host, /*cache*/ undefined, jsOnlyExtensions, /*redirectedReferences*/ undefined); + } + function nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, lookupConfig) { + var extensions; + if (lookupConfig) { + extensions = tsconfigExtensions; + } + else if (compilerOptions.noDtsResolution) { + extensions = [Extensions.TsOnly]; + if (compilerOptions.allowJs) + extensions.push(Extensions.JavaScript); + if (compilerOptions.resolveJsonModule) + extensions.push(Extensions.Json); + } + else { + extensions = compilerOptions.resolveJsonModule ? tsPlusJsonExtensions : tsExtensions; + } + return nodeModuleNameResolverWorker(NodeResolutionFeatures.None, moduleName, ts.getDirectoryPath(containingFile), compilerOptions, host, cache, extensions, redirectedReference); + } + ts.nodeModuleNameResolver = nodeModuleNameResolver; + function nodeModuleNameResolverWorker(features, moduleName, containingDirectory, compilerOptions, host, cache, extensions, redirectedReference) { + var _a, _b; + var traceEnabled = isTraceEnabled(compilerOptions, host); + var failedLookupLocations = []; + var affectingLocations = []; + // conditions are only used by the node16/nodenext resolver - there's no priority order in the list, + //it's essentially a set (priority is determined by object insertion order in the object we look at). + var conditions = features & NodeResolutionFeatures.EsmMode ? ["node", "import", "types"] : ["node", "require", "types"]; + if (compilerOptions.noDtsResolution) { + conditions.pop(); + } + var diagnostics = []; + var state = { + compilerOptions: compilerOptions, + host: host, + traceEnabled: traceEnabled, + failedLookupLocations: failedLookupLocations, + affectingLocations: affectingLocations, + packageJsonInfoCache: cache, + features: features, + conditions: conditions, + requestContainingDirectory: containingDirectory, + reportDiagnostic: function (diag) { return void diagnostics.push(diag); }, + }; + if (traceEnabled && ts.getEmitModuleResolutionKind(compilerOptions) >= ts.ModuleResolutionKind.Node16 && ts.getEmitModuleResolutionKind(compilerOptions) <= ts.ModuleResolutionKind.NodeNext) { + trace(host, ts.Diagnostics.Resolving_in_0_mode_with_conditions_1, features & NodeResolutionFeatures.EsmMode ? "ESM" : "CJS", conditions.map(function (c) { return "'".concat(c, "'"); }).join(", ")); + } + var result = ts.forEach(extensions, function (ext) { return tryResolve(ext); }); + return createResolvedModuleWithFailedLookupLocations((_a = result === null || result === void 0 ? void 0 : result.value) === null || _a === void 0 ? void 0 : _a.resolved, (_b = result === null || result === void 0 ? void 0 : result.value) === null || _b === void 0 ? void 0 : _b.isExternalLibraryImport, failedLookupLocations, affectingLocations, diagnostics, state.resultFromCache); + function tryResolve(extensions) { + var loader = function (extensions, candidate, onlyRecordFailures, state) { return nodeLoadModuleByRelativeName(extensions, candidate, onlyRecordFailures, state, /*considerPackageJson*/ true); }; + var resolved = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loader, state); + if (resolved) { + return toSearchResult({ resolved: resolved, isExternalLibraryImport: pathContainsNodeModules(resolved.path) }); + } + if (!ts.isExternalModuleNameRelative(moduleName)) { + var resolved_1; + if (features & NodeResolutionFeatures.Imports && ts.startsWith(moduleName, "#")) { + resolved_1 = loadModuleFromImports(extensions, moduleName, containingDirectory, state, cache, redirectedReference); + } + if (!resolved_1 && features & NodeResolutionFeatures.SelfName) { + resolved_1 = loadModuleFromSelfNameReference(extensions, moduleName, containingDirectory, state, cache, redirectedReference); + } + if (!resolved_1) { + if (traceEnabled) { + trace(host, ts.Diagnostics.Loading_module_0_from_node_modules_folder_target_file_type_1, moduleName, Extensions[extensions]); + } + resolved_1 = loadModuleFromNearestNodeModulesDirectory(extensions, moduleName, containingDirectory, state, cache, redirectedReference); + } + if (!resolved_1) + return undefined; + var resolvedValue = resolved_1.value; + if (!compilerOptions.preserveSymlinks && resolvedValue && !resolvedValue.originalPath) { + var path = realPath(resolvedValue.path, host, traceEnabled); + var pathsAreEqual = arePathsEqual(path, resolvedValue.path, host); + var originalPath = pathsAreEqual ? undefined : resolvedValue.path; + // If the path and realpath are differing only in casing prefer path so that we can issue correct errors for casing under forceConsistentCasingInFileNames + resolvedValue = __assign(__assign({}, resolvedValue), { path: pathsAreEqual ? resolvedValue.path : path, originalPath: originalPath }); + } + // For node_modules lookups, get the real path so that multiple accesses to an `npm link`-ed module do not create duplicate files. + return { value: resolvedValue && { resolved: resolvedValue, isExternalLibraryImport: true } }; + } + else { + var _a = normalizePathForCJSResolution(containingDirectory, moduleName), candidate = _a.path, parts = _a.parts; + var resolved_2 = nodeLoadModuleByRelativeName(extensions, candidate, /*onlyRecordFailures*/ false, state, /*considerPackageJson*/ true); + // Treat explicit "node_modules" import as an external library import. + return resolved_2 && toSearchResult({ resolved: resolved_2, isExternalLibraryImport: ts.contains(parts, "node_modules") }); + } + } + } + // If you import from "." inside a containing directory "/foo", the result of `normalizePath` + // would be "/foo", but this loses the information that `foo` is a directory and we intended + // to look inside of it. The Node CommonJS resolution algorithm doesn't call this out + // (https://nodejs.org/api/modules.html#all-together), but it seems that module paths ending + // in `.` are actually normalized to `./` before proceeding with the resolution algorithm. + function normalizePathForCJSResolution(containingDirectory, moduleName) { + var combined = ts.combinePaths(containingDirectory, moduleName); + var parts = ts.getPathComponents(combined); + var lastPart = ts.lastOrUndefined(parts); + var path = lastPart === "." || lastPart === ".." ? ts.ensureTrailingDirectorySeparator(ts.normalizePath(combined)) : ts.normalizePath(combined); + return { path: path, parts: parts }; + } + function realPath(path, host, traceEnabled) { + if (!host.realpath) { + return path; + } + var real = ts.normalizePath(host.realpath(path)); + if (traceEnabled) { + trace(host, ts.Diagnostics.Resolving_real_path_for_0_result_1, path, real); + } + ts.Debug.assert(host.fileExists(real), "".concat(path, " linked to nonexistent file ").concat(real)); + return real; + } + function nodeLoadModuleByRelativeName(extensions, candidate, onlyRecordFailures, state, considerPackageJson) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_type_1, candidate, Extensions[extensions]); + } + if (!ts.hasTrailingDirectorySeparator(candidate)) { + if (!onlyRecordFailures) { + var parentOfCandidate = ts.getDirectoryPath(candidate); + if (!ts.directoryProbablyExists(parentOfCandidate, state.host)) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, parentOfCandidate); + } + onlyRecordFailures = true; + } + } + var resolvedFromFile = loadModuleFromFile(extensions, candidate, onlyRecordFailures, state); + if (resolvedFromFile) { + var packageDirectory = considerPackageJson ? parseNodeModuleFromPath(resolvedFromFile.path) : undefined; + var packageInfo = packageDirectory ? getPackageJsonInfo(packageDirectory, /*onlyRecordFailures*/ false, state) : undefined; + return withPackageId(packageInfo, resolvedFromFile); + } + } + if (!onlyRecordFailures) { + var candidateExists = ts.directoryProbablyExists(candidate, state.host); + if (!candidateExists) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, candidate); + } + onlyRecordFailures = true; + } + } + // esm mode relative imports shouldn't do any directory lookups (either inside `package.json` + // files or implicit `index.js`es). This is a notable depature from cjs norms, where `./foo/pkg` + // could have been redirected by `./foo/pkg/package.json` to an arbitrary location! + if (!(state.features & NodeResolutionFeatures.EsmMode)) { + return loadNodeModuleFromDirectory(extensions, candidate, onlyRecordFailures, state, considerPackageJson); + } + return undefined; + } + /*@internal*/ + ts.nodeModulesPathPart = "/node_modules/"; + /*@internal*/ + function pathContainsNodeModules(path) { + return ts.stringContains(path, ts.nodeModulesPathPart); + } + ts.pathContainsNodeModules = pathContainsNodeModules; + /** + * This will be called on the successfully resolved path from `loadModuleFromFile`. + * (Not needed for `loadModuleFromNodeModules` as that looks up the `package.json` as part of resolution.) + * + * packageDirectory is the directory of the package itself. + * For `blah/node_modules/foo/index.d.ts` this is packageDirectory: "foo" + * For `/node_modules/foo/bar.d.ts` this is packageDirectory: "foo" + * For `/node_modules/@types/foo/bar/index.d.ts` this is packageDirectory: "@types/foo" + * For `/node_modules/foo/bar/index.d.ts` this is packageDirectory: "foo" + */ + /* @internal */ + function parseNodeModuleFromPath(resolved) { + var path = ts.normalizePath(resolved); + var idx = path.lastIndexOf(ts.nodeModulesPathPart); + if (idx === -1) { + return undefined; + } + var indexAfterNodeModules = idx + ts.nodeModulesPathPart.length; + var indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path, indexAfterNodeModules); + if (path.charCodeAt(indexAfterNodeModules) === 64 /* CharacterCodes.at */) { + indexAfterPackageName = moveToNextDirectorySeparatorIfAvailable(path, indexAfterPackageName); + } + return path.slice(0, indexAfterPackageName); + } + ts.parseNodeModuleFromPath = parseNodeModuleFromPath; + function moveToNextDirectorySeparatorIfAvailable(path, prevSeparatorIndex) { + var nextSeparatorIndex = path.indexOf(ts.directorySeparator, prevSeparatorIndex + 1); + return nextSeparatorIndex === -1 ? prevSeparatorIndex : nextSeparatorIndex; + } + function loadModuleFromFileNoPackageId(extensions, candidate, onlyRecordFailures, state) { + return noPackageId(loadModuleFromFile(extensions, candidate, onlyRecordFailures, state)); + } + /** + * @param {boolean} onlyRecordFailures - if true then function won't try to actually load files but instead record all attempts as failures. This flag is necessary + * in cases when we know upfront that all load attempts will fail (because containing folder does not exists) however we still need to record all failed lookup locations. + */ + function loadModuleFromFile(extensions, candidate, onlyRecordFailures, state) { + if (extensions === Extensions.Json || extensions === Extensions.TSConfig) { + var extensionLess = ts.tryRemoveExtension(candidate, ".json" /* Extension.Json */); + var extension = extensionLess ? candidate.substring(extensionLess.length) : ""; + return (extensionLess === undefined && extensions === Extensions.Json) ? undefined : tryAddingExtensions(extensionLess || candidate, extensions, extension, onlyRecordFailures, state); + } + // esm mode resolutions don't include automatic extension lookup (without additional flags, at least) + if (!(state.features & NodeResolutionFeatures.EsmMode)) { + // First, try adding an extension. An import of "foo" could be matched by a file "foo.ts", or "foo.js" by "foo.js.ts" + var resolvedByAddingExtension = tryAddingExtensions(candidate, extensions, "", onlyRecordFailures, state); + if (resolvedByAddingExtension) { + return resolvedByAddingExtension; + } + } + return loadModuleFromFileNoImplicitExtensions(extensions, candidate, onlyRecordFailures, state); + } + function loadModuleFromFileNoImplicitExtensions(extensions, candidate, onlyRecordFailures, state) { + // If that didn't work, try stripping a ".js" or ".jsx" extension and replacing it with a TypeScript one; + // e.g. "./foo.js" can be matched by "./foo.ts" or "./foo.d.ts" + if (ts.hasJSFileExtension(candidate) || (ts.fileExtensionIs(candidate, ".json" /* Extension.Json */) && state.compilerOptions.resolveJsonModule)) { + var extensionless = ts.removeFileExtension(candidate); + var extension = candidate.substring(extensionless.length); + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.File_name_0_has_a_1_extension_stripping_it, candidate, extension); + } + return tryAddingExtensions(extensionless, extensions, extension, onlyRecordFailures, state); + } + } + function loadJSOrExactTSFileName(extensions, candidate, onlyRecordFailures, state) { + if ((extensions === Extensions.TypeScript || extensions === Extensions.DtsOnly) && ts.fileExtensionIsOneOf(candidate, ts.supportedTSExtensionsFlat)) { + var result = tryFile(candidate, onlyRecordFailures, state); + return result !== undefined ? { path: candidate, ext: ts.tryExtractTSExtension(candidate) } : undefined; + } + return loadModuleFromFileNoImplicitExtensions(extensions, candidate, onlyRecordFailures, state); + } + /** Try to return an existing file that adds one of the `extensions` to `candidate`. */ + function tryAddingExtensions(candidate, extensions, originalExtension, onlyRecordFailures, state) { + if (!onlyRecordFailures) { + // check if containing folder exists - if it doesn't then just record failures for all supported extensions without disk probing + var directory = ts.getDirectoryPath(candidate); + if (directory) { + onlyRecordFailures = !ts.directoryProbablyExists(directory, state.host); + } + } + switch (extensions) { + case Extensions.DtsOnly: + switch (originalExtension) { + case ".mjs" /* Extension.Mjs */: + case ".mts" /* Extension.Mts */: + case ".d.mts" /* Extension.Dmts */: + return tryExtension(".d.mts" /* Extension.Dmts */); + case ".cjs" /* Extension.Cjs */: + case ".cts" /* Extension.Cts */: + case ".d.cts" /* Extension.Dcts */: + return tryExtension(".d.cts" /* Extension.Dcts */); + case ".json" /* Extension.Json */: + candidate += ".json" /* Extension.Json */; + return tryExtension(".d.ts" /* Extension.Dts */); + default: return tryExtension(".d.ts" /* Extension.Dts */); + } + case Extensions.TypeScript: + case Extensions.TsOnly: + var useDts = extensions === Extensions.TypeScript; + switch (originalExtension) { + case ".mjs" /* Extension.Mjs */: + case ".mts" /* Extension.Mts */: + case ".d.mts" /* Extension.Dmts */: + return tryExtension(".mts" /* Extension.Mts */) || (useDts ? tryExtension(".d.mts" /* Extension.Dmts */) : undefined); + case ".cjs" /* Extension.Cjs */: + case ".cts" /* Extension.Cts */: + case ".d.cts" /* Extension.Dcts */: + return tryExtension(".cts" /* Extension.Cts */) || (useDts ? tryExtension(".d.cts" /* Extension.Dcts */) : undefined); + case ".json" /* Extension.Json */: + candidate += ".json" /* Extension.Json */; + return useDts ? tryExtension(".d.ts" /* Extension.Dts */) : undefined; + default: + return tryExtension(".ts" /* Extension.Ts */) || tryExtension(".tsx" /* Extension.Tsx */) || (useDts ? tryExtension(".d.ts" /* Extension.Dts */) : undefined); + } + case Extensions.JavaScript: + switch (originalExtension) { + case ".mjs" /* Extension.Mjs */: + case ".mts" /* Extension.Mts */: + case ".d.mts" /* Extension.Dmts */: + return tryExtension(".mjs" /* Extension.Mjs */); + case ".cjs" /* Extension.Cjs */: + case ".cts" /* Extension.Cts */: + case ".d.cts" /* Extension.Dcts */: + return tryExtension(".cjs" /* Extension.Cjs */); + case ".json" /* Extension.Json */: + return tryExtension(".json" /* Extension.Json */); + default: + return tryExtension(".js" /* Extension.Js */) || tryExtension(".jsx" /* Extension.Jsx */); + } + case Extensions.TSConfig: + case Extensions.Json: + return tryExtension(".json" /* Extension.Json */); + } + function tryExtension(ext) { + var path = tryFile(candidate + ext, onlyRecordFailures, state); + return path === undefined ? undefined : { path: path, ext: ext }; + } + } + /** Return the file if it exists. */ + function tryFile(fileName, onlyRecordFailures, state) { + var _a, _b; + if (!((_a = state.compilerOptions.moduleSuffixes) === null || _a === void 0 ? void 0 : _a.length)) { + return tryFileLookup(fileName, onlyRecordFailures, state); + } + var ext = (_b = ts.tryGetExtensionFromPath(fileName)) !== null && _b !== void 0 ? _b : ""; + var fileNameNoExtension = ext ? ts.removeExtension(fileName, ext) : fileName; + return ts.forEach(state.compilerOptions.moduleSuffixes, function (suffix) { return tryFileLookup(fileNameNoExtension + suffix + ext, onlyRecordFailures, state); }); + } + function tryFileLookup(fileName, onlyRecordFailures, state) { + if (!onlyRecordFailures) { + if (state.host.fileExists(fileName)) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.File_0_exist_use_it_as_a_name_resolution_result, fileName); + } + return fileName; + } + else { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.File_0_does_not_exist, fileName); + } + } + } + state.failedLookupLocations.push(fileName); + return undefined; + } + function loadNodeModuleFromDirectory(extensions, candidate, onlyRecordFailures, state, considerPackageJson) { + if (considerPackageJson === void 0) { considerPackageJson = true; } + var packageInfo = considerPackageJson ? getPackageJsonInfo(candidate, onlyRecordFailures, state) : undefined; + var packageJsonContent = packageInfo && packageInfo.contents.packageJsonContent; + var versionPaths = packageInfo && packageInfo.contents.versionPaths; + return withPackageId(packageInfo, loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, packageJsonContent, versionPaths)); + } + /* @internal */ + function getEntrypointsFromPackageJsonInfo(packageJsonInfo, options, host, cache, resolveJs) { + if (!resolveJs && packageJsonInfo.contents.resolvedEntrypoints !== undefined) { + // Cached value excludes resolutions to JS files - those could be + // cached separately, but they're used rarely. + return packageJsonInfo.contents.resolvedEntrypoints; + } + var entrypoints; + var extensions = resolveJs ? Extensions.JavaScript : Extensions.TypeScript; + var features = getDefaultNodeResolutionFeatures(options); + var requireState = getTemporaryModuleResolutionState(cache === null || cache === void 0 ? void 0 : cache.getPackageJsonInfoCache(), host, options); + requireState.conditions = ["node", "require", "types"]; + requireState.requestContainingDirectory = packageJsonInfo.packageDirectory; + var requireResolution = loadNodeModuleFromDirectoryWorker(extensions, packageJsonInfo.packageDirectory, + /*onlyRecordFailures*/ false, requireState, packageJsonInfo.contents.packageJsonContent, packageJsonInfo.contents.versionPaths); + entrypoints = ts.append(entrypoints, requireResolution === null || requireResolution === void 0 ? void 0 : requireResolution.path); + if (features & NodeResolutionFeatures.Exports && packageJsonInfo.contents.packageJsonContent.exports) { + for (var _i = 0, _a = [["node", "import", "types"], ["node", "require", "types"]]; _i < _a.length; _i++) { + var conditions = _a[_i]; + var exportState = __assign(__assign({}, requireState), { failedLookupLocations: [], conditions: conditions }); + var exportResolutions = loadEntrypointsFromExportMap(packageJsonInfo, packageJsonInfo.contents.packageJsonContent.exports, exportState, extensions); + if (exportResolutions) { + for (var _b = 0, exportResolutions_1 = exportResolutions; _b < exportResolutions_1.length; _b++) { + var resolution = exportResolutions_1[_b]; + entrypoints = ts.appendIfUnique(entrypoints, resolution.path); + } + } + } + } + return packageJsonInfo.contents.resolvedEntrypoints = entrypoints || false; + } + ts.getEntrypointsFromPackageJsonInfo = getEntrypointsFromPackageJsonInfo; + function loadEntrypointsFromExportMap(scope, exports, state, extensions) { + var entrypoints; + if (ts.isArray(exports)) { + for (var _i = 0, exports_1 = exports; _i < exports_1.length; _i++) { + var target = exports_1[_i]; + loadEntrypointsFromTargetExports(target); + } + } + // eslint-disable-next-line no-null/no-null + else if (typeof exports === "object" && exports !== null && allKeysStartWithDot(exports)) { + for (var key in exports) { + loadEntrypointsFromTargetExports(exports[key]); + } + } + else { + loadEntrypointsFromTargetExports(exports); + } + return entrypoints; + function loadEntrypointsFromTargetExports(target) { + var _a, _b; + if (typeof target === "string" && ts.startsWith(target, "./") && target.indexOf("*") === -1) { + var partsAfterFirst = ts.getPathComponents(target).slice(2); + if (partsAfterFirst.indexOf("..") >= 0 || partsAfterFirst.indexOf(".") >= 0 || partsAfterFirst.indexOf("node_modules") >= 0) { + return false; + } + var resolvedTarget = ts.combinePaths(scope.packageDirectory, target); + var finalPath = ts.getNormalizedAbsolutePath(resolvedTarget, (_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a)); + var result = loadJSOrExactTSFileName(extensions, finalPath, /*recordOnlyFailures*/ false, state); + if (result) { + entrypoints = ts.appendIfUnique(entrypoints, result, function (a, b) { return a.path === b.path; }); + return true; + } + } + else if (Array.isArray(target)) { + for (var _i = 0, target_1 = target; _i < target_1.length; _i++) { + var t = target_1[_i]; + var success = loadEntrypointsFromTargetExports(t); + if (success) { + return true; + } + } + } + // eslint-disable-next-line no-null/no-null + else if (typeof target === "object" && target !== null) { + return ts.forEach(ts.getOwnKeys(target), function (key) { + if (key === "default" || ts.contains(state.conditions, key) || isApplicableVersionedTypesKey(state.conditions, key)) { + loadEntrypointsFromTargetExports(target[key]); + return true; + } + }); + } + } + } + /*@internal*/ + function getTemporaryModuleResolutionState(packageJsonInfoCache, host, options) { + return { + host: host, + compilerOptions: options, + traceEnabled: isTraceEnabled(options, host), + failedLookupLocations: ts.noopPush, + affectingLocations: ts.noopPush, + packageJsonInfoCache: packageJsonInfoCache, + features: NodeResolutionFeatures.None, + conditions: ts.emptyArray, + requestContainingDirectory: undefined, + reportDiagnostic: ts.noop + }; + } + ts.getTemporaryModuleResolutionState = getTemporaryModuleResolutionState; + /** + * A function for locating the package.json scope for a given path + */ + /*@internal*/ + function getPackageScopeForPath(fileName, state) { + var parts = ts.getPathComponents(fileName); + parts.pop(); + while (parts.length > 0) { + var pkg = getPackageJsonInfo(ts.getPathFromPathComponents(parts), /*onlyRecordFailures*/ false, state); + if (pkg) { + return pkg; + } + parts.pop(); + } + return undefined; + } + ts.getPackageScopeForPath = getPackageScopeForPath; + /*@internal*/ + function getPackageJsonInfo(packageDirectory, onlyRecordFailures, state) { + var _a, _b, _c; + var host = state.host, traceEnabled = state.traceEnabled; + var packageJsonPath = ts.combinePaths(packageDirectory, "package.json"); + if (onlyRecordFailures) { + state.failedLookupLocations.push(packageJsonPath); + return undefined; + } + var existing = (_a = state.packageJsonInfoCache) === null || _a === void 0 ? void 0 : _a.getPackageJsonInfo(packageJsonPath); + if (existing !== undefined) { + if (typeof existing !== "boolean") { + if (traceEnabled) + trace(host, ts.Diagnostics.File_0_exists_according_to_earlier_cached_lookups, packageJsonPath); + state.affectingLocations.push(packageJsonPath); + return existing.packageDirectory === packageDirectory ? + existing : + { packageDirectory: packageDirectory, contents: existing.contents }; + } + else { + if (existing && traceEnabled) + trace(host, ts.Diagnostics.File_0_does_not_exist_according_to_earlier_cached_lookups, packageJsonPath); + state.failedLookupLocations.push(packageJsonPath); + return undefined; + } + } + var directoryExists = ts.directoryProbablyExists(packageDirectory, host); + if (directoryExists && host.fileExists(packageJsonPath)) { + var packageJsonContent = ts.readJson(packageJsonPath, host); + if (traceEnabled) { + trace(host, ts.Diagnostics.Found_package_json_at_0, packageJsonPath); + } + var versionPaths = readPackageJsonTypesVersionPaths(packageJsonContent, state); + var result = { packageDirectory: packageDirectory, contents: { packageJsonContent: packageJsonContent, versionPaths: versionPaths, resolvedEntrypoints: undefined } }; + (_b = state.packageJsonInfoCache) === null || _b === void 0 ? void 0 : _b.setPackageJsonInfo(packageJsonPath, result); + state.affectingLocations.push(packageJsonPath); + return result; + } + else { + if (directoryExists && traceEnabled) { + trace(host, ts.Diagnostics.File_0_does_not_exist, packageJsonPath); + } + (_c = state.packageJsonInfoCache) === null || _c === void 0 ? void 0 : _c.setPackageJsonInfo(packageJsonPath, directoryExists); + // record package json as one of failed lookup locations - in the future if this file will appear it will invalidate resolution results + state.failedLookupLocations.push(packageJsonPath); + } + } + ts.getPackageJsonInfo = getPackageJsonInfo; + function loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, jsonContent, versionPaths) { + var packageFile; + if (jsonContent) { + switch (extensions) { + case Extensions.JavaScript: + case Extensions.Json: + case Extensions.TsOnly: + packageFile = readPackageJsonMainField(jsonContent, candidate, state); + break; + case Extensions.TypeScript: + // When resolving typescript modules, try resolving using main field as well + packageFile = readPackageJsonTypesFields(jsonContent, candidate, state) || readPackageJsonMainField(jsonContent, candidate, state); + break; + case Extensions.DtsOnly: + packageFile = readPackageJsonTypesFields(jsonContent, candidate, state); + break; + case Extensions.TSConfig: + packageFile = readPackageJsonTSConfigField(jsonContent, candidate, state); + break; + default: + return ts.Debug.assertNever(extensions); + } + } + var loader = function (extensions, candidate, onlyRecordFailures, state) { + var fromFile = tryFile(candidate, onlyRecordFailures, state); + if (fromFile) { + var resolved = resolvedIfExtensionMatches(extensions, fromFile); + if (resolved) { + return noPackageId(resolved); + } + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.File_0_has_an_unsupported_extension_so_skipping_it, fromFile); + } + } + // Even if extensions is DtsOnly, we can still look up a .ts file as a result of package.json "types" + var nextExtensions = extensions === Extensions.DtsOnly ? Extensions.TypeScript : extensions; + // Don't do package.json lookup recursively, because Node.js' package lookup doesn't. + // Disable `EsmMode` for the resolution of the package path for cjs-mode packages (so the `main` field can omit extensions) + // (technically it only emits a deprecation warning in esm packages right now, but that's probably + // enough to mean we don't need to support it) + var features = state.features; + if ((jsonContent === null || jsonContent === void 0 ? void 0 : jsonContent.type) !== "module") { + state.features &= ~NodeResolutionFeatures.EsmMode; + } + var result = nodeLoadModuleByRelativeName(nextExtensions, candidate, onlyRecordFailures, state, /*considerPackageJson*/ false); + state.features = features; + return result; + }; + var onlyRecordFailuresForPackageFile = packageFile ? !ts.directoryProbablyExists(ts.getDirectoryPath(packageFile), state.host) : undefined; + var onlyRecordFailuresForIndex = onlyRecordFailures || !ts.directoryProbablyExists(candidate, state.host); + var indexPath = ts.combinePaths(candidate, extensions === Extensions.TSConfig ? "tsconfig" : "index"); + if (versionPaths && (!packageFile || ts.containsPath(candidate, packageFile))) { + var moduleName = ts.getRelativePathFromDirectory(candidate, packageFile || indexPath, /*ignoreCase*/ false); + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2, versionPaths.version, ts.version, moduleName); + } + var result = tryLoadModuleUsingPaths(extensions, moduleName, candidate, versionPaths.paths, /*pathPatterns*/ undefined, loader, onlyRecordFailuresForPackageFile || onlyRecordFailuresForIndex, state); + if (result) { + return removeIgnoredPackageId(result.value); + } + } + // It won't have a `packageId` set, because we disabled `considerPackageJson`. + var packageFileResult = packageFile && removeIgnoredPackageId(loader(extensions, packageFile, onlyRecordFailuresForPackageFile, state)); + if (packageFileResult) + return packageFileResult; + // esm mode resolutions don't do package `index` lookups + if (!(state.features & NodeResolutionFeatures.EsmMode)) { + return loadModuleFromFile(extensions, indexPath, onlyRecordFailuresForIndex, state); + } + } + /** Resolve from an arbitrarily specified file. Return `undefined` if it has an unsupported extension. */ + function resolvedIfExtensionMatches(extensions, path) { + var ext = ts.tryGetExtensionFromPath(path); + return ext !== undefined && extensionIsOk(extensions, ext) ? { path: path, ext: ext } : undefined; + } + /** True if `extension` is one of the supported `extensions`. */ + function extensionIsOk(extensions, extension) { + switch (extensions) { + case Extensions.JavaScript: + return extension === ".js" /* Extension.Js */ || extension === ".jsx" /* Extension.Jsx */ || extension === ".mjs" /* Extension.Mjs */ || extension === ".cjs" /* Extension.Cjs */; + case Extensions.TSConfig: + case Extensions.Json: + return extension === ".json" /* Extension.Json */; + case Extensions.TypeScript: + return extension === ".ts" /* Extension.Ts */ || extension === ".tsx" /* Extension.Tsx */ || extension === ".mts" /* Extension.Mts */ || extension === ".cts" /* Extension.Cts */ || extension === ".d.ts" /* Extension.Dts */ || extension === ".d.mts" /* Extension.Dmts */ || extension === ".d.cts" /* Extension.Dcts */; + case Extensions.TsOnly: + return extension === ".ts" /* Extension.Ts */ || extension === ".tsx" /* Extension.Tsx */ || extension === ".mts" /* Extension.Mts */ || extension === ".cts" /* Extension.Cts */; + case Extensions.DtsOnly: + return extension === ".d.ts" /* Extension.Dts */ || extension === ".d.mts" /* Extension.Dmts */ || extension === ".d.cts" /* Extension.Dcts */; + } + } + /* @internal */ + function parsePackageName(moduleName) { + var idx = moduleName.indexOf(ts.directorySeparator); + if (moduleName[0] === "@") { + idx = moduleName.indexOf(ts.directorySeparator, idx + 1); + } + return idx === -1 ? { packageName: moduleName, rest: "" } : { packageName: moduleName.slice(0, idx), rest: moduleName.slice(idx + 1) }; + } + ts.parsePackageName = parsePackageName; + /* @internal */ + function allKeysStartWithDot(obj) { + return ts.every(ts.getOwnKeys(obj), function (k) { return ts.startsWith(k, "."); }); + } + ts.allKeysStartWithDot = allKeysStartWithDot; + function noKeyStartsWithDot(obj) { + return !ts.some(ts.getOwnKeys(obj), function (k) { return ts.startsWith(k, "."); }); + } + function loadModuleFromSelfNameReference(extensions, moduleName, directory, state, cache, redirectedReference) { + var _a, _b; + var directoryPath = ts.getNormalizedAbsolutePath(ts.combinePaths(directory, "dummy"), (_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a)); + var scope = getPackageScopeForPath(directoryPath, state); + if (!scope || !scope.contents.packageJsonContent.exports) { + return undefined; + } + if (typeof scope.contents.packageJsonContent.name !== "string") { + return undefined; + } + var parts = ts.getPathComponents(moduleName); // unrooted paths should have `""` as their 0th entry + var nameParts = ts.getPathComponents(scope.contents.packageJsonContent.name); + if (!ts.every(nameParts, function (p, i) { return parts[i] === p; })) { + return undefined; + } + var trailingParts = parts.slice(nameParts.length); + return loadModuleFromExports(scope, extensions, !ts.length(trailingParts) ? "." : ".".concat(ts.directorySeparator).concat(trailingParts.join(ts.directorySeparator)), state, cache, redirectedReference); + } + function loadModuleFromExports(scope, extensions, subpath, state, cache, redirectedReference) { + if (!scope.contents.packageJsonContent.exports) { + return undefined; + } + if (subpath === ".") { + var mainExport = void 0; + if (typeof scope.contents.packageJsonContent.exports === "string" || Array.isArray(scope.contents.packageJsonContent.exports) || (typeof scope.contents.packageJsonContent.exports === "object" && noKeyStartsWithDot(scope.contents.packageJsonContent.exports))) { + mainExport = scope.contents.packageJsonContent.exports; + } + else if (ts.hasProperty(scope.contents.packageJsonContent.exports, ".")) { + mainExport = scope.contents.packageJsonContent.exports["."]; + } + if (mainExport) { + var loadModuleFromTargetImportOrExport = getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, subpath, scope, /*isImports*/ false); + return loadModuleFromTargetImportOrExport(mainExport, "", /*pattern*/ false, "."); + } + } + else if (allKeysStartWithDot(scope.contents.packageJsonContent.exports)) { + if (typeof scope.contents.packageJsonContent.exports !== "object") { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Export_specifier_0_does_not_exist_in_package_json_scope_at_path_1, subpath, scope.packageDirectory); + } + return toSearchResult(/*value*/ undefined); + } + var result = loadModuleFromImportsOrExports(extensions, state, cache, redirectedReference, subpath, scope.contents.packageJsonContent.exports, scope, /*isImports*/ false); + if (result) { + return result; + } + } + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Export_specifier_0_does_not_exist_in_package_json_scope_at_path_1, subpath, scope.packageDirectory); + } + return toSearchResult(/*value*/ undefined); + } + function loadModuleFromImports(extensions, moduleName, directory, state, cache, redirectedReference) { + var _a, _b; + if (moduleName === "#" || ts.startsWith(moduleName, "#/")) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Invalid_import_specifier_0_has_no_possible_resolutions, moduleName); + } + return toSearchResult(/*value*/ undefined); + } + var directoryPath = ts.getNormalizedAbsolutePath(ts.combinePaths(directory, "dummy"), (_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a)); + var scope = getPackageScopeForPath(directoryPath, state); + if (!scope) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve, directoryPath); + } + return toSearchResult(/*value*/ undefined); + } + if (!scope.contents.packageJsonContent.imports) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.package_json_scope_0_has_no_imports_defined, scope.packageDirectory); + } + return toSearchResult(/*value*/ undefined); + } + var result = loadModuleFromImportsOrExports(extensions, state, cache, redirectedReference, moduleName, scope.contents.packageJsonContent.imports, scope, /*isImports*/ true); + if (result) { + return result; + } + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1, moduleName, scope.packageDirectory); + } + return toSearchResult(/*value*/ undefined); + } + /** + * @internal + * From https://github.com/nodejs/node/blob/8f39f51cbbd3b2de14b9ee896e26421cc5b20121/lib/internal/modules/esm/resolve.js#L722 - + * "longest" has some nuance as to what "longest" means in the presence of pattern trailers + */ + function comparePatternKeys(a, b) { + var aPatternIndex = a.indexOf("*"); + var bPatternIndex = b.indexOf("*"); + var baseLenA = aPatternIndex === -1 ? a.length : aPatternIndex + 1; + var baseLenB = bPatternIndex === -1 ? b.length : bPatternIndex + 1; + if (baseLenA > baseLenB) + return -1; + if (baseLenB > baseLenA) + return 1; + if (aPatternIndex === -1) + return 1; + if (bPatternIndex === -1) + return -1; + if (a.length > b.length) + return -1; + if (b.length > a.length) + return 1; + return 0; + } + ts.comparePatternKeys = comparePatternKeys; + function loadModuleFromImportsOrExports(extensions, state, cache, redirectedReference, moduleName, lookupTable, scope, isImports) { + var loadModuleFromTargetImportOrExport = getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, moduleName, scope, isImports); + if (!ts.endsWith(moduleName, ts.directorySeparator) && moduleName.indexOf("*") === -1 && ts.hasProperty(lookupTable, moduleName)) { + var target = lookupTable[moduleName]; + return loadModuleFromTargetImportOrExport(target, /*subpath*/ "", /*pattern*/ false, moduleName); + } + var expandingKeys = ts.sort(ts.filter(ts.getOwnKeys(lookupTable), function (k) { return k.indexOf("*") !== -1 || ts.endsWith(k, "/"); }), comparePatternKeys); + for (var _i = 0, expandingKeys_1 = expandingKeys; _i < expandingKeys_1.length; _i++) { + var potentialTarget = expandingKeys_1[_i]; + if (state.features & NodeResolutionFeatures.ExportsPatternTrailers && matchesPatternWithTrailer(potentialTarget, moduleName)) { + var target = lookupTable[potentialTarget]; + var starPos = potentialTarget.indexOf("*"); + var subpath = moduleName.substring(potentialTarget.substring(0, starPos).length, moduleName.length - (potentialTarget.length - 1 - starPos)); + return loadModuleFromTargetImportOrExport(target, subpath, /*pattern*/ true, potentialTarget); + } + else if (ts.endsWith(potentialTarget, "*") && ts.startsWith(moduleName, potentialTarget.substring(0, potentialTarget.length - 1))) { + var target = lookupTable[potentialTarget]; + var subpath = moduleName.substring(potentialTarget.length - 1); + return loadModuleFromTargetImportOrExport(target, subpath, /*pattern*/ true, potentialTarget); + } + else if (ts.startsWith(moduleName, potentialTarget)) { + var target = lookupTable[potentialTarget]; + var subpath = moduleName.substring(potentialTarget.length); + return loadModuleFromTargetImportOrExport(target, subpath, /*pattern*/ false, potentialTarget); + } + } + function matchesPatternWithTrailer(target, name) { + if (ts.endsWith(target, "*")) + return false; // handled by next case in loop + var starPos = target.indexOf("*"); + if (starPos === -1) + return false; // handled by last case in loop + return ts.startsWith(name, target.substring(0, starPos)) && ts.endsWith(name, target.substring(starPos + 1)); + } + } + /** + * Gets the self-recursive function specialized to retrieving the targeted import/export element for the given resolution configuration + */ + function getLoadModuleFromTargetImportOrExport(extensions, state, cache, redirectedReference, moduleName, scope, isImports) { + return loadModuleFromTargetImportOrExport; + function loadModuleFromTargetImportOrExport(target, subpath, pattern, key) { + if (typeof target === "string") { + if (!pattern && subpath.length > 0 && !ts.endsWith(target, "/")) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName); + } + return toSearchResult(/*value*/ undefined); + } + if (!ts.startsWith(target, "./")) { + if (isImports && !ts.startsWith(target, "../") && !ts.startsWith(target, "/") && !ts.isRootedDiskPath(target)) { + var combinedLookup = pattern ? target.replace(/\*/g, subpath) : target + subpath; + traceIfEnabled(state, ts.Diagnostics.Using_0_subpath_1_with_target_2, "imports", key, combinedLookup); + traceIfEnabled(state, ts.Diagnostics.Resolving_module_0_from_1, combinedLookup, scope.packageDirectory + "/"); + var result = nodeModuleNameResolverWorker(state.features, combinedLookup, scope.packageDirectory + "/", state.compilerOptions, state.host, cache, [extensions], redirectedReference); + return toSearchResult(result.resolvedModule ? { path: result.resolvedModule.resolvedFileName, extension: result.resolvedModule.extension, packageId: result.resolvedModule.packageId, originalPath: result.resolvedModule.originalPath } : undefined); + } + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName); + } + return toSearchResult(/*value*/ undefined); + } + var parts = ts.pathIsRelative(target) ? ts.getPathComponents(target).slice(1) : ts.getPathComponents(target); + var partsAfterFirst = parts.slice(1); + if (partsAfterFirst.indexOf("..") >= 0 || partsAfterFirst.indexOf(".") >= 0 || partsAfterFirst.indexOf("node_modules") >= 0) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName); + } + return toSearchResult(/*value*/ undefined); + } + var resolvedTarget = ts.combinePaths(scope.packageDirectory, target); + // TODO: Assert that `resolvedTarget` is actually within the package directory? That's what the spec says.... but I'm not sure we need + // to be in the business of validating everyone's import and export map correctness. + var subpathParts = ts.getPathComponents(subpath); + if (subpathParts.indexOf("..") >= 0 || subpathParts.indexOf(".") >= 0 || subpathParts.indexOf("node_modules") >= 0) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName); + } + return toSearchResult(/*value*/ undefined); + } + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Using_0_subpath_1_with_target_2, isImports ? "imports" : "exports", key, pattern ? target.replace(/\*/g, subpath) : target + subpath); + } + var finalPath = toAbsolutePath(pattern ? resolvedTarget.replace(/\*/g, subpath) : resolvedTarget + subpath); + var inputLink = tryLoadInputFileForPath(finalPath, subpath, ts.combinePaths(scope.packageDirectory, "package.json"), isImports); + if (inputLink) + return inputLink; + return toSearchResult(withPackageId(scope, loadJSOrExactTSFileName(extensions, finalPath, /*onlyRecordFailures*/ false, state))); + } + else if (typeof target === "object" && target !== null) { // eslint-disable-line no-null/no-null + if (!Array.isArray(target)) { + for (var _i = 0, _a = ts.getOwnKeys(target); _i < _a.length; _i++) { + var condition = _a[_i]; + if (condition === "default" || state.conditions.indexOf(condition) >= 0 || isApplicableVersionedTypesKey(state.conditions, condition)) { + traceIfEnabled(state, ts.Diagnostics.Matched_0_condition_1, isImports ? "imports" : "exports", condition); + var subTarget = target[condition]; + var result = loadModuleFromTargetImportOrExport(subTarget, subpath, pattern, key); + if (result) { + return result; + } + } + else { + traceIfEnabled(state, ts.Diagnostics.Saw_non_matching_condition_0, condition); + } + } + return undefined; + } + else { + if (!ts.length(target)) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName); + } + return toSearchResult(/*value*/ undefined); + } + for (var _b = 0, target_2 = target; _b < target_2.length; _b++) { + var elem = target_2[_b]; + var result = loadModuleFromTargetImportOrExport(elem, subpath, pattern, key); + if (result) { + return result; + } + } + } + } + else if (target === null) { // eslint-disable-line no-null/no-null + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.package_json_scope_0_explicitly_maps_specifier_1_to_null, scope.packageDirectory, moduleName); + } + return toSearchResult(/*value*/ undefined); + } + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.package_json_scope_0_has_invalid_type_for_target_of_specifier_1, scope.packageDirectory, moduleName); + } + return toSearchResult(/*value*/ undefined); + function toAbsolutePath(path) { + var _a, _b; + if (path === undefined) + return path; + return ts.getNormalizedAbsolutePath(path, (_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a)); + } + function combineDirectoryPath(root, dir) { + return ts.ensureTrailingDirectorySeparator(ts.combinePaths(root, dir)); + } + function useCaseSensitiveFileNames() { + return !state.host.useCaseSensitiveFileNames ? true : + typeof state.host.useCaseSensitiveFileNames === "boolean" ? state.host.useCaseSensitiveFileNames : + state.host.useCaseSensitiveFileNames(); + } + function tryLoadInputFileForPath(finalPath, entry, packagePath, isImports) { + var _a, _b, _c, _d; + // Replace any references to outputs for files in the program with the input files to support package self-names used with outDir + // PROBLEM: We don't know how to calculate the output paths yet, because the "common source directory" we use as the base of the file structure + // we reproduce into the output directory is based on the set of input files, which we're still in the process of traversing and resolving! + // _Given that_, we have to guess what the base of the output directory is (obviously the user wrote the export map, so has some idea what it is!). + // We are going to probe _so many_ possible paths. We limit where we'll do this to try to reduce the possibilities of false positive lookups. + if ((extensions === Extensions.TypeScript || extensions === Extensions.JavaScript || extensions === Extensions.Json) + && (state.compilerOptions.declarationDir || state.compilerOptions.outDir) + && finalPath.indexOf("/node_modules/") === -1 + && (state.compilerOptions.configFile ? ts.containsPath(scope.packageDirectory, toAbsolutePath(state.compilerOptions.configFile.fileName), !useCaseSensitiveFileNames()) : true)) { + // So that all means we'll only try these guesses for files outside `node_modules` in a directory where the `package.json` and `tsconfig.json` are siblings. + // Even with all that, we still don't know if the root of the output file structure will be (relative to the package file) + // `.`, `./src` or any other deeper directory structure. (If project references are used, it's definitely `.` by fiat, so that should be pretty common.) + var getCanonicalFileName = ts.hostGetCanonicalFileName({ useCaseSensitiveFileNames: useCaseSensitiveFileNames }); + var commonSourceDirGuesses = []; + // A `rootDir` compiler option strongly indicates the root location + // A `composite` project is using project references and has it's common src dir set to `.`, so it shouldn't need to check any other locations + if (state.compilerOptions.rootDir || (state.compilerOptions.composite && state.compilerOptions.configFilePath)) { + var commonDir = toAbsolutePath(ts.getCommonSourceDirectory(state.compilerOptions, function () { return []; }, ((_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a)) || "", getCanonicalFileName)); + commonSourceDirGuesses.push(commonDir); + } + else if (state.requestContainingDirectory) { + // However without either of those set we're in the dark. Let's say you have + // + // ./tools/index.ts + // ./src/index.ts + // ./dist/index.js + // ./package.json <-- references ./dist/index.js + // ./tsconfig.json <-- loads ./src/index.ts + // + // How do we know `./src` is the common src dir, and not `./tools`, given only the `./dist` out dir and `./dist/index.js` filename? + // Answer: We... don't. We know we're looking for an `index.ts` input file, but we have _no clue_ which subfolder it's supposed to be loaded from + // without more context. + // But we do have more context! Just a tiny bit more! We're resolving an import _for some other input file_! And that input file, too + // must be inside the common source directory! So we propagate that tidbit of info all the way to here via state.requestContainingDirectory + var requestingFile_1 = toAbsolutePath(ts.combinePaths(state.requestContainingDirectory, "index.ts")); + // And we can try every folder above the common folder for the request folder and the config/package base directory + // This technically can be wrong - we may load ./src/index.ts when ./src/sub/index.ts was right because we don't + // know if only `./src/sub` files were loaded by the program; but this has the best chance to be right of just about anything + // else we have. And, given that we're about to load `./src/index.ts` because we choose it as likely correct, there will then + // be a file outside of `./src/sub` in the program (the file we resolved to), making us de-facto right. So this fallback lookup + // logic may influence what files are pulled in by self-names, which in turn influences the output path shape, but it's all + // internally consistent so the paths should be stable so long as we prefer the "most general" (meaning: top-most-level directory) possible results first. + var commonDir = toAbsolutePath(ts.getCommonSourceDirectory(state.compilerOptions, function () { return [requestingFile_1, toAbsolutePath(packagePath)]; }, ((_d = (_c = state.host).getCurrentDirectory) === null || _d === void 0 ? void 0 : _d.call(_c)) || "", getCanonicalFileName)); + commonSourceDirGuesses.push(commonDir); + var fragment = ts.ensureTrailingDirectorySeparator(commonDir); + while (fragment && fragment.length > 1) { + var parts = ts.getPathComponents(fragment); + parts.pop(); // remove a directory + var commonDir_1 = ts.getPathFromPathComponents(parts); + commonSourceDirGuesses.unshift(commonDir_1); + fragment = ts.ensureTrailingDirectorySeparator(commonDir_1); + } + } + if (commonSourceDirGuesses.length > 1) { + state.reportDiagnostic(ts.createCompilerDiagnostic(isImports + ? ts.Diagnostics.The_project_root_is_ambiguous_but_is_required_to_resolve_import_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate + : ts.Diagnostics.The_project_root_is_ambiguous_but_is_required_to_resolve_export_map_entry_0_in_file_1_Supply_the_rootDir_compiler_option_to_disambiguate, entry === "" ? "." : entry, // replace empty string with `.` - the reverse of the operation done when entries are built - so main entrypoint errors don't look weird + packagePath)); + } + for (var _i = 0, commonSourceDirGuesses_1 = commonSourceDirGuesses; _i < commonSourceDirGuesses_1.length; _i++) { + var commonSourceDirGuess = commonSourceDirGuesses_1[_i]; + var candidateDirectories = getOutputDirectoriesForBaseDirectory(commonSourceDirGuess); + for (var _e = 0, candidateDirectories_1 = candidateDirectories; _e < candidateDirectories_1.length; _e++) { + var candidateDir = candidateDirectories_1[_e]; + if (ts.containsPath(candidateDir, finalPath, !useCaseSensitiveFileNames())) { + // The matched export is looking up something in either the out declaration or js dir, now map the written path back into the source dir and source extension + var pathFragment = finalPath.slice(candidateDir.length + 1); // +1 to also remove directory seperator + var possibleInputBase = ts.combinePaths(commonSourceDirGuess, pathFragment); + var jsAndDtsExtensions = [".mjs" /* Extension.Mjs */, ".cjs" /* Extension.Cjs */, ".js" /* Extension.Js */, ".json" /* Extension.Json */, ".d.mts" /* Extension.Dmts */, ".d.cts" /* Extension.Dcts */, ".d.ts" /* Extension.Dts */]; + for (var _f = 0, jsAndDtsExtensions_1 = jsAndDtsExtensions; _f < jsAndDtsExtensions_1.length; _f++) { + var ext = jsAndDtsExtensions_1[_f]; + if (ts.fileExtensionIs(possibleInputBase, ext)) { + var inputExts = ts.getPossibleOriginalInputExtensionForExtension(possibleInputBase); + for (var _g = 0, inputExts_1 = inputExts; _g < inputExts_1.length; _g++) { + var possibleExt = inputExts_1[_g]; + var possibleInputWithInputExtension = ts.changeAnyExtension(possibleInputBase, possibleExt, ext, !useCaseSensitiveFileNames()); + if ((extensions === Extensions.TypeScript && ts.hasJSFileExtension(possibleInputWithInputExtension)) || + (extensions === Extensions.JavaScript && ts.hasTSFileExtension(possibleInputWithInputExtension))) { + continue; + } + if (state.host.fileExists(possibleInputWithInputExtension)) { + return toSearchResult(withPackageId(scope, loadJSOrExactTSFileName(extensions, possibleInputWithInputExtension, /*onlyRecordFailures*/ false, state))); + } + } + } + } + } + } + } + } + return undefined; + function getOutputDirectoriesForBaseDirectory(commonSourceDirGuess) { + var _a, _b; + // Config file ouput paths are processed to be relative to the host's current directory, while + // otherwise the paths are resolved relative to the common source dir the compiler puts together + var currentDir = state.compilerOptions.configFile ? ((_b = (_a = state.host).getCurrentDirectory) === null || _b === void 0 ? void 0 : _b.call(_a)) || "" : commonSourceDirGuess; + var candidateDirectories = []; + if (state.compilerOptions.declarationDir) { + candidateDirectories.push(toAbsolutePath(combineDirectoryPath(currentDir, state.compilerOptions.declarationDir))); + } + if (state.compilerOptions.outDir && state.compilerOptions.outDir !== state.compilerOptions.declarationDir) { + candidateDirectories.push(toAbsolutePath(combineDirectoryPath(currentDir, state.compilerOptions.outDir))); + } + return candidateDirectories; + } + } + } + } + /* @internal */ + function isApplicableVersionedTypesKey(conditions, key) { + if (conditions.indexOf("types") === -1) + return false; // only apply versioned types conditions if the types condition is applied + if (!ts.startsWith(key, "types@")) + return false; + var range = ts.VersionRange.tryParse(key.substring("types@".length)); + if (!range) + return false; + return range.test(ts.version); + } + ts.isApplicableVersionedTypesKey = isApplicableVersionedTypesKey; + function loadModuleFromNearestNodeModulesDirectory(extensions, moduleName, directory, state, cache, redirectedReference) { + return loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName, directory, state, /*typesScopeOnly*/ false, cache, redirectedReference); + } + function loadModuleFromNearestNodeModulesDirectoryTypesScope(moduleName, directory, state) { + // Extensions parameter here doesn't actually matter, because typesOnly ensures we're just doing @types lookup, which is always DtsOnly. + return loadModuleFromNearestNodeModulesDirectoryWorker(Extensions.DtsOnly, moduleName, directory, state, /*typesScopeOnly*/ true, /*cache*/ undefined, /*redirectedReference*/ undefined); + } + function loadModuleFromNearestNodeModulesDirectoryWorker(extensions, moduleName, directory, state, typesScopeOnly, cache, redirectedReference) { + var perModuleNameCache = cache && cache.getOrCreateCacheForModuleName(moduleName, state.features === 0 ? undefined : state.features & NodeResolutionFeatures.EsmMode ? ts.ModuleKind.ESNext : ts.ModuleKind.CommonJS, redirectedReference); + return ts.forEachAncestorDirectory(ts.normalizeSlashes(directory), function (ancestorDirectory) { + if (ts.getBaseFileName(ancestorDirectory) !== "node_modules") { + var resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache, moduleName, ancestorDirectory, state); + if (resolutionFromCache) { + return resolutionFromCache; + } + return toSearchResult(loadModuleFromImmediateNodeModulesDirectory(extensions, moduleName, ancestorDirectory, state, typesScopeOnly, cache, redirectedReference)); + } + }); + } + function loadModuleFromImmediateNodeModulesDirectory(extensions, moduleName, directory, state, typesScopeOnly, cache, redirectedReference) { + var nodeModulesFolder = ts.combinePaths(directory, "node_modules"); + var nodeModulesFolderExists = ts.directoryProbablyExists(nodeModulesFolder, state.host); + if (!nodeModulesFolderExists && state.traceEnabled) { + trace(state.host, ts.Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, nodeModulesFolder); + } + var packageResult = typesScopeOnly ? undefined : loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesFolder, nodeModulesFolderExists, state, cache, redirectedReference); + if (packageResult) { + return packageResult; + } + if (extensions === Extensions.TypeScript || extensions === Extensions.DtsOnly) { + var nodeModulesAtTypes_1 = ts.combinePaths(nodeModulesFolder, "@types"); + var nodeModulesAtTypesExists = nodeModulesFolderExists; + if (nodeModulesFolderExists && !ts.directoryProbablyExists(nodeModulesAtTypes_1, state.host)) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it, nodeModulesAtTypes_1); + } + nodeModulesAtTypesExists = false; + } + return loadModuleFromSpecificNodeModulesDirectory(Extensions.DtsOnly, mangleScopedPackageNameWithTrace(moduleName, state), nodeModulesAtTypes_1, nodeModulesAtTypesExists, state, cache, redirectedReference); + } + } + function loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, nodeModulesDirectory, nodeModulesDirectoryExists, state, cache, redirectedReference) { + var _a; + var candidate = ts.normalizePath(ts.combinePaths(nodeModulesDirectory, moduleName)); + // First look for a nested package.json, as in `node_modules/foo/bar/package.json`. + var packageInfo = getPackageJsonInfo(candidate, !nodeModulesDirectoryExists, state); + // But only if we're not respecting export maps (if we are, we might redirect around this location) + if (!(state.features & NodeResolutionFeatures.Exports)) { + if (packageInfo) { + var fromFile = loadModuleFromFile(extensions, candidate, !nodeModulesDirectoryExists, state); + if (fromFile) { + return noPackageId(fromFile); + } + var fromDirectory = loadNodeModuleFromDirectoryWorker(extensions, candidate, !nodeModulesDirectoryExists, state, packageInfo.contents.packageJsonContent, packageInfo.contents.versionPaths); + return withPackageId(packageInfo, fromDirectory); + } + } + var loader = function (extensions, candidate, onlyRecordFailures, state) { + var pathAndExtension = loadModuleFromFile(extensions, candidate, onlyRecordFailures, state) || + loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFailures, state, packageInfo && packageInfo.contents.packageJsonContent, packageInfo && packageInfo.contents.versionPaths); + if (!pathAndExtension && packageInfo + // eslint-disable-next-line no-null/no-null + && (packageInfo.contents.packageJsonContent.exports === undefined || packageInfo.contents.packageJsonContent.exports === null) + && state.features & NodeResolutionFeatures.EsmMode) { + // EsmMode disables index lookup in `loadNodeModuleFromDirectoryWorker` generally, however non-relative package resolutions still assume + // a default `index.js` entrypoint if no `main` or `exports` are present + pathAndExtension = loadModuleFromFile(extensions, ts.combinePaths(candidate, "index.js"), onlyRecordFailures, state); + } + return withPackageId(packageInfo, pathAndExtension); + }; + var _b = parsePackageName(moduleName), packageName = _b.packageName, rest = _b.rest; + var packageDirectory = ts.combinePaths(nodeModulesDirectory, packageName); + if (rest !== "") { + // Previous `packageInfo` may have been from a nested package.json; ensure we have the one from the package root now. + packageInfo = getPackageJsonInfo(packageDirectory, !nodeModulesDirectoryExists, state); + } + // package exports are higher priority than file/directory/typesVersions lookups and (and, if there's exports present, blocks them) + if (packageInfo && packageInfo.contents.packageJsonContent.exports && state.features & NodeResolutionFeatures.Exports) { + return (_a = loadModuleFromExports(packageInfo, extensions, ts.combinePaths(".", rest), state, cache, redirectedReference)) === null || _a === void 0 ? void 0 : _a.value; + } + if (rest !== "" && packageInfo && packageInfo.contents.versionPaths) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2, packageInfo.contents.versionPaths.version, ts.version, rest); + } + var packageDirectoryExists = nodeModulesDirectoryExists && ts.directoryProbablyExists(packageDirectory, state.host); + var fromPaths = tryLoadModuleUsingPaths(extensions, rest, packageDirectory, packageInfo.contents.versionPaths.paths, /*pathPatterns*/ undefined, loader, !packageDirectoryExists, state); + if (fromPaths) { + return fromPaths.value; + } + } + return loader(extensions, candidate, !nodeModulesDirectoryExists, state); + } + function tryLoadModuleUsingPaths(extensions, moduleName, baseDirectory, paths, pathPatterns, loader, onlyRecordFailures, state) { + pathPatterns || (pathPatterns = ts.tryParsePatterns(paths)); + var matchedPattern = ts.matchPatternOrExact(pathPatterns, moduleName); + if (matchedPattern) { + var matchedStar_1 = ts.isString(matchedPattern) ? undefined : ts.matchedText(matchedPattern, moduleName); + var matchedPatternText = ts.isString(matchedPattern) ? matchedPattern : ts.patternText(matchedPattern); + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Module_name_0_matched_pattern_1, moduleName, matchedPatternText); + } + var resolved = ts.forEach(paths[matchedPatternText], function (subst) { + var path = matchedStar_1 ? subst.replace("*", matchedStar_1) : subst; + // When baseUrl is not specified, the command line parser resolves relative paths to the config file location. + var candidate = ts.normalizePath(ts.combinePaths(baseDirectory, path)); + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Trying_substitution_0_candidate_module_location_Colon_1, subst, path); + } + // A path mapping may have an extension, in contrast to an import, which should omit it. + var extension = ts.tryGetExtensionFromPath(subst); + if (extension !== undefined) { + var path_1 = tryFile(candidate, onlyRecordFailures, state); + if (path_1 !== undefined) { + return noPackageId({ path: path_1, ext: extension }); + } + } + return loader(extensions, candidate, onlyRecordFailures || !ts.directoryProbablyExists(ts.getDirectoryPath(candidate), state.host), state); + }); + return { value: resolved }; + } + } + /** Double underscores are used in DefinitelyTyped to delimit scoped packages. */ + var mangledScopedPackageSeparator = "__"; + /** For a scoped package, we must look in `@types/foo__bar` instead of `@types/@foo/bar`. */ + function mangleScopedPackageNameWithTrace(packageName, state) { + var mangled = mangleScopedPackageName(packageName); + if (state.traceEnabled && mangled !== packageName) { + trace(state.host, ts.Diagnostics.Scoped_package_detected_looking_in_0, mangled); + } + return mangled; + } + /* @internal */ + function getTypesPackageName(packageName) { + return "@types/".concat(mangleScopedPackageName(packageName)); + } + ts.getTypesPackageName = getTypesPackageName; + /* @internal */ + function mangleScopedPackageName(packageName) { + if (ts.startsWith(packageName, "@")) { + var replaceSlash = packageName.replace(ts.directorySeparator, mangledScopedPackageSeparator); + if (replaceSlash !== packageName) { + return replaceSlash.slice(1); // Take off the "@" + } + } + return packageName; + } + ts.mangleScopedPackageName = mangleScopedPackageName; + /* @internal */ + function getPackageNameFromTypesPackageName(mangledName) { + var withoutAtTypePrefix = ts.removePrefix(mangledName, "@types/"); + if (withoutAtTypePrefix !== mangledName) { + return unmangleScopedPackageName(withoutAtTypePrefix); + } + return mangledName; + } + ts.getPackageNameFromTypesPackageName = getPackageNameFromTypesPackageName; + /* @internal */ + function unmangleScopedPackageName(typesPackageName) { + return ts.stringContains(typesPackageName, mangledScopedPackageSeparator) ? + "@" + typesPackageName.replace(mangledScopedPackageSeparator, ts.directorySeparator) : + typesPackageName; + } + ts.unmangleScopedPackageName = unmangleScopedPackageName; + function tryFindNonRelativeModuleNameInCache(cache, moduleName, containingDirectory, state) { + var result = cache && cache.get(containingDirectory); + if (result) { + if (state.traceEnabled) { + trace(state.host, ts.Diagnostics.Resolution_for_module_0_was_found_in_cache_from_location_1, moduleName, containingDirectory); + } + state.resultFromCache = result; + return { value: result.resolvedModule && { path: result.resolvedModule.resolvedFileName, originalPath: result.resolvedModule.originalPath || true, extension: result.resolvedModule.extension, packageId: result.resolvedModule.packageId } }; + } + } + function classicNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference) { + var traceEnabled = isTraceEnabled(compilerOptions, host); + var failedLookupLocations = []; + var affectingLocations = []; + var containingDirectory = ts.getDirectoryPath(containingFile); + var diagnostics = []; + var state = { + compilerOptions: compilerOptions, + host: host, + traceEnabled: traceEnabled, + failedLookupLocations: failedLookupLocations, + affectingLocations: affectingLocations, + packageJsonInfoCache: cache, + features: NodeResolutionFeatures.None, + conditions: [], + requestContainingDirectory: containingDirectory, + reportDiagnostic: function (diag) { return void diagnostics.push(diag); }, + }; + var resolved = tryResolve(Extensions.TypeScript) || tryResolve(Extensions.JavaScript); + // No originalPath because classic resolution doesn't resolve realPath + return createResolvedModuleWithFailedLookupLocations(resolved && resolved.value, + /*isExternalLibraryImport*/ false, failedLookupLocations, affectingLocations, diagnostics, state.resultFromCache); + function tryResolve(extensions) { + var resolvedUsingSettings = tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, containingDirectory, loadModuleFromFileNoPackageId, state); + if (resolvedUsingSettings) { + return { value: resolvedUsingSettings }; + } + if (!ts.isExternalModuleNameRelative(moduleName)) { + var perModuleNameCache_1 = cache && cache.getOrCreateCacheForModuleName(moduleName, /*mode*/ undefined, redirectedReference); + // Climb up parent directories looking for a module. + var resolved_3 = ts.forEachAncestorDirectory(containingDirectory, function (directory) { + var resolutionFromCache = tryFindNonRelativeModuleNameInCache(perModuleNameCache_1, moduleName, directory, state); + if (resolutionFromCache) { + return resolutionFromCache; + } + var searchName = ts.normalizePath(ts.combinePaths(directory, moduleName)); + return toSearchResult(loadModuleFromFileNoPackageId(extensions, searchName, /*onlyRecordFailures*/ false, state)); + }); + if (resolved_3) { + return resolved_3; + } + if (extensions === Extensions.TypeScript) { + // If we didn't find the file normally, look it up in @types. + return loadModuleFromNearestNodeModulesDirectoryTypesScope(moduleName, containingDirectory, state); + } + } + else { + var candidate = ts.normalizePath(ts.combinePaths(containingDirectory, moduleName)); + return toSearchResult(loadModuleFromFileNoPackageId(extensions, candidate, /*onlyRecordFailures*/ false, state)); + } + } + } + ts.classicNameResolver = classicNameResolver; + /** + * A host may load a module from a global cache of typings. + * This is the minumum code needed to expose that functionality; the rest is in the host. + */ + /* @internal */ + function loadModuleFromGlobalCache(moduleName, projectName, compilerOptions, host, globalCache, packageJsonInfoCache) { + var traceEnabled = isTraceEnabled(compilerOptions, host); + if (traceEnabled) { + trace(host, ts.Diagnostics.Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using_cache_location_2, projectName, moduleName, globalCache); + } + var failedLookupLocations = []; + var affectingLocations = []; + var diagnostics = []; + var state = { + compilerOptions: compilerOptions, + host: host, + traceEnabled: traceEnabled, + failedLookupLocations: failedLookupLocations, + affectingLocations: affectingLocations, + packageJsonInfoCache: packageJsonInfoCache, + features: NodeResolutionFeatures.None, + conditions: [], + requestContainingDirectory: undefined, + reportDiagnostic: function (diag) { return void diagnostics.push(diag); }, + }; + var resolved = loadModuleFromImmediateNodeModulesDirectory(Extensions.DtsOnly, moduleName, globalCache, state, /*typesScopeOnly*/ false, /*cache*/ undefined, /*redirectedReference*/ undefined); + return createResolvedModuleWithFailedLookupLocations(resolved, + /*isExternalLibraryImport*/ true, failedLookupLocations, affectingLocations, diagnostics, state.resultFromCache); + } + ts.loadModuleFromGlobalCache = loadModuleFromGlobalCache; + /** + * Wraps value to SearchResult. + * @returns undefined if value is undefined or { value } otherwise + */ + function toSearchResult(value) { + return value !== undefined ? { value: value } : undefined; + } + function traceIfEnabled(state, diagnostic) { + var args = []; + for (var _i = 2; _i < arguments.length; _i++) { + args[_i - 2] = arguments[_i]; + } + if (state.traceEnabled) { + trace.apply(void 0, __spreadArray([state.host, diagnostic], args, false)); + } + } +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var ModuleInstanceState; + (function (ModuleInstanceState) { + ModuleInstanceState[ModuleInstanceState["NonInstantiated"] = 0] = "NonInstantiated"; + ModuleInstanceState[ModuleInstanceState["Instantiated"] = 1] = "Instantiated"; + ModuleInstanceState[ModuleInstanceState["ConstEnumOnly"] = 2] = "ConstEnumOnly"; + })(ModuleInstanceState = ts.ModuleInstanceState || (ts.ModuleInstanceState = {})); + function getModuleInstanceState(node, visited) { + if (node.body && !node.body.parent) { + // getModuleInstanceStateForAliasTarget needs to walk up the parent chain, so parent pointers must be set on this tree already + ts.setParent(node.body, node); + ts.setParentRecursive(node.body, /*incremental*/ false); + } + return node.body ? getModuleInstanceStateCached(node.body, visited) : 1 /* ModuleInstanceState.Instantiated */; + } + ts.getModuleInstanceState = getModuleInstanceState; + function getModuleInstanceStateCached(node, visited) { + if (visited === void 0) { visited = new ts.Map(); } + var nodeId = ts.getNodeId(node); + if (visited.has(nodeId)) { + return visited.get(nodeId) || 0 /* ModuleInstanceState.NonInstantiated */; + } + visited.set(nodeId, undefined); + var result = getModuleInstanceStateWorker(node, visited); + visited.set(nodeId, result); + return result; + } + function getModuleInstanceStateWorker(node, visited) { + // A module is uninstantiated if it contains only + switch (node.kind) { + // 1. interface declarations, type alias declarations + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + return 0 /* ModuleInstanceState.NonInstantiated */; + // 2. const enum declarations + case 263 /* SyntaxKind.EnumDeclaration */: + if (ts.isEnumConst(node)) { + return 2 /* ModuleInstanceState.ConstEnumOnly */; + } + break; + // 3. non-exported import declarations + case 269 /* SyntaxKind.ImportDeclaration */: + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + if (!(ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */))) { + return 0 /* ModuleInstanceState.NonInstantiated */; + } + break; + // 4. Export alias declarations pointing at only uninstantiated modules or things uninstantiated modules contain + case 275 /* SyntaxKind.ExportDeclaration */: + var exportDeclaration = node; + if (!exportDeclaration.moduleSpecifier && exportDeclaration.exportClause && exportDeclaration.exportClause.kind === 276 /* SyntaxKind.NamedExports */) { + var state = 0 /* ModuleInstanceState.NonInstantiated */; + for (var _i = 0, _a = exportDeclaration.exportClause.elements; _i < _a.length; _i++) { + var specifier = _a[_i]; + var specifierState = getModuleInstanceStateForAliasTarget(specifier, visited); + if (specifierState > state) { + state = specifierState; + } + if (state === 1 /* ModuleInstanceState.Instantiated */) { + return state; + } + } + return state; + } + break; + // 5. other uninstantiated module declarations. + case 265 /* SyntaxKind.ModuleBlock */: { + var state_1 = 0 /* ModuleInstanceState.NonInstantiated */; + ts.forEachChild(node, function (n) { + var childState = getModuleInstanceStateCached(n, visited); + switch (childState) { + case 0 /* ModuleInstanceState.NonInstantiated */: + // child is non-instantiated - continue searching + return; + case 2 /* ModuleInstanceState.ConstEnumOnly */: + // child is const enum only - record state and continue searching + state_1 = 2 /* ModuleInstanceState.ConstEnumOnly */; + return; + case 1 /* ModuleInstanceState.Instantiated */: + // child is instantiated - record state and stop + state_1 = 1 /* ModuleInstanceState.Instantiated */; + return true; + default: + ts.Debug.assertNever(childState); + } + }); + return state_1; + } + case 264 /* SyntaxKind.ModuleDeclaration */: + return getModuleInstanceState(node, visited); + case 79 /* SyntaxKind.Identifier */: + // Only jsdoc typedef definition can exist in jsdoc namespace, and it should + // be considered the same as type alias + if (node.isInJSDocNamespace) { + return 0 /* ModuleInstanceState.NonInstantiated */; + } + } + return 1 /* ModuleInstanceState.Instantiated */; + } + function getModuleInstanceStateForAliasTarget(specifier, visited) { + var name = specifier.propertyName || specifier.name; + var p = specifier.parent; + while (p) { + if (ts.isBlock(p) || ts.isModuleBlock(p) || ts.isSourceFile(p)) { + var statements = p.statements; + var found = void 0; + for (var _i = 0, statements_2 = statements; _i < statements_2.length; _i++) { + var statement = statements_2[_i]; + if (ts.nodeHasName(statement, name)) { + if (!statement.parent) { + ts.setParent(statement, p); + ts.setParentRecursive(statement, /*incremental*/ false); + } + var state = getModuleInstanceStateCached(statement, visited); + if (found === undefined || state > found) { + found = state; + } + if (found === 1 /* ModuleInstanceState.Instantiated */) { + return found; + } + } + } + if (found !== undefined) { + return found; + } + } + p = p.parent; + } + return 1 /* ModuleInstanceState.Instantiated */; // Couldn't locate, assume could refer to a value + } + var ContainerFlags; + (function (ContainerFlags) { + // The current node is not a container, and no container manipulation should happen before + // recursing into it. + ContainerFlags[ContainerFlags["None"] = 0] = "None"; + // The current node is a container. It should be set as the current container (and block- + // container) before recursing into it. The current node does not have locals. Examples: + // + // Classes, ObjectLiterals, TypeLiterals, Interfaces... + ContainerFlags[ContainerFlags["IsContainer"] = 1] = "IsContainer"; + // The current node is a block-scoped-container. It should be set as the current block- + // container before recursing into it. Examples: + // + // Blocks (when not parented by functions), Catch clauses, For/For-in/For-of statements... + ContainerFlags[ContainerFlags["IsBlockScopedContainer"] = 2] = "IsBlockScopedContainer"; + // The current node is the container of a control flow path. The current control flow should + // be saved and restored, and a new control flow initialized within the container. + ContainerFlags[ContainerFlags["IsControlFlowContainer"] = 4] = "IsControlFlowContainer"; + ContainerFlags[ContainerFlags["IsFunctionLike"] = 8] = "IsFunctionLike"; + ContainerFlags[ContainerFlags["IsFunctionExpression"] = 16] = "IsFunctionExpression"; + ContainerFlags[ContainerFlags["HasLocals"] = 32] = "HasLocals"; + ContainerFlags[ContainerFlags["IsInterface"] = 64] = "IsInterface"; + ContainerFlags[ContainerFlags["IsObjectLiteralOrClassExpressionMethodOrAccessor"] = 128] = "IsObjectLiteralOrClassExpressionMethodOrAccessor"; + })(ContainerFlags || (ContainerFlags = {})); + function initFlowNode(node) { + ts.Debug.attachFlowNodeDebugInfo(node); + return node; + } + var binder = createBinder(); + function bindSourceFile(file, options) { + ts.performance.mark("beforeBind"); + ts.perfLogger.logStartBindFile("" + file.fileName); + binder(file, options); + ts.perfLogger.logStopBindFile(); + ts.performance.mark("afterBind"); + ts.performance.measure("Bind", "beforeBind", "afterBind"); + } + ts.bindSourceFile = bindSourceFile; + function createBinder() { + var file; + var options; + var languageVersion; + var parent; + var container; + var thisParentContainer; // Container one level up + var blockScopeContainer; + var lastContainer; + var delayedTypeAliases; + var seenThisKeyword; + // state used by control flow analysis + var currentFlow; + var currentBreakTarget; + var currentContinueTarget; + var currentReturnTarget; + var currentTrueTarget; + var currentFalseTarget; + var currentExceptionTarget; + var preSwitchCaseFlow; + var activeLabelList; + var hasExplicitReturn; + // state used for emit helpers + var emitFlags; + // If this file is an external module, then it is automatically in strict-mode according to + // ES6. If it is not an external module, then we'll determine if it is in strict mode or + // not depending on if we see "use strict" in certain places or if we hit a class/namespace + // or if compiler options contain alwaysStrict. + var inStrictMode; + // If we are binding an assignment pattern, we will bind certain expressions differently. + var inAssignmentPattern = false; + var symbolCount = 0; + var Symbol; + var classifiableNames; + var unreachableFlow = { flags: 1 /* FlowFlags.Unreachable */ }; + var reportedUnreachableFlow = { flags: 1 /* FlowFlags.Unreachable */ }; + var bindBinaryExpressionFlow = createBindBinaryExpressionFlow(); + /** + * Inside the binder, we may create a diagnostic for an as-yet unbound node (with potentially no parent pointers, implying no accessible source file) + * If so, the node _must_ be in the current file (as that's the only way anything could have traversed to it to yield it as the error node) + * This version of `createDiagnosticForNode` uses the binder's context to account for this, and always yields correct diagnostics even in these situations. + */ + function createDiagnosticForNode(node, message, arg0, arg1, arg2) { + return ts.createDiagnosticForNodeInSourceFile(ts.getSourceFileOfNode(node) || file, node, message, arg0, arg1, arg2); + } + function bindSourceFile(f, opts) { + file = f; + options = opts; + languageVersion = ts.getEmitScriptTarget(options); + inStrictMode = bindInStrictMode(file, opts); + classifiableNames = new ts.Set(); + symbolCount = 0; + Symbol = ts.objectAllocator.getSymbolConstructor(); + // Attach debugging information if necessary + ts.Debug.attachFlowNodeDebugInfo(unreachableFlow); + ts.Debug.attachFlowNodeDebugInfo(reportedUnreachableFlow); + if (!file.locals) { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("bind" /* tracing.Phase.Bind */, "bindSourceFile", { path: file.path }, /*separateBeginAndEnd*/ true); + bind(file); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + file.symbolCount = symbolCount; + file.classifiableNames = classifiableNames; + delayedBindJSDocTypedefTag(); + } + file = undefined; + options = undefined; + languageVersion = undefined; + parent = undefined; + container = undefined; + thisParentContainer = undefined; + blockScopeContainer = undefined; + lastContainer = undefined; + delayedTypeAliases = undefined; + seenThisKeyword = false; + currentFlow = undefined; + currentBreakTarget = undefined; + currentContinueTarget = undefined; + currentReturnTarget = undefined; + currentTrueTarget = undefined; + currentFalseTarget = undefined; + currentExceptionTarget = undefined; + activeLabelList = undefined; + hasExplicitReturn = false; + inAssignmentPattern = false; + emitFlags = 0 /* NodeFlags.None */; + } + return bindSourceFile; + function bindInStrictMode(file, opts) { + if (ts.getStrictOptionValue(opts, "alwaysStrict") && !file.isDeclarationFile) { + // bind in strict mode source files with alwaysStrict option + return true; + } + else { + return !!file.externalModuleIndicator; + } + } + function createSymbol(flags, name) { + symbolCount++; + return new Symbol(flags, name); + } + function addDeclarationToSymbol(symbol, node, symbolFlags) { + symbol.flags |= symbolFlags; + node.symbol = symbol; + symbol.declarations = ts.appendIfUnique(symbol.declarations, node); + if (symbolFlags & (32 /* SymbolFlags.Class */ | 384 /* SymbolFlags.Enum */ | 1536 /* SymbolFlags.Module */ | 3 /* SymbolFlags.Variable */) && !symbol.exports) { + symbol.exports = ts.createSymbolTable(); + } + if (symbolFlags & (32 /* SymbolFlags.Class */ | 64 /* SymbolFlags.Interface */ | 2048 /* SymbolFlags.TypeLiteral */ | 4096 /* SymbolFlags.ObjectLiteral */) && !symbol.members) { + symbol.members = ts.createSymbolTable(); + } + // On merge of const enum module with class or function, reset const enum only flag (namespaces will already recalculate) + if (symbol.constEnumOnlyModule && (symbol.flags & (16 /* SymbolFlags.Function */ | 32 /* SymbolFlags.Class */ | 256 /* SymbolFlags.RegularEnum */))) { + symbol.constEnumOnlyModule = false; + } + if (symbolFlags & 111551 /* SymbolFlags.Value */) { + ts.setValueDeclaration(symbol, node); + } + } + // Should not be called on a declaration with a computed property name, + // unless it is a well known Symbol. + function getDeclarationName(node) { + if (node.kind === 274 /* SyntaxKind.ExportAssignment */) { + return node.isExportEquals ? "export=" /* InternalSymbolName.ExportEquals */ : "default" /* InternalSymbolName.Default */; + } + var name = ts.getNameOfDeclaration(node); + if (name) { + if (ts.isAmbientModule(node)) { + var moduleName = ts.getTextOfIdentifierOrLiteral(name); + return (ts.isGlobalScopeAugmentation(node) ? "__global" : "\"".concat(moduleName, "\"")); + } + if (name.kind === 164 /* SyntaxKind.ComputedPropertyName */) { + var nameExpression = name.expression; + // treat computed property names where expression is string/numeric literal as just string/numeric literal + if (ts.isStringOrNumericLiteralLike(nameExpression)) { + return ts.escapeLeadingUnderscores(nameExpression.text); + } + if (ts.isSignedNumericLiteral(nameExpression)) { + return ts.tokenToString(nameExpression.operator) + nameExpression.operand.text; + } + else { + ts.Debug.fail("Only computed properties with literal names have declaration names"); + } + } + if (ts.isPrivateIdentifier(name)) { + // containingClass exists because private names only allowed inside classes + var containingClass = ts.getContainingClass(node); + if (!containingClass) { + // we can get here in cases where there is already a parse error. + return undefined; + } + var containingClassSymbol = containingClass.symbol; + return ts.getSymbolNameForPrivateIdentifier(containingClassSymbol, name.escapedText); + } + return ts.isPropertyNameLiteral(name) ? ts.getEscapedTextOfIdentifierOrLiteral(name) : undefined; + } + switch (node.kind) { + case 173 /* SyntaxKind.Constructor */: + return "__constructor" /* InternalSymbolName.Constructor */; + case 181 /* SyntaxKind.FunctionType */: + case 176 /* SyntaxKind.CallSignature */: + case 326 /* SyntaxKind.JSDocSignature */: + return "__call" /* InternalSymbolName.Call */; + case 182 /* SyntaxKind.ConstructorType */: + case 177 /* SyntaxKind.ConstructSignature */: + return "__new" /* InternalSymbolName.New */; + case 178 /* SyntaxKind.IndexSignature */: + return "__index" /* InternalSymbolName.Index */; + case 275 /* SyntaxKind.ExportDeclaration */: + return "__export" /* InternalSymbolName.ExportStar */; + case 308 /* SyntaxKind.SourceFile */: + // json file should behave as + // module.exports = ... + return "export=" /* InternalSymbolName.ExportEquals */; + case 223 /* SyntaxKind.BinaryExpression */: + if (ts.getAssignmentDeclarationKind(node) === 2 /* AssignmentDeclarationKind.ModuleExports */) { + // module.exports = ... + return "export=" /* InternalSymbolName.ExportEquals */; + } + ts.Debug.fail("Unknown binary declaration kind"); + break; + case 320 /* SyntaxKind.JSDocFunctionType */: + return (ts.isJSDocConstructSignature(node) ? "__new" /* InternalSymbolName.New */ : "__call" /* InternalSymbolName.Call */); + case 166 /* SyntaxKind.Parameter */: + // Parameters with names are handled at the top of this function. Parameters + // without names can only come from JSDocFunctionTypes. + ts.Debug.assert(node.parent.kind === 320 /* SyntaxKind.JSDocFunctionType */, "Impossible parameter parent kind", function () { return "parent is: ".concat(ts.Debug.formatSyntaxKind(node.parent.kind), ", expected JSDocFunctionType"); }); + var functionType = node.parent; + var index = functionType.parameters.indexOf(node); + return "arg" + index; + } + } + function getDisplayName(node) { + return ts.isNamedDeclaration(node) ? ts.declarationNameToString(node.name) : ts.unescapeLeadingUnderscores(ts.Debug.checkDefined(getDeclarationName(node))); + } + /** + * Declares a Symbol for the node and adds it to symbols. Reports errors for conflicting identifier names. + * @param symbolTable - The symbol table which node will be added to. + * @param parent - node's parent declaration. + * @param node - The declaration to be added to the symbol table + * @param includes - The SymbolFlags that node has in addition to its declaration type (eg: export, ambient, etc.) + * @param excludes - The flags which node cannot be declared alongside in a symbol table. Used to report forbidden declarations. + */ + function declareSymbol(symbolTable, parent, node, includes, excludes, isReplaceableByMethod, isComputedName) { + ts.Debug.assert(isComputedName || !ts.hasDynamicName(node)); + var isDefaultExport = ts.hasSyntacticModifier(node, 1024 /* ModifierFlags.Default */) || ts.isExportSpecifier(node) && node.name.escapedText === "default"; + // The exported symbol for an export default function/class node is always named "default" + var name = isComputedName ? "__computed" /* InternalSymbolName.Computed */ + : isDefaultExport && parent ? "default" /* InternalSymbolName.Default */ + : getDeclarationName(node); + var symbol; + if (name === undefined) { + symbol = createSymbol(0 /* SymbolFlags.None */, "__missing" /* InternalSymbolName.Missing */); + } + else { + // Check and see if the symbol table already has a symbol with this name. If not, + // create a new symbol with this name and add it to the table. Note that we don't + // give the new symbol any flags *yet*. This ensures that it will not conflict + // with the 'excludes' flags we pass in. + // + // If we do get an existing symbol, see if it conflicts with the new symbol we're + // creating. For example, a 'var' symbol and a 'class' symbol will conflict within + // the same symbol table. If we have a conflict, report the issue on each + // declaration we have for this symbol, and then create a new symbol for this + // declaration. + // + // Note that when properties declared in Javascript constructors + // (marked by isReplaceableByMethod) conflict with another symbol, the property loses. + // Always. This allows the common Javascript pattern of overwriting a prototype method + // with an bound instance method of the same type: `this.method = this.method.bind(this)` + // + // If we created a new symbol, either because we didn't have a symbol with this name + // in the symbol table, or we conflicted with an existing symbol, then just add this + // node as the sole declaration of the new symbol. + // + // Otherwise, we'll be merging into a compatible existing symbol (for example when + // you have multiple 'vars' with the same name in the same container). In this case + // just add this node into the declarations list of the symbol. + symbol = symbolTable.get(name); + if (includes & 2885600 /* SymbolFlags.Classifiable */) { + classifiableNames.add(name); + } + if (!symbol) { + symbolTable.set(name, symbol = createSymbol(0 /* SymbolFlags.None */, name)); + if (isReplaceableByMethod) + symbol.isReplaceableByMethod = true; + } + else if (isReplaceableByMethod && !symbol.isReplaceableByMethod) { + // A symbol already exists, so don't add this as a declaration. + return symbol; + } + else if (symbol.flags & excludes) { + if (symbol.isReplaceableByMethod) { + // Javascript constructor-declared symbols can be discarded in favor of + // prototype symbols like methods. + symbolTable.set(name, symbol = createSymbol(0 /* SymbolFlags.None */, name)); + } + else if (!(includes & 3 /* SymbolFlags.Variable */ && symbol.flags & 67108864 /* SymbolFlags.Assignment */)) { + // Assignment declarations are allowed to merge with variables, no matter what other flags they have. + if (ts.isNamedDeclaration(node)) { + ts.setParent(node.name, node); + } + // Report errors every position with duplicate declaration + // Report errors on previous encountered declarations + var message_1 = symbol.flags & 2 /* SymbolFlags.BlockScopedVariable */ + ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0 + : ts.Diagnostics.Duplicate_identifier_0; + var messageNeedsName_1 = true; + if (symbol.flags & 384 /* SymbolFlags.Enum */ || includes & 384 /* SymbolFlags.Enum */) { + message_1 = ts.Diagnostics.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations; + messageNeedsName_1 = false; + } + var multipleDefaultExports_1 = false; + if (ts.length(symbol.declarations)) { + // If the current node is a default export of some sort, then check if + // there are any other default exports that we need to error on. + // We'll know whether we have other default exports depending on if `symbol` already has a declaration list set. + if (isDefaultExport) { + message_1 = ts.Diagnostics.A_module_cannot_have_multiple_default_exports; + messageNeedsName_1 = false; + multipleDefaultExports_1 = true; + } + else { + // This is to properly report an error in the case "export default { }" is after export default of class declaration or function declaration. + // Error on multiple export default in the following case: + // 1. multiple export default of class declaration or function declaration by checking NodeFlags.Default + // 2. multiple export default of export assignment. This one doesn't have NodeFlags.Default on (as export default doesn't considered as modifiers) + if (symbol.declarations && symbol.declarations.length && + (node.kind === 274 /* SyntaxKind.ExportAssignment */ && !node.isExportEquals)) { + message_1 = ts.Diagnostics.A_module_cannot_have_multiple_default_exports; + messageNeedsName_1 = false; + multipleDefaultExports_1 = true; + } + } + } + var relatedInformation_1 = []; + if (ts.isTypeAliasDeclaration(node) && ts.nodeIsMissing(node.type) && ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */) && symbol.flags & (2097152 /* SymbolFlags.Alias */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */)) { + // export type T; - may have meant export type { T }? + relatedInformation_1.push(createDiagnosticForNode(node, ts.Diagnostics.Did_you_mean_0, "export type { ".concat(ts.unescapeLeadingUnderscores(node.name.escapedText), " }"))); + } + var declarationName_1 = ts.getNameOfDeclaration(node) || node; + ts.forEach(symbol.declarations, function (declaration, index) { + var decl = ts.getNameOfDeclaration(declaration) || declaration; + var diag = createDiagnosticForNode(decl, message_1, messageNeedsName_1 ? getDisplayName(declaration) : undefined); + file.bindDiagnostics.push(multipleDefaultExports_1 ? ts.addRelatedInfo(diag, createDiagnosticForNode(declarationName_1, index === 0 ? ts.Diagnostics.Another_export_default_is_here : ts.Diagnostics.and_here)) : diag); + if (multipleDefaultExports_1) { + relatedInformation_1.push(createDiagnosticForNode(decl, ts.Diagnostics.The_first_export_default_is_here)); + } + }); + var diag = createDiagnosticForNode(declarationName_1, message_1, messageNeedsName_1 ? getDisplayName(node) : undefined); + file.bindDiagnostics.push(ts.addRelatedInfo.apply(void 0, __spreadArray([diag], relatedInformation_1, false))); + symbol = createSymbol(0 /* SymbolFlags.None */, name); + } + } + } + addDeclarationToSymbol(symbol, node, includes); + if (symbol.parent) { + ts.Debug.assert(symbol.parent === parent, "Existing symbol parent should match new one"); + } + else { + symbol.parent = parent; + } + return symbol; + } + function declareModuleMember(node, symbolFlags, symbolExcludes) { + var hasExportModifier = !!(ts.getCombinedModifierFlags(node) & 1 /* ModifierFlags.Export */) || jsdocTreatAsExported(node); + if (symbolFlags & 2097152 /* SymbolFlags.Alias */) { + if (node.kind === 278 /* SyntaxKind.ExportSpecifier */ || (node.kind === 268 /* SyntaxKind.ImportEqualsDeclaration */ && hasExportModifier)) { + return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes); + } + else { + return declareSymbol(container.locals, /*parent*/ undefined, node, symbolFlags, symbolExcludes); + } + } + else { + // Exported module members are given 2 symbols: A local symbol that is classified with an ExportValue flag, + // and an associated export symbol with all the correct flags set on it. There are 2 main reasons: + // + // 1. We treat locals and exports of the same name as mutually exclusive within a container. + // That means the binder will issue a Duplicate Identifier error if you mix locals and exports + // with the same name in the same container. + // TODO: Make this a more specific error and decouple it from the exclusion logic. + // 2. When we checkIdentifier in the checker, we set its resolved symbol to the local symbol, + // but return the export symbol (by calling getExportSymbolOfValueSymbolIfExported). That way + // when the emitter comes back to it, it knows not to qualify the name if it was found in a containing scope. + // NOTE: Nested ambient modules always should go to to 'locals' table to prevent their automatic merge + // during global merging in the checker. Why? The only case when ambient module is permitted inside another module is module augmentation + // and this case is specially handled. Module augmentations should only be merged with original module definition + // and should never be merged directly with other augmentation, and the latter case would be possible if automatic merge is allowed. + if (ts.isJSDocTypeAlias(node)) + ts.Debug.assert(ts.isInJSFile(node)); // We shouldn't add symbols for JSDoc nodes if not in a JS file. + if (!ts.isAmbientModule(node) && (hasExportModifier || container.flags & 64 /* NodeFlags.ExportContext */)) { + if (!container.locals || (ts.hasSyntacticModifier(node, 1024 /* ModifierFlags.Default */) && !getDeclarationName(node))) { + return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes); // No local symbol for an unnamed default! + } + var exportKind = symbolFlags & 111551 /* SymbolFlags.Value */ ? 1048576 /* SymbolFlags.ExportValue */ : 0; + var local = declareSymbol(container.locals, /*parent*/ undefined, node, exportKind, symbolExcludes); + local.exportSymbol = declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes); + node.localSymbol = local; + return local; + } + else { + return declareSymbol(container.locals, /*parent*/ undefined, node, symbolFlags, symbolExcludes); + } + } + } + function jsdocTreatAsExported(node) { + if (node.parent && ts.isModuleDeclaration(node)) { + node = node.parent; + } + if (!ts.isJSDocTypeAlias(node)) + return false; + // jsdoc typedef handling is a bit of a doozy, but to summarize, treat the typedef as exported if: + // 1. It has an explicit name (since by default typedefs are always directly exported, either at the top level or in a container), or + if (!ts.isJSDocEnumTag(node) && !!node.fullName) + return true; + // 2. The thing a nameless typedef pulls its name from is implicitly a direct export (either by assignment or actual export flag). + var declName = ts.getNameOfDeclaration(node); + if (!declName) + return false; + if (ts.isPropertyAccessEntityNameExpression(declName.parent) && isTopLevelNamespaceAssignment(declName.parent)) + return true; + if (ts.isDeclaration(declName.parent) && ts.getCombinedModifierFlags(declName.parent) & 1 /* ModifierFlags.Export */) + return true; + // This could potentially be simplified by having `delayedBindJSDocTypedefTag` pass in an override for `hasExportModifier`, since it should + // already have calculated and branched on most of this. + return false; + } + // All container nodes are kept on a linked list in declaration order. This list is used by + // the getLocalNameOfContainer function in the type checker to validate that the local name + // used for a container is unique. + function bindContainer(node, containerFlags) { + // Before we recurse into a node's children, we first save the existing parent, container + // and block-container. Then after we pop out of processing the children, we restore + // these saved values. + var saveContainer = container; + var saveThisParentContainer = thisParentContainer; + var savedBlockScopeContainer = blockScopeContainer; + // Depending on what kind of node this is, we may have to adjust the current container + // and block-container. If the current node is a container, then it is automatically + // considered the current block-container as well. Also, for containers that we know + // may contain locals, we eagerly initialize the .locals field. We do this because + // it's highly likely that the .locals will be needed to place some child in (for example, + // a parameter, or variable declaration). + // + // However, we do not proactively create the .locals for block-containers because it's + // totally normal and common for block-containers to never actually have a block-scoped + // variable in them. We don't want to end up allocating an object for every 'block' we + // run into when most of them won't be necessary. + // + // Finally, if this is a block-container, then we clear out any existing .locals object + // it may contain within it. This happens in incremental scenarios. Because we can be + // reusing a node from a previous compilation, that node may have had 'locals' created + // for it. We must clear this so we don't accidentally move any stale data forward from + // a previous compilation. + if (containerFlags & 1 /* ContainerFlags.IsContainer */) { + if (node.kind !== 216 /* SyntaxKind.ArrowFunction */) { + thisParentContainer = container; + } + container = blockScopeContainer = node; + if (containerFlags & 32 /* ContainerFlags.HasLocals */) { + container.locals = ts.createSymbolTable(); + } + addToContainerChain(container); + } + else if (containerFlags & 2 /* ContainerFlags.IsBlockScopedContainer */) { + blockScopeContainer = node; + blockScopeContainer.locals = undefined; + } + if (containerFlags & 4 /* ContainerFlags.IsControlFlowContainer */) { + var saveCurrentFlow = currentFlow; + var saveBreakTarget = currentBreakTarget; + var saveContinueTarget = currentContinueTarget; + var saveReturnTarget = currentReturnTarget; + var saveExceptionTarget = currentExceptionTarget; + var saveActiveLabelList = activeLabelList; + var saveHasExplicitReturn = hasExplicitReturn; + var isImmediatelyInvoked = (containerFlags & 16 /* ContainerFlags.IsFunctionExpression */ && + !ts.hasSyntacticModifier(node, 512 /* ModifierFlags.Async */) && + !node.asteriskToken && + !!ts.getImmediatelyInvokedFunctionExpression(node)) || + node.kind === 172 /* SyntaxKind.ClassStaticBlockDeclaration */; + // A non-async, non-generator IIFE is considered part of the containing control flow. Return statements behave + // similarly to break statements that exit to a label just past the statement body. + if (!isImmediatelyInvoked) { + currentFlow = initFlowNode({ flags: 2 /* FlowFlags.Start */ }); + if (containerFlags & (16 /* ContainerFlags.IsFunctionExpression */ | 128 /* ContainerFlags.IsObjectLiteralOrClassExpressionMethodOrAccessor */)) { + currentFlow.node = node; + } + } + // We create a return control flow graph for IIFEs and constructors. For constructors + // we use the return control flow graph in strict property initialization checks. + currentReturnTarget = isImmediatelyInvoked || node.kind === 173 /* SyntaxKind.Constructor */ || (ts.isInJSFile(node) && (node.kind === 259 /* SyntaxKind.FunctionDeclaration */ || node.kind === 215 /* SyntaxKind.FunctionExpression */)) ? createBranchLabel() : undefined; + currentExceptionTarget = undefined; + currentBreakTarget = undefined; + currentContinueTarget = undefined; + activeLabelList = undefined; + hasExplicitReturn = false; + bindChildren(node); + // Reset all reachability check related flags on node (for incremental scenarios) + node.flags &= ~2816 /* NodeFlags.ReachabilityAndEmitFlags */; + if (!(currentFlow.flags & 1 /* FlowFlags.Unreachable */) && containerFlags & 8 /* ContainerFlags.IsFunctionLike */ && ts.nodeIsPresent(node.body)) { + node.flags |= 256 /* NodeFlags.HasImplicitReturn */; + if (hasExplicitReturn) + node.flags |= 512 /* NodeFlags.HasExplicitReturn */; + node.endFlowNode = currentFlow; + } + if (node.kind === 308 /* SyntaxKind.SourceFile */) { + node.flags |= emitFlags; + node.endFlowNode = currentFlow; + } + if (currentReturnTarget) { + addAntecedent(currentReturnTarget, currentFlow); + currentFlow = finishFlowLabel(currentReturnTarget); + if (node.kind === 173 /* SyntaxKind.Constructor */ || node.kind === 172 /* SyntaxKind.ClassStaticBlockDeclaration */ || (ts.isInJSFile(node) && (node.kind === 259 /* SyntaxKind.FunctionDeclaration */ || node.kind === 215 /* SyntaxKind.FunctionExpression */))) { + node.returnFlowNode = currentFlow; + } + } + if (!isImmediatelyInvoked) { + currentFlow = saveCurrentFlow; + } + currentBreakTarget = saveBreakTarget; + currentContinueTarget = saveContinueTarget; + currentReturnTarget = saveReturnTarget; + currentExceptionTarget = saveExceptionTarget; + activeLabelList = saveActiveLabelList; + hasExplicitReturn = saveHasExplicitReturn; + } + else if (containerFlags & 64 /* ContainerFlags.IsInterface */) { + seenThisKeyword = false; + bindChildren(node); + node.flags = seenThisKeyword ? node.flags | 128 /* NodeFlags.ContainsThis */ : node.flags & ~128 /* NodeFlags.ContainsThis */; + } + else { + bindChildren(node); + } + container = saveContainer; + thisParentContainer = saveThisParentContainer; + blockScopeContainer = savedBlockScopeContainer; + } + function bindEachFunctionsFirst(nodes) { + bindEach(nodes, function (n) { return n.kind === 259 /* SyntaxKind.FunctionDeclaration */ ? bind(n) : undefined; }); + bindEach(nodes, function (n) { return n.kind !== 259 /* SyntaxKind.FunctionDeclaration */ ? bind(n) : undefined; }); + } + function bindEach(nodes, bindFunction) { + if (bindFunction === void 0) { bindFunction = bind; } + if (nodes === undefined) { + return; + } + ts.forEach(nodes, bindFunction); + } + function bindEachChild(node) { + ts.forEachChild(node, bind, bindEach); + } + function bindChildren(node) { + var saveInAssignmentPattern = inAssignmentPattern; + // Most nodes aren't valid in an assignment pattern, so we clear the value here + // and set it before we descend into nodes that could actually be part of an assignment pattern. + inAssignmentPattern = false; + if (checkUnreachable(node)) { + bindEachChild(node); + bindJSDoc(node); + inAssignmentPattern = saveInAssignmentPattern; + return; + } + if (node.kind >= 240 /* SyntaxKind.FirstStatement */ && node.kind <= 256 /* SyntaxKind.LastStatement */ && !options.allowUnreachableCode) { + node.flowNode = currentFlow; + } + switch (node.kind) { + case 244 /* SyntaxKind.WhileStatement */: + bindWhileStatement(node); + break; + case 243 /* SyntaxKind.DoStatement */: + bindDoStatement(node); + break; + case 245 /* SyntaxKind.ForStatement */: + bindForStatement(node); + break; + case 246 /* SyntaxKind.ForInStatement */: + case 247 /* SyntaxKind.ForOfStatement */: + bindForInOrForOfStatement(node); + break; + case 242 /* SyntaxKind.IfStatement */: + bindIfStatement(node); + break; + case 250 /* SyntaxKind.ReturnStatement */: + case 254 /* SyntaxKind.ThrowStatement */: + bindReturnOrThrow(node); + break; + case 249 /* SyntaxKind.BreakStatement */: + case 248 /* SyntaxKind.ContinueStatement */: + bindBreakOrContinueStatement(node); + break; + case 255 /* SyntaxKind.TryStatement */: + bindTryStatement(node); + break; + case 252 /* SyntaxKind.SwitchStatement */: + bindSwitchStatement(node); + break; + case 266 /* SyntaxKind.CaseBlock */: + bindCaseBlock(node); + break; + case 292 /* SyntaxKind.CaseClause */: + bindCaseClause(node); + break; + case 241 /* SyntaxKind.ExpressionStatement */: + bindExpressionStatement(node); + break; + case 253 /* SyntaxKind.LabeledStatement */: + bindLabeledStatement(node); + break; + case 221 /* SyntaxKind.PrefixUnaryExpression */: + bindPrefixUnaryExpressionFlow(node); + break; + case 222 /* SyntaxKind.PostfixUnaryExpression */: + bindPostfixUnaryExpressionFlow(node); + break; + case 223 /* SyntaxKind.BinaryExpression */: + if (ts.isDestructuringAssignment(node)) { + // Carry over whether we are in an assignment pattern to + // binary expressions that could actually be an initializer + inAssignmentPattern = saveInAssignmentPattern; + bindDestructuringAssignmentFlow(node); + return; + } + bindBinaryExpressionFlow(node); + break; + case 217 /* SyntaxKind.DeleteExpression */: + bindDeleteExpressionFlow(node); + break; + case 224 /* SyntaxKind.ConditionalExpression */: + bindConditionalExpressionFlow(node); + break; + case 257 /* SyntaxKind.VariableDeclaration */: + bindVariableDeclarationFlow(node); + break; + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 209 /* SyntaxKind.ElementAccessExpression */: + bindAccessExpressionFlow(node); + break; + case 210 /* SyntaxKind.CallExpression */: + bindCallExpressionFlow(node); + break; + case 232 /* SyntaxKind.NonNullExpression */: + bindNonNullExpressionFlow(node); + break; + case 348 /* SyntaxKind.JSDocTypedefTag */: + case 341 /* SyntaxKind.JSDocCallbackTag */: + case 342 /* SyntaxKind.JSDocEnumTag */: + bindJSDocTypeAlias(node); + break; + // In source files and blocks, bind functions first to match hoisting that occurs at runtime + case 308 /* SyntaxKind.SourceFile */: { + bindEachFunctionsFirst(node.statements); + bind(node.endOfFileToken); + break; + } + case 238 /* SyntaxKind.Block */: + case 265 /* SyntaxKind.ModuleBlock */: + bindEachFunctionsFirst(node.statements); + break; + case 205 /* SyntaxKind.BindingElement */: + bindBindingElementFlow(node); + break; + case 166 /* SyntaxKind.Parameter */: + bindParameterFlow(node); + break; + case 207 /* SyntaxKind.ObjectLiteralExpression */: + case 206 /* SyntaxKind.ArrayLiteralExpression */: + case 299 /* SyntaxKind.PropertyAssignment */: + case 227 /* SyntaxKind.SpreadElement */: + // Carry over whether we are in an assignment pattern of Object and Array literals + // as well as their children that are valid assignment targets. + inAssignmentPattern = saveInAssignmentPattern; + // falls through + default: + bindEachChild(node); + break; + } + bindJSDoc(node); + inAssignmentPattern = saveInAssignmentPattern; + } + function isNarrowingExpression(expr) { + switch (expr.kind) { + case 79 /* SyntaxKind.Identifier */: + case 80 /* SyntaxKind.PrivateIdentifier */: + case 108 /* SyntaxKind.ThisKeyword */: + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 209 /* SyntaxKind.ElementAccessExpression */: + return containsNarrowableReference(expr); + case 210 /* SyntaxKind.CallExpression */: + return hasNarrowableArgument(expr); + case 214 /* SyntaxKind.ParenthesizedExpression */: + case 232 /* SyntaxKind.NonNullExpression */: + return isNarrowingExpression(expr.expression); + case 223 /* SyntaxKind.BinaryExpression */: + return isNarrowingBinaryExpression(expr); + case 221 /* SyntaxKind.PrefixUnaryExpression */: + return expr.operator === 53 /* SyntaxKind.ExclamationToken */ && isNarrowingExpression(expr.operand); + case 218 /* SyntaxKind.TypeOfExpression */: + return isNarrowingExpression(expr.expression); + } + return false; + } + function isNarrowableReference(expr) { + return ts.isDottedName(expr) + || (ts.isPropertyAccessExpression(expr) || ts.isNonNullExpression(expr) || ts.isParenthesizedExpression(expr)) && isNarrowableReference(expr.expression) + || ts.isBinaryExpression(expr) && expr.operatorToken.kind === 27 /* SyntaxKind.CommaToken */ && isNarrowableReference(expr.right) + || ts.isElementAccessExpression(expr) && (ts.isStringOrNumericLiteralLike(expr.argumentExpression) || ts.isEntityNameExpression(expr.argumentExpression)) && isNarrowableReference(expr.expression) + || ts.isAssignmentExpression(expr) && isNarrowableReference(expr.left); + } + function containsNarrowableReference(expr) { + return isNarrowableReference(expr) || ts.isOptionalChain(expr) && containsNarrowableReference(expr.expression); + } + function hasNarrowableArgument(expr) { + if (expr.arguments) { + for (var _i = 0, _a = expr.arguments; _i < _a.length; _i++) { + var argument = _a[_i]; + if (containsNarrowableReference(argument)) { + return true; + } + } + } + if (expr.expression.kind === 208 /* SyntaxKind.PropertyAccessExpression */ && + containsNarrowableReference(expr.expression.expression)) { + return true; + } + return false; + } + function isNarrowingTypeofOperands(expr1, expr2) { + return ts.isTypeOfExpression(expr1) && isNarrowableOperand(expr1.expression) && ts.isStringLiteralLike(expr2); + } + function isNarrowingBinaryExpression(expr) { + switch (expr.operatorToken.kind) { + case 63 /* SyntaxKind.EqualsToken */: + case 75 /* SyntaxKind.BarBarEqualsToken */: + case 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */: + case 77 /* SyntaxKind.QuestionQuestionEqualsToken */: + return containsNarrowableReference(expr.left); + case 34 /* SyntaxKind.EqualsEqualsToken */: + case 35 /* SyntaxKind.ExclamationEqualsToken */: + case 36 /* SyntaxKind.EqualsEqualsEqualsToken */: + case 37 /* SyntaxKind.ExclamationEqualsEqualsToken */: + return isNarrowableOperand(expr.left) || isNarrowableOperand(expr.right) || + isNarrowingTypeofOperands(expr.right, expr.left) || isNarrowingTypeofOperands(expr.left, expr.right); + case 102 /* SyntaxKind.InstanceOfKeyword */: + return isNarrowableOperand(expr.left); + case 101 /* SyntaxKind.InKeyword */: + return isNarrowingExpression(expr.right); + case 27 /* SyntaxKind.CommaToken */: + return isNarrowingExpression(expr.right); + } + return false; + } + function isNarrowableOperand(expr) { + switch (expr.kind) { + case 214 /* SyntaxKind.ParenthesizedExpression */: + return isNarrowableOperand(expr.expression); + case 223 /* SyntaxKind.BinaryExpression */: + switch (expr.operatorToken.kind) { + case 63 /* SyntaxKind.EqualsToken */: + return isNarrowableOperand(expr.left); + case 27 /* SyntaxKind.CommaToken */: + return isNarrowableOperand(expr.right); + } + } + return containsNarrowableReference(expr); + } + function createBranchLabel() { + return initFlowNode({ flags: 4 /* FlowFlags.BranchLabel */, antecedents: undefined }); + } + function createLoopLabel() { + return initFlowNode({ flags: 8 /* FlowFlags.LoopLabel */, antecedents: undefined }); + } + function createReduceLabel(target, antecedents, antecedent) { + return initFlowNode({ flags: 1024 /* FlowFlags.ReduceLabel */, target: target, antecedents: antecedents, antecedent: antecedent }); + } + function setFlowNodeReferenced(flow) { + // On first reference we set the Referenced flag, thereafter we set the Shared flag + flow.flags |= flow.flags & 2048 /* FlowFlags.Referenced */ ? 4096 /* FlowFlags.Shared */ : 2048 /* FlowFlags.Referenced */; + } + function addAntecedent(label, antecedent) { + if (!(antecedent.flags & 1 /* FlowFlags.Unreachable */) && !ts.contains(label.antecedents, antecedent)) { + (label.antecedents || (label.antecedents = [])).push(antecedent); + setFlowNodeReferenced(antecedent); + } + } + function createFlowCondition(flags, antecedent, expression) { + if (antecedent.flags & 1 /* FlowFlags.Unreachable */) { + return antecedent; + } + if (!expression) { + return flags & 32 /* FlowFlags.TrueCondition */ ? antecedent : unreachableFlow; + } + if ((expression.kind === 110 /* SyntaxKind.TrueKeyword */ && flags & 64 /* FlowFlags.FalseCondition */ || + expression.kind === 95 /* SyntaxKind.FalseKeyword */ && flags & 32 /* FlowFlags.TrueCondition */) && + !ts.isExpressionOfOptionalChainRoot(expression) && !ts.isNullishCoalesce(expression.parent)) { + return unreachableFlow; + } + if (!isNarrowingExpression(expression)) { + return antecedent; + } + setFlowNodeReferenced(antecedent); + return initFlowNode({ flags: flags, antecedent: antecedent, node: expression }); + } + function createFlowSwitchClause(antecedent, switchStatement, clauseStart, clauseEnd) { + setFlowNodeReferenced(antecedent); + return initFlowNode({ flags: 128 /* FlowFlags.SwitchClause */, antecedent: antecedent, switchStatement: switchStatement, clauseStart: clauseStart, clauseEnd: clauseEnd }); + } + function createFlowMutation(flags, antecedent, node) { + setFlowNodeReferenced(antecedent); + var result = initFlowNode({ flags: flags, antecedent: antecedent, node: node }); + if (currentExceptionTarget) { + addAntecedent(currentExceptionTarget, result); + } + return result; + } + function createFlowCall(antecedent, node) { + setFlowNodeReferenced(antecedent); + return initFlowNode({ flags: 512 /* FlowFlags.Call */, antecedent: antecedent, node: node }); + } + function finishFlowLabel(flow) { + var antecedents = flow.antecedents; + if (!antecedents) { + return unreachableFlow; + } + if (antecedents.length === 1) { + return antecedents[0]; + } + return flow; + } + function isStatementCondition(node) { + var parent = node.parent; + switch (parent.kind) { + case 242 /* SyntaxKind.IfStatement */: + case 244 /* SyntaxKind.WhileStatement */: + case 243 /* SyntaxKind.DoStatement */: + return parent.expression === node; + case 245 /* SyntaxKind.ForStatement */: + case 224 /* SyntaxKind.ConditionalExpression */: + return parent.condition === node; + } + return false; + } + function isLogicalExpression(node) { + while (true) { + if (node.kind === 214 /* SyntaxKind.ParenthesizedExpression */) { + node = node.expression; + } + else if (node.kind === 221 /* SyntaxKind.PrefixUnaryExpression */ && node.operator === 53 /* SyntaxKind.ExclamationToken */) { + node = node.operand; + } + else { + return node.kind === 223 /* SyntaxKind.BinaryExpression */ && (node.operatorToken.kind === 55 /* SyntaxKind.AmpersandAmpersandToken */ || + node.operatorToken.kind === 56 /* SyntaxKind.BarBarToken */ || + node.operatorToken.kind === 60 /* SyntaxKind.QuestionQuestionToken */); + } + } + } + function isLogicalAssignmentExpression(node) { + node = ts.skipParentheses(node); + return ts.isBinaryExpression(node) && ts.isLogicalOrCoalescingAssignmentOperator(node.operatorToken.kind); + } + function isTopLevelLogicalExpression(node) { + while (ts.isParenthesizedExpression(node.parent) || + ts.isPrefixUnaryExpression(node.parent) && node.parent.operator === 53 /* SyntaxKind.ExclamationToken */) { + node = node.parent; + } + return !isStatementCondition(node) && + !isLogicalExpression(node.parent) && + !(ts.isOptionalChain(node.parent) && node.parent.expression === node); + } + function doWithConditionalBranches(action, value, trueTarget, falseTarget) { + var savedTrueTarget = currentTrueTarget; + var savedFalseTarget = currentFalseTarget; + currentTrueTarget = trueTarget; + currentFalseTarget = falseTarget; + action(value); + currentTrueTarget = savedTrueTarget; + currentFalseTarget = savedFalseTarget; + } + function bindCondition(node, trueTarget, falseTarget) { + doWithConditionalBranches(bind, node, trueTarget, falseTarget); + if (!node || !isLogicalAssignmentExpression(node) && !isLogicalExpression(node) && !(ts.isOptionalChain(node) && ts.isOutermostOptionalChain(node))) { + addAntecedent(trueTarget, createFlowCondition(32 /* FlowFlags.TrueCondition */, currentFlow, node)); + addAntecedent(falseTarget, createFlowCondition(64 /* FlowFlags.FalseCondition */, currentFlow, node)); + } + } + function bindIterativeStatement(node, breakTarget, continueTarget) { + var saveBreakTarget = currentBreakTarget; + var saveContinueTarget = currentContinueTarget; + currentBreakTarget = breakTarget; + currentContinueTarget = continueTarget; + bind(node); + currentBreakTarget = saveBreakTarget; + currentContinueTarget = saveContinueTarget; + } + function setContinueTarget(node, target) { + var label = activeLabelList; + while (label && node.parent.kind === 253 /* SyntaxKind.LabeledStatement */) { + label.continueTarget = target; + label = label.next; + node = node.parent; + } + return target; + } + function bindWhileStatement(node) { + var preWhileLabel = setContinueTarget(node, createLoopLabel()); + var preBodyLabel = createBranchLabel(); + var postWhileLabel = createBranchLabel(); + addAntecedent(preWhileLabel, currentFlow); + currentFlow = preWhileLabel; + bindCondition(node.expression, preBodyLabel, postWhileLabel); + currentFlow = finishFlowLabel(preBodyLabel); + bindIterativeStatement(node.statement, postWhileLabel, preWhileLabel); + addAntecedent(preWhileLabel, currentFlow); + currentFlow = finishFlowLabel(postWhileLabel); + } + function bindDoStatement(node) { + var preDoLabel = createLoopLabel(); + var preConditionLabel = setContinueTarget(node, createBranchLabel()); + var postDoLabel = createBranchLabel(); + addAntecedent(preDoLabel, currentFlow); + currentFlow = preDoLabel; + bindIterativeStatement(node.statement, postDoLabel, preConditionLabel); + addAntecedent(preConditionLabel, currentFlow); + currentFlow = finishFlowLabel(preConditionLabel); + bindCondition(node.expression, preDoLabel, postDoLabel); + currentFlow = finishFlowLabel(postDoLabel); + } + function bindForStatement(node) { + var preLoopLabel = setContinueTarget(node, createLoopLabel()); + var preBodyLabel = createBranchLabel(); + var postLoopLabel = createBranchLabel(); + bind(node.initializer); + addAntecedent(preLoopLabel, currentFlow); + currentFlow = preLoopLabel; + bindCondition(node.condition, preBodyLabel, postLoopLabel); + currentFlow = finishFlowLabel(preBodyLabel); + bindIterativeStatement(node.statement, postLoopLabel, preLoopLabel); + bind(node.incrementor); + addAntecedent(preLoopLabel, currentFlow); + currentFlow = finishFlowLabel(postLoopLabel); + } + function bindForInOrForOfStatement(node) { + var preLoopLabel = setContinueTarget(node, createLoopLabel()); + var postLoopLabel = createBranchLabel(); + bind(node.expression); + addAntecedent(preLoopLabel, currentFlow); + currentFlow = preLoopLabel; + if (node.kind === 247 /* SyntaxKind.ForOfStatement */) { + bind(node.awaitModifier); + } + addAntecedent(postLoopLabel, currentFlow); + bind(node.initializer); + if (node.initializer.kind !== 258 /* SyntaxKind.VariableDeclarationList */) { + bindAssignmentTargetFlow(node.initializer); + } + bindIterativeStatement(node.statement, postLoopLabel, preLoopLabel); + addAntecedent(preLoopLabel, currentFlow); + currentFlow = finishFlowLabel(postLoopLabel); + } + function bindIfStatement(node) { + var thenLabel = createBranchLabel(); + var elseLabel = createBranchLabel(); + var postIfLabel = createBranchLabel(); + bindCondition(node.expression, thenLabel, elseLabel); + currentFlow = finishFlowLabel(thenLabel); + bind(node.thenStatement); + addAntecedent(postIfLabel, currentFlow); + currentFlow = finishFlowLabel(elseLabel); + bind(node.elseStatement); + addAntecedent(postIfLabel, currentFlow); + currentFlow = finishFlowLabel(postIfLabel); + } + function bindReturnOrThrow(node) { + bind(node.expression); + if (node.kind === 250 /* SyntaxKind.ReturnStatement */) { + hasExplicitReturn = true; + if (currentReturnTarget) { + addAntecedent(currentReturnTarget, currentFlow); + } + } + currentFlow = unreachableFlow; + } + function findActiveLabel(name) { + for (var label = activeLabelList; label; label = label.next) { + if (label.name === name) { + return label; + } + } + return undefined; + } + function bindBreakOrContinueFlow(node, breakTarget, continueTarget) { + var flowLabel = node.kind === 249 /* SyntaxKind.BreakStatement */ ? breakTarget : continueTarget; + if (flowLabel) { + addAntecedent(flowLabel, currentFlow); + currentFlow = unreachableFlow; + } + } + function bindBreakOrContinueStatement(node) { + bind(node.label); + if (node.label) { + var activeLabel = findActiveLabel(node.label.escapedText); + if (activeLabel) { + activeLabel.referenced = true; + bindBreakOrContinueFlow(node, activeLabel.breakTarget, activeLabel.continueTarget); + } + } + else { + bindBreakOrContinueFlow(node, currentBreakTarget, currentContinueTarget); + } + } + function bindTryStatement(node) { + // We conservatively assume that *any* code in the try block can cause an exception, but we only need + // to track code that causes mutations (because only mutations widen the possible control flow type of + // a variable). The exceptionLabel is the target label for control flows that result from exceptions. + // We add all mutation flow nodes as antecedents of this label such that we can analyze them as possible + // antecedents of the start of catch or finally blocks. Furthermore, we add the current control flow to + // represent exceptions that occur before any mutations. + var saveReturnTarget = currentReturnTarget; + var saveExceptionTarget = currentExceptionTarget; + var normalExitLabel = createBranchLabel(); + var returnLabel = createBranchLabel(); + var exceptionLabel = createBranchLabel(); + if (node.finallyBlock) { + currentReturnTarget = returnLabel; + } + addAntecedent(exceptionLabel, currentFlow); + currentExceptionTarget = exceptionLabel; + bind(node.tryBlock); + addAntecedent(normalExitLabel, currentFlow); + if (node.catchClause) { + // Start of catch clause is the target of exceptions from try block. + currentFlow = finishFlowLabel(exceptionLabel); + // The currentExceptionTarget now represents control flows from exceptions in the catch clause. + // Effectively, in a try-catch-finally, if an exception occurs in the try block, the catch block + // acts like a second try block. + exceptionLabel = createBranchLabel(); + addAntecedent(exceptionLabel, currentFlow); + currentExceptionTarget = exceptionLabel; + bind(node.catchClause); + addAntecedent(normalExitLabel, currentFlow); + } + currentReturnTarget = saveReturnTarget; + currentExceptionTarget = saveExceptionTarget; + if (node.finallyBlock) { + // Possible ways control can reach the finally block: + // 1) Normal completion of try block of a try-finally or try-catch-finally + // 2) Normal completion of catch block (following exception in try block) of a try-catch-finally + // 3) Return in try or catch block of a try-finally or try-catch-finally + // 4) Exception in try block of a try-finally + // 5) Exception in catch block of a try-catch-finally + // When analyzing a control flow graph that starts inside a finally block we want to consider all + // five possibilities above. However, when analyzing a control flow graph that starts outside (past) + // the finally block, we only want to consider the first two (if we're past a finally block then it + // must have completed normally). Likewise, when analyzing a control flow graph from return statements + // in try or catch blocks in an IIFE, we only want to consider the third. To make this possible, we + // inject a ReduceLabel node into the control flow graph. This node contains an alternate reduced + // set of antecedents for the pre-finally label. As control flow analysis passes by a ReduceLabel + // node, the pre-finally label is temporarily switched to the reduced antecedent set. + var finallyLabel = createBranchLabel(); + finallyLabel.antecedents = ts.concatenate(ts.concatenate(normalExitLabel.antecedents, exceptionLabel.antecedents), returnLabel.antecedents); + currentFlow = finallyLabel; + bind(node.finallyBlock); + if (currentFlow.flags & 1 /* FlowFlags.Unreachable */) { + // If the end of the finally block is unreachable, the end of the entire try statement is unreachable. + currentFlow = unreachableFlow; + } + else { + // If we have an IIFE return target and return statements in the try or catch blocks, add a control + // flow that goes back through the finally block and back through only the return statements. + if (currentReturnTarget && returnLabel.antecedents) { + addAntecedent(currentReturnTarget, createReduceLabel(finallyLabel, returnLabel.antecedents, currentFlow)); + } + // If we have an outer exception target (i.e. a containing try-finally or try-catch-finally), add a + // control flow that goes back through the finally blok and back through each possible exception source. + if (currentExceptionTarget && exceptionLabel.antecedents) { + addAntecedent(currentExceptionTarget, createReduceLabel(finallyLabel, exceptionLabel.antecedents, currentFlow)); + } + // If the end of the finally block is reachable, but the end of the try and catch blocks are not, + // convert the current flow to unreachable. For example, 'try { return 1; } finally { ... }' should + // result in an unreachable current control flow. + currentFlow = normalExitLabel.antecedents ? createReduceLabel(finallyLabel, normalExitLabel.antecedents, currentFlow) : unreachableFlow; + } + } + else { + currentFlow = finishFlowLabel(normalExitLabel); + } + } + function bindSwitchStatement(node) { + var postSwitchLabel = createBranchLabel(); + bind(node.expression); + var saveBreakTarget = currentBreakTarget; + var savePreSwitchCaseFlow = preSwitchCaseFlow; + currentBreakTarget = postSwitchLabel; + preSwitchCaseFlow = currentFlow; + bind(node.caseBlock); + addAntecedent(postSwitchLabel, currentFlow); + var hasDefault = ts.forEach(node.caseBlock.clauses, function (c) { return c.kind === 293 /* SyntaxKind.DefaultClause */; }); + // We mark a switch statement as possibly exhaustive if it has no default clause and if all + // case clauses have unreachable end points (e.g. they all return). Note, we no longer need + // this property in control flow analysis, it's there only for backwards compatibility. + node.possiblyExhaustive = !hasDefault && !postSwitchLabel.antecedents; + if (!hasDefault) { + addAntecedent(postSwitchLabel, createFlowSwitchClause(preSwitchCaseFlow, node, 0, 0)); + } + currentBreakTarget = saveBreakTarget; + preSwitchCaseFlow = savePreSwitchCaseFlow; + currentFlow = finishFlowLabel(postSwitchLabel); + } + function bindCaseBlock(node) { + var clauses = node.clauses; + var isNarrowingSwitch = isNarrowingExpression(node.parent.expression); + var fallthroughFlow = unreachableFlow; + for (var i = 0; i < clauses.length; i++) { + var clauseStart = i; + while (!clauses[i].statements.length && i + 1 < clauses.length) { + bind(clauses[i]); + i++; + } + var preCaseLabel = createBranchLabel(); + addAntecedent(preCaseLabel, isNarrowingSwitch ? createFlowSwitchClause(preSwitchCaseFlow, node.parent, clauseStart, i + 1) : preSwitchCaseFlow); + addAntecedent(preCaseLabel, fallthroughFlow); + currentFlow = finishFlowLabel(preCaseLabel); + var clause = clauses[i]; + bind(clause); + fallthroughFlow = currentFlow; + if (!(currentFlow.flags & 1 /* FlowFlags.Unreachable */) && i !== clauses.length - 1 && options.noFallthroughCasesInSwitch) { + clause.fallthroughFlowNode = currentFlow; + } + } + } + function bindCaseClause(node) { + var saveCurrentFlow = currentFlow; + currentFlow = preSwitchCaseFlow; + bind(node.expression); + currentFlow = saveCurrentFlow; + bindEach(node.statements); + } + function bindExpressionStatement(node) { + bind(node.expression); + maybeBindExpressionFlowIfCall(node.expression); + } + function maybeBindExpressionFlowIfCall(node) { + // A top level or comma expression call expression with a dotted function name and at least one argument + // is potentially an assertion and is therefore included in the control flow. + if (node.kind === 210 /* SyntaxKind.CallExpression */) { + var call = node; + if (call.expression.kind !== 106 /* SyntaxKind.SuperKeyword */ && ts.isDottedName(call.expression)) { + currentFlow = createFlowCall(currentFlow, call); + } + } + } + function bindLabeledStatement(node) { + var postStatementLabel = createBranchLabel(); + activeLabelList = { + next: activeLabelList, + name: node.label.escapedText, + breakTarget: postStatementLabel, + continueTarget: undefined, + referenced: false + }; + bind(node.label); + bind(node.statement); + if (!activeLabelList.referenced && !options.allowUnusedLabels) { + errorOrSuggestionOnNode(ts.unusedLabelIsError(options), node.label, ts.Diagnostics.Unused_label); + } + activeLabelList = activeLabelList.next; + addAntecedent(postStatementLabel, currentFlow); + currentFlow = finishFlowLabel(postStatementLabel); + } + function bindDestructuringTargetFlow(node) { + if (node.kind === 223 /* SyntaxKind.BinaryExpression */ && node.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */) { + bindAssignmentTargetFlow(node.left); + } + else { + bindAssignmentTargetFlow(node); + } + } + function bindAssignmentTargetFlow(node) { + if (isNarrowableReference(node)) { + currentFlow = createFlowMutation(16 /* FlowFlags.Assignment */, currentFlow, node); + } + else if (node.kind === 206 /* SyntaxKind.ArrayLiteralExpression */) { + for (var _i = 0, _a = node.elements; _i < _a.length; _i++) { + var e = _a[_i]; + if (e.kind === 227 /* SyntaxKind.SpreadElement */) { + bindAssignmentTargetFlow(e.expression); + } + else { + bindDestructuringTargetFlow(e); + } + } + } + else if (node.kind === 207 /* SyntaxKind.ObjectLiteralExpression */) { + for (var _b = 0, _c = node.properties; _b < _c.length; _b++) { + var p = _c[_b]; + if (p.kind === 299 /* SyntaxKind.PropertyAssignment */) { + bindDestructuringTargetFlow(p.initializer); + } + else if (p.kind === 300 /* SyntaxKind.ShorthandPropertyAssignment */) { + bindAssignmentTargetFlow(p.name); + } + else if (p.kind === 301 /* SyntaxKind.SpreadAssignment */) { + bindAssignmentTargetFlow(p.expression); + } + } + } + } + function bindLogicalLikeExpression(node, trueTarget, falseTarget) { + var preRightLabel = createBranchLabel(); + if (node.operatorToken.kind === 55 /* SyntaxKind.AmpersandAmpersandToken */ || node.operatorToken.kind === 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */) { + bindCondition(node.left, preRightLabel, falseTarget); + } + else { + bindCondition(node.left, trueTarget, preRightLabel); + } + currentFlow = finishFlowLabel(preRightLabel); + bind(node.operatorToken); + if (ts.isLogicalOrCoalescingAssignmentOperator(node.operatorToken.kind)) { + doWithConditionalBranches(bind, node.right, trueTarget, falseTarget); + bindAssignmentTargetFlow(node.left); + addAntecedent(trueTarget, createFlowCondition(32 /* FlowFlags.TrueCondition */, currentFlow, node)); + addAntecedent(falseTarget, createFlowCondition(64 /* FlowFlags.FalseCondition */, currentFlow, node)); + } + else { + bindCondition(node.right, trueTarget, falseTarget); + } + } + function bindPrefixUnaryExpressionFlow(node) { + if (node.operator === 53 /* SyntaxKind.ExclamationToken */) { + var saveTrueTarget = currentTrueTarget; + currentTrueTarget = currentFalseTarget; + currentFalseTarget = saveTrueTarget; + bindEachChild(node); + currentFalseTarget = currentTrueTarget; + currentTrueTarget = saveTrueTarget; + } + else { + bindEachChild(node); + if (node.operator === 45 /* SyntaxKind.PlusPlusToken */ || node.operator === 46 /* SyntaxKind.MinusMinusToken */) { + bindAssignmentTargetFlow(node.operand); + } + } + } + function bindPostfixUnaryExpressionFlow(node) { + bindEachChild(node); + if (node.operator === 45 /* SyntaxKind.PlusPlusToken */ || node.operator === 46 /* SyntaxKind.MinusMinusToken */) { + bindAssignmentTargetFlow(node.operand); + } + } + function bindDestructuringAssignmentFlow(node) { + if (inAssignmentPattern) { + inAssignmentPattern = false; + bind(node.operatorToken); + bind(node.right); + inAssignmentPattern = true; + bind(node.left); + } + else { + inAssignmentPattern = true; + bind(node.left); + inAssignmentPattern = false; + bind(node.operatorToken); + bind(node.right); + } + bindAssignmentTargetFlow(node.left); + } + function createBindBinaryExpressionFlow() { + return ts.createBinaryExpressionTrampoline(onEnter, onLeft, onOperator, onRight, onExit, /*foldState*/ undefined); + function onEnter(node, state) { + if (state) { + state.stackIndex++; + // Emulate the work that `bind` does before reaching `bindChildren`. A normal call to + // `bindBinaryExpressionFlow` will already have done this work. + ts.setParent(node, parent); + var saveInStrictMode = inStrictMode; + bindWorker(node); + var saveParent = parent; + parent = node; + state.skip = false; + state.inStrictModeStack[state.stackIndex] = saveInStrictMode; + state.parentStack[state.stackIndex] = saveParent; + } + else { + state = { + stackIndex: 0, + skip: false, + inStrictModeStack: [undefined], + parentStack: [undefined] + }; + } + // TODO: bindLogicalExpression is recursive - if we want to handle deeply nested `&&` expressions + // we'll need to handle the `bindLogicalExpression` scenarios in this state machine, too + // For now, though, since the common cases are chained `+`, leaving it recursive is fine + var operator = node.operatorToken.kind; + if (operator === 55 /* SyntaxKind.AmpersandAmpersandToken */ || + operator === 56 /* SyntaxKind.BarBarToken */ || + operator === 60 /* SyntaxKind.QuestionQuestionToken */ || + ts.isLogicalOrCoalescingAssignmentOperator(operator)) { + if (isTopLevelLogicalExpression(node)) { + var postExpressionLabel = createBranchLabel(); + bindLogicalLikeExpression(node, postExpressionLabel, postExpressionLabel); + currentFlow = finishFlowLabel(postExpressionLabel); + } + else { + bindLogicalLikeExpression(node, currentTrueTarget, currentFalseTarget); + } + state.skip = true; + } + return state; + } + function onLeft(left, state, node) { + if (!state.skip) { + var maybeBound = maybeBind(left); + if (node.operatorToken.kind === 27 /* SyntaxKind.CommaToken */) { + maybeBindExpressionFlowIfCall(left); + } + return maybeBound; + } + } + function onOperator(operatorToken, state, _node) { + if (!state.skip) { + bind(operatorToken); + } + } + function onRight(right, state, node) { + if (!state.skip) { + var maybeBound = maybeBind(right); + if (node.operatorToken.kind === 27 /* SyntaxKind.CommaToken */) { + maybeBindExpressionFlowIfCall(right); + } + return maybeBound; + } + } + function onExit(node, state) { + if (!state.skip) { + var operator = node.operatorToken.kind; + if (ts.isAssignmentOperator(operator) && !ts.isAssignmentTarget(node)) { + bindAssignmentTargetFlow(node.left); + if (operator === 63 /* SyntaxKind.EqualsToken */ && node.left.kind === 209 /* SyntaxKind.ElementAccessExpression */) { + var elementAccess = node.left; + if (isNarrowableOperand(elementAccess.expression)) { + currentFlow = createFlowMutation(256 /* FlowFlags.ArrayMutation */, currentFlow, node); + } + } + } + } + var savedInStrictMode = state.inStrictModeStack[state.stackIndex]; + var savedParent = state.parentStack[state.stackIndex]; + if (savedInStrictMode !== undefined) { + inStrictMode = savedInStrictMode; + } + if (savedParent !== undefined) { + parent = savedParent; + } + state.skip = false; + state.stackIndex--; + } + function maybeBind(node) { + if (node && ts.isBinaryExpression(node) && !ts.isDestructuringAssignment(node)) { + return node; + } + bind(node); + } + } + function bindDeleteExpressionFlow(node) { + bindEachChild(node); + if (node.expression.kind === 208 /* SyntaxKind.PropertyAccessExpression */) { + bindAssignmentTargetFlow(node.expression); + } + } + function bindConditionalExpressionFlow(node) { + var trueLabel = createBranchLabel(); + var falseLabel = createBranchLabel(); + var postExpressionLabel = createBranchLabel(); + bindCondition(node.condition, trueLabel, falseLabel); + currentFlow = finishFlowLabel(trueLabel); + bind(node.questionToken); + bind(node.whenTrue); + addAntecedent(postExpressionLabel, currentFlow); + currentFlow = finishFlowLabel(falseLabel); + bind(node.colonToken); + bind(node.whenFalse); + addAntecedent(postExpressionLabel, currentFlow); + currentFlow = finishFlowLabel(postExpressionLabel); + } + function bindInitializedVariableFlow(node) { + var name = !ts.isOmittedExpression(node) ? node.name : undefined; + if (ts.isBindingPattern(name)) { + for (var _i = 0, _a = name.elements; _i < _a.length; _i++) { + var child = _a[_i]; + bindInitializedVariableFlow(child); + } + } + else { + currentFlow = createFlowMutation(16 /* FlowFlags.Assignment */, currentFlow, node); + } + } + function bindVariableDeclarationFlow(node) { + bindEachChild(node); + if (node.initializer || ts.isForInOrOfStatement(node.parent.parent)) { + bindInitializedVariableFlow(node); + } + } + function bindBindingElementFlow(node) { + // When evaluating a binding pattern, the initializer is evaluated before the binding pattern, per: + // - https://tc39.es/ecma262/#sec-destructuring-binding-patterns-runtime-semantics-iteratorbindinginitialization + // - `BindingElement: BindingPattern Initializer?` + // - https://tc39.es/ecma262/#sec-runtime-semantics-keyedbindinginitialization + // - `BindingElement: BindingPattern Initializer?` + bind(node.dotDotDotToken); + bind(node.propertyName); + bindInitializer(node.initializer); + bind(node.name); + } + function bindParameterFlow(node) { + bindEach(node.modifiers); + bind(node.dotDotDotToken); + bind(node.questionToken); + bind(node.type); + bindInitializer(node.initializer); + bind(node.name); + } + // a BindingElement/Parameter does not have side effects if initializers are not evaluated and used. (see GH#49759) + function bindInitializer(node) { + if (!node) { + return; + } + var entryFlow = currentFlow; + bind(node); + if (entryFlow === unreachableFlow || entryFlow === currentFlow) { + return; + } + var exitFlow = createBranchLabel(); + addAntecedent(exitFlow, entryFlow); + addAntecedent(exitFlow, currentFlow); + currentFlow = finishFlowLabel(exitFlow); + } + function bindJSDocTypeAlias(node) { + bind(node.tagName); + if (node.kind !== 342 /* SyntaxKind.JSDocEnumTag */ && node.fullName) { + // don't bind the type name yet; that's delayed until delayedBindJSDocTypedefTag + ts.setParent(node.fullName, node); + ts.setParentRecursive(node.fullName, /*incremental*/ false); + } + if (typeof node.comment !== "string") { + bindEach(node.comment); + } + } + function bindJSDocClassTag(node) { + bindEachChild(node); + var host = ts.getHostSignatureFromJSDoc(node); + if (host && host.kind !== 171 /* SyntaxKind.MethodDeclaration */) { + addDeclarationToSymbol(host.symbol, host, 32 /* SymbolFlags.Class */); + } + } + function bindOptionalExpression(node, trueTarget, falseTarget) { + doWithConditionalBranches(bind, node, trueTarget, falseTarget); + if (!ts.isOptionalChain(node) || ts.isOutermostOptionalChain(node)) { + addAntecedent(trueTarget, createFlowCondition(32 /* FlowFlags.TrueCondition */, currentFlow, node)); + addAntecedent(falseTarget, createFlowCondition(64 /* FlowFlags.FalseCondition */, currentFlow, node)); + } + } + function bindOptionalChainRest(node) { + switch (node.kind) { + case 208 /* SyntaxKind.PropertyAccessExpression */: + bind(node.questionDotToken); + bind(node.name); + break; + case 209 /* SyntaxKind.ElementAccessExpression */: + bind(node.questionDotToken); + bind(node.argumentExpression); + break; + case 210 /* SyntaxKind.CallExpression */: + bind(node.questionDotToken); + bindEach(node.typeArguments); + bindEach(node.arguments); + break; + } + } + function bindOptionalChain(node, trueTarget, falseTarget) { + // For an optional chain, we emulate the behavior of a logical expression: + // + // a?.b -> a && a.b + // a?.b.c -> a && a.b.c + // a?.b?.c -> a && a.b && a.b.c + // a?.[x = 1] -> a && a[x = 1] + // + // To do this we descend through the chain until we reach the root of a chain (the expression with a `?.`) + // and build it's CFA graph as if it were the first condition (`a && ...`). Then we bind the rest + // of the node as part of the "true" branch, and continue to do so as we ascend back up to the outermost + // chain node. We then treat the entire node as the right side of the expression. + var preChainLabel = ts.isOptionalChainRoot(node) ? createBranchLabel() : undefined; + bindOptionalExpression(node.expression, preChainLabel || trueTarget, falseTarget); + if (preChainLabel) { + currentFlow = finishFlowLabel(preChainLabel); + } + doWithConditionalBranches(bindOptionalChainRest, node, trueTarget, falseTarget); + if (ts.isOutermostOptionalChain(node)) { + addAntecedent(trueTarget, createFlowCondition(32 /* FlowFlags.TrueCondition */, currentFlow, node)); + addAntecedent(falseTarget, createFlowCondition(64 /* FlowFlags.FalseCondition */, currentFlow, node)); + } + } + function bindOptionalChainFlow(node) { + if (isTopLevelLogicalExpression(node)) { + var postExpressionLabel = createBranchLabel(); + bindOptionalChain(node, postExpressionLabel, postExpressionLabel); + currentFlow = finishFlowLabel(postExpressionLabel); + } + else { + bindOptionalChain(node, currentTrueTarget, currentFalseTarget); + } + } + function bindNonNullExpressionFlow(node) { + if (ts.isOptionalChain(node)) { + bindOptionalChainFlow(node); + } + else { + bindEachChild(node); + } + } + function bindAccessExpressionFlow(node) { + if (ts.isOptionalChain(node)) { + bindOptionalChainFlow(node); + } + else { + bindEachChild(node); + } + } + function bindCallExpressionFlow(node) { + if (ts.isOptionalChain(node)) { + bindOptionalChainFlow(node); + } + else { + // If the target of the call expression is a function expression or arrow function we have + // an immediately invoked function expression (IIFE). Initialize the flowNode property to + // the current control flow (which includes evaluation of the IIFE arguments). + var expr = ts.skipParentheses(node.expression); + if (expr.kind === 215 /* SyntaxKind.FunctionExpression */ || expr.kind === 216 /* SyntaxKind.ArrowFunction */) { + bindEach(node.typeArguments); + bindEach(node.arguments); + bind(node.expression); + } + else { + bindEachChild(node); + if (node.expression.kind === 106 /* SyntaxKind.SuperKeyword */) { + currentFlow = createFlowCall(currentFlow, node); + } + } + } + if (node.expression.kind === 208 /* SyntaxKind.PropertyAccessExpression */) { + var propertyAccess = node.expression; + if (ts.isIdentifier(propertyAccess.name) && isNarrowableOperand(propertyAccess.expression) && ts.isPushOrUnshiftIdentifier(propertyAccess.name)) { + currentFlow = createFlowMutation(256 /* FlowFlags.ArrayMutation */, currentFlow, node); + } + } + } + function getContainerFlags(node) { + switch (node.kind) { + case 228 /* SyntaxKind.ClassExpression */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 207 /* SyntaxKind.ObjectLiteralExpression */: + case 184 /* SyntaxKind.TypeLiteral */: + case 325 /* SyntaxKind.JSDocTypeLiteral */: + case 289 /* SyntaxKind.JsxAttributes */: + return 1 /* ContainerFlags.IsContainer */; + case 261 /* SyntaxKind.InterfaceDeclaration */: + return 1 /* ContainerFlags.IsContainer */ | 64 /* ContainerFlags.IsInterface */; + case 264 /* SyntaxKind.ModuleDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 197 /* SyntaxKind.MappedType */: + case 178 /* SyntaxKind.IndexSignature */: + return 1 /* ContainerFlags.IsContainer */ | 32 /* ContainerFlags.HasLocals */; + case 308 /* SyntaxKind.SourceFile */: + return 1 /* ContainerFlags.IsContainer */ | 4 /* ContainerFlags.IsControlFlowContainer */ | 32 /* ContainerFlags.HasLocals */; + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 171 /* SyntaxKind.MethodDeclaration */: + if (ts.isObjectLiteralOrClassExpressionMethodOrAccessor(node)) { + return 1 /* ContainerFlags.IsContainer */ | 4 /* ContainerFlags.IsControlFlowContainer */ | 32 /* ContainerFlags.HasLocals */ | 8 /* ContainerFlags.IsFunctionLike */ | 128 /* ContainerFlags.IsObjectLiteralOrClassExpressionMethodOrAccessor */; + } + // falls through + case 173 /* SyntaxKind.Constructor */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + case 176 /* SyntaxKind.CallSignature */: + case 326 /* SyntaxKind.JSDocSignature */: + case 320 /* SyntaxKind.JSDocFunctionType */: + case 181 /* SyntaxKind.FunctionType */: + case 177 /* SyntaxKind.ConstructSignature */: + case 182 /* SyntaxKind.ConstructorType */: + case 172 /* SyntaxKind.ClassStaticBlockDeclaration */: + return 1 /* ContainerFlags.IsContainer */ | 4 /* ContainerFlags.IsControlFlowContainer */ | 32 /* ContainerFlags.HasLocals */ | 8 /* ContainerFlags.IsFunctionLike */; + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + return 1 /* ContainerFlags.IsContainer */ | 4 /* ContainerFlags.IsControlFlowContainer */ | 32 /* ContainerFlags.HasLocals */ | 8 /* ContainerFlags.IsFunctionLike */ | 16 /* ContainerFlags.IsFunctionExpression */; + case 265 /* SyntaxKind.ModuleBlock */: + return 4 /* ContainerFlags.IsControlFlowContainer */; + case 169 /* SyntaxKind.PropertyDeclaration */: + return node.initializer ? 4 /* ContainerFlags.IsControlFlowContainer */ : 0; + case 295 /* SyntaxKind.CatchClause */: + case 245 /* SyntaxKind.ForStatement */: + case 246 /* SyntaxKind.ForInStatement */: + case 247 /* SyntaxKind.ForOfStatement */: + case 266 /* SyntaxKind.CaseBlock */: + return 2 /* ContainerFlags.IsBlockScopedContainer */; + case 238 /* SyntaxKind.Block */: + // do not treat blocks directly inside a function as a block-scoped-container. + // Locals that reside in this block should go to the function locals. Otherwise 'x' + // would not appear to be a redeclaration of a block scoped local in the following + // example: + // + // function foo() { + // var x; + // let x; + // } + // + // If we placed 'var x' into the function locals and 'let x' into the locals of + // the block, then there would be no collision. + // + // By not creating a new block-scoped-container here, we ensure that both 'var x' + // and 'let x' go into the Function-container's locals, and we do get a collision + // conflict. + return ts.isFunctionLike(node.parent) || ts.isClassStaticBlockDeclaration(node.parent) ? 0 /* ContainerFlags.None */ : 2 /* ContainerFlags.IsBlockScopedContainer */; + } + return 0 /* ContainerFlags.None */; + } + function addToContainerChain(next) { + if (lastContainer) { + lastContainer.nextContainer = next; + } + lastContainer = next; + } + function declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes) { + switch (container.kind) { + // Modules, source files, and classes need specialized handling for how their + // members are declared (for example, a member of a class will go into a specific + // symbol table depending on if it is static or not). We defer to specialized + // handlers to take care of declaring these child members. + case 264 /* SyntaxKind.ModuleDeclaration */: + return declareModuleMember(node, symbolFlags, symbolExcludes); + case 308 /* SyntaxKind.SourceFile */: + return declareSourceFileMember(node, symbolFlags, symbolExcludes); + case 228 /* SyntaxKind.ClassExpression */: + case 260 /* SyntaxKind.ClassDeclaration */: + return declareClassMember(node, symbolFlags, symbolExcludes); + case 263 /* SyntaxKind.EnumDeclaration */: + return declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes); + case 184 /* SyntaxKind.TypeLiteral */: + case 325 /* SyntaxKind.JSDocTypeLiteral */: + case 207 /* SyntaxKind.ObjectLiteralExpression */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 289 /* SyntaxKind.JsxAttributes */: + // Interface/Object-types always have their children added to the 'members' of + // their container. They are only accessible through an instance of their + // container, and are never in scope otherwise (even inside the body of the + // object / type / interface declaring them). An exception is type parameters, + // which are in scope without qualification (similar to 'locals'). + return declareSymbol(container.symbol.members, container.symbol, node, symbolFlags, symbolExcludes); + case 181 /* SyntaxKind.FunctionType */: + case 182 /* SyntaxKind.ConstructorType */: + case 176 /* SyntaxKind.CallSignature */: + case 177 /* SyntaxKind.ConstructSignature */: + case 326 /* SyntaxKind.JSDocSignature */: + case 178 /* SyntaxKind.IndexSignature */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + case 173 /* SyntaxKind.Constructor */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + case 320 /* SyntaxKind.JSDocFunctionType */: + case 348 /* SyntaxKind.JSDocTypedefTag */: + case 341 /* SyntaxKind.JSDocCallbackTag */: + case 172 /* SyntaxKind.ClassStaticBlockDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 197 /* SyntaxKind.MappedType */: + // All the children of these container types are never visible through another + // symbol (i.e. through another symbol's 'exports' or 'members'). Instead, + // they're only accessed 'lexically' (i.e. from code that exists underneath + // their container in the tree). To accomplish this, we simply add their declared + // symbol to the 'locals' of the container. These symbols can then be found as + // the type checker walks up the containers, checking them for matching names. + return declareSymbol(container.locals, /*parent*/ undefined, node, symbolFlags, symbolExcludes); + } + } + function declareClassMember(node, symbolFlags, symbolExcludes) { + return ts.isStatic(node) + ? declareSymbol(container.symbol.exports, container.symbol, node, symbolFlags, symbolExcludes) + : declareSymbol(container.symbol.members, container.symbol, node, symbolFlags, symbolExcludes); + } + function declareSourceFileMember(node, symbolFlags, symbolExcludes) { + return ts.isExternalModule(file) + ? declareModuleMember(node, symbolFlags, symbolExcludes) + : declareSymbol(file.locals, /*parent*/ undefined, node, symbolFlags, symbolExcludes); + } + function hasExportDeclarations(node) { + var body = ts.isSourceFile(node) ? node : ts.tryCast(node.body, ts.isModuleBlock); + return !!body && body.statements.some(function (s) { return ts.isExportDeclaration(s) || ts.isExportAssignment(s); }); + } + function setExportContextFlag(node) { + // A declaration source file or ambient module declaration that contains no export declarations (but possibly regular + // declarations with export modifiers) is an export context in which declarations are implicitly exported. + if (node.flags & 16777216 /* NodeFlags.Ambient */ && !hasExportDeclarations(node)) { + node.flags |= 64 /* NodeFlags.ExportContext */; + } + else { + node.flags &= ~64 /* NodeFlags.ExportContext */; + } + } + function bindModuleDeclaration(node) { + setExportContextFlag(node); + if (ts.isAmbientModule(node)) { + if (ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */)) { + errorOnFirstToken(node, ts.Diagnostics.export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always_visible); + } + if (ts.isModuleAugmentationExternal(node)) { + declareModuleSymbol(node); + } + else { + var pattern = void 0; + if (node.name.kind === 10 /* SyntaxKind.StringLiteral */) { + var text = node.name.text; + pattern = ts.tryParsePattern(text); + if (pattern === undefined) { + errorOnFirstToken(node.name, ts.Diagnostics.Pattern_0_can_have_at_most_one_Asterisk_character, text); + } + } + var symbol = declareSymbolAndAddToSymbolTable(node, 512 /* SymbolFlags.ValueModule */, 110735 /* SymbolFlags.ValueModuleExcludes */); + file.patternAmbientModules = ts.append(file.patternAmbientModules, pattern && !ts.isString(pattern) ? { pattern: pattern, symbol: symbol } : undefined); + } + } + else { + var state = declareModuleSymbol(node); + if (state !== 0 /* ModuleInstanceState.NonInstantiated */) { + var symbol = node.symbol; + // if module was already merged with some function, class or non-const enum, treat it as non-const-enum-only + symbol.constEnumOnlyModule = (!(symbol.flags & (16 /* SymbolFlags.Function */ | 32 /* SymbolFlags.Class */ | 256 /* SymbolFlags.RegularEnum */))) + // Current must be `const enum` only + && state === 2 /* ModuleInstanceState.ConstEnumOnly */ + // Can't have been set to 'false' in a previous merged symbol. ('undefined' OK) + && symbol.constEnumOnlyModule !== false; + } + } + } + function declareModuleSymbol(node) { + var state = getModuleInstanceState(node); + var instantiated = state !== 0 /* ModuleInstanceState.NonInstantiated */; + declareSymbolAndAddToSymbolTable(node, instantiated ? 512 /* SymbolFlags.ValueModule */ : 1024 /* SymbolFlags.NamespaceModule */, instantiated ? 110735 /* SymbolFlags.ValueModuleExcludes */ : 0 /* SymbolFlags.NamespaceModuleExcludes */); + return state; + } + function bindFunctionOrConstructorType(node) { + // For a given function symbol "<...>(...) => T" we want to generate a symbol identical + // to the one we would get for: { <...>(...): T } + // + // We do that by making an anonymous type literal symbol, and then setting the function + // symbol as its sole member. To the rest of the system, this symbol will be indistinguishable + // from an actual type literal symbol you would have gotten had you used the long form. + var symbol = createSymbol(131072 /* SymbolFlags.Signature */, getDeclarationName(node)); // TODO: GH#18217 + addDeclarationToSymbol(symbol, node, 131072 /* SymbolFlags.Signature */); + var typeLiteralSymbol = createSymbol(2048 /* SymbolFlags.TypeLiteral */, "__type" /* InternalSymbolName.Type */); + addDeclarationToSymbol(typeLiteralSymbol, node, 2048 /* SymbolFlags.TypeLiteral */); + typeLiteralSymbol.members = ts.createSymbolTable(); + typeLiteralSymbol.members.set(symbol.escapedName, symbol); + } + function bindObjectLiteralExpression(node) { + return bindAnonymousDeclaration(node, 4096 /* SymbolFlags.ObjectLiteral */, "__object" /* InternalSymbolName.Object */); + } + function bindJsxAttributes(node) { + return bindAnonymousDeclaration(node, 4096 /* SymbolFlags.ObjectLiteral */, "__jsxAttributes" /* InternalSymbolName.JSXAttributes */); + } + function bindJsxAttribute(node, symbolFlags, symbolExcludes) { + return declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes); + } + function bindAnonymousDeclaration(node, symbolFlags, name) { + var symbol = createSymbol(symbolFlags, name); + if (symbolFlags & (8 /* SymbolFlags.EnumMember */ | 106500 /* SymbolFlags.ClassMember */)) { + symbol.parent = container.symbol; + } + addDeclarationToSymbol(symbol, node, symbolFlags); + return symbol; + } + function bindBlockScopedDeclaration(node, symbolFlags, symbolExcludes) { + switch (blockScopeContainer.kind) { + case 264 /* SyntaxKind.ModuleDeclaration */: + declareModuleMember(node, symbolFlags, symbolExcludes); + break; + case 308 /* SyntaxKind.SourceFile */: + if (ts.isExternalOrCommonJsModule(container)) { + declareModuleMember(node, symbolFlags, symbolExcludes); + break; + } + // falls through + default: + if (!blockScopeContainer.locals) { + blockScopeContainer.locals = ts.createSymbolTable(); + addToContainerChain(blockScopeContainer); + } + declareSymbol(blockScopeContainer.locals, /*parent*/ undefined, node, symbolFlags, symbolExcludes); + } + } + function delayedBindJSDocTypedefTag() { + if (!delayedTypeAliases) { + return; + } + var saveContainer = container; + var saveLastContainer = lastContainer; + var saveBlockScopeContainer = blockScopeContainer; + var saveParent = parent; + var saveCurrentFlow = currentFlow; + for (var _i = 0, delayedTypeAliases_1 = delayedTypeAliases; _i < delayedTypeAliases_1.length; _i++) { + var typeAlias = delayedTypeAliases_1[_i]; + var host = typeAlias.parent.parent; + container = ts.findAncestor(host.parent, function (n) { return !!(getContainerFlags(n) & 1 /* ContainerFlags.IsContainer */); }) || file; + blockScopeContainer = ts.getEnclosingBlockScopeContainer(host) || file; + currentFlow = initFlowNode({ flags: 2 /* FlowFlags.Start */ }); + parent = typeAlias; + bind(typeAlias.typeExpression); + var declName = ts.getNameOfDeclaration(typeAlias); + if ((ts.isJSDocEnumTag(typeAlias) || !typeAlias.fullName) && declName && ts.isPropertyAccessEntityNameExpression(declName.parent)) { + // typedef anchored to an A.B.C assignment - we need to bind into B's namespace under name C + var isTopLevel = isTopLevelNamespaceAssignment(declName.parent); + if (isTopLevel) { + bindPotentiallyMissingNamespaces(file.symbol, declName.parent, isTopLevel, !!ts.findAncestor(declName, function (d) { return ts.isPropertyAccessExpression(d) && d.name.escapedText === "prototype"; }), /*containerIsClass*/ false); + var oldContainer = container; + switch (ts.getAssignmentDeclarationPropertyAccessKind(declName.parent)) { + case 1 /* AssignmentDeclarationKind.ExportsProperty */: + case 2 /* AssignmentDeclarationKind.ModuleExports */: + if (!ts.isExternalOrCommonJsModule(file)) { + container = undefined; + } + else { + container = file; + } + break; + case 4 /* AssignmentDeclarationKind.ThisProperty */: + container = declName.parent.expression; + break; + case 3 /* AssignmentDeclarationKind.PrototypeProperty */: + container = declName.parent.expression.name; + break; + case 5 /* AssignmentDeclarationKind.Property */: + container = isExportsOrModuleExportsOrAlias(file, declName.parent.expression) ? file + : ts.isPropertyAccessExpression(declName.parent.expression) ? declName.parent.expression.name + : declName.parent.expression; + break; + case 0 /* AssignmentDeclarationKind.None */: + return ts.Debug.fail("Shouldn't have detected typedef or enum on non-assignment declaration"); + } + if (container) { + declareModuleMember(typeAlias, 524288 /* SymbolFlags.TypeAlias */, 788968 /* SymbolFlags.TypeAliasExcludes */); + } + container = oldContainer; + } + } + else if (ts.isJSDocEnumTag(typeAlias) || !typeAlias.fullName || typeAlias.fullName.kind === 79 /* SyntaxKind.Identifier */) { + parent = typeAlias.parent; + bindBlockScopedDeclaration(typeAlias, 524288 /* SymbolFlags.TypeAlias */, 788968 /* SymbolFlags.TypeAliasExcludes */); + } + else { + bind(typeAlias.fullName); + } + } + container = saveContainer; + lastContainer = saveLastContainer; + blockScopeContainer = saveBlockScopeContainer; + parent = saveParent; + currentFlow = saveCurrentFlow; + } + // The binder visits every node in the syntax tree so it is a convenient place to perform a single localized + // check for reserved words used as identifiers in strict mode code, as well as `yield` or `await` in + // [Yield] or [Await] contexts, respectively. + function checkContextualIdentifier(node) { + // Report error only if there are no parse errors in file + if (!file.parseDiagnostics.length && + !(node.flags & 16777216 /* NodeFlags.Ambient */) && + !(node.flags & 8388608 /* NodeFlags.JSDoc */) && + !ts.isIdentifierName(node)) { + // strict mode identifiers + if (inStrictMode && + node.originalKeywordKind >= 117 /* SyntaxKind.FirstFutureReservedWord */ && + node.originalKeywordKind <= 125 /* SyntaxKind.LastFutureReservedWord */) { + file.bindDiagnostics.push(createDiagnosticForNode(node, getStrictModeIdentifierMessage(node), ts.declarationNameToString(node))); + } + else if (node.originalKeywordKind === 133 /* SyntaxKind.AwaitKeyword */) { + if (ts.isExternalModule(file) && ts.isInTopLevelContext(node)) { + file.bindDiagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module, ts.declarationNameToString(node))); + } + else if (node.flags & 32768 /* NodeFlags.AwaitContext */) { + file.bindDiagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here, ts.declarationNameToString(node))); + } + } + else if (node.originalKeywordKind === 125 /* SyntaxKind.YieldKeyword */ && node.flags & 8192 /* NodeFlags.YieldContext */) { + file.bindDiagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here, ts.declarationNameToString(node))); + } + } + } + function getStrictModeIdentifierMessage(node) { + // Provide specialized messages to help the user understand why we think they're in + // strict mode. + if (ts.getContainingClass(node)) { + return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode; + } + if (file.externalModuleIndicator) { + return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode; + } + return ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode; + } + // The binder visits every node, so this is a good place to check for + // the reserved private name (there is only one) + function checkPrivateIdentifier(node) { + if (node.escapedText === "#constructor") { + // Report error only if there are no parse errors in file + if (!file.parseDiagnostics.length) { + file.bindDiagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.constructor_is_a_reserved_word, ts.declarationNameToString(node))); + } + } + } + function checkStrictModeBinaryExpression(node) { + if (inStrictMode && ts.isLeftHandSideExpression(node.left) && ts.isAssignmentOperator(node.operatorToken.kind)) { + // ECMA 262 (Annex C) The identifier eval or arguments may not appear as the LeftHandSideExpression of an + // Assignment operator(11.13) or of a PostfixExpression(11.3) + checkStrictModeEvalOrArguments(node, node.left); + } + } + function checkStrictModeCatchClause(node) { + // It is a SyntaxError if a TryStatement with a Catch occurs within strict code and the Identifier of the + // Catch production is eval or arguments + if (inStrictMode && node.variableDeclaration) { + checkStrictModeEvalOrArguments(node, node.variableDeclaration.name); + } + } + function checkStrictModeDeleteExpression(node) { + // Grammar checking + if (inStrictMode && node.expression.kind === 79 /* SyntaxKind.Identifier */) { + // When a delete operator occurs within strict mode code, a SyntaxError is thrown if its + // UnaryExpression is a direct reference to a variable, function argument, or function name + var span = ts.getErrorSpanForNode(file, node.expression); + file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, ts.Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode)); + } + } + function isEvalOrArgumentsIdentifier(node) { + return ts.isIdentifier(node) && (node.escapedText === "eval" || node.escapedText === "arguments"); + } + function checkStrictModeEvalOrArguments(contextNode, name) { + if (name && name.kind === 79 /* SyntaxKind.Identifier */) { + var identifier = name; + if (isEvalOrArgumentsIdentifier(identifier)) { + // We check first if the name is inside class declaration or class expression; if so give explicit message + // otherwise report generic error message. + var span = ts.getErrorSpanForNode(file, name); + file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, getStrictModeEvalOrArgumentsMessage(contextNode), ts.idText(identifier))); + } + } + } + function getStrictModeEvalOrArgumentsMessage(node) { + // Provide specialized messages to help the user understand why we think they're in + // strict mode. + if (ts.getContainingClass(node)) { + return ts.Diagnostics.Code_contained_in_a_class_is_evaluated_in_JavaScript_s_strict_mode_which_does_not_allow_this_use_of_0_For_more_information_see_https_Colon_Slash_Slashdeveloper_mozilla_org_Slashen_US_Slashdocs_SlashWeb_SlashJavaScript_SlashReference_SlashStrict_mode; + } + if (file.externalModuleIndicator) { + return ts.Diagnostics.Invalid_use_of_0_Modules_are_automatically_in_strict_mode; + } + return ts.Diagnostics.Invalid_use_of_0_in_strict_mode; + } + function checkStrictModeFunctionName(node) { + if (inStrictMode) { + // It is a SyntaxError if the identifier eval or arguments appears within a FormalParameterList of a strict mode FunctionDeclaration or FunctionExpression (13.1)) + checkStrictModeEvalOrArguments(node, node.name); + } + } + function getStrictModeBlockScopeFunctionDeclarationMessage(node) { + // Provide specialized messages to help the user understand why we think they're in + // strict mode. + if (ts.getContainingClass(node)) { + return ts.Diagnostics.Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Class_definitions_are_automatically_in_strict_mode; + } + if (file.externalModuleIndicator) { + return ts.Diagnostics.Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Modules_are_automatically_in_strict_mode; + } + return ts.Diagnostics.Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5; + } + function checkStrictModeFunctionDeclaration(node) { + if (languageVersion < 2 /* ScriptTarget.ES2015 */) { + // Report error if function is not top level function declaration + if (blockScopeContainer.kind !== 308 /* SyntaxKind.SourceFile */ && + blockScopeContainer.kind !== 264 /* SyntaxKind.ModuleDeclaration */ && + !ts.isFunctionLikeOrClassStaticBlockDeclaration(blockScopeContainer)) { + // We check first if the name is inside class declaration or class expression; if so give explicit message + // otherwise report generic error message. + var errorSpan = ts.getErrorSpanForNode(file, node); + file.bindDiagnostics.push(ts.createFileDiagnostic(file, errorSpan.start, errorSpan.length, getStrictModeBlockScopeFunctionDeclarationMessage(node))); + } + } + } + function checkStrictModeNumericLiteral(node) { + if (languageVersion < 1 /* ScriptTarget.ES5 */ && inStrictMode && node.numericLiteralFlags & 32 /* TokenFlags.Octal */) { + file.bindDiagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.Octal_literals_are_not_allowed_in_strict_mode)); + } + } + function checkStrictModePostfixUnaryExpression(node) { + // Grammar checking + // The identifier eval or arguments may not appear as the LeftHandSideExpression of an + // Assignment operator(11.13) or of a PostfixExpression(11.3) or as the UnaryExpression + // operated upon by a Prefix Increment(11.4.4) or a Prefix Decrement(11.4.5) operator. + if (inStrictMode) { + checkStrictModeEvalOrArguments(node, node.operand); + } + } + function checkStrictModePrefixUnaryExpression(node) { + // Grammar checking + if (inStrictMode) { + if (node.operator === 45 /* SyntaxKind.PlusPlusToken */ || node.operator === 46 /* SyntaxKind.MinusMinusToken */) { + checkStrictModeEvalOrArguments(node, node.operand); + } + } + } + function checkStrictModeWithStatement(node) { + // Grammar checking for withStatement + if (inStrictMode) { + errorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_strict_mode); + } + } + function checkStrictModeLabeledStatement(node) { + // Grammar checking for labeledStatement + if (inStrictMode && ts.getEmitScriptTarget(options) >= 2 /* ScriptTarget.ES2015 */) { + if (ts.isDeclarationStatement(node.statement) || ts.isVariableStatement(node.statement)) { + errorOnFirstToken(node.label, ts.Diagnostics.A_label_is_not_allowed_here); + } + } + } + function errorOnFirstToken(node, message, arg0, arg1, arg2) { + var span = ts.getSpanOfTokenAtPosition(file, node.pos); + file.bindDiagnostics.push(ts.createFileDiagnostic(file, span.start, span.length, message, arg0, arg1, arg2)); + } + function errorOrSuggestionOnNode(isError, node, message) { + errorOrSuggestionOnRange(isError, node, node, message); + } + function errorOrSuggestionOnRange(isError, startNode, endNode, message) { + addErrorOrSuggestionDiagnostic(isError, { pos: ts.getTokenPosOfNode(startNode, file), end: endNode.end }, message); + } + function addErrorOrSuggestionDiagnostic(isError, range, message) { + var diag = ts.createFileDiagnostic(file, range.pos, range.end - range.pos, message); + if (isError) { + file.bindDiagnostics.push(diag); + } + else { + file.bindSuggestionDiagnostics = ts.append(file.bindSuggestionDiagnostics, __assign(__assign({}, diag), { category: ts.DiagnosticCategory.Suggestion })); + } + } + function bind(node) { + if (!node) { + return; + } + ts.setParent(node, parent); + if (ts.tracing) + node.tracingPath = file.path; + var saveInStrictMode = inStrictMode; + // Even though in the AST the jsdoc @typedef node belongs to the current node, + // its symbol might be in the same scope with the current node's symbol. Consider: + // + // /** @typedef {string | number} MyType */ + // function foo(); + // + // Here the current node is "foo", which is a container, but the scope of "MyType" should + // not be inside "foo". Therefore we always bind @typedef before bind the parent node, + // and skip binding this tag later when binding all the other jsdoc tags. + // First we bind declaration nodes to a symbol if possible. We'll both create a symbol + // and then potentially add the symbol to an appropriate symbol table. Possible + // destination symbol tables are: + // + // 1) The 'exports' table of the current container's symbol. + // 2) The 'members' table of the current container's symbol. + // 3) The 'locals' table of the current container. + // + // However, not all symbols will end up in any of these tables. 'Anonymous' symbols + // (like TypeLiterals for example) will not be put in any table. + bindWorker(node); + // Then we recurse into the children of the node to bind them as well. For certain + // symbols we do specialized work when we recurse. For example, we'll keep track of + // the current 'container' node when it changes. This helps us know which symbol table + // a local should go into for example. Since terminal nodes are known not to have + // children, as an optimization we don't process those. + if (node.kind > 162 /* SyntaxKind.LastToken */) { + var saveParent = parent; + parent = node; + var containerFlags = getContainerFlags(node); + if (containerFlags === 0 /* ContainerFlags.None */) { + bindChildren(node); + } + else { + bindContainer(node, containerFlags); + } + parent = saveParent; + } + else { + var saveParent = parent; + if (node.kind === 1 /* SyntaxKind.EndOfFileToken */) + parent = node; + bindJSDoc(node); + parent = saveParent; + } + inStrictMode = saveInStrictMode; + } + function bindJSDoc(node) { + if (ts.hasJSDocNodes(node)) { + if (ts.isInJSFile(node)) { + for (var _i = 0, _a = node.jsDoc; _i < _a.length; _i++) { + var j = _a[_i]; + bind(j); + } + } + else { + for (var _b = 0, _c = node.jsDoc; _b < _c.length; _b++) { + var j = _c[_b]; + ts.setParent(j, node); + ts.setParentRecursive(j, /*incremental*/ false); + } + } + } + } + function updateStrictModeStatementList(statements) { + if (!inStrictMode) { + for (var _i = 0, statements_3 = statements; _i < statements_3.length; _i++) { + var statement = statements_3[_i]; + if (!ts.isPrologueDirective(statement)) { + return; + } + if (isUseStrictPrologueDirective(statement)) { + inStrictMode = true; + return; + } + } + } + } + /// Should be called only on prologue directives (isPrologueDirective(node) should be true) + function isUseStrictPrologueDirective(node) { + var nodeText = ts.getSourceTextOfNodeFromSourceFile(file, node.expression); + // Note: the node text must be exactly "use strict" or 'use strict'. It is not ok for the + // string to contain unicode escapes (as per ES5). + return nodeText === '"use strict"' || nodeText === "'use strict'"; + } + function bindWorker(node) { + switch (node.kind) { + /* Strict mode checks */ + case 79 /* SyntaxKind.Identifier */: + // for typedef type names with namespaces, bind the new jsdoc type symbol here + // because it requires all containing namespaces to be in effect, namely the + // current "blockScopeContainer" needs to be set to its immediate namespace parent. + if (node.isInJSDocNamespace) { + var parentNode = node.parent; + while (parentNode && !ts.isJSDocTypeAlias(parentNode)) { + parentNode = parentNode.parent; + } + bindBlockScopedDeclaration(parentNode, 524288 /* SymbolFlags.TypeAlias */, 788968 /* SymbolFlags.TypeAliasExcludes */); + break; + } + // falls through + case 108 /* SyntaxKind.ThisKeyword */: + if (currentFlow && (ts.isExpression(node) || parent.kind === 300 /* SyntaxKind.ShorthandPropertyAssignment */)) { + node.flowNode = currentFlow; + } + return checkContextualIdentifier(node); + case 163 /* SyntaxKind.QualifiedName */: + if (currentFlow && ts.isPartOfTypeQuery(node)) { + node.flowNode = currentFlow; + } + break; + case 233 /* SyntaxKind.MetaProperty */: + case 106 /* SyntaxKind.SuperKeyword */: + node.flowNode = currentFlow; + break; + case 80 /* SyntaxKind.PrivateIdentifier */: + return checkPrivateIdentifier(node); + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 209 /* SyntaxKind.ElementAccessExpression */: + var expr = node; + if (currentFlow && isNarrowableReference(expr)) { + expr.flowNode = currentFlow; + } + if (ts.isSpecialPropertyDeclaration(expr)) { + bindSpecialPropertyDeclaration(expr); + } + if (ts.isInJSFile(expr) && + file.commonJsModuleIndicator && + ts.isModuleExportsAccessExpression(expr) && + !lookupSymbolForName(blockScopeContainer, "module")) { + declareSymbol(file.locals, /*parent*/ undefined, expr.expression, 1 /* SymbolFlags.FunctionScopedVariable */ | 134217728 /* SymbolFlags.ModuleExports */, 111550 /* SymbolFlags.FunctionScopedVariableExcludes */); + } + break; + case 223 /* SyntaxKind.BinaryExpression */: + var specialKind = ts.getAssignmentDeclarationKind(node); + switch (specialKind) { + case 1 /* AssignmentDeclarationKind.ExportsProperty */: + bindExportsPropertyAssignment(node); + break; + case 2 /* AssignmentDeclarationKind.ModuleExports */: + bindModuleExportsAssignment(node); + break; + case 3 /* AssignmentDeclarationKind.PrototypeProperty */: + bindPrototypePropertyAssignment(node.left, node); + break; + case 6 /* AssignmentDeclarationKind.Prototype */: + bindPrototypeAssignment(node); + break; + case 4 /* AssignmentDeclarationKind.ThisProperty */: + bindThisPropertyAssignment(node); + break; + case 5 /* AssignmentDeclarationKind.Property */: + var expression = node.left.expression; + if (ts.isInJSFile(node) && ts.isIdentifier(expression)) { + var symbol = lookupSymbolForName(blockScopeContainer, expression.escapedText); + if (ts.isThisInitializedDeclaration(symbol === null || symbol === void 0 ? void 0 : symbol.valueDeclaration)) { + bindThisPropertyAssignment(node); + break; + } + } + bindSpecialPropertyAssignment(node); + break; + case 0 /* AssignmentDeclarationKind.None */: + // Nothing to do + break; + default: + ts.Debug.fail("Unknown binary expression special property assignment kind"); + } + return checkStrictModeBinaryExpression(node); + case 295 /* SyntaxKind.CatchClause */: + return checkStrictModeCatchClause(node); + case 217 /* SyntaxKind.DeleteExpression */: + return checkStrictModeDeleteExpression(node); + case 8 /* SyntaxKind.NumericLiteral */: + return checkStrictModeNumericLiteral(node); + case 222 /* SyntaxKind.PostfixUnaryExpression */: + return checkStrictModePostfixUnaryExpression(node); + case 221 /* SyntaxKind.PrefixUnaryExpression */: + return checkStrictModePrefixUnaryExpression(node); + case 251 /* SyntaxKind.WithStatement */: + return checkStrictModeWithStatement(node); + case 253 /* SyntaxKind.LabeledStatement */: + return checkStrictModeLabeledStatement(node); + case 194 /* SyntaxKind.ThisType */: + seenThisKeyword = true; + return; + case 179 /* SyntaxKind.TypePredicate */: + break; // Binding the children will handle everything + case 165 /* SyntaxKind.TypeParameter */: + return bindTypeParameter(node); + case 166 /* SyntaxKind.Parameter */: + return bindParameter(node); + case 257 /* SyntaxKind.VariableDeclaration */: + return bindVariableDeclarationOrBindingElement(node); + case 205 /* SyntaxKind.BindingElement */: + node.flowNode = currentFlow; + return bindVariableDeclarationOrBindingElement(node); + case 169 /* SyntaxKind.PropertyDeclaration */: + case 168 /* SyntaxKind.PropertySignature */: + return bindPropertyWorker(node); + case 299 /* SyntaxKind.PropertyAssignment */: + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + return bindPropertyOrMethodOrAccessor(node, 4 /* SymbolFlags.Property */, 0 /* SymbolFlags.PropertyExcludes */); + case 302 /* SyntaxKind.EnumMember */: + return bindPropertyOrMethodOrAccessor(node, 8 /* SymbolFlags.EnumMember */, 900095 /* SymbolFlags.EnumMemberExcludes */); + case 176 /* SyntaxKind.CallSignature */: + case 177 /* SyntaxKind.ConstructSignature */: + case 178 /* SyntaxKind.IndexSignature */: + return declareSymbolAndAddToSymbolTable(node, 131072 /* SymbolFlags.Signature */, 0 /* SymbolFlags.None */); + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + // If this is an ObjectLiteralExpression method, then it sits in the same space + // as other properties in the object literal. So we use SymbolFlags.PropertyExcludes + // so that it will conflict with any other object literal members with the same + // name. + return bindPropertyOrMethodOrAccessor(node, 8192 /* SymbolFlags.Method */ | (node.questionToken ? 16777216 /* SymbolFlags.Optional */ : 0 /* SymbolFlags.None */), ts.isObjectLiteralMethod(node) ? 0 /* SymbolFlags.PropertyExcludes */ : 103359 /* SymbolFlags.MethodExcludes */); + case 259 /* SyntaxKind.FunctionDeclaration */: + return bindFunctionDeclaration(node); + case 173 /* SyntaxKind.Constructor */: + return declareSymbolAndAddToSymbolTable(node, 16384 /* SymbolFlags.Constructor */, /*symbolExcludes:*/ 0 /* SymbolFlags.None */); + case 174 /* SyntaxKind.GetAccessor */: + return bindPropertyOrMethodOrAccessor(node, 32768 /* SymbolFlags.GetAccessor */, 46015 /* SymbolFlags.GetAccessorExcludes */); + case 175 /* SyntaxKind.SetAccessor */: + return bindPropertyOrMethodOrAccessor(node, 65536 /* SymbolFlags.SetAccessor */, 78783 /* SymbolFlags.SetAccessorExcludes */); + case 181 /* SyntaxKind.FunctionType */: + case 320 /* SyntaxKind.JSDocFunctionType */: + case 326 /* SyntaxKind.JSDocSignature */: + case 182 /* SyntaxKind.ConstructorType */: + return bindFunctionOrConstructorType(node); + case 184 /* SyntaxKind.TypeLiteral */: + case 325 /* SyntaxKind.JSDocTypeLiteral */: + case 197 /* SyntaxKind.MappedType */: + return bindAnonymousTypeWorker(node); + case 335 /* SyntaxKind.JSDocClassTag */: + return bindJSDocClassTag(node); + case 207 /* SyntaxKind.ObjectLiteralExpression */: + return bindObjectLiteralExpression(node); + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + return bindFunctionExpression(node); + case 210 /* SyntaxKind.CallExpression */: + var assignmentKind = ts.getAssignmentDeclarationKind(node); + switch (assignmentKind) { + case 7 /* AssignmentDeclarationKind.ObjectDefinePropertyValue */: + return bindObjectDefinePropertyAssignment(node); + case 8 /* AssignmentDeclarationKind.ObjectDefinePropertyExports */: + return bindObjectDefinePropertyExport(node); + case 9 /* AssignmentDeclarationKind.ObjectDefinePrototypeProperty */: + return bindObjectDefinePrototypeProperty(node); + case 0 /* AssignmentDeclarationKind.None */: + break; // Nothing to do + default: + return ts.Debug.fail("Unknown call expression assignment declaration kind"); + } + if (ts.isInJSFile(node)) { + bindCallExpression(node); + } + break; + // Members of classes, interfaces, and modules + case 228 /* SyntaxKind.ClassExpression */: + case 260 /* SyntaxKind.ClassDeclaration */: + // All classes are automatically in strict mode in ES6. + inStrictMode = true; + return bindClassLikeDeclaration(node); + case 261 /* SyntaxKind.InterfaceDeclaration */: + return bindBlockScopedDeclaration(node, 64 /* SymbolFlags.Interface */, 788872 /* SymbolFlags.InterfaceExcludes */); + case 262 /* SyntaxKind.TypeAliasDeclaration */: + return bindBlockScopedDeclaration(node, 524288 /* SymbolFlags.TypeAlias */, 788968 /* SymbolFlags.TypeAliasExcludes */); + case 263 /* SyntaxKind.EnumDeclaration */: + return bindEnumDeclaration(node); + case 264 /* SyntaxKind.ModuleDeclaration */: + return bindModuleDeclaration(node); + // Jsx-attributes + case 289 /* SyntaxKind.JsxAttributes */: + return bindJsxAttributes(node); + case 288 /* SyntaxKind.JsxAttribute */: + return bindJsxAttribute(node, 4 /* SymbolFlags.Property */, 0 /* SymbolFlags.PropertyExcludes */); + // Imports and exports + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + case 271 /* SyntaxKind.NamespaceImport */: + case 273 /* SyntaxKind.ImportSpecifier */: + case 278 /* SyntaxKind.ExportSpecifier */: + return declareSymbolAndAddToSymbolTable(node, 2097152 /* SymbolFlags.Alias */, 2097152 /* SymbolFlags.AliasExcludes */); + case 267 /* SyntaxKind.NamespaceExportDeclaration */: + return bindNamespaceExportDeclaration(node); + case 270 /* SyntaxKind.ImportClause */: + return bindImportClause(node); + case 275 /* SyntaxKind.ExportDeclaration */: + return bindExportDeclaration(node); + case 274 /* SyntaxKind.ExportAssignment */: + return bindExportAssignment(node); + case 308 /* SyntaxKind.SourceFile */: + updateStrictModeStatementList(node.statements); + return bindSourceFileIfExternalModule(); + case 238 /* SyntaxKind.Block */: + if (!ts.isFunctionLikeOrClassStaticBlockDeclaration(node.parent)) { + return; + } + // falls through + case 265 /* SyntaxKind.ModuleBlock */: + return updateStrictModeStatementList(node.statements); + case 343 /* SyntaxKind.JSDocParameterTag */: + if (node.parent.kind === 326 /* SyntaxKind.JSDocSignature */) { + return bindParameter(node); + } + if (node.parent.kind !== 325 /* SyntaxKind.JSDocTypeLiteral */) { + break; + } + // falls through + case 350 /* SyntaxKind.JSDocPropertyTag */: + var propTag = node; + var flags = propTag.isBracketed || propTag.typeExpression && propTag.typeExpression.type.kind === 319 /* SyntaxKind.JSDocOptionalType */ ? + 4 /* SymbolFlags.Property */ | 16777216 /* SymbolFlags.Optional */ : + 4 /* SymbolFlags.Property */; + return declareSymbolAndAddToSymbolTable(propTag, flags, 0 /* SymbolFlags.PropertyExcludes */); + case 348 /* SyntaxKind.JSDocTypedefTag */: + case 341 /* SyntaxKind.JSDocCallbackTag */: + case 342 /* SyntaxKind.JSDocEnumTag */: + return (delayedTypeAliases || (delayedTypeAliases = [])).push(node); + } + } + function bindPropertyWorker(node) { + var isAutoAccessor = ts.isAutoAccessorPropertyDeclaration(node); + var includes = isAutoAccessor ? 98304 /* SymbolFlags.Accessor */ : 4 /* SymbolFlags.Property */; + var excludes = isAutoAccessor ? 13247 /* SymbolFlags.AccessorExcludes */ : 0 /* SymbolFlags.PropertyExcludes */; + return bindPropertyOrMethodOrAccessor(node, includes | (node.questionToken ? 16777216 /* SymbolFlags.Optional */ : 0 /* SymbolFlags.None */), excludes); + } + function bindAnonymousTypeWorker(node) { + return bindAnonymousDeclaration(node, 2048 /* SymbolFlags.TypeLiteral */, "__type" /* InternalSymbolName.Type */); + } + function bindSourceFileIfExternalModule() { + setExportContextFlag(file); + if (ts.isExternalModule(file)) { + bindSourceFileAsExternalModule(); + } + else if (ts.isJsonSourceFile(file)) { + bindSourceFileAsExternalModule(); + // Create symbol equivalent for the module.exports = {} + var originalSymbol = file.symbol; + declareSymbol(file.symbol.exports, file.symbol, file, 4 /* SymbolFlags.Property */, 67108863 /* SymbolFlags.All */); + file.symbol = originalSymbol; + } + } + function bindSourceFileAsExternalModule() { + bindAnonymousDeclaration(file, 512 /* SymbolFlags.ValueModule */, "\"".concat(ts.removeFileExtension(file.fileName), "\"")); + } + function bindExportAssignment(node) { + if (!container.symbol || !container.symbol.exports) { + // Incorrect export assignment in some sort of block construct + bindAnonymousDeclaration(node, 111551 /* SymbolFlags.Value */, getDeclarationName(node)); + } + else { + var flags = ts.exportAssignmentIsAlias(node) + // An export default clause with an EntityNameExpression or a class expression exports all meanings of that identifier or expression; + ? 2097152 /* SymbolFlags.Alias */ + // An export default clause with any other expression exports a value + : 4 /* SymbolFlags.Property */; + // If there is an `export default x;` alias declaration, can't `export default` anything else. + // (In contrast, you can still have `export default function f() {}` and `export default interface I {}`.) + var symbol = declareSymbol(container.symbol.exports, container.symbol, node, flags, 67108863 /* SymbolFlags.All */); + if (node.isExportEquals) { + // Will be an error later, since the module already has other exports. Just make sure this has a valueDeclaration set. + ts.setValueDeclaration(symbol, node); + } + } + } + function bindNamespaceExportDeclaration(node) { + if (ts.some(node.modifiers)) { + file.bindDiagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.Modifiers_cannot_appear_here)); + } + var diag = !ts.isSourceFile(node.parent) ? ts.Diagnostics.Global_module_exports_may_only_appear_at_top_level + : !ts.isExternalModule(node.parent) ? ts.Diagnostics.Global_module_exports_may_only_appear_in_module_files + : !node.parent.isDeclarationFile ? ts.Diagnostics.Global_module_exports_may_only_appear_in_declaration_files + : undefined; + if (diag) { + file.bindDiagnostics.push(createDiagnosticForNode(node, diag)); + } + else { + file.symbol.globalExports = file.symbol.globalExports || ts.createSymbolTable(); + declareSymbol(file.symbol.globalExports, file.symbol, node, 2097152 /* SymbolFlags.Alias */, 2097152 /* SymbolFlags.AliasExcludes */); + } + } + function bindExportDeclaration(node) { + if (!container.symbol || !container.symbol.exports) { + // Export * in some sort of block construct + bindAnonymousDeclaration(node, 8388608 /* SymbolFlags.ExportStar */, getDeclarationName(node)); + } + else if (!node.exportClause) { + // All export * declarations are collected in an __export symbol + declareSymbol(container.symbol.exports, container.symbol, node, 8388608 /* SymbolFlags.ExportStar */, 0 /* SymbolFlags.None */); + } + else if (ts.isNamespaceExport(node.exportClause)) { + // declareSymbol walks up parents to find name text, parent _must_ be set + // but won't be set by the normal binder walk until `bindChildren` later on. + ts.setParent(node.exportClause, node); + declareSymbol(container.symbol.exports, container.symbol, node.exportClause, 2097152 /* SymbolFlags.Alias */, 2097152 /* SymbolFlags.AliasExcludes */); + } + } + function bindImportClause(node) { + if (node.name) { + declareSymbolAndAddToSymbolTable(node, 2097152 /* SymbolFlags.Alias */, 2097152 /* SymbolFlags.AliasExcludes */); + } + } + function setCommonJsModuleIndicator(node) { + if (file.externalModuleIndicator && file.externalModuleIndicator !== true) { + return false; + } + if (!file.commonJsModuleIndicator) { + file.commonJsModuleIndicator = node; + if (!file.externalModuleIndicator) { + bindSourceFileAsExternalModule(); + } + } + return true; + } + function bindObjectDefinePropertyExport(node) { + if (!setCommonJsModuleIndicator(node)) { + return; + } + var symbol = forEachIdentifierInEntityName(node.arguments[0], /*parent*/ undefined, function (id, symbol) { + if (symbol) { + addDeclarationToSymbol(symbol, id, 1536 /* SymbolFlags.Module */ | 67108864 /* SymbolFlags.Assignment */); + } + return symbol; + }); + if (symbol) { + var flags = 4 /* SymbolFlags.Property */ | 1048576 /* SymbolFlags.ExportValue */; + declareSymbol(symbol.exports, symbol, node, flags, 0 /* SymbolFlags.None */); + } + } + function bindExportsPropertyAssignment(node) { + // When we create a property via 'exports.foo = bar', the 'exports.foo' property access + // expression is the declaration + if (!setCommonJsModuleIndicator(node)) { + return; + } + var symbol = forEachIdentifierInEntityName(node.left.expression, /*parent*/ undefined, function (id, symbol) { + if (symbol) { + addDeclarationToSymbol(symbol, id, 1536 /* SymbolFlags.Module */ | 67108864 /* SymbolFlags.Assignment */); + } + return symbol; + }); + if (symbol) { + var isAlias = ts.isAliasableExpression(node.right) && (ts.isExportsIdentifier(node.left.expression) || ts.isModuleExportsAccessExpression(node.left.expression)); + var flags = isAlias ? 2097152 /* SymbolFlags.Alias */ : 4 /* SymbolFlags.Property */ | 1048576 /* SymbolFlags.ExportValue */; + ts.setParent(node.left, node); + declareSymbol(symbol.exports, symbol, node.left, flags, 0 /* SymbolFlags.None */); + } + } + function bindModuleExportsAssignment(node) { + // A common practice in node modules is to set 'export = module.exports = {}', this ensures that 'exports' + // is still pointing to 'module.exports'. + // We do not want to consider this as 'export=' since a module can have only one of these. + // Similarly we do not want to treat 'module.exports = exports' as an 'export='. + if (!setCommonJsModuleIndicator(node)) { + return; + } + var assignedExpression = ts.getRightMostAssignedExpression(node.right); + if (ts.isEmptyObjectLiteral(assignedExpression) || container === file && isExportsOrModuleExportsOrAlias(file, assignedExpression)) { + return; + } + if (ts.isObjectLiteralExpression(assignedExpression) && ts.every(assignedExpression.properties, ts.isShorthandPropertyAssignment)) { + ts.forEach(assignedExpression.properties, bindExportAssignedObjectMemberAlias); + return; + } + // 'module.exports = expr' assignment + var flags = ts.exportAssignmentIsAlias(node) + ? 2097152 /* SymbolFlags.Alias */ + : 4 /* SymbolFlags.Property */ | 1048576 /* SymbolFlags.ExportValue */ | 512 /* SymbolFlags.ValueModule */; + var symbol = declareSymbol(file.symbol.exports, file.symbol, node, flags | 67108864 /* SymbolFlags.Assignment */, 0 /* SymbolFlags.None */); + ts.setValueDeclaration(symbol, node); + } + function bindExportAssignedObjectMemberAlias(node) { + declareSymbol(file.symbol.exports, file.symbol, node, 2097152 /* SymbolFlags.Alias */ | 67108864 /* SymbolFlags.Assignment */, 0 /* SymbolFlags.None */); + } + function bindThisPropertyAssignment(node) { + ts.Debug.assert(ts.isInJSFile(node)); + // private identifiers *must* be declared (even in JS files) + var hasPrivateIdentifier = (ts.isBinaryExpression(node) && ts.isPropertyAccessExpression(node.left) && ts.isPrivateIdentifier(node.left.name)) + || (ts.isPropertyAccessExpression(node) && ts.isPrivateIdentifier(node.name)); + if (hasPrivateIdentifier) { + return; + } + var thisContainer = ts.getThisContainer(node, /*includeArrowFunctions*/ false); + switch (thisContainer.kind) { + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + var constructorSymbol = thisContainer.symbol; + // For `f.prototype.m = function() { this.x = 0; }`, `this.x = 0` should modify `f`'s members, not the function expression. + if (ts.isBinaryExpression(thisContainer.parent) && thisContainer.parent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */) { + var l = thisContainer.parent.left; + if (ts.isBindableStaticAccessExpression(l) && ts.isPrototypeAccess(l.expression)) { + constructorSymbol = lookupSymbolForPropertyAccess(l.expression.expression, thisParentContainer); + } + } + if (constructorSymbol && constructorSymbol.valueDeclaration) { + // Declare a 'member' if the container is an ES5 class or ES6 constructor + constructorSymbol.members = constructorSymbol.members || ts.createSymbolTable(); + // It's acceptable for multiple 'this' assignments of the same identifier to occur + if (ts.hasDynamicName(node)) { + bindDynamicallyNamedThisPropertyAssignment(node, constructorSymbol, constructorSymbol.members); + } + else { + declareSymbol(constructorSymbol.members, constructorSymbol, node, 4 /* SymbolFlags.Property */ | 67108864 /* SymbolFlags.Assignment */, 0 /* SymbolFlags.PropertyExcludes */ & ~4 /* SymbolFlags.Property */); + } + addDeclarationToSymbol(constructorSymbol, constructorSymbol.valueDeclaration, 32 /* SymbolFlags.Class */); + } + break; + case 173 /* SyntaxKind.Constructor */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 172 /* SyntaxKind.ClassStaticBlockDeclaration */: + // this.foo assignment in a JavaScript class + // Bind this property to the containing class + var containingClass = thisContainer.parent; + var symbolTable = ts.isStatic(thisContainer) ? containingClass.symbol.exports : containingClass.symbol.members; + if (ts.hasDynamicName(node)) { + bindDynamicallyNamedThisPropertyAssignment(node, containingClass.symbol, symbolTable); + } + else { + declareSymbol(symbolTable, containingClass.symbol, node, 4 /* SymbolFlags.Property */ | 67108864 /* SymbolFlags.Assignment */, 0 /* SymbolFlags.None */, /*isReplaceableByMethod*/ true); + } + break; + case 308 /* SyntaxKind.SourceFile */: + // this.property = assignment in a source file -- declare symbol in exports for a module, in locals for a script + if (ts.hasDynamicName(node)) { + break; + } + else if (thisContainer.commonJsModuleIndicator) { + declareSymbol(thisContainer.symbol.exports, thisContainer.symbol, node, 4 /* SymbolFlags.Property */ | 1048576 /* SymbolFlags.ExportValue */, 0 /* SymbolFlags.None */); + } + else { + declareSymbolAndAddToSymbolTable(node, 1 /* SymbolFlags.FunctionScopedVariable */, 111550 /* SymbolFlags.FunctionScopedVariableExcludes */); + } + break; + default: + ts.Debug.failBadSyntaxKind(thisContainer); + } + } + function bindDynamicallyNamedThisPropertyAssignment(node, symbol, symbolTable) { + declareSymbol(symbolTable, symbol, node, 4 /* SymbolFlags.Property */, 0 /* SymbolFlags.None */, /*isReplaceableByMethod*/ true, /*isComputedName*/ true); + addLateBoundAssignmentDeclarationToSymbol(node, symbol); + } + function addLateBoundAssignmentDeclarationToSymbol(node, symbol) { + if (symbol) { + (symbol.assignmentDeclarationMembers || (symbol.assignmentDeclarationMembers = new ts.Map())).set(ts.getNodeId(node), node); + } + } + function bindSpecialPropertyDeclaration(node) { + if (node.expression.kind === 108 /* SyntaxKind.ThisKeyword */) { + bindThisPropertyAssignment(node); + } + else if (ts.isBindableStaticAccessExpression(node) && node.parent.parent.kind === 308 /* SyntaxKind.SourceFile */) { + if (ts.isPrototypeAccess(node.expression)) { + bindPrototypePropertyAssignment(node, node.parent); + } + else { + bindStaticPropertyAssignment(node); + } + } + } + /** For `x.prototype = { p, ... }`, declare members p,... if `x` is function/class/{}, or not declared. */ + function bindPrototypeAssignment(node) { + ts.setParent(node.left, node); + ts.setParent(node.right, node); + bindPropertyAssignment(node.left.expression, node.left, /*isPrototypeProperty*/ false, /*containerIsClass*/ true); + } + function bindObjectDefinePrototypeProperty(node) { + var namespaceSymbol = lookupSymbolForPropertyAccess(node.arguments[0].expression); + if (namespaceSymbol && namespaceSymbol.valueDeclaration) { + // Ensure the namespace symbol becomes class-like + addDeclarationToSymbol(namespaceSymbol, namespaceSymbol.valueDeclaration, 32 /* SymbolFlags.Class */); + } + bindPotentiallyNewExpandoMemberToNamespace(node, namespaceSymbol, /*isPrototypeProperty*/ true); + } + /** + * For `x.prototype.y = z`, declare a member `y` on `x` if `x` is a function or class, or not declared. + * Note that jsdoc preceding an ExpressionStatement like `x.prototype.y;` is also treated as a declaration. + */ + function bindPrototypePropertyAssignment(lhs, parent) { + // Look up the function in the local scope, since prototype assignments should + // follow the function declaration + var classPrototype = lhs.expression; + var constructorFunction = classPrototype.expression; + // Fix up parent pointers since we're going to use these nodes before we bind into them + ts.setParent(constructorFunction, classPrototype); + ts.setParent(classPrototype, lhs); + ts.setParent(lhs, parent); + bindPropertyAssignment(constructorFunction, lhs, /*isPrototypeProperty*/ true, /*containerIsClass*/ true); + } + function bindObjectDefinePropertyAssignment(node) { + var namespaceSymbol = lookupSymbolForPropertyAccess(node.arguments[0]); + var isToplevel = node.parent.parent.kind === 308 /* SyntaxKind.SourceFile */; + namespaceSymbol = bindPotentiallyMissingNamespaces(namespaceSymbol, node.arguments[0], isToplevel, /*isPrototypeProperty*/ false, /*containerIsClass*/ false); + bindPotentiallyNewExpandoMemberToNamespace(node, namespaceSymbol, /*isPrototypeProperty*/ false); + } + function bindSpecialPropertyAssignment(node) { + var _a; + // Class declarations in Typescript do not allow property declarations + var parentSymbol = lookupSymbolForPropertyAccess(node.left.expression, container) || lookupSymbolForPropertyAccess(node.left.expression, blockScopeContainer); + if (!ts.isInJSFile(node) && !ts.isFunctionSymbol(parentSymbol)) { + return; + } + var rootExpr = ts.getLeftmostAccessExpression(node.left); + if (ts.isIdentifier(rootExpr) && ((_a = lookupSymbolForName(container, rootExpr.escapedText)) === null || _a === void 0 ? void 0 : _a.flags) & 2097152 /* SymbolFlags.Alias */) { + return; + } + // Fix up parent pointers since we're going to use these nodes before we bind into them + ts.setParent(node.left, node); + ts.setParent(node.right, node); + if (ts.isIdentifier(node.left.expression) && container === file && isExportsOrModuleExportsOrAlias(file, node.left.expression)) { + // This can be an alias for the 'exports' or 'module.exports' names, e.g. + // var util = module.exports; + // util.property = function ... + bindExportsPropertyAssignment(node); + } + else if (ts.hasDynamicName(node)) { + bindAnonymousDeclaration(node, 4 /* SymbolFlags.Property */ | 67108864 /* SymbolFlags.Assignment */, "__computed" /* InternalSymbolName.Computed */); + var sym = bindPotentiallyMissingNamespaces(parentSymbol, node.left.expression, isTopLevelNamespaceAssignment(node.left), /*isPrototype*/ false, /*containerIsClass*/ false); + addLateBoundAssignmentDeclarationToSymbol(node, sym); + } + else { + bindStaticPropertyAssignment(ts.cast(node.left, ts.isBindableStaticNameExpression)); + } + } + /** + * For nodes like `x.y = z`, declare a member 'y' on 'x' if x is a function (or IIFE) or class or {}, or not declared. + * Also works for expression statements preceded by JSDoc, like / ** @type number * / x.y; + */ + function bindStaticPropertyAssignment(node) { + ts.Debug.assert(!ts.isIdentifier(node)); + ts.setParent(node.expression, node); + bindPropertyAssignment(node.expression, node, /*isPrototypeProperty*/ false, /*containerIsClass*/ false); + } + function bindPotentiallyMissingNamespaces(namespaceSymbol, entityName, isToplevel, isPrototypeProperty, containerIsClass) { + if ((namespaceSymbol === null || namespaceSymbol === void 0 ? void 0 : namespaceSymbol.flags) & 2097152 /* SymbolFlags.Alias */) { + return namespaceSymbol; + } + if (isToplevel && !isPrototypeProperty) { + // make symbols or add declarations for intermediate containers + var flags_2 = 1536 /* SymbolFlags.Module */ | 67108864 /* SymbolFlags.Assignment */; + var excludeFlags_1 = 110735 /* SymbolFlags.ValueModuleExcludes */ & ~67108864 /* SymbolFlags.Assignment */; + namespaceSymbol = forEachIdentifierInEntityName(entityName, namespaceSymbol, function (id, symbol, parent) { + if (symbol) { + addDeclarationToSymbol(symbol, id, flags_2); + return symbol; + } + else { + var table = parent ? parent.exports : + file.jsGlobalAugmentations || (file.jsGlobalAugmentations = ts.createSymbolTable()); + return declareSymbol(table, parent, id, flags_2, excludeFlags_1); + } + }); + } + if (containerIsClass && namespaceSymbol && namespaceSymbol.valueDeclaration) { + addDeclarationToSymbol(namespaceSymbol, namespaceSymbol.valueDeclaration, 32 /* SymbolFlags.Class */); + } + return namespaceSymbol; + } + function bindPotentiallyNewExpandoMemberToNamespace(declaration, namespaceSymbol, isPrototypeProperty) { + if (!namespaceSymbol || !isExpandoSymbol(namespaceSymbol)) { + return; + } + // Set up the members collection if it doesn't exist already + var symbolTable = isPrototypeProperty ? + (namespaceSymbol.members || (namespaceSymbol.members = ts.createSymbolTable())) : + (namespaceSymbol.exports || (namespaceSymbol.exports = ts.createSymbolTable())); + var includes = 0 /* SymbolFlags.None */; + var excludes = 0 /* SymbolFlags.None */; + // Method-like + if (ts.isFunctionLikeDeclaration(ts.getAssignedExpandoInitializer(declaration))) { + includes = 8192 /* SymbolFlags.Method */; + excludes = 103359 /* SymbolFlags.MethodExcludes */; + } + // Maybe accessor-like + else if (ts.isCallExpression(declaration) && ts.isBindableObjectDefinePropertyCall(declaration)) { + if (ts.some(declaration.arguments[2].properties, function (p) { + var id = ts.getNameOfDeclaration(p); + return !!id && ts.isIdentifier(id) && ts.idText(id) === "set"; + })) { + // We mix in `SymbolFLags.Property` so in the checker `getTypeOfVariableParameterOrProperty` is used for this + // symbol, instead of `getTypeOfAccessor` (which will assert as there is no real accessor declaration) + includes |= 65536 /* SymbolFlags.SetAccessor */ | 4 /* SymbolFlags.Property */; + excludes |= 78783 /* SymbolFlags.SetAccessorExcludes */; + } + if (ts.some(declaration.arguments[2].properties, function (p) { + var id = ts.getNameOfDeclaration(p); + return !!id && ts.isIdentifier(id) && ts.idText(id) === "get"; + })) { + includes |= 32768 /* SymbolFlags.GetAccessor */ | 4 /* SymbolFlags.Property */; + excludes |= 46015 /* SymbolFlags.GetAccessorExcludes */; + } + } + if (includes === 0 /* SymbolFlags.None */) { + includes = 4 /* SymbolFlags.Property */; + excludes = 0 /* SymbolFlags.PropertyExcludes */; + } + declareSymbol(symbolTable, namespaceSymbol, declaration, includes | 67108864 /* SymbolFlags.Assignment */, excludes & ~67108864 /* SymbolFlags.Assignment */); + } + function isTopLevelNamespaceAssignment(propertyAccess) { + return ts.isBinaryExpression(propertyAccess.parent) + ? getParentOfBinaryExpression(propertyAccess.parent).parent.kind === 308 /* SyntaxKind.SourceFile */ + : propertyAccess.parent.parent.kind === 308 /* SyntaxKind.SourceFile */; + } + function bindPropertyAssignment(name, propertyAccess, isPrototypeProperty, containerIsClass) { + var namespaceSymbol = lookupSymbolForPropertyAccess(name, container) || lookupSymbolForPropertyAccess(name, blockScopeContainer); + var isToplevel = isTopLevelNamespaceAssignment(propertyAccess); + namespaceSymbol = bindPotentiallyMissingNamespaces(namespaceSymbol, propertyAccess.expression, isToplevel, isPrototypeProperty, containerIsClass); + bindPotentiallyNewExpandoMemberToNamespace(propertyAccess, namespaceSymbol, isPrototypeProperty); + } + /** + * Javascript expando values are: + * - Functions + * - classes + * - namespaces + * - variables initialized with function expressions + * - with class expressions + * - with empty object literals + * - with non-empty object literals if assigned to the prototype property + */ + function isExpandoSymbol(symbol) { + if (symbol.flags & (16 /* SymbolFlags.Function */ | 32 /* SymbolFlags.Class */ | 1024 /* SymbolFlags.NamespaceModule */)) { + return true; + } + var node = symbol.valueDeclaration; + if (node && ts.isCallExpression(node)) { + return !!ts.getAssignedExpandoInitializer(node); + } + var init = !node ? undefined : + ts.isVariableDeclaration(node) ? node.initializer : + ts.isBinaryExpression(node) ? node.right : + ts.isPropertyAccessExpression(node) && ts.isBinaryExpression(node.parent) ? node.parent.right : + undefined; + init = init && ts.getRightMostAssignedExpression(init); + if (init) { + var isPrototypeAssignment = ts.isPrototypeAccess(ts.isVariableDeclaration(node) ? node.name : ts.isBinaryExpression(node) ? node.left : node); + return !!ts.getExpandoInitializer(ts.isBinaryExpression(init) && (init.operatorToken.kind === 56 /* SyntaxKind.BarBarToken */ || init.operatorToken.kind === 60 /* SyntaxKind.QuestionQuestionToken */) ? init.right : init, isPrototypeAssignment); + } + return false; + } + function getParentOfBinaryExpression(expr) { + while (ts.isBinaryExpression(expr.parent)) { + expr = expr.parent; + } + return expr.parent; + } + function lookupSymbolForPropertyAccess(node, lookupContainer) { + if (lookupContainer === void 0) { lookupContainer = container; } + if (ts.isIdentifier(node)) { + return lookupSymbolForName(lookupContainer, node.escapedText); + } + else { + var symbol = lookupSymbolForPropertyAccess(node.expression); + return symbol && symbol.exports && symbol.exports.get(ts.getElementOrPropertyAccessName(node)); + } + } + function forEachIdentifierInEntityName(e, parent, action) { + if (isExportsOrModuleExportsOrAlias(file, e)) { + return file.symbol; + } + else if (ts.isIdentifier(e)) { + return action(e, lookupSymbolForPropertyAccess(e), parent); + } + else { + var s = forEachIdentifierInEntityName(e.expression, parent, action); + var name = ts.getNameOrArgument(e); + // unreachable + if (ts.isPrivateIdentifier(name)) { + ts.Debug.fail("unexpected PrivateIdentifier"); + } + return action(name, s && s.exports && s.exports.get(ts.getElementOrPropertyAccessName(e)), s); + } + } + function bindCallExpression(node) { + // We're only inspecting call expressions to detect CommonJS modules, so we can skip + // this check if we've already seen the module indicator + if (!file.commonJsModuleIndicator && ts.isRequireCall(node, /*checkArgumentIsStringLiteralLike*/ false)) { + setCommonJsModuleIndicator(node); + } + } + function bindClassLikeDeclaration(node) { + if (node.kind === 260 /* SyntaxKind.ClassDeclaration */) { + bindBlockScopedDeclaration(node, 32 /* SymbolFlags.Class */, 899503 /* SymbolFlags.ClassExcludes */); + } + else { + var bindingName = node.name ? node.name.escapedText : "__class" /* InternalSymbolName.Class */; + bindAnonymousDeclaration(node, 32 /* SymbolFlags.Class */, bindingName); + // Add name of class expression into the map for semantic classifier + if (node.name) { + classifiableNames.add(node.name.escapedText); + } + } + var symbol = node.symbol; + // TypeScript 1.0 spec (April 2014): 8.4 + // Every class automatically contains a static property member named 'prototype', the + // type of which is an instantiation of the class type with type Any supplied as a type + // argument for each type parameter. It is an error to explicitly declare a static + // property member with the name 'prototype'. + // + // Note: we check for this here because this class may be merging into a module. The + // module might have an exported variable called 'prototype'. We can't allow that as + // that would clash with the built-in 'prototype' for the class. + var prototypeSymbol = createSymbol(4 /* SymbolFlags.Property */ | 4194304 /* SymbolFlags.Prototype */, "prototype"); + var symbolExport = symbol.exports.get(prototypeSymbol.escapedName); + if (symbolExport) { + if (node.name) { + ts.setParent(node.name, node); + } + file.bindDiagnostics.push(createDiagnosticForNode(symbolExport.declarations[0], ts.Diagnostics.Duplicate_identifier_0, ts.symbolName(prototypeSymbol))); + } + symbol.exports.set(prototypeSymbol.escapedName, prototypeSymbol); + prototypeSymbol.parent = symbol; + } + function bindEnumDeclaration(node) { + return ts.isEnumConst(node) + ? bindBlockScopedDeclaration(node, 128 /* SymbolFlags.ConstEnum */, 899967 /* SymbolFlags.ConstEnumExcludes */) + : bindBlockScopedDeclaration(node, 256 /* SymbolFlags.RegularEnum */, 899327 /* SymbolFlags.RegularEnumExcludes */); + } + function bindVariableDeclarationOrBindingElement(node) { + if (inStrictMode) { + checkStrictModeEvalOrArguments(node, node.name); + } + if (!ts.isBindingPattern(node.name)) { + var possibleVariableDecl = node.kind === 257 /* SyntaxKind.VariableDeclaration */ ? node : node.parent.parent; + if (ts.isInJSFile(node) && + ts.isVariableDeclarationInitializedToBareOrAccessedRequire(possibleVariableDecl) && + !ts.getJSDocTypeTag(node) && + !(ts.getCombinedModifierFlags(node) & 1 /* ModifierFlags.Export */)) { + declareSymbolAndAddToSymbolTable(node, 2097152 /* SymbolFlags.Alias */, 2097152 /* SymbolFlags.AliasExcludes */); + } + else if (ts.isBlockOrCatchScoped(node)) { + bindBlockScopedDeclaration(node, 2 /* SymbolFlags.BlockScopedVariable */, 111551 /* SymbolFlags.BlockScopedVariableExcludes */); + } + else if (ts.isParameterDeclaration(node)) { + // It is safe to walk up parent chain to find whether the node is a destructuring parameter declaration + // because its parent chain has already been set up, since parents are set before descending into children. + // + // If node is a binding element in parameter declaration, we need to use ParameterExcludes. + // Using ParameterExcludes flag allows the compiler to report an error on duplicate identifiers in Parameter Declaration + // For example: + // function foo([a,a]) {} // Duplicate Identifier error + // function bar(a,a) {} // Duplicate Identifier error, parameter declaration in this case is handled in bindParameter + // // which correctly set excluded symbols + declareSymbolAndAddToSymbolTable(node, 1 /* SymbolFlags.FunctionScopedVariable */, 111551 /* SymbolFlags.ParameterExcludes */); + } + else { + declareSymbolAndAddToSymbolTable(node, 1 /* SymbolFlags.FunctionScopedVariable */, 111550 /* SymbolFlags.FunctionScopedVariableExcludes */); + } + } + } + function bindParameter(node) { + if (node.kind === 343 /* SyntaxKind.JSDocParameterTag */ && container.kind !== 326 /* SyntaxKind.JSDocSignature */) { + return; + } + if (inStrictMode && !(node.flags & 16777216 /* NodeFlags.Ambient */)) { + // It is a SyntaxError if the identifier eval or arguments appears within a FormalParameterList of a + // strict mode FunctionLikeDeclaration or FunctionExpression(13.1) + checkStrictModeEvalOrArguments(node, node.name); + } + if (ts.isBindingPattern(node.name)) { + bindAnonymousDeclaration(node, 1 /* SymbolFlags.FunctionScopedVariable */, "__" + node.parent.parameters.indexOf(node)); + } + else { + declareSymbolAndAddToSymbolTable(node, 1 /* SymbolFlags.FunctionScopedVariable */, 111551 /* SymbolFlags.ParameterExcludes */); + } + // If this is a property-parameter, then also declare the property symbol into the + // containing class. + if (ts.isParameterPropertyDeclaration(node, node.parent)) { + var classDeclaration = node.parent.parent; + declareSymbol(classDeclaration.symbol.members, classDeclaration.symbol, node, 4 /* SymbolFlags.Property */ | (node.questionToken ? 16777216 /* SymbolFlags.Optional */ : 0 /* SymbolFlags.None */), 0 /* SymbolFlags.PropertyExcludes */); + } + } + function bindFunctionDeclaration(node) { + if (!file.isDeclarationFile && !(node.flags & 16777216 /* NodeFlags.Ambient */)) { + if (ts.isAsyncFunction(node)) { + emitFlags |= 2048 /* NodeFlags.HasAsyncFunctions */; + } + } + checkStrictModeFunctionName(node); + if (inStrictMode) { + checkStrictModeFunctionDeclaration(node); + bindBlockScopedDeclaration(node, 16 /* SymbolFlags.Function */, 110991 /* SymbolFlags.FunctionExcludes */); + } + else { + declareSymbolAndAddToSymbolTable(node, 16 /* SymbolFlags.Function */, 110991 /* SymbolFlags.FunctionExcludes */); + } + } + function bindFunctionExpression(node) { + if (!file.isDeclarationFile && !(node.flags & 16777216 /* NodeFlags.Ambient */)) { + if (ts.isAsyncFunction(node)) { + emitFlags |= 2048 /* NodeFlags.HasAsyncFunctions */; + } + } + if (currentFlow) { + node.flowNode = currentFlow; + } + checkStrictModeFunctionName(node); + var bindingName = node.name ? node.name.escapedText : "__function" /* InternalSymbolName.Function */; + return bindAnonymousDeclaration(node, 16 /* SymbolFlags.Function */, bindingName); + } + function bindPropertyOrMethodOrAccessor(node, symbolFlags, symbolExcludes) { + if (!file.isDeclarationFile && !(node.flags & 16777216 /* NodeFlags.Ambient */) && ts.isAsyncFunction(node)) { + emitFlags |= 2048 /* NodeFlags.HasAsyncFunctions */; + } + if (currentFlow && ts.isObjectLiteralOrClassExpressionMethodOrAccessor(node)) { + node.flowNode = currentFlow; + } + return ts.hasDynamicName(node) + ? bindAnonymousDeclaration(node, symbolFlags, "__computed" /* InternalSymbolName.Computed */) + : declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes); + } + function getInferTypeContainer(node) { + var extendsType = ts.findAncestor(node, function (n) { return n.parent && ts.isConditionalTypeNode(n.parent) && n.parent.extendsType === n; }); + return extendsType && extendsType.parent; + } + function bindTypeParameter(node) { + if (ts.isJSDocTemplateTag(node.parent)) { + var container_1 = ts.getEffectiveContainerForJSDocTemplateTag(node.parent); + if (container_1) { + if (!container_1.locals) { + container_1.locals = ts.createSymbolTable(); + } + declareSymbol(container_1.locals, /*parent*/ undefined, node, 262144 /* SymbolFlags.TypeParameter */, 526824 /* SymbolFlags.TypeParameterExcludes */); + } + else { + declareSymbolAndAddToSymbolTable(node, 262144 /* SymbolFlags.TypeParameter */, 526824 /* SymbolFlags.TypeParameterExcludes */); + } + } + else if (node.parent.kind === 192 /* SyntaxKind.InferType */) { + var container_2 = getInferTypeContainer(node.parent); + if (container_2) { + if (!container_2.locals) { + container_2.locals = ts.createSymbolTable(); + } + declareSymbol(container_2.locals, /*parent*/ undefined, node, 262144 /* SymbolFlags.TypeParameter */, 526824 /* SymbolFlags.TypeParameterExcludes */); + } + else { + bindAnonymousDeclaration(node, 262144 /* SymbolFlags.TypeParameter */, getDeclarationName(node)); // TODO: GH#18217 + } + } + else { + declareSymbolAndAddToSymbolTable(node, 262144 /* SymbolFlags.TypeParameter */, 526824 /* SymbolFlags.TypeParameterExcludes */); + } + } + // reachability checks + function shouldReportErrorOnModuleDeclaration(node) { + var instanceState = getModuleInstanceState(node); + return instanceState === 1 /* ModuleInstanceState.Instantiated */ || (instanceState === 2 /* ModuleInstanceState.ConstEnumOnly */ && ts.shouldPreserveConstEnums(options)); + } + function checkUnreachable(node) { + if (!(currentFlow.flags & 1 /* FlowFlags.Unreachable */)) { + return false; + } + if (currentFlow === unreachableFlow) { + var reportError = + // report error on all statements except empty ones + (ts.isStatementButNotDeclaration(node) && node.kind !== 239 /* SyntaxKind.EmptyStatement */) || + // report error on class declarations + node.kind === 260 /* SyntaxKind.ClassDeclaration */ || + // report error on instantiated modules or const-enums only modules if preserveConstEnums is set + (node.kind === 264 /* SyntaxKind.ModuleDeclaration */ && shouldReportErrorOnModuleDeclaration(node)); + if (reportError) { + currentFlow = reportedUnreachableFlow; + if (!options.allowUnreachableCode) { + // unreachable code is reported if + // - user has explicitly asked about it AND + // - statement is in not ambient context (statements in ambient context is already an error + // so we should not report extras) AND + // - node is not variable statement OR + // - node is block scoped variable statement OR + // - node is not block scoped variable statement and at least one variable declaration has initializer + // Rationale: we don't want to report errors on non-initialized var's since they are hoisted + // On the other side we do want to report errors on non-initialized 'lets' because of TDZ + var isError_1 = ts.unreachableCodeIsError(options) && + !(node.flags & 16777216 /* NodeFlags.Ambient */) && + (!ts.isVariableStatement(node) || + !!(ts.getCombinedNodeFlags(node.declarationList) & 3 /* NodeFlags.BlockScoped */) || + node.declarationList.declarations.some(function (d) { return !!d.initializer; })); + eachUnreachableRange(node, function (start, end) { return errorOrSuggestionOnRange(isError_1, start, end, ts.Diagnostics.Unreachable_code_detected); }); + } + } + } + return true; + } + } + function eachUnreachableRange(node, cb) { + if (ts.isStatement(node) && isExecutableStatement(node) && ts.isBlock(node.parent)) { + var statements = node.parent.statements; + var slice_1 = ts.sliceAfter(statements, node); + ts.getRangesWhere(slice_1, isExecutableStatement, function (start, afterEnd) { return cb(slice_1[start], slice_1[afterEnd - 1]); }); + } + else { + cb(node, node); + } + } + // As opposed to a pure declaration like an `interface` + function isExecutableStatement(s) { + // Don't remove statements that can validly be used before they appear. + return !ts.isFunctionDeclaration(s) && !isPurelyTypeDeclaration(s) && !ts.isEnumDeclaration(s) && + // `var x;` may declare a variable used above + !(ts.isVariableStatement(s) && !(ts.getCombinedNodeFlags(s) & (1 /* NodeFlags.Let */ | 2 /* NodeFlags.Const */)) && s.declarationList.declarations.some(function (d) { return !d.initializer; })); + } + function isPurelyTypeDeclaration(s) { + switch (s.kind) { + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + return true; + case 264 /* SyntaxKind.ModuleDeclaration */: + return getModuleInstanceState(s) !== 1 /* ModuleInstanceState.Instantiated */; + case 263 /* SyntaxKind.EnumDeclaration */: + return ts.hasSyntacticModifier(s, 2048 /* ModifierFlags.Const */); + default: + return false; + } + } + function isExportsOrModuleExportsOrAlias(sourceFile, node) { + var i = 0; + var q = ts.createQueue(); + q.enqueue(node); + while (!q.isEmpty() && i < 100) { + i++; + node = q.dequeue(); + if (ts.isExportsIdentifier(node) || ts.isModuleExportsAccessExpression(node)) { + return true; + } + else if (ts.isIdentifier(node)) { + var symbol = lookupSymbolForName(sourceFile, node.escapedText); + if (!!symbol && !!symbol.valueDeclaration && ts.isVariableDeclaration(symbol.valueDeclaration) && !!symbol.valueDeclaration.initializer) { + var init = symbol.valueDeclaration.initializer; + q.enqueue(init); + if (ts.isAssignmentExpression(init, /*excludeCompoundAssignment*/ true)) { + q.enqueue(init.left); + q.enqueue(init.right); + } + } + } + } + return false; + } + ts.isExportsOrModuleExportsOrAlias = isExportsOrModuleExportsOrAlias; + function lookupSymbolForName(container, name) { + var local = container.locals && container.locals.get(name); + if (local) { + return local.exportSymbol || local; + } + if (ts.isSourceFile(container) && container.jsGlobalAugmentations && container.jsGlobalAugmentations.has(name)) { + return container.jsGlobalAugmentations.get(name); + } + return container.symbol && container.symbol.exports && container.symbol.exports.get(name); + } +})(ts || (ts = {})); +/** @internal */ +var ts; +(function (ts) { + function createGetSymbolWalker(getRestTypeOfSignature, getTypePredicateOfSignature, getReturnTypeOfSignature, getBaseTypes, resolveStructuredTypeMembers, getTypeOfSymbol, getResolvedSymbol, getConstraintOfTypeParameter, getFirstIdentifier, getTypeArguments) { + return getSymbolWalker; + function getSymbolWalker(accept) { + if (accept === void 0) { accept = function () { return true; }; } + var visitedTypes = []; // Sparse array from id to type + var visitedSymbols = []; // Sparse array from id to symbol + return { + walkType: function (type) { + try { + visitType(type); + return { visitedTypes: ts.getOwnValues(visitedTypes), visitedSymbols: ts.getOwnValues(visitedSymbols) }; + } + finally { + ts.clear(visitedTypes); + ts.clear(visitedSymbols); + } + }, + walkSymbol: function (symbol) { + try { + visitSymbol(symbol); + return { visitedTypes: ts.getOwnValues(visitedTypes), visitedSymbols: ts.getOwnValues(visitedSymbols) }; + } + finally { + ts.clear(visitedTypes); + ts.clear(visitedSymbols); + } + }, + }; + function visitType(type) { + if (!type) { + return; + } + if (visitedTypes[type.id]) { + return; + } + visitedTypes[type.id] = type; + // Reuse visitSymbol to visit the type's symbol, + // but be sure to bail on recuring into the type if accept declines the symbol. + var shouldBail = visitSymbol(type.symbol); + if (shouldBail) + return; + // Visit the type's related types, if any + if (type.flags & 524288 /* TypeFlags.Object */) { + var objectType = type; + var objectFlags = objectType.objectFlags; + if (objectFlags & 4 /* ObjectFlags.Reference */) { + visitTypeReference(type); + } + if (objectFlags & 32 /* ObjectFlags.Mapped */) { + visitMappedType(type); + } + if (objectFlags & (1 /* ObjectFlags.Class */ | 2 /* ObjectFlags.Interface */)) { + visitInterfaceType(type); + } + if (objectFlags & (8 /* ObjectFlags.Tuple */ | 16 /* ObjectFlags.Anonymous */)) { + visitObjectType(objectType); + } + } + if (type.flags & 262144 /* TypeFlags.TypeParameter */) { + visitTypeParameter(type); + } + if (type.flags & 3145728 /* TypeFlags.UnionOrIntersection */) { + visitUnionOrIntersectionType(type); + } + if (type.flags & 4194304 /* TypeFlags.Index */) { + visitIndexType(type); + } + if (type.flags & 8388608 /* TypeFlags.IndexedAccess */) { + visitIndexedAccessType(type); + } + } + function visitTypeReference(type) { + visitType(type.target); + ts.forEach(getTypeArguments(type), visitType); + } + function visitTypeParameter(type) { + visitType(getConstraintOfTypeParameter(type)); + } + function visitUnionOrIntersectionType(type) { + ts.forEach(type.types, visitType); + } + function visitIndexType(type) { + visitType(type.type); + } + function visitIndexedAccessType(type) { + visitType(type.objectType); + visitType(type.indexType); + visitType(type.constraint); + } + function visitMappedType(type) { + visitType(type.typeParameter); + visitType(type.constraintType); + visitType(type.templateType); + visitType(type.modifiersType); + } + function visitSignature(signature) { + var typePredicate = getTypePredicateOfSignature(signature); + if (typePredicate) { + visitType(typePredicate.type); + } + ts.forEach(signature.typeParameters, visitType); + for (var _i = 0, _a = signature.parameters; _i < _a.length; _i++) { + var parameter = _a[_i]; + visitSymbol(parameter); + } + visitType(getRestTypeOfSignature(signature)); + visitType(getReturnTypeOfSignature(signature)); + } + function visitInterfaceType(interfaceT) { + visitObjectType(interfaceT); + ts.forEach(interfaceT.typeParameters, visitType); + ts.forEach(getBaseTypes(interfaceT), visitType); + visitType(interfaceT.thisType); + } + function visitObjectType(type) { + var resolved = resolveStructuredTypeMembers(type); + for (var _i = 0, _a = resolved.indexInfos; _i < _a.length; _i++) { + var info = _a[_i]; + visitType(info.keyType); + visitType(info.type); + } + for (var _b = 0, _c = resolved.callSignatures; _b < _c.length; _b++) { + var signature = _c[_b]; + visitSignature(signature); + } + for (var _d = 0, _e = resolved.constructSignatures; _d < _e.length; _d++) { + var signature = _e[_d]; + visitSignature(signature); + } + for (var _f = 0, _g = resolved.properties; _f < _g.length; _f++) { + var p = _g[_f]; + visitSymbol(p); + } + } + function visitSymbol(symbol) { + if (!symbol) { + return false; + } + var symbolId = ts.getSymbolId(symbol); + if (visitedSymbols[symbolId]) { + return false; + } + visitedSymbols[symbolId] = symbol; + if (!accept(symbol)) { + return true; + } + var t = getTypeOfSymbol(symbol); + visitType(t); // Should handle members on classes and such + if (symbol.exports) { + symbol.exports.forEach(visitSymbol); + } + ts.forEach(symbol.declarations, function (d) { + // Type queries are too far resolved when we just visit the symbol's type + // (their type resolved directly to the member deeply referenced) + // So to get the intervening symbols, we need to check if there's a type + // query node on any of the symbol's declarations and get symbols there + if (d.type && d.type.kind === 183 /* SyntaxKind.TypeQuery */) { + var query = d.type; + var entity = getResolvedSymbol(getFirstIdentifier(query.exprName)); + visitSymbol(entity); + } + }); + return false; + } + } + } + ts.createGetSymbolWalker = createGetSymbolWalker; +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var ambientModuleSymbolRegex = /^".+"$/; + var anon = "(anonymous)"; + var nextSymbolId = 1; + var nextNodeId = 1; + var nextMergeId = 1; + var nextFlowId = 1; + var IterationUse; + (function (IterationUse) { + IterationUse[IterationUse["AllowsSyncIterablesFlag"] = 1] = "AllowsSyncIterablesFlag"; + IterationUse[IterationUse["AllowsAsyncIterablesFlag"] = 2] = "AllowsAsyncIterablesFlag"; + IterationUse[IterationUse["AllowsStringInputFlag"] = 4] = "AllowsStringInputFlag"; + IterationUse[IterationUse["ForOfFlag"] = 8] = "ForOfFlag"; + IterationUse[IterationUse["YieldStarFlag"] = 16] = "YieldStarFlag"; + IterationUse[IterationUse["SpreadFlag"] = 32] = "SpreadFlag"; + IterationUse[IterationUse["DestructuringFlag"] = 64] = "DestructuringFlag"; + IterationUse[IterationUse["PossiblyOutOfBounds"] = 128] = "PossiblyOutOfBounds"; + // Spread, Destructuring, Array element assignment + IterationUse[IterationUse["Element"] = 1] = "Element"; + IterationUse[IterationUse["Spread"] = 33] = "Spread"; + IterationUse[IterationUse["Destructuring"] = 65] = "Destructuring"; + IterationUse[IterationUse["ForOf"] = 13] = "ForOf"; + IterationUse[IterationUse["ForAwaitOf"] = 15] = "ForAwaitOf"; + IterationUse[IterationUse["YieldStar"] = 17] = "YieldStar"; + IterationUse[IterationUse["AsyncYieldStar"] = 19] = "AsyncYieldStar"; + IterationUse[IterationUse["GeneratorReturnType"] = 1] = "GeneratorReturnType"; + IterationUse[IterationUse["AsyncGeneratorReturnType"] = 2] = "AsyncGeneratorReturnType"; + })(IterationUse || (IterationUse = {})); + var IterationTypeKind; + (function (IterationTypeKind) { + IterationTypeKind[IterationTypeKind["Yield"] = 0] = "Yield"; + IterationTypeKind[IterationTypeKind["Return"] = 1] = "Return"; + IterationTypeKind[IterationTypeKind["Next"] = 2] = "Next"; + })(IterationTypeKind || (IterationTypeKind = {})); + var WideningKind; + (function (WideningKind) { + WideningKind[WideningKind["Normal"] = 0] = "Normal"; + WideningKind[WideningKind["FunctionReturn"] = 1] = "FunctionReturn"; + WideningKind[WideningKind["GeneratorNext"] = 2] = "GeneratorNext"; + WideningKind[WideningKind["GeneratorYield"] = 3] = "GeneratorYield"; + })(WideningKind || (WideningKind = {})); + var TypeFacts; + (function (TypeFacts) { + TypeFacts[TypeFacts["None"] = 0] = "None"; + TypeFacts[TypeFacts["TypeofEQString"] = 1] = "TypeofEQString"; + TypeFacts[TypeFacts["TypeofEQNumber"] = 2] = "TypeofEQNumber"; + TypeFacts[TypeFacts["TypeofEQBigInt"] = 4] = "TypeofEQBigInt"; + TypeFacts[TypeFacts["TypeofEQBoolean"] = 8] = "TypeofEQBoolean"; + TypeFacts[TypeFacts["TypeofEQSymbol"] = 16] = "TypeofEQSymbol"; + TypeFacts[TypeFacts["TypeofEQObject"] = 32] = "TypeofEQObject"; + TypeFacts[TypeFacts["TypeofEQFunction"] = 64] = "TypeofEQFunction"; + TypeFacts[TypeFacts["TypeofEQHostObject"] = 128] = "TypeofEQHostObject"; + TypeFacts[TypeFacts["TypeofNEString"] = 256] = "TypeofNEString"; + TypeFacts[TypeFacts["TypeofNENumber"] = 512] = "TypeofNENumber"; + TypeFacts[TypeFacts["TypeofNEBigInt"] = 1024] = "TypeofNEBigInt"; + TypeFacts[TypeFacts["TypeofNEBoolean"] = 2048] = "TypeofNEBoolean"; + TypeFacts[TypeFacts["TypeofNESymbol"] = 4096] = "TypeofNESymbol"; + TypeFacts[TypeFacts["TypeofNEObject"] = 8192] = "TypeofNEObject"; + TypeFacts[TypeFacts["TypeofNEFunction"] = 16384] = "TypeofNEFunction"; + TypeFacts[TypeFacts["TypeofNEHostObject"] = 32768] = "TypeofNEHostObject"; + TypeFacts[TypeFacts["EQUndefined"] = 65536] = "EQUndefined"; + TypeFacts[TypeFacts["EQNull"] = 131072] = "EQNull"; + TypeFacts[TypeFacts["EQUndefinedOrNull"] = 262144] = "EQUndefinedOrNull"; + TypeFacts[TypeFacts["NEUndefined"] = 524288] = "NEUndefined"; + TypeFacts[TypeFacts["NENull"] = 1048576] = "NENull"; + TypeFacts[TypeFacts["NEUndefinedOrNull"] = 2097152] = "NEUndefinedOrNull"; + TypeFacts[TypeFacts["Truthy"] = 4194304] = "Truthy"; + TypeFacts[TypeFacts["Falsy"] = 8388608] = "Falsy"; + TypeFacts[TypeFacts["IsUndefined"] = 16777216] = "IsUndefined"; + TypeFacts[TypeFacts["IsNull"] = 33554432] = "IsNull"; + TypeFacts[TypeFacts["IsUndefinedOrNull"] = 50331648] = "IsUndefinedOrNull"; + TypeFacts[TypeFacts["All"] = 134217727] = "All"; + // The following members encode facts about particular kinds of types for use in the getTypeFacts function. + // The presence of a particular fact means that the given test is true for some (and possibly all) values + // of that kind of type. + TypeFacts[TypeFacts["BaseStringStrictFacts"] = 3735041] = "BaseStringStrictFacts"; + TypeFacts[TypeFacts["BaseStringFacts"] = 12582401] = "BaseStringFacts"; + TypeFacts[TypeFacts["StringStrictFacts"] = 16317953] = "StringStrictFacts"; + TypeFacts[TypeFacts["StringFacts"] = 16776705] = "StringFacts"; + TypeFacts[TypeFacts["EmptyStringStrictFacts"] = 12123649] = "EmptyStringStrictFacts"; + TypeFacts[TypeFacts["EmptyStringFacts"] = 12582401] = "EmptyStringFacts"; + TypeFacts[TypeFacts["NonEmptyStringStrictFacts"] = 7929345] = "NonEmptyStringStrictFacts"; + TypeFacts[TypeFacts["NonEmptyStringFacts"] = 16776705] = "NonEmptyStringFacts"; + TypeFacts[TypeFacts["BaseNumberStrictFacts"] = 3734786] = "BaseNumberStrictFacts"; + TypeFacts[TypeFacts["BaseNumberFacts"] = 12582146] = "BaseNumberFacts"; + TypeFacts[TypeFacts["NumberStrictFacts"] = 16317698] = "NumberStrictFacts"; + TypeFacts[TypeFacts["NumberFacts"] = 16776450] = "NumberFacts"; + TypeFacts[TypeFacts["ZeroNumberStrictFacts"] = 12123394] = "ZeroNumberStrictFacts"; + TypeFacts[TypeFacts["ZeroNumberFacts"] = 12582146] = "ZeroNumberFacts"; + TypeFacts[TypeFacts["NonZeroNumberStrictFacts"] = 7929090] = "NonZeroNumberStrictFacts"; + TypeFacts[TypeFacts["NonZeroNumberFacts"] = 16776450] = "NonZeroNumberFacts"; + TypeFacts[TypeFacts["BaseBigIntStrictFacts"] = 3734276] = "BaseBigIntStrictFacts"; + TypeFacts[TypeFacts["BaseBigIntFacts"] = 12581636] = "BaseBigIntFacts"; + TypeFacts[TypeFacts["BigIntStrictFacts"] = 16317188] = "BigIntStrictFacts"; + TypeFacts[TypeFacts["BigIntFacts"] = 16775940] = "BigIntFacts"; + TypeFacts[TypeFacts["ZeroBigIntStrictFacts"] = 12122884] = "ZeroBigIntStrictFacts"; + TypeFacts[TypeFacts["ZeroBigIntFacts"] = 12581636] = "ZeroBigIntFacts"; + TypeFacts[TypeFacts["NonZeroBigIntStrictFacts"] = 7928580] = "NonZeroBigIntStrictFacts"; + TypeFacts[TypeFacts["NonZeroBigIntFacts"] = 16775940] = "NonZeroBigIntFacts"; + TypeFacts[TypeFacts["BaseBooleanStrictFacts"] = 3733256] = "BaseBooleanStrictFacts"; + TypeFacts[TypeFacts["BaseBooleanFacts"] = 12580616] = "BaseBooleanFacts"; + TypeFacts[TypeFacts["BooleanStrictFacts"] = 16316168] = "BooleanStrictFacts"; + TypeFacts[TypeFacts["BooleanFacts"] = 16774920] = "BooleanFacts"; + TypeFacts[TypeFacts["FalseStrictFacts"] = 12121864] = "FalseStrictFacts"; + TypeFacts[TypeFacts["FalseFacts"] = 12580616] = "FalseFacts"; + TypeFacts[TypeFacts["TrueStrictFacts"] = 7927560] = "TrueStrictFacts"; + TypeFacts[TypeFacts["TrueFacts"] = 16774920] = "TrueFacts"; + TypeFacts[TypeFacts["SymbolStrictFacts"] = 7925520] = "SymbolStrictFacts"; + TypeFacts[TypeFacts["SymbolFacts"] = 16772880] = "SymbolFacts"; + TypeFacts[TypeFacts["ObjectStrictFacts"] = 7888800] = "ObjectStrictFacts"; + TypeFacts[TypeFacts["ObjectFacts"] = 16736160] = "ObjectFacts"; + TypeFacts[TypeFacts["FunctionStrictFacts"] = 7880640] = "FunctionStrictFacts"; + TypeFacts[TypeFacts["FunctionFacts"] = 16728000] = "FunctionFacts"; + TypeFacts[TypeFacts["VoidFacts"] = 9830144] = "VoidFacts"; + TypeFacts[TypeFacts["UndefinedFacts"] = 26607360] = "UndefinedFacts"; + TypeFacts[TypeFacts["NullFacts"] = 42917664] = "NullFacts"; + TypeFacts[TypeFacts["EmptyObjectStrictFacts"] = 83427327] = "EmptyObjectStrictFacts"; + TypeFacts[TypeFacts["EmptyObjectFacts"] = 83886079] = "EmptyObjectFacts"; + TypeFacts[TypeFacts["UnknownFacts"] = 83886079] = "UnknownFacts"; + TypeFacts[TypeFacts["AllTypeofNE"] = 556800] = "AllTypeofNE"; + // Masks + TypeFacts[TypeFacts["OrFactsMask"] = 8256] = "OrFactsMask"; + TypeFacts[TypeFacts["AndFactsMask"] = 134209471] = "AndFactsMask"; + })(TypeFacts = ts.TypeFacts || (ts.TypeFacts = {})); + var typeofNEFacts = new ts.Map(ts.getEntries({ + string: 256 /* TypeFacts.TypeofNEString */, + number: 512 /* TypeFacts.TypeofNENumber */, + bigint: 1024 /* TypeFacts.TypeofNEBigInt */, + boolean: 2048 /* TypeFacts.TypeofNEBoolean */, + symbol: 4096 /* TypeFacts.TypeofNESymbol */, + undefined: 524288 /* TypeFacts.NEUndefined */, + object: 8192 /* TypeFacts.TypeofNEObject */, + function: 16384 /* TypeFacts.TypeofNEFunction */ + })); + var TypeSystemPropertyName; + (function (TypeSystemPropertyName) { + TypeSystemPropertyName[TypeSystemPropertyName["Type"] = 0] = "Type"; + TypeSystemPropertyName[TypeSystemPropertyName["ResolvedBaseConstructorType"] = 1] = "ResolvedBaseConstructorType"; + TypeSystemPropertyName[TypeSystemPropertyName["DeclaredType"] = 2] = "DeclaredType"; + TypeSystemPropertyName[TypeSystemPropertyName["ResolvedReturnType"] = 3] = "ResolvedReturnType"; + TypeSystemPropertyName[TypeSystemPropertyName["ImmediateBaseConstraint"] = 4] = "ImmediateBaseConstraint"; + TypeSystemPropertyName[TypeSystemPropertyName["EnumTagType"] = 5] = "EnumTagType"; + TypeSystemPropertyName[TypeSystemPropertyName["ResolvedTypeArguments"] = 6] = "ResolvedTypeArguments"; + TypeSystemPropertyName[TypeSystemPropertyName["ResolvedBaseTypes"] = 7] = "ResolvedBaseTypes"; + TypeSystemPropertyName[TypeSystemPropertyName["WriteType"] = 8] = "WriteType"; + })(TypeSystemPropertyName || (TypeSystemPropertyName = {})); + var CheckMode; + (function (CheckMode) { + CheckMode[CheckMode["Normal"] = 0] = "Normal"; + CheckMode[CheckMode["Contextual"] = 1] = "Contextual"; + CheckMode[CheckMode["Inferential"] = 2] = "Inferential"; + CheckMode[CheckMode["SkipContextSensitive"] = 4] = "SkipContextSensitive"; + CheckMode[CheckMode["SkipGenericFunctions"] = 8] = "SkipGenericFunctions"; + CheckMode[CheckMode["IsForSignatureHelp"] = 16] = "IsForSignatureHelp"; + CheckMode[CheckMode["IsForStringLiteralArgumentCompletions"] = 32] = "IsForStringLiteralArgumentCompletions"; + CheckMode[CheckMode["RestBindingElement"] = 64] = "RestBindingElement"; + // e.g. in `const { a, ...rest } = foo`, when checking the type of `foo` to determine the type of `rest`, + // we need to preserve generic types instead of substituting them for constraints + })(CheckMode = ts.CheckMode || (ts.CheckMode = {})); + var SignatureCheckMode; + (function (SignatureCheckMode) { + SignatureCheckMode[SignatureCheckMode["BivariantCallback"] = 1] = "BivariantCallback"; + SignatureCheckMode[SignatureCheckMode["StrictCallback"] = 2] = "StrictCallback"; + SignatureCheckMode[SignatureCheckMode["IgnoreReturnTypes"] = 4] = "IgnoreReturnTypes"; + SignatureCheckMode[SignatureCheckMode["StrictArity"] = 8] = "StrictArity"; + SignatureCheckMode[SignatureCheckMode["Callback"] = 3] = "Callback"; + })(SignatureCheckMode = ts.SignatureCheckMode || (ts.SignatureCheckMode = {})); + var IntersectionState; + (function (IntersectionState) { + IntersectionState[IntersectionState["None"] = 0] = "None"; + IntersectionState[IntersectionState["Source"] = 1] = "Source"; + IntersectionState[IntersectionState["Target"] = 2] = "Target"; + })(IntersectionState || (IntersectionState = {})); + var RecursionFlags; + (function (RecursionFlags) { + RecursionFlags[RecursionFlags["None"] = 0] = "None"; + RecursionFlags[RecursionFlags["Source"] = 1] = "Source"; + RecursionFlags[RecursionFlags["Target"] = 2] = "Target"; + RecursionFlags[RecursionFlags["Both"] = 3] = "Both"; + })(RecursionFlags || (RecursionFlags = {})); + var MappedTypeModifiers; + (function (MappedTypeModifiers) { + MappedTypeModifiers[MappedTypeModifiers["IncludeReadonly"] = 1] = "IncludeReadonly"; + MappedTypeModifiers[MappedTypeModifiers["ExcludeReadonly"] = 2] = "ExcludeReadonly"; + MappedTypeModifiers[MappedTypeModifiers["IncludeOptional"] = 4] = "IncludeOptional"; + MappedTypeModifiers[MappedTypeModifiers["ExcludeOptional"] = 8] = "ExcludeOptional"; + })(MappedTypeModifiers || (MappedTypeModifiers = {})); + var ExpandingFlags; + (function (ExpandingFlags) { + ExpandingFlags[ExpandingFlags["None"] = 0] = "None"; + ExpandingFlags[ExpandingFlags["Source"] = 1] = "Source"; + ExpandingFlags[ExpandingFlags["Target"] = 2] = "Target"; + ExpandingFlags[ExpandingFlags["Both"] = 3] = "Both"; + })(ExpandingFlags || (ExpandingFlags = {})); + var MembersOrExportsResolutionKind; + (function (MembersOrExportsResolutionKind) { + MembersOrExportsResolutionKind["resolvedExports"] = "resolvedExports"; + MembersOrExportsResolutionKind["resolvedMembers"] = "resolvedMembers"; + })(MembersOrExportsResolutionKind || (MembersOrExportsResolutionKind = {})); + var UnusedKind; + (function (UnusedKind) { + UnusedKind[UnusedKind["Local"] = 0] = "Local"; + UnusedKind[UnusedKind["Parameter"] = 1] = "Parameter"; + })(UnusedKind || (UnusedKind = {})); + var isNotOverloadAndNotAccessor = ts.and(isNotOverload, isNotAccessor); + var DeclarationMeaning; + (function (DeclarationMeaning) { + DeclarationMeaning[DeclarationMeaning["GetAccessor"] = 1] = "GetAccessor"; + DeclarationMeaning[DeclarationMeaning["SetAccessor"] = 2] = "SetAccessor"; + DeclarationMeaning[DeclarationMeaning["PropertyAssignment"] = 4] = "PropertyAssignment"; + DeclarationMeaning[DeclarationMeaning["Method"] = 8] = "Method"; + DeclarationMeaning[DeclarationMeaning["PrivateStatic"] = 16] = "PrivateStatic"; + DeclarationMeaning[DeclarationMeaning["GetOrSetAccessor"] = 3] = "GetOrSetAccessor"; + DeclarationMeaning[DeclarationMeaning["PropertyAssignmentOrMethod"] = 12] = "PropertyAssignmentOrMethod"; + })(DeclarationMeaning || (DeclarationMeaning = {})); + var DeclarationSpaces; + (function (DeclarationSpaces) { + DeclarationSpaces[DeclarationSpaces["None"] = 0] = "None"; + DeclarationSpaces[DeclarationSpaces["ExportValue"] = 1] = "ExportValue"; + DeclarationSpaces[DeclarationSpaces["ExportType"] = 2] = "ExportType"; + DeclarationSpaces[DeclarationSpaces["ExportNamespace"] = 4] = "ExportNamespace"; + })(DeclarationSpaces || (DeclarationSpaces = {})); + var MinArgumentCountFlags; + (function (MinArgumentCountFlags) { + MinArgumentCountFlags[MinArgumentCountFlags["None"] = 0] = "None"; + MinArgumentCountFlags[MinArgumentCountFlags["StrongArityForUntypedJS"] = 1] = "StrongArityForUntypedJS"; + MinArgumentCountFlags[MinArgumentCountFlags["VoidIsNonOptional"] = 2] = "VoidIsNonOptional"; + })(MinArgumentCountFlags || (MinArgumentCountFlags = {})); + var IntrinsicTypeKind; + (function (IntrinsicTypeKind) { + IntrinsicTypeKind[IntrinsicTypeKind["Uppercase"] = 0] = "Uppercase"; + IntrinsicTypeKind[IntrinsicTypeKind["Lowercase"] = 1] = "Lowercase"; + IntrinsicTypeKind[IntrinsicTypeKind["Capitalize"] = 2] = "Capitalize"; + IntrinsicTypeKind[IntrinsicTypeKind["Uncapitalize"] = 3] = "Uncapitalize"; + })(IntrinsicTypeKind || (IntrinsicTypeKind = {})); + var intrinsicTypeKinds = new ts.Map(ts.getEntries({ + Uppercase: 0 /* IntrinsicTypeKind.Uppercase */, + Lowercase: 1 /* IntrinsicTypeKind.Lowercase */, + Capitalize: 2 /* IntrinsicTypeKind.Capitalize */, + Uncapitalize: 3 /* IntrinsicTypeKind.Uncapitalize */ + })); + function SymbolLinks() { + } + function NodeLinks() { + this.flags = 0; + } + function getNodeId(node) { + if (!node.id) { + node.id = nextNodeId; + nextNodeId++; + } + return node.id; + } + ts.getNodeId = getNodeId; + function getSymbolId(symbol) { + if (!symbol.id) { + symbol.id = nextSymbolId; + nextSymbolId++; + } + return symbol.id; + } + ts.getSymbolId = getSymbolId; + function isInstantiatedModule(node, preserveConstEnums) { + var moduleState = ts.getModuleInstanceState(node); + return moduleState === 1 /* ModuleInstanceState.Instantiated */ || + (preserveConstEnums && moduleState === 2 /* ModuleInstanceState.ConstEnumOnly */); + } + ts.isInstantiatedModule = isInstantiatedModule; + function createTypeChecker(host) { + var getPackagesMap = ts.memoize(function () { + // A package name maps to true when we detect it has .d.ts files. + // This is useful as an approximation of whether a package bundles its own types. + // Note: we only look at files already found by module resolution, + // so there may be files we did not consider. + var map = new ts.Map(); + host.getSourceFiles().forEach(function (sf) { + if (!sf.resolvedModules) + return; + sf.resolvedModules.forEach(function (r) { + if (r && r.packageId) + map.set(r.packageId.name, r.extension === ".d.ts" /* Extension.Dts */ || !!map.get(r.packageId.name)); + }); + }); + return map; + }); + var deferredDiagnosticsCallbacks = []; + var addLazyDiagnostic = function (arg) { + deferredDiagnosticsCallbacks.push(arg); + }; + // Cancellation that controls whether or not we can cancel in the middle of type checking. + // In general cancelling is *not* safe for the type checker. We might be in the middle of + // computing something, and we will leave our internals in an inconsistent state. Callers + // who set the cancellation token should catch if a cancellation exception occurs, and + // should throw away and create a new TypeChecker. + // + // Currently we only support setting the cancellation token when getting diagnostics. This + // is because diagnostics can be quite expensive, and we want to allow hosts to bail out if + // they no longer need the information (for example, if the user started editing again). + var cancellationToken; + var requestedExternalEmitHelpers; + var externalHelpersModule; + var Symbol = ts.objectAllocator.getSymbolConstructor(); + var Type = ts.objectAllocator.getTypeConstructor(); + var Signature = ts.objectAllocator.getSignatureConstructor(); + var typeCount = 0; + var symbolCount = 0; + var enumCount = 0; + var totalInstantiationCount = 0; + var instantiationCount = 0; + var instantiationDepth = 0; + var inlineLevel = 0; + var currentNode; + var varianceTypeParameter; + var emptySymbols = ts.createSymbolTable(); + var arrayVariances = [1 /* VarianceFlags.Covariant */]; + var compilerOptions = host.getCompilerOptions(); + var languageVersion = ts.getEmitScriptTarget(compilerOptions); + var moduleKind = ts.getEmitModuleKind(compilerOptions); + var useDefineForClassFields = ts.getUseDefineForClassFields(compilerOptions); + var allowSyntheticDefaultImports = ts.getAllowSyntheticDefaultImports(compilerOptions); + var strictNullChecks = ts.getStrictOptionValue(compilerOptions, "strictNullChecks"); + var strictFunctionTypes = ts.getStrictOptionValue(compilerOptions, "strictFunctionTypes"); + var strictBindCallApply = ts.getStrictOptionValue(compilerOptions, "strictBindCallApply"); + var strictPropertyInitialization = ts.getStrictOptionValue(compilerOptions, "strictPropertyInitialization"); + var noImplicitAny = ts.getStrictOptionValue(compilerOptions, "noImplicitAny"); + var noImplicitThis = ts.getStrictOptionValue(compilerOptions, "noImplicitThis"); + var useUnknownInCatchVariables = ts.getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables"); + var keyofStringsOnly = !!compilerOptions.keyofStringsOnly; + var freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : 8192 /* ObjectFlags.FreshLiteral */; + var exactOptionalPropertyTypes = compilerOptions.exactOptionalPropertyTypes; + var checkBinaryExpression = createCheckBinaryExpression(); + var emitResolver = createResolver(); + var nodeBuilder = createNodeBuilder(); + var globals = ts.createSymbolTable(); + var undefinedSymbol = createSymbol(4 /* SymbolFlags.Property */, "undefined"); + undefinedSymbol.declarations = []; + var globalThisSymbol = createSymbol(1536 /* SymbolFlags.Module */, "globalThis", 8 /* CheckFlags.Readonly */); + globalThisSymbol.exports = globals; + globalThisSymbol.declarations = []; + globals.set(globalThisSymbol.escapedName, globalThisSymbol); + var argumentsSymbol = createSymbol(4 /* SymbolFlags.Property */, "arguments"); + var requireSymbol = createSymbol(4 /* SymbolFlags.Property */, "require"); + /** This will be set during calls to `getResolvedSignature` where services determines an apparent number of arguments greater than what is actually provided. */ + var apparentArgumentCount; + // for public members that accept a Node or one of its subtypes, we must guard against + // synthetic nodes created during transformations by calling `getParseTreeNode`. + // for most of these, we perform the guard only on `checker` to avoid any possible + // extra cost of calling `getParseTreeNode` when calling these functions from inside the + // checker. + var checker = { + getNodeCount: function () { return ts.sum(host.getSourceFiles(), "nodeCount"); }, + getIdentifierCount: function () { return ts.sum(host.getSourceFiles(), "identifierCount"); }, + getSymbolCount: function () { return ts.sum(host.getSourceFiles(), "symbolCount") + symbolCount; }, + getTypeCount: function () { return typeCount; }, + getInstantiationCount: function () { return totalInstantiationCount; }, + getRelationCacheSizes: function () { return ({ + assignable: assignableRelation.size, + identity: identityRelation.size, + subtype: subtypeRelation.size, + strictSubtype: strictSubtypeRelation.size, + }); }, + isUndefinedSymbol: function (symbol) { return symbol === undefinedSymbol; }, + isArgumentsSymbol: function (symbol) { return symbol === argumentsSymbol; }, + isUnknownSymbol: function (symbol) { return symbol === unknownSymbol; }, + getMergedSymbol: getMergedSymbol, + getDiagnostics: getDiagnostics, + getGlobalDiagnostics: getGlobalDiagnostics, + getRecursionIdentity: getRecursionIdentity, + getUnmatchedProperties: getUnmatchedProperties, + getTypeOfSymbolAtLocation: function (symbol, locationIn) { + var location = ts.getParseTreeNode(locationIn); + return location ? getTypeOfSymbolAtLocation(symbol, location) : errorType; + }, + getTypeOfSymbol: getTypeOfSymbol, + getSymbolsOfParameterPropertyDeclaration: function (parameterIn, parameterName) { + var parameter = ts.getParseTreeNode(parameterIn, ts.isParameter); + if (parameter === undefined) + return ts.Debug.fail("Cannot get symbols of a synthetic parameter that cannot be resolved to a parse-tree node."); + return getSymbolsOfParameterPropertyDeclaration(parameter, ts.escapeLeadingUnderscores(parameterName)); + }, + getDeclaredTypeOfSymbol: getDeclaredTypeOfSymbol, + getPropertiesOfType: getPropertiesOfType, + getPropertyOfType: function (type, name) { return getPropertyOfType(type, ts.escapeLeadingUnderscores(name)); }, + getPrivateIdentifierPropertyOfType: function (leftType, name, location) { + var node = ts.getParseTreeNode(location); + if (!node) { + return undefined; + } + var propName = ts.escapeLeadingUnderscores(name); + var lexicallyScopedIdentifier = lookupSymbolForPrivateIdentifierDeclaration(propName, node); + return lexicallyScopedIdentifier ? getPrivateIdentifierPropertyOfType(leftType, lexicallyScopedIdentifier) : undefined; + }, + getTypeOfPropertyOfType: function (type, name) { return getTypeOfPropertyOfType(type, ts.escapeLeadingUnderscores(name)); }, + getIndexInfoOfType: function (type, kind) { return getIndexInfoOfType(type, kind === 0 /* IndexKind.String */ ? stringType : numberType); }, + getIndexInfosOfType: getIndexInfosOfType, + getIndexInfosOfIndexSymbol: getIndexInfosOfIndexSymbol, + getSignaturesOfType: getSignaturesOfType, + getIndexTypeOfType: function (type, kind) { return getIndexTypeOfType(type, kind === 0 /* IndexKind.String */ ? stringType : numberType); }, + getIndexType: function (type) { return getIndexType(type); }, + getBaseTypes: getBaseTypes, + getBaseTypeOfLiteralType: getBaseTypeOfLiteralType, + getWidenedType: getWidenedType, + getTypeFromTypeNode: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.isTypeNode); + return node ? getTypeFromTypeNode(node) : errorType; + }, + getParameterType: getTypeAtPosition, + getParameterIdentifierNameAtPosition: getParameterIdentifierNameAtPosition, + getPromisedTypeOfPromise: getPromisedTypeOfPromise, + getAwaitedType: function (type) { return getAwaitedType(type); }, + getReturnTypeOfSignature: getReturnTypeOfSignature, + isNullableType: isNullableType, + getNullableType: getNullableType, + getNonNullableType: getNonNullableType, + getNonOptionalType: removeOptionalTypeMarker, + getTypeArguments: getTypeArguments, + typeToTypeNode: nodeBuilder.typeToTypeNode, + indexInfoToIndexSignatureDeclaration: nodeBuilder.indexInfoToIndexSignatureDeclaration, + signatureToSignatureDeclaration: nodeBuilder.signatureToSignatureDeclaration, + symbolToEntityName: nodeBuilder.symbolToEntityName, + symbolToExpression: nodeBuilder.symbolToExpression, + symbolToNode: nodeBuilder.symbolToNode, + symbolToTypeParameterDeclarations: nodeBuilder.symbolToTypeParameterDeclarations, + symbolToParameterDeclaration: nodeBuilder.symbolToParameterDeclaration, + typeParameterToDeclaration: nodeBuilder.typeParameterToDeclaration, + getSymbolsInScope: function (locationIn, meaning) { + var location = ts.getParseTreeNode(locationIn); + return location ? getSymbolsInScope(location, meaning) : []; + }, + getSymbolAtLocation: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn); + // set ignoreErrors: true because any lookups invoked by the API shouldn't cause any new errors + return node ? getSymbolAtLocation(node, /*ignoreErrors*/ true) : undefined; + }, + getIndexInfosAtLocation: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn); + return node ? getIndexInfosAtLocation(node) : undefined; + }, + getShorthandAssignmentValueSymbol: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn); + return node ? getShorthandAssignmentValueSymbol(node) : undefined; + }, + getExportSpecifierLocalTargetSymbol: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.isExportSpecifier); + return node ? getExportSpecifierLocalTargetSymbol(node) : undefined; + }, + getExportSymbolOfSymbol: function (symbol) { + return getMergedSymbol(symbol.exportSymbol || symbol); + }, + getTypeAtLocation: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn); + return node ? getTypeOfNode(node) : errorType; + }, + getTypeOfAssignmentPattern: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.isAssignmentPattern); + return node && getTypeOfAssignmentPattern(node) || errorType; + }, + getPropertySymbolOfDestructuringAssignment: function (locationIn) { + var location = ts.getParseTreeNode(locationIn, ts.isIdentifier); + return location ? getPropertySymbolOfDestructuringAssignment(location) : undefined; + }, + signatureToString: function (signature, enclosingDeclaration, flags, kind) { + return signatureToString(signature, ts.getParseTreeNode(enclosingDeclaration), flags, kind); + }, + typeToString: function (type, enclosingDeclaration, flags) { + return typeToString(type, ts.getParseTreeNode(enclosingDeclaration), flags); + }, + symbolToString: function (symbol, enclosingDeclaration, meaning, flags) { + return symbolToString(symbol, ts.getParseTreeNode(enclosingDeclaration), meaning, flags); + }, + typePredicateToString: function (predicate, enclosingDeclaration, flags) { + return typePredicateToString(predicate, ts.getParseTreeNode(enclosingDeclaration), flags); + }, + writeSignature: function (signature, enclosingDeclaration, flags, kind, writer) { + return signatureToString(signature, ts.getParseTreeNode(enclosingDeclaration), flags, kind, writer); + }, + writeType: function (type, enclosingDeclaration, flags, writer) { + return typeToString(type, ts.getParseTreeNode(enclosingDeclaration), flags, writer); + }, + writeSymbol: function (symbol, enclosingDeclaration, meaning, flags, writer) { + return symbolToString(symbol, ts.getParseTreeNode(enclosingDeclaration), meaning, flags, writer); + }, + writeTypePredicate: function (predicate, enclosingDeclaration, flags, writer) { + return typePredicateToString(predicate, ts.getParseTreeNode(enclosingDeclaration), flags, writer); + }, + getAugmentedPropertiesOfType: getAugmentedPropertiesOfType, + getRootSymbols: getRootSymbols, + getSymbolOfExpando: getSymbolOfExpando, + getContextualType: function (nodeIn, contextFlags) { + var node = ts.getParseTreeNode(nodeIn, ts.isExpression); + if (!node) { + return undefined; + } + if (contextFlags & 4 /* ContextFlags.Completions */) { + return runWithInferenceBlockedFromSourceNode(node, function () { return getContextualType(node, contextFlags); }); + } + return getContextualType(node, contextFlags); + }, + getContextualTypeForObjectLiteralElement: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.isObjectLiteralElementLike); + return node ? getContextualTypeForObjectLiteralElement(node, /*contextFlags*/ undefined) : undefined; + }, + getContextualTypeForArgumentAtIndex: function (nodeIn, argIndex) { + var node = ts.getParseTreeNode(nodeIn, ts.isCallLikeExpression); + return node && getContextualTypeForArgumentAtIndex(node, argIndex); + }, + getContextualTypeForJsxAttribute: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.isJsxAttributeLike); + return node && getContextualTypeForJsxAttribute(node, /*contextFlags*/ undefined); + }, + isContextSensitive: isContextSensitive, + getTypeOfPropertyOfContextualType: getTypeOfPropertyOfContextualType, + getFullyQualifiedName: getFullyQualifiedName, + getResolvedSignature: function (node, candidatesOutArray, argumentCount) { + return getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 0 /* CheckMode.Normal */); + }, + getResolvedSignatureForStringLiteralCompletions: function (call, editingArgument, candidatesOutArray) { + return getResolvedSignatureWorker(call, candidatesOutArray, /*argumentCount*/ undefined, 32 /* CheckMode.IsForStringLiteralArgumentCompletions */, editingArgument); + }, + getResolvedSignatureForSignatureHelp: function (node, candidatesOutArray, argumentCount) { + return getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 16 /* CheckMode.IsForSignatureHelp */); + }, + getExpandedParameters: getExpandedParameters, + hasEffectiveRestParameter: hasEffectiveRestParameter, + containsArgumentsReference: containsArgumentsReference, + getConstantValue: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn, canHaveConstantValue); + return node ? getConstantValue(node) : undefined; + }, + isValidPropertyAccess: function (nodeIn, propertyName) { + var node = ts.getParseTreeNode(nodeIn, ts.isPropertyAccessOrQualifiedNameOrImportTypeNode); + return !!node && isValidPropertyAccess(node, ts.escapeLeadingUnderscores(propertyName)); + }, + isValidPropertyAccessForCompletions: function (nodeIn, type, property) { + var node = ts.getParseTreeNode(nodeIn, ts.isPropertyAccessExpression); + return !!node && isValidPropertyAccessForCompletions(node, type, property); + }, + getSignatureFromDeclaration: function (declarationIn) { + var declaration = ts.getParseTreeNode(declarationIn, ts.isFunctionLike); + return declaration ? getSignatureFromDeclaration(declaration) : undefined; + }, + isImplementationOfOverload: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.isFunctionLike); + return node ? isImplementationOfOverload(node) : undefined; + }, + getImmediateAliasedSymbol: getImmediateAliasedSymbol, + getAliasedSymbol: resolveAlias, + getEmitResolver: getEmitResolver, + getExportsOfModule: getExportsOfModuleAsArray, + getExportsAndPropertiesOfModule: getExportsAndPropertiesOfModule, + forEachExportAndPropertyOfModule: forEachExportAndPropertyOfModule, + getSymbolWalker: ts.createGetSymbolWalker(getRestTypeOfSignature, getTypePredicateOfSignature, getReturnTypeOfSignature, getBaseTypes, resolveStructuredTypeMembers, getTypeOfSymbol, getResolvedSymbol, getConstraintOfTypeParameter, ts.getFirstIdentifier, getTypeArguments), + getAmbientModules: getAmbientModules, + getJsxIntrinsicTagNamesAt: getJsxIntrinsicTagNamesAt, + isOptionalParameter: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.isParameter); + return node ? isOptionalParameter(node) : false; + }, + tryGetMemberInModuleExports: function (name, symbol) { return tryGetMemberInModuleExports(ts.escapeLeadingUnderscores(name), symbol); }, + tryGetMemberInModuleExportsAndProperties: function (name, symbol) { return tryGetMemberInModuleExportsAndProperties(ts.escapeLeadingUnderscores(name), symbol); }, + tryFindAmbientModule: function (moduleName) { return tryFindAmbientModule(moduleName, /*withAugmentations*/ true); }, + tryFindAmbientModuleWithoutAugmentations: function (moduleName) { + // we deliberately exclude augmentations + // since we are only interested in declarations of the module itself + return tryFindAmbientModule(moduleName, /*withAugmentations*/ false); + }, + getApparentType: getApparentType, + getUnionType: getUnionType, + isTypeAssignableTo: isTypeAssignableTo, + createAnonymousType: createAnonymousType, + createSignature: createSignature, + createSymbol: createSymbol, + createIndexInfo: createIndexInfo, + getAnyType: function () { return anyType; }, + getStringType: function () { return stringType; }, + getNumberType: function () { return numberType; }, + createPromiseType: createPromiseType, + createArrayType: createArrayType, + getElementTypeOfArrayType: getElementTypeOfArrayType, + getBooleanType: function () { return booleanType; }, + getFalseType: function (fresh) { return fresh ? falseType : regularFalseType; }, + getTrueType: function (fresh) { return fresh ? trueType : regularTrueType; }, + getVoidType: function () { return voidType; }, + getUndefinedType: function () { return undefinedType; }, + getNullType: function () { return nullType; }, + getESSymbolType: function () { return esSymbolType; }, + getNeverType: function () { return neverType; }, + getOptionalType: function () { return optionalType; }, + getPromiseType: function () { return getGlobalPromiseType(/*reportErrors*/ false); }, + getPromiseLikeType: function () { return getGlobalPromiseLikeType(/*reportErrors*/ false); }, + getAsyncIterableType: function () { + var type = getGlobalAsyncIterableType(/*reportErrors*/ false); + if (type === emptyGenericType) + return undefined; + return type; + }, + isSymbolAccessible: isSymbolAccessible, + isArrayType: isArrayType, + isTupleType: isTupleType, + isArrayLikeType: isArrayLikeType, + isTypeInvalidDueToUnionDiscriminant: isTypeInvalidDueToUnionDiscriminant, + getExactOptionalProperties: getExactOptionalProperties, + getAllPossiblePropertiesOfTypes: getAllPossiblePropertiesOfTypes, + getSuggestedSymbolForNonexistentProperty: getSuggestedSymbolForNonexistentProperty, + getSuggestionForNonexistentProperty: getSuggestionForNonexistentProperty, + getSuggestedSymbolForNonexistentJSXAttribute: getSuggestedSymbolForNonexistentJSXAttribute, + getSuggestedSymbolForNonexistentSymbol: function (location, name, meaning) { return getSuggestedSymbolForNonexistentSymbol(location, ts.escapeLeadingUnderscores(name), meaning); }, + getSuggestionForNonexistentSymbol: function (location, name, meaning) { return getSuggestionForNonexistentSymbol(location, ts.escapeLeadingUnderscores(name), meaning); }, + getSuggestedSymbolForNonexistentModule: getSuggestedSymbolForNonexistentModule, + getSuggestionForNonexistentExport: getSuggestionForNonexistentExport, + getSuggestedSymbolForNonexistentClassMember: getSuggestedSymbolForNonexistentClassMember, + getBaseConstraintOfType: getBaseConstraintOfType, + getDefaultFromTypeParameter: function (type) { return type && type.flags & 262144 /* TypeFlags.TypeParameter */ ? getDefaultFromTypeParameter(type) : undefined; }, + resolveName: function (name, location, meaning, excludeGlobals) { + return resolveName(location, ts.escapeLeadingUnderscores(name), meaning, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false, excludeGlobals); + }, + getJsxNamespace: function (n) { return ts.unescapeLeadingUnderscores(getJsxNamespace(n)); }, + getJsxFragmentFactory: function (n) { + var jsxFragmentFactory = getJsxFragmentFactoryEntity(n); + return jsxFragmentFactory && ts.unescapeLeadingUnderscores(ts.getFirstIdentifier(jsxFragmentFactory).escapedText); + }, + getAccessibleSymbolChain: getAccessibleSymbolChain, + getTypePredicateOfSignature: getTypePredicateOfSignature, + resolveExternalModuleName: function (moduleSpecifierIn) { + var moduleSpecifier = ts.getParseTreeNode(moduleSpecifierIn, ts.isExpression); + return moduleSpecifier && resolveExternalModuleName(moduleSpecifier, moduleSpecifier, /*ignoreErrors*/ true); + }, + resolveExternalModuleSymbol: resolveExternalModuleSymbol, + tryGetThisTypeAt: function (nodeIn, includeGlobalThis, container) { + var node = ts.getParseTreeNode(nodeIn); + return node && tryGetThisTypeAt(node, includeGlobalThis, container); + }, + getTypeArgumentConstraint: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.isTypeNode); + return node && getTypeArgumentConstraint(node); + }, + getSuggestionDiagnostics: function (fileIn, ct) { + var file = ts.getParseTreeNode(fileIn, ts.isSourceFile) || ts.Debug.fail("Could not determine parsed source file."); + if (ts.skipTypeChecking(file, compilerOptions, host)) { + return ts.emptyArray; + } + var diagnostics; + try { + // Record the cancellation token so it can be checked later on during checkSourceElement. + // Do this in a finally block so we can ensure that it gets reset back to nothing after + // this call is done. + cancellationToken = ct; + // Ensure file is type checked, with _eager_ diagnostic production, so identifiers are registered as potentially unused + checkSourceFileWithEagerDiagnostics(file); + ts.Debug.assert(!!(getNodeLinks(file).flags & 1 /* NodeCheckFlags.TypeChecked */)); + diagnostics = ts.addRange(diagnostics, suggestionDiagnostics.getDiagnostics(file.fileName)); + checkUnusedIdentifiers(getPotentiallyUnusedIdentifiers(file), function (containingNode, kind, diag) { + if (!ts.containsParseError(containingNode) && !unusedIsError(kind, !!(containingNode.flags & 16777216 /* NodeFlags.Ambient */))) { + (diagnostics || (diagnostics = [])).push(__assign(__assign({}, diag), { category: ts.DiagnosticCategory.Suggestion })); + } + }); + return diagnostics || ts.emptyArray; + } + finally { + cancellationToken = undefined; + } + }, + runWithCancellationToken: function (token, callback) { + try { + cancellationToken = token; + return callback(checker); + } + finally { + cancellationToken = undefined; + } + }, + getLocalTypeParametersOfClassOrInterfaceOrTypeAlias: getLocalTypeParametersOfClassOrInterfaceOrTypeAlias, + isDeclarationVisible: isDeclarationVisible, + isPropertyAccessible: isPropertyAccessible, + getTypeOnlyAliasDeclaration: getTypeOnlyAliasDeclaration, + getMemberOverrideModifierStatus: getMemberOverrideModifierStatus, + isTypeParameterPossiblyReferenced: isTypeParameterPossiblyReferenced, + }; + function runWithInferenceBlockedFromSourceNode(node, fn) { + var containingCall = ts.findAncestor(node, ts.isCallLikeExpression); + var containingCallResolvedSignature = containingCall && getNodeLinks(containingCall).resolvedSignature; + if (containingCall) { + var toMarkSkip = node; + do { + getNodeLinks(toMarkSkip).skipDirectInference = true; + toMarkSkip = toMarkSkip.parent; + } while (toMarkSkip && toMarkSkip !== containingCall); + getNodeLinks(containingCall).resolvedSignature = undefined; + } + var result = fn(); + if (containingCall) { + var toMarkSkip = node; + do { + getNodeLinks(toMarkSkip).skipDirectInference = undefined; + toMarkSkip = toMarkSkip.parent; + } while (toMarkSkip && toMarkSkip !== containingCall); + getNodeLinks(containingCall).resolvedSignature = containingCallResolvedSignature; + } + return result; + } + function getResolvedSignatureWorker(nodeIn, candidatesOutArray, argumentCount, checkMode, editingArgument) { + var node = ts.getParseTreeNode(nodeIn, ts.isCallLikeExpression); + apparentArgumentCount = argumentCount; + var res = !node ? undefined : + editingArgument ? runWithInferenceBlockedFromSourceNode(editingArgument, function () { return getResolvedSignature(node, candidatesOutArray, checkMode); }) : + getResolvedSignature(node, candidatesOutArray, checkMode); + apparentArgumentCount = undefined; + return res; + } + var tupleTypes = new ts.Map(); + var unionTypes = new ts.Map(); + var intersectionTypes = new ts.Map(); + var stringLiteralTypes = new ts.Map(); + var numberLiteralTypes = new ts.Map(); + var bigIntLiteralTypes = new ts.Map(); + var enumLiteralTypes = new ts.Map(); + var indexedAccessTypes = new ts.Map(); + var templateLiteralTypes = new ts.Map(); + var stringMappingTypes = new ts.Map(); + var substitutionTypes = new ts.Map(); + var subtypeReductionCache = new ts.Map(); + var cachedTypes = new ts.Map(); + var evolvingArrayTypes = []; + var undefinedProperties = new ts.Map(); + var markerTypes = new ts.Set(); + var unknownSymbol = createSymbol(4 /* SymbolFlags.Property */, "unknown"); + var resolvingSymbol = createSymbol(0, "__resolving__" /* InternalSymbolName.Resolving */); + var unresolvedSymbols = new ts.Map(); + var errorTypes = new ts.Map(); + var anyType = createIntrinsicType(1 /* TypeFlags.Any */, "any"); + var autoType = createIntrinsicType(1 /* TypeFlags.Any */, "any", 262144 /* ObjectFlags.NonInferrableType */); + var wildcardType = createIntrinsicType(1 /* TypeFlags.Any */, "any"); + var errorType = createIntrinsicType(1 /* TypeFlags.Any */, "error"); + var unresolvedType = createIntrinsicType(1 /* TypeFlags.Any */, "unresolved"); + var nonInferrableAnyType = createIntrinsicType(1 /* TypeFlags.Any */, "any", 65536 /* ObjectFlags.ContainsWideningType */); + var intrinsicMarkerType = createIntrinsicType(1 /* TypeFlags.Any */, "intrinsic"); + var unknownType = createIntrinsicType(2 /* TypeFlags.Unknown */, "unknown"); + var nonNullUnknownType = createIntrinsicType(2 /* TypeFlags.Unknown */, "unknown"); + var undefinedType = createIntrinsicType(32768 /* TypeFlags.Undefined */, "undefined"); + var undefinedWideningType = strictNullChecks ? undefinedType : createIntrinsicType(32768 /* TypeFlags.Undefined */, "undefined", 65536 /* ObjectFlags.ContainsWideningType */); + var optionalType = createIntrinsicType(32768 /* TypeFlags.Undefined */, "undefined"); + var missingType = exactOptionalPropertyTypes ? createIntrinsicType(32768 /* TypeFlags.Undefined */, "undefined") : undefinedType; + var nullType = createIntrinsicType(65536 /* TypeFlags.Null */, "null"); + var nullWideningType = strictNullChecks ? nullType : createIntrinsicType(65536 /* TypeFlags.Null */, "null", 65536 /* ObjectFlags.ContainsWideningType */); + var stringType = createIntrinsicType(4 /* TypeFlags.String */, "string"); + var numberType = createIntrinsicType(8 /* TypeFlags.Number */, "number"); + var bigintType = createIntrinsicType(64 /* TypeFlags.BigInt */, "bigint"); + var falseType = createIntrinsicType(512 /* TypeFlags.BooleanLiteral */, "false"); + var regularFalseType = createIntrinsicType(512 /* TypeFlags.BooleanLiteral */, "false"); + var trueType = createIntrinsicType(512 /* TypeFlags.BooleanLiteral */, "true"); + var regularTrueType = createIntrinsicType(512 /* TypeFlags.BooleanLiteral */, "true"); + trueType.regularType = regularTrueType; + trueType.freshType = trueType; + regularTrueType.regularType = regularTrueType; + regularTrueType.freshType = trueType; + falseType.regularType = regularFalseType; + falseType.freshType = falseType; + regularFalseType.regularType = regularFalseType; + regularFalseType.freshType = falseType; + var booleanType = getUnionType([regularFalseType, regularTrueType]); + var esSymbolType = createIntrinsicType(4096 /* TypeFlags.ESSymbol */, "symbol"); + var voidType = createIntrinsicType(16384 /* TypeFlags.Void */, "void"); + var neverType = createIntrinsicType(131072 /* TypeFlags.Never */, "never"); + var silentNeverType = createIntrinsicType(131072 /* TypeFlags.Never */, "never", 262144 /* ObjectFlags.NonInferrableType */); + var implicitNeverType = createIntrinsicType(131072 /* TypeFlags.Never */, "never"); + var unreachableNeverType = createIntrinsicType(131072 /* TypeFlags.Never */, "never"); + var nonPrimitiveType = createIntrinsicType(67108864 /* TypeFlags.NonPrimitive */, "object"); + var stringOrNumberType = getUnionType([stringType, numberType]); + var stringNumberSymbolType = getUnionType([stringType, numberType, esSymbolType]); + var keyofConstraintType = keyofStringsOnly ? stringType : stringNumberSymbolType; + var numberOrBigIntType = getUnionType([numberType, bigintType]); + var templateConstraintType = getUnionType([stringType, numberType, booleanType, bigintType, nullType, undefinedType]); + var numericStringType = getTemplateLiteralType(["", ""], [numberType]); // The `${number}` type + var restrictiveMapper = makeFunctionTypeMapper(function (t) { return t.flags & 262144 /* TypeFlags.TypeParameter */ ? getRestrictiveTypeParameter(t) : t; }, function () { return "(restrictive mapper)"; }); + var permissiveMapper = makeFunctionTypeMapper(function (t) { return t.flags & 262144 /* TypeFlags.TypeParameter */ ? wildcardType : t; }, function () { return "(permissive mapper)"; }); + var uniqueLiteralType = createIntrinsicType(131072 /* TypeFlags.Never */, "never"); // `uniqueLiteralType` is a special `never` flagged by union reduction to behave as a literal + var uniqueLiteralMapper = makeFunctionTypeMapper(function (t) { return t.flags & 262144 /* TypeFlags.TypeParameter */ ? uniqueLiteralType : t; }, function () { return "(unique literal mapper)"; }); // replace all type parameters with the unique literal type (disregarding constraints) + var outofbandVarianceMarkerHandler; + var reportUnreliableMapper = makeFunctionTypeMapper(function (t) { + if (outofbandVarianceMarkerHandler && (t === markerSuperType || t === markerSubType || t === markerOtherType)) { + outofbandVarianceMarkerHandler(/*onlyUnreliable*/ true); + } + return t; + }, function () { return "(unmeasurable reporter)"; }); + var reportUnmeasurableMapper = makeFunctionTypeMapper(function (t) { + if (outofbandVarianceMarkerHandler && (t === markerSuperType || t === markerSubType || t === markerOtherType)) { + outofbandVarianceMarkerHandler(/*onlyUnreliable*/ false); + } + return t; + }, function () { return "(unreliable reporter)"; }); + var emptyObjectType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray); + var emptyJsxObjectType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray); + emptyJsxObjectType.objectFlags |= 2048 /* ObjectFlags.JsxAttributes */; + var emptyTypeLiteralSymbol = createSymbol(2048 /* SymbolFlags.TypeLiteral */, "__type" /* InternalSymbolName.Type */); + emptyTypeLiteralSymbol.members = ts.createSymbolTable(); + var emptyTypeLiteralType = createAnonymousType(emptyTypeLiteralSymbol, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray); + var unknownEmptyObjectType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray); + var unknownUnionType = strictNullChecks ? getUnionType([undefinedType, nullType, unknownEmptyObjectType]) : unknownType; + var emptyGenericType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray); + emptyGenericType.instantiations = new ts.Map(); + var anyFunctionType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray); + // The anyFunctionType contains the anyFunctionType by definition. The flag is further propagated + // in getPropagatingFlagsOfTypes, and it is checked in inferFromTypes. + anyFunctionType.objectFlags |= 262144 /* ObjectFlags.NonInferrableType */; + var noConstraintType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray); + var circularConstraintType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray); + var resolvingDefaultType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray); + var markerSuperType = createTypeParameter(); + var markerSubType = createTypeParameter(); + markerSubType.constraint = markerSuperType; + var markerOtherType = createTypeParameter(); + var markerSuperTypeForCheck = createTypeParameter(); + var markerSubTypeForCheck = createTypeParameter(); + markerSubTypeForCheck.constraint = markerSuperTypeForCheck; + var noTypePredicate = createTypePredicate(1 /* TypePredicateKind.Identifier */, "<>", 0, anyType); + var anySignature = createSignature(undefined, undefined, undefined, ts.emptyArray, anyType, /*resolvedTypePredicate*/ undefined, 0, 0 /* SignatureFlags.None */); + var unknownSignature = createSignature(undefined, undefined, undefined, ts.emptyArray, errorType, /*resolvedTypePredicate*/ undefined, 0, 0 /* SignatureFlags.None */); + var resolvingSignature = createSignature(undefined, undefined, undefined, ts.emptyArray, anyType, /*resolvedTypePredicate*/ undefined, 0, 0 /* SignatureFlags.None */); + var silentNeverSignature = createSignature(undefined, undefined, undefined, ts.emptyArray, silentNeverType, /*resolvedTypePredicate*/ undefined, 0, 0 /* SignatureFlags.None */); + var enumNumberIndexInfo = createIndexInfo(numberType, stringType, /*isReadonly*/ true); + var iterationTypesCache = new ts.Map(); // cache for common IterationTypes instances + var noIterationTypes = { + get yieldType() { return ts.Debug.fail("Not supported"); }, + get returnType() { return ts.Debug.fail("Not supported"); }, + get nextType() { return ts.Debug.fail("Not supported"); }, + }; + var anyIterationTypes = createIterationTypes(anyType, anyType, anyType); + var anyIterationTypesExceptNext = createIterationTypes(anyType, anyType, unknownType); + var defaultIterationTypes = createIterationTypes(neverType, anyType, undefinedType); // default iteration types for `Iterator`. + var asyncIterationTypesResolver = { + iterableCacheKey: "iterationTypesOfAsyncIterable", + iteratorCacheKey: "iterationTypesOfAsyncIterator", + iteratorSymbolName: "asyncIterator", + getGlobalIteratorType: getGlobalAsyncIteratorType, + getGlobalIterableType: getGlobalAsyncIterableType, + getGlobalIterableIteratorType: getGlobalAsyncIterableIteratorType, + getGlobalGeneratorType: getGlobalAsyncGeneratorType, + resolveIterationType: getAwaitedType, + mustHaveANextMethodDiagnostic: ts.Diagnostics.An_async_iterator_must_have_a_next_method, + mustBeAMethodDiagnostic: ts.Diagnostics.The_0_property_of_an_async_iterator_must_be_a_method, + mustHaveAValueDiagnostic: ts.Diagnostics.The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property, + }; + var syncIterationTypesResolver = { + iterableCacheKey: "iterationTypesOfIterable", + iteratorCacheKey: "iterationTypesOfIterator", + iteratorSymbolName: "iterator", + getGlobalIteratorType: getGlobalIteratorType, + getGlobalIterableType: getGlobalIterableType, + getGlobalIterableIteratorType: getGlobalIterableIteratorType, + getGlobalGeneratorType: getGlobalGeneratorType, + resolveIterationType: function (type, _errorNode) { return type; }, + mustHaveANextMethodDiagnostic: ts.Diagnostics.An_iterator_must_have_a_next_method, + mustBeAMethodDiagnostic: ts.Diagnostics.The_0_property_of_an_iterator_must_be_a_method, + mustHaveAValueDiagnostic: ts.Diagnostics.The_type_returned_by_the_0_method_of_an_iterator_must_have_a_value_property, + }; + /** Key is "/path/to/a.ts|/path/to/b.ts". */ + var amalgamatedDuplicates; + var reverseMappedCache = new ts.Map(); + var inInferTypeForHomomorphicMappedType = false; + var ambientModulesCache; + /** + * List of every ambient module with a "*" wildcard. + * Unlike other ambient modules, these can't be stored in `globals` because symbol tables only deal with exact matches. + * This is only used if there is no exact match. + */ + var patternAmbientModules; + var patternAmbientModuleAugmentations; + var globalObjectType; + var globalFunctionType; + var globalCallableFunctionType; + var globalNewableFunctionType; + var globalArrayType; + var globalReadonlyArrayType; + var globalStringType; + var globalNumberType; + var globalBooleanType; + var globalRegExpType; + var globalThisType; + var anyArrayType; + var autoArrayType; + var anyReadonlyArrayType; + var deferredGlobalNonNullableTypeAlias; + // The library files are only loaded when the feature is used. + // This allows users to just specify library files they want to used through --lib + // and they will not get an error from not having unrelated library files + var deferredGlobalESSymbolConstructorSymbol; + var deferredGlobalESSymbolConstructorTypeSymbol; + var deferredGlobalESSymbolType; + var deferredGlobalTypedPropertyDescriptorType; + var deferredGlobalPromiseType; + var deferredGlobalPromiseLikeType; + var deferredGlobalPromiseConstructorSymbol; + var deferredGlobalPromiseConstructorLikeType; + var deferredGlobalIterableType; + var deferredGlobalIteratorType; + var deferredGlobalIterableIteratorType; + var deferredGlobalGeneratorType; + var deferredGlobalIteratorYieldResultType; + var deferredGlobalIteratorReturnResultType; + var deferredGlobalAsyncIterableType; + var deferredGlobalAsyncIteratorType; + var deferredGlobalAsyncIterableIteratorType; + var deferredGlobalAsyncGeneratorType; + var deferredGlobalTemplateStringsArrayType; + var deferredGlobalImportMetaType; + var deferredGlobalImportMetaExpressionType; + var deferredGlobalImportCallOptionsType; + var deferredGlobalExtractSymbol; + var deferredGlobalOmitSymbol; + var deferredGlobalAwaitedSymbol; + var deferredGlobalBigIntType; + var deferredGlobalNaNSymbol; + var deferredGlobalRecordSymbol; + var allPotentiallyUnusedIdentifiers = new ts.Map(); // key is file name + var flowLoopStart = 0; + var flowLoopCount = 0; + var sharedFlowCount = 0; + var flowAnalysisDisabled = false; + var flowInvocationCount = 0; + var lastFlowNode; + var lastFlowNodeReachable; + var flowTypeCache; + var emptyStringType = getStringLiteralType(""); + var zeroType = getNumberLiteralType(0); + var zeroBigIntType = getBigIntLiteralType({ negative: false, base10Value: "0" }); + var resolutionTargets = []; + var resolutionResults = []; + var resolutionPropertyNames = []; + var suggestionCount = 0; + var maximumSuggestionCount = 10; + var mergedSymbols = []; + var symbolLinks = []; + var nodeLinks = []; + var flowLoopCaches = []; + var flowLoopNodes = []; + var flowLoopKeys = []; + var flowLoopTypes = []; + var sharedFlowNodes = []; + var sharedFlowTypes = []; + var flowNodeReachable = []; + var flowNodePostSuper = []; + var potentialThisCollisions = []; + var potentialNewTargetCollisions = []; + var potentialWeakMapSetCollisions = []; + var potentialReflectCollisions = []; + var potentialUnusedRenamedBindingElementsInTypes = []; + var awaitedTypeStack = []; + var diagnostics = ts.createDiagnosticCollection(); + var suggestionDiagnostics = ts.createDiagnosticCollection(); + var typeofType = createTypeofType(); + var _jsxNamespace; + var _jsxFactoryEntity; + var subtypeRelation = new ts.Map(); + var strictSubtypeRelation = new ts.Map(); + var assignableRelation = new ts.Map(); + var comparableRelation = new ts.Map(); + var identityRelation = new ts.Map(); + var enumRelation = new ts.Map(); + var builtinGlobals = ts.createSymbolTable(); + builtinGlobals.set(undefinedSymbol.escapedName, undefinedSymbol); + // Extensions suggested for path imports when module resolution is node16 or higher. + // The first element of each tuple is the extension a file has. + // The second element of each tuple is the extension that should be used in a path import. + // e.g. if we want to import file `foo.mts`, we should write `import {} from "./foo.mjs". + var suggestedExtensions = [ + [".mts", ".mjs"], + [".ts", ".js"], + [".cts", ".cjs"], + [".mjs", ".mjs"], + [".js", ".js"], + [".cjs", ".cjs"], + [".tsx", compilerOptions.jsx === 1 /* JsxEmit.Preserve */ ? ".jsx" : ".js"], + [".jsx", ".jsx"], + [".json", ".json"], + ]; + initializeTypeChecker(); + return checker; + function getCachedType(key) { + return key ? cachedTypes.get(key) : undefined; + } + function setCachedType(key, type) { + if (key) + cachedTypes.set(key, type); + return type; + } + function getJsxNamespace(location) { + if (location) { + var file = ts.getSourceFileOfNode(location); + if (file) { + if (ts.isJsxOpeningFragment(location)) { + if (file.localJsxFragmentNamespace) { + return file.localJsxFragmentNamespace; + } + var jsxFragmentPragma = file.pragmas.get("jsxfrag"); + if (jsxFragmentPragma) { + var chosenPragma = ts.isArray(jsxFragmentPragma) ? jsxFragmentPragma[0] : jsxFragmentPragma; + file.localJsxFragmentFactory = ts.parseIsolatedEntityName(chosenPragma.arguments.factory, languageVersion); + ts.visitNode(file.localJsxFragmentFactory, markAsSynthetic); + if (file.localJsxFragmentFactory) { + return file.localJsxFragmentNamespace = ts.getFirstIdentifier(file.localJsxFragmentFactory).escapedText; + } + } + var entity = getJsxFragmentFactoryEntity(location); + if (entity) { + file.localJsxFragmentFactory = entity; + return file.localJsxFragmentNamespace = ts.getFirstIdentifier(entity).escapedText; + } + } + else { + var localJsxNamespace = getLocalJsxNamespace(file); + if (localJsxNamespace) { + return file.localJsxNamespace = localJsxNamespace; + } + } + } + } + if (!_jsxNamespace) { + _jsxNamespace = "React"; + if (compilerOptions.jsxFactory) { + _jsxFactoryEntity = ts.parseIsolatedEntityName(compilerOptions.jsxFactory, languageVersion); + ts.visitNode(_jsxFactoryEntity, markAsSynthetic); + if (_jsxFactoryEntity) { + _jsxNamespace = ts.getFirstIdentifier(_jsxFactoryEntity).escapedText; + } + } + else if (compilerOptions.reactNamespace) { + _jsxNamespace = ts.escapeLeadingUnderscores(compilerOptions.reactNamespace); + } + } + if (!_jsxFactoryEntity) { + _jsxFactoryEntity = ts.factory.createQualifiedName(ts.factory.createIdentifier(ts.unescapeLeadingUnderscores(_jsxNamespace)), "createElement"); + } + return _jsxNamespace; + } + function getLocalJsxNamespace(file) { + if (file.localJsxNamespace) { + return file.localJsxNamespace; + } + var jsxPragma = file.pragmas.get("jsx"); + if (jsxPragma) { + var chosenPragma = ts.isArray(jsxPragma) ? jsxPragma[0] : jsxPragma; + file.localJsxFactory = ts.parseIsolatedEntityName(chosenPragma.arguments.factory, languageVersion); + ts.visitNode(file.localJsxFactory, markAsSynthetic); + if (file.localJsxFactory) { + return file.localJsxNamespace = ts.getFirstIdentifier(file.localJsxFactory).escapedText; + } + } + } + function markAsSynthetic(node) { + ts.setTextRangePosEnd(node, -1, -1); + return ts.visitEachChild(node, markAsSynthetic, ts.nullTransformationContext); + } + function getEmitResolver(sourceFile, cancellationToken) { + // Ensure we have all the type information in place for this file so that all the + // emitter questions of this resolver will return the right information. + getDiagnostics(sourceFile, cancellationToken); + return emitResolver; + } + function lookupOrIssueError(location, message, arg0, arg1, arg2, arg3) { + var diagnostic = location + ? ts.createDiagnosticForNode(location, message, arg0, arg1, arg2, arg3) + : ts.createCompilerDiagnostic(message, arg0, arg1, arg2, arg3); + var existing = diagnostics.lookup(diagnostic); + if (existing) { + return existing; + } + else { + diagnostics.add(diagnostic); + return diagnostic; + } + } + function errorSkippedOn(key, location, message, arg0, arg1, arg2, arg3) { + var diagnostic = error(location, message, arg0, arg1, arg2, arg3); + diagnostic.skippedOn = key; + return diagnostic; + } + function createError(location, message, arg0, arg1, arg2, arg3) { + return location + ? ts.createDiagnosticForNode(location, message, arg0, arg1, arg2, arg3) + : ts.createCompilerDiagnostic(message, arg0, arg1, arg2, arg3); + } + function error(location, message, arg0, arg1, arg2, arg3) { + var diagnostic = createError(location, message, arg0, arg1, arg2, arg3); + diagnostics.add(diagnostic); + return diagnostic; + } + function addErrorOrSuggestion(isError, diagnostic) { + if (isError) { + diagnostics.add(diagnostic); + } + else { + suggestionDiagnostics.add(__assign(__assign({}, diagnostic), { category: ts.DiagnosticCategory.Suggestion })); + } + } + function errorOrSuggestion(isError, location, message, arg0, arg1, arg2, arg3) { + // Pseudo-synthesized input node + if (location.pos < 0 || location.end < 0) { + if (!isError) { + return; // Drop suggestions (we have no span to suggest on) + } + // Issue errors globally + var file = ts.getSourceFileOfNode(location); + addErrorOrSuggestion(isError, "message" in message ? ts.createFileDiagnostic(file, 0, 0, message, arg0, arg1, arg2, arg3) : ts.createDiagnosticForFileFromMessageChain(file, message)); // eslint-disable-line local/no-in-operator + return; + } + addErrorOrSuggestion(isError, "message" in message ? ts.createDiagnosticForNode(location, message, arg0, arg1, arg2, arg3) : ts.createDiagnosticForNodeFromMessageChain(location, message)); // eslint-disable-line local/no-in-operator + } + function errorAndMaybeSuggestAwait(location, maybeMissingAwait, message, arg0, arg1, arg2, arg3) { + var diagnostic = error(location, message, arg0, arg1, arg2, arg3); + if (maybeMissingAwait) { + var related = ts.createDiagnosticForNode(location, ts.Diagnostics.Did_you_forget_to_use_await); + ts.addRelatedInfo(diagnostic, related); + } + return diagnostic; + } + function addDeprecatedSuggestionWorker(declarations, diagnostic) { + var deprecatedTag = Array.isArray(declarations) ? ts.forEach(declarations, ts.getJSDocDeprecatedTag) : ts.getJSDocDeprecatedTag(declarations); + if (deprecatedTag) { + ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(deprecatedTag, ts.Diagnostics.The_declaration_was_marked_as_deprecated_here)); + } + // We call `addRelatedInfo()` before adding the diagnostic to prevent duplicates. + suggestionDiagnostics.add(diagnostic); + return diagnostic; + } + function isDeprecatedSymbol(symbol) { + return !!(getDeclarationNodeFlagsFromSymbol(symbol) & 268435456 /* NodeFlags.Deprecated */); + } + function addDeprecatedSuggestion(location, declarations, deprecatedEntity) { + var diagnostic = ts.createDiagnosticForNode(location, ts.Diagnostics._0_is_deprecated, deprecatedEntity); + return addDeprecatedSuggestionWorker(declarations, diagnostic); + } + function addDeprecatedSuggestionWithSignature(location, declaration, deprecatedEntity, signatureString) { + var diagnostic = deprecatedEntity + ? ts.createDiagnosticForNode(location, ts.Diagnostics.The_signature_0_of_1_is_deprecated, signatureString, deprecatedEntity) + : ts.createDiagnosticForNode(location, ts.Diagnostics._0_is_deprecated, signatureString); + return addDeprecatedSuggestionWorker(declaration, diagnostic); + } + function createSymbol(flags, name, checkFlags) { + symbolCount++; + var symbol = new Symbol(flags | 33554432 /* SymbolFlags.Transient */, name); + symbol.checkFlags = checkFlags || 0; + return symbol; + } + function getExcludedSymbolFlags(flags) { + var result = 0; + if (flags & 2 /* SymbolFlags.BlockScopedVariable */) + result |= 111551 /* SymbolFlags.BlockScopedVariableExcludes */; + if (flags & 1 /* SymbolFlags.FunctionScopedVariable */) + result |= 111550 /* SymbolFlags.FunctionScopedVariableExcludes */; + if (flags & 4 /* SymbolFlags.Property */) + result |= 0 /* SymbolFlags.PropertyExcludes */; + if (flags & 8 /* SymbolFlags.EnumMember */) + result |= 900095 /* SymbolFlags.EnumMemberExcludes */; + if (flags & 16 /* SymbolFlags.Function */) + result |= 110991 /* SymbolFlags.FunctionExcludes */; + if (flags & 32 /* SymbolFlags.Class */) + result |= 899503 /* SymbolFlags.ClassExcludes */; + if (flags & 64 /* SymbolFlags.Interface */) + result |= 788872 /* SymbolFlags.InterfaceExcludes */; + if (flags & 256 /* SymbolFlags.RegularEnum */) + result |= 899327 /* SymbolFlags.RegularEnumExcludes */; + if (flags & 128 /* SymbolFlags.ConstEnum */) + result |= 899967 /* SymbolFlags.ConstEnumExcludes */; + if (flags & 512 /* SymbolFlags.ValueModule */) + result |= 110735 /* SymbolFlags.ValueModuleExcludes */; + if (flags & 8192 /* SymbolFlags.Method */) + result |= 103359 /* SymbolFlags.MethodExcludes */; + if (flags & 32768 /* SymbolFlags.GetAccessor */) + result |= 46015 /* SymbolFlags.GetAccessorExcludes */; + if (flags & 65536 /* SymbolFlags.SetAccessor */) + result |= 78783 /* SymbolFlags.SetAccessorExcludes */; + if (flags & 262144 /* SymbolFlags.TypeParameter */) + result |= 526824 /* SymbolFlags.TypeParameterExcludes */; + if (flags & 524288 /* SymbolFlags.TypeAlias */) + result |= 788968 /* SymbolFlags.TypeAliasExcludes */; + if (flags & 2097152 /* SymbolFlags.Alias */) + result |= 2097152 /* SymbolFlags.AliasExcludes */; + return result; + } + function recordMergedSymbol(target, source) { + if (!source.mergeId) { + source.mergeId = nextMergeId; + nextMergeId++; + } + mergedSymbols[source.mergeId] = target; + } + function cloneSymbol(symbol) { + var result = createSymbol(symbol.flags, symbol.escapedName); + result.declarations = symbol.declarations ? symbol.declarations.slice() : []; + result.parent = symbol.parent; + if (symbol.valueDeclaration) + result.valueDeclaration = symbol.valueDeclaration; + if (symbol.constEnumOnlyModule) + result.constEnumOnlyModule = true; + if (symbol.members) + result.members = new ts.Map(symbol.members); + if (symbol.exports) + result.exports = new ts.Map(symbol.exports); + recordMergedSymbol(result, symbol); + return result; + } + /** + * Note: if target is transient, then it is mutable, and mergeSymbol with both mutate and return it. + * If target is not transient, mergeSymbol will produce a transient clone, mutate that and return it. + */ + function mergeSymbol(target, source, unidirectional) { + if (unidirectional === void 0) { unidirectional = false; } + if (!(target.flags & getExcludedSymbolFlags(source.flags)) || + (source.flags | target.flags) & 67108864 /* SymbolFlags.Assignment */) { + if (source === target) { + // This can happen when an export assigned namespace exports something also erroneously exported at the top level + // See `declarationFileNoCrashOnExtraExportModifier` for an example + return target; + } + if (!(target.flags & 33554432 /* SymbolFlags.Transient */)) { + var resolvedTarget = resolveSymbol(target); + if (resolvedTarget === unknownSymbol) { + return source; + } + target = cloneSymbol(resolvedTarget); + } + // Javascript static-property-assignment declarations always merge, even though they are also values + if (source.flags & 512 /* SymbolFlags.ValueModule */ && target.flags & 512 /* SymbolFlags.ValueModule */ && target.constEnumOnlyModule && !source.constEnumOnlyModule) { + // reset flag when merging instantiated module into value module that has only const enums + target.constEnumOnlyModule = false; + } + target.flags |= source.flags; + if (source.valueDeclaration) { + ts.setValueDeclaration(target, source.valueDeclaration); + } + ts.addRange(target.declarations, source.declarations); + if (source.members) { + if (!target.members) + target.members = ts.createSymbolTable(); + mergeSymbolTable(target.members, source.members, unidirectional); + } + if (source.exports) { + if (!target.exports) + target.exports = ts.createSymbolTable(); + mergeSymbolTable(target.exports, source.exports, unidirectional); + } + if (!unidirectional) { + recordMergedSymbol(target, source); + } + } + else if (target.flags & 1024 /* SymbolFlags.NamespaceModule */) { + // Do not report an error when merging `var globalThis` with the built-in `globalThis`, + // as we will already report a "Declaration name conflicts..." error, and this error + // won't make much sense. + if (target !== globalThisSymbol) { + error(source.declarations && ts.getNameOfDeclaration(source.declarations[0]), ts.Diagnostics.Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity, symbolToString(target)); + } + } + else { // error + var isEitherEnum = !!(target.flags & 384 /* SymbolFlags.Enum */ || source.flags & 384 /* SymbolFlags.Enum */); + var isEitherBlockScoped_1 = !!(target.flags & 2 /* SymbolFlags.BlockScopedVariable */ || source.flags & 2 /* SymbolFlags.BlockScopedVariable */); + var message = isEitherEnum ? ts.Diagnostics.Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations + : isEitherBlockScoped_1 ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0 + : ts.Diagnostics.Duplicate_identifier_0; + var sourceSymbolFile = source.declarations && ts.getSourceFileOfNode(source.declarations[0]); + var targetSymbolFile = target.declarations && ts.getSourceFileOfNode(target.declarations[0]); + var isSourcePlainJs = ts.isPlainJsFile(sourceSymbolFile, compilerOptions.checkJs); + var isTargetPlainJs = ts.isPlainJsFile(targetSymbolFile, compilerOptions.checkJs); + var symbolName_1 = symbolToString(source); + // Collect top-level duplicate identifier errors into one mapping, so we can then merge their diagnostics if there are a bunch + if (sourceSymbolFile && targetSymbolFile && amalgamatedDuplicates && !isEitherEnum && sourceSymbolFile !== targetSymbolFile) { + var firstFile_1 = ts.comparePaths(sourceSymbolFile.path, targetSymbolFile.path) === -1 /* Comparison.LessThan */ ? sourceSymbolFile : targetSymbolFile; + var secondFile_1 = firstFile_1 === sourceSymbolFile ? targetSymbolFile : sourceSymbolFile; + var filesDuplicates = ts.getOrUpdate(amalgamatedDuplicates, "".concat(firstFile_1.path, "|").concat(secondFile_1.path), function () { + return ({ firstFile: firstFile_1, secondFile: secondFile_1, conflictingSymbols: new ts.Map() }); + }); + var conflictingSymbolInfo = ts.getOrUpdate(filesDuplicates.conflictingSymbols, symbolName_1, function () { + return ({ isBlockScoped: isEitherBlockScoped_1, firstFileLocations: [], secondFileLocations: [] }); + }); + if (!isSourcePlainJs) + addDuplicateLocations(conflictingSymbolInfo.firstFileLocations, source); + if (!isTargetPlainJs) + addDuplicateLocations(conflictingSymbolInfo.secondFileLocations, target); + } + else { + if (!isSourcePlainJs) + addDuplicateDeclarationErrorsForSymbols(source, message, symbolName_1, target); + if (!isTargetPlainJs) + addDuplicateDeclarationErrorsForSymbols(target, message, symbolName_1, source); + } + } + return target; + function addDuplicateLocations(locs, symbol) { + if (symbol.declarations) { + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + ts.pushIfUnique(locs, decl); + } + } + } + } + function addDuplicateDeclarationErrorsForSymbols(target, message, symbolName, source) { + ts.forEach(target.declarations, function (node) { + addDuplicateDeclarationError(node, message, symbolName, source.declarations); + }); + } + function addDuplicateDeclarationError(node, message, symbolName, relatedNodes) { + var errorNode = (ts.getExpandoInitializer(node, /*isPrototypeAssignment*/ false) ? ts.getNameOfExpando(node) : ts.getNameOfDeclaration(node)) || node; + var err = lookupOrIssueError(errorNode, message, symbolName); + var _loop_7 = function (relatedNode) { + var adjustedNode = (ts.getExpandoInitializer(relatedNode, /*isPrototypeAssignment*/ false) ? ts.getNameOfExpando(relatedNode) : ts.getNameOfDeclaration(relatedNode)) || relatedNode; + if (adjustedNode === errorNode) + return "continue"; + err.relatedInformation = err.relatedInformation || []; + var leadingMessage = ts.createDiagnosticForNode(adjustedNode, ts.Diagnostics._0_was_also_declared_here, symbolName); + var followOnMessage = ts.createDiagnosticForNode(adjustedNode, ts.Diagnostics.and_here); + if (ts.length(err.relatedInformation) >= 5 || ts.some(err.relatedInformation, function (r) { return ts.compareDiagnostics(r, followOnMessage) === 0 /* Comparison.EqualTo */ || ts.compareDiagnostics(r, leadingMessage) === 0 /* Comparison.EqualTo */; })) + return "continue"; + ts.addRelatedInfo(err, !ts.length(err.relatedInformation) ? leadingMessage : followOnMessage); + }; + for (var _i = 0, _a = relatedNodes || ts.emptyArray; _i < _a.length; _i++) { + var relatedNode = _a[_i]; + _loop_7(relatedNode); + } + } + function combineSymbolTables(first, second) { + if (!(first === null || first === void 0 ? void 0 : first.size)) + return second; + if (!(second === null || second === void 0 ? void 0 : second.size)) + return first; + var combined = ts.createSymbolTable(); + mergeSymbolTable(combined, first); + mergeSymbolTable(combined, second); + return combined; + } + function mergeSymbolTable(target, source, unidirectional) { + if (unidirectional === void 0) { unidirectional = false; } + source.forEach(function (sourceSymbol, id) { + var targetSymbol = target.get(id); + target.set(id, targetSymbol ? mergeSymbol(targetSymbol, sourceSymbol, unidirectional) : getMergedSymbol(sourceSymbol)); + }); + } + function mergeModuleAugmentation(moduleName) { + var _a, _b, _c; + var moduleAugmentation = moduleName.parent; + if (((_a = moduleAugmentation.symbol.declarations) === null || _a === void 0 ? void 0 : _a[0]) !== moduleAugmentation) { + // this is a combined symbol for multiple augmentations within the same file. + // its symbol already has accumulated information for all declarations + // so we need to add it just once - do the work only for first declaration + ts.Debug.assert(moduleAugmentation.symbol.declarations.length > 1); + return; + } + if (ts.isGlobalScopeAugmentation(moduleAugmentation)) { + mergeSymbolTable(globals, moduleAugmentation.symbol.exports); + } + else { + // find a module that about to be augmented + // do not validate names of augmentations that are defined in ambient context + var moduleNotFoundError = !(moduleName.parent.parent.flags & 16777216 /* NodeFlags.Ambient */) + ? ts.Diagnostics.Invalid_module_name_in_augmentation_module_0_cannot_be_found + : undefined; + var mainModule_1 = resolveExternalModuleNameWorker(moduleName, moduleName, moduleNotFoundError, /*isForAugmentation*/ true); + if (!mainModule_1) { + return; + } + // obtain item referenced by 'export=' + mainModule_1 = resolveExternalModuleSymbol(mainModule_1); + if (mainModule_1.flags & 1920 /* SymbolFlags.Namespace */) { + // If we're merging an augmentation to a pattern ambient module, we want to + // perform the merge unidirectionally from the augmentation ('a.foo') to + // the pattern ('*.foo'), so that 'getMergedSymbol()' on a.foo gives you + // all the exports both from the pattern and from the augmentation, but + // 'getMergedSymbol()' on *.foo only gives you exports from *.foo. + if (ts.some(patternAmbientModules, function (module) { return mainModule_1 === module.symbol; })) { + var merged = mergeSymbol(moduleAugmentation.symbol, mainModule_1, /*unidirectional*/ true); + if (!patternAmbientModuleAugmentations) { + patternAmbientModuleAugmentations = new ts.Map(); + } + // moduleName will be a StringLiteral since this is not `declare global`. + patternAmbientModuleAugmentations.set(moduleName.text, merged); + } + else { + if (((_b = mainModule_1.exports) === null || _b === void 0 ? void 0 : _b.get("__export" /* InternalSymbolName.ExportStar */)) && ((_c = moduleAugmentation.symbol.exports) === null || _c === void 0 ? void 0 : _c.size)) { + // We may need to merge the module augmentation's exports into the target symbols of the resolved exports + var resolvedExports = getResolvedMembersOrExportsOfSymbol(mainModule_1, "resolvedExports" /* MembersOrExportsResolutionKind.resolvedExports */); + for (var _i = 0, _d = ts.arrayFrom(moduleAugmentation.symbol.exports.entries()); _i < _d.length; _i++) { + var _e = _d[_i], key = _e[0], value = _e[1]; + if (resolvedExports.has(key) && !mainModule_1.exports.has(key)) { + mergeSymbol(resolvedExports.get(key), value); + } + } + } + mergeSymbol(mainModule_1, moduleAugmentation.symbol); + } + } + else { + // moduleName will be a StringLiteral since this is not `declare global`. + error(moduleName, ts.Diagnostics.Cannot_augment_module_0_because_it_resolves_to_a_non_module_entity, moduleName.text); + } + } + } + function addToSymbolTable(target, source, message) { + source.forEach(function (sourceSymbol, id) { + var targetSymbol = target.get(id); + if (targetSymbol) { + // Error on redeclarations + ts.forEach(targetSymbol.declarations, addDeclarationDiagnostic(ts.unescapeLeadingUnderscores(id), message)); + } + else { + target.set(id, sourceSymbol); + } + }); + function addDeclarationDiagnostic(id, message) { + return function (declaration) { return diagnostics.add(ts.createDiagnosticForNode(declaration, message, id)); }; + } + } + function getSymbolLinks(symbol) { + if (symbol.flags & 33554432 /* SymbolFlags.Transient */) + return symbol; + var id = getSymbolId(symbol); + return symbolLinks[id] || (symbolLinks[id] = new SymbolLinks()); + } + function getNodeLinks(node) { + var nodeId = getNodeId(node); + return nodeLinks[nodeId] || (nodeLinks[nodeId] = new NodeLinks()); + } + function isGlobalSourceFile(node) { + return node.kind === 308 /* SyntaxKind.SourceFile */ && !ts.isExternalOrCommonJsModule(node); + } + function getSymbol(symbols, name, meaning) { + if (meaning) { + var symbol = getMergedSymbol(symbols.get(name)); + if (symbol) { + ts.Debug.assert((ts.getCheckFlags(symbol) & 1 /* CheckFlags.Instantiated */) === 0, "Should never get an instantiated symbol here."); + if (symbol.flags & meaning) { + return symbol; + } + if (symbol.flags & 2097152 /* SymbolFlags.Alias */) { + var targetFlags = getAllSymbolFlags(symbol); + // `targetFlags` will be `SymbolFlags.All` if an error occurred in alias resolution; this avoids cascading errors + if (targetFlags & meaning) { + return symbol; + } + } + } + } + // return undefined if we can't find a symbol. + } + /** + * Get symbols that represent parameter-property-declaration as parameter and as property declaration + * @param parameter a parameterDeclaration node + * @param parameterName a name of the parameter to get the symbols for. + * @return a tuple of two symbols + */ + function getSymbolsOfParameterPropertyDeclaration(parameter, parameterName) { + var constructorDeclaration = parameter.parent; + var classDeclaration = parameter.parent.parent; + var parameterSymbol = getSymbol(constructorDeclaration.locals, parameterName, 111551 /* SymbolFlags.Value */); + var propertySymbol = getSymbol(getMembersOfSymbol(classDeclaration.symbol), parameterName, 111551 /* SymbolFlags.Value */); + if (parameterSymbol && propertySymbol) { + return [parameterSymbol, propertySymbol]; + } + return ts.Debug.fail("There should exist two symbols, one as property declaration and one as parameter declaration"); + } + function isBlockScopedNameDeclaredBeforeUse(declaration, usage) { + var declarationFile = ts.getSourceFileOfNode(declaration); + var useFile = ts.getSourceFileOfNode(usage); + var declContainer = ts.getEnclosingBlockScopeContainer(declaration); + if (declarationFile !== useFile) { + if ((moduleKind && (declarationFile.externalModuleIndicator || useFile.externalModuleIndicator)) || + (!ts.outFile(compilerOptions)) || + isInTypeQuery(usage) || + declaration.flags & 16777216 /* NodeFlags.Ambient */) { + // nodes are in different files and order cannot be determined + return true; + } + // declaration is after usage + // can be legal if usage is deferred (i.e. inside function or in initializer of instance property) + if (isUsedInFunctionOrInstanceProperty(usage, declaration)) { + return true; + } + var sourceFiles = host.getSourceFiles(); + return sourceFiles.indexOf(declarationFile) <= sourceFiles.indexOf(useFile); + } + if (declaration.pos <= usage.pos && !(ts.isPropertyDeclaration(declaration) && ts.isThisProperty(usage.parent) && !declaration.initializer && !declaration.exclamationToken)) { + // declaration is before usage + if (declaration.kind === 205 /* SyntaxKind.BindingElement */) { + // still might be illegal if declaration and usage are both binding elements (eg var [a = b, b = b] = [1, 2]) + var errorBindingElement = ts.getAncestor(usage, 205 /* SyntaxKind.BindingElement */); + if (errorBindingElement) { + return ts.findAncestor(errorBindingElement, ts.isBindingElement) !== ts.findAncestor(declaration, ts.isBindingElement) || + declaration.pos < errorBindingElement.pos; + } + // or it might be illegal if usage happens before parent variable is declared (eg var [a] = a) + return isBlockScopedNameDeclaredBeforeUse(ts.getAncestor(declaration, 257 /* SyntaxKind.VariableDeclaration */), usage); + } + else if (declaration.kind === 257 /* SyntaxKind.VariableDeclaration */) { + // still might be illegal if usage is in the initializer of the variable declaration (eg var a = a) + return !isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration, usage); + } + else if (ts.isClassDeclaration(declaration)) { + // still might be illegal if the usage is within a computed property name in the class (eg class A { static p = "a"; [A.p]() {} }) + return !ts.findAncestor(usage, function (n) { return ts.isComputedPropertyName(n) && n.parent.parent === declaration; }); + } + else if (ts.isPropertyDeclaration(declaration)) { + // still might be illegal if a self-referencing property initializer (eg private x = this.x) + return !isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, /*stopAtAnyPropertyDeclaration*/ false); + } + else if (ts.isParameterPropertyDeclaration(declaration, declaration.parent)) { + // foo = this.bar is illegal in esnext+useDefineForClassFields when bar is a parameter property + return !(ts.getEmitScriptTarget(compilerOptions) === 99 /* ScriptTarget.ESNext */ && useDefineForClassFields + && ts.getContainingClass(declaration) === ts.getContainingClass(usage) + && isUsedInFunctionOrInstanceProperty(usage, declaration)); + } + return true; + } + // declaration is after usage, but it can still be legal if usage is deferred: + // 1. inside an export specifier + // 2. inside a function + // 3. inside an instance property initializer, a reference to a non-instance property + // (except when target: "esnext" and useDefineForClassFields: true and the reference is to a parameter property) + // 4. inside a static property initializer, a reference to a static method in the same class + // 5. inside a TS export= declaration (since we will move the export statement during emit to avoid TDZ) + // or if usage is in a type context: + // 1. inside a type query (typeof in type position) + // 2. inside a jsdoc comment + if (usage.parent.kind === 278 /* SyntaxKind.ExportSpecifier */ || (usage.parent.kind === 274 /* SyntaxKind.ExportAssignment */ && usage.parent.isExportEquals)) { + // export specifiers do not use the variable, they only make it available for use + return true; + } + // When resolving symbols for exports, the `usage` location passed in can be the export site directly + if (usage.kind === 274 /* SyntaxKind.ExportAssignment */ && usage.isExportEquals) { + return true; + } + if (!!(usage.flags & 8388608 /* NodeFlags.JSDoc */) || isInTypeQuery(usage) || usageInTypeDeclaration()) { + return true; + } + if (isUsedInFunctionOrInstanceProperty(usage, declaration)) { + if (ts.getEmitScriptTarget(compilerOptions) === 99 /* ScriptTarget.ESNext */ && useDefineForClassFields + && ts.getContainingClass(declaration) + && (ts.isPropertyDeclaration(declaration) || ts.isParameterPropertyDeclaration(declaration, declaration.parent))) { + return !isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, /*stopAtAnyPropertyDeclaration*/ true); + } + else { + return true; + } + } + return false; + function usageInTypeDeclaration() { + return !!ts.findAncestor(usage, function (node) { return ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node); }); + } + function isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration, usage) { + switch (declaration.parent.parent.kind) { + case 240 /* SyntaxKind.VariableStatement */: + case 245 /* SyntaxKind.ForStatement */: + case 247 /* SyntaxKind.ForOfStatement */: + // variable statement/for/for-of statement case, + // use site should not be inside variable declaration (initializer of declaration or binding element) + if (isSameScopeDescendentOf(usage, declaration, declContainer)) { + return true; + } + break; + } + // ForIn/ForOf case - use site should not be used in expression part + var grandparent = declaration.parent.parent; + return ts.isForInOrOfStatement(grandparent) && isSameScopeDescendentOf(usage, grandparent.expression, declContainer); + } + function isUsedInFunctionOrInstanceProperty(usage, declaration) { + return !!ts.findAncestor(usage, function (current) { + if (current === declContainer) { + return "quit"; + } + if (ts.isFunctionLike(current)) { + return true; + } + if (ts.isClassStaticBlockDeclaration(current)) { + return declaration.pos < usage.pos; + } + var propertyDeclaration = ts.tryCast(current.parent, ts.isPropertyDeclaration); + if (propertyDeclaration) { + var initializerOfProperty = propertyDeclaration.initializer === current; + if (initializerOfProperty) { + if (ts.isStatic(current.parent)) { + if (declaration.kind === 171 /* SyntaxKind.MethodDeclaration */) { + return true; + } + if (ts.isPropertyDeclaration(declaration) && ts.getContainingClass(usage) === ts.getContainingClass(declaration)) { + var propName = declaration.name; + if (ts.isIdentifier(propName) || ts.isPrivateIdentifier(propName)) { + var type = getTypeOfSymbol(getSymbolOfNode(declaration)); + var staticBlocks = ts.filter(declaration.parent.members, ts.isClassStaticBlockDeclaration); + if (isPropertyInitializedInStaticBlocks(propName, type, staticBlocks, declaration.parent.pos, current.pos)) { + return true; + } + } + } + } + else { + var isDeclarationInstanceProperty = declaration.kind === 169 /* SyntaxKind.PropertyDeclaration */ && !ts.isStatic(declaration); + if (!isDeclarationInstanceProperty || ts.getContainingClass(usage) !== ts.getContainingClass(declaration)) { + return true; + } + } + } + } + return false; + }); + } + /** stopAtAnyPropertyDeclaration is used for detecting ES-standard class field use-before-def errors */ + function isPropertyImmediatelyReferencedWithinDeclaration(declaration, usage, stopAtAnyPropertyDeclaration) { + // always legal if usage is after declaration + if (usage.end > declaration.end) { + return false; + } + // still might be legal if usage is deferred (e.g. x: any = () => this.x) + // otherwise illegal if immediately referenced within the declaration (e.g. x: any = this.x) + var ancestorChangingReferenceScope = ts.findAncestor(usage, function (node) { + if (node === declaration) { + return "quit"; + } + switch (node.kind) { + case 216 /* SyntaxKind.ArrowFunction */: + return true; + case 169 /* SyntaxKind.PropertyDeclaration */: + // even when stopping at any property declaration, they need to come from the same class + return stopAtAnyPropertyDeclaration && + (ts.isPropertyDeclaration(declaration) && node.parent === declaration.parent + || ts.isParameterPropertyDeclaration(declaration, declaration.parent) && node.parent === declaration.parent.parent) + ? "quit" : true; + case 238 /* SyntaxKind.Block */: + switch (node.parent.kind) { + case 174 /* SyntaxKind.GetAccessor */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 175 /* SyntaxKind.SetAccessor */: + return true; + default: + return false; + } + default: + return false; + } + }); + return ancestorChangingReferenceScope === undefined; + } + } + function useOuterVariableScopeInParameter(result, location, lastLocation) { + var target = ts.getEmitScriptTarget(compilerOptions); + var functionLocation = location; + if (ts.isParameter(lastLocation) + && functionLocation.body + && result.valueDeclaration + && result.valueDeclaration.pos >= functionLocation.body.pos + && result.valueDeclaration.end <= functionLocation.body.end) { + // check for several cases where we introduce temporaries that require moving the name/initializer of the parameter to the body + // - static field in a class expression + // - optional chaining pre-es2020 + // - nullish coalesce pre-es2020 + // - spread assignment in binding pattern pre-es2017 + if (target >= 2 /* ScriptTarget.ES2015 */) { + var links = getNodeLinks(functionLocation); + if (links.declarationRequiresScopeChange === undefined) { + links.declarationRequiresScopeChange = ts.forEach(functionLocation.parameters, requiresScopeChange) || false; + } + return !links.declarationRequiresScopeChange; + } + } + return false; + function requiresScopeChange(node) { + return requiresScopeChangeWorker(node.name) + || !!node.initializer && requiresScopeChangeWorker(node.initializer); + } + function requiresScopeChangeWorker(node) { + switch (node.kind) { + case 216 /* SyntaxKind.ArrowFunction */: + case 215 /* SyntaxKind.FunctionExpression */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 173 /* SyntaxKind.Constructor */: + // do not descend into these + return false; + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 299 /* SyntaxKind.PropertyAssignment */: + return requiresScopeChangeWorker(node.name); + case 169 /* SyntaxKind.PropertyDeclaration */: + // static properties in classes introduce temporary variables + if (ts.hasStaticModifier(node)) { + return target < 99 /* ScriptTarget.ESNext */ || !useDefineForClassFields; + } + return requiresScopeChangeWorker(node.name); + default: + // null coalesce and optional chain pre-es2020 produce temporary variables + if (ts.isNullishCoalesce(node) || ts.isOptionalChain(node)) { + return target < 7 /* ScriptTarget.ES2020 */; + } + if (ts.isBindingElement(node) && node.dotDotDotToken && ts.isObjectBindingPattern(node.parent)) { + return target < 4 /* ScriptTarget.ES2017 */; + } + if (ts.isTypeNode(node)) + return false; + return ts.forEachChild(node, requiresScopeChangeWorker) || false; + } + } + } + function isConstAssertion(location) { + return (ts.isAssertionExpression(location) && ts.isConstTypeReference(location.type)) + || (ts.isJSDocTypeTag(location) && ts.isConstTypeReference(location.typeExpression)); + } + /** + * Resolve a given name for a given meaning at a given location. An error is reported if the name was not found and + * the nameNotFoundMessage argument is not undefined. Returns the resolved symbol, or undefined if no symbol with + * the given name can be found. + * + * @param nameNotFoundMessage If defined, we will report errors found during resolve. + * @param isUse If true, this will count towards --noUnusedLocals / --noUnusedParameters. + */ + function resolveName(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, getSpellingSuggestions) { + if (excludeGlobals === void 0) { excludeGlobals = false; } + if (getSpellingSuggestions === void 0) { getSpellingSuggestions = true; } + return resolveNameHelper(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, getSpellingSuggestions, getSymbol); + } + function resolveNameHelper(location, name, meaning, nameNotFoundMessage, nameArg, isUse, excludeGlobals, getSpellingSuggestions, lookup) { + var _a, _b, _c; + var originalLocation = location; // needed for did-you-mean error reporting, which gathers candidates starting from the original location + var result; + var lastLocation; + var lastSelfReferenceLocation; + var propertyWithInvalidInitializer; + var associatedDeclarationForContainingInitializerOrBindingName; + var withinDeferredContext = false; + var errorLocation = location; + var grandparent; + var isInExternalModule = false; + loop: while (location) { + if (name === "const" && isConstAssertion(location)) { + // `const` in an `as const` has no symbol, but issues no error because there is no *actual* lookup of the type + // (it refers to the constant type of the expression instead) + return undefined; + } + // Locals of a source file are not in scope (because they get merged into the global symbol table) + if (location.locals && !isGlobalSourceFile(location)) { + if (result = lookup(location.locals, name, meaning)) { + var useResult = true; + if (ts.isFunctionLike(location) && lastLocation && lastLocation !== location.body) { + // symbol lookup restrictions for function-like declarations + // - Type parameters of a function are in scope in the entire function declaration, including the parameter + // list and return type. However, local types are only in scope in the function body. + // - parameters are only in the scope of function body + // This restriction does not apply to JSDoc comment types because they are parented + // at a higher level than type parameters would normally be + if (meaning & result.flags & 788968 /* SymbolFlags.Type */ && lastLocation.kind !== 323 /* SyntaxKind.JSDoc */) { + useResult = result.flags & 262144 /* SymbolFlags.TypeParameter */ + // type parameters are visible in parameter list, return type and type parameter list + ? lastLocation === location.type || + lastLocation.kind === 166 /* SyntaxKind.Parameter */ || + lastLocation.kind === 343 /* SyntaxKind.JSDocParameterTag */ || + lastLocation.kind === 344 /* SyntaxKind.JSDocReturnTag */ || + lastLocation.kind === 165 /* SyntaxKind.TypeParameter */ + // local types not visible outside the function body + : false; + } + if (meaning & result.flags & 3 /* SymbolFlags.Variable */) { + // expression inside parameter will lookup as normal variable scope when targeting es2015+ + if (useOuterVariableScopeInParameter(result, location, lastLocation)) { + useResult = false; + } + else if (result.flags & 1 /* SymbolFlags.FunctionScopedVariable */) { + // parameters are visible only inside function body, parameter list and return type + // technically for parameter list case here we might mix parameters and variables declared in function, + // however it is detected separately when checking initializers of parameters + // to make sure that they reference no variables declared after them. + useResult = + lastLocation.kind === 166 /* SyntaxKind.Parameter */ || + (lastLocation === location.type && + !!ts.findAncestor(result.valueDeclaration, ts.isParameter)); + } + } + } + else if (location.kind === 191 /* SyntaxKind.ConditionalType */) { + // A type parameter declared using 'infer T' in a conditional type is visible only in + // the true branch of the conditional type. + useResult = lastLocation === location.trueType; + } + if (useResult) { + break loop; + } + else { + result = undefined; + } + } + } + withinDeferredContext = withinDeferredContext || getIsDeferredContext(location, lastLocation); + switch (location.kind) { + case 308 /* SyntaxKind.SourceFile */: + if (!ts.isExternalOrCommonJsModule(location)) + break; + isInExternalModule = true; + // falls through + case 264 /* SyntaxKind.ModuleDeclaration */: + var moduleExports = ((_a = getSymbolOfNode(location)) === null || _a === void 0 ? void 0 : _a.exports) || emptySymbols; + if (location.kind === 308 /* SyntaxKind.SourceFile */ || (ts.isModuleDeclaration(location) && location.flags & 16777216 /* NodeFlags.Ambient */ && !ts.isGlobalScopeAugmentation(location))) { + // It's an external module. First see if the module has an export default and if the local + // name of that export default matches. + if (result = moduleExports.get("default" /* InternalSymbolName.Default */)) { + var localSymbol = ts.getLocalSymbolForExportDefault(result); + if (localSymbol && (result.flags & meaning) && localSymbol.escapedName === name) { + break loop; + } + result = undefined; + } + // Because of module/namespace merging, a module's exports are in scope, + // yet we never want to treat an export specifier as putting a member in scope. + // Therefore, if the name we find is purely an export specifier, it is not actually considered in scope. + // Two things to note about this: + // 1. We have to check this without calling getSymbol. The problem with calling getSymbol + // on an export specifier is that it might find the export specifier itself, and try to + // resolve it as an alias. This will cause the checker to consider the export specifier + // a circular alias reference when it might not be. + // 2. We check === SymbolFlags.Alias in order to check that the symbol is *purely* + // an alias. If we used &, we'd be throwing out symbols that have non alias aspects, + // which is not the desired behavior. + var moduleExport = moduleExports.get(name); + if (moduleExport && + moduleExport.flags === 2097152 /* SymbolFlags.Alias */ && + (ts.getDeclarationOfKind(moduleExport, 278 /* SyntaxKind.ExportSpecifier */) || ts.getDeclarationOfKind(moduleExport, 277 /* SyntaxKind.NamespaceExport */))) { + break; + } + } + // ES6 exports are also visible locally (except for 'default'), but commonjs exports are not (except typedefs) + if (name !== "default" /* InternalSymbolName.Default */ && (result = lookup(moduleExports, name, meaning & 2623475 /* SymbolFlags.ModuleMember */))) { + if (ts.isSourceFile(location) && location.commonJsModuleIndicator && !((_b = result.declarations) === null || _b === void 0 ? void 0 : _b.some(ts.isJSDocTypeAlias))) { + result = undefined; + } + else { + break loop; + } + } + break; + case 263 /* SyntaxKind.EnumDeclaration */: + if (result = lookup(((_c = getSymbolOfNode(location)) === null || _c === void 0 ? void 0 : _c.exports) || emptySymbols, name, meaning & 8 /* SymbolFlags.EnumMember */)) { + break loop; + } + break; + case 169 /* SyntaxKind.PropertyDeclaration */: + // TypeScript 1.0 spec (April 2014): 8.4.1 + // Initializer expressions for instance member variables are evaluated in the scope + // of the class constructor body but are not permitted to reference parameters or + // local variables of the constructor. This effectively means that entities from outer scopes + // by the same name as a constructor parameter or local variable are inaccessible + // in initializer expressions for instance member variables. + if (!ts.isStatic(location)) { + var ctor = findConstructorDeclaration(location.parent); + if (ctor && ctor.locals) { + if (lookup(ctor.locals, name, meaning & 111551 /* SymbolFlags.Value */)) { + // Remember the property node, it will be used later to report appropriate error + ts.Debug.assertNode(location, ts.isPropertyDeclaration); + propertyWithInvalidInitializer = location; + } + } + } + break; + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + // The below is used to lookup type parameters within a class or interface, as they are added to the class/interface locals + // These can never be latebound, so the symbol's raw members are sufficient. `getMembersOfNode` cannot be used, as it would + // trigger resolving late-bound names, which we may already be in the process of doing while we're here! + if (result = lookup(getSymbolOfNode(location).members || emptySymbols, name, meaning & 788968 /* SymbolFlags.Type */)) { + if (!isTypeParameterSymbolDeclaredInContainer(result, location)) { + // ignore type parameters not declared in this container + result = undefined; + break; + } + if (lastLocation && ts.isStatic(lastLocation)) { + // TypeScript 1.0 spec (April 2014): 3.4.1 + // The scope of a type parameter extends over the entire declaration with which the type + // parameter list is associated, with the exception of static member declarations in classes. + if (nameNotFoundMessage) { + error(errorLocation, ts.Diagnostics.Static_members_cannot_reference_class_type_parameters); + } + return undefined; + } + break loop; + } + if (location.kind === 228 /* SyntaxKind.ClassExpression */ && meaning & 32 /* SymbolFlags.Class */) { + var className = location.name; + if (className && name === className.escapedText) { + result = location.symbol; + break loop; + } + } + break; + case 230 /* SyntaxKind.ExpressionWithTypeArguments */: + // The type parameters of a class are not in scope in the base class expression. + if (lastLocation === location.expression && location.parent.token === 94 /* SyntaxKind.ExtendsKeyword */) { + var container = location.parent.parent; + if (ts.isClassLike(container) && (result = lookup(getSymbolOfNode(container).members, name, meaning & 788968 /* SymbolFlags.Type */))) { + if (nameNotFoundMessage) { + error(errorLocation, ts.Diagnostics.Base_class_expressions_cannot_reference_class_type_parameters); + } + return undefined; + } + } + break; + // It is not legal to reference a class's own type parameters from a computed property name that + // belongs to the class. For example: + // + // function foo() { return '' } + // class C { // <-- Class's own type parameter T + // [foo()]() { } // <-- Reference to T from class's own computed property + // } + // + case 164 /* SyntaxKind.ComputedPropertyName */: + grandparent = location.parent.parent; + if (ts.isClassLike(grandparent) || grandparent.kind === 261 /* SyntaxKind.InterfaceDeclaration */) { + // A reference to this grandparent's type parameters would be an error + if (result = lookup(getSymbolOfNode(grandparent).members, name, meaning & 788968 /* SymbolFlags.Type */)) { + if (nameNotFoundMessage) { + error(errorLocation, ts.Diagnostics.A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type); + } + return undefined; + } + } + break; + case 216 /* SyntaxKind.ArrowFunction */: + // when targeting ES6 or higher there is no 'arguments' in an arrow function + // for lower compile targets the resolved symbol is used to emit an error + if (ts.getEmitScriptTarget(compilerOptions) >= 2 /* ScriptTarget.ES2015 */) { + break; + } + // falls through + case 171 /* SyntaxKind.MethodDeclaration */: + case 173 /* SyntaxKind.Constructor */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 259 /* SyntaxKind.FunctionDeclaration */: + if (meaning & 3 /* SymbolFlags.Variable */ && name === "arguments") { + result = argumentsSymbol; + break loop; + } + break; + case 215 /* SyntaxKind.FunctionExpression */: + if (meaning & 3 /* SymbolFlags.Variable */ && name === "arguments") { + result = argumentsSymbol; + break loop; + } + if (meaning & 16 /* SymbolFlags.Function */) { + var functionName = location.name; + if (functionName && name === functionName.escapedText) { + result = location.symbol; + break loop; + } + } + break; + case 167 /* SyntaxKind.Decorator */: + // Decorators are resolved at the class declaration. Resolving at the parameter + // or member would result in looking up locals in the method. + // + // function y() {} + // class C { + // method(@y x, y) {} // <-- decorator y should be resolved at the class declaration, not the parameter. + // } + // + if (location.parent && location.parent.kind === 166 /* SyntaxKind.Parameter */) { + location = location.parent; + } + // + // function y() {} + // class C { + // @y method(x, y) {} // <-- decorator y should be resolved at the class declaration, not the method. + // } + // + // class Decorators are resolved outside of the class to avoid referencing type parameters of that class. + // + // type T = number; + // declare function y(x: T): any; + // @param(1 as T) // <-- T should resolve to the type alias outside of class C + // class C {} + if (location.parent && (ts.isClassElement(location.parent) || location.parent.kind === 260 /* SyntaxKind.ClassDeclaration */)) { + location = location.parent; + } + break; + case 348 /* SyntaxKind.JSDocTypedefTag */: + case 341 /* SyntaxKind.JSDocCallbackTag */: + case 342 /* SyntaxKind.JSDocEnumTag */: + // js type aliases do not resolve names from their host, so skip past it + var root = ts.getJSDocRoot(location); + if (root) { + location = root.parent; + } + break; + case 166 /* SyntaxKind.Parameter */: + if (lastLocation && (lastLocation === location.initializer || + lastLocation === location.name && ts.isBindingPattern(lastLocation))) { + if (!associatedDeclarationForContainingInitializerOrBindingName) { + associatedDeclarationForContainingInitializerOrBindingName = location; + } + } + break; + case 205 /* SyntaxKind.BindingElement */: + if (lastLocation && (lastLocation === location.initializer || + lastLocation === location.name && ts.isBindingPattern(lastLocation))) { + if (ts.isParameterDeclaration(location) && !associatedDeclarationForContainingInitializerOrBindingName) { + associatedDeclarationForContainingInitializerOrBindingName = location; + } + } + break; + case 192 /* SyntaxKind.InferType */: + if (meaning & 262144 /* SymbolFlags.TypeParameter */) { + var parameterName = location.typeParameter.name; + if (parameterName && name === parameterName.escapedText) { + result = location.typeParameter.symbol; + break loop; + } + } + break; + } + if (isSelfReferenceLocation(location)) { + lastSelfReferenceLocation = location; + } + lastLocation = location; + location = ts.isJSDocTemplateTag(location) ? ts.getEffectiveContainerForJSDocTemplateTag(location) || location.parent : + ts.isJSDocParameterTag(location) || ts.isJSDocReturnTag(location) ? ts.getHostSignatureFromJSDoc(location) || location.parent : + location.parent; + } + // We just climbed up parents looking for the name, meaning that we started in a descendant node of `lastLocation`. + // If `result === lastSelfReferenceLocation.symbol`, that means that we are somewhere inside `lastSelfReferenceLocation` looking up a name, and resolving to `lastLocation` itself. + // That means that this is a self-reference of `lastLocation`, and shouldn't count this when considering whether `lastLocation` is used. + if (isUse && result && (!lastSelfReferenceLocation || result !== lastSelfReferenceLocation.symbol)) { + result.isReferenced |= meaning; + } + if (!result) { + if (lastLocation) { + ts.Debug.assert(lastLocation.kind === 308 /* SyntaxKind.SourceFile */); + if (lastLocation.commonJsModuleIndicator && name === "exports" && meaning & lastLocation.symbol.flags) { + return lastLocation.symbol; + } + } + if (!excludeGlobals) { + result = lookup(globals, name, meaning); + } + } + if (!result) { + if (originalLocation && ts.isInJSFile(originalLocation) && originalLocation.parent) { + if (ts.isRequireCall(originalLocation.parent, /*checkArgumentIsStringLiteralLike*/ false)) { + return requireSymbol; + } + } + } + // The invalid initializer error is needed in two situation: + // 1. When result is undefined, after checking for a missing "this." + // 2. When result is defined + function checkAndReportErrorForInvalidInitializer() { + if (propertyWithInvalidInitializer && !(useDefineForClassFields && ts.getEmitScriptTarget(compilerOptions) >= 9 /* ScriptTarget.ES2022 */)) { + // We have a match, but the reference occurred within a property initializer and the identifier also binds + // to a local variable in the constructor where the code will be emitted. Note that this is actually allowed + // with ESNext+useDefineForClassFields because the scope semantics are different. + error(errorLocation, errorLocation && propertyWithInvalidInitializer.type && ts.textRangeContainsPositionInclusive(propertyWithInvalidInitializer.type, errorLocation.pos) + ? ts.Diagnostics.Type_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor + : ts.Diagnostics.Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor, ts.declarationNameToString(propertyWithInvalidInitializer.name), diagnosticName(nameArg)); + return true; + } + return false; + } + if (!result) { + if (nameNotFoundMessage) { + addLazyDiagnostic(function () { + if (!errorLocation || + !checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) && // TODO: GH#18217 + !checkAndReportErrorForInvalidInitializer() && + !checkAndReportErrorForExtendingInterface(errorLocation) && + !checkAndReportErrorForUsingTypeAsNamespace(errorLocation, name, meaning) && + !checkAndReportErrorForExportingPrimitiveType(errorLocation, name) && + !checkAndReportErrorForUsingNamespaceAsTypeOrValue(errorLocation, name, meaning) && + !checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) && + !checkAndReportErrorForUsingValueAsType(errorLocation, name, meaning)) { + var suggestion = void 0; + var suggestedLib = void 0; + // Report missing lib first + if (nameArg) { + suggestedLib = getSuggestedLibForNonExistentName(nameArg); + if (suggestedLib) { + error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg), suggestedLib); + } + } + // then spelling suggestions + if (!suggestedLib && getSpellingSuggestions && suggestionCount < maximumSuggestionCount) { + suggestion = getSuggestedSymbolForNonexistentSymbol(originalLocation, name, meaning); + var isGlobalScopeAugmentationDeclaration = (suggestion === null || suggestion === void 0 ? void 0 : suggestion.valueDeclaration) && ts.isAmbientModule(suggestion.valueDeclaration) && ts.isGlobalScopeAugmentation(suggestion.valueDeclaration); + if (isGlobalScopeAugmentationDeclaration) { + suggestion = undefined; + } + if (suggestion) { + var suggestionName = symbolToString(suggestion); + var isUncheckedJS = isUncheckedJSSuggestion(originalLocation, suggestion, /*excludeClasses*/ false); + var message = meaning === 1920 /* SymbolFlags.Namespace */ || nameArg && typeof nameArg !== "string" && ts.nodeIsSynthesized(nameArg) ? ts.Diagnostics.Cannot_find_namespace_0_Did_you_mean_1 + : isUncheckedJS ? ts.Diagnostics.Could_not_find_name_0_Did_you_mean_1 + : ts.Diagnostics.Cannot_find_name_0_Did_you_mean_1; + var diagnostic = createError(errorLocation, message, diagnosticName(nameArg), suggestionName); + addErrorOrSuggestion(!isUncheckedJS, diagnostic); + if (suggestion.valueDeclaration) { + ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(suggestion.valueDeclaration, ts.Diagnostics._0_is_declared_here, suggestionName)); + } + } + } + // And then fall back to unspecified "not found" + if (!suggestion && !suggestedLib && nameArg) { + error(errorLocation, nameNotFoundMessage, diagnosticName(nameArg)); + } + suggestionCount++; + } + }); + } + return undefined; + } + else if (nameNotFoundMessage && checkAndReportErrorForInvalidInitializer()) { + return undefined; + } + // Perform extra checks only if error reporting was requested + if (nameNotFoundMessage) { + addLazyDiagnostic(function () { + // Only check for block-scoped variable if we have an error location and are looking for the + // name with variable meaning + // For example, + // declare module foo { + // interface bar {} + // } + // const foo/*1*/: foo/*2*/.bar; + // The foo at /*1*/ and /*2*/ will share same symbol with two meanings: + // block-scoped variable and namespace module. However, only when we + // try to resolve name in /*1*/ which is used in variable position, + // we want to check for block-scoped + if (errorLocation && + (meaning & 2 /* SymbolFlags.BlockScopedVariable */ || + ((meaning & 32 /* SymbolFlags.Class */ || meaning & 384 /* SymbolFlags.Enum */) && (meaning & 111551 /* SymbolFlags.Value */) === 111551 /* SymbolFlags.Value */))) { + var exportOrLocalSymbol = getExportSymbolOfValueSymbolIfExported(result); + if (exportOrLocalSymbol.flags & 2 /* SymbolFlags.BlockScopedVariable */ || exportOrLocalSymbol.flags & 32 /* SymbolFlags.Class */ || exportOrLocalSymbol.flags & 384 /* SymbolFlags.Enum */) { + checkResolvedBlockScopedVariable(exportOrLocalSymbol, errorLocation); + } + } + // If we're in an external module, we can't reference value symbols created from UMD export declarations + if (result && isInExternalModule && (meaning & 111551 /* SymbolFlags.Value */) === 111551 /* SymbolFlags.Value */ && !(originalLocation.flags & 8388608 /* NodeFlags.JSDoc */)) { + var merged = getMergedSymbol(result); + if (ts.length(merged.declarations) && ts.every(merged.declarations, function (d) { return ts.isNamespaceExportDeclaration(d) || ts.isSourceFile(d) && !!d.symbol.globalExports; })) { + errorOrSuggestion(!compilerOptions.allowUmdGlobalAccess, errorLocation, ts.Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead, ts.unescapeLeadingUnderscores(name)); + } + } + // If we're in a parameter initializer or binding name, we can't reference the values of the parameter whose initializer we're within or parameters to the right + if (result && associatedDeclarationForContainingInitializerOrBindingName && !withinDeferredContext && (meaning & 111551 /* SymbolFlags.Value */) === 111551 /* SymbolFlags.Value */) { + var candidate = getMergedSymbol(getLateBoundSymbol(result)); + var root = ts.getRootDeclaration(associatedDeclarationForContainingInitializerOrBindingName); + // A parameter initializer or binding pattern initializer within a parameter cannot refer to itself + if (candidate === getSymbolOfNode(associatedDeclarationForContainingInitializerOrBindingName)) { + error(errorLocation, ts.Diagnostics.Parameter_0_cannot_reference_itself, ts.declarationNameToString(associatedDeclarationForContainingInitializerOrBindingName.name)); + } + // And it cannot refer to any declarations which come after it + else if (candidate.valueDeclaration && candidate.valueDeclaration.pos > associatedDeclarationForContainingInitializerOrBindingName.pos && root.parent.locals && lookup(root.parent.locals, candidate.escapedName, meaning) === candidate) { + error(errorLocation, ts.Diagnostics.Parameter_0_cannot_reference_identifier_1_declared_after_it, ts.declarationNameToString(associatedDeclarationForContainingInitializerOrBindingName.name), ts.declarationNameToString(errorLocation)); + } + } + if (result && errorLocation && meaning & 111551 /* SymbolFlags.Value */ && result.flags & 2097152 /* SymbolFlags.Alias */ && !(result.flags & 111551 /* SymbolFlags.Value */) && !ts.isValidTypeOnlyAliasUseSite(errorLocation)) { + var typeOnlyDeclaration = getTypeOnlyAliasDeclaration(result, 111551 /* SymbolFlags.Value */); + if (typeOnlyDeclaration) { + var message = typeOnlyDeclaration.kind === 278 /* SyntaxKind.ExportSpecifier */ + ? ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type + : ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type; + var unescapedName = ts.unescapeLeadingUnderscores(name); + addTypeOnlyDeclarationRelatedInfo(error(errorLocation, message, unescapedName), typeOnlyDeclaration, unescapedName); + } + } + }); + } + return result; + } + function addTypeOnlyDeclarationRelatedInfo(diagnostic, typeOnlyDeclaration, unescapedName) { + if (!typeOnlyDeclaration) + return diagnostic; + return ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(typeOnlyDeclaration, typeOnlyDeclaration.kind === 278 /* SyntaxKind.ExportSpecifier */ ? ts.Diagnostics._0_was_exported_here : ts.Diagnostics._0_was_imported_here, unescapedName)); + } + function getIsDeferredContext(location, lastLocation) { + if (location.kind !== 216 /* SyntaxKind.ArrowFunction */ && location.kind !== 215 /* SyntaxKind.FunctionExpression */) { + // initializers in instance property declaration of class like entities are executed in constructor and thus deferred + return ts.isTypeQueryNode(location) || ((ts.isFunctionLikeDeclaration(location) || + (location.kind === 169 /* SyntaxKind.PropertyDeclaration */ && !ts.isStatic(location))) && (!lastLocation || lastLocation !== location.name)); // A name is evaluated within the enclosing scope - so it shouldn't count as deferred + } + if (lastLocation && lastLocation === location.name) { + return false; + } + // generator functions and async functions are not inlined in control flow when immediately invoked + if (location.asteriskToken || ts.hasSyntacticModifier(location, 512 /* ModifierFlags.Async */)) { + return true; + } + return !ts.getImmediatelyInvokedFunctionExpression(location); + } + function isSelfReferenceLocation(node) { + switch (node.kind) { + case 259 /* SyntaxKind.FunctionDeclaration */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 264 /* SyntaxKind.ModuleDeclaration */: // For `namespace N { N; }` + return true; + default: + return false; + } + } + function diagnosticName(nameArg) { + return ts.isString(nameArg) ? ts.unescapeLeadingUnderscores(nameArg) : ts.declarationNameToString(nameArg); + } + function isTypeParameterSymbolDeclaredInContainer(symbol, container) { + if (symbol.declarations) { + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + if (decl.kind === 165 /* SyntaxKind.TypeParameter */) { + var parent = ts.isJSDocTemplateTag(decl.parent) ? ts.getJSDocHost(decl.parent) : decl.parent; + if (parent === container) { + return !(ts.isJSDocTemplateTag(decl.parent) && ts.find(decl.parent.parent.tags, ts.isJSDocTypeAlias)); + } + } + } + } + return false; + } + function checkAndReportErrorForMissingPrefix(errorLocation, name, nameArg) { + if (!ts.isIdentifier(errorLocation) || errorLocation.escapedText !== name || isTypeReferenceIdentifier(errorLocation) || isInTypeQuery(errorLocation)) { + return false; + } + var container = ts.getThisContainer(errorLocation, /*includeArrowFunctions*/ false); + var location = container; + while (location) { + if (ts.isClassLike(location.parent)) { + var classSymbol = getSymbolOfNode(location.parent); + if (!classSymbol) { + break; + } + // Check to see if a static member exists. + var constructorType = getTypeOfSymbol(classSymbol); + if (getPropertyOfType(constructorType, name)) { + error(errorLocation, ts.Diagnostics.Cannot_find_name_0_Did_you_mean_the_static_member_1_0, diagnosticName(nameArg), symbolToString(classSymbol)); + return true; + } + // No static member is present. + // Check if we're in an instance method and look for a relevant instance member. + if (location === container && !ts.isStatic(location)) { + var instanceType = getDeclaredTypeOfSymbol(classSymbol).thisType; // TODO: GH#18217 + if (getPropertyOfType(instanceType, name)) { + error(errorLocation, ts.Diagnostics.Cannot_find_name_0_Did_you_mean_the_instance_member_this_0, diagnosticName(nameArg)); + return true; + } + } + } + location = location.parent; + } + return false; + } + function checkAndReportErrorForExtendingInterface(errorLocation) { + var expression = getEntityNameForExtendingInterface(errorLocation); + if (expression && resolveEntityName(expression, 64 /* SymbolFlags.Interface */, /*ignoreErrors*/ true)) { + error(errorLocation, ts.Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements, ts.getTextOfNode(expression)); + return true; + } + return false; + } + /** + * Climbs up parents to an ExpressionWithTypeArguments, and returns its expression, + * but returns undefined if that expression is not an EntityNameExpression. + */ + function getEntityNameForExtendingInterface(node) { + switch (node.kind) { + case 79 /* SyntaxKind.Identifier */: + case 208 /* SyntaxKind.PropertyAccessExpression */: + return node.parent ? getEntityNameForExtendingInterface(node.parent) : undefined; + case 230 /* SyntaxKind.ExpressionWithTypeArguments */: + if (ts.isEntityNameExpression(node.expression)) { + return node.expression; + } + // falls through + default: + return undefined; + } + } + function checkAndReportErrorForUsingTypeAsNamespace(errorLocation, name, meaning) { + var namespaceMeaning = 1920 /* SymbolFlags.Namespace */ | (ts.isInJSFile(errorLocation) ? 111551 /* SymbolFlags.Value */ : 0); + if (meaning === namespaceMeaning) { + var symbol = resolveSymbol(resolveName(errorLocation, name, 788968 /* SymbolFlags.Type */ & ~namespaceMeaning, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false)); + var parent = errorLocation.parent; + if (symbol) { + if (ts.isQualifiedName(parent)) { + ts.Debug.assert(parent.left === errorLocation, "Should only be resolving left side of qualified name as a namespace"); + var propName = parent.right.escapedText; + var propType = getPropertyOfType(getDeclaredTypeOfSymbol(symbol), propName); + if (propType) { + error(parent, ts.Diagnostics.Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_property_1_in_0_with_0_1, ts.unescapeLeadingUnderscores(name), ts.unescapeLeadingUnderscores(propName)); + return true; + } + } + error(errorLocation, ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_namespace_here, ts.unescapeLeadingUnderscores(name)); + return true; + } + } + return false; + } + function checkAndReportErrorForUsingValueAsType(errorLocation, name, meaning) { + if (meaning & (788968 /* SymbolFlags.Type */ & ~1920 /* SymbolFlags.Namespace */)) { + var symbol = resolveSymbol(resolveName(errorLocation, name, ~788968 /* SymbolFlags.Type */ & 111551 /* SymbolFlags.Value */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false)); + if (symbol && !(symbol.flags & 1920 /* SymbolFlags.Namespace */)) { + error(errorLocation, ts.Diagnostics._0_refers_to_a_value_but_is_being_used_as_a_type_here_Did_you_mean_typeof_0, ts.unescapeLeadingUnderscores(name)); + return true; + } + } + return false; + } + function isPrimitiveTypeName(name) { + return name === "any" || name === "string" || name === "number" || name === "boolean" || name === "never" || name === "unknown"; + } + function checkAndReportErrorForExportingPrimitiveType(errorLocation, name) { + if (isPrimitiveTypeName(name) && errorLocation.parent.kind === 278 /* SyntaxKind.ExportSpecifier */) { + error(errorLocation, ts.Diagnostics.Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module, name); + return true; + } + return false; + } + function checkAndReportErrorForUsingTypeAsValue(errorLocation, name, meaning) { + if (meaning & 111551 /* SymbolFlags.Value */) { + if (isPrimitiveTypeName(name)) { + if (isExtendedByInterface(errorLocation)) { + error(errorLocation, ts.Diagnostics.An_interface_cannot_extend_a_primitive_type_like_0_an_interface_can_only_extend_named_types_and_classes, ts.unescapeLeadingUnderscores(name)); + } + else { + error(errorLocation, ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here, ts.unescapeLeadingUnderscores(name)); + } + return true; + } + var symbol = resolveSymbol(resolveName(errorLocation, name, 788968 /* SymbolFlags.Type */ & ~111551 /* SymbolFlags.Value */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false)); + var allFlags = symbol && getAllSymbolFlags(symbol); + if (symbol && allFlags !== undefined && !(allFlags & 111551 /* SymbolFlags.Value */)) { + var rawName = ts.unescapeLeadingUnderscores(name); + if (isES2015OrLaterConstructorName(name)) { + error(errorLocation, ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later, rawName); + } + else if (maybeMappedType(errorLocation, symbol)) { + error(errorLocation, ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Did_you_mean_to_use_1_in_0, rawName, rawName === "K" ? "P" : "K"); + } + else { + error(errorLocation, ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here, rawName); + } + return true; + } + } + return false; + } + function isExtendedByInterface(node) { + var grandparent = node.parent.parent; + var parentOfGrandparent = grandparent.parent; + if (grandparent && parentOfGrandparent) { + var isExtending = ts.isHeritageClause(grandparent) && grandparent.token === 94 /* SyntaxKind.ExtendsKeyword */; + var isInterface = ts.isInterfaceDeclaration(parentOfGrandparent); + return isExtending && isInterface; + } + return false; + } + function maybeMappedType(node, symbol) { + var container = ts.findAncestor(node.parent, function (n) { + return ts.isComputedPropertyName(n) || ts.isPropertySignature(n) ? false : ts.isTypeLiteralNode(n) || "quit"; + }); + if (container && container.members.length === 1) { + var type = getDeclaredTypeOfSymbol(symbol); + return !!(type.flags & 1048576 /* TypeFlags.Union */) && allTypesAssignableToKind(type, 384 /* TypeFlags.StringOrNumberLiteral */, /*strict*/ true); + } + return false; + } + function isES2015OrLaterConstructorName(n) { + switch (n) { + case "Promise": + case "Symbol": + case "Map": + case "WeakMap": + case "Set": + case "WeakSet": + return true; + } + return false; + } + function checkAndReportErrorForUsingNamespaceAsTypeOrValue(errorLocation, name, meaning) { + if (meaning & (111551 /* SymbolFlags.Value */ & ~788968 /* SymbolFlags.Type */)) { + var symbol = resolveSymbol(resolveName(errorLocation, name, 1024 /* SymbolFlags.NamespaceModule */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false)); + if (symbol) { + error(errorLocation, ts.Diagnostics.Cannot_use_namespace_0_as_a_value, ts.unescapeLeadingUnderscores(name)); + return true; + } + } + else if (meaning & (788968 /* SymbolFlags.Type */ & ~111551 /* SymbolFlags.Value */)) { + var symbol = resolveSymbol(resolveName(errorLocation, name, 1536 /* SymbolFlags.Module */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false)); + if (symbol) { + error(errorLocation, ts.Diagnostics.Cannot_use_namespace_0_as_a_type, ts.unescapeLeadingUnderscores(name)); + return true; + } + } + return false; + } + function checkResolvedBlockScopedVariable(result, errorLocation) { + var _a; + ts.Debug.assert(!!(result.flags & 2 /* SymbolFlags.BlockScopedVariable */ || result.flags & 32 /* SymbolFlags.Class */ || result.flags & 384 /* SymbolFlags.Enum */)); + if (result.flags & (16 /* SymbolFlags.Function */ | 1 /* SymbolFlags.FunctionScopedVariable */ | 67108864 /* SymbolFlags.Assignment */) && result.flags & 32 /* SymbolFlags.Class */) { + // constructor functions aren't block scoped + return; + } + // Block-scoped variables cannot be used before their definition + var declaration = (_a = result.declarations) === null || _a === void 0 ? void 0 : _a.find(function (d) { return ts.isBlockOrCatchScoped(d) || ts.isClassLike(d) || (d.kind === 263 /* SyntaxKind.EnumDeclaration */); }); + if (declaration === undefined) + return ts.Debug.fail("checkResolvedBlockScopedVariable could not find block-scoped declaration"); + if (!(declaration.flags & 16777216 /* NodeFlags.Ambient */) && !isBlockScopedNameDeclaredBeforeUse(declaration, errorLocation)) { + var diagnosticMessage = void 0; + var declarationName = ts.declarationNameToString(ts.getNameOfDeclaration(declaration)); + if (result.flags & 2 /* SymbolFlags.BlockScopedVariable */) { + diagnosticMessage = error(errorLocation, ts.Diagnostics.Block_scoped_variable_0_used_before_its_declaration, declarationName); + } + else if (result.flags & 32 /* SymbolFlags.Class */) { + diagnosticMessage = error(errorLocation, ts.Diagnostics.Class_0_used_before_its_declaration, declarationName); + } + else if (result.flags & 256 /* SymbolFlags.RegularEnum */) { + diagnosticMessage = error(errorLocation, ts.Diagnostics.Enum_0_used_before_its_declaration, declarationName); + } + else { + ts.Debug.assert(!!(result.flags & 128 /* SymbolFlags.ConstEnum */)); + if (ts.shouldPreserveConstEnums(compilerOptions)) { + diagnosticMessage = error(errorLocation, ts.Diagnostics.Enum_0_used_before_its_declaration, declarationName); + } + } + if (diagnosticMessage) { + ts.addRelatedInfo(diagnosticMessage, ts.createDiagnosticForNode(declaration, ts.Diagnostics._0_is_declared_here, declarationName)); + } + } + } + /* Starting from 'initial' node walk up the parent chain until 'stopAt' node is reached. + * If at any point current node is equal to 'parent' node - return true. + * If current node is an IIFE, continue walking up. + * Return false if 'stopAt' node is reached or isFunctionLike(current) === true. + */ + function isSameScopeDescendentOf(initial, parent, stopAt) { + return !!parent && !!ts.findAncestor(initial, function (n) { return n === parent + || (n === stopAt || ts.isFunctionLike(n) && !ts.getImmediatelyInvokedFunctionExpression(n) ? "quit" : false); }); + } + function getAnyImportSyntax(node) { + switch (node.kind) { + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return node; + case 270 /* SyntaxKind.ImportClause */: + return node.parent; + case 271 /* SyntaxKind.NamespaceImport */: + return node.parent.parent; + case 273 /* SyntaxKind.ImportSpecifier */: + return node.parent.parent.parent; + default: + return undefined; + } + } + function getDeclarationOfAliasSymbol(symbol) { + return symbol.declarations && ts.findLast(symbol.declarations, isAliasSymbolDeclaration); + } + /** + * An alias symbol is created by one of the following declarations: + * import = ... + * import from ... + * import * as from ... + * import { x as } from ... + * export { x as } from ... + * export * as ns from ... + * export = + * export default + * module.exports = + * {} + * {name: } + * const { x } = require ... + */ + function isAliasSymbolDeclaration(node) { + return node.kind === 268 /* SyntaxKind.ImportEqualsDeclaration */ + || node.kind === 267 /* SyntaxKind.NamespaceExportDeclaration */ + || node.kind === 270 /* SyntaxKind.ImportClause */ && !!node.name + || node.kind === 271 /* SyntaxKind.NamespaceImport */ + || node.kind === 277 /* SyntaxKind.NamespaceExport */ + || node.kind === 273 /* SyntaxKind.ImportSpecifier */ + || node.kind === 278 /* SyntaxKind.ExportSpecifier */ + || node.kind === 274 /* SyntaxKind.ExportAssignment */ && ts.exportAssignmentIsAlias(node) + || ts.isBinaryExpression(node) && ts.getAssignmentDeclarationKind(node) === 2 /* AssignmentDeclarationKind.ModuleExports */ && ts.exportAssignmentIsAlias(node) + || ts.isAccessExpression(node) + && ts.isBinaryExpression(node.parent) + && node.parent.left === node + && node.parent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ + && isAliasableOrJsExpression(node.parent.right) + || node.kind === 300 /* SyntaxKind.ShorthandPropertyAssignment */ + || node.kind === 299 /* SyntaxKind.PropertyAssignment */ && isAliasableOrJsExpression(node.initializer) + || node.kind === 257 /* SyntaxKind.VariableDeclaration */ && ts.isVariableDeclarationInitializedToBareOrAccessedRequire(node) + || node.kind === 205 /* SyntaxKind.BindingElement */ && ts.isVariableDeclarationInitializedToBareOrAccessedRequire(node.parent.parent); + } + function isAliasableOrJsExpression(e) { + return ts.isAliasableExpression(e) || ts.isFunctionExpression(e) && isJSConstructor(e); + } + function getTargetOfImportEqualsDeclaration(node, dontResolveAlias) { + var commonJSPropertyAccess = getCommonJSPropertyAccess(node); + if (commonJSPropertyAccess) { + var name = ts.getLeftmostAccessExpression(commonJSPropertyAccess.expression).arguments[0]; + return ts.isIdentifier(commonJSPropertyAccess.name) + ? resolveSymbol(getPropertyOfType(resolveExternalModuleTypeByLiteral(name), commonJSPropertyAccess.name.escapedText)) + : undefined; + } + if (ts.isVariableDeclaration(node) || node.moduleReference.kind === 280 /* SyntaxKind.ExternalModuleReference */) { + var immediate = resolveExternalModuleName(node, ts.getExternalModuleRequireArgument(node) || ts.getExternalModuleImportEqualsDeclarationExpression(node)); + var resolved_4 = resolveExternalModuleSymbol(immediate); + markSymbolOfAliasDeclarationIfTypeOnly(node, immediate, resolved_4, /*overwriteEmpty*/ false); + return resolved_4; + } + var resolved = getSymbolOfPartOfRightHandSideOfImportEquals(node.moduleReference, dontResolveAlias); + checkAndReportErrorForResolvingImportAliasToTypeOnlySymbol(node, resolved); + return resolved; + } + function checkAndReportErrorForResolvingImportAliasToTypeOnlySymbol(node, resolved) { + if (markSymbolOfAliasDeclarationIfTypeOnly(node, /*immediateTarget*/ undefined, resolved, /*overwriteEmpty*/ false) && !node.isTypeOnly) { + var typeOnlyDeclaration = getTypeOnlyAliasDeclaration(getSymbolOfNode(node)); + var isExport = typeOnlyDeclaration.kind === 278 /* SyntaxKind.ExportSpecifier */; + var message = isExport + ? ts.Diagnostics.An_import_alias_cannot_reference_a_declaration_that_was_exported_using_export_type + : ts.Diagnostics.An_import_alias_cannot_reference_a_declaration_that_was_imported_using_import_type; + var relatedMessage = isExport + ? ts.Diagnostics._0_was_exported_here + : ts.Diagnostics._0_was_imported_here; + var name = ts.unescapeLeadingUnderscores(typeOnlyDeclaration.name.escapedText); + ts.addRelatedInfo(error(node.moduleReference, message), ts.createDiagnosticForNode(typeOnlyDeclaration, relatedMessage, name)); + } + } + function resolveExportByName(moduleSymbol, name, sourceNode, dontResolveAlias) { + var exportValue = moduleSymbol.exports.get("export=" /* InternalSymbolName.ExportEquals */); + var exportSymbol = exportValue ? getPropertyOfType(getTypeOfSymbol(exportValue), name) : moduleSymbol.exports.get(name); + var resolved = resolveSymbol(exportSymbol, dontResolveAlias); + markSymbolOfAliasDeclarationIfTypeOnly(sourceNode, exportSymbol, resolved, /*overwriteEmpty*/ false); + return resolved; + } + function isSyntacticDefault(node) { + return ((ts.isExportAssignment(node) && !node.isExportEquals) || ts.hasSyntacticModifier(node, 1024 /* ModifierFlags.Default */) || ts.isExportSpecifier(node)); + } + function getUsageModeForExpression(usage) { + return ts.isStringLiteralLike(usage) ? ts.getModeForUsageLocation(ts.getSourceFileOfNode(usage), usage) : undefined; + } + function isESMFormatImportImportingCommonjsFormatFile(usageMode, targetMode) { + return usageMode === ts.ModuleKind.ESNext && targetMode === ts.ModuleKind.CommonJS; + } + function isOnlyImportedAsDefault(usage) { + var usageMode = getUsageModeForExpression(usage); + return usageMode === ts.ModuleKind.ESNext && ts.endsWith(usage.text, ".json" /* Extension.Json */); + } + function canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, usage) { + var usageMode = file && getUsageModeForExpression(usage); + if (file && usageMode !== undefined) { + var result = isESMFormatImportImportingCommonjsFormatFile(usageMode, file.impliedNodeFormat); + if (usageMode === ts.ModuleKind.ESNext || result) { + return result; + } + // fallthrough on cjs usages so we imply defaults for interop'd imports, too + } + if (!allowSyntheticDefaultImports) { + return false; + } + // Declaration files (and ambient modules) + if (!file || file.isDeclarationFile) { + // Definitely cannot have a synthetic default if they have a syntactic default member specified + var defaultExportSymbol = resolveExportByName(moduleSymbol, "default" /* InternalSymbolName.Default */, /*sourceNode*/ undefined, /*dontResolveAlias*/ true); // Dont resolve alias because we want the immediately exported symbol's declaration + if (defaultExportSymbol && ts.some(defaultExportSymbol.declarations, isSyntacticDefault)) { + return false; + } + // It _might_ still be incorrect to assume there is no __esModule marker on the import at runtime, even if there is no `default` member + // So we check a bit more, + if (resolveExportByName(moduleSymbol, ts.escapeLeadingUnderscores("__esModule"), /*sourceNode*/ undefined, dontResolveAlias)) { + // If there is an `__esModule` specified in the declaration (meaning someone explicitly added it or wrote it in their code), + // it definitely is a module and does not have a synthetic default + return false; + } + // There are _many_ declaration files not written with esmodules in mind that still get compiled into a format with __esModule set + // Meaning there may be no default at runtime - however to be on the permissive side, we allow access to a synthetic default member + // as there is no marker to indicate if the accompanying JS has `__esModule` or not, or is even native esm + return true; + } + // TypeScript files never have a synthetic default (as they are always emitted with an __esModule marker) _unless_ they contain an export= statement + if (!ts.isSourceFileJS(file)) { + return hasExportAssignmentSymbol(moduleSymbol); + } + // JS files have a synthetic default if they do not contain ES2015+ module syntax (export = is not valid in js) _and_ do not have an __esModule marker + return typeof file.externalModuleIndicator !== "object" && !resolveExportByName(moduleSymbol, ts.escapeLeadingUnderscores("__esModule"), /*sourceNode*/ undefined, dontResolveAlias); + } + function getTargetOfImportClause(node, dontResolveAlias) { + var moduleSymbol = resolveExternalModuleName(node, node.parent.moduleSpecifier); + if (moduleSymbol) { + return getTargetofModuleDefault(moduleSymbol, node, dontResolveAlias); + } + } + function getTargetofModuleDefault(moduleSymbol, node, dontResolveAlias) { + var _a; + var exportDefaultSymbol; + if (ts.isShorthandAmbientModuleSymbol(moduleSymbol)) { + exportDefaultSymbol = moduleSymbol; + } + else { + exportDefaultSymbol = resolveExportByName(moduleSymbol, "default" /* InternalSymbolName.Default */, node, dontResolveAlias); + } + var file = (_a = moduleSymbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isSourceFile); + var specifier = getModuleSpecifierForImportOrExport(node); + if (!specifier) { + return exportDefaultSymbol; + } + var hasDefaultOnly = isOnlyImportedAsDefault(specifier); + var hasSyntheticDefault = canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, specifier); + if (!exportDefaultSymbol && !hasSyntheticDefault && !hasDefaultOnly) { + if (hasExportAssignmentSymbol(moduleSymbol)) { + var compilerOptionName = moduleKind >= ts.ModuleKind.ES2015 ? "allowSyntheticDefaultImports" : "esModuleInterop"; + var exportEqualsSymbol = moduleSymbol.exports.get("export=" /* InternalSymbolName.ExportEquals */); + var exportAssignment = exportEqualsSymbol.valueDeclaration; + var err = error(node.name, ts.Diagnostics.Module_0_can_only_be_default_imported_using_the_1_flag, symbolToString(moduleSymbol), compilerOptionName); + if (exportAssignment) { + ts.addRelatedInfo(err, ts.createDiagnosticForNode(exportAssignment, ts.Diagnostics.This_module_is_declared_with_export_and_can_only_be_used_with_a_default_import_when_using_the_0_flag, compilerOptionName)); + } + } + else if (ts.isImportClause(node)) { + reportNonDefaultExport(moduleSymbol, node); + } + else { + errorNoModuleMemberSymbol(moduleSymbol, moduleSymbol, node, ts.isImportOrExportSpecifier(node) && node.propertyName || node.name); + } + } + else if (hasSyntheticDefault || hasDefaultOnly) { + // per emit behavior, a synthetic default overrides a "real" .default member if `__esModule` is not present + var resolved = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias); + markSymbolOfAliasDeclarationIfTypeOnly(node, moduleSymbol, resolved, /*overwriteTypeOnly*/ false); + return resolved; + } + markSymbolOfAliasDeclarationIfTypeOnly(node, exportDefaultSymbol, /*finalTarget*/ undefined, /*overwriteTypeOnly*/ false); + return exportDefaultSymbol; + } + function getModuleSpecifierForImportOrExport(node) { + switch (node.kind) { + case 270 /* SyntaxKind.ImportClause */: return node.parent.moduleSpecifier; + case 268 /* SyntaxKind.ImportEqualsDeclaration */: return ts.isExternalModuleReference(node.moduleReference) ? node.moduleReference.expression : undefined; + case 271 /* SyntaxKind.NamespaceImport */: return node.parent.parent.moduleSpecifier; + case 273 /* SyntaxKind.ImportSpecifier */: return node.parent.parent.parent.moduleSpecifier; + case 278 /* SyntaxKind.ExportSpecifier */: return node.parent.parent.moduleSpecifier; + default: return ts.Debug.assertNever(node); + } + } + function reportNonDefaultExport(moduleSymbol, node) { + var _a, _b, _c; + if ((_a = moduleSymbol.exports) === null || _a === void 0 ? void 0 : _a.has(node.symbol.escapedName)) { + error(node.name, ts.Diagnostics.Module_0_has_no_default_export_Did_you_mean_to_use_import_1_from_0_instead, symbolToString(moduleSymbol), symbolToString(node.symbol)); + } + else { + var diagnostic = error(node.name, ts.Diagnostics.Module_0_has_no_default_export, symbolToString(moduleSymbol)); + var exportStar = (_b = moduleSymbol.exports) === null || _b === void 0 ? void 0 : _b.get("__export" /* InternalSymbolName.ExportStar */); + if (exportStar) { + var defaultExport = (_c = exportStar.declarations) === null || _c === void 0 ? void 0 : _c.find(function (decl) { + var _a, _b; + return !!(ts.isExportDeclaration(decl) && decl.moduleSpecifier && + ((_b = (_a = resolveExternalModuleName(decl, decl.moduleSpecifier)) === null || _a === void 0 ? void 0 : _a.exports) === null || _b === void 0 ? void 0 : _b.has("default" /* InternalSymbolName.Default */))); + }); + if (defaultExport) { + ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(defaultExport, ts.Diagnostics.export_Asterisk_does_not_re_export_a_default)); + } + } + } + } + function getTargetOfNamespaceImport(node, dontResolveAlias) { + var moduleSpecifier = node.parent.parent.moduleSpecifier; + var immediate = resolveExternalModuleName(node, moduleSpecifier); + var resolved = resolveESModuleSymbol(immediate, moduleSpecifier, dontResolveAlias, /*suppressUsageError*/ false); + markSymbolOfAliasDeclarationIfTypeOnly(node, immediate, resolved, /*overwriteEmpty*/ false); + return resolved; + } + function getTargetOfNamespaceExport(node, dontResolveAlias) { + var moduleSpecifier = node.parent.moduleSpecifier; + var immediate = moduleSpecifier && resolveExternalModuleName(node, moduleSpecifier); + var resolved = moduleSpecifier && resolveESModuleSymbol(immediate, moduleSpecifier, dontResolveAlias, /*suppressUsageError*/ false); + markSymbolOfAliasDeclarationIfTypeOnly(node, immediate, resolved, /*overwriteEmpty*/ false); + return resolved; + } + // This function creates a synthetic symbol that combines the value side of one symbol with the + // type/namespace side of another symbol. Consider this example: + // + // declare module graphics { + // interface Point { + // x: number; + // y: number; + // } + // } + // declare var graphics: { + // Point: new (x: number, y: number) => graphics.Point; + // } + // declare module "graphics" { + // export = graphics; + // } + // + // An 'import { Point } from "graphics"' needs to create a symbol that combines the value side 'Point' + // property with the type/namespace side interface 'Point'. + function combineValueAndTypeSymbols(valueSymbol, typeSymbol) { + if (valueSymbol === unknownSymbol && typeSymbol === unknownSymbol) { + return unknownSymbol; + } + if (valueSymbol.flags & (788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */)) { + return valueSymbol; + } + var result = createSymbol(valueSymbol.flags | typeSymbol.flags, valueSymbol.escapedName); + result.declarations = ts.deduplicate(ts.concatenate(valueSymbol.declarations, typeSymbol.declarations), ts.equateValues); + result.parent = valueSymbol.parent || typeSymbol.parent; + if (valueSymbol.valueDeclaration) + result.valueDeclaration = valueSymbol.valueDeclaration; + if (typeSymbol.members) + result.members = new ts.Map(typeSymbol.members); + if (valueSymbol.exports) + result.exports = new ts.Map(valueSymbol.exports); + return result; + } + function getExportOfModule(symbol, name, specifier, dontResolveAlias) { + if (symbol.flags & 1536 /* SymbolFlags.Module */) { + var exportSymbol = getExportsOfSymbol(symbol).get(name.escapedText); + var resolved = resolveSymbol(exportSymbol, dontResolveAlias); + markSymbolOfAliasDeclarationIfTypeOnly(specifier, exportSymbol, resolved, /*overwriteEmpty*/ false); + return resolved; + } + } + function getPropertyOfVariable(symbol, name) { + if (symbol.flags & 3 /* SymbolFlags.Variable */) { + var typeAnnotation = symbol.valueDeclaration.type; + if (typeAnnotation) { + return resolveSymbol(getPropertyOfType(getTypeFromTypeNode(typeAnnotation), name)); + } + } + } + function getExternalModuleMember(node, specifier, dontResolveAlias) { + var _a; + if (dontResolveAlias === void 0) { dontResolveAlias = false; } + var moduleSpecifier = ts.getExternalModuleRequireArgument(node) || node.moduleSpecifier; + var moduleSymbol = resolveExternalModuleName(node, moduleSpecifier); // TODO: GH#18217 + var name = !ts.isPropertyAccessExpression(specifier) && specifier.propertyName || specifier.name; + if (!ts.isIdentifier(name)) { + return undefined; + } + var suppressInteropError = name.escapedText === "default" /* InternalSymbolName.Default */ && !!(compilerOptions.allowSyntheticDefaultImports || ts.getESModuleInterop(compilerOptions)); + var targetSymbol = resolveESModuleSymbol(moduleSymbol, moduleSpecifier, /*dontResolveAlias*/ false, suppressInteropError); + if (targetSymbol) { + if (name.escapedText) { + if (ts.isShorthandAmbientModuleSymbol(moduleSymbol)) { + return moduleSymbol; + } + var symbolFromVariable = void 0; + // First check if module was specified with "export=". If so, get the member from the resolved type + if (moduleSymbol && moduleSymbol.exports && moduleSymbol.exports.get("export=" /* InternalSymbolName.ExportEquals */)) { + symbolFromVariable = getPropertyOfType(getTypeOfSymbol(targetSymbol), name.escapedText, /*skipObjectFunctionPropertyAugment*/ true); + } + else { + symbolFromVariable = getPropertyOfVariable(targetSymbol, name.escapedText); + } + // if symbolFromVariable is export - get its final target + symbolFromVariable = resolveSymbol(symbolFromVariable, dontResolveAlias); + var symbolFromModule = getExportOfModule(targetSymbol, name, specifier, dontResolveAlias); + if (symbolFromModule === undefined && name.escapedText === "default" /* InternalSymbolName.Default */) { + var file = (_a = moduleSymbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isSourceFile); + if (isOnlyImportedAsDefault(moduleSpecifier) || canHaveSyntheticDefault(file, moduleSymbol, dontResolveAlias, moduleSpecifier)) { + symbolFromModule = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) || resolveSymbol(moduleSymbol, dontResolveAlias); + } + } + var symbol = symbolFromModule && symbolFromVariable && symbolFromModule !== symbolFromVariable ? + combineValueAndTypeSymbols(symbolFromVariable, symbolFromModule) : + symbolFromModule || symbolFromVariable; + if (!symbol) { + errorNoModuleMemberSymbol(moduleSymbol, targetSymbol, node, name); + } + return symbol; + } + } + } + function errorNoModuleMemberSymbol(moduleSymbol, targetSymbol, node, name) { + var _a; + var moduleName = getFullyQualifiedName(moduleSymbol, node); + var declarationName = ts.declarationNameToString(name); + var suggestion = getSuggestedSymbolForNonexistentModule(name, targetSymbol); + if (suggestion !== undefined) { + var suggestionName = symbolToString(suggestion); + var diagnostic = error(name, ts.Diagnostics._0_has_no_exported_member_named_1_Did_you_mean_2, moduleName, declarationName, suggestionName); + if (suggestion.valueDeclaration) { + ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(suggestion.valueDeclaration, ts.Diagnostics._0_is_declared_here, suggestionName)); + } + } + else { + if ((_a = moduleSymbol.exports) === null || _a === void 0 ? void 0 : _a.has("default" /* InternalSymbolName.Default */)) { + error(name, ts.Diagnostics.Module_0_has_no_exported_member_1_Did_you_mean_to_use_import_1_from_0_instead, moduleName, declarationName); + } + else { + reportNonExportedMember(node, name, declarationName, moduleSymbol, moduleName); + } + } + } + function reportNonExportedMember(node, name, declarationName, moduleSymbol, moduleName) { + var _a, _b; + var localSymbol = (_b = (_a = moduleSymbol.valueDeclaration) === null || _a === void 0 ? void 0 : _a.locals) === null || _b === void 0 ? void 0 : _b.get(name.escapedText); + var exports = moduleSymbol.exports; + if (localSymbol) { + var exportedEqualsSymbol = exports === null || exports === void 0 ? void 0 : exports.get("export=" /* InternalSymbolName.ExportEquals */); + if (exportedEqualsSymbol) { + getSymbolIfSameReference(exportedEqualsSymbol, localSymbol) ? reportInvalidImportEqualsExportMember(node, name, declarationName, moduleName) : + error(name, ts.Diagnostics.Module_0_has_no_exported_member_1, moduleName, declarationName); + } + else { + var exportedSymbol = exports ? ts.find(symbolsToArray(exports), function (symbol) { return !!getSymbolIfSameReference(symbol, localSymbol); }) : undefined; + var diagnostic = exportedSymbol ? error(name, ts.Diagnostics.Module_0_declares_1_locally_but_it_is_exported_as_2, moduleName, declarationName, symbolToString(exportedSymbol)) : + error(name, ts.Diagnostics.Module_0_declares_1_locally_but_it_is_not_exported, moduleName, declarationName); + if (localSymbol.declarations) { + ts.addRelatedInfo.apply(void 0, __spreadArray([diagnostic], ts.map(localSymbol.declarations, function (decl, index) { + return ts.createDiagnosticForNode(decl, index === 0 ? ts.Diagnostics._0_is_declared_here : ts.Diagnostics.and_here, declarationName); + }), false)); + } + } + } + else { + error(name, ts.Diagnostics.Module_0_has_no_exported_member_1, moduleName, declarationName); + } + } + function reportInvalidImportEqualsExportMember(node, name, declarationName, moduleName) { + if (moduleKind >= ts.ModuleKind.ES2015) { + var message = ts.getESModuleInterop(compilerOptions) ? ts.Diagnostics._0_can_only_be_imported_by_using_a_default_import : + ts.Diagnostics._0_can_only_be_imported_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import; + error(name, message, declarationName); + } + else { + if (ts.isInJSFile(node)) { + var message = ts.getESModuleInterop(compilerOptions) ? ts.Diagnostics._0_can_only_be_imported_by_using_a_require_call_or_by_using_a_default_import : + ts.Diagnostics._0_can_only_be_imported_by_using_a_require_call_or_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import; + error(name, message, declarationName); + } + else { + var message = ts.getESModuleInterop(compilerOptions) ? ts.Diagnostics._0_can_only_be_imported_by_using_import_1_require_2_or_a_default_import : + ts.Diagnostics._0_can_only_be_imported_by_using_import_1_require_2_or_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import; + error(name, message, declarationName, declarationName, moduleName); + } + } + } + function getTargetOfImportSpecifier(node, dontResolveAlias) { + if (ts.isImportSpecifier(node) && ts.idText(node.propertyName || node.name) === "default" /* InternalSymbolName.Default */) { + var specifier = getModuleSpecifierForImportOrExport(node); + var moduleSymbol = specifier && resolveExternalModuleName(node, specifier); + if (moduleSymbol) { + return getTargetofModuleDefault(moduleSymbol, node, dontResolveAlias); + } + } + var root = ts.isBindingElement(node) ? ts.getRootDeclaration(node) : node.parent.parent.parent; + var commonJSPropertyAccess = getCommonJSPropertyAccess(root); + var resolved = getExternalModuleMember(root, commonJSPropertyAccess || node, dontResolveAlias); + var name = node.propertyName || node.name; + if (commonJSPropertyAccess && resolved && ts.isIdentifier(name)) { + return resolveSymbol(getPropertyOfType(getTypeOfSymbol(resolved), name.escapedText), dontResolveAlias); + } + markSymbolOfAliasDeclarationIfTypeOnly(node, /*immediateTarget*/ undefined, resolved, /*overwriteEmpty*/ false); + return resolved; + } + function getCommonJSPropertyAccess(node) { + if (ts.isVariableDeclaration(node) && node.initializer && ts.isPropertyAccessExpression(node.initializer)) { + return node.initializer; + } + } + function getTargetOfNamespaceExportDeclaration(node, dontResolveAlias) { + var resolved = resolveExternalModuleSymbol(node.parent.symbol, dontResolveAlias); + markSymbolOfAliasDeclarationIfTypeOnly(node, /*immediateTarget*/ undefined, resolved, /*overwriteEmpty*/ false); + return resolved; + } + function getTargetOfExportSpecifier(node, meaning, dontResolveAlias) { + if (ts.idText(node.propertyName || node.name) === "default" /* InternalSymbolName.Default */) { + var specifier = getModuleSpecifierForImportOrExport(node); + var moduleSymbol = specifier && resolveExternalModuleName(node, specifier); + if (moduleSymbol) { + return getTargetofModuleDefault(moduleSymbol, node, !!dontResolveAlias); + } + } + var resolved = node.parent.parent.moduleSpecifier ? + getExternalModuleMember(node.parent.parent, node, dontResolveAlias) : + resolveEntityName(node.propertyName || node.name, meaning, /*ignoreErrors*/ false, dontResolveAlias); + markSymbolOfAliasDeclarationIfTypeOnly(node, /*immediateTarget*/ undefined, resolved, /*overwriteEmpty*/ false); + return resolved; + } + function getTargetOfExportAssignment(node, dontResolveAlias) { + var expression = ts.isExportAssignment(node) ? node.expression : node.right; + var resolved = getTargetOfAliasLikeExpression(expression, dontResolveAlias); + markSymbolOfAliasDeclarationIfTypeOnly(node, /*immediateTarget*/ undefined, resolved, /*overwriteEmpty*/ false); + return resolved; + } + function getTargetOfAliasLikeExpression(expression, dontResolveAlias) { + if (ts.isClassExpression(expression)) { + return checkExpressionCached(expression).symbol; + } + if (!ts.isEntityName(expression) && !ts.isEntityNameExpression(expression)) { + return undefined; + } + var aliasLike = resolveEntityName(expression, 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */, /*ignoreErrors*/ true, dontResolveAlias); + if (aliasLike) { + return aliasLike; + } + checkExpressionCached(expression); + return getNodeLinks(expression).resolvedSymbol; + } + function getTargetOfAccessExpression(node, dontRecursivelyResolve) { + if (!(ts.isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */)) { + return undefined; + } + return getTargetOfAliasLikeExpression(node.parent.right, dontRecursivelyResolve); + } + function getTargetOfAliasDeclaration(node, dontRecursivelyResolve) { + if (dontRecursivelyResolve === void 0) { dontRecursivelyResolve = false; } + switch (node.kind) { + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + case 257 /* SyntaxKind.VariableDeclaration */: + return getTargetOfImportEqualsDeclaration(node, dontRecursivelyResolve); + case 270 /* SyntaxKind.ImportClause */: + return getTargetOfImportClause(node, dontRecursivelyResolve); + case 271 /* SyntaxKind.NamespaceImport */: + return getTargetOfNamespaceImport(node, dontRecursivelyResolve); + case 277 /* SyntaxKind.NamespaceExport */: + return getTargetOfNamespaceExport(node, dontRecursivelyResolve); + case 273 /* SyntaxKind.ImportSpecifier */: + case 205 /* SyntaxKind.BindingElement */: + return getTargetOfImportSpecifier(node, dontRecursivelyResolve); + case 278 /* SyntaxKind.ExportSpecifier */: + return getTargetOfExportSpecifier(node, 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */, dontRecursivelyResolve); + case 274 /* SyntaxKind.ExportAssignment */: + case 223 /* SyntaxKind.BinaryExpression */: + return getTargetOfExportAssignment(node, dontRecursivelyResolve); + case 267 /* SyntaxKind.NamespaceExportDeclaration */: + return getTargetOfNamespaceExportDeclaration(node, dontRecursivelyResolve); + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + return resolveEntityName(node.name, 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */, /*ignoreErrors*/ true, dontRecursivelyResolve); + case 299 /* SyntaxKind.PropertyAssignment */: + return getTargetOfAliasLikeExpression(node.initializer, dontRecursivelyResolve); + case 209 /* SyntaxKind.ElementAccessExpression */: + case 208 /* SyntaxKind.PropertyAccessExpression */: + return getTargetOfAccessExpression(node, dontRecursivelyResolve); + default: + return ts.Debug.fail(); + } + } + /** + * Indicates that a symbol is an alias that does not merge with a local declaration. + * OR Is a JSContainer which may merge an alias with a local declaration + */ + function isNonLocalAlias(symbol, excludes) { + if (excludes === void 0) { excludes = 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */; } + if (!symbol) + return false; + return (symbol.flags & (2097152 /* SymbolFlags.Alias */ | excludes)) === 2097152 /* SymbolFlags.Alias */ || !!(symbol.flags & 2097152 /* SymbolFlags.Alias */ && symbol.flags & 67108864 /* SymbolFlags.Assignment */); + } + function resolveSymbol(symbol, dontResolveAlias) { + return !dontResolveAlias && isNonLocalAlias(symbol) ? resolveAlias(symbol) : symbol; + } + function resolveAlias(symbol) { + ts.Debug.assert((symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0, "Should only get Alias here."); + var links = getSymbolLinks(symbol); + if (!links.aliasTarget) { + links.aliasTarget = resolvingSymbol; + var node = getDeclarationOfAliasSymbol(symbol); + if (!node) + return ts.Debug.fail(); + var target = getTargetOfAliasDeclaration(node); + if (links.aliasTarget === resolvingSymbol) { + links.aliasTarget = target || unknownSymbol; + } + else { + error(node, ts.Diagnostics.Circular_definition_of_import_alias_0, symbolToString(symbol)); + } + } + else if (links.aliasTarget === resolvingSymbol) { + links.aliasTarget = unknownSymbol; + } + return links.aliasTarget; + } + function tryResolveAlias(symbol) { + var links = getSymbolLinks(symbol); + if (links.aliasTarget !== resolvingSymbol) { + return resolveAlias(symbol); + } + return undefined; + } + /** + * Gets combined flags of a `symbol` and all alias targets it resolves to. `resolveAlias` + * is typically recursive over chains of aliases, but stops mid-chain if an alias is merged + * with another exported symbol, e.g. + * ```ts + * // a.ts + * export const a = 0; + * // b.ts + * export { a } from "./a"; + * export type a = number; + * // c.ts + * import { a } from "./b"; + * ``` + * Calling `resolveAlias` on the `a` in c.ts would stop at the merged symbol exported + * from b.ts, even though there is still more alias to resolve. Consequently, if we were + * trying to determine if the `a` in c.ts has a value meaning, looking at the flags on + * the local symbol and on the symbol returned by `resolveAlias` is not enough. + * @returns SymbolFlags.All if `symbol` is an alias that ultimately resolves to `unknown`; + * combined flags of all alias targets otherwise. + */ + function getAllSymbolFlags(symbol) { + var flags = symbol.flags; + var seenSymbols; + while (symbol.flags & 2097152 /* SymbolFlags.Alias */) { + var target = resolveAlias(symbol); + if (target === unknownSymbol) { + return 67108863 /* SymbolFlags.All */; + } + // Optimizations - try to avoid creating or adding to + // `seenSymbols` if possible + if (target === symbol || (seenSymbols === null || seenSymbols === void 0 ? void 0 : seenSymbols.has(target))) { + break; + } + if (target.flags & 2097152 /* SymbolFlags.Alias */) { + if (seenSymbols) { + seenSymbols.add(target); + } + else { + seenSymbols = new ts.Set([symbol, target]); + } + } + flags |= target.flags; + symbol = target; + } + return flags; + } + /** + * Marks a symbol as type-only if its declaration is syntactically type-only. + * If it is not itself marked type-only, but resolves to a type-only alias + * somewhere in its resolution chain, save a reference to the type-only alias declaration + * so the alias _not_ marked type-only can be identified as _transitively_ type-only. + * + * This function is called on each alias declaration that could be type-only or resolve to + * another type-only alias during `resolveAlias`, so that later, when an alias is used in a + * JS-emitting expression, we can quickly determine if that symbol is effectively type-only + * and issue an error if so. + * + * @param aliasDeclaration The alias declaration not marked as type-only + * @param immediateTarget The symbol to which the alias declaration immediately resolves + * @param finalTarget The symbol to which the alias declaration ultimately resolves + * @param overwriteEmpty Checks `resolvesToSymbol` for type-only declarations even if `aliasDeclaration` + * has already been marked as not resolving to a type-only alias. Used when recursively resolving qualified + * names of import aliases, e.g. `import C = a.b.C`. If namespace `a` is not found to be type-only, the + * import declaration will initially be marked as not resolving to a type-only symbol. But, namespace `b` + * must still be checked for a type-only marker, overwriting the previous negative result if found. + */ + function markSymbolOfAliasDeclarationIfTypeOnly(aliasDeclaration, immediateTarget, finalTarget, overwriteEmpty) { + if (!aliasDeclaration || ts.isPropertyAccessExpression(aliasDeclaration)) + return false; + // If the declaration itself is type-only, mark it and return. + // No need to check what it resolves to. + var sourceSymbol = getSymbolOfNode(aliasDeclaration); + if (ts.isTypeOnlyImportOrExportDeclaration(aliasDeclaration)) { + var links_1 = getSymbolLinks(sourceSymbol); + links_1.typeOnlyDeclaration = aliasDeclaration; + return true; + } + var links = getSymbolLinks(sourceSymbol); + return markSymbolOfAliasDeclarationIfTypeOnlyWorker(links, immediateTarget, overwriteEmpty) + || markSymbolOfAliasDeclarationIfTypeOnlyWorker(links, finalTarget, overwriteEmpty); + } + function markSymbolOfAliasDeclarationIfTypeOnlyWorker(aliasDeclarationLinks, target, overwriteEmpty) { + var _a, _b, _c; + if (target && (aliasDeclarationLinks.typeOnlyDeclaration === undefined || overwriteEmpty && aliasDeclarationLinks.typeOnlyDeclaration === false)) { + var exportSymbol = (_b = (_a = target.exports) === null || _a === void 0 ? void 0 : _a.get("export=" /* InternalSymbolName.ExportEquals */)) !== null && _b !== void 0 ? _b : target; + var typeOnly = exportSymbol.declarations && ts.find(exportSymbol.declarations, ts.isTypeOnlyImportOrExportDeclaration); + aliasDeclarationLinks.typeOnlyDeclaration = (_c = typeOnly !== null && typeOnly !== void 0 ? typeOnly : getSymbolLinks(exportSymbol).typeOnlyDeclaration) !== null && _c !== void 0 ? _c : false; + } + return !!aliasDeclarationLinks.typeOnlyDeclaration; + } + /** Indicates that a symbol directly or indirectly resolves to a type-only import or export. */ + function getTypeOnlyAliasDeclaration(symbol, include) { + if (!(symbol.flags & 2097152 /* SymbolFlags.Alias */)) { + return undefined; + } + var links = getSymbolLinks(symbol); + if (include === undefined) { + return links.typeOnlyDeclaration || undefined; + } + if (links.typeOnlyDeclaration) { + return getAllSymbolFlags(resolveAlias(links.typeOnlyDeclaration.symbol)) & include ? links.typeOnlyDeclaration : undefined; + } + return undefined; + } + function markExportAsReferenced(node) { + var symbol = getSymbolOfNode(node); + var target = resolveAlias(symbol); + if (target) { + var markAlias = target === unknownSymbol || + ((getAllSymbolFlags(target) & 111551 /* SymbolFlags.Value */) && !isConstEnumOrConstEnumOnlyModule(target) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* SymbolFlags.Value */)); + if (markAlias) { + markAliasSymbolAsReferenced(symbol); + } + } + } + // When an alias symbol is referenced, we need to mark the entity it references as referenced and in turn repeat that until + // we reach a non-alias or an exported entity (which is always considered referenced). We do this by checking the target of + // the alias as an expression (which recursively takes us back here if the target references another alias). + function markAliasSymbolAsReferenced(symbol) { + var links = getSymbolLinks(symbol); + if (!links.referenced) { + links.referenced = true; + var node = getDeclarationOfAliasSymbol(symbol); + if (!node) + return ts.Debug.fail(); + // We defer checking of the reference of an `import =` until the import itself is referenced, + // This way a chain of imports can be elided if ultimately the final input is only used in a type + // position. + if (ts.isInternalModuleImportEqualsDeclaration(node)) { + if (getAllSymbolFlags(resolveSymbol(symbol)) & 111551 /* SymbolFlags.Value */) { + // import foo = + checkExpressionCached(node.moduleReference); + } + } + } + } + // Aliases that resolve to const enums are not marked as referenced because they are not emitted, + // but their usage in value positions must be tracked to determine if the import can be type-only. + function markConstEnumAliasAsReferenced(symbol) { + var links = getSymbolLinks(symbol); + if (!links.constEnumReferenced) { + links.constEnumReferenced = true; + } + } + // This function is only for imports with entity names + function getSymbolOfPartOfRightHandSideOfImportEquals(entityName, dontResolveAlias) { + // There are three things we might try to look for. In the following examples, + // the search term is enclosed in |...|: + // + // import a = |b|; // Namespace + // import a = |b.c|; // Value, type, namespace + // import a = |b.c|.d; // Namespace + if (entityName.kind === 79 /* SyntaxKind.Identifier */ && ts.isRightSideOfQualifiedNameOrPropertyAccess(entityName)) { + entityName = entityName.parent; + } + // Check for case 1 and 3 in the above example + if (entityName.kind === 79 /* SyntaxKind.Identifier */ || entityName.parent.kind === 163 /* SyntaxKind.QualifiedName */) { + return resolveEntityName(entityName, 1920 /* SymbolFlags.Namespace */, /*ignoreErrors*/ false, dontResolveAlias); + } + else { + // Case 2 in above example + // entityName.kind could be a QualifiedName or a Missing identifier + ts.Debug.assert(entityName.parent.kind === 268 /* SyntaxKind.ImportEqualsDeclaration */); + return resolveEntityName(entityName, 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */, /*ignoreErrors*/ false, dontResolveAlias); + } + } + function getFullyQualifiedName(symbol, containingLocation) { + return symbol.parent ? getFullyQualifiedName(symbol.parent, containingLocation) + "." + symbolToString(symbol) : symbolToString(symbol, containingLocation, /*meaning*/ undefined, 32 /* SymbolFormatFlags.DoNotIncludeSymbolChain */ | 4 /* SymbolFormatFlags.AllowAnyNodeKind */); + } + function getContainingQualifiedNameNode(node) { + while (ts.isQualifiedName(node.parent)) { + node = node.parent; + } + return node; + } + function tryGetQualifiedNameAsValue(node) { + var left = ts.getFirstIdentifier(node); + var symbol = resolveName(left, left.escapedText, 111551 /* SymbolFlags.Value */, undefined, left, /*isUse*/ true); + if (!symbol) { + return undefined; + } + while (ts.isQualifiedName(left.parent)) { + var type = getTypeOfSymbol(symbol); + symbol = getPropertyOfType(type, left.parent.right.escapedText); + if (!symbol) { + return undefined; + } + left = left.parent; + } + return symbol; + } + /** + * Resolves a qualified name and any involved aliases. + */ + function resolveEntityName(name, meaning, ignoreErrors, dontResolveAlias, location) { + if (ts.nodeIsMissing(name)) { + return undefined; + } + var namespaceMeaning = 1920 /* SymbolFlags.Namespace */ | (ts.isInJSFile(name) ? meaning & 111551 /* SymbolFlags.Value */ : 0); + var symbol; + if (name.kind === 79 /* SyntaxKind.Identifier */) { + var message = meaning === namespaceMeaning || ts.nodeIsSynthesized(name) ? ts.Diagnostics.Cannot_find_namespace_0 : getCannotFindNameDiagnosticForName(ts.getFirstIdentifier(name)); + var symbolFromJSPrototype = ts.isInJSFile(name) && !ts.nodeIsSynthesized(name) ? resolveEntityNameFromAssignmentDeclaration(name, meaning) : undefined; + symbol = getMergedSymbol(resolveName(location || name, name.escapedText, meaning, ignoreErrors || symbolFromJSPrototype ? undefined : message, name, /*isUse*/ true, false)); + if (!symbol) { + return getMergedSymbol(symbolFromJSPrototype); + } + } + else if (name.kind === 163 /* SyntaxKind.QualifiedName */ || name.kind === 208 /* SyntaxKind.PropertyAccessExpression */) { + var left = name.kind === 163 /* SyntaxKind.QualifiedName */ ? name.left : name.expression; + var right = name.kind === 163 /* SyntaxKind.QualifiedName */ ? name.right : name.name; + var namespace = resolveEntityName(left, namespaceMeaning, ignoreErrors, /*dontResolveAlias*/ false, location); + if (!namespace || ts.nodeIsMissing(right)) { + return undefined; + } + else if (namespace === unknownSymbol) { + return namespace; + } + if (namespace.valueDeclaration && + ts.isInJSFile(namespace.valueDeclaration) && + ts.isVariableDeclaration(namespace.valueDeclaration) && + namespace.valueDeclaration.initializer && + isCommonJsRequire(namespace.valueDeclaration.initializer)) { + var moduleName = namespace.valueDeclaration.initializer.arguments[0]; + var moduleSym = resolveExternalModuleName(moduleName, moduleName); + if (moduleSym) { + var resolvedModuleSymbol = resolveExternalModuleSymbol(moduleSym); + if (resolvedModuleSymbol) { + namespace = resolvedModuleSymbol; + } + } + } + symbol = getMergedSymbol(getSymbol(getExportsOfSymbol(namespace), right.escapedText, meaning)); + if (!symbol) { + if (!ignoreErrors) { + var namespaceName = getFullyQualifiedName(namespace); + var declarationName = ts.declarationNameToString(right); + var suggestionForNonexistentModule = getSuggestedSymbolForNonexistentModule(right, namespace); + if (suggestionForNonexistentModule) { + error(right, ts.Diagnostics._0_has_no_exported_member_named_1_Did_you_mean_2, namespaceName, declarationName, symbolToString(suggestionForNonexistentModule)); + return undefined; + } + var containingQualifiedName = ts.isQualifiedName(name) && getContainingQualifiedNameNode(name); + var canSuggestTypeof = globalObjectType // <-- can't pull on types if global types aren't initialized yet + && (meaning & 788968 /* SymbolFlags.Type */) + && containingQualifiedName + && !ts.isTypeOfExpression(containingQualifiedName.parent) + && tryGetQualifiedNameAsValue(containingQualifiedName); + if (canSuggestTypeof) { + error(containingQualifiedName, ts.Diagnostics._0_refers_to_a_value_but_is_being_used_as_a_type_here_Did_you_mean_typeof_0, ts.entityNameToString(containingQualifiedName)); + return undefined; + } + if (meaning & 1920 /* SymbolFlags.Namespace */ && ts.isQualifiedName(name.parent)) { + var exportedTypeSymbol = getMergedSymbol(getSymbol(getExportsOfSymbol(namespace), right.escapedText, 788968 /* SymbolFlags.Type */)); + if (exportedTypeSymbol) { + error(name.parent.right, ts.Diagnostics.Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_property_1_in_0_with_0_1, symbolToString(exportedTypeSymbol), ts.unescapeLeadingUnderscores(name.parent.right.escapedText)); + return undefined; + } + } + error(right, ts.Diagnostics.Namespace_0_has_no_exported_member_1, namespaceName, declarationName); + } + return undefined; + } + } + else { + throw ts.Debug.assertNever(name, "Unknown entity name kind."); + } + ts.Debug.assert((ts.getCheckFlags(symbol) & 1 /* CheckFlags.Instantiated */) === 0, "Should never get an instantiated symbol here."); + if (!ts.nodeIsSynthesized(name) && ts.isEntityName(name) && (symbol.flags & 2097152 /* SymbolFlags.Alias */ || name.parent.kind === 274 /* SyntaxKind.ExportAssignment */)) { + markSymbolOfAliasDeclarationIfTypeOnly(ts.getAliasDeclarationFromName(name), symbol, /*finalTarget*/ undefined, /*overwriteEmpty*/ true); + } + return (symbol.flags & meaning) || dontResolveAlias ? symbol : resolveAlias(symbol); + } + /** + * 1. For prototype-property methods like `A.prototype.m = function () ...`, try to resolve names in the scope of `A` too. + * Note that prototype-property assignment to locations outside the current file (eg globals) doesn't work, so + * name resolution won't work either. + * 2. For property assignments like `{ x: function f () { } }`, try to resolve names in the scope of `f` too. + */ + function resolveEntityNameFromAssignmentDeclaration(name, meaning) { + if (isJSDocTypeReference(name.parent)) { + var secondaryLocation = getAssignmentDeclarationLocation(name.parent); + if (secondaryLocation) { + return resolveName(secondaryLocation, name.escapedText, meaning, /*nameNotFoundMessage*/ undefined, name, /*isUse*/ true); + } + } + } + function getAssignmentDeclarationLocation(node) { + var typeAlias = ts.findAncestor(node, function (node) { return !(ts.isJSDocNode(node) || node.flags & 8388608 /* NodeFlags.JSDoc */) ? "quit" : ts.isJSDocTypeAlias(node); }); + if (typeAlias) { + return; + } + var host = ts.getJSDocHost(node); + if (host && ts.isExpressionStatement(host) && ts.isPrototypePropertyAssignment(host.expression)) { + // /** @param {K} p */ X.prototype.m = function () { } <-- look for K on X's declaration + var symbol = getSymbolOfNode(host.expression.left); + if (symbol) { + return getDeclarationOfJSPrototypeContainer(symbol); + } + } + if (host && ts.isFunctionExpression(host) && ts.isPrototypePropertyAssignment(host.parent) && ts.isExpressionStatement(host.parent.parent)) { + // X.prototype.m = /** @param {K} p */ function () { } <-- look for K on X's declaration + var symbol = getSymbolOfNode(host.parent.left); + if (symbol) { + return getDeclarationOfJSPrototypeContainer(symbol); + } + } + if (host && (ts.isObjectLiteralMethod(host) || ts.isPropertyAssignment(host)) && + ts.isBinaryExpression(host.parent.parent) && + ts.getAssignmentDeclarationKind(host.parent.parent) === 6 /* AssignmentDeclarationKind.Prototype */) { + // X.prototype = { /** @param {K} p */m() { } } <-- look for K on X's declaration + var symbol = getSymbolOfNode(host.parent.parent.left); + if (symbol) { + return getDeclarationOfJSPrototypeContainer(symbol); + } + } + var sig = ts.getEffectiveJSDocHost(node); + if (sig && ts.isFunctionLike(sig)) { + var symbol = getSymbolOfNode(sig); + return symbol && symbol.valueDeclaration; + } + } + function getDeclarationOfJSPrototypeContainer(symbol) { + var decl = symbol.parent.valueDeclaration; + if (!decl) { + return undefined; + } + var initializer = ts.isAssignmentDeclaration(decl) ? ts.getAssignedExpandoInitializer(decl) : + ts.hasOnlyExpressionInitializer(decl) ? ts.getDeclaredExpandoInitializer(decl) : + undefined; + return initializer || decl; + } + /** + * Get the real symbol of a declaration with an expando initializer. + * + * Normally, declarations have an associated symbol, but when a declaration has an expando + * initializer, the expando's symbol is the one that has all the members merged into it. + */ + function getExpandoSymbol(symbol) { + var decl = symbol.valueDeclaration; + if (!decl || !ts.isInJSFile(decl) || symbol.flags & 524288 /* SymbolFlags.TypeAlias */ || ts.getExpandoInitializer(decl, /*isPrototypeAssignment*/ false)) { + return undefined; + } + var init = ts.isVariableDeclaration(decl) ? ts.getDeclaredExpandoInitializer(decl) : ts.getAssignedExpandoInitializer(decl); + if (init) { + var initSymbol = getSymbolOfNode(init); + if (initSymbol) { + return mergeJSSymbols(initSymbol, symbol); + } + } + } + function resolveExternalModuleName(location, moduleReferenceExpression, ignoreErrors) { + var isClassic = ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.Classic; + var errorMessage = isClassic ? + ts.Diagnostics.Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_node_or_to_add_aliases_to_the_paths_option + : ts.Diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations; + return resolveExternalModuleNameWorker(location, moduleReferenceExpression, ignoreErrors ? undefined : errorMessage); + } + function resolveExternalModuleNameWorker(location, moduleReferenceExpression, moduleNotFoundError, isForAugmentation) { + if (isForAugmentation === void 0) { isForAugmentation = false; } + return ts.isStringLiteralLike(moduleReferenceExpression) + ? resolveExternalModule(location, moduleReferenceExpression.text, moduleNotFoundError, moduleReferenceExpression, isForAugmentation) + : undefined; + } + function resolveExternalModule(location, moduleReference, moduleNotFoundError, errorNode, isForAugmentation) { + var _a, _b, _c, _d, _e, _f, _g, _h; + if (isForAugmentation === void 0) { isForAugmentation = false; } + if (ts.startsWith(moduleReference, "@types/")) { + var diag = ts.Diagnostics.Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1; + var withoutAtTypePrefix = ts.removePrefix(moduleReference, "@types/"); + error(errorNode, diag, withoutAtTypePrefix, moduleReference); + } + var ambientModule = tryFindAmbientModule(moduleReference, /*withAugmentations*/ true); + if (ambientModule) { + return ambientModule; + } + var currentSourceFile = ts.getSourceFileOfNode(location); + var contextSpecifier = ts.isStringLiteralLike(location) + ? location + : ((_a = ts.findAncestor(location, ts.isImportCall)) === null || _a === void 0 ? void 0 : _a.arguments[0]) || + ((_b = ts.findAncestor(location, ts.isImportDeclaration)) === null || _b === void 0 ? void 0 : _b.moduleSpecifier) || + ((_c = ts.findAncestor(location, ts.isExternalModuleImportEqualsDeclaration)) === null || _c === void 0 ? void 0 : _c.moduleReference.expression) || + ((_d = ts.findAncestor(location, ts.isExportDeclaration)) === null || _d === void 0 ? void 0 : _d.moduleSpecifier) || + ((_e = (ts.isModuleDeclaration(location) ? location : location.parent && ts.isModuleDeclaration(location.parent) && location.parent.name === location ? location.parent : undefined)) === null || _e === void 0 ? void 0 : _e.name) || + ((_f = (ts.isLiteralImportTypeNode(location) ? location : undefined)) === null || _f === void 0 ? void 0 : _f.argument.literal); + var mode = contextSpecifier && ts.isStringLiteralLike(contextSpecifier) ? ts.getModeForUsageLocation(currentSourceFile, contextSpecifier) : currentSourceFile.impliedNodeFormat; + var resolvedModule = ts.getResolvedModule(currentSourceFile, moduleReference, mode); + var resolutionDiagnostic = resolvedModule && ts.getResolutionDiagnostic(compilerOptions, resolvedModule); + var sourceFile = resolvedModule + && (!resolutionDiagnostic || resolutionDiagnostic === ts.Diagnostics.Module_0_was_resolved_to_1_but_jsx_is_not_set) + && host.getSourceFile(resolvedModule.resolvedFileName); + if (sourceFile) { + // If there's a resolutionDiagnostic we need to report it even if a sourceFile is found. + if (resolutionDiagnostic) { + error(errorNode, resolutionDiagnostic, moduleReference, resolvedModule.resolvedFileName); + } + if (sourceFile.symbol) { + if (resolvedModule.isExternalLibraryImport && !ts.resolutionExtensionIsTSOrJson(resolvedModule.extension)) { + errorOnImplicitAnyModule(/*isError*/ false, errorNode, resolvedModule, moduleReference); + } + if (ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.Node16 || ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeNext) { + var isSyncImport = (currentSourceFile.impliedNodeFormat === ts.ModuleKind.CommonJS && !ts.findAncestor(location, ts.isImportCall)) || !!ts.findAncestor(location, ts.isImportEqualsDeclaration); + var overrideClauseHost = ts.findAncestor(location, function (l) { return ts.isImportTypeNode(l) || ts.isExportDeclaration(l) || ts.isImportDeclaration(l); }); + var overrideClause = overrideClauseHost && ts.isImportTypeNode(overrideClauseHost) ? (_g = overrideClauseHost.assertions) === null || _g === void 0 ? void 0 : _g.assertClause : overrideClauseHost === null || overrideClauseHost === void 0 ? void 0 : overrideClauseHost.assertClause; + // An override clause will take effect for type-only imports and import types, and allows importing the types across formats, regardless of + // normal mode restrictions + if (isSyncImport && sourceFile.impliedNodeFormat === ts.ModuleKind.ESNext && !ts.getResolutionModeOverrideForClause(overrideClause)) { + if (ts.findAncestor(location, ts.isImportEqualsDeclaration)) { + // ImportEquals in a ESM file resolving to another ESM file + error(errorNode, ts.Diagnostics.Module_0_cannot_be_imported_using_this_construct_The_specifier_only_resolves_to_an_ES_module_which_cannot_be_imported_with_require_Use_an_ECMAScript_import_instead, moduleReference); + } + else { + // CJS file resolving to an ESM file + var diagnosticDetails = void 0; + var ext = ts.tryGetExtensionFromPath(currentSourceFile.fileName); + if (ext === ".ts" /* Extension.Ts */ || ext === ".js" /* Extension.Js */ || ext === ".tsx" /* Extension.Tsx */ || ext === ".jsx" /* Extension.Jsx */) { + var scope = currentSourceFile.packageJsonScope; + var targetExt = ext === ".ts" /* Extension.Ts */ ? ".mts" /* Extension.Mts */ : ext === ".js" /* Extension.Js */ ? ".mjs" /* Extension.Mjs */ : undefined; + if (scope && !scope.contents.packageJsonContent.type) { + if (targetExt) { + diagnosticDetails = ts.chainDiagnosticMessages( + /*details*/ undefined, ts.Diagnostics.To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_add_the_field_type_Colon_module_to_1, targetExt, ts.combinePaths(scope.packageDirectory, "package.json")); + } + else { + diagnosticDetails = ts.chainDiagnosticMessages( + /*details*/ undefined, ts.Diagnostics.To_convert_this_file_to_an_ECMAScript_module_add_the_field_type_Colon_module_to_0, ts.combinePaths(scope.packageDirectory, "package.json")); + } + } + else { + if (targetExt) { + diagnosticDetails = ts.chainDiagnosticMessages( + /*details*/ undefined, ts.Diagnostics.To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_create_a_local_package_json_file_with_type_Colon_module, targetExt); + } + else { + diagnosticDetails = ts.chainDiagnosticMessages( + /*details*/ undefined, ts.Diagnostics.To_convert_this_file_to_an_ECMAScript_module_create_a_local_package_json_file_with_type_Colon_module); + } + } + } + diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(errorNode, ts.chainDiagnosticMessages(diagnosticDetails, ts.Diagnostics.The_current_file_is_a_CommonJS_module_whose_imports_will_produce_require_calls_however_the_referenced_file_is_an_ECMAScript_module_and_cannot_be_imported_with_require_Consider_writing_a_dynamic_import_0_call_instead, moduleReference))); + } + } + } + // merged symbol is module declaration symbol combined with all augmentations + return getMergedSymbol(sourceFile.symbol); + } + if (moduleNotFoundError) { + // report errors only if it was requested + error(errorNode, ts.Diagnostics.File_0_is_not_a_module, sourceFile.fileName); + } + return undefined; + } + if (patternAmbientModules) { + var pattern = ts.findBestPatternMatch(patternAmbientModules, function (_) { return _.pattern; }, moduleReference); + if (pattern) { + // If the module reference matched a pattern ambient module ('*.foo') but there's also a + // module augmentation by the specific name requested ('a.foo'), we store the merged symbol + // by the augmentation name ('a.foo'), because asking for *.foo should not give you exports + // from a.foo. + var augmentation = patternAmbientModuleAugmentations && patternAmbientModuleAugmentations.get(moduleReference); + if (augmentation) { + return getMergedSymbol(augmentation); + } + return getMergedSymbol(pattern.symbol); + } + } + // May be an untyped module. If so, ignore resolutionDiagnostic. + if (resolvedModule && !ts.resolutionExtensionIsTSOrJson(resolvedModule.extension) && resolutionDiagnostic === undefined || resolutionDiagnostic === ts.Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type) { + if (isForAugmentation) { + var diag = ts.Diagnostics.Invalid_module_name_in_augmentation_Module_0_resolves_to_an_untyped_module_at_1_which_cannot_be_augmented; + error(errorNode, diag, moduleReference, resolvedModule.resolvedFileName); + } + else { + errorOnImplicitAnyModule(/*isError*/ noImplicitAny && !!moduleNotFoundError, errorNode, resolvedModule, moduleReference); + } + // Failed imports and untyped modules are both treated in an untyped manner; only difference is whether we give a diagnostic first. + return undefined; + } + if (moduleNotFoundError) { + // See if this was possibly a projectReference redirect + if (resolvedModule) { + var redirect = host.getProjectReferenceRedirect(resolvedModule.resolvedFileName); + if (redirect) { + error(errorNode, ts.Diagnostics.Output_file_0_has_not_been_built_from_source_file_1, redirect, resolvedModule.resolvedFileName); + return undefined; + } + } + if (resolutionDiagnostic) { + error(errorNode, resolutionDiagnostic, moduleReference, resolvedModule.resolvedFileName); + } + else { + var tsExtension = ts.tryExtractTSExtension(moduleReference); + var isExtensionlessRelativePathImport = ts.pathIsRelative(moduleReference) && !ts.hasExtension(moduleReference); + var moduleResolutionKind = ts.getEmitModuleResolutionKind(compilerOptions); + var resolutionIsNode16OrNext = moduleResolutionKind === ts.ModuleResolutionKind.Node16 || + moduleResolutionKind === ts.ModuleResolutionKind.NodeNext; + if (tsExtension) { + var diag = ts.Diagnostics.An_import_path_cannot_end_with_a_0_extension_Consider_importing_1_instead; + var importSourceWithoutExtension = ts.removeExtension(moduleReference, tsExtension); + var replacedImportSource = importSourceWithoutExtension; + /** + * Direct users to import source with .js extension if outputting an ES module. + * @see https://github.com/microsoft/TypeScript/issues/42151 + */ + if (moduleKind >= ts.ModuleKind.ES2015) { + replacedImportSource += tsExtension === ".mts" /* Extension.Mts */ ? ".mjs" : tsExtension === ".cts" /* Extension.Cts */ ? ".cjs" : ".js"; + } + error(errorNode, diag, tsExtension, replacedImportSource); + } + else if (!compilerOptions.resolveJsonModule && + ts.fileExtensionIs(moduleReference, ".json" /* Extension.Json */) && + ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.Classic && + ts.hasJsonModuleEmitEnabled(compilerOptions)) { + error(errorNode, ts.Diagnostics.Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension, moduleReference); + } + else if (mode === ts.ModuleKind.ESNext && resolutionIsNode16OrNext && isExtensionlessRelativePathImport) { + var absoluteRef_1 = ts.getNormalizedAbsolutePath(moduleReference, ts.getDirectoryPath(currentSourceFile.path)); + var suggestedExt = (_h = suggestedExtensions.find(function (_a) { + var actualExt = _a[0], _importExt = _a[1]; + return host.fileExists(absoluteRef_1 + actualExt); + })) === null || _h === void 0 ? void 0 : _h[1]; + if (suggestedExt) { + error(errorNode, ts.Diagnostics.Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node16_or_nodenext_Did_you_mean_0, moduleReference + suggestedExt); + } + else { + error(errorNode, ts.Diagnostics.Relative_import_paths_need_explicit_file_extensions_in_EcmaScript_imports_when_moduleResolution_is_node16_or_nodenext_Consider_adding_an_extension_to_the_import_path); + } + } + else { + error(errorNode, moduleNotFoundError, moduleReference); + } + } + } + return undefined; + } + function errorOnImplicitAnyModule(isError, errorNode, _a, moduleReference) { + var packageId = _a.packageId, resolvedFileName = _a.resolvedFileName; + var errorInfo = !ts.isExternalModuleNameRelative(moduleReference) && packageId + ? typesPackageExists(packageId.name) + ? ts.chainDiagnosticMessages( + /*details*/ undefined, ts.Diagnostics.If_the_0_package_actually_exposes_this_module_consider_sending_a_pull_request_to_amend_https_Colon_Slash_Slashgithub_com_SlashDefinitelyTyped_SlashDefinitelyTyped_Slashtree_Slashmaster_Slashtypes_Slash_1, packageId.name, ts.mangleScopedPackageName(packageId.name)) + : packageBundlesTypes(packageId.name) + ? ts.chainDiagnosticMessages( + /*details*/ undefined, ts.Diagnostics.If_the_0_package_actually_exposes_this_module_try_adding_a_new_declaration_d_ts_file_containing_declare_module_1, packageId.name, moduleReference) + : ts.chainDiagnosticMessages( + /*details*/ undefined, ts.Diagnostics.Try_npm_i_save_dev_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare_module_0, moduleReference, ts.mangleScopedPackageName(packageId.name)) + : undefined; + errorOrSuggestion(isError, errorNode, ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type, moduleReference, resolvedFileName)); + } + function typesPackageExists(packageName) { + return getPackagesMap().has(ts.getTypesPackageName(packageName)); + } + function packageBundlesTypes(packageName) { + return !!getPackagesMap().get(packageName); + } + function resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias) { + if (moduleSymbol === null || moduleSymbol === void 0 ? void 0 : moduleSymbol.exports) { + var exportEquals = resolveSymbol(moduleSymbol.exports.get("export=" /* InternalSymbolName.ExportEquals */), dontResolveAlias); + var exported = getCommonJsExportEquals(getMergedSymbol(exportEquals), getMergedSymbol(moduleSymbol)); + return getMergedSymbol(exported) || moduleSymbol; + } + return undefined; + } + function getCommonJsExportEquals(exported, moduleSymbol) { + if (!exported || exported === unknownSymbol || exported === moduleSymbol || moduleSymbol.exports.size === 1 || exported.flags & 2097152 /* SymbolFlags.Alias */) { + return exported; + } + var links = getSymbolLinks(exported); + if (links.cjsExportMerged) { + return links.cjsExportMerged; + } + var merged = exported.flags & 33554432 /* SymbolFlags.Transient */ ? exported : cloneSymbol(exported); + merged.flags = merged.flags | 512 /* SymbolFlags.ValueModule */; + if (merged.exports === undefined) { + merged.exports = ts.createSymbolTable(); + } + moduleSymbol.exports.forEach(function (s, name) { + if (name === "export=" /* InternalSymbolName.ExportEquals */) + return; + merged.exports.set(name, merged.exports.has(name) ? mergeSymbol(merged.exports.get(name), s) : s); + }); + getSymbolLinks(merged).cjsExportMerged = merged; + return links.cjsExportMerged = merged; + } + // An external module with an 'export =' declaration may be referenced as an ES6 module provided the 'export =' + // references a symbol that is at least declared as a module or a variable. The target of the 'export =' may + // combine other declarations with the module or variable (e.g. a class/module, function/module, interface/variable). + function resolveESModuleSymbol(moduleSymbol, referencingLocation, dontResolveAlias, suppressInteropError) { + var _a; + var symbol = resolveExternalModuleSymbol(moduleSymbol, dontResolveAlias); + if (!dontResolveAlias && symbol) { + if (!suppressInteropError && !(symbol.flags & (1536 /* SymbolFlags.Module */ | 3 /* SymbolFlags.Variable */)) && !ts.getDeclarationOfKind(symbol, 308 /* SyntaxKind.SourceFile */)) { + var compilerOptionName = moduleKind >= ts.ModuleKind.ES2015 + ? "allowSyntheticDefaultImports" + : "esModuleInterop"; + error(referencingLocation, ts.Diagnostics.This_module_can_only_be_referenced_with_ECMAScript_imports_Slashexports_by_turning_on_the_0_flag_and_referencing_its_default_export, compilerOptionName); + return symbol; + } + var referenceParent = referencingLocation.parent; + if ((ts.isImportDeclaration(referenceParent) && ts.getNamespaceDeclarationNode(referenceParent)) || + ts.isImportCall(referenceParent)) { + var reference = ts.isImportCall(referenceParent) ? referenceParent.arguments[0] : referenceParent.moduleSpecifier; + var type = getTypeOfSymbol(symbol); + var defaultOnlyType = getTypeWithSyntheticDefaultOnly(type, symbol, moduleSymbol, reference); + if (defaultOnlyType) { + return cloneTypeAsModuleType(symbol, defaultOnlyType, referenceParent); + } + var targetFile = (_a = moduleSymbol === null || moduleSymbol === void 0 ? void 0 : moduleSymbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isSourceFile); + var isEsmCjsRef = targetFile && isESMFormatImportImportingCommonjsFormatFile(getUsageModeForExpression(reference), targetFile.impliedNodeFormat); + if (ts.getESModuleInterop(compilerOptions) || isEsmCjsRef) { + var sigs = getSignaturesOfStructuredType(type, 0 /* SignatureKind.Call */); + if (!sigs || !sigs.length) { + sigs = getSignaturesOfStructuredType(type, 1 /* SignatureKind.Construct */); + } + if ((sigs && sigs.length) || + getPropertyOfType(type, "default" /* InternalSymbolName.Default */, /*skipObjectFunctionPropertyAugment*/ true) || + isEsmCjsRef) { + var moduleType = getTypeWithSyntheticDefaultImportType(type, symbol, moduleSymbol, reference); + return cloneTypeAsModuleType(symbol, moduleType, referenceParent); + } + } + } + } + return symbol; + } + /** + * Create a new symbol which has the module's type less the call and construct signatures + */ + function cloneTypeAsModuleType(symbol, moduleType, referenceParent) { + var result = createSymbol(symbol.flags, symbol.escapedName); + result.declarations = symbol.declarations ? symbol.declarations.slice() : []; + result.parent = symbol.parent; + result.target = symbol; + result.originatingImport = referenceParent; + if (symbol.valueDeclaration) + result.valueDeclaration = symbol.valueDeclaration; + if (symbol.constEnumOnlyModule) + result.constEnumOnlyModule = true; + if (symbol.members) + result.members = new ts.Map(symbol.members); + if (symbol.exports) + result.exports = new ts.Map(symbol.exports); + var resolvedModuleType = resolveStructuredTypeMembers(moduleType); // Should already be resolved from the signature checks above + result.type = createAnonymousType(result, resolvedModuleType.members, ts.emptyArray, ts.emptyArray, resolvedModuleType.indexInfos); + return result; + } + function hasExportAssignmentSymbol(moduleSymbol) { + return moduleSymbol.exports.get("export=" /* InternalSymbolName.ExportEquals */) !== undefined; + } + function getExportsOfModuleAsArray(moduleSymbol) { + return symbolsToArray(getExportsOfModule(moduleSymbol)); + } + function getExportsAndPropertiesOfModule(moduleSymbol) { + var exports = getExportsOfModuleAsArray(moduleSymbol); + var exportEquals = resolveExternalModuleSymbol(moduleSymbol); + if (exportEquals !== moduleSymbol) { + var type = getTypeOfSymbol(exportEquals); + if (shouldTreatPropertiesOfExternalModuleAsExports(type)) { + ts.addRange(exports, getPropertiesOfType(type)); + } + } + return exports; + } + function forEachExportAndPropertyOfModule(moduleSymbol, cb) { + var exports = getExportsOfModule(moduleSymbol); + exports.forEach(function (symbol, key) { + if (!isReservedMemberName(key)) { + cb(symbol, key); + } + }); + var exportEquals = resolveExternalModuleSymbol(moduleSymbol); + if (exportEquals !== moduleSymbol) { + var type = getTypeOfSymbol(exportEquals); + if (shouldTreatPropertiesOfExternalModuleAsExports(type)) { + forEachPropertyOfType(type, function (symbol, escapedName) { + cb(symbol, escapedName); + }); + } + } + } + function tryGetMemberInModuleExports(memberName, moduleSymbol) { + var symbolTable = getExportsOfModule(moduleSymbol); + if (symbolTable) { + return symbolTable.get(memberName); + } + } + function tryGetMemberInModuleExportsAndProperties(memberName, moduleSymbol) { + var symbol = tryGetMemberInModuleExports(memberName, moduleSymbol); + if (symbol) { + return symbol; + } + var exportEquals = resolveExternalModuleSymbol(moduleSymbol); + if (exportEquals === moduleSymbol) { + return undefined; + } + var type = getTypeOfSymbol(exportEquals); + return shouldTreatPropertiesOfExternalModuleAsExports(type) ? getPropertyOfType(type, memberName) : undefined; + } + function shouldTreatPropertiesOfExternalModuleAsExports(resolvedExternalModuleType) { + return !(resolvedExternalModuleType.flags & 131068 /* TypeFlags.Primitive */ || + ts.getObjectFlags(resolvedExternalModuleType) & 1 /* ObjectFlags.Class */ || + // `isArrayOrTupleLikeType` is too expensive to use in this auto-imports hot path + isArrayType(resolvedExternalModuleType) || + isTupleType(resolvedExternalModuleType)); + } + function getExportsOfSymbol(symbol) { + return symbol.flags & 6256 /* SymbolFlags.LateBindingContainer */ ? getResolvedMembersOrExportsOfSymbol(symbol, "resolvedExports" /* MembersOrExportsResolutionKind.resolvedExports */) : + symbol.flags & 1536 /* SymbolFlags.Module */ ? getExportsOfModule(symbol) : + symbol.exports || emptySymbols; + } + function getExportsOfModule(moduleSymbol) { + var links = getSymbolLinks(moduleSymbol); + return links.resolvedExports || (links.resolvedExports = getExportsOfModuleWorker(moduleSymbol)); + } + /** + * Extends one symbol table with another while collecting information on name collisions for error message generation into the `lookupTable` argument + * Not passing `lookupTable` and `exportNode` disables this collection, and just extends the tables + */ + function extendExportSymbols(target, source, lookupTable, exportNode) { + if (!source) + return; + source.forEach(function (sourceSymbol, id) { + if (id === "default" /* InternalSymbolName.Default */) + return; + var targetSymbol = target.get(id); + if (!targetSymbol) { + target.set(id, sourceSymbol); + if (lookupTable && exportNode) { + lookupTable.set(id, { + specifierText: ts.getTextOfNode(exportNode.moduleSpecifier) + }); + } + } + else if (lookupTable && exportNode && targetSymbol && resolveSymbol(targetSymbol) !== resolveSymbol(sourceSymbol)) { + var collisionTracker = lookupTable.get(id); + if (!collisionTracker.exportsWithDuplicate) { + collisionTracker.exportsWithDuplicate = [exportNode]; + } + else { + collisionTracker.exportsWithDuplicate.push(exportNode); + } + } + }); + } + function getExportsOfModuleWorker(moduleSymbol) { + var visitedSymbols = []; + // A module defined by an 'export=' consists of one export that needs to be resolved + moduleSymbol = resolveExternalModuleSymbol(moduleSymbol); + return visit(moduleSymbol) || emptySymbols; + // The ES6 spec permits export * declarations in a module to circularly reference the module itself. For example, + // module 'a' can 'export * from "b"' and 'b' can 'export * from "a"' without error. + function visit(symbol) { + if (!(symbol && symbol.exports && ts.pushIfUnique(visitedSymbols, symbol))) { + return; + } + var symbols = new ts.Map(symbol.exports); + // All export * declarations are collected in an __export symbol by the binder + var exportStars = symbol.exports.get("__export" /* InternalSymbolName.ExportStar */); + if (exportStars) { + var nestedSymbols = ts.createSymbolTable(); + var lookupTable_1 = new ts.Map(); + if (exportStars.declarations) { + for (var _i = 0, _a = exportStars.declarations; _i < _a.length; _i++) { + var node = _a[_i]; + var resolvedModule = resolveExternalModuleName(node, node.moduleSpecifier); + var exportedSymbols = visit(resolvedModule); + extendExportSymbols(nestedSymbols, exportedSymbols, lookupTable_1, node); + } + } + lookupTable_1.forEach(function (_a, id) { + var exportsWithDuplicate = _a.exportsWithDuplicate; + // It's not an error if the file with multiple `export *`s with duplicate names exports a member with that name itself + if (id === "export=" || !(exportsWithDuplicate && exportsWithDuplicate.length) || symbols.has(id)) { + return; + } + for (var _i = 0, exportsWithDuplicate_1 = exportsWithDuplicate; _i < exportsWithDuplicate_1.length; _i++) { + var node = exportsWithDuplicate_1[_i]; + diagnostics.add(ts.createDiagnosticForNode(node, ts.Diagnostics.Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambiguity, lookupTable_1.get(id).specifierText, ts.unescapeLeadingUnderscores(id))); + } + }); + extendExportSymbols(symbols, nestedSymbols); + } + return symbols; + } + } + function getMergedSymbol(symbol) { + var merged; + return symbol && symbol.mergeId && (merged = mergedSymbols[symbol.mergeId]) ? merged : symbol; + } + function getSymbolOfNode(node) { + return getMergedSymbol(node.symbol && getLateBoundSymbol(node.symbol)); + } + function getParentOfSymbol(symbol) { + return getMergedSymbol(symbol.parent && getLateBoundSymbol(symbol.parent)); + } + function getAlternativeContainingModules(symbol, enclosingDeclaration) { + var containingFile = ts.getSourceFileOfNode(enclosingDeclaration); + var id = getNodeId(containingFile); + var links = getSymbolLinks(symbol); + var results; + if (links.extendedContainersByFile && (results = links.extendedContainersByFile.get(id))) { + return results; + } + if (containingFile && containingFile.imports) { + // Try to make an import using an import already in the enclosing file, if possible + for (var _i = 0, _a = containingFile.imports; _i < _a.length; _i++) { + var importRef = _a[_i]; + if (ts.nodeIsSynthesized(importRef)) + continue; // Synthetic names can't be resolved by `resolveExternalModuleName` - they'll cause a debug assert if they error + var resolvedModule = resolveExternalModuleName(enclosingDeclaration, importRef, /*ignoreErrors*/ true); + if (!resolvedModule) + continue; + var ref = getAliasForSymbolInContainer(resolvedModule, symbol); + if (!ref) + continue; + results = ts.append(results, resolvedModule); + } + if (ts.length(results)) { + (links.extendedContainersByFile || (links.extendedContainersByFile = new ts.Map())).set(id, results); + return results; + } + } + if (links.extendedContainers) { + return links.extendedContainers; + } + // No results from files already being imported by this file - expand search (expensive, but not location-specific, so cached) + var otherFiles = host.getSourceFiles(); + for (var _b = 0, otherFiles_1 = otherFiles; _b < otherFiles_1.length; _b++) { + var file = otherFiles_1[_b]; + if (!ts.isExternalModule(file)) + continue; + var sym = getSymbolOfNode(file); + var ref = getAliasForSymbolInContainer(sym, symbol); + if (!ref) + continue; + results = ts.append(results, sym); + } + return links.extendedContainers = results || ts.emptyArray; + } + /** + * Attempts to find the symbol corresponding to the container a symbol is in - usually this + * is just its' `.parent`, but for locals, this value is `undefined` + */ + function getContainersOfSymbol(symbol, enclosingDeclaration, meaning) { + var container = getParentOfSymbol(symbol); + // Type parameters end up in the `members` lists but are not externally visible + if (container && !(symbol.flags & 262144 /* SymbolFlags.TypeParameter */)) { + var additionalContainers = ts.mapDefined(container.declarations, fileSymbolIfFileSymbolExportEqualsContainer); + var reexportContainers = enclosingDeclaration && getAlternativeContainingModules(symbol, enclosingDeclaration); + var objectLiteralContainer = getVariableDeclarationOfObjectLiteral(container, meaning); + if (enclosingDeclaration && + container.flags & getQualifiedLeftMeaning(meaning) && + getAccessibleSymbolChain(container, enclosingDeclaration, 1920 /* SymbolFlags.Namespace */, /*externalOnly*/ false)) { + return ts.append(ts.concatenate(ts.concatenate([container], additionalContainers), reexportContainers), objectLiteralContainer); // This order expresses a preference for the real container if it is in scope + } + // we potentially have a symbol which is a member of the instance side of something - look for a variable in scope with the container's type + // which may be acting like a namespace (eg, `Symbol` acts like a namespace when looking up `Symbol.toStringTag`) + var firstVariableMatch = !(container.flags & getQualifiedLeftMeaning(meaning)) + && container.flags & 788968 /* SymbolFlags.Type */ + && getDeclaredTypeOfSymbol(container).flags & 524288 /* TypeFlags.Object */ + && meaning === 111551 /* SymbolFlags.Value */ + ? forEachSymbolTableInScope(enclosingDeclaration, function (t) { + return ts.forEachEntry(t, function (s) { + if (s.flags & getQualifiedLeftMeaning(meaning) && getTypeOfSymbol(s) === getDeclaredTypeOfSymbol(container)) { + return s; + } + }); + }) : undefined; + var res = firstVariableMatch ? __spreadArray(__spreadArray([firstVariableMatch], additionalContainers, true), [container], false) : __spreadArray(__spreadArray([], additionalContainers, true), [container], false); + res = ts.append(res, objectLiteralContainer); + res = ts.addRange(res, reexportContainers); + return res; + } + var candidates = ts.mapDefined(symbol.declarations, function (d) { + if (!ts.isAmbientModule(d) && d.parent) { + // direct children of a module + if (hasNonGlobalAugmentationExternalModuleSymbol(d.parent)) { + return getSymbolOfNode(d.parent); + } + // export ='d member of an ambient module + if (ts.isModuleBlock(d.parent) && d.parent.parent && resolveExternalModuleSymbol(getSymbolOfNode(d.parent.parent)) === symbol) { + return getSymbolOfNode(d.parent.parent); + } + } + if (ts.isClassExpression(d) && ts.isBinaryExpression(d.parent) && d.parent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ && ts.isAccessExpression(d.parent.left) && ts.isEntityNameExpression(d.parent.left.expression)) { + if (ts.isModuleExportsAccessExpression(d.parent.left) || ts.isExportsIdentifier(d.parent.left.expression)) { + return getSymbolOfNode(ts.getSourceFileOfNode(d)); + } + checkExpressionCached(d.parent.left.expression); + return getNodeLinks(d.parent.left.expression).resolvedSymbol; + } + }); + if (!ts.length(candidates)) { + return undefined; + } + return ts.mapDefined(candidates, function (candidate) { return getAliasForSymbolInContainer(candidate, symbol) ? candidate : undefined; }); + function fileSymbolIfFileSymbolExportEqualsContainer(d) { + return container && getFileSymbolIfFileSymbolExportEqualsContainer(d, container); + } + } + function getVariableDeclarationOfObjectLiteral(symbol, meaning) { + // If we're trying to reference some object literal in, eg `var a = { x: 1 }`, the symbol for the literal, `__object`, is distinct + // from the symbol of the declaration it is being assigned to. Since we can use the declaration to refer to the literal, however, + // we'd like to make that connection here - potentially causing us to paint the declaration's visibility, and therefore the literal. + var firstDecl = !!ts.length(symbol.declarations) && ts.first(symbol.declarations); + if (meaning & 111551 /* SymbolFlags.Value */ && firstDecl && firstDecl.parent && ts.isVariableDeclaration(firstDecl.parent)) { + if (ts.isObjectLiteralExpression(firstDecl) && firstDecl === firstDecl.parent.initializer || ts.isTypeLiteralNode(firstDecl) && firstDecl === firstDecl.parent.type) { + return getSymbolOfNode(firstDecl.parent); + } + } + } + function getFileSymbolIfFileSymbolExportEqualsContainer(d, container) { + var fileSymbol = getExternalModuleContainer(d); + var exported = fileSymbol && fileSymbol.exports && fileSymbol.exports.get("export=" /* InternalSymbolName.ExportEquals */); + return exported && getSymbolIfSameReference(exported, container) ? fileSymbol : undefined; + } + function getAliasForSymbolInContainer(container, symbol) { + if (container === getParentOfSymbol(symbol)) { + // fast path, `symbol` is either already the alias or isn't aliased + return symbol; + } + // Check if container is a thing with an `export=` which points directly at `symbol`, and if so, return + // the container itself as the alias for the symbol + var exportEquals = container.exports && container.exports.get("export=" /* InternalSymbolName.ExportEquals */); + if (exportEquals && getSymbolIfSameReference(exportEquals, symbol)) { + return container; + } + var exports = getExportsOfSymbol(container); + var quick = exports.get(symbol.escapedName); + if (quick && getSymbolIfSameReference(quick, symbol)) { + return quick; + } + return ts.forEachEntry(exports, function (exported) { + if (getSymbolIfSameReference(exported, symbol)) { + return exported; + } + }); + } + /** + * Checks if two symbols, through aliasing and/or merging, refer to the same thing + */ + function getSymbolIfSameReference(s1, s2) { + if (getMergedSymbol(resolveSymbol(getMergedSymbol(s1))) === getMergedSymbol(resolveSymbol(getMergedSymbol(s2)))) { + return s1; + } + } + function getExportSymbolOfValueSymbolIfExported(symbol) { + return getMergedSymbol(symbol && (symbol.flags & 1048576 /* SymbolFlags.ExportValue */) !== 0 && symbol.exportSymbol || symbol); + } + function symbolIsValue(symbol, includeTypeOnlyMembers) { + return !!(symbol.flags & 111551 /* SymbolFlags.Value */ || + symbol.flags & 2097152 /* SymbolFlags.Alias */ && getAllSymbolFlags(symbol) & 111551 /* SymbolFlags.Value */ && (includeTypeOnlyMembers || !getTypeOnlyAliasDeclaration(symbol))); + } + function findConstructorDeclaration(node) { + var members = node.members; + for (var _i = 0, members_3 = members; _i < members_3.length; _i++) { + var member = members_3[_i]; + if (member.kind === 173 /* SyntaxKind.Constructor */ && ts.nodeIsPresent(member.body)) { + return member; + } + } + } + function createType(flags) { + var result = new Type(checker, flags); + typeCount++; + result.id = typeCount; + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.recordType(result); + return result; + } + function createOriginType(flags) { + return new Type(checker, flags); + } + function createIntrinsicType(kind, intrinsicName, objectFlags) { + if (objectFlags === void 0) { objectFlags = 0; } + var type = createType(kind); + type.intrinsicName = intrinsicName; + type.objectFlags = objectFlags; + return type; + } + function createObjectType(objectFlags, symbol) { + var type = createType(524288 /* TypeFlags.Object */); + type.objectFlags = objectFlags; + type.symbol = symbol; + type.members = undefined; + type.properties = undefined; + type.callSignatures = undefined; + type.constructSignatures = undefined; + type.indexInfos = undefined; + return type; + } + function createTypeofType() { + return getUnionType(ts.arrayFrom(typeofNEFacts.keys(), getStringLiteralType)); + } + function createTypeParameter(symbol) { + var type = createType(262144 /* TypeFlags.TypeParameter */); + if (symbol) + type.symbol = symbol; + return type; + } + // A reserved member name starts with two underscores, but the third character cannot be an underscore, + // @, or #. A third underscore indicates an escaped form of an identifier that started + // with at least two underscores. The @ character indicates that the name is denoted by a well known ES + // Symbol instance and the # character indicates that the name is a PrivateIdentifier. + function isReservedMemberName(name) { + return name.charCodeAt(0) === 95 /* CharacterCodes._ */ && + name.charCodeAt(1) === 95 /* CharacterCodes._ */ && + name.charCodeAt(2) !== 95 /* CharacterCodes._ */ && + name.charCodeAt(2) !== 64 /* CharacterCodes.at */ && + name.charCodeAt(2) !== 35 /* CharacterCodes.hash */; + } + function getNamedMembers(members) { + var result; + members.forEach(function (symbol, id) { + if (isNamedMember(symbol, id)) { + (result || (result = [])).push(symbol); + } + }); + return result || ts.emptyArray; + } + function isNamedMember(member, escapedName) { + return !isReservedMemberName(escapedName) && symbolIsValue(member); + } + function getNamedOrIndexSignatureMembers(members) { + var result = getNamedMembers(members); + var index = getIndexSymbolFromSymbolTable(members); + return index ? ts.concatenate(result, [index]) : result; + } + function setStructuredTypeMembers(type, members, callSignatures, constructSignatures, indexInfos) { + var resolved = type; + resolved.members = members; + resolved.properties = ts.emptyArray; + resolved.callSignatures = callSignatures; + resolved.constructSignatures = constructSignatures; + resolved.indexInfos = indexInfos; + // This can loop back to getPropertyOfType() which would crash if `callSignatures` & `constructSignatures` are not initialized. + if (members !== emptySymbols) + resolved.properties = getNamedMembers(members); + return resolved; + } + function createAnonymousType(symbol, members, callSignatures, constructSignatures, indexInfos) { + return setStructuredTypeMembers(createObjectType(16 /* ObjectFlags.Anonymous */, symbol), members, callSignatures, constructSignatures, indexInfos); + } + function getResolvedTypeWithoutAbstractConstructSignatures(type) { + if (type.constructSignatures.length === 0) + return type; + if (type.objectTypeWithoutAbstractConstructSignatures) + return type.objectTypeWithoutAbstractConstructSignatures; + var constructSignatures = ts.filter(type.constructSignatures, function (signature) { return !(signature.flags & 4 /* SignatureFlags.Abstract */); }); + if (type.constructSignatures === constructSignatures) + return type; + var typeCopy = createAnonymousType(type.symbol, type.members, type.callSignatures, ts.some(constructSignatures) ? constructSignatures : ts.emptyArray, type.indexInfos); + type.objectTypeWithoutAbstractConstructSignatures = typeCopy; + typeCopy.objectTypeWithoutAbstractConstructSignatures = typeCopy; + return typeCopy; + } + function forEachSymbolTableInScope(enclosingDeclaration, callback) { + var result; + var _loop_8 = function (location) { + // Locals of a source file are not in scope (because they get merged into the global symbol table) + if (location.locals && !isGlobalSourceFile(location)) { + if (result = callback(location.locals, /*ignoreQualification*/ undefined, /*isLocalNameLookup*/ true, location)) { + return { value: result }; + } + } + switch (location.kind) { + case 308 /* SyntaxKind.SourceFile */: + if (!ts.isExternalOrCommonJsModule(location)) { + break; + } + // falls through + case 264 /* SyntaxKind.ModuleDeclaration */: + var sym = getSymbolOfNode(location); + // `sym` may not have exports if this module declaration is backed by the symbol for a `const` that's being rewritten + // into a namespace - in such cases, it's best to just let the namespace appear empty (the const members couldn't have referred + // to one another anyway) + if (result = callback((sym === null || sym === void 0 ? void 0 : sym.exports) || emptySymbols, /*ignoreQualification*/ undefined, /*isLocalNameLookup*/ true, location)) { + return { value: result }; + } + break; + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + // Type parameters are bound into `members` lists so they can merge across declarations + // This is troublesome, since in all other respects, they behave like locals :cries: + // TODO: the below is shared with similar code in `resolveName` - in fact, rephrasing all this symbol + // lookup logic in terms of `resolveName` would be nice + // The below is used to lookup type parameters within a class or interface, as they are added to the class/interface locals + // These can never be latebound, so the symbol's raw members are sufficient. `getMembersOfNode` cannot be used, as it would + // trigger resolving late-bound names, which we may already be in the process of doing while we're here! + var table_1; + // TODO: Should this filtered table be cached in some way? + (getSymbolOfNode(location).members || emptySymbols).forEach(function (memberSymbol, key) { + if (memberSymbol.flags & (788968 /* SymbolFlags.Type */ & ~67108864 /* SymbolFlags.Assignment */)) { + (table_1 || (table_1 = ts.createSymbolTable())).set(key, memberSymbol); + } + }); + if (table_1 && (result = callback(table_1, /*ignoreQualification*/ undefined, /*isLocalNameLookup*/ false, location))) { + return { value: result }; + } + break; + } + }; + for (var location = enclosingDeclaration; location; location = location.parent) { + var state_2 = _loop_8(location); + if (typeof state_2 === "object") + return state_2.value; + } + return callback(globals, /*ignoreQualification*/ undefined, /*isLocalNameLookup*/ true); + } + function getQualifiedLeftMeaning(rightMeaning) { + // If we are looking in value space, the parent meaning is value, other wise it is namespace + return rightMeaning === 111551 /* SymbolFlags.Value */ ? 111551 /* SymbolFlags.Value */ : 1920 /* SymbolFlags.Namespace */; + } + function getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, useOnlyExternalAliasing, visitedSymbolTablesMap) { + if (visitedSymbolTablesMap === void 0) { visitedSymbolTablesMap = new ts.Map(); } + if (!(symbol && !isPropertyOrMethodDeclarationSymbol(symbol))) { + return undefined; + } + var links = getSymbolLinks(symbol); + var cache = (links.accessibleChainCache || (links.accessibleChainCache = new ts.Map())); + // Go from enclosingDeclaration to the first scope we check, so the cache is keyed off the scope and thus shared more + var firstRelevantLocation = forEachSymbolTableInScope(enclosingDeclaration, function (_, __, ___, node) { return node; }); + var key = "".concat(useOnlyExternalAliasing ? 0 : 1, "|").concat(firstRelevantLocation && getNodeId(firstRelevantLocation), "|").concat(meaning); + if (cache.has(key)) { + return cache.get(key); + } + var id = getSymbolId(symbol); + var visitedSymbolTables = visitedSymbolTablesMap.get(id); + if (!visitedSymbolTables) { + visitedSymbolTablesMap.set(id, visitedSymbolTables = []); + } + var result = forEachSymbolTableInScope(enclosingDeclaration, getAccessibleSymbolChainFromSymbolTable); + cache.set(key, result); + return result; + /** + * @param {ignoreQualification} boolean Set when a symbol is being looked for through the exports of another symbol (meaning we have a route to qualify it already) + */ + function getAccessibleSymbolChainFromSymbolTable(symbols, ignoreQualification, isLocalNameLookup) { + if (!ts.pushIfUnique(visitedSymbolTables, symbols)) { + return undefined; + } + var result = trySymbolTable(symbols, ignoreQualification, isLocalNameLookup); + visitedSymbolTables.pop(); + return result; + } + function canQualifySymbol(symbolFromSymbolTable, meaning) { + // If the symbol is equivalent and doesn't need further qualification, this symbol is accessible + return !needsQualification(symbolFromSymbolTable, enclosingDeclaration, meaning) || + // If symbol needs qualification, make sure that parent is accessible, if it is then this symbol is accessible too + !!getAccessibleSymbolChain(symbolFromSymbolTable.parent, enclosingDeclaration, getQualifiedLeftMeaning(meaning), useOnlyExternalAliasing, visitedSymbolTablesMap); + } + function isAccessible(symbolFromSymbolTable, resolvedAliasSymbol, ignoreQualification) { + return (symbol === (resolvedAliasSymbol || symbolFromSymbolTable) || getMergedSymbol(symbol) === getMergedSymbol(resolvedAliasSymbol || symbolFromSymbolTable)) && + // if the symbolFromSymbolTable is not external module (it could be if it was determined as ambient external module and would be in globals table) + // and if symbolFromSymbolTable or alias resolution matches the symbol, + // check the symbol can be qualified, it is only then this symbol is accessible + !ts.some(symbolFromSymbolTable.declarations, hasNonGlobalAugmentationExternalModuleSymbol) && + (ignoreQualification || canQualifySymbol(getMergedSymbol(symbolFromSymbolTable), meaning)); + } + function trySymbolTable(symbols, ignoreQualification, isLocalNameLookup) { + // If symbol is directly available by its name in the symbol table + if (isAccessible(symbols.get(symbol.escapedName), /*resolvedAliasSymbol*/ undefined, ignoreQualification)) { + return [symbol]; + } + // Check if symbol is any of the aliases in scope + var result = ts.forEachEntry(symbols, function (symbolFromSymbolTable) { + if (symbolFromSymbolTable.flags & 2097152 /* SymbolFlags.Alias */ + && symbolFromSymbolTable.escapedName !== "export=" /* InternalSymbolName.ExportEquals */ + && symbolFromSymbolTable.escapedName !== "default" /* InternalSymbolName.Default */ + && !(ts.isUMDExportSymbol(symbolFromSymbolTable) && enclosingDeclaration && ts.isExternalModule(ts.getSourceFileOfNode(enclosingDeclaration))) + // If `!useOnlyExternalAliasing`, we can use any type of alias to get the name + && (!useOnlyExternalAliasing || ts.some(symbolFromSymbolTable.declarations, ts.isExternalModuleImportEqualsDeclaration)) + // If we're looking up a local name to reference directly, omit namespace reexports, otherwise when we're trawling through an export list to make a dotted name, we can keep it + && (isLocalNameLookup ? !ts.some(symbolFromSymbolTable.declarations, ts.isNamespaceReexportDeclaration) : true) + // While exports are generally considered to be in scope, export-specifier declared symbols are _not_ + // See similar comment in `resolveName` for details + && (ignoreQualification || !ts.getDeclarationOfKind(symbolFromSymbolTable, 278 /* SyntaxKind.ExportSpecifier */))) { + var resolvedImportedSymbol = resolveAlias(symbolFromSymbolTable); + var candidate = getCandidateListForSymbol(symbolFromSymbolTable, resolvedImportedSymbol, ignoreQualification); + if (candidate) { + return candidate; + } + } + if (symbolFromSymbolTable.escapedName === symbol.escapedName && symbolFromSymbolTable.exportSymbol) { + if (isAccessible(getMergedSymbol(symbolFromSymbolTable.exportSymbol), /*aliasSymbol*/ undefined, ignoreQualification)) { + return [symbol]; + } + } + }); + // If there's no result and we're looking at the global symbol table, treat `globalThis` like an alias and try to lookup thru that + return result || (symbols === globals ? getCandidateListForSymbol(globalThisSymbol, globalThisSymbol, ignoreQualification) : undefined); + } + function getCandidateListForSymbol(symbolFromSymbolTable, resolvedImportedSymbol, ignoreQualification) { + if (isAccessible(symbolFromSymbolTable, resolvedImportedSymbol, ignoreQualification)) { + return [symbolFromSymbolTable]; + } + // Look in the exported members, if we can find accessibleSymbolChain, symbol is accessible using this chain + // but only if the symbolFromSymbolTable can be qualified + var candidateTable = getExportsOfSymbol(resolvedImportedSymbol); + var accessibleSymbolsFromExports = candidateTable && getAccessibleSymbolChainFromSymbolTable(candidateTable, /*ignoreQualification*/ true); + if (accessibleSymbolsFromExports && canQualifySymbol(symbolFromSymbolTable, getQualifiedLeftMeaning(meaning))) { + return [symbolFromSymbolTable].concat(accessibleSymbolsFromExports); + } + } + } + function needsQualification(symbol, enclosingDeclaration, meaning) { + var qualify = false; + forEachSymbolTableInScope(enclosingDeclaration, function (symbolTable) { + // If symbol of this name is not available in the symbol table we are ok + var symbolFromSymbolTable = getMergedSymbol(symbolTable.get(symbol.escapedName)); + if (!symbolFromSymbolTable) { + // Continue to the next symbol table + return false; + } + // If the symbol with this name is present it should refer to the symbol + if (symbolFromSymbolTable === symbol) { + // No need to qualify + return true; + } + // Qualify if the symbol from symbol table has same meaning as expected + var shouldResolveAlias = (symbolFromSymbolTable.flags & 2097152 /* SymbolFlags.Alias */ && !ts.getDeclarationOfKind(symbolFromSymbolTable, 278 /* SyntaxKind.ExportSpecifier */)); + symbolFromSymbolTable = shouldResolveAlias ? resolveAlias(symbolFromSymbolTable) : symbolFromSymbolTable; + var flags = shouldResolveAlias ? getAllSymbolFlags(symbolFromSymbolTable) : symbolFromSymbolTable.flags; + if (flags & meaning) { + qualify = true; + return true; + } + // Continue to the next symbol table + return false; + }); + return qualify; + } + function isPropertyOrMethodDeclarationSymbol(symbol) { + if (symbol.declarations && symbol.declarations.length) { + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + switch (declaration.kind) { + case 169 /* SyntaxKind.PropertyDeclaration */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + continue; + default: + return false; + } + } + return true; + } + return false; + } + function isTypeSymbolAccessible(typeSymbol, enclosingDeclaration) { + var access = isSymbolAccessibleWorker(typeSymbol, enclosingDeclaration, 788968 /* SymbolFlags.Type */, /*shouldComputeAliasesToMakeVisible*/ false, /*allowModules*/ true); + return access.accessibility === 0 /* SymbolAccessibility.Accessible */; + } + function isValueSymbolAccessible(typeSymbol, enclosingDeclaration) { + var access = isSymbolAccessibleWorker(typeSymbol, enclosingDeclaration, 111551 /* SymbolFlags.Value */, /*shouldComputeAliasesToMakeVisible*/ false, /*allowModules*/ true); + return access.accessibility === 0 /* SymbolAccessibility.Accessible */; + } + function isSymbolAccessibleByFlags(typeSymbol, enclosingDeclaration, flags) { + var access = isSymbolAccessibleWorker(typeSymbol, enclosingDeclaration, flags, /*shouldComputeAliasesToMakeVisible*/ false, /*allowModules*/ false); + return access.accessibility === 0 /* SymbolAccessibility.Accessible */; + } + function isAnySymbolAccessible(symbols, enclosingDeclaration, initialSymbol, meaning, shouldComputeAliasesToMakeVisible, allowModules) { + if (!ts.length(symbols)) + return; + var hadAccessibleChain; + var earlyModuleBail = false; + for (var _i = 0, _a = symbols; _i < _a.length; _i++) { + var symbol = _a[_i]; + // Symbol is accessible if it by itself is accessible + var accessibleSymbolChain = getAccessibleSymbolChain(symbol, enclosingDeclaration, meaning, /*useOnlyExternalAliasing*/ false); + if (accessibleSymbolChain) { + hadAccessibleChain = symbol; + var hasAccessibleDeclarations = hasVisibleDeclarations(accessibleSymbolChain[0], shouldComputeAliasesToMakeVisible); + if (hasAccessibleDeclarations) { + return hasAccessibleDeclarations; + } + } + if (allowModules) { + if (ts.some(symbol.declarations, hasNonGlobalAugmentationExternalModuleSymbol)) { + if (shouldComputeAliasesToMakeVisible) { + earlyModuleBail = true; + // Generally speaking, we want to use the aliases that already exist to refer to a module, if present + // In order to do so, we need to find those aliases in order to retain them in declaration emit; so + // if we are in declaration emit, we cannot use the fast path for module visibility until we've exhausted + // all other visibility options (in order to capture the possible aliases used to reference the module) + continue; + } + // Any meaning of a module symbol is always accessible via an `import` type + return { + accessibility: 0 /* SymbolAccessibility.Accessible */ + }; + } + } + // If we haven't got the accessible symbol, it doesn't mean the symbol is actually inaccessible. + // It could be a qualified symbol and hence verify the path + // e.g.: + // module m { + // export class c { + // } + // } + // const x: typeof m.c + // In the above example when we start with checking if typeof m.c symbol is accessible, + // we are going to see if c can be accessed in scope directly. + // But it can't, hence the accessible is going to be undefined, but that doesn't mean m.c is inaccessible + // It is accessible if the parent m is accessible because then m.c can be accessed through qualification + var containers = getContainersOfSymbol(symbol, enclosingDeclaration, meaning); + var parentResult = isAnySymbolAccessible(containers, enclosingDeclaration, initialSymbol, initialSymbol === symbol ? getQualifiedLeftMeaning(meaning) : meaning, shouldComputeAliasesToMakeVisible, allowModules); + if (parentResult) { + return parentResult; + } + } + if (earlyModuleBail) { + return { + accessibility: 0 /* SymbolAccessibility.Accessible */ + }; + } + if (hadAccessibleChain) { + return { + accessibility: 1 /* SymbolAccessibility.NotAccessible */, + errorSymbolName: symbolToString(initialSymbol, enclosingDeclaration, meaning), + errorModuleName: hadAccessibleChain !== initialSymbol ? symbolToString(hadAccessibleChain, enclosingDeclaration, 1920 /* SymbolFlags.Namespace */) : undefined, + }; + } + } + /** + * Check if the given symbol in given enclosing declaration is accessible and mark all associated alias to be visible if requested + * + * @param symbol a Symbol to check if accessible + * @param enclosingDeclaration a Node containing reference to the symbol + * @param meaning a SymbolFlags to check if such meaning of the symbol is accessible + * @param shouldComputeAliasToMakeVisible a boolean value to indicate whether to return aliases to be mark visible in case the symbol is accessible + */ + function isSymbolAccessible(symbol, enclosingDeclaration, meaning, shouldComputeAliasesToMakeVisible) { + return isSymbolAccessibleWorker(symbol, enclosingDeclaration, meaning, shouldComputeAliasesToMakeVisible, /*allowModules*/ true); + } + function isSymbolAccessibleWorker(symbol, enclosingDeclaration, meaning, shouldComputeAliasesToMakeVisible, allowModules) { + if (symbol && enclosingDeclaration) { + var result = isAnySymbolAccessible([symbol], enclosingDeclaration, symbol, meaning, shouldComputeAliasesToMakeVisible, allowModules); + if (result) { + return result; + } + // This could be a symbol that is not exported in the external module + // or it could be a symbol from different external module that is not aliased and hence cannot be named + var symbolExternalModule = ts.forEach(symbol.declarations, getExternalModuleContainer); + if (symbolExternalModule) { + var enclosingExternalModule = getExternalModuleContainer(enclosingDeclaration); + if (symbolExternalModule !== enclosingExternalModule) { + // name from different external module that is not visible + return { + accessibility: 2 /* SymbolAccessibility.CannotBeNamed */, + errorSymbolName: symbolToString(symbol, enclosingDeclaration, meaning), + errorModuleName: symbolToString(symbolExternalModule), + errorNode: ts.isInJSFile(enclosingDeclaration) ? enclosingDeclaration : undefined, + }; + } + } + // Just a local name that is not accessible + return { + accessibility: 1 /* SymbolAccessibility.NotAccessible */, + errorSymbolName: symbolToString(symbol, enclosingDeclaration, meaning), + }; + } + return { accessibility: 0 /* SymbolAccessibility.Accessible */ }; + } + function getExternalModuleContainer(declaration) { + var node = ts.findAncestor(declaration, hasExternalModuleSymbol); + return node && getSymbolOfNode(node); + } + function hasExternalModuleSymbol(declaration) { + return ts.isAmbientModule(declaration) || (declaration.kind === 308 /* SyntaxKind.SourceFile */ && ts.isExternalOrCommonJsModule(declaration)); + } + function hasNonGlobalAugmentationExternalModuleSymbol(declaration) { + return ts.isModuleWithStringLiteralName(declaration) || (declaration.kind === 308 /* SyntaxKind.SourceFile */ && ts.isExternalOrCommonJsModule(declaration)); + } + function hasVisibleDeclarations(symbol, shouldComputeAliasToMakeVisible) { + var aliasesToMakeVisible; + if (!ts.every(ts.filter(symbol.declarations, function (d) { return d.kind !== 79 /* SyntaxKind.Identifier */; }), getIsDeclarationVisible)) { + return undefined; + } + return { accessibility: 0 /* SymbolAccessibility.Accessible */, aliasesToMakeVisible: aliasesToMakeVisible }; + function getIsDeclarationVisible(declaration) { + var _a, _b; + if (!isDeclarationVisible(declaration)) { + // Mark the unexported alias as visible if its parent is visible + // because these kind of aliases can be used to name types in declaration file + var anyImportSyntax = getAnyImportSyntax(declaration); + if (anyImportSyntax && + !ts.hasSyntacticModifier(anyImportSyntax, 1 /* ModifierFlags.Export */) && // import clause without export + isDeclarationVisible(anyImportSyntax.parent)) { + return addVisibleAlias(declaration, anyImportSyntax); + } + else if (ts.isVariableDeclaration(declaration) && ts.isVariableStatement(declaration.parent.parent) && + !ts.hasSyntacticModifier(declaration.parent.parent, 1 /* ModifierFlags.Export */) && // unexported variable statement + isDeclarationVisible(declaration.parent.parent.parent)) { + return addVisibleAlias(declaration, declaration.parent.parent); + } + else if (ts.isLateVisibilityPaintedStatement(declaration) // unexported top-level statement + && !ts.hasSyntacticModifier(declaration, 1 /* ModifierFlags.Export */) + && isDeclarationVisible(declaration.parent)) { + return addVisibleAlias(declaration, declaration); + } + else if (ts.isBindingElement(declaration)) { + if (symbol.flags & 2097152 /* SymbolFlags.Alias */ && ts.isInJSFile(declaration) && ((_a = declaration.parent) === null || _a === void 0 ? void 0 : _a.parent) // exported import-like top-level JS require statement + && ts.isVariableDeclaration(declaration.parent.parent) + && ((_b = declaration.parent.parent.parent) === null || _b === void 0 ? void 0 : _b.parent) && ts.isVariableStatement(declaration.parent.parent.parent.parent) + && !ts.hasSyntacticModifier(declaration.parent.parent.parent.parent, 1 /* ModifierFlags.Export */) + && declaration.parent.parent.parent.parent.parent // check if the thing containing the variable statement is visible (ie, the file) + && isDeclarationVisible(declaration.parent.parent.parent.parent.parent)) { + return addVisibleAlias(declaration, declaration.parent.parent.parent.parent); + } + else if (symbol.flags & 2 /* SymbolFlags.BlockScopedVariable */) { + var variableStatement = ts.findAncestor(declaration, ts.isVariableStatement); + if (ts.hasSyntacticModifier(variableStatement, 1 /* ModifierFlags.Export */)) { + return true; + } + if (!isDeclarationVisible(variableStatement.parent)) { + return false; + } + return addVisibleAlias(declaration, variableStatement); + } + } + // Declaration is not visible + return false; + } + return true; + } + function addVisibleAlias(declaration, aliasingStatement) { + // In function "buildTypeDisplay" where we decide whether to write type-alias or serialize types, + // we want to just check if type- alias is accessible or not but we don't care about emitting those alias at that time + // since we will do the emitting later in trackSymbol. + if (shouldComputeAliasToMakeVisible) { + getNodeLinks(declaration).isVisible = true; + aliasesToMakeVisible = ts.appendIfUnique(aliasesToMakeVisible, aliasingStatement); + } + return true; + } + } + function isEntityNameVisible(entityName, enclosingDeclaration) { + // get symbol of the first identifier of the entityName + var meaning; + if (entityName.parent.kind === 183 /* SyntaxKind.TypeQuery */ || + entityName.parent.kind === 230 /* SyntaxKind.ExpressionWithTypeArguments */ && !ts.isPartOfTypeNode(entityName.parent) || + entityName.parent.kind === 164 /* SyntaxKind.ComputedPropertyName */) { + // Typeof value + meaning = 111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */; + } + else if (entityName.kind === 163 /* SyntaxKind.QualifiedName */ || entityName.kind === 208 /* SyntaxKind.PropertyAccessExpression */ || + entityName.parent.kind === 268 /* SyntaxKind.ImportEqualsDeclaration */) { + // Left identifier from type reference or TypeAlias + // Entity name of the import declaration + meaning = 1920 /* SymbolFlags.Namespace */; + } + else { + // Type Reference or TypeAlias entity = Identifier + meaning = 788968 /* SymbolFlags.Type */; + } + var firstIdentifier = ts.getFirstIdentifier(entityName); + var symbol = resolveName(enclosingDeclaration, firstIdentifier.escapedText, meaning, /*nodeNotFoundErrorMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false); + if (symbol && symbol.flags & 262144 /* SymbolFlags.TypeParameter */ && meaning & 788968 /* SymbolFlags.Type */) { + return { accessibility: 0 /* SymbolAccessibility.Accessible */ }; + } + if (!symbol && ts.isThisIdentifier(firstIdentifier) && isSymbolAccessible(getSymbolOfNode(ts.getThisContainer(firstIdentifier, /*includeArrowFunctions*/ false)), firstIdentifier, meaning, /*computeAliases*/ false).accessibility === 0 /* SymbolAccessibility.Accessible */) { + return { accessibility: 0 /* SymbolAccessibility.Accessible */ }; + } + // Verify if the symbol is accessible + return (symbol && hasVisibleDeclarations(symbol, /*shouldComputeAliasToMakeVisible*/ true)) || { + accessibility: 1 /* SymbolAccessibility.NotAccessible */, + errorSymbolName: ts.getTextOfNode(firstIdentifier), + errorNode: firstIdentifier + }; + } + function symbolToString(symbol, enclosingDeclaration, meaning, flags, writer) { + if (flags === void 0) { flags = 4 /* SymbolFormatFlags.AllowAnyNodeKind */; } + var nodeFlags = 70221824 /* NodeBuilderFlags.IgnoreErrors */; + if (flags & 2 /* SymbolFormatFlags.UseOnlyExternalAliasing */) { + nodeFlags |= 128 /* NodeBuilderFlags.UseOnlyExternalAliasing */; + } + if (flags & 1 /* SymbolFormatFlags.WriteTypeParametersOrArguments */) { + nodeFlags |= 512 /* NodeBuilderFlags.WriteTypeParametersInQualifiedName */; + } + if (flags & 8 /* SymbolFormatFlags.UseAliasDefinedOutsideCurrentScope */) { + nodeFlags |= 16384 /* NodeBuilderFlags.UseAliasDefinedOutsideCurrentScope */; + } + if (flags & 32 /* SymbolFormatFlags.DoNotIncludeSymbolChain */) { + nodeFlags |= 134217728 /* NodeBuilderFlags.DoNotIncludeSymbolChain */; + } + if (flags & 16 /* SymbolFormatFlags.WriteComputedProps */) { + nodeFlags |= 1073741824 /* NodeBuilderFlags.WriteComputedProps */; + } + var builder = flags & 4 /* SymbolFormatFlags.AllowAnyNodeKind */ ? nodeBuilder.symbolToNode : nodeBuilder.symbolToEntityName; + return writer ? symbolToStringWorker(writer).getText() : ts.usingSingleLineStringWriter(symbolToStringWorker); + function symbolToStringWorker(writer) { + var entity = builder(symbol, meaning, enclosingDeclaration, nodeFlags); // TODO: GH#18217 + // add neverAsciiEscape for GH#39027 + var printer = (enclosingDeclaration === null || enclosingDeclaration === void 0 ? void 0 : enclosingDeclaration.kind) === 308 /* SyntaxKind.SourceFile */ ? ts.createPrinter({ removeComments: true, neverAsciiEscape: true }) : ts.createPrinter({ removeComments: true }); + var sourceFile = enclosingDeclaration && ts.getSourceFileOfNode(enclosingDeclaration); + printer.writeNode(4 /* EmitHint.Unspecified */, entity, /*sourceFile*/ sourceFile, writer); + return writer; + } + } + function signatureToString(signature, enclosingDeclaration, flags, kind, writer) { + if (flags === void 0) { flags = 0 /* TypeFormatFlags.None */; } + return writer ? signatureToStringWorker(writer).getText() : ts.usingSingleLineStringWriter(signatureToStringWorker); + function signatureToStringWorker(writer) { + var sigOutput; + if (flags & 262144 /* TypeFormatFlags.WriteArrowStyleSignature */) { + sigOutput = kind === 1 /* SignatureKind.Construct */ ? 182 /* SyntaxKind.ConstructorType */ : 181 /* SyntaxKind.FunctionType */; + } + else { + sigOutput = kind === 1 /* SignatureKind.Construct */ ? 177 /* SyntaxKind.ConstructSignature */ : 176 /* SyntaxKind.CallSignature */; + } + var sig = nodeBuilder.signatureToSignatureDeclaration(signature, sigOutput, enclosingDeclaration, toNodeBuilderFlags(flags) | 70221824 /* NodeBuilderFlags.IgnoreErrors */ | 512 /* NodeBuilderFlags.WriteTypeParametersInQualifiedName */); + var printer = ts.createPrinter({ removeComments: true, omitTrailingSemicolon: true }); + var sourceFile = enclosingDeclaration && ts.getSourceFileOfNode(enclosingDeclaration); + printer.writeNode(4 /* EmitHint.Unspecified */, sig, /*sourceFile*/ sourceFile, ts.getTrailingSemicolonDeferringWriter(writer)); // TODO: GH#18217 + return writer; + } + } + function typeToString(type, enclosingDeclaration, flags, writer) { + if (flags === void 0) { flags = 1048576 /* TypeFormatFlags.AllowUniqueESSymbolType */ | 16384 /* TypeFormatFlags.UseAliasDefinedOutsideCurrentScope */; } + if (writer === void 0) { writer = ts.createTextWriter(""); } + var noTruncation = compilerOptions.noErrorTruncation || flags & 1 /* TypeFormatFlags.NoTruncation */; + var typeNode = nodeBuilder.typeToTypeNode(type, enclosingDeclaration, toNodeBuilderFlags(flags) | 70221824 /* NodeBuilderFlags.IgnoreErrors */ | (noTruncation ? 1 /* NodeBuilderFlags.NoTruncation */ : 0), writer); + if (typeNode === undefined) + return ts.Debug.fail("should always get typenode"); + // The unresolved type gets a synthesized comment on `any` to hint to users that it's not a plain `any`. + // Otherwise, we always strip comments out. + var options = { removeComments: type !== unresolvedType }; + var printer = ts.createPrinter(options); + var sourceFile = enclosingDeclaration && ts.getSourceFileOfNode(enclosingDeclaration); + printer.writeNode(4 /* EmitHint.Unspecified */, typeNode, /*sourceFile*/ sourceFile, writer); + var result = writer.getText(); + var maxLength = noTruncation ? ts.noTruncationMaximumTruncationLength * 2 : ts.defaultMaximumTruncationLength * 2; + if (maxLength && result && result.length >= maxLength) { + return result.substr(0, maxLength - "...".length) + "..."; + } + return result; + } + function getTypeNamesForErrorDisplay(left, right) { + var leftStr = symbolValueDeclarationIsContextSensitive(left.symbol) ? typeToString(left, left.symbol.valueDeclaration) : typeToString(left); + var rightStr = symbolValueDeclarationIsContextSensitive(right.symbol) ? typeToString(right, right.symbol.valueDeclaration) : typeToString(right); + if (leftStr === rightStr) { + leftStr = getTypeNameForErrorDisplay(left); + rightStr = getTypeNameForErrorDisplay(right); + } + return [leftStr, rightStr]; + } + function getTypeNameForErrorDisplay(type) { + return typeToString(type, /*enclosingDeclaration*/ undefined, 64 /* TypeFormatFlags.UseFullyQualifiedType */); + } + function symbolValueDeclarationIsContextSensitive(symbol) { + return symbol && !!symbol.valueDeclaration && ts.isExpression(symbol.valueDeclaration) && !isContextSensitive(symbol.valueDeclaration); + } + function toNodeBuilderFlags(flags) { + if (flags === void 0) { flags = 0 /* TypeFormatFlags.None */; } + return flags & 848330091 /* TypeFormatFlags.NodeBuilderFlagsMask */; + } + function isClassInstanceSide(type) { + return !!type.symbol && !!(type.symbol.flags & 32 /* SymbolFlags.Class */) && (type === getDeclaredTypeOfClassOrInterface(type.symbol) || (!!(type.flags & 524288 /* TypeFlags.Object */) && !!(ts.getObjectFlags(type) & 16777216 /* ObjectFlags.IsClassInstanceClone */))); + } + function createNodeBuilder() { + return { + typeToTypeNode: function (type, enclosingDeclaration, flags, tracker) { + return withContext(enclosingDeclaration, flags, tracker, function (context) { return typeToTypeNodeHelper(type, context); }); + }, + indexInfoToIndexSignatureDeclaration: function (indexInfo, enclosingDeclaration, flags, tracker) { + return withContext(enclosingDeclaration, flags, tracker, function (context) { return indexInfoToIndexSignatureDeclarationHelper(indexInfo, context, /*typeNode*/ undefined); }); + }, + signatureToSignatureDeclaration: function (signature, kind, enclosingDeclaration, flags, tracker) { + return withContext(enclosingDeclaration, flags, tracker, function (context) { return signatureToSignatureDeclarationHelper(signature, kind, context); }); + }, + symbolToEntityName: function (symbol, meaning, enclosingDeclaration, flags, tracker) { + return withContext(enclosingDeclaration, flags, tracker, function (context) { return symbolToName(symbol, context, meaning, /*expectsIdentifier*/ false); }); + }, + symbolToExpression: function (symbol, meaning, enclosingDeclaration, flags, tracker) { + return withContext(enclosingDeclaration, flags, tracker, function (context) { return symbolToExpression(symbol, context, meaning); }); + }, + symbolToTypeParameterDeclarations: function (symbol, enclosingDeclaration, flags, tracker) { + return withContext(enclosingDeclaration, flags, tracker, function (context) { return typeParametersToTypeParameterDeclarations(symbol, context); }); + }, + symbolToParameterDeclaration: function (symbol, enclosingDeclaration, flags, tracker) { + return withContext(enclosingDeclaration, flags, tracker, function (context) { return symbolToParameterDeclaration(symbol, context); }); + }, + typeParameterToDeclaration: function (parameter, enclosingDeclaration, flags, tracker) { + return withContext(enclosingDeclaration, flags, tracker, function (context) { return typeParameterToDeclaration(parameter, context); }); + }, + symbolTableToDeclarationStatements: function (symbolTable, enclosingDeclaration, flags, tracker, bundled) { + return withContext(enclosingDeclaration, flags, tracker, function (context) { return symbolTableToDeclarationStatements(symbolTable, context, bundled); }); + }, + symbolToNode: function (symbol, meaning, enclosingDeclaration, flags, tracker) { + return withContext(enclosingDeclaration, flags, tracker, function (context) { return symbolToNode(symbol, context, meaning); }); + }, + }; + function symbolToNode(symbol, context, meaning) { + if (context.flags & 1073741824 /* NodeBuilderFlags.WriteComputedProps */) { + if (symbol.valueDeclaration) { + var name = ts.getNameOfDeclaration(symbol.valueDeclaration); + if (name && ts.isComputedPropertyName(name)) + return name; + } + var nameType = getSymbolLinks(symbol).nameType; + if (nameType && nameType.flags & (1024 /* TypeFlags.EnumLiteral */ | 8192 /* TypeFlags.UniqueESSymbol */)) { + context.enclosingDeclaration = nameType.symbol.valueDeclaration; + return ts.factory.createComputedPropertyName(symbolToExpression(nameType.symbol, context, meaning)); + } + } + return symbolToExpression(symbol, context, meaning); + } + function withContext(enclosingDeclaration, flags, tracker, cb) { + var _a, _b; + ts.Debug.assert(enclosingDeclaration === undefined || (enclosingDeclaration.flags & 8 /* NodeFlags.Synthesized */) === 0); + var context = { + enclosingDeclaration: enclosingDeclaration, + flags: flags || 0 /* NodeBuilderFlags.None */, + // If no full tracker is provided, fake up a dummy one with a basic limited-functionality moduleResolverHost + tracker: tracker && tracker.trackSymbol ? tracker : { trackSymbol: function () { return false; }, moduleResolverHost: flags & 134217728 /* NodeBuilderFlags.DoNotIncludeSymbolChain */ ? { + getCommonSourceDirectory: !!host.getCommonSourceDirectory ? function () { return host.getCommonSourceDirectory(); } : function () { return ""; }, + getCurrentDirectory: function () { return host.getCurrentDirectory(); }, + getSymlinkCache: ts.maybeBind(host, host.getSymlinkCache), + getPackageJsonInfoCache: function () { var _a; return (_a = host.getPackageJsonInfoCache) === null || _a === void 0 ? void 0 : _a.call(host); }, + useCaseSensitiveFileNames: ts.maybeBind(host, host.useCaseSensitiveFileNames), + redirectTargetsMap: host.redirectTargetsMap, + getProjectReferenceRedirect: function (fileName) { return host.getProjectReferenceRedirect(fileName); }, + isSourceOfProjectReferenceRedirect: function (fileName) { return host.isSourceOfProjectReferenceRedirect(fileName); }, + fileExists: function (fileName) { return host.fileExists(fileName); }, + getFileIncludeReasons: function () { return host.getFileIncludeReasons(); }, + readFile: host.readFile ? (function (fileName) { return host.readFile(fileName); }) : undefined, + } : undefined }, + encounteredError: false, + reportedDiagnostic: false, + visitedTypes: undefined, + symbolDepth: undefined, + inferTypeParameters: undefined, + approximateLength: 0 + }; + context.tracker = wrapSymbolTrackerToReportForContext(context, context.tracker); + var resultingNode = cb(context); + if (context.truncating && context.flags & 1 /* NodeBuilderFlags.NoTruncation */) { + (_b = (_a = context.tracker) === null || _a === void 0 ? void 0 : _a.reportTruncationError) === null || _b === void 0 ? void 0 : _b.call(_a); + } + return context.encounteredError ? undefined : resultingNode; + } + function wrapSymbolTrackerToReportForContext(context, tracker) { + var oldTrackSymbol = tracker.trackSymbol; + return __assign(__assign({}, tracker), { reportCyclicStructureError: wrapReportedDiagnostic(tracker.reportCyclicStructureError), reportInaccessibleThisError: wrapReportedDiagnostic(tracker.reportInaccessibleThisError), reportInaccessibleUniqueSymbolError: wrapReportedDiagnostic(tracker.reportInaccessibleUniqueSymbolError), reportLikelyUnsafeImportRequiredError: wrapReportedDiagnostic(tracker.reportLikelyUnsafeImportRequiredError), reportNonlocalAugmentation: wrapReportedDiagnostic(tracker.reportNonlocalAugmentation), reportPrivateInBaseOfClassExpression: wrapReportedDiagnostic(tracker.reportPrivateInBaseOfClassExpression), reportNonSerializableProperty: wrapReportedDiagnostic(tracker.reportNonSerializableProperty), trackSymbol: oldTrackSymbol && (function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + var result = oldTrackSymbol.apply(void 0, args); + if (result) { + context.reportedDiagnostic = true; + } + return result; + }) }); + function wrapReportedDiagnostic(method) { + if (!method) { + return method; + } + return (function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + context.reportedDiagnostic = true; + return method.apply(void 0, args); + }); + } + } + function checkTruncationLength(context) { + if (context.truncating) + return context.truncating; + return context.truncating = context.approximateLength > ((context.flags & 1 /* NodeBuilderFlags.NoTruncation */) ? ts.noTruncationMaximumTruncationLength : ts.defaultMaximumTruncationLength); + } + function typeToTypeNodeHelper(type, context) { + var savedFlags = context.flags; + var typeNode = typeToTypeNodeWorker(type, context); + context.flags = savedFlags; + return typeNode; + } + function typeToTypeNodeWorker(type, context) { + if (cancellationToken && cancellationToken.throwIfCancellationRequested) { + cancellationToken.throwIfCancellationRequested(); + } + var inTypeAlias = context.flags & 8388608 /* NodeBuilderFlags.InTypeAlias */; + context.flags &= ~8388608 /* NodeBuilderFlags.InTypeAlias */; + if (!type) { + if (!(context.flags & 262144 /* NodeBuilderFlags.AllowEmptyUnionOrIntersection */)) { + context.encounteredError = true; + return undefined; // TODO: GH#18217 + } + context.approximateLength += 3; + return ts.factory.createKeywordTypeNode(131 /* SyntaxKind.AnyKeyword */); + } + if (!(context.flags & 536870912 /* NodeBuilderFlags.NoTypeReduction */)) { + type = getReducedType(type); + } + if (type.flags & 1 /* TypeFlags.Any */) { + if (type.aliasSymbol) { + return ts.factory.createTypeReferenceNode(symbolToEntityNameNode(type.aliasSymbol), mapToTypeNodes(type.aliasTypeArguments, context)); + } + if (type === unresolvedType) { + return ts.addSyntheticLeadingComment(ts.factory.createKeywordTypeNode(131 /* SyntaxKind.AnyKeyword */), 3 /* SyntaxKind.MultiLineCommentTrivia */, "unresolved"); + } + context.approximateLength += 3; + return ts.factory.createKeywordTypeNode(type === intrinsicMarkerType ? 139 /* SyntaxKind.IntrinsicKeyword */ : 131 /* SyntaxKind.AnyKeyword */); + } + if (type.flags & 2 /* TypeFlags.Unknown */) { + return ts.factory.createKeywordTypeNode(157 /* SyntaxKind.UnknownKeyword */); + } + if (type.flags & 4 /* TypeFlags.String */) { + context.approximateLength += 6; + return ts.factory.createKeywordTypeNode(152 /* SyntaxKind.StringKeyword */); + } + if (type.flags & 8 /* TypeFlags.Number */) { + context.approximateLength += 6; + return ts.factory.createKeywordTypeNode(148 /* SyntaxKind.NumberKeyword */); + } + if (type.flags & 64 /* TypeFlags.BigInt */) { + context.approximateLength += 6; + return ts.factory.createKeywordTypeNode(160 /* SyntaxKind.BigIntKeyword */); + } + if (type.flags & 16 /* TypeFlags.Boolean */ && !type.aliasSymbol) { + context.approximateLength += 7; + return ts.factory.createKeywordTypeNode(134 /* SyntaxKind.BooleanKeyword */); + } + if (type.flags & 1024 /* TypeFlags.EnumLiteral */ && !(type.flags & 1048576 /* TypeFlags.Union */)) { + var parentSymbol = getParentOfSymbol(type.symbol); + var parentName = symbolToTypeNode(parentSymbol, context, 788968 /* SymbolFlags.Type */); + if (getDeclaredTypeOfSymbol(parentSymbol) === type) { + return parentName; + } + var memberName = ts.symbolName(type.symbol); + if (ts.isIdentifierText(memberName, 0 /* ScriptTarget.ES3 */)) { + return appendReferenceToType(parentName, ts.factory.createTypeReferenceNode(memberName, /*typeArguments*/ undefined)); + } + if (ts.isImportTypeNode(parentName)) { + parentName.isTypeOf = true; // mutably update, node is freshly manufactured anyhow + return ts.factory.createIndexedAccessTypeNode(parentName, ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(memberName))); + } + else if (ts.isTypeReferenceNode(parentName)) { + return ts.factory.createIndexedAccessTypeNode(ts.factory.createTypeQueryNode(parentName.typeName), ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(memberName))); + } + else { + return ts.Debug.fail("Unhandled type node kind returned from `symbolToTypeNode`."); + } + } + if (type.flags & 1056 /* TypeFlags.EnumLike */) { + return symbolToTypeNode(type.symbol, context, 788968 /* SymbolFlags.Type */); + } + if (type.flags & 128 /* TypeFlags.StringLiteral */) { + context.approximateLength += (type.value.length + 2); + return ts.factory.createLiteralTypeNode(ts.setEmitFlags(ts.factory.createStringLiteral(type.value, !!(context.flags & 268435456 /* NodeBuilderFlags.UseSingleQuotesForStringLiteralType */)), 16777216 /* EmitFlags.NoAsciiEscaping */)); + } + if (type.flags & 256 /* TypeFlags.NumberLiteral */) { + var value = type.value; + context.approximateLength += ("" + value).length; + return ts.factory.createLiteralTypeNode(value < 0 ? ts.factory.createPrefixUnaryExpression(40 /* SyntaxKind.MinusToken */, ts.factory.createNumericLiteral(-value)) : ts.factory.createNumericLiteral(value)); + } + if (type.flags & 2048 /* TypeFlags.BigIntLiteral */) { + context.approximateLength += (ts.pseudoBigIntToString(type.value).length) + 1; + return ts.factory.createLiteralTypeNode((ts.factory.createBigIntLiteral(type.value))); + } + if (type.flags & 512 /* TypeFlags.BooleanLiteral */) { + context.approximateLength += type.intrinsicName.length; + return ts.factory.createLiteralTypeNode(type.intrinsicName === "true" ? ts.factory.createTrue() : ts.factory.createFalse()); + } + if (type.flags & 8192 /* TypeFlags.UniqueESSymbol */) { + if (!(context.flags & 1048576 /* NodeBuilderFlags.AllowUniqueESSymbolType */)) { + if (isValueSymbolAccessible(type.symbol, context.enclosingDeclaration)) { + context.approximateLength += 6; + return symbolToTypeNode(type.symbol, context, 111551 /* SymbolFlags.Value */); + } + if (context.tracker.reportInaccessibleUniqueSymbolError) { + context.tracker.reportInaccessibleUniqueSymbolError(); + } + } + context.approximateLength += 13; + return ts.factory.createTypeOperatorNode(156 /* SyntaxKind.UniqueKeyword */, ts.factory.createKeywordTypeNode(153 /* SyntaxKind.SymbolKeyword */)); + } + if (type.flags & 16384 /* TypeFlags.Void */) { + context.approximateLength += 4; + return ts.factory.createKeywordTypeNode(114 /* SyntaxKind.VoidKeyword */); + } + if (type.flags & 32768 /* TypeFlags.Undefined */) { + context.approximateLength += 9; + return ts.factory.createKeywordTypeNode(155 /* SyntaxKind.UndefinedKeyword */); + } + if (type.flags & 65536 /* TypeFlags.Null */) { + context.approximateLength += 4; + return ts.factory.createLiteralTypeNode(ts.factory.createNull()); + } + if (type.flags & 131072 /* TypeFlags.Never */) { + context.approximateLength += 5; + return ts.factory.createKeywordTypeNode(144 /* SyntaxKind.NeverKeyword */); + } + if (type.flags & 4096 /* TypeFlags.ESSymbol */) { + context.approximateLength += 6; + return ts.factory.createKeywordTypeNode(153 /* SyntaxKind.SymbolKeyword */); + } + if (type.flags & 67108864 /* TypeFlags.NonPrimitive */) { + context.approximateLength += 6; + return ts.factory.createKeywordTypeNode(149 /* SyntaxKind.ObjectKeyword */); + } + if (ts.isThisTypeParameter(type)) { + if (context.flags & 4194304 /* NodeBuilderFlags.InObjectTypeLiteral */) { + if (!context.encounteredError && !(context.flags & 32768 /* NodeBuilderFlags.AllowThisInObjectLiteral */)) { + context.encounteredError = true; + } + if (context.tracker.reportInaccessibleThisError) { + context.tracker.reportInaccessibleThisError(); + } + } + context.approximateLength += 4; + return ts.factory.createThisTypeNode(); + } + if (!inTypeAlias && type.aliasSymbol && (context.flags & 16384 /* NodeBuilderFlags.UseAliasDefinedOutsideCurrentScope */ || isTypeSymbolAccessible(type.aliasSymbol, context.enclosingDeclaration))) { + var typeArgumentNodes = mapToTypeNodes(type.aliasTypeArguments, context); + if (isReservedMemberName(type.aliasSymbol.escapedName) && !(type.aliasSymbol.flags & 32 /* SymbolFlags.Class */)) + return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(""), typeArgumentNodes); + if (ts.length(typeArgumentNodes) === 1 && type.aliasSymbol === globalArrayType.symbol) { + return ts.factory.createArrayTypeNode(typeArgumentNodes[0]); + } + return symbolToTypeNode(type.aliasSymbol, context, 788968 /* SymbolFlags.Type */, typeArgumentNodes); + } + var objectFlags = ts.getObjectFlags(type); + if (objectFlags & 4 /* ObjectFlags.Reference */) { + ts.Debug.assert(!!(type.flags & 524288 /* TypeFlags.Object */)); + return type.node ? visitAndTransformType(type, typeReferenceToTypeNode) : typeReferenceToTypeNode(type); + } + if (type.flags & 262144 /* TypeFlags.TypeParameter */ || objectFlags & 3 /* ObjectFlags.ClassOrInterface */) { + if (type.flags & 262144 /* TypeFlags.TypeParameter */ && ts.contains(context.inferTypeParameters, type)) { + context.approximateLength += (ts.symbolName(type.symbol).length + 6); + var constraintNode = void 0; + var constraint = getConstraintOfTypeParameter(type); + if (constraint) { + // If the infer type has a constraint that is not the same as the constraint + // we would have normally inferred based on context, we emit the constraint + // using `infer T extends ?`. We omit inferred constraints from type references + // as they may be elided. + var inferredConstraint = getInferredTypeParameterConstraint(type, /*omitTypeReferences*/ true); + if (!(inferredConstraint && isTypeIdenticalTo(constraint, inferredConstraint))) { + context.approximateLength += 9; + constraintNode = constraint && typeToTypeNodeHelper(constraint, context); + } + } + return ts.factory.createInferTypeNode(typeParameterToDeclarationWithConstraint(type, context, constraintNode)); + } + if (context.flags & 4 /* NodeBuilderFlags.GenerateNamesForShadowedTypeParams */ && + type.flags & 262144 /* TypeFlags.TypeParameter */ && + !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration)) { + var name_2 = typeParameterToName(type, context); + context.approximateLength += ts.idText(name_2).length; + return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(ts.idText(name_2)), /*typeArguments*/ undefined); + } + // Ignore constraint/default when creating a usage (as opposed to declaration) of a type parameter. + if (type.symbol) { + return symbolToTypeNode(type.symbol, context, 788968 /* SymbolFlags.Type */); + } + var name = (type === markerSuperTypeForCheck || type === markerSubTypeForCheck) && varianceTypeParameter && varianceTypeParameter.symbol ? + (type === markerSubTypeForCheck ? "sub-" : "super-") + ts.symbolName(varianceTypeParameter.symbol) : "?"; + return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(name), /*typeArguments*/ undefined); + } + if (type.flags & 1048576 /* TypeFlags.Union */ && type.origin) { + type = type.origin; + } + if (type.flags & (1048576 /* TypeFlags.Union */ | 2097152 /* TypeFlags.Intersection */)) { + var types = type.flags & 1048576 /* TypeFlags.Union */ ? formatUnionTypes(type.types) : type.types; + if (ts.length(types) === 1) { + return typeToTypeNodeHelper(types[0], context); + } + var typeNodes = mapToTypeNodes(types, context, /*isBareList*/ true); + if (typeNodes && typeNodes.length > 0) { + return type.flags & 1048576 /* TypeFlags.Union */ ? ts.factory.createUnionTypeNode(typeNodes) : ts.factory.createIntersectionTypeNode(typeNodes); + } + else { + if (!context.encounteredError && !(context.flags & 262144 /* NodeBuilderFlags.AllowEmptyUnionOrIntersection */)) { + context.encounteredError = true; + } + return undefined; // TODO: GH#18217 + } + } + if (objectFlags & (16 /* ObjectFlags.Anonymous */ | 32 /* ObjectFlags.Mapped */)) { + ts.Debug.assert(!!(type.flags & 524288 /* TypeFlags.Object */)); + // The type is an object literal type. + return createAnonymousTypeNode(type); + } + if (type.flags & 4194304 /* TypeFlags.Index */) { + var indexedType = type.type; + context.approximateLength += 6; + var indexTypeNode = typeToTypeNodeHelper(indexedType, context); + return ts.factory.createTypeOperatorNode(141 /* SyntaxKind.KeyOfKeyword */, indexTypeNode); + } + if (type.flags & 134217728 /* TypeFlags.TemplateLiteral */) { + var texts_1 = type.texts; + var types_1 = type.types; + var templateHead = ts.factory.createTemplateHead(texts_1[0]); + var templateSpans = ts.factory.createNodeArray(ts.map(types_1, function (t, i) { return ts.factory.createTemplateLiteralTypeSpan(typeToTypeNodeHelper(t, context), (i < types_1.length - 1 ? ts.factory.createTemplateMiddle : ts.factory.createTemplateTail)(texts_1[i + 1])); })); + context.approximateLength += 2; + return ts.factory.createTemplateLiteralType(templateHead, templateSpans); + } + if (type.flags & 268435456 /* TypeFlags.StringMapping */) { + var typeNode = typeToTypeNodeHelper(type.type, context); + return symbolToTypeNode(type.symbol, context, 788968 /* SymbolFlags.Type */, [typeNode]); + } + if (type.flags & 8388608 /* TypeFlags.IndexedAccess */) { + var objectTypeNode = typeToTypeNodeHelper(type.objectType, context); + var indexTypeNode = typeToTypeNodeHelper(type.indexType, context); + context.approximateLength += 2; + return ts.factory.createIndexedAccessTypeNode(objectTypeNode, indexTypeNode); + } + if (type.flags & 16777216 /* TypeFlags.Conditional */) { + return visitAndTransformType(type, function (type) { return conditionalTypeToTypeNode(type); }); + } + if (type.flags & 33554432 /* TypeFlags.Substitution */) { + return typeToTypeNodeHelper(type.baseType, context); + } + return ts.Debug.fail("Should be unreachable."); + function conditionalTypeToTypeNode(type) { + var checkTypeNode = typeToTypeNodeHelper(type.checkType, context); + context.approximateLength += 15; + if (context.flags & 4 /* NodeBuilderFlags.GenerateNamesForShadowedTypeParams */ && type.root.isDistributive && !(type.checkType.flags & 262144 /* TypeFlags.TypeParameter */)) { + var newParam = createTypeParameter(createSymbol(262144 /* SymbolFlags.TypeParameter */, "T")); + var name = typeParameterToName(newParam, context); + var newTypeVariable = ts.factory.createTypeReferenceNode(name); + context.approximateLength += 37; // 15 each for two added conditionals, 7 for an added infer type + var newMapper = prependTypeMapping(type.root.checkType, newParam, type.mapper); + var saveInferTypeParameters_1 = context.inferTypeParameters; + context.inferTypeParameters = type.root.inferTypeParameters; + var extendsTypeNode_1 = typeToTypeNodeHelper(instantiateType(type.root.extendsType, newMapper), context); + context.inferTypeParameters = saveInferTypeParameters_1; + var trueTypeNode_1 = typeToTypeNodeOrCircularityElision(instantiateType(getTypeFromTypeNode(type.root.node.trueType), newMapper)); + var falseTypeNode_1 = typeToTypeNodeOrCircularityElision(instantiateType(getTypeFromTypeNode(type.root.node.falseType), newMapper)); + // outermost conditional makes `T` a type parameter, allowing the inner conditionals to be distributive + // second conditional makes `T` have `T & checkType` substitution, so it is correctly usable as the checkType + // inner conditional runs the check the user provided on the check type (distributively) and returns the result + // checkType extends infer T ? T extends checkType ? T extends extendsType ? trueType : falseType : never : never; + // this is potentially simplifiable to + // checkType extends infer T ? T extends checkType & extendsType ? trueType : falseType : never; + // but that may confuse users who read the output more. + // On the other hand, + // checkType extends infer T extends checkType ? T extends extendsType ? trueType : falseType : never; + // may also work with `infer ... extends ...` in, but would produce declarations only compatible with the latest TS. + return ts.factory.createConditionalTypeNode(checkTypeNode, ts.factory.createInferTypeNode(ts.factory.createTypeParameterDeclaration(/*modifiers*/ undefined, ts.factory.cloneNode(newTypeVariable.typeName))), ts.factory.createConditionalTypeNode(ts.factory.createTypeReferenceNode(ts.factory.cloneNode(name)), typeToTypeNodeHelper(type.checkType, context), ts.factory.createConditionalTypeNode(newTypeVariable, extendsTypeNode_1, trueTypeNode_1, falseTypeNode_1), ts.factory.createKeywordTypeNode(144 /* SyntaxKind.NeverKeyword */)), ts.factory.createKeywordTypeNode(144 /* SyntaxKind.NeverKeyword */)); + } + var saveInferTypeParameters = context.inferTypeParameters; + context.inferTypeParameters = type.root.inferTypeParameters; + var extendsTypeNode = typeToTypeNodeHelper(type.extendsType, context); + context.inferTypeParameters = saveInferTypeParameters; + var trueTypeNode = typeToTypeNodeOrCircularityElision(getTrueTypeFromConditionalType(type)); + var falseTypeNode = typeToTypeNodeOrCircularityElision(getFalseTypeFromConditionalType(type)); + return ts.factory.createConditionalTypeNode(checkTypeNode, extendsTypeNode, trueTypeNode, falseTypeNode); + } + function typeToTypeNodeOrCircularityElision(type) { + var _a, _b, _c; + if (type.flags & 1048576 /* TypeFlags.Union */) { + if ((_a = context.visitedTypes) === null || _a === void 0 ? void 0 : _a.has(getTypeId(type))) { + if (!(context.flags & 131072 /* NodeBuilderFlags.AllowAnonymousIdentifier */)) { + context.encounteredError = true; + (_c = (_b = context.tracker) === null || _b === void 0 ? void 0 : _b.reportCyclicStructureError) === null || _c === void 0 ? void 0 : _c.call(_b); + } + return createElidedInformationPlaceholder(context); + } + return visitAndTransformType(type, function (type) { return typeToTypeNodeHelper(type, context); }); + } + return typeToTypeNodeHelper(type, context); + } + function isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type) { + return isMappedTypeWithKeyofConstraintDeclaration(type) + && !(getModifiersTypeFromMappedType(type).flags & 262144 /* TypeFlags.TypeParameter */); + } + function createMappedTypeNodeFromType(type) { + ts.Debug.assert(!!(type.flags & 524288 /* TypeFlags.Object */)); + var readonlyToken = type.declaration.readonlyToken ? ts.factory.createToken(type.declaration.readonlyToken.kind) : undefined; + var questionToken = type.declaration.questionToken ? ts.factory.createToken(type.declaration.questionToken.kind) : undefined; + var appropriateConstraintTypeNode; + var newTypeVariable; + if (isMappedTypeWithKeyofConstraintDeclaration(type)) { + // We have a { [P in keyof T]: X } + // We do this to ensure we retain the toplevel keyof-ness of the type which may be lost due to keyof distribution during `getConstraintTypeFromMappedType` + if (isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type) && context.flags & 4 /* NodeBuilderFlags.GenerateNamesForShadowedTypeParams */) { + var newParam = createTypeParameter(createSymbol(262144 /* SymbolFlags.TypeParameter */, "T")); + var name = typeParameterToName(newParam, context); + newTypeVariable = ts.factory.createTypeReferenceNode(name); + } + appropriateConstraintTypeNode = ts.factory.createTypeOperatorNode(141 /* SyntaxKind.KeyOfKeyword */, newTypeVariable || typeToTypeNodeHelper(getModifiersTypeFromMappedType(type), context)); + } + else { + appropriateConstraintTypeNode = typeToTypeNodeHelper(getConstraintTypeFromMappedType(type), context); + } + var typeParameterNode = typeParameterToDeclarationWithConstraint(getTypeParameterFromMappedType(type), context, appropriateConstraintTypeNode); + var nameTypeNode = type.declaration.nameType ? typeToTypeNodeHelper(getNameTypeFromMappedType(type), context) : undefined; + var templateTypeNode = typeToTypeNodeHelper(removeMissingType(getTemplateTypeFromMappedType(type), !!(getMappedTypeModifiers(type) & 4 /* MappedTypeModifiers.IncludeOptional */)), context); + var mappedTypeNode = ts.factory.createMappedTypeNode(readonlyToken, typeParameterNode, nameTypeNode, questionToken, templateTypeNode, /*members*/ undefined); + context.approximateLength += 10; + var result = ts.setEmitFlags(mappedTypeNode, 1 /* EmitFlags.SingleLine */); + if (isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type) && context.flags & 4 /* NodeBuilderFlags.GenerateNamesForShadowedTypeParams */) { + // homomorphic mapped type with a non-homomorphic naive inlining + // wrap it with a conditional like `SomeModifiersType extends infer U ? {..the mapped type...} : never` to ensure the resulting + // type stays homomorphic + var originalConstraint = instantiateType(getConstraintOfTypeParameter(getTypeFromTypeNode(type.declaration.typeParameter.constraint.type)) || unknownType, type.mapper); + return ts.factory.createConditionalTypeNode(typeToTypeNodeHelper(getModifiersTypeFromMappedType(type), context), ts.factory.createInferTypeNode(ts.factory.createTypeParameterDeclaration(/*modifiers*/ undefined, ts.factory.cloneNode(newTypeVariable.typeName), originalConstraint.flags & 2 /* TypeFlags.Unknown */ ? undefined : typeToTypeNodeHelper(originalConstraint, context))), result, ts.factory.createKeywordTypeNode(144 /* SyntaxKind.NeverKeyword */)); + } + return result; + } + function createAnonymousTypeNode(type) { + var _a; + var typeId = type.id; + var symbol = type.symbol; + if (symbol) { + var isInstanceType = isClassInstanceSide(type) ? 788968 /* SymbolFlags.Type */ : 111551 /* SymbolFlags.Value */; + if (isJSConstructor(symbol.valueDeclaration)) { + // Instance and static types share the same symbol; only add 'typeof' for the static side. + return symbolToTypeNode(symbol, context, isInstanceType); + } + // Always use 'typeof T' for type of class, enum, and module objects + else if (symbol.flags & 32 /* SymbolFlags.Class */ + && !getBaseTypeVariableOfClass(symbol) + && !(symbol.valueDeclaration && ts.isClassLike(symbol.valueDeclaration) && context.flags & 2048 /* NodeBuilderFlags.WriteClassExpressionAsTypeLiteral */ && (!ts.isClassDeclaration(symbol.valueDeclaration) || isSymbolAccessible(symbol, context.enclosingDeclaration, isInstanceType, /*computeAliases*/ false).accessibility !== 0 /* SymbolAccessibility.Accessible */)) || + symbol.flags & (384 /* SymbolFlags.Enum */ | 512 /* SymbolFlags.ValueModule */) || + shouldWriteTypeOfFunctionSymbol()) { + return symbolToTypeNode(symbol, context, isInstanceType); + } + else if ((_a = context.visitedTypes) === null || _a === void 0 ? void 0 : _a.has(typeId)) { + // If type is an anonymous type literal in a type alias declaration, use type alias name + var typeAlias = getTypeAliasForTypeLiteral(type); + if (typeAlias) { + // The specified symbol flags need to be reinterpreted as type flags + return symbolToTypeNode(typeAlias, context, 788968 /* SymbolFlags.Type */); + } + else { + return createElidedInformationPlaceholder(context); + } + } + else { + return visitAndTransformType(type, createTypeNodeFromObjectType); + } + } + else { + // Anonymous types without a symbol are never circular. + return createTypeNodeFromObjectType(type); + } + function shouldWriteTypeOfFunctionSymbol() { + var _a; + var isStaticMethodSymbol = !!(symbol.flags & 8192 /* SymbolFlags.Method */) && // typeof static method + ts.some(symbol.declarations, function (declaration) { return ts.isStatic(declaration); }); + var isNonLocalFunctionSymbol = !!(symbol.flags & 16 /* SymbolFlags.Function */) && + (symbol.parent || // is exported function symbol + ts.forEach(symbol.declarations, function (declaration) { + return declaration.parent.kind === 308 /* SyntaxKind.SourceFile */ || declaration.parent.kind === 265 /* SyntaxKind.ModuleBlock */; + })); + if (isStaticMethodSymbol || isNonLocalFunctionSymbol) { + // typeof is allowed only for static/non local functions + return (!!(context.flags & 4096 /* NodeBuilderFlags.UseTypeOfFunction */) || ((_a = context.visitedTypes) === null || _a === void 0 ? void 0 : _a.has(typeId))) && // it is type of the symbol uses itself recursively + (!(context.flags & 8 /* NodeBuilderFlags.UseStructuralFallback */) || isValueSymbolAccessible(symbol, context.enclosingDeclaration)); // And the build is going to succeed without visibility error or there is no structural fallback allowed + } + } + } + function visitAndTransformType(type, transform) { + var _a, _b; + var typeId = type.id; + var isConstructorObject = ts.getObjectFlags(type) & 16 /* ObjectFlags.Anonymous */ && type.symbol && type.symbol.flags & 32 /* SymbolFlags.Class */; + var id = ts.getObjectFlags(type) & 4 /* ObjectFlags.Reference */ && type.node ? "N" + getNodeId(type.node) : + type.flags & 16777216 /* TypeFlags.Conditional */ ? "N" + getNodeId(type.root.node) : + type.symbol ? (isConstructorObject ? "+" : "") + getSymbolId(type.symbol) : + undefined; + // Since instantiations of the same anonymous type have the same symbol, tracking symbols instead + // of types allows us to catch circular references to instantiations of the same anonymous type + if (!context.visitedTypes) { + context.visitedTypes = new ts.Set(); + } + if (id && !context.symbolDepth) { + context.symbolDepth = new ts.Map(); + } + var links = context.enclosingDeclaration && getNodeLinks(context.enclosingDeclaration); + var key = "".concat(getTypeId(type), "|").concat(context.flags); + if (links) { + links.serializedTypes || (links.serializedTypes = new ts.Map()); + } + var cachedResult = (_a = links === null || links === void 0 ? void 0 : links.serializedTypes) === null || _a === void 0 ? void 0 : _a.get(key); + if (cachedResult) { + if (cachedResult.truncating) { + context.truncating = true; + } + context.approximateLength += cachedResult.addedLength; + return deepCloneOrReuseNode(cachedResult); + } + var depth; + if (id) { + depth = context.symbolDepth.get(id) || 0; + if (depth > 10) { + return createElidedInformationPlaceholder(context); + } + context.symbolDepth.set(id, depth + 1); + } + context.visitedTypes.add(typeId); + var startLength = context.approximateLength; + var result = transform(type); + var addedLength = context.approximateLength - startLength; + if (!context.reportedDiagnostic && !context.encounteredError) { + if (context.truncating) { + result.truncating = true; + } + result.addedLength = addedLength; + (_b = links === null || links === void 0 ? void 0 : links.serializedTypes) === null || _b === void 0 ? void 0 : _b.set(key, result); + } + context.visitedTypes.delete(typeId); + if (id) { + context.symbolDepth.set(id, depth); + } + return result; + function deepCloneOrReuseNode(node) { + if (!ts.nodeIsSynthesized(node) && ts.getParseTreeNode(node) === node) { + return node; + } + return ts.setTextRange(ts.factory.cloneNode(ts.visitEachChild(node, deepCloneOrReuseNode, ts.nullTransformationContext, deepCloneOrReuseNodes)), node); + } + function deepCloneOrReuseNodes(nodes, visitor, test, start, count) { + if (nodes && nodes.length === 0) { + // Ensure we explicitly make a copy of an empty array; visitNodes will not do this unless the array has elements, + // which can lead to us reusing the same empty NodeArray more than once within the same AST during type noding. + return ts.setTextRange(ts.factory.createNodeArray(/*nodes*/ undefined, nodes.hasTrailingComma), nodes); + } + return ts.visitNodes(nodes, visitor, test, start, count); + } + } + function createTypeNodeFromObjectType(type) { + if (isGenericMappedType(type) || type.containsError) { + return createMappedTypeNodeFromType(type); + } + var resolved = resolveStructuredTypeMembers(type); + if (!resolved.properties.length && !resolved.indexInfos.length) { + if (!resolved.callSignatures.length && !resolved.constructSignatures.length) { + context.approximateLength += 2; + return ts.setEmitFlags(ts.factory.createTypeLiteralNode(/*members*/ undefined), 1 /* EmitFlags.SingleLine */); + } + if (resolved.callSignatures.length === 1 && !resolved.constructSignatures.length) { + var signature = resolved.callSignatures[0]; + var signatureNode = signatureToSignatureDeclarationHelper(signature, 181 /* SyntaxKind.FunctionType */, context); + return signatureNode; + } + if (resolved.constructSignatures.length === 1 && !resolved.callSignatures.length) { + var signature = resolved.constructSignatures[0]; + var signatureNode = signatureToSignatureDeclarationHelper(signature, 182 /* SyntaxKind.ConstructorType */, context); + return signatureNode; + } + } + var abstractSignatures = ts.filter(resolved.constructSignatures, function (signature) { return !!(signature.flags & 4 /* SignatureFlags.Abstract */); }); + if (ts.some(abstractSignatures)) { + var types = ts.map(abstractSignatures, getOrCreateTypeFromSignature); + // count the number of type elements excluding abstract constructors + var typeElementCount = resolved.callSignatures.length + + (resolved.constructSignatures.length - abstractSignatures.length) + + resolved.indexInfos.length + + // exclude `prototype` when writing a class expression as a type literal, as per + // the logic in `createTypeNodesFromResolvedType`. + (context.flags & 2048 /* NodeBuilderFlags.WriteClassExpressionAsTypeLiteral */ ? + ts.countWhere(resolved.properties, function (p) { return !(p.flags & 4194304 /* SymbolFlags.Prototype */); }) : + ts.length(resolved.properties)); + // don't include an empty object literal if there were no other static-side + // properties to write, i.e. `abstract class C { }` becomes `abstract new () => {}` + // and not `(abstract new () => {}) & {}` + if (typeElementCount) { + // create a copy of the object type without any abstract construct signatures. + types.push(getResolvedTypeWithoutAbstractConstructSignatures(resolved)); + } + return typeToTypeNodeHelper(getIntersectionType(types), context); + } + var savedFlags = context.flags; + context.flags |= 4194304 /* NodeBuilderFlags.InObjectTypeLiteral */; + var members = createTypeNodesFromResolvedType(resolved); + context.flags = savedFlags; + var typeLiteralNode = ts.factory.createTypeLiteralNode(members); + context.approximateLength += 2; + ts.setEmitFlags(typeLiteralNode, (context.flags & 1024 /* NodeBuilderFlags.MultilineObjectLiterals */) ? 0 : 1 /* EmitFlags.SingleLine */); + return typeLiteralNode; + } + function typeReferenceToTypeNode(type) { + var typeArguments = getTypeArguments(type); + if (type.target === globalArrayType || type.target === globalReadonlyArrayType) { + if (context.flags & 2 /* NodeBuilderFlags.WriteArrayAsGenericType */) { + var typeArgumentNode = typeToTypeNodeHelper(typeArguments[0], context); + return ts.factory.createTypeReferenceNode(type.target === globalArrayType ? "Array" : "ReadonlyArray", [typeArgumentNode]); + } + var elementType = typeToTypeNodeHelper(typeArguments[0], context); + var arrayType = ts.factory.createArrayTypeNode(elementType); + return type.target === globalArrayType ? arrayType : ts.factory.createTypeOperatorNode(146 /* SyntaxKind.ReadonlyKeyword */, arrayType); + } + else if (type.target.objectFlags & 8 /* ObjectFlags.Tuple */) { + typeArguments = ts.sameMap(typeArguments, function (t, i) { return removeMissingType(t, !!(type.target.elementFlags[i] & 2 /* ElementFlags.Optional */)); }); + if (typeArguments.length > 0) { + var arity = getTypeReferenceArity(type); + var tupleConstituentNodes = mapToTypeNodes(typeArguments.slice(0, arity), context); + if (tupleConstituentNodes) { + if (type.target.labeledElementDeclarations) { + for (var i = 0; i < tupleConstituentNodes.length; i++) { + var flags = type.target.elementFlags[i]; + tupleConstituentNodes[i] = ts.factory.createNamedTupleMember(flags & 12 /* ElementFlags.Variable */ ? ts.factory.createToken(25 /* SyntaxKind.DotDotDotToken */) : undefined, ts.factory.createIdentifier(ts.unescapeLeadingUnderscores(getTupleElementLabel(type.target.labeledElementDeclarations[i]))), flags & 2 /* ElementFlags.Optional */ ? ts.factory.createToken(57 /* SyntaxKind.QuestionToken */) : undefined, flags & 4 /* ElementFlags.Rest */ ? ts.factory.createArrayTypeNode(tupleConstituentNodes[i]) : + tupleConstituentNodes[i]); + } + } + else { + for (var i = 0; i < Math.min(arity, tupleConstituentNodes.length); i++) { + var flags = type.target.elementFlags[i]; + tupleConstituentNodes[i] = + flags & 12 /* ElementFlags.Variable */ ? ts.factory.createRestTypeNode(flags & 4 /* ElementFlags.Rest */ ? ts.factory.createArrayTypeNode(tupleConstituentNodes[i]) : tupleConstituentNodes[i]) : + flags & 2 /* ElementFlags.Optional */ ? ts.factory.createOptionalTypeNode(tupleConstituentNodes[i]) : + tupleConstituentNodes[i]; + } + } + var tupleTypeNode = ts.setEmitFlags(ts.factory.createTupleTypeNode(tupleConstituentNodes), 1 /* EmitFlags.SingleLine */); + return type.target.readonly ? ts.factory.createTypeOperatorNode(146 /* SyntaxKind.ReadonlyKeyword */, tupleTypeNode) : tupleTypeNode; + } + } + if (context.encounteredError || (context.flags & 524288 /* NodeBuilderFlags.AllowEmptyTuple */)) { + var tupleTypeNode = ts.setEmitFlags(ts.factory.createTupleTypeNode([]), 1 /* EmitFlags.SingleLine */); + return type.target.readonly ? ts.factory.createTypeOperatorNode(146 /* SyntaxKind.ReadonlyKeyword */, tupleTypeNode) : tupleTypeNode; + } + context.encounteredError = true; + return undefined; // TODO: GH#18217 + } + else if (context.flags & 2048 /* NodeBuilderFlags.WriteClassExpressionAsTypeLiteral */ && + type.symbol.valueDeclaration && + ts.isClassLike(type.symbol.valueDeclaration) && + !isValueSymbolAccessible(type.symbol, context.enclosingDeclaration)) { + return createAnonymousTypeNode(type); + } + else { + var outerTypeParameters = type.target.outerTypeParameters; + var i = 0; + var resultType = void 0; + if (outerTypeParameters) { + var length_2 = outerTypeParameters.length; + while (i < length_2) { + // Find group of type arguments for type parameters with the same declaring container. + var start = i; + var parent = getParentSymbolOfTypeParameter(outerTypeParameters[i]); + do { + i++; + } while (i < length_2 && getParentSymbolOfTypeParameter(outerTypeParameters[i]) === parent); + // When type parameters are their own type arguments for the whole group (i.e. we have + // the default outer type arguments), we don't show the group. + if (!ts.rangeEquals(outerTypeParameters, typeArguments, start, i)) { + var typeArgumentSlice = mapToTypeNodes(typeArguments.slice(start, i), context); + var flags_3 = context.flags; + context.flags |= 16 /* NodeBuilderFlags.ForbidIndexedAccessSymbolReferences */; + var ref = symbolToTypeNode(parent, context, 788968 /* SymbolFlags.Type */, typeArgumentSlice); + context.flags = flags_3; + resultType = !resultType ? ref : appendReferenceToType(resultType, ref); + } + } + } + var typeArgumentNodes = void 0; + if (typeArguments.length > 0) { + var typeParameterCount = (type.target.typeParameters || ts.emptyArray).length; + typeArgumentNodes = mapToTypeNodes(typeArguments.slice(i, typeParameterCount), context); + } + var flags = context.flags; + context.flags |= 16 /* NodeBuilderFlags.ForbidIndexedAccessSymbolReferences */; + var finalRef = symbolToTypeNode(type.symbol, context, 788968 /* SymbolFlags.Type */, typeArgumentNodes); + context.flags = flags; + return !resultType ? finalRef : appendReferenceToType(resultType, finalRef); + } + } + function appendReferenceToType(root, ref) { + if (ts.isImportTypeNode(root)) { + // first shift type arguments + var typeArguments = root.typeArguments; + var qualifier = root.qualifier; + if (qualifier) { + if (ts.isIdentifier(qualifier)) { + qualifier = ts.factory.updateIdentifier(qualifier, typeArguments); + } + else { + qualifier = ts.factory.updateQualifiedName(qualifier, qualifier.left, ts.factory.updateIdentifier(qualifier.right, typeArguments)); + } + } + typeArguments = ref.typeArguments; + // then move qualifiers + var ids = getAccessStack(ref); + for (var _i = 0, ids_1 = ids; _i < ids_1.length; _i++) { + var id = ids_1[_i]; + qualifier = qualifier ? ts.factory.createQualifiedName(qualifier, id) : id; + } + return ts.factory.updateImportTypeNode(root, root.argument, root.assertions, qualifier, typeArguments, root.isTypeOf); + } + else { + // first shift type arguments + var typeArguments = root.typeArguments; + var typeName = root.typeName; + if (ts.isIdentifier(typeName)) { + typeName = ts.factory.updateIdentifier(typeName, typeArguments); + } + else { + typeName = ts.factory.updateQualifiedName(typeName, typeName.left, ts.factory.updateIdentifier(typeName.right, typeArguments)); + } + typeArguments = ref.typeArguments; + // then move qualifiers + var ids = getAccessStack(ref); + for (var _a = 0, ids_2 = ids; _a < ids_2.length; _a++) { + var id = ids_2[_a]; + typeName = ts.factory.createQualifiedName(typeName, id); + } + return ts.factory.updateTypeReferenceNode(root, typeName, typeArguments); + } + } + function getAccessStack(ref) { + var state = ref.typeName; + var ids = []; + while (!ts.isIdentifier(state)) { + ids.unshift(state.right); + state = state.left; + } + ids.unshift(state); + return ids; + } + function createTypeNodesFromResolvedType(resolvedType) { + if (checkTruncationLength(context)) { + return [ts.factory.createPropertySignature(/*modifiers*/ undefined, "...", /*questionToken*/ undefined, /*type*/ undefined)]; + } + var typeElements = []; + for (var _i = 0, _a = resolvedType.callSignatures; _i < _a.length; _i++) { + var signature = _a[_i]; + typeElements.push(signatureToSignatureDeclarationHelper(signature, 176 /* SyntaxKind.CallSignature */, context)); + } + for (var _b = 0, _c = resolvedType.constructSignatures; _b < _c.length; _b++) { + var signature = _c[_b]; + if (signature.flags & 4 /* SignatureFlags.Abstract */) + continue; + typeElements.push(signatureToSignatureDeclarationHelper(signature, 177 /* SyntaxKind.ConstructSignature */, context)); + } + for (var _d = 0, _e = resolvedType.indexInfos; _d < _e.length; _d++) { + var info = _e[_d]; + typeElements.push(indexInfoToIndexSignatureDeclarationHelper(info, context, resolvedType.objectFlags & 1024 /* ObjectFlags.ReverseMapped */ ? createElidedInformationPlaceholder(context) : undefined)); + } + var properties = resolvedType.properties; + if (!properties) { + return typeElements; + } + var i = 0; + for (var _f = 0, properties_1 = properties; _f < properties_1.length; _f++) { + var propertySymbol = properties_1[_f]; + i++; + if (context.flags & 2048 /* NodeBuilderFlags.WriteClassExpressionAsTypeLiteral */) { + if (propertySymbol.flags & 4194304 /* SymbolFlags.Prototype */) { + continue; + } + if (ts.getDeclarationModifierFlagsFromSymbol(propertySymbol) & (8 /* ModifierFlags.Private */ | 16 /* ModifierFlags.Protected */) && context.tracker.reportPrivateInBaseOfClassExpression) { + context.tracker.reportPrivateInBaseOfClassExpression(ts.unescapeLeadingUnderscores(propertySymbol.escapedName)); + } + } + if (checkTruncationLength(context) && (i + 2 < properties.length - 1)) { + typeElements.push(ts.factory.createPropertySignature(/*modifiers*/ undefined, "... ".concat(properties.length - i, " more ..."), /*questionToken*/ undefined, /*type*/ undefined)); + addPropertyToElementList(properties[properties.length - 1], context, typeElements); + break; + } + addPropertyToElementList(propertySymbol, context, typeElements); + } + return typeElements.length ? typeElements : undefined; + } + } + function createElidedInformationPlaceholder(context) { + context.approximateLength += 3; + if (!(context.flags & 1 /* NodeBuilderFlags.NoTruncation */)) { + return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier("..."), /*typeArguments*/ undefined); + } + return ts.factory.createKeywordTypeNode(131 /* SyntaxKind.AnyKeyword */); + } + function shouldUsePlaceholderForProperty(propertySymbol, context) { + var _a; + // Use placeholders for reverse mapped types we've either already descended into, or which + // are nested reverse mappings within a mapping over a non-anonymous type. The later is a restriction mostly just to + // reduce the blowup in printback size from doing, eg, a deep reverse mapping over `Window`. + // Since anonymous types usually come from expressions, this allows us to preserve the output + // for deep mappings which likely come from expressions, while truncating those parts which + // come from mappings over library functions. + return !!(ts.getCheckFlags(propertySymbol) & 8192 /* CheckFlags.ReverseMapped */) + && (ts.contains(context.reverseMappedStack, propertySymbol) + || (((_a = context.reverseMappedStack) === null || _a === void 0 ? void 0 : _a[0]) + && !(ts.getObjectFlags(ts.last(context.reverseMappedStack).propertyType) & 16 /* ObjectFlags.Anonymous */))); + } + function addPropertyToElementList(propertySymbol, context, typeElements) { + var _a, _b; + var propertyIsReverseMapped = !!(ts.getCheckFlags(propertySymbol) & 8192 /* CheckFlags.ReverseMapped */); + var propertyType = shouldUsePlaceholderForProperty(propertySymbol, context) ? + anyType : getNonMissingTypeOfSymbol(propertySymbol); + var saveEnclosingDeclaration = context.enclosingDeclaration; + context.enclosingDeclaration = undefined; + if (context.tracker.trackSymbol && isLateBoundName(propertySymbol.escapedName)) { + if (propertySymbol.declarations) { + var decl = ts.first(propertySymbol.declarations); + if (hasLateBindableName(decl)) { + if (ts.isBinaryExpression(decl)) { + var name = ts.getNameOfDeclaration(decl); + if (name && ts.isElementAccessExpression(name) && ts.isPropertyAccessEntityNameExpression(name.argumentExpression)) { + trackComputedName(name.argumentExpression, saveEnclosingDeclaration, context); + } + } + else { + trackComputedName(decl.name.expression, saveEnclosingDeclaration, context); + } + } + } + else if ((_a = context.tracker) === null || _a === void 0 ? void 0 : _a.reportNonSerializableProperty) { + context.tracker.reportNonSerializableProperty(symbolToString(propertySymbol)); + } + } + context.enclosingDeclaration = propertySymbol.valueDeclaration || ((_b = propertySymbol.declarations) === null || _b === void 0 ? void 0 : _b[0]) || saveEnclosingDeclaration; + var propertyName = getPropertyNameNodeForSymbol(propertySymbol, context); + context.enclosingDeclaration = saveEnclosingDeclaration; + context.approximateLength += (ts.symbolName(propertySymbol).length + 1); + var optionalToken = propertySymbol.flags & 16777216 /* SymbolFlags.Optional */ ? ts.factory.createToken(57 /* SyntaxKind.QuestionToken */) : undefined; + if (propertySymbol.flags & (16 /* SymbolFlags.Function */ | 8192 /* SymbolFlags.Method */) && !getPropertiesOfObjectType(propertyType).length && !isReadonlySymbol(propertySymbol)) { + var signatures = getSignaturesOfType(filterType(propertyType, function (t) { return !(t.flags & 32768 /* TypeFlags.Undefined */); }), 0 /* SignatureKind.Call */); + for (var _i = 0, signatures_1 = signatures; _i < signatures_1.length; _i++) { + var signature = signatures_1[_i]; + var methodDeclaration = signatureToSignatureDeclarationHelper(signature, 170 /* SyntaxKind.MethodSignature */, context, { name: propertyName, questionToken: optionalToken }); + typeElements.push(preserveCommentsOn(methodDeclaration)); + } + } + else { + var propertyTypeNode = void 0; + if (shouldUsePlaceholderForProperty(propertySymbol, context)) { + propertyTypeNode = createElidedInformationPlaceholder(context); + } + else { + if (propertyIsReverseMapped) { + context.reverseMappedStack || (context.reverseMappedStack = []); + context.reverseMappedStack.push(propertySymbol); + } + propertyTypeNode = propertyType ? serializeTypeForDeclaration(context, propertyType, propertySymbol, saveEnclosingDeclaration) : ts.factory.createKeywordTypeNode(131 /* SyntaxKind.AnyKeyword */); + if (propertyIsReverseMapped) { + context.reverseMappedStack.pop(); + } + } + var modifiers = isReadonlySymbol(propertySymbol) ? [ts.factory.createToken(146 /* SyntaxKind.ReadonlyKeyword */)] : undefined; + if (modifiers) { + context.approximateLength += 9; + } + var propertySignature = ts.factory.createPropertySignature(modifiers, propertyName, optionalToken, propertyTypeNode); + typeElements.push(preserveCommentsOn(propertySignature)); + } + function preserveCommentsOn(node) { + var _a; + if (ts.some(propertySymbol.declarations, function (d) { return d.kind === 350 /* SyntaxKind.JSDocPropertyTag */; })) { + var d = (_a = propertySymbol.declarations) === null || _a === void 0 ? void 0 : _a.find(function (d) { return d.kind === 350 /* SyntaxKind.JSDocPropertyTag */; }); + var commentText = ts.getTextOfJSDocComment(d.comment); + if (commentText) { + ts.setSyntheticLeadingComments(node, [{ kind: 3 /* SyntaxKind.MultiLineCommentTrivia */, text: "*\n * " + commentText.replace(/\n/g, "\n * ") + "\n ", pos: -1, end: -1, hasTrailingNewLine: true }]); + } + } + else if (propertySymbol.valueDeclaration) { + // Copy comments to node for declaration emit + ts.setCommentRange(node, propertySymbol.valueDeclaration); + } + return node; + } + } + function mapToTypeNodes(types, context, isBareList) { + if (ts.some(types)) { + if (checkTruncationLength(context)) { + if (!isBareList) { + return [ts.factory.createTypeReferenceNode("...", /*typeArguments*/ undefined)]; + } + else if (types.length > 2) { + return [ + typeToTypeNodeHelper(types[0], context), + ts.factory.createTypeReferenceNode("... ".concat(types.length - 2, " more ..."), /*typeArguments*/ undefined), + typeToTypeNodeHelper(types[types.length - 1], context) + ]; + } + } + var mayHaveNameCollisions = !(context.flags & 64 /* NodeBuilderFlags.UseFullyQualifiedType */); + /** Map from type reference identifier text to [type, index in `result` where the type node is] */ + var seenNames = mayHaveNameCollisions ? ts.createUnderscoreEscapedMultiMap() : undefined; + var result_5 = []; + var i = 0; + for (var _i = 0, types_2 = types; _i < types_2.length; _i++) { + var type = types_2[_i]; + i++; + if (checkTruncationLength(context) && (i + 2 < types.length - 1)) { + result_5.push(ts.factory.createTypeReferenceNode("... ".concat(types.length - i, " more ..."), /*typeArguments*/ undefined)); + var typeNode_1 = typeToTypeNodeHelper(types[types.length - 1], context); + if (typeNode_1) { + result_5.push(typeNode_1); + } + break; + } + context.approximateLength += 2; // Account for whitespace + separator + var typeNode = typeToTypeNodeHelper(type, context); + if (typeNode) { + result_5.push(typeNode); + if (seenNames && ts.isIdentifierTypeReference(typeNode)) { + seenNames.add(typeNode.typeName.escapedText, [type, result_5.length - 1]); + } + } + } + if (seenNames) { + // To avoid printing types like `[Foo, Foo]` or `Bar & Bar` where + // occurrences of the same name actually come from different + // namespaces, go through the single-identifier type reference nodes + // we just generated, and see if any names were generated more than + // once while referring to different types. If so, regenerate the + // type node for each entry by that name with the + // `UseFullyQualifiedType` flag enabled. + var saveContextFlags = context.flags; + context.flags |= 64 /* NodeBuilderFlags.UseFullyQualifiedType */; + seenNames.forEach(function (types) { + if (!ts.arrayIsHomogeneous(types, function (_a, _b) { + var a = _a[0]; + var b = _b[0]; + return typesAreSameReference(a, b); + })) { + for (var _i = 0, types_3 = types; _i < types_3.length; _i++) { + var _a = types_3[_i], type = _a[0], resultIndex = _a[1]; + result_5[resultIndex] = typeToTypeNodeHelper(type, context); + } + } + }); + context.flags = saveContextFlags; + } + return result_5; + } + } + function typesAreSameReference(a, b) { + return a === b + || !!a.symbol && a.symbol === b.symbol + || !!a.aliasSymbol && a.aliasSymbol === b.aliasSymbol; + } + function indexInfoToIndexSignatureDeclarationHelper(indexInfo, context, typeNode) { + var name = ts.getNameFromIndexInfo(indexInfo) || "x"; + var indexerTypeNode = typeToTypeNodeHelper(indexInfo.keyType, context); + var indexingParameter = ts.factory.createParameterDeclaration( + /*modifiers*/ undefined, + /*dotDotDotToken*/ undefined, name, + /*questionToken*/ undefined, indexerTypeNode, + /*initializer*/ undefined); + if (!typeNode) { + typeNode = typeToTypeNodeHelper(indexInfo.type || anyType, context); + } + if (!indexInfo.type && !(context.flags & 2097152 /* NodeBuilderFlags.AllowEmptyIndexInfoType */)) { + context.encounteredError = true; + } + context.approximateLength += (name.length + 4); + return ts.factory.createIndexSignature(indexInfo.isReadonly ? [ts.factory.createToken(146 /* SyntaxKind.ReadonlyKeyword */)] : undefined, [indexingParameter], typeNode); + } + function signatureToSignatureDeclarationHelper(signature, kind, context, options) { + var _a, _b, _c, _d; + var suppressAny = context.flags & 256 /* NodeBuilderFlags.SuppressAnyReturnType */; + if (suppressAny) + context.flags &= ~256 /* NodeBuilderFlags.SuppressAnyReturnType */; // suppress only toplevel `any`s + context.approximateLength += 3; // Usually a signature contributes a few more characters than this, but 3 is the minimum + var typeParameters; + var typeArguments; + if (context.flags & 32 /* NodeBuilderFlags.WriteTypeArgumentsOfSignature */ && signature.target && signature.mapper && signature.target.typeParameters) { + typeArguments = signature.target.typeParameters.map(function (parameter) { return typeToTypeNodeHelper(instantiateType(parameter, signature.mapper), context); }); + } + else { + typeParameters = signature.typeParameters && signature.typeParameters.map(function (parameter) { return typeParameterToDeclaration(parameter, context); }); + } + var expandedParams = getExpandedParameters(signature, /*skipUnionExpanding*/ true)[0]; + // If the expanded parameter list had a variadic in a non-trailing position, don't expand it + var parameters = (ts.some(expandedParams, function (p) { return p !== expandedParams[expandedParams.length - 1] && !!(ts.getCheckFlags(p) & 32768 /* CheckFlags.RestParameter */); }) ? signature.parameters : expandedParams).map(function (parameter) { return symbolToParameterDeclaration(parameter, context, kind === 173 /* SyntaxKind.Constructor */, options === null || options === void 0 ? void 0 : options.privateSymbolVisitor, options === null || options === void 0 ? void 0 : options.bundledImports); }); + var thisParameter = context.flags & 33554432 /* NodeBuilderFlags.OmitThisParameter */ ? undefined : tryGetThisParameterDeclaration(signature, context); + if (thisParameter) { + parameters.unshift(thisParameter); + } + var returnTypeNode; + var typePredicate = getTypePredicateOfSignature(signature); + if (typePredicate) { + var assertsModifier = typePredicate.kind === 2 /* TypePredicateKind.AssertsThis */ || typePredicate.kind === 3 /* TypePredicateKind.AssertsIdentifier */ ? + ts.factory.createToken(129 /* SyntaxKind.AssertsKeyword */) : + undefined; + var parameterName = typePredicate.kind === 1 /* TypePredicateKind.Identifier */ || typePredicate.kind === 3 /* TypePredicateKind.AssertsIdentifier */ ? + ts.setEmitFlags(ts.factory.createIdentifier(typePredicate.parameterName), 16777216 /* EmitFlags.NoAsciiEscaping */) : + ts.factory.createThisTypeNode(); + var typeNode = typePredicate.type && typeToTypeNodeHelper(typePredicate.type, context); + returnTypeNode = ts.factory.createTypePredicateNode(assertsModifier, parameterName, typeNode); + } + else { + var returnType = getReturnTypeOfSignature(signature); + if (returnType && !(suppressAny && isTypeAny(returnType))) { + returnTypeNode = serializeReturnTypeForSignature(context, returnType, signature, options === null || options === void 0 ? void 0 : options.privateSymbolVisitor, options === null || options === void 0 ? void 0 : options.bundledImports); + } + else if (!suppressAny) { + returnTypeNode = ts.factory.createKeywordTypeNode(131 /* SyntaxKind.AnyKeyword */); + } + } + var modifiers = options === null || options === void 0 ? void 0 : options.modifiers; + if ((kind === 182 /* SyntaxKind.ConstructorType */) && signature.flags & 4 /* SignatureFlags.Abstract */) { + var flags = ts.modifiersToFlags(modifiers); + modifiers = ts.factory.createModifiersFromModifierFlags(flags | 256 /* ModifierFlags.Abstract */); + } + var node = kind === 176 /* SyntaxKind.CallSignature */ ? ts.factory.createCallSignature(typeParameters, parameters, returnTypeNode) : + kind === 177 /* SyntaxKind.ConstructSignature */ ? ts.factory.createConstructSignature(typeParameters, parameters, returnTypeNode) : + kind === 170 /* SyntaxKind.MethodSignature */ ? ts.factory.createMethodSignature(modifiers, (_a = options === null || options === void 0 ? void 0 : options.name) !== null && _a !== void 0 ? _a : ts.factory.createIdentifier(""), options === null || options === void 0 ? void 0 : options.questionToken, typeParameters, parameters, returnTypeNode) : + kind === 171 /* SyntaxKind.MethodDeclaration */ ? ts.factory.createMethodDeclaration(modifiers, /*asteriskToken*/ undefined, (_b = options === null || options === void 0 ? void 0 : options.name) !== null && _b !== void 0 ? _b : ts.factory.createIdentifier(""), /*questionToken*/ undefined, typeParameters, parameters, returnTypeNode, /*body*/ undefined) : + kind === 173 /* SyntaxKind.Constructor */ ? ts.factory.createConstructorDeclaration(modifiers, parameters, /*body*/ undefined) : + kind === 174 /* SyntaxKind.GetAccessor */ ? ts.factory.createGetAccessorDeclaration(modifiers, (_c = options === null || options === void 0 ? void 0 : options.name) !== null && _c !== void 0 ? _c : ts.factory.createIdentifier(""), parameters, returnTypeNode, /*body*/ undefined) : + kind === 175 /* SyntaxKind.SetAccessor */ ? ts.factory.createSetAccessorDeclaration(modifiers, (_d = options === null || options === void 0 ? void 0 : options.name) !== null && _d !== void 0 ? _d : ts.factory.createIdentifier(""), parameters, /*body*/ undefined) : + kind === 178 /* SyntaxKind.IndexSignature */ ? ts.factory.createIndexSignature(modifiers, parameters, returnTypeNode) : + kind === 320 /* SyntaxKind.JSDocFunctionType */ ? ts.factory.createJSDocFunctionType(parameters, returnTypeNode) : + kind === 181 /* SyntaxKind.FunctionType */ ? ts.factory.createFunctionTypeNode(typeParameters, parameters, returnTypeNode !== null && returnTypeNode !== void 0 ? returnTypeNode : ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(""))) : + kind === 182 /* SyntaxKind.ConstructorType */ ? ts.factory.createConstructorTypeNode(modifiers, typeParameters, parameters, returnTypeNode !== null && returnTypeNode !== void 0 ? returnTypeNode : ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(""))) : + kind === 259 /* SyntaxKind.FunctionDeclaration */ ? ts.factory.createFunctionDeclaration(modifiers, /*asteriskToken*/ undefined, (options === null || options === void 0 ? void 0 : options.name) ? ts.cast(options.name, ts.isIdentifier) : ts.factory.createIdentifier(""), typeParameters, parameters, returnTypeNode, /*body*/ undefined) : + kind === 215 /* SyntaxKind.FunctionExpression */ ? ts.factory.createFunctionExpression(modifiers, /*asteriskToken*/ undefined, (options === null || options === void 0 ? void 0 : options.name) ? ts.cast(options.name, ts.isIdentifier) : ts.factory.createIdentifier(""), typeParameters, parameters, returnTypeNode, ts.factory.createBlock([])) : + kind === 216 /* SyntaxKind.ArrowFunction */ ? ts.factory.createArrowFunction(modifiers, typeParameters, parameters, returnTypeNode, /*equalsGreaterThanToken*/ undefined, ts.factory.createBlock([])) : + ts.Debug.assertNever(kind); + if (typeArguments) { + node.typeArguments = ts.factory.createNodeArray(typeArguments); + } + return node; + } + function tryGetThisParameterDeclaration(signature, context) { + if (signature.thisParameter) { + return symbolToParameterDeclaration(signature.thisParameter, context); + } + if (signature.declaration) { + var thisTag = ts.getJSDocThisTag(signature.declaration); + if (thisTag && thisTag.typeExpression) { + return ts.factory.createParameterDeclaration( + /* modifiers */ undefined, + /* dotDotDotToken */ undefined, "this", + /* questionToken */ undefined, typeToTypeNodeHelper(getTypeFromTypeNode(thisTag.typeExpression), context)); + } + } + } + function typeParameterToDeclarationWithConstraint(type, context, constraintNode) { + var savedContextFlags = context.flags; + context.flags &= ~512 /* NodeBuilderFlags.WriteTypeParametersInQualifiedName */; // Avoids potential infinite loop when building for a claimspace with a generic + var modifiers = ts.factory.createModifiersFromModifierFlags(getVarianceModifiers(type)); + var name = typeParameterToName(type, context); + var defaultParameter = getDefaultFromTypeParameter(type); + var defaultParameterNode = defaultParameter && typeToTypeNodeHelper(defaultParameter, context); + context.flags = savedContextFlags; + return ts.factory.createTypeParameterDeclaration(modifiers, name, constraintNode, defaultParameterNode); + } + function typeParameterToDeclaration(type, context, constraint) { + if (constraint === void 0) { constraint = getConstraintOfTypeParameter(type); } + var constraintNode = constraint && typeToTypeNodeHelper(constraint, context); + return typeParameterToDeclarationWithConstraint(type, context, constraintNode); + } + function symbolToParameterDeclaration(parameterSymbol, context, preserveModifierFlags, privateSymbolVisitor, bundledImports) { + var parameterDeclaration = ts.getDeclarationOfKind(parameterSymbol, 166 /* SyntaxKind.Parameter */); + if (!parameterDeclaration && !ts.isTransientSymbol(parameterSymbol)) { + parameterDeclaration = ts.getDeclarationOfKind(parameterSymbol, 343 /* SyntaxKind.JSDocParameterTag */); + } + var parameterType = getTypeOfSymbol(parameterSymbol); + if (parameterDeclaration && isRequiredInitializedParameter(parameterDeclaration)) { + parameterType = getOptionalType(parameterType); + } + var parameterTypeNode = serializeTypeForDeclaration(context, parameterType, parameterSymbol, context.enclosingDeclaration, privateSymbolVisitor, bundledImports); + var modifiers = !(context.flags & 8192 /* NodeBuilderFlags.OmitParameterModifiers */) && preserveModifierFlags && parameterDeclaration && ts.canHaveModifiers(parameterDeclaration) ? ts.map(ts.getModifiers(parameterDeclaration), ts.factory.cloneNode) : undefined; + var isRest = parameterDeclaration && ts.isRestParameter(parameterDeclaration) || ts.getCheckFlags(parameterSymbol) & 32768 /* CheckFlags.RestParameter */; + var dotDotDotToken = isRest ? ts.factory.createToken(25 /* SyntaxKind.DotDotDotToken */) : undefined; + var name = parameterDeclaration ? parameterDeclaration.name ? + parameterDeclaration.name.kind === 79 /* SyntaxKind.Identifier */ ? ts.setEmitFlags(ts.factory.cloneNode(parameterDeclaration.name), 16777216 /* EmitFlags.NoAsciiEscaping */) : + parameterDeclaration.name.kind === 163 /* SyntaxKind.QualifiedName */ ? ts.setEmitFlags(ts.factory.cloneNode(parameterDeclaration.name.right), 16777216 /* EmitFlags.NoAsciiEscaping */) : + cloneBindingName(parameterDeclaration.name) : + ts.symbolName(parameterSymbol) : + ts.symbolName(parameterSymbol); + var isOptional = parameterDeclaration && isOptionalParameter(parameterDeclaration) || ts.getCheckFlags(parameterSymbol) & 16384 /* CheckFlags.OptionalParameter */; + var questionToken = isOptional ? ts.factory.createToken(57 /* SyntaxKind.QuestionToken */) : undefined; + var parameterNode = ts.factory.createParameterDeclaration(modifiers, dotDotDotToken, name, questionToken, parameterTypeNode, + /*initializer*/ undefined); + context.approximateLength += ts.symbolName(parameterSymbol).length + 3; + return parameterNode; + function cloneBindingName(node) { + return elideInitializerAndSetEmitFlags(node); + function elideInitializerAndSetEmitFlags(node) { + if (context.tracker.trackSymbol && ts.isComputedPropertyName(node) && isLateBindableName(node)) { + trackComputedName(node.expression, context.enclosingDeclaration, context); + } + var visited = ts.visitEachChild(node, elideInitializerAndSetEmitFlags, ts.nullTransformationContext, /*nodesVisitor*/ undefined, elideInitializerAndSetEmitFlags); + if (ts.isBindingElement(visited)) { + visited = ts.factory.updateBindingElement(visited, visited.dotDotDotToken, visited.propertyName, visited.name, + /*initializer*/ undefined); + } + if (!ts.nodeIsSynthesized(visited)) { + visited = ts.factory.cloneNode(visited); + } + return ts.setEmitFlags(visited, 1 /* EmitFlags.SingleLine */ | 16777216 /* EmitFlags.NoAsciiEscaping */); + } + } + } + function trackComputedName(accessExpression, enclosingDeclaration, context) { + if (!context.tracker.trackSymbol) + return; + // get symbol of the first identifier of the entityName + var firstIdentifier = ts.getFirstIdentifier(accessExpression); + var name = resolveName(firstIdentifier, firstIdentifier.escapedText, 111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */, /*nodeNotFoundErrorMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ true); + if (name) { + context.tracker.trackSymbol(name, enclosingDeclaration, 111551 /* SymbolFlags.Value */); + } + } + function lookupSymbolChain(symbol, context, meaning, yieldModuleSymbol) { + context.tracker.trackSymbol(symbol, context.enclosingDeclaration, meaning); // TODO: GH#18217 + return lookupSymbolChainWorker(symbol, context, meaning, yieldModuleSymbol); + } + function lookupSymbolChainWorker(symbol, context, meaning, yieldModuleSymbol) { + // Try to get qualified name if the symbol is not a type parameter and there is an enclosing declaration. + var chain; + var isTypeParameter = symbol.flags & 262144 /* SymbolFlags.TypeParameter */; + if (!isTypeParameter && (context.enclosingDeclaration || context.flags & 64 /* NodeBuilderFlags.UseFullyQualifiedType */) && !(context.flags & 134217728 /* NodeBuilderFlags.DoNotIncludeSymbolChain */)) { + chain = ts.Debug.checkDefined(getSymbolChain(symbol, meaning, /*endOfChain*/ true)); + ts.Debug.assert(chain && chain.length > 0); + } + else { + chain = [symbol]; + } + return chain; + /** @param endOfChain Set to false for recursive calls; non-recursive calls should always output something. */ + function getSymbolChain(symbol, meaning, endOfChain) { + var accessibleSymbolChain = getAccessibleSymbolChain(symbol, context.enclosingDeclaration, meaning, !!(context.flags & 128 /* NodeBuilderFlags.UseOnlyExternalAliasing */)); + var parentSpecifiers; + if (!accessibleSymbolChain || + needsQualification(accessibleSymbolChain[0], context.enclosingDeclaration, accessibleSymbolChain.length === 1 ? meaning : getQualifiedLeftMeaning(meaning))) { + // Go up and add our parent. + var parents_1 = getContainersOfSymbol(accessibleSymbolChain ? accessibleSymbolChain[0] : symbol, context.enclosingDeclaration, meaning); + if (ts.length(parents_1)) { + parentSpecifiers = parents_1.map(function (symbol) { + return ts.some(symbol.declarations, hasNonGlobalAugmentationExternalModuleSymbol) + ? getSpecifierForModuleSymbol(symbol, context) + : undefined; + }); + var indices = parents_1.map(function (_, i) { return i; }); + indices.sort(sortByBestName); + var sortedParents = indices.map(function (i) { return parents_1[i]; }); + for (var _i = 0, sortedParents_1 = sortedParents; _i < sortedParents_1.length; _i++) { + var parent = sortedParents_1[_i]; + var parentChain = getSymbolChain(parent, getQualifiedLeftMeaning(meaning), /*endOfChain*/ false); + if (parentChain) { + if (parent.exports && parent.exports.get("export=" /* InternalSymbolName.ExportEquals */) && + getSymbolIfSameReference(parent.exports.get("export=" /* InternalSymbolName.ExportEquals */), symbol)) { + // parentChain root _is_ symbol - symbol is a module export=, so it kinda looks like it's own parent + // No need to lookup an alias for the symbol in itself + accessibleSymbolChain = parentChain; + break; + } + accessibleSymbolChain = parentChain.concat(accessibleSymbolChain || [getAliasForSymbolInContainer(parent, symbol) || symbol]); + break; + } + } + } + } + if (accessibleSymbolChain) { + return accessibleSymbolChain; + } + if ( + // If this is the last part of outputting the symbol, always output. The cases apply only to parent symbols. + endOfChain || + // If a parent symbol is an anonymous type, don't write it. + !(symbol.flags & (2048 /* SymbolFlags.TypeLiteral */ | 4096 /* SymbolFlags.ObjectLiteral */))) { + // If a parent symbol is an external module, don't write it. (We prefer just `x` vs `"foo/bar".x`.) + if (!endOfChain && !yieldModuleSymbol && !!ts.forEach(symbol.declarations, hasNonGlobalAugmentationExternalModuleSymbol)) { + return; + } + return [symbol]; + } + function sortByBestName(a, b) { + var specifierA = parentSpecifiers[a]; + var specifierB = parentSpecifiers[b]; + if (specifierA && specifierB) { + var isBRelative = ts.pathIsRelative(specifierB); + if (ts.pathIsRelative(specifierA) === isBRelative) { + // Both relative or both non-relative, sort by number of parts + return ts.moduleSpecifiers.countPathComponents(specifierA) - ts.moduleSpecifiers.countPathComponents(specifierB); + } + if (isBRelative) { + // A is non-relative, B is relative: prefer A + return -1; + } + // A is relative, B is non-relative: prefer B + return 1; + } + return 0; + } + } + } + function typeParametersToTypeParameterDeclarations(symbol, context) { + var typeParameterNodes; + var targetSymbol = getTargetSymbol(symbol); + if (targetSymbol.flags & (32 /* SymbolFlags.Class */ | 64 /* SymbolFlags.Interface */ | 524288 /* SymbolFlags.TypeAlias */)) { + typeParameterNodes = ts.factory.createNodeArray(ts.map(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol), function (tp) { return typeParameterToDeclaration(tp, context); })); + } + return typeParameterNodes; + } + function lookupTypeParameterNodes(chain, index, context) { + var _a; + ts.Debug.assert(chain && 0 <= index && index < chain.length); + var symbol = chain[index]; + var symbolId = getSymbolId(symbol); + if ((_a = context.typeParameterSymbolList) === null || _a === void 0 ? void 0 : _a.has(symbolId)) { + return undefined; + } + (context.typeParameterSymbolList || (context.typeParameterSymbolList = new ts.Set())).add(symbolId); + var typeParameterNodes; + if (context.flags & 512 /* NodeBuilderFlags.WriteTypeParametersInQualifiedName */ && index < (chain.length - 1)) { + var parentSymbol = symbol; + var nextSymbol_1 = chain[index + 1]; + if (ts.getCheckFlags(nextSymbol_1) & 1 /* CheckFlags.Instantiated */) { + var params = getTypeParametersOfClassOrInterface(parentSymbol.flags & 2097152 /* SymbolFlags.Alias */ ? resolveAlias(parentSymbol) : parentSymbol); + typeParameterNodes = mapToTypeNodes(ts.map(params, function (t) { return getMappedType(t, nextSymbol_1.mapper); }), context); + } + else { + typeParameterNodes = typeParametersToTypeParameterDeclarations(symbol, context); + } + } + return typeParameterNodes; + } + /** + * Given A[B][C][D], finds A[B] + */ + function getTopmostIndexedAccessType(top) { + if (ts.isIndexedAccessTypeNode(top.objectType)) { + return getTopmostIndexedAccessType(top.objectType); + } + return top; + } + function getSpecifierForModuleSymbol(symbol, context, overrideImportMode) { + var _a; + var file = ts.getDeclarationOfKind(symbol, 308 /* SyntaxKind.SourceFile */); + if (!file) { + var equivalentFileSymbol = ts.firstDefined(symbol.declarations, function (d) { return getFileSymbolIfFileSymbolExportEqualsContainer(d, symbol); }); + if (equivalentFileSymbol) { + file = ts.getDeclarationOfKind(equivalentFileSymbol, 308 /* SyntaxKind.SourceFile */); + } + } + if (file && file.moduleName !== undefined) { + // Use the amd name if it is available + return file.moduleName; + } + if (!file) { + if (context.tracker.trackReferencedAmbientModule) { + var ambientDecls = ts.filter(symbol.declarations, ts.isAmbientModule); + if (ts.length(ambientDecls)) { + for (var _i = 0, _b = ambientDecls; _i < _b.length; _i++) { + var decl = _b[_i]; + context.tracker.trackReferencedAmbientModule(decl, symbol); + } + } + } + if (ambientModuleSymbolRegex.test(symbol.escapedName)) { + return symbol.escapedName.substring(1, symbol.escapedName.length - 1); + } + } + if (!context.enclosingDeclaration || !context.tracker.moduleResolverHost) { + // If there's no context declaration, we can't lookup a non-ambient specifier, so we just use the symbol name + if (ambientModuleSymbolRegex.test(symbol.escapedName)) { + return symbol.escapedName.substring(1, symbol.escapedName.length - 1); + } + return ts.getSourceFileOfNode(ts.getNonAugmentationDeclaration(symbol)).fileName; // A resolver may not be provided for baselines and errors - in those cases we use the fileName in full + } + var contextFile = ts.getSourceFileOfNode(ts.getOriginalNode(context.enclosingDeclaration)); + var resolutionMode = overrideImportMode || (contextFile === null || contextFile === void 0 ? void 0 : contextFile.impliedNodeFormat); + var cacheKey = getSpecifierCacheKey(contextFile.path, resolutionMode); + var links = getSymbolLinks(symbol); + var specifier = links.specifierCache && links.specifierCache.get(cacheKey); + if (!specifier) { + var isBundle_1 = !!ts.outFile(compilerOptions); + // For declaration bundles, we need to generate absolute paths relative to the common source dir for imports, + // just like how the declaration emitter does for the ambient module declarations - we can easily accomplish this + // using the `baseUrl` compiler option (which we would otherwise never use in declaration emit) and a non-relative + // specifier preference + var moduleResolverHost = context.tracker.moduleResolverHost; + var specifierCompilerOptions = isBundle_1 ? __assign(__assign({}, compilerOptions), { baseUrl: moduleResolverHost.getCommonSourceDirectory() }) : compilerOptions; + specifier = ts.first(ts.moduleSpecifiers.getModuleSpecifiers(symbol, checker, specifierCompilerOptions, contextFile, moduleResolverHost, { + importModuleSpecifierPreference: isBundle_1 ? "non-relative" : "project-relative", + importModuleSpecifierEnding: isBundle_1 ? "minimal" + : resolutionMode === ts.ModuleKind.ESNext ? "js" + : undefined, + }, { overrideImportMode: overrideImportMode })); + (_a = links.specifierCache) !== null && _a !== void 0 ? _a : (links.specifierCache = new ts.Map()); + links.specifierCache.set(cacheKey, specifier); + } + return specifier; + function getSpecifierCacheKey(path, mode) { + return mode === undefined ? path : "".concat(mode, "|").concat(path); + } + } + function symbolToEntityNameNode(symbol) { + var identifier = ts.factory.createIdentifier(ts.unescapeLeadingUnderscores(symbol.escapedName)); + return symbol.parent ? ts.factory.createQualifiedName(symbolToEntityNameNode(symbol.parent), identifier) : identifier; + } + function symbolToTypeNode(symbol, context, meaning, overrideTypeArguments) { + var _a, _b, _c, _d; + var chain = lookupSymbolChain(symbol, context, meaning, !(context.flags & 16384 /* NodeBuilderFlags.UseAliasDefinedOutsideCurrentScope */)); // If we're using aliases outside the current scope, dont bother with the module + var isTypeOf = meaning === 111551 /* SymbolFlags.Value */; + if (ts.some(chain[0].declarations, hasNonGlobalAugmentationExternalModuleSymbol)) { + // module is root, must use `ImportTypeNode` + var nonRootParts = chain.length > 1 ? createAccessFromSymbolChain(chain, chain.length - 1, 1) : undefined; + var typeParameterNodes = overrideTypeArguments || lookupTypeParameterNodes(chain, 0, context); + var contextFile = ts.getSourceFileOfNode(ts.getOriginalNode(context.enclosingDeclaration)); + var targetFile = ts.getSourceFileOfModule(chain[0]); + var specifier = void 0; + var assertion = void 0; + if (ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.Node16 || ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeNext) { + // An `import` type directed at an esm format file is only going to resolve in esm mode - set the esm mode assertion + if ((targetFile === null || targetFile === void 0 ? void 0 : targetFile.impliedNodeFormat) === ts.ModuleKind.ESNext && targetFile.impliedNodeFormat !== (contextFile === null || contextFile === void 0 ? void 0 : contextFile.impliedNodeFormat)) { + specifier = getSpecifierForModuleSymbol(chain[0], context, ts.ModuleKind.ESNext); + assertion = ts.factory.createImportTypeAssertionContainer(ts.factory.createAssertClause(ts.factory.createNodeArray([ + ts.factory.createAssertEntry(ts.factory.createStringLiteral("resolution-mode"), ts.factory.createStringLiteral("import")) + ]))); + (_b = (_a = context.tracker).reportImportTypeNodeResolutionModeOverride) === null || _b === void 0 ? void 0 : _b.call(_a); + } + } + if (!specifier) { + specifier = getSpecifierForModuleSymbol(chain[0], context); + } + if (!(context.flags & 67108864 /* NodeBuilderFlags.AllowNodeModulesRelativePaths */) && ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.Classic && specifier.indexOf("/node_modules/") >= 0) { + var oldSpecifier = specifier; + if (ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.Node16 || ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeNext) { + // We might be able to write a portable import type using a mode override; try specifier generation again, but with a different mode set + var swappedMode = (contextFile === null || contextFile === void 0 ? void 0 : contextFile.impliedNodeFormat) === ts.ModuleKind.ESNext ? ts.ModuleKind.CommonJS : ts.ModuleKind.ESNext; + specifier = getSpecifierForModuleSymbol(chain[0], context, swappedMode); + if (specifier.indexOf("/node_modules/") >= 0) { + // Still unreachable :( + specifier = oldSpecifier; + } + else { + assertion = ts.factory.createImportTypeAssertionContainer(ts.factory.createAssertClause(ts.factory.createNodeArray([ + ts.factory.createAssertEntry(ts.factory.createStringLiteral("resolution-mode"), ts.factory.createStringLiteral(swappedMode === ts.ModuleKind.ESNext ? "import" : "require")) + ]))); + (_d = (_c = context.tracker).reportImportTypeNodeResolutionModeOverride) === null || _d === void 0 ? void 0 : _d.call(_c); + } + } + if (!assertion) { + // If ultimately we can only name the symbol with a reference that dives into a `node_modules` folder, we should error + // since declaration files with these kinds of references are liable to fail when published :( + context.encounteredError = true; + if (context.tracker.reportLikelyUnsafeImportRequiredError) { + context.tracker.reportLikelyUnsafeImportRequiredError(oldSpecifier); + } + } + } + var lit = ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(specifier)); + if (context.tracker.trackExternalModuleSymbolOfImportTypeNode) + context.tracker.trackExternalModuleSymbolOfImportTypeNode(chain[0]); + context.approximateLength += specifier.length + 10; // specifier + import("") + if (!nonRootParts || ts.isEntityName(nonRootParts)) { + if (nonRootParts) { + var lastId = ts.isIdentifier(nonRootParts) ? nonRootParts : nonRootParts.right; + lastId.typeArguments = undefined; + } + return ts.factory.createImportTypeNode(lit, assertion, nonRootParts, typeParameterNodes, isTypeOf); + } + else { + var splitNode = getTopmostIndexedAccessType(nonRootParts); + var qualifier = splitNode.objectType.typeName; + return ts.factory.createIndexedAccessTypeNode(ts.factory.createImportTypeNode(lit, assertion, qualifier, typeParameterNodes, isTypeOf), splitNode.indexType); + } + } + var entityName = createAccessFromSymbolChain(chain, chain.length - 1, 0); + if (ts.isIndexedAccessTypeNode(entityName)) { + return entityName; // Indexed accesses can never be `typeof` + } + if (isTypeOf) { + return ts.factory.createTypeQueryNode(entityName); + } + else { + var lastId = ts.isIdentifier(entityName) ? entityName : entityName.right; + var lastTypeArgs = lastId.typeArguments; + lastId.typeArguments = undefined; + return ts.factory.createTypeReferenceNode(entityName, lastTypeArgs); + } + function createAccessFromSymbolChain(chain, index, stopper) { + var typeParameterNodes = index === (chain.length - 1) ? overrideTypeArguments : lookupTypeParameterNodes(chain, index, context); + var symbol = chain[index]; + var parent = chain[index - 1]; + var symbolName; + if (index === 0) { + context.flags |= 16777216 /* NodeBuilderFlags.InInitialEntityName */; + symbolName = getNameOfSymbolAsWritten(symbol, context); + context.approximateLength += (symbolName ? symbolName.length : 0) + 1; + context.flags ^= 16777216 /* NodeBuilderFlags.InInitialEntityName */; + } + else { + if (parent && getExportsOfSymbol(parent)) { + var exports_2 = getExportsOfSymbol(parent); + ts.forEachEntry(exports_2, function (ex, name) { + if (getSymbolIfSameReference(ex, symbol) && !isLateBoundName(name) && name !== "export=" /* InternalSymbolName.ExportEquals */) { + symbolName = ts.unescapeLeadingUnderscores(name); + return true; + } + }); + } + } + if (symbolName === undefined) { + var name = ts.firstDefined(symbol.declarations, ts.getNameOfDeclaration); + if (name && ts.isComputedPropertyName(name) && ts.isEntityName(name.expression)) { + var LHS = createAccessFromSymbolChain(chain, index - 1, stopper); + if (ts.isEntityName(LHS)) { + return ts.factory.createIndexedAccessTypeNode(ts.factory.createParenthesizedType(ts.factory.createTypeQueryNode(LHS)), ts.factory.createTypeQueryNode(name.expression)); + } + return LHS; + } + symbolName = getNameOfSymbolAsWritten(symbol, context); + } + context.approximateLength += symbolName.length + 1; + if (!(context.flags & 16 /* NodeBuilderFlags.ForbidIndexedAccessSymbolReferences */) && parent && + getMembersOfSymbol(parent) && getMembersOfSymbol(parent).get(symbol.escapedName) && + getSymbolIfSameReference(getMembersOfSymbol(parent).get(symbol.escapedName), symbol)) { + // Should use an indexed access + var LHS = createAccessFromSymbolChain(chain, index - 1, stopper); + if (ts.isIndexedAccessTypeNode(LHS)) { + return ts.factory.createIndexedAccessTypeNode(LHS, ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(symbolName))); + } + else { + return ts.factory.createIndexedAccessTypeNode(ts.factory.createTypeReferenceNode(LHS, typeParameterNodes), ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(symbolName))); + } + } + var identifier = ts.setEmitFlags(ts.factory.createIdentifier(symbolName, typeParameterNodes), 16777216 /* EmitFlags.NoAsciiEscaping */); + identifier.symbol = symbol; + if (index > stopper) { + var LHS = createAccessFromSymbolChain(chain, index - 1, stopper); + if (!ts.isEntityName(LHS)) { + return ts.Debug.fail("Impossible construct - an export of an indexed access cannot be reachable"); + } + return ts.factory.createQualifiedName(LHS, identifier); + } + return identifier; + } + } + function typeParameterShadowsNameInScope(escapedName, context, type) { + var result = resolveName(context.enclosingDeclaration, escapedName, 788968 /* SymbolFlags.Type */, /*nameNotFoundArg*/ undefined, escapedName, /*isUse*/ false); + if (result) { + if (result.flags & 262144 /* SymbolFlags.TypeParameter */ && result === type.symbol) { + return false; + } + return true; + } + return false; + } + function typeParameterToName(type, context) { + var _a, _b; + if (context.flags & 4 /* NodeBuilderFlags.GenerateNamesForShadowedTypeParams */ && context.typeParameterNames) { + var cached = context.typeParameterNames.get(getTypeId(type)); + if (cached) { + return cached; + } + } + var result = symbolToName(type.symbol, context, 788968 /* SymbolFlags.Type */, /*expectsIdentifier*/ true); + if (!(result.kind & 79 /* SyntaxKind.Identifier */)) { + return ts.factory.createIdentifier("(Missing type parameter)"); + } + if (context.flags & 4 /* NodeBuilderFlags.GenerateNamesForShadowedTypeParams */) { + var rawtext = result.escapedText; + var i = ((_a = context.typeParameterNamesByTextNextNameCount) === null || _a === void 0 ? void 0 : _a.get(rawtext)) || 0; + var text = rawtext; + while (((_b = context.typeParameterNamesByText) === null || _b === void 0 ? void 0 : _b.has(text)) || typeParameterShadowsNameInScope(text, context, type)) { + i++; + text = "".concat(rawtext, "_").concat(i); + } + if (text !== rawtext) { + result = ts.factory.createIdentifier(text, result.typeArguments); + } + // avoiding iterations of the above loop turns out to be worth it when `i` starts to get large, so we cache the max + // `i` we've used thus far, to save work later + (context.typeParameterNamesByTextNextNameCount || (context.typeParameterNamesByTextNextNameCount = new ts.Map())).set(rawtext, i); + (context.typeParameterNames || (context.typeParameterNames = new ts.Map())).set(getTypeId(type), result); + (context.typeParameterNamesByText || (context.typeParameterNamesByText = new ts.Set())).add(rawtext); + } + return result; + } + function symbolToName(symbol, context, meaning, expectsIdentifier) { + var chain = lookupSymbolChain(symbol, context, meaning); + if (expectsIdentifier && chain.length !== 1 + && !context.encounteredError + && !(context.flags & 65536 /* NodeBuilderFlags.AllowQualifiedNameInPlaceOfIdentifier */)) { + context.encounteredError = true; + } + return createEntityNameFromSymbolChain(chain, chain.length - 1); + function createEntityNameFromSymbolChain(chain, index) { + var typeParameterNodes = lookupTypeParameterNodes(chain, index, context); + var symbol = chain[index]; + if (index === 0) { + context.flags |= 16777216 /* NodeBuilderFlags.InInitialEntityName */; + } + var symbolName = getNameOfSymbolAsWritten(symbol, context); + if (index === 0) { + context.flags ^= 16777216 /* NodeBuilderFlags.InInitialEntityName */; + } + var identifier = ts.setEmitFlags(ts.factory.createIdentifier(symbolName, typeParameterNodes), 16777216 /* EmitFlags.NoAsciiEscaping */); + identifier.symbol = symbol; + return index > 0 ? ts.factory.createQualifiedName(createEntityNameFromSymbolChain(chain, index - 1), identifier) : identifier; + } + } + function symbolToExpression(symbol, context, meaning) { + var chain = lookupSymbolChain(symbol, context, meaning); + return createExpressionFromSymbolChain(chain, chain.length - 1); + function createExpressionFromSymbolChain(chain, index) { + var typeParameterNodes = lookupTypeParameterNodes(chain, index, context); + var symbol = chain[index]; + if (index === 0) { + context.flags |= 16777216 /* NodeBuilderFlags.InInitialEntityName */; + } + var symbolName = getNameOfSymbolAsWritten(symbol, context); + if (index === 0) { + context.flags ^= 16777216 /* NodeBuilderFlags.InInitialEntityName */; + } + var firstChar = symbolName.charCodeAt(0); + if (ts.isSingleOrDoubleQuote(firstChar) && ts.some(symbol.declarations, hasNonGlobalAugmentationExternalModuleSymbol)) { + return ts.factory.createStringLiteral(getSpecifierForModuleSymbol(symbol, context)); + } + var canUsePropertyAccess = firstChar === 35 /* CharacterCodes.hash */ ? + symbolName.length > 1 && ts.isIdentifierStart(symbolName.charCodeAt(1), languageVersion) : + ts.isIdentifierStart(firstChar, languageVersion); + if (index === 0 || canUsePropertyAccess) { + var identifier = ts.setEmitFlags(ts.factory.createIdentifier(symbolName, typeParameterNodes), 16777216 /* EmitFlags.NoAsciiEscaping */); + identifier.symbol = symbol; + return index > 0 ? ts.factory.createPropertyAccessExpression(createExpressionFromSymbolChain(chain, index - 1), identifier) : identifier; + } + else { + if (firstChar === 91 /* CharacterCodes.openBracket */) { + symbolName = symbolName.substring(1, symbolName.length - 1); + firstChar = symbolName.charCodeAt(0); + } + var expression = void 0; + if (ts.isSingleOrDoubleQuote(firstChar) && !(symbol.flags & 8 /* SymbolFlags.EnumMember */)) { + expression = ts.factory.createStringLiteral(ts.stripQuotes(symbolName).replace(/\\./g, function (s) { return s.substring(1); }), firstChar === 39 /* CharacterCodes.singleQuote */); + } + else if (("" + +symbolName) === symbolName) { + expression = ts.factory.createNumericLiteral(+symbolName); + } + if (!expression) { + expression = ts.setEmitFlags(ts.factory.createIdentifier(symbolName, typeParameterNodes), 16777216 /* EmitFlags.NoAsciiEscaping */); + expression.symbol = symbol; + } + return ts.factory.createElementAccessExpression(createExpressionFromSymbolChain(chain, index - 1), expression); + } + } + } + function isStringNamed(d) { + var name = ts.getNameOfDeclaration(d); + return !!name && ts.isStringLiteral(name); + } + function isSingleQuotedStringNamed(d) { + var name = ts.getNameOfDeclaration(d); + return !!(name && ts.isStringLiteral(name) && (name.singleQuote || !ts.nodeIsSynthesized(name) && ts.startsWith(ts.getTextOfNode(name, /*includeTrivia*/ false), "'"))); + } + function getPropertyNameNodeForSymbol(symbol, context) { + var singleQuote = !!ts.length(symbol.declarations) && ts.every(symbol.declarations, isSingleQuotedStringNamed); + var fromNameType = getPropertyNameNodeForSymbolFromNameType(symbol, context, singleQuote); + if (fromNameType) { + return fromNameType; + } + var rawName = ts.unescapeLeadingUnderscores(symbol.escapedName); + var stringNamed = !!ts.length(symbol.declarations) && ts.every(symbol.declarations, isStringNamed); + return ts.createPropertyNameNodeForIdentifierOrLiteral(rawName, ts.getEmitScriptTarget(compilerOptions), singleQuote, stringNamed); + } + // See getNameForSymbolFromNameType for a stringy equivalent + function getPropertyNameNodeForSymbolFromNameType(symbol, context, singleQuote) { + var nameType = getSymbolLinks(symbol).nameType; + if (nameType) { + if (nameType.flags & 384 /* TypeFlags.StringOrNumberLiteral */) { + var name = "" + nameType.value; + if (!ts.isIdentifierText(name, ts.getEmitScriptTarget(compilerOptions)) && !ts.isNumericLiteralName(name)) { + return ts.factory.createStringLiteral(name, !!singleQuote); + } + if (ts.isNumericLiteralName(name) && ts.startsWith(name, "-")) { + return ts.factory.createComputedPropertyName(ts.factory.createNumericLiteral(+name)); + } + return ts.createPropertyNameNodeForIdentifierOrLiteral(name, ts.getEmitScriptTarget(compilerOptions)); + } + if (nameType.flags & 8192 /* TypeFlags.UniqueESSymbol */) { + return ts.factory.createComputedPropertyName(symbolToExpression(nameType.symbol, context, 111551 /* SymbolFlags.Value */)); + } + } + } + function cloneNodeBuilderContext(context) { + var initial = __assign({}, context); + // Make type parameters created within this context not consume the name outside this context + // The symbol serializer ends up creating many sibling scopes that all need "separate" contexts when + // it comes to naming things - within a normal `typeToTypeNode` call, the node builder only ever descends + // through the type tree, so the only cases where we could have used distinct sibling scopes was when there + // were multiple generic overloads with similar generated type parameter names + // The effect: + // When we write out + // export const x: (x: T) => T + // export const y: (x: T) => T + // we write it out like that, rather than as + // export const x: (x: T) => T + // export const y: (x: T_1) => T_1 + if (initial.typeParameterNames) { + initial.typeParameterNames = new ts.Map(initial.typeParameterNames); + } + if (initial.typeParameterNamesByText) { + initial.typeParameterNamesByText = new ts.Set(initial.typeParameterNamesByText); + } + if (initial.typeParameterSymbolList) { + initial.typeParameterSymbolList = new ts.Set(initial.typeParameterSymbolList); + } + initial.tracker = wrapSymbolTrackerToReportForContext(initial, initial.tracker); + return initial; + } + function getDeclarationWithTypeAnnotation(symbol, enclosingDeclaration) { + return symbol.declarations && ts.find(symbol.declarations, function (s) { return !!ts.getEffectiveTypeAnnotationNode(s) && (!enclosingDeclaration || !!ts.findAncestor(s, function (n) { return n === enclosingDeclaration; })); }); + } + function existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type) { + return !(ts.getObjectFlags(type) & 4 /* ObjectFlags.Reference */) || !ts.isTypeReferenceNode(existing) || ts.length(existing.typeArguments) >= getMinTypeArgumentCount(type.target.typeParameters); + } + /** + * Unlike `typeToTypeNodeHelper`, this handles setting up the `AllowUniqueESSymbolType` flag + * so a `unique symbol` is returned when appropriate for the input symbol, rather than `typeof sym` + */ + function serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled) { + if (!isErrorType(type) && enclosingDeclaration) { + var declWithExistingAnnotation = getDeclarationWithTypeAnnotation(symbol, enclosingDeclaration); + if (declWithExistingAnnotation && !ts.isFunctionLikeDeclaration(declWithExistingAnnotation) && !ts.isGetAccessorDeclaration(declWithExistingAnnotation)) { + // try to reuse the existing annotation + var existing = ts.getEffectiveTypeAnnotationNode(declWithExistingAnnotation); + if (typeNodeIsEquivalentToType(existing, declWithExistingAnnotation, type) && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(existing, type)) { + var result_6 = serializeExistingTypeNode(context, existing, includePrivateSymbol, bundled); + if (result_6) { + return result_6; + } + } + } + } + var oldFlags = context.flags; + if (type.flags & 8192 /* TypeFlags.UniqueESSymbol */ && + type.symbol === symbol && (!context.enclosingDeclaration || ts.some(symbol.declarations, function (d) { return ts.getSourceFileOfNode(d) === ts.getSourceFileOfNode(context.enclosingDeclaration); }))) { + context.flags |= 1048576 /* NodeBuilderFlags.AllowUniqueESSymbolType */; + } + var result = typeToTypeNodeHelper(type, context); + context.flags = oldFlags; + return result; + } + function typeNodeIsEquivalentToType(typeNode, annotatedDeclaration, type) { + var typeFromTypeNode = getTypeFromTypeNode(typeNode); + if (typeFromTypeNode === type) { + return true; + } + if (ts.isParameter(annotatedDeclaration) && annotatedDeclaration.questionToken) { + return getTypeWithFacts(type, 524288 /* TypeFacts.NEUndefined */) === typeFromTypeNode; + } + return false; + } + function serializeReturnTypeForSignature(context, type, signature, includePrivateSymbol, bundled) { + if (!isErrorType(type) && context.enclosingDeclaration) { + var annotation = signature.declaration && ts.getEffectiveReturnTypeNode(signature.declaration); + if (!!ts.findAncestor(annotation, function (n) { return n === context.enclosingDeclaration; }) && annotation) { + var annotated = getTypeFromTypeNode(annotation); + var thisInstantiated = annotated.flags & 262144 /* TypeFlags.TypeParameter */ && annotated.isThisType ? instantiateType(annotated, signature.mapper) : annotated; + if (thisInstantiated === type && existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(annotation, type)) { + var result = serializeExistingTypeNode(context, annotation, includePrivateSymbol, bundled); + if (result) { + return result; + } + } + } + } + return typeToTypeNodeHelper(type, context); + } + function trackExistingEntityName(node, context, includePrivateSymbol) { + var _a, _b; + var introducesError = false; + var leftmost = ts.getFirstIdentifier(node); + if (ts.isInJSFile(node) && (ts.isExportsIdentifier(leftmost) || ts.isModuleExportsAccessExpression(leftmost.parent) || (ts.isQualifiedName(leftmost.parent) && ts.isModuleIdentifier(leftmost.parent.left) && ts.isExportsIdentifier(leftmost.parent.right)))) { + introducesError = true; + return { introducesError: introducesError, node: node }; + } + var sym = resolveEntityName(leftmost, 67108863 /* SymbolFlags.All */, /*ignoreErrors*/ true, /*dontResolveALias*/ true); + if (sym) { + if (isSymbolAccessible(sym, context.enclosingDeclaration, 67108863 /* SymbolFlags.All */, /*shouldComputeAliasesToMakeVisible*/ false).accessibility !== 0 /* SymbolAccessibility.Accessible */) { + introducesError = true; + } + else { + (_b = (_a = context.tracker) === null || _a === void 0 ? void 0 : _a.trackSymbol) === null || _b === void 0 ? void 0 : _b.call(_a, sym, context.enclosingDeclaration, 67108863 /* SymbolFlags.All */); + includePrivateSymbol === null || includePrivateSymbol === void 0 ? void 0 : includePrivateSymbol(sym); + } + if (ts.isIdentifier(node)) { + var type = getDeclaredTypeOfSymbol(sym); + var name = sym.flags & 262144 /* SymbolFlags.TypeParameter */ && !isTypeSymbolAccessible(type.symbol, context.enclosingDeclaration) ? typeParameterToName(type, context) : ts.factory.cloneNode(node); + name.symbol = sym; // for quickinfo, which uses identifier symbol information + return { introducesError: introducesError, node: ts.setEmitFlags(ts.setOriginalNode(name, node), 16777216 /* EmitFlags.NoAsciiEscaping */) }; + } + } + return { introducesError: introducesError, node: node }; + } + function serializeExistingTypeNode(context, existing, includePrivateSymbol, bundled) { + if (cancellationToken && cancellationToken.throwIfCancellationRequested) { + cancellationToken.throwIfCancellationRequested(); + } + var hadError = false; + var file = ts.getSourceFileOfNode(existing); + var transformed = ts.visitNode(existing, visitExistingNodeTreeSymbols); + if (hadError) { + return undefined; + } + return transformed === existing ? ts.setTextRange(ts.factory.cloneNode(existing), existing) : transformed; + function visitExistingNodeTreeSymbols(node) { + // We don't _actually_ support jsdoc namepath types, emit `any` instead + if (ts.isJSDocAllType(node) || node.kind === 322 /* SyntaxKind.JSDocNamepathType */) { + return ts.factory.createKeywordTypeNode(131 /* SyntaxKind.AnyKeyword */); + } + if (ts.isJSDocUnknownType(node)) { + return ts.factory.createKeywordTypeNode(157 /* SyntaxKind.UnknownKeyword */); + } + if (ts.isJSDocNullableType(node)) { + return ts.factory.createUnionTypeNode([ts.visitNode(node.type, visitExistingNodeTreeSymbols), ts.factory.createLiteralTypeNode(ts.factory.createNull())]); + } + if (ts.isJSDocOptionalType(node)) { + return ts.factory.createUnionTypeNode([ts.visitNode(node.type, visitExistingNodeTreeSymbols), ts.factory.createKeywordTypeNode(155 /* SyntaxKind.UndefinedKeyword */)]); + } + if (ts.isJSDocNonNullableType(node)) { + return ts.visitNode(node.type, visitExistingNodeTreeSymbols); + } + if (ts.isJSDocVariadicType(node)) { + return ts.factory.createArrayTypeNode(ts.visitNode(node.type, visitExistingNodeTreeSymbols)); + } + if (ts.isJSDocTypeLiteral(node)) { + return ts.factory.createTypeLiteralNode(ts.map(node.jsDocPropertyTags, function (t) { + var name = ts.isIdentifier(t.name) ? t.name : t.name.right; + var typeViaParent = getTypeOfPropertyOfType(getTypeFromTypeNode(node), name.escapedText); + var overrideTypeNode = typeViaParent && t.typeExpression && getTypeFromTypeNode(t.typeExpression.type) !== typeViaParent ? typeToTypeNodeHelper(typeViaParent, context) : undefined; + return ts.factory.createPropertySignature( + /*modifiers*/ undefined, name, t.isBracketed || t.typeExpression && ts.isJSDocOptionalType(t.typeExpression.type) ? ts.factory.createToken(57 /* SyntaxKind.QuestionToken */) : undefined, overrideTypeNode || (t.typeExpression && ts.visitNode(t.typeExpression.type, visitExistingNodeTreeSymbols)) || ts.factory.createKeywordTypeNode(131 /* SyntaxKind.AnyKeyword */)); + })); + } + if (ts.isTypeReferenceNode(node) && ts.isIdentifier(node.typeName) && node.typeName.escapedText === "") { + return ts.setOriginalNode(ts.factory.createKeywordTypeNode(131 /* SyntaxKind.AnyKeyword */), node); + } + if ((ts.isExpressionWithTypeArguments(node) || ts.isTypeReferenceNode(node)) && ts.isJSDocIndexSignature(node)) { + return ts.factory.createTypeLiteralNode([ts.factory.createIndexSignature( + /*modifiers*/ undefined, [ts.factory.createParameterDeclaration( + /*modifiers*/ undefined, + /*dotdotdotToken*/ undefined, "x", + /*questionToken*/ undefined, ts.visitNode(node.typeArguments[0], visitExistingNodeTreeSymbols))], ts.visitNode(node.typeArguments[1], visitExistingNodeTreeSymbols))]); + } + if (ts.isJSDocFunctionType(node)) { + if (ts.isJSDocConstructSignature(node)) { + var newTypeNode_1; + return ts.factory.createConstructorTypeNode( + /*modifiers*/ undefined, ts.visitNodes(node.typeParameters, visitExistingNodeTreeSymbols), ts.mapDefined(node.parameters, function (p, i) { return p.name && ts.isIdentifier(p.name) && p.name.escapedText === "new" ? (newTypeNode_1 = p.type, undefined) : ts.factory.createParameterDeclaration( + /*modifiers*/ undefined, getEffectiveDotDotDotForParameter(p), getNameForJSDocFunctionParameter(p, i), p.questionToken, ts.visitNode(p.type, visitExistingNodeTreeSymbols), + /*initializer*/ undefined); }), ts.visitNode(newTypeNode_1 || node.type, visitExistingNodeTreeSymbols) || ts.factory.createKeywordTypeNode(131 /* SyntaxKind.AnyKeyword */)); + } + else { + return ts.factory.createFunctionTypeNode(ts.visitNodes(node.typeParameters, visitExistingNodeTreeSymbols), ts.map(node.parameters, function (p, i) { return ts.factory.createParameterDeclaration( + /*modifiers*/ undefined, getEffectiveDotDotDotForParameter(p), getNameForJSDocFunctionParameter(p, i), p.questionToken, ts.visitNode(p.type, visitExistingNodeTreeSymbols), + /*initializer*/ undefined); }), ts.visitNode(node.type, visitExistingNodeTreeSymbols) || ts.factory.createKeywordTypeNode(131 /* SyntaxKind.AnyKeyword */)); + } + } + if (ts.isTypeReferenceNode(node) && ts.isInJSDoc(node) && (!existingTypeNodeIsNotReferenceOrIsReferenceWithCompatibleTypeArgumentCount(node, getTypeFromTypeNode(node)) || getIntendedTypeFromJSDocTypeReference(node) || unknownSymbol === resolveTypeReferenceName(node, 788968 /* SymbolFlags.Type */, /*ignoreErrors*/ true))) { + return ts.setOriginalNode(typeToTypeNodeHelper(getTypeFromTypeNode(node), context), node); + } + if (ts.isLiteralImportTypeNode(node)) { + var nodeSymbol = getNodeLinks(node).resolvedSymbol; + if (ts.isInJSDoc(node) && + nodeSymbol && + ( + // The import type resolved using jsdoc fallback logic + (!node.isTypeOf && !(nodeSymbol.flags & 788968 /* SymbolFlags.Type */)) || + // The import type had type arguments autofilled by js fallback logic + !(ts.length(node.typeArguments) >= getMinTypeArgumentCount(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(nodeSymbol))))) { + return ts.setOriginalNode(typeToTypeNodeHelper(getTypeFromTypeNode(node), context), node); + } + return ts.factory.updateImportTypeNode(node, ts.factory.updateLiteralTypeNode(node.argument, rewriteModuleSpecifier(node, node.argument.literal)), node.assertions, node.qualifier, ts.visitNodes(node.typeArguments, visitExistingNodeTreeSymbols, ts.isTypeNode), node.isTypeOf); + } + if (ts.isEntityName(node) || ts.isEntityNameExpression(node)) { + var _a = trackExistingEntityName(node, context, includePrivateSymbol), introducesError = _a.introducesError, result = _a.node; + hadError = hadError || introducesError; + if (result !== node) { + return result; + } + } + if (file && ts.isTupleTypeNode(node) && (ts.getLineAndCharacterOfPosition(file, node.pos).line === ts.getLineAndCharacterOfPosition(file, node.end).line)) { + ts.setEmitFlags(node, 1 /* EmitFlags.SingleLine */); + } + return ts.visitEachChild(node, visitExistingNodeTreeSymbols, ts.nullTransformationContext); + function getEffectiveDotDotDotForParameter(p) { + return p.dotDotDotToken || (p.type && ts.isJSDocVariadicType(p.type) ? ts.factory.createToken(25 /* SyntaxKind.DotDotDotToken */) : undefined); + } + /** Note that `new:T` parameters are not handled, but should be before calling this function. */ + function getNameForJSDocFunctionParameter(p, index) { + return p.name && ts.isIdentifier(p.name) && p.name.escapedText === "this" ? "this" + : getEffectiveDotDotDotForParameter(p) ? "args" + : "arg".concat(index); + } + function rewriteModuleSpecifier(parent, lit) { + if (bundled) { + if (context.tracker && context.tracker.moduleResolverHost) { + var targetFile = getExternalModuleFileFromDeclaration(parent); + if (targetFile) { + var getCanonicalFileName = ts.createGetCanonicalFileName(!!host.useCaseSensitiveFileNames); + var resolverHost = { + getCanonicalFileName: getCanonicalFileName, + getCurrentDirectory: function () { return context.tracker.moduleResolverHost.getCurrentDirectory(); }, + getCommonSourceDirectory: function () { return context.tracker.moduleResolverHost.getCommonSourceDirectory(); } + }; + var newName = ts.getResolvedExternalModuleName(resolverHost, targetFile); + return ts.factory.createStringLiteral(newName); + } + } + } + else { + if (context.tracker && context.tracker.trackExternalModuleSymbolOfImportTypeNode) { + var moduleSym = resolveExternalModuleNameWorker(lit, lit, /*moduleNotFoundError*/ undefined); + if (moduleSym) { + context.tracker.trackExternalModuleSymbolOfImportTypeNode(moduleSym); + } + } + } + return lit; + } + } + } + function symbolTableToDeclarationStatements(symbolTable, context, bundled) { + var serializePropertySymbolForClass = makeSerializePropertySymbol(ts.factory.createPropertyDeclaration, 171 /* SyntaxKind.MethodDeclaration */, /*useAcessors*/ true); + var serializePropertySymbolForInterfaceWorker = makeSerializePropertySymbol(function (mods, name, question, type) { return ts.factory.createPropertySignature(mods, name, question, type); }, 170 /* SyntaxKind.MethodSignature */, /*useAcessors*/ false); + // TODO: Use `setOriginalNode` on original declaration names where possible so these declarations see some kind of + // declaration mapping + // We save the enclosing declaration off here so it's not adjusted by well-meaning declaration + // emit codepaths which want to apply more specific contexts (so we can still refer to the root real declaration + // we're trying to emit from later on) + var enclosingDeclaration = context.enclosingDeclaration; + var results = []; + var visitedSymbols = new ts.Set(); + var deferredPrivatesStack = []; + var oldcontext = context; + context = __assign(__assign({}, oldcontext), { usedSymbolNames: new ts.Set(oldcontext.usedSymbolNames), remappedSymbolNames: new ts.Map(), tracker: __assign(__assign({}, oldcontext.tracker), { trackSymbol: function (sym, decl, meaning) { + var accessibleResult = isSymbolAccessible(sym, decl, meaning, /*computeAliases*/ false); + if (accessibleResult.accessibility === 0 /* SymbolAccessibility.Accessible */) { + // Lookup the root symbol of the chain of refs we'll use to access it and serialize it + var chain = lookupSymbolChainWorker(sym, context, meaning); + if (!(sym.flags & 4 /* SymbolFlags.Property */)) { + includePrivateSymbol(chain[0]); + } + } + else if (oldcontext.tracker && oldcontext.tracker.trackSymbol) { + return oldcontext.tracker.trackSymbol(sym, decl, meaning); + } + return false; + } }) }); + context.tracker = wrapSymbolTrackerToReportForContext(context, context.tracker); + ts.forEachEntry(symbolTable, function (symbol, name) { + var baseName = ts.unescapeLeadingUnderscores(name); + void getInternalSymbolName(symbol, baseName); // Called to cache values into `usedSymbolNames` and `remappedSymbolNames` + }); + var addingDeclare = !bundled; + var exportEquals = symbolTable.get("export=" /* InternalSymbolName.ExportEquals */); + if (exportEquals && symbolTable.size > 1 && exportEquals.flags & 2097152 /* SymbolFlags.Alias */) { + symbolTable = ts.createSymbolTable(); + // Remove extraneous elements from root symbol table (they'll be mixed back in when the target of the `export=` is looked up) + symbolTable.set("export=" /* InternalSymbolName.ExportEquals */, exportEquals); + } + visitSymbolTable(symbolTable); + return mergeRedundantStatements(results); + function isIdentifierAndNotUndefined(node) { + return !!node && node.kind === 79 /* SyntaxKind.Identifier */; + } + function getNamesOfDeclaration(statement) { + if (ts.isVariableStatement(statement)) { + return ts.filter(ts.map(statement.declarationList.declarations, ts.getNameOfDeclaration), isIdentifierAndNotUndefined); + } + return ts.filter([ts.getNameOfDeclaration(statement)], isIdentifierAndNotUndefined); + } + function flattenExportAssignedNamespace(statements) { + var exportAssignment = ts.find(statements, ts.isExportAssignment); + var nsIndex = ts.findIndex(statements, ts.isModuleDeclaration); + var ns = nsIndex !== -1 ? statements[nsIndex] : undefined; + if (ns && exportAssignment && exportAssignment.isExportEquals && + ts.isIdentifier(exportAssignment.expression) && ts.isIdentifier(ns.name) && ts.idText(ns.name) === ts.idText(exportAssignment.expression) && + ns.body && ts.isModuleBlock(ns.body)) { + // Pass 0: Correct situations where a module has both an `export = ns` and multiple top-level exports by stripping the export modifiers from + // the top-level exports and exporting them in the targeted ns, as can occur when a js file has both typedefs and `module.export` assignments + var excessExports = ts.filter(statements, function (s) { return !!(ts.getEffectiveModifierFlags(s) & 1 /* ModifierFlags.Export */); }); + var name_3 = ns.name; + var body = ns.body; + if (ts.length(excessExports)) { + ns = ts.factory.updateModuleDeclaration(ns, ns.modifiers, ns.name, body = ts.factory.updateModuleBlock(body, ts.factory.createNodeArray(__spreadArray(__spreadArray([], ns.body.statements, true), [ts.factory.createExportDeclaration( + /*modifiers*/ undefined, + /*isTypeOnly*/ false, ts.factory.createNamedExports(ts.map(ts.flatMap(excessExports, function (e) { return getNamesOfDeclaration(e); }), function (id) { return ts.factory.createExportSpecifier(/*isTypeOnly*/ false, /*alias*/ undefined, id); })), + /*moduleSpecifier*/ undefined)], false)))); + statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, nsIndex), true), [ns], false), statements.slice(nsIndex + 1), true); + } + // Pass 1: Flatten `export namespace _exports {} export = _exports;` so long as the `export=` only points at a single namespace declaration + if (!ts.find(statements, function (s) { return s !== ns && ts.nodeHasName(s, name_3); })) { + results = []; + // If the namespace contains no export assignments or declarations, and no declarations flagged with `export`, then _everything_ is exported - + // to respect this as the top level, we need to add an `export` modifier to everything + var mixinExportFlag_1 = !ts.some(body.statements, function (s) { return ts.hasSyntacticModifier(s, 1 /* ModifierFlags.Export */) || ts.isExportAssignment(s) || ts.isExportDeclaration(s); }); + ts.forEach(body.statements, function (s) { + addResult(s, mixinExportFlag_1 ? 1 /* ModifierFlags.Export */ : 0 /* ModifierFlags.None */); // Recalculates the ambient (and export, if applicable from above) flag + }); + statements = __spreadArray(__spreadArray([], ts.filter(statements, function (s) { return s !== ns && s !== exportAssignment; }), true), results, true); + } + } + return statements; + } + function mergeExportDeclarations(statements) { + // Pass 2: Combine all `export {}` declarations + var exports = ts.filter(statements, function (d) { return ts.isExportDeclaration(d) && !d.moduleSpecifier && !!d.exportClause && ts.isNamedExports(d.exportClause); }); + if (ts.length(exports) > 1) { + var nonExports = ts.filter(statements, function (d) { return !ts.isExportDeclaration(d) || !!d.moduleSpecifier || !d.exportClause; }); + statements = __spreadArray(__spreadArray([], nonExports, true), [ts.factory.createExportDeclaration( + /*modifiers*/ undefined, + /*isTypeOnly*/ false, ts.factory.createNamedExports(ts.flatMap(exports, function (e) { return ts.cast(e.exportClause, ts.isNamedExports).elements; })), + /*moduleSpecifier*/ undefined)], false); + } + // Pass 2b: Also combine all `export {} from "..."` declarations as needed + var reexports = ts.filter(statements, function (d) { return ts.isExportDeclaration(d) && !!d.moduleSpecifier && !!d.exportClause && ts.isNamedExports(d.exportClause); }); + if (ts.length(reexports) > 1) { + var groups = ts.group(reexports, function (decl) { return ts.isStringLiteral(decl.moduleSpecifier) ? ">" + decl.moduleSpecifier.text : ">"; }); + if (groups.length !== reexports.length) { + var _loop_9 = function (group_1) { + if (group_1.length > 1) { + // remove group members from statements and then merge group members and add back to statements + statements = __spreadArray(__spreadArray([], ts.filter(statements, function (s) { return group_1.indexOf(s) === -1; }), true), [ + ts.factory.createExportDeclaration( + /*modifiers*/ undefined, + /*isTypeOnly*/ false, ts.factory.createNamedExports(ts.flatMap(group_1, function (e) { return ts.cast(e.exportClause, ts.isNamedExports).elements; })), group_1[0].moduleSpecifier) + ], false); + } + }; + for (var _i = 0, groups_1 = groups; _i < groups_1.length; _i++) { + var group_1 = groups_1[_i]; + _loop_9(group_1); + } + } + } + return statements; + } + function inlineExportModifiers(statements) { + // Pass 3: Move all `export {}`'s to `export` modifiers where possible + var index = ts.findIndex(statements, function (d) { return ts.isExportDeclaration(d) && !d.moduleSpecifier && !d.assertClause && !!d.exportClause && ts.isNamedExports(d.exportClause); }); + if (index >= 0) { + var exportDecl = statements[index]; + var replacements = ts.mapDefined(exportDecl.exportClause.elements, function (e) { + if (!e.propertyName) { + // export {name} - look thru `statements` for `name`, and if all results can take an `export` modifier, do so and filter it + var indices = ts.indicesOf(statements); + var associatedIndices = ts.filter(indices, function (i) { return ts.nodeHasName(statements[i], e.name); }); + if (ts.length(associatedIndices) && ts.every(associatedIndices, function (i) { return ts.canHaveExportModifier(statements[i]); })) { + for (var _i = 0, associatedIndices_1 = associatedIndices; _i < associatedIndices_1.length; _i++) { + var index_1 = associatedIndices_1[_i]; + statements[index_1] = addExportModifier(statements[index_1]); + } + return undefined; + } + } + return e; + }); + if (!ts.length(replacements)) { + // all clauses removed, remove the export declaration + ts.orderedRemoveItemAt(statements, index); + } + else { + // some items filtered, others not - update the export declaration + statements[index] = ts.factory.updateExportDeclaration(exportDecl, exportDecl.modifiers, exportDecl.isTypeOnly, ts.factory.updateNamedExports(exportDecl.exportClause, replacements), exportDecl.moduleSpecifier, exportDecl.assertClause); + } + } + return statements; + } + function mergeRedundantStatements(statements) { + statements = flattenExportAssignedNamespace(statements); + statements = mergeExportDeclarations(statements); + statements = inlineExportModifiers(statements); + // Not a cleanup, but as a final step: If there is a mix of `export` and non-`export` declarations, but no `export =` or `export {}` add a `export {};` so + // declaration privacy is respected. + if (enclosingDeclaration && + ((ts.isSourceFile(enclosingDeclaration) && ts.isExternalOrCommonJsModule(enclosingDeclaration)) || ts.isModuleDeclaration(enclosingDeclaration)) && + (!ts.some(statements, ts.isExternalModuleIndicator) || (!ts.hasScopeMarker(statements) && ts.some(statements, ts.needsScopeMarker)))) { + statements.push(ts.createEmptyExports(ts.factory)); + } + return statements; + } + function addExportModifier(node) { + var flags = (ts.getEffectiveModifierFlags(node) | 1 /* ModifierFlags.Export */) & ~2 /* ModifierFlags.Ambient */; + return ts.factory.updateModifiers(node, flags); + } + function removeExportModifier(node) { + var flags = ts.getEffectiveModifierFlags(node) & ~1 /* ModifierFlags.Export */; + return ts.factory.updateModifiers(node, flags); + } + function visitSymbolTable(symbolTable, suppressNewPrivateContext, propertyAsAlias) { + if (!suppressNewPrivateContext) { + deferredPrivatesStack.push(new ts.Map()); + } + symbolTable.forEach(function (symbol) { + serializeSymbol(symbol, /*isPrivate*/ false, !!propertyAsAlias); + }); + if (!suppressNewPrivateContext) { + // deferredPrivates will be filled up by visiting the symbol table + // And will continue to iterate as elements are added while visited `deferredPrivates` + // (As that's how a map iterator is defined to work) + deferredPrivatesStack[deferredPrivatesStack.length - 1].forEach(function (symbol) { + serializeSymbol(symbol, /*isPrivate*/ true, !!propertyAsAlias); + }); + deferredPrivatesStack.pop(); + } + } + function serializeSymbol(symbol, isPrivate, propertyAsAlias) { + // cache visited list based on merged symbol, since we want to use the unmerged top-level symbol, but + // still skip reserializing it if we encounter the merged product later on + var visitedSym = getMergedSymbol(symbol); + if (visitedSymbols.has(getSymbolId(visitedSym))) { + return; // Already printed + } + visitedSymbols.add(getSymbolId(visitedSym)); + // Only actually serialize symbols within the correct enclosing declaration, otherwise do nothing with the out-of-context symbol + var skipMembershipCheck = !isPrivate; // We only call this on exported symbols when we know they're in the correct scope + if (skipMembershipCheck || (!!ts.length(symbol.declarations) && ts.some(symbol.declarations, function (d) { return !!ts.findAncestor(d, function (n) { return n === enclosingDeclaration; }); }))) { + var oldContext = context; + context = cloneNodeBuilderContext(context); + serializeSymbolWorker(symbol, isPrivate, propertyAsAlias); + if (context.reportedDiagnostic) { + oldcontext.reportedDiagnostic = context.reportedDiagnostic; // hoist diagnostic result into outer context + } + context = oldContext; + } + } + // Synthesize declarations for a symbol - might be an Interface, a Class, a Namespace, a Type, a Variable (const, let, or var), an Alias + // or a merge of some number of those. + // An interesting challenge is ensuring that when classes merge with namespaces and interfaces, is keeping + // each symbol in only one of the representations + // Also, synthesizing a default export of some kind + // If it's an alias: emit `export default ref` + // If it's a property: emit `export default _default` with a `_default` prop + // If it's a class/interface/function: emit a class/interface/function with a `default` modifier + // These forms can merge, eg (`export default 12; export default interface A {}`) + function serializeSymbolWorker(symbol, isPrivate, propertyAsAlias) { + var _a, _b, _c, _d; + var symbolName = ts.unescapeLeadingUnderscores(symbol.escapedName); + var isDefault = symbol.escapedName === "default" /* InternalSymbolName.Default */; + if (isPrivate && !(context.flags & 131072 /* NodeBuilderFlags.AllowAnonymousIdentifier */) && ts.isStringANonContextualKeyword(symbolName) && !isDefault) { + // Oh no. We cannot use this symbol's name as it's name... It's likely some jsdoc had an invalid name like `export` or `default` :( + context.encounteredError = true; + // TODO: Issue error via symbol tracker? + return; // If we need to emit a private with a keyword name, we're done for, since something else will try to refer to it by that name + } + var needsPostExportDefault = isDefault && !!(symbol.flags & -113 /* SymbolFlags.ExportDoesNotSupportDefaultModifier */ + || (symbol.flags & 16 /* SymbolFlags.Function */ && ts.length(getPropertiesOfType(getTypeOfSymbol(symbol))))) && !(symbol.flags & 2097152 /* SymbolFlags.Alias */); // An alias symbol should preclude needing to make an alias ourselves + var needsExportDeclaration = !needsPostExportDefault && !isPrivate && ts.isStringANonContextualKeyword(symbolName) && !isDefault; + // `serializeVariableOrProperty` will handle adding the export declaration if it is run (since `getInternalSymbolName` will create the name mapping), so we need to ensuer we unset `needsExportDeclaration` if it is + if (needsPostExportDefault || needsExportDeclaration) { + isPrivate = true; + } + var modifierFlags = (!isPrivate ? 1 /* ModifierFlags.Export */ : 0) | (isDefault && !needsPostExportDefault ? 1024 /* ModifierFlags.Default */ : 0); + var isConstMergedWithNS = symbol.flags & 1536 /* SymbolFlags.Module */ && + symbol.flags & (2 /* SymbolFlags.BlockScopedVariable */ | 1 /* SymbolFlags.FunctionScopedVariable */ | 4 /* SymbolFlags.Property */) && + symbol.escapedName !== "export=" /* InternalSymbolName.ExportEquals */; + var isConstMergedWithNSPrintableAsSignatureMerge = isConstMergedWithNS && isTypeRepresentableAsFunctionNamespaceMerge(getTypeOfSymbol(symbol), symbol); + if (symbol.flags & (16 /* SymbolFlags.Function */ | 8192 /* SymbolFlags.Method */) || isConstMergedWithNSPrintableAsSignatureMerge) { + serializeAsFunctionNamespaceMerge(getTypeOfSymbol(symbol), symbol, getInternalSymbolName(symbol, symbolName), modifierFlags); + } + if (symbol.flags & 524288 /* SymbolFlags.TypeAlias */) { + serializeTypeAlias(symbol, symbolName, modifierFlags); + } + // Need to skip over export= symbols below - json source files get a single `Property` flagged + // symbol of name `export=` which needs to be handled like an alias. It's not great, but it is what it is. + if (symbol.flags & (2 /* SymbolFlags.BlockScopedVariable */ | 1 /* SymbolFlags.FunctionScopedVariable */ | 4 /* SymbolFlags.Property */) + && symbol.escapedName !== "export=" /* InternalSymbolName.ExportEquals */ + && !(symbol.flags & 4194304 /* SymbolFlags.Prototype */) + && !(symbol.flags & 32 /* SymbolFlags.Class */) + && !(symbol.flags & 8192 /* SymbolFlags.Method */) + && !isConstMergedWithNSPrintableAsSignatureMerge) { + if (propertyAsAlias) { + var createdExport = serializeMaybeAliasAssignment(symbol); + if (createdExport) { + needsExportDeclaration = false; + needsPostExportDefault = false; + } + } + else { + var type = getTypeOfSymbol(symbol); + var localName = getInternalSymbolName(symbol, symbolName); + if (!(symbol.flags & 16 /* SymbolFlags.Function */) && isTypeRepresentableAsFunctionNamespaceMerge(type, symbol)) { + // If the type looks like a function declaration + ns could represent it, and it's type is sourced locally, rewrite it into a function declaration + ns + serializeAsFunctionNamespaceMerge(type, symbol, localName, modifierFlags); + } + else { + // A Class + Property merge is made for a `module.exports.Member = class {}`, and it doesn't serialize well as either a class _or_ a property symbol - in fact, _it behaves like an alias!_ + // `var` is `FunctionScopedVariable`, `const` and `let` are `BlockScopedVariable`, and `module.exports.thing =` is `Property` + var flags = !(symbol.flags & 2 /* SymbolFlags.BlockScopedVariable */) + ? ((_a = symbol.parent) === null || _a === void 0 ? void 0 : _a.valueDeclaration) && ts.isSourceFile((_b = symbol.parent) === null || _b === void 0 ? void 0 : _b.valueDeclaration) + ? 2 /* NodeFlags.Const */ + : undefined + : isConstVariable(symbol) + ? 2 /* NodeFlags.Const */ + : 1 /* NodeFlags.Let */; + var name = (needsPostExportDefault || !(symbol.flags & 4 /* SymbolFlags.Property */)) ? localName : getUnusedName(localName, symbol); + var textRange = symbol.declarations && ts.find(symbol.declarations, function (d) { return ts.isVariableDeclaration(d); }); + if (textRange && ts.isVariableDeclarationList(textRange.parent) && textRange.parent.declarations.length === 1) { + textRange = textRange.parent.parent; + } + var propertyAccessRequire = (_c = symbol.declarations) === null || _c === void 0 ? void 0 : _c.find(ts.isPropertyAccessExpression); + if (propertyAccessRequire && ts.isBinaryExpression(propertyAccessRequire.parent) && ts.isIdentifier(propertyAccessRequire.parent.right) + && ((_d = type.symbol) === null || _d === void 0 ? void 0 : _d.valueDeclaration) && ts.isSourceFile(type.symbol.valueDeclaration)) { + var alias = localName === propertyAccessRequire.parent.right.escapedText ? undefined : propertyAccessRequire.parent.right; + addResult(ts.factory.createExportDeclaration( + /*modifiers*/ undefined, + /*isTypeOnly*/ false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(/*isTypeOnly*/ false, alias, localName)])), 0 /* ModifierFlags.None */); + context.tracker.trackSymbol(type.symbol, context.enclosingDeclaration, 111551 /* SymbolFlags.Value */); + } + else { + var statement = ts.setTextRange(ts.factory.createVariableStatement(/*modifiers*/ undefined, ts.factory.createVariableDeclarationList([ + ts.factory.createVariableDeclaration(name, /*exclamationToken*/ undefined, serializeTypeForDeclaration(context, type, symbol, enclosingDeclaration, includePrivateSymbol, bundled)) + ], flags)), textRange); + addResult(statement, name !== localName ? modifierFlags & ~1 /* ModifierFlags.Export */ : modifierFlags); + if (name !== localName && !isPrivate) { + // We rename the variable declaration we generate for Property symbols since they may have a name which + // conflicts with a local declaration. For example, given input: + // ``` + // function g() {} + // module.exports.g = g + // ``` + // In such a situation, we have a local variable named `g`, and a separate exported variable named `g`. + // Naively, we would emit + // ``` + // function g() {} + // export const g: typeof g; + // ``` + // That's obviously incorrect - the `g` in the type annotation needs to refer to the local `g`, but + // the export declaration shadows it. + // To work around that, we instead write + // ``` + // function g() {} + // const g_1: typeof g; + // export { g_1 as g }; + // ``` + // To create an export named `g` that does _not_ shadow the local `g` + addResult(ts.factory.createExportDeclaration( + /*modifiers*/ undefined, + /*isTypeOnly*/ false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(/*isTypeOnly*/ false, name, localName)])), 0 /* ModifierFlags.None */); + needsExportDeclaration = false; + needsPostExportDefault = false; + } + } + } + } + } + if (symbol.flags & 384 /* SymbolFlags.Enum */) { + serializeEnum(symbol, symbolName, modifierFlags); + } + if (symbol.flags & 32 /* SymbolFlags.Class */) { + if (symbol.flags & 4 /* SymbolFlags.Property */ + && symbol.valueDeclaration + && ts.isBinaryExpression(symbol.valueDeclaration.parent) + && ts.isClassExpression(symbol.valueDeclaration.parent.right)) { + // Looks like a `module.exports.Sub = class {}` - if we serialize `symbol` as a class, the result will have no members, + // since the classiness is actually from the target of the effective alias the symbol is. yes. A BlockScopedVariable|Class|Property + // _really_ acts like an Alias, and none of a BlockScopedVariable, Class, or Property. This is the travesty of JS binding today. + serializeAsAlias(symbol, getInternalSymbolName(symbol, symbolName), modifierFlags); + } + else { + serializeAsClass(symbol, getInternalSymbolName(symbol, symbolName), modifierFlags); + } + } + if ((symbol.flags & (512 /* SymbolFlags.ValueModule */ | 1024 /* SymbolFlags.NamespaceModule */) && (!isConstMergedWithNS || isTypeOnlyNamespace(symbol))) || isConstMergedWithNSPrintableAsSignatureMerge) { + serializeModule(symbol, symbolName, modifierFlags); + } + // The class meaning serialization should handle serializing all interface members + if (symbol.flags & 64 /* SymbolFlags.Interface */ && !(symbol.flags & 32 /* SymbolFlags.Class */)) { + serializeInterface(symbol, symbolName, modifierFlags); + } + if (symbol.flags & 2097152 /* SymbolFlags.Alias */) { + serializeAsAlias(symbol, getInternalSymbolName(symbol, symbolName), modifierFlags); + } + if (symbol.flags & 4 /* SymbolFlags.Property */ && symbol.escapedName === "export=" /* InternalSymbolName.ExportEquals */) { + serializeMaybeAliasAssignment(symbol); + } + if (symbol.flags & 8388608 /* SymbolFlags.ExportStar */) { + // synthesize export * from "moduleReference" + // Straightforward - only one thing to do - make an export declaration + if (symbol.declarations) { + for (var _i = 0, _e = symbol.declarations; _i < _e.length; _i++) { + var node = _e[_i]; + var resolvedModule = resolveExternalModuleName(node, node.moduleSpecifier); + if (!resolvedModule) + continue; + addResult(ts.factory.createExportDeclaration(/*modifiers*/ undefined, /*isTypeOnly*/ false, /*exportClause*/ undefined, ts.factory.createStringLiteral(getSpecifierForModuleSymbol(resolvedModule, context))), 0 /* ModifierFlags.None */); + } + } + } + if (needsPostExportDefault) { + addResult(ts.factory.createExportAssignment(/*modifiers*/ undefined, /*isExportAssignment*/ false, ts.factory.createIdentifier(getInternalSymbolName(symbol, symbolName))), 0 /* ModifierFlags.None */); + } + else if (needsExportDeclaration) { + addResult(ts.factory.createExportDeclaration( + /*modifiers*/ undefined, + /*isTypeOnly*/ false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(/*isTypeOnly*/ false, getInternalSymbolName(symbol, symbolName), symbolName)])), 0 /* ModifierFlags.None */); + } + } + function includePrivateSymbol(symbol) { + if (ts.some(symbol.declarations, ts.isParameterDeclaration)) + return; + ts.Debug.assertIsDefined(deferredPrivatesStack[deferredPrivatesStack.length - 1]); + getUnusedName(ts.unescapeLeadingUnderscores(symbol.escapedName), symbol); // Call to cache unique name for symbol + // Blanket moving (import) aliases into the root private context should work, since imports are not valid within namespaces + // (so they must have been in the root to begin with if they were real imports) cjs `require` aliases (an upcoming feature) + // will throw a wrench in this, since those may have been nested, but we'll need to synthesize them in the outer scope + // anyway, as that's the only place the import they translate to is valid. In such a case, we might need to use a unique name + // for the moved import; which hopefully the above `getUnusedName` call should produce. + var isExternalImportAlias = !!(symbol.flags & 2097152 /* SymbolFlags.Alias */) && !ts.some(symbol.declarations, function (d) { + return !!ts.findAncestor(d, ts.isExportDeclaration) || + ts.isNamespaceExport(d) || + (ts.isImportEqualsDeclaration(d) && !ts.isExternalModuleReference(d.moduleReference)); + }); + deferredPrivatesStack[isExternalImportAlias ? 0 : (deferredPrivatesStack.length - 1)].set(getSymbolId(symbol), symbol); + } + function isExportingScope(enclosingDeclaration) { + return ((ts.isSourceFile(enclosingDeclaration) && (ts.isExternalOrCommonJsModule(enclosingDeclaration) || ts.isJsonSourceFile(enclosingDeclaration))) || + (ts.isAmbientModule(enclosingDeclaration) && !ts.isGlobalScopeAugmentation(enclosingDeclaration))); + } + // Prepends a `declare` and/or `export` modifier if the context requires it, and then adds `node` to `result` and returns `node` + function addResult(node, additionalModifierFlags) { + if (ts.canHaveModifiers(node)) { + var newModifierFlags = 0 /* ModifierFlags.None */; + var enclosingDeclaration_1 = context.enclosingDeclaration && + (ts.isJSDocTypeAlias(context.enclosingDeclaration) ? ts.getSourceFileOfNode(context.enclosingDeclaration) : context.enclosingDeclaration); + if (additionalModifierFlags & 1 /* ModifierFlags.Export */ && + enclosingDeclaration_1 && (isExportingScope(enclosingDeclaration_1) || ts.isModuleDeclaration(enclosingDeclaration_1)) && + ts.canHaveExportModifier(node)) { + // Classes, namespaces, variables, functions, interfaces, and types should all be `export`ed in a module context if not private + newModifierFlags |= 1 /* ModifierFlags.Export */; + } + if (addingDeclare && !(newModifierFlags & 1 /* ModifierFlags.Export */) && + (!enclosingDeclaration_1 || !(enclosingDeclaration_1.flags & 16777216 /* NodeFlags.Ambient */)) && + (ts.isEnumDeclaration(node) || ts.isVariableStatement(node) || ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isModuleDeclaration(node))) { + // Classes, namespaces, variables, enums, and functions all need `declare` modifiers to be valid in a declaration file top-level scope + newModifierFlags |= 2 /* ModifierFlags.Ambient */; + } + if ((additionalModifierFlags & 1024 /* ModifierFlags.Default */) && (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isFunctionDeclaration(node))) { + newModifierFlags |= 1024 /* ModifierFlags.Default */; + } + if (newModifierFlags) { + node = ts.factory.updateModifiers(node, newModifierFlags | ts.getEffectiveModifierFlags(node)); + } + } + results.push(node); + } + function serializeTypeAlias(symbol, symbolName, modifierFlags) { + var _a; + var aliasType = getDeclaredTypeOfTypeAlias(symbol); + var typeParams = getSymbolLinks(symbol).typeParameters; + var typeParamDecls = ts.map(typeParams, function (p) { return typeParameterToDeclaration(p, context); }); + var jsdocAliasDecl = (_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isJSDocTypeAlias); + var commentText = ts.getTextOfJSDocComment(jsdocAliasDecl ? jsdocAliasDecl.comment || jsdocAliasDecl.parent.comment : undefined); + var oldFlags = context.flags; + context.flags |= 8388608 /* NodeBuilderFlags.InTypeAlias */; + var oldEnclosingDecl = context.enclosingDeclaration; + context.enclosingDeclaration = jsdocAliasDecl; + var typeNode = jsdocAliasDecl && jsdocAliasDecl.typeExpression + && ts.isJSDocTypeExpression(jsdocAliasDecl.typeExpression) + && serializeExistingTypeNode(context, jsdocAliasDecl.typeExpression.type, includePrivateSymbol, bundled) + || typeToTypeNodeHelper(aliasType, context); + addResult(ts.setSyntheticLeadingComments(ts.factory.createTypeAliasDeclaration(/*modifiers*/ undefined, getInternalSymbolName(symbol, symbolName), typeParamDecls, typeNode), !commentText ? [] : [{ kind: 3 /* SyntaxKind.MultiLineCommentTrivia */, text: "*\n * " + commentText.replace(/\n/g, "\n * ") + "\n ", pos: -1, end: -1, hasTrailingNewLine: true }]), modifierFlags); + context.flags = oldFlags; + context.enclosingDeclaration = oldEnclosingDecl; + } + function serializeInterface(symbol, symbolName, modifierFlags) { + var interfaceType = getDeclaredTypeOfClassOrInterface(symbol); + var localParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol); + var typeParamDecls = ts.map(localParams, function (p) { return typeParameterToDeclaration(p, context); }); + var baseTypes = getBaseTypes(interfaceType); + var baseType = ts.length(baseTypes) ? getIntersectionType(baseTypes) : undefined; + var members = ts.flatMap(getPropertiesOfType(interfaceType), function (p) { return serializePropertySymbolForInterface(p, baseType); }); + var callSignatures = serializeSignatures(0 /* SignatureKind.Call */, interfaceType, baseType, 176 /* SyntaxKind.CallSignature */); + var constructSignatures = serializeSignatures(1 /* SignatureKind.Construct */, interfaceType, baseType, 177 /* SyntaxKind.ConstructSignature */); + var indexSignatures = serializeIndexSignatures(interfaceType, baseType); + var heritageClauses = !ts.length(baseTypes) ? undefined : [ts.factory.createHeritageClause(94 /* SyntaxKind.ExtendsKeyword */, ts.mapDefined(baseTypes, function (b) { return trySerializeAsTypeReference(b, 111551 /* SymbolFlags.Value */); }))]; + addResult(ts.factory.createInterfaceDeclaration( + /*modifiers*/ undefined, getInternalSymbolName(symbol, symbolName), typeParamDecls, heritageClauses, __spreadArray(__spreadArray(__spreadArray(__spreadArray([], indexSignatures, true), constructSignatures, true), callSignatures, true), members, true)), modifierFlags); + } + function getNamespaceMembersForSerialization(symbol) { + return !symbol.exports ? [] : ts.filter(ts.arrayFrom(symbol.exports.values()), isNamespaceMember); + } + function isTypeOnlyNamespace(symbol) { + return ts.every(getNamespaceMembersForSerialization(symbol), function (m) { return !(getAllSymbolFlags(resolveSymbol(m)) & 111551 /* SymbolFlags.Value */); }); + } + function serializeModule(symbol, symbolName, modifierFlags) { + var members = getNamespaceMembersForSerialization(symbol); + // Split NS members up by declaration - members whose parent symbol is the ns symbol vs those whose is not (but were added in later via merging) + var locationMap = ts.arrayToMultiMap(members, function (m) { return m.parent && m.parent === symbol ? "real" : "merged"; }); + var realMembers = locationMap.get("real") || ts.emptyArray; + var mergedMembers = locationMap.get("merged") || ts.emptyArray; + // TODO: `suppressNewPrivateContext` is questionable -we need to simply be emitting privates in whatever scope they were declared in, rather + // than whatever scope we traverse to them in. That's a bit of a complex rewrite, since we're not _actually_ tracking privates at all in advance, + // so we don't even have placeholders to fill in. + if (ts.length(realMembers)) { + var localName = getInternalSymbolName(symbol, symbolName); + serializeAsNamespaceDeclaration(realMembers, localName, modifierFlags, !!(symbol.flags & (16 /* SymbolFlags.Function */ | 67108864 /* SymbolFlags.Assignment */))); + } + if (ts.length(mergedMembers)) { + var containingFile_1 = ts.getSourceFileOfNode(context.enclosingDeclaration); + var localName = getInternalSymbolName(symbol, symbolName); + var nsBody = ts.factory.createModuleBlock([ts.factory.createExportDeclaration( + /*modifiers*/ undefined, + /*isTypeOnly*/ false, ts.factory.createNamedExports(ts.mapDefined(ts.filter(mergedMembers, function (n) { return n.escapedName !== "export=" /* InternalSymbolName.ExportEquals */; }), function (s) { + var _a, _b; + var name = ts.unescapeLeadingUnderscores(s.escapedName); + var localName = getInternalSymbolName(s, name); + var aliasDecl = s.declarations && getDeclarationOfAliasSymbol(s); + if (containingFile_1 && (aliasDecl ? containingFile_1 !== ts.getSourceFileOfNode(aliasDecl) : !ts.some(s.declarations, function (d) { return ts.getSourceFileOfNode(d) === containingFile_1; }))) { + (_b = (_a = context.tracker) === null || _a === void 0 ? void 0 : _a.reportNonlocalAugmentation) === null || _b === void 0 ? void 0 : _b.call(_a, containingFile_1, symbol, s); + return undefined; + } + var target = aliasDecl && getTargetOfAliasDeclaration(aliasDecl, /*dontRecursivelyResolve*/ true); + includePrivateSymbol(target || s); + var targetName = target ? getInternalSymbolName(target, ts.unescapeLeadingUnderscores(target.escapedName)) : localName; + return ts.factory.createExportSpecifier(/*isTypeOnly*/ false, name === targetName ? undefined : targetName, name); + })))]); + addResult(ts.factory.createModuleDeclaration( + /*modifiers*/ undefined, ts.factory.createIdentifier(localName), nsBody, 16 /* NodeFlags.Namespace */), 0 /* ModifierFlags.None */); + } + } + function serializeEnum(symbol, symbolName, modifierFlags) { + addResult(ts.factory.createEnumDeclaration(ts.factory.createModifiersFromModifierFlags(isConstEnumSymbol(symbol) ? 2048 /* ModifierFlags.Const */ : 0), getInternalSymbolName(symbol, symbolName), ts.map(ts.filter(getPropertiesOfType(getTypeOfSymbol(symbol)), function (p) { return !!(p.flags & 8 /* SymbolFlags.EnumMember */); }), function (p) { + // TODO: Handle computed names + // I hate that to get the initialized value we need to walk back to the declarations here; but there's no + // other way to get the possible const value of an enum member that I'm aware of, as the value is cached + // _on the declaration_, not on the declaration's symbol... + var initializedValue = p.declarations && p.declarations[0] && ts.isEnumMember(p.declarations[0]) ? getConstantValue(p.declarations[0]) : undefined; + return ts.factory.createEnumMember(ts.unescapeLeadingUnderscores(p.escapedName), initializedValue === undefined ? undefined : + typeof initializedValue === "string" ? ts.factory.createStringLiteral(initializedValue) : + ts.factory.createNumericLiteral(initializedValue)); + })), modifierFlags); + } + function serializeAsFunctionNamespaceMerge(type, symbol, localName, modifierFlags) { + var signatures = getSignaturesOfType(type, 0 /* SignatureKind.Call */); + for (var _i = 0, signatures_2 = signatures; _i < signatures_2.length; _i++) { + var sig = signatures_2[_i]; + // Each overload becomes a separate function declaration, in order + var decl = signatureToSignatureDeclarationHelper(sig, 259 /* SyntaxKind.FunctionDeclaration */, context, { name: ts.factory.createIdentifier(localName), privateSymbolVisitor: includePrivateSymbol, bundledImports: bundled }); + addResult(ts.setTextRange(decl, getSignatureTextRangeLocation(sig)), modifierFlags); + } + // Module symbol emit will take care of module-y members, provided it has exports + if (!(symbol.flags & (512 /* SymbolFlags.ValueModule */ | 1024 /* SymbolFlags.NamespaceModule */) && !!symbol.exports && !!symbol.exports.size)) { + var props = ts.filter(getPropertiesOfType(type), isNamespaceMember); + serializeAsNamespaceDeclaration(props, localName, modifierFlags, /*suppressNewPrivateContext*/ true); + } + } + function getSignatureTextRangeLocation(signature) { + if (signature.declaration && signature.declaration.parent) { + if (ts.isBinaryExpression(signature.declaration.parent) && ts.getAssignmentDeclarationKind(signature.declaration.parent) === 5 /* AssignmentDeclarationKind.Property */) { + return signature.declaration.parent; + } + // for expressions assigned to `var`s, use the `var` as the text range + if (ts.isVariableDeclaration(signature.declaration.parent) && signature.declaration.parent.parent) { + return signature.declaration.parent.parent; + } + } + return signature.declaration; + } + function serializeAsNamespaceDeclaration(props, localName, modifierFlags, suppressNewPrivateContext) { + if (ts.length(props)) { + var localVsRemoteMap = ts.arrayToMultiMap(props, function (p) { + return !ts.length(p.declarations) || ts.some(p.declarations, function (d) { + return ts.getSourceFileOfNode(d) === ts.getSourceFileOfNode(context.enclosingDeclaration); + }) ? "local" : "remote"; + }); + var localProps = localVsRemoteMap.get("local") || ts.emptyArray; + // handle remote props first - we need to make an `import` declaration that points at the module containing each remote + // prop in the outermost scope (TODO: a namespace within a namespace would need to be appropriately handled by this) + // Example: + // import Foo_1 = require("./exporter"); + // export namespace ns { + // import Foo = Foo_1.Foo; + // export { Foo }; + // export const c: number; + // } + // This is needed because in JS, statements like `const x = require("./f")` support both type and value lookup, even if they're + // normally just value lookup (so it functions kinda like an alias even when it's not an alias) + // _Usually_, we'll simply print the top-level as an alias instead of a `var` in such situations, however is is theoretically + // possible to encounter a situation where a type has members from both the current file and other files - in those situations, + // emit akin to the above would be needed. + // Add a namespace + // Create namespace as non-synthetic so it is usable as an enclosing declaration + var fakespace = ts.parseNodeFactory.createModuleDeclaration(/*modifiers*/ undefined, ts.factory.createIdentifier(localName), ts.factory.createModuleBlock([]), 16 /* NodeFlags.Namespace */); + ts.setParent(fakespace, enclosingDeclaration); + fakespace.locals = ts.createSymbolTable(props); + fakespace.symbol = props[0].parent; + var oldResults = results; + results = []; + var oldAddingDeclare = addingDeclare; + addingDeclare = false; + var subcontext = __assign(__assign({}, context), { enclosingDeclaration: fakespace }); + var oldContext = context; + context = subcontext; + // TODO: implement handling for the localVsRemoteMap.get("remote") - should be difficult to trigger (see comment above), as only interesting cross-file js merges should make this possible + visitSymbolTable(ts.createSymbolTable(localProps), suppressNewPrivateContext, /*propertyAsAlias*/ true); + context = oldContext; + addingDeclare = oldAddingDeclare; + var declarations = results; + results = oldResults; + // replace namespace with synthetic version + var defaultReplaced = ts.map(declarations, function (d) { return ts.isExportAssignment(d) && !d.isExportEquals && ts.isIdentifier(d.expression) ? ts.factory.createExportDeclaration( + /*modifiers*/ undefined, + /*isTypeOnly*/ false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(/*isTypeOnly*/ false, d.expression, ts.factory.createIdentifier("default" /* InternalSymbolName.Default */))])) : d; }); + var exportModifierStripped = ts.every(defaultReplaced, function (d) { return ts.hasSyntacticModifier(d, 1 /* ModifierFlags.Export */); }) ? ts.map(defaultReplaced, removeExportModifier) : defaultReplaced; + fakespace = ts.factory.updateModuleDeclaration(fakespace, fakespace.modifiers, fakespace.name, ts.factory.createModuleBlock(exportModifierStripped)); + addResult(fakespace, modifierFlags); // namespaces can never be default exported + } + } + function isNamespaceMember(p) { + return !!(p.flags & (788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */ | 2097152 /* SymbolFlags.Alias */)) || + !(p.flags & 4194304 /* SymbolFlags.Prototype */ || p.escapedName === "prototype" || p.valueDeclaration && ts.isStatic(p.valueDeclaration) && ts.isClassLike(p.valueDeclaration.parent)); + } + function sanitizeJSDocImplements(clauses) { + var result = ts.mapDefined(clauses, function (e) { + var _a; + var oldEnclosing = context.enclosingDeclaration; + context.enclosingDeclaration = e; + var expr = e.expression; + if (ts.isEntityNameExpression(expr)) { + if (ts.isIdentifier(expr) && ts.idText(expr) === "") { + return cleanup(/*result*/ undefined); // Empty heritage clause, should be an error, but prefer emitting no heritage clauses to reemitting the empty one + } + var introducesError = void 0; + (_a = trackExistingEntityName(expr, context, includePrivateSymbol), introducesError = _a.introducesError, expr = _a.node); + if (introducesError) { + return cleanup(/*result*/ undefined); + } + } + return cleanup(ts.factory.createExpressionWithTypeArguments(expr, ts.map(e.typeArguments, function (a) { + return serializeExistingTypeNode(context, a, includePrivateSymbol, bundled) + || typeToTypeNodeHelper(getTypeFromTypeNode(a), context); + }))); + function cleanup(result) { + context.enclosingDeclaration = oldEnclosing; + return result; + } + }); + if (result.length === clauses.length) { + return result; + } + return undefined; + } + function serializeAsClass(symbol, localName, modifierFlags) { + var _a, _b; + var originalDecl = (_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isClassLike); + var oldEnclosing = context.enclosingDeclaration; + context.enclosingDeclaration = originalDecl || oldEnclosing; + var localParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol); + var typeParamDecls = ts.map(localParams, function (p) { return typeParameterToDeclaration(p, context); }); + var classType = getDeclaredTypeOfClassOrInterface(symbol); + var baseTypes = getBaseTypes(classType); + var originalImplements = originalDecl && ts.getEffectiveImplementsTypeNodes(originalDecl); + var implementsExpressions = originalImplements && sanitizeJSDocImplements(originalImplements) + || ts.mapDefined(getImplementsTypes(classType), serializeImplementedType); + var staticType = getTypeOfSymbol(symbol); + var isClass = !!((_b = staticType.symbol) === null || _b === void 0 ? void 0 : _b.valueDeclaration) && ts.isClassLike(staticType.symbol.valueDeclaration); + var staticBaseType = isClass + ? getBaseConstructorTypeOfClass(staticType) + : anyType; + var heritageClauses = __spreadArray(__spreadArray([], !ts.length(baseTypes) ? [] : [ts.factory.createHeritageClause(94 /* SyntaxKind.ExtendsKeyword */, ts.map(baseTypes, function (b) { return serializeBaseType(b, staticBaseType, localName); }))], true), !ts.length(implementsExpressions) ? [] : [ts.factory.createHeritageClause(117 /* SyntaxKind.ImplementsKeyword */, implementsExpressions)], true); + var symbolProps = getNonInheritedProperties(classType, baseTypes, getPropertiesOfType(classType)); + var publicSymbolProps = ts.filter(symbolProps, function (s) { + // `valueDeclaration` could be undefined if inherited from + // a union/intersection base type, but inherited properties + // don't matter here. + var valueDecl = s.valueDeclaration; + return !!valueDecl && !(ts.isNamedDeclaration(valueDecl) && ts.isPrivateIdentifier(valueDecl.name)); + }); + var hasPrivateIdentifier = ts.some(symbolProps, function (s) { + // `valueDeclaration` could be undefined if inherited from + // a union/intersection base type, but inherited properties + // don't matter here. + var valueDecl = s.valueDeclaration; + return !!valueDecl && ts.isNamedDeclaration(valueDecl) && ts.isPrivateIdentifier(valueDecl.name); + }); + // Boil down all private properties into a single one. + var privateProperties = hasPrivateIdentifier ? + [ts.factory.createPropertyDeclaration( + /*modifiers*/ undefined, ts.factory.createPrivateIdentifier("#private"), + /*questionOrExclamationToken*/ undefined, + /*type*/ undefined, + /*initializer*/ undefined)] : + ts.emptyArray; + var publicProperties = ts.flatMap(publicSymbolProps, function (p) { return serializePropertySymbolForClass(p, /*isStatic*/ false, baseTypes[0]); }); + // Consider static members empty if symbol also has function or module meaning - function namespacey emit will handle statics + var staticMembers = ts.flatMap(ts.filter(getPropertiesOfType(staticType), function (p) { return !(p.flags & 4194304 /* SymbolFlags.Prototype */) && p.escapedName !== "prototype" && !isNamespaceMember(p); }), function (p) { return serializePropertySymbolForClass(p, /*isStatic*/ true, staticBaseType); }); + // When we encounter an `X.prototype.y` assignment in a JS file, we bind `X` as a class regardless as to whether + // the value is ever initialized with a class or function-like value. For cases where `X` could never be + // created via `new`, we will inject a `private constructor()` declaration to indicate it is not createable. + var isNonConstructableClassLikeInJsFile = !isClass && + !!symbol.valueDeclaration && + ts.isInJSFile(symbol.valueDeclaration) && + !ts.some(getSignaturesOfType(staticType, 1 /* SignatureKind.Construct */)); + var constructors = isNonConstructableClassLikeInJsFile ? + [ts.factory.createConstructorDeclaration(ts.factory.createModifiersFromModifierFlags(8 /* ModifierFlags.Private */), [], /*body*/ undefined)] : + serializeSignatures(1 /* SignatureKind.Construct */, staticType, staticBaseType, 173 /* SyntaxKind.Constructor */); + var indexSignatures = serializeIndexSignatures(classType, baseTypes[0]); + context.enclosingDeclaration = oldEnclosing; + addResult(ts.setTextRange(ts.factory.createClassDeclaration( + /*modifiers*/ undefined, localName, typeParamDecls, heritageClauses, __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], indexSignatures, true), staticMembers, true), constructors, true), publicProperties, true), privateProperties, true)), symbol.declarations && ts.filter(symbol.declarations, function (d) { return ts.isClassDeclaration(d) || ts.isClassExpression(d); })[0]), modifierFlags); + } + function getSomeTargetNameFromDeclarations(declarations) { + return ts.firstDefined(declarations, function (d) { + if (ts.isImportSpecifier(d) || ts.isExportSpecifier(d)) { + return ts.idText(d.propertyName || d.name); + } + if (ts.isBinaryExpression(d) || ts.isExportAssignment(d)) { + var expression = ts.isExportAssignment(d) ? d.expression : d.right; + if (ts.isPropertyAccessExpression(expression)) { + return ts.idText(expression.name); + } + } + if (isAliasSymbolDeclaration(d)) { + // This is... heuristic, at best. But it's probably better than always printing the name of the shorthand ambient module. + var name = ts.getNameOfDeclaration(d); + if (name && ts.isIdentifier(name)) { + return ts.idText(name); + } + } + return undefined; + }); + } + function serializeAsAlias(symbol, localName, modifierFlags) { + var _a, _b, _c, _d, _e; + // synthesize an alias, eg `export { symbolName as Name }` + // need to mark the alias `symbol` points at + // as something we need to serialize as a private declaration as well + var node = getDeclarationOfAliasSymbol(symbol); + if (!node) + return ts.Debug.fail(); + var target = getMergedSymbol(getTargetOfAliasDeclaration(node, /*dontRecursivelyResolve*/ true)); + if (!target) { + return; + } + // If `target` refers to a shorthand module symbol, the name we're trying to pull out isn;t recoverable from the target symbol + // In such a scenario, we must fall back to looking for an alias declaration on `symbol` and pulling the target name from that + var verbatimTargetName = ts.isShorthandAmbientModuleSymbol(target) && getSomeTargetNameFromDeclarations(symbol.declarations) || ts.unescapeLeadingUnderscores(target.escapedName); + if (verbatimTargetName === "export=" /* InternalSymbolName.ExportEquals */ && (ts.getESModuleInterop(compilerOptions) || compilerOptions.allowSyntheticDefaultImports)) { + // target refers to an `export=` symbol that was hoisted into a synthetic default - rename here to match + verbatimTargetName = "default" /* InternalSymbolName.Default */; + } + var targetName = getInternalSymbolName(target, verbatimTargetName); + includePrivateSymbol(target); // the target may be within the same scope - attempt to serialize it first + switch (node.kind) { + case 205 /* SyntaxKind.BindingElement */: + if (((_b = (_a = node.parent) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.kind) === 257 /* SyntaxKind.VariableDeclaration */) { + // const { SomeClass } = require('./lib'); + var specifier_1 = getSpecifierForModuleSymbol(target.parent || target, context); // './lib' + var propertyName = node.propertyName; + addResult(ts.factory.createImportDeclaration( + /*modifiers*/ undefined, ts.factory.createImportClause(/*isTypeOnly*/ false, /*name*/ undefined, ts.factory.createNamedImports([ts.factory.createImportSpecifier( + /*isTypeOnly*/ false, propertyName && ts.isIdentifier(propertyName) ? ts.factory.createIdentifier(ts.idText(propertyName)) : undefined, ts.factory.createIdentifier(localName))])), ts.factory.createStringLiteral(specifier_1), + /*importClause*/ undefined), 0 /* ModifierFlags.None */); + break; + } + // We don't know how to serialize this (nested?) binding element + ts.Debug.failBadSyntaxKind(((_c = node.parent) === null || _c === void 0 ? void 0 : _c.parent) || node, "Unhandled binding element grandparent kind in declaration serialization"); + break; + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + if (((_e = (_d = node.parent) === null || _d === void 0 ? void 0 : _d.parent) === null || _e === void 0 ? void 0 : _e.kind) === 223 /* SyntaxKind.BinaryExpression */) { + // module.exports = { SomeClass } + serializeExportSpecifier(ts.unescapeLeadingUnderscores(symbol.escapedName), targetName); + } + break; + case 257 /* SyntaxKind.VariableDeclaration */: + // commonjs require: const x = require('y') + if (ts.isPropertyAccessExpression(node.initializer)) { + // const x = require('y').z + var initializer = node.initializer; // require('y').z + var uniqueName = ts.factory.createUniqueName(localName); // _x + var specifier_2 = getSpecifierForModuleSymbol(target.parent || target, context); // 'y' + // import _x = require('y'); + addResult(ts.factory.createImportEqualsDeclaration( + /*modifiers*/ undefined, + /*isTypeOnly*/ false, uniqueName, ts.factory.createExternalModuleReference(ts.factory.createStringLiteral(specifier_2))), 0 /* ModifierFlags.None */); + // import x = _x.z + addResult(ts.factory.createImportEqualsDeclaration( + /*modifiers*/ undefined, + /*isTypeOnly*/ false, ts.factory.createIdentifier(localName), ts.factory.createQualifiedName(uniqueName, initializer.name)), modifierFlags); + break; + } + // else fall through and treat commonjs require just like import= + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + // This _specifically_ only exists to handle json declarations - where we make aliases, but since + // we emit no declarations for the json document, must not refer to it in the declarations + if (target.escapedName === "export=" /* InternalSymbolName.ExportEquals */ && ts.some(target.declarations, ts.isJsonSourceFile)) { + serializeMaybeAliasAssignment(symbol); + break; + } + // Could be a local `import localName = ns.member` or + // an external `import localName = require("whatever")` + var isLocalImport = !(target.flags & 512 /* SymbolFlags.ValueModule */) && !ts.isVariableDeclaration(node); + addResult(ts.factory.createImportEqualsDeclaration( + /*modifiers*/ undefined, + /*isTypeOnly*/ false, ts.factory.createIdentifier(localName), isLocalImport + ? symbolToName(target, context, 67108863 /* SymbolFlags.All */, /*expectsIdentifier*/ false) + : ts.factory.createExternalModuleReference(ts.factory.createStringLiteral(getSpecifierForModuleSymbol(target, context)))), isLocalImport ? modifierFlags : 0 /* ModifierFlags.None */); + break; + case 267 /* SyntaxKind.NamespaceExportDeclaration */: + // export as namespace foo + // TODO: Not part of a file's local or export symbol tables + // Is bound into file.symbol.globalExports instead, which we don't currently traverse + addResult(ts.factory.createNamespaceExportDeclaration(ts.idText(node.name)), 0 /* ModifierFlags.None */); + break; + case 270 /* SyntaxKind.ImportClause */: + addResult(ts.factory.createImportDeclaration( + /*modifiers*/ undefined, ts.factory.createImportClause(/*isTypeOnly*/ false, ts.factory.createIdentifier(localName), /*namedBindings*/ undefined), + // We use `target.parent || target` below as `target.parent` is unset when the target is a module which has been export assigned + // And then made into a default by the `esModuleInterop` or `allowSyntheticDefaultImports` flag + // In such cases, the `target` refers to the module itself already + ts.factory.createStringLiteral(getSpecifierForModuleSymbol(target.parent || target, context)), + /*assertClause*/ undefined), 0 /* ModifierFlags.None */); + break; + case 271 /* SyntaxKind.NamespaceImport */: + addResult(ts.factory.createImportDeclaration( + /*modifiers*/ undefined, ts.factory.createImportClause(/*isTypeOnly*/ false, /*importClause*/ undefined, ts.factory.createNamespaceImport(ts.factory.createIdentifier(localName))), ts.factory.createStringLiteral(getSpecifierForModuleSymbol(target, context)), + /*assertClause*/ undefined), 0 /* ModifierFlags.None */); + break; + case 277 /* SyntaxKind.NamespaceExport */: + addResult(ts.factory.createExportDeclaration( + /*modifiers*/ undefined, + /*isTypeOnly*/ false, ts.factory.createNamespaceExport(ts.factory.createIdentifier(localName)), ts.factory.createStringLiteral(getSpecifierForModuleSymbol(target, context))), 0 /* ModifierFlags.None */); + break; + case 273 /* SyntaxKind.ImportSpecifier */: + addResult(ts.factory.createImportDeclaration( + /*modifiers*/ undefined, ts.factory.createImportClause( + /*isTypeOnly*/ false, + /*importClause*/ undefined, ts.factory.createNamedImports([ + ts.factory.createImportSpecifier( + /*isTypeOnly*/ false, localName !== verbatimTargetName ? ts.factory.createIdentifier(verbatimTargetName) : undefined, ts.factory.createIdentifier(localName)) + ])), ts.factory.createStringLiteral(getSpecifierForModuleSymbol(target.parent || target, context)), + /*assertClause*/ undefined), 0 /* ModifierFlags.None */); + break; + case 278 /* SyntaxKind.ExportSpecifier */: + // does not use localName because the symbol name in this case refers to the name in the exports table, + // which we must exactly preserve + var specifier = node.parent.parent.moduleSpecifier; + // targetName is only used when the target is local, as otherwise the target is an alias that points at + // another file + serializeExportSpecifier(ts.unescapeLeadingUnderscores(symbol.escapedName), specifier ? verbatimTargetName : targetName, specifier && ts.isStringLiteralLike(specifier) ? ts.factory.createStringLiteral(specifier.text) : undefined); + break; + case 274 /* SyntaxKind.ExportAssignment */: + serializeMaybeAliasAssignment(symbol); + break; + case 223 /* SyntaxKind.BinaryExpression */: + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 209 /* SyntaxKind.ElementAccessExpression */: + // Could be best encoded as though an export specifier or as though an export assignment + // If name is default or export=, do an export assignment + // Otherwise do an export specifier + if (symbol.escapedName === "default" /* InternalSymbolName.Default */ || symbol.escapedName === "export=" /* InternalSymbolName.ExportEquals */) { + serializeMaybeAliasAssignment(symbol); + } + else { + serializeExportSpecifier(localName, targetName); + } + break; + default: + return ts.Debug.failBadSyntaxKind(node, "Unhandled alias declaration kind in symbol serializer!"); + } + } + function serializeExportSpecifier(localName, targetName, specifier) { + addResult(ts.factory.createExportDeclaration( + /*modifiers*/ undefined, + /*isTypeOnly*/ false, ts.factory.createNamedExports([ts.factory.createExportSpecifier(/*isTypeOnly*/ false, localName !== targetName ? targetName : undefined, localName)]), specifier), 0 /* ModifierFlags.None */); + } + /** + * Returns `true` if an export assignment or declaration was produced for the symbol + */ + function serializeMaybeAliasAssignment(symbol) { + if (symbol.flags & 4194304 /* SymbolFlags.Prototype */) { + return false; + } + var name = ts.unescapeLeadingUnderscores(symbol.escapedName); + var isExportEquals = name === "export=" /* InternalSymbolName.ExportEquals */; + var isDefault = name === "default" /* InternalSymbolName.Default */; + var isExportAssignmentCompatibleSymbolName = isExportEquals || isDefault; + // synthesize export = ref + // ref should refer to either be a locally scoped symbol which we need to emit, or + // a reference to another namespace/module which we may need to emit an `import` statement for + var aliasDecl = symbol.declarations && getDeclarationOfAliasSymbol(symbol); + // serialize what the alias points to, preserve the declaration's initializer + var target = aliasDecl && getTargetOfAliasDeclaration(aliasDecl, /*dontRecursivelyResolve*/ true); + // If the target resolves and resolves to a thing defined in this file, emit as an alias, otherwise emit as a const + if (target && ts.length(target.declarations) && ts.some(target.declarations, function (d) { return ts.getSourceFileOfNode(d) === ts.getSourceFileOfNode(enclosingDeclaration); })) { + // In case `target` refers to a namespace member, look at the declaration and serialize the leftmost symbol in it + // eg, `namespace A { export class B {} }; exports = A.B;` + // Technically, this is all that's required in the case where the assignment is an entity name expression + var expr = aliasDecl && ((ts.isExportAssignment(aliasDecl) || ts.isBinaryExpression(aliasDecl)) ? ts.getExportAssignmentExpression(aliasDecl) : ts.getPropertyAssignmentAliasLikeExpression(aliasDecl)); + var first_1 = expr && ts.isEntityNameExpression(expr) ? getFirstNonModuleExportsIdentifier(expr) : undefined; + var referenced = first_1 && resolveEntityName(first_1, 67108863 /* SymbolFlags.All */, /*ignoreErrors*/ true, /*dontResolveAlias*/ true, enclosingDeclaration); + if (referenced || target) { + includePrivateSymbol(referenced || target); + } + // We disable the context's symbol tracker for the duration of this name serialization + // as, by virtue of being here, the name is required to print something, and we don't want to + // issue a visibility error on it. Only anonymous classes that an alias points at _would_ issue + // a visibility error here (as they're not visible within any scope), but we want to hoist them + // into the containing scope anyway, so we want to skip the visibility checks. + var oldTrack = context.tracker.trackSymbol; + context.tracker.trackSymbol = function () { return false; }; + if (isExportAssignmentCompatibleSymbolName) { + results.push(ts.factory.createExportAssignment( + /*modifiers*/ undefined, isExportEquals, symbolToExpression(target, context, 67108863 /* SymbolFlags.All */))); + } + else { + if (first_1 === expr && first_1) { + // serialize as `export {target as name}` + serializeExportSpecifier(name, ts.idText(first_1)); + } + else if (expr && ts.isClassExpression(expr)) { + serializeExportSpecifier(name, getInternalSymbolName(target, ts.symbolName(target))); + } + else { + // serialize as `import _Ref = t.arg.et; export { _Ref as name }` + var varName = getUnusedName(name, symbol); + addResult(ts.factory.createImportEqualsDeclaration( + /*modifiers*/ undefined, + /*isTypeOnly*/ false, ts.factory.createIdentifier(varName), symbolToName(target, context, 67108863 /* SymbolFlags.All */, /*expectsIdentifier*/ false)), 0 /* ModifierFlags.None */); + serializeExportSpecifier(name, varName); + } + } + context.tracker.trackSymbol = oldTrack; + return true; + } + else { + // serialize as an anonymous property declaration + var varName = getUnusedName(name, symbol); + // We have to use `getWidenedType` here since the object within a json file is unwidened within the file + // (Unwidened types can only exist in expression contexts and should never be serialized) + var typeToSerialize = getWidenedType(getTypeOfSymbol(getMergedSymbol(symbol))); + if (isTypeRepresentableAsFunctionNamespaceMerge(typeToSerialize, symbol)) { + // If there are no index signatures and `typeToSerialize` is an object type, emit as a namespace instead of a const + serializeAsFunctionNamespaceMerge(typeToSerialize, symbol, varName, isExportAssignmentCompatibleSymbolName ? 0 /* ModifierFlags.None */ : 1 /* ModifierFlags.Export */); + } + else { + var statement = ts.factory.createVariableStatement(/*modifiers*/ undefined, ts.factory.createVariableDeclarationList([ + ts.factory.createVariableDeclaration(varName, /*exclamationToken*/ undefined, serializeTypeForDeclaration(context, typeToSerialize, symbol, enclosingDeclaration, includePrivateSymbol, bundled)) + ], 2 /* NodeFlags.Const */)); + // Inlined JSON types exported with [module.]exports= will already emit an export=, so should use `declare`. + // Otherwise, the type itself should be exported. + addResult(statement, target && target.flags & 4 /* SymbolFlags.Property */ && target.escapedName === "export=" /* InternalSymbolName.ExportEquals */ ? 2 /* ModifierFlags.Ambient */ + : name === varName ? 1 /* ModifierFlags.Export */ + : 0 /* ModifierFlags.None */); + } + if (isExportAssignmentCompatibleSymbolName) { + results.push(ts.factory.createExportAssignment( + /*modifiers*/ undefined, isExportEquals, ts.factory.createIdentifier(varName))); + return true; + } + else if (name !== varName) { + serializeExportSpecifier(name, varName); + return true; + } + return false; + } + } + function isTypeRepresentableAsFunctionNamespaceMerge(typeToSerialize, hostSymbol) { + // Only object types which are not constructable, or indexable, whose members all come from the + // context source file, and whose property names are all valid identifiers and not late-bound, _and_ + // whose input is not type annotated (if the input symbol has an annotation we can reuse, we should prefer it) + var ctxSrc = ts.getSourceFileOfNode(context.enclosingDeclaration); + return ts.getObjectFlags(typeToSerialize) & (16 /* ObjectFlags.Anonymous */ | 32 /* ObjectFlags.Mapped */) && + !ts.length(getIndexInfosOfType(typeToSerialize)) && + !isClassInstanceSide(typeToSerialize) && // While a class instance is potentially representable as a NS, prefer printing a reference to the instance type and serializing the class + !!(ts.length(ts.filter(getPropertiesOfType(typeToSerialize), isNamespaceMember)) || ts.length(getSignaturesOfType(typeToSerialize, 0 /* SignatureKind.Call */))) && + !ts.length(getSignaturesOfType(typeToSerialize, 1 /* SignatureKind.Construct */)) && // TODO: could probably serialize as function + ns + class, now that that's OK + !getDeclarationWithTypeAnnotation(hostSymbol, enclosingDeclaration) && + !(typeToSerialize.symbol && ts.some(typeToSerialize.symbol.declarations, function (d) { return ts.getSourceFileOfNode(d) !== ctxSrc; })) && + !ts.some(getPropertiesOfType(typeToSerialize), function (p) { return isLateBoundName(p.escapedName); }) && + !ts.some(getPropertiesOfType(typeToSerialize), function (p) { return ts.some(p.declarations, function (d) { return ts.getSourceFileOfNode(d) !== ctxSrc; }); }) && + ts.every(getPropertiesOfType(typeToSerialize), function (p) { return ts.isIdentifierText(ts.symbolName(p), languageVersion); }); + } + function makeSerializePropertySymbol(createProperty, methodKind, useAccessors) { + return function serializePropertySymbol(p, isStatic, baseType) { + var _a, _b, _c, _d, _e; + var modifierFlags = ts.getDeclarationModifierFlagsFromSymbol(p); + var isPrivate = !!(modifierFlags & 8 /* ModifierFlags.Private */); + if (isStatic && (p.flags & (788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */ | 2097152 /* SymbolFlags.Alias */))) { + // Only value-only-meaning symbols can be correctly encoded as class statics, type/namespace/alias meaning symbols + // need to be merged namespace members + return []; + } + if (p.flags & 4194304 /* SymbolFlags.Prototype */ || + (baseType && getPropertyOfType(baseType, p.escapedName) + && isReadonlySymbol(getPropertyOfType(baseType, p.escapedName)) === isReadonlySymbol(p) + && (p.flags & 16777216 /* SymbolFlags.Optional */) === (getPropertyOfType(baseType, p.escapedName).flags & 16777216 /* SymbolFlags.Optional */) + && isTypeIdenticalTo(getTypeOfSymbol(p), getTypeOfPropertyOfType(baseType, p.escapedName)))) { + return []; + } + var flag = (modifierFlags & ~512 /* ModifierFlags.Async */) | (isStatic ? 32 /* ModifierFlags.Static */ : 0); + var name = getPropertyNameNodeForSymbol(p, context); + var firstPropertyLikeDecl = (_a = p.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.or(ts.isPropertyDeclaration, ts.isAccessor, ts.isVariableDeclaration, ts.isPropertySignature, ts.isBinaryExpression, ts.isPropertyAccessExpression)); + if (p.flags & 98304 /* SymbolFlags.Accessor */ && useAccessors) { + var result = []; + if (p.flags & 65536 /* SymbolFlags.SetAccessor */) { + result.push(ts.setTextRange(ts.factory.createSetAccessorDeclaration(ts.factory.createModifiersFromModifierFlags(flag), name, [ts.factory.createParameterDeclaration( + /*modifiers*/ undefined, + /*dotDotDotToken*/ undefined, "arg", + /*questionToken*/ undefined, isPrivate ? undefined : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled))], + /*body*/ undefined), ((_b = p.declarations) === null || _b === void 0 ? void 0 : _b.find(ts.isSetAccessor)) || firstPropertyLikeDecl)); + } + if (p.flags & 32768 /* SymbolFlags.GetAccessor */) { + var isPrivate_1 = modifierFlags & 8 /* ModifierFlags.Private */; + result.push(ts.setTextRange(ts.factory.createGetAccessorDeclaration(ts.factory.createModifiersFromModifierFlags(flag), name, [], isPrivate_1 ? undefined : serializeTypeForDeclaration(context, getTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled), + /*body*/ undefined), ((_c = p.declarations) === null || _c === void 0 ? void 0 : _c.find(ts.isGetAccessor)) || firstPropertyLikeDecl)); + } + return result; + } + // This is an else/if as accessors and properties can't merge in TS, but might in JS + // If this happens, we assume the accessor takes priority, as it imposes more constraints + else if (p.flags & (4 /* SymbolFlags.Property */ | 3 /* SymbolFlags.Variable */ | 98304 /* SymbolFlags.Accessor */)) { + return ts.setTextRange(createProperty(ts.factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 64 /* ModifierFlags.Readonly */ : 0) | flag), name, p.flags & 16777216 /* SymbolFlags.Optional */ ? ts.factory.createToken(57 /* SyntaxKind.QuestionToken */) : undefined, isPrivate ? undefined : serializeTypeForDeclaration(context, getWriteTypeOfSymbol(p), p, enclosingDeclaration, includePrivateSymbol, bundled), + // TODO: https://github.com/microsoft/TypeScript/pull/32372#discussion_r328386357 + // interface members can't have initializers, however class members _can_ + /*initializer*/ undefined), ((_d = p.declarations) === null || _d === void 0 ? void 0 : _d.find(ts.or(ts.isPropertyDeclaration, ts.isVariableDeclaration))) || firstPropertyLikeDecl); + } + if (p.flags & (8192 /* SymbolFlags.Method */ | 16 /* SymbolFlags.Function */)) { + var type = getTypeOfSymbol(p); + var signatures = getSignaturesOfType(type, 0 /* SignatureKind.Call */); + if (flag & 8 /* ModifierFlags.Private */) { + return ts.setTextRange(createProperty(ts.factory.createModifiersFromModifierFlags((isReadonlySymbol(p) ? 64 /* ModifierFlags.Readonly */ : 0) | flag), name, p.flags & 16777216 /* SymbolFlags.Optional */ ? ts.factory.createToken(57 /* SyntaxKind.QuestionToken */) : undefined, + /*type*/ undefined, + /*initializer*/ undefined), ((_e = p.declarations) === null || _e === void 0 ? void 0 : _e.find(ts.isFunctionLikeDeclaration)) || signatures[0] && signatures[0].declaration || p.declarations && p.declarations[0]); + } + var results_1 = []; + for (var _i = 0, signatures_3 = signatures; _i < signatures_3.length; _i++) { + var sig = signatures_3[_i]; + // Each overload becomes a separate method declaration, in order + var decl = signatureToSignatureDeclarationHelper(sig, methodKind, context, { + name: name, + questionToken: p.flags & 16777216 /* SymbolFlags.Optional */ ? ts.factory.createToken(57 /* SyntaxKind.QuestionToken */) : undefined, + modifiers: flag ? ts.factory.createModifiersFromModifierFlags(flag) : undefined + }); + var location = sig.declaration && ts.isPrototypePropertyAssignment(sig.declaration.parent) ? sig.declaration.parent : sig.declaration; + results_1.push(ts.setTextRange(decl, location)); + } + return results_1; + } + // The `Constructor`'s symbol isn't in the class's properties lists, obviously, since it's a signature on the static + return ts.Debug.fail("Unhandled class member kind! ".concat(p.__debugFlags || p.flags)); + }; + } + function serializePropertySymbolForInterface(p, baseType) { + return serializePropertySymbolForInterfaceWorker(p, /*isStatic*/ false, baseType); + } + function serializeSignatures(kind, input, baseType, outputKind) { + var signatures = getSignaturesOfType(input, kind); + if (kind === 1 /* SignatureKind.Construct */) { + if (!baseType && ts.every(signatures, function (s) { return ts.length(s.parameters) === 0; })) { + return []; // No base type, every constructor is empty - elide the extraneous `constructor()` + } + if (baseType) { + // If there is a base type, if every signature in the class is identical to a signature in the baseType, elide all the declarations + var baseSigs = getSignaturesOfType(baseType, 1 /* SignatureKind.Construct */); + if (!ts.length(baseSigs) && ts.every(signatures, function (s) { return ts.length(s.parameters) === 0; })) { + return []; // Base had no explicit signatures, if all our signatures are also implicit, return an empty list + } + if (baseSigs.length === signatures.length) { + var failed = false; + for (var i = 0; i < baseSigs.length; i++) { + if (!compareSignaturesIdentical(signatures[i], baseSigs[i], /*partialMatch*/ false, /*ignoreThisTypes*/ false, /*ignoreReturnTypes*/ true, compareTypesIdentical)) { + failed = true; + break; + } + } + if (!failed) { + return []; // Every signature was identical - elide constructor list as it is inherited + } + } + } + var privateProtected = 0; + for (var _i = 0, signatures_4 = signatures; _i < signatures_4.length; _i++) { + var s = signatures_4[_i]; + if (s.declaration) { + privateProtected |= ts.getSelectedEffectiveModifierFlags(s.declaration, 8 /* ModifierFlags.Private */ | 16 /* ModifierFlags.Protected */); + } + } + if (privateProtected) { + return [ts.setTextRange(ts.factory.createConstructorDeclaration(ts.factory.createModifiersFromModifierFlags(privateProtected), + /*parameters*/ [], + /*body*/ undefined), signatures[0].declaration)]; + } + } + var results = []; + for (var _a = 0, signatures_5 = signatures; _a < signatures_5.length; _a++) { + var sig = signatures_5[_a]; + // Each overload becomes a separate constructor declaration, in order + var decl = signatureToSignatureDeclarationHelper(sig, outputKind, context); + results.push(ts.setTextRange(decl, sig.declaration)); + } + return results; + } + function serializeIndexSignatures(input, baseType) { + var results = []; + for (var _i = 0, _a = getIndexInfosOfType(input); _i < _a.length; _i++) { + var info = _a[_i]; + if (baseType) { + var baseInfo = getIndexInfoOfType(baseType, info.keyType); + if (baseInfo) { + if (isTypeIdenticalTo(info.type, baseInfo.type)) { + continue; // elide identical index signatures + } + } + } + results.push(indexInfoToIndexSignatureDeclarationHelper(info, context, /*typeNode*/ undefined)); + } + return results; + } + function serializeBaseType(t, staticType, rootName) { + var ref = trySerializeAsTypeReference(t, 111551 /* SymbolFlags.Value */); + if (ref) { + return ref; + } + var tempName = getUnusedName("".concat(rootName, "_base")); + var statement = ts.factory.createVariableStatement(/*modifiers*/ undefined, ts.factory.createVariableDeclarationList([ + ts.factory.createVariableDeclaration(tempName, /*exclamationToken*/ undefined, typeToTypeNodeHelper(staticType, context)) + ], 2 /* NodeFlags.Const */)); + addResult(statement, 0 /* ModifierFlags.None */); + return ts.factory.createExpressionWithTypeArguments(ts.factory.createIdentifier(tempName), /*typeArgs*/ undefined); + } + function trySerializeAsTypeReference(t, flags) { + var typeArgs; + var reference; + // We don't use `isValueSymbolAccessible` below. since that considers alternative containers (like modules) + // which we can't write out in a syntactically valid way as an expression + if (t.target && isSymbolAccessibleByFlags(t.target.symbol, enclosingDeclaration, flags)) { + typeArgs = ts.map(getTypeArguments(t), function (t) { return typeToTypeNodeHelper(t, context); }); + reference = symbolToExpression(t.target.symbol, context, 788968 /* SymbolFlags.Type */); + } + else if (t.symbol && isSymbolAccessibleByFlags(t.symbol, enclosingDeclaration, flags)) { + reference = symbolToExpression(t.symbol, context, 788968 /* SymbolFlags.Type */); + } + if (reference) { + return ts.factory.createExpressionWithTypeArguments(reference, typeArgs); + } + } + function serializeImplementedType(t) { + var ref = trySerializeAsTypeReference(t, 788968 /* SymbolFlags.Type */); + if (ref) { + return ref; + } + if (t.symbol) { + return ts.factory.createExpressionWithTypeArguments(symbolToExpression(t.symbol, context, 788968 /* SymbolFlags.Type */), /*typeArgs*/ undefined); + } + } + function getUnusedName(input, symbol) { + var _a, _b; + var id = symbol ? getSymbolId(symbol) : undefined; + if (id) { + if (context.remappedSymbolNames.has(id)) { + return context.remappedSymbolNames.get(id); + } + } + if (symbol) { + input = getNameCandidateWorker(symbol, input); + } + var i = 0; + var original = input; + while ((_a = context.usedSymbolNames) === null || _a === void 0 ? void 0 : _a.has(input)) { + i++; + input = "".concat(original, "_").concat(i); + } + (_b = context.usedSymbolNames) === null || _b === void 0 ? void 0 : _b.add(input); + if (id) { + context.remappedSymbolNames.set(id, input); + } + return input; + } + function getNameCandidateWorker(symbol, localName) { + if (localName === "default" /* InternalSymbolName.Default */ || localName === "__class" /* InternalSymbolName.Class */ || localName === "__function" /* InternalSymbolName.Function */) { + var flags = context.flags; + context.flags |= 16777216 /* NodeBuilderFlags.InInitialEntityName */; + var nameCandidate = getNameOfSymbolAsWritten(symbol, context); + context.flags = flags; + localName = nameCandidate.length > 0 && ts.isSingleOrDoubleQuote(nameCandidate.charCodeAt(0)) ? ts.stripQuotes(nameCandidate) : nameCandidate; + } + if (localName === "default" /* InternalSymbolName.Default */) { + localName = "_default"; + } + else if (localName === "export=" /* InternalSymbolName.ExportEquals */) { + localName = "_exports"; + } + localName = ts.isIdentifierText(localName, languageVersion) && !ts.isStringANonContextualKeyword(localName) ? localName : "_" + localName.replace(/[^a-zA-Z0-9]/g, "_"); + return localName; + } + function getInternalSymbolName(symbol, localName) { + var id = getSymbolId(symbol); + if (context.remappedSymbolNames.has(id)) { + return context.remappedSymbolNames.get(id); + } + localName = getNameCandidateWorker(symbol, localName); + // The result of this is going to be used as the symbol's name - lock it in, so `getUnusedName` will also pick it up + context.remappedSymbolNames.set(id, localName); + return localName; + } + } + } + function typePredicateToString(typePredicate, enclosingDeclaration, flags, writer) { + if (flags === void 0) { flags = 16384 /* TypeFormatFlags.UseAliasDefinedOutsideCurrentScope */; } + return writer ? typePredicateToStringWorker(writer).getText() : ts.usingSingleLineStringWriter(typePredicateToStringWorker); + function typePredicateToStringWorker(writer) { + var predicate = ts.factory.createTypePredicateNode(typePredicate.kind === 2 /* TypePredicateKind.AssertsThis */ || typePredicate.kind === 3 /* TypePredicateKind.AssertsIdentifier */ ? ts.factory.createToken(129 /* SyntaxKind.AssertsKeyword */) : undefined, typePredicate.kind === 1 /* TypePredicateKind.Identifier */ || typePredicate.kind === 3 /* TypePredicateKind.AssertsIdentifier */ ? ts.factory.createIdentifier(typePredicate.parameterName) : ts.factory.createThisTypeNode(), typePredicate.type && nodeBuilder.typeToTypeNode(typePredicate.type, enclosingDeclaration, toNodeBuilderFlags(flags) | 70221824 /* NodeBuilderFlags.IgnoreErrors */ | 512 /* NodeBuilderFlags.WriteTypeParametersInQualifiedName */) // TODO: GH#18217 + ); + var printer = ts.createPrinter({ removeComments: true }); + var sourceFile = enclosingDeclaration && ts.getSourceFileOfNode(enclosingDeclaration); + printer.writeNode(4 /* EmitHint.Unspecified */, predicate, /*sourceFile*/ sourceFile, writer); + return writer; + } + } + function formatUnionTypes(types) { + var result = []; + var flags = 0; + for (var i = 0; i < types.length; i++) { + var t = types[i]; + flags |= t.flags; + if (!(t.flags & 98304 /* TypeFlags.Nullable */)) { + if (t.flags & (512 /* TypeFlags.BooleanLiteral */ | 1024 /* TypeFlags.EnumLiteral */)) { + var baseType = t.flags & 512 /* TypeFlags.BooleanLiteral */ ? booleanType : getBaseTypeOfEnumLiteralType(t); + if (baseType.flags & 1048576 /* TypeFlags.Union */) { + var count = baseType.types.length; + if (i + count <= types.length && getRegularTypeOfLiteralType(types[i + count - 1]) === getRegularTypeOfLiteralType(baseType.types[count - 1])) { + result.push(baseType); + i += count - 1; + continue; + } + } + } + result.push(t); + } + } + if (flags & 65536 /* TypeFlags.Null */) + result.push(nullType); + if (flags & 32768 /* TypeFlags.Undefined */) + result.push(undefinedType); + return result || types; + } + function visibilityToString(flags) { + if (flags === 8 /* ModifierFlags.Private */) { + return "private"; + } + if (flags === 16 /* ModifierFlags.Protected */) { + return "protected"; + } + return "public"; + } + function getTypeAliasForTypeLiteral(type) { + if (type.symbol && type.symbol.flags & 2048 /* SymbolFlags.TypeLiteral */ && type.symbol.declarations) { + var node = ts.walkUpParenthesizedTypes(type.symbol.declarations[0].parent); + if (node.kind === 262 /* SyntaxKind.TypeAliasDeclaration */) { + return getSymbolOfNode(node); + } + } + return undefined; + } + function isTopLevelInExternalModuleAugmentation(node) { + return node && node.parent && + node.parent.kind === 265 /* SyntaxKind.ModuleBlock */ && + ts.isExternalModuleAugmentation(node.parent.parent); + } + function isDefaultBindingContext(location) { + return location.kind === 308 /* SyntaxKind.SourceFile */ || ts.isAmbientModule(location); + } + function getNameOfSymbolFromNameType(symbol, context) { + var nameType = getSymbolLinks(symbol).nameType; + if (nameType) { + if (nameType.flags & 384 /* TypeFlags.StringOrNumberLiteral */) { + var name = "" + nameType.value; + if (!ts.isIdentifierText(name, ts.getEmitScriptTarget(compilerOptions)) && !ts.isNumericLiteralName(name)) { + return "\"".concat(ts.escapeString(name, 34 /* CharacterCodes.doubleQuote */), "\""); + } + if (ts.isNumericLiteralName(name) && ts.startsWith(name, "-")) { + return "[".concat(name, "]"); + } + return name; + } + if (nameType.flags & 8192 /* TypeFlags.UniqueESSymbol */) { + return "[".concat(getNameOfSymbolAsWritten(nameType.symbol, context), "]"); + } + } + } + /** + * Gets a human-readable name for a symbol. + * Should *not* be used for the right-hand side of a `.` -- use `symbolName(symbol)` for that instead. + * + * Unlike `symbolName(symbol)`, this will include quotes if the name is from a string literal. + * It will also use a representation of a number as written instead of a decimal form, e.g. `0o11` instead of `9`. + */ + function getNameOfSymbolAsWritten(symbol, context) { + if (context && symbol.escapedName === "default" /* InternalSymbolName.Default */ && !(context.flags & 16384 /* NodeBuilderFlags.UseAliasDefinedOutsideCurrentScope */) && + // If it's not the first part of an entity name, it must print as `default` + (!(context.flags & 16777216 /* NodeBuilderFlags.InInitialEntityName */) || + // if the symbol is synthesized, it will only be referenced externally it must print as `default` + !symbol.declarations || + // if not in the same binding context (source file, module declaration), it must print as `default` + (context.enclosingDeclaration && ts.findAncestor(symbol.declarations[0], isDefaultBindingContext) !== ts.findAncestor(context.enclosingDeclaration, isDefaultBindingContext)))) { + return "default"; + } + if (symbol.declarations && symbol.declarations.length) { + var declaration = ts.firstDefined(symbol.declarations, function (d) { return ts.getNameOfDeclaration(d) ? d : undefined; }); // Try using a declaration with a name, first + var name_4 = declaration && ts.getNameOfDeclaration(declaration); + if (declaration && name_4) { + if (ts.isCallExpression(declaration) && ts.isBindableObjectDefinePropertyCall(declaration)) { + return ts.symbolName(symbol); + } + if (ts.isComputedPropertyName(name_4) && !(ts.getCheckFlags(symbol) & 4096 /* CheckFlags.Late */)) { + var nameType = getSymbolLinks(symbol).nameType; + if (nameType && nameType.flags & 384 /* TypeFlags.StringOrNumberLiteral */) { + // Computed property name isn't late bound, but has a well-known name type - use name type to generate a symbol name + var result = getNameOfSymbolFromNameType(symbol, context); + if (result !== undefined) { + return result; + } + } + } + return ts.declarationNameToString(name_4); + } + if (!declaration) { + declaration = symbol.declarations[0]; // Declaration may be nameless, but we'll try anyway + } + if (declaration.parent && declaration.parent.kind === 257 /* SyntaxKind.VariableDeclaration */) { + return ts.declarationNameToString(declaration.parent.name); + } + switch (declaration.kind) { + case 228 /* SyntaxKind.ClassExpression */: + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + if (context && !context.encounteredError && !(context.flags & 131072 /* NodeBuilderFlags.AllowAnonymousIdentifier */)) { + context.encounteredError = true; + } + return declaration.kind === 228 /* SyntaxKind.ClassExpression */ ? "(Anonymous class)" : "(Anonymous function)"; + } + } + var name = getNameOfSymbolFromNameType(symbol, context); + return name !== undefined ? name : ts.symbolName(symbol); + } + function isDeclarationVisible(node) { + if (node) { + var links = getNodeLinks(node); + if (links.isVisible === undefined) { + links.isVisible = !!determineIfDeclarationIsVisible(); + } + return links.isVisible; + } + return false; + function determineIfDeclarationIsVisible() { + switch (node.kind) { + case 341 /* SyntaxKind.JSDocCallbackTag */: + case 348 /* SyntaxKind.JSDocTypedefTag */: + case 342 /* SyntaxKind.JSDocEnumTag */: + // Top-level jsdoc type aliases are considered exported + // First parent is comment node, second is hosting declaration or token; we only care about those tokens or declarations whose parent is a source file + return !!(node.parent && node.parent.parent && node.parent.parent.parent && ts.isSourceFile(node.parent.parent.parent)); + case 205 /* SyntaxKind.BindingElement */: + return isDeclarationVisible(node.parent.parent); + case 257 /* SyntaxKind.VariableDeclaration */: + if (ts.isBindingPattern(node.name) && + !node.name.elements.length) { + // If the binding pattern is empty, this variable declaration is not visible + return false; + } + // falls through + case 264 /* SyntaxKind.ModuleDeclaration */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + // external module augmentation is always visible + if (ts.isExternalModuleAugmentation(node)) { + return true; + } + var parent = getDeclarationContainer(node); + // If the node is not exported or it is not ambient module element (except import declaration) + if (!(ts.getCombinedModifierFlags(node) & 1 /* ModifierFlags.Export */) && + !(node.kind !== 268 /* SyntaxKind.ImportEqualsDeclaration */ && parent.kind !== 308 /* SyntaxKind.SourceFile */ && parent.flags & 16777216 /* NodeFlags.Ambient */)) { + return isGlobalSourceFile(parent); + } + // Exported members/ambient module elements (exception import declaration) are visible if parent is visible + return isDeclarationVisible(parent); + case 169 /* SyntaxKind.PropertyDeclaration */: + case 168 /* SyntaxKind.PropertySignature */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + if (ts.hasEffectiveModifier(node, 8 /* ModifierFlags.Private */ | 16 /* ModifierFlags.Protected */)) { + // Private/protected properties/methods are not visible + return false; + } + // Public properties/methods are visible if its parents are visible, so: + // falls through + case 173 /* SyntaxKind.Constructor */: + case 177 /* SyntaxKind.ConstructSignature */: + case 176 /* SyntaxKind.CallSignature */: + case 178 /* SyntaxKind.IndexSignature */: + case 166 /* SyntaxKind.Parameter */: + case 265 /* SyntaxKind.ModuleBlock */: + case 181 /* SyntaxKind.FunctionType */: + case 182 /* SyntaxKind.ConstructorType */: + case 184 /* SyntaxKind.TypeLiteral */: + case 180 /* SyntaxKind.TypeReference */: + case 185 /* SyntaxKind.ArrayType */: + case 186 /* SyntaxKind.TupleType */: + case 189 /* SyntaxKind.UnionType */: + case 190 /* SyntaxKind.IntersectionType */: + case 193 /* SyntaxKind.ParenthesizedType */: + case 199 /* SyntaxKind.NamedTupleMember */: + return isDeclarationVisible(node.parent); + // Default binding, import specifier and namespace import is visible + // only on demand so by default it is not visible + case 270 /* SyntaxKind.ImportClause */: + case 271 /* SyntaxKind.NamespaceImport */: + case 273 /* SyntaxKind.ImportSpecifier */: + return false; + // Type parameters are always visible + case 165 /* SyntaxKind.TypeParameter */: + // Source file and namespace export are always visible + // falls through + case 308 /* SyntaxKind.SourceFile */: + case 267 /* SyntaxKind.NamespaceExportDeclaration */: + return true; + // Export assignments do not create name bindings outside the module + case 274 /* SyntaxKind.ExportAssignment */: + return false; + default: + return false; + } + } + } + function collectLinkedAliases(node, setVisibility) { + var exportSymbol; + if (node.parent && node.parent.kind === 274 /* SyntaxKind.ExportAssignment */) { + exportSymbol = resolveName(node, node.escapedText, 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */ | 2097152 /* SymbolFlags.Alias */, /*nameNotFoundMessage*/ undefined, node, /*isUse*/ false); + } + else if (node.parent.kind === 278 /* SyntaxKind.ExportSpecifier */) { + exportSymbol = getTargetOfExportSpecifier(node.parent, 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */ | 2097152 /* SymbolFlags.Alias */); + } + var result; + var visited; + if (exportSymbol) { + visited = new ts.Set(); + visited.add(getSymbolId(exportSymbol)); + buildVisibleNodeList(exportSymbol.declarations); + } + return result; + function buildVisibleNodeList(declarations) { + ts.forEach(declarations, function (declaration) { + var resultNode = getAnyImportSyntax(declaration) || declaration; + if (setVisibility) { + getNodeLinks(declaration).isVisible = true; + } + else { + result = result || []; + ts.pushIfUnique(result, resultNode); + } + if (ts.isInternalModuleImportEqualsDeclaration(declaration)) { + // Add the referenced top container visible + var internalModuleReference = declaration.moduleReference; + var firstIdentifier = ts.getFirstIdentifier(internalModuleReference); + var importSymbol = resolveName(declaration, firstIdentifier.escapedText, 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */, undefined, undefined, /*isUse*/ false); + if (importSymbol && visited) { + if (ts.tryAddToSet(visited, getSymbolId(importSymbol))) { + buildVisibleNodeList(importSymbol.declarations); + } + } + } + }); + } + } + /** + * Push an entry on the type resolution stack. If an entry with the given target and the given property name + * is already on the stack, and no entries in between already have a type, then a circularity has occurred. + * In this case, the result values of the existing entry and all entries pushed after it are changed to false, + * and the value false is returned. Otherwise, the new entry is just pushed onto the stack, and true is returned. + * In order to see if the same query has already been done before, the target object and the propertyName both + * must match the one passed in. + * + * @param target The symbol, type, or signature whose type is being queried + * @param propertyName The property name that should be used to query the target for its type + */ + function pushTypeResolution(target, propertyName) { + var resolutionCycleStartIndex = findResolutionCycleStartIndex(target, propertyName); + if (resolutionCycleStartIndex >= 0) { + // A cycle was found + var length_3 = resolutionTargets.length; + for (var i = resolutionCycleStartIndex; i < length_3; i++) { + resolutionResults[i] = false; + } + return false; + } + resolutionTargets.push(target); + resolutionResults.push(/*items*/ true); + resolutionPropertyNames.push(propertyName); + return true; + } + function findResolutionCycleStartIndex(target, propertyName) { + for (var i = resolutionTargets.length - 1; i >= 0; i--) { + if (hasType(resolutionTargets[i], resolutionPropertyNames[i])) { + return -1; + } + if (resolutionTargets[i] === target && resolutionPropertyNames[i] === propertyName) { + return i; + } + } + return -1; + } + function hasType(target, propertyName) { + switch (propertyName) { + case 0 /* TypeSystemPropertyName.Type */: + return !!getSymbolLinks(target).type; + case 5 /* TypeSystemPropertyName.EnumTagType */: + return !!(getNodeLinks(target).resolvedEnumType); + case 2 /* TypeSystemPropertyName.DeclaredType */: + return !!getSymbolLinks(target).declaredType; + case 1 /* TypeSystemPropertyName.ResolvedBaseConstructorType */: + return !!target.resolvedBaseConstructorType; + case 3 /* TypeSystemPropertyName.ResolvedReturnType */: + return !!target.resolvedReturnType; + case 4 /* TypeSystemPropertyName.ImmediateBaseConstraint */: + return !!target.immediateBaseConstraint; + case 6 /* TypeSystemPropertyName.ResolvedTypeArguments */: + return !!target.resolvedTypeArguments; + case 7 /* TypeSystemPropertyName.ResolvedBaseTypes */: + return !!target.baseTypesResolved; + case 8 /* TypeSystemPropertyName.WriteType */: + return !!getSymbolLinks(target).writeType; + } + return ts.Debug.assertNever(propertyName); + } + /** + * Pop an entry from the type resolution stack and return its associated result value. The result value will + * be true if no circularities were detected, or false if a circularity was found. + */ + function popTypeResolution() { + resolutionTargets.pop(); + resolutionPropertyNames.pop(); + return resolutionResults.pop(); + } + function getDeclarationContainer(node) { + return ts.findAncestor(ts.getRootDeclaration(node), function (node) { + switch (node.kind) { + case 257 /* SyntaxKind.VariableDeclaration */: + case 258 /* SyntaxKind.VariableDeclarationList */: + case 273 /* SyntaxKind.ImportSpecifier */: + case 272 /* SyntaxKind.NamedImports */: + case 271 /* SyntaxKind.NamespaceImport */: + case 270 /* SyntaxKind.ImportClause */: + return false; + default: + return true; + } + }).parent; + } + function getTypeOfPrototypeProperty(prototype) { + // TypeScript 1.0 spec (April 2014): 8.4 + // Every class automatically contains a static property member named 'prototype', + // the type of which is an instantiation of the class type with type Any supplied as a type argument for each type parameter. + // It is an error to explicitly declare a static property member with the name 'prototype'. + var classType = getDeclaredTypeOfSymbol(getParentOfSymbol(prototype)); + return classType.typeParameters ? createTypeReference(classType, ts.map(classType.typeParameters, function (_) { return anyType; })) : classType; + } + // Return the type of the given property in the given type, or undefined if no such property exists + function getTypeOfPropertyOfType(type, name) { + var prop = getPropertyOfType(type, name); + return prop ? getTypeOfSymbol(prop) : undefined; + } + function getTypeOfPropertyOrIndexSignature(type, name) { + var _a; + return getTypeOfPropertyOfType(type, name) || ((_a = getApplicableIndexInfoForName(type, name)) === null || _a === void 0 ? void 0 : _a.type) || unknownType; + } + function isTypeAny(type) { + return type && (type.flags & 1 /* TypeFlags.Any */) !== 0; + } + function isErrorType(type) { + // The only 'any' types that have alias symbols are those manufactured by getTypeFromTypeAliasReference for + // a reference to an unresolved symbol. We want those to behave like the errorType. + return type === errorType || !!(type.flags & 1 /* TypeFlags.Any */ && type.aliasSymbol); + } + // Return the type of a binding element parent. We check SymbolLinks first to see if a type has been + // assigned by contextual typing. + function getTypeForBindingElementParent(node, checkMode) { + if (checkMode !== 0 /* CheckMode.Normal */) { + return getTypeForVariableLikeDeclaration(node, /*includeOptionality*/ false, checkMode); + } + var symbol = getSymbolOfNode(node); + return symbol && getSymbolLinks(symbol).type || getTypeForVariableLikeDeclaration(node, /*includeOptionality*/ false, checkMode); + } + function getRestType(source, properties, symbol) { + source = filterType(source, function (t) { return !(t.flags & 98304 /* TypeFlags.Nullable */); }); + if (source.flags & 131072 /* TypeFlags.Never */) { + return emptyObjectType; + } + if (source.flags & 1048576 /* TypeFlags.Union */) { + return mapType(source, function (t) { return getRestType(t, properties, symbol); }); + } + var omitKeyType = getUnionType(ts.map(properties, getLiteralTypeFromPropertyName)); + var spreadableProperties = []; + var unspreadableToRestKeys = []; + for (var _i = 0, _a = getPropertiesOfType(source); _i < _a.length; _i++) { + var prop = _a[_i]; + var literalTypeFromProperty = getLiteralTypeFromProperty(prop, 8576 /* TypeFlags.StringOrNumberLiteralOrUnique */); + if (!isTypeAssignableTo(literalTypeFromProperty, omitKeyType) + && !(ts.getDeclarationModifierFlagsFromSymbol(prop) & (8 /* ModifierFlags.Private */ | 16 /* ModifierFlags.Protected */)) + && isSpreadableProperty(prop)) { + spreadableProperties.push(prop); + } + else { + unspreadableToRestKeys.push(literalTypeFromProperty); + } + } + if (isGenericObjectType(source) || isGenericIndexType(omitKeyType)) { + if (unspreadableToRestKeys.length) { + // If the type we're spreading from has properties that cannot + // be spread into the rest type (e.g. getters, methods), ensure + // they are explicitly omitted, as they would in the non-generic case. + omitKeyType = getUnionType(__spreadArray([omitKeyType], unspreadableToRestKeys, true)); + } + if (omitKeyType.flags & 131072 /* TypeFlags.Never */) { + return source; + } + var omitTypeAlias = getGlobalOmitSymbol(); + if (!omitTypeAlias) { + return errorType; + } + return getTypeAliasInstantiation(omitTypeAlias, [source, omitKeyType]); + } + var members = ts.createSymbolTable(); + for (var _b = 0, spreadableProperties_1 = spreadableProperties; _b < spreadableProperties_1.length; _b++) { + var prop = spreadableProperties_1[_b]; + members.set(prop.escapedName, getSpreadSymbol(prop, /*readonly*/ false)); + } + var result = createAnonymousType(symbol, members, ts.emptyArray, ts.emptyArray, getIndexInfosOfType(source)); + result.objectFlags |= 4194304 /* ObjectFlags.ObjectRestType */; + return result; + } + function isGenericTypeWithUndefinedConstraint(type) { + return !!(type.flags & 465829888 /* TypeFlags.Instantiable */) && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 32768 /* TypeFlags.Undefined */); + } + function getNonUndefinedType(type) { + var typeOrConstraint = someType(type, isGenericTypeWithUndefinedConstraint) ? mapType(type, function (t) { return t.flags & 465829888 /* TypeFlags.Instantiable */ ? getBaseConstraintOrType(t) : t; }) : type; + return getTypeWithFacts(typeOrConstraint, 524288 /* TypeFacts.NEUndefined */); + } + // Determine the control flow type associated with a destructuring declaration or assignment. The following + // forms of destructuring are possible: + // let { x } = obj; // BindingElement + // let [ x ] = obj; // BindingElement + // { x } = obj; // ShorthandPropertyAssignment + // { x: v } = obj; // PropertyAssignment + // [ x ] = obj; // Expression + // We construct a synthetic element access expression corresponding to 'obj.x' such that the control + // flow analyzer doesn't have to handle all the different syntactic forms. + function getFlowTypeOfDestructuring(node, declaredType) { + var reference = getSyntheticElementAccess(node); + return reference ? getFlowTypeOfReference(reference, declaredType) : declaredType; + } + function getSyntheticElementAccess(node) { + var parentAccess = getParentElementAccess(node); + if (parentAccess && parentAccess.flowNode) { + var propName = getDestructuringPropertyName(node); + if (propName) { + var literal = ts.setTextRange(ts.parseNodeFactory.createStringLiteral(propName), node); + var lhsExpr = ts.isLeftHandSideExpression(parentAccess) ? parentAccess : ts.parseNodeFactory.createParenthesizedExpression(parentAccess); + var result = ts.setTextRange(ts.parseNodeFactory.createElementAccessExpression(lhsExpr, literal), node); + ts.setParent(literal, result); + ts.setParent(result, node); + if (lhsExpr !== parentAccess) { + ts.setParent(lhsExpr, result); + } + result.flowNode = parentAccess.flowNode; + return result; + } + } + } + function getParentElementAccess(node) { + var ancestor = node.parent.parent; + switch (ancestor.kind) { + case 205 /* SyntaxKind.BindingElement */: + case 299 /* SyntaxKind.PropertyAssignment */: + return getSyntheticElementAccess(ancestor); + case 206 /* SyntaxKind.ArrayLiteralExpression */: + return getSyntheticElementAccess(node.parent); + case 257 /* SyntaxKind.VariableDeclaration */: + return ancestor.initializer; + case 223 /* SyntaxKind.BinaryExpression */: + return ancestor.right; + } + } + function getDestructuringPropertyName(node) { + var parent = node.parent; + if (node.kind === 205 /* SyntaxKind.BindingElement */ && parent.kind === 203 /* SyntaxKind.ObjectBindingPattern */) { + return getLiteralPropertyNameText(node.propertyName || node.name); + } + if (node.kind === 299 /* SyntaxKind.PropertyAssignment */ || node.kind === 300 /* SyntaxKind.ShorthandPropertyAssignment */) { + return getLiteralPropertyNameText(node.name); + } + return "" + parent.elements.indexOf(node); + } + function getLiteralPropertyNameText(name) { + var type = getLiteralTypeFromPropertyName(name); + return type.flags & (128 /* TypeFlags.StringLiteral */ | 256 /* TypeFlags.NumberLiteral */) ? "" + type.value : undefined; + } + /** Return the inferred type for a binding element */ + function getTypeForBindingElement(declaration) { + var checkMode = declaration.dotDotDotToken ? 64 /* CheckMode.RestBindingElement */ : 0 /* CheckMode.Normal */; + var parentType = getTypeForBindingElementParent(declaration.parent.parent, checkMode); + return parentType && getBindingElementTypeFromParentType(declaration, parentType); + } + function getBindingElementTypeFromParentType(declaration, parentType) { + // If an any type was inferred for parent, infer that for the binding element + if (isTypeAny(parentType)) { + return parentType; + } + var pattern = declaration.parent; + // Relax null check on ambient destructuring parameters, since the parameters have no implementation and are just documentation + if (strictNullChecks && declaration.flags & 16777216 /* NodeFlags.Ambient */ && ts.isParameterDeclaration(declaration)) { + parentType = getNonNullableType(parentType); + } + // Filter `undefined` from the type we check against if the parent has an initializer and that initializer is not possibly `undefined` + else if (strictNullChecks && pattern.parent.initializer && !(getTypeFacts(getTypeOfInitializer(pattern.parent.initializer)) & 65536 /* TypeFacts.EQUndefined */)) { + parentType = getTypeWithFacts(parentType, 524288 /* TypeFacts.NEUndefined */); + } + var type; + if (pattern.kind === 203 /* SyntaxKind.ObjectBindingPattern */) { + if (declaration.dotDotDotToken) { + parentType = getReducedType(parentType); + if (parentType.flags & 2 /* TypeFlags.Unknown */ || !isValidSpreadType(parentType)) { + error(declaration, ts.Diagnostics.Rest_types_may_only_be_created_from_object_types); + return errorType; + } + var literalMembers = []; + for (var _i = 0, _a = pattern.elements; _i < _a.length; _i++) { + var element = _a[_i]; + if (!element.dotDotDotToken) { + literalMembers.push(element.propertyName || element.name); + } + } + type = getRestType(parentType, literalMembers, declaration.symbol); + } + else { + // Use explicitly specified property name ({ p: xxx } form), or otherwise the implied name ({ p } form) + var name = declaration.propertyName || declaration.name; + var indexType = getLiteralTypeFromPropertyName(name); + var declaredType = getIndexedAccessType(parentType, indexType, 32 /* AccessFlags.ExpressionPosition */, name); + type = getFlowTypeOfDestructuring(declaration, declaredType); + } + } + else { + // This elementType will be used if the specific property corresponding to this index is not + // present (aka the tuple element property). This call also checks that the parentType is in + // fact an iterable or array (depending on target language). + var elementType = checkIteratedTypeOrElementType(65 /* IterationUse.Destructuring */ | (declaration.dotDotDotToken ? 0 : 128 /* IterationUse.PossiblyOutOfBounds */), parentType, undefinedType, pattern); + var index_2 = pattern.elements.indexOf(declaration); + if (declaration.dotDotDotToken) { + // If the parent is a tuple type, the rest element has a tuple type of the + // remaining tuple element types. Otherwise, the rest element has an array type with same + // element type as the parent type. + type = everyType(parentType, isTupleType) ? + mapType(parentType, function (t) { return sliceTupleType(t, index_2); }) : + createArrayType(elementType); + } + else if (isArrayLikeType(parentType)) { + var indexType = getNumberLiteralType(index_2); + var accessFlags = 32 /* AccessFlags.ExpressionPosition */ | (hasDefaultValue(declaration) ? 16 /* AccessFlags.NoTupleBoundsCheck */ : 0); + var declaredType = getIndexedAccessTypeOrUndefined(parentType, indexType, accessFlags, declaration.name) || errorType; + type = getFlowTypeOfDestructuring(declaration, declaredType); + } + else { + type = elementType; + } + } + if (!declaration.initializer) { + return type; + } + if (ts.getEffectiveTypeAnnotationNode(ts.walkUpBindingElementsAndPatterns(declaration))) { + // In strict null checking mode, if a default value of a non-undefined type is specified, remove + // undefined from the final type. + return strictNullChecks && !(getTypeFacts(checkDeclarationInitializer(declaration, 0 /* CheckMode.Normal */)) & 16777216 /* TypeFacts.IsUndefined */) ? getNonUndefinedType(type) : type; + } + return widenTypeInferredFromInitializer(declaration, getUnionType([getNonUndefinedType(type), checkDeclarationInitializer(declaration, 0 /* CheckMode.Normal */)], 2 /* UnionReduction.Subtype */)); + } + function getTypeForDeclarationFromJSDocComment(declaration) { + var jsdocType = ts.getJSDocType(declaration); + if (jsdocType) { + return getTypeFromTypeNode(jsdocType); + } + return undefined; + } + function isNullOrUndefined(node) { + var expr = ts.skipParentheses(node, /*excludeJSDocTypeAssertions*/ true); + return expr.kind === 104 /* SyntaxKind.NullKeyword */ || expr.kind === 79 /* SyntaxKind.Identifier */ && getResolvedSymbol(expr) === undefinedSymbol; + } + function isEmptyArrayLiteral(node) { + var expr = ts.skipParentheses(node, /*excludeJSDocTypeAssertions*/ true); + return expr.kind === 206 /* SyntaxKind.ArrayLiteralExpression */ && expr.elements.length === 0; + } + function addOptionality(type, isProperty, isOptional) { + if (isProperty === void 0) { isProperty = false; } + if (isOptional === void 0) { isOptional = true; } + return strictNullChecks && isOptional ? getOptionalType(type, isProperty) : type; + } + // Return the inferred type for a variable, parameter, or property declaration + function getTypeForVariableLikeDeclaration(declaration, includeOptionality, checkMode) { + // A variable declared in a for..in statement is of type string, or of type keyof T when the + // right hand expression is of a type parameter type. + if (ts.isVariableDeclaration(declaration) && declaration.parent.parent.kind === 246 /* SyntaxKind.ForInStatement */) { + var indexType = getIndexType(getNonNullableTypeIfNeeded(checkExpression(declaration.parent.parent.expression, /*checkMode*/ checkMode))); + return indexType.flags & (262144 /* TypeFlags.TypeParameter */ | 4194304 /* TypeFlags.Index */) ? getExtractStringType(indexType) : stringType; + } + if (ts.isVariableDeclaration(declaration) && declaration.parent.parent.kind === 247 /* SyntaxKind.ForOfStatement */) { + // checkRightHandSideOfForOf will return undefined if the for-of expression type was + // missing properties/signatures required to get its iteratedType (like + // [Symbol.iterator] or next). This may be because we accessed properties from anyType, + // or it may have led to an error inside getElementTypeOfIterable. + var forOfStatement = declaration.parent.parent; + return checkRightHandSideOfForOf(forOfStatement) || anyType; + } + if (ts.isBindingPattern(declaration.parent)) { + return getTypeForBindingElement(declaration); + } + var isProperty = ts.isPropertyDeclaration(declaration) && !ts.hasAccessorModifier(declaration) || ts.isPropertySignature(declaration); + var isOptional = includeOptionality && (isProperty && !!declaration.questionToken || + ts.isParameter(declaration) && (!!declaration.questionToken || isJSDocOptionalParameter(declaration)) || + isOptionalJSDocPropertyLikeTag(declaration)); + // Use type from type annotation if one is present + var declaredType = tryGetTypeFromEffectiveTypeNode(declaration); + if (declaredType) { + return addOptionality(declaredType, isProperty, isOptional); + } + if ((noImplicitAny || ts.isInJSFile(declaration)) && + ts.isVariableDeclaration(declaration) && !ts.isBindingPattern(declaration.name) && + !(ts.getCombinedModifierFlags(declaration) & 1 /* ModifierFlags.Export */) && !(declaration.flags & 16777216 /* NodeFlags.Ambient */)) { + // If --noImplicitAny is on or the declaration is in a Javascript file, + // use control flow tracked 'any' type for non-ambient, non-exported var or let variables with no + // initializer or a 'null' or 'undefined' initializer. + if (!(ts.getCombinedNodeFlags(declaration) & 2 /* NodeFlags.Const */) && (!declaration.initializer || isNullOrUndefined(declaration.initializer))) { + return autoType; + } + // Use control flow tracked 'any[]' type for non-ambient, non-exported variables with an empty array + // literal initializer. + if (declaration.initializer && isEmptyArrayLiteral(declaration.initializer)) { + return autoArrayType; + } + } + if (ts.isParameter(declaration)) { + var func = declaration.parent; + // For a parameter of a set accessor, use the type of the get accessor if one is present + if (func.kind === 175 /* SyntaxKind.SetAccessor */ && hasBindableName(func)) { + var getter = ts.getDeclarationOfKind(getSymbolOfNode(declaration.parent), 174 /* SyntaxKind.GetAccessor */); + if (getter) { + var getterSignature = getSignatureFromDeclaration(getter); + var thisParameter = getAccessorThisParameter(func); + if (thisParameter && declaration === thisParameter) { + // Use the type from the *getter* + ts.Debug.assert(!thisParameter.type); + return getTypeOfSymbol(getterSignature.thisParameter); + } + return getReturnTypeOfSignature(getterSignature); + } + } + var parameterTypeOfTypeTag = getParameterTypeOfTypeTag(func, declaration); + if (parameterTypeOfTypeTag) + return parameterTypeOfTypeTag; + // Use contextual parameter type if one is available + var type = declaration.symbol.escapedName === "this" /* InternalSymbolName.This */ ? getContextualThisParameterType(func) : getContextuallyTypedParameterType(declaration); + if (type) { + return addOptionality(type, /*isProperty*/ false, isOptional); + } + } + // Use the type of the initializer expression if one is present and the declaration is + // not a parameter of a contextually typed function + if (ts.hasOnlyExpressionInitializer(declaration) && !!declaration.initializer) { + if (ts.isInJSFile(declaration) && !ts.isParameter(declaration)) { + var containerObjectType = getJSContainerObjectType(declaration, getSymbolOfNode(declaration), ts.getDeclaredExpandoInitializer(declaration)); + if (containerObjectType) { + return containerObjectType; + } + } + var type = widenTypeInferredFromInitializer(declaration, checkDeclarationInitializer(declaration, checkMode)); + return addOptionality(type, isProperty, isOptional); + } + if (ts.isPropertyDeclaration(declaration) && (noImplicitAny || ts.isInJSFile(declaration))) { + // We have a property declaration with no type annotation or initializer, in noImplicitAny mode or a .js file. + // Use control flow analysis of this.xxx assignments in the constructor or static block to determine the type of the property. + if (!ts.hasStaticModifier(declaration)) { + var constructor = findConstructorDeclaration(declaration.parent); + var type = constructor ? getFlowTypeInConstructor(declaration.symbol, constructor) : + ts.getEffectiveModifierFlags(declaration) & 2 /* ModifierFlags.Ambient */ ? getTypeOfPropertyInBaseClass(declaration.symbol) : + undefined; + return type && addOptionality(type, /*isProperty*/ true, isOptional); + } + else { + var staticBlocks = ts.filter(declaration.parent.members, ts.isClassStaticBlockDeclaration); + var type = staticBlocks.length ? getFlowTypeInStaticBlocks(declaration.symbol, staticBlocks) : + ts.getEffectiveModifierFlags(declaration) & 2 /* ModifierFlags.Ambient */ ? getTypeOfPropertyInBaseClass(declaration.symbol) : + undefined; + return type && addOptionality(type, /*isProperty*/ true, isOptional); + } + } + if (ts.isJsxAttribute(declaration)) { + // if JSX attribute doesn't have initializer, by default the attribute will have boolean value of true. + // I.e is sugar for + return trueType; + } + // If the declaration specifies a binding pattern and is not a parameter of a contextually + // typed function, use the type implied by the binding pattern + if (ts.isBindingPattern(declaration.name)) { + return getTypeFromBindingPattern(declaration.name, /*includePatternInType*/ false, /*reportErrors*/ true); + } + // No type specified and nothing can be inferred + return undefined; + } + function isConstructorDeclaredProperty(symbol) { + // A property is considered a constructor declared property when all declaration sites are this.xxx assignments, + // when no declaration sites have JSDoc type annotations, and when at least one declaration site is in the body of + // a class constructor. + if (symbol.valueDeclaration && ts.isBinaryExpression(symbol.valueDeclaration)) { + var links = getSymbolLinks(symbol); + if (links.isConstructorDeclaredProperty === undefined) { + links.isConstructorDeclaredProperty = false; + links.isConstructorDeclaredProperty = !!getDeclaringConstructor(symbol) && ts.every(symbol.declarations, function (declaration) { + return ts.isBinaryExpression(declaration) && + isPossiblyAliasedThisProperty(declaration) && + (declaration.left.kind !== 209 /* SyntaxKind.ElementAccessExpression */ || ts.isStringOrNumericLiteralLike(declaration.left.argumentExpression)) && + !getAnnotatedTypeForAssignmentDeclaration(/*declaredType*/ undefined, declaration, symbol, declaration); + }); + } + return links.isConstructorDeclaredProperty; + } + return false; + } + function isAutoTypedProperty(symbol) { + // A property is auto-typed when its declaration has no type annotation or initializer and we're in + // noImplicitAny mode or a .js file. + var declaration = symbol.valueDeclaration; + return declaration && ts.isPropertyDeclaration(declaration) && !ts.getEffectiveTypeAnnotationNode(declaration) && + !declaration.initializer && (noImplicitAny || ts.isInJSFile(declaration)); + } + function getDeclaringConstructor(symbol) { + if (!symbol.declarations) { + return; + } + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + var container = ts.getThisContainer(declaration, /*includeArrowFunctions*/ false); + if (container && (container.kind === 173 /* SyntaxKind.Constructor */ || isJSConstructor(container))) { + return container; + } + } + } + /** Create a synthetic property access flow node after the last statement of the file */ + function getFlowTypeFromCommonJSExport(symbol) { + var file = ts.getSourceFileOfNode(symbol.declarations[0]); + var accessName = ts.unescapeLeadingUnderscores(symbol.escapedName); + var areAllModuleExports = symbol.declarations.every(function (d) { return ts.isInJSFile(d) && ts.isAccessExpression(d) && ts.isModuleExportsAccessExpression(d.expression); }); + var reference = areAllModuleExports + ? ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("module"), ts.factory.createIdentifier("exports")), accessName) + : ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("exports"), accessName); + if (areAllModuleExports) { + ts.setParent(reference.expression.expression, reference.expression); + } + ts.setParent(reference.expression, reference); + ts.setParent(reference, file); + reference.flowNode = file.endFlowNode; + return getFlowTypeOfReference(reference, autoType, undefinedType); + } + function getFlowTypeInStaticBlocks(symbol, staticBlocks) { + var accessName = ts.startsWith(symbol.escapedName, "__#") + ? ts.factory.createPrivateIdentifier(symbol.escapedName.split("@")[1]) + : ts.unescapeLeadingUnderscores(symbol.escapedName); + for (var _i = 0, staticBlocks_1 = staticBlocks; _i < staticBlocks_1.length; _i++) { + var staticBlock = staticBlocks_1[_i]; + var reference = ts.factory.createPropertyAccessExpression(ts.factory.createThis(), accessName); + ts.setParent(reference.expression, reference); + ts.setParent(reference, staticBlock); + reference.flowNode = staticBlock.returnFlowNode; + var flowType = getFlowTypeOfProperty(reference, symbol); + if (noImplicitAny && (flowType === autoType || flowType === autoArrayType)) { + error(symbol.valueDeclaration, ts.Diagnostics.Member_0_implicitly_has_an_1_type, symbolToString(symbol), typeToString(flowType)); + } + // We don't infer a type if assignments are only null or undefined. + if (everyType(flowType, isNullableType)) { + continue; + } + return convertAutoToAny(flowType); + } + } + function getFlowTypeInConstructor(symbol, constructor) { + var accessName = ts.startsWith(symbol.escapedName, "__#") + ? ts.factory.createPrivateIdentifier(symbol.escapedName.split("@")[1]) + : ts.unescapeLeadingUnderscores(symbol.escapedName); + var reference = ts.factory.createPropertyAccessExpression(ts.factory.createThis(), accessName); + ts.setParent(reference.expression, reference); + ts.setParent(reference, constructor); + reference.flowNode = constructor.returnFlowNode; + var flowType = getFlowTypeOfProperty(reference, symbol); + if (noImplicitAny && (flowType === autoType || flowType === autoArrayType)) { + error(symbol.valueDeclaration, ts.Diagnostics.Member_0_implicitly_has_an_1_type, symbolToString(symbol), typeToString(flowType)); + } + // We don't infer a type if assignments are only null or undefined. + return everyType(flowType, isNullableType) ? undefined : convertAutoToAny(flowType); + } + function getFlowTypeOfProperty(reference, prop) { + var initialType = (prop === null || prop === void 0 ? void 0 : prop.valueDeclaration) + && (!isAutoTypedProperty(prop) || ts.getEffectiveModifierFlags(prop.valueDeclaration) & 2 /* ModifierFlags.Ambient */) + && getTypeOfPropertyInBaseClass(prop) + || undefinedType; + return getFlowTypeOfReference(reference, autoType, initialType); + } + function getWidenedTypeForAssignmentDeclaration(symbol, resolvedSymbol) { + // function/class/{} initializers are themselves containers, so they won't merge in the same way as other initializers + var container = ts.getAssignedExpandoInitializer(symbol.valueDeclaration); + if (container) { + var tag = ts.getJSDocTypeTag(container); + if (tag && tag.typeExpression) { + return getTypeFromTypeNode(tag.typeExpression); + } + var containerObjectType = symbol.valueDeclaration && getJSContainerObjectType(symbol.valueDeclaration, symbol, container); + return containerObjectType || getWidenedLiteralType(checkExpressionCached(container)); + } + var type; + var definedInConstructor = false; + var definedInMethod = false; + // We use control flow analysis to determine the type of the property if the property qualifies as a constructor + // declared property and the resulting control flow type isn't just undefined or null. + if (isConstructorDeclaredProperty(symbol)) { + type = getFlowTypeInConstructor(symbol, getDeclaringConstructor(symbol)); + } + if (!type) { + var types = void 0; + if (symbol.declarations) { + var jsdocType = void 0; + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + var expression = (ts.isBinaryExpression(declaration) || ts.isCallExpression(declaration)) ? declaration : + ts.isAccessExpression(declaration) ? ts.isBinaryExpression(declaration.parent) ? declaration.parent : declaration : + undefined; + if (!expression) { + continue; // Non-assignment declaration merged in (eg, an Identifier to mark the thing as a namespace) - skip over it and pull type info from elsewhere + } + var kind = ts.isAccessExpression(expression) + ? ts.getAssignmentDeclarationPropertyAccessKind(expression) + : ts.getAssignmentDeclarationKind(expression); + if (kind === 4 /* AssignmentDeclarationKind.ThisProperty */ || ts.isBinaryExpression(expression) && isPossiblyAliasedThisProperty(expression, kind)) { + if (isDeclarationInConstructor(expression)) { + definedInConstructor = true; + } + else { + definedInMethod = true; + } + } + if (!ts.isCallExpression(expression)) { + jsdocType = getAnnotatedTypeForAssignmentDeclaration(jsdocType, expression, symbol, declaration); + } + if (!jsdocType) { + (types || (types = [])).push((ts.isBinaryExpression(expression) || ts.isCallExpression(expression)) ? getInitializerTypeFromAssignmentDeclaration(symbol, resolvedSymbol, expression, kind) : neverType); + } + } + type = jsdocType; + } + if (!type) { + if (!ts.length(types)) { + return errorType; // No types from any declarations :( + } + var constructorTypes = definedInConstructor && symbol.declarations ? getConstructorDefinedThisAssignmentTypes(types, symbol.declarations) : undefined; + // use only the constructor types unless they were only assigned null | undefined (including widening variants) + if (definedInMethod) { + var propType = getTypeOfPropertyInBaseClass(symbol); + if (propType) { + (constructorTypes || (constructorTypes = [])).push(propType); + definedInConstructor = true; + } + } + var sourceTypes = ts.some(constructorTypes, function (t) { return !!(t.flags & ~98304 /* TypeFlags.Nullable */); }) ? constructorTypes : types; // TODO: GH#18217 + type = getUnionType(sourceTypes); + } + } + var widened = getWidenedType(addOptionality(type, /*isProperty*/ false, definedInMethod && !definedInConstructor)); + if (symbol.valueDeclaration && filterType(widened, function (t) { return !!(t.flags & ~98304 /* TypeFlags.Nullable */); }) === neverType) { + reportImplicitAny(symbol.valueDeclaration, anyType); + return anyType; + } + return widened; + } + function getJSContainerObjectType(decl, symbol, init) { + var _a, _b; + if (!ts.isInJSFile(decl) || !init || !ts.isObjectLiteralExpression(init) || init.properties.length) { + return undefined; + } + var exports = ts.createSymbolTable(); + while (ts.isBinaryExpression(decl) || ts.isPropertyAccessExpression(decl)) { + var s_2 = getSymbolOfNode(decl); + if ((_a = s_2 === null || s_2 === void 0 ? void 0 : s_2.exports) === null || _a === void 0 ? void 0 : _a.size) { + mergeSymbolTable(exports, s_2.exports); + } + decl = ts.isBinaryExpression(decl) ? decl.parent : decl.parent.parent; + } + var s = getSymbolOfNode(decl); + if ((_b = s === null || s === void 0 ? void 0 : s.exports) === null || _b === void 0 ? void 0 : _b.size) { + mergeSymbolTable(exports, s.exports); + } + var type = createAnonymousType(symbol, exports, ts.emptyArray, ts.emptyArray, ts.emptyArray); + type.objectFlags |= 4096 /* ObjectFlags.JSLiteral */; + return type; + } + function getAnnotatedTypeForAssignmentDeclaration(declaredType, expression, symbol, declaration) { + var _a; + var typeNode = ts.getEffectiveTypeAnnotationNode(expression.parent); + if (typeNode) { + var type = getWidenedType(getTypeFromTypeNode(typeNode)); + if (!declaredType) { + return type; + } + else if (!isErrorType(declaredType) && !isErrorType(type) && !isTypeIdenticalTo(declaredType, type)) { + errorNextVariableOrPropertyDeclarationMustHaveSameType(/*firstDeclaration*/ undefined, declaredType, declaration, type); + } + } + if ((_a = symbol.parent) === null || _a === void 0 ? void 0 : _a.valueDeclaration) { + var typeNode_2 = ts.getEffectiveTypeAnnotationNode(symbol.parent.valueDeclaration); + if (typeNode_2) { + var annotationSymbol = getPropertyOfType(getTypeFromTypeNode(typeNode_2), symbol.escapedName); + if (annotationSymbol) { + return getNonMissingTypeOfSymbol(annotationSymbol); + } + } + } + return declaredType; + } + /** If we don't have an explicit JSDoc type, get the type from the initializer. */ + function getInitializerTypeFromAssignmentDeclaration(symbol, resolvedSymbol, expression, kind) { + if (ts.isCallExpression(expression)) { + if (resolvedSymbol) { + return getTypeOfSymbol(resolvedSymbol); // This shouldn't happen except under some hopefully forbidden merges of export assignments and object define assignments + } + var objectLitType = checkExpressionCached(expression.arguments[2]); + var valueType = getTypeOfPropertyOfType(objectLitType, "value"); + if (valueType) { + return valueType; + } + var getFunc = getTypeOfPropertyOfType(objectLitType, "get"); + if (getFunc) { + var getSig = getSingleCallSignature(getFunc); + if (getSig) { + return getReturnTypeOfSignature(getSig); + } + } + var setFunc = getTypeOfPropertyOfType(objectLitType, "set"); + if (setFunc) { + var setSig = getSingleCallSignature(setFunc); + if (setSig) { + return getTypeOfFirstParameterOfSignature(setSig); + } + } + return anyType; + } + if (containsSameNamedThisProperty(expression.left, expression.right)) { + return anyType; + } + var isDirectExport = kind === 1 /* AssignmentDeclarationKind.ExportsProperty */ && (ts.isPropertyAccessExpression(expression.left) || ts.isElementAccessExpression(expression.left)) && (ts.isModuleExportsAccessExpression(expression.left.expression) || (ts.isIdentifier(expression.left.expression) && ts.isExportsIdentifier(expression.left.expression))); + var type = resolvedSymbol ? getTypeOfSymbol(resolvedSymbol) + : isDirectExport ? getRegularTypeOfLiteralType(checkExpressionCached(expression.right)) + : getWidenedLiteralType(checkExpressionCached(expression.right)); + if (type.flags & 524288 /* TypeFlags.Object */ && + kind === 2 /* AssignmentDeclarationKind.ModuleExports */ && + symbol.escapedName === "export=" /* InternalSymbolName.ExportEquals */) { + var exportedType = resolveStructuredTypeMembers(type); + var members_4 = ts.createSymbolTable(); + ts.copyEntries(exportedType.members, members_4); + var initialSize = members_4.size; + if (resolvedSymbol && !resolvedSymbol.exports) { + resolvedSymbol.exports = ts.createSymbolTable(); + } + (resolvedSymbol || symbol).exports.forEach(function (s, name) { + var _a; + var exportedMember = members_4.get(name); + if (exportedMember && exportedMember !== s && !(s.flags & 2097152 /* SymbolFlags.Alias */)) { + if (s.flags & 111551 /* SymbolFlags.Value */ && exportedMember.flags & 111551 /* SymbolFlags.Value */) { + // If the member has an additional value-like declaration, union the types from the two declarations, + // but issue an error if they occurred in two different files. The purpose is to support a JS file with + // a pattern like: + // + // module.exports = { a: true }; + // module.exports.a = 3; + // + // but we may have a JS file with `module.exports = { a: true }` along with a TypeScript module augmentation + // declaring an `export const a: number`. In that case, we issue a duplicate identifier error, because + // it's unclear what that's supposed to mean, so it's probably a mistake. + if (s.valueDeclaration && exportedMember.valueDeclaration && ts.getSourceFileOfNode(s.valueDeclaration) !== ts.getSourceFileOfNode(exportedMember.valueDeclaration)) { + var unescapedName = ts.unescapeLeadingUnderscores(s.escapedName); + var exportedMemberName = ((_a = ts.tryCast(exportedMember.valueDeclaration, ts.isNamedDeclaration)) === null || _a === void 0 ? void 0 : _a.name) || exportedMember.valueDeclaration; + ts.addRelatedInfo(error(s.valueDeclaration, ts.Diagnostics.Duplicate_identifier_0, unescapedName), ts.createDiagnosticForNode(exportedMemberName, ts.Diagnostics._0_was_also_declared_here, unescapedName)); + ts.addRelatedInfo(error(exportedMemberName, ts.Diagnostics.Duplicate_identifier_0, unescapedName), ts.createDiagnosticForNode(s.valueDeclaration, ts.Diagnostics._0_was_also_declared_here, unescapedName)); + } + var union = createSymbol(s.flags | exportedMember.flags, name); + union.type = getUnionType([getTypeOfSymbol(s), getTypeOfSymbol(exportedMember)]); + union.valueDeclaration = exportedMember.valueDeclaration; + union.declarations = ts.concatenate(exportedMember.declarations, s.declarations); + members_4.set(name, union); + } + else { + members_4.set(name, mergeSymbol(s, exportedMember)); + } + } + else { + members_4.set(name, s); + } + }); + var result = createAnonymousType(initialSize !== members_4.size ? undefined : exportedType.symbol, // Only set the type's symbol if it looks to be the same as the original type + members_4, exportedType.callSignatures, exportedType.constructSignatures, exportedType.indexInfos); + if (initialSize === members_4.size) { + if (type.aliasSymbol) { + result.aliasSymbol = type.aliasSymbol; + result.aliasTypeArguments = type.aliasTypeArguments; + } + if (ts.getObjectFlags(type) & 4 /* ObjectFlags.Reference */) { + result.aliasSymbol = type.symbol; + var args = getTypeArguments(type); + result.aliasTypeArguments = ts.length(args) ? args : undefined; + } + } + result.objectFlags |= (ts.getObjectFlags(type) & 4096 /* ObjectFlags.JSLiteral */); // Propagate JSLiteral flag + if (result.symbol && result.symbol.flags & 32 /* SymbolFlags.Class */ && type === getDeclaredTypeOfClassOrInterface(result.symbol)) { + result.objectFlags |= 16777216 /* ObjectFlags.IsClassInstanceClone */; // Propagate the knowledge that this type is equivalent to the symbol's class instance type + } + return result; + } + if (isEmptyArrayLiteralType(type)) { + reportImplicitAny(expression, anyArrayType); + return anyArrayType; + } + return type; + } + function containsSameNamedThisProperty(thisProperty, expression) { + return ts.isPropertyAccessExpression(thisProperty) + && thisProperty.expression.kind === 108 /* SyntaxKind.ThisKeyword */ + && ts.forEachChildRecursively(expression, function (n) { return isMatchingReference(thisProperty, n); }); + } + function isDeclarationInConstructor(expression) { + var thisContainer = ts.getThisContainer(expression, /*includeArrowFunctions*/ false); + // Properties defined in a constructor (or base constructor, or javascript constructor function) don't get undefined added. + // Function expressions that are assigned to the prototype count as methods. + return thisContainer.kind === 173 /* SyntaxKind.Constructor */ || + thisContainer.kind === 259 /* SyntaxKind.FunctionDeclaration */ || + (thisContainer.kind === 215 /* SyntaxKind.FunctionExpression */ && !ts.isPrototypePropertyAssignment(thisContainer.parent)); + } + function getConstructorDefinedThisAssignmentTypes(types, declarations) { + ts.Debug.assert(types.length === declarations.length); + return types.filter(function (_, i) { + var declaration = declarations[i]; + var expression = ts.isBinaryExpression(declaration) ? declaration : + ts.isBinaryExpression(declaration.parent) ? declaration.parent : undefined; + return expression && isDeclarationInConstructor(expression); + }); + } + // Return the type implied by a binding pattern element. This is the type of the initializer of the element if + // one is present. Otherwise, if the element is itself a binding pattern, it is the type implied by the binding + // pattern. Otherwise, it is the type any. + function getTypeFromBindingElement(element, includePatternInType, reportErrors) { + if (element.initializer) { + // The type implied by a binding pattern is independent of context, so we check the initializer with no + // contextual type or, if the element itself is a binding pattern, with the type implied by that binding + // pattern. + var contextualType = ts.isBindingPattern(element.name) ? getTypeFromBindingPattern(element.name, /*includePatternInType*/ true, /*reportErrors*/ false) : unknownType; + return addOptionality(widenTypeInferredFromInitializer(element, checkDeclarationInitializer(element, 0 /* CheckMode.Normal */, contextualType))); + } + if (ts.isBindingPattern(element.name)) { + return getTypeFromBindingPattern(element.name, includePatternInType, reportErrors); + } + if (reportErrors && !declarationBelongsToPrivateAmbientMember(element)) { + reportImplicitAny(element, anyType); + } + // When we're including the pattern in the type (an indication we're obtaining a contextual type), we + // use a non-inferrable any type. Inference will never directly infer this type, but it is possible + // to infer a type that contains it, e.g. for a binding pattern like [foo] or { foo }. In such cases, + // widening of the binding pattern type substitutes a regular any for the non-inferrable any. + return includePatternInType ? nonInferrableAnyType : anyType; + } + // Return the type implied by an object binding pattern + function getTypeFromObjectBindingPattern(pattern, includePatternInType, reportErrors) { + var members = ts.createSymbolTable(); + var stringIndexInfo; + var objectFlags = 128 /* ObjectFlags.ObjectLiteral */ | 131072 /* ObjectFlags.ContainsObjectOrArrayLiteral */; + ts.forEach(pattern.elements, function (e) { + var name = e.propertyName || e.name; + if (e.dotDotDotToken) { + stringIndexInfo = createIndexInfo(stringType, anyType, /*isReadonly*/ false); + return; + } + var exprType = getLiteralTypeFromPropertyName(name); + if (!isTypeUsableAsPropertyName(exprType)) { + // do not include computed properties in the implied type + objectFlags |= 512 /* ObjectFlags.ObjectLiteralPatternWithComputedProperties */; + return; + } + var text = getPropertyNameFromType(exprType); + var flags = 4 /* SymbolFlags.Property */ | (e.initializer ? 16777216 /* SymbolFlags.Optional */ : 0); + var symbol = createSymbol(flags, text); + symbol.type = getTypeFromBindingElement(e, includePatternInType, reportErrors); + symbol.bindingElement = e; + members.set(symbol.escapedName, symbol); + }); + var result = createAnonymousType(undefined, members, ts.emptyArray, ts.emptyArray, stringIndexInfo ? [stringIndexInfo] : ts.emptyArray); + result.objectFlags |= objectFlags; + if (includePatternInType) { + result.pattern = pattern; + result.objectFlags |= 131072 /* ObjectFlags.ContainsObjectOrArrayLiteral */; + } + return result; + } + // Return the type implied by an array binding pattern + function getTypeFromArrayBindingPattern(pattern, includePatternInType, reportErrors) { + var elements = pattern.elements; + var lastElement = ts.lastOrUndefined(elements); + var restElement = lastElement && lastElement.kind === 205 /* SyntaxKind.BindingElement */ && lastElement.dotDotDotToken ? lastElement : undefined; + if (elements.length === 0 || elements.length === 1 && restElement) { + return languageVersion >= 2 /* ScriptTarget.ES2015 */ ? createIterableType(anyType) : anyArrayType; + } + var elementTypes = ts.map(elements, function (e) { return ts.isOmittedExpression(e) ? anyType : getTypeFromBindingElement(e, includePatternInType, reportErrors); }); + var minLength = ts.findLastIndex(elements, function (e) { return !(e === restElement || ts.isOmittedExpression(e) || hasDefaultValue(e)); }, elements.length - 1) + 1; + var elementFlags = ts.map(elements, function (e, i) { return e === restElement ? 4 /* ElementFlags.Rest */ : i >= minLength ? 2 /* ElementFlags.Optional */ : 1 /* ElementFlags.Required */; }); + var result = createTupleType(elementTypes, elementFlags); + if (includePatternInType) { + result = cloneTypeReference(result); + result.pattern = pattern; + result.objectFlags |= 131072 /* ObjectFlags.ContainsObjectOrArrayLiteral */; + } + return result; + } + // Return the type implied by a binding pattern. This is the type implied purely by the binding pattern itself + // and without regard to its context (i.e. without regard any type annotation or initializer associated with the + // declaration in which the binding pattern is contained). For example, the implied type of [x, y] is [any, any] + // and the implied type of { x, y: z = 1 } is { x: any; y: number; }. The type implied by a binding pattern is + // used as the contextual type of an initializer associated with the binding pattern. Also, for a destructuring + // parameter with no type annotation or initializer, the type implied by the binding pattern becomes the type of + // the parameter. + function getTypeFromBindingPattern(pattern, includePatternInType, reportErrors) { + if (includePatternInType === void 0) { includePatternInType = false; } + if (reportErrors === void 0) { reportErrors = false; } + return pattern.kind === 203 /* SyntaxKind.ObjectBindingPattern */ + ? getTypeFromObjectBindingPattern(pattern, includePatternInType, reportErrors) + : getTypeFromArrayBindingPattern(pattern, includePatternInType, reportErrors); + } + // Return the type associated with a variable, parameter, or property declaration. In the simple case this is the type + // specified in a type annotation or inferred from an initializer. However, in the case of a destructuring declaration it + // is a bit more involved. For example: + // + // var [x, s = ""] = [1, "one"]; + // + // Here, the array literal [1, "one"] is contextually typed by the type [any, string], which is the implied type of the + // binding pattern [x, s = ""]. Because the contextual type is a tuple type, the resulting type of [1, "one"] is the + // tuple type [number, string]. Thus, the type inferred for 'x' is number and the type inferred for 's' is string. + function getWidenedTypeForVariableLikeDeclaration(declaration, reportErrors) { + return widenTypeForVariableLikeDeclaration(getTypeForVariableLikeDeclaration(declaration, /*includeOptionality*/ true, 0 /* CheckMode.Normal */), declaration, reportErrors); + } + function isGlobalSymbolConstructor(node) { + var symbol = getSymbolOfNode(node); + var globalSymbol = getGlobalESSymbolConstructorTypeSymbol(/*reportErrors*/ false); + return globalSymbol && symbol && symbol === globalSymbol; + } + function widenTypeForVariableLikeDeclaration(type, declaration, reportErrors) { + if (type) { + // TODO: If back compat with pre-3.0/4.0 libs isn't required, remove the following SymbolConstructor special case transforming `symbol` into `unique symbol` + if (type.flags & 4096 /* TypeFlags.ESSymbol */ && isGlobalSymbolConstructor(declaration.parent)) { + type = getESSymbolLikeTypeForNode(declaration); + } + if (reportErrors) { + reportErrorsFromWidening(declaration, type); + } + // always widen a 'unique symbol' type if the type was created for a different declaration. + if (type.flags & 8192 /* TypeFlags.UniqueESSymbol */ && (ts.isBindingElement(declaration) || !declaration.type) && type.symbol !== getSymbolOfNode(declaration)) { + type = esSymbolType; + } + return getWidenedType(type); + } + // Rest parameters default to type any[], other parameters default to type any + type = ts.isParameter(declaration) && declaration.dotDotDotToken ? anyArrayType : anyType; + // Report implicit any errors unless this is a private property within an ambient declaration + if (reportErrors) { + if (!declarationBelongsToPrivateAmbientMember(declaration)) { + reportImplicitAny(declaration, type); + } + } + return type; + } + function declarationBelongsToPrivateAmbientMember(declaration) { + var root = ts.getRootDeclaration(declaration); + var memberDeclaration = root.kind === 166 /* SyntaxKind.Parameter */ ? root.parent : root; + return isPrivateWithinAmbient(memberDeclaration); + } + function tryGetTypeFromEffectiveTypeNode(node) { + var typeNode = ts.getEffectiveTypeAnnotationNode(node); + if (typeNode) { + return getTypeFromTypeNode(typeNode); + } + } + function getTypeOfVariableOrParameterOrProperty(symbol) { + var links = getSymbolLinks(symbol); + if (!links.type) { + var type = getTypeOfVariableOrParameterOrPropertyWorker(symbol); + // For a contextually typed parameter it is possible that a type has already + // been assigned (in assignTypeToParameterAndFixTypeParameters), and we want + // to preserve this type. + if (!links.type) { + links.type = type; + } + } + return links.type; + } + function getTypeOfVariableOrParameterOrPropertyWorker(symbol) { + // Handle prototype property + if (symbol.flags & 4194304 /* SymbolFlags.Prototype */) { + return getTypeOfPrototypeProperty(symbol); + } + // CommonsJS require and module both have type any. + if (symbol === requireSymbol) { + return anyType; + } + if (symbol.flags & 134217728 /* SymbolFlags.ModuleExports */ && symbol.valueDeclaration) { + var fileSymbol = getSymbolOfNode(ts.getSourceFileOfNode(symbol.valueDeclaration)); + var result = createSymbol(fileSymbol.flags, "exports"); + result.declarations = fileSymbol.declarations ? fileSymbol.declarations.slice() : []; + result.parent = symbol; + result.target = fileSymbol; + if (fileSymbol.valueDeclaration) + result.valueDeclaration = fileSymbol.valueDeclaration; + if (fileSymbol.members) + result.members = new ts.Map(fileSymbol.members); + if (fileSymbol.exports) + result.exports = new ts.Map(fileSymbol.exports); + var members = ts.createSymbolTable(); + members.set("exports", result); + return createAnonymousType(symbol, members, ts.emptyArray, ts.emptyArray, ts.emptyArray); + } + // Handle catch clause variables + ts.Debug.assertIsDefined(symbol.valueDeclaration); + var declaration = symbol.valueDeclaration; + if (ts.isCatchClauseVariableDeclarationOrBindingElement(declaration)) { + var typeNode = ts.getEffectiveTypeAnnotationNode(declaration); + if (typeNode === undefined) { + return useUnknownInCatchVariables ? unknownType : anyType; + } + var type_1 = getTypeOfNode(typeNode); + // an errorType will make `checkTryStatement` issue an error + return isTypeAny(type_1) || type_1 === unknownType ? type_1 : errorType; + } + // Handle export default expressions + if (ts.isSourceFile(declaration) && ts.isJsonSourceFile(declaration)) { + if (!declaration.statements.length) { + return emptyObjectType; + } + return getWidenedType(getWidenedLiteralType(checkExpression(declaration.statements[0].expression))); + } + if (ts.isAccessor(declaration)) { + // Binding of certain patterns in JS code will occasionally mark symbols as both properties + // and accessors. Here we dispatch to accessor resolution if needed. + return getTypeOfAccessors(symbol); + } + // Handle variable, parameter or property + if (!pushTypeResolution(symbol, 0 /* TypeSystemPropertyName.Type */)) { + // Symbol is property of some kind that is merged with something - should use `getTypeOfFuncClassEnumModule` and not `getTypeOfVariableOrParameterOrProperty` + if (symbol.flags & 512 /* SymbolFlags.ValueModule */ && !(symbol.flags & 67108864 /* SymbolFlags.Assignment */)) { + return getTypeOfFuncClassEnumModule(symbol); + } + return reportCircularityError(symbol); + } + var type; + if (declaration.kind === 274 /* SyntaxKind.ExportAssignment */) { + type = widenTypeForVariableLikeDeclaration(tryGetTypeFromEffectiveTypeNode(declaration) || checkExpressionCached(declaration.expression), declaration); + } + else if (ts.isBinaryExpression(declaration) || + (ts.isInJSFile(declaration) && + (ts.isCallExpression(declaration) || (ts.isPropertyAccessExpression(declaration) || ts.isBindableStaticElementAccessExpression(declaration)) && ts.isBinaryExpression(declaration.parent)))) { + type = getWidenedTypeForAssignmentDeclaration(symbol); + } + else if (ts.isPropertyAccessExpression(declaration) + || ts.isElementAccessExpression(declaration) + || ts.isIdentifier(declaration) + || ts.isStringLiteralLike(declaration) + || ts.isNumericLiteral(declaration) + || ts.isClassDeclaration(declaration) + || ts.isFunctionDeclaration(declaration) + || (ts.isMethodDeclaration(declaration) && !ts.isObjectLiteralMethod(declaration)) + || ts.isMethodSignature(declaration) + || ts.isSourceFile(declaration)) { + // Symbol is property of some kind that is merged with something - should use `getTypeOfFuncClassEnumModule` and not `getTypeOfVariableOrParameterOrProperty` + if (symbol.flags & (16 /* SymbolFlags.Function */ | 8192 /* SymbolFlags.Method */ | 32 /* SymbolFlags.Class */ | 384 /* SymbolFlags.Enum */ | 512 /* SymbolFlags.ValueModule */)) { + return getTypeOfFuncClassEnumModule(symbol); + } + type = ts.isBinaryExpression(declaration.parent) ? + getWidenedTypeForAssignmentDeclaration(symbol) : + tryGetTypeFromEffectiveTypeNode(declaration) || anyType; + } + else if (ts.isPropertyAssignment(declaration)) { + type = tryGetTypeFromEffectiveTypeNode(declaration) || checkPropertyAssignment(declaration); + } + else if (ts.isJsxAttribute(declaration)) { + type = tryGetTypeFromEffectiveTypeNode(declaration) || checkJsxAttribute(declaration); + } + else if (ts.isShorthandPropertyAssignment(declaration)) { + type = tryGetTypeFromEffectiveTypeNode(declaration) || checkExpressionForMutableLocation(declaration.name, 0 /* CheckMode.Normal */); + } + else if (ts.isObjectLiteralMethod(declaration)) { + type = tryGetTypeFromEffectiveTypeNode(declaration) || checkObjectLiteralMethod(declaration, 0 /* CheckMode.Normal */); + } + else if (ts.isParameter(declaration) + || ts.isPropertyDeclaration(declaration) + || ts.isPropertySignature(declaration) + || ts.isVariableDeclaration(declaration) + || ts.isBindingElement(declaration) + || ts.isJSDocPropertyLikeTag(declaration)) { + type = getWidenedTypeForVariableLikeDeclaration(declaration, /*includeOptionality*/ true); + } + // getTypeOfSymbol dispatches some JS merges incorrectly because their symbol flags are not mutually exclusive. + // Re-dispatch based on valueDeclaration.kind instead. + else if (ts.isEnumDeclaration(declaration)) { + type = getTypeOfFuncClassEnumModule(symbol); + } + else if (ts.isEnumMember(declaration)) { + type = getTypeOfEnumMember(symbol); + } + else { + return ts.Debug.fail("Unhandled declaration kind! " + ts.Debug.formatSyntaxKind(declaration.kind) + " for " + ts.Debug.formatSymbol(symbol)); + } + if (!popTypeResolution()) { + // Symbol is property of some kind that is merged with something - should use `getTypeOfFuncClassEnumModule` and not `getTypeOfVariableOrParameterOrProperty` + if (symbol.flags & 512 /* SymbolFlags.ValueModule */ && !(symbol.flags & 67108864 /* SymbolFlags.Assignment */)) { + return getTypeOfFuncClassEnumModule(symbol); + } + return reportCircularityError(symbol); + } + return type; + } + function getAnnotatedAccessorTypeNode(accessor) { + if (accessor) { + switch (accessor.kind) { + case 174 /* SyntaxKind.GetAccessor */: + var getterTypeAnnotation = ts.getEffectiveReturnTypeNode(accessor); + return getterTypeAnnotation; + case 175 /* SyntaxKind.SetAccessor */: + var setterTypeAnnotation = ts.getEffectiveSetAccessorTypeAnnotationNode(accessor); + return setterTypeAnnotation; + case 169 /* SyntaxKind.PropertyDeclaration */: + ts.Debug.assert(ts.hasAccessorModifier(accessor)); + var accessorTypeAnnotation = ts.getEffectiveTypeAnnotationNode(accessor); + return accessorTypeAnnotation; + } + } + return undefined; + } + function getAnnotatedAccessorType(accessor) { + var node = getAnnotatedAccessorTypeNode(accessor); + return node && getTypeFromTypeNode(node); + } + function getAnnotatedAccessorThisParameter(accessor) { + var parameter = getAccessorThisParameter(accessor); + return parameter && parameter.symbol; + } + function getThisTypeOfDeclaration(declaration) { + return getThisTypeOfSignature(getSignatureFromDeclaration(declaration)); + } + function getTypeOfAccessors(symbol) { + var links = getSymbolLinks(symbol); + if (!links.type) { + if (!pushTypeResolution(symbol, 0 /* TypeSystemPropertyName.Type */)) { + return errorType; + } + var getter = ts.getDeclarationOfKind(symbol, 174 /* SyntaxKind.GetAccessor */); + var setter = ts.getDeclarationOfKind(symbol, 175 /* SyntaxKind.SetAccessor */); + var accessor = ts.tryCast(ts.getDeclarationOfKind(symbol, 169 /* SyntaxKind.PropertyDeclaration */), ts.isAutoAccessorPropertyDeclaration); + // We try to resolve a getter type annotation, a setter type annotation, or a getter function + // body return type inference, in that order. + var type = getter && ts.isInJSFile(getter) && getTypeForDeclarationFromJSDocComment(getter) || + getAnnotatedAccessorType(getter) || + getAnnotatedAccessorType(setter) || + getAnnotatedAccessorType(accessor) || + getter && getter.body && getReturnTypeFromBody(getter) || + accessor && accessor.initializer && getWidenedTypeForVariableLikeDeclaration(accessor, /*includeOptionality*/ true); + if (!type) { + if (setter && !isPrivateWithinAmbient(setter)) { + errorOrSuggestion(noImplicitAny, setter, ts.Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation, symbolToString(symbol)); + } + else if (getter && !isPrivateWithinAmbient(getter)) { + errorOrSuggestion(noImplicitAny, getter, ts.Diagnostics.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation, symbolToString(symbol)); + } + else if (accessor && !isPrivateWithinAmbient(accessor)) { + errorOrSuggestion(noImplicitAny, accessor, ts.Diagnostics.Member_0_implicitly_has_an_1_type, symbolToString(symbol), "any"); + } + type = anyType; + } + if (!popTypeResolution()) { + if (getAnnotatedAccessorTypeNode(getter)) { + error(getter, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol)); + } + else if (getAnnotatedAccessorTypeNode(setter)) { + error(setter, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol)); + } + else if (getAnnotatedAccessorTypeNode(accessor)) { + error(setter, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol)); + } + else if (getter && noImplicitAny) { + error(getter, ts.Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, symbolToString(symbol)); + } + type = anyType; + } + links.type = type; + } + return links.type; + } + function getWriteTypeOfAccessors(symbol) { + var _a; + var links = getSymbolLinks(symbol); + if (!links.writeType) { + if (!pushTypeResolution(symbol, 8 /* TypeSystemPropertyName.WriteType */)) { + return errorType; + } + var setter = (_a = ts.getDeclarationOfKind(symbol, 175 /* SyntaxKind.SetAccessor */)) !== null && _a !== void 0 ? _a : ts.tryCast(ts.getDeclarationOfKind(symbol, 169 /* SyntaxKind.PropertyDeclaration */), ts.isAutoAccessorPropertyDeclaration); + var writeType = getAnnotatedAccessorType(setter); + if (!popTypeResolution()) { + if (getAnnotatedAccessorTypeNode(setter)) { + error(setter, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol)); + } + writeType = anyType; + } + // Absent an explicit setter type annotation we use the read type of the accessor. + links.writeType = writeType || getTypeOfAccessors(symbol); + } + return links.writeType; + } + function getBaseTypeVariableOfClass(symbol) { + var baseConstructorType = getBaseConstructorTypeOfClass(getDeclaredTypeOfClassOrInterface(symbol)); + return baseConstructorType.flags & 8650752 /* TypeFlags.TypeVariable */ ? baseConstructorType : + baseConstructorType.flags & 2097152 /* TypeFlags.Intersection */ ? ts.find(baseConstructorType.types, function (t) { return !!(t.flags & 8650752 /* TypeFlags.TypeVariable */); }) : + undefined; + } + function getTypeOfFuncClassEnumModule(symbol) { + var links = getSymbolLinks(symbol); + var originalLinks = links; + if (!links.type) { + var expando = symbol.valueDeclaration && getSymbolOfExpando(symbol.valueDeclaration, /*allowDeclaration*/ false); + if (expando) { + var merged = mergeJSSymbols(symbol, expando); + if (merged) { + // note:we overwrite links because we just cloned the symbol + symbol = links = merged; + } + } + originalLinks.type = links.type = getTypeOfFuncClassEnumModuleWorker(symbol); + } + return links.type; + } + function getTypeOfFuncClassEnumModuleWorker(symbol) { + var declaration = symbol.valueDeclaration; + if (symbol.flags & 1536 /* SymbolFlags.Module */ && ts.isShorthandAmbientModuleSymbol(symbol)) { + return anyType; + } + else if (declaration && (declaration.kind === 223 /* SyntaxKind.BinaryExpression */ || + ts.isAccessExpression(declaration) && + declaration.parent.kind === 223 /* SyntaxKind.BinaryExpression */)) { + return getWidenedTypeForAssignmentDeclaration(symbol); + } + else if (symbol.flags & 512 /* SymbolFlags.ValueModule */ && declaration && ts.isSourceFile(declaration) && declaration.commonJsModuleIndicator) { + var resolvedModule = resolveExternalModuleSymbol(symbol); + if (resolvedModule !== symbol) { + if (!pushTypeResolution(symbol, 0 /* TypeSystemPropertyName.Type */)) { + return errorType; + } + var exportEquals = getMergedSymbol(symbol.exports.get("export=" /* InternalSymbolName.ExportEquals */)); + var type_2 = getWidenedTypeForAssignmentDeclaration(exportEquals, exportEquals === resolvedModule ? undefined : resolvedModule); + if (!popTypeResolution()) { + return reportCircularityError(symbol); + } + return type_2; + } + } + var type = createObjectType(16 /* ObjectFlags.Anonymous */, symbol); + if (symbol.flags & 32 /* SymbolFlags.Class */) { + var baseTypeVariable = getBaseTypeVariableOfClass(symbol); + return baseTypeVariable ? getIntersectionType([type, baseTypeVariable]) : type; + } + else { + return strictNullChecks && symbol.flags & 16777216 /* SymbolFlags.Optional */ ? getOptionalType(type) : type; + } + } + function getTypeOfEnumMember(symbol) { + var links = getSymbolLinks(symbol); + return links.type || (links.type = getDeclaredTypeOfEnumMember(symbol)); + } + function getTypeOfAlias(symbol) { + var links = getSymbolLinks(symbol); + if (!links.type) { + var targetSymbol = resolveAlias(symbol); + var exportSymbol = symbol.declarations && getTargetOfAliasDeclaration(getDeclarationOfAliasSymbol(symbol), /*dontResolveAlias*/ true); + var declaredType = ts.firstDefined(exportSymbol === null || exportSymbol === void 0 ? void 0 : exportSymbol.declarations, function (d) { return ts.isExportAssignment(d) ? tryGetTypeFromEffectiveTypeNode(d) : undefined; }); + // It only makes sense to get the type of a value symbol. If the result of resolving + // the alias is not a value, then it has no type. To get the type associated with a + // type symbol, call getDeclaredTypeOfSymbol. + // This check is important because without it, a call to getTypeOfSymbol could end + // up recursively calling getTypeOfAlias, causing a stack overflow. + links.type = (exportSymbol === null || exportSymbol === void 0 ? void 0 : exportSymbol.declarations) && isDuplicatedCommonJSExport(exportSymbol.declarations) && symbol.declarations.length ? getFlowTypeFromCommonJSExport(exportSymbol) + : isDuplicatedCommonJSExport(symbol.declarations) ? autoType + : declaredType ? declaredType + : getAllSymbolFlags(targetSymbol) & 111551 /* SymbolFlags.Value */ ? getTypeOfSymbol(targetSymbol) + : errorType; + } + return links.type; + } + function getTypeOfInstantiatedSymbol(symbol) { + var links = getSymbolLinks(symbol); + return links.type || (links.type = instantiateType(getTypeOfSymbol(links.target), links.mapper)); + } + function getWriteTypeOfInstantiatedSymbol(symbol) { + var links = getSymbolLinks(symbol); + return links.writeType || (links.writeType = instantiateType(getWriteTypeOfSymbol(links.target), links.mapper)); + } + function reportCircularityError(symbol) { + var declaration = symbol.valueDeclaration; + // Check if variable has type annotation that circularly references the variable itself + if (ts.getEffectiveTypeAnnotationNode(declaration)) { + error(symbol.valueDeclaration, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_type_annotation, symbolToString(symbol)); + return errorType; + } + // Check if variable has initializer that circularly references the variable itself + if (noImplicitAny && (declaration.kind !== 166 /* SyntaxKind.Parameter */ || declaration.initializer)) { + error(symbol.valueDeclaration, ts.Diagnostics._0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer, symbolToString(symbol)); + } + // Circularities could also result from parameters in function expressions that end up + // having themselves as contextual types following type argument inference. In those cases + // we have already reported an implicit any error so we don't report anything here. + return anyType; + } + function getTypeOfSymbolWithDeferredType(symbol) { + var links = getSymbolLinks(symbol); + if (!links.type) { + ts.Debug.assertIsDefined(links.deferralParent); + ts.Debug.assertIsDefined(links.deferralConstituents); + links.type = links.deferralParent.flags & 1048576 /* TypeFlags.Union */ ? getUnionType(links.deferralConstituents) : getIntersectionType(links.deferralConstituents); + } + return links.type; + } + function getWriteTypeOfSymbolWithDeferredType(symbol) { + var links = getSymbolLinks(symbol); + if (!links.writeType && links.deferralWriteConstituents) { + ts.Debug.assertIsDefined(links.deferralParent); + ts.Debug.assertIsDefined(links.deferralConstituents); + links.writeType = links.deferralParent.flags & 1048576 /* TypeFlags.Union */ ? getUnionType(links.deferralWriteConstituents) : getIntersectionType(links.deferralWriteConstituents); + } + return links.writeType; + } + /** + * Distinct write types come only from set accessors, but synthetic union and intersection + * properties deriving from set accessors will either pre-compute or defer the union or + * intersection of the writeTypes of their constituents. + */ + function getWriteTypeOfSymbol(symbol) { + var checkFlags = ts.getCheckFlags(symbol); + if (symbol.flags & 4 /* SymbolFlags.Property */) { + return checkFlags & 2 /* CheckFlags.SyntheticProperty */ ? + checkFlags & 65536 /* CheckFlags.DeferredType */ ? + getWriteTypeOfSymbolWithDeferredType(symbol) || getTypeOfSymbolWithDeferredType(symbol) : + symbol.writeType || symbol.type : + getTypeOfSymbol(symbol); + } + if (symbol.flags & 98304 /* SymbolFlags.Accessor */) { + return checkFlags & 1 /* CheckFlags.Instantiated */ ? + getWriteTypeOfInstantiatedSymbol(symbol) : + getWriteTypeOfAccessors(symbol); + } + return getTypeOfSymbol(symbol); + } + function getTypeOfSymbol(symbol) { + var checkFlags = ts.getCheckFlags(symbol); + if (checkFlags & 65536 /* CheckFlags.DeferredType */) { + return getTypeOfSymbolWithDeferredType(symbol); + } + if (checkFlags & 1 /* CheckFlags.Instantiated */) { + return getTypeOfInstantiatedSymbol(symbol); + } + if (checkFlags & 262144 /* CheckFlags.Mapped */) { + return getTypeOfMappedSymbol(symbol); + } + if (checkFlags & 8192 /* CheckFlags.ReverseMapped */) { + return getTypeOfReverseMappedSymbol(symbol); + } + if (symbol.flags & (3 /* SymbolFlags.Variable */ | 4 /* SymbolFlags.Property */)) { + return getTypeOfVariableOrParameterOrProperty(symbol); + } + if (symbol.flags & (16 /* SymbolFlags.Function */ | 8192 /* SymbolFlags.Method */ | 32 /* SymbolFlags.Class */ | 384 /* SymbolFlags.Enum */ | 512 /* SymbolFlags.ValueModule */)) { + return getTypeOfFuncClassEnumModule(symbol); + } + if (symbol.flags & 8 /* SymbolFlags.EnumMember */) { + return getTypeOfEnumMember(symbol); + } + if (symbol.flags & 98304 /* SymbolFlags.Accessor */) { + return getTypeOfAccessors(symbol); + } + if (symbol.flags & 2097152 /* SymbolFlags.Alias */) { + return getTypeOfAlias(symbol); + } + return errorType; + } + function getNonMissingTypeOfSymbol(symbol) { + return removeMissingType(getTypeOfSymbol(symbol), !!(symbol.flags & 16777216 /* SymbolFlags.Optional */)); + } + function isReferenceToType(type, target) { + return type !== undefined + && target !== undefined + && (ts.getObjectFlags(type) & 4 /* ObjectFlags.Reference */) !== 0 + && type.target === target; + } + function getTargetType(type) { + return ts.getObjectFlags(type) & 4 /* ObjectFlags.Reference */ ? type.target : type; + } + // TODO: GH#18217 If `checkBase` is undefined, we should not call this because this will always return false. + function hasBaseType(type, checkBase) { + return check(type); + function check(type) { + if (ts.getObjectFlags(type) & (3 /* ObjectFlags.ClassOrInterface */ | 4 /* ObjectFlags.Reference */)) { + var target = getTargetType(type); + return target === checkBase || ts.some(getBaseTypes(target), check); + } + else if (type.flags & 2097152 /* TypeFlags.Intersection */) { + return ts.some(type.types, check); + } + return false; + } + } + // Appends the type parameters given by a list of declarations to a set of type parameters and returns the resulting set. + // The function allocates a new array if the input type parameter set is undefined, but otherwise it modifies the set + // in-place and returns the same array. + function appendTypeParameters(typeParameters, declarations) { + for (var _i = 0, declarations_2 = declarations; _i < declarations_2.length; _i++) { + var declaration = declarations_2[_i]; + typeParameters = ts.appendIfUnique(typeParameters, getDeclaredTypeOfTypeParameter(getSymbolOfNode(declaration))); + } + return typeParameters; + } + // Return the outer type parameters of a node or undefined if the node has no outer type parameters. + function getOuterTypeParameters(node, includeThisTypes) { + while (true) { + node = node.parent; // TODO: GH#18217 Use SourceFile kind check instead + if (node && ts.isBinaryExpression(node)) { + // prototype assignments get the outer type parameters of their constructor function + var assignmentKind = ts.getAssignmentDeclarationKind(node); + if (assignmentKind === 6 /* AssignmentDeclarationKind.Prototype */ || assignmentKind === 3 /* AssignmentDeclarationKind.PrototypeProperty */) { + var symbol = getSymbolOfNode(node.left); + if (symbol && symbol.parent && !ts.findAncestor(symbol.parent.valueDeclaration, function (d) { return node === d; })) { + node = symbol.parent.valueDeclaration; + } + } + } + if (!node) { + return undefined; + } + switch (node.kind) { + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 176 /* SyntaxKind.CallSignature */: + case 177 /* SyntaxKind.ConstructSignature */: + case 170 /* SyntaxKind.MethodSignature */: + case 181 /* SyntaxKind.FunctionType */: + case 182 /* SyntaxKind.ConstructorType */: + case 320 /* SyntaxKind.JSDocFunctionType */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 347 /* SyntaxKind.JSDocTemplateTag */: + case 348 /* SyntaxKind.JSDocTypedefTag */: + case 342 /* SyntaxKind.JSDocEnumTag */: + case 341 /* SyntaxKind.JSDocCallbackTag */: + case 197 /* SyntaxKind.MappedType */: + case 191 /* SyntaxKind.ConditionalType */: { + var outerTypeParameters = getOuterTypeParameters(node, includeThisTypes); + if (node.kind === 197 /* SyntaxKind.MappedType */) { + return ts.append(outerTypeParameters, getDeclaredTypeOfTypeParameter(getSymbolOfNode(node.typeParameter))); + } + else if (node.kind === 191 /* SyntaxKind.ConditionalType */) { + return ts.concatenate(outerTypeParameters, getInferTypeParameters(node)); + } + var outerAndOwnTypeParameters = appendTypeParameters(outerTypeParameters, ts.getEffectiveTypeParameterDeclarations(node)); + var thisType = includeThisTypes && + (node.kind === 260 /* SyntaxKind.ClassDeclaration */ || node.kind === 228 /* SyntaxKind.ClassExpression */ || node.kind === 261 /* SyntaxKind.InterfaceDeclaration */ || isJSConstructor(node)) && + getDeclaredTypeOfClassOrInterface(getSymbolOfNode(node)).thisType; + return thisType ? ts.append(outerAndOwnTypeParameters, thisType) : outerAndOwnTypeParameters; + } + case 343 /* SyntaxKind.JSDocParameterTag */: + var paramSymbol = ts.getParameterSymbolFromJSDoc(node); + if (paramSymbol) { + node = paramSymbol.valueDeclaration; + } + break; + case 323 /* SyntaxKind.JSDoc */: { + var outerTypeParameters = getOuterTypeParameters(node, includeThisTypes); + return node.tags + ? appendTypeParameters(outerTypeParameters, ts.flatMap(node.tags, function (t) { return ts.isJSDocTemplateTag(t) ? t.typeParameters : undefined; })) + : outerTypeParameters; + } + } + } + } + // The outer type parameters are those defined by enclosing generic classes, methods, or functions. + function getOuterTypeParametersOfClassOrInterface(symbol) { + var declaration = symbol.flags & 32 /* SymbolFlags.Class */ ? symbol.valueDeclaration : ts.getDeclarationOfKind(symbol, 261 /* SyntaxKind.InterfaceDeclaration */); + ts.Debug.assert(!!declaration, "Class was missing valueDeclaration -OR- non-class had no interface declarations"); + return getOuterTypeParameters(declaration); + } + // The local type parameters are the combined set of type parameters from all declarations of the class, + // interface, or type alias. + function getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol) { + if (!symbol.declarations) { + return; + } + var result; + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var node = _a[_i]; + if (node.kind === 261 /* SyntaxKind.InterfaceDeclaration */ || + node.kind === 260 /* SyntaxKind.ClassDeclaration */ || + node.kind === 228 /* SyntaxKind.ClassExpression */ || + isJSConstructor(node) || + ts.isTypeAlias(node)) { + var declaration = node; + result = appendTypeParameters(result, ts.getEffectiveTypeParameterDeclarations(declaration)); + } + } + return result; + } + // The full set of type parameters for a generic class or interface type consists of its outer type parameters plus + // its locally declared type parameters. + function getTypeParametersOfClassOrInterface(symbol) { + return ts.concatenate(getOuterTypeParametersOfClassOrInterface(symbol), getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol)); + } + // A type is a mixin constructor if it has a single construct signature taking no type parameters and a single + // rest parameter of type any[]. + function isMixinConstructorType(type) { + var signatures = getSignaturesOfType(type, 1 /* SignatureKind.Construct */); + if (signatures.length === 1) { + var s = signatures[0]; + if (!s.typeParameters && s.parameters.length === 1 && signatureHasRestParameter(s)) { + var paramType = getTypeOfParameter(s.parameters[0]); + return isTypeAny(paramType) || getElementTypeOfArrayType(paramType) === anyType; + } + } + return false; + } + function isConstructorType(type) { + if (getSignaturesOfType(type, 1 /* SignatureKind.Construct */).length > 0) { + return true; + } + if (type.flags & 8650752 /* TypeFlags.TypeVariable */) { + var constraint = getBaseConstraintOfType(type); + return !!constraint && isMixinConstructorType(constraint); + } + return false; + } + function getBaseTypeNodeOfClass(type) { + var decl = ts.getClassLikeDeclarationOfSymbol(type.symbol); + return decl && ts.getEffectiveBaseTypeNode(decl); + } + function getConstructorsForTypeArguments(type, typeArgumentNodes, location) { + var typeArgCount = ts.length(typeArgumentNodes); + var isJavascript = ts.isInJSFile(location); + return ts.filter(getSignaturesOfType(type, 1 /* SignatureKind.Construct */), function (sig) { return (isJavascript || typeArgCount >= getMinTypeArgumentCount(sig.typeParameters)) && typeArgCount <= ts.length(sig.typeParameters); }); + } + function getInstantiatedConstructorsForTypeArguments(type, typeArgumentNodes, location) { + var signatures = getConstructorsForTypeArguments(type, typeArgumentNodes, location); + var typeArguments = ts.map(typeArgumentNodes, getTypeFromTypeNode); + return ts.sameMap(signatures, function (sig) { return ts.some(sig.typeParameters) ? getSignatureInstantiation(sig, typeArguments, ts.isInJSFile(location)) : sig; }); + } + /** + * The base constructor of a class can resolve to + * * undefinedType if the class has no extends clause, + * * unknownType if an error occurred during resolution of the extends expression, + * * nullType if the extends expression is the null value, + * * anyType if the extends expression has type any, or + * * an object type with at least one construct signature. + */ + function getBaseConstructorTypeOfClass(type) { + if (!type.resolvedBaseConstructorType) { + var decl = ts.getClassLikeDeclarationOfSymbol(type.symbol); + var extended = decl && ts.getEffectiveBaseTypeNode(decl); + var baseTypeNode = getBaseTypeNodeOfClass(type); + if (!baseTypeNode) { + return type.resolvedBaseConstructorType = undefinedType; + } + if (!pushTypeResolution(type, 1 /* TypeSystemPropertyName.ResolvedBaseConstructorType */)) { + return errorType; + } + var baseConstructorType = checkExpression(baseTypeNode.expression); + if (extended && baseTypeNode !== extended) { + ts.Debug.assert(!extended.typeArguments); // Because this is in a JS file, and baseTypeNode is in an @extends tag + checkExpression(extended.expression); + } + if (baseConstructorType.flags & (524288 /* TypeFlags.Object */ | 2097152 /* TypeFlags.Intersection */)) { + // Resolving the members of a class requires us to resolve the base class of that class. + // We force resolution here such that we catch circularities now. + resolveStructuredTypeMembers(baseConstructorType); + } + if (!popTypeResolution()) { + error(type.symbol.valueDeclaration, ts.Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_base_expression, symbolToString(type.symbol)); + return type.resolvedBaseConstructorType = errorType; + } + if (!(baseConstructorType.flags & 1 /* TypeFlags.Any */) && baseConstructorType !== nullWideningType && !isConstructorType(baseConstructorType)) { + var err = error(baseTypeNode.expression, ts.Diagnostics.Type_0_is_not_a_constructor_function_type, typeToString(baseConstructorType)); + if (baseConstructorType.flags & 262144 /* TypeFlags.TypeParameter */) { + var constraint = getConstraintFromTypeParameter(baseConstructorType); + var ctorReturn = unknownType; + if (constraint) { + var ctorSig = getSignaturesOfType(constraint, 1 /* SignatureKind.Construct */); + if (ctorSig[0]) { + ctorReturn = getReturnTypeOfSignature(ctorSig[0]); + } + } + if (baseConstructorType.symbol.declarations) { + ts.addRelatedInfo(err, ts.createDiagnosticForNode(baseConstructorType.symbol.declarations[0], ts.Diagnostics.Did_you_mean_for_0_to_be_constrained_to_type_new_args_Colon_any_1, symbolToString(baseConstructorType.symbol), typeToString(ctorReturn))); + } + } + return type.resolvedBaseConstructorType = errorType; + } + type.resolvedBaseConstructorType = baseConstructorType; + } + return type.resolvedBaseConstructorType; + } + function getImplementsTypes(type) { + var resolvedImplementsTypes = ts.emptyArray; + if (type.symbol.declarations) { + for (var _i = 0, _a = type.symbol.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + var implementsTypeNodes = ts.getEffectiveImplementsTypeNodes(declaration); + if (!implementsTypeNodes) + continue; + for (var _b = 0, implementsTypeNodes_1 = implementsTypeNodes; _b < implementsTypeNodes_1.length; _b++) { + var node = implementsTypeNodes_1[_b]; + var implementsType = getTypeFromTypeNode(node); + if (!isErrorType(implementsType)) { + if (resolvedImplementsTypes === ts.emptyArray) { + resolvedImplementsTypes = [implementsType]; + } + else { + resolvedImplementsTypes.push(implementsType); + } + } + } + } + } + return resolvedImplementsTypes; + } + function reportCircularBaseType(node, type) { + error(node, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, /*enclosingDeclaration*/ undefined, 2 /* TypeFormatFlags.WriteArrayAsGenericType */)); + } + function getBaseTypes(type) { + if (!type.baseTypesResolved) { + if (pushTypeResolution(type, 7 /* TypeSystemPropertyName.ResolvedBaseTypes */)) { + if (type.objectFlags & 8 /* ObjectFlags.Tuple */) { + type.resolvedBaseTypes = [getTupleBaseType(type)]; + } + else if (type.symbol.flags & (32 /* SymbolFlags.Class */ | 64 /* SymbolFlags.Interface */)) { + if (type.symbol.flags & 32 /* SymbolFlags.Class */) { + resolveBaseTypesOfClass(type); + } + if (type.symbol.flags & 64 /* SymbolFlags.Interface */) { + resolveBaseTypesOfInterface(type); + } + } + else { + ts.Debug.fail("type must be class or interface"); + } + if (!popTypeResolution() && type.symbol.declarations) { + for (var _i = 0, _a = type.symbol.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + if (declaration.kind === 260 /* SyntaxKind.ClassDeclaration */ || declaration.kind === 261 /* SyntaxKind.InterfaceDeclaration */) { + reportCircularBaseType(declaration, type); + } + } + } + } + type.baseTypesResolved = true; + } + return type.resolvedBaseTypes; + } + function getTupleBaseType(type) { + var elementTypes = ts.sameMap(type.typeParameters, function (t, i) { return type.elementFlags[i] & 8 /* ElementFlags.Variadic */ ? getIndexedAccessType(t, numberType) : t; }); + return createArrayType(getUnionType(elementTypes || ts.emptyArray), type.readonly); + } + function resolveBaseTypesOfClass(type) { + type.resolvedBaseTypes = ts.resolvingEmptyArray; + var baseConstructorType = getApparentType(getBaseConstructorTypeOfClass(type)); + if (!(baseConstructorType.flags & (524288 /* TypeFlags.Object */ | 2097152 /* TypeFlags.Intersection */ | 1 /* TypeFlags.Any */))) { + return type.resolvedBaseTypes = ts.emptyArray; + } + var baseTypeNode = getBaseTypeNodeOfClass(type); + var baseType; + var originalBaseType = baseConstructorType.symbol ? getDeclaredTypeOfSymbol(baseConstructorType.symbol) : undefined; + if (baseConstructorType.symbol && baseConstructorType.symbol.flags & 32 /* SymbolFlags.Class */ && + areAllOuterTypeParametersApplied(originalBaseType)) { + // When base constructor type is a class with no captured type arguments we know that the constructors all have the same type parameters as the + // class and all return the instance type of the class. There is no need for further checks and we can apply the + // type arguments in the same manner as a type reference to get the same error reporting experience. + baseType = getTypeFromClassOrInterfaceReference(baseTypeNode, baseConstructorType.symbol); + } + else if (baseConstructorType.flags & 1 /* TypeFlags.Any */) { + baseType = baseConstructorType; + } + else { + // The class derives from a "class-like" constructor function, check that we have at least one construct signature + // with a matching number of type parameters and use the return type of the first instantiated signature. Elsewhere + // we check that all instantiated signatures return the same type. + var constructors = getInstantiatedConstructorsForTypeArguments(baseConstructorType, baseTypeNode.typeArguments, baseTypeNode); + if (!constructors.length) { + error(baseTypeNode.expression, ts.Diagnostics.No_base_constructor_has_the_specified_number_of_type_arguments); + return type.resolvedBaseTypes = ts.emptyArray; + } + baseType = getReturnTypeOfSignature(constructors[0]); + } + if (isErrorType(baseType)) { + return type.resolvedBaseTypes = ts.emptyArray; + } + var reducedBaseType = getReducedType(baseType); + if (!isValidBaseType(reducedBaseType)) { + var elaboration = elaborateNeverIntersection(/*errorInfo*/ undefined, baseType); + var diagnostic = ts.chainDiagnosticMessages(elaboration, ts.Diagnostics.Base_constructor_return_type_0_is_not_an_object_type_or_intersection_of_object_types_with_statically_known_members, typeToString(reducedBaseType)); + diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(baseTypeNode.expression, diagnostic)); + return type.resolvedBaseTypes = ts.emptyArray; + } + if (type === reducedBaseType || hasBaseType(reducedBaseType, type)) { + error(type.symbol.valueDeclaration, ts.Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, /*enclosingDeclaration*/ undefined, 2 /* TypeFormatFlags.WriteArrayAsGenericType */)); + return type.resolvedBaseTypes = ts.emptyArray; + } + if (type.resolvedBaseTypes === ts.resolvingEmptyArray) { + // Circular reference, likely through instantiation of default parameters + // (otherwise there'd be an error from hasBaseType) - this is fine, but `.members` should be reset + // as `getIndexedAccessType` via `instantiateType` via `getTypeFromClassOrInterfaceReference` forces a + // partial instantiation of the members without the base types fully resolved + type.members = undefined; + } + return type.resolvedBaseTypes = [reducedBaseType]; + } + function areAllOuterTypeParametersApplied(type) { + // An unapplied type parameter has its symbol still the same as the matching argument symbol. + // Since parameters are applied outer-to-inner, only the last outer parameter needs to be checked. + var outerTypeParameters = type.outerTypeParameters; + if (outerTypeParameters) { + var last_1 = outerTypeParameters.length - 1; + var typeArguments = getTypeArguments(type); + return outerTypeParameters[last_1].symbol !== typeArguments[last_1].symbol; + } + return true; + } + // A valid base type is `any`, an object type or intersection of object types. + function isValidBaseType(type) { + if (type.flags & 262144 /* TypeFlags.TypeParameter */) { + var constraint = getBaseConstraintOfType(type); + if (constraint) { + return isValidBaseType(constraint); + } + } + // TODO: Given that we allow type parmeters here now, is this `!isGenericMappedType(type)` check really needed? + // There's no reason a `T` should be allowed while a `Readonly` should not. + return !!(type.flags & (524288 /* TypeFlags.Object */ | 67108864 /* TypeFlags.NonPrimitive */ | 1 /* TypeFlags.Any */) && !isGenericMappedType(type) || + type.flags & 2097152 /* TypeFlags.Intersection */ && ts.every(type.types, isValidBaseType)); + } + function resolveBaseTypesOfInterface(type) { + type.resolvedBaseTypes = type.resolvedBaseTypes || ts.emptyArray; + if (type.symbol.declarations) { + for (var _i = 0, _a = type.symbol.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + if (declaration.kind === 261 /* SyntaxKind.InterfaceDeclaration */ && ts.getInterfaceBaseTypeNodes(declaration)) { + for (var _b = 0, _c = ts.getInterfaceBaseTypeNodes(declaration); _b < _c.length; _b++) { + var node = _c[_b]; + var baseType = getReducedType(getTypeFromTypeNode(node)); + if (!isErrorType(baseType)) { + if (isValidBaseType(baseType)) { + if (type !== baseType && !hasBaseType(baseType, type)) { + if (type.resolvedBaseTypes === ts.emptyArray) { + type.resolvedBaseTypes = [baseType]; + } + else { + type.resolvedBaseTypes.push(baseType); + } + } + else { + reportCircularBaseType(declaration, type); + } + } + else { + error(node, ts.Diagnostics.An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_members); + } + } + } + } + } + } + } + /** + * Returns true if the interface given by the symbol is free of "this" references. + * + * Specifically, the result is true if the interface itself contains no references + * to "this" in its body, if all base types are interfaces, + * and if none of the base interfaces have a "this" type. + */ + function isThislessInterface(symbol) { + if (!symbol.declarations) { + return true; + } + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + if (declaration.kind === 261 /* SyntaxKind.InterfaceDeclaration */) { + if (declaration.flags & 128 /* NodeFlags.ContainsThis */) { + return false; + } + var baseTypeNodes = ts.getInterfaceBaseTypeNodes(declaration); + if (baseTypeNodes) { + for (var _b = 0, baseTypeNodes_1 = baseTypeNodes; _b < baseTypeNodes_1.length; _b++) { + var node = baseTypeNodes_1[_b]; + if (ts.isEntityNameExpression(node.expression)) { + var baseSymbol = resolveEntityName(node.expression, 788968 /* SymbolFlags.Type */, /*ignoreErrors*/ true); + if (!baseSymbol || !(baseSymbol.flags & 64 /* SymbolFlags.Interface */) || getDeclaredTypeOfClassOrInterface(baseSymbol).thisType) { + return false; + } + } + } + } + } + } + return true; + } + function getDeclaredTypeOfClassOrInterface(symbol) { + var links = getSymbolLinks(symbol); + var originalLinks = links; + if (!links.declaredType) { + var kind = symbol.flags & 32 /* SymbolFlags.Class */ ? 1 /* ObjectFlags.Class */ : 2 /* ObjectFlags.Interface */; + var merged = mergeJSSymbols(symbol, symbol.valueDeclaration && getAssignedClassSymbol(symbol.valueDeclaration)); + if (merged) { + // note:we overwrite links because we just cloned the symbol + symbol = links = merged; + } + var type = originalLinks.declaredType = links.declaredType = createObjectType(kind, symbol); + var outerTypeParameters = getOuterTypeParametersOfClassOrInterface(symbol); + var localTypeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol); + // A class or interface is generic if it has type parameters or a "this" type. We always give classes a "this" type + // because it is not feasible to analyze all members to determine if the "this" type escapes the class (in particular, + // property types inferred from initializers and method return types inferred from return statements are very hard + // to exhaustively analyze). We give interfaces a "this" type if we can't definitely determine that they are free of + // "this" references. + if (outerTypeParameters || localTypeParameters || kind === 1 /* ObjectFlags.Class */ || !isThislessInterface(symbol)) { + type.objectFlags |= 4 /* ObjectFlags.Reference */; + type.typeParameters = ts.concatenate(outerTypeParameters, localTypeParameters); + type.outerTypeParameters = outerTypeParameters; + type.localTypeParameters = localTypeParameters; + type.instantiations = new ts.Map(); + type.instantiations.set(getTypeListId(type.typeParameters), type); + type.target = type; + type.resolvedTypeArguments = type.typeParameters; + type.thisType = createTypeParameter(symbol); + type.thisType.isThisType = true; + type.thisType.constraint = type; + } + } + return links.declaredType; + } + function getDeclaredTypeOfTypeAlias(symbol) { + var _a; + var links = getSymbolLinks(symbol); + if (!links.declaredType) { + // Note that we use the links object as the target here because the symbol object is used as the unique + // identity for resolution of the 'type' property in SymbolLinks. + if (!pushTypeResolution(symbol, 2 /* TypeSystemPropertyName.DeclaredType */)) { + return errorType; + } + var declaration = ts.Debug.checkDefined((_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isTypeAlias), "Type alias symbol with no valid declaration found"); + var typeNode = ts.isJSDocTypeAlias(declaration) ? declaration.typeExpression : declaration.type; + // If typeNode is missing, we will error in checkJSDocTypedefTag. + var type = typeNode ? getTypeFromTypeNode(typeNode) : errorType; + if (popTypeResolution()) { + var typeParameters = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol); + if (typeParameters) { + // Initialize the instantiation cache for generic type aliases. The declared type corresponds to + // an instantiation of the type alias with the type parameters supplied as type arguments. + links.typeParameters = typeParameters; + links.instantiations = new ts.Map(); + links.instantiations.set(getTypeListId(typeParameters), type); + } + } + else { + type = errorType; + if (declaration.kind === 342 /* SyntaxKind.JSDocEnumTag */) { + error(declaration.typeExpression.type, ts.Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol)); + } + else { + error(ts.isNamedDeclaration(declaration) ? declaration.name || declaration : declaration, ts.Diagnostics.Type_alias_0_circularly_references_itself, symbolToString(symbol)); + } + } + links.declaredType = type; + } + return links.declaredType; + } + function isStringConcatExpression(expr) { + if (ts.isStringLiteralLike(expr)) { + return true; + } + else if (expr.kind === 223 /* SyntaxKind.BinaryExpression */) { + return isStringConcatExpression(expr.left) && isStringConcatExpression(expr.right); + } + return false; + } + function isLiteralEnumMember(member) { + var expr = member.initializer; + if (!expr) { + return !(member.flags & 16777216 /* NodeFlags.Ambient */); + } + switch (expr.kind) { + case 10 /* SyntaxKind.StringLiteral */: + case 8 /* SyntaxKind.NumericLiteral */: + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + return true; + case 221 /* SyntaxKind.PrefixUnaryExpression */: + return expr.operator === 40 /* SyntaxKind.MinusToken */ && + expr.operand.kind === 8 /* SyntaxKind.NumericLiteral */; + case 79 /* SyntaxKind.Identifier */: + return ts.nodeIsMissing(expr) || !!getSymbolOfNode(member.parent).exports.get(expr.escapedText); + case 223 /* SyntaxKind.BinaryExpression */: + return isStringConcatExpression(expr); + default: + return false; + } + } + function getEnumKind(symbol) { + var links = getSymbolLinks(symbol); + if (links.enumKind !== undefined) { + return links.enumKind; + } + var hasNonLiteralMember = false; + if (symbol.declarations) { + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + if (declaration.kind === 263 /* SyntaxKind.EnumDeclaration */) { + for (var _b = 0, _c = declaration.members; _b < _c.length; _b++) { + var member = _c[_b]; + if (member.initializer && ts.isStringLiteralLike(member.initializer)) { + return links.enumKind = 1 /* EnumKind.Literal */; + } + if (!isLiteralEnumMember(member)) { + hasNonLiteralMember = true; + } + } + } + } + } + return links.enumKind = hasNonLiteralMember ? 0 /* EnumKind.Numeric */ : 1 /* EnumKind.Literal */; + } + function getBaseTypeOfEnumLiteralType(type) { + return type.flags & 1024 /* TypeFlags.EnumLiteral */ && !(type.flags & 1048576 /* TypeFlags.Union */) ? getDeclaredTypeOfSymbol(getParentOfSymbol(type.symbol)) : type; + } + function getDeclaredTypeOfEnum(symbol) { + var links = getSymbolLinks(symbol); + if (links.declaredType) { + return links.declaredType; + } + if (getEnumKind(symbol) === 1 /* EnumKind.Literal */) { + enumCount++; + var memberTypeList = []; + if (symbol.declarations) { + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + if (declaration.kind === 263 /* SyntaxKind.EnumDeclaration */) { + for (var _b = 0, _c = declaration.members; _b < _c.length; _b++) { + var member = _c[_b]; + var value = getEnumMemberValue(member); + var memberType = getFreshTypeOfLiteralType(getEnumLiteralType(value !== undefined ? value : 0, enumCount, getSymbolOfNode(member))); + getSymbolLinks(getSymbolOfNode(member)).declaredType = memberType; + memberTypeList.push(getRegularTypeOfLiteralType(memberType)); + } + } + } + } + if (memberTypeList.length) { + var enumType_1 = getUnionType(memberTypeList, 1 /* UnionReduction.Literal */, symbol, /*aliasTypeArguments*/ undefined); + if (enumType_1.flags & 1048576 /* TypeFlags.Union */) { + enumType_1.flags |= 1024 /* TypeFlags.EnumLiteral */; + enumType_1.symbol = symbol; + } + return links.declaredType = enumType_1; + } + } + var enumType = createType(32 /* TypeFlags.Enum */); + enumType.symbol = symbol; + return links.declaredType = enumType; + } + function getDeclaredTypeOfEnumMember(symbol) { + var links = getSymbolLinks(symbol); + if (!links.declaredType) { + var enumType = getDeclaredTypeOfEnum(getParentOfSymbol(symbol)); + if (!links.declaredType) { + links.declaredType = enumType; + } + } + return links.declaredType; + } + function getDeclaredTypeOfTypeParameter(symbol) { + var links = getSymbolLinks(symbol); + return links.declaredType || (links.declaredType = createTypeParameter(symbol)); + } + function getDeclaredTypeOfAlias(symbol) { + var links = getSymbolLinks(symbol); + return links.declaredType || (links.declaredType = getDeclaredTypeOfSymbol(resolveAlias(symbol))); + } + function getDeclaredTypeOfSymbol(symbol) { + return tryGetDeclaredTypeOfSymbol(symbol) || errorType; + } + function tryGetDeclaredTypeOfSymbol(symbol) { + if (symbol.flags & (32 /* SymbolFlags.Class */ | 64 /* SymbolFlags.Interface */)) { + return getDeclaredTypeOfClassOrInterface(symbol); + } + if (symbol.flags & 524288 /* SymbolFlags.TypeAlias */) { + return getDeclaredTypeOfTypeAlias(symbol); + } + if (symbol.flags & 262144 /* SymbolFlags.TypeParameter */) { + return getDeclaredTypeOfTypeParameter(symbol); + } + if (symbol.flags & 384 /* SymbolFlags.Enum */) { + return getDeclaredTypeOfEnum(symbol); + } + if (symbol.flags & 8 /* SymbolFlags.EnumMember */) { + return getDeclaredTypeOfEnumMember(symbol); + } + if (symbol.flags & 2097152 /* SymbolFlags.Alias */) { + return getDeclaredTypeOfAlias(symbol); + } + return undefined; + } + /** + * A type is free of this references if it's the any, string, number, boolean, symbol, or void keyword, a string + * literal type, an array with an element type that is free of this references, or a type reference that is + * free of this references. + */ + function isThislessType(node) { + switch (node.kind) { + case 131 /* SyntaxKind.AnyKeyword */: + case 157 /* SyntaxKind.UnknownKeyword */: + case 152 /* SyntaxKind.StringKeyword */: + case 148 /* SyntaxKind.NumberKeyword */: + case 160 /* SyntaxKind.BigIntKeyword */: + case 134 /* SyntaxKind.BooleanKeyword */: + case 153 /* SyntaxKind.SymbolKeyword */: + case 149 /* SyntaxKind.ObjectKeyword */: + case 114 /* SyntaxKind.VoidKeyword */: + case 155 /* SyntaxKind.UndefinedKeyword */: + case 144 /* SyntaxKind.NeverKeyword */: + case 198 /* SyntaxKind.LiteralType */: + return true; + case 185 /* SyntaxKind.ArrayType */: + return isThislessType(node.elementType); + case 180 /* SyntaxKind.TypeReference */: + return !node.typeArguments || node.typeArguments.every(isThislessType); + } + return false; + } + /** A type parameter is thisless if its constraint is thisless, or if it has no constraint. */ + function isThislessTypeParameter(node) { + var constraint = ts.getEffectiveConstraintOfTypeParameter(node); + return !constraint || isThislessType(constraint); + } + /** + * A variable-like declaration is free of this references if it has a type annotation + * that is thisless, or if it has no type annotation and no initializer (and is thus of type any). + */ + function isThislessVariableLikeDeclaration(node) { + var typeNode = ts.getEffectiveTypeAnnotationNode(node); + return typeNode ? isThislessType(typeNode) : !ts.hasInitializer(node); + } + /** + * A function-like declaration is considered free of `this` references if it has a return type + * annotation that is free of this references and if each parameter is thisless and if + * each type parameter (if present) is thisless. + */ + function isThislessFunctionLikeDeclaration(node) { + var returnType = ts.getEffectiveReturnTypeNode(node); + var typeParameters = ts.getEffectiveTypeParameterDeclarations(node); + return (node.kind === 173 /* SyntaxKind.Constructor */ || (!!returnType && isThislessType(returnType))) && + node.parameters.every(isThislessVariableLikeDeclaration) && + typeParameters.every(isThislessTypeParameter); + } + /** + * Returns true if the class or interface member given by the symbol is free of "this" references. The + * function may return false for symbols that are actually free of "this" references because it is not + * feasible to perform a complete analysis in all cases. In particular, property members with types + * inferred from their initializers and function members with inferred return types are conservatively + * assumed not to be free of "this" references. + */ + function isThisless(symbol) { + if (symbol.declarations && symbol.declarations.length === 1) { + var declaration = symbol.declarations[0]; + if (declaration) { + switch (declaration.kind) { + case 169 /* SyntaxKind.PropertyDeclaration */: + case 168 /* SyntaxKind.PropertySignature */: + return isThislessVariableLikeDeclaration(declaration); + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + case 173 /* SyntaxKind.Constructor */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + return isThislessFunctionLikeDeclaration(declaration); + } + } + } + return false; + } + // The mappingThisOnly flag indicates that the only type parameter being mapped is "this". When the flag is true, + // we check symbols to see if we can quickly conclude they are free of "this" references, thus needing no instantiation. + function createInstantiatedSymbolTable(symbols, mapper, mappingThisOnly) { + var result = ts.createSymbolTable(); + for (var _i = 0, symbols_2 = symbols; _i < symbols_2.length; _i++) { + var symbol = symbols_2[_i]; + result.set(symbol.escapedName, mappingThisOnly && isThisless(symbol) ? symbol : instantiateSymbol(symbol, mapper)); + } + return result; + } + function addInheritedMembers(symbols, baseSymbols) { + for (var _i = 0, baseSymbols_1 = baseSymbols; _i < baseSymbols_1.length; _i++) { + var s = baseSymbols_1[_i]; + if (!symbols.has(s.escapedName) && !isStaticPrivateIdentifierProperty(s)) { + symbols.set(s.escapedName, s); + } + } + } + function isStaticPrivateIdentifierProperty(s) { + return !!s.valueDeclaration && ts.isPrivateIdentifierClassElementDeclaration(s.valueDeclaration) && ts.isStatic(s.valueDeclaration); + } + function resolveDeclaredMembers(type) { + if (!type.declaredProperties) { + var symbol = type.symbol; + var members = getMembersOfSymbol(symbol); + type.declaredProperties = getNamedMembers(members); + // Start with signatures at empty array in case of recursive types + type.declaredCallSignatures = ts.emptyArray; + type.declaredConstructSignatures = ts.emptyArray; + type.declaredIndexInfos = ts.emptyArray; + type.declaredCallSignatures = getSignaturesOfSymbol(members.get("__call" /* InternalSymbolName.Call */)); + type.declaredConstructSignatures = getSignaturesOfSymbol(members.get("__new" /* InternalSymbolName.New */)); + type.declaredIndexInfos = getIndexInfosOfSymbol(symbol); + } + return type; + } + /** + * Indicates whether a type can be used as a property name. + */ + function isTypeUsableAsPropertyName(type) { + return !!(type.flags & 8576 /* TypeFlags.StringOrNumberLiteralOrUnique */); + } + /** + * Indicates whether a declaration name is definitely late-bindable. + * A declaration name is only late-bindable if: + * - It is a `ComputedPropertyName`. + * - Its expression is an `Identifier` or either a `PropertyAccessExpression` an + * `ElementAccessExpression` consisting only of these same three types of nodes. + * - The type of its expression is a string or numeric literal type, or is a `unique symbol` type. + */ + function isLateBindableName(node) { + if (!ts.isComputedPropertyName(node) && !ts.isElementAccessExpression(node)) { + return false; + } + var expr = ts.isComputedPropertyName(node) ? node.expression : node.argumentExpression; + return ts.isEntityNameExpression(expr) + && isTypeUsableAsPropertyName(ts.isComputedPropertyName(node) ? checkComputedPropertyName(node) : checkExpressionCached(expr)); + } + function isLateBoundName(name) { + return name.charCodeAt(0) === 95 /* CharacterCodes._ */ && + name.charCodeAt(1) === 95 /* CharacterCodes._ */ && + name.charCodeAt(2) === 64 /* CharacterCodes.at */; + } + /** + * Indicates whether a declaration has a late-bindable dynamic name. + */ + function hasLateBindableName(node) { + var name = ts.getNameOfDeclaration(node); + return !!name && isLateBindableName(name); + } + /** + * Indicates whether a declaration has an early-bound name or a dynamic name that can be late-bound. + */ + function hasBindableName(node) { + return !ts.hasDynamicName(node) || hasLateBindableName(node); + } + /** + * Indicates whether a declaration name is a dynamic name that cannot be late-bound. + */ + function isNonBindableDynamicName(node) { + return ts.isDynamicName(node) && !isLateBindableName(node); + } + /** + * Gets the symbolic name for a member from its type. + */ + function getPropertyNameFromType(type) { + if (type.flags & 8192 /* TypeFlags.UniqueESSymbol */) { + return type.escapedName; + } + if (type.flags & (128 /* TypeFlags.StringLiteral */ | 256 /* TypeFlags.NumberLiteral */)) { + return ts.escapeLeadingUnderscores("" + type.value); + } + return ts.Debug.fail(); + } + /** + * Adds a declaration to a late-bound dynamic member. This performs the same function for + * late-bound members that `addDeclarationToSymbol` in binder.ts performs for early-bound + * members. + */ + function addDeclarationToLateBoundSymbol(symbol, member, symbolFlags) { + ts.Debug.assert(!!(ts.getCheckFlags(symbol) & 4096 /* CheckFlags.Late */), "Expected a late-bound symbol."); + symbol.flags |= symbolFlags; + getSymbolLinks(member.symbol).lateSymbol = symbol; + if (!symbol.declarations) { + symbol.declarations = [member]; + } + else if (!member.symbol.isReplaceableByMethod) { + symbol.declarations.push(member); + } + if (symbolFlags & 111551 /* SymbolFlags.Value */) { + if (!symbol.valueDeclaration || symbol.valueDeclaration.kind !== member.kind) { + symbol.valueDeclaration = member; + } + } + } + /** + * Performs late-binding of a dynamic member. This performs the same function for + * late-bound members that `declareSymbol` in binder.ts performs for early-bound + * members. + * + * If a symbol is a dynamic name from a computed property, we perform an additional "late" + * binding phase to attempt to resolve the name for the symbol from the type of the computed + * property's expression. If the type of the expression is a string-literal, numeric-literal, + * or unique symbol type, we can use that type as the name of the symbol. + * + * For example, given: + * + * const x = Symbol(); + * + * interface I { + * [x]: number; + * } + * + * The binder gives the property `[x]: number` a special symbol with the name "__computed". + * In the late-binding phase we can type-check the expression `x` and see that it has a + * unique symbol type which we can then use as the name of the member. This allows users + * to define custom symbols that can be used in the members of an object type. + * + * @param parent The containing symbol for the member. + * @param earlySymbols The early-bound symbols of the parent. + * @param lateSymbols The late-bound symbols of the parent. + * @param decl The member to bind. + */ + function lateBindMember(parent, earlySymbols, lateSymbols, decl) { + ts.Debug.assert(!!decl.symbol, "The member is expected to have a symbol."); + var links = getNodeLinks(decl); + if (!links.resolvedSymbol) { + // In the event we attempt to resolve the late-bound name of this member recursively, + // fall back to the early-bound name of this member. + links.resolvedSymbol = decl.symbol; + var declName = ts.isBinaryExpression(decl) ? decl.left : decl.name; + var type = ts.isElementAccessExpression(declName) ? checkExpressionCached(declName.argumentExpression) : checkComputedPropertyName(declName); + if (isTypeUsableAsPropertyName(type)) { + var memberName = getPropertyNameFromType(type); + var symbolFlags = decl.symbol.flags; + // Get or add a late-bound symbol for the member. This allows us to merge late-bound accessor declarations. + var lateSymbol = lateSymbols.get(memberName); + if (!lateSymbol) + lateSymbols.set(memberName, lateSymbol = createSymbol(0 /* SymbolFlags.None */, memberName, 4096 /* CheckFlags.Late */)); + // Report an error if a late-bound member has the same name as an early-bound member, + // or if we have another early-bound symbol declaration with the same name and + // conflicting flags. + var earlySymbol = earlySymbols && earlySymbols.get(memberName); + if (lateSymbol.flags & getExcludedSymbolFlags(symbolFlags) || earlySymbol) { + // If we have an existing early-bound member, combine its declarations so that we can + // report an error at each declaration. + var declarations = earlySymbol ? ts.concatenate(earlySymbol.declarations, lateSymbol.declarations) : lateSymbol.declarations; + var name_5 = !(type.flags & 8192 /* TypeFlags.UniqueESSymbol */) && ts.unescapeLeadingUnderscores(memberName) || ts.declarationNameToString(declName); + ts.forEach(declarations, function (declaration) { return error(ts.getNameOfDeclaration(declaration) || declaration, ts.Diagnostics.Property_0_was_also_declared_here, name_5); }); + error(declName || decl, ts.Diagnostics.Duplicate_property_0, name_5); + lateSymbol = createSymbol(0 /* SymbolFlags.None */, memberName, 4096 /* CheckFlags.Late */); + } + lateSymbol.nameType = type; + addDeclarationToLateBoundSymbol(lateSymbol, decl, symbolFlags); + if (lateSymbol.parent) { + ts.Debug.assert(lateSymbol.parent === parent, "Existing symbol parent should match new one"); + } + else { + lateSymbol.parent = parent; + } + return links.resolvedSymbol = lateSymbol; + } + } + return links.resolvedSymbol; + } + function getResolvedMembersOrExportsOfSymbol(symbol, resolutionKind) { + var links = getSymbolLinks(symbol); + if (!links[resolutionKind]) { + var isStatic_1 = resolutionKind === "resolvedExports" /* MembersOrExportsResolutionKind.resolvedExports */; + var earlySymbols = !isStatic_1 ? symbol.members : + symbol.flags & 1536 /* SymbolFlags.Module */ ? getExportsOfModuleWorker(symbol) : + symbol.exports; + // In the event we recursively resolve the members/exports of the symbol, we + // set the initial value of resolvedMembers/resolvedExports to the early-bound + // members/exports of the symbol. + links[resolutionKind] = earlySymbols || emptySymbols; + // fill in any as-yet-unresolved late-bound members. + var lateSymbols = ts.createSymbolTable(); + for (var _i = 0, _a = symbol.declarations || ts.emptyArray; _i < _a.length; _i++) { + var decl = _a[_i]; + var members = ts.getMembersOfDeclaration(decl); + if (members) { + for (var _b = 0, members_5 = members; _b < members_5.length; _b++) { + var member = members_5[_b]; + if (isStatic_1 === ts.hasStaticModifier(member)) { + if (hasLateBindableName(member)) { + lateBindMember(symbol, earlySymbols, lateSymbols, member); + } + } + } + } + } + var assignments = symbol.assignmentDeclarationMembers; + if (assignments) { + var decls = ts.arrayFrom(assignments.values()); + for (var _c = 0, decls_1 = decls; _c < decls_1.length; _c++) { + var member = decls_1[_c]; + var assignmentKind = ts.getAssignmentDeclarationKind(member); + var isInstanceMember = assignmentKind === 3 /* AssignmentDeclarationKind.PrototypeProperty */ + || ts.isBinaryExpression(member) && isPossiblyAliasedThisProperty(member, assignmentKind) + || assignmentKind === 9 /* AssignmentDeclarationKind.ObjectDefinePrototypeProperty */ + || assignmentKind === 6 /* AssignmentDeclarationKind.Prototype */; // A straight `Prototype` assignment probably can never have a computed name + if (isStatic_1 === !isInstanceMember) { + if (hasLateBindableName(member)) { + lateBindMember(symbol, earlySymbols, lateSymbols, member); + } + } + } + } + links[resolutionKind] = combineSymbolTables(earlySymbols, lateSymbols) || emptySymbols; + } + return links[resolutionKind]; + } + /** + * Gets a SymbolTable containing both the early- and late-bound members of a symbol. + * + * For a description of late-binding, see `lateBindMember`. + */ + function getMembersOfSymbol(symbol) { + return symbol.flags & 6256 /* SymbolFlags.LateBindingContainer */ + ? getResolvedMembersOrExportsOfSymbol(symbol, "resolvedMembers" /* MembersOrExportsResolutionKind.resolvedMembers */) + : symbol.members || emptySymbols; + } + /** + * If a symbol is the dynamic name of the member of an object type, get the late-bound + * symbol of the member. + * + * For a description of late-binding, see `lateBindMember`. + */ + function getLateBoundSymbol(symbol) { + if (symbol.flags & 106500 /* SymbolFlags.ClassMember */ && symbol.escapedName === "__computed" /* InternalSymbolName.Computed */) { + var links = getSymbolLinks(symbol); + if (!links.lateSymbol && ts.some(symbol.declarations, hasLateBindableName)) { + // force late binding of members/exports. This will set the late-bound symbol + var parent = getMergedSymbol(symbol.parent); + if (ts.some(symbol.declarations, ts.hasStaticModifier)) { + getExportsOfSymbol(parent); + } + else { + getMembersOfSymbol(parent); + } + } + return links.lateSymbol || (links.lateSymbol = symbol); + } + return symbol; + } + function getTypeWithThisArgument(type, thisArgument, needApparentType) { + if (ts.getObjectFlags(type) & 4 /* ObjectFlags.Reference */) { + var target = type.target; + var typeArguments = getTypeArguments(type); + if (ts.length(target.typeParameters) === ts.length(typeArguments)) { + var ref = createTypeReference(target, ts.concatenate(typeArguments, [thisArgument || target.thisType])); + return needApparentType ? getApparentType(ref) : ref; + } + } + else if (type.flags & 2097152 /* TypeFlags.Intersection */) { + var types = ts.sameMap(type.types, function (t) { return getTypeWithThisArgument(t, thisArgument, needApparentType); }); + return types !== type.types ? getIntersectionType(types) : type; + } + return needApparentType ? getApparentType(type) : type; + } + function resolveObjectTypeMembers(type, source, typeParameters, typeArguments) { + var mapper; + var members; + var callSignatures; + var constructSignatures; + var indexInfos; + if (ts.rangeEquals(typeParameters, typeArguments, 0, typeParameters.length)) { + members = source.symbol ? getMembersOfSymbol(source.symbol) : ts.createSymbolTable(source.declaredProperties); + callSignatures = source.declaredCallSignatures; + constructSignatures = source.declaredConstructSignatures; + indexInfos = source.declaredIndexInfos; + } + else { + mapper = createTypeMapper(typeParameters, typeArguments); + members = createInstantiatedSymbolTable(source.declaredProperties, mapper, /*mappingThisOnly*/ typeParameters.length === 1); + callSignatures = instantiateSignatures(source.declaredCallSignatures, mapper); + constructSignatures = instantiateSignatures(source.declaredConstructSignatures, mapper); + indexInfos = instantiateIndexInfos(source.declaredIndexInfos, mapper); + } + var baseTypes = getBaseTypes(source); + if (baseTypes.length) { + if (source.symbol && members === getMembersOfSymbol(source.symbol)) { + members = ts.createSymbolTable(source.declaredProperties); + } + setStructuredTypeMembers(type, members, callSignatures, constructSignatures, indexInfos); + var thisArgument = ts.lastOrUndefined(typeArguments); + for (var _i = 0, baseTypes_1 = baseTypes; _i < baseTypes_1.length; _i++) { + var baseType = baseTypes_1[_i]; + var instantiatedBaseType = thisArgument ? getTypeWithThisArgument(instantiateType(baseType, mapper), thisArgument) : baseType; + addInheritedMembers(members, getPropertiesOfType(instantiatedBaseType)); + callSignatures = ts.concatenate(callSignatures, getSignaturesOfType(instantiatedBaseType, 0 /* SignatureKind.Call */)); + constructSignatures = ts.concatenate(constructSignatures, getSignaturesOfType(instantiatedBaseType, 1 /* SignatureKind.Construct */)); + var inheritedIndexInfos = instantiatedBaseType !== anyType ? getIndexInfosOfType(instantiatedBaseType) : [createIndexInfo(stringType, anyType, /*isReadonly*/ false)]; + indexInfos = ts.concatenate(indexInfos, ts.filter(inheritedIndexInfos, function (info) { return !findIndexInfo(indexInfos, info.keyType); })); + } + } + setStructuredTypeMembers(type, members, callSignatures, constructSignatures, indexInfos); + } + function resolveClassOrInterfaceMembers(type) { + resolveObjectTypeMembers(type, resolveDeclaredMembers(type), ts.emptyArray, ts.emptyArray); + } + function resolveTypeReferenceMembers(type) { + var source = resolveDeclaredMembers(type.target); + var typeParameters = ts.concatenate(source.typeParameters, [source.thisType]); + var typeArguments = getTypeArguments(type); + var paddedTypeArguments = typeArguments.length === typeParameters.length ? typeArguments : ts.concatenate(typeArguments, [type]); + resolveObjectTypeMembers(type, source, typeParameters, paddedTypeArguments); + } + function createSignature(declaration, typeParameters, thisParameter, parameters, resolvedReturnType, resolvedTypePredicate, minArgumentCount, flags) { + var sig = new Signature(checker, flags); + sig.declaration = declaration; + sig.typeParameters = typeParameters; + sig.parameters = parameters; + sig.thisParameter = thisParameter; + sig.resolvedReturnType = resolvedReturnType; + sig.resolvedTypePredicate = resolvedTypePredicate; + sig.minArgumentCount = minArgumentCount; + sig.resolvedMinArgumentCount = undefined; + sig.target = undefined; + sig.mapper = undefined; + sig.compositeSignatures = undefined; + sig.compositeKind = undefined; + return sig; + } + function cloneSignature(sig) { + var result = createSignature(sig.declaration, sig.typeParameters, sig.thisParameter, sig.parameters, /*resolvedReturnType*/ undefined, + /*resolvedTypePredicate*/ undefined, sig.minArgumentCount, sig.flags & 39 /* SignatureFlags.PropagatingFlags */); + result.target = sig.target; + result.mapper = sig.mapper; + result.compositeSignatures = sig.compositeSignatures; + result.compositeKind = sig.compositeKind; + return result; + } + function createUnionSignature(signature, unionSignatures) { + var result = cloneSignature(signature); + result.compositeSignatures = unionSignatures; + result.compositeKind = 1048576 /* TypeFlags.Union */; + result.target = undefined; + result.mapper = undefined; + return result; + } + function getOptionalCallSignature(signature, callChainFlags) { + if ((signature.flags & 24 /* SignatureFlags.CallChainFlags */) === callChainFlags) { + return signature; + } + if (!signature.optionalCallSignatureCache) { + signature.optionalCallSignatureCache = {}; + } + var key = callChainFlags === 8 /* SignatureFlags.IsInnerCallChain */ ? "inner" : "outer"; + return signature.optionalCallSignatureCache[key] + || (signature.optionalCallSignatureCache[key] = createOptionalCallSignature(signature, callChainFlags)); + } + function createOptionalCallSignature(signature, callChainFlags) { + ts.Debug.assert(callChainFlags === 8 /* SignatureFlags.IsInnerCallChain */ || callChainFlags === 16 /* SignatureFlags.IsOuterCallChain */, "An optional call signature can either be for an inner call chain or an outer call chain, but not both."); + var result = cloneSignature(signature); + result.flags |= callChainFlags; + return result; + } + function getExpandedParameters(sig, skipUnionExpanding) { + if (signatureHasRestParameter(sig)) { + var restIndex_1 = sig.parameters.length - 1; + var restType = getTypeOfSymbol(sig.parameters[restIndex_1]); + if (isTupleType(restType)) { + return [expandSignatureParametersWithTupleMembers(restType, restIndex_1)]; + } + else if (!skipUnionExpanding && restType.flags & 1048576 /* TypeFlags.Union */ && ts.every(restType.types, isTupleType)) { + return ts.map(restType.types, function (t) { return expandSignatureParametersWithTupleMembers(t, restIndex_1); }); + } + } + return [sig.parameters]; + function expandSignatureParametersWithTupleMembers(restType, restIndex) { + var elementTypes = getTypeArguments(restType); + var associatedNames = restType.target.labeledElementDeclarations; + var restParams = ts.map(elementTypes, function (t, i) { + // Lookup the label from the individual tuple passed in before falling back to the signature `rest` parameter name + var tupleLabelName = !!associatedNames && getTupleElementLabel(associatedNames[i]); + var name = tupleLabelName || getParameterNameAtPosition(sig, restIndex + i, restType); + var flags = restType.target.elementFlags[i]; + var checkFlags = flags & 12 /* ElementFlags.Variable */ ? 32768 /* CheckFlags.RestParameter */ : + flags & 2 /* ElementFlags.Optional */ ? 16384 /* CheckFlags.OptionalParameter */ : 0; + var symbol = createSymbol(1 /* SymbolFlags.FunctionScopedVariable */, name, checkFlags); + symbol.type = flags & 4 /* ElementFlags.Rest */ ? createArrayType(t) : t; + return symbol; + }); + return ts.concatenate(sig.parameters.slice(0, restIndex), restParams); + } + } + function getDefaultConstructSignatures(classType) { + var baseConstructorType = getBaseConstructorTypeOfClass(classType); + var baseSignatures = getSignaturesOfType(baseConstructorType, 1 /* SignatureKind.Construct */); + var declaration = ts.getClassLikeDeclarationOfSymbol(classType.symbol); + var isAbstract = !!declaration && ts.hasSyntacticModifier(declaration, 256 /* ModifierFlags.Abstract */); + if (baseSignatures.length === 0) { + return [createSignature(undefined, classType.localTypeParameters, undefined, ts.emptyArray, classType, /*resolvedTypePredicate*/ undefined, 0, isAbstract ? 4 /* SignatureFlags.Abstract */ : 0 /* SignatureFlags.None */)]; + } + var baseTypeNode = getBaseTypeNodeOfClass(classType); + var isJavaScript = ts.isInJSFile(baseTypeNode); + var typeArguments = typeArgumentsFromTypeReferenceNode(baseTypeNode); + var typeArgCount = ts.length(typeArguments); + var result = []; + for (var _i = 0, baseSignatures_1 = baseSignatures; _i < baseSignatures_1.length; _i++) { + var baseSig = baseSignatures_1[_i]; + var minTypeArgumentCount = getMinTypeArgumentCount(baseSig.typeParameters); + var typeParamCount = ts.length(baseSig.typeParameters); + if (isJavaScript || typeArgCount >= minTypeArgumentCount && typeArgCount <= typeParamCount) { + var sig = typeParamCount ? createSignatureInstantiation(baseSig, fillMissingTypeArguments(typeArguments, baseSig.typeParameters, minTypeArgumentCount, isJavaScript)) : cloneSignature(baseSig); + sig.typeParameters = classType.localTypeParameters; + sig.resolvedReturnType = classType; + sig.flags = isAbstract ? sig.flags | 4 /* SignatureFlags.Abstract */ : sig.flags & ~4 /* SignatureFlags.Abstract */; + result.push(sig); + } + } + return result; + } + function findMatchingSignature(signatureList, signature, partialMatch, ignoreThisTypes, ignoreReturnTypes) { + for (var _i = 0, signatureList_1 = signatureList; _i < signatureList_1.length; _i++) { + var s = signatureList_1[_i]; + if (compareSignaturesIdentical(s, signature, partialMatch, ignoreThisTypes, ignoreReturnTypes, partialMatch ? compareTypesSubtypeOf : compareTypesIdentical)) { + return s; + } + } + } + function findMatchingSignatures(signatureLists, signature, listIndex) { + if (signature.typeParameters) { + // We require an exact match for generic signatures, so we only return signatures from the first + // signature list and only if they have exact matches in the other signature lists. + if (listIndex > 0) { + return undefined; + } + for (var i = 1; i < signatureLists.length; i++) { + if (!findMatchingSignature(signatureLists[i], signature, /*partialMatch*/ false, /*ignoreThisTypes*/ false, /*ignoreReturnTypes*/ false)) { + return undefined; + } + } + return [signature]; + } + var result; + for (var i = 0; i < signatureLists.length; i++) { + // Allow matching non-generic signatures to have excess parameters and different return types. + // Prefer matching this types if possible. + var match = i === listIndex ? signature : findMatchingSignature(signatureLists[i], signature, /*partialMatch*/ true, /*ignoreThisTypes*/ false, /*ignoreReturnTypes*/ true); + if (!match) { + return undefined; + } + result = ts.appendIfUnique(result, match); + } + return result; + } + // The signatures of a union type are those signatures that are present in each of the constituent types. + // Generic signatures must match exactly, but non-generic signatures are allowed to have extra optional + // parameters and may differ in return types. When signatures differ in return types, the resulting return + // type is the union of the constituent return types. + function getUnionSignatures(signatureLists) { + var result; + var indexWithLengthOverOne; + for (var i = 0; i < signatureLists.length; i++) { + if (signatureLists[i].length === 0) + return ts.emptyArray; + if (signatureLists[i].length > 1) { + indexWithLengthOverOne = indexWithLengthOverOne === undefined ? i : -1; // -1 is a signal there are multiple overload sets + } + for (var _i = 0, _a = signatureLists[i]; _i < _a.length; _i++) { + var signature = _a[_i]; + // Only process signatures with parameter lists that aren't already in the result list + if (!result || !findMatchingSignature(result, signature, /*partialMatch*/ false, /*ignoreThisTypes*/ false, /*ignoreReturnTypes*/ true)) { + var unionSignatures = findMatchingSignatures(signatureLists, signature, i); + if (unionSignatures) { + var s = signature; + // Union the result types when more than one signature matches + if (unionSignatures.length > 1) { + var thisParameter = signature.thisParameter; + var firstThisParameterOfUnionSignatures = ts.forEach(unionSignatures, function (sig) { return sig.thisParameter; }); + if (firstThisParameterOfUnionSignatures) { + var thisType = getIntersectionType(ts.mapDefined(unionSignatures, function (sig) { return sig.thisParameter && getTypeOfSymbol(sig.thisParameter); })); + thisParameter = createSymbolWithType(firstThisParameterOfUnionSignatures, thisType); + } + s = createUnionSignature(signature, unionSignatures); + s.thisParameter = thisParameter; + } + (result || (result = [])).push(s); + } + } + } + } + if (!ts.length(result) && indexWithLengthOverOne !== -1) { + // No sufficiently similar signature existed to subsume all the other signatures in the union - time to see if we can make a single + // signature that handles all over them. We only do this when there are overloads in only one constituent. + // (Overloads are conditional in nature and having overloads in multiple constituents would necessitate making a power set of + // signatures from the type, whose ordering would be non-obvious) + var masterList = signatureLists[indexWithLengthOverOne !== undefined ? indexWithLengthOverOne : 0]; + var results = masterList.slice(); + var _loop_10 = function (signatures) { + if (signatures !== masterList) { + var signature_1 = signatures[0]; + ts.Debug.assert(!!signature_1, "getUnionSignatures bails early on empty signature lists and should not have empty lists on second pass"); + results = !!signature_1.typeParameters && ts.some(results, function (s) { return !!s.typeParameters && !compareTypeParametersIdentical(signature_1.typeParameters, s.typeParameters); }) ? undefined : ts.map(results, function (sig) { return combineSignaturesOfUnionMembers(sig, signature_1); }); + if (!results) { + return "break"; + } + } + }; + for (var _b = 0, signatureLists_1 = signatureLists; _b < signatureLists_1.length; _b++) { + var signatures = signatureLists_1[_b]; + var state_3 = _loop_10(signatures); + if (state_3 === "break") + break; + } + result = results; + } + return result || ts.emptyArray; + } + function compareTypeParametersIdentical(sourceParams, targetParams) { + if (ts.length(sourceParams) !== ts.length(targetParams)) { + return false; + } + if (!sourceParams || !targetParams) { + return true; + } + var mapper = createTypeMapper(targetParams, sourceParams); + for (var i = 0; i < sourceParams.length; i++) { + var source = sourceParams[i]; + var target = targetParams[i]; + if (source === target) + continue; + // We instantiate the target type parameter constraints into the source types so we can recognize `` as the same as `` + if (!isTypeIdenticalTo(getConstraintFromTypeParameter(source) || unknownType, instantiateType(getConstraintFromTypeParameter(target) || unknownType, mapper))) + return false; + // We don't compare defaults - we just use the type parameter defaults from the first signature that seems to match. + // It might make sense to combine these defaults in the future, but doing so intelligently requires knowing + // if the parameter is used covariantly or contravariantly (so we intersect if it's used like a parameter or union if used like a return type) + // and, since it's just an inference _default_, just picking one arbitrarily works OK. + } + return true; + } + function combineUnionThisParam(left, right, mapper) { + if (!left || !right) { + return left || right; + } + // A signature `this` type might be a read or a write position... It's very possible that it should be invariant + // and we should refuse to merge signatures if there are `this` types and they do not match. However, so as to be + // permissive when calling, for now, we'll intersect the `this` types just like we do for param types in union signatures. + var thisType = getIntersectionType([getTypeOfSymbol(left), instantiateType(getTypeOfSymbol(right), mapper)]); + return createSymbolWithType(left, thisType); + } + function combineUnionParameters(left, right, mapper) { + var leftCount = getParameterCount(left); + var rightCount = getParameterCount(right); + var longest = leftCount >= rightCount ? left : right; + var shorter = longest === left ? right : left; + var longestCount = longest === left ? leftCount : rightCount; + var eitherHasEffectiveRest = (hasEffectiveRestParameter(left) || hasEffectiveRestParameter(right)); + var needsExtraRestElement = eitherHasEffectiveRest && !hasEffectiveRestParameter(longest); + var params = new Array(longestCount + (needsExtraRestElement ? 1 : 0)); + for (var i = 0; i < longestCount; i++) { + var longestParamType = tryGetTypeAtPosition(longest, i); + if (longest === right) { + longestParamType = instantiateType(longestParamType, mapper); + } + var shorterParamType = tryGetTypeAtPosition(shorter, i) || unknownType; + if (shorter === right) { + shorterParamType = instantiateType(shorterParamType, mapper); + } + var unionParamType = getIntersectionType([longestParamType, shorterParamType]); + var isRestParam = eitherHasEffectiveRest && !needsExtraRestElement && i === (longestCount - 1); + var isOptional = i >= getMinArgumentCount(longest) && i >= getMinArgumentCount(shorter); + var leftName = i >= leftCount ? undefined : getParameterNameAtPosition(left, i); + var rightName = i >= rightCount ? undefined : getParameterNameAtPosition(right, i); + var paramName = leftName === rightName ? leftName : + !leftName ? rightName : + !rightName ? leftName : + undefined; + var paramSymbol = createSymbol(1 /* SymbolFlags.FunctionScopedVariable */ | (isOptional && !isRestParam ? 16777216 /* SymbolFlags.Optional */ : 0), paramName || "arg".concat(i)); + paramSymbol.type = isRestParam ? createArrayType(unionParamType) : unionParamType; + params[i] = paramSymbol; + } + if (needsExtraRestElement) { + var restParamSymbol = createSymbol(1 /* SymbolFlags.FunctionScopedVariable */, "args"); + restParamSymbol.type = createArrayType(getTypeAtPosition(shorter, longestCount)); + if (shorter === right) { + restParamSymbol.type = instantiateType(restParamSymbol.type, mapper); + } + params[longestCount] = restParamSymbol; + } + return params; + } + function combineSignaturesOfUnionMembers(left, right) { + var typeParams = left.typeParameters || right.typeParameters; + var paramMapper; + if (left.typeParameters && right.typeParameters) { + paramMapper = createTypeMapper(right.typeParameters, left.typeParameters); + // We just use the type parameter defaults from the first signature + } + var declaration = left.declaration; + var params = combineUnionParameters(left, right, paramMapper); + var thisParam = combineUnionThisParam(left.thisParameter, right.thisParameter, paramMapper); + var minArgCount = Math.max(left.minArgumentCount, right.minArgumentCount); + var result = createSignature(declaration, typeParams, thisParam, params, + /*resolvedReturnType*/ undefined, + /*resolvedTypePredicate*/ undefined, minArgCount, (left.flags | right.flags) & 39 /* SignatureFlags.PropagatingFlags */); + result.compositeKind = 1048576 /* TypeFlags.Union */; + result.compositeSignatures = ts.concatenate(left.compositeKind !== 2097152 /* TypeFlags.Intersection */ && left.compositeSignatures || [left], [right]); + if (paramMapper) { + result.mapper = left.compositeKind !== 2097152 /* TypeFlags.Intersection */ && left.mapper && left.compositeSignatures ? combineTypeMappers(left.mapper, paramMapper) : paramMapper; + } + return result; + } + function getUnionIndexInfos(types) { + var sourceInfos = getIndexInfosOfType(types[0]); + if (sourceInfos) { + var result = []; + var _loop_11 = function (info) { + var indexType = info.keyType; + if (ts.every(types, function (t) { return !!getIndexInfoOfType(t, indexType); })) { + result.push(createIndexInfo(indexType, getUnionType(ts.map(types, function (t) { return getIndexTypeOfType(t, indexType); })), ts.some(types, function (t) { return getIndexInfoOfType(t, indexType).isReadonly; }))); + } + }; + for (var _i = 0, sourceInfos_1 = sourceInfos; _i < sourceInfos_1.length; _i++) { + var info = sourceInfos_1[_i]; + _loop_11(info); + } + return result; + } + return ts.emptyArray; + } + function resolveUnionTypeMembers(type) { + // The members and properties collections are empty for union types. To get all properties of a union + // type use getPropertiesOfType (only the language service uses this). + var callSignatures = getUnionSignatures(ts.map(type.types, function (t) { return t === globalFunctionType ? [unknownSignature] : getSignaturesOfType(t, 0 /* SignatureKind.Call */); })); + var constructSignatures = getUnionSignatures(ts.map(type.types, function (t) { return getSignaturesOfType(t, 1 /* SignatureKind.Construct */); })); + var indexInfos = getUnionIndexInfos(type.types); + setStructuredTypeMembers(type, emptySymbols, callSignatures, constructSignatures, indexInfos); + } + function intersectTypes(type1, type2) { + return !type1 ? type2 : !type2 ? type1 : getIntersectionType([type1, type2]); + } + function findMixins(types) { + var constructorTypeCount = ts.countWhere(types, function (t) { return getSignaturesOfType(t, 1 /* SignatureKind.Construct */).length > 0; }); + var mixinFlags = ts.map(types, isMixinConstructorType); + if (constructorTypeCount > 0 && constructorTypeCount === ts.countWhere(mixinFlags, function (b) { return b; })) { + var firstMixinIndex = mixinFlags.indexOf(/*searchElement*/ true); + mixinFlags[firstMixinIndex] = false; + } + return mixinFlags; + } + function includeMixinType(type, types, mixinFlags, index) { + var mixedTypes = []; + for (var i = 0; i < types.length; i++) { + if (i === index) { + mixedTypes.push(type); + } + else if (mixinFlags[i]) { + mixedTypes.push(getReturnTypeOfSignature(getSignaturesOfType(types[i], 1 /* SignatureKind.Construct */)[0])); + } + } + return getIntersectionType(mixedTypes); + } + function resolveIntersectionTypeMembers(type) { + // The members and properties collections are empty for intersection types. To get all properties of an + // intersection type use getPropertiesOfType (only the language service uses this). + var callSignatures; + var constructSignatures; + var indexInfos; + var types = type.types; + var mixinFlags = findMixins(types); + var mixinCount = ts.countWhere(mixinFlags, function (b) { return b; }); + var _loop_12 = function (i) { + var t = type.types[i]; + // When an intersection type contains mixin constructor types, the construct signatures from + // those types are discarded and their return types are mixed into the return types of all + // other construct signatures in the intersection type. For example, the intersection type + // '{ new(...args: any[]) => A } & { new(s: string) => B }' has a single construct signature + // 'new(s: string) => A & B'. + if (!mixinFlags[i]) { + var signatures = getSignaturesOfType(t, 1 /* SignatureKind.Construct */); + if (signatures.length && mixinCount > 0) { + signatures = ts.map(signatures, function (s) { + var clone = cloneSignature(s); + clone.resolvedReturnType = includeMixinType(getReturnTypeOfSignature(s), types, mixinFlags, i); + return clone; + }); + } + constructSignatures = appendSignatures(constructSignatures, signatures); + } + callSignatures = appendSignatures(callSignatures, getSignaturesOfType(t, 0 /* SignatureKind.Call */)); + indexInfos = ts.reduceLeft(getIndexInfosOfType(t), function (infos, newInfo) { return appendIndexInfo(infos, newInfo, /*union*/ false); }, indexInfos); + }; + for (var i = 0; i < types.length; i++) { + _loop_12(i); + } + setStructuredTypeMembers(type, emptySymbols, callSignatures || ts.emptyArray, constructSignatures || ts.emptyArray, indexInfos || ts.emptyArray); + } + function appendSignatures(signatures, newSignatures) { + var _loop_13 = function (sig) { + if (!signatures || ts.every(signatures, function (s) { return !compareSignaturesIdentical(s, sig, /*partialMatch*/ false, /*ignoreThisTypes*/ false, /*ignoreReturnTypes*/ false, compareTypesIdentical); })) { + signatures = ts.append(signatures, sig); + } + }; + for (var _i = 0, newSignatures_1 = newSignatures; _i < newSignatures_1.length; _i++) { + var sig = newSignatures_1[_i]; + _loop_13(sig); + } + return signatures; + } + function appendIndexInfo(indexInfos, newInfo, union) { + if (indexInfos) { + for (var i = 0; i < indexInfos.length; i++) { + var info = indexInfos[i]; + if (info.keyType === newInfo.keyType) { + indexInfos[i] = createIndexInfo(info.keyType, union ? getUnionType([info.type, newInfo.type]) : getIntersectionType([info.type, newInfo.type]), union ? info.isReadonly || newInfo.isReadonly : info.isReadonly && newInfo.isReadonly); + return indexInfos; + } + } + } + return ts.append(indexInfos, newInfo); + } + /** + * Converts an AnonymousType to a ResolvedType. + */ + function resolveAnonymousTypeMembers(type) { + if (type.target) { + setStructuredTypeMembers(type, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray); + var members_6 = createInstantiatedSymbolTable(getPropertiesOfObjectType(type.target), type.mapper, /*mappingThisOnly*/ false); + var callSignatures = instantiateSignatures(getSignaturesOfType(type.target, 0 /* SignatureKind.Call */), type.mapper); + var constructSignatures = instantiateSignatures(getSignaturesOfType(type.target, 1 /* SignatureKind.Construct */), type.mapper); + var indexInfos_1 = instantiateIndexInfos(getIndexInfosOfType(type.target), type.mapper); + setStructuredTypeMembers(type, members_6, callSignatures, constructSignatures, indexInfos_1); + return; + } + var symbol = getMergedSymbol(type.symbol); + if (symbol.flags & 2048 /* SymbolFlags.TypeLiteral */) { + setStructuredTypeMembers(type, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray); + var members_7 = getMembersOfSymbol(symbol); + var callSignatures = getSignaturesOfSymbol(members_7.get("__call" /* InternalSymbolName.Call */)); + var constructSignatures = getSignaturesOfSymbol(members_7.get("__new" /* InternalSymbolName.New */)); + var indexInfos_2 = getIndexInfosOfSymbol(symbol); + setStructuredTypeMembers(type, members_7, callSignatures, constructSignatures, indexInfos_2); + return; + } + // Combinations of function, class, enum and module + var members = emptySymbols; + var indexInfos; + if (symbol.exports) { + members = getExportsOfSymbol(symbol); + if (symbol === globalThisSymbol) { + var varsOnly_1 = new ts.Map(); + members.forEach(function (p) { + var _a; + if (!(p.flags & 418 /* SymbolFlags.BlockScoped */) && !(p.flags & 512 /* SymbolFlags.ValueModule */ && ((_a = p.declarations) === null || _a === void 0 ? void 0 : _a.length) && ts.every(p.declarations, ts.isAmbientModule))) { + varsOnly_1.set(p.escapedName, p); + } + }); + members = varsOnly_1; + } + } + var baseConstructorIndexInfo; + setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, ts.emptyArray); + if (symbol.flags & 32 /* SymbolFlags.Class */) { + var classType = getDeclaredTypeOfClassOrInterface(symbol); + var baseConstructorType = getBaseConstructorTypeOfClass(classType); + if (baseConstructorType.flags & (524288 /* TypeFlags.Object */ | 2097152 /* TypeFlags.Intersection */ | 8650752 /* TypeFlags.TypeVariable */)) { + members = ts.createSymbolTable(getNamedOrIndexSignatureMembers(members)); + addInheritedMembers(members, getPropertiesOfType(baseConstructorType)); + } + else if (baseConstructorType === anyType) { + baseConstructorIndexInfo = createIndexInfo(stringType, anyType, /*isReadonly*/ false); + } + } + var indexSymbol = getIndexSymbolFromSymbolTable(members); + if (indexSymbol) { + indexInfos = getIndexInfosOfIndexSymbol(indexSymbol); + } + else { + if (baseConstructorIndexInfo) { + indexInfos = ts.append(indexInfos, baseConstructorIndexInfo); + } + if (symbol.flags & 384 /* SymbolFlags.Enum */ && (getDeclaredTypeOfSymbol(symbol).flags & 32 /* TypeFlags.Enum */ || + ts.some(type.properties, function (prop) { return !!(getTypeOfSymbol(prop).flags & 296 /* TypeFlags.NumberLike */); }))) { + indexInfos = ts.append(indexInfos, enumNumberIndexInfo); + } + } + setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, indexInfos || ts.emptyArray); + // We resolve the members before computing the signatures because a signature may use + // typeof with a qualified name expression that circularly references the type we are + // in the process of resolving (see issue #6072). The temporarily empty signature list + // will never be observed because a qualified name can't reference signatures. + if (symbol.flags & (16 /* SymbolFlags.Function */ | 8192 /* SymbolFlags.Method */)) { + type.callSignatures = getSignaturesOfSymbol(symbol); + } + // And likewise for construct signatures for classes + if (symbol.flags & 32 /* SymbolFlags.Class */) { + var classType_1 = getDeclaredTypeOfClassOrInterface(symbol); + var constructSignatures = symbol.members ? getSignaturesOfSymbol(symbol.members.get("__constructor" /* InternalSymbolName.Constructor */)) : ts.emptyArray; + if (symbol.flags & 16 /* SymbolFlags.Function */) { + constructSignatures = ts.addRange(constructSignatures.slice(), ts.mapDefined(type.callSignatures, function (sig) { return isJSConstructor(sig.declaration) ? + createSignature(sig.declaration, sig.typeParameters, sig.thisParameter, sig.parameters, classType_1, /*resolvedTypePredicate*/ undefined, sig.minArgumentCount, sig.flags & 39 /* SignatureFlags.PropagatingFlags */) : + undefined; })); + } + if (!constructSignatures.length) { + constructSignatures = getDefaultConstructSignatures(classType_1); + } + type.constructSignatures = constructSignatures; + } + } + function replaceIndexedAccess(instantiable, type, replacement) { + // map type.indexType to 0 + // map type.objectType to `[TReplacement]` + // thus making the indexed access `[TReplacement][0]` or `TReplacement` + return instantiateType(instantiable, createTypeMapper([type.indexType, type.objectType], [getNumberLiteralType(0), createTupleType([replacement])])); + } + function resolveReverseMappedTypeMembers(type) { + var indexInfo = getIndexInfoOfType(type.source, stringType); + var modifiers = getMappedTypeModifiers(type.mappedType); + var readonlyMask = modifiers & 1 /* MappedTypeModifiers.IncludeReadonly */ ? false : true; + var optionalMask = modifiers & 4 /* MappedTypeModifiers.IncludeOptional */ ? 0 : 16777216 /* SymbolFlags.Optional */; + var indexInfos = indexInfo ? [createIndexInfo(stringType, inferReverseMappedType(indexInfo.type, type.mappedType, type.constraintType), readonlyMask && indexInfo.isReadonly)] : ts.emptyArray; + var members = ts.createSymbolTable(); + for (var _i = 0, _a = getPropertiesOfType(type.source); _i < _a.length; _i++) { + var prop = _a[_i]; + var checkFlags = 8192 /* CheckFlags.ReverseMapped */ | (readonlyMask && isReadonlySymbol(prop) ? 8 /* CheckFlags.Readonly */ : 0); + var inferredProp = createSymbol(4 /* SymbolFlags.Property */ | prop.flags & optionalMask, prop.escapedName, checkFlags); + inferredProp.declarations = prop.declarations; + inferredProp.nameType = getSymbolLinks(prop).nameType; + inferredProp.propertyType = getTypeOfSymbol(prop); + if (type.constraintType.type.flags & 8388608 /* TypeFlags.IndexedAccess */ + && type.constraintType.type.objectType.flags & 262144 /* TypeFlags.TypeParameter */ + && type.constraintType.type.indexType.flags & 262144 /* TypeFlags.TypeParameter */) { + // A reverse mapping of `{[K in keyof T[K_1]]: T[K_1]}` is the same as that of `{[K in keyof T]: T}`, since all we care about is + // inferring to the "type parameter" (or indexed access) shared by the constraint and template. So, to reduce the number of + // type identities produced, we simplify such indexed access occurences + var newTypeParam = type.constraintType.type.objectType; + var newMappedType = replaceIndexedAccess(type.mappedType, type.constraintType.type, newTypeParam); + inferredProp.mappedType = newMappedType; + inferredProp.constraintType = getIndexType(newTypeParam); + } + else { + inferredProp.mappedType = type.mappedType; + inferredProp.constraintType = type.constraintType; + } + members.set(prop.escapedName, inferredProp); + } + setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, indexInfos); + } + // Return the lower bound of the key type in a mapped type. Intuitively, the lower + // bound includes those keys that are known to always be present, for example because + // because of constraints on type parameters (e.g. 'keyof T' for a constrained T). + function getLowerBoundOfKeyType(type) { + if (type.flags & 4194304 /* TypeFlags.Index */) { + var t = getApparentType(type.type); + return isGenericTupleType(t) ? getKnownKeysOfTupleType(t) : getIndexType(t); + } + if (type.flags & 16777216 /* TypeFlags.Conditional */) { + if (type.root.isDistributive) { + var checkType = type.checkType; + var constraint = getLowerBoundOfKeyType(checkType); + if (constraint !== checkType) { + return getConditionalTypeInstantiation(type, prependTypeMapping(type.root.checkType, constraint, type.mapper)); + } + } + return type; + } + if (type.flags & 1048576 /* TypeFlags.Union */) { + return mapType(type, getLowerBoundOfKeyType); + } + if (type.flags & 2097152 /* TypeFlags.Intersection */) { + // Similarly to getTypeFromIntersectionTypeNode, we preserve the special string & {}, number & {}, + // and bigint & {} intersections that are used to prevent subtype reduction in union types. + var types = type.types; + if (types.length === 2 && !!(types[0].flags & (4 /* TypeFlags.String */ | 8 /* TypeFlags.Number */ | 64 /* TypeFlags.BigInt */)) && types[1] === emptyTypeLiteralType) { + return type; + } + return getIntersectionType(ts.sameMap(type.types, getLowerBoundOfKeyType)); + } + return type; + } + function getIsLateCheckFlag(s) { + return ts.getCheckFlags(s) & 4096 /* CheckFlags.Late */; + } + function forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(type, include, stringsOnly, cb) { + for (var _i = 0, _a = getPropertiesOfType(type); _i < _a.length; _i++) { + var prop = _a[_i]; + cb(getLiteralTypeFromProperty(prop, include)); + } + if (type.flags & 1 /* TypeFlags.Any */) { + cb(stringType); + } + else { + for (var _b = 0, _c = getIndexInfosOfType(type); _b < _c.length; _b++) { + var info = _c[_b]; + if (!stringsOnly || info.keyType.flags & (4 /* TypeFlags.String */ | 134217728 /* TypeFlags.TemplateLiteral */)) { + cb(info.keyType); + } + } + } + } + /** Resolve the members of a mapped type { [P in K]: T } */ + function resolveMappedTypeMembers(type) { + var members = ts.createSymbolTable(); + var indexInfos; + // Resolve upfront such that recursive references see an empty object type. + setStructuredTypeMembers(type, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray); + // In { [P in K]: T }, we refer to P as the type parameter type, K as the constraint type, + // and T as the template type. + var typeParameter = getTypeParameterFromMappedType(type); + var constraintType = getConstraintTypeFromMappedType(type); + var nameType = getNameTypeFromMappedType(type.target || type); + var templateType = getTemplateTypeFromMappedType(type.target || type); + var modifiersType = getApparentType(getModifiersTypeFromMappedType(type)); // The 'T' in 'keyof T' + var templateModifiers = getMappedTypeModifiers(type); + var include = keyofStringsOnly ? 128 /* TypeFlags.StringLiteral */ : 8576 /* TypeFlags.StringOrNumberLiteralOrUnique */; + if (isMappedTypeWithKeyofConstraintDeclaration(type)) { + // We have a { [P in keyof T]: X } + forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, include, keyofStringsOnly, addMemberForKeyType); + } + else { + forEachType(getLowerBoundOfKeyType(constraintType), addMemberForKeyType); + } + setStructuredTypeMembers(type, members, ts.emptyArray, ts.emptyArray, indexInfos || ts.emptyArray); + function addMemberForKeyType(keyType) { + var propNameType = nameType ? instantiateType(nameType, appendTypeMapping(type.mapper, typeParameter, keyType)) : keyType; + forEachType(propNameType, function (t) { return addMemberForKeyTypeWorker(keyType, t); }); + } + function addMemberForKeyTypeWorker(keyType, propNameType) { + // If the current iteration type constituent is a string literal type, create a property. + // Otherwise, for type string create a string index signature. + if (isTypeUsableAsPropertyName(propNameType)) { + var propName = getPropertyNameFromType(propNameType); + // String enum members from separate enums with identical values + // are distinct types with the same property name. Make the resulting + // property symbol's name type be the union of those enum member types. + var existingProp = members.get(propName); + if (existingProp) { + existingProp.nameType = getUnionType([existingProp.nameType, propNameType]); + existingProp.keyType = getUnionType([existingProp.keyType, keyType]); + } + else { + var modifiersProp = isTypeUsableAsPropertyName(keyType) ? getPropertyOfType(modifiersType, getPropertyNameFromType(keyType)) : undefined; + var isOptional = !!(templateModifiers & 4 /* MappedTypeModifiers.IncludeOptional */ || + !(templateModifiers & 8 /* MappedTypeModifiers.ExcludeOptional */) && modifiersProp && modifiersProp.flags & 16777216 /* SymbolFlags.Optional */); + var isReadonly = !!(templateModifiers & 1 /* MappedTypeModifiers.IncludeReadonly */ || + !(templateModifiers & 2 /* MappedTypeModifiers.ExcludeReadonly */) && modifiersProp && isReadonlySymbol(modifiersProp)); + var stripOptional = strictNullChecks && !isOptional && modifiersProp && modifiersProp.flags & 16777216 /* SymbolFlags.Optional */; + var lateFlag = modifiersProp ? getIsLateCheckFlag(modifiersProp) : 0; + var prop = createSymbol(4 /* SymbolFlags.Property */ | (isOptional ? 16777216 /* SymbolFlags.Optional */ : 0), propName, lateFlag | 262144 /* CheckFlags.Mapped */ | (isReadonly ? 8 /* CheckFlags.Readonly */ : 0) | (stripOptional ? 524288 /* CheckFlags.StripOptional */ : 0)); + prop.mappedType = type; + prop.nameType = propNameType; + prop.keyType = keyType; + if (modifiersProp) { + prop.syntheticOrigin = modifiersProp; + // If the mapped type has an `as XXX` clause, the property name likely won't match the declaration name and + // multiple properties may map to the same name. Thus, we attach no declarations to the symbol. + prop.declarations = nameType ? undefined : modifiersProp.declarations; + } + members.set(propName, prop); + } + } + else if (isValidIndexKeyType(propNameType) || propNameType.flags & (1 /* TypeFlags.Any */ | 32 /* TypeFlags.Enum */)) { + var indexKeyType = propNameType.flags & (1 /* TypeFlags.Any */ | 4 /* TypeFlags.String */) ? stringType : + propNameType.flags & (8 /* TypeFlags.Number */ | 32 /* TypeFlags.Enum */) ? numberType : + propNameType; + var propType = instantiateType(templateType, appendTypeMapping(type.mapper, typeParameter, keyType)); + var indexInfo = createIndexInfo(indexKeyType, propType, !!(templateModifiers & 1 /* MappedTypeModifiers.IncludeReadonly */)); + indexInfos = appendIndexInfo(indexInfos, indexInfo, /*union*/ true); + } + } + } + function getTypeOfMappedSymbol(symbol) { + if (!symbol.type) { + var mappedType = symbol.mappedType; + if (!pushTypeResolution(symbol, 0 /* TypeSystemPropertyName.Type */)) { + mappedType.containsError = true; + return errorType; + } + var templateType = getTemplateTypeFromMappedType(mappedType.target || mappedType); + var mapper = appendTypeMapping(mappedType.mapper, getTypeParameterFromMappedType(mappedType), symbol.keyType); + var propType = instantiateType(templateType, mapper); + // When creating an optional property in strictNullChecks mode, if 'undefined' isn't assignable to the + // type, we include 'undefined' in the type. Similarly, when creating a non-optional property in strictNullChecks + // mode, if the underlying property is optional we remove 'undefined' from the type. + var type = strictNullChecks && symbol.flags & 16777216 /* SymbolFlags.Optional */ && !maybeTypeOfKind(propType, 32768 /* TypeFlags.Undefined */ | 16384 /* TypeFlags.Void */) ? getOptionalType(propType, /*isProperty*/ true) : + symbol.checkFlags & 524288 /* CheckFlags.StripOptional */ ? removeMissingOrUndefinedType(propType) : + propType; + if (!popTypeResolution()) { + error(currentNode, ts.Diagnostics.Type_of_property_0_circularly_references_itself_in_mapped_type_1, symbolToString(symbol), typeToString(mappedType)); + type = errorType; + } + symbol.type = type; + } + return symbol.type; + } + function getTypeParameterFromMappedType(type) { + return type.typeParameter || + (type.typeParameter = getDeclaredTypeOfTypeParameter(getSymbolOfNode(type.declaration.typeParameter))); + } + function getConstraintTypeFromMappedType(type) { + return type.constraintType || + (type.constraintType = getConstraintOfTypeParameter(getTypeParameterFromMappedType(type)) || errorType); + } + function getNameTypeFromMappedType(type) { + return type.declaration.nameType ? + type.nameType || (type.nameType = instantiateType(getTypeFromTypeNode(type.declaration.nameType), type.mapper)) : + undefined; + } + function getTemplateTypeFromMappedType(type) { + return type.templateType || + (type.templateType = type.declaration.type ? + instantiateType(addOptionality(getTypeFromTypeNode(type.declaration.type), /*isProperty*/ true, !!(getMappedTypeModifiers(type) & 4 /* MappedTypeModifiers.IncludeOptional */)), type.mapper) : + errorType); + } + function getConstraintDeclarationForMappedType(type) { + return ts.getEffectiveConstraintOfTypeParameter(type.declaration.typeParameter); + } + function isMappedTypeWithKeyofConstraintDeclaration(type) { + var constraintDeclaration = getConstraintDeclarationForMappedType(type); // TODO: GH#18217 + return constraintDeclaration.kind === 195 /* SyntaxKind.TypeOperator */ && + constraintDeclaration.operator === 141 /* SyntaxKind.KeyOfKeyword */; + } + function getModifiersTypeFromMappedType(type) { + if (!type.modifiersType) { + if (isMappedTypeWithKeyofConstraintDeclaration(type)) { + // If the constraint declaration is a 'keyof T' node, the modifiers type is T. We check + // AST nodes here because, when T is a non-generic type, the logic below eagerly resolves + // 'keyof T' to a literal union type and we can't recover T from that type. + type.modifiersType = instantiateType(getTypeFromTypeNode(getConstraintDeclarationForMappedType(type).type), type.mapper); + } + else { + // Otherwise, get the declared constraint type, and if the constraint type is a type parameter, + // get the constraint of that type parameter. If the resulting type is an indexed type 'keyof T', + // the modifiers type is T. Otherwise, the modifiers type is unknown. + var declaredType = getTypeFromMappedTypeNode(type.declaration); + var constraint = getConstraintTypeFromMappedType(declaredType); + var extendedConstraint = constraint && constraint.flags & 262144 /* TypeFlags.TypeParameter */ ? getConstraintOfTypeParameter(constraint) : constraint; + type.modifiersType = extendedConstraint && extendedConstraint.flags & 4194304 /* TypeFlags.Index */ ? instantiateType(extendedConstraint.type, type.mapper) : unknownType; + } + } + return type.modifiersType; + } + function getMappedTypeModifiers(type) { + var declaration = type.declaration; + return (declaration.readonlyToken ? declaration.readonlyToken.kind === 40 /* SyntaxKind.MinusToken */ ? 2 /* MappedTypeModifiers.ExcludeReadonly */ : 1 /* MappedTypeModifiers.IncludeReadonly */ : 0) | + (declaration.questionToken ? declaration.questionToken.kind === 40 /* SyntaxKind.MinusToken */ ? 8 /* MappedTypeModifiers.ExcludeOptional */ : 4 /* MappedTypeModifiers.IncludeOptional */ : 0); + } + function getMappedTypeOptionality(type) { + var modifiers = getMappedTypeModifiers(type); + return modifiers & 8 /* MappedTypeModifiers.ExcludeOptional */ ? -1 : modifiers & 4 /* MappedTypeModifiers.IncludeOptional */ ? 1 : 0; + } + function getCombinedMappedTypeOptionality(type) { + var optionality = getMappedTypeOptionality(type); + var modifiersType = getModifiersTypeFromMappedType(type); + return optionality || (isGenericMappedType(modifiersType) ? getMappedTypeOptionality(modifiersType) : 0); + } + function isPartialMappedType(type) { + return !!(ts.getObjectFlags(type) & 32 /* ObjectFlags.Mapped */ && getMappedTypeModifiers(type) & 4 /* MappedTypeModifiers.IncludeOptional */); + } + function isGenericMappedType(type) { + if (ts.getObjectFlags(type) & 32 /* ObjectFlags.Mapped */) { + var constraint = getConstraintTypeFromMappedType(type); + if (isGenericIndexType(constraint)) { + return true; + } + // A mapped type is generic if the 'as' clause references generic types other than the iteration type. + // To determine this, we substitute the constraint type (that we now know isn't generic) for the iteration + // type and check whether the resulting type is generic. + var nameType = getNameTypeFromMappedType(type); + if (nameType && isGenericIndexType(instantiateType(nameType, makeUnaryTypeMapper(getTypeParameterFromMappedType(type), constraint)))) { + return true; + } + } + return false; + } + function resolveStructuredTypeMembers(type) { + if (!type.members) { + if (type.flags & 524288 /* TypeFlags.Object */) { + if (type.objectFlags & 4 /* ObjectFlags.Reference */) { + resolveTypeReferenceMembers(type); + } + else if (type.objectFlags & 3 /* ObjectFlags.ClassOrInterface */) { + resolveClassOrInterfaceMembers(type); + } + else if (type.objectFlags & 1024 /* ObjectFlags.ReverseMapped */) { + resolveReverseMappedTypeMembers(type); + } + else if (type.objectFlags & 16 /* ObjectFlags.Anonymous */) { + resolveAnonymousTypeMembers(type); + } + else if (type.objectFlags & 32 /* ObjectFlags.Mapped */) { + resolveMappedTypeMembers(type); + } + else { + ts.Debug.fail("Unhandled object type " + ts.Debug.formatObjectFlags(type.objectFlags)); + } + } + else if (type.flags & 1048576 /* TypeFlags.Union */) { + resolveUnionTypeMembers(type); + } + else if (type.flags & 2097152 /* TypeFlags.Intersection */) { + resolveIntersectionTypeMembers(type); + } + else { + ts.Debug.fail("Unhandled type " + ts.Debug.formatTypeFlags(type.flags)); + } + } + return type; + } + /** Return properties of an object type or an empty array for other types */ + function getPropertiesOfObjectType(type) { + if (type.flags & 524288 /* TypeFlags.Object */) { + return resolveStructuredTypeMembers(type).properties; + } + return ts.emptyArray; + } + /** If the given type is an object type and that type has a property by the given name, + * return the symbol for that property. Otherwise return undefined. + */ + function getPropertyOfObjectType(type, name) { + if (type.flags & 524288 /* TypeFlags.Object */) { + var resolved = resolveStructuredTypeMembers(type); + var symbol = resolved.members.get(name); + if (symbol && symbolIsValue(symbol)) { + return symbol; + } + } + } + function getPropertiesOfUnionOrIntersectionType(type) { + if (!type.resolvedProperties) { + var members = ts.createSymbolTable(); + for (var _i = 0, _a = type.types; _i < _a.length; _i++) { + var current = _a[_i]; + for (var _b = 0, _c = getPropertiesOfType(current); _b < _c.length; _b++) { + var prop = _c[_b]; + if (!members.has(prop.escapedName)) { + var combinedProp = getPropertyOfUnionOrIntersectionType(type, prop.escapedName); + if (combinedProp) { + members.set(prop.escapedName, combinedProp); + } + } + } + // The properties of a union type are those that are present in all constituent types, so + // we only need to check the properties of the first type without index signature + if (type.flags & 1048576 /* TypeFlags.Union */ && getIndexInfosOfType(current).length === 0) { + break; + } + } + type.resolvedProperties = getNamedMembers(members); + } + return type.resolvedProperties; + } + function getPropertiesOfType(type) { + type = getReducedApparentType(type); + return type.flags & 3145728 /* TypeFlags.UnionOrIntersection */ ? + getPropertiesOfUnionOrIntersectionType(type) : + getPropertiesOfObjectType(type); + } + function forEachPropertyOfType(type, action) { + type = getReducedApparentType(type); + if (type.flags & 3670016 /* TypeFlags.StructuredType */) { + resolveStructuredTypeMembers(type).members.forEach(function (symbol, escapedName) { + if (isNamedMember(symbol, escapedName)) { + action(symbol, escapedName); + } + }); + } + } + function isTypeInvalidDueToUnionDiscriminant(contextualType, obj) { + var list = obj.properties; + return list.some(function (property) { + var nameType = property.name && getLiteralTypeFromPropertyName(property.name); + var name = nameType && isTypeUsableAsPropertyName(nameType) ? getPropertyNameFromType(nameType) : undefined; + var expected = name === undefined ? undefined : getTypeOfPropertyOfType(contextualType, name); + return !!expected && isLiteralType(expected) && !isTypeAssignableTo(getTypeOfNode(property), expected); + }); + } + function getAllPossiblePropertiesOfTypes(types) { + var unionType = getUnionType(types); + if (!(unionType.flags & 1048576 /* TypeFlags.Union */)) { + return getAugmentedPropertiesOfType(unionType); + } + var props = ts.createSymbolTable(); + for (var _i = 0, types_4 = types; _i < types_4.length; _i++) { + var memberType = types_4[_i]; + for (var _a = 0, _b = getAugmentedPropertiesOfType(memberType); _a < _b.length; _a++) { + var escapedName = _b[_a].escapedName; + if (!props.has(escapedName)) { + var prop = createUnionOrIntersectionProperty(unionType, escapedName); + // May be undefined if the property is private + if (prop) + props.set(escapedName, prop); + } + } + } + return ts.arrayFrom(props.values()); + } + function getConstraintOfType(type) { + return type.flags & 262144 /* TypeFlags.TypeParameter */ ? getConstraintOfTypeParameter(type) : + type.flags & 8388608 /* TypeFlags.IndexedAccess */ ? getConstraintOfIndexedAccess(type) : + type.flags & 16777216 /* TypeFlags.Conditional */ ? getConstraintOfConditionalType(type) : + getBaseConstraintOfType(type); + } + function getConstraintOfTypeParameter(typeParameter) { + return hasNonCircularBaseConstraint(typeParameter) ? getConstraintFromTypeParameter(typeParameter) : undefined; + } + function getConstraintOfIndexedAccess(type) { + return hasNonCircularBaseConstraint(type) ? getConstraintFromIndexedAccess(type) : undefined; + } + function getSimplifiedTypeOrConstraint(type) { + var simplified = getSimplifiedType(type, /*writing*/ false); + return simplified !== type ? simplified : getConstraintOfType(type); + } + function getConstraintFromIndexedAccess(type) { + if (isMappedTypeGenericIndexedAccess(type)) { + // For indexed access types of the form { [P in K]: E }[X], where K is non-generic and X is generic, + // we substitute an instantiation of E where P is replaced with X. + return substituteIndexedMappedType(type.objectType, type.indexType); + } + var indexConstraint = getSimplifiedTypeOrConstraint(type.indexType); + if (indexConstraint && indexConstraint !== type.indexType) { + var indexedAccess = getIndexedAccessTypeOrUndefined(type.objectType, indexConstraint, type.accessFlags); + if (indexedAccess) { + return indexedAccess; + } + } + var objectConstraint = getSimplifiedTypeOrConstraint(type.objectType); + if (objectConstraint && objectConstraint !== type.objectType) { + return getIndexedAccessTypeOrUndefined(objectConstraint, type.indexType, type.accessFlags); + } + return undefined; + } + function getDefaultConstraintOfConditionalType(type) { + if (!type.resolvedDefaultConstraint) { + // An `any` branch of a conditional type would normally be viral - specifically, without special handling here, + // a conditional type with a single branch of type `any` would be assignable to anything, since it's constraint would simplify to + // just `any`. This result is _usually_ unwanted - so instead here we elide an `any` branch from the constraint type, + // in effect treating `any` like `never` rather than `unknown` in this location. + var trueConstraint = getInferredTrueTypeFromConditionalType(type); + var falseConstraint = getFalseTypeFromConditionalType(type); + type.resolvedDefaultConstraint = isTypeAny(trueConstraint) ? falseConstraint : isTypeAny(falseConstraint) ? trueConstraint : getUnionType([trueConstraint, falseConstraint]); + } + return type.resolvedDefaultConstraint; + } + function getConstraintOfDistributiveConditionalType(type) { + // Check if we have a conditional type of the form 'T extends U ? X : Y', where T is a constrained + // type parameter. If so, create an instantiation of the conditional type where T is replaced + // with its constraint. We do this because if the constraint is a union type it will be distributed + // over the conditional type and possibly reduced. For example, 'T extends undefined ? never : T' + // removes 'undefined' from T. + // We skip returning a distributive constraint for a restrictive instantiation of a conditional type + // as the constraint for all type params (check type included) have been replace with `unknown`, which + // is going to produce even more false positive/negative results than the distribute constraint already does. + // Please note: the distributive constraint is a kludge for emulating what a negated type could to do filter + // a union - once negated types exist and are applied to the conditional false branch, this "constraint" + // likely doesn't need to exist. + if (type.root.isDistributive && type.restrictiveInstantiation !== type) { + var simplified = getSimplifiedType(type.checkType, /*writing*/ false); + var constraint = simplified === type.checkType ? getConstraintOfType(simplified) : simplified; + if (constraint && constraint !== type.checkType) { + var instantiated = getConditionalTypeInstantiation(type, prependTypeMapping(type.root.checkType, constraint, type.mapper)); + if (!(instantiated.flags & 131072 /* TypeFlags.Never */)) { + return instantiated; + } + } + } + return undefined; + } + function getConstraintFromConditionalType(type) { + return getConstraintOfDistributiveConditionalType(type) || getDefaultConstraintOfConditionalType(type); + } + function getConstraintOfConditionalType(type) { + return hasNonCircularBaseConstraint(type) ? getConstraintFromConditionalType(type) : undefined; + } + function getEffectiveConstraintOfIntersection(types, targetIsUnion) { + var constraints; + var hasDisjointDomainType = false; + for (var _i = 0, types_5 = types; _i < types_5.length; _i++) { + var t = types_5[_i]; + if (t.flags & 465829888 /* TypeFlags.Instantiable */) { + // We keep following constraints as long as we have an instantiable type that is known + // not to be circular or infinite (hence we stop on index access types). + var constraint = getConstraintOfType(t); + while (constraint && constraint.flags & (262144 /* TypeFlags.TypeParameter */ | 4194304 /* TypeFlags.Index */ | 16777216 /* TypeFlags.Conditional */)) { + constraint = getConstraintOfType(constraint); + } + if (constraint) { + constraints = ts.append(constraints, constraint); + if (targetIsUnion) { + constraints = ts.append(constraints, t); + } + } + } + else if (t.flags & 469892092 /* TypeFlags.DisjointDomains */ || isEmptyAnonymousObjectType(t)) { + hasDisjointDomainType = true; + } + } + // If the target is a union type or if we are intersecting with types belonging to one of the + // disjoint domains, we may end up producing a constraint that hasn't been examined before. + if (constraints && (targetIsUnion || hasDisjointDomainType)) { + if (hasDisjointDomainType) { + // We add any types belong to one of the disjoint domains because they might cause the final + // intersection operation to reduce the union constraints. + for (var _a = 0, types_6 = types; _a < types_6.length; _a++) { + var t = types_6[_a]; + if (t.flags & 469892092 /* TypeFlags.DisjointDomains */ || isEmptyAnonymousObjectType(t)) { + constraints = ts.append(constraints, t); + } + } + } + // The source types were normalized; ensure the result is normalized too. + return getNormalizedType(getIntersectionType(constraints), /*writing*/ false); + } + return undefined; + } + function getBaseConstraintOfType(type) { + if (type.flags & (58982400 /* TypeFlags.InstantiableNonPrimitive */ | 3145728 /* TypeFlags.UnionOrIntersection */ | 134217728 /* TypeFlags.TemplateLiteral */ | 268435456 /* TypeFlags.StringMapping */)) { + var constraint = getResolvedBaseConstraint(type); + return constraint !== noConstraintType && constraint !== circularConstraintType ? constraint : undefined; + } + return type.flags & 4194304 /* TypeFlags.Index */ ? keyofConstraintType : undefined; + } + /** + * This is similar to `getBaseConstraintOfType` except it returns the input type if there's no base constraint, instead of `undefined` + * It also doesn't map indexes to `string`, as where this is used this would be unneeded (and likely undesirable) + */ + function getBaseConstraintOrType(type) { + return getBaseConstraintOfType(type) || type; + } + function hasNonCircularBaseConstraint(type) { + return getResolvedBaseConstraint(type) !== circularConstraintType; + } + /** + * Return the resolved base constraint of a type variable. The noConstraintType singleton is returned if the + * type variable has no constraint, and the circularConstraintType singleton is returned if the constraint + * circularly references the type variable. + */ + function getResolvedBaseConstraint(type) { + if (type.resolvedBaseConstraint) { + return type.resolvedBaseConstraint; + } + var stack = []; + return type.resolvedBaseConstraint = getTypeWithThisArgument(getImmediateBaseConstraint(type), type); + function getImmediateBaseConstraint(t) { + if (!t.immediateBaseConstraint) { + if (!pushTypeResolution(t, 4 /* TypeSystemPropertyName.ImmediateBaseConstraint */)) { + return circularConstraintType; + } + var result = void 0; + // We always explore at least 10 levels of nested constraints. Thereafter, we continue to explore + // up to 50 levels of nested constraints provided there are no "deeply nested" types on the stack + // (i.e. no types for which five instantiations have been recorded on the stack). If we reach 50 + // levels of nesting, we are presumably exploring a repeating pattern with a long cycle that hasn't + // yet triggered the deeply nested limiter. We have no test cases that actually get to 50 levels of + // nesting, so it is effectively just a safety stop. + var identity_1 = getRecursionIdentity(t); + if (stack.length < 10 || stack.length < 50 && !ts.contains(stack, identity_1)) { + stack.push(identity_1); + result = computeBaseConstraint(getSimplifiedType(t, /*writing*/ false)); + stack.pop(); + } + if (!popTypeResolution()) { + if (t.flags & 262144 /* TypeFlags.TypeParameter */) { + var errorNode = getConstraintDeclaration(t); + if (errorNode) { + var diagnostic = error(errorNode, ts.Diagnostics.Type_parameter_0_has_a_circular_constraint, typeToString(t)); + if (currentNode && !ts.isNodeDescendantOf(errorNode, currentNode) && !ts.isNodeDescendantOf(currentNode, errorNode)) { + ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(currentNode, ts.Diagnostics.Circularity_originates_in_type_at_this_location)); + } + } + } + result = circularConstraintType; + } + t.immediateBaseConstraint = result || noConstraintType; + } + return t.immediateBaseConstraint; + } + function getBaseConstraint(t) { + var c = getImmediateBaseConstraint(t); + return c !== noConstraintType && c !== circularConstraintType ? c : undefined; + } + function computeBaseConstraint(t) { + if (t.flags & 262144 /* TypeFlags.TypeParameter */) { + var constraint = getConstraintFromTypeParameter(t); + return t.isThisType || !constraint ? + constraint : + getBaseConstraint(constraint); + } + if (t.flags & 3145728 /* TypeFlags.UnionOrIntersection */) { + var types = t.types; + var baseTypes = []; + var different = false; + for (var _i = 0, types_7 = types; _i < types_7.length; _i++) { + var type_3 = types_7[_i]; + var baseType = getBaseConstraint(type_3); + if (baseType) { + if (baseType !== type_3) { + different = true; + } + baseTypes.push(baseType); + } + else { + different = true; + } + } + if (!different) { + return t; + } + return t.flags & 1048576 /* TypeFlags.Union */ && baseTypes.length === types.length ? getUnionType(baseTypes) : + t.flags & 2097152 /* TypeFlags.Intersection */ && baseTypes.length ? getIntersectionType(baseTypes) : + undefined; + } + if (t.flags & 4194304 /* TypeFlags.Index */) { + return keyofConstraintType; + } + if (t.flags & 134217728 /* TypeFlags.TemplateLiteral */) { + var types = t.types; + var constraints = ts.mapDefined(types, getBaseConstraint); + return constraints.length === types.length ? getTemplateLiteralType(t.texts, constraints) : stringType; + } + if (t.flags & 268435456 /* TypeFlags.StringMapping */) { + var constraint = getBaseConstraint(t.type); + return constraint && constraint !== t.type ? getStringMappingType(t.symbol, constraint) : stringType; + } + if (t.flags & 8388608 /* TypeFlags.IndexedAccess */) { + if (isMappedTypeGenericIndexedAccess(t)) { + // For indexed access types of the form { [P in K]: E }[X], where K is non-generic and X is generic, + // we substitute an instantiation of E where P is replaced with X. + return getBaseConstraint(substituteIndexedMappedType(t.objectType, t.indexType)); + } + var baseObjectType = getBaseConstraint(t.objectType); + var baseIndexType = getBaseConstraint(t.indexType); + var baseIndexedAccess = baseObjectType && baseIndexType && getIndexedAccessTypeOrUndefined(baseObjectType, baseIndexType, t.accessFlags); + return baseIndexedAccess && getBaseConstraint(baseIndexedAccess); + } + if (t.flags & 16777216 /* TypeFlags.Conditional */) { + var constraint = getConstraintFromConditionalType(t); + return constraint && getBaseConstraint(constraint); + } + if (t.flags & 33554432 /* TypeFlags.Substitution */) { + return getBaseConstraint(getSubstitutionIntersection(t)); + } + return t; + } + } + function getApparentTypeOfIntersectionType(type) { + return type.resolvedApparentType || (type.resolvedApparentType = getTypeWithThisArgument(type, type, /*apparentType*/ true)); + } + function getResolvedTypeParameterDefault(typeParameter) { + if (!typeParameter.default) { + if (typeParameter.target) { + var targetDefault = getResolvedTypeParameterDefault(typeParameter.target); + typeParameter.default = targetDefault ? instantiateType(targetDefault, typeParameter.mapper) : noConstraintType; + } + else { + // To block recursion, set the initial value to the resolvingDefaultType. + typeParameter.default = resolvingDefaultType; + var defaultDeclaration = typeParameter.symbol && ts.forEach(typeParameter.symbol.declarations, function (decl) { return ts.isTypeParameterDeclaration(decl) && decl.default; }); + var defaultType = defaultDeclaration ? getTypeFromTypeNode(defaultDeclaration) : noConstraintType; + if (typeParameter.default === resolvingDefaultType) { + // If we have not been called recursively, set the correct default type. + typeParameter.default = defaultType; + } + } + } + else if (typeParameter.default === resolvingDefaultType) { + // If we are called recursively for this type parameter, mark the default as circular. + typeParameter.default = circularConstraintType; + } + return typeParameter.default; + } + /** + * Gets the default type for a type parameter. + * + * If the type parameter is the result of an instantiation, this gets the instantiated + * default type of its target. If the type parameter has no default type or the default is + * circular, `undefined` is returned. + */ + function getDefaultFromTypeParameter(typeParameter) { + var defaultType = getResolvedTypeParameterDefault(typeParameter); + return defaultType !== noConstraintType && defaultType !== circularConstraintType ? defaultType : undefined; + } + function hasNonCircularTypeParameterDefault(typeParameter) { + return getResolvedTypeParameterDefault(typeParameter) !== circularConstraintType; + } + /** + * Indicates whether the declaration of a typeParameter has a default type. + */ + function hasTypeParameterDefault(typeParameter) { + return !!(typeParameter.symbol && ts.forEach(typeParameter.symbol.declarations, function (decl) { return ts.isTypeParameterDeclaration(decl) && decl.default; })); + } + function getApparentTypeOfMappedType(type) { + return type.resolvedApparentType || (type.resolvedApparentType = getResolvedApparentTypeOfMappedType(type)); + } + function getResolvedApparentTypeOfMappedType(type) { + var typeVariable = getHomomorphicTypeVariable(type); + if (typeVariable && !type.declaration.nameType) { + var constraint = getConstraintOfTypeParameter(typeVariable); + if (constraint && isArrayOrTupleType(constraint)) { + return instantiateType(type, prependTypeMapping(typeVariable, constraint, type.mapper)); + } + } + return type; + } + function isMappedTypeGenericIndexedAccess(type) { + var objectType; + return !!(type.flags & 8388608 /* TypeFlags.IndexedAccess */ && ts.getObjectFlags(objectType = type.objectType) & 32 /* ObjectFlags.Mapped */ && + !isGenericMappedType(objectType) && isGenericIndexType(type.indexType) && + !(getMappedTypeModifiers(objectType) & 8 /* MappedTypeModifiers.ExcludeOptional */) && !objectType.declaration.nameType); + } + /** + * For a type parameter, return the base constraint of the type parameter. For the string, number, + * boolean, and symbol primitive types, return the corresponding object types. Otherwise return the + * type itself. + */ + function getApparentType(type) { + var t = !(type.flags & 465829888 /* TypeFlags.Instantiable */) ? type : getBaseConstraintOfType(type) || unknownType; + return ts.getObjectFlags(t) & 32 /* ObjectFlags.Mapped */ ? getApparentTypeOfMappedType(t) : + t.flags & 2097152 /* TypeFlags.Intersection */ ? getApparentTypeOfIntersectionType(t) : + t.flags & 402653316 /* TypeFlags.StringLike */ ? globalStringType : + t.flags & 296 /* TypeFlags.NumberLike */ ? globalNumberType : + t.flags & 2112 /* TypeFlags.BigIntLike */ ? getGlobalBigIntType() : + t.flags & 528 /* TypeFlags.BooleanLike */ ? globalBooleanType : + t.flags & 12288 /* TypeFlags.ESSymbolLike */ ? getGlobalESSymbolType() : + t.flags & 67108864 /* TypeFlags.NonPrimitive */ ? emptyObjectType : + t.flags & 4194304 /* TypeFlags.Index */ ? keyofConstraintType : + t.flags & 2 /* TypeFlags.Unknown */ && !strictNullChecks ? emptyObjectType : + t; + } + function getReducedApparentType(type) { + // Since getApparentType may return a non-reduced union or intersection type, we need to perform + // type reduction both before and after obtaining the apparent type. For example, given a type parameter + // 'T extends A | B', the type 'T & X' becomes 'A & X | B & X' after obtaining the apparent type, and + // that type may need further reduction to remove empty intersections. + return getReducedType(getApparentType(getReducedType(type))); + } + function createUnionOrIntersectionProperty(containingType, name, skipObjectFunctionPropertyAugment) { + var _a, _b; + var singleProp; + var propSet; + var indexTypes; + var isUnion = containingType.flags & 1048576 /* TypeFlags.Union */; + // Flags we want to propagate to the result if they exist in all source symbols + var optionalFlag; + var syntheticFlag = 4 /* CheckFlags.SyntheticMethod */; + var checkFlags = isUnion ? 0 : 8 /* CheckFlags.Readonly */; + var mergedInstantiations = false; + for (var _i = 0, _c = containingType.types; _i < _c.length; _i++) { + var current = _c[_i]; + var type = getApparentType(current); + if (!(isErrorType(type) || type.flags & 131072 /* TypeFlags.Never */)) { + var prop = getPropertyOfType(type, name, skipObjectFunctionPropertyAugment); + var modifiers = prop ? ts.getDeclarationModifierFlagsFromSymbol(prop) : 0; + if (prop) { + if (prop.flags & 106500 /* SymbolFlags.ClassMember */) { + optionalFlag !== null && optionalFlag !== void 0 ? optionalFlag : (optionalFlag = isUnion ? 0 /* SymbolFlags.None */ : 16777216 /* SymbolFlags.Optional */); + if (isUnion) { + optionalFlag |= (prop.flags & 16777216 /* SymbolFlags.Optional */); + } + else { + optionalFlag &= prop.flags; + } + } + if (!singleProp) { + singleProp = prop; + } + else if (prop !== singleProp) { + var isInstantiation = (getTargetSymbol(prop) || prop) === (getTargetSymbol(singleProp) || singleProp); + // If the symbols are instances of one another with identical types - consider the symbols + // equivalent and just use the first one, which thus allows us to avoid eliding private + // members when intersecting a (this-)instantiations of a class with its raw base or another instance + if (isInstantiation && compareProperties(singleProp, prop, function (a, b) { return a === b ? -1 /* Ternary.True */ : 0 /* Ternary.False */; }) === -1 /* Ternary.True */) { + // If we merged instantiations of a generic type, we replicate the symbol parent resetting behavior we used + // to do when we recorded multiple distinct symbols so that we still get, eg, `Array.length` printed + // back and not `Array.length` when we're looking at a `.length` access on a `string[] | number[]` + mergedInstantiations = !!singleProp.parent && !!ts.length(getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(singleProp.parent)); + } + else { + if (!propSet) { + propSet = new ts.Map(); + propSet.set(getSymbolId(singleProp), singleProp); + } + var id = getSymbolId(prop); + if (!propSet.has(id)) { + propSet.set(id, prop); + } + } + } + if (isUnion && isReadonlySymbol(prop)) { + checkFlags |= 8 /* CheckFlags.Readonly */; + } + else if (!isUnion && !isReadonlySymbol(prop)) { + checkFlags &= ~8 /* CheckFlags.Readonly */; + } + checkFlags |= (!(modifiers & 24 /* ModifierFlags.NonPublicAccessibilityModifier */) ? 256 /* CheckFlags.ContainsPublic */ : 0) | + (modifiers & 16 /* ModifierFlags.Protected */ ? 512 /* CheckFlags.ContainsProtected */ : 0) | + (modifiers & 8 /* ModifierFlags.Private */ ? 1024 /* CheckFlags.ContainsPrivate */ : 0) | + (modifiers & 32 /* ModifierFlags.Static */ ? 2048 /* CheckFlags.ContainsStatic */ : 0); + if (!isPrototypeProperty(prop)) { + syntheticFlag = 2 /* CheckFlags.SyntheticProperty */; + } + } + else if (isUnion) { + var indexInfo = !isLateBoundName(name) && getApplicableIndexInfoForName(type, name); + if (indexInfo) { + checkFlags |= 32 /* CheckFlags.WritePartial */ | (indexInfo.isReadonly ? 8 /* CheckFlags.Readonly */ : 0); + indexTypes = ts.append(indexTypes, isTupleType(type) ? getRestTypeOfTupleType(type) || undefinedType : indexInfo.type); + } + else if (isObjectLiteralType(type) && !(ts.getObjectFlags(type) & 2097152 /* ObjectFlags.ContainsSpread */)) { + checkFlags |= 32 /* CheckFlags.WritePartial */; + indexTypes = ts.append(indexTypes, undefinedType); + } + else { + checkFlags |= 16 /* CheckFlags.ReadPartial */; + } + } + } + } + if (!singleProp || + isUnion && + (propSet || checkFlags & 48 /* CheckFlags.Partial */) && + checkFlags & (1024 /* CheckFlags.ContainsPrivate */ | 512 /* CheckFlags.ContainsProtected */) && + !(propSet && getCommonDeclarationsOfSymbols(ts.arrayFrom(propSet.values())))) { + // No property was found, or, in a union, a property has a private or protected declaration in one + // constituent, but is missing or has a different declaration in another constituent. + return undefined; + } + if (!propSet && !(checkFlags & 16 /* CheckFlags.ReadPartial */) && !indexTypes) { + if (mergedInstantiations) { + // No symbol from a union/intersection should have a `.parent` set (since unions/intersections don't act as symbol parents) + // Unless that parent is "reconstituted" from the "first value declaration" on the symbol (which is likely different than its instantiated parent!) + // They also have a `.containingType` set, which affects some services endpoints behavior, like `getRootSymbol` + var clone_1 = createSymbolWithType(singleProp, singleProp.type); + clone_1.parent = (_b = (_a = singleProp.valueDeclaration) === null || _a === void 0 ? void 0 : _a.symbol) === null || _b === void 0 ? void 0 : _b.parent; + clone_1.containingType = containingType; + clone_1.mapper = singleProp.mapper; + return clone_1; + } + else { + return singleProp; + } + } + var props = propSet ? ts.arrayFrom(propSet.values()) : [singleProp]; + var declarations; + var firstType; + var nameType; + var propTypes = []; + var writeTypes; + var firstValueDeclaration; + var hasNonUniformValueDeclaration = false; + for (var _d = 0, props_1 = props; _d < props_1.length; _d++) { + var prop = props_1[_d]; + if (!firstValueDeclaration) { + firstValueDeclaration = prop.valueDeclaration; + } + else if (prop.valueDeclaration && prop.valueDeclaration !== firstValueDeclaration) { + hasNonUniformValueDeclaration = true; + } + declarations = ts.addRange(declarations, prop.declarations); + var type = getTypeOfSymbol(prop); + if (!firstType) { + firstType = type; + nameType = getSymbolLinks(prop).nameType; + } + var writeType = getWriteTypeOfSymbol(prop); + if (writeTypes || writeType !== type) { + writeTypes = ts.append(!writeTypes ? propTypes.slice() : writeTypes, writeType); + } + else if (type !== firstType) { + checkFlags |= 64 /* CheckFlags.HasNonUniformType */; + } + if (isLiteralType(type) || isPatternLiteralType(type) || type === uniqueLiteralType) { + checkFlags |= 128 /* CheckFlags.HasLiteralType */; + } + if (type.flags & 131072 /* TypeFlags.Never */ && type !== uniqueLiteralType) { + checkFlags |= 131072 /* CheckFlags.HasNeverType */; + } + propTypes.push(type); + } + ts.addRange(propTypes, indexTypes); + var result = createSymbol(4 /* SymbolFlags.Property */ | (optionalFlag !== null && optionalFlag !== void 0 ? optionalFlag : 0), name, syntheticFlag | checkFlags); + result.containingType = containingType; + if (!hasNonUniformValueDeclaration && firstValueDeclaration) { + result.valueDeclaration = firstValueDeclaration; + // Inherit information about parent type. + if (firstValueDeclaration.symbol.parent) { + result.parent = firstValueDeclaration.symbol.parent; + } + } + result.declarations = declarations; + result.nameType = nameType; + if (propTypes.length > 2) { + // When `propTypes` has the potential to explode in size when normalized, defer normalization until absolutely needed + result.checkFlags |= 65536 /* CheckFlags.DeferredType */; + result.deferralParent = containingType; + result.deferralConstituents = propTypes; + result.deferralWriteConstituents = writeTypes; + } + else { + result.type = isUnion ? getUnionType(propTypes) : getIntersectionType(propTypes); + if (writeTypes) { + result.writeType = isUnion ? getUnionType(writeTypes) : getIntersectionType(writeTypes); + } + } + return result; + } + // Return the symbol for a given property in a union or intersection type, or undefined if the property + // does not exist in any constituent type. Note that the returned property may only be present in some + // constituents, in which case the isPartial flag is set when the containing type is union type. We need + // these partial properties when identifying discriminant properties, but otherwise they are filtered out + // and do not appear to be present in the union type. + function getUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment) { + var _a, _b; + var property = ((_a = type.propertyCacheWithoutObjectFunctionPropertyAugment) === null || _a === void 0 ? void 0 : _a.get(name)) || + !skipObjectFunctionPropertyAugment ? (_b = type.propertyCache) === null || _b === void 0 ? void 0 : _b.get(name) : undefined; + if (!property) { + property = createUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment); + if (property) { + var properties = skipObjectFunctionPropertyAugment ? type.propertyCacheWithoutObjectFunctionPropertyAugment || (type.propertyCacheWithoutObjectFunctionPropertyAugment = ts.createSymbolTable()) : type.propertyCache || (type.propertyCache = ts.createSymbolTable()); + properties.set(name, property); + } + } + return property; + } + function getCommonDeclarationsOfSymbols(symbols) { + var commonDeclarations; + var _loop_14 = function (symbol) { + if (!symbol.declarations) { + return { value: undefined }; + } + if (!commonDeclarations) { + commonDeclarations = new ts.Set(symbol.declarations); + return "continue"; + } + commonDeclarations.forEach(function (declaration) { + if (!ts.contains(symbol.declarations, declaration)) { + commonDeclarations.delete(declaration); + } + }); + if (commonDeclarations.size === 0) { + return { value: undefined }; + } + }; + for (var _i = 0, symbols_3 = symbols; _i < symbols_3.length; _i++) { + var symbol = symbols_3[_i]; + var state_4 = _loop_14(symbol); + if (typeof state_4 === "object") + return state_4.value; + } + return commonDeclarations; + } + function getPropertyOfUnionOrIntersectionType(type, name, skipObjectFunctionPropertyAugment) { + var property = getUnionOrIntersectionProperty(type, name, skipObjectFunctionPropertyAugment); + // We need to filter out partial properties in union types + return property && !(ts.getCheckFlags(property) & 16 /* CheckFlags.ReadPartial */) ? property : undefined; + } + /** + * Return the reduced form of the given type. For a union type, it is a union of the normalized constituent types. + * For an intersection of types containing one or more mututally exclusive discriminant properties, it is 'never'. + * For all other types, it is simply the type itself. Discriminant properties are considered mutually exclusive when + * no constituent property has type 'never', but the intersection of the constituent property types is 'never'. + */ + function getReducedType(type) { + if (type.flags & 1048576 /* TypeFlags.Union */ && type.objectFlags & 16777216 /* ObjectFlags.ContainsIntersections */) { + return type.resolvedReducedType || (type.resolvedReducedType = getReducedUnionType(type)); + } + else if (type.flags & 2097152 /* TypeFlags.Intersection */) { + if (!(type.objectFlags & 16777216 /* ObjectFlags.IsNeverIntersectionComputed */)) { + type.objectFlags |= 16777216 /* ObjectFlags.IsNeverIntersectionComputed */ | + (ts.some(getPropertiesOfUnionOrIntersectionType(type), isNeverReducedProperty) ? 33554432 /* ObjectFlags.IsNeverIntersection */ : 0); + } + return type.objectFlags & 33554432 /* ObjectFlags.IsNeverIntersection */ ? neverType : type; + } + return type; + } + function getReducedUnionType(unionType) { + var reducedTypes = ts.sameMap(unionType.types, getReducedType); + if (reducedTypes === unionType.types) { + return unionType; + } + var reduced = getUnionType(reducedTypes); + if (reduced.flags & 1048576 /* TypeFlags.Union */) { + reduced.resolvedReducedType = reduced; + } + return reduced; + } + function isNeverReducedProperty(prop) { + return isDiscriminantWithNeverType(prop) || isConflictingPrivateProperty(prop); + } + function isDiscriminantWithNeverType(prop) { + // Return true for a synthetic non-optional property with non-uniform types, where at least one is + // a literal type and none is never, that reduces to never. + return !(prop.flags & 16777216 /* SymbolFlags.Optional */) && + (ts.getCheckFlags(prop) & (192 /* CheckFlags.Discriminant */ | 131072 /* CheckFlags.HasNeverType */)) === 192 /* CheckFlags.Discriminant */ && + !!(getTypeOfSymbol(prop).flags & 131072 /* TypeFlags.Never */); + } + function isConflictingPrivateProperty(prop) { + // Return true for a synthetic property with multiple declarations, at least one of which is private. + return !prop.valueDeclaration && !!(ts.getCheckFlags(prop) & 1024 /* CheckFlags.ContainsPrivate */); + } + function elaborateNeverIntersection(errorInfo, type) { + if (type.flags & 2097152 /* TypeFlags.Intersection */ && ts.getObjectFlags(type) & 33554432 /* ObjectFlags.IsNeverIntersection */) { + var neverProp = ts.find(getPropertiesOfUnionOrIntersectionType(type), isDiscriminantWithNeverType); + if (neverProp) { + return ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.The_intersection_0_was_reduced_to_never_because_property_1_has_conflicting_types_in_some_constituents, typeToString(type, /*enclosingDeclaration*/ undefined, 536870912 /* TypeFormatFlags.NoTypeReduction */), symbolToString(neverProp)); + } + var privateProp = ts.find(getPropertiesOfUnionOrIntersectionType(type), isConflictingPrivateProperty); + if (privateProp) { + return ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.The_intersection_0_was_reduced_to_never_because_property_1_exists_in_multiple_constituents_and_is_private_in_some, typeToString(type, /*enclosingDeclaration*/ undefined, 536870912 /* TypeFormatFlags.NoTypeReduction */), symbolToString(privateProp)); + } + } + return errorInfo; + } + /** + * Return the symbol for the property with the given name in the given type. Creates synthetic union properties when + * necessary, maps primitive types and type parameters are to their apparent types, and augments with properties from + * Object and Function as appropriate. + * + * @param type a type to look up property from + * @param name a name of property to look up in a given type + */ + function getPropertyOfType(type, name, skipObjectFunctionPropertyAugment, includeTypeOnlyMembers) { + type = getReducedApparentType(type); + if (type.flags & 524288 /* TypeFlags.Object */) { + var resolved = resolveStructuredTypeMembers(type); + var symbol = resolved.members.get(name); + if (symbol && symbolIsValue(symbol, includeTypeOnlyMembers)) { + return symbol; + } + if (skipObjectFunctionPropertyAugment) + return undefined; + var functionType = resolved === anyFunctionType ? globalFunctionType : + resolved.callSignatures.length ? globalCallableFunctionType : + resolved.constructSignatures.length ? globalNewableFunctionType : + undefined; + if (functionType) { + var symbol_1 = getPropertyOfObjectType(functionType, name); + if (symbol_1) { + return symbol_1; + } + } + return getPropertyOfObjectType(globalObjectType, name); + } + if (type.flags & 3145728 /* TypeFlags.UnionOrIntersection */) { + return getPropertyOfUnionOrIntersectionType(type, name, skipObjectFunctionPropertyAugment); + } + return undefined; + } + function getSignaturesOfStructuredType(type, kind) { + if (type.flags & 3670016 /* TypeFlags.StructuredType */) { + var resolved = resolveStructuredTypeMembers(type); + return kind === 0 /* SignatureKind.Call */ ? resolved.callSignatures : resolved.constructSignatures; + } + return ts.emptyArray; + } + /** + * Return the signatures of the given kind in the given type. Creates synthetic union signatures when necessary and + * maps primitive types and type parameters are to their apparent types. + */ + function getSignaturesOfType(type, kind) { + return getSignaturesOfStructuredType(getReducedApparentType(type), kind); + } + function findIndexInfo(indexInfos, keyType) { + return ts.find(indexInfos, function (info) { return info.keyType === keyType; }); + } + function findApplicableIndexInfo(indexInfos, keyType) { + // Index signatures for type 'string' are considered only when no other index signatures apply. + var stringIndexInfo; + var applicableInfo; + var applicableInfos; + for (var _i = 0, indexInfos_3 = indexInfos; _i < indexInfos_3.length; _i++) { + var info = indexInfos_3[_i]; + if (info.keyType === stringType) { + stringIndexInfo = info; + } + else if (isApplicableIndexType(keyType, info.keyType)) { + if (!applicableInfo) { + applicableInfo = info; + } + else { + (applicableInfos || (applicableInfos = [applicableInfo])).push(info); + } + } + } + // When more than one index signature is applicable we create a synthetic IndexInfo. Instead of computing + // the intersected key type, we just use unknownType for the key type as nothing actually depends on the + // keyType property of the returned IndexInfo. + return applicableInfos ? createIndexInfo(unknownType, getIntersectionType(ts.map(applicableInfos, function (info) { return info.type; })), ts.reduceLeft(applicableInfos, function (isReadonly, info) { return isReadonly && info.isReadonly; }, /*initial*/ true)) : + applicableInfo ? applicableInfo : + stringIndexInfo && isApplicableIndexType(keyType, stringType) ? stringIndexInfo : + undefined; + } + function isApplicableIndexType(source, target) { + // A 'string' index signature applies to types assignable to 'string' or 'number', and a 'number' index + // signature applies to types assignable to 'number', `${number}` and numeric string literal types. + return isTypeAssignableTo(source, target) || + target === stringType && isTypeAssignableTo(source, numberType) || + target === numberType && (source === numericStringType || !!(source.flags & 128 /* TypeFlags.StringLiteral */) && ts.isNumericLiteralName(source.value)); + } + function getIndexInfosOfStructuredType(type) { + if (type.flags & 3670016 /* TypeFlags.StructuredType */) { + var resolved = resolveStructuredTypeMembers(type); + return resolved.indexInfos; + } + return ts.emptyArray; + } + function getIndexInfosOfType(type) { + return getIndexInfosOfStructuredType(getReducedApparentType(type)); + } + // Return the indexing info of the given kind in the given type. Creates synthetic union index types when necessary and + // maps primitive types and type parameters are to their apparent types. + function getIndexInfoOfType(type, keyType) { + return findIndexInfo(getIndexInfosOfType(type), keyType); + } + // Return the index type of the given kind in the given type. Creates synthetic union index types when necessary and + // maps primitive types and type parameters are to their apparent types. + function getIndexTypeOfType(type, keyType) { + var _a; + return (_a = getIndexInfoOfType(type, keyType)) === null || _a === void 0 ? void 0 : _a.type; + } + function getApplicableIndexInfos(type, keyType) { + return getIndexInfosOfType(type).filter(function (info) { return isApplicableIndexType(keyType, info.keyType); }); + } + function getApplicableIndexInfo(type, keyType) { + return findApplicableIndexInfo(getIndexInfosOfType(type), keyType); + } + function getApplicableIndexInfoForName(type, name) { + return getApplicableIndexInfo(type, isLateBoundName(name) ? esSymbolType : getStringLiteralType(ts.unescapeLeadingUnderscores(name))); + } + // Return list of type parameters with duplicates removed (duplicate identifier errors are generated in the actual + // type checking functions). + function getTypeParametersFromDeclaration(declaration) { + var _a; + var result; + for (var _i = 0, _b = ts.getEffectiveTypeParameterDeclarations(declaration); _i < _b.length; _i++) { + var node = _b[_i]; + result = ts.appendIfUnique(result, getDeclaredTypeOfTypeParameter(node.symbol)); + } + return (result === null || result === void 0 ? void 0 : result.length) ? result + : ts.isFunctionDeclaration(declaration) ? (_a = getSignatureOfTypeTag(declaration)) === null || _a === void 0 ? void 0 : _a.typeParameters + : undefined; + } + function symbolsToArray(symbols) { + var result = []; + symbols.forEach(function (symbol, id) { + if (!isReservedMemberName(id)) { + result.push(symbol); + } + }); + return result; + } + function isJSDocOptionalParameter(node) { + return ts.isInJSFile(node) && ( + // node.type should only be a JSDocOptionalType when node is a parameter of a JSDocFunctionType + node.type && node.type.kind === 319 /* SyntaxKind.JSDocOptionalType */ + || ts.getJSDocParameterTags(node).some(function (_a) { + var isBracketed = _a.isBracketed, typeExpression = _a.typeExpression; + return isBracketed || !!typeExpression && typeExpression.type.kind === 319 /* SyntaxKind.JSDocOptionalType */; + })); + } + function tryFindAmbientModule(moduleName, withAugmentations) { + if (ts.isExternalModuleNameRelative(moduleName)) { + return undefined; + } + var symbol = getSymbol(globals, '"' + moduleName + '"', 512 /* SymbolFlags.ValueModule */); + // merged symbol is module declaration symbol combined with all augmentations + return symbol && withAugmentations ? getMergedSymbol(symbol) : symbol; + } + function isOptionalParameter(node) { + if (ts.hasQuestionToken(node) || isOptionalJSDocPropertyLikeTag(node) || isJSDocOptionalParameter(node)) { + return true; + } + if (node.initializer) { + var signature = getSignatureFromDeclaration(node.parent); + var parameterIndex = node.parent.parameters.indexOf(node); + ts.Debug.assert(parameterIndex >= 0); + // Only consider syntactic or instantiated parameters as optional, not `void` parameters as this function is used + // in grammar checks and checking for `void` too early results in parameter types widening too early + // and causes some noImplicitAny errors to be lost. + return parameterIndex >= getMinArgumentCount(signature, 1 /* MinArgumentCountFlags.StrongArityForUntypedJS */ | 2 /* MinArgumentCountFlags.VoidIsNonOptional */); + } + var iife = ts.getImmediatelyInvokedFunctionExpression(node.parent); + if (iife) { + return !node.type && + !node.dotDotDotToken && + node.parent.parameters.indexOf(node) >= iife.arguments.length; + } + return false; + } + function isOptionalPropertyDeclaration(node) { + return ts.isPropertyDeclaration(node) && !ts.hasAccessorModifier(node) && node.questionToken; + } + function isOptionalJSDocPropertyLikeTag(node) { + if (!ts.isJSDocPropertyLikeTag(node)) { + return false; + } + var isBracketed = node.isBracketed, typeExpression = node.typeExpression; + return isBracketed || !!typeExpression && typeExpression.type.kind === 319 /* SyntaxKind.JSDocOptionalType */; + } + function createTypePredicate(kind, parameterName, parameterIndex, type) { + return { kind: kind, parameterName: parameterName, parameterIndex: parameterIndex, type: type }; + } + /** + * Gets the minimum number of type arguments needed to satisfy all non-optional type + * parameters. + */ + function getMinTypeArgumentCount(typeParameters) { + var minTypeArgumentCount = 0; + if (typeParameters) { + for (var i = 0; i < typeParameters.length; i++) { + if (!hasTypeParameterDefault(typeParameters[i])) { + minTypeArgumentCount = i + 1; + } + } + } + return minTypeArgumentCount; + } + function fillMissingTypeArguments(typeArguments, typeParameters, minTypeArgumentCount, isJavaScriptImplicitAny) { + var numTypeParameters = ts.length(typeParameters); + if (!numTypeParameters) { + return []; + } + var numTypeArguments = ts.length(typeArguments); + if (isJavaScriptImplicitAny || (numTypeArguments >= minTypeArgumentCount && numTypeArguments <= numTypeParameters)) { + var result = typeArguments ? typeArguments.slice() : []; + // Map invalid forward references in default types to the error type + for (var i = numTypeArguments; i < numTypeParameters; i++) { + result[i] = errorType; + } + var baseDefaultType = getDefaultTypeArgumentType(isJavaScriptImplicitAny); + for (var i = numTypeArguments; i < numTypeParameters; i++) { + var defaultType = getDefaultFromTypeParameter(typeParameters[i]); + if (isJavaScriptImplicitAny && defaultType && (isTypeIdenticalTo(defaultType, unknownType) || isTypeIdenticalTo(defaultType, emptyObjectType))) { + defaultType = anyType; + } + result[i] = defaultType ? instantiateType(defaultType, createTypeMapper(typeParameters, result)) : baseDefaultType; + } + result.length = typeParameters.length; + return result; + } + return typeArguments && typeArguments.slice(); + } + function getSignatureFromDeclaration(declaration) { + var links = getNodeLinks(declaration); + if (!links.resolvedSignature) { + var parameters = []; + var flags = 0 /* SignatureFlags.None */; + var minArgumentCount = 0; + var thisParameter = void 0; + var hasThisParameter = false; + var iife = ts.getImmediatelyInvokedFunctionExpression(declaration); + var isJSConstructSignature = ts.isJSDocConstructSignature(declaration); + var isUntypedSignatureInJSFile = !iife && + ts.isInJSFile(declaration) && + ts.isValueSignatureDeclaration(declaration) && + !ts.hasJSDocParameterTags(declaration) && + !ts.getJSDocType(declaration); + if (isUntypedSignatureInJSFile) { + flags |= 32 /* SignatureFlags.IsUntypedSignatureInJSFile */; + } + // If this is a JSDoc construct signature, then skip the first parameter in the + // parameter list. The first parameter represents the return type of the construct + // signature. + for (var i = isJSConstructSignature ? 1 : 0; i < declaration.parameters.length; i++) { + var param = declaration.parameters[i]; + var paramSymbol = param.symbol; + var type = ts.isJSDocParameterTag(param) ? (param.typeExpression && param.typeExpression.type) : param.type; + // Include parameter symbol instead of property symbol in the signature + if (paramSymbol && !!(paramSymbol.flags & 4 /* SymbolFlags.Property */) && !ts.isBindingPattern(param.name)) { + var resolvedSymbol = resolveName(param, paramSymbol.escapedName, 111551 /* SymbolFlags.Value */, undefined, undefined, /*isUse*/ false); + paramSymbol = resolvedSymbol; + } + if (i === 0 && paramSymbol.escapedName === "this" /* InternalSymbolName.This */) { + hasThisParameter = true; + thisParameter = param.symbol; + } + else { + parameters.push(paramSymbol); + } + if (type && type.kind === 198 /* SyntaxKind.LiteralType */) { + flags |= 2 /* SignatureFlags.HasLiteralTypes */; + } + // Record a new minimum argument count if this is not an optional parameter + var isOptionalParameter_1 = isOptionalJSDocPropertyLikeTag(param) || + param.initializer || param.questionToken || ts.isRestParameter(param) || + iife && parameters.length > iife.arguments.length && !type || + isJSDocOptionalParameter(param); + if (!isOptionalParameter_1) { + minArgumentCount = parameters.length; + } + } + // If only one accessor includes a this-type annotation, the other behaves as if it had the same type annotation + if ((declaration.kind === 174 /* SyntaxKind.GetAccessor */ || declaration.kind === 175 /* SyntaxKind.SetAccessor */) && + hasBindableName(declaration) && + (!hasThisParameter || !thisParameter)) { + var otherKind = declaration.kind === 174 /* SyntaxKind.GetAccessor */ ? 175 /* SyntaxKind.SetAccessor */ : 174 /* SyntaxKind.GetAccessor */; + var other = ts.getDeclarationOfKind(getSymbolOfNode(declaration), otherKind); + if (other) { + thisParameter = getAnnotatedAccessorThisParameter(other); + } + } + var classType = declaration.kind === 173 /* SyntaxKind.Constructor */ ? + getDeclaredTypeOfClassOrInterface(getMergedSymbol(declaration.parent.symbol)) + : undefined; + var typeParameters = classType ? classType.localTypeParameters : getTypeParametersFromDeclaration(declaration); + if (ts.hasRestParameter(declaration) || ts.isInJSFile(declaration) && maybeAddJsSyntheticRestParameter(declaration, parameters)) { + flags |= 1 /* SignatureFlags.HasRestParameter */; + } + if (ts.isConstructorTypeNode(declaration) && ts.hasSyntacticModifier(declaration, 256 /* ModifierFlags.Abstract */) || + ts.isConstructorDeclaration(declaration) && ts.hasSyntacticModifier(declaration.parent, 256 /* ModifierFlags.Abstract */)) { + flags |= 4 /* SignatureFlags.Abstract */; + } + links.resolvedSignature = createSignature(declaration, typeParameters, thisParameter, parameters, + /*resolvedReturnType*/ undefined, /*resolvedTypePredicate*/ undefined, minArgumentCount, flags); + } + return links.resolvedSignature; + } + /** + * A JS function gets a synthetic rest parameter if it references `arguments` AND: + * 1. It has no parameters but at least one `@param` with a type that starts with `...` + * OR + * 2. It has at least one parameter, and the last parameter has a matching `@param` with a type that starts with `...` + */ + function maybeAddJsSyntheticRestParameter(declaration, parameters) { + if (ts.isJSDocSignature(declaration) || !containsArgumentsReference(declaration)) { + return false; + } + var lastParam = ts.lastOrUndefined(declaration.parameters); + var lastParamTags = lastParam ? ts.getJSDocParameterTags(lastParam) : ts.getJSDocTags(declaration).filter(ts.isJSDocParameterTag); + var lastParamVariadicType = ts.firstDefined(lastParamTags, function (p) { + return p.typeExpression && ts.isJSDocVariadicType(p.typeExpression.type) ? p.typeExpression.type : undefined; + }); + var syntheticArgsSymbol = createSymbol(3 /* SymbolFlags.Variable */, "args", 32768 /* CheckFlags.RestParameter */); + if (lastParamVariadicType) { + // Parameter has effective annotation, lock in type + syntheticArgsSymbol.type = createArrayType(getTypeFromTypeNode(lastParamVariadicType.type)); + } + else { + // Parameter has no annotation + // By using a `DeferredType` symbol, we allow the type of this rest arg to be overriden by contextual type assignment so long as its type hasn't been + // cached by `getTypeOfSymbol` yet. + syntheticArgsSymbol.checkFlags |= 65536 /* CheckFlags.DeferredType */; + syntheticArgsSymbol.deferralParent = neverType; + syntheticArgsSymbol.deferralConstituents = [anyArrayType]; + syntheticArgsSymbol.deferralWriteConstituents = [anyArrayType]; + } + if (lastParamVariadicType) { + // Replace the last parameter with a rest parameter. + parameters.pop(); + } + parameters.push(syntheticArgsSymbol); + return true; + } + function getSignatureOfTypeTag(node) { + // should be attached to a function declaration or expression + if (!(ts.isInJSFile(node) && ts.isFunctionLikeDeclaration(node))) + return undefined; + var typeTag = ts.getJSDocTypeTag(node); + return (typeTag === null || typeTag === void 0 ? void 0 : typeTag.typeExpression) && getSingleCallSignature(getTypeFromTypeNode(typeTag.typeExpression)); + } + function getParameterTypeOfTypeTag(func, parameter) { + var signature = getSignatureOfTypeTag(func); + if (!signature) + return undefined; + var pos = func.parameters.indexOf(parameter); + return parameter.dotDotDotToken ? getRestTypeAtPosition(signature, pos) : getTypeAtPosition(signature, pos); + } + function getReturnTypeOfTypeTag(node) { + var signature = getSignatureOfTypeTag(node); + return signature && getReturnTypeOfSignature(signature); + } + function containsArgumentsReference(declaration) { + var links = getNodeLinks(declaration); + if (links.containsArgumentsReference === undefined) { + if (links.flags & 8192 /* NodeCheckFlags.CaptureArguments */) { + links.containsArgumentsReference = true; + } + else { + links.containsArgumentsReference = traverse(declaration.body); + } + } + return links.containsArgumentsReference; + function traverse(node) { + if (!node) + return false; + switch (node.kind) { + case 79 /* SyntaxKind.Identifier */: + return node.escapedText === argumentsSymbol.escapedName && getReferencedValueSymbol(node) === argumentsSymbol; + case 169 /* SyntaxKind.PropertyDeclaration */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + return node.name.kind === 164 /* SyntaxKind.ComputedPropertyName */ + && traverse(node.name); + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 209 /* SyntaxKind.ElementAccessExpression */: + return traverse(node.expression); + case 299 /* SyntaxKind.PropertyAssignment */: + return traverse(node.initializer); + default: + return !ts.nodeStartsNewLexicalEnvironment(node) && !ts.isPartOfTypeNode(node) && !!ts.forEachChild(node, traverse); + } + } + } + function getSignaturesOfSymbol(symbol) { + if (!symbol || !symbol.declarations) + return ts.emptyArray; + var result = []; + for (var i = 0; i < symbol.declarations.length; i++) { + var decl = symbol.declarations[i]; + if (!ts.isFunctionLike(decl)) + continue; + // Don't include signature if node is the implementation of an overloaded function. A node is considered + // an implementation node if it has a body and the previous node is of the same kind and immediately + // precedes the implementation node (i.e. has the same parent and ends where the implementation starts). + if (i > 0 && decl.body) { + var previous = symbol.declarations[i - 1]; + if (decl.parent === previous.parent && decl.kind === previous.kind && decl.pos === previous.end) { + continue; + } + } + // If this is a function or method declaration, get the signature from the @type tag for the sake of optional parameters. + // Exclude contextually-typed kinds because we already apply the @type tag to the context, plus applying it here to the initializer would supress checks that the two are compatible. + result.push((!ts.isFunctionExpressionOrArrowFunction(decl) && + !ts.isObjectLiteralMethod(decl) && + getSignatureOfTypeTag(decl)) || + getSignatureFromDeclaration(decl)); + } + return result; + } + function resolveExternalModuleTypeByLiteral(name) { + var moduleSym = resolveExternalModuleName(name, name); + if (moduleSym) { + var resolvedModuleSymbol = resolveExternalModuleSymbol(moduleSym); + if (resolvedModuleSymbol) { + return getTypeOfSymbol(resolvedModuleSymbol); + } + } + return anyType; + } + function getThisTypeOfSignature(signature) { + if (signature.thisParameter) { + return getTypeOfSymbol(signature.thisParameter); + } + } + function getTypePredicateOfSignature(signature) { + if (!signature.resolvedTypePredicate) { + if (signature.target) { + var targetTypePredicate = getTypePredicateOfSignature(signature.target); + signature.resolvedTypePredicate = targetTypePredicate ? instantiateTypePredicate(targetTypePredicate, signature.mapper) : noTypePredicate; + } + else if (signature.compositeSignatures) { + signature.resolvedTypePredicate = getUnionOrIntersectionTypePredicate(signature.compositeSignatures, signature.compositeKind) || noTypePredicate; + } + else { + var type = signature.declaration && ts.getEffectiveReturnTypeNode(signature.declaration); + var jsdocPredicate = void 0; + if (!type) { + var jsdocSignature = getSignatureOfTypeTag(signature.declaration); + if (jsdocSignature && signature !== jsdocSignature) { + jsdocPredicate = getTypePredicateOfSignature(jsdocSignature); + } + } + signature.resolvedTypePredicate = type && ts.isTypePredicateNode(type) ? + createTypePredicateFromTypePredicateNode(type, signature) : + jsdocPredicate || noTypePredicate; + } + ts.Debug.assert(!!signature.resolvedTypePredicate); + } + return signature.resolvedTypePredicate === noTypePredicate ? undefined : signature.resolvedTypePredicate; + } + function createTypePredicateFromTypePredicateNode(node, signature) { + var parameterName = node.parameterName; + var type = node.type && getTypeFromTypeNode(node.type); + return parameterName.kind === 194 /* SyntaxKind.ThisType */ ? + createTypePredicate(node.assertsModifier ? 2 /* TypePredicateKind.AssertsThis */ : 0 /* TypePredicateKind.This */, /*parameterName*/ undefined, /*parameterIndex*/ undefined, type) : + createTypePredicate(node.assertsModifier ? 3 /* TypePredicateKind.AssertsIdentifier */ : 1 /* TypePredicateKind.Identifier */, parameterName.escapedText, ts.findIndex(signature.parameters, function (p) { return p.escapedName === parameterName.escapedText; }), type); + } + function getUnionOrIntersectionType(types, kind, unionReduction) { + return kind !== 2097152 /* TypeFlags.Intersection */ ? getUnionType(types, unionReduction) : getIntersectionType(types); + } + function getReturnTypeOfSignature(signature) { + if (!signature.resolvedReturnType) { + if (!pushTypeResolution(signature, 3 /* TypeSystemPropertyName.ResolvedReturnType */)) { + return errorType; + } + var type = signature.target ? instantiateType(getReturnTypeOfSignature(signature.target), signature.mapper) : + signature.compositeSignatures ? instantiateType(getUnionOrIntersectionType(ts.map(signature.compositeSignatures, getReturnTypeOfSignature), signature.compositeKind, 2 /* UnionReduction.Subtype */), signature.mapper) : + getReturnTypeFromAnnotation(signature.declaration) || + (ts.nodeIsMissing(signature.declaration.body) ? anyType : getReturnTypeFromBody(signature.declaration)); + if (signature.flags & 8 /* SignatureFlags.IsInnerCallChain */) { + type = addOptionalTypeMarker(type); + } + else if (signature.flags & 16 /* SignatureFlags.IsOuterCallChain */) { + type = getOptionalType(type); + } + if (!popTypeResolution()) { + if (signature.declaration) { + var typeNode = ts.getEffectiveReturnTypeNode(signature.declaration); + if (typeNode) { + error(typeNode, ts.Diagnostics.Return_type_annotation_circularly_references_itself); + } + else if (noImplicitAny) { + var declaration = signature.declaration; + var name = ts.getNameOfDeclaration(declaration); + if (name) { + error(name, ts.Diagnostics._0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions, ts.declarationNameToString(name)); + } + else { + error(declaration, ts.Diagnostics.Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions); + } + } + } + type = anyType; + } + signature.resolvedReturnType = type; + } + return signature.resolvedReturnType; + } + function getReturnTypeFromAnnotation(declaration) { + if (declaration.kind === 173 /* SyntaxKind.Constructor */) { + return getDeclaredTypeOfClassOrInterface(getMergedSymbol(declaration.parent.symbol)); + } + if (ts.isJSDocConstructSignature(declaration)) { + return getTypeFromTypeNode(declaration.parameters[0].type); // TODO: GH#18217 + } + var typeNode = ts.getEffectiveReturnTypeNode(declaration); + if (typeNode) { + return getTypeFromTypeNode(typeNode); + } + if (declaration.kind === 174 /* SyntaxKind.GetAccessor */ && hasBindableName(declaration)) { + var jsDocType = ts.isInJSFile(declaration) && getTypeForDeclarationFromJSDocComment(declaration); + if (jsDocType) { + return jsDocType; + } + var setter = ts.getDeclarationOfKind(getSymbolOfNode(declaration), 175 /* SyntaxKind.SetAccessor */); + var setterType = getAnnotatedAccessorType(setter); + if (setterType) { + return setterType; + } + } + return getReturnTypeOfTypeTag(declaration); + } + function isResolvingReturnTypeOfSignature(signature) { + return !signature.resolvedReturnType && findResolutionCycleStartIndex(signature, 3 /* TypeSystemPropertyName.ResolvedReturnType */) >= 0; + } + function getRestTypeOfSignature(signature) { + return tryGetRestTypeOfSignature(signature) || anyType; + } + function tryGetRestTypeOfSignature(signature) { + if (signatureHasRestParameter(signature)) { + var sigRestType = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]); + var restType = isTupleType(sigRestType) ? getRestTypeOfTupleType(sigRestType) : sigRestType; + return restType && getIndexTypeOfType(restType, numberType); + } + return undefined; + } + function getSignatureInstantiation(signature, typeArguments, isJavascript, inferredTypeParameters) { + var instantiatedSignature = getSignatureInstantiationWithoutFillingInTypeArguments(signature, fillMissingTypeArguments(typeArguments, signature.typeParameters, getMinTypeArgumentCount(signature.typeParameters), isJavascript)); + if (inferredTypeParameters) { + var returnSignature = getSingleCallOrConstructSignature(getReturnTypeOfSignature(instantiatedSignature)); + if (returnSignature) { + var newReturnSignature = cloneSignature(returnSignature); + newReturnSignature.typeParameters = inferredTypeParameters; + var newInstantiatedSignature = cloneSignature(instantiatedSignature); + newInstantiatedSignature.resolvedReturnType = getOrCreateTypeFromSignature(newReturnSignature); + return newInstantiatedSignature; + } + } + return instantiatedSignature; + } + function getSignatureInstantiationWithoutFillingInTypeArguments(signature, typeArguments) { + var instantiations = signature.instantiations || (signature.instantiations = new ts.Map()); + var id = getTypeListId(typeArguments); + var instantiation = instantiations.get(id); + if (!instantiation) { + instantiations.set(id, instantiation = createSignatureInstantiation(signature, typeArguments)); + } + return instantiation; + } + function createSignatureInstantiation(signature, typeArguments) { + return instantiateSignature(signature, createSignatureTypeMapper(signature, typeArguments), /*eraseTypeParameters*/ true); + } + function createSignatureTypeMapper(signature, typeArguments) { + return createTypeMapper(signature.typeParameters, typeArguments); + } + function getErasedSignature(signature) { + return signature.typeParameters ? + signature.erasedSignatureCache || (signature.erasedSignatureCache = createErasedSignature(signature)) : + signature; + } + function createErasedSignature(signature) { + // Create an instantiation of the signature where all type arguments are the any type. + return instantiateSignature(signature, createTypeEraser(signature.typeParameters), /*eraseTypeParameters*/ true); + } + function getCanonicalSignature(signature) { + return signature.typeParameters ? + signature.canonicalSignatureCache || (signature.canonicalSignatureCache = createCanonicalSignature(signature)) : + signature; + } + function createCanonicalSignature(signature) { + // Create an instantiation of the signature where each unconstrained type parameter is replaced with + // its original. When a generic class or interface is instantiated, each generic method in the class or + // interface is instantiated with a fresh set of cloned type parameters (which we need to handle scenarios + // where different generations of the same type parameter are in scope). This leads to a lot of new type + // identities, and potentially a lot of work comparing those identities, so here we create an instantiation + // that uses the original type identities for all unconstrained type parameters. + return getSignatureInstantiation(signature, ts.map(signature.typeParameters, function (tp) { return tp.target && !getConstraintOfTypeParameter(tp.target) ? tp.target : tp; }), ts.isInJSFile(signature.declaration)); + } + function getBaseSignature(signature) { + var typeParameters = signature.typeParameters; + if (typeParameters) { + if (signature.baseSignatureCache) { + return signature.baseSignatureCache; + } + var typeEraser = createTypeEraser(typeParameters); + var baseConstraintMapper_1 = createTypeMapper(typeParameters, ts.map(typeParameters, function (tp) { return getConstraintOfTypeParameter(tp) || unknownType; })); + var baseConstraints = ts.map(typeParameters, function (tp) { return instantiateType(tp, baseConstraintMapper_1) || unknownType; }); + // Run N type params thru the immediate constraint mapper up to N times + // This way any noncircular interdependent type parameters are definitely resolved to their external dependencies + for (var i = 0; i < typeParameters.length - 1; i++) { + baseConstraints = instantiateTypes(baseConstraints, baseConstraintMapper_1); + } + // and then apply a type eraser to remove any remaining circularly dependent type parameters + baseConstraints = instantiateTypes(baseConstraints, typeEraser); + return signature.baseSignatureCache = instantiateSignature(signature, createTypeMapper(typeParameters, baseConstraints), /*eraseTypeParameters*/ true); + } + return signature; + } + function getOrCreateTypeFromSignature(signature) { + var _a; + // There are two ways to declare a construct signature, one is by declaring a class constructor + // using the constructor keyword, and the other is declaring a bare construct signature in an + // object type literal or interface (using the new keyword). Each way of declaring a constructor + // will result in a different declaration kind. + if (!signature.isolatedSignatureType) { + var kind = (_a = signature.declaration) === null || _a === void 0 ? void 0 : _a.kind; + // If declaration is undefined, it is likely to be the signature of the default constructor. + var isConstructor = kind === undefined || kind === 173 /* SyntaxKind.Constructor */ || kind === 177 /* SyntaxKind.ConstructSignature */ || kind === 182 /* SyntaxKind.ConstructorType */; + var type = createObjectType(16 /* ObjectFlags.Anonymous */); + type.members = emptySymbols; + type.properties = ts.emptyArray; + type.callSignatures = !isConstructor ? [signature] : ts.emptyArray; + type.constructSignatures = isConstructor ? [signature] : ts.emptyArray; + type.indexInfos = ts.emptyArray; + signature.isolatedSignatureType = type; + } + return signature.isolatedSignatureType; + } + function getIndexSymbol(symbol) { + return symbol.members ? getIndexSymbolFromSymbolTable(symbol.members) : undefined; + } + function getIndexSymbolFromSymbolTable(symbolTable) { + return symbolTable.get("__index" /* InternalSymbolName.Index */); + } + function createIndexInfo(keyType, type, isReadonly, declaration) { + return { keyType: keyType, type: type, isReadonly: isReadonly, declaration: declaration }; + } + function getIndexInfosOfSymbol(symbol) { + var indexSymbol = getIndexSymbol(symbol); + return indexSymbol ? getIndexInfosOfIndexSymbol(indexSymbol) : ts.emptyArray; + } + function getIndexInfosOfIndexSymbol(indexSymbol) { + if (indexSymbol.declarations) { + var indexInfos_4 = []; + var _loop_15 = function (declaration) { + if (declaration.parameters.length === 1) { + var parameter = declaration.parameters[0]; + if (parameter.type) { + forEachType(getTypeFromTypeNode(parameter.type), function (keyType) { + if (isValidIndexKeyType(keyType) && !findIndexInfo(indexInfos_4, keyType)) { + indexInfos_4.push(createIndexInfo(keyType, declaration.type ? getTypeFromTypeNode(declaration.type) : anyType, ts.hasEffectiveModifier(declaration, 64 /* ModifierFlags.Readonly */), declaration)); + } + }); + } + } + }; + for (var _i = 0, _a = indexSymbol.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + _loop_15(declaration); + } + return indexInfos_4; + } + return ts.emptyArray; + } + function isValidIndexKeyType(type) { + return !!(type.flags & (4 /* TypeFlags.String */ | 8 /* TypeFlags.Number */ | 4096 /* TypeFlags.ESSymbol */)) || isPatternLiteralType(type) || + !!(type.flags & 2097152 /* TypeFlags.Intersection */) && !isGenericType(type) && ts.some(type.types, isValidIndexKeyType); + } + function getConstraintDeclaration(type) { + return ts.mapDefined(ts.filter(type.symbol && type.symbol.declarations, ts.isTypeParameterDeclaration), ts.getEffectiveConstraintOfTypeParameter)[0]; + } + function getInferredTypeParameterConstraint(typeParameter, omitTypeReferences) { + var _a; + var inferences; + if ((_a = typeParameter.symbol) === null || _a === void 0 ? void 0 : _a.declarations) { + var _loop_16 = function (declaration) { + if (declaration.parent.kind === 192 /* SyntaxKind.InferType */) { + // When an 'infer T' declaration is immediately contained in a type reference node + // (such as 'Foo'), T's constraint is inferred from the constraint of the + // corresponding type parameter in 'Foo'. When multiple 'infer T' declarations are + // present, we form an intersection of the inferred constraint types. + var _c = ts.walkUpParenthesizedTypesAndGetParentAndChild(declaration.parent.parent), _d = _c[0], childTypeParameter = _d === void 0 ? declaration.parent : _d, grandParent = _c[1]; + if (grandParent.kind === 180 /* SyntaxKind.TypeReference */ && !omitTypeReferences) { + var typeReference_1 = grandParent; + var typeParameters_1 = getTypeParametersForTypeReference(typeReference_1); + if (typeParameters_1) { + var index = typeReference_1.typeArguments.indexOf(childTypeParameter); + if (index < typeParameters_1.length) { + var declaredConstraint = getConstraintOfTypeParameter(typeParameters_1[index]); + if (declaredConstraint) { + // Type parameter constraints can reference other type parameters so + // constraints need to be instantiated. If instantiation produces the + // type parameter itself, we discard that inference. For example, in + // type Foo = [T, U]; + // type Bar = T extends Foo ? Foo : T; + // the instantiated constraint for U is X, so we discard that inference. + var mapper = makeDeferredTypeMapper(typeParameters_1, typeParameters_1.map(function (_, index) { return function () { + return getEffectiveTypeArgumentAtIndex(typeReference_1, typeParameters_1, index); + }; })); + var constraint = instantiateType(declaredConstraint, mapper); + if (constraint !== typeParameter) { + inferences = ts.append(inferences, constraint); + } + } + } + } + } + // When an 'infer T' declaration is immediately contained in a rest parameter declaration, a rest type + // or a named rest tuple element, we infer an 'unknown[]' constraint. + else if (grandParent.kind === 166 /* SyntaxKind.Parameter */ && grandParent.dotDotDotToken || + grandParent.kind === 188 /* SyntaxKind.RestType */ || + grandParent.kind === 199 /* SyntaxKind.NamedTupleMember */ && grandParent.dotDotDotToken) { + inferences = ts.append(inferences, createArrayType(unknownType)); + } + // When an 'infer T' declaration is immediately contained in a string template type, we infer a 'string' + // constraint. + else if (grandParent.kind === 201 /* SyntaxKind.TemplateLiteralTypeSpan */) { + inferences = ts.append(inferences, stringType); + } + // When an 'infer T' declaration is in the constraint position of a mapped type, we infer a 'keyof any' + // constraint. + else if (grandParent.kind === 165 /* SyntaxKind.TypeParameter */ && grandParent.parent.kind === 197 /* SyntaxKind.MappedType */) { + inferences = ts.append(inferences, keyofConstraintType); + } + // When an 'infer T' declaration is the template of a mapped type, and that mapped type is the extends + // clause of a conditional whose check type is also a mapped type, give it a constraint equal to the template + // of the check type's mapped type + else if (grandParent.kind === 197 /* SyntaxKind.MappedType */ && grandParent.type && + ts.skipParentheses(grandParent.type) === declaration.parent && grandParent.parent.kind === 191 /* SyntaxKind.ConditionalType */ && + grandParent.parent.extendsType === grandParent && grandParent.parent.checkType.kind === 197 /* SyntaxKind.MappedType */ && + grandParent.parent.checkType.type) { + var checkMappedType_1 = grandParent.parent.checkType; + var nodeType = getTypeFromTypeNode(checkMappedType_1.type); + inferences = ts.append(inferences, instantiateType(nodeType, makeUnaryTypeMapper(getDeclaredTypeOfTypeParameter(getSymbolOfNode(checkMappedType_1.typeParameter)), checkMappedType_1.typeParameter.constraint ? getTypeFromTypeNode(checkMappedType_1.typeParameter.constraint) : keyofConstraintType))); + } + } + }; + for (var _i = 0, _b = typeParameter.symbol.declarations; _i < _b.length; _i++) { + var declaration = _b[_i]; + _loop_16(declaration); + } + } + return inferences && getIntersectionType(inferences); + } + /** This is a worker function. Use getConstraintOfTypeParameter which guards against circular constraints. */ + function getConstraintFromTypeParameter(typeParameter) { + if (!typeParameter.constraint) { + if (typeParameter.target) { + var targetConstraint = getConstraintOfTypeParameter(typeParameter.target); + typeParameter.constraint = targetConstraint ? instantiateType(targetConstraint, typeParameter.mapper) : noConstraintType; + } + else { + var constraintDeclaration = getConstraintDeclaration(typeParameter); + if (!constraintDeclaration) { + typeParameter.constraint = getInferredTypeParameterConstraint(typeParameter) || noConstraintType; + } + else { + var type = getTypeFromTypeNode(constraintDeclaration); + if (type.flags & 1 /* TypeFlags.Any */ && !isErrorType(type)) { // Allow errorType to propegate to keep downstream errors suppressed + // use keyofConstraintType as the base constraint for mapped type key constraints (unknown isn;t assignable to that, but `any` was), + // use unknown otherwise + type = constraintDeclaration.parent.parent.kind === 197 /* SyntaxKind.MappedType */ ? keyofConstraintType : unknownType; + } + typeParameter.constraint = type; + } + } + } + return typeParameter.constraint === noConstraintType ? undefined : typeParameter.constraint; + } + function getParentSymbolOfTypeParameter(typeParameter) { + var tp = ts.getDeclarationOfKind(typeParameter.symbol, 165 /* SyntaxKind.TypeParameter */); + var host = ts.isJSDocTemplateTag(tp.parent) ? ts.getEffectiveContainerForJSDocTemplateTag(tp.parent) : tp.parent; + return host && getSymbolOfNode(host); + } + function getTypeListId(types) { + var result = ""; + if (types) { + var length_4 = types.length; + var i = 0; + while (i < length_4) { + var startId = types[i].id; + var count = 1; + while (i + count < length_4 && types[i + count].id === startId + count) { + count++; + } + if (result.length) { + result += ","; + } + result += startId; + if (count > 1) { + result += ":" + count; + } + i += count; + } + } + return result; + } + function getAliasId(aliasSymbol, aliasTypeArguments) { + return aliasSymbol ? "@".concat(getSymbolId(aliasSymbol)) + (aliasTypeArguments ? ":".concat(getTypeListId(aliasTypeArguments)) : "") : ""; + } + // This function is used to propagate certain flags when creating new object type references and union types. + // It is only necessary to do so if a constituent type might be the undefined type, the null type, the type + // of an object literal or a non-inferrable type. This is because there are operations in the type checker + // that care about the presence of such types at arbitrary depth in a containing type. + function getPropagatingFlagsOfTypes(types, excludeKinds) { + var result = 0; + for (var _i = 0, types_8 = types; _i < types_8.length; _i++) { + var type = types_8[_i]; + if (excludeKinds === undefined || !(type.flags & excludeKinds)) { + result |= ts.getObjectFlags(type); + } + } + return result & 458752 /* ObjectFlags.PropagatingFlags */; + } + function createTypeReference(target, typeArguments) { + var id = getTypeListId(typeArguments); + var type = target.instantiations.get(id); + if (!type) { + type = createObjectType(4 /* ObjectFlags.Reference */, target.symbol); + target.instantiations.set(id, type); + type.objectFlags |= typeArguments ? getPropagatingFlagsOfTypes(typeArguments) : 0; + type.target = target; + type.resolvedTypeArguments = typeArguments; + } + return type; + } + function cloneTypeReference(source) { + var type = createType(source.flags); + type.symbol = source.symbol; + type.objectFlags = source.objectFlags; + type.target = source.target; + type.resolvedTypeArguments = source.resolvedTypeArguments; + return type; + } + function createDeferredTypeReference(target, node, mapper, aliasSymbol, aliasTypeArguments) { + if (!aliasSymbol) { + aliasSymbol = getAliasSymbolForTypeNode(node); + var localAliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol); + aliasTypeArguments = mapper ? instantiateTypes(localAliasTypeArguments, mapper) : localAliasTypeArguments; + } + var type = createObjectType(4 /* ObjectFlags.Reference */, target.symbol); + type.target = target; + type.node = node; + type.mapper = mapper; + type.aliasSymbol = aliasSymbol; + type.aliasTypeArguments = aliasTypeArguments; + return type; + } + function getTypeArguments(type) { + var _a, _b; + if (!type.resolvedTypeArguments) { + if (!pushTypeResolution(type, 6 /* TypeSystemPropertyName.ResolvedTypeArguments */)) { + return ((_a = type.target.localTypeParameters) === null || _a === void 0 ? void 0 : _a.map(function () { return errorType; })) || ts.emptyArray; + } + var node = type.node; + var typeArguments = !node ? ts.emptyArray : + node.kind === 180 /* SyntaxKind.TypeReference */ ? ts.concatenate(type.target.outerTypeParameters, getEffectiveTypeArguments(node, type.target.localTypeParameters)) : + node.kind === 185 /* SyntaxKind.ArrayType */ ? [getTypeFromTypeNode(node.elementType)] : + ts.map(node.elements, getTypeFromTypeNode); + if (popTypeResolution()) { + type.resolvedTypeArguments = type.mapper ? instantiateTypes(typeArguments, type.mapper) : typeArguments; + } + else { + type.resolvedTypeArguments = ((_b = type.target.localTypeParameters) === null || _b === void 0 ? void 0 : _b.map(function () { return errorType; })) || ts.emptyArray; + error(type.node || currentNode, type.target.symbol ? ts.Diagnostics.Type_arguments_for_0_circularly_reference_themselves : ts.Diagnostics.Tuple_type_arguments_circularly_reference_themselves, type.target.symbol && symbolToString(type.target.symbol)); + } + } + return type.resolvedTypeArguments; + } + function getTypeReferenceArity(type) { + return ts.length(type.target.typeParameters); + } + /** + * Get type from type-reference that reference to class or interface + */ + function getTypeFromClassOrInterfaceReference(node, symbol) { + var type = getDeclaredTypeOfSymbol(getMergedSymbol(symbol)); + var typeParameters = type.localTypeParameters; + if (typeParameters) { + var numTypeArguments = ts.length(node.typeArguments); + var minTypeArgumentCount = getMinTypeArgumentCount(typeParameters); + var isJs = ts.isInJSFile(node); + var isJsImplicitAny = !noImplicitAny && isJs; + if (!isJsImplicitAny && (numTypeArguments < minTypeArgumentCount || numTypeArguments > typeParameters.length)) { + var missingAugmentsTag = isJs && ts.isExpressionWithTypeArguments(node) && !ts.isJSDocAugmentsTag(node.parent); + var diag = minTypeArgumentCount === typeParameters.length ? + missingAugmentsTag ? + ts.Diagnostics.Expected_0_type_arguments_provide_these_with_an_extends_tag : + ts.Diagnostics.Generic_type_0_requires_1_type_argument_s : + missingAugmentsTag ? + ts.Diagnostics.Expected_0_1_type_arguments_provide_these_with_an_extends_tag : + ts.Diagnostics.Generic_type_0_requires_between_1_and_2_type_arguments; + var typeStr = typeToString(type, /*enclosingDeclaration*/ undefined, 2 /* TypeFormatFlags.WriteArrayAsGenericType */); + error(node, diag, typeStr, minTypeArgumentCount, typeParameters.length); + if (!isJs) { + // TODO: Adopt same permissive behavior in TS as in JS to reduce follow-on editing experience failures (requires editing fillMissingTypeArguments) + return errorType; + } + } + if (node.kind === 180 /* SyntaxKind.TypeReference */ && isDeferredTypeReferenceNode(node, ts.length(node.typeArguments) !== typeParameters.length)) { + return createDeferredTypeReference(type, node, /*mapper*/ undefined); + } + // In a type reference, the outer type parameters of the referenced class or interface are automatically + // supplied as type arguments and the type reference only specifies arguments for the local type parameters + // of the class or interface. + var typeArguments = ts.concatenate(type.outerTypeParameters, fillMissingTypeArguments(typeArgumentsFromTypeReferenceNode(node), typeParameters, minTypeArgumentCount, isJs)); + return createTypeReference(type, typeArguments); + } + return checkNoTypeArguments(node, symbol) ? type : errorType; + } + function getTypeAliasInstantiation(symbol, typeArguments, aliasSymbol, aliasTypeArguments) { + var type = getDeclaredTypeOfSymbol(symbol); + if (type === intrinsicMarkerType && intrinsicTypeKinds.has(symbol.escapedName) && typeArguments && typeArguments.length === 1) { + return getStringMappingType(symbol, typeArguments[0]); + } + var links = getSymbolLinks(symbol); + var typeParameters = links.typeParameters; + var id = getTypeListId(typeArguments) + getAliasId(aliasSymbol, aliasTypeArguments); + var instantiation = links.instantiations.get(id); + if (!instantiation) { + links.instantiations.set(id, instantiation = instantiateTypeWithAlias(type, createTypeMapper(typeParameters, fillMissingTypeArguments(typeArguments, typeParameters, getMinTypeArgumentCount(typeParameters), ts.isInJSFile(symbol.valueDeclaration))), aliasSymbol, aliasTypeArguments)); + } + return instantiation; + } + /** + * Get type from reference to type alias. When a type alias is generic, the declared type of the type alias may include + * references to the type parameters of the alias. We replace those with the actual type arguments by instantiating the + * declared type. Instantiations are cached using the type identities of the type arguments as the key. + */ + function getTypeFromTypeAliasReference(node, symbol) { + if (ts.getCheckFlags(symbol) & 1048576 /* CheckFlags.Unresolved */) { + var typeArguments = typeArgumentsFromTypeReferenceNode(node); + var id = getAliasId(symbol, typeArguments); + var errorType_1 = errorTypes.get(id); + if (!errorType_1) { + errorType_1 = createIntrinsicType(1 /* TypeFlags.Any */, "error"); + errorType_1.aliasSymbol = symbol; + errorType_1.aliasTypeArguments = typeArguments; + errorTypes.set(id, errorType_1); + } + return errorType_1; + } + var type = getDeclaredTypeOfSymbol(symbol); + var typeParameters = getSymbolLinks(symbol).typeParameters; + if (typeParameters) { + var numTypeArguments = ts.length(node.typeArguments); + var minTypeArgumentCount = getMinTypeArgumentCount(typeParameters); + if (numTypeArguments < minTypeArgumentCount || numTypeArguments > typeParameters.length) { + error(node, minTypeArgumentCount === typeParameters.length ? + ts.Diagnostics.Generic_type_0_requires_1_type_argument_s : + ts.Diagnostics.Generic_type_0_requires_between_1_and_2_type_arguments, symbolToString(symbol), minTypeArgumentCount, typeParameters.length); + return errorType; + } + // We refrain from associating a local type alias with an instantiation of a top-level type alias + // because the local alias may end up being referenced in an inferred return type where it is not + // accessible--which in turn may lead to a large structural expansion of the type when generating + // a .d.ts file. See #43622 for an example. + var aliasSymbol = getAliasSymbolForTypeNode(node); + var newAliasSymbol = aliasSymbol && (isLocalTypeAlias(symbol) || !isLocalTypeAlias(aliasSymbol)) ? aliasSymbol : undefined; + return getTypeAliasInstantiation(symbol, typeArgumentsFromTypeReferenceNode(node), newAliasSymbol, getTypeArgumentsForAliasSymbol(newAliasSymbol)); + } + return checkNoTypeArguments(node, symbol) ? type : errorType; + } + function isLocalTypeAlias(symbol) { + var _a; + var declaration = (_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isTypeAlias); + return !!(declaration && ts.getContainingFunction(declaration)); + } + function getTypeReferenceName(node) { + switch (node.kind) { + case 180 /* SyntaxKind.TypeReference */: + return node.typeName; + case 230 /* SyntaxKind.ExpressionWithTypeArguments */: + // We only support expressions that are simple qualified names. For other + // expressions this produces undefined. + var expr = node.expression; + if (ts.isEntityNameExpression(expr)) { + return expr; + } + // fall through; + } + return undefined; + } + function getSymbolPath(symbol) { + return symbol.parent ? "".concat(getSymbolPath(symbol.parent), ".").concat(symbol.escapedName) : symbol.escapedName; + } + function getUnresolvedSymbolForEntityName(name) { + var identifier = name.kind === 163 /* SyntaxKind.QualifiedName */ ? name.right : + name.kind === 208 /* SyntaxKind.PropertyAccessExpression */ ? name.name : + name; + var text = identifier.escapedText; + if (text) { + var parentSymbol = name.kind === 163 /* SyntaxKind.QualifiedName */ ? getUnresolvedSymbolForEntityName(name.left) : + name.kind === 208 /* SyntaxKind.PropertyAccessExpression */ ? getUnresolvedSymbolForEntityName(name.expression) : + undefined; + var path = parentSymbol ? "".concat(getSymbolPath(parentSymbol), ".").concat(text) : text; + var result = unresolvedSymbols.get(path); + if (!result) { + unresolvedSymbols.set(path, result = createSymbol(524288 /* SymbolFlags.TypeAlias */, text, 1048576 /* CheckFlags.Unresolved */)); + result.parent = parentSymbol; + result.declaredType = unresolvedType; + } + return result; + } + return unknownSymbol; + } + function resolveTypeReferenceName(typeReference, meaning, ignoreErrors) { + var name = getTypeReferenceName(typeReference); + if (!name) { + return unknownSymbol; + } + var symbol = resolveEntityName(name, meaning, ignoreErrors); + return symbol && symbol !== unknownSymbol ? symbol : + ignoreErrors ? unknownSymbol : getUnresolvedSymbolForEntityName(name); + } + function getTypeReferenceType(node, symbol) { + if (symbol === unknownSymbol) { + return errorType; + } + symbol = getExpandoSymbol(symbol) || symbol; + if (symbol.flags & (32 /* SymbolFlags.Class */ | 64 /* SymbolFlags.Interface */)) { + return getTypeFromClassOrInterfaceReference(node, symbol); + } + if (symbol.flags & 524288 /* SymbolFlags.TypeAlias */) { + return getTypeFromTypeAliasReference(node, symbol); + } + // Get type from reference to named type that cannot be generic (enum or type parameter) + var res = tryGetDeclaredTypeOfSymbol(symbol); + if (res) { + return checkNoTypeArguments(node, symbol) ? getRegularTypeOfLiteralType(res) : errorType; + } + if (symbol.flags & 111551 /* SymbolFlags.Value */ && isJSDocTypeReference(node)) { + var jsdocType = getTypeFromJSDocValueReference(node, symbol); + if (jsdocType) { + return jsdocType; + } + else { + // Resolve the type reference as a Type for the purpose of reporting errors. + resolveTypeReferenceName(node, 788968 /* SymbolFlags.Type */); + return getTypeOfSymbol(symbol); + } + } + return errorType; + } + /** + * A JSdoc TypeReference may be to a value, but resolve it as a type anyway. + * Example: import('./b').ConstructorFunction + */ + function getTypeFromJSDocValueReference(node, symbol) { + var links = getNodeLinks(node); + if (!links.resolvedJSDocType) { + var valueType = getTypeOfSymbol(symbol); + var typeType = valueType; + if (symbol.valueDeclaration) { + var isImportTypeWithQualifier = node.kind === 202 /* SyntaxKind.ImportType */ && node.qualifier; + // valueType might not have a symbol, eg, {import('./b').STRING_LITERAL} + if (valueType.symbol && valueType.symbol !== symbol && isImportTypeWithQualifier) { + typeType = getTypeReferenceType(node, valueType.symbol); + } + } + links.resolvedJSDocType = typeType; + } + return links.resolvedJSDocType; + } + function getSubstitutionType(baseType, constraint) { + if (constraint.flags & 3 /* TypeFlags.AnyOrUnknown */ || constraint === baseType || + !isGenericType(baseType) && !isGenericType(constraint)) { + return baseType; + } + var id = "".concat(getTypeId(baseType), ">").concat(getTypeId(constraint)); + var cached = substitutionTypes.get(id); + if (cached) { + return cached; + } + var result = createType(33554432 /* TypeFlags.Substitution */); + result.baseType = baseType; + result.constraint = constraint; + substitutionTypes.set(id, result); + return result; + } + function getSubstitutionIntersection(substitutionType) { + return getIntersectionType([substitutionType.constraint, substitutionType.baseType]); + } + function isUnaryTupleTypeNode(node) { + return node.kind === 186 /* SyntaxKind.TupleType */ && node.elements.length === 1; + } + function getImpliedConstraint(type, checkNode, extendsNode) { + return isUnaryTupleTypeNode(checkNode) && isUnaryTupleTypeNode(extendsNode) ? getImpliedConstraint(type, checkNode.elements[0], extendsNode.elements[0]) : + getActualTypeVariable(getTypeFromTypeNode(checkNode)) === getActualTypeVariable(type) ? getTypeFromTypeNode(extendsNode) : + undefined; + } + function getConditionalFlowTypeOfType(type, node) { + var constraints; + var covariant = true; + while (node && !ts.isStatement(node) && node.kind !== 323 /* SyntaxKind.JSDoc */) { + var parent = node.parent; + // only consider variance flipped by parameter locations - `keyof` types would usually be considered variance inverting, but + // often get used in indexed accesses where they behave sortof invariantly, but our checking is lax + if (parent.kind === 166 /* SyntaxKind.Parameter */) { + covariant = !covariant; + } + // Always substitute on type parameters, regardless of variance, since even + // in contravariant positions, they may rely on substituted constraints to be valid + if ((covariant || type.flags & 8650752 /* TypeFlags.TypeVariable */) && parent.kind === 191 /* SyntaxKind.ConditionalType */ && node === parent.trueType) { + var constraint = getImpliedConstraint(type, parent.checkType, parent.extendsType); + if (constraint) { + constraints = ts.append(constraints, constraint); + } + } + // Given a homomorphic mapped type { [K in keyof T]: XXX }, where T is constrained to an array or tuple type, in the + // template type XXX, K has an added constraint of number | `${number}`. + else if (type.flags & 262144 /* TypeFlags.TypeParameter */ && parent.kind === 197 /* SyntaxKind.MappedType */ && node === parent.type) { + var mappedType = getTypeFromTypeNode(parent); + if (getTypeParameterFromMappedType(mappedType) === getActualTypeVariable(type)) { + var typeParameter = getHomomorphicTypeVariable(mappedType); + if (typeParameter) { + var constraint = getConstraintOfTypeParameter(typeParameter); + if (constraint && everyType(constraint, isArrayOrTupleType)) { + constraints = ts.append(constraints, getUnionType([numberType, numericStringType])); + } + } + } + } + node = parent; + } + return constraints ? getSubstitutionType(type, getIntersectionType(constraints)) : type; + } + function isJSDocTypeReference(node) { + return !!(node.flags & 8388608 /* NodeFlags.JSDoc */) && (node.kind === 180 /* SyntaxKind.TypeReference */ || node.kind === 202 /* SyntaxKind.ImportType */); + } + function checkNoTypeArguments(node, symbol) { + if (node.typeArguments) { + error(node, ts.Diagnostics.Type_0_is_not_generic, symbol ? symbolToString(symbol) : node.typeName ? ts.declarationNameToString(node.typeName) : anon); + return false; + } + return true; + } + function getIntendedTypeFromJSDocTypeReference(node) { + if (ts.isIdentifier(node.typeName)) { + var typeArgs = node.typeArguments; + switch (node.typeName.escapedText) { + case "String": + checkNoTypeArguments(node); + return stringType; + case "Number": + checkNoTypeArguments(node); + return numberType; + case "Boolean": + checkNoTypeArguments(node); + return booleanType; + case "Void": + checkNoTypeArguments(node); + return voidType; + case "Undefined": + checkNoTypeArguments(node); + return undefinedType; + case "Null": + checkNoTypeArguments(node); + return nullType; + case "Function": + case "function": + checkNoTypeArguments(node); + return globalFunctionType; + case "array": + return (!typeArgs || !typeArgs.length) && !noImplicitAny ? anyArrayType : undefined; + case "promise": + return (!typeArgs || !typeArgs.length) && !noImplicitAny ? createPromiseType(anyType) : undefined; + case "Object": + if (typeArgs && typeArgs.length === 2) { + if (ts.isJSDocIndexSignature(node)) { + var indexed = getTypeFromTypeNode(typeArgs[0]); + var target = getTypeFromTypeNode(typeArgs[1]); + var indexInfo = indexed === stringType || indexed === numberType ? [createIndexInfo(indexed, target, /*isReadonly*/ false)] : ts.emptyArray; + return createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, indexInfo); + } + return anyType; + } + checkNoTypeArguments(node); + return !noImplicitAny ? anyType : undefined; + } + } + } + function getTypeFromJSDocNullableTypeNode(node) { + var type = getTypeFromTypeNode(node.type); + return strictNullChecks ? getNullableType(type, 65536 /* TypeFlags.Null */) : type; + } + function getTypeFromTypeReference(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + // handle LS queries on the `const` in `x as const` by resolving to the type of `x` + if (ts.isConstTypeReference(node) && ts.isAssertionExpression(node.parent)) { + links.resolvedSymbol = unknownSymbol; + return links.resolvedType = checkExpressionCached(node.parent.expression); + } + var symbol = void 0; + var type = void 0; + var meaning = 788968 /* SymbolFlags.Type */; + if (isJSDocTypeReference(node)) { + type = getIntendedTypeFromJSDocTypeReference(node); + if (!type) { + symbol = resolveTypeReferenceName(node, meaning, /*ignoreErrors*/ true); + if (symbol === unknownSymbol) { + symbol = resolveTypeReferenceName(node, meaning | 111551 /* SymbolFlags.Value */); + } + else { + resolveTypeReferenceName(node, meaning); // Resolve again to mark errors, if any + } + type = getTypeReferenceType(node, symbol); + } + } + if (!type) { + symbol = resolveTypeReferenceName(node, meaning); + type = getTypeReferenceType(node, symbol); + } + // Cache both the resolved symbol and the resolved type. The resolved symbol is needed when we check the + // type reference in checkTypeReferenceNode. + links.resolvedSymbol = symbol; + links.resolvedType = type; + } + return links.resolvedType; + } + function typeArgumentsFromTypeReferenceNode(node) { + return ts.map(node.typeArguments, getTypeFromTypeNode); + } + function getTypeFromTypeQueryNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + // TypeScript 1.0 spec (April 2014): 3.6.3 + // The expression is processed as an identifier expression (section 4.3) + // or property access expression(section 4.10), + // the widened type(section 3.9) of which becomes the result. + var type = checkExpressionWithTypeArguments(node); + links.resolvedType = getRegularTypeOfLiteralType(getWidenedType(type)); + } + return links.resolvedType; + } + function getTypeOfGlobalSymbol(symbol, arity) { + function getTypeDeclaration(symbol) { + var declarations = symbol.declarations; + if (declarations) { + for (var _i = 0, declarations_3 = declarations; _i < declarations_3.length; _i++) { + var declaration = declarations_3[_i]; + switch (declaration.kind) { + case 260 /* SyntaxKind.ClassDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + return declaration; + } + } + } + } + if (!symbol) { + return arity ? emptyGenericType : emptyObjectType; + } + var type = getDeclaredTypeOfSymbol(symbol); + if (!(type.flags & 524288 /* TypeFlags.Object */)) { + error(getTypeDeclaration(symbol), ts.Diagnostics.Global_type_0_must_be_a_class_or_interface_type, ts.symbolName(symbol)); + return arity ? emptyGenericType : emptyObjectType; + } + if (ts.length(type.typeParameters) !== arity) { + error(getTypeDeclaration(symbol), ts.Diagnostics.Global_type_0_must_have_1_type_parameter_s, ts.symbolName(symbol), arity); + return arity ? emptyGenericType : emptyObjectType; + } + return type; + } + function getGlobalValueSymbol(name, reportErrors) { + return getGlobalSymbol(name, 111551 /* SymbolFlags.Value */, reportErrors ? ts.Diagnostics.Cannot_find_global_value_0 : undefined); + } + function getGlobalTypeSymbol(name, reportErrors) { + return getGlobalSymbol(name, 788968 /* SymbolFlags.Type */, reportErrors ? ts.Diagnostics.Cannot_find_global_type_0 : undefined); + } + function getGlobalTypeAliasSymbol(name, arity, reportErrors) { + var symbol = getGlobalSymbol(name, 788968 /* SymbolFlags.Type */, reportErrors ? ts.Diagnostics.Cannot_find_global_type_0 : undefined); + if (symbol) { + // Resolve the declared type of the symbol. This resolves type parameters for the type + // alias so that we can check arity. + getDeclaredTypeOfSymbol(symbol); + if (ts.length(getSymbolLinks(symbol).typeParameters) !== arity) { + var decl = symbol.declarations && ts.find(symbol.declarations, ts.isTypeAliasDeclaration); + error(decl, ts.Diagnostics.Global_type_0_must_have_1_type_parameter_s, ts.symbolName(symbol), arity); + return undefined; + } + } + return symbol; + } + function getGlobalSymbol(name, meaning, diagnostic) { + // Don't track references for global symbols anyway, so value if `isReference` is arbitrary + return resolveName(undefined, name, meaning, diagnostic, name, /*isUse*/ false, /*excludeGlobals*/ false, /*getSpellingSuggestions*/ false); + } + function getGlobalType(name, arity, reportErrors) { + var symbol = getGlobalTypeSymbol(name, reportErrors); + return symbol || reportErrors ? getTypeOfGlobalSymbol(symbol, arity) : undefined; + } + function getGlobalTypedPropertyDescriptorType() { + // We always report an error, so store a result in the event we could not resolve the symbol to prevent reporting it multiple times + return deferredGlobalTypedPropertyDescriptorType || (deferredGlobalTypedPropertyDescriptorType = getGlobalType("TypedPropertyDescriptor", /*arity*/ 1, /*reportErrors*/ true) || emptyGenericType); + } + function getGlobalTemplateStringsArrayType() { + // We always report an error, so store a result in the event we could not resolve the symbol to prevent reporting it multiple times + return deferredGlobalTemplateStringsArrayType || (deferredGlobalTemplateStringsArrayType = getGlobalType("TemplateStringsArray", /*arity*/ 0, /*reportErrors*/ true) || emptyObjectType); + } + function getGlobalImportMetaType() { + // We always report an error, so store a result in the event we could not resolve the symbol to prevent reporting it multiple times + return deferredGlobalImportMetaType || (deferredGlobalImportMetaType = getGlobalType("ImportMeta", /*arity*/ 0, /*reportErrors*/ true) || emptyObjectType); + } + function getGlobalImportMetaExpressionType() { + if (!deferredGlobalImportMetaExpressionType) { + // Create a synthetic type `ImportMetaExpression { meta: MetaProperty }` + var symbol = createSymbol(0 /* SymbolFlags.None */, "ImportMetaExpression"); + var importMetaType = getGlobalImportMetaType(); + var metaPropertySymbol = createSymbol(4 /* SymbolFlags.Property */, "meta", 8 /* CheckFlags.Readonly */); + metaPropertySymbol.parent = symbol; + metaPropertySymbol.type = importMetaType; + var members = ts.createSymbolTable([metaPropertySymbol]); + symbol.members = members; + deferredGlobalImportMetaExpressionType = createAnonymousType(symbol, members, ts.emptyArray, ts.emptyArray, ts.emptyArray); + } + return deferredGlobalImportMetaExpressionType; + } + function getGlobalImportCallOptionsType(reportErrors) { + return (deferredGlobalImportCallOptionsType || (deferredGlobalImportCallOptionsType = getGlobalType("ImportCallOptions", /*arity*/ 0, reportErrors))) || emptyObjectType; + } + function getGlobalESSymbolConstructorSymbol(reportErrors) { + return deferredGlobalESSymbolConstructorSymbol || (deferredGlobalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol", reportErrors)); + } + function getGlobalESSymbolConstructorTypeSymbol(reportErrors) { + return deferredGlobalESSymbolConstructorTypeSymbol || (deferredGlobalESSymbolConstructorTypeSymbol = getGlobalTypeSymbol("SymbolConstructor", reportErrors)); + } + function getGlobalESSymbolType() { + return (deferredGlobalESSymbolType || (deferredGlobalESSymbolType = getGlobalType("Symbol", /*arity*/ 0, /*reportErrors*/ false))) || emptyObjectType; + } + function getGlobalPromiseType(reportErrors) { + return (deferredGlobalPromiseType || (deferredGlobalPromiseType = getGlobalType("Promise", /*arity*/ 1, reportErrors))) || emptyGenericType; + } + function getGlobalPromiseLikeType(reportErrors) { + return (deferredGlobalPromiseLikeType || (deferredGlobalPromiseLikeType = getGlobalType("PromiseLike", /*arity*/ 1, reportErrors))) || emptyGenericType; + } + function getGlobalPromiseConstructorSymbol(reportErrors) { + return deferredGlobalPromiseConstructorSymbol || (deferredGlobalPromiseConstructorSymbol = getGlobalValueSymbol("Promise", reportErrors)); + } + function getGlobalPromiseConstructorLikeType(reportErrors) { + return (deferredGlobalPromiseConstructorLikeType || (deferredGlobalPromiseConstructorLikeType = getGlobalType("PromiseConstructorLike", /*arity*/ 0, reportErrors))) || emptyObjectType; + } + function getGlobalAsyncIterableType(reportErrors) { + return (deferredGlobalAsyncIterableType || (deferredGlobalAsyncIterableType = getGlobalType("AsyncIterable", /*arity*/ 1, reportErrors))) || emptyGenericType; + } + function getGlobalAsyncIteratorType(reportErrors) { + return (deferredGlobalAsyncIteratorType || (deferredGlobalAsyncIteratorType = getGlobalType("AsyncIterator", /*arity*/ 3, reportErrors))) || emptyGenericType; + } + function getGlobalAsyncIterableIteratorType(reportErrors) { + return (deferredGlobalAsyncIterableIteratorType || (deferredGlobalAsyncIterableIteratorType = getGlobalType("AsyncIterableIterator", /*arity*/ 1, reportErrors))) || emptyGenericType; + } + function getGlobalAsyncGeneratorType(reportErrors) { + return (deferredGlobalAsyncGeneratorType || (deferredGlobalAsyncGeneratorType = getGlobalType("AsyncGenerator", /*arity*/ 3, reportErrors))) || emptyGenericType; + } + function getGlobalIterableType(reportErrors) { + return (deferredGlobalIterableType || (deferredGlobalIterableType = getGlobalType("Iterable", /*arity*/ 1, reportErrors))) || emptyGenericType; + } + function getGlobalIteratorType(reportErrors) { + return (deferredGlobalIteratorType || (deferredGlobalIteratorType = getGlobalType("Iterator", /*arity*/ 3, reportErrors))) || emptyGenericType; + } + function getGlobalIterableIteratorType(reportErrors) { + return (deferredGlobalIterableIteratorType || (deferredGlobalIterableIteratorType = getGlobalType("IterableIterator", /*arity*/ 1, reportErrors))) || emptyGenericType; + } + function getGlobalGeneratorType(reportErrors) { + return (deferredGlobalGeneratorType || (deferredGlobalGeneratorType = getGlobalType("Generator", /*arity*/ 3, reportErrors))) || emptyGenericType; + } + function getGlobalIteratorYieldResultType(reportErrors) { + return (deferredGlobalIteratorYieldResultType || (deferredGlobalIteratorYieldResultType = getGlobalType("IteratorYieldResult", /*arity*/ 1, reportErrors))) || emptyGenericType; + } + function getGlobalIteratorReturnResultType(reportErrors) { + return (deferredGlobalIteratorReturnResultType || (deferredGlobalIteratorReturnResultType = getGlobalType("IteratorReturnResult", /*arity*/ 1, reportErrors))) || emptyGenericType; + } + function getGlobalTypeOrUndefined(name, arity) { + if (arity === void 0) { arity = 0; } + var symbol = getGlobalSymbol(name, 788968 /* SymbolFlags.Type */, /*diagnostic*/ undefined); + return symbol && getTypeOfGlobalSymbol(symbol, arity); + } + function getGlobalExtractSymbol() { + // We always report an error, so cache a result in the event we could not resolve the symbol to prevent reporting it multiple times + deferredGlobalExtractSymbol || (deferredGlobalExtractSymbol = getGlobalTypeAliasSymbol("Extract", /*arity*/ 2, /*reportErrors*/ true) || unknownSymbol); + return deferredGlobalExtractSymbol === unknownSymbol ? undefined : deferredGlobalExtractSymbol; + } + function getGlobalOmitSymbol() { + // We always report an error, so cache a result in the event we could not resolve the symbol to prevent reporting it multiple times + deferredGlobalOmitSymbol || (deferredGlobalOmitSymbol = getGlobalTypeAliasSymbol("Omit", /*arity*/ 2, /*reportErrors*/ true) || unknownSymbol); + return deferredGlobalOmitSymbol === unknownSymbol ? undefined : deferredGlobalOmitSymbol; + } + function getGlobalAwaitedSymbol(reportErrors) { + // Only cache `unknownSymbol` if we are reporting errors so that we don't report the error more than once. + deferredGlobalAwaitedSymbol || (deferredGlobalAwaitedSymbol = getGlobalTypeAliasSymbol("Awaited", /*arity*/ 1, reportErrors) || (reportErrors ? unknownSymbol : undefined)); + return deferredGlobalAwaitedSymbol === unknownSymbol ? undefined : deferredGlobalAwaitedSymbol; + } + function getGlobalBigIntType() { + return (deferredGlobalBigIntType || (deferredGlobalBigIntType = getGlobalType("BigInt", /*arity*/ 0, /*reportErrors*/ false))) || emptyObjectType; + } + function getGlobalNaNSymbol() { + return (deferredGlobalNaNSymbol || (deferredGlobalNaNSymbol = getGlobalValueSymbol("NaN", /*reportErrors*/ false))); + } + function getGlobalRecordSymbol() { + deferredGlobalRecordSymbol || (deferredGlobalRecordSymbol = getGlobalTypeAliasSymbol("Record", /*arity*/ 2, /*reportErrors*/ true) || unknownSymbol); + return deferredGlobalRecordSymbol === unknownSymbol ? undefined : deferredGlobalRecordSymbol; + } + /** + * Instantiates a global type that is generic with some element type, and returns that instantiation. + */ + function createTypeFromGenericGlobalType(genericGlobalType, typeArguments) { + return genericGlobalType !== emptyGenericType ? createTypeReference(genericGlobalType, typeArguments) : emptyObjectType; + } + function createTypedPropertyDescriptorType(propertyType) { + return createTypeFromGenericGlobalType(getGlobalTypedPropertyDescriptorType(), [propertyType]); + } + function createIterableType(iteratedType) { + return createTypeFromGenericGlobalType(getGlobalIterableType(/*reportErrors*/ true), [iteratedType]); + } + function createArrayType(elementType, readonly) { + return createTypeFromGenericGlobalType(readonly ? globalReadonlyArrayType : globalArrayType, [elementType]); + } + function getTupleElementFlags(node) { + switch (node.kind) { + case 187 /* SyntaxKind.OptionalType */: + return 2 /* ElementFlags.Optional */; + case 188 /* SyntaxKind.RestType */: + return getRestTypeElementFlags(node); + case 199 /* SyntaxKind.NamedTupleMember */: + return node.questionToken ? 2 /* ElementFlags.Optional */ : + node.dotDotDotToken ? getRestTypeElementFlags(node) : + 1 /* ElementFlags.Required */; + default: + return 1 /* ElementFlags.Required */; + } + } + function getRestTypeElementFlags(node) { + return getArrayElementTypeNode(node.type) ? 4 /* ElementFlags.Rest */ : 8 /* ElementFlags.Variadic */; + } + function getArrayOrTupleTargetType(node) { + var readonly = isReadonlyTypeOperator(node.parent); + var elementType = getArrayElementTypeNode(node); + if (elementType) { + return readonly ? globalReadonlyArrayType : globalArrayType; + } + var elementFlags = ts.map(node.elements, getTupleElementFlags); + var missingName = ts.some(node.elements, function (e) { return e.kind !== 199 /* SyntaxKind.NamedTupleMember */; }); + return getTupleTargetType(elementFlags, readonly, /*associatedNames*/ missingName ? undefined : node.elements); + } + // Return true if the given type reference node is directly aliased or if it needs to be deferred + // because it is possibly contained in a circular chain of eagerly resolved types. + function isDeferredTypeReferenceNode(node, hasDefaultTypeArguments) { + return !!getAliasSymbolForTypeNode(node) || isResolvedByTypeAlias(node) && (node.kind === 185 /* SyntaxKind.ArrayType */ ? mayResolveTypeAlias(node.elementType) : + node.kind === 186 /* SyntaxKind.TupleType */ ? ts.some(node.elements, mayResolveTypeAlias) : + hasDefaultTypeArguments || ts.some(node.typeArguments, mayResolveTypeAlias)); + } + // Return true when the given node is transitively contained in type constructs that eagerly + // resolve their constituent types. We include SyntaxKind.TypeReference because type arguments + // of type aliases are eagerly resolved. + function isResolvedByTypeAlias(node) { + var parent = node.parent; + switch (parent.kind) { + case 193 /* SyntaxKind.ParenthesizedType */: + case 199 /* SyntaxKind.NamedTupleMember */: + case 180 /* SyntaxKind.TypeReference */: + case 189 /* SyntaxKind.UnionType */: + case 190 /* SyntaxKind.IntersectionType */: + case 196 /* SyntaxKind.IndexedAccessType */: + case 191 /* SyntaxKind.ConditionalType */: + case 195 /* SyntaxKind.TypeOperator */: + case 185 /* SyntaxKind.ArrayType */: + case 186 /* SyntaxKind.TupleType */: + return isResolvedByTypeAlias(parent); + case 262 /* SyntaxKind.TypeAliasDeclaration */: + return true; + } + return false; + } + // Return true if resolving the given node (i.e. getTypeFromTypeNode) possibly causes resolution + // of a type alias. + function mayResolveTypeAlias(node) { + switch (node.kind) { + case 180 /* SyntaxKind.TypeReference */: + return isJSDocTypeReference(node) || !!(resolveTypeReferenceName(node, 788968 /* SymbolFlags.Type */).flags & 524288 /* SymbolFlags.TypeAlias */); + case 183 /* SyntaxKind.TypeQuery */: + return true; + case 195 /* SyntaxKind.TypeOperator */: + return node.operator !== 156 /* SyntaxKind.UniqueKeyword */ && mayResolveTypeAlias(node.type); + case 193 /* SyntaxKind.ParenthesizedType */: + case 187 /* SyntaxKind.OptionalType */: + case 199 /* SyntaxKind.NamedTupleMember */: + case 319 /* SyntaxKind.JSDocOptionalType */: + case 317 /* SyntaxKind.JSDocNullableType */: + case 318 /* SyntaxKind.JSDocNonNullableType */: + case 312 /* SyntaxKind.JSDocTypeExpression */: + return mayResolveTypeAlias(node.type); + case 188 /* SyntaxKind.RestType */: + return node.type.kind !== 185 /* SyntaxKind.ArrayType */ || mayResolveTypeAlias(node.type.elementType); + case 189 /* SyntaxKind.UnionType */: + case 190 /* SyntaxKind.IntersectionType */: + return ts.some(node.types, mayResolveTypeAlias); + case 196 /* SyntaxKind.IndexedAccessType */: + return mayResolveTypeAlias(node.objectType) || mayResolveTypeAlias(node.indexType); + case 191 /* SyntaxKind.ConditionalType */: + return mayResolveTypeAlias(node.checkType) || mayResolveTypeAlias(node.extendsType) || + mayResolveTypeAlias(node.trueType) || mayResolveTypeAlias(node.falseType); + } + return false; + } + function getTypeFromArrayOrTupleTypeNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + var target = getArrayOrTupleTargetType(node); + if (target === emptyGenericType) { + links.resolvedType = emptyObjectType; + } + else if (!(node.kind === 186 /* SyntaxKind.TupleType */ && ts.some(node.elements, function (e) { return !!(getTupleElementFlags(e) & 8 /* ElementFlags.Variadic */); })) && isDeferredTypeReferenceNode(node)) { + links.resolvedType = node.kind === 186 /* SyntaxKind.TupleType */ && node.elements.length === 0 ? target : + createDeferredTypeReference(target, node, /*mapper*/ undefined); + } + else { + var elementTypes = node.kind === 185 /* SyntaxKind.ArrayType */ ? [getTypeFromTypeNode(node.elementType)] : ts.map(node.elements, getTypeFromTypeNode); + links.resolvedType = createNormalizedTypeReference(target, elementTypes); + } + } + return links.resolvedType; + } + function isReadonlyTypeOperator(node) { + return ts.isTypeOperatorNode(node) && node.operator === 146 /* SyntaxKind.ReadonlyKeyword */; + } + function createTupleType(elementTypes, elementFlags, readonly, namedMemberDeclarations) { + if (readonly === void 0) { readonly = false; } + var tupleTarget = getTupleTargetType(elementFlags || ts.map(elementTypes, function (_) { return 1 /* ElementFlags.Required */; }), readonly, namedMemberDeclarations); + return tupleTarget === emptyGenericType ? emptyObjectType : + elementTypes.length ? createNormalizedTypeReference(tupleTarget, elementTypes) : + tupleTarget; + } + function getTupleTargetType(elementFlags, readonly, namedMemberDeclarations) { + if (elementFlags.length === 1 && elementFlags[0] & 4 /* ElementFlags.Rest */) { + // [...X[]] is equivalent to just X[] + return readonly ? globalReadonlyArrayType : globalArrayType; + } + var key = ts.map(elementFlags, function (f) { return f & 1 /* ElementFlags.Required */ ? "#" : f & 2 /* ElementFlags.Optional */ ? "?" : f & 4 /* ElementFlags.Rest */ ? "." : "*"; }).join() + + (readonly ? "R" : "") + + (namedMemberDeclarations && namedMemberDeclarations.length ? "," + ts.map(namedMemberDeclarations, getNodeId).join(",") : ""); + var type = tupleTypes.get(key); + if (!type) { + tupleTypes.set(key, type = createTupleTargetType(elementFlags, readonly, namedMemberDeclarations)); + } + return type; + } + // We represent tuple types as type references to synthesized generic interface types created by + // this function. The types are of the form: + // + // interface Tuple extends Array { 0: T0, 1: T1, 2: T2, ... } + // + // Note that the generic type created by this function has no symbol associated with it. The same + // is true for each of the synthesized type parameters. + function createTupleTargetType(elementFlags, readonly, namedMemberDeclarations) { + var arity = elementFlags.length; + var minLength = ts.countWhere(elementFlags, function (f) { return !!(f & (1 /* ElementFlags.Required */ | 8 /* ElementFlags.Variadic */)); }); + var typeParameters; + var properties = []; + var combinedFlags = 0; + if (arity) { + typeParameters = new Array(arity); + for (var i = 0; i < arity; i++) { + var typeParameter = typeParameters[i] = createTypeParameter(); + var flags = elementFlags[i]; + combinedFlags |= flags; + if (!(combinedFlags & 12 /* ElementFlags.Variable */)) { + var property = createSymbol(4 /* SymbolFlags.Property */ | (flags & 2 /* ElementFlags.Optional */ ? 16777216 /* SymbolFlags.Optional */ : 0), "" + i, readonly ? 8 /* CheckFlags.Readonly */ : 0); + property.tupleLabelDeclaration = namedMemberDeclarations === null || namedMemberDeclarations === void 0 ? void 0 : namedMemberDeclarations[i]; + property.type = typeParameter; + properties.push(property); + } + } + } + var fixedLength = properties.length; + var lengthSymbol = createSymbol(4 /* SymbolFlags.Property */, "length", readonly ? 8 /* CheckFlags.Readonly */ : 0); + if (combinedFlags & 12 /* ElementFlags.Variable */) { + lengthSymbol.type = numberType; + } + else { + var literalTypes = []; + for (var i = minLength; i <= arity; i++) + literalTypes.push(getNumberLiteralType(i)); + lengthSymbol.type = getUnionType(literalTypes); + } + properties.push(lengthSymbol); + var type = createObjectType(8 /* ObjectFlags.Tuple */ | 4 /* ObjectFlags.Reference */); + type.typeParameters = typeParameters; + type.outerTypeParameters = undefined; + type.localTypeParameters = typeParameters; + type.instantiations = new ts.Map(); + type.instantiations.set(getTypeListId(type.typeParameters), type); + type.target = type; + type.resolvedTypeArguments = type.typeParameters; + type.thisType = createTypeParameter(); + type.thisType.isThisType = true; + type.thisType.constraint = type; + type.declaredProperties = properties; + type.declaredCallSignatures = ts.emptyArray; + type.declaredConstructSignatures = ts.emptyArray; + type.declaredIndexInfos = ts.emptyArray; + type.elementFlags = elementFlags; + type.minLength = minLength; + type.fixedLength = fixedLength; + type.hasRestElement = !!(combinedFlags & 12 /* ElementFlags.Variable */); + type.combinedFlags = combinedFlags; + type.readonly = readonly; + type.labeledElementDeclarations = namedMemberDeclarations; + return type; + } + function createNormalizedTypeReference(target, typeArguments) { + return target.objectFlags & 8 /* ObjectFlags.Tuple */ ? createNormalizedTupleType(target, typeArguments) : createTypeReference(target, typeArguments); + } + function createNormalizedTupleType(target, elementTypes) { + var _a, _b, _c; + if (!(target.combinedFlags & 14 /* ElementFlags.NonRequired */)) { + // No need to normalize when we only have regular required elements + return createTypeReference(target, elementTypes); + } + if (target.combinedFlags & 8 /* ElementFlags.Variadic */) { + // Transform [A, ...(X | Y | Z)] into [A, ...X] | [A, ...Y] | [A, ...Z] + var unionIndex_1 = ts.findIndex(elementTypes, function (t, i) { return !!(target.elementFlags[i] & 8 /* ElementFlags.Variadic */ && t.flags & (131072 /* TypeFlags.Never */ | 1048576 /* TypeFlags.Union */)); }); + if (unionIndex_1 >= 0) { + return checkCrossProductUnion(ts.map(elementTypes, function (t, i) { return target.elementFlags[i] & 8 /* ElementFlags.Variadic */ ? t : unknownType; })) ? + mapType(elementTypes[unionIndex_1], function (t) { return createNormalizedTupleType(target, ts.replaceElement(elementTypes, unionIndex_1, t)); }) : + errorType; + } + } + // We have optional, rest, or variadic elements that may need normalizing. Normalization ensures that all variadic + // elements are generic and that the tuple type has one of the following layouts, disregarding variadic elements: + // (1) Zero or more required elements, followed by zero or more optional elements, followed by zero or one rest element. + // (2) Zero or more required elements, followed by a rest element, followed by zero or more required elements. + // In either layout, zero or more generic variadic elements may be present at any location. + var expandedTypes = []; + var expandedFlags = []; + var expandedDeclarations = []; + var lastRequiredIndex = -1; + var firstRestIndex = -1; + var lastOptionalOrRestIndex = -1; + var _loop_17 = function (i) { + var type = elementTypes[i]; + var flags = target.elementFlags[i]; + if (flags & 8 /* ElementFlags.Variadic */) { + if (type.flags & 58982400 /* TypeFlags.InstantiableNonPrimitive */ || isGenericMappedType(type)) { + // Generic variadic elements stay as they are. + addElement(type, 8 /* ElementFlags.Variadic */, (_a = target.labeledElementDeclarations) === null || _a === void 0 ? void 0 : _a[i]); + } + else if (isTupleType(type)) { + var elements = getTypeArguments(type); + if (elements.length + expandedTypes.length >= 10000) { + error(currentNode, ts.isPartOfTypeNode(currentNode) + ? ts.Diagnostics.Type_produces_a_tuple_type_that_is_too_large_to_represent + : ts.Diagnostics.Expression_produces_a_tuple_type_that_is_too_large_to_represent); + return { value: errorType }; + } + // Spread variadic elements with tuple types into the resulting tuple. + ts.forEach(elements, function (t, n) { var _a; return addElement(t, type.target.elementFlags[n], (_a = type.target.labeledElementDeclarations) === null || _a === void 0 ? void 0 : _a[n]); }); + } + else { + // Treat everything else as an array type and create a rest element. + addElement(isArrayLikeType(type) && getIndexTypeOfType(type, numberType) || errorType, 4 /* ElementFlags.Rest */, (_b = target.labeledElementDeclarations) === null || _b === void 0 ? void 0 : _b[i]); + } + } + else { + // Copy other element kinds with no change. + addElement(type, flags, (_c = target.labeledElementDeclarations) === null || _c === void 0 ? void 0 : _c[i]); + } + }; + for (var i = 0; i < elementTypes.length; i++) { + var state_5 = _loop_17(i); + if (typeof state_5 === "object") + return state_5.value; + } + // Turn optional elements preceding the last required element into required elements + for (var i = 0; i < lastRequiredIndex; i++) { + if (expandedFlags[i] & 2 /* ElementFlags.Optional */) + expandedFlags[i] = 1 /* ElementFlags.Required */; + } + if (firstRestIndex >= 0 && firstRestIndex < lastOptionalOrRestIndex) { + // Turn elements between first rest and last optional/rest into a single rest element + expandedTypes[firstRestIndex] = getUnionType(ts.sameMap(expandedTypes.slice(firstRestIndex, lastOptionalOrRestIndex + 1), function (t, i) { return expandedFlags[firstRestIndex + i] & 8 /* ElementFlags.Variadic */ ? getIndexedAccessType(t, numberType) : t; })); + expandedTypes.splice(firstRestIndex + 1, lastOptionalOrRestIndex - firstRestIndex); + expandedFlags.splice(firstRestIndex + 1, lastOptionalOrRestIndex - firstRestIndex); + expandedDeclarations === null || expandedDeclarations === void 0 ? void 0 : expandedDeclarations.splice(firstRestIndex + 1, lastOptionalOrRestIndex - firstRestIndex); + } + var tupleTarget = getTupleTargetType(expandedFlags, target.readonly, expandedDeclarations); + return tupleTarget === emptyGenericType ? emptyObjectType : + expandedFlags.length ? createTypeReference(tupleTarget, expandedTypes) : + tupleTarget; + function addElement(type, flags, declaration) { + if (flags & 1 /* ElementFlags.Required */) { + lastRequiredIndex = expandedFlags.length; + } + if (flags & 4 /* ElementFlags.Rest */ && firstRestIndex < 0) { + firstRestIndex = expandedFlags.length; + } + if (flags & (2 /* ElementFlags.Optional */ | 4 /* ElementFlags.Rest */)) { + lastOptionalOrRestIndex = expandedFlags.length; + } + expandedTypes.push(flags & 2 /* ElementFlags.Optional */ ? addOptionality(type, /*isProperty*/ true) : type); + expandedFlags.push(flags); + if (expandedDeclarations && declaration) { + expandedDeclarations.push(declaration); + } + else { + expandedDeclarations = undefined; + } + } + } + function sliceTupleType(type, index, endSkipCount) { + if (endSkipCount === void 0) { endSkipCount = 0; } + var target = type.target; + var endIndex = getTypeReferenceArity(type) - endSkipCount; + return index > target.fixedLength ? getRestArrayTypeOfTupleType(type) || createTupleType(ts.emptyArray) : + createTupleType(getTypeArguments(type).slice(index, endIndex), target.elementFlags.slice(index, endIndex), + /*readonly*/ false, target.labeledElementDeclarations && target.labeledElementDeclarations.slice(index, endIndex)); + } + function getKnownKeysOfTupleType(type) { + return getUnionType(ts.append(ts.arrayOf(type.target.fixedLength, function (i) { return getStringLiteralType("" + i); }), getIndexType(type.target.readonly ? globalReadonlyArrayType : globalArrayType))); + } + // Return count of starting consecutive tuple elements of the given kind(s) + function getStartElementCount(type, flags) { + var index = ts.findIndex(type.elementFlags, function (f) { return !(f & flags); }); + return index >= 0 ? index : type.elementFlags.length; + } + // Return count of ending consecutive tuple elements of the given kind(s) + function getEndElementCount(type, flags) { + return type.elementFlags.length - ts.findLastIndex(type.elementFlags, function (f) { return !(f & flags); }) - 1; + } + function getTypeFromOptionalTypeNode(node) { + return addOptionality(getTypeFromTypeNode(node.type), /*isProperty*/ true); + } + function getTypeId(type) { + return type.id; + } + function containsType(types, type) { + return ts.binarySearch(types, type, getTypeId, ts.compareValues) >= 0; + } + function insertType(types, type) { + var index = ts.binarySearch(types, type, getTypeId, ts.compareValues); + if (index < 0) { + types.splice(~index, 0, type); + return true; + } + return false; + } + function addTypeToUnion(typeSet, includes, type) { + var flags = type.flags; + if (flags & 1048576 /* TypeFlags.Union */) { + return addTypesToUnion(typeSet, includes | (isNamedUnionType(type) ? 1048576 /* TypeFlags.Union */ : 0), type.types); + } + // We ignore 'never' types in unions + if (!(flags & 131072 /* TypeFlags.Never */)) { + includes |= flags & 205258751 /* TypeFlags.IncludesMask */; + if (flags & 465829888 /* TypeFlags.Instantiable */) + includes |= 33554432 /* TypeFlags.IncludesInstantiable */; + if (type === wildcardType) + includes |= 8388608 /* TypeFlags.IncludesWildcard */; + if (!strictNullChecks && flags & 98304 /* TypeFlags.Nullable */) { + if (!(ts.getObjectFlags(type) & 65536 /* ObjectFlags.ContainsWideningType */)) + includes |= 4194304 /* TypeFlags.IncludesNonWideningType */; + } + else { + var len = typeSet.length; + var index = len && type.id > typeSet[len - 1].id ? ~len : ts.binarySearch(typeSet, type, getTypeId, ts.compareValues); + if (index < 0) { + typeSet.splice(~index, 0, type); + } + } + } + return includes; + } + // Add the given types to the given type set. Order is preserved, duplicates are removed, + // and nested types of the given kind are flattened into the set. + function addTypesToUnion(typeSet, includes, types) { + for (var _i = 0, types_9 = types; _i < types_9.length; _i++) { + var type = types_9[_i]; + includes = addTypeToUnion(typeSet, includes, type); + } + return includes; + } + function removeSubtypes(types, hasObjectTypes) { + // [] and [T] immediately reduce to [] and [T] respectively + if (types.length < 2) { + return types; + } + var id = getTypeListId(types); + var match = subtypeReductionCache.get(id); + if (match) { + return match; + } + // We assume that redundant primitive types have already been removed from the types array and that there + // are no any and unknown types in the array. Thus, the only possible supertypes for primitive types are empty + // object types, and if none of those are present we can exclude primitive types from the subtype check. + var hasEmptyObject = hasObjectTypes && ts.some(types, function (t) { return !!(t.flags & 524288 /* TypeFlags.Object */) && !isGenericMappedType(t) && isEmptyResolvedType(resolveStructuredTypeMembers(t)); }); + var len = types.length; + var i = len; + var count = 0; + while (i > 0) { + i--; + var source = types[i]; + if (hasEmptyObject || source.flags & 469499904 /* TypeFlags.StructuredOrInstantiable */) { + // Find the first property with a unit type, if any. When constituents have a property by the same name + // but of a different unit type, we can quickly disqualify them from subtype checks. This helps subtype + // reduction of large discriminated union types. + var keyProperty = source.flags & (524288 /* TypeFlags.Object */ | 2097152 /* TypeFlags.Intersection */ | 58982400 /* TypeFlags.InstantiableNonPrimitive */) ? + ts.find(getPropertiesOfType(source), function (p) { return isUnitType(getTypeOfSymbol(p)); }) : + undefined; + var keyPropertyType = keyProperty && getRegularTypeOfLiteralType(getTypeOfSymbol(keyProperty)); + for (var _i = 0, types_10 = types; _i < types_10.length; _i++) { + var target = types_10[_i]; + if (source !== target) { + if (count === 100000) { + // After 100000 subtype checks we estimate the remaining amount of work by assuming the + // same ratio of checks per element. If the estimated number of remaining type checks is + // greater than 1M we deem the union type too complex to represent. This for example + // caps union types at 1000 unique object types. + var estimatedCount = (count / (len - i)) * len; + if (estimatedCount > 1000000) { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes" /* tracing.Phase.CheckTypes */, "removeSubtypes_DepthLimit", { typeIds: types.map(function (t) { return t.id; }) }); + error(currentNode, ts.Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent); + return undefined; + } + } + count++; + if (keyProperty && target.flags & (524288 /* TypeFlags.Object */ | 2097152 /* TypeFlags.Intersection */ | 58982400 /* TypeFlags.InstantiableNonPrimitive */)) { + var t = getTypeOfPropertyOfType(target, keyProperty.escapedName); + if (t && isUnitType(t) && getRegularTypeOfLiteralType(t) !== keyPropertyType) { + continue; + } + } + if (isTypeRelatedTo(source, target, strictSubtypeRelation) && (!(ts.getObjectFlags(getTargetType(source)) & 1 /* ObjectFlags.Class */) || + !(ts.getObjectFlags(getTargetType(target)) & 1 /* ObjectFlags.Class */) || + isTypeDerivedFrom(source, target))) { + ts.orderedRemoveItemAt(types, i); + break; + } + } + } + } + } + subtypeReductionCache.set(id, types); + return types; + } + function removeRedundantLiteralTypes(types, includes, reduceVoidUndefined) { + var i = types.length; + while (i > 0) { + i--; + var t = types[i]; + var flags = t.flags; + var remove = flags & (128 /* TypeFlags.StringLiteral */ | 134217728 /* TypeFlags.TemplateLiteral */ | 268435456 /* TypeFlags.StringMapping */) && includes & 4 /* TypeFlags.String */ || + flags & 256 /* TypeFlags.NumberLiteral */ && includes & 8 /* TypeFlags.Number */ || + flags & 2048 /* TypeFlags.BigIntLiteral */ && includes & 64 /* TypeFlags.BigInt */ || + flags & 8192 /* TypeFlags.UniqueESSymbol */ && includes & 4096 /* TypeFlags.ESSymbol */ || + reduceVoidUndefined && flags & 32768 /* TypeFlags.Undefined */ && includes & 16384 /* TypeFlags.Void */ || + isFreshLiteralType(t) && containsType(types, t.regularType); + if (remove) { + ts.orderedRemoveItemAt(types, i); + } + } + } + function removeStringLiteralsMatchedByTemplateLiterals(types) { + var templates = ts.filter(types, isPatternLiteralType); + if (templates.length) { + var i = types.length; + var _loop_18 = function () { + i--; + var t = types[i]; + if (t.flags & 128 /* TypeFlags.StringLiteral */ && ts.some(templates, function (template) { return isTypeMatchedByTemplateLiteralType(t, template); })) { + ts.orderedRemoveItemAt(types, i); + } + }; + while (i > 0) { + _loop_18(); + } + } + } + function isNamedUnionType(type) { + return !!(type.flags & 1048576 /* TypeFlags.Union */ && (type.aliasSymbol || type.origin)); + } + function addNamedUnions(namedUnions, types) { + for (var _i = 0, types_11 = types; _i < types_11.length; _i++) { + var t = types_11[_i]; + if (t.flags & 1048576 /* TypeFlags.Union */) { + var origin = t.origin; + if (t.aliasSymbol || origin && !(origin.flags & 1048576 /* TypeFlags.Union */)) { + ts.pushIfUnique(namedUnions, t); + } + else if (origin && origin.flags & 1048576 /* TypeFlags.Union */) { + addNamedUnions(namedUnions, origin.types); + } + } + } + } + function createOriginUnionOrIntersectionType(flags, types) { + var result = createOriginType(flags); + result.types = types; + return result; + } + // We sort and deduplicate the constituent types based on object identity. If the subtypeReduction + // flag is specified we also reduce the constituent type set to only include types that aren't subtypes + // of other types. Subtype reduction is expensive for large union types and is possible only when union + // types are known not to circularly reference themselves (as is the case with union types created by + // expression constructs such as array literals and the || and ?: operators). Named types can + // circularly reference themselves and therefore cannot be subtype reduced during their declaration. + // For example, "type Item = string | (() => Item" is a named type that circularly references itself. + function getUnionType(types, unionReduction, aliasSymbol, aliasTypeArguments, origin) { + if (unionReduction === void 0) { unionReduction = 1 /* UnionReduction.Literal */; } + if (types.length === 0) { + return neverType; + } + if (types.length === 1) { + return types[0]; + } + var typeSet = []; + var includes = addTypesToUnion(typeSet, 0, types); + if (unionReduction !== 0 /* UnionReduction.None */) { + if (includes & 3 /* TypeFlags.AnyOrUnknown */) { + return includes & 1 /* TypeFlags.Any */ ? + includes & 8388608 /* TypeFlags.IncludesWildcard */ ? wildcardType : anyType : + includes & 65536 /* TypeFlags.Null */ || containsType(typeSet, unknownType) ? unknownType : nonNullUnknownType; + } + if (exactOptionalPropertyTypes && includes & 32768 /* TypeFlags.Undefined */) { + var missingIndex = ts.binarySearch(typeSet, missingType, getTypeId, ts.compareValues); + if (missingIndex >= 0 && containsType(typeSet, undefinedType)) { + ts.orderedRemoveItemAt(typeSet, missingIndex); + } + } + if (includes & (2944 /* TypeFlags.Literal */ | 8192 /* TypeFlags.UniqueESSymbol */ | 134217728 /* TypeFlags.TemplateLiteral */ | 268435456 /* TypeFlags.StringMapping */) || includes & 16384 /* TypeFlags.Void */ && includes & 32768 /* TypeFlags.Undefined */) { + removeRedundantLiteralTypes(typeSet, includes, !!(unionReduction & 2 /* UnionReduction.Subtype */)); + } + if (includes & 128 /* TypeFlags.StringLiteral */ && includes & 134217728 /* TypeFlags.TemplateLiteral */) { + removeStringLiteralsMatchedByTemplateLiterals(typeSet); + } + if (unionReduction === 2 /* UnionReduction.Subtype */) { + typeSet = removeSubtypes(typeSet, !!(includes & 524288 /* TypeFlags.Object */)); + if (!typeSet) { + return errorType; + } + } + if (typeSet.length === 0) { + return includes & 65536 /* TypeFlags.Null */ ? includes & 4194304 /* TypeFlags.IncludesNonWideningType */ ? nullType : nullWideningType : + includes & 32768 /* TypeFlags.Undefined */ ? includes & 4194304 /* TypeFlags.IncludesNonWideningType */ ? undefinedType : undefinedWideningType : + neverType; + } + } + if (!origin && includes & 1048576 /* TypeFlags.Union */) { + var namedUnions = []; + addNamedUnions(namedUnions, types); + var reducedTypes = []; + var _loop_19 = function (t) { + if (!ts.some(namedUnions, function (union) { return containsType(union.types, t); })) { + reducedTypes.push(t); + } + }; + for (var _i = 0, typeSet_1 = typeSet; _i < typeSet_1.length; _i++) { + var t = typeSet_1[_i]; + _loop_19(t); + } + if (!aliasSymbol && namedUnions.length === 1 && reducedTypes.length === 0) { + return namedUnions[0]; + } + // We create a denormalized origin type only when the union was created from one or more named unions + // (unions with alias symbols or origins) and when there is no overlap between those named unions. + var namedTypesCount = ts.reduceLeft(namedUnions, function (sum, union) { return sum + union.types.length; }, 0); + if (namedTypesCount + reducedTypes.length === typeSet.length) { + for (var _a = 0, namedUnions_1 = namedUnions; _a < namedUnions_1.length; _a++) { + var t = namedUnions_1[_a]; + insertType(reducedTypes, t); + } + origin = createOriginUnionOrIntersectionType(1048576 /* TypeFlags.Union */, reducedTypes); + } + } + var objectFlags = (includes & 36323363 /* TypeFlags.NotPrimitiveUnion */ ? 0 : 32768 /* ObjectFlags.PrimitiveUnion */) | + (includes & 2097152 /* TypeFlags.Intersection */ ? 16777216 /* ObjectFlags.ContainsIntersections */ : 0); + return getUnionTypeFromSortedList(typeSet, objectFlags, aliasSymbol, aliasTypeArguments, origin); + } + function getUnionOrIntersectionTypePredicate(signatures, kind) { + var first; + var types = []; + for (var _i = 0, signatures_6 = signatures; _i < signatures_6.length; _i++) { + var sig = signatures_6[_i]; + var pred = getTypePredicateOfSignature(sig); + if (!pred || pred.kind === 2 /* TypePredicateKind.AssertsThis */ || pred.kind === 3 /* TypePredicateKind.AssertsIdentifier */) { + if (kind !== 2097152 /* TypeFlags.Intersection */) { + continue; + } + else { + return; // intersections demand all members be type predicates for the result to have a predicate + } + } + if (first) { + if (!typePredicateKindsMatch(first, pred)) { + // No common type predicate. + return undefined; + } + } + else { + first = pred; + } + types.push(pred.type); + } + if (!first) { + // No signatures had a type predicate. + return undefined; + } + var compositeType = getUnionOrIntersectionType(types, kind); + return createTypePredicate(first.kind, first.parameterName, first.parameterIndex, compositeType); + } + function typePredicateKindsMatch(a, b) { + return a.kind === b.kind && a.parameterIndex === b.parameterIndex; + } + // This function assumes the constituent type list is sorted and deduplicated. + function getUnionTypeFromSortedList(types, objectFlags, aliasSymbol, aliasTypeArguments, origin) { + if (types.length === 0) { + return neverType; + } + if (types.length === 1) { + return types[0]; + } + var typeKey = !origin ? getTypeListId(types) : + origin.flags & 1048576 /* TypeFlags.Union */ ? "|".concat(getTypeListId(origin.types)) : + origin.flags & 2097152 /* TypeFlags.Intersection */ ? "&".concat(getTypeListId(origin.types)) : + "#".concat(origin.type.id, "|").concat(getTypeListId(types)); // origin type id alone is insufficient, as `keyof x` may resolve to multiple WIP values while `x` is still resolving + var id = typeKey + getAliasId(aliasSymbol, aliasTypeArguments); + var type = unionTypes.get(id); + if (!type) { + type = createType(1048576 /* TypeFlags.Union */); + type.objectFlags = objectFlags | getPropagatingFlagsOfTypes(types, /*excludeKinds*/ 98304 /* TypeFlags.Nullable */); + type.types = types; + type.origin = origin; + type.aliasSymbol = aliasSymbol; + type.aliasTypeArguments = aliasTypeArguments; + if (types.length === 2 && types[0].flags & 512 /* TypeFlags.BooleanLiteral */ && types[1].flags & 512 /* TypeFlags.BooleanLiteral */) { + type.flags |= 16 /* TypeFlags.Boolean */; + type.intrinsicName = "boolean"; + } + unionTypes.set(id, type); + } + return type; + } + function getTypeFromUnionTypeNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + var aliasSymbol = getAliasSymbolForTypeNode(node); + links.resolvedType = getUnionType(ts.map(node.types, getTypeFromTypeNode), 1 /* UnionReduction.Literal */, aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol)); + } + return links.resolvedType; + } + function addTypeToIntersection(typeSet, includes, type) { + var flags = type.flags; + if (flags & 2097152 /* TypeFlags.Intersection */) { + return addTypesToIntersection(typeSet, includes, type.types); + } + if (isEmptyAnonymousObjectType(type)) { + if (!(includes & 16777216 /* TypeFlags.IncludesEmptyObject */)) { + includes |= 16777216 /* TypeFlags.IncludesEmptyObject */; + typeSet.set(type.id.toString(), type); + } + } + else { + if (flags & 3 /* TypeFlags.AnyOrUnknown */) { + if (type === wildcardType) + includes |= 8388608 /* TypeFlags.IncludesWildcard */; + } + else if (strictNullChecks || !(flags & 98304 /* TypeFlags.Nullable */)) { + if (exactOptionalPropertyTypes && type === missingType) { + includes |= 262144 /* TypeFlags.IncludesMissingType */; + type = undefinedType; + } + if (!typeSet.has(type.id.toString())) { + if (type.flags & 109440 /* TypeFlags.Unit */ && includes & 109440 /* TypeFlags.Unit */) { + // We have seen two distinct unit types which means we should reduce to an + // empty intersection. Adding TypeFlags.NonPrimitive causes that to happen. + includes |= 67108864 /* TypeFlags.NonPrimitive */; + } + typeSet.set(type.id.toString(), type); + } + } + includes |= flags & 205258751 /* TypeFlags.IncludesMask */; + } + return includes; + } + // Add the given types to the given type set. Order is preserved, freshness is removed from literal + // types, duplicates are removed, and nested types of the given kind are flattened into the set. + function addTypesToIntersection(typeSet, includes, types) { + for (var _i = 0, types_12 = types; _i < types_12.length; _i++) { + var type = types_12[_i]; + includes = addTypeToIntersection(typeSet, includes, getRegularTypeOfLiteralType(type)); + } + return includes; + } + function removeRedundantSupertypes(types, includes) { + var i = types.length; + while (i > 0) { + i--; + var t = types[i]; + var remove = t.flags & 4 /* TypeFlags.String */ && includes & (128 /* TypeFlags.StringLiteral */ | 134217728 /* TypeFlags.TemplateLiteral */ | 268435456 /* TypeFlags.StringMapping */) || + t.flags & 8 /* TypeFlags.Number */ && includes & 256 /* TypeFlags.NumberLiteral */ || + t.flags & 64 /* TypeFlags.BigInt */ && includes & 2048 /* TypeFlags.BigIntLiteral */ || + t.flags & 4096 /* TypeFlags.ESSymbol */ && includes & 8192 /* TypeFlags.UniqueESSymbol */ || + t.flags & 16384 /* TypeFlags.Void */ && includes & 32768 /* TypeFlags.Undefined */ || + isEmptyAnonymousObjectType(t) && includes & 470302716 /* TypeFlags.DefinitelyNonNullable */; + if (remove) { + ts.orderedRemoveItemAt(types, i); + } + } + } + // Check that the given type has a match in every union. A given type is matched by + // an identical type, and a literal type is additionally matched by its corresponding + // primitive type. + function eachUnionContains(unionTypes, type) { + for (var _i = 0, unionTypes_1 = unionTypes; _i < unionTypes_1.length; _i++) { + var u = unionTypes_1[_i]; + if (!containsType(u.types, type)) { + var primitive = type.flags & 128 /* TypeFlags.StringLiteral */ ? stringType : + type.flags & 256 /* TypeFlags.NumberLiteral */ ? numberType : + type.flags & 2048 /* TypeFlags.BigIntLiteral */ ? bigintType : + type.flags & 8192 /* TypeFlags.UniqueESSymbol */ ? esSymbolType : + undefined; + if (!primitive || !containsType(u.types, primitive)) { + return false; + } + } + } + return true; + } + /** + * Returns `true` if the intersection of the template literals and string literals is the empty set, eg `get${string}` & "setX", and should reduce to `never` + */ + function extractRedundantTemplateLiterals(types) { + var i = types.length; + var literals = ts.filter(types, function (t) { return !!(t.flags & 128 /* TypeFlags.StringLiteral */); }); + while (i > 0) { + i--; + var t = types[i]; + if (!(t.flags & 134217728 /* TypeFlags.TemplateLiteral */)) + continue; + for (var _i = 0, literals_1 = literals; _i < literals_1.length; _i++) { + var t2 = literals_1[_i]; + if (isTypeSubtypeOf(t2, t)) { + // eg, ``get${T}` & "getX"` is just `"getX"` + ts.orderedRemoveItemAt(types, i); + break; + } + else if (isPatternLiteralType(t)) { + return true; + } + } + } + return false; + } + function eachIsUnionContaining(types, flag) { + return ts.every(types, function (t) { return !!(t.flags & 1048576 /* TypeFlags.Union */) && ts.some(t.types, function (tt) { return !!(tt.flags & flag); }); }); + } + function removeFromEach(types, flag) { + for (var i = 0; i < types.length; i++) { + types[i] = filterType(types[i], function (t) { return !(t.flags & flag); }); + } + } + // If the given list of types contains more than one union of primitive types, replace the + // first with a union containing an intersection of those primitive types, then remove the + // other unions and return true. Otherwise, do nothing and return false. + function intersectUnionsOfPrimitiveTypes(types) { + var unionTypes; + var index = ts.findIndex(types, function (t) { return !!(ts.getObjectFlags(t) & 32768 /* ObjectFlags.PrimitiveUnion */); }); + if (index < 0) { + return false; + } + var i = index + 1; + // Remove all but the first union of primitive types and collect them in + // the unionTypes array. + while (i < types.length) { + var t = types[i]; + if (ts.getObjectFlags(t) & 32768 /* ObjectFlags.PrimitiveUnion */) { + (unionTypes || (unionTypes = [types[index]])).push(t); + ts.orderedRemoveItemAt(types, i); + } + else { + i++; + } + } + // Return false if there was only one union of primitive types + if (!unionTypes) { + return false; + } + // We have more than one union of primitive types, now intersect them. For each + // type in each union we check if the type is matched in every union and if so + // we include it in the result. + var checked = []; + var result = []; + for (var _i = 0, unionTypes_2 = unionTypes; _i < unionTypes_2.length; _i++) { + var u = unionTypes_2[_i]; + for (var _a = 0, _b = u.types; _a < _b.length; _a++) { + var t = _b[_a]; + if (insertType(checked, t)) { + if (eachUnionContains(unionTypes, t)) { + insertType(result, t); + } + } + } + } + // Finally replace the first union with the result + types[index] = getUnionTypeFromSortedList(result, 32768 /* ObjectFlags.PrimitiveUnion */); + return true; + } + function createIntersectionType(types, aliasSymbol, aliasTypeArguments) { + var result = createType(2097152 /* TypeFlags.Intersection */); + result.objectFlags = getPropagatingFlagsOfTypes(types, /*excludeKinds*/ 98304 /* TypeFlags.Nullable */); + result.types = types; + result.aliasSymbol = aliasSymbol; + result.aliasTypeArguments = aliasTypeArguments; + return result; + } + // We normalize combinations of intersection and union types based on the distributive property of the '&' + // operator. Specifically, because X & (A | B) is equivalent to X & A | X & B, we can transform intersection + // types with union type constituents into equivalent union types with intersection type constituents and + // effectively ensure that union types are always at the top level in type representations. + // + // We do not perform structural deduplication on intersection types. Intersection types are created only by the & + // type operator and we can't reduce those because we want to support recursive intersection types. For example, + // a type alias of the form "type List = T & { next: List }" cannot be reduced during its declaration. + // Also, unlike union types, the order of the constituent types is preserved in order that overload resolution + // for intersections of types with signatures can be deterministic. + function getIntersectionType(types, aliasSymbol, aliasTypeArguments, noSupertypeReduction) { + var typeMembershipMap = new ts.Map(); + var includes = addTypesToIntersection(typeMembershipMap, 0, types); + var typeSet = ts.arrayFrom(typeMembershipMap.values()); + // An intersection type is considered empty if it contains + // the type never, or + // more than one unit type or, + // an object type and a nullable type (null or undefined), or + // a string-like type and a type known to be non-string-like, or + // a number-like type and a type known to be non-number-like, or + // a symbol-like type and a type known to be non-symbol-like, or + // a void-like type and a type known to be non-void-like, or + // a non-primitive type and a type known to be primitive. + if (includes & 131072 /* TypeFlags.Never */) { + return ts.contains(typeSet, silentNeverType) ? silentNeverType : neverType; + } + if (strictNullChecks && includes & 98304 /* TypeFlags.Nullable */ && includes & (524288 /* TypeFlags.Object */ | 67108864 /* TypeFlags.NonPrimitive */ | 16777216 /* TypeFlags.IncludesEmptyObject */) || + includes & 67108864 /* TypeFlags.NonPrimitive */ && includes & (469892092 /* TypeFlags.DisjointDomains */ & ~67108864 /* TypeFlags.NonPrimitive */) || + includes & 402653316 /* TypeFlags.StringLike */ && includes & (469892092 /* TypeFlags.DisjointDomains */ & ~402653316 /* TypeFlags.StringLike */) || + includes & 296 /* TypeFlags.NumberLike */ && includes & (469892092 /* TypeFlags.DisjointDomains */ & ~296 /* TypeFlags.NumberLike */) || + includes & 2112 /* TypeFlags.BigIntLike */ && includes & (469892092 /* TypeFlags.DisjointDomains */ & ~2112 /* TypeFlags.BigIntLike */) || + includes & 12288 /* TypeFlags.ESSymbolLike */ && includes & (469892092 /* TypeFlags.DisjointDomains */ & ~12288 /* TypeFlags.ESSymbolLike */) || + includes & 49152 /* TypeFlags.VoidLike */ && includes & (469892092 /* TypeFlags.DisjointDomains */ & ~49152 /* TypeFlags.VoidLike */)) { + return neverType; + } + if (includes & 134217728 /* TypeFlags.TemplateLiteral */ && includes & 128 /* TypeFlags.StringLiteral */ && extractRedundantTemplateLiterals(typeSet)) { + return neverType; + } + if (includes & 1 /* TypeFlags.Any */) { + return includes & 8388608 /* TypeFlags.IncludesWildcard */ ? wildcardType : anyType; + } + if (!strictNullChecks && includes & 98304 /* TypeFlags.Nullable */) { + return includes & 16777216 /* TypeFlags.IncludesEmptyObject */ ? neverType : includes & 32768 /* TypeFlags.Undefined */ ? undefinedType : nullType; + } + if (includes & 4 /* TypeFlags.String */ && includes & (128 /* TypeFlags.StringLiteral */ | 134217728 /* TypeFlags.TemplateLiteral */ | 268435456 /* TypeFlags.StringMapping */) || + includes & 8 /* TypeFlags.Number */ && includes & 256 /* TypeFlags.NumberLiteral */ || + includes & 64 /* TypeFlags.BigInt */ && includes & 2048 /* TypeFlags.BigIntLiteral */ || + includes & 4096 /* TypeFlags.ESSymbol */ && includes & 8192 /* TypeFlags.UniqueESSymbol */ || + includes & 16384 /* TypeFlags.Void */ && includes & 32768 /* TypeFlags.Undefined */ || + includes & 16777216 /* TypeFlags.IncludesEmptyObject */ && includes & 470302716 /* TypeFlags.DefinitelyNonNullable */) { + if (!noSupertypeReduction) + removeRedundantSupertypes(typeSet, includes); + } + if (includes & 262144 /* TypeFlags.IncludesMissingType */) { + typeSet[typeSet.indexOf(undefinedType)] = missingType; + } + if (typeSet.length === 0) { + return unknownType; + } + if (typeSet.length === 1) { + return typeSet[0]; + } + var id = getTypeListId(typeSet) + getAliasId(aliasSymbol, aliasTypeArguments); + var result = intersectionTypes.get(id); + if (!result) { + if (includes & 1048576 /* TypeFlags.Union */) { + if (intersectUnionsOfPrimitiveTypes(typeSet)) { + // When the intersection creates a reduced set (which might mean that *all* union types have + // disappeared), we restart the operation to get a new set of combined flags. Once we have + // reduced we'll never reduce again, so this occurs at most once. + result = getIntersectionType(typeSet, aliasSymbol, aliasTypeArguments); + } + else if (eachIsUnionContaining(typeSet, 32768 /* TypeFlags.Undefined */)) { + var undefinedOrMissingType = exactOptionalPropertyTypes && ts.some(typeSet, function (t) { return containsType(t.types, missingType); }) ? missingType : undefinedType; + removeFromEach(typeSet, 32768 /* TypeFlags.Undefined */); + result = getUnionType([getIntersectionType(typeSet), undefinedOrMissingType], 1 /* UnionReduction.Literal */, aliasSymbol, aliasTypeArguments); + } + else if (eachIsUnionContaining(typeSet, 65536 /* TypeFlags.Null */)) { + removeFromEach(typeSet, 65536 /* TypeFlags.Null */); + result = getUnionType([getIntersectionType(typeSet), nullType], 1 /* UnionReduction.Literal */, aliasSymbol, aliasTypeArguments); + } + else { + // We are attempting to construct a type of the form X & (A | B) & (C | D). Transform this into a type of + // the form X & A & C | X & A & D | X & B & C | X & B & D. If the estimated size of the resulting union type + // exceeds 100000 constituents, report an error. + if (!checkCrossProductUnion(typeSet)) { + return errorType; + } + var constituents = getCrossProductIntersections(typeSet); + // We attach a denormalized origin type when at least one constituent of the cross-product union is an + // intersection (i.e. when the intersection didn't just reduce one or more unions to smaller unions) and + // the denormalized origin has fewer constituents than the union itself. + var origin = ts.some(constituents, function (t) { return !!(t.flags & 2097152 /* TypeFlags.Intersection */); }) && getConstituentCountOfTypes(constituents) > getConstituentCountOfTypes(typeSet) ? createOriginUnionOrIntersectionType(2097152 /* TypeFlags.Intersection */, typeSet) : undefined; + result = getUnionType(constituents, 1 /* UnionReduction.Literal */, aliasSymbol, aliasTypeArguments, origin); + } + } + else { + result = createIntersectionType(typeSet, aliasSymbol, aliasTypeArguments); + } + intersectionTypes.set(id, result); + } + return result; + } + function getCrossProductUnionSize(types) { + return ts.reduceLeft(types, function (n, t) { return t.flags & 1048576 /* TypeFlags.Union */ ? n * t.types.length : t.flags & 131072 /* TypeFlags.Never */ ? 0 : n; }, 1); + } + function checkCrossProductUnion(types) { + var size = getCrossProductUnionSize(types); + if (size >= 100000) { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes" /* tracing.Phase.CheckTypes */, "checkCrossProductUnion_DepthLimit", { typeIds: types.map(function (t) { return t.id; }), size: size }); + error(currentNode, ts.Diagnostics.Expression_produces_a_union_type_that_is_too_complex_to_represent); + return false; + } + return true; + } + function getCrossProductIntersections(types) { + var count = getCrossProductUnionSize(types); + var intersections = []; + for (var i = 0; i < count; i++) { + var constituents = types.slice(); + var n = i; + for (var j = types.length - 1; j >= 0; j--) { + if (types[j].flags & 1048576 /* TypeFlags.Union */) { + var sourceTypes = types[j].types; + var length_5 = sourceTypes.length; + constituents[j] = sourceTypes[n % length_5]; + n = Math.floor(n / length_5); + } + } + var t = getIntersectionType(constituents); + if (!(t.flags & 131072 /* TypeFlags.Never */)) + intersections.push(t); + } + return intersections; + } + function getConstituentCount(type) { + return !(type.flags & 3145728 /* TypeFlags.UnionOrIntersection */) || type.aliasSymbol ? 1 : + type.flags & 1048576 /* TypeFlags.Union */ && type.origin ? getConstituentCount(type.origin) : + getConstituentCountOfTypes(type.types); + } + function getConstituentCountOfTypes(types) { + return ts.reduceLeft(types, function (n, t) { return n + getConstituentCount(t); }, 0); + } + function getTypeFromIntersectionTypeNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + var aliasSymbol = getAliasSymbolForTypeNode(node); + var types = ts.map(node.types, getTypeFromTypeNode); + var noSupertypeReduction = types.length === 2 && !!(types[0].flags & (4 /* TypeFlags.String */ | 8 /* TypeFlags.Number */ | 64 /* TypeFlags.BigInt */)) && types[1] === emptyTypeLiteralType; + links.resolvedType = getIntersectionType(types, aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol), noSupertypeReduction); + } + return links.resolvedType; + } + function createIndexType(type, stringsOnly) { + var result = createType(4194304 /* TypeFlags.Index */); + result.type = type; + result.stringsOnly = stringsOnly; + return result; + } + function createOriginIndexType(type) { + var result = createOriginType(4194304 /* TypeFlags.Index */); + result.type = type; + return result; + } + function getIndexTypeForGenericType(type, stringsOnly) { + return stringsOnly ? + type.resolvedStringIndexType || (type.resolvedStringIndexType = createIndexType(type, /*stringsOnly*/ true)) : + type.resolvedIndexType || (type.resolvedIndexType = createIndexType(type, /*stringsOnly*/ false)); + } + /** + * This roughly mirrors `resolveMappedTypeMembers` in the nongeneric case, except only reports a union of the keys calculated, + * rather than manufacturing the properties. We can't just fetch the `constraintType` since that would ignore mappings + * and mapping the `constraintType` directly ignores how mapped types map _properties_ and not keys (thus ignoring subtype + * reduction in the constraintType) when possible. + * @param noIndexSignatures Indicates if _string_ index signatures should be elided. (other index signatures are always reported) + */ + function getIndexTypeForMappedType(type, stringsOnly, noIndexSignatures) { + var typeParameter = getTypeParameterFromMappedType(type); + var constraintType = getConstraintTypeFromMappedType(type); + var nameType = getNameTypeFromMappedType(type.target || type); + if (!nameType && !noIndexSignatures) { + // no mapping and no filtering required, just quickly bail to returning the constraint in the common case + return constraintType; + } + var keyTypes = []; + if (isMappedTypeWithKeyofConstraintDeclaration(type)) { + // We have a { [P in keyof T]: X } + // `getApparentType` on the T in a generic mapped type can trigger a circularity + // (conditionals and `infer` types create a circular dependency in the constraint resolution) + // so we only eagerly manifest the keys if the constraint is nongeneric + if (!isGenericIndexType(constraintType)) { + var modifiersType = getApparentType(getModifiersTypeFromMappedType(type)); // The 'T' in 'keyof T' + forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, 8576 /* TypeFlags.StringOrNumberLiteralOrUnique */, stringsOnly, addMemberForKeyType); + } + else { + // we have a generic index and a homomorphic mapping (but a distributive key remapping) - we need to defer the whole `keyof whatever` for later + // since it's not safe to resolve the shape of modifier type + return getIndexTypeForGenericType(type, stringsOnly); + } + } + else { + forEachType(getLowerBoundOfKeyType(constraintType), addMemberForKeyType); + } + if (isGenericIndexType(constraintType)) { // include the generic component in the resulting type + forEachType(constraintType, addMemberForKeyType); + } + // we had to pick apart the constraintType to potentially map/filter it - compare the final resulting list with the original constraintType, + // so we can return the union that preserves aliases/origin data if possible + var result = noIndexSignatures ? filterType(getUnionType(keyTypes), function (t) { return !(t.flags & (1 /* TypeFlags.Any */ | 4 /* TypeFlags.String */)); }) : getUnionType(keyTypes); + if (result.flags & 1048576 /* TypeFlags.Union */ && constraintType.flags & 1048576 /* TypeFlags.Union */ && getTypeListId(result.types) === getTypeListId(constraintType.types)) { + return constraintType; + } + return result; + function addMemberForKeyType(keyType) { + var propNameType = nameType ? instantiateType(nameType, appendTypeMapping(type.mapper, typeParameter, keyType)) : keyType; + // `keyof` currently always returns `string | number` for concrete `string` index signatures - the below ternary keeps that behavior for mapped types + // See `getLiteralTypeFromProperties` where there's a similar ternary to cause the same behavior. + keyTypes.push(propNameType === stringType ? stringOrNumberType : propNameType); + } + } + // Ordinarily we reduce a keyof M, where M is a mapped type { [P in K as N

]: X }, to simply N. This however presumes + // that N distributes over union types, i.e. that N is equivalent to N | N | N. Specifically, we only + // want to perform the reduction when the name type of a mapped type is distributive with respect to the type variable + // introduced by the 'in' clause of the mapped type. Note that non-generic types are considered to be distributive because + // they're the same type regardless of what's being distributed over. + function hasDistributiveNameType(mappedType) { + var typeVariable = getTypeParameterFromMappedType(mappedType); + return isDistributive(getNameTypeFromMappedType(mappedType) || typeVariable); + function isDistributive(type) { + return type.flags & (3 /* TypeFlags.AnyOrUnknown */ | 131068 /* TypeFlags.Primitive */ | 131072 /* TypeFlags.Never */ | 262144 /* TypeFlags.TypeParameter */ | 524288 /* TypeFlags.Object */ | 67108864 /* TypeFlags.NonPrimitive */) ? true : + type.flags & 16777216 /* TypeFlags.Conditional */ ? type.root.isDistributive && type.checkType === typeVariable : + type.flags & (3145728 /* TypeFlags.UnionOrIntersection */ | 134217728 /* TypeFlags.TemplateLiteral */) ? ts.every(type.types, isDistributive) : + type.flags & 8388608 /* TypeFlags.IndexedAccess */ ? isDistributive(type.objectType) && isDistributive(type.indexType) : + type.flags & 33554432 /* TypeFlags.Substitution */ ? isDistributive(type.baseType) && isDistributive(type.constraint) : + type.flags & 268435456 /* TypeFlags.StringMapping */ ? isDistributive(type.type) : + false; + } + } + function getLiteralTypeFromPropertyName(name) { + if (ts.isPrivateIdentifier(name)) { + return neverType; + } + return ts.isIdentifier(name) ? getStringLiteralType(ts.unescapeLeadingUnderscores(name.escapedText)) : + getRegularTypeOfLiteralType(ts.isComputedPropertyName(name) ? checkComputedPropertyName(name) : checkExpression(name)); + } + function getLiteralTypeFromProperty(prop, include, includeNonPublic) { + if (includeNonPublic || !(ts.getDeclarationModifierFlagsFromSymbol(prop) & 24 /* ModifierFlags.NonPublicAccessibilityModifier */)) { + var type = getSymbolLinks(getLateBoundSymbol(prop)).nameType; + if (!type) { + var name = ts.getNameOfDeclaration(prop.valueDeclaration); + type = prop.escapedName === "default" /* InternalSymbolName.Default */ ? getStringLiteralType("default") : + name && getLiteralTypeFromPropertyName(name) || (!ts.isKnownSymbol(prop) ? getStringLiteralType(ts.symbolName(prop)) : undefined); + } + if (type && type.flags & include) { + return type; + } + } + return neverType; + } + function isKeyTypeIncluded(keyType, include) { + return !!(keyType.flags & include || keyType.flags & 2097152 /* TypeFlags.Intersection */ && ts.some(keyType.types, function (t) { return isKeyTypeIncluded(t, include); })); + } + function getLiteralTypeFromProperties(type, include, includeOrigin) { + var origin = includeOrigin && (ts.getObjectFlags(type) & (3 /* ObjectFlags.ClassOrInterface */ | 4 /* ObjectFlags.Reference */) || type.aliasSymbol) ? createOriginIndexType(type) : undefined; + var propertyTypes = ts.map(getPropertiesOfType(type), function (prop) { return getLiteralTypeFromProperty(prop, include); }); + var indexKeyTypes = ts.map(getIndexInfosOfType(type), function (info) { return info !== enumNumberIndexInfo && isKeyTypeIncluded(info.keyType, include) ? + info.keyType === stringType && include & 8 /* TypeFlags.Number */ ? stringOrNumberType : info.keyType : neverType; }); + return getUnionType(ts.concatenate(propertyTypes, indexKeyTypes), 1 /* UnionReduction.Literal */, + /*aliasSymbol*/ undefined, /*aliasTypeArguments*/ undefined, origin); + } + /** + * A union type which is reducible upon instantiation (meaning some members are removed under certain instantiations) + * must be kept generic, as that instantiation information needs to flow through the type system. By replacing all + * type parameters in the union with a special never type that is treated as a literal in `getReducedType`, we can cause the `getReducedType` logic + * to reduce the resulting type if possible (since only intersections with conflicting literal-typed properties are reducible). + */ + function isPossiblyReducibleByInstantiation(type) { + var uniqueFilled = getUniqueLiteralFilledInstantiation(type); + return getReducedType(uniqueFilled) !== uniqueFilled; + } + function shouldDeferIndexType(type) { + return !!(type.flags & 58982400 /* TypeFlags.InstantiableNonPrimitive */ || + isGenericTupleType(type) || + isGenericMappedType(type) && !hasDistributiveNameType(type) || + type.flags & 1048576 /* TypeFlags.Union */ && ts.some(type.types, isPossiblyReducibleByInstantiation) || + type.flags & 2097152 /* TypeFlags.Intersection */ && maybeTypeOfKind(type, 465829888 /* TypeFlags.Instantiable */) && ts.some(type.types, isEmptyAnonymousObjectType)); + } + function getIndexType(type, stringsOnly, noIndexSignatures) { + if (stringsOnly === void 0) { stringsOnly = keyofStringsOnly; } + type = getReducedType(type); + return shouldDeferIndexType(type) ? getIndexTypeForGenericType(type, stringsOnly) : + type.flags & 1048576 /* TypeFlags.Union */ ? getIntersectionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) : + type.flags & 2097152 /* TypeFlags.Intersection */ ? getUnionType(ts.map(type.types, function (t) { return getIndexType(t, stringsOnly, noIndexSignatures); })) : + ts.getObjectFlags(type) & 32 /* ObjectFlags.Mapped */ ? getIndexTypeForMappedType(type, stringsOnly, noIndexSignatures) : + type === wildcardType ? wildcardType : + type.flags & 2 /* TypeFlags.Unknown */ ? neverType : + type.flags & (1 /* TypeFlags.Any */ | 131072 /* TypeFlags.Never */) ? keyofConstraintType : + getLiteralTypeFromProperties(type, (noIndexSignatures ? 128 /* TypeFlags.StringLiteral */ : 402653316 /* TypeFlags.StringLike */) | (stringsOnly ? 0 : 296 /* TypeFlags.NumberLike */ | 12288 /* TypeFlags.ESSymbolLike */), stringsOnly === keyofStringsOnly && !noIndexSignatures); + } + function getExtractStringType(type) { + if (keyofStringsOnly) { + return type; + } + var extractTypeAlias = getGlobalExtractSymbol(); + return extractTypeAlias ? getTypeAliasInstantiation(extractTypeAlias, [type, stringType]) : stringType; + } + function getIndexTypeOrString(type) { + var indexType = getExtractStringType(getIndexType(type)); + return indexType.flags & 131072 /* TypeFlags.Never */ ? stringType : indexType; + } + function getTypeFromTypeOperatorNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + switch (node.operator) { + case 141 /* SyntaxKind.KeyOfKeyword */: + links.resolvedType = getIndexType(getTypeFromTypeNode(node.type)); + break; + case 156 /* SyntaxKind.UniqueKeyword */: + links.resolvedType = node.type.kind === 153 /* SyntaxKind.SymbolKeyword */ + ? getESSymbolLikeTypeForNode(ts.walkUpParenthesizedTypes(node.parent)) + : errorType; + break; + case 146 /* SyntaxKind.ReadonlyKeyword */: + links.resolvedType = getTypeFromTypeNode(node.type); + break; + default: + throw ts.Debug.assertNever(node.operator); + } + } + return links.resolvedType; + } + function getTypeFromTemplateTypeNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + links.resolvedType = getTemplateLiteralType(__spreadArray([node.head.text], ts.map(node.templateSpans, function (span) { return span.literal.text; }), true), ts.map(node.templateSpans, function (span) { return getTypeFromTypeNode(span.type); })); + } + return links.resolvedType; + } + function getTemplateLiteralType(texts, types) { + var unionIndex = ts.findIndex(types, function (t) { return !!(t.flags & (131072 /* TypeFlags.Never */ | 1048576 /* TypeFlags.Union */)); }); + if (unionIndex >= 0) { + return checkCrossProductUnion(types) ? + mapType(types[unionIndex], function (t) { return getTemplateLiteralType(texts, ts.replaceElement(types, unionIndex, t)); }) : + errorType; + } + if (ts.contains(types, wildcardType)) { + return wildcardType; + } + var newTypes = []; + var newTexts = []; + var text = texts[0]; + if (!addSpans(texts, types)) { + return stringType; + } + if (newTypes.length === 0) { + return getStringLiteralType(text); + } + newTexts.push(text); + if (ts.every(newTexts, function (t) { return t === ""; })) { + if (ts.every(newTypes, function (t) { return !!(t.flags & 4 /* TypeFlags.String */); })) { + return stringType; + } + // Normalize `${Mapping}` into Mapping + if (newTypes.length === 1 && isPatternLiteralType(newTypes[0])) { + return newTypes[0]; + } + } + var id = "".concat(getTypeListId(newTypes), "|").concat(ts.map(newTexts, function (t) { return t.length; }).join(","), "|").concat(newTexts.join("")); + var type = templateLiteralTypes.get(id); + if (!type) { + templateLiteralTypes.set(id, type = createTemplateLiteralType(newTexts, newTypes)); + } + return type; + function addSpans(texts, types) { + var isTextsArray = ts.isArray(texts); + for (var i = 0; i < types.length; i++) { + var t = types[i]; + var addText = isTextsArray ? texts[i + 1] : texts; + if (t.flags & (2944 /* TypeFlags.Literal */ | 65536 /* TypeFlags.Null */ | 32768 /* TypeFlags.Undefined */)) { + text += getTemplateStringForType(t) || ""; + text += addText; + if (!isTextsArray) + return true; + } + else if (t.flags & 134217728 /* TypeFlags.TemplateLiteral */) { + text += t.texts[0]; + if (!addSpans(t.texts, t.types)) + return false; + text += addText; + if (!isTextsArray) + return true; + } + else if (isGenericIndexType(t) || isPatternLiteralPlaceholderType(t)) { + newTypes.push(t); + newTexts.push(text); + text = addText; + } + else if (t.flags & 2097152 /* TypeFlags.Intersection */) { + var added = addSpans(texts[i + 1], t.types); + if (!added) + return false; + } + else if (isTextsArray) { + return false; + } + } + return true; + } + } + function getTemplateStringForType(type) { + return type.flags & 128 /* TypeFlags.StringLiteral */ ? type.value : + type.flags & 256 /* TypeFlags.NumberLiteral */ ? "" + type.value : + type.flags & 2048 /* TypeFlags.BigIntLiteral */ ? ts.pseudoBigIntToString(type.value) : + type.flags & (512 /* TypeFlags.BooleanLiteral */ | 98304 /* TypeFlags.Nullable */) ? type.intrinsicName : + undefined; + } + function createTemplateLiteralType(texts, types) { + var type = createType(134217728 /* TypeFlags.TemplateLiteral */); + type.texts = texts; + type.types = types; + return type; + } + function getStringMappingType(symbol, type) { + return type.flags & (1048576 /* TypeFlags.Union */ | 131072 /* TypeFlags.Never */) ? mapType(type, function (t) { return getStringMappingType(symbol, t); }) : + type.flags & 128 /* TypeFlags.StringLiteral */ ? getStringLiteralType(applyStringMapping(symbol, type.value)) : + type.flags & 134217728 /* TypeFlags.TemplateLiteral */ ? getTemplateLiteralType.apply(void 0, applyTemplateStringMapping(symbol, type.texts, type.types)) : + // Mapping> === Mapping + type.flags & 268435456 /* TypeFlags.StringMapping */ && symbol === type.symbol ? type : + type.flags & (1 /* TypeFlags.Any */ | 4 /* TypeFlags.String */ | 268435456 /* TypeFlags.StringMapping */) || isGenericIndexType(type) ? getStringMappingTypeForGenericType(symbol, type) : + // This handles Mapping<`${number}`> and Mapping<`${bigint}`> + isPatternLiteralPlaceholderType(type) ? getStringMappingTypeForGenericType(symbol, getTemplateLiteralType(["", ""], [type])) : + type; + } + function applyStringMapping(symbol, str) { + switch (intrinsicTypeKinds.get(symbol.escapedName)) { + case 0 /* IntrinsicTypeKind.Uppercase */: return str.toUpperCase(); + case 1 /* IntrinsicTypeKind.Lowercase */: return str.toLowerCase(); + case 2 /* IntrinsicTypeKind.Capitalize */: return str.charAt(0).toUpperCase() + str.slice(1); + case 3 /* IntrinsicTypeKind.Uncapitalize */: return str.charAt(0).toLowerCase() + str.slice(1); + } + return str; + } + function applyTemplateStringMapping(symbol, texts, types) { + switch (intrinsicTypeKinds.get(symbol.escapedName)) { + case 0 /* IntrinsicTypeKind.Uppercase */: return [texts.map(function (t) { return t.toUpperCase(); }), types.map(function (t) { return getStringMappingType(symbol, t); })]; + case 1 /* IntrinsicTypeKind.Lowercase */: return [texts.map(function (t) { return t.toLowerCase(); }), types.map(function (t) { return getStringMappingType(symbol, t); })]; + case 2 /* IntrinsicTypeKind.Capitalize */: return [texts[0] === "" ? texts : __spreadArray([texts[0].charAt(0).toUpperCase() + texts[0].slice(1)], texts.slice(1), true), texts[0] === "" ? __spreadArray([getStringMappingType(symbol, types[0])], types.slice(1), true) : types]; + case 3 /* IntrinsicTypeKind.Uncapitalize */: return [texts[0] === "" ? texts : __spreadArray([texts[0].charAt(0).toLowerCase() + texts[0].slice(1)], texts.slice(1), true), texts[0] === "" ? __spreadArray([getStringMappingType(symbol, types[0])], types.slice(1), true) : types]; + } + return [texts, types]; + } + function getStringMappingTypeForGenericType(symbol, type) { + var id = "".concat(getSymbolId(symbol), ",").concat(getTypeId(type)); + var result = stringMappingTypes.get(id); + if (!result) { + stringMappingTypes.set(id, result = createStringMappingType(symbol, type)); + } + return result; + } + function createStringMappingType(symbol, type) { + var result = createType(268435456 /* TypeFlags.StringMapping */); + result.symbol = symbol; + result.type = type; + return result; + } + function createIndexedAccessType(objectType, indexType, accessFlags, aliasSymbol, aliasTypeArguments) { + var type = createType(8388608 /* TypeFlags.IndexedAccess */); + type.objectType = objectType; + type.indexType = indexType; + type.accessFlags = accessFlags; + type.aliasSymbol = aliasSymbol; + type.aliasTypeArguments = aliasTypeArguments; + return type; + } + /** + * Returns if a type is or consists of a JSLiteral object type + * In addition to objects which are directly literals, + * * unions where every element is a jsliteral + * * intersections where at least one element is a jsliteral + * * and instantiable types constrained to a jsliteral + * Should all count as literals and not print errors on access or assignment of possibly existing properties. + * This mirrors the behavior of the index signature propagation, to which this behaves similarly (but doesn't affect assignability or inference). + */ + function isJSLiteralType(type) { + if (noImplicitAny) { + return false; // Flag is meaningless under `noImplicitAny` mode + } + if (ts.getObjectFlags(type) & 4096 /* ObjectFlags.JSLiteral */) { + return true; + } + if (type.flags & 1048576 /* TypeFlags.Union */) { + return ts.every(type.types, isJSLiteralType); + } + if (type.flags & 2097152 /* TypeFlags.Intersection */) { + return ts.some(type.types, isJSLiteralType); + } + if (type.flags & 465829888 /* TypeFlags.Instantiable */) { + var constraint = getResolvedBaseConstraint(type); + return constraint !== type && isJSLiteralType(constraint); + } + return false; + } + function getPropertyNameFromIndex(indexType, accessNode) { + return isTypeUsableAsPropertyName(indexType) ? + getPropertyNameFromType(indexType) : + accessNode && ts.isPropertyName(accessNode) ? + // late bound names are handled in the first branch, so here we only need to handle normal names + ts.getPropertyNameForPropertyNameNode(accessNode) : + undefined; + } + function isUncalledFunctionReference(node, symbol) { + if (symbol.flags & (16 /* SymbolFlags.Function */ | 8192 /* SymbolFlags.Method */)) { + var parent = ts.findAncestor(node.parent, function (n) { return !ts.isAccessExpression(n); }) || node.parent; + if (ts.isCallLikeExpression(parent)) { + return ts.isCallOrNewExpression(parent) && ts.isIdentifier(node) && hasMatchingArgument(parent, node); + } + return ts.every(symbol.declarations, function (d) { return !ts.isFunctionLike(d) || !!(ts.getCombinedNodeFlags(d) & 268435456 /* NodeFlags.Deprecated */); }); + } + return true; + } + function getPropertyTypeForIndexType(originalObjectType, objectType, indexType, fullIndexType, accessNode, accessFlags) { + var _a; + var accessExpression = accessNode && accessNode.kind === 209 /* SyntaxKind.ElementAccessExpression */ ? accessNode : undefined; + var propName = accessNode && ts.isPrivateIdentifier(accessNode) ? undefined : getPropertyNameFromIndex(indexType, accessNode); + if (propName !== undefined) { + if (accessFlags & 256 /* AccessFlags.Contextual */) { + return getTypeOfPropertyOfContextualType(objectType, propName) || anyType; + } + var prop = getPropertyOfType(objectType, propName); + if (prop) { + if (accessFlags & 64 /* AccessFlags.ReportDeprecated */ && accessNode && prop.declarations && isDeprecatedSymbol(prop) && isUncalledFunctionReference(accessNode, prop)) { + var deprecatedNode = (_a = accessExpression === null || accessExpression === void 0 ? void 0 : accessExpression.argumentExpression) !== null && _a !== void 0 ? _a : (ts.isIndexedAccessTypeNode(accessNode) ? accessNode.indexType : accessNode); + addDeprecatedSuggestion(deprecatedNode, prop.declarations, propName); + } + if (accessExpression) { + markPropertyAsReferenced(prop, accessExpression, isSelfTypeAccess(accessExpression.expression, objectType.symbol)); + if (isAssignmentToReadonlyEntity(accessExpression, prop, ts.getAssignmentTargetKind(accessExpression))) { + error(accessExpression.argumentExpression, ts.Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property, symbolToString(prop)); + return undefined; + } + if (accessFlags & 8 /* AccessFlags.CacheSymbol */) { + getNodeLinks(accessNode).resolvedSymbol = prop; + } + if (isThisPropertyAccessInConstructor(accessExpression, prop)) { + return autoType; + } + } + var propType = getTypeOfSymbol(prop); + return accessExpression && ts.getAssignmentTargetKind(accessExpression) !== 1 /* AssignmentKind.Definite */ ? + getFlowTypeOfReference(accessExpression, propType) : + propType; + } + if (everyType(objectType, isTupleType) && ts.isNumericLiteralName(propName)) { + var index = +propName; + if (accessNode && everyType(objectType, function (t) { return !t.target.hasRestElement; }) && !(accessFlags & 16 /* AccessFlags.NoTupleBoundsCheck */)) { + var indexNode = getIndexNodeForAccessExpression(accessNode); + if (isTupleType(objectType)) { + if (index < 0) { + error(indexNode, ts.Diagnostics.A_tuple_type_cannot_be_indexed_with_a_negative_value); + return undefinedType; + } + error(indexNode, ts.Diagnostics.Tuple_type_0_of_length_1_has_no_element_at_index_2, typeToString(objectType), getTypeReferenceArity(objectType), ts.unescapeLeadingUnderscores(propName)); + } + else { + error(indexNode, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.unescapeLeadingUnderscores(propName), typeToString(objectType)); + } + } + if (index >= 0) { + errorIfWritingToReadonlyIndex(getIndexInfoOfType(objectType, numberType)); + return mapType(objectType, function (t) { + var restType = getRestTypeOfTupleType(t) || undefinedType; + return accessFlags & 1 /* AccessFlags.IncludeUndefined */ ? getUnionType([restType, undefinedType]) : restType; + }); + } + } + } + if (!(indexType.flags & 98304 /* TypeFlags.Nullable */) && isTypeAssignableToKind(indexType, 402653316 /* TypeFlags.StringLike */ | 296 /* TypeFlags.NumberLike */ | 12288 /* TypeFlags.ESSymbolLike */)) { + if (objectType.flags & (1 /* TypeFlags.Any */ | 131072 /* TypeFlags.Never */)) { + return objectType; + } + // If no index signature is applicable, we default to the string index signature. In effect, this means the string + // index signature applies even when accessing with a symbol-like type. + var indexInfo = getApplicableIndexInfo(objectType, indexType) || getIndexInfoOfType(objectType, stringType); + if (indexInfo) { + if (accessFlags & 2 /* AccessFlags.NoIndexSignatures */ && indexInfo.keyType !== numberType) { + if (accessExpression) { + error(accessExpression, ts.Diagnostics.Type_0_cannot_be_used_to_index_type_1, typeToString(indexType), typeToString(originalObjectType)); + } + return undefined; + } + if (accessNode && indexInfo.keyType === stringType && !isTypeAssignableToKind(indexType, 4 /* TypeFlags.String */ | 8 /* TypeFlags.Number */)) { + var indexNode = getIndexNodeForAccessExpression(accessNode); + error(indexNode, ts.Diagnostics.Type_0_cannot_be_used_as_an_index_type, typeToString(indexType)); + return accessFlags & 1 /* AccessFlags.IncludeUndefined */ ? getUnionType([indexInfo.type, undefinedType]) : indexInfo.type; + } + errorIfWritingToReadonlyIndex(indexInfo); + // When accessing an enum object with its own type, + // e.g. E[E.A] for enum E { A }, undefined shouldn't + // be included in the result type + if ((accessFlags & 1 /* AccessFlags.IncludeUndefined */) && + !(objectType.symbol && + objectType.symbol.flags & (256 /* SymbolFlags.RegularEnum */ | 128 /* SymbolFlags.ConstEnum */) && + (indexType.symbol && + indexType.flags & 1024 /* TypeFlags.EnumLiteral */ && + getParentOfSymbol(indexType.symbol) === objectType.symbol))) { + return getUnionType([indexInfo.type, undefinedType]); + } + return indexInfo.type; + } + if (indexType.flags & 131072 /* TypeFlags.Never */) { + return neverType; + } + if (isJSLiteralType(objectType)) { + return anyType; + } + if (accessExpression && !isConstEnumObjectType(objectType)) { + if (isObjectLiteralType(objectType)) { + if (noImplicitAny && indexType.flags & (128 /* TypeFlags.StringLiteral */ | 256 /* TypeFlags.NumberLiteral */)) { + diagnostics.add(ts.createDiagnosticForNode(accessExpression, ts.Diagnostics.Property_0_does_not_exist_on_type_1, indexType.value, typeToString(objectType))); + return undefinedType; + } + else if (indexType.flags & (8 /* TypeFlags.Number */ | 4 /* TypeFlags.String */)) { + var types = ts.map(objectType.properties, function (property) { + return getTypeOfSymbol(property); + }); + return getUnionType(ts.append(types, undefinedType)); + } + } + if (objectType.symbol === globalThisSymbol && propName !== undefined && globalThisSymbol.exports.has(propName) && (globalThisSymbol.exports.get(propName).flags & 418 /* SymbolFlags.BlockScoped */)) { + error(accessExpression, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.unescapeLeadingUnderscores(propName), typeToString(objectType)); + } + else if (noImplicitAny && !compilerOptions.suppressImplicitAnyIndexErrors && !(accessFlags & 128 /* AccessFlags.SuppressNoImplicitAnyError */)) { + if (propName !== undefined && typeHasStaticProperty(propName, objectType)) { + var typeName = typeToString(objectType); + error(accessExpression, ts.Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_to_access_the_static_member_2_instead, propName, typeName, typeName + "[" + ts.getTextOfNode(accessExpression.argumentExpression) + "]"); + } + else if (getIndexTypeOfType(objectType, numberType)) { + error(accessExpression.argumentExpression, ts.Diagnostics.Element_implicitly_has_an_any_type_because_index_expression_is_not_of_type_number); + } + else { + var suggestion = void 0; + if (propName !== undefined && (suggestion = getSuggestionForNonexistentProperty(propName, objectType))) { + if (suggestion !== undefined) { + error(accessExpression.argumentExpression, ts.Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2, propName, typeToString(objectType), suggestion); + } + } + else { + var suggestion_1 = getSuggestionForNonexistentIndexSignature(objectType, accessExpression, indexType); + if (suggestion_1 !== undefined) { + error(accessExpression, ts.Diagnostics.Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_Did_you_mean_to_call_1, typeToString(objectType), suggestion_1); + } + else { + var errorInfo = void 0; + if (indexType.flags & 1024 /* TypeFlags.EnumLiteral */) { + errorInfo = ts.chainDiagnosticMessages(/* details */ undefined, ts.Diagnostics.Property_0_does_not_exist_on_type_1, "[" + typeToString(indexType) + "]", typeToString(objectType)); + } + else if (indexType.flags & 8192 /* TypeFlags.UniqueESSymbol */) { + var symbolName_2 = getFullyQualifiedName(indexType.symbol, accessExpression); + errorInfo = ts.chainDiagnosticMessages(/* details */ undefined, ts.Diagnostics.Property_0_does_not_exist_on_type_1, "[" + symbolName_2 + "]", typeToString(objectType)); + } + else if (indexType.flags & 128 /* TypeFlags.StringLiteral */) { + errorInfo = ts.chainDiagnosticMessages(/* details */ undefined, ts.Diagnostics.Property_0_does_not_exist_on_type_1, indexType.value, typeToString(objectType)); + } + else if (indexType.flags & 256 /* TypeFlags.NumberLiteral */) { + errorInfo = ts.chainDiagnosticMessages(/* details */ undefined, ts.Diagnostics.Property_0_does_not_exist_on_type_1, indexType.value, typeToString(objectType)); + } + else if (indexType.flags & (8 /* TypeFlags.Number */ | 4 /* TypeFlags.String */)) { + errorInfo = ts.chainDiagnosticMessages(/* details */ undefined, ts.Diagnostics.No_index_signature_with_a_parameter_of_type_0_was_found_on_type_1, typeToString(indexType), typeToString(objectType)); + } + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Element_implicitly_has_an_any_type_because_expression_of_type_0_can_t_be_used_to_index_type_1, typeToString(fullIndexType), typeToString(objectType)); + diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(accessExpression, errorInfo)); + } + } + } + } + return undefined; + } + } + if (isJSLiteralType(objectType)) { + return anyType; + } + if (accessNode) { + var indexNode = getIndexNodeForAccessExpression(accessNode); + if (indexType.flags & (128 /* TypeFlags.StringLiteral */ | 256 /* TypeFlags.NumberLiteral */)) { + error(indexNode, ts.Diagnostics.Property_0_does_not_exist_on_type_1, "" + indexType.value, typeToString(objectType)); + } + else if (indexType.flags & (4 /* TypeFlags.String */ | 8 /* TypeFlags.Number */)) { + error(indexNode, ts.Diagnostics.Type_0_has_no_matching_index_signature_for_type_1, typeToString(objectType), typeToString(indexType)); + } + else { + error(indexNode, ts.Diagnostics.Type_0_cannot_be_used_as_an_index_type, typeToString(indexType)); + } + } + if (isTypeAny(indexType)) { + return indexType; + } + return undefined; + function errorIfWritingToReadonlyIndex(indexInfo) { + if (indexInfo && indexInfo.isReadonly && accessExpression && (ts.isAssignmentTarget(accessExpression) || ts.isDeleteTarget(accessExpression))) { + error(accessExpression, ts.Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(objectType)); + } + } + } + function getIndexNodeForAccessExpression(accessNode) { + return accessNode.kind === 209 /* SyntaxKind.ElementAccessExpression */ ? accessNode.argumentExpression : + accessNode.kind === 196 /* SyntaxKind.IndexedAccessType */ ? accessNode.indexType : + accessNode.kind === 164 /* SyntaxKind.ComputedPropertyName */ ? accessNode.expression : + accessNode; + } + function isPatternLiteralPlaceholderType(type) { + return !!(type.flags & (1 /* TypeFlags.Any */ | 4 /* TypeFlags.String */ | 8 /* TypeFlags.Number */ | 64 /* TypeFlags.BigInt */)) || isPatternLiteralType(type); + } + function isPatternLiteralType(type) { + return !!(type.flags & 134217728 /* TypeFlags.TemplateLiteral */) && ts.every(type.types, isPatternLiteralPlaceholderType) || + !!(type.flags & 268435456 /* TypeFlags.StringMapping */) && isPatternLiteralPlaceholderType(type.type); + } + function isGenericType(type) { + return !!getGenericObjectFlags(type); + } + function isGenericObjectType(type) { + return !!(getGenericObjectFlags(type) & 4194304 /* ObjectFlags.IsGenericObjectType */); + } + function isGenericIndexType(type) { + return !!(getGenericObjectFlags(type) & 8388608 /* ObjectFlags.IsGenericIndexType */); + } + function getGenericObjectFlags(type) { + if (type.flags & 3145728 /* TypeFlags.UnionOrIntersection */) { + if (!(type.objectFlags & 2097152 /* ObjectFlags.IsGenericTypeComputed */)) { + type.objectFlags |= 2097152 /* ObjectFlags.IsGenericTypeComputed */ | + ts.reduceLeft(type.types, function (flags, t) { return flags | getGenericObjectFlags(t); }, 0); + } + return type.objectFlags & 12582912 /* ObjectFlags.IsGenericType */; + } + if (type.flags & 33554432 /* TypeFlags.Substitution */) { + if (!(type.objectFlags & 2097152 /* ObjectFlags.IsGenericTypeComputed */)) { + type.objectFlags |= 2097152 /* ObjectFlags.IsGenericTypeComputed */ | + getGenericObjectFlags(type.baseType) | getGenericObjectFlags(type.constraint); + } + return type.objectFlags & 12582912 /* ObjectFlags.IsGenericType */; + } + return (type.flags & 58982400 /* TypeFlags.InstantiableNonPrimitive */ || isGenericMappedType(type) || isGenericTupleType(type) ? 4194304 /* ObjectFlags.IsGenericObjectType */ : 0) | + (type.flags & (58982400 /* TypeFlags.InstantiableNonPrimitive */ | 4194304 /* TypeFlags.Index */ | 134217728 /* TypeFlags.TemplateLiteral */ | 268435456 /* TypeFlags.StringMapping */) && !isPatternLiteralType(type) ? 8388608 /* ObjectFlags.IsGenericIndexType */ : 0); + } + function getSimplifiedType(type, writing) { + return type.flags & 8388608 /* TypeFlags.IndexedAccess */ ? getSimplifiedIndexedAccessType(type, writing) : + type.flags & 16777216 /* TypeFlags.Conditional */ ? getSimplifiedConditionalType(type, writing) : + type; + } + function distributeIndexOverObjectType(objectType, indexType, writing) { + // (T | U)[K] -> T[K] | U[K] (reading) + // (T | U)[K] -> T[K] & U[K] (writing) + // (T & U)[K] -> T[K] & U[K] + if (objectType.flags & 1048576 /* TypeFlags.Union */ || objectType.flags & 2097152 /* TypeFlags.Intersection */ && !shouldDeferIndexType(objectType)) { + var types = ts.map(objectType.types, function (t) { return getSimplifiedType(getIndexedAccessType(t, indexType), writing); }); + return objectType.flags & 2097152 /* TypeFlags.Intersection */ || writing ? getIntersectionType(types) : getUnionType(types); + } + } + function distributeObjectOverIndexType(objectType, indexType, writing) { + // T[A | B] -> T[A] | T[B] (reading) + // T[A | B] -> T[A] & T[B] (writing) + if (indexType.flags & 1048576 /* TypeFlags.Union */) { + var types = ts.map(indexType.types, function (t) { return getSimplifiedType(getIndexedAccessType(objectType, t), writing); }); + return writing ? getIntersectionType(types) : getUnionType(types); + } + } + // Transform an indexed access to a simpler form, if possible. Return the simpler form, or return + // the type itself if no transformation is possible. The writing flag indicates that the type is + // the target of an assignment. + function getSimplifiedIndexedAccessType(type, writing) { + var cache = writing ? "simplifiedForWriting" : "simplifiedForReading"; + if (type[cache]) { + return type[cache] === circularConstraintType ? type : type[cache]; + } + type[cache] = circularConstraintType; + // We recursively simplify the object type as it may in turn be an indexed access type. For example, with + // '{ [P in T]: { [Q in U]: number } }[T][U]' we want to first simplify the inner indexed access type. + var objectType = getSimplifiedType(type.objectType, writing); + var indexType = getSimplifiedType(type.indexType, writing); + // T[A | B] -> T[A] | T[B] (reading) + // T[A | B] -> T[A] & T[B] (writing) + var distributedOverIndex = distributeObjectOverIndexType(objectType, indexType, writing); + if (distributedOverIndex) { + return type[cache] = distributedOverIndex; + } + // Only do the inner distributions if the index can no longer be instantiated to cause index distribution again + if (!(indexType.flags & 465829888 /* TypeFlags.Instantiable */)) { + // (T | U)[K] -> T[K] | U[K] (reading) + // (T | U)[K] -> T[K] & U[K] (writing) + // (T & U)[K] -> T[K] & U[K] + var distributedOverObject = distributeIndexOverObjectType(objectType, indexType, writing); + if (distributedOverObject) { + return type[cache] = distributedOverObject; + } + } + // So ultimately (reading): + // ((A & B) | C)[K1 | K2] -> ((A & B) | C)[K1] | ((A & B) | C)[K2] -> (A & B)[K1] | C[K1] | (A & B)[K2] | C[K2] -> (A[K1] & B[K1]) | C[K1] | (A[K2] & B[K2]) | C[K2] + // A generic tuple type indexed by a number exists only when the index type doesn't select a + // fixed element. We simplify to either the combined type of all elements (when the index type + // the actual number type) or to the combined type of all non-fixed elements. + if (isGenericTupleType(objectType) && indexType.flags & 296 /* TypeFlags.NumberLike */) { + var elementType = getElementTypeOfSliceOfTupleType(objectType, indexType.flags & 8 /* TypeFlags.Number */ ? 0 : objectType.target.fixedLength, /*endSkipCount*/ 0, writing); + if (elementType) { + return type[cache] = elementType; + } + } + // If the object type is a mapped type { [P in K]: E }, where K is generic, or { [P in K as N]: E }, where + // K is generic and N is assignable to P, instantiate E using a mapper that substitutes the index type for P. + // For example, for an index access { [P in K]: Box }[X], we construct the type Box. + if (isGenericMappedType(objectType)) { + var nameType = getNameTypeFromMappedType(objectType); + if (!nameType || isTypeAssignableTo(nameType, getTypeParameterFromMappedType(objectType))) { + return type[cache] = mapType(substituteIndexedMappedType(objectType, type.indexType), function (t) { return getSimplifiedType(t, writing); }); + } + } + return type[cache] = type; + } + function getSimplifiedConditionalType(type, writing) { + var checkType = type.checkType; + var extendsType = type.extendsType; + var trueType = getTrueTypeFromConditionalType(type); + var falseType = getFalseTypeFromConditionalType(type); + // Simplifications for types of the form `T extends U ? T : never` and `T extends U ? never : T`. + if (falseType.flags & 131072 /* TypeFlags.Never */ && getActualTypeVariable(trueType) === getActualTypeVariable(checkType)) { + if (checkType.flags & 1 /* TypeFlags.Any */ || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(extendsType))) { // Always true + return getSimplifiedType(trueType, writing); + } + else if (isIntersectionEmpty(checkType, extendsType)) { // Always false + return neverType; + } + } + else if (trueType.flags & 131072 /* TypeFlags.Never */ && getActualTypeVariable(falseType) === getActualTypeVariable(checkType)) { + if (!(checkType.flags & 1 /* TypeFlags.Any */) && isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(extendsType))) { // Always true + return neverType; + } + else if (checkType.flags & 1 /* TypeFlags.Any */ || isIntersectionEmpty(checkType, extendsType)) { // Always false + return getSimplifiedType(falseType, writing); + } + } + return type; + } + /** + * Invokes union simplification logic to determine if an intersection is considered empty as a union constituent + */ + function isIntersectionEmpty(type1, type2) { + return !!(getUnionType([intersectTypes(type1, type2), neverType]).flags & 131072 /* TypeFlags.Never */); + } + function substituteIndexedMappedType(objectType, index) { + var mapper = createTypeMapper([getTypeParameterFromMappedType(objectType)], [index]); + var templateMapper = combineTypeMappers(objectType.mapper, mapper); + return instantiateType(getTemplateTypeFromMappedType(objectType.target || objectType), templateMapper); + } + function getIndexedAccessType(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments) { + if (accessFlags === void 0) { accessFlags = 0 /* AccessFlags.None */; } + return getIndexedAccessTypeOrUndefined(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments) || (accessNode ? errorType : unknownType); + } + function indexTypeLessThan(indexType, limit) { + return everyType(indexType, function (t) { + if (t.flags & 384 /* TypeFlags.StringOrNumberLiteral */) { + var propName = getPropertyNameFromType(t); + if (ts.isNumericLiteralName(propName)) { + var index = +propName; + return index >= 0 && index < limit; + } + } + return false; + }); + } + function getIndexedAccessTypeOrUndefined(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments) { + if (accessFlags === void 0) { accessFlags = 0 /* AccessFlags.None */; } + if (objectType === wildcardType || indexType === wildcardType) { + return wildcardType; + } + // If the object type has a string index signature and no other members we know that the result will + // always be the type of that index signature and we can simplify accordingly. + if (isStringIndexSignatureOnlyType(objectType) && !(indexType.flags & 98304 /* TypeFlags.Nullable */) && isTypeAssignableToKind(indexType, 4 /* TypeFlags.String */ | 8 /* TypeFlags.Number */)) { + indexType = stringType; + } + // In noUncheckedIndexedAccess mode, indexed access operations that occur in an expression in a read position and resolve to + // an index signature have 'undefined' included in their type. + if (compilerOptions.noUncheckedIndexedAccess && accessFlags & 32 /* AccessFlags.ExpressionPosition */) + accessFlags |= 1 /* AccessFlags.IncludeUndefined */; + // If the index type is generic, or if the object type is generic and doesn't originate in an expression and + // the operation isn't exclusively indexing the fixed (non-variadic) portion of a tuple type, we are performing + // a higher-order index access where we cannot meaningfully access the properties of the object type. Note that + // for a generic T and a non-generic K, we eagerly resolve T[K] if it originates in an expression. This is to + // preserve backwards compatibility. For example, an element access 'this["foo"]' has always been resolved + // eagerly using the constraint type of 'this' at the given location. + if (isGenericIndexType(indexType) || (accessNode && accessNode.kind !== 196 /* SyntaxKind.IndexedAccessType */ ? + isGenericTupleType(objectType) && !indexTypeLessThan(indexType, objectType.target.fixedLength) : + isGenericObjectType(objectType) && !(isTupleType(objectType) && indexTypeLessThan(indexType, objectType.target.fixedLength)))) { + if (objectType.flags & 3 /* TypeFlags.AnyOrUnknown */) { + return objectType; + } + // Defer the operation by creating an indexed access type. + var persistentAccessFlags = accessFlags & 1 /* AccessFlags.Persistent */; + var id = objectType.id + "," + indexType.id + "," + persistentAccessFlags + getAliasId(aliasSymbol, aliasTypeArguments); + var type = indexedAccessTypes.get(id); + if (!type) { + indexedAccessTypes.set(id, type = createIndexedAccessType(objectType, indexType, persistentAccessFlags, aliasSymbol, aliasTypeArguments)); + } + return type; + } + // In the following we resolve T[K] to the type of the property in T selected by K. + // We treat boolean as different from other unions to improve errors; + // skipping straight to getPropertyTypeForIndexType gives errors with 'boolean' instead of 'true'. + var apparentObjectType = getReducedApparentType(objectType); + if (indexType.flags & 1048576 /* TypeFlags.Union */ && !(indexType.flags & 16 /* TypeFlags.Boolean */)) { + var propTypes = []; + var wasMissingProp = false; + for (var _i = 0, _a = indexType.types; _i < _a.length; _i++) { + var t = _a[_i]; + var propType = getPropertyTypeForIndexType(objectType, apparentObjectType, t, indexType, accessNode, accessFlags | (wasMissingProp ? 128 /* AccessFlags.SuppressNoImplicitAnyError */ : 0)); + if (propType) { + propTypes.push(propType); + } + else if (!accessNode) { + // If there's no error node, we can immeditely stop, since error reporting is off + return undefined; + } + else { + // Otherwise we set a flag and return at the end of the loop so we still mark all errors + wasMissingProp = true; + } + } + if (wasMissingProp) { + return undefined; + } + return accessFlags & 4 /* AccessFlags.Writing */ + ? getIntersectionType(propTypes, aliasSymbol, aliasTypeArguments) + : getUnionType(propTypes, 1 /* UnionReduction.Literal */, aliasSymbol, aliasTypeArguments); + } + return getPropertyTypeForIndexType(objectType, apparentObjectType, indexType, indexType, accessNode, accessFlags | 8 /* AccessFlags.CacheSymbol */ | 64 /* AccessFlags.ReportDeprecated */); + } + function getTypeFromIndexedAccessTypeNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + var objectType = getTypeFromTypeNode(node.objectType); + var indexType = getTypeFromTypeNode(node.indexType); + var potentialAlias = getAliasSymbolForTypeNode(node); + links.resolvedType = getIndexedAccessType(objectType, indexType, 0 /* AccessFlags.None */, node, potentialAlias, getTypeArgumentsForAliasSymbol(potentialAlias)); + } + return links.resolvedType; + } + function getTypeFromMappedTypeNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + var type = createObjectType(32 /* ObjectFlags.Mapped */, node.symbol); + type.declaration = node; + type.aliasSymbol = getAliasSymbolForTypeNode(node); + type.aliasTypeArguments = getTypeArgumentsForAliasSymbol(type.aliasSymbol); + links.resolvedType = type; + // Eagerly resolve the constraint type which forces an error if the constraint type circularly + // references itself through one or more type aliases. + getConstraintTypeFromMappedType(type); + } + return links.resolvedType; + } + function getActualTypeVariable(type) { + if (type.flags & 33554432 /* TypeFlags.Substitution */) { + return type.baseType; + } + if (type.flags & 8388608 /* TypeFlags.IndexedAccess */ && (type.objectType.flags & 33554432 /* TypeFlags.Substitution */ || + type.indexType.flags & 33554432 /* TypeFlags.Substitution */)) { + return getIndexedAccessType(getActualTypeVariable(type.objectType), getActualTypeVariable(type.indexType)); + } + return type; + } + function maybeCloneTypeParameter(p) { + var constraint = getConstraintOfTypeParameter(p); + return constraint && (isGenericObjectType(constraint) || isGenericIndexType(constraint)) ? cloneTypeParameter(p) : p; + } + function isTypicalNondistributiveConditional(root) { + return !root.isDistributive && isSingletonTupleType(root.node.checkType) && isSingletonTupleType(root.node.extendsType); + } + function isSingletonTupleType(node) { + return ts.isTupleTypeNode(node) && + ts.length(node.elements) === 1 && + !ts.isOptionalTypeNode(node.elements[0]) && + !ts.isRestTypeNode(node.elements[0]) && + !(ts.isNamedTupleMember(node.elements[0]) && (node.elements[0].questionToken || node.elements[0].dotDotDotToken)); + } + /** + * We syntactually check for common nondistributive conditional shapes and unwrap them into + * the intended comparison - we do this so we can check if the unwrapped types are generic or + * not and appropriately defer condition calculation + */ + function unwrapNondistributiveConditionalTuple(root, type) { + return isTypicalNondistributiveConditional(root) && isTupleType(type) ? getTypeArguments(type)[0] : type; + } + function getConditionalType(root, mapper, aliasSymbol, aliasTypeArguments) { + var result; + var extraTypes; + var tailCount = 0; + // We loop here for an immediately nested conditional type in the false position, effectively treating + // types of the form 'A extends B ? X : C extends D ? Y : E extends F ? Z : ...' as a single construct for + // purposes of resolution. We also loop here when resolution of a conditional type ends in resolution of + // another (or, through recursion, possibly the same) conditional type. In the potentially tail-recursive + // cases we increment the tail recursion counter and stop after 1000 iterations. + while (true) { + if (tailCount === 1000) { + error(currentNode, ts.Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite); + result = errorType; + break; + } + var isUnwrapped = isTypicalNondistributiveConditional(root); + var checkType = instantiateType(unwrapNondistributiveConditionalTuple(root, getActualTypeVariable(root.checkType)), mapper); + var checkTypeInstantiable = isGenericType(checkType); + var extendsType = instantiateType(unwrapNondistributiveConditionalTuple(root, root.extendsType), mapper); + if (checkType === wildcardType || extendsType === wildcardType) { + return wildcardType; + } + var combinedMapper = void 0; + if (root.inferTypeParameters) { + // When we're looking at making an inference for an infer type, when we get its constraint, it'll automagically be + // instantiated with the context, so it doesn't need the mapper for the inference contex - however the constraint + // may refer to another _root_, _uncloned_ `infer` type parameter [1], or to something mapped by `mapper` [2]. + // [1] Eg, if we have `Foo` and `Foo` - `B` is constrained to `T`, which, in turn, has been instantiated + // as `number` + // Conversely, if we have `Foo`, `B` is still constrained to `T` and `T` is instantiated as `A` + // [2] Eg, if we have `Foo` and `Foo` where `Q` is mapped by `mapper` into `number` - `B` is constrained to `T` + // which is in turn instantiated as `Q`, which is in turn instantiated as `number`. + // So we need to: + // * Clone the type parameters so their constraints can be instantiated in the context of `mapper` (otherwise theyd only get inference context information) + // * Set the clones to both map the conditional's enclosing `mapper` and the original params + // * instantiate the extends type with the clones + // * incorporate all of the component mappers into the combined mapper for the true and false members + // This means we have three mappers that need applying: + // * The original `mapper` used to create this conditional + // * The mapper that maps the old root type parameter to the clone (`freshMapper`) + // * The mapper that maps the clone to its inference result (`context.mapper`) + var freshParams = ts.sameMap(root.inferTypeParameters, maybeCloneTypeParameter); + var freshMapper = freshParams !== root.inferTypeParameters ? createTypeMapper(root.inferTypeParameters, freshParams) : undefined; + var context = createInferenceContext(freshParams, /*signature*/ undefined, 0 /* InferenceFlags.None */); + if (freshMapper) { + var freshCombinedMapper = combineTypeMappers(mapper, freshMapper); + for (var _i = 0, freshParams_1 = freshParams; _i < freshParams_1.length; _i++) { + var p = freshParams_1[_i]; + if (root.inferTypeParameters.indexOf(p) === -1) { + p.mapper = freshCombinedMapper; + } + } + } + if (!checkTypeInstantiable) { + // We don't want inferences from constraints as they may cause us to eagerly resolve the + // conditional type instead of deferring resolution. Also, we always want strict function + // types rules (i.e. proper contravariance) for inferences. + inferTypes(context.inferences, checkType, instantiateType(extendsType, freshMapper), 512 /* InferencePriority.NoConstraints */ | 1024 /* InferencePriority.AlwaysStrict */); + } + var innerMapper = combineTypeMappers(freshMapper, context.mapper); + // It's possible for 'infer T' type paramteters to be given uninstantiated constraints when the + // those type parameters are used in type references (see getInferredTypeParameterConstraint). For + // that reason we need context.mapper to be first in the combined mapper. See #42636 for examples. + combinedMapper = mapper ? combineTypeMappers(innerMapper, mapper) : innerMapper; + } + // Instantiate the extends type including inferences for 'infer T' type parameters + var inferredExtendsType = combinedMapper ? instantiateType(unwrapNondistributiveConditionalTuple(root, root.extendsType), combinedMapper) : extendsType; + // We attempt to resolve the conditional type only when the check and extends types are non-generic + if (!checkTypeInstantiable && !isGenericType(inferredExtendsType)) { + // Return falseType for a definitely false extends check. We check an instantiations of the two + // types with type parameters mapped to the wildcard type, the most permissive instantiations + // possible (the wildcard type is assignable to and from all types). If those are not related, + // then no instantiations will be and we can just return the false branch type. + if (!(inferredExtendsType.flags & 3 /* TypeFlags.AnyOrUnknown */) && ((checkType.flags & 1 /* TypeFlags.Any */ && !isUnwrapped) || !isTypeAssignableTo(getPermissiveInstantiation(checkType), getPermissiveInstantiation(inferredExtendsType)))) { + // Return union of trueType and falseType for 'any' since it matches anything + if (checkType.flags & 1 /* TypeFlags.Any */ && !isUnwrapped) { + (extraTypes || (extraTypes = [])).push(instantiateType(getTypeFromTypeNode(root.node.trueType), combinedMapper || mapper)); + } + // If falseType is an immediately nested conditional type that isn't distributive or has an + // identical checkType, switch to that type and loop. + var falseType_1 = getTypeFromTypeNode(root.node.falseType); + if (falseType_1.flags & 16777216 /* TypeFlags.Conditional */) { + var newRoot = falseType_1.root; + if (newRoot.node.parent === root.node && (!newRoot.isDistributive || newRoot.checkType === root.checkType)) { + root = newRoot; + continue; + } + if (canTailRecurse(falseType_1, mapper)) { + continue; + } + } + result = instantiateType(falseType_1, mapper); + break; + } + // Return trueType for a definitely true extends check. We check instantiations of the two + // types with type parameters mapped to their restrictive form, i.e. a form of the type parameter + // that has no constraint. This ensures that, for example, the type + // type Foo = T extends { x: string } ? string : number + // doesn't immediately resolve to 'string' instead of being deferred. + if (inferredExtendsType.flags & 3 /* TypeFlags.AnyOrUnknown */ || isTypeAssignableTo(getRestrictiveInstantiation(checkType), getRestrictiveInstantiation(inferredExtendsType))) { + var trueType_1 = getTypeFromTypeNode(root.node.trueType); + var trueMapper = combinedMapper || mapper; + if (canTailRecurse(trueType_1, trueMapper)) { + continue; + } + result = instantiateType(trueType_1, trueMapper); + break; + } + } + // Return a deferred type for a check that is neither definitely true nor definitely false + result = createType(16777216 /* TypeFlags.Conditional */); + result.root = root; + result.checkType = instantiateType(root.checkType, mapper); + result.extendsType = instantiateType(root.extendsType, mapper); + result.mapper = mapper; + result.combinedMapper = combinedMapper; + result.aliasSymbol = aliasSymbol || root.aliasSymbol; + result.aliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(root.aliasTypeArguments, mapper); // TODO: GH#18217 + break; + } + return extraTypes ? getUnionType(ts.append(extraTypes, result)) : result; + // We tail-recurse for generic conditional types that (a) have not already been evaluated and cached, and + // (b) are non distributive, have a check type that is unaffected by instantiation, or have a non-union check + // type. Note that recursion is possible only through aliased conditional types, so we only increment the tail + // recursion counter for those. + function canTailRecurse(newType, newMapper) { + if (newType.flags & 16777216 /* TypeFlags.Conditional */ && newMapper) { + var newRoot = newType.root; + if (newRoot.outerTypeParameters) { + var typeParamMapper_1 = combineTypeMappers(newType.mapper, newMapper); + var typeArguments = ts.map(newRoot.outerTypeParameters, function (t) { return getMappedType(t, typeParamMapper_1); }); + var newRootMapper = createTypeMapper(newRoot.outerTypeParameters, typeArguments); + var newCheckType = newRoot.isDistributive ? getMappedType(newRoot.checkType, newRootMapper) : undefined; + if (!newCheckType || newCheckType === newRoot.checkType || !(newCheckType.flags & (1048576 /* TypeFlags.Union */ | 131072 /* TypeFlags.Never */))) { + root = newRoot; + mapper = newRootMapper; + aliasSymbol = undefined; + aliasTypeArguments = undefined; + if (newRoot.aliasSymbol) { + tailCount++; + } + return true; + } + } + } + return false; + } + } + function getTrueTypeFromConditionalType(type) { + return type.resolvedTrueType || (type.resolvedTrueType = instantiateType(getTypeFromTypeNode(type.root.node.trueType), type.mapper)); + } + function getFalseTypeFromConditionalType(type) { + return type.resolvedFalseType || (type.resolvedFalseType = instantiateType(getTypeFromTypeNode(type.root.node.falseType), type.mapper)); + } + function getInferredTrueTypeFromConditionalType(type) { + return type.resolvedInferredTrueType || (type.resolvedInferredTrueType = type.combinedMapper ? instantiateType(getTypeFromTypeNode(type.root.node.trueType), type.combinedMapper) : getTrueTypeFromConditionalType(type)); + } + function getInferTypeParameters(node) { + var result; + if (node.locals) { + node.locals.forEach(function (symbol) { + if (symbol.flags & 262144 /* SymbolFlags.TypeParameter */) { + result = ts.append(result, getDeclaredTypeOfSymbol(symbol)); + } + }); + } + return result; + } + function isDistributionDependent(root) { + return root.isDistributive && (isTypeParameterPossiblyReferenced(root.checkType, root.node.trueType) || + isTypeParameterPossiblyReferenced(root.checkType, root.node.falseType)); + } + function getTypeFromConditionalTypeNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + var checkType = getTypeFromTypeNode(node.checkType); + var aliasSymbol = getAliasSymbolForTypeNode(node); + var aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol); + var allOuterTypeParameters = getOuterTypeParameters(node, /*includeThisTypes*/ true); + var outerTypeParameters = aliasTypeArguments ? allOuterTypeParameters : ts.filter(allOuterTypeParameters, function (tp) { return isTypeParameterPossiblyReferenced(tp, node); }); + var root = { + node: node, + checkType: checkType, + extendsType: getTypeFromTypeNode(node.extendsType), + isDistributive: !!(checkType.flags & 262144 /* TypeFlags.TypeParameter */), + inferTypeParameters: getInferTypeParameters(node), + outerTypeParameters: outerTypeParameters, + instantiations: undefined, + aliasSymbol: aliasSymbol, + aliasTypeArguments: aliasTypeArguments + }; + links.resolvedType = getConditionalType(root, /*mapper*/ undefined); + if (outerTypeParameters) { + root.instantiations = new ts.Map(); + root.instantiations.set(getTypeListId(outerTypeParameters), links.resolvedType); + } + } + return links.resolvedType; + } + function getTypeFromInferTypeNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + links.resolvedType = getDeclaredTypeOfTypeParameter(getSymbolOfNode(node.typeParameter)); + } + return links.resolvedType; + } + function getIdentifierChain(node) { + if (ts.isIdentifier(node)) { + return [node]; + } + else { + return ts.append(getIdentifierChain(node.left), node.right); + } + } + function getTypeFromImportTypeNode(node) { + var _a; + var links = getNodeLinks(node); + if (!links.resolvedType) { + if (node.isTypeOf && node.typeArguments) { // Only the non-typeof form can make use of type arguments + error(node, ts.Diagnostics.Type_arguments_cannot_be_used_here); + links.resolvedSymbol = unknownSymbol; + return links.resolvedType = errorType; + } + if (!ts.isLiteralImportTypeNode(node)) { + error(node.argument, ts.Diagnostics.String_literal_expected); + links.resolvedSymbol = unknownSymbol; + return links.resolvedType = errorType; + } + var targetMeaning = node.isTypeOf ? 111551 /* SymbolFlags.Value */ : node.flags & 8388608 /* NodeFlags.JSDoc */ ? 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ : 788968 /* SymbolFlags.Type */; + // TODO: Future work: support unions/generics/whatever via a deferred import-type + var innerModuleSymbol = resolveExternalModuleName(node, node.argument.literal); + if (!innerModuleSymbol) { + links.resolvedSymbol = unknownSymbol; + return links.resolvedType = errorType; + } + var isExportEquals = !!((_a = innerModuleSymbol.exports) === null || _a === void 0 ? void 0 : _a.get("export=" /* InternalSymbolName.ExportEquals */)); + var moduleSymbol = resolveExternalModuleSymbol(innerModuleSymbol, /*dontResolveAlias*/ false); + if (!ts.nodeIsMissing(node.qualifier)) { + var nameStack = getIdentifierChain(node.qualifier); + var currentNamespace = moduleSymbol; + var current = void 0; + while (current = nameStack.shift()) { + var meaning = nameStack.length ? 1920 /* SymbolFlags.Namespace */ : targetMeaning; + // typeof a.b.c is normally resolved using `checkExpression` which in turn defers to `checkQualifiedName` + // That, in turn, ultimately uses `getPropertyOfType` on the type of the symbol, which differs slightly from + // the `exports` lookup process that only looks up namespace members which is used for most type references + var mergedResolvedSymbol = getMergedSymbol(resolveSymbol(currentNamespace)); + var symbolFromVariable = node.isTypeOf || ts.isInJSFile(node) && isExportEquals + ? getPropertyOfType(getTypeOfSymbol(mergedResolvedSymbol), current.escapedText, /*skipObjectFunctionPropertyAugment*/ false, /*includeTypeOnlyMembers*/ true) + : undefined; + var symbolFromModule = node.isTypeOf ? undefined : getSymbol(getExportsOfSymbol(mergedResolvedSymbol), current.escapedText, meaning); + var next = symbolFromModule !== null && symbolFromModule !== void 0 ? symbolFromModule : symbolFromVariable; + if (!next) { + error(current, ts.Diagnostics.Namespace_0_has_no_exported_member_1, getFullyQualifiedName(currentNamespace), ts.declarationNameToString(current)); + return links.resolvedType = errorType; + } + getNodeLinks(current).resolvedSymbol = next; + getNodeLinks(current.parent).resolvedSymbol = next; + currentNamespace = next; + } + links.resolvedType = resolveImportSymbolType(node, links, currentNamespace, targetMeaning); + } + else { + if (moduleSymbol.flags & targetMeaning) { + links.resolvedType = resolveImportSymbolType(node, links, moduleSymbol, targetMeaning); + } + else { + var errorMessage = targetMeaning === 111551 /* SymbolFlags.Value */ + ? ts.Diagnostics.Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here + : ts.Diagnostics.Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0; + error(node, errorMessage, node.argument.literal.text); + links.resolvedSymbol = unknownSymbol; + links.resolvedType = errorType; + } + } + } + return links.resolvedType; + } + function resolveImportSymbolType(node, links, symbol, meaning) { + var resolvedSymbol = resolveSymbol(symbol); + links.resolvedSymbol = resolvedSymbol; + if (meaning === 111551 /* SymbolFlags.Value */) { + return getTypeOfSymbol(symbol); // intentionally doesn't use resolved symbol so type is cached as expected on the alias + } + else { + return getTypeReferenceType(node, resolvedSymbol); // getTypeReferenceType doesn't handle aliases - it must get the resolved symbol + } + } + function getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + // Deferred resolution of members is handled by resolveObjectTypeMembers + var aliasSymbol = getAliasSymbolForTypeNode(node); + if (getMembersOfSymbol(node.symbol).size === 0 && !aliasSymbol) { + links.resolvedType = emptyTypeLiteralType; + } + else { + var type = createObjectType(16 /* ObjectFlags.Anonymous */, node.symbol); + type.aliasSymbol = aliasSymbol; + type.aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol); + if (ts.isJSDocTypeLiteral(node) && node.isArrayType) { + type = createArrayType(type); + } + links.resolvedType = type; + } + } + return links.resolvedType; + } + function getAliasSymbolForTypeNode(node) { + var host = node.parent; + while (ts.isParenthesizedTypeNode(host) || ts.isJSDocTypeExpression(host) || ts.isTypeOperatorNode(host) && host.operator === 146 /* SyntaxKind.ReadonlyKeyword */) { + host = host.parent; + } + return ts.isTypeAlias(host) ? getSymbolOfNode(host) : undefined; + } + function getTypeArgumentsForAliasSymbol(symbol) { + return symbol ? getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol) : undefined; + } + function isNonGenericObjectType(type) { + return !!(type.flags & 524288 /* TypeFlags.Object */) && !isGenericMappedType(type); + } + function isEmptyObjectTypeOrSpreadsIntoEmptyObject(type) { + return isEmptyObjectType(type) || !!(type.flags & (65536 /* TypeFlags.Null */ | 32768 /* TypeFlags.Undefined */ | 528 /* TypeFlags.BooleanLike */ | 296 /* TypeFlags.NumberLike */ | 2112 /* TypeFlags.BigIntLike */ | 402653316 /* TypeFlags.StringLike */ | 1056 /* TypeFlags.EnumLike */ | 67108864 /* TypeFlags.NonPrimitive */ | 4194304 /* TypeFlags.Index */)); + } + function tryMergeUnionOfObjectTypeAndEmptyObject(type, readonly) { + if (!(type.flags & 1048576 /* TypeFlags.Union */)) { + return type; + } + if (ts.every(type.types, isEmptyObjectTypeOrSpreadsIntoEmptyObject)) { + return ts.find(type.types, isEmptyObjectType) || emptyObjectType; + } + var firstType = ts.find(type.types, function (t) { return !isEmptyObjectTypeOrSpreadsIntoEmptyObject(t); }); + if (!firstType) { + return type; + } + var secondType = ts.find(type.types, function (t) { return t !== firstType && !isEmptyObjectTypeOrSpreadsIntoEmptyObject(t); }); + if (secondType) { + return type; + } + return getAnonymousPartialType(firstType); + function getAnonymousPartialType(type) { + // gets the type as if it had been spread, but where everything in the spread is made optional + var members = ts.createSymbolTable(); + for (var _i = 0, _a = getPropertiesOfType(type); _i < _a.length; _i++) { + var prop = _a[_i]; + if (ts.getDeclarationModifierFlagsFromSymbol(prop) & (8 /* ModifierFlags.Private */ | 16 /* ModifierFlags.Protected */)) { + // do nothing, skip privates + } + else if (isSpreadableProperty(prop)) { + var isSetonlyAccessor = prop.flags & 65536 /* SymbolFlags.SetAccessor */ && !(prop.flags & 32768 /* SymbolFlags.GetAccessor */); + var flags = 4 /* SymbolFlags.Property */ | 16777216 /* SymbolFlags.Optional */; + var result = createSymbol(flags, prop.escapedName, getIsLateCheckFlag(prop) | (readonly ? 8 /* CheckFlags.Readonly */ : 0)); + result.type = isSetonlyAccessor ? undefinedType : addOptionality(getTypeOfSymbol(prop), /*isProperty*/ true); + result.declarations = prop.declarations; + result.nameType = getSymbolLinks(prop).nameType; + result.syntheticOrigin = prop; + members.set(prop.escapedName, result); + } + } + var spread = createAnonymousType(type.symbol, members, ts.emptyArray, ts.emptyArray, getIndexInfosOfType(type)); + spread.objectFlags |= 128 /* ObjectFlags.ObjectLiteral */ | 131072 /* ObjectFlags.ContainsObjectOrArrayLiteral */; + return spread; + } + } + /** + * Since the source of spread types are object literals, which are not binary, + * this function should be called in a left folding style, with left = previous result of getSpreadType + * and right = the new element to be spread. + */ + function getSpreadType(left, right, symbol, objectFlags, readonly) { + if (left.flags & 1 /* TypeFlags.Any */ || right.flags & 1 /* TypeFlags.Any */) { + return anyType; + } + if (left.flags & 2 /* TypeFlags.Unknown */ || right.flags & 2 /* TypeFlags.Unknown */) { + return unknownType; + } + if (left.flags & 131072 /* TypeFlags.Never */) { + return right; + } + if (right.flags & 131072 /* TypeFlags.Never */) { + return left; + } + left = tryMergeUnionOfObjectTypeAndEmptyObject(left, readonly); + if (left.flags & 1048576 /* TypeFlags.Union */) { + return checkCrossProductUnion([left, right]) + ? mapType(left, function (t) { return getSpreadType(t, right, symbol, objectFlags, readonly); }) + : errorType; + } + right = tryMergeUnionOfObjectTypeAndEmptyObject(right, readonly); + if (right.flags & 1048576 /* TypeFlags.Union */) { + return checkCrossProductUnion([left, right]) + ? mapType(right, function (t) { return getSpreadType(left, t, symbol, objectFlags, readonly); }) + : errorType; + } + if (right.flags & (528 /* TypeFlags.BooleanLike */ | 296 /* TypeFlags.NumberLike */ | 2112 /* TypeFlags.BigIntLike */ | 402653316 /* TypeFlags.StringLike */ | 1056 /* TypeFlags.EnumLike */ | 67108864 /* TypeFlags.NonPrimitive */ | 4194304 /* TypeFlags.Index */)) { + return left; + } + if (isGenericObjectType(left) || isGenericObjectType(right)) { + if (isEmptyObjectType(left)) { + return right; + } + // When the left type is an intersection, we may need to merge the last constituent of the + // intersection with the right type. For example when the left type is 'T & { a: string }' + // and the right type is '{ b: string }' we produce 'T & { a: string, b: string }'. + if (left.flags & 2097152 /* TypeFlags.Intersection */) { + var types = left.types; + var lastLeft = types[types.length - 1]; + if (isNonGenericObjectType(lastLeft) && isNonGenericObjectType(right)) { + return getIntersectionType(ts.concatenate(types.slice(0, types.length - 1), [getSpreadType(lastLeft, right, symbol, objectFlags, readonly)])); + } + } + return getIntersectionType([left, right]); + } + var members = ts.createSymbolTable(); + var skippedPrivateMembers = new ts.Set(); + var indexInfos = left === emptyObjectType ? getIndexInfosOfType(right) : getUnionIndexInfos([left, right]); + for (var _i = 0, _a = getPropertiesOfType(right); _i < _a.length; _i++) { + var rightProp = _a[_i]; + if (ts.getDeclarationModifierFlagsFromSymbol(rightProp) & (8 /* ModifierFlags.Private */ | 16 /* ModifierFlags.Protected */)) { + skippedPrivateMembers.add(rightProp.escapedName); + } + else if (isSpreadableProperty(rightProp)) { + members.set(rightProp.escapedName, getSpreadSymbol(rightProp, readonly)); + } + } + for (var _b = 0, _c = getPropertiesOfType(left); _b < _c.length; _b++) { + var leftProp = _c[_b]; + if (skippedPrivateMembers.has(leftProp.escapedName) || !isSpreadableProperty(leftProp)) { + continue; + } + if (members.has(leftProp.escapedName)) { + var rightProp = members.get(leftProp.escapedName); + var rightType = getTypeOfSymbol(rightProp); + if (rightProp.flags & 16777216 /* SymbolFlags.Optional */) { + var declarations = ts.concatenate(leftProp.declarations, rightProp.declarations); + var flags = 4 /* SymbolFlags.Property */ | (leftProp.flags & 16777216 /* SymbolFlags.Optional */); + var result = createSymbol(flags, leftProp.escapedName); + result.type = getUnionType([getTypeOfSymbol(leftProp), removeMissingOrUndefinedType(rightType)], 2 /* UnionReduction.Subtype */); + result.leftSpread = leftProp; + result.rightSpread = rightProp; + result.declarations = declarations; + result.nameType = getSymbolLinks(leftProp).nameType; + members.set(leftProp.escapedName, result); + } + } + else { + members.set(leftProp.escapedName, getSpreadSymbol(leftProp, readonly)); + } + } + var spread = createAnonymousType(symbol, members, ts.emptyArray, ts.emptyArray, ts.sameMap(indexInfos, function (info) { return getIndexInfoWithReadonly(info, readonly); })); + spread.objectFlags |= 128 /* ObjectFlags.ObjectLiteral */ | 131072 /* ObjectFlags.ContainsObjectOrArrayLiteral */ | 2097152 /* ObjectFlags.ContainsSpread */ | objectFlags; + return spread; + } + /** We approximate own properties as non-methods plus methods that are inside the object literal */ + function isSpreadableProperty(prop) { + var _a; + return !ts.some(prop.declarations, ts.isPrivateIdentifierClassElementDeclaration) && + (!(prop.flags & (8192 /* SymbolFlags.Method */ | 32768 /* SymbolFlags.GetAccessor */ | 65536 /* SymbolFlags.SetAccessor */)) || + !((_a = prop.declarations) === null || _a === void 0 ? void 0 : _a.some(function (decl) { return ts.isClassLike(decl.parent); }))); + } + function getSpreadSymbol(prop, readonly) { + var isSetonlyAccessor = prop.flags & 65536 /* SymbolFlags.SetAccessor */ && !(prop.flags & 32768 /* SymbolFlags.GetAccessor */); + if (!isSetonlyAccessor && readonly === isReadonlySymbol(prop)) { + return prop; + } + var flags = 4 /* SymbolFlags.Property */ | (prop.flags & 16777216 /* SymbolFlags.Optional */); + var result = createSymbol(flags, prop.escapedName, getIsLateCheckFlag(prop) | (readonly ? 8 /* CheckFlags.Readonly */ : 0)); + result.type = isSetonlyAccessor ? undefinedType : getTypeOfSymbol(prop); + result.declarations = prop.declarations; + result.nameType = getSymbolLinks(prop).nameType; + result.syntheticOrigin = prop; + return result; + } + function getIndexInfoWithReadonly(info, readonly) { + return info.isReadonly !== readonly ? createIndexInfo(info.keyType, info.type, readonly, info.declaration) : info; + } + function createLiteralType(flags, value, symbol, regularType) { + var type = createType(flags); + type.symbol = symbol; + type.value = value; + type.regularType = regularType || type; + return type; + } + function getFreshTypeOfLiteralType(type) { + if (type.flags & 2944 /* TypeFlags.Literal */) { + if (!type.freshType) { + var freshType = createLiteralType(type.flags, type.value, type.symbol, type); + freshType.freshType = freshType; + type.freshType = freshType; + } + return type.freshType; + } + return type; + } + function getRegularTypeOfLiteralType(type) { + return type.flags & 2944 /* TypeFlags.Literal */ ? type.regularType : + type.flags & 1048576 /* TypeFlags.Union */ ? (type.regularType || (type.regularType = mapType(type, getRegularTypeOfLiteralType))) : + type; + } + function isFreshLiteralType(type) { + return !!(type.flags & 2944 /* TypeFlags.Literal */) && type.freshType === type; + } + function getStringLiteralType(value) { + var type; + return stringLiteralTypes.get(value) || + (stringLiteralTypes.set(value, type = createLiteralType(128 /* TypeFlags.StringLiteral */, value)), type); + } + function getNumberLiteralType(value) { + var type; + return numberLiteralTypes.get(value) || + (numberLiteralTypes.set(value, type = createLiteralType(256 /* TypeFlags.NumberLiteral */, value)), type); + } + function getBigIntLiteralType(value) { + var type; + var key = ts.pseudoBigIntToString(value); + return bigIntLiteralTypes.get(key) || + (bigIntLiteralTypes.set(key, type = createLiteralType(2048 /* TypeFlags.BigIntLiteral */, value)), type); + } + function getEnumLiteralType(value, enumId, symbol) { + var type; + var qualifier = typeof value === "string" ? "@" : "#"; + var key = enumId + qualifier + value; + var flags = 1024 /* TypeFlags.EnumLiteral */ | (typeof value === "string" ? 128 /* TypeFlags.StringLiteral */ : 256 /* TypeFlags.NumberLiteral */); + return enumLiteralTypes.get(key) || + (enumLiteralTypes.set(key, type = createLiteralType(flags, value, symbol)), type); + } + function getTypeFromLiteralTypeNode(node) { + if (node.literal.kind === 104 /* SyntaxKind.NullKeyword */) { + return nullType; + } + var links = getNodeLinks(node); + if (!links.resolvedType) { + links.resolvedType = getRegularTypeOfLiteralType(checkExpression(node.literal)); + } + return links.resolvedType; + } + function createUniqueESSymbolType(symbol) { + var type = createType(8192 /* TypeFlags.UniqueESSymbol */); + type.symbol = symbol; + type.escapedName = "__@".concat(type.symbol.escapedName, "@").concat(getSymbolId(type.symbol)); + return type; + } + function getESSymbolLikeTypeForNode(node) { + if (ts.isValidESSymbolDeclaration(node)) { + var symbol = ts.isCommonJsExportPropertyAssignment(node) ? getSymbolOfNode(node.left) : getSymbolOfNode(node); + if (symbol) { + var links = getSymbolLinks(symbol); + return links.uniqueESSymbolType || (links.uniqueESSymbolType = createUniqueESSymbolType(symbol)); + } + } + return esSymbolType; + } + function getThisType(node) { + var container = ts.getThisContainer(node, /*includeArrowFunctions*/ false); + var parent = container && container.parent; + if (parent && (ts.isClassLike(parent) || parent.kind === 261 /* SyntaxKind.InterfaceDeclaration */)) { + if (!ts.isStatic(container) && + (!ts.isConstructorDeclaration(container) || ts.isNodeDescendantOf(node, container.body))) { + return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(parent)).thisType; + } + } + // inside x.prototype = { ... } + if (parent && ts.isObjectLiteralExpression(parent) && ts.isBinaryExpression(parent.parent) && ts.getAssignmentDeclarationKind(parent.parent) === 6 /* AssignmentDeclarationKind.Prototype */) { + return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(parent.parent.left).parent).thisType; + } + // /** @return {this} */ + // x.prototype.m = function() { ... } + var host = node.flags & 8388608 /* NodeFlags.JSDoc */ ? ts.getHostSignatureFromJSDoc(node) : undefined; + if (host && ts.isFunctionExpression(host) && ts.isBinaryExpression(host.parent) && ts.getAssignmentDeclarationKind(host.parent) === 3 /* AssignmentDeclarationKind.PrototypeProperty */) { + return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(host.parent.left).parent).thisType; + } + // inside constructor function C() { ... } + if (isJSConstructor(container) && ts.isNodeDescendantOf(node, container.body)) { + return getDeclaredTypeOfClassOrInterface(getSymbolOfNode(container)).thisType; + } + error(node, ts.Diagnostics.A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface); + return errorType; + } + function getTypeFromThisTypeNode(node) { + var links = getNodeLinks(node); + if (!links.resolvedType) { + links.resolvedType = getThisType(node); + } + return links.resolvedType; + } + function getTypeFromRestTypeNode(node) { + return getTypeFromTypeNode(getArrayElementTypeNode(node.type) || node.type); + } + function getArrayElementTypeNode(node) { + switch (node.kind) { + case 193 /* SyntaxKind.ParenthesizedType */: + return getArrayElementTypeNode(node.type); + case 186 /* SyntaxKind.TupleType */: + if (node.elements.length === 1) { + node = node.elements[0]; + if (node.kind === 188 /* SyntaxKind.RestType */ || node.kind === 199 /* SyntaxKind.NamedTupleMember */ && node.dotDotDotToken) { + return getArrayElementTypeNode(node.type); + } + } + break; + case 185 /* SyntaxKind.ArrayType */: + return node.elementType; + } + return undefined; + } + function getTypeFromNamedTupleTypeNode(node) { + var links = getNodeLinks(node); + return links.resolvedType || (links.resolvedType = + node.dotDotDotToken ? getTypeFromRestTypeNode(node) : + addOptionality(getTypeFromTypeNode(node.type), /*isProperty*/ true, !!node.questionToken)); + } + function getTypeFromTypeNode(node) { + return getConditionalFlowTypeOfType(getTypeFromTypeNodeWorker(node), node); + } + function getTypeFromTypeNodeWorker(node) { + switch (node.kind) { + case 131 /* SyntaxKind.AnyKeyword */: + case 315 /* SyntaxKind.JSDocAllType */: + case 316 /* SyntaxKind.JSDocUnknownType */: + return anyType; + case 157 /* SyntaxKind.UnknownKeyword */: + return unknownType; + case 152 /* SyntaxKind.StringKeyword */: + return stringType; + case 148 /* SyntaxKind.NumberKeyword */: + return numberType; + case 160 /* SyntaxKind.BigIntKeyword */: + return bigintType; + case 134 /* SyntaxKind.BooleanKeyword */: + return booleanType; + case 153 /* SyntaxKind.SymbolKeyword */: + return esSymbolType; + case 114 /* SyntaxKind.VoidKeyword */: + return voidType; + case 155 /* SyntaxKind.UndefinedKeyword */: + return undefinedType; + case 104 /* SyntaxKind.NullKeyword */: + // TODO(rbuckton): `NullKeyword` is no longer a `TypeNode`, but we defensively allow it here because of incorrect casts in the Language Service. + return nullType; + case 144 /* SyntaxKind.NeverKeyword */: + return neverType; + case 149 /* SyntaxKind.ObjectKeyword */: + return node.flags & 262144 /* NodeFlags.JavaScriptFile */ && !noImplicitAny ? anyType : nonPrimitiveType; + case 139 /* SyntaxKind.IntrinsicKeyword */: + return intrinsicMarkerType; + case 194 /* SyntaxKind.ThisType */: + case 108 /* SyntaxKind.ThisKeyword */: + // TODO(rbuckton): `ThisKeyword` is no longer a `TypeNode`, but we defensively allow it here because of incorrect casts in the Language Service and because of `isPartOfTypeNode`. + return getTypeFromThisTypeNode(node); + case 198 /* SyntaxKind.LiteralType */: + return getTypeFromLiteralTypeNode(node); + case 180 /* SyntaxKind.TypeReference */: + return getTypeFromTypeReference(node); + case 179 /* SyntaxKind.TypePredicate */: + return node.assertsModifier ? voidType : booleanType; + case 230 /* SyntaxKind.ExpressionWithTypeArguments */: + return getTypeFromTypeReference(node); + case 183 /* SyntaxKind.TypeQuery */: + return getTypeFromTypeQueryNode(node); + case 185 /* SyntaxKind.ArrayType */: + case 186 /* SyntaxKind.TupleType */: + return getTypeFromArrayOrTupleTypeNode(node); + case 187 /* SyntaxKind.OptionalType */: + return getTypeFromOptionalTypeNode(node); + case 189 /* SyntaxKind.UnionType */: + return getTypeFromUnionTypeNode(node); + case 190 /* SyntaxKind.IntersectionType */: + return getTypeFromIntersectionTypeNode(node); + case 317 /* SyntaxKind.JSDocNullableType */: + return getTypeFromJSDocNullableTypeNode(node); + case 319 /* SyntaxKind.JSDocOptionalType */: + return addOptionality(getTypeFromTypeNode(node.type)); + case 199 /* SyntaxKind.NamedTupleMember */: + return getTypeFromNamedTupleTypeNode(node); + case 193 /* SyntaxKind.ParenthesizedType */: + case 318 /* SyntaxKind.JSDocNonNullableType */: + case 312 /* SyntaxKind.JSDocTypeExpression */: + return getTypeFromTypeNode(node.type); + case 188 /* SyntaxKind.RestType */: + return getTypeFromRestTypeNode(node); + case 321 /* SyntaxKind.JSDocVariadicType */: + return getTypeFromJSDocVariadicType(node); + case 181 /* SyntaxKind.FunctionType */: + case 182 /* SyntaxKind.ConstructorType */: + case 184 /* SyntaxKind.TypeLiteral */: + case 325 /* SyntaxKind.JSDocTypeLiteral */: + case 320 /* SyntaxKind.JSDocFunctionType */: + case 326 /* SyntaxKind.JSDocSignature */: + return getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node); + case 195 /* SyntaxKind.TypeOperator */: + return getTypeFromTypeOperatorNode(node); + case 196 /* SyntaxKind.IndexedAccessType */: + return getTypeFromIndexedAccessTypeNode(node); + case 197 /* SyntaxKind.MappedType */: + return getTypeFromMappedTypeNode(node); + case 191 /* SyntaxKind.ConditionalType */: + return getTypeFromConditionalTypeNode(node); + case 192 /* SyntaxKind.InferType */: + return getTypeFromInferTypeNode(node); + case 200 /* SyntaxKind.TemplateLiteralType */: + return getTypeFromTemplateTypeNode(node); + case 202 /* SyntaxKind.ImportType */: + return getTypeFromImportTypeNode(node); + // This function assumes that an identifier, qualified name, or property access expression is a type expression + // Callers should first ensure this by calling `isPartOfTypeNode` + // TODO(rbuckton): These aren't valid TypeNodes, but we treat them as such because of `isPartOfTypeNode`, which returns `true` for things that aren't `TypeNode`s. + case 79 /* SyntaxKind.Identifier */: + case 163 /* SyntaxKind.QualifiedName */: + case 208 /* SyntaxKind.PropertyAccessExpression */: + var symbol = getSymbolAtLocation(node); + return symbol ? getDeclaredTypeOfSymbol(symbol) : errorType; + default: + return errorType; + } + } + function instantiateList(items, mapper, instantiator) { + if (items && items.length) { + for (var i = 0; i < items.length; i++) { + var item = items[i]; + var mapped = instantiator(item, mapper); + if (item !== mapped) { + var result = i === 0 ? [] : items.slice(0, i); + result.push(mapped); + for (i++; i < items.length; i++) { + result.push(instantiator(items[i], mapper)); + } + return result; + } + } + } + return items; + } + function instantiateTypes(types, mapper) { + return instantiateList(types, mapper, instantiateType); + } + function instantiateSignatures(signatures, mapper) { + return instantiateList(signatures, mapper, instantiateSignature); + } + function instantiateIndexInfos(indexInfos, mapper) { + return instantiateList(indexInfos, mapper, instantiateIndexInfo); + } + function createTypeMapper(sources, targets) { + return sources.length === 1 ? makeUnaryTypeMapper(sources[0], targets ? targets[0] : anyType) : makeArrayTypeMapper(sources, targets); + } + function getMappedType(type, mapper) { + switch (mapper.kind) { + case 0 /* TypeMapKind.Simple */: + return type === mapper.source ? mapper.target : type; + case 1 /* TypeMapKind.Array */: { + var sources = mapper.sources; + var targets = mapper.targets; + for (var i = 0; i < sources.length; i++) { + if (type === sources[i]) { + return targets ? targets[i] : anyType; + } + } + return type; + } + case 2 /* TypeMapKind.Deferred */: { + var sources = mapper.sources; + var targets = mapper.targets; + for (var i = 0; i < sources.length; i++) { + if (type === sources[i]) { + return targets[i](); + } + } + return type; + } + case 3 /* TypeMapKind.Function */: + return mapper.func(type); + case 4 /* TypeMapKind.Composite */: + case 5 /* TypeMapKind.Merged */: + var t1 = getMappedType(type, mapper.mapper1); + return t1 !== type && mapper.kind === 4 /* TypeMapKind.Composite */ ? instantiateType(t1, mapper.mapper2) : getMappedType(t1, mapper.mapper2); + } + } + function makeUnaryTypeMapper(source, target) { + return ts.Debug.attachDebugPrototypeIfDebug({ kind: 0 /* TypeMapKind.Simple */, source: source, target: target }); + } + function makeArrayTypeMapper(sources, targets) { + return ts.Debug.attachDebugPrototypeIfDebug({ kind: 1 /* TypeMapKind.Array */, sources: sources, targets: targets }); + } + function makeFunctionTypeMapper(func, debugInfo) { + return ts.Debug.attachDebugPrototypeIfDebug({ kind: 3 /* TypeMapKind.Function */, func: func, debugInfo: ts.Debug.isDebugging ? debugInfo : undefined }); + } + function makeDeferredTypeMapper(sources, targets) { + return ts.Debug.attachDebugPrototypeIfDebug({ kind: 2 /* TypeMapKind.Deferred */, sources: sources, targets: targets }); + } + function makeCompositeTypeMapper(kind, mapper1, mapper2) { + return ts.Debug.attachDebugPrototypeIfDebug({ kind: kind, mapper1: mapper1, mapper2: mapper2 }); + } + function createTypeEraser(sources) { + return createTypeMapper(sources, /*targets*/ undefined); + } + /** + * Maps forward-references to later types parameters to the empty object type. + * This is used during inference when instantiating type parameter defaults. + */ + function createBackreferenceMapper(context, index) { + var forwardInferences = context.inferences.slice(index); + return createTypeMapper(ts.map(forwardInferences, function (i) { return i.typeParameter; }), ts.map(forwardInferences, function () { return unknownType; })); + } + function combineTypeMappers(mapper1, mapper2) { + return mapper1 ? makeCompositeTypeMapper(4 /* TypeMapKind.Composite */, mapper1, mapper2) : mapper2; + } + function mergeTypeMappers(mapper1, mapper2) { + return mapper1 ? makeCompositeTypeMapper(5 /* TypeMapKind.Merged */, mapper1, mapper2) : mapper2; + } + function prependTypeMapping(source, target, mapper) { + return !mapper ? makeUnaryTypeMapper(source, target) : makeCompositeTypeMapper(5 /* TypeMapKind.Merged */, makeUnaryTypeMapper(source, target), mapper); + } + function appendTypeMapping(mapper, source, target) { + return !mapper ? makeUnaryTypeMapper(source, target) : makeCompositeTypeMapper(5 /* TypeMapKind.Merged */, mapper, makeUnaryTypeMapper(source, target)); + } + function getRestrictiveTypeParameter(tp) { + return !tp.constraint && !getConstraintDeclaration(tp) || tp.constraint === noConstraintType ? tp : tp.restrictiveInstantiation || (tp.restrictiveInstantiation = createTypeParameter(tp.symbol), + tp.restrictiveInstantiation.constraint = noConstraintType, + tp.restrictiveInstantiation); + } + function cloneTypeParameter(typeParameter) { + var result = createTypeParameter(typeParameter.symbol); + result.target = typeParameter; + return result; + } + function instantiateTypePredicate(predicate, mapper) { + return createTypePredicate(predicate.kind, predicate.parameterName, predicate.parameterIndex, instantiateType(predicate.type, mapper)); + } + function instantiateSignature(signature, mapper, eraseTypeParameters) { + var freshTypeParameters; + if (signature.typeParameters && !eraseTypeParameters) { + // First create a fresh set of type parameters, then include a mapping from the old to the + // new type parameters in the mapper function. Finally store this mapper in the new type + // parameters such that we can use it when instantiating constraints. + freshTypeParameters = ts.map(signature.typeParameters, cloneTypeParameter); + mapper = combineTypeMappers(createTypeMapper(signature.typeParameters, freshTypeParameters), mapper); + for (var _i = 0, freshTypeParameters_1 = freshTypeParameters; _i < freshTypeParameters_1.length; _i++) { + var tp = freshTypeParameters_1[_i]; + tp.mapper = mapper; + } + } + // Don't compute resolvedReturnType and resolvedTypePredicate now, + // because using `mapper` now could trigger inferences to become fixed. (See `createInferenceContext`.) + // See GH#17600. + var result = createSignature(signature.declaration, freshTypeParameters, signature.thisParameter && instantiateSymbol(signature.thisParameter, mapper), instantiateList(signature.parameters, mapper, instantiateSymbol), + /*resolvedReturnType*/ undefined, + /*resolvedTypePredicate*/ undefined, signature.minArgumentCount, signature.flags & 39 /* SignatureFlags.PropagatingFlags */); + result.target = signature; + result.mapper = mapper; + return result; + } + function instantiateSymbol(symbol, mapper) { + var links = getSymbolLinks(symbol); + if (links.type && !couldContainTypeVariables(links.type)) { + // If the type of the symbol is already resolved, and if that type could not possibly + // be affected by instantiation, simply return the symbol itself. + return symbol; + } + if (ts.getCheckFlags(symbol) & 1 /* CheckFlags.Instantiated */) { + // If symbol being instantiated is itself a instantiation, fetch the original target and combine the + // type mappers. This ensures that original type identities are properly preserved and that aliases + // always reference a non-aliases. + symbol = links.target; + mapper = combineTypeMappers(links.mapper, mapper); + } + // Keep the flags from the symbol we're instantiating. Mark that is instantiated, and + // also transient so that we can just store data on it directly. + var result = createSymbol(symbol.flags, symbol.escapedName, 1 /* CheckFlags.Instantiated */ | ts.getCheckFlags(symbol) & (8 /* CheckFlags.Readonly */ | 4096 /* CheckFlags.Late */ | 16384 /* CheckFlags.OptionalParameter */ | 32768 /* CheckFlags.RestParameter */)); + result.declarations = symbol.declarations; + result.parent = symbol.parent; + result.target = symbol; + result.mapper = mapper; + if (symbol.valueDeclaration) { + result.valueDeclaration = symbol.valueDeclaration; + } + if (links.nameType) { + result.nameType = links.nameType; + } + return result; + } + function getObjectTypeInstantiation(type, mapper, aliasSymbol, aliasTypeArguments) { + var declaration = type.objectFlags & 4 /* ObjectFlags.Reference */ ? type.node : + type.objectFlags & 8388608 /* ObjectFlags.InstantiationExpressionType */ ? type.node : + type.symbol.declarations[0]; + var links = getNodeLinks(declaration); + var target = type.objectFlags & 4 /* ObjectFlags.Reference */ ? links.resolvedType : + type.objectFlags & 64 /* ObjectFlags.Instantiated */ ? type.target : type; + var typeParameters = links.outerTypeParameters; + if (!typeParameters) { + // The first time an anonymous type is instantiated we compute and store a list of the type + // parameters that are in scope (and therefore potentially referenced). For type literals that + // aren't the right hand side of a generic type alias declaration we optimize by reducing the + // set of type parameters to those that are possibly referenced in the literal. + var outerTypeParameters = getOuterTypeParameters(declaration, /*includeThisTypes*/ true); + if (isJSConstructor(declaration)) { + var templateTagParameters = getTypeParametersFromDeclaration(declaration); + outerTypeParameters = ts.addRange(outerTypeParameters, templateTagParameters); + } + typeParameters = outerTypeParameters || ts.emptyArray; + var allDeclarations_1 = type.objectFlags & (4 /* ObjectFlags.Reference */ | 8388608 /* ObjectFlags.InstantiationExpressionType */) ? [declaration] : type.symbol.declarations; + typeParameters = (target.objectFlags & (4 /* ObjectFlags.Reference */ | 8388608 /* ObjectFlags.InstantiationExpressionType */) || target.symbol.flags & 8192 /* SymbolFlags.Method */ || target.symbol.flags & 2048 /* SymbolFlags.TypeLiteral */) && !target.aliasTypeArguments ? + ts.filter(typeParameters, function (tp) { return ts.some(allDeclarations_1, function (d) { return isTypeParameterPossiblyReferenced(tp, d); }); }) : + typeParameters; + links.outerTypeParameters = typeParameters; + } + if (typeParameters.length) { + // We are instantiating an anonymous type that has one or more type parameters in scope. Apply the + // mapper to the type parameters to produce the effective list of type arguments, and compute the + // instantiation cache key from the type IDs of the type arguments. + var combinedMapper_1 = combineTypeMappers(type.mapper, mapper); + var typeArguments = ts.map(typeParameters, function (t) { return getMappedType(t, combinedMapper_1); }); + var newAliasSymbol = aliasSymbol || type.aliasSymbol; + var newAliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(type.aliasTypeArguments, mapper); + var id = getTypeListId(typeArguments) + getAliasId(newAliasSymbol, newAliasTypeArguments); + if (!target.instantiations) { + target.instantiations = new ts.Map(); + target.instantiations.set(getTypeListId(typeParameters) + getAliasId(target.aliasSymbol, target.aliasTypeArguments), target); + } + var result = target.instantiations.get(id); + if (!result) { + var newMapper = createTypeMapper(typeParameters, typeArguments); + result = target.objectFlags & 4 /* ObjectFlags.Reference */ ? createDeferredTypeReference(type.target, type.node, newMapper, newAliasSymbol, newAliasTypeArguments) : + target.objectFlags & 32 /* ObjectFlags.Mapped */ ? instantiateMappedType(target, newMapper, newAliasSymbol, newAliasTypeArguments) : + instantiateAnonymousType(target, newMapper, newAliasSymbol, newAliasTypeArguments); + target.instantiations.set(id, result); + } + return result; + } + return type; + } + function maybeTypeParameterReference(node) { + return !(node.parent.kind === 180 /* SyntaxKind.TypeReference */ && node.parent.typeArguments && node === node.parent.typeName || + node.parent.kind === 202 /* SyntaxKind.ImportType */ && node.parent.typeArguments && node === node.parent.qualifier); + } + function isTypeParameterPossiblyReferenced(tp, node) { + // If the type parameter doesn't have exactly one declaration, if there are intervening statement blocks + // between the node and the type parameter declaration, if the node contains actual references to the + // type parameter, or if the node contains type queries that we can't prove couldn't contain references to the type parameter, + // we consider the type parameter possibly referenced. + if (tp.symbol && tp.symbol.declarations && tp.symbol.declarations.length === 1) { + var container = tp.symbol.declarations[0].parent; + for (var n = node; n !== container; n = n.parent) { + if (!n || n.kind === 238 /* SyntaxKind.Block */ || n.kind === 191 /* SyntaxKind.ConditionalType */ && ts.forEachChild(n.extendsType, containsReference)) { + return true; + } + } + return containsReference(node); + } + return true; + function containsReference(node) { + switch (node.kind) { + case 194 /* SyntaxKind.ThisType */: + return !!tp.isThisType; + case 79 /* SyntaxKind.Identifier */: + return !tp.isThisType && ts.isPartOfTypeNode(node) && maybeTypeParameterReference(node) && + getTypeFromTypeNodeWorker(node) === tp; // use worker because we're looking for === equality + case 183 /* SyntaxKind.TypeQuery */: + var entityName = node.exprName; + var firstIdentifier = ts.getFirstIdentifier(entityName); + var firstIdentifierSymbol = getResolvedSymbol(firstIdentifier); + var tpDeclaration = tp.symbol.declarations[0]; // There is exactly one declaration, otherwise `containsReference` is not called + var tpScope_1; + if (tpDeclaration.kind === 165 /* SyntaxKind.TypeParameter */) { // Type parameter is a regular type parameter, e.g. foo + tpScope_1 = tpDeclaration.parent; + } + else if (tp.isThisType) { + // Type parameter is the this type, and its declaration is the class declaration. + tpScope_1 = tpDeclaration; + } + else { + // Type parameter's declaration was unrecognized. + // This could happen if the type parameter comes from e.g. a JSDoc annotation, so we default to returning true. + return true; + } + if (firstIdentifierSymbol.declarations) { + return ts.some(firstIdentifierSymbol.declarations, function (idDecl) { return ts.isNodeDescendantOf(idDecl, tpScope_1); }) || + ts.some(node.typeArguments, containsReference); + } + return true; + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + return !node.type && !!node.body || + ts.some(node.typeParameters, containsReference) || + ts.some(node.parameters, containsReference) || + !!node.type && containsReference(node.type); + } + return !!ts.forEachChild(node, containsReference); + } + } + function getHomomorphicTypeVariable(type) { + var constraintType = getConstraintTypeFromMappedType(type); + if (constraintType.flags & 4194304 /* TypeFlags.Index */) { + var typeVariable = getActualTypeVariable(constraintType.type); + if (typeVariable.flags & 262144 /* TypeFlags.TypeParameter */) { + return typeVariable; + } + } + return undefined; + } + function instantiateMappedType(type, mapper, aliasSymbol, aliasTypeArguments) { + // For a homomorphic mapped type { [P in keyof T]: X }, where T is some type variable, the mapping + // operation depends on T as follows: + // * If T is a primitive type no mapping is performed and the result is simply T. + // * If T is a union type we distribute the mapped type over the union. + // * If T is an array we map to an array where the element type has been transformed. + // * If T is a tuple we map to a tuple where the element types have been transformed. + // * Otherwise we map to an object type where the type of each property has been transformed. + // For example, when T is instantiated to a union type A | B, we produce { [P in keyof A]: X } | + // { [P in keyof B]: X }, and when when T is instantiated to a union type A | undefined, we produce + // { [P in keyof A]: X } | undefined. + var typeVariable = getHomomorphicTypeVariable(type); + if (typeVariable) { + var mappedTypeVariable = instantiateType(typeVariable, mapper); + if (typeVariable !== mappedTypeVariable) { + return mapTypeWithAlias(getReducedType(mappedTypeVariable), function (t) { + if (t.flags & (3 /* TypeFlags.AnyOrUnknown */ | 58982400 /* TypeFlags.InstantiableNonPrimitive */ | 524288 /* TypeFlags.Object */ | 2097152 /* TypeFlags.Intersection */) && t !== wildcardType && !isErrorType(t)) { + if (!type.declaration.nameType) { + var constraint = void 0; + if (isArrayType(t) || t.flags & 1 /* TypeFlags.Any */ && findResolutionCycleStartIndex(typeVariable, 4 /* TypeSystemPropertyName.ImmediateBaseConstraint */) < 0 && + (constraint = getConstraintOfTypeParameter(typeVariable)) && everyType(constraint, isArrayOrTupleType)) { + return instantiateMappedArrayType(t, type, prependTypeMapping(typeVariable, t, mapper)); + } + if (isGenericTupleType(t)) { + return instantiateMappedGenericTupleType(t, type, typeVariable, mapper); + } + if (isTupleType(t)) { + return instantiateMappedTupleType(t, type, prependTypeMapping(typeVariable, t, mapper)); + } + } + return instantiateAnonymousType(type, prependTypeMapping(typeVariable, t, mapper)); + } + return t; + }, aliasSymbol, aliasTypeArguments); + } + } + // If the constraint type of the instantiation is the wildcard type, return the wildcard type. + return instantiateType(getConstraintTypeFromMappedType(type), mapper) === wildcardType ? wildcardType : instantiateAnonymousType(type, mapper, aliasSymbol, aliasTypeArguments); + } + function getModifiedReadonlyState(state, modifiers) { + return modifiers & 1 /* MappedTypeModifiers.IncludeReadonly */ ? true : modifiers & 2 /* MappedTypeModifiers.ExcludeReadonly */ ? false : state; + } + function instantiateMappedGenericTupleType(tupleType, mappedType, typeVariable, mapper) { + // When a tuple type is generic (i.e. when it contains variadic elements), we want to eagerly map the + // non-generic elements and defer mapping the generic elements. In order to facilitate this, we transform + // M<[A, B?, ...T, ...C[]] into [...M<[A]>, ...M<[B?]>, ...M, ...M] and then rely on tuple type + // normalization to resolve the non-generic parts of the resulting tuple. + var elementFlags = tupleType.target.elementFlags; + var elementTypes = ts.map(getTypeArguments(tupleType), function (t, i) { + var singleton = elementFlags[i] & 8 /* ElementFlags.Variadic */ ? t : + elementFlags[i] & 4 /* ElementFlags.Rest */ ? createArrayType(t) : + createTupleType([t], [elementFlags[i]]); + // The singleton is never a generic tuple type, so it is safe to recurse here. + return instantiateMappedType(mappedType, prependTypeMapping(typeVariable, singleton, mapper)); + }); + var newReadonly = getModifiedReadonlyState(tupleType.target.readonly, getMappedTypeModifiers(mappedType)); + return createTupleType(elementTypes, ts.map(elementTypes, function (_) { return 8 /* ElementFlags.Variadic */; }), newReadonly); + } + function instantiateMappedArrayType(arrayType, mappedType, mapper) { + var elementType = instantiateMappedTypeTemplate(mappedType, numberType, /*isOptional*/ true, mapper); + return isErrorType(elementType) ? errorType : + createArrayType(elementType, getModifiedReadonlyState(isReadonlyArrayType(arrayType), getMappedTypeModifiers(mappedType))); + } + function instantiateMappedTupleType(tupleType, mappedType, mapper) { + var elementFlags = tupleType.target.elementFlags; + var elementTypes = ts.map(getTypeArguments(tupleType), function (_, i) { + return instantiateMappedTypeTemplate(mappedType, getStringLiteralType("" + i), !!(elementFlags[i] & 2 /* ElementFlags.Optional */), mapper); + }); + var modifiers = getMappedTypeModifiers(mappedType); + var newTupleModifiers = modifiers & 4 /* MappedTypeModifiers.IncludeOptional */ ? ts.map(elementFlags, function (f) { return f & 1 /* ElementFlags.Required */ ? 2 /* ElementFlags.Optional */ : f; }) : + modifiers & 8 /* MappedTypeModifiers.ExcludeOptional */ ? ts.map(elementFlags, function (f) { return f & 2 /* ElementFlags.Optional */ ? 1 /* ElementFlags.Required */ : f; }) : + elementFlags; + var newReadonly = getModifiedReadonlyState(tupleType.target.readonly, modifiers); + return ts.contains(elementTypes, errorType) ? errorType : + createTupleType(elementTypes, newTupleModifiers, newReadonly, tupleType.target.labeledElementDeclarations); + } + function instantiateMappedTypeTemplate(type, key, isOptional, mapper) { + var templateMapper = appendTypeMapping(mapper, getTypeParameterFromMappedType(type), key); + var propType = instantiateType(getTemplateTypeFromMappedType(type.target || type), templateMapper); + var modifiers = getMappedTypeModifiers(type); + return strictNullChecks && modifiers & 4 /* MappedTypeModifiers.IncludeOptional */ && !maybeTypeOfKind(propType, 32768 /* TypeFlags.Undefined */ | 16384 /* TypeFlags.Void */) ? getOptionalType(propType, /*isProperty*/ true) : + strictNullChecks && modifiers & 8 /* MappedTypeModifiers.ExcludeOptional */ && isOptional ? getTypeWithFacts(propType, 524288 /* TypeFacts.NEUndefined */) : + propType; + } + function instantiateAnonymousType(type, mapper, aliasSymbol, aliasTypeArguments) { + var result = createObjectType(type.objectFlags | 64 /* ObjectFlags.Instantiated */, type.symbol); + if (type.objectFlags & 32 /* ObjectFlags.Mapped */) { + result.declaration = type.declaration; + // C.f. instantiateSignature + var origTypeParameter = getTypeParameterFromMappedType(type); + var freshTypeParameter = cloneTypeParameter(origTypeParameter); + result.typeParameter = freshTypeParameter; + mapper = combineTypeMappers(makeUnaryTypeMapper(origTypeParameter, freshTypeParameter), mapper); + freshTypeParameter.mapper = mapper; + } + if (type.objectFlags & 8388608 /* ObjectFlags.InstantiationExpressionType */) { + result.node = type.node; + } + result.target = type; + result.mapper = mapper; + result.aliasSymbol = aliasSymbol || type.aliasSymbol; + result.aliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(type.aliasTypeArguments, mapper); + result.objectFlags |= result.aliasTypeArguments ? getPropagatingFlagsOfTypes(result.aliasTypeArguments) : 0; + return result; + } + function getConditionalTypeInstantiation(type, mapper, aliasSymbol, aliasTypeArguments) { + var root = type.root; + if (root.outerTypeParameters) { + // We are instantiating a conditional type that has one or more type parameters in scope. Apply the + // mapper to the type parameters to produce the effective list of type arguments, and compute the + // instantiation cache key from the type IDs of the type arguments. + var typeArguments = ts.map(root.outerTypeParameters, function (t) { return getMappedType(t, mapper); }); + var id = getTypeListId(typeArguments) + getAliasId(aliasSymbol, aliasTypeArguments); + var result = root.instantiations.get(id); + if (!result) { + var newMapper_1 = createTypeMapper(root.outerTypeParameters, typeArguments); + var checkType_1 = root.checkType; + var distributionType = root.isDistributive ? getMappedType(checkType_1, newMapper_1) : undefined; + // Distributive conditional types are distributed over union types. For example, when the + // distributive conditional type T extends U ? X : Y is instantiated with A | B for T, the + // result is (A extends U ? X : Y) | (B extends U ? X : Y). + result = distributionType && checkType_1 !== distributionType && distributionType.flags & (1048576 /* TypeFlags.Union */ | 131072 /* TypeFlags.Never */) ? + mapTypeWithAlias(getReducedType(distributionType), function (t) { return getConditionalType(root, prependTypeMapping(checkType_1, t, newMapper_1)); }, aliasSymbol, aliasTypeArguments) : + getConditionalType(root, newMapper_1, aliasSymbol, aliasTypeArguments); + root.instantiations.set(id, result); + } + return result; + } + return type; + } + function instantiateType(type, mapper) { + return type && mapper ? instantiateTypeWithAlias(type, mapper, /*aliasSymbol*/ undefined, /*aliasTypeArguments*/ undefined) : type; + } + function instantiateTypeWithAlias(type, mapper, aliasSymbol, aliasTypeArguments) { + if (!couldContainTypeVariables(type)) { + return type; + } + if (instantiationDepth === 100 || instantiationCount >= 5000000) { + // We have reached 100 recursive type instantiations, or 5M type instantiations caused by the same statement + // or expression. There is a very high likelyhood we're dealing with a combination of infinite generic types + // that perpetually generate new type identities, so we stop the recursion here by yielding the error type. + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes" /* tracing.Phase.CheckTypes */, "instantiateType_DepthLimit", { typeId: type.id, instantiationDepth: instantiationDepth, instantiationCount: instantiationCount }); + error(currentNode, ts.Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite); + return errorType; + } + totalInstantiationCount++; + instantiationCount++; + instantiationDepth++; + var result = instantiateTypeWorker(type, mapper, aliasSymbol, aliasTypeArguments); + instantiationDepth--; + return result; + } + function instantiateTypeWorker(type, mapper, aliasSymbol, aliasTypeArguments) { + var flags = type.flags; + if (flags & 262144 /* TypeFlags.TypeParameter */) { + return getMappedType(type, mapper); + } + if (flags & 524288 /* TypeFlags.Object */) { + var objectFlags = type.objectFlags; + if (objectFlags & (4 /* ObjectFlags.Reference */ | 16 /* ObjectFlags.Anonymous */ | 32 /* ObjectFlags.Mapped */)) { + if (objectFlags & 4 /* ObjectFlags.Reference */ && !type.node) { + var resolvedTypeArguments = type.resolvedTypeArguments; + var newTypeArguments = instantiateTypes(resolvedTypeArguments, mapper); + return newTypeArguments !== resolvedTypeArguments ? createNormalizedTypeReference(type.target, newTypeArguments) : type; + } + if (objectFlags & 1024 /* ObjectFlags.ReverseMapped */) { + return instantiateReverseMappedType(type, mapper); + } + return getObjectTypeInstantiation(type, mapper, aliasSymbol, aliasTypeArguments); + } + return type; + } + if (flags & 3145728 /* TypeFlags.UnionOrIntersection */) { + var origin = type.flags & 1048576 /* TypeFlags.Union */ ? type.origin : undefined; + var types = origin && origin.flags & 3145728 /* TypeFlags.UnionOrIntersection */ ? origin.types : type.types; + var newTypes = instantiateTypes(types, mapper); + if (newTypes === types && aliasSymbol === type.aliasSymbol) { + return type; + } + var newAliasSymbol = aliasSymbol || type.aliasSymbol; + var newAliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(type.aliasTypeArguments, mapper); + return flags & 2097152 /* TypeFlags.Intersection */ || origin && origin.flags & 2097152 /* TypeFlags.Intersection */ ? + getIntersectionType(newTypes, newAliasSymbol, newAliasTypeArguments) : + getUnionType(newTypes, 1 /* UnionReduction.Literal */, newAliasSymbol, newAliasTypeArguments); + } + if (flags & 4194304 /* TypeFlags.Index */) { + return getIndexType(instantiateType(type.type, mapper)); + } + if (flags & 134217728 /* TypeFlags.TemplateLiteral */) { + return getTemplateLiteralType(type.texts, instantiateTypes(type.types, mapper)); + } + if (flags & 268435456 /* TypeFlags.StringMapping */) { + return getStringMappingType(type.symbol, instantiateType(type.type, mapper)); + } + if (flags & 8388608 /* TypeFlags.IndexedAccess */) { + var newAliasSymbol = aliasSymbol || type.aliasSymbol; + var newAliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(type.aliasTypeArguments, mapper); + return getIndexedAccessType(instantiateType(type.objectType, mapper), instantiateType(type.indexType, mapper), type.accessFlags, /*accessNode*/ undefined, newAliasSymbol, newAliasTypeArguments); + } + if (flags & 16777216 /* TypeFlags.Conditional */) { + return getConditionalTypeInstantiation(type, combineTypeMappers(type.mapper, mapper), aliasSymbol, aliasTypeArguments); + } + if (flags & 33554432 /* TypeFlags.Substitution */) { + var newBaseType = instantiateType(type.baseType, mapper); + var newConstraint = instantiateType(type.constraint, mapper); + // A substitution type originates in the true branch of a conditional type and can be resolved + // to just the base type in the same cases as the conditional type resolves to its true branch + // (because the base type is then known to satisfy the constraint). + if (newBaseType.flags & 8650752 /* TypeFlags.TypeVariable */ && isGenericType(newConstraint)) { + return getSubstitutionType(newBaseType, newConstraint); + } + if (newConstraint.flags & 3 /* TypeFlags.AnyOrUnknown */ || isTypeAssignableTo(getRestrictiveInstantiation(newBaseType), getRestrictiveInstantiation(newConstraint))) { + return newBaseType; + } + return newBaseType.flags & 8650752 /* TypeFlags.TypeVariable */ ? getSubstitutionType(newBaseType, newConstraint) : getIntersectionType([newConstraint, newBaseType]); + } + return type; + } + function instantiateReverseMappedType(type, mapper) { + var innerMappedType = instantiateType(type.mappedType, mapper); + if (!(ts.getObjectFlags(innerMappedType) & 32 /* ObjectFlags.Mapped */)) { + return type; + } + var innerIndexType = instantiateType(type.constraintType, mapper); + if (!(innerIndexType.flags & 4194304 /* TypeFlags.Index */)) { + return type; + } + var instantiated = inferTypeForHomomorphicMappedType(instantiateType(type.source, mapper), innerMappedType, innerIndexType); + if (instantiated) { + return instantiated; + } + return type; // Nested invocation of `inferTypeForHomomorphicMappedType` or the `source` instantiated into something unmappable + } + function getUniqueLiteralFilledInstantiation(type) { + return type.flags & (131068 /* TypeFlags.Primitive */ | 3 /* TypeFlags.AnyOrUnknown */ | 131072 /* TypeFlags.Never */) ? type : + type.uniqueLiteralFilledInstantiation || (type.uniqueLiteralFilledInstantiation = instantiateType(type, uniqueLiteralMapper)); + } + function getPermissiveInstantiation(type) { + return type.flags & (131068 /* TypeFlags.Primitive */ | 3 /* TypeFlags.AnyOrUnknown */ | 131072 /* TypeFlags.Never */) ? type : + type.permissiveInstantiation || (type.permissiveInstantiation = instantiateType(type, permissiveMapper)); + } + function getRestrictiveInstantiation(type) { + if (type.flags & (131068 /* TypeFlags.Primitive */ | 3 /* TypeFlags.AnyOrUnknown */ | 131072 /* TypeFlags.Never */)) { + return type; + } + if (type.restrictiveInstantiation) { + return type.restrictiveInstantiation; + } + type.restrictiveInstantiation = instantiateType(type, restrictiveMapper); + // We set the following so we don't attempt to set the restrictive instance of a restrictive instance + // which is redundant - we'll produce new type identities, but all type params have already been mapped. + // This also gives us a way to detect restrictive instances upon comparisons and _disable_ the "distributeive constraint" + // assignability check for them, which is distinctly unsafe, as once you have a restrctive instance, all the type parameters + // are constrained to `unknown` and produce tons of false positives/negatives! + type.restrictiveInstantiation.restrictiveInstantiation = type.restrictiveInstantiation; + return type.restrictiveInstantiation; + } + function instantiateIndexInfo(info, mapper) { + return createIndexInfo(info.keyType, instantiateType(info.type, mapper), info.isReadonly, info.declaration); + } + // Returns true if the given expression contains (at any level of nesting) a function or arrow expression + // that is subject to contextual typing. + function isContextSensitive(node) { + ts.Debug.assert(node.kind !== 171 /* SyntaxKind.MethodDeclaration */ || ts.isObjectLiteralMethod(node)); + switch (node.kind) { + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 259 /* SyntaxKind.FunctionDeclaration */: // Function declarations can have context when annotated with a jsdoc @type + return isContextSensitiveFunctionLikeDeclaration(node); + case 207 /* SyntaxKind.ObjectLiteralExpression */: + return ts.some(node.properties, isContextSensitive); + case 206 /* SyntaxKind.ArrayLiteralExpression */: + return ts.some(node.elements, isContextSensitive); + case 224 /* SyntaxKind.ConditionalExpression */: + return isContextSensitive(node.whenTrue) || + isContextSensitive(node.whenFalse); + case 223 /* SyntaxKind.BinaryExpression */: + return (node.operatorToken.kind === 56 /* SyntaxKind.BarBarToken */ || node.operatorToken.kind === 60 /* SyntaxKind.QuestionQuestionToken */) && + (isContextSensitive(node.left) || isContextSensitive(node.right)); + case 299 /* SyntaxKind.PropertyAssignment */: + return isContextSensitive(node.initializer); + case 214 /* SyntaxKind.ParenthesizedExpression */: + return isContextSensitive(node.expression); + case 289 /* SyntaxKind.JsxAttributes */: + return ts.some(node.properties, isContextSensitive) || ts.isJsxOpeningElement(node.parent) && ts.some(node.parent.parent.children, isContextSensitive); + case 288 /* SyntaxKind.JsxAttribute */: { + // If there is no initializer, JSX attribute has a boolean value of true which is not context sensitive. + var initializer = node.initializer; + return !!initializer && isContextSensitive(initializer); + } + case 291 /* SyntaxKind.JsxExpression */: { + // It is possible to that node.expression is undefined (e.g

) + var expression = node.expression; + return !!expression && isContextSensitive(expression); + } + } + return false; + } + function isContextSensitiveFunctionLikeDeclaration(node) { + return ts.hasContextSensitiveParameters(node) || hasContextSensitiveReturnExpression(node); + } + function hasContextSensitiveReturnExpression(node) { + // TODO(anhans): A block should be context-sensitive if it has a context-sensitive return value. + return !node.typeParameters && !ts.getEffectiveReturnTypeNode(node) && !!node.body && node.body.kind !== 238 /* SyntaxKind.Block */ && isContextSensitive(node.body); + } + function isContextSensitiveFunctionOrObjectLiteralMethod(func) { + return (ts.isFunctionExpressionOrArrowFunction(func) || ts.isObjectLiteralMethod(func)) && + isContextSensitiveFunctionLikeDeclaration(func); + } + function getTypeWithoutSignatures(type) { + if (type.flags & 524288 /* TypeFlags.Object */) { + var resolved = resolveStructuredTypeMembers(type); + if (resolved.constructSignatures.length || resolved.callSignatures.length) { + var result = createObjectType(16 /* ObjectFlags.Anonymous */, type.symbol); + result.members = resolved.members; + result.properties = resolved.properties; + result.callSignatures = ts.emptyArray; + result.constructSignatures = ts.emptyArray; + result.indexInfos = ts.emptyArray; + return result; + } + } + else if (type.flags & 2097152 /* TypeFlags.Intersection */) { + return getIntersectionType(ts.map(type.types, getTypeWithoutSignatures)); + } + return type; + } + // TYPE CHECKING + function isTypeIdenticalTo(source, target) { + return isTypeRelatedTo(source, target, identityRelation); + } + function compareTypesIdentical(source, target) { + return isTypeRelatedTo(source, target, identityRelation) ? -1 /* Ternary.True */ : 0 /* Ternary.False */; + } + function compareTypesAssignable(source, target) { + return isTypeRelatedTo(source, target, assignableRelation) ? -1 /* Ternary.True */ : 0 /* Ternary.False */; + } + function compareTypesSubtypeOf(source, target) { + return isTypeRelatedTo(source, target, subtypeRelation) ? -1 /* Ternary.True */ : 0 /* Ternary.False */; + } + function isTypeSubtypeOf(source, target) { + return isTypeRelatedTo(source, target, subtypeRelation); + } + function isTypeAssignableTo(source, target) { + return isTypeRelatedTo(source, target, assignableRelation); + } + // An object type S is considered to be derived from an object type T if + // S is a union type and every constituent of S is derived from T, + // T is a union type and S is derived from at least one constituent of T, or + // S is a type variable with a base constraint that is derived from T, + // T is one of the global types Object and Function and S is a subtype of T, or + // T occurs directly or indirectly in an 'extends' clause of S. + // Note that this check ignores type parameters and only considers the + // inheritance hierarchy. + function isTypeDerivedFrom(source, target) { + return source.flags & 1048576 /* TypeFlags.Union */ ? ts.every(source.types, function (t) { return isTypeDerivedFrom(t, target); }) : + target.flags & 1048576 /* TypeFlags.Union */ ? ts.some(target.types, function (t) { return isTypeDerivedFrom(source, t); }) : + source.flags & 58982400 /* TypeFlags.InstantiableNonPrimitive */ ? isTypeDerivedFrom(getBaseConstraintOfType(source) || unknownType, target) : + target === globalObjectType ? !!(source.flags & (524288 /* TypeFlags.Object */ | 67108864 /* TypeFlags.NonPrimitive */)) : + target === globalFunctionType ? !!(source.flags & 524288 /* TypeFlags.Object */) && isFunctionObjectType(source) : + hasBaseType(source, getTargetType(target)) || (isArrayType(target) && !isReadonlyArrayType(target) && isTypeDerivedFrom(source, globalReadonlyArrayType)); + } + /** + * This is *not* a bi-directional relationship. + * If one needs to check both directions for comparability, use a second call to this function or 'checkTypeComparableTo'. + * + * A type S is comparable to a type T if some (but not necessarily all) of the possible values of S are also possible values of T. + * It is used to check following cases: + * - the types of the left and right sides of equality/inequality operators (`===`, `!==`, `==`, `!=`). + * - the types of `case` clause expressions and their respective `switch` expressions. + * - the type of an expression in a type assertion with the type being asserted. + */ + function isTypeComparableTo(source, target) { + return isTypeRelatedTo(source, target, comparableRelation); + } + function areTypesComparable(type1, type2) { + return isTypeComparableTo(type1, type2) || isTypeComparableTo(type2, type1); + } + function checkTypeAssignableTo(source, target, errorNode, headMessage, containingMessageChain, errorOutputObject) { + return checkTypeRelatedTo(source, target, assignableRelation, errorNode, headMessage, containingMessageChain, errorOutputObject); + } + /** + * Like `checkTypeAssignableTo`, but if it would issue an error, instead performs structural comparisons of the types using the given expression node to + * attempt to issue more specific errors on, for example, specific object literal properties or tuple members. + */ + function checkTypeAssignableToAndOptionallyElaborate(source, target, errorNode, expr, headMessage, containingMessageChain) { + return checkTypeRelatedToAndOptionallyElaborate(source, target, assignableRelation, errorNode, expr, headMessage, containingMessageChain, /*errorOutputContainer*/ undefined); + } + function checkTypeRelatedToAndOptionallyElaborate(source, target, relation, errorNode, expr, headMessage, containingMessageChain, errorOutputContainer) { + if (isTypeRelatedTo(source, target, relation)) + return true; + if (!errorNode || !elaborateError(expr, source, target, relation, headMessage, containingMessageChain, errorOutputContainer)) { + return checkTypeRelatedTo(source, target, relation, errorNode, headMessage, containingMessageChain, errorOutputContainer); + } + return false; + } + function isOrHasGenericConditional(type) { + return !!(type.flags & 16777216 /* TypeFlags.Conditional */ || (type.flags & 2097152 /* TypeFlags.Intersection */ && ts.some(type.types, isOrHasGenericConditional))); + } + function elaborateError(node, source, target, relation, headMessage, containingMessageChain, errorOutputContainer) { + if (!node || isOrHasGenericConditional(target)) + return false; + if (!checkTypeRelatedTo(source, target, relation, /*errorNode*/ undefined) + && elaborateDidYouMeanToCallOrConstruct(node, source, target, relation, headMessage, containingMessageChain, errorOutputContainer)) { + return true; + } + switch (node.kind) { + case 291 /* SyntaxKind.JsxExpression */: + case 214 /* SyntaxKind.ParenthesizedExpression */: + return elaborateError(node.expression, source, target, relation, headMessage, containingMessageChain, errorOutputContainer); + case 223 /* SyntaxKind.BinaryExpression */: + switch (node.operatorToken.kind) { + case 63 /* SyntaxKind.EqualsToken */: + case 27 /* SyntaxKind.CommaToken */: + return elaborateError(node.right, source, target, relation, headMessage, containingMessageChain, errorOutputContainer); + } + break; + case 207 /* SyntaxKind.ObjectLiteralExpression */: + return elaborateObjectLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer); + case 206 /* SyntaxKind.ArrayLiteralExpression */: + return elaborateArrayLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer); + case 289 /* SyntaxKind.JsxAttributes */: + return elaborateJsxComponents(node, source, target, relation, containingMessageChain, errorOutputContainer); + case 216 /* SyntaxKind.ArrowFunction */: + return elaborateArrowFunction(node, source, target, relation, containingMessageChain, errorOutputContainer); + } + return false; + } + function elaborateDidYouMeanToCallOrConstruct(node, source, target, relation, headMessage, containingMessageChain, errorOutputContainer) { + var callSignatures = getSignaturesOfType(source, 0 /* SignatureKind.Call */); + var constructSignatures = getSignaturesOfType(source, 1 /* SignatureKind.Construct */); + for (var _i = 0, _a = [constructSignatures, callSignatures]; _i < _a.length; _i++) { + var signatures = _a[_i]; + if (ts.some(signatures, function (s) { + var returnType = getReturnTypeOfSignature(s); + return !(returnType.flags & (1 /* TypeFlags.Any */ | 131072 /* TypeFlags.Never */)) && checkTypeRelatedTo(returnType, target, relation, /*errorNode*/ undefined); + })) { + var resultObj = errorOutputContainer || {}; + checkTypeAssignableTo(source, target, node, headMessage, containingMessageChain, resultObj); + var diagnostic = resultObj.errors[resultObj.errors.length - 1]; + ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(node, signatures === constructSignatures ? ts.Diagnostics.Did_you_mean_to_use_new_with_this_expression : ts.Diagnostics.Did_you_mean_to_call_this_expression)); + return true; + } + } + return false; + } + function elaborateArrowFunction(node, source, target, relation, containingMessageChain, errorOutputContainer) { + // Don't elaborate blocks + if (ts.isBlock(node.body)) { + return false; + } + // Or functions with annotated parameter types + if (ts.some(node.parameters, ts.hasType)) { + return false; + } + var sourceSig = getSingleCallSignature(source); + if (!sourceSig) { + return false; + } + var targetSignatures = getSignaturesOfType(target, 0 /* SignatureKind.Call */); + if (!ts.length(targetSignatures)) { + return false; + } + var returnExpression = node.body; + var sourceReturn = getReturnTypeOfSignature(sourceSig); + var targetReturn = getUnionType(ts.map(targetSignatures, getReturnTypeOfSignature)); + if (!checkTypeRelatedTo(sourceReturn, targetReturn, relation, /*errorNode*/ undefined)) { + var elaborated = returnExpression && elaborateError(returnExpression, sourceReturn, targetReturn, relation, /*headMessage*/ undefined, containingMessageChain, errorOutputContainer); + if (elaborated) { + return elaborated; + } + var resultObj = errorOutputContainer || {}; + checkTypeRelatedTo(sourceReturn, targetReturn, relation, returnExpression, /*message*/ undefined, containingMessageChain, resultObj); + if (resultObj.errors) { + if (target.symbol && ts.length(target.symbol.declarations)) { + ts.addRelatedInfo(resultObj.errors[resultObj.errors.length - 1], ts.createDiagnosticForNode(target.symbol.declarations[0], ts.Diagnostics.The_expected_type_comes_from_the_return_type_of_this_signature)); + } + if ((ts.getFunctionFlags(node) & 2 /* FunctionFlags.Async */) === 0 + // exclude cases where source itself is promisy - this way we don't make a suggestion when relating + // an IPromise and a Promise that are slightly different + && !getTypeOfPropertyOfType(sourceReturn, "then") + && checkTypeRelatedTo(createPromiseType(sourceReturn), targetReturn, relation, /*errorNode*/ undefined)) { + ts.addRelatedInfo(resultObj.errors[resultObj.errors.length - 1], ts.createDiagnosticForNode(node, ts.Diagnostics.Did_you_mean_to_mark_this_function_as_async)); + } + return true; + } + } + return false; + } + function getBestMatchIndexedAccessTypeOrUndefined(source, target, nameType) { + var idx = getIndexedAccessTypeOrUndefined(target, nameType); + if (idx) { + return idx; + } + if (target.flags & 1048576 /* TypeFlags.Union */) { + var best = getBestMatchingType(source, target); + if (best) { + return getIndexedAccessTypeOrUndefined(best, nameType); + } + } + } + function checkExpressionForMutableLocationWithContextualType(next, sourcePropType) { + next.contextualType = sourcePropType; + try { + return checkExpressionForMutableLocation(next, 1 /* CheckMode.Contextual */, sourcePropType); + } + finally { + next.contextualType = undefined; + } + } + /** + * For every element returned from the iterator, checks that element to issue an error on a property of that element's type + * If that element would issue an error, we first attempt to dive into that element's inner expression and issue a more specific error by recuring into `elaborateError` + * Otherwise, we issue an error on _every_ element which fail the assignability check + */ + function elaborateElementwise(iterator, source, target, relation, containingMessageChain, errorOutputContainer) { + // Assignability failure - check each prop individually, and if that fails, fall back on the bad error span + var reportedError = false; + for (var status = iterator.next(); !status.done; status = iterator.next()) { + var _a = status.value, prop = _a.errorNode, next = _a.innerExpression, nameType = _a.nameType, errorMessage = _a.errorMessage; + var targetPropType = getBestMatchIndexedAccessTypeOrUndefined(source, target, nameType); + if (!targetPropType || targetPropType.flags & 8388608 /* TypeFlags.IndexedAccess */) + continue; // Don't elaborate on indexes on generic variables + var sourcePropType = getIndexedAccessTypeOrUndefined(source, nameType); + if (!sourcePropType) + continue; + var propName = getPropertyNameFromIndex(nameType, /*accessNode*/ undefined); + if (!checkTypeRelatedTo(sourcePropType, targetPropType, relation, /*errorNode*/ undefined)) { + var elaborated = next && elaborateError(next, sourcePropType, targetPropType, relation, /*headMessage*/ undefined, containingMessageChain, errorOutputContainer); + reportedError = true; + if (!elaborated) { + // Issue error on the prop itself, since the prop couldn't elaborate the error + var resultObj = errorOutputContainer || {}; + // Use the expression type, if available + var specificSource = next ? checkExpressionForMutableLocationWithContextualType(next, sourcePropType) : sourcePropType; + if (exactOptionalPropertyTypes && isExactOptionalPropertyMismatch(specificSource, targetPropType)) { + var diag = ts.createDiagnosticForNode(prop, ts.Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_type_of_the_target, typeToString(specificSource), typeToString(targetPropType)); + diagnostics.add(diag); + resultObj.errors = [diag]; + } + else { + var targetIsOptional = !!(propName && (getPropertyOfType(target, propName) || unknownSymbol).flags & 16777216 /* SymbolFlags.Optional */); + var sourceIsOptional = !!(propName && (getPropertyOfType(source, propName) || unknownSymbol).flags & 16777216 /* SymbolFlags.Optional */); + targetPropType = removeMissingType(targetPropType, targetIsOptional); + sourcePropType = removeMissingType(sourcePropType, targetIsOptional && sourceIsOptional); + var result = checkTypeRelatedTo(specificSource, targetPropType, relation, prop, errorMessage, containingMessageChain, resultObj); + if (result && specificSource !== sourcePropType) { + // If for whatever reason the expression type doesn't yield an error, make sure we still issue an error on the sourcePropType + checkTypeRelatedTo(sourcePropType, targetPropType, relation, prop, errorMessage, containingMessageChain, resultObj); + } + } + if (resultObj.errors) { + var reportedDiag = resultObj.errors[resultObj.errors.length - 1]; + var propertyName = isTypeUsableAsPropertyName(nameType) ? getPropertyNameFromType(nameType) : undefined; + var targetProp = propertyName !== undefined ? getPropertyOfType(target, propertyName) : undefined; + var issuedElaboration = false; + if (!targetProp) { + var indexInfo = getApplicableIndexInfo(target, nameType); + if (indexInfo && indexInfo.declaration && !ts.getSourceFileOfNode(indexInfo.declaration).hasNoDefaultLib) { + issuedElaboration = true; + ts.addRelatedInfo(reportedDiag, ts.createDiagnosticForNode(indexInfo.declaration, ts.Diagnostics.The_expected_type_comes_from_this_index_signature)); + } + } + if (!issuedElaboration && (targetProp && ts.length(targetProp.declarations) || target.symbol && ts.length(target.symbol.declarations))) { + var targetNode = targetProp && ts.length(targetProp.declarations) ? targetProp.declarations[0] : target.symbol.declarations[0]; + if (!ts.getSourceFileOfNode(targetNode).hasNoDefaultLib) { + ts.addRelatedInfo(reportedDiag, ts.createDiagnosticForNode(targetNode, ts.Diagnostics.The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1, propertyName && !(nameType.flags & 8192 /* TypeFlags.UniqueESSymbol */) ? ts.unescapeLeadingUnderscores(propertyName) : typeToString(nameType), typeToString(target))); + } + } + } + } + } + } + return reportedError; + } + function generateJsxAttributes(node) { + var _i, _a, prop; + return __generator(this, function (_b) { + switch (_b.label) { + case 0: + if (!ts.length(node.properties)) + return [2 /*return*/]; + _i = 0, _a = node.properties; + _b.label = 1; + case 1: + if (!(_i < _a.length)) return [3 /*break*/, 4]; + prop = _a[_i]; + if (ts.isJsxSpreadAttribute(prop) || isHyphenatedJsxName(ts.idText(prop.name))) + return [3 /*break*/, 3]; + return [4 /*yield*/, { errorNode: prop.name, innerExpression: prop.initializer, nameType: getStringLiteralType(ts.idText(prop.name)) }]; + case 2: + _b.sent(); + _b.label = 3; + case 3: + _i++; + return [3 /*break*/, 1]; + case 4: return [2 /*return*/]; + } + }); + } + function generateJsxChildren(node, getInvalidTextDiagnostic) { + var memberOffset, i, child, nameType, elem; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + if (!ts.length(node.children)) + return [2 /*return*/]; + memberOffset = 0; + i = 0; + _a.label = 1; + case 1: + if (!(i < node.children.length)) return [3 /*break*/, 5]; + child = node.children[i]; + nameType = getNumberLiteralType(i - memberOffset); + elem = getElaborationElementForJsxChild(child, nameType, getInvalidTextDiagnostic); + if (!elem) return [3 /*break*/, 3]; + return [4 /*yield*/, elem]; + case 2: + _a.sent(); + return [3 /*break*/, 4]; + case 3: + memberOffset++; + _a.label = 4; + case 4: + i++; + return [3 /*break*/, 1]; + case 5: return [2 /*return*/]; + } + }); + } + function getElaborationElementForJsxChild(child, nameType, getInvalidTextDiagnostic) { + switch (child.kind) { + case 291 /* SyntaxKind.JsxExpression */: + // child is of the type of the expression + return { errorNode: child, innerExpression: child.expression, nameType: nameType }; + case 11 /* SyntaxKind.JsxText */: + if (child.containsOnlyTriviaWhiteSpaces) { + break; // Whitespace only jsx text isn't real jsx text + } + // child is a string + return { errorNode: child, innerExpression: undefined, nameType: nameType, errorMessage: getInvalidTextDiagnostic() }; + case 281 /* SyntaxKind.JsxElement */: + case 282 /* SyntaxKind.JsxSelfClosingElement */: + case 285 /* SyntaxKind.JsxFragment */: + // child is of type JSX.Element + return { errorNode: child, innerExpression: child, nameType: nameType }; + default: + return ts.Debug.assertNever(child, "Found invalid jsx child"); + } + } + function elaborateJsxComponents(node, source, target, relation, containingMessageChain, errorOutputContainer) { + var result = elaborateElementwise(generateJsxAttributes(node), source, target, relation, containingMessageChain, errorOutputContainer); + var invalidTextDiagnostic; + if (ts.isJsxOpeningElement(node.parent) && ts.isJsxElement(node.parent.parent)) { + var containingElement = node.parent.parent; + var childPropName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node)); + var childrenPropName = childPropName === undefined ? "children" : ts.unescapeLeadingUnderscores(childPropName); + var childrenNameType = getStringLiteralType(childrenPropName); + var childrenTargetType = getIndexedAccessType(target, childrenNameType); + var validChildren = ts.getSemanticJsxChildren(containingElement.children); + if (!ts.length(validChildren)) { + return result; + } + var moreThanOneRealChildren = ts.length(validChildren) > 1; + var arrayLikeTargetParts = filterType(childrenTargetType, isArrayOrTupleLikeType); + var nonArrayLikeTargetParts = filterType(childrenTargetType, function (t) { return !isArrayOrTupleLikeType(t); }); + if (moreThanOneRealChildren) { + if (arrayLikeTargetParts !== neverType) { + var realSource = createTupleType(checkJsxChildren(containingElement, 0 /* CheckMode.Normal */)); + var children = generateJsxChildren(containingElement, getInvalidTextualChildDiagnostic); + result = elaborateElementwise(children, realSource, arrayLikeTargetParts, relation, containingMessageChain, errorOutputContainer) || result; + } + else if (!isTypeRelatedTo(getIndexedAccessType(source, childrenNameType), childrenTargetType, relation)) { + // arity mismatch + result = true; + var diag = error(containingElement.openingElement.tagName, ts.Diagnostics.This_JSX_tag_s_0_prop_expects_a_single_child_of_type_1_but_multiple_children_were_provided, childrenPropName, typeToString(childrenTargetType)); + if (errorOutputContainer && errorOutputContainer.skipLogging) { + (errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag); + } + } + } + else { + if (nonArrayLikeTargetParts !== neverType) { + var child = validChildren[0]; + var elem_1 = getElaborationElementForJsxChild(child, childrenNameType, getInvalidTextualChildDiagnostic); + if (elem_1) { + result = elaborateElementwise((function () { return __generator(this, function (_a) { + switch (_a.label) { + case 0: return [4 /*yield*/, elem_1]; + case 1: + _a.sent(); + return [2 /*return*/]; + } + }); })(), source, target, relation, containingMessageChain, errorOutputContainer) || result; + } + } + else if (!isTypeRelatedTo(getIndexedAccessType(source, childrenNameType), childrenTargetType, relation)) { + // arity mismatch + result = true; + var diag = error(containingElement.openingElement.tagName, ts.Diagnostics.This_JSX_tag_s_0_prop_expects_type_1_which_requires_multiple_children_but_only_a_single_child_was_provided, childrenPropName, typeToString(childrenTargetType)); + if (errorOutputContainer && errorOutputContainer.skipLogging) { + (errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag); + } + } + } + } + return result; + function getInvalidTextualChildDiagnostic() { + if (!invalidTextDiagnostic) { + var tagNameText = ts.getTextOfNode(node.parent.tagName); + var childPropName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node)); + var childrenPropName = childPropName === undefined ? "children" : ts.unescapeLeadingUnderscores(childPropName); + var childrenTargetType = getIndexedAccessType(target, getStringLiteralType(childrenPropName)); + var diagnostic = ts.Diagnostics._0_components_don_t_accept_text_as_child_elements_Text_in_JSX_has_the_type_string_but_the_expected_type_of_1_is_2; + invalidTextDiagnostic = __assign(__assign({}, diagnostic), { key: "!!ALREADY FORMATTED!!", message: ts.formatMessage(/*_dummy*/ undefined, diagnostic, tagNameText, childrenPropName, typeToString(childrenTargetType)) }); + } + return invalidTextDiagnostic; + } + } + function generateLimitedTupleElements(node, target) { + var len, i, elem, nameType; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + len = ts.length(node.elements); + if (!len) + return [2 /*return*/]; + i = 0; + _a.label = 1; + case 1: + if (!(i < len)) return [3 /*break*/, 4]; + // Skip elements which do not exist in the target - a length error on the tuple overall is likely better than an error on a mismatched index signature + if (isTupleLikeType(target) && !getPropertyOfType(target, ("" + i))) + return [3 /*break*/, 3]; + elem = node.elements[i]; + if (ts.isOmittedExpression(elem)) + return [3 /*break*/, 3]; + nameType = getNumberLiteralType(i); + return [4 /*yield*/, { errorNode: elem, innerExpression: elem, nameType: nameType }]; + case 2: + _a.sent(); + _a.label = 3; + case 3: + i++; + return [3 /*break*/, 1]; + case 4: return [2 /*return*/]; + } + }); + } + function elaborateArrayLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) { + if (target.flags & (131068 /* TypeFlags.Primitive */ | 131072 /* TypeFlags.Never */)) + return false; + if (isTupleLikeType(source)) { + return elaborateElementwise(generateLimitedTupleElements(node, target), source, target, relation, containingMessageChain, errorOutputContainer); + } + // recreate a tuple from the elements, if possible + // Since we're re-doing the expression type, we need to reapply the contextual type + var oldContext = node.contextualType; + node.contextualType = target; + try { + var tupleizedType = checkArrayLiteral(node, 1 /* CheckMode.Contextual */, /*forceTuple*/ true); + node.contextualType = oldContext; + if (isTupleLikeType(tupleizedType)) { + return elaborateElementwise(generateLimitedTupleElements(node, target), tupleizedType, target, relation, containingMessageChain, errorOutputContainer); + } + return false; + } + finally { + node.contextualType = oldContext; + } + } + function generateObjectLiteralElements(node) { + var _i, _a, prop, type, _b; + return __generator(this, function (_c) { + switch (_c.label) { + case 0: + if (!ts.length(node.properties)) + return [2 /*return*/]; + _i = 0, _a = node.properties; + _c.label = 1; + case 1: + if (!(_i < _a.length)) return [3 /*break*/, 8]; + prop = _a[_i]; + if (ts.isSpreadAssignment(prop)) + return [3 /*break*/, 7]; + type = getLiteralTypeFromProperty(getSymbolOfNode(prop), 8576 /* TypeFlags.StringOrNumberLiteralOrUnique */); + if (!type || (type.flags & 131072 /* TypeFlags.Never */)) { + return [3 /*break*/, 7]; + } + _b = prop.kind; + switch (_b) { + case 175 /* SyntaxKind.SetAccessor */: return [3 /*break*/, 2]; + case 174 /* SyntaxKind.GetAccessor */: return [3 /*break*/, 2]; + case 171 /* SyntaxKind.MethodDeclaration */: return [3 /*break*/, 2]; + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: return [3 /*break*/, 2]; + case 299 /* SyntaxKind.PropertyAssignment */: return [3 /*break*/, 4]; + } + return [3 /*break*/, 6]; + case 2: return [4 /*yield*/, { errorNode: prop.name, innerExpression: undefined, nameType: type }]; + case 3: + _c.sent(); + return [3 /*break*/, 7]; + case 4: return [4 /*yield*/, { errorNode: prop.name, innerExpression: prop.initializer, nameType: type, errorMessage: ts.isComputedNonLiteralName(prop.name) ? ts.Diagnostics.Type_of_computed_property_s_value_is_0_which_is_not_assignable_to_type_1 : undefined }]; + case 5: + _c.sent(); + return [3 /*break*/, 7]; + case 6: + ts.Debug.assertNever(prop); + _c.label = 7; + case 7: + _i++; + return [3 /*break*/, 1]; + case 8: return [2 /*return*/]; + } + }); + } + function elaborateObjectLiteral(node, source, target, relation, containingMessageChain, errorOutputContainer) { + if (target.flags & (131068 /* TypeFlags.Primitive */ | 131072 /* TypeFlags.Never */)) + return false; + return elaborateElementwise(generateObjectLiteralElements(node), source, target, relation, containingMessageChain, errorOutputContainer); + } + /** + * This is *not* a bi-directional relationship. + * If one needs to check both directions for comparability, use a second call to this function or 'isTypeComparableTo'. + */ + function checkTypeComparableTo(source, target, errorNode, headMessage, containingMessageChain) { + return checkTypeRelatedTo(source, target, comparableRelation, errorNode, headMessage, containingMessageChain); + } + function isSignatureAssignableTo(source, target, ignoreReturnTypes) { + return compareSignaturesRelated(source, target, ignoreReturnTypes ? 4 /* SignatureCheckMode.IgnoreReturnTypes */ : 0, /*reportErrors*/ false, + /*errorReporter*/ undefined, /*errorReporter*/ undefined, compareTypesAssignable, /*reportUnreliableMarkers*/ undefined) !== 0 /* Ternary.False */; + } + /** + * Returns true if `s` is `(...args: any[]) => any` or `(this: any, ...args: any[]) => any` + */ + function isAnySignature(s) { + return !s.typeParameters && (!s.thisParameter || isTypeAny(getTypeOfParameter(s.thisParameter))) && s.parameters.length === 1 && + signatureHasRestParameter(s) && (getTypeOfParameter(s.parameters[0]) === anyArrayType || isTypeAny(getTypeOfParameter(s.parameters[0]))) && + isTypeAny(getReturnTypeOfSignature(s)); + } + /** + * See signatureRelatedTo, compareSignaturesIdentical + */ + function compareSignaturesRelated(source, target, checkMode, reportErrors, errorReporter, incompatibleErrorReporter, compareTypes, reportUnreliableMarkers) { + // TODO (drosen): De-duplicate code between related functions. + if (source === target) { + return -1 /* Ternary.True */; + } + if (isAnySignature(target)) { + return -1 /* Ternary.True */; + } + var targetCount = getParameterCount(target); + var sourceHasMoreParameters = !hasEffectiveRestParameter(target) && + (checkMode & 8 /* SignatureCheckMode.StrictArity */ ? hasEffectiveRestParameter(source) || getParameterCount(source) > targetCount : getMinArgumentCount(source) > targetCount); + if (sourceHasMoreParameters) { + return 0 /* Ternary.False */; + } + if (source.typeParameters && source.typeParameters !== target.typeParameters) { + target = getCanonicalSignature(target); + source = instantiateSignatureInContextOf(source, target, /*inferenceContext*/ undefined, compareTypes); + } + var sourceCount = getParameterCount(source); + var sourceRestType = getNonArrayRestType(source); + var targetRestType = getNonArrayRestType(target); + if (sourceRestType || targetRestType) { + void instantiateType(sourceRestType || targetRestType, reportUnreliableMarkers); + } + var kind = target.declaration ? target.declaration.kind : 0 /* SyntaxKind.Unknown */; + var strictVariance = !(checkMode & 3 /* SignatureCheckMode.Callback */) && strictFunctionTypes && kind !== 171 /* SyntaxKind.MethodDeclaration */ && + kind !== 170 /* SyntaxKind.MethodSignature */ && kind !== 173 /* SyntaxKind.Constructor */; + var result = -1 /* Ternary.True */; + var sourceThisType = getThisTypeOfSignature(source); + if (sourceThisType && sourceThisType !== voidType) { + var targetThisType = getThisTypeOfSignature(target); + if (targetThisType) { + // void sources are assignable to anything. + var related = !strictVariance && compareTypes(sourceThisType, targetThisType, /*reportErrors*/ false) + || compareTypes(targetThisType, sourceThisType, reportErrors); + if (!related) { + if (reportErrors) { + errorReporter(ts.Diagnostics.The_this_types_of_each_signature_are_incompatible); + } + return 0 /* Ternary.False */; + } + result &= related; + } + } + var paramCount = sourceRestType || targetRestType ? Math.min(sourceCount, targetCount) : Math.max(sourceCount, targetCount); + var restIndex = sourceRestType || targetRestType ? paramCount - 1 : -1; + for (var i = 0; i < paramCount; i++) { + var sourceType = i === restIndex ? getRestTypeAtPosition(source, i) : tryGetTypeAtPosition(source, i); + var targetType = i === restIndex ? getRestTypeAtPosition(target, i) : tryGetTypeAtPosition(target, i); + if (sourceType && targetType) { + // In order to ensure that any generic type Foo is at least co-variant with respect to T no matter + // how Foo uses T, we need to relate parameters bi-variantly (given that parameters are input positions, + // they naturally relate only contra-variantly). However, if the source and target parameters both have + // function types with a single call signature, we know we are relating two callback parameters. In + // that case it is sufficient to only relate the parameters of the signatures co-variantly because, + // similar to return values, callback parameters are output positions. This means that a Promise, + // where T is used only in callback parameter positions, will be co-variant (as opposed to bi-variant) + // with respect to T. + var sourceSig = checkMode & 3 /* SignatureCheckMode.Callback */ ? undefined : getSingleCallSignature(getNonNullableType(sourceType)); + var targetSig = checkMode & 3 /* SignatureCheckMode.Callback */ ? undefined : getSingleCallSignature(getNonNullableType(targetType)); + var callbacks = sourceSig && targetSig && !getTypePredicateOfSignature(sourceSig) && !getTypePredicateOfSignature(targetSig) && + (getTypeFacts(sourceType) & 50331648 /* TypeFacts.IsUndefinedOrNull */) === (getTypeFacts(targetType) & 50331648 /* TypeFacts.IsUndefinedOrNull */); + var related = callbacks ? + compareSignaturesRelated(targetSig, sourceSig, (checkMode & 8 /* SignatureCheckMode.StrictArity */) | (strictVariance ? 2 /* SignatureCheckMode.StrictCallback */ : 1 /* SignatureCheckMode.BivariantCallback */), reportErrors, errorReporter, incompatibleErrorReporter, compareTypes, reportUnreliableMarkers) : + !(checkMode & 3 /* SignatureCheckMode.Callback */) && !strictVariance && compareTypes(sourceType, targetType, /*reportErrors*/ false) || compareTypes(targetType, sourceType, reportErrors); + // With strict arity, (x: number | undefined) => void is a subtype of (x?: number | undefined) => void + if (related && checkMode & 8 /* SignatureCheckMode.StrictArity */ && i >= getMinArgumentCount(source) && i < getMinArgumentCount(target) && compareTypes(sourceType, targetType, /*reportErrors*/ false)) { + related = 0 /* Ternary.False */; + } + if (!related) { + if (reportErrors) { + errorReporter(ts.Diagnostics.Types_of_parameters_0_and_1_are_incompatible, ts.unescapeLeadingUnderscores(getParameterNameAtPosition(source, i)), ts.unescapeLeadingUnderscores(getParameterNameAtPosition(target, i))); + } + return 0 /* Ternary.False */; + } + result &= related; + } + } + if (!(checkMode & 4 /* SignatureCheckMode.IgnoreReturnTypes */)) { + // If a signature resolution is already in-flight, skip issuing a circularity error + // here and just use the `any` type directly + var targetReturnType = isResolvingReturnTypeOfSignature(target) ? anyType + : target.declaration && isJSConstructor(target.declaration) ? getDeclaredTypeOfClassOrInterface(getMergedSymbol(target.declaration.symbol)) + : getReturnTypeOfSignature(target); + if (targetReturnType === voidType || targetReturnType === anyType) { + return result; + } + var sourceReturnType = isResolvingReturnTypeOfSignature(source) ? anyType + : source.declaration && isJSConstructor(source.declaration) ? getDeclaredTypeOfClassOrInterface(getMergedSymbol(source.declaration.symbol)) + : getReturnTypeOfSignature(source); + // The following block preserves behavior forbidding boolean returning functions from being assignable to type guard returning functions + var targetTypePredicate = getTypePredicateOfSignature(target); + if (targetTypePredicate) { + var sourceTypePredicate = getTypePredicateOfSignature(source); + if (sourceTypePredicate) { + result &= compareTypePredicateRelatedTo(sourceTypePredicate, targetTypePredicate, reportErrors, errorReporter, compareTypes); + } + else if (ts.isIdentifierTypePredicate(targetTypePredicate)) { + if (reportErrors) { + errorReporter(ts.Diagnostics.Signature_0_must_be_a_type_predicate, signatureToString(source)); + } + return 0 /* Ternary.False */; + } + } + else { + // When relating callback signatures, we still need to relate return types bi-variantly as otherwise + // the containing type wouldn't be co-variant. For example, interface Foo { add(cb: () => T): void } + // wouldn't be co-variant for T without this rule. + result &= checkMode & 1 /* SignatureCheckMode.BivariantCallback */ && compareTypes(targetReturnType, sourceReturnType, /*reportErrors*/ false) || + compareTypes(sourceReturnType, targetReturnType, reportErrors); + if (!result && reportErrors && incompatibleErrorReporter) { + incompatibleErrorReporter(sourceReturnType, targetReturnType); + } + } + } + return result; + } + function compareTypePredicateRelatedTo(source, target, reportErrors, errorReporter, compareTypes) { + if (source.kind !== target.kind) { + if (reportErrors) { + errorReporter(ts.Diagnostics.A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard); + errorReporter(ts.Diagnostics.Type_predicate_0_is_not_assignable_to_1, typePredicateToString(source), typePredicateToString(target)); + } + return 0 /* Ternary.False */; + } + if (source.kind === 1 /* TypePredicateKind.Identifier */ || source.kind === 3 /* TypePredicateKind.AssertsIdentifier */) { + if (source.parameterIndex !== target.parameterIndex) { + if (reportErrors) { + errorReporter(ts.Diagnostics.Parameter_0_is_not_in_the_same_position_as_parameter_1, source.parameterName, target.parameterName); + errorReporter(ts.Diagnostics.Type_predicate_0_is_not_assignable_to_1, typePredicateToString(source), typePredicateToString(target)); + } + return 0 /* Ternary.False */; + } + } + var related = source.type === target.type ? -1 /* Ternary.True */ : + source.type && target.type ? compareTypes(source.type, target.type, reportErrors) : + 0 /* Ternary.False */; + if (related === 0 /* Ternary.False */ && reportErrors) { + errorReporter(ts.Diagnostics.Type_predicate_0_is_not_assignable_to_1, typePredicateToString(source), typePredicateToString(target)); + } + return related; + } + function isImplementationCompatibleWithOverload(implementation, overload) { + var erasedSource = getErasedSignature(implementation); + var erasedTarget = getErasedSignature(overload); + // First see if the return types are compatible in either direction. + var sourceReturnType = getReturnTypeOfSignature(erasedSource); + var targetReturnType = getReturnTypeOfSignature(erasedTarget); + if (targetReturnType === voidType + || isTypeRelatedTo(targetReturnType, sourceReturnType, assignableRelation) + || isTypeRelatedTo(sourceReturnType, targetReturnType, assignableRelation)) { + return isSignatureAssignableTo(erasedSource, erasedTarget, /*ignoreReturnTypes*/ true); + } + return false; + } + function isEmptyResolvedType(t) { + return t !== anyFunctionType && + t.properties.length === 0 && + t.callSignatures.length === 0 && + t.constructSignatures.length === 0 && + t.indexInfos.length === 0; + } + function isEmptyObjectType(type) { + return type.flags & 524288 /* TypeFlags.Object */ ? !isGenericMappedType(type) && isEmptyResolvedType(resolveStructuredTypeMembers(type)) : + type.flags & 67108864 /* TypeFlags.NonPrimitive */ ? true : + type.flags & 1048576 /* TypeFlags.Union */ ? ts.some(type.types, isEmptyObjectType) : + type.flags & 2097152 /* TypeFlags.Intersection */ ? ts.every(type.types, isEmptyObjectType) : + false; + } + function isEmptyAnonymousObjectType(type) { + return !!(ts.getObjectFlags(type) & 16 /* ObjectFlags.Anonymous */ && (type.members && isEmptyResolvedType(type) || + type.symbol && type.symbol.flags & 2048 /* SymbolFlags.TypeLiteral */ && getMembersOfSymbol(type.symbol).size === 0)); + } + function isUnknownLikeUnionType(type) { + if (strictNullChecks && type.flags & 1048576 /* TypeFlags.Union */) { + if (!(type.objectFlags & 33554432 /* ObjectFlags.IsUnknownLikeUnionComputed */)) { + var types = type.types; + type.objectFlags |= 33554432 /* ObjectFlags.IsUnknownLikeUnionComputed */ | (types.length >= 3 && types[0].flags & 32768 /* TypeFlags.Undefined */ && + types[1].flags & 65536 /* TypeFlags.Null */ && ts.some(types, isEmptyAnonymousObjectType) ? 67108864 /* ObjectFlags.IsUnknownLikeUnion */ : 0); + } + return !!(type.objectFlags & 67108864 /* ObjectFlags.IsUnknownLikeUnion */); + } + return false; + } + function containsUndefinedType(type) { + return !!((type.flags & 1048576 /* TypeFlags.Union */ ? type.types[0] : type).flags & 32768 /* TypeFlags.Undefined */); + } + function isStringIndexSignatureOnlyType(type) { + return type.flags & 524288 /* TypeFlags.Object */ && !isGenericMappedType(type) && getPropertiesOfType(type).length === 0 && getIndexInfosOfType(type).length === 1 && !!getIndexInfoOfType(type, stringType) || + type.flags & 3145728 /* TypeFlags.UnionOrIntersection */ && ts.every(type.types, isStringIndexSignatureOnlyType) || + false; + } + function isEnumTypeRelatedTo(sourceSymbol, targetSymbol, errorReporter) { + if (sourceSymbol === targetSymbol) { + return true; + } + var id = getSymbolId(sourceSymbol) + "," + getSymbolId(targetSymbol); + var entry = enumRelation.get(id); + if (entry !== undefined && !(!(entry & 4 /* RelationComparisonResult.Reported */) && entry & 2 /* RelationComparisonResult.Failed */ && errorReporter)) { + return !!(entry & 1 /* RelationComparisonResult.Succeeded */); + } + if (sourceSymbol.escapedName !== targetSymbol.escapedName || !(sourceSymbol.flags & 256 /* SymbolFlags.RegularEnum */) || !(targetSymbol.flags & 256 /* SymbolFlags.RegularEnum */)) { + enumRelation.set(id, 2 /* RelationComparisonResult.Failed */ | 4 /* RelationComparisonResult.Reported */); + return false; + } + var targetEnumType = getTypeOfSymbol(targetSymbol); + for (var _i = 0, _a = getPropertiesOfType(getTypeOfSymbol(sourceSymbol)); _i < _a.length; _i++) { + var property = _a[_i]; + if (property.flags & 8 /* SymbolFlags.EnumMember */) { + var targetProperty = getPropertyOfType(targetEnumType, property.escapedName); + if (!targetProperty || !(targetProperty.flags & 8 /* SymbolFlags.EnumMember */)) { + if (errorReporter) { + errorReporter(ts.Diagnostics.Property_0_is_missing_in_type_1, ts.symbolName(property), typeToString(getDeclaredTypeOfSymbol(targetSymbol), /*enclosingDeclaration*/ undefined, 64 /* TypeFormatFlags.UseFullyQualifiedType */)); + enumRelation.set(id, 2 /* RelationComparisonResult.Failed */ | 4 /* RelationComparisonResult.Reported */); + } + else { + enumRelation.set(id, 2 /* RelationComparisonResult.Failed */); + } + return false; + } + } + } + enumRelation.set(id, 1 /* RelationComparisonResult.Succeeded */); + return true; + } + function isSimpleTypeRelatedTo(source, target, relation, errorReporter) { + var s = source.flags; + var t = target.flags; + if (t & 3 /* TypeFlags.AnyOrUnknown */ || s & 131072 /* TypeFlags.Never */ || source === wildcardType) + return true; + if (t & 131072 /* TypeFlags.Never */) + return false; + if (s & 402653316 /* TypeFlags.StringLike */ && t & 4 /* TypeFlags.String */) + return true; + if (s & 128 /* TypeFlags.StringLiteral */ && s & 1024 /* TypeFlags.EnumLiteral */ && + t & 128 /* TypeFlags.StringLiteral */ && !(t & 1024 /* TypeFlags.EnumLiteral */) && + source.value === target.value) + return true; + if (s & 296 /* TypeFlags.NumberLike */ && t & 8 /* TypeFlags.Number */) + return true; + if (s & 256 /* TypeFlags.NumberLiteral */ && s & 1024 /* TypeFlags.EnumLiteral */ && + t & 256 /* TypeFlags.NumberLiteral */ && !(t & 1024 /* TypeFlags.EnumLiteral */) && + source.value === target.value) + return true; + if (s & 2112 /* TypeFlags.BigIntLike */ && t & 64 /* TypeFlags.BigInt */) + return true; + if (s & 528 /* TypeFlags.BooleanLike */ && t & 16 /* TypeFlags.Boolean */) + return true; + if (s & 12288 /* TypeFlags.ESSymbolLike */ && t & 4096 /* TypeFlags.ESSymbol */) + return true; + if (s & 32 /* TypeFlags.Enum */ && t & 32 /* TypeFlags.Enum */ && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter)) + return true; + if (s & 1024 /* TypeFlags.EnumLiteral */ && t & 1024 /* TypeFlags.EnumLiteral */) { + if (s & 1048576 /* TypeFlags.Union */ && t & 1048576 /* TypeFlags.Union */ && isEnumTypeRelatedTo(source.symbol, target.symbol, errorReporter)) + return true; + if (s & 2944 /* TypeFlags.Literal */ && t & 2944 /* TypeFlags.Literal */ && + source.value === target.value && + isEnumTypeRelatedTo(getParentOfSymbol(source.symbol), getParentOfSymbol(target.symbol), errorReporter)) + return true; + } + // In non-strictNullChecks mode, `undefined` and `null` are assignable to anything except `never`. + // Since unions and intersections may reduce to `never`, we exclude them here. + if (s & 32768 /* TypeFlags.Undefined */ && (!strictNullChecks && !(t & 3145728 /* TypeFlags.UnionOrIntersection */) || t & (32768 /* TypeFlags.Undefined */ | 16384 /* TypeFlags.Void */))) + return true; + if (s & 65536 /* TypeFlags.Null */ && (!strictNullChecks && !(t & 3145728 /* TypeFlags.UnionOrIntersection */) || t & 65536 /* TypeFlags.Null */)) + return true; + if (s & 524288 /* TypeFlags.Object */ && t & 67108864 /* TypeFlags.NonPrimitive */ && !(relation === strictSubtypeRelation && isEmptyAnonymousObjectType(source) && !(ts.getObjectFlags(source) & 8192 /* ObjectFlags.FreshLiteral */))) + return true; + if (relation === assignableRelation || relation === comparableRelation) { + if (s & 1 /* TypeFlags.Any */) + return true; + // Type number or any numeric literal type is assignable to any numeric enum type or any + // numeric enum literal type. This rule exists for backwards compatibility reasons because + // bit-flag enum types sometimes look like literal enum types with numeric literal values. + if (s & (8 /* TypeFlags.Number */ | 256 /* TypeFlags.NumberLiteral */) && !(s & 1024 /* TypeFlags.EnumLiteral */) && (t & 32 /* TypeFlags.Enum */ || relation === assignableRelation && t & 256 /* TypeFlags.NumberLiteral */ && t & 1024 /* TypeFlags.EnumLiteral */)) + return true; + // Anything is assignable to a union containing undefined, null, and {} + if (isUnknownLikeUnionType(target)) + return true; + } + return false; + } + function isTypeRelatedTo(source, target, relation) { + if (isFreshLiteralType(source)) { + source = source.regularType; + } + if (isFreshLiteralType(target)) { + target = target.regularType; + } + if (source === target) { + return true; + } + if (relation !== identityRelation) { + if (relation === comparableRelation && !(target.flags & 131072 /* TypeFlags.Never */) && isSimpleTypeRelatedTo(target, source, relation) || isSimpleTypeRelatedTo(source, target, relation)) { + return true; + } + } + else if (!((source.flags | target.flags) & (3145728 /* TypeFlags.UnionOrIntersection */ | 8388608 /* TypeFlags.IndexedAccess */ | 16777216 /* TypeFlags.Conditional */ | 33554432 /* TypeFlags.Substitution */))) { + // We have excluded types that may simplify to other forms, so types must have identical flags + if (source.flags !== target.flags) + return false; + if (source.flags & 67358815 /* TypeFlags.Singleton */) + return true; + } + if (source.flags & 524288 /* TypeFlags.Object */ && target.flags & 524288 /* TypeFlags.Object */) { + var related = relation.get(getRelationKey(source, target, 0 /* IntersectionState.None */, relation, /*ignoreConstraints*/ false)); + if (related !== undefined) { + return !!(related & 1 /* RelationComparisonResult.Succeeded */); + } + } + if (source.flags & 469499904 /* TypeFlags.StructuredOrInstantiable */ || target.flags & 469499904 /* TypeFlags.StructuredOrInstantiable */) { + return checkTypeRelatedTo(source, target, relation, /*errorNode*/ undefined); + } + return false; + } + function isIgnoredJsxProperty(source, sourceProp) { + return ts.getObjectFlags(source) & 2048 /* ObjectFlags.JsxAttributes */ && isHyphenatedJsxName(sourceProp.escapedName); + } + function getNormalizedType(type, writing) { + while (true) { + var t = isFreshLiteralType(type) ? type.regularType : + ts.getObjectFlags(type) & 4 /* ObjectFlags.Reference */ ? type.node ? createTypeReference(type.target, getTypeArguments(type)) : getSingleBaseForNonAugmentingSubtype(type) || type : + type.flags & 3145728 /* TypeFlags.UnionOrIntersection */ ? getNormalizedUnionOrIntersectionType(type, writing) : + type.flags & 33554432 /* TypeFlags.Substitution */ ? writing ? type.baseType : getSubstitutionIntersection(type) : + type.flags & 25165824 /* TypeFlags.Simplifiable */ ? getSimplifiedType(type, writing) : + type; + if (t === type) + return t; + type = t; + } + } + function getNormalizedUnionOrIntersectionType(type, writing) { + var reduced = getReducedType(type); + if (reduced !== type) { + return reduced; + } + if (type.flags & 2097152 /* TypeFlags.Intersection */ && ts.some(type.types, isEmptyAnonymousObjectType)) { + var normalizedTypes = ts.sameMap(type.types, function (t) { return getNormalizedType(t, writing); }); + if (normalizedTypes !== type.types) { + return getIntersectionType(normalizedTypes); + } + } + return type; + } + /** + * Checks if 'source' is related to 'target' (e.g.: is a assignable to). + * @param source The left-hand-side of the relation. + * @param target The right-hand-side of the relation. + * @param relation The relation considered. One of 'identityRelation', 'subtypeRelation', 'assignableRelation', or 'comparableRelation'. + * Used as both to determine which checks are performed and as a cache of previously computed results. + * @param errorNode The suggested node upon which all errors will be reported, if defined. This may or may not be the actual node used. + * @param headMessage If the error chain should be prepended by a head message, then headMessage will be used. + * @param containingMessageChain A chain of errors to prepend any new errors found. + * @param errorOutputContainer Return the diagnostic. Do not log if 'skipLogging' is truthy. + */ + function checkTypeRelatedTo(source, target, relation, errorNode, headMessage, containingMessageChain, errorOutputContainer) { + var errorInfo; + var relatedInfo; + var maybeKeys; + var sourceStack; + var targetStack; + var maybeCount = 0; + var sourceDepth = 0; + var targetDepth = 0; + var expandingFlags = 0 /* ExpandingFlags.None */; + var overflow = false; + var overrideNextErrorInfo = 0; // How many `reportRelationError` calls should be skipped in the elaboration pyramid + var lastSkippedInfo; + var incompatibleStack; + var inPropertyCheck = false; + ts.Debug.assert(relation !== identityRelation || !errorNode, "no error reporting in identity checking"); + var result = isRelatedTo(source, target, 3 /* RecursionFlags.Both */, /*reportErrors*/ !!errorNode, headMessage); + if (incompatibleStack) { + reportIncompatibleStack(); + } + if (overflow) { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes" /* tracing.Phase.CheckTypes */, "checkTypeRelatedTo_DepthLimit", { sourceId: source.id, targetId: target.id, depth: sourceDepth, targetDepth: targetDepth }); + var diag = error(errorNode || currentNode, ts.Diagnostics.Excessive_stack_depth_comparing_types_0_and_1, typeToString(source), typeToString(target)); + if (errorOutputContainer) { + (errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag); + } + } + else if (errorInfo) { + if (containingMessageChain) { + var chain = containingMessageChain(); + if (chain) { + ts.concatenateDiagnosticMessageChains(chain, errorInfo); + errorInfo = chain; + } + } + var relatedInformation = void 0; + // Check if we should issue an extra diagnostic to produce a quickfix for a slightly incorrect import statement + if (headMessage && errorNode && !result && source.symbol) { + var links = getSymbolLinks(source.symbol); + if (links.originatingImport && !ts.isImportCall(links.originatingImport)) { + var helpfulRetry = checkTypeRelatedTo(getTypeOfSymbol(links.target), target, relation, /*errorNode*/ undefined); + if (helpfulRetry) { + // Likely an incorrect import. Issue a helpful diagnostic to produce a quickfix to change the import + var diag_1 = ts.createDiagnosticForNode(links.originatingImport, ts.Diagnostics.Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cause_a_failure_at_runtime_Consider_using_a_default_import_or_import_require_here_instead); + relatedInformation = ts.append(relatedInformation, diag_1); // Cause the error to appear with the error that triggered it + } + } + } + var diag = ts.createDiagnosticForNodeFromMessageChain(errorNode, errorInfo, relatedInformation); + if (relatedInfo) { + ts.addRelatedInfo.apply(void 0, __spreadArray([diag], relatedInfo, false)); + } + if (errorOutputContainer) { + (errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag); + } + if (!errorOutputContainer || !errorOutputContainer.skipLogging) { + diagnostics.add(diag); + } + } + if (errorNode && errorOutputContainer && errorOutputContainer.skipLogging && result === 0 /* Ternary.False */) { + ts.Debug.assert(!!errorOutputContainer.errors, "missed opportunity to interact with error."); + } + return result !== 0 /* Ternary.False */; + function resetErrorInfo(saved) { + errorInfo = saved.errorInfo; + lastSkippedInfo = saved.lastSkippedInfo; + incompatibleStack = saved.incompatibleStack; + overrideNextErrorInfo = saved.overrideNextErrorInfo; + relatedInfo = saved.relatedInfo; + } + function captureErrorCalculationState() { + return { + errorInfo: errorInfo, + lastSkippedInfo: lastSkippedInfo, + incompatibleStack: incompatibleStack === null || incompatibleStack === void 0 ? void 0 : incompatibleStack.slice(), + overrideNextErrorInfo: overrideNextErrorInfo, + relatedInfo: relatedInfo === null || relatedInfo === void 0 ? void 0 : relatedInfo.slice(), + }; + } + function reportIncompatibleError(message, arg0, arg1, arg2, arg3) { + overrideNextErrorInfo++; // Suppress the next relation error + lastSkippedInfo = undefined; // Reset skipped info cache + (incompatibleStack || (incompatibleStack = [])).push([message, arg0, arg1, arg2, arg3]); + } + function reportIncompatibleStack() { + var stack = incompatibleStack || []; + incompatibleStack = undefined; + var info = lastSkippedInfo; + lastSkippedInfo = undefined; + if (stack.length === 1) { + reportError.apply(void 0, stack[0]); + if (info) { + // Actually do the last relation error + reportRelationError.apply(void 0, __spreadArray([/*headMessage*/ undefined], info, false)); + } + return; + } + // The first error will be the innermost, while the last will be the outermost - so by popping off the end, + // we can build from left to right + var path = ""; + var secondaryRootErrors = []; + while (stack.length) { + var _a = stack.pop(), msg = _a[0], args = _a.slice(1); + switch (msg.code) { + case ts.Diagnostics.Types_of_property_0_are_incompatible.code: { + // Parenthesize a `new` if there is one + if (path.indexOf("new ") === 0) { + path = "(".concat(path, ")"); + } + var str = "" + args[0]; + // If leading, just print back the arg (irrespective of if it's a valid identifier) + if (path.length === 0) { + path = "".concat(str); + } + // Otherwise write a dotted name if possible + else if (ts.isIdentifierText(str, ts.getEmitScriptTarget(compilerOptions))) { + path = "".concat(path, ".").concat(str); + } + // Failing that, check if the name is already a computed name + else if (str[0] === "[" && str[str.length - 1] === "]") { + path = "".concat(path).concat(str); + } + // And finally write out a computed name as a last resort + else { + path = "".concat(path, "[").concat(str, "]"); + } + break; + } + case ts.Diagnostics.Call_signature_return_types_0_and_1_are_incompatible.code: + case ts.Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible.code: + case ts.Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code: + case ts.Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code: { + if (path.length === 0) { + // Don't flatten signature compatability errors at the start of a chain - instead prefer + // to unify (the with no arguments bit is excessive for printback) and print them back + var mappedMsg = msg; + if (msg.code === ts.Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code) { + mappedMsg = ts.Diagnostics.Call_signature_return_types_0_and_1_are_incompatible; + } + else if (msg.code === ts.Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code) { + mappedMsg = ts.Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible; + } + secondaryRootErrors.unshift([mappedMsg, args[0], args[1]]); + } + else { + var prefix = (msg.code === ts.Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible.code || + msg.code === ts.Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code) + ? "new " + : ""; + var params = (msg.code === ts.Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code || + msg.code === ts.Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1.code) + ? "" + : "..."; + path = "".concat(prefix).concat(path, "(").concat(params, ")"); + } + break; + } + case ts.Diagnostics.Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target.code: { + secondaryRootErrors.unshift([ts.Diagnostics.Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target, args[0], args[1]]); + break; + } + case ts.Diagnostics.Type_at_positions_0_through_1_in_source_is_not_compatible_with_type_at_position_2_in_target.code: { + secondaryRootErrors.unshift([ts.Diagnostics.Type_at_positions_0_through_1_in_source_is_not_compatible_with_type_at_position_2_in_target, args[0], args[1], args[2]]); + break; + } + default: + return ts.Debug.fail("Unhandled Diagnostic: ".concat(msg.code)); + } + } + if (path) { + reportError(path[path.length - 1] === ")" + ? ts.Diagnostics.The_types_returned_by_0_are_incompatible_between_these_types + : ts.Diagnostics.The_types_of_0_are_incompatible_between_these_types, path); + } + else { + // Remove the innermost secondary error as it will duplicate the error already reported by `reportRelationError` on entry + secondaryRootErrors.shift(); + } + for (var _i = 0, secondaryRootErrors_1 = secondaryRootErrors; _i < secondaryRootErrors_1.length; _i++) { + var _b = secondaryRootErrors_1[_i], msg = _b[0], args = _b.slice(1); + var originalValue = msg.elidedInCompatabilityPyramid; + msg.elidedInCompatabilityPyramid = false; // Temporarily override elision to ensure error is reported + reportError.apply(void 0, __spreadArray([msg], args, false)); + msg.elidedInCompatabilityPyramid = originalValue; + } + if (info) { + // Actually do the last relation error + reportRelationError.apply(void 0, __spreadArray([/*headMessage*/ undefined], info, false)); + } + } + function reportError(message, arg0, arg1, arg2, arg3) { + ts.Debug.assert(!!errorNode); + if (incompatibleStack) + reportIncompatibleStack(); + if (message.elidedInCompatabilityPyramid) + return; + errorInfo = ts.chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2, arg3); + } + function associateRelatedInfo(info) { + ts.Debug.assert(!!errorInfo); + if (!relatedInfo) { + relatedInfo = [info]; + } + else { + relatedInfo.push(info); + } + } + function reportRelationError(message, source, target) { + if (incompatibleStack) + reportIncompatibleStack(); + var _a = getTypeNamesForErrorDisplay(source, target), sourceType = _a[0], targetType = _a[1]; + var generalizedSource = source; + var generalizedSourceType = sourceType; + if (isLiteralType(source) && !typeCouldHaveTopLevelSingletonTypes(target)) { + generalizedSource = getBaseTypeOfLiteralType(source); + ts.Debug.assert(!isTypeAssignableTo(generalizedSource, target), "generalized source shouldn't be assignable"); + generalizedSourceType = getTypeNameForErrorDisplay(generalizedSource); + } + if (target.flags & 262144 /* TypeFlags.TypeParameter */ && target !== markerSuperTypeForCheck && target !== markerSubTypeForCheck) { + var constraint = getBaseConstraintOfType(target); + var needsOriginalSource = void 0; + if (constraint && (isTypeAssignableTo(generalizedSource, constraint) || (needsOriginalSource = isTypeAssignableTo(source, constraint)))) { + reportError(ts.Diagnostics._0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_constraint_2, needsOriginalSource ? sourceType : generalizedSourceType, targetType, typeToString(constraint)); + } + else { + errorInfo = undefined; + reportError(ts.Diagnostics._0_could_be_instantiated_with_an_arbitrary_type_which_could_be_unrelated_to_1, targetType, generalizedSourceType); + } + } + if (!message) { + if (relation === comparableRelation) { + message = ts.Diagnostics.Type_0_is_not_comparable_to_type_1; + } + else if (sourceType === targetType) { + message = ts.Diagnostics.Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated; + } + else if (exactOptionalPropertyTypes && getExactOptionalUnassignableProperties(source, target).length) { + message = ts.Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties; + } + else { + if (source.flags & 128 /* TypeFlags.StringLiteral */ && target.flags & 1048576 /* TypeFlags.Union */) { + var suggestedType = getSuggestedTypeForNonexistentStringLiteralType(source, target); + if (suggestedType) { + reportError(ts.Diagnostics.Type_0_is_not_assignable_to_type_1_Did_you_mean_2, generalizedSourceType, targetType, typeToString(suggestedType)); + return; + } + } + message = ts.Diagnostics.Type_0_is_not_assignable_to_type_1; + } + } + else if (message === ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1 + && exactOptionalPropertyTypes + && getExactOptionalUnassignableProperties(source, target).length) { + message = ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties; + } + reportError(message, generalizedSourceType, targetType); + } + function tryElaborateErrorsForPrimitivesAndObjects(source, target) { + var sourceType = symbolValueDeclarationIsContextSensitive(source.symbol) ? typeToString(source, source.symbol.valueDeclaration) : typeToString(source); + var targetType = symbolValueDeclarationIsContextSensitive(target.symbol) ? typeToString(target, target.symbol.valueDeclaration) : typeToString(target); + if ((globalStringType === source && stringType === target) || + (globalNumberType === source && numberType === target) || + (globalBooleanType === source && booleanType === target) || + (getGlobalESSymbolType() === source && esSymbolType === target)) { + reportError(ts.Diagnostics._0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible, targetType, sourceType); + } + } + /** + * Try and elaborate array and tuple errors. Returns false + * if we have found an elaboration, or we should ignore + * any other elaborations when relating the `source` and + * `target` types. + */ + function tryElaborateArrayLikeErrors(source, target, reportErrors) { + /** + * The spec for elaboration is: + * - If the source is a readonly tuple and the target is a mutable array or tuple, elaborate on mutability and skip property elaborations. + * - If the source is a tuple then skip property elaborations if the target is an array or tuple. + * - If the source is a readonly array and the target is a mutable array or tuple, elaborate on mutability and skip property elaborations. + * - If the source an array then skip property elaborations if the target is a tuple. + */ + if (isTupleType(source)) { + if (source.target.readonly && isMutableArrayOrTuple(target)) { + if (reportErrors) { + reportError(ts.Diagnostics.The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1, typeToString(source), typeToString(target)); + } + return false; + } + return isArrayOrTupleType(target); + } + if (isReadonlyArrayType(source) && isMutableArrayOrTuple(target)) { + if (reportErrors) { + reportError(ts.Diagnostics.The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1, typeToString(source), typeToString(target)); + } + return false; + } + if (isTupleType(target)) { + return isArrayType(source); + } + return true; + } + function isRelatedToWorker(source, target, reportErrors) { + return isRelatedTo(source, target, 3 /* RecursionFlags.Both */, reportErrors); + } + /** + * Compare two types and return + * * Ternary.True if they are related with no assumptions, + * * Ternary.Maybe if they are related with assumptions of other relationships, or + * * Ternary.False if they are not related. + */ + function isRelatedTo(originalSource, originalTarget, recursionFlags, reportErrors, headMessage, intersectionState) { + if (recursionFlags === void 0) { recursionFlags = 3 /* RecursionFlags.Both */; } + if (reportErrors === void 0) { reportErrors = false; } + if (intersectionState === void 0) { intersectionState = 0 /* IntersectionState.None */; } + // Before normalization: if `source` is type an object type, and `target` is primitive, + // skip all the checks we don't need and just return `isSimpleTypeRelatedTo` result + if (originalSource.flags & 524288 /* TypeFlags.Object */ && originalTarget.flags & 131068 /* TypeFlags.Primitive */) { + if (isSimpleTypeRelatedTo(originalSource, originalTarget, relation, reportErrors ? reportError : undefined)) { + return -1 /* Ternary.True */; + } + if (reportErrors) { + reportErrorResults(originalSource, originalTarget, originalSource, originalTarget, headMessage); + } + return 0 /* Ternary.False */; + } + // Normalize the source and target types: Turn fresh literal types into regular literal types, + // turn deferred type references into regular type references, simplify indexed access and + // conditional types, and resolve substitution types to either the substitution (on the source + // side) or the type variable (on the target side). + var source = getNormalizedType(originalSource, /*writing*/ false); + var target = getNormalizedType(originalTarget, /*writing*/ true); + if (source === target) + return -1 /* Ternary.True */; + if (relation === identityRelation) { + if (source.flags !== target.flags) + return 0 /* Ternary.False */; + if (source.flags & 67358815 /* TypeFlags.Singleton */) + return -1 /* Ternary.True */; + traceUnionsOrIntersectionsTooLarge(source, target); + return recursiveTypeRelatedTo(source, target, /*reportErrors*/ false, 0 /* IntersectionState.None */, recursionFlags); + } + // We fastpath comparing a type parameter to exactly its constraint, as this is _super_ common, + // and otherwise, for type parameters in large unions, causes us to need to compare the union to itself, + // as we break down the _target_ union first, _then_ get the source constraint - so for every + // member of the target, we attempt to find a match in the source. This avoids that in cases where + // the target is exactly the constraint. + if (source.flags & 262144 /* TypeFlags.TypeParameter */ && getConstraintOfType(source) === target) { + return -1 /* Ternary.True */; + } + // See if we're relating a definitely non-nullable type to a union that includes null and/or undefined + // plus a single non-nullable type. If so, remove null and/or undefined from the target type. + if (source.flags & 470302716 /* TypeFlags.DefinitelyNonNullable */ && target.flags & 1048576 /* TypeFlags.Union */) { + var types = target.types; + var candidate = types.length === 2 && types[0].flags & 98304 /* TypeFlags.Nullable */ ? types[1] : + types.length === 3 && types[0].flags & 98304 /* TypeFlags.Nullable */ && types[1].flags & 98304 /* TypeFlags.Nullable */ ? types[2] : + undefined; + if (candidate && !(candidate.flags & 98304 /* TypeFlags.Nullable */)) { + target = getNormalizedType(candidate, /*writing*/ true); + if (source === target) + return -1 /* Ternary.True */; + } + } + if (relation === comparableRelation && !(target.flags & 131072 /* TypeFlags.Never */) && isSimpleTypeRelatedTo(target, source, relation) || + isSimpleTypeRelatedTo(source, target, relation, reportErrors ? reportError : undefined)) + return -1 /* Ternary.True */; + if (source.flags & 469499904 /* TypeFlags.StructuredOrInstantiable */ || target.flags & 469499904 /* TypeFlags.StructuredOrInstantiable */) { + var isPerformingExcessPropertyChecks = !(intersectionState & 2 /* IntersectionState.Target */) && (isObjectLiteralType(source) && ts.getObjectFlags(source) & 8192 /* ObjectFlags.FreshLiteral */); + if (isPerformingExcessPropertyChecks) { + if (hasExcessProperties(source, target, reportErrors)) { + if (reportErrors) { + reportRelationError(headMessage, source, originalTarget.aliasSymbol ? originalTarget : target); + } + return 0 /* Ternary.False */; + } + } + var isPerformingCommonPropertyChecks = (relation !== comparableRelation || isUnitType(source)) && + !(intersectionState & 2 /* IntersectionState.Target */) && + source.flags & (131068 /* TypeFlags.Primitive */ | 524288 /* TypeFlags.Object */ | 2097152 /* TypeFlags.Intersection */) && source !== globalObjectType && + target.flags & (524288 /* TypeFlags.Object */ | 2097152 /* TypeFlags.Intersection */) && isWeakType(target) && + (getPropertiesOfType(source).length > 0 || typeHasCallOrConstructSignatures(source)); + var isComparingJsxAttributes = !!(ts.getObjectFlags(source) & 2048 /* ObjectFlags.JsxAttributes */); + if (isPerformingCommonPropertyChecks && !hasCommonProperties(source, target, isComparingJsxAttributes)) { + if (reportErrors) { + var sourceString = typeToString(originalSource.aliasSymbol ? originalSource : source); + var targetString = typeToString(originalTarget.aliasSymbol ? originalTarget : target); + var calls = getSignaturesOfType(source, 0 /* SignatureKind.Call */); + var constructs = getSignaturesOfType(source, 1 /* SignatureKind.Construct */); + if (calls.length > 0 && isRelatedTo(getReturnTypeOfSignature(calls[0]), target, 1 /* RecursionFlags.Source */, /*reportErrors*/ false) || + constructs.length > 0 && isRelatedTo(getReturnTypeOfSignature(constructs[0]), target, 1 /* RecursionFlags.Source */, /*reportErrors*/ false)) { + reportError(ts.Diagnostics.Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it, sourceString, targetString); + } + else { + reportError(ts.Diagnostics.Type_0_has_no_properties_in_common_with_type_1, sourceString, targetString); + } + } + return 0 /* Ternary.False */; + } + traceUnionsOrIntersectionsTooLarge(source, target); + var skipCaching = source.flags & 1048576 /* TypeFlags.Union */ && source.types.length < 4 && !(target.flags & 1048576 /* TypeFlags.Union */) || + target.flags & 1048576 /* TypeFlags.Union */ && target.types.length < 4 && !(source.flags & 469499904 /* TypeFlags.StructuredOrInstantiable */); + var result_7 = skipCaching ? + unionOrIntersectionRelatedTo(source, target, reportErrors, intersectionState) : + recursiveTypeRelatedTo(source, target, reportErrors, intersectionState, recursionFlags); + if (result_7) { + return result_7; + } + } + if (reportErrors) { + reportErrorResults(originalSource, originalTarget, source, target, headMessage); + } + return 0 /* Ternary.False */; + } + function reportErrorResults(originalSource, originalTarget, source, target, headMessage) { + var _a, _b; + var sourceHasBase = !!getSingleBaseForNonAugmentingSubtype(originalSource); + var targetHasBase = !!getSingleBaseForNonAugmentingSubtype(originalTarget); + source = (originalSource.aliasSymbol || sourceHasBase) ? originalSource : source; + target = (originalTarget.aliasSymbol || targetHasBase) ? originalTarget : target; + var maybeSuppress = overrideNextErrorInfo > 0; + if (maybeSuppress) { + overrideNextErrorInfo--; + } + if (source.flags & 524288 /* TypeFlags.Object */ && target.flags & 524288 /* TypeFlags.Object */) { + var currentError = errorInfo; + tryElaborateArrayLikeErrors(source, target, /*reportErrors*/ true); + if (errorInfo !== currentError) { + maybeSuppress = !!errorInfo; + } + } + if (source.flags & 524288 /* TypeFlags.Object */ && target.flags & 131068 /* TypeFlags.Primitive */) { + tryElaborateErrorsForPrimitivesAndObjects(source, target); + } + else if (source.symbol && source.flags & 524288 /* TypeFlags.Object */ && globalObjectType === source) { + reportError(ts.Diagnostics.The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead); + } + else if (ts.getObjectFlags(source) & 2048 /* ObjectFlags.JsxAttributes */ && target.flags & 2097152 /* TypeFlags.Intersection */) { + var targetTypes = target.types; + var intrinsicAttributes = getJsxType(JsxNames.IntrinsicAttributes, errorNode); + var intrinsicClassAttributes = getJsxType(JsxNames.IntrinsicClassAttributes, errorNode); + if (!isErrorType(intrinsicAttributes) && !isErrorType(intrinsicClassAttributes) && + (ts.contains(targetTypes, intrinsicAttributes) || ts.contains(targetTypes, intrinsicClassAttributes))) { + // do not report top error + return; + } + } + else { + errorInfo = elaborateNeverIntersection(errorInfo, originalTarget); + } + if (!headMessage && maybeSuppress) { + lastSkippedInfo = [source, target]; + // Used by, eg, missing property checking to replace the top-level message with a more informative one + return; + } + reportRelationError(headMessage, source, target); + if (source.flags & 262144 /* TypeFlags.TypeParameter */ && ((_b = (_a = source.symbol) === null || _a === void 0 ? void 0 : _a.declarations) === null || _b === void 0 ? void 0 : _b[0]) && !getConstraintOfType(source)) { + var syntheticParam = cloneTypeParameter(source); + syntheticParam.constraint = instantiateType(target, makeUnaryTypeMapper(source, syntheticParam)); + if (hasNonCircularBaseConstraint(syntheticParam)) { + var targetConstraintString = typeToString(target, source.symbol.declarations[0]); + associateRelatedInfo(ts.createDiagnosticForNode(source.symbol.declarations[0], ts.Diagnostics.This_type_parameter_might_need_an_extends_0_constraint, targetConstraintString)); + } + } + } + function traceUnionsOrIntersectionsTooLarge(source, target) { + if (!ts.tracing) { + return; + } + if ((source.flags & 3145728 /* TypeFlags.UnionOrIntersection */) && (target.flags & 3145728 /* TypeFlags.UnionOrIntersection */)) { + var sourceUnionOrIntersection = source; + var targetUnionOrIntersection = target; + if (sourceUnionOrIntersection.objectFlags & targetUnionOrIntersection.objectFlags & 32768 /* ObjectFlags.PrimitiveUnion */) { + // There's a fast path for comparing primitive unions + return; + } + var sourceSize = sourceUnionOrIntersection.types.length; + var targetSize = targetUnionOrIntersection.types.length; + if (sourceSize * targetSize > 1E6) { + ts.tracing.instant("checkTypes" /* tracing.Phase.CheckTypes */, "traceUnionsOrIntersectionsTooLarge_DepthLimit", { + sourceId: source.id, + sourceSize: sourceSize, + targetId: target.id, + targetSize: targetSize, + pos: errorNode === null || errorNode === void 0 ? void 0 : errorNode.pos, + end: errorNode === null || errorNode === void 0 ? void 0 : errorNode.end + }); + } + } + } + function getTypeOfPropertyInTypes(types, name) { + var appendPropType = function (propTypes, type) { + var _a; + type = getApparentType(type); + var prop = type.flags & 3145728 /* TypeFlags.UnionOrIntersection */ ? getPropertyOfUnionOrIntersectionType(type, name) : getPropertyOfObjectType(type, name); + var propType = prop && getTypeOfSymbol(prop) || ((_a = getApplicableIndexInfoForName(type, name)) === null || _a === void 0 ? void 0 : _a.type) || undefinedType; + return ts.append(propTypes, propType); + }; + return getUnionType(ts.reduceLeft(types, appendPropType, /*initial*/ undefined) || ts.emptyArray); + } + function hasExcessProperties(source, target, reportErrors) { + var _a; + if (!isExcessPropertyCheckTarget(target) || !noImplicitAny && ts.getObjectFlags(target) & 4096 /* ObjectFlags.JSLiteral */) { + return false; // Disable excess property checks on JS literals to simulate having an implicit "index signature" - but only outside of noImplicitAny + } + var isComparingJsxAttributes = !!(ts.getObjectFlags(source) & 2048 /* ObjectFlags.JsxAttributes */); + if ((relation === assignableRelation || relation === comparableRelation) && + (isTypeSubsetOf(globalObjectType, target) || (!isComparingJsxAttributes && isEmptyObjectType(target)))) { + return false; + } + var reducedTarget = target; + var checkTypes; + if (target.flags & 1048576 /* TypeFlags.Union */) { + reducedTarget = findMatchingDiscriminantType(source, target, isRelatedTo) || filterPrimitivesIfContainsNonPrimitive(target); + checkTypes = reducedTarget.flags & 1048576 /* TypeFlags.Union */ ? reducedTarget.types : [reducedTarget]; + } + var _loop_20 = function (prop) { + if (shouldCheckAsExcessProperty(prop, source.symbol) && !isIgnoredJsxProperty(source, prop)) { + if (!isKnownProperty(reducedTarget, prop.escapedName, isComparingJsxAttributes)) { + if (reportErrors) { + // Report error in terms of object types in the target as those are the only ones + // we check in isKnownProperty. + var errorTarget = filterType(reducedTarget, isExcessPropertyCheckTarget); + // We know *exactly* where things went wrong when comparing the types. + // Use this property as the error node as this will be more helpful in + // reasoning about what went wrong. + if (!errorNode) + return { value: ts.Debug.fail() }; + if (ts.isJsxAttributes(errorNode) || ts.isJsxOpeningLikeElement(errorNode) || ts.isJsxOpeningLikeElement(errorNode.parent)) { + // JsxAttributes has an object-literal flag and undergo same type-assignablity check as normal object-literal. + // However, using an object-literal error message will be very confusing to the users so we give different a message. + if (prop.valueDeclaration && ts.isJsxAttribute(prop.valueDeclaration) && ts.getSourceFileOfNode(errorNode) === ts.getSourceFileOfNode(prop.valueDeclaration.name)) { + // Note that extraneous children (as in `extra`) don't pass this check, + // since `children` is a SyntaxKind.PropertySignature instead of a SyntaxKind.JsxAttribute. + errorNode = prop.valueDeclaration.name; + } + var propName = symbolToString(prop); + var suggestionSymbol = getSuggestedSymbolForNonexistentJSXAttribute(propName, errorTarget); + var suggestion = suggestionSymbol ? symbolToString(suggestionSymbol) : undefined; + if (suggestion) { + reportError(ts.Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2, propName, typeToString(errorTarget), suggestion); + } + else { + reportError(ts.Diagnostics.Property_0_does_not_exist_on_type_1, propName, typeToString(errorTarget)); + } + } + else { + // use the property's value declaration if the property is assigned inside the literal itself + var objectLiteralDeclaration_1 = ((_a = source.symbol) === null || _a === void 0 ? void 0 : _a.declarations) && ts.firstOrUndefined(source.symbol.declarations); + var suggestion = void 0; + if (prop.valueDeclaration && ts.findAncestor(prop.valueDeclaration, function (d) { return d === objectLiteralDeclaration_1; }) && ts.getSourceFileOfNode(objectLiteralDeclaration_1) === ts.getSourceFileOfNode(errorNode)) { + var propDeclaration = prop.valueDeclaration; + ts.Debug.assertNode(propDeclaration, ts.isObjectLiteralElementLike); + errorNode = propDeclaration; + var name = propDeclaration.name; + if (ts.isIdentifier(name)) { + suggestion = getSuggestionForNonexistentProperty(name, errorTarget); + } + } + if (suggestion !== undefined) { + reportError(ts.Diagnostics.Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_write_2, symbolToString(prop), typeToString(errorTarget), suggestion); + } + else { + reportError(ts.Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1, symbolToString(prop), typeToString(errorTarget)); + } + } + } + return { value: true }; + } + if (checkTypes && !isRelatedTo(getTypeOfSymbol(prop), getTypeOfPropertyInTypes(checkTypes, prop.escapedName), 3 /* RecursionFlags.Both */, reportErrors)) { + if (reportErrors) { + reportIncompatibleError(ts.Diagnostics.Types_of_property_0_are_incompatible, symbolToString(prop)); + } + return { value: true }; + } + } + }; + for (var _i = 0, _b = getPropertiesOfType(source); _i < _b.length; _i++) { + var prop = _b[_i]; + var state_6 = _loop_20(prop); + if (typeof state_6 === "object") + return state_6.value; + } + return false; + } + function shouldCheckAsExcessProperty(prop, container) { + return prop.valueDeclaration && container.valueDeclaration && prop.valueDeclaration.parent === container.valueDeclaration; + } + function unionOrIntersectionRelatedTo(source, target, reportErrors, intersectionState) { + // Note that these checks are specifically ordered to produce correct results. In particular, + // we need to deconstruct unions before intersections (because unions are always at the top), + // and we need to handle "each" relations before "some" relations for the same kind of type. + if (source.flags & 1048576 /* TypeFlags.Union */) { + return relation === comparableRelation ? + someTypeRelatedToType(source, target, reportErrors && !(source.flags & 131068 /* TypeFlags.Primitive */), intersectionState) : + eachTypeRelatedToType(source, target, reportErrors && !(source.flags & 131068 /* TypeFlags.Primitive */), intersectionState); + } + if (target.flags & 1048576 /* TypeFlags.Union */) { + return typeRelatedToSomeType(getRegularTypeOfObjectLiteral(source), target, reportErrors && !(source.flags & 131068 /* TypeFlags.Primitive */) && !(target.flags & 131068 /* TypeFlags.Primitive */)); + } + if (target.flags & 2097152 /* TypeFlags.Intersection */) { + return typeRelatedToEachType(source, target, reportErrors, 2 /* IntersectionState.Target */); + } + // Source is an intersection. For the comparable relation, if the target is a primitive type we hoist the + // constraints of all non-primitive types in the source into a new intersection. We do this because the + // intersection may further constrain the constraints of the non-primitive types. For example, given a type + // parameter 'T extends 1 | 2', the intersection 'T & 1' should be reduced to '1' such that it doesn't + // appear to be comparable to '2'. + if (relation === comparableRelation && target.flags & 131068 /* TypeFlags.Primitive */) { + var constraints = ts.sameMap(source.types, function (t) { return t.flags & 465829888 /* TypeFlags.Instantiable */ ? getBaseConstraintOfType(t) || unknownType : t; }); + if (constraints !== source.types) { + source = getIntersectionType(constraints); + if (source.flags & 131072 /* TypeFlags.Never */) { + return 0 /* Ternary.False */; + } + if (!(source.flags & 2097152 /* TypeFlags.Intersection */)) { + return isRelatedTo(source, target, 1 /* RecursionFlags.Source */, /*reportErrors*/ false) || + isRelatedTo(target, source, 1 /* RecursionFlags.Source */, /*reportErrors*/ false); + } + } + } + // Check to see if any constituents of the intersection are immediately related to the target. + // Don't report errors though. Elaborating on whether a source constituent is related to the target is + // not actually useful and leads to some confusing error messages. Instead, we rely on the caller + // checking whether the full intersection viewed as an object is related to the target. + return someTypeRelatedToType(source, target, /*reportErrors*/ false, 1 /* IntersectionState.Source */); + } + function eachTypeRelatedToSomeType(source, target) { + var result = -1 /* Ternary.True */; + var sourceTypes = source.types; + for (var _i = 0, sourceTypes_1 = sourceTypes; _i < sourceTypes_1.length; _i++) { + var sourceType = sourceTypes_1[_i]; + var related = typeRelatedToSomeType(sourceType, target, /*reportErrors*/ false); + if (!related) { + return 0 /* Ternary.False */; + } + result &= related; + } + return result; + } + function typeRelatedToSomeType(source, target, reportErrors) { + var targetTypes = target.types; + if (target.flags & 1048576 /* TypeFlags.Union */) { + if (containsType(targetTypes, source)) { + return -1 /* Ternary.True */; + } + var match = getMatchingUnionConstituentForType(target, source); + if (match) { + var related = isRelatedTo(source, match, 2 /* RecursionFlags.Target */, /*reportErrors*/ false); + if (related) { + return related; + } + } + } + for (var _i = 0, targetTypes_1 = targetTypes; _i < targetTypes_1.length; _i++) { + var type = targetTypes_1[_i]; + var related = isRelatedTo(source, type, 2 /* RecursionFlags.Target */, /*reportErrors*/ false); + if (related) { + return related; + } + } + if (reportErrors) { + // Elaborate only if we can find a best matching type in the target union + var bestMatchingType = getBestMatchingType(source, target, isRelatedTo); + if (bestMatchingType) { + isRelatedTo(source, bestMatchingType, 2 /* RecursionFlags.Target */, /*reportErrors*/ true); + } + } + return 0 /* Ternary.False */; + } + function typeRelatedToEachType(source, target, reportErrors, intersectionState) { + var result = -1 /* Ternary.True */; + var targetTypes = target.types; + for (var _i = 0, targetTypes_2 = targetTypes; _i < targetTypes_2.length; _i++) { + var targetType = targetTypes_2[_i]; + var related = isRelatedTo(source, targetType, 2 /* RecursionFlags.Target */, reportErrors, /*headMessage*/ undefined, intersectionState); + if (!related) { + return 0 /* Ternary.False */; + } + result &= related; + } + return result; + } + function someTypeRelatedToType(source, target, reportErrors, intersectionState) { + var sourceTypes = source.types; + if (source.flags & 1048576 /* TypeFlags.Union */ && containsType(sourceTypes, target)) { + return -1 /* Ternary.True */; + } + var len = sourceTypes.length; + for (var i = 0; i < len; i++) { + var related = isRelatedTo(sourceTypes[i], target, 1 /* RecursionFlags.Source */, reportErrors && i === len - 1, /*headMessage*/ undefined, intersectionState); + if (related) { + return related; + } + } + return 0 /* Ternary.False */; + } + function getUndefinedStrippedTargetIfNeeded(source, target) { + // As a builtin type, `undefined` is a very low type ID - making it almsot always first, making this a very fast check to see + // if we need to strip `undefined` from the target + if (source.flags & 1048576 /* TypeFlags.Union */ && target.flags & 1048576 /* TypeFlags.Union */ && + !(source.types[0].flags & 32768 /* TypeFlags.Undefined */) && target.types[0].flags & 32768 /* TypeFlags.Undefined */) { + return extractTypesOfKind(target, ~32768 /* TypeFlags.Undefined */); + } + return target; + } + function eachTypeRelatedToType(source, target, reportErrors, intersectionState) { + var result = -1 /* Ternary.True */; + var sourceTypes = source.types; + // We strip `undefined` from the target if the `source` trivially doesn't contain it for our correspondence-checking fastpath + // since `undefined` is frequently added by optionality and would otherwise spoil a potentially useful correspondence + var undefinedStrippedTarget = getUndefinedStrippedTargetIfNeeded(source, target); + for (var i = 0; i < sourceTypes.length; i++) { + var sourceType = sourceTypes[i]; + if (undefinedStrippedTarget.flags & 1048576 /* TypeFlags.Union */ && sourceTypes.length >= undefinedStrippedTarget.types.length && sourceTypes.length % undefinedStrippedTarget.types.length === 0) { + // many unions are mappings of one another; in such cases, simply comparing members at the same index can shortcut the comparison + // such unions will have identical lengths, and their corresponding elements will match up. Another common scenario is where a large + // union has a union of objects intersected with it. In such cases, if the input was, eg `("a" | "b" | "c") & (string | boolean | {} | {whatever})`, + // the result will have the structure `"a" | "b" | "c" | "a" & {} | "b" & {} | "c" & {} | "a" & {whatever} | "b" & {whatever} | "c" & {whatever}` + // - the resulting union has a length which is a multiple of the original union, and the elements correspond modulo the length of the original union + var related_1 = isRelatedTo(sourceType, undefinedStrippedTarget.types[i % undefinedStrippedTarget.types.length], 3 /* RecursionFlags.Both */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState); + if (related_1) { + result &= related_1; + continue; + } + } + var related = isRelatedTo(sourceType, target, 1 /* RecursionFlags.Source */, reportErrors, /*headMessage*/ undefined, intersectionState); + if (!related) { + return 0 /* Ternary.False */; + } + result &= related; + } + return result; + } + function typeArgumentsRelatedTo(sources, targets, variances, reportErrors, intersectionState) { + if (sources === void 0) { sources = ts.emptyArray; } + if (targets === void 0) { targets = ts.emptyArray; } + if (variances === void 0) { variances = ts.emptyArray; } + if (sources.length !== targets.length && relation === identityRelation) { + return 0 /* Ternary.False */; + } + var length = sources.length <= targets.length ? sources.length : targets.length; + var result = -1 /* Ternary.True */; + for (var i = 0; i < length; i++) { + // When variance information isn't available we default to covariance. This happens + // in the process of computing variance information for recursive types and when + // comparing 'this' type arguments. + var varianceFlags = i < variances.length ? variances[i] : 1 /* VarianceFlags.Covariant */; + var variance = varianceFlags & 7 /* VarianceFlags.VarianceMask */; + // We ignore arguments for independent type parameters (because they're never witnessed). + if (variance !== 4 /* VarianceFlags.Independent */) { + var s = sources[i]; + var t = targets[i]; + var related = -1 /* Ternary.True */; + if (varianceFlags & 8 /* VarianceFlags.Unmeasurable */) { + // Even an `Unmeasurable` variance works out without a structural check if the source and target are _identical_. + // We can't simply assume invariance, because `Unmeasurable` marks nonlinear relations, for example, a relation tained by + // the `-?` modifier in a mapped type (where, no matter how the inputs are related, the outputs still might not be) + related = relation === identityRelation ? isRelatedTo(s, t, 3 /* RecursionFlags.Both */, /*reportErrors*/ false) : compareTypesIdentical(s, t); + } + else if (variance === 1 /* VarianceFlags.Covariant */) { + related = isRelatedTo(s, t, 3 /* RecursionFlags.Both */, reportErrors, /*headMessage*/ undefined, intersectionState); + } + else if (variance === 2 /* VarianceFlags.Contravariant */) { + related = isRelatedTo(t, s, 3 /* RecursionFlags.Both */, reportErrors, /*headMessage*/ undefined, intersectionState); + } + else if (variance === 3 /* VarianceFlags.Bivariant */) { + // In the bivariant case we first compare contravariantly without reporting + // errors. Then, if that doesn't succeed, we compare covariantly with error + // reporting. Thus, error elaboration will be based on the the covariant check, + // which is generally easier to reason about. + related = isRelatedTo(t, s, 3 /* RecursionFlags.Both */, /*reportErrors*/ false); + if (!related) { + related = isRelatedTo(s, t, 3 /* RecursionFlags.Both */, reportErrors, /*headMessage*/ undefined, intersectionState); + } + } + else { + // In the invariant case we first compare covariantly, and only when that + // succeeds do we proceed to compare contravariantly. Thus, error elaboration + // will typically be based on the covariant check. + related = isRelatedTo(s, t, 3 /* RecursionFlags.Both */, reportErrors, /*headMessage*/ undefined, intersectionState); + if (related) { + related &= isRelatedTo(t, s, 3 /* RecursionFlags.Both */, reportErrors, /*headMessage*/ undefined, intersectionState); + } + } + if (!related) { + return 0 /* Ternary.False */; + } + result &= related; + } + } + return result; + } + // Determine if possibly recursive types are related. First, check if the result is already available in the global cache. + // Second, check if we have already started a comparison of the given two types in which case we assume the result to be true. + // Third, check if both types are part of deeply nested chains of generic type instantiations and if so assume the types are + // equal and infinitely expanding. Fourth, if we have reached a depth of 100 nested comparisons, assume we have runaway recursion + // and issue an error. Otherwise, actually compare the structure of the two types. + function recursiveTypeRelatedTo(source, target, reportErrors, intersectionState, recursionFlags) { + if (overflow) { + return 0 /* Ternary.False */; + } + var id = getRelationKey(source, target, intersectionState, relation, /*ingnoreConstraints*/ false); + var entry = relation.get(id); + if (entry !== undefined) { + if (reportErrors && entry & 2 /* RelationComparisonResult.Failed */ && !(entry & 4 /* RelationComparisonResult.Reported */)) { + // We are elaborating errors and the cached result is an unreported failure. The result will be reported + // as a failure, and should be updated as a reported failure by the bottom of this function. + } + else { + if (outofbandVarianceMarkerHandler) { + // We're in the middle of variance checking - integrate any unmeasurable/unreliable flags from this cached component + var saved = entry & 24 /* RelationComparisonResult.ReportsMask */; + if (saved & 8 /* RelationComparisonResult.ReportsUnmeasurable */) { + instantiateType(source, reportUnmeasurableMapper); + } + if (saved & 16 /* RelationComparisonResult.ReportsUnreliable */) { + instantiateType(source, reportUnreliableMapper); + } + } + return entry & 1 /* RelationComparisonResult.Succeeded */ ? -1 /* Ternary.True */ : 0 /* Ternary.False */; + } + } + if (!maybeKeys) { + maybeKeys = []; + sourceStack = []; + targetStack = []; + } + else { + // A key that starts with "*" is an indication that we have type references that reference constrained + // type parameters. For such keys we also check against the key we would have gotten if all type parameters + // were unconstrained. + var broadestEquivalentId = id.startsWith("*") ? getRelationKey(source, target, intersectionState, relation, /*ignoreConstraints*/ true) : undefined; + for (var i = 0; i < maybeCount; i++) { + // If source and target are already being compared, consider them related with assumptions + if (id === maybeKeys[i] || broadestEquivalentId && broadestEquivalentId === maybeKeys[i]) { + return 3 /* Ternary.Maybe */; + } + } + if (sourceDepth === 100 || targetDepth === 100) { + overflow = true; + return 0 /* Ternary.False */; + } + } + var maybeStart = maybeCount; + maybeKeys[maybeCount] = id; + maybeCount++; + var saveExpandingFlags = expandingFlags; + if (recursionFlags & 1 /* RecursionFlags.Source */) { + sourceStack[sourceDepth] = source; + sourceDepth++; + if (!(expandingFlags & 1 /* ExpandingFlags.Source */) && isDeeplyNestedType(source, sourceStack, sourceDepth)) + expandingFlags |= 1 /* ExpandingFlags.Source */; + } + if (recursionFlags & 2 /* RecursionFlags.Target */) { + targetStack[targetDepth] = target; + targetDepth++; + if (!(expandingFlags & 2 /* ExpandingFlags.Target */) && isDeeplyNestedType(target, targetStack, targetDepth)) + expandingFlags |= 2 /* ExpandingFlags.Target */; + } + var originalHandler; + var propagatingVarianceFlags = 0; + if (outofbandVarianceMarkerHandler) { + originalHandler = outofbandVarianceMarkerHandler; + outofbandVarianceMarkerHandler = function (onlyUnreliable) { + propagatingVarianceFlags |= onlyUnreliable ? 16 /* RelationComparisonResult.ReportsUnreliable */ : 8 /* RelationComparisonResult.ReportsUnmeasurable */; + return originalHandler(onlyUnreliable); + }; + } + var result; + if (expandingFlags === 3 /* ExpandingFlags.Both */) { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes" /* tracing.Phase.CheckTypes */, "recursiveTypeRelatedTo_DepthLimit", { + sourceId: source.id, + sourceIdStack: sourceStack.map(function (t) { return t.id; }), + targetId: target.id, + targetIdStack: targetStack.map(function (t) { return t.id; }), + depth: sourceDepth, + targetDepth: targetDepth + }); + result = 3 /* Ternary.Maybe */; + } + else { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("checkTypes" /* tracing.Phase.CheckTypes */, "structuredTypeRelatedTo", { sourceId: source.id, targetId: target.id }); + result = structuredTypeRelatedTo(source, target, reportErrors, intersectionState); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + } + if (outofbandVarianceMarkerHandler) { + outofbandVarianceMarkerHandler = originalHandler; + } + if (recursionFlags & 1 /* RecursionFlags.Source */) { + sourceDepth--; + } + if (recursionFlags & 2 /* RecursionFlags.Target */) { + targetDepth--; + } + expandingFlags = saveExpandingFlags; + if (result) { + if (result === -1 /* Ternary.True */ || (sourceDepth === 0 && targetDepth === 0)) { + if (result === -1 /* Ternary.True */ || result === 3 /* Ternary.Maybe */) { + // If result is definitely true, record all maybe keys as having succeeded. Also, record Ternary.Maybe + // results as having succeeded once we reach depth 0, but never record Ternary.Unknown results. + for (var i = maybeStart; i < maybeCount; i++) { + relation.set(maybeKeys[i], 1 /* RelationComparisonResult.Succeeded */ | propagatingVarianceFlags); + } + } + maybeCount = maybeStart; + } + } + else { + // A false result goes straight into global cache (when something is false under + // assumptions it will also be false without assumptions) + relation.set(id, (reportErrors ? 4 /* RelationComparisonResult.Reported */ : 0) | 2 /* RelationComparisonResult.Failed */ | propagatingVarianceFlags); + maybeCount = maybeStart; + } + return result; + } + function structuredTypeRelatedTo(source, target, reportErrors, intersectionState) { + var saveErrorInfo = captureErrorCalculationState(); + var result = structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState, saveErrorInfo); + if (relation !== identityRelation) { + // The combined constraint of an intersection type is the intersection of the constraints of + // the constituents. When an intersection type contains instantiable types with union type + // constraints, there are situations where we need to examine the combined constraint. One is + // when the target is a union type. Another is when the intersection contains types belonging + // to one of the disjoint domains. For example, given type variables T and U, each with the + // constraint 'string | number', the combined constraint of 'T & U' is 'string | number' and + // we need to check this constraint against a union on the target side. Also, given a type + // variable V constrained to 'string | number', 'V & number' has a combined constraint of + // 'string & number | number & number' which reduces to just 'number'. + // This also handles type parameters, as a type parameter with a union constraint compared against a union + // needs to have its constraint hoisted into an intersection with said type parameter, this way + // the type param can be compared with itself in the target (with the influence of its constraint to match other parts) + // For example, if `T extends 1 | 2` and `U extends 2 | 3` and we compare `T & U` to `T & U & (1 | 2 | 3)` + if (!result && (source.flags & 2097152 /* TypeFlags.Intersection */ || source.flags & 262144 /* TypeFlags.TypeParameter */ && target.flags & 1048576 /* TypeFlags.Union */)) { + var constraint = getEffectiveConstraintOfIntersection(source.flags & 2097152 /* TypeFlags.Intersection */ ? source.types : [source], !!(target.flags & 1048576 /* TypeFlags.Union */)); + if (constraint && everyType(constraint, function (c) { return c !== source; })) { // Skip comparison if expansion contains the source itself + // TODO: Stack errors so we get a pyramid for the "normal" comparison above, _and_ a second for this + result = isRelatedTo(constraint, target, 1 /* RecursionFlags.Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState); + } + } + // For certain combinations involving intersections and optional, excess, or mismatched properties we need + // an extra property check where the intersection is viewed as a single object. The following are motivating + // examples that all should be errors, but aren't without this extra property check: + // + // let obj: { a: { x: string } } & { c: number } = { a: { x: 'hello', y: 2 }, c: 5 }; // Nested excess property + // + // declare let wrong: { a: { y: string } }; + // let weak: { a?: { x?: number } } & { c?: string } = wrong; // Nested weak object type + // + // function foo(x: { a?: string }, y: T & { a: boolean }) { + // x = y; // Mismatched property in source intersection + // } + // + // We suppress recursive intersection property checks because they can generate lots of work when relating + // recursive intersections that are structurally similar but not exactly identical. See #37854. + if (result && !inPropertyCheck && (target.flags & 2097152 /* TypeFlags.Intersection */ && !isGenericObjectType(target) && source.flags & (524288 /* TypeFlags.Object */ | 2097152 /* TypeFlags.Intersection */) || + isNonGenericObjectType(target) && !isArrayOrTupleType(target) && source.flags & 2097152 /* TypeFlags.Intersection */ && getApparentType(source).flags & 3670016 /* TypeFlags.StructuredType */ && !ts.some(source.types, function (t) { return !!(ts.getObjectFlags(t) & 262144 /* ObjectFlags.NonInferrableType */); }))) { + inPropertyCheck = true; + result &= propertiesRelatedTo(source, target, reportErrors, /*excludedProperties*/ undefined, 0 /* IntersectionState.None */); + inPropertyCheck = false; + } + } + if (result) { + resetErrorInfo(saveErrorInfo); + } + return result; + } + function structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState, saveErrorInfo) { + var result; + var originalErrorInfo; + var varianceCheckFailed = false; + var sourceFlags = source.flags; + var targetFlags = target.flags; + if (relation === identityRelation) { + // We've already checked that source.flags and target.flags are identical + if (sourceFlags & 3145728 /* TypeFlags.UnionOrIntersection */) { + var result_8 = eachTypeRelatedToSomeType(source, target); + if (result_8) { + result_8 &= eachTypeRelatedToSomeType(target, source); + } + return result_8; + } + if (sourceFlags & 4194304 /* TypeFlags.Index */) { + return isRelatedTo(source.type, target.type, 3 /* RecursionFlags.Both */, /*reportErrors*/ false); + } + if (sourceFlags & 8388608 /* TypeFlags.IndexedAccess */) { + if (result = isRelatedTo(source.objectType, target.objectType, 3 /* RecursionFlags.Both */, /*reportErrors*/ false)) { + if (result &= isRelatedTo(source.indexType, target.indexType, 3 /* RecursionFlags.Both */, /*reportErrors*/ false)) { + return result; + } + } + } + if (sourceFlags & 16777216 /* TypeFlags.Conditional */) { + if (source.root.isDistributive === target.root.isDistributive) { + if (result = isRelatedTo(source.checkType, target.checkType, 3 /* RecursionFlags.Both */, /*reportErrors*/ false)) { + if (result &= isRelatedTo(source.extendsType, target.extendsType, 3 /* RecursionFlags.Both */, /*reportErrors*/ false)) { + if (result &= isRelatedTo(getTrueTypeFromConditionalType(source), getTrueTypeFromConditionalType(target), 3 /* RecursionFlags.Both */, /*reportErrors*/ false)) { + if (result &= isRelatedTo(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target), 3 /* RecursionFlags.Both */, /*reportErrors*/ false)) { + return result; + } + } + } + } + } + } + if (sourceFlags & 33554432 /* TypeFlags.Substitution */) { + if (result = isRelatedTo(source.baseType, target.baseType, 3 /* RecursionFlags.Both */, /*reportErrors*/ false)) { + if (result &= isRelatedTo(source.constraint, target.constraint, 3 /* RecursionFlags.Both */, /*reportErrors*/ false)) { + return result; + } + } + } + if (!(sourceFlags & 524288 /* TypeFlags.Object */)) { + return 0 /* Ternary.False */; + } + } + else if (sourceFlags & 3145728 /* TypeFlags.UnionOrIntersection */ || targetFlags & 3145728 /* TypeFlags.UnionOrIntersection */) { + if (result = unionOrIntersectionRelatedTo(source, target, reportErrors, intersectionState)) { + return result; + } + // The ordered decomposition above doesn't handle all cases. Specifically, we also need to handle: + // Source is instantiable (e.g. source has union or intersection constraint). + // Source is an object, target is a union (e.g. { a, b: boolean } <=> { a, b: true } | { a, b: false }). + // Source is an intersection, target is an object (e.g. { a } & { b } <=> { a, b }). + // Source is an intersection, target is a union (e.g. { a } & { b: boolean } <=> { a, b: true } | { a, b: false }). + // Source is an intersection, target instantiable (e.g. string & { tag } <=> T["a"] constrained to string & { tag }). + if (!(sourceFlags & 465829888 /* TypeFlags.Instantiable */ || + sourceFlags & 524288 /* TypeFlags.Object */ && targetFlags & 1048576 /* TypeFlags.Union */ || + sourceFlags & 2097152 /* TypeFlags.Intersection */ && targetFlags & (524288 /* TypeFlags.Object */ | 1048576 /* TypeFlags.Union */ | 465829888 /* TypeFlags.Instantiable */))) { + return 0 /* Ternary.False */; + } + } + // We limit alias variance probing to only object and conditional types since their alias behavior + // is more predictable than other, interned types, which may or may not have an alias depending on + // the order in which things were checked. + if (sourceFlags & (524288 /* TypeFlags.Object */ | 16777216 /* TypeFlags.Conditional */) && source.aliasSymbol && source.aliasTypeArguments && + source.aliasSymbol === target.aliasSymbol && !(isMarkerType(source) || isMarkerType(target))) { + var variances = getAliasVariances(source.aliasSymbol); + if (variances === ts.emptyArray) { + return 1 /* Ternary.Unknown */; + } + var varianceResult = relateVariances(source.aliasTypeArguments, target.aliasTypeArguments, variances, intersectionState); + if (varianceResult !== undefined) { + return varianceResult; + } + } + // For a generic type T and a type U that is assignable to T, [...U] is assignable to T, U is assignable to readonly [...T], + // and U is assignable to [...T] when U is constrained to a mutable array or tuple type. + if (isSingleElementGenericTupleType(source) && !source.target.readonly && (result = isRelatedTo(getTypeArguments(source)[0], target, 1 /* RecursionFlags.Source */)) || + isSingleElementGenericTupleType(target) && (target.target.readonly || isMutableArrayOrTuple(getBaseConstraintOfType(source) || source)) && (result = isRelatedTo(source, getTypeArguments(target)[0], 2 /* RecursionFlags.Target */))) { + return result; + } + if (targetFlags & 262144 /* TypeFlags.TypeParameter */) { + // A source type { [P in Q]: X } is related to a target type T if keyof T is related to Q and X is related to T[Q]. + if (ts.getObjectFlags(source) & 32 /* ObjectFlags.Mapped */ && !source.declaration.nameType && isRelatedTo(getIndexType(target), getConstraintTypeFromMappedType(source), 3 /* RecursionFlags.Both */)) { + if (!(getMappedTypeModifiers(source) & 4 /* MappedTypeModifiers.IncludeOptional */)) { + var templateType = getTemplateTypeFromMappedType(source); + var indexedAccessType = getIndexedAccessType(target, getTypeParameterFromMappedType(source)); + if (result = isRelatedTo(templateType, indexedAccessType, 3 /* RecursionFlags.Both */, reportErrors)) { + return result; + } + } + } + if (relation === comparableRelation && sourceFlags & 262144 /* TypeFlags.TypeParameter */) { + // This is a carve-out in comparability to essentially forbid comparing a type parameter + // with another type parameter unless one extends the other. (Remember: comparability is mostly bidirectional!) + var constraint = getConstraintOfTypeParameter(source); + if (constraint && hasNonCircularBaseConstraint(source)) { + while (constraint && someType(constraint, function (c) { return !!(c.flags & 262144 /* TypeFlags.TypeParameter */); })) { + if (result = isRelatedTo(constraint, target, 1 /* RecursionFlags.Source */, /*reportErrors*/ false)) { + return result; + } + constraint = getConstraintOfTypeParameter(constraint); + } + } + return 0 /* Ternary.False */; + } + } + else if (targetFlags & 4194304 /* TypeFlags.Index */) { + var targetType_1 = target.type; + // A keyof S is related to a keyof T if T is related to S. + if (sourceFlags & 4194304 /* TypeFlags.Index */) { + if (result = isRelatedTo(targetType_1, source.type, 3 /* RecursionFlags.Both */, /*reportErrors*/ false)) { + return result; + } + } + if (isTupleType(targetType_1)) { + // An index type can have a tuple type target when the tuple type contains variadic elements. + // Check if the source is related to the known keys of the tuple type. + if (result = isRelatedTo(source, getKnownKeysOfTupleType(targetType_1), 2 /* RecursionFlags.Target */, reportErrors)) { + return result; + } + } + else { + // A type S is assignable to keyof T if S is assignable to keyof C, where C is the + // simplified form of T or, if T doesn't simplify, the constraint of T. + var constraint = getSimplifiedTypeOrConstraint(targetType_1); + if (constraint) { + // We require Ternary.True here such that circular constraints don't cause + // false positives. For example, given 'T extends { [K in keyof T]: string }', + // 'keyof T' has itself as its constraint and produces a Ternary.Maybe when + // related to other types. + if (isRelatedTo(source, getIndexType(constraint, target.stringsOnly), 2 /* RecursionFlags.Target */, reportErrors) === -1 /* Ternary.True */) { + return -1 /* Ternary.True */; + } + } + else if (isGenericMappedType(targetType_1)) { + // generic mapped types that don't simplify or have a constraint still have a very simple set of keys we can compare against + // - their nameType or constraintType. + // In many ways, this comparison is a deferred version of what `getIndexTypeForMappedType` does to actually resolve the keys for _non_-generic types + var nameType_1 = getNameTypeFromMappedType(targetType_1); + var constraintType = getConstraintTypeFromMappedType(targetType_1); + var targetKeys = void 0; + if (nameType_1 && isMappedTypeWithKeyofConstraintDeclaration(targetType_1)) { + // we need to get the apparent mappings and union them with the generic mappings, since some properties may be + // missing from the `constraintType` which will otherwise be mapped in the object + var modifiersType = getApparentType(getModifiersTypeFromMappedType(targetType_1)); + var mappedKeys_1 = []; + forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, 8576 /* TypeFlags.StringOrNumberLiteralOrUnique */, + /*stringsOnly*/ false, function (t) { return void mappedKeys_1.push(instantiateType(nameType_1, appendTypeMapping(targetType_1.mapper, getTypeParameterFromMappedType(targetType_1), t))); }); + // We still need to include the non-apparent (and thus still generic) keys in the target side of the comparison (in case they're in the source side) + targetKeys = getUnionType(__spreadArray(__spreadArray([], mappedKeys_1, true), [nameType_1], false)); + } + else { + targetKeys = nameType_1 || constraintType; + } + if (isRelatedTo(source, targetKeys, 2 /* RecursionFlags.Target */, reportErrors) === -1 /* Ternary.True */) { + return -1 /* Ternary.True */; + } + } + } + } + else if (targetFlags & 8388608 /* TypeFlags.IndexedAccess */) { + if (sourceFlags & 8388608 /* TypeFlags.IndexedAccess */) { + // Relate components directly before falling back to constraint relationships + // A type S[K] is related to a type T[J] if S is related to T and K is related to J. + if (result = isRelatedTo(source.objectType, target.objectType, 3 /* RecursionFlags.Both */, reportErrors)) { + result &= isRelatedTo(source.indexType, target.indexType, 3 /* RecursionFlags.Both */, reportErrors); + } + if (result) { + return result; + } + if (reportErrors) { + originalErrorInfo = errorInfo; + } + } + // A type S is related to a type T[K] if S is related to C, where C is the base + // constraint of T[K] for writing. + if (relation === assignableRelation || relation === comparableRelation) { + var objectType = target.objectType; + var indexType = target.indexType; + var baseObjectType = getBaseConstraintOfType(objectType) || objectType; + var baseIndexType = getBaseConstraintOfType(indexType) || indexType; + if (!isGenericObjectType(baseObjectType) && !isGenericIndexType(baseIndexType)) { + var accessFlags = 4 /* AccessFlags.Writing */ | (baseObjectType !== objectType ? 2 /* AccessFlags.NoIndexSignatures */ : 0); + var constraint = getIndexedAccessTypeOrUndefined(baseObjectType, baseIndexType, accessFlags); + if (constraint) { + if (reportErrors && originalErrorInfo) { + // create a new chain for the constraint error + resetErrorInfo(saveErrorInfo); + } + if (result = isRelatedTo(source, constraint, 2 /* RecursionFlags.Target */, reportErrors, /* headMessage */ undefined, intersectionState)) { + return result; + } + // prefer the shorter chain of the constraint comparison chain, and the direct comparison chain + if (reportErrors && originalErrorInfo && errorInfo) { + errorInfo = countMessageChainBreadth([originalErrorInfo]) <= countMessageChainBreadth([errorInfo]) ? originalErrorInfo : errorInfo; + } + } + } + } + if (reportErrors) { + originalErrorInfo = undefined; + } + } + else if (isGenericMappedType(target) && relation !== identityRelation) { + // Check if source type `S` is related to target type `{ [P in Q]: T }` or `{ [P in Q as R]: T}`. + var keysRemapped = !!target.declaration.nameType; + var templateType = getTemplateTypeFromMappedType(target); + var modifiers = getMappedTypeModifiers(target); + if (!(modifiers & 8 /* MappedTypeModifiers.ExcludeOptional */)) { + // If the mapped type has shape `{ [P in Q]: T[P] }`, + // source `S` is related to target if `T` = `S`, i.e. `S` is related to `{ [P in Q]: S[P] }`. + if (!keysRemapped && templateType.flags & 8388608 /* TypeFlags.IndexedAccess */ && templateType.objectType === source && + templateType.indexType === getTypeParameterFromMappedType(target)) { + return -1 /* Ternary.True */; + } + if (!isGenericMappedType(source)) { + // If target has shape `{ [P in Q as R]: T}`, then its keys have type `R`. + // If target has shape `{ [P in Q]: T }`, then its keys have type `Q`. + var targetKeys = keysRemapped ? getNameTypeFromMappedType(target) : getConstraintTypeFromMappedType(target); + // Type of the keys of source type `S`, i.e. `keyof S`. + var sourceKeys = getIndexType(source, /*stringsOnly*/ undefined, /*noIndexSignatures*/ true); + var includeOptional = modifiers & 4 /* MappedTypeModifiers.IncludeOptional */; + var filteredByApplicability = includeOptional ? intersectTypes(targetKeys, sourceKeys) : undefined; + // A source type `S` is related to a target type `{ [P in Q]: T }` if `Q` is related to `keyof S` and `S[Q]` is related to `T`. + // A source type `S` is related to a target type `{ [P in Q as R]: T }` if `R` is related to `keyof S` and `S[R]` is related to `T. + // A source type `S` is related to a target type `{ [P in Q]?: T }` if some constituent `Q'` of `Q` is related to `keyof S` and `S[Q']` is related to `T`. + // A source type `S` is related to a target type `{ [P in Q as R]?: T }` if some constituent `R'` of `R` is related to `keyof S` and `S[R']` is related to `T`. + if (includeOptional + ? !(filteredByApplicability.flags & 131072 /* TypeFlags.Never */) + : isRelatedTo(targetKeys, sourceKeys, 3 /* RecursionFlags.Both */)) { + var templateType_1 = getTemplateTypeFromMappedType(target); + var typeParameter = getTypeParameterFromMappedType(target); + // Fastpath: When the template type has the form `Obj[P]` where `P` is the mapped type parameter, directly compare source `S` with `Obj` + // to avoid creating the (potentially very large) number of new intermediate types made by manufacturing `S[P]`. + var nonNullComponent = extractTypesOfKind(templateType_1, ~98304 /* TypeFlags.Nullable */); + if (!keysRemapped && nonNullComponent.flags & 8388608 /* TypeFlags.IndexedAccess */ && nonNullComponent.indexType === typeParameter) { + if (result = isRelatedTo(source, nonNullComponent.objectType, 2 /* RecursionFlags.Target */, reportErrors)) { + return result; + } + } + else { + // We need to compare the type of a property on the source type `S` to the type of the same property on the target type, + // so we need to construct an indexing type representing a property, and then use indexing type to index the source type for comparison. + // If the target type has shape `{ [P in Q]: T }`, then a property of the target has type `P`. + // If the target type has shape `{ [P in Q]?: T }`, then a property of the target has type `P`, + // but the property is optional, so we only want to compare properties `P` that are common between `keyof S` and `Q`. + // If the target type has shape `{ [P in Q as R]: T }`, then a property of the target has type `R`. + // If the target type has shape `{ [P in Q as R]?: T }`, then a property of the target has type `R`, + // but the property is optional, so we only want to compare properties `R` that are common between `keyof S` and `R`. + var indexingType = keysRemapped + ? (filteredByApplicability || targetKeys) + : filteredByApplicability + ? getIntersectionType([filteredByApplicability, typeParameter]) + : typeParameter; + var indexedAccessType = getIndexedAccessType(source, indexingType); + // Compare `S[indexingType]` to `T`, where `T` is the type of a property of the target type. + if (result = isRelatedTo(indexedAccessType, templateType_1, 3 /* RecursionFlags.Both */, reportErrors)) { + return result; + } + } + } + originalErrorInfo = errorInfo; + resetErrorInfo(saveErrorInfo); + } + } + } + else if (targetFlags & 16777216 /* TypeFlags.Conditional */) { + // If we reach 10 levels of nesting for the same conditional type, assume it is an infinitely expanding recursive + // conditional type and bail out with a Ternary.Maybe result. + if (isDeeplyNestedType(target, targetStack, targetDepth, 10)) { + return 3 /* Ternary.Maybe */; + } + var c = target; + // We check for a relationship to a conditional type target only when the conditional type has no + // 'infer' positions and is not distributive or is distributive but doesn't reference the check type + // parameter in either of the result types. + if (!c.root.inferTypeParameters && !isDistributionDependent(c.root)) { + // Check if the conditional is always true or always false but still deferred for distribution purposes. + var skipTrue = !isTypeAssignableTo(getPermissiveInstantiation(c.checkType), getPermissiveInstantiation(c.extendsType)); + var skipFalse = !skipTrue && isTypeAssignableTo(getRestrictiveInstantiation(c.checkType), getRestrictiveInstantiation(c.extendsType)); + // TODO: Find a nice way to include potential conditional type breakdowns in error output, if they seem good (they usually don't) + if (result = skipTrue ? -1 /* Ternary.True */ : isRelatedTo(source, getTrueTypeFromConditionalType(c), 2 /* RecursionFlags.Target */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState)) { + result &= skipFalse ? -1 /* Ternary.True */ : isRelatedTo(source, getFalseTypeFromConditionalType(c), 2 /* RecursionFlags.Target */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState); + if (result) { + return result; + } + } + } + } + else if (targetFlags & 134217728 /* TypeFlags.TemplateLiteral */) { + if (sourceFlags & 134217728 /* TypeFlags.TemplateLiteral */) { + if (relation === comparableRelation) { + return templateLiteralTypesDefinitelyUnrelated(source, target) ? 0 /* Ternary.False */ : -1 /* Ternary.True */; + } + // Report unreliable variance for type variables referenced in template literal type placeholders. + // For example, `foo-${number}` is related to `foo-${string}` even though number isn't related to string. + instantiateType(source, reportUnreliableMapper); + } + if (isTypeMatchedByTemplateLiteralType(source, target)) { + return -1 /* Ternary.True */; + } + } + else if (target.flags & 268435456 /* TypeFlags.StringMapping */) { + if (!(source.flags & 268435456 /* TypeFlags.StringMapping */)) { + if (isMemberOfStringMapping(source, target)) { + return -1 /* Ternary.True */; + } + } + } + if (sourceFlags & 8650752 /* TypeFlags.TypeVariable */) { + // IndexedAccess comparisons are handled above in the `targetFlags & TypeFlage.IndexedAccess` branch + if (!(sourceFlags & 8388608 /* TypeFlags.IndexedAccess */ && targetFlags & 8388608 /* TypeFlags.IndexedAccess */)) { + var constraint = getConstraintOfType(source) || unknownType; + // hi-speed no-this-instantiation check (less accurate, but avoids costly `this`-instantiation when the constraint will suffice), see #28231 for report on why this is needed + if (result = isRelatedTo(constraint, target, 1 /* RecursionFlags.Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState)) { + return result; + } + // slower, fuller, this-instantiated check (necessary when comparing raw `this` types from base classes), see `subclassWithPolymorphicThisIsAssignable.ts` test for example + else if (result = isRelatedTo(getTypeWithThisArgument(constraint, source), target, 1 /* RecursionFlags.Source */, reportErrors && constraint !== unknownType && !(targetFlags & sourceFlags & 262144 /* TypeFlags.TypeParameter */), /*headMessage*/ undefined, intersectionState)) { + return result; + } + if (isMappedTypeGenericIndexedAccess(source)) { + // For an indexed access type { [P in K]: E}[X], above we have already explored an instantiation of E with X + // substituted for P. We also want to explore type { [P in K]: E }[C], where C is the constraint of X. + var indexConstraint = getConstraintOfType(source.indexType); + if (indexConstraint) { + if (result = isRelatedTo(getIndexedAccessType(source.objectType, indexConstraint), target, 1 /* RecursionFlags.Source */, reportErrors)) { + return result; + } + } + } + } + } + else if (sourceFlags & 4194304 /* TypeFlags.Index */) { + if (result = isRelatedTo(keyofConstraintType, target, 1 /* RecursionFlags.Source */, reportErrors)) { + return result; + } + } + else if (sourceFlags & 134217728 /* TypeFlags.TemplateLiteral */ && !(targetFlags & 524288 /* TypeFlags.Object */)) { + if (!(targetFlags & 134217728 /* TypeFlags.TemplateLiteral */)) { + var constraint = getBaseConstraintOfType(source); + if (constraint && constraint !== source && (result = isRelatedTo(constraint, target, 1 /* RecursionFlags.Source */, reportErrors))) { + return result; + } + } + } + else if (sourceFlags & 268435456 /* TypeFlags.StringMapping */) { + if (targetFlags & 268435456 /* TypeFlags.StringMapping */) { + if (source.symbol !== target.symbol) { + return 0 /* Ternary.False */; + } + if (result = isRelatedTo(source.type, target.type, 3 /* RecursionFlags.Both */, reportErrors)) { + return result; + } + } + else { + var constraint = getBaseConstraintOfType(source); + if (constraint && (result = isRelatedTo(constraint, target, 1 /* RecursionFlags.Source */, reportErrors))) { + return result; + } + } + } + else if (sourceFlags & 16777216 /* TypeFlags.Conditional */) { + // If we reach 10 levels of nesting for the same conditional type, assume it is an infinitely expanding recursive + // conditional type and bail out with a Ternary.Maybe result. + if (isDeeplyNestedType(source, sourceStack, sourceDepth, 10)) { + return 3 /* Ternary.Maybe */; + } + if (targetFlags & 16777216 /* TypeFlags.Conditional */) { + // Two conditional types 'T1 extends U1 ? X1 : Y1' and 'T2 extends U2 ? X2 : Y2' are related if + // one of T1 and T2 is related to the other, U1 and U2 are identical types, X1 is related to X2, + // and Y1 is related to Y2. + var sourceParams = source.root.inferTypeParameters; + var sourceExtends = source.extendsType; + var mapper = void 0; + if (sourceParams) { + // If the source has infer type parameters, we instantiate them in the context of the target + var ctx = createInferenceContext(sourceParams, /*signature*/ undefined, 0 /* InferenceFlags.None */, isRelatedToWorker); + inferTypes(ctx.inferences, target.extendsType, sourceExtends, 512 /* InferencePriority.NoConstraints */ | 1024 /* InferencePriority.AlwaysStrict */); + sourceExtends = instantiateType(sourceExtends, ctx.mapper); + mapper = ctx.mapper; + } + if (isTypeIdenticalTo(sourceExtends, target.extendsType) && + (isRelatedTo(source.checkType, target.checkType, 3 /* RecursionFlags.Both */) || isRelatedTo(target.checkType, source.checkType, 3 /* RecursionFlags.Both */))) { + if (result = isRelatedTo(instantiateType(getTrueTypeFromConditionalType(source), mapper), getTrueTypeFromConditionalType(target), 3 /* RecursionFlags.Both */, reportErrors)) { + result &= isRelatedTo(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target), 3 /* RecursionFlags.Both */, reportErrors); + } + if (result) { + return result; + } + } + } + else { + // conditionals aren't related to one another via distributive constraint as it is much too inaccurate and allows way + // more assignments than are desirable (since it maps the source check type to its constraint, it loses information) + var distributiveConstraint = hasNonCircularBaseConstraint(source) ? getConstraintOfDistributiveConditionalType(source) : undefined; + if (distributiveConstraint) { + if (result = isRelatedTo(distributiveConstraint, target, 1 /* RecursionFlags.Source */, reportErrors)) { + return result; + } + } + } + // conditionals _can_ be related to one another via normal constraint, as, eg, `A extends B ? O : never` should be assignable to `O` + // when `O` is a conditional (`never` is trivially assignable to `O`, as is `O`!). + var defaultConstraint = getDefaultConstraintOfConditionalType(source); + if (defaultConstraint) { + if (result = isRelatedTo(defaultConstraint, target, 1 /* RecursionFlags.Source */, reportErrors)) { + return result; + } + } + } + else { + // An empty object type is related to any mapped type that includes a '?' modifier. + if (relation !== subtypeRelation && relation !== strictSubtypeRelation && isPartialMappedType(target) && isEmptyObjectType(source)) { + return -1 /* Ternary.True */; + } + if (isGenericMappedType(target)) { + if (isGenericMappedType(source)) { + if (result = mappedTypeRelatedTo(source, target, reportErrors)) { + return result; + } + } + return 0 /* Ternary.False */; + } + var sourceIsPrimitive = !!(sourceFlags & 131068 /* TypeFlags.Primitive */); + if (relation !== identityRelation) { + source = getApparentType(source); + sourceFlags = source.flags; + } + else if (isGenericMappedType(source)) { + return 0 /* Ternary.False */; + } + if (ts.getObjectFlags(source) & 4 /* ObjectFlags.Reference */ && ts.getObjectFlags(target) & 4 /* ObjectFlags.Reference */ && source.target === target.target && + !isTupleType(source) && !(isMarkerType(source) || isMarkerType(target))) { + // When strictNullChecks is disabled, the element type of the empty array literal is undefinedWideningType, + // and an empty array literal wouldn't be assignable to a `never[]` without this check. + if (isEmptyArrayLiteralType(source)) { + return -1 /* Ternary.True */; + } + // We have type references to the same generic type, and the type references are not marker + // type references (which are intended by be compared structurally). Obtain the variance + // information for the type parameters and relate the type arguments accordingly. + var variances = getVariances(source.target); + // We return Ternary.Maybe for a recursive invocation of getVariances (signalled by emptyArray). This + // effectively means we measure variance only from type parameter occurrences that aren't nested in + // recursive instantiations of the generic type. + if (variances === ts.emptyArray) { + return 1 /* Ternary.Unknown */; + } + var varianceResult = relateVariances(getTypeArguments(source), getTypeArguments(target), variances, intersectionState); + if (varianceResult !== undefined) { + return varianceResult; + } + } + else if (isReadonlyArrayType(target) ? isArrayOrTupleType(source) : isArrayType(target) && isTupleType(source) && !source.target.readonly) { + if (relation !== identityRelation) { + return isRelatedTo(getIndexTypeOfType(source, numberType) || anyType, getIndexTypeOfType(target, numberType) || anyType, 3 /* RecursionFlags.Both */, reportErrors); + } + else { + // By flags alone, we know that the `target` is a readonly array while the source is a normal array or tuple + // or `target` is an array and source is a tuple - in both cases the types cannot be identical, by construction + return 0 /* Ternary.False */; + } + } + // Consider a fresh empty object literal type "closed" under the subtype relationship - this way `{} <- {[idx: string]: any} <- fresh({})` + // and not `{} <- fresh({}) <- {[idx: string]: any}` + else if ((relation === subtypeRelation || relation === strictSubtypeRelation) && isEmptyObjectType(target) && ts.getObjectFlags(target) & 8192 /* ObjectFlags.FreshLiteral */ && !isEmptyObjectType(source)) { + return 0 /* Ternary.False */; + } + // Even if relationship doesn't hold for unions, intersections, or generic type references, + // it may hold in a structural comparison. + // In a check of the form X = A & B, we will have previously checked if A relates to X or B relates + // to X. Failing both of those we want to check if the aggregation of A and B's members structurally + // relates to X. Thus, we include intersection types on the source side here. + if (sourceFlags & (524288 /* TypeFlags.Object */ | 2097152 /* TypeFlags.Intersection */) && targetFlags & 524288 /* TypeFlags.Object */) { + // Report structural errors only if we haven't reported any errors yet + var reportStructuralErrors = reportErrors && errorInfo === saveErrorInfo.errorInfo && !sourceIsPrimitive; + result = propertiesRelatedTo(source, target, reportStructuralErrors, /*excludedProperties*/ undefined, intersectionState); + if (result) { + result &= signaturesRelatedTo(source, target, 0 /* SignatureKind.Call */, reportStructuralErrors); + if (result) { + result &= signaturesRelatedTo(source, target, 1 /* SignatureKind.Construct */, reportStructuralErrors); + if (result) { + result &= indexSignaturesRelatedTo(source, target, sourceIsPrimitive, reportStructuralErrors, intersectionState); + } + } + } + if (varianceCheckFailed && result) { + errorInfo = originalErrorInfo || errorInfo || saveErrorInfo.errorInfo; // Use variance error (there is no structural one) and return false + } + else if (result) { + return result; + } + } + // If S is an object type and T is a discriminated union, S may be related to T if + // there exists a constituent of T for every combination of the discriminants of S + // with respect to T. We do not report errors here, as we will use the existing + // error result from checking each constituent of the union. + if (sourceFlags & (524288 /* TypeFlags.Object */ | 2097152 /* TypeFlags.Intersection */) && targetFlags & 1048576 /* TypeFlags.Union */) { + var objectOnlyTarget = extractTypesOfKind(target, 524288 /* TypeFlags.Object */ | 2097152 /* TypeFlags.Intersection */ | 33554432 /* TypeFlags.Substitution */); + if (objectOnlyTarget.flags & 1048576 /* TypeFlags.Union */) { + var result_9 = typeRelatedToDiscriminatedType(source, objectOnlyTarget); + if (result_9) { + return result_9; + } + } + } + } + return 0 /* Ternary.False */; + function countMessageChainBreadth(info) { + if (!info) + return 0; + return ts.reduceLeft(info, function (value, chain) { return value + 1 + countMessageChainBreadth(chain.next); }, 0); + } + function relateVariances(sourceTypeArguments, targetTypeArguments, variances, intersectionState) { + if (result = typeArgumentsRelatedTo(sourceTypeArguments, targetTypeArguments, variances, reportErrors, intersectionState)) { + return result; + } + if (ts.some(variances, function (v) { return !!(v & 24 /* VarianceFlags.AllowsStructuralFallback */); })) { + // If some type parameter was `Unmeasurable` or `Unreliable`, and we couldn't pass by assuming it was identical, then we + // have to allow a structural fallback check + // We elide the variance-based error elaborations, since those might not be too helpful, since we'll potentially + // be assuming identity of the type parameter. + originalErrorInfo = undefined; + resetErrorInfo(saveErrorInfo); + return undefined; + } + var allowStructuralFallback = targetTypeArguments && hasCovariantVoidArgument(targetTypeArguments, variances); + varianceCheckFailed = !allowStructuralFallback; + // The type arguments did not relate appropriately, but it may be because we have no variance + // information (in which case typeArgumentsRelatedTo defaulted to covariance for all type + // arguments). It might also be the case that the target type has a 'void' type argument for + // a covariant type parameter that is only used in return positions within the generic type + // (in which case any type argument is permitted on the source side). In those cases we proceed + // with a structural comparison. Otherwise, we know for certain the instantiations aren't + // related and we can return here. + if (variances !== ts.emptyArray && !allowStructuralFallback) { + // In some cases generic types that are covariant in regular type checking mode become + // invariant in --strictFunctionTypes mode because one or more type parameters are used in + // both co- and contravariant positions. In order to make it easier to diagnose *why* such + // types are invariant, if any of the type parameters are invariant we reset the reported + // errors and instead force a structural comparison (which will include elaborations that + // reveal the reason). + // We can switch on `reportErrors` here, since varianceCheckFailed guarantees we return `False`, + // we can return `False` early here to skip calculating the structural error message we don't need. + if (varianceCheckFailed && !(reportErrors && ts.some(variances, function (v) { return (v & 7 /* VarianceFlags.VarianceMask */) === 0 /* VarianceFlags.Invariant */; }))) { + return 0 /* Ternary.False */; + } + // We remember the original error information so we can restore it in case the structural + // comparison unexpectedly succeeds. This can happen when the structural comparison result + // is a Ternary.Maybe for example caused by the recursion depth limiter. + originalErrorInfo = errorInfo; + resetErrorInfo(saveErrorInfo); + } + } + } + // A type [P in S]: X is related to a type [Q in T]: Y if T is related to S and X' is + // related to Y, where X' is an instantiation of X in which P is replaced with Q. Notice + // that S and T are contra-variant whereas X and Y are co-variant. + function mappedTypeRelatedTo(source, target, reportErrors) { + var modifiersRelated = relation === comparableRelation || (relation === identityRelation ? getMappedTypeModifiers(source) === getMappedTypeModifiers(target) : + getCombinedMappedTypeOptionality(source) <= getCombinedMappedTypeOptionality(target)); + if (modifiersRelated) { + var result_10; + var targetConstraint = getConstraintTypeFromMappedType(target); + var sourceConstraint = instantiateType(getConstraintTypeFromMappedType(source), getCombinedMappedTypeOptionality(source) < 0 ? reportUnmeasurableMapper : reportUnreliableMapper); + if (result_10 = isRelatedTo(targetConstraint, sourceConstraint, 3 /* RecursionFlags.Both */, reportErrors)) { + var mapper = createTypeMapper([getTypeParameterFromMappedType(source)], [getTypeParameterFromMappedType(target)]); + if (instantiateType(getNameTypeFromMappedType(source), mapper) === instantiateType(getNameTypeFromMappedType(target), mapper)) { + return result_10 & isRelatedTo(instantiateType(getTemplateTypeFromMappedType(source), mapper), getTemplateTypeFromMappedType(target), 3 /* RecursionFlags.Both */, reportErrors); + } + } + } + return 0 /* Ternary.False */; + } + function typeRelatedToDiscriminatedType(source, target) { + // 1. Generate the combinations of discriminant properties & types 'source' can satisfy. + // a. If the number of combinations is above a set limit, the comparison is too complex. + // 2. Filter 'target' to the subset of types whose discriminants exist in the matrix. + // a. If 'target' does not satisfy all discriminants in the matrix, 'source' is not related. + // 3. For each type in the filtered 'target', determine if all non-discriminant properties of + // 'target' are related to a property in 'source'. + // + // NOTE: See ~/tests/cases/conformance/types/typeRelationships/assignmentCompatibility/assignmentCompatWithDiscriminatedUnion.ts + // for examples. + var sourceProperties = getPropertiesOfType(source); + var sourcePropertiesFiltered = findDiscriminantProperties(sourceProperties, target); + if (!sourcePropertiesFiltered) + return 0 /* Ternary.False */; + // Though we could compute the number of combinations as we generate + // the matrix, this would incur additional memory overhead due to + // array allocations. To reduce this overhead, we first compute + // the number of combinations to ensure we will not surpass our + // fixed limit before incurring the cost of any allocations: + var numCombinations = 1; + for (var _i = 0, sourcePropertiesFiltered_1 = sourcePropertiesFiltered; _i < sourcePropertiesFiltered_1.length; _i++) { + var sourceProperty = sourcePropertiesFiltered_1[_i]; + numCombinations *= countTypes(getNonMissingTypeOfSymbol(sourceProperty)); + if (numCombinations > 25) { + // We've reached the complexity limit. + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes" /* tracing.Phase.CheckTypes */, "typeRelatedToDiscriminatedType_DepthLimit", { sourceId: source.id, targetId: target.id, numCombinations: numCombinations }); + return 0 /* Ternary.False */; + } + } + // Compute the set of types for each discriminant property. + var sourceDiscriminantTypes = new Array(sourcePropertiesFiltered.length); + var excludedProperties = new ts.Set(); + for (var i = 0; i < sourcePropertiesFiltered.length; i++) { + var sourceProperty = sourcePropertiesFiltered[i]; + var sourcePropertyType = getNonMissingTypeOfSymbol(sourceProperty); + sourceDiscriminantTypes[i] = sourcePropertyType.flags & 1048576 /* TypeFlags.Union */ + ? sourcePropertyType.types + : [sourcePropertyType]; + excludedProperties.add(sourceProperty.escapedName); + } + // Match each combination of the cartesian product of discriminant properties to one or more + // constituents of 'target'. If any combination does not have a match then 'source' is not relatable. + var discriminantCombinations = ts.cartesianProduct(sourceDiscriminantTypes); + var matchingTypes = []; + var _loop_21 = function (combination) { + var hasMatch = false; + outer: for (var _c = 0, _d = target.types; _c < _d.length; _c++) { + var type = _d[_c]; + var _loop_22 = function (i) { + var sourceProperty = sourcePropertiesFiltered[i]; + var targetProperty = getPropertyOfType(type, sourceProperty.escapedName); + if (!targetProperty) + return "continue-outer"; + if (sourceProperty === targetProperty) + return "continue"; + // We compare the source property to the target in the context of a single discriminant type. + var related = propertyRelatedTo(source, target, sourceProperty, targetProperty, function (_) { return combination[i]; }, /*reportErrors*/ false, 0 /* IntersectionState.None */, /*skipOptional*/ strictNullChecks || relation === comparableRelation); + // If the target property could not be found, or if the properties were not related, + // then this constituent is not a match. + if (!related) { + return "continue-outer"; + } + }; + for (var i = 0; i < sourcePropertiesFiltered.length; i++) { + var state_8 = _loop_22(i); + switch (state_8) { + case "continue-outer": continue outer; + } + } + ts.pushIfUnique(matchingTypes, type, ts.equateValues); + hasMatch = true; + } + if (!hasMatch) { + return { value: 0 /* Ternary.False */ }; + } + }; + for (var _a = 0, discriminantCombinations_1 = discriminantCombinations; _a < discriminantCombinations_1.length; _a++) { + var combination = discriminantCombinations_1[_a]; + var state_7 = _loop_21(combination); + if (typeof state_7 === "object") + return state_7.value; + } + // Compare the remaining non-discriminant properties of each match. + var result = -1 /* Ternary.True */; + for (var _b = 0, matchingTypes_1 = matchingTypes; _b < matchingTypes_1.length; _b++) { + var type = matchingTypes_1[_b]; + result &= propertiesRelatedTo(source, type, /*reportErrors*/ false, excludedProperties, 0 /* IntersectionState.None */); + if (result) { + result &= signaturesRelatedTo(source, type, 0 /* SignatureKind.Call */, /*reportStructuralErrors*/ false); + if (result) { + result &= signaturesRelatedTo(source, type, 1 /* SignatureKind.Construct */, /*reportStructuralErrors*/ false); + if (result && !(isTupleType(source) && isTupleType(type))) { + // Comparing numeric index types when both `source` and `type` are tuples is unnecessary as the + // element types should be sufficiently covered by `propertiesRelatedTo`. It also causes problems + // with index type assignability as the types for the excluded discriminants are still included + // in the index type. + result &= indexSignaturesRelatedTo(source, type, /*sourceIsPrimitive*/ false, /*reportStructuralErrors*/ false, 0 /* IntersectionState.None */); + } + } + } + if (!result) { + return result; + } + } + return result; + } + function excludeProperties(properties, excludedProperties) { + if (!excludedProperties || properties.length === 0) + return properties; + var result; + for (var i = 0; i < properties.length; i++) { + if (!excludedProperties.has(properties[i].escapedName)) { + if (result) { + result.push(properties[i]); + } + } + else if (!result) { + result = properties.slice(0, i); + } + } + return result || properties; + } + function isPropertySymbolTypeRelated(sourceProp, targetProp, getTypeOfSourceProperty, reportErrors, intersectionState) { + var targetIsOptional = strictNullChecks && !!(ts.getCheckFlags(targetProp) & 48 /* CheckFlags.Partial */); + var effectiveTarget = addOptionality(getNonMissingTypeOfSymbol(targetProp), /*isProperty*/ false, targetIsOptional); + var effectiveSource = getTypeOfSourceProperty(sourceProp); + return isRelatedTo(effectiveSource, effectiveTarget, 3 /* RecursionFlags.Both */, reportErrors, /*headMessage*/ undefined, intersectionState); + } + function propertyRelatedTo(source, target, sourceProp, targetProp, getTypeOfSourceProperty, reportErrors, intersectionState, skipOptional) { + var sourcePropFlags = ts.getDeclarationModifierFlagsFromSymbol(sourceProp); + var targetPropFlags = ts.getDeclarationModifierFlagsFromSymbol(targetProp); + if (sourcePropFlags & 8 /* ModifierFlags.Private */ || targetPropFlags & 8 /* ModifierFlags.Private */) { + if (sourceProp.valueDeclaration !== targetProp.valueDeclaration) { + if (reportErrors) { + if (sourcePropFlags & 8 /* ModifierFlags.Private */ && targetPropFlags & 8 /* ModifierFlags.Private */) { + reportError(ts.Diagnostics.Types_have_separate_declarations_of_a_private_property_0, symbolToString(targetProp)); + } + else { + reportError(ts.Diagnostics.Property_0_is_private_in_type_1_but_not_in_type_2, symbolToString(targetProp), typeToString(sourcePropFlags & 8 /* ModifierFlags.Private */ ? source : target), typeToString(sourcePropFlags & 8 /* ModifierFlags.Private */ ? target : source)); + } + } + return 0 /* Ternary.False */; + } + } + else if (targetPropFlags & 16 /* ModifierFlags.Protected */) { + if (!isValidOverrideOf(sourceProp, targetProp)) { + if (reportErrors) { + reportError(ts.Diagnostics.Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2, symbolToString(targetProp), typeToString(getDeclaringClass(sourceProp) || source), typeToString(getDeclaringClass(targetProp) || target)); + } + return 0 /* Ternary.False */; + } + } + else if (sourcePropFlags & 16 /* ModifierFlags.Protected */) { + if (reportErrors) { + reportError(ts.Diagnostics.Property_0_is_protected_in_type_1_but_public_in_type_2, symbolToString(targetProp), typeToString(source), typeToString(target)); + } + return 0 /* Ternary.False */; + } + // Ensure {readonly a: whatever} is not a subtype of {a: whatever}, + // while {a: whatever} is a subtype of {readonly a: whatever}. + // This ensures the subtype relationship is ordered, and preventing declaration order + // from deciding which type "wins" in union subtype reduction. + // They're still assignable to one another, since `readonly` doesn't affect assignability. + // This is only applied during the strictSubtypeRelation -- currently used in subtype reduction + if (relation === strictSubtypeRelation && + isReadonlySymbol(sourceProp) && !isReadonlySymbol(targetProp)) { + return 0 /* Ternary.False */; + } + // If the target comes from a partial union prop, allow `undefined` in the target type + var related = isPropertySymbolTypeRelated(sourceProp, targetProp, getTypeOfSourceProperty, reportErrors, intersectionState); + if (!related) { + if (reportErrors) { + reportIncompatibleError(ts.Diagnostics.Types_of_property_0_are_incompatible, symbolToString(targetProp)); + } + return 0 /* Ternary.False */; + } + // When checking for comparability, be more lenient with optional properties. + if (!skipOptional && sourceProp.flags & 16777216 /* SymbolFlags.Optional */ && targetProp.flags & 106500 /* SymbolFlags.ClassMember */ && !(targetProp.flags & 16777216 /* SymbolFlags.Optional */)) { + // TypeScript 1.0 spec (April 2014): 3.8.3 + // S is a subtype of a type T, and T is a supertype of S if ... + // S' and T are object types and, for each member M in T.. + // M is a property and S' contains a property N where + // if M is a required property, N is also a required property + // (M - property in T) + // (N - property in S) + if (reportErrors) { + reportError(ts.Diagnostics.Property_0_is_optional_in_type_1_but_required_in_type_2, symbolToString(targetProp), typeToString(source), typeToString(target)); + } + return 0 /* Ternary.False */; + } + return related; + } + function reportUnmatchedProperty(source, target, unmatchedProperty, requireOptionalProperties) { + var shouldSkipElaboration = false; + // give specific error in case where private names have the same description + if (unmatchedProperty.valueDeclaration + && ts.isNamedDeclaration(unmatchedProperty.valueDeclaration) + && ts.isPrivateIdentifier(unmatchedProperty.valueDeclaration.name) + && source.symbol + && source.symbol.flags & 32 /* SymbolFlags.Class */) { + var privateIdentifierDescription = unmatchedProperty.valueDeclaration.name.escapedText; + var symbolTableKey = ts.getSymbolNameForPrivateIdentifier(source.symbol, privateIdentifierDescription); + if (symbolTableKey && getPropertyOfType(source, symbolTableKey)) { + var sourceName = ts.factory.getDeclarationName(source.symbol.valueDeclaration); + var targetName = ts.factory.getDeclarationName(target.symbol.valueDeclaration); + reportError(ts.Diagnostics.Property_0_in_type_1_refers_to_a_different_member_that_cannot_be_accessed_from_within_type_2, diagnosticName(privateIdentifierDescription), diagnosticName(sourceName.escapedText === "" ? anon : sourceName), diagnosticName(targetName.escapedText === "" ? anon : targetName)); + return; + } + } + var props = ts.arrayFrom(getUnmatchedProperties(source, target, requireOptionalProperties, /*matchDiscriminantProperties*/ false)); + if (!headMessage || (headMessage.code !== ts.Diagnostics.Class_0_incorrectly_implements_interface_1.code && + headMessage.code !== ts.Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass.code)) { + shouldSkipElaboration = true; // Retain top-level error for interface implementing issues, otherwise omit it + } + if (props.length === 1) { + var propName = symbolToString(unmatchedProperty, /*enclosingDeclaration*/ undefined, 0 /* SymbolFlags.None */, 4 /* SymbolFormatFlags.AllowAnyNodeKind */ | 16 /* SymbolFormatFlags.WriteComputedProps */); + reportError.apply(void 0, __spreadArray([ts.Diagnostics.Property_0_is_missing_in_type_1_but_required_in_type_2, propName], getTypeNamesForErrorDisplay(source, target), false)); + if (ts.length(unmatchedProperty.declarations)) { + associateRelatedInfo(ts.createDiagnosticForNode(unmatchedProperty.declarations[0], ts.Diagnostics._0_is_declared_here, propName)); + } + if (shouldSkipElaboration && errorInfo) { + overrideNextErrorInfo++; + } + } + else if (tryElaborateArrayLikeErrors(source, target, /*reportErrors*/ false)) { + if (props.length > 5) { // arbitrary cutoff for too-long list form + reportError(ts.Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more, typeToString(source), typeToString(target), ts.map(props.slice(0, 4), function (p) { return symbolToString(p); }).join(", "), props.length - 4); + } + else { + reportError(ts.Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2, typeToString(source), typeToString(target), ts.map(props, function (p) { return symbolToString(p); }).join(", ")); + } + if (shouldSkipElaboration && errorInfo) { + overrideNextErrorInfo++; + } + } + // No array like or unmatched property error - just issue top level error (errorInfo = undefined) + } + function propertiesRelatedTo(source, target, reportErrors, excludedProperties, intersectionState) { + if (relation === identityRelation) { + return propertiesIdenticalTo(source, target, excludedProperties); + } + var result = -1 /* Ternary.True */; + if (isTupleType(target)) { + if (isArrayOrTupleType(source)) { + if (!target.target.readonly && (isReadonlyArrayType(source) || isTupleType(source) && source.target.readonly)) { + return 0 /* Ternary.False */; + } + var sourceArity = getTypeReferenceArity(source); + var targetArity = getTypeReferenceArity(target); + var sourceRestFlag = isTupleType(source) ? source.target.combinedFlags & 4 /* ElementFlags.Rest */ : 4 /* ElementFlags.Rest */; + var targetRestFlag = target.target.combinedFlags & 4 /* ElementFlags.Rest */; + var sourceMinLength = isTupleType(source) ? source.target.minLength : 0; + var targetMinLength = target.target.minLength; + if (!sourceRestFlag && sourceArity < targetMinLength) { + if (reportErrors) { + reportError(ts.Diagnostics.Source_has_0_element_s_but_target_requires_1, sourceArity, targetMinLength); + } + return 0 /* Ternary.False */; + } + if (!targetRestFlag && targetArity < sourceMinLength) { + if (reportErrors) { + reportError(ts.Diagnostics.Source_has_0_element_s_but_target_allows_only_1, sourceMinLength, targetArity); + } + return 0 /* Ternary.False */; + } + if (!targetRestFlag && (sourceRestFlag || targetArity < sourceArity)) { + if (reportErrors) { + if (sourceMinLength < targetMinLength) { + reportError(ts.Diagnostics.Target_requires_0_element_s_but_source_may_have_fewer, targetMinLength); + } + else { + reportError(ts.Diagnostics.Target_allows_only_0_element_s_but_source_may_have_more, targetArity); + } + } + return 0 /* Ternary.False */; + } + var sourceTypeArguments = getTypeArguments(source); + var targetTypeArguments = getTypeArguments(target); + var startCount = Math.min(isTupleType(source) ? getStartElementCount(source.target, 11 /* ElementFlags.NonRest */) : 0, getStartElementCount(target.target, 11 /* ElementFlags.NonRest */)); + var endCount = Math.min(isTupleType(source) ? getEndElementCount(source.target, 11 /* ElementFlags.NonRest */) : 0, targetRestFlag ? getEndElementCount(target.target, 11 /* ElementFlags.NonRest */) : 0); + var canExcludeDiscriminants = !!excludedProperties; + for (var i = 0; i < targetArity; i++) { + var sourceIndex = i < targetArity - endCount ? i : i + sourceArity - targetArity; + var sourceFlags = isTupleType(source) && (i < startCount || i >= targetArity - endCount) ? source.target.elementFlags[sourceIndex] : 4 /* ElementFlags.Rest */; + var targetFlags = target.target.elementFlags[i]; + if (targetFlags & 8 /* ElementFlags.Variadic */ && !(sourceFlags & 8 /* ElementFlags.Variadic */)) { + if (reportErrors) { + reportError(ts.Diagnostics.Source_provides_no_match_for_variadic_element_at_position_0_in_target, i); + } + return 0 /* Ternary.False */; + } + if (sourceFlags & 8 /* ElementFlags.Variadic */ && !(targetFlags & 12 /* ElementFlags.Variable */)) { + if (reportErrors) { + reportError(ts.Diagnostics.Variadic_element_at_position_0_in_source_does_not_match_element_at_position_1_in_target, sourceIndex, i); + } + return 0 /* Ternary.False */; + } + if (targetFlags & 1 /* ElementFlags.Required */ && !(sourceFlags & 1 /* ElementFlags.Required */)) { + if (reportErrors) { + reportError(ts.Diagnostics.Source_provides_no_match_for_required_element_at_position_0_in_target, i); + } + return 0 /* Ternary.False */; + } + // We can only exclude discriminant properties if we have not yet encountered a variable-length element. + if (canExcludeDiscriminants) { + if (sourceFlags & 12 /* ElementFlags.Variable */ || targetFlags & 12 /* ElementFlags.Variable */) { + canExcludeDiscriminants = false; + } + if (canExcludeDiscriminants && (excludedProperties === null || excludedProperties === void 0 ? void 0 : excludedProperties.has(("" + i)))) { + continue; + } + } + var sourceType = !isTupleType(source) ? sourceTypeArguments[0] : + i < startCount || i >= targetArity - endCount ? removeMissingType(sourceTypeArguments[sourceIndex], !!(sourceFlags & targetFlags & 2 /* ElementFlags.Optional */)) : + getElementTypeOfSliceOfTupleType(source, startCount, endCount) || neverType; + var targetType = targetTypeArguments[i]; + var targetCheckType = sourceFlags & 8 /* ElementFlags.Variadic */ && targetFlags & 4 /* ElementFlags.Rest */ ? createArrayType(targetType) : + removeMissingType(targetType, !!(targetFlags & 2 /* ElementFlags.Optional */)); + var related = isRelatedTo(sourceType, targetCheckType, 3 /* RecursionFlags.Both */, reportErrors, /*headMessage*/ undefined, intersectionState); + if (!related) { + if (reportErrors && (targetArity > 1 || sourceArity > 1)) { + if (i < startCount || i >= targetArity - endCount || sourceArity - startCount - endCount === 1) { + reportIncompatibleError(ts.Diagnostics.Type_at_position_0_in_source_is_not_compatible_with_type_at_position_1_in_target, sourceIndex, i); + } + else { + reportIncompatibleError(ts.Diagnostics.Type_at_positions_0_through_1_in_source_is_not_compatible_with_type_at_position_2_in_target, startCount, sourceArity - endCount - 1, i); + } + } + return 0 /* Ternary.False */; + } + result &= related; + } + return result; + } + if (target.target.combinedFlags & 12 /* ElementFlags.Variable */) { + return 0 /* Ternary.False */; + } + } + var requireOptionalProperties = (relation === subtypeRelation || relation === strictSubtypeRelation) && !isObjectLiteralType(source) && !isEmptyArrayLiteralType(source) && !isTupleType(source); + var unmatchedProperty = getUnmatchedProperty(source, target, requireOptionalProperties, /*matchDiscriminantProperties*/ false); + if (unmatchedProperty) { + if (reportErrors && shouldReportUnmatchedPropertyError(source, target)) { + reportUnmatchedProperty(source, target, unmatchedProperty, requireOptionalProperties); + } + return 0 /* Ternary.False */; + } + if (isObjectLiteralType(target)) { + for (var _i = 0, _a = excludeProperties(getPropertiesOfType(source), excludedProperties); _i < _a.length; _i++) { + var sourceProp = _a[_i]; + if (!getPropertyOfObjectType(target, sourceProp.escapedName)) { + var sourceType = getTypeOfSymbol(sourceProp); + if (!(sourceType.flags & 32768 /* TypeFlags.Undefined */)) { + if (reportErrors) { + reportError(ts.Diagnostics.Property_0_does_not_exist_on_type_1, symbolToString(sourceProp), typeToString(target)); + } + return 0 /* Ternary.False */; + } + } + } + } + // We only call this for union target types when we're attempting to do excess property checking - in those cases, we want to get _all possible props_ + // from the target union, across all members + var properties = getPropertiesOfType(target); + var numericNamesOnly = isTupleType(source) && isTupleType(target); + for (var _b = 0, _c = excludeProperties(properties, excludedProperties); _b < _c.length; _b++) { + var targetProp = _c[_b]; + var name = targetProp.escapedName; + if (!(targetProp.flags & 4194304 /* SymbolFlags.Prototype */) && (!numericNamesOnly || ts.isNumericLiteralName(name) || name === "length")) { + var sourceProp = getPropertyOfType(source, name); + if (sourceProp && sourceProp !== targetProp) { + var related = propertyRelatedTo(source, target, sourceProp, targetProp, getNonMissingTypeOfSymbol, reportErrors, intersectionState, relation === comparableRelation); + if (!related) { + return 0 /* Ternary.False */; + } + result &= related; + } + } + } + return result; + } + function propertiesIdenticalTo(source, target, excludedProperties) { + if (!(source.flags & 524288 /* TypeFlags.Object */ && target.flags & 524288 /* TypeFlags.Object */)) { + return 0 /* Ternary.False */; + } + var sourceProperties = excludeProperties(getPropertiesOfObjectType(source), excludedProperties); + var targetProperties = excludeProperties(getPropertiesOfObjectType(target), excludedProperties); + if (sourceProperties.length !== targetProperties.length) { + return 0 /* Ternary.False */; + } + var result = -1 /* Ternary.True */; + for (var _i = 0, sourceProperties_1 = sourceProperties; _i < sourceProperties_1.length; _i++) { + var sourceProp = sourceProperties_1[_i]; + var targetProp = getPropertyOfObjectType(target, sourceProp.escapedName); + if (!targetProp) { + return 0 /* Ternary.False */; + } + var related = compareProperties(sourceProp, targetProp, isRelatedTo); + if (!related) { + return 0 /* Ternary.False */; + } + result &= related; + } + return result; + } + function signaturesRelatedTo(source, target, kind, reportErrors) { + var _a, _b; + if (relation === identityRelation) { + return signaturesIdenticalTo(source, target, kind); + } + if (target === anyFunctionType || source === anyFunctionType) { + return -1 /* Ternary.True */; + } + var sourceIsJSConstructor = source.symbol && isJSConstructor(source.symbol.valueDeclaration); + var targetIsJSConstructor = target.symbol && isJSConstructor(target.symbol.valueDeclaration); + var sourceSignatures = getSignaturesOfType(source, (sourceIsJSConstructor && kind === 1 /* SignatureKind.Construct */) ? + 0 /* SignatureKind.Call */ : kind); + var targetSignatures = getSignaturesOfType(target, (targetIsJSConstructor && kind === 1 /* SignatureKind.Construct */) ? + 0 /* SignatureKind.Call */ : kind); + if (kind === 1 /* SignatureKind.Construct */ && sourceSignatures.length && targetSignatures.length) { + var sourceIsAbstract = !!(sourceSignatures[0].flags & 4 /* SignatureFlags.Abstract */); + var targetIsAbstract = !!(targetSignatures[0].flags & 4 /* SignatureFlags.Abstract */); + if (sourceIsAbstract && !targetIsAbstract) { + // An abstract constructor type is not assignable to a non-abstract constructor type + // as it would otherwise be possible to new an abstract class. Note that the assignability + // check we perform for an extends clause excludes construct signatures from the target, + // so this check never proceeds. + if (reportErrors) { + reportError(ts.Diagnostics.Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type); + } + return 0 /* Ternary.False */; + } + if (!constructorVisibilitiesAreCompatible(sourceSignatures[0], targetSignatures[0], reportErrors)) { + return 0 /* Ternary.False */; + } + } + var result = -1 /* Ternary.True */; + var incompatibleReporter = kind === 1 /* SignatureKind.Construct */ ? reportIncompatibleConstructSignatureReturn : reportIncompatibleCallSignatureReturn; + var sourceObjectFlags = ts.getObjectFlags(source); + var targetObjectFlags = ts.getObjectFlags(target); + if (sourceObjectFlags & 64 /* ObjectFlags.Instantiated */ && targetObjectFlags & 64 /* ObjectFlags.Instantiated */ && source.symbol === target.symbol || + sourceObjectFlags & 4 /* ObjectFlags.Reference */ && targetObjectFlags & 4 /* ObjectFlags.Reference */ && source.target === target.target) { + // We have instantiations of the same anonymous type (which typically will be the type of a + // method). Simply do a pairwise comparison of the signatures in the two signature lists instead + // of the much more expensive N * M comparison matrix we explore below. We erase type parameters + // as they are known to always be the same. + for (var i = 0; i < targetSignatures.length; i++) { + var related = signatureRelatedTo(sourceSignatures[i], targetSignatures[i], /*erase*/ true, reportErrors, incompatibleReporter(sourceSignatures[i], targetSignatures[i])); + if (!related) { + return 0 /* Ternary.False */; + } + result &= related; + } + } + else if (sourceSignatures.length === 1 && targetSignatures.length === 1) { + // For simple functions (functions with a single signature) we only erase type parameters for + // the comparable relation. Otherwise, if the source signature is generic, we instantiate it + // in the context of the target signature before checking the relationship. Ideally we'd do + // this regardless of the number of signatures, but the potential costs are prohibitive due + // to the quadratic nature of the logic below. + var eraseGenerics = relation === comparableRelation || !!compilerOptions.noStrictGenericChecks; + var sourceSignature = ts.first(sourceSignatures); + var targetSignature = ts.first(targetSignatures); + result = signatureRelatedTo(sourceSignature, targetSignature, eraseGenerics, reportErrors, incompatibleReporter(sourceSignature, targetSignature)); + if (!result && reportErrors && kind === 1 /* SignatureKind.Construct */ && (sourceObjectFlags & targetObjectFlags) && + (((_a = targetSignature.declaration) === null || _a === void 0 ? void 0 : _a.kind) === 173 /* SyntaxKind.Constructor */ || ((_b = sourceSignature.declaration) === null || _b === void 0 ? void 0 : _b.kind) === 173 /* SyntaxKind.Constructor */)) { + var constructSignatureToString = function (signature) { + return signatureToString(signature, /*enclosingDeclaration*/ undefined, 262144 /* TypeFormatFlags.WriteArrowStyleSignature */, kind); + }; + reportError(ts.Diagnostics.Type_0_is_not_assignable_to_type_1, constructSignatureToString(sourceSignature), constructSignatureToString(targetSignature)); + reportError(ts.Diagnostics.Types_of_construct_signatures_are_incompatible); + return result; + } + } + else { + outer: for (var _i = 0, targetSignatures_1 = targetSignatures; _i < targetSignatures_1.length; _i++) { + var t = targetSignatures_1[_i]; + var saveErrorInfo = captureErrorCalculationState(); + // Only elaborate errors from the first failure + var shouldElaborateErrors = reportErrors; + for (var _c = 0, sourceSignatures_1 = sourceSignatures; _c < sourceSignatures_1.length; _c++) { + var s = sourceSignatures_1[_c]; + var related = signatureRelatedTo(s, t, /*erase*/ true, shouldElaborateErrors, incompatibleReporter(s, t)); + if (related) { + result &= related; + resetErrorInfo(saveErrorInfo); + continue outer; + } + shouldElaborateErrors = false; + } + if (shouldElaborateErrors) { + reportError(ts.Diagnostics.Type_0_provides_no_match_for_the_signature_1, typeToString(source), signatureToString(t, /*enclosingDeclaration*/ undefined, /*flags*/ undefined, kind)); + } + return 0 /* Ternary.False */; + } + } + return result; + } + function shouldReportUnmatchedPropertyError(source, target) { + var typeCallSignatures = getSignaturesOfStructuredType(source, 0 /* SignatureKind.Call */); + var typeConstructSignatures = getSignaturesOfStructuredType(source, 1 /* SignatureKind.Construct */); + var typeProperties = getPropertiesOfObjectType(source); + if ((typeCallSignatures.length || typeConstructSignatures.length) && !typeProperties.length) { + if ((getSignaturesOfType(target, 0 /* SignatureKind.Call */).length && typeCallSignatures.length) || + (getSignaturesOfType(target, 1 /* SignatureKind.Construct */).length && typeConstructSignatures.length)) { + return true; // target has similar signature kinds to source, still focus on the unmatched property + } + return false; + } + return true; + } + function reportIncompatibleCallSignatureReturn(siga, sigb) { + if (siga.parameters.length === 0 && sigb.parameters.length === 0) { + return function (source, target) { return reportIncompatibleError(ts.Diagnostics.Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1, typeToString(source), typeToString(target)); }; + } + return function (source, target) { return reportIncompatibleError(ts.Diagnostics.Call_signature_return_types_0_and_1_are_incompatible, typeToString(source), typeToString(target)); }; + } + function reportIncompatibleConstructSignatureReturn(siga, sigb) { + if (siga.parameters.length === 0 && sigb.parameters.length === 0) { + return function (source, target) { return reportIncompatibleError(ts.Diagnostics.Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1, typeToString(source), typeToString(target)); }; + } + return function (source, target) { return reportIncompatibleError(ts.Diagnostics.Construct_signature_return_types_0_and_1_are_incompatible, typeToString(source), typeToString(target)); }; + } + /** + * See signatureAssignableTo, compareSignaturesIdentical + */ + function signatureRelatedTo(source, target, erase, reportErrors, incompatibleReporter) { + return compareSignaturesRelated(erase ? getErasedSignature(source) : source, erase ? getErasedSignature(target) : target, relation === strictSubtypeRelation ? 8 /* SignatureCheckMode.StrictArity */ : 0, reportErrors, reportError, incompatibleReporter, isRelatedToWorker, reportUnreliableMapper); + } + function signaturesIdenticalTo(source, target, kind) { + var sourceSignatures = getSignaturesOfType(source, kind); + var targetSignatures = getSignaturesOfType(target, kind); + if (sourceSignatures.length !== targetSignatures.length) { + return 0 /* Ternary.False */; + } + var result = -1 /* Ternary.True */; + for (var i = 0; i < sourceSignatures.length; i++) { + var related = compareSignaturesIdentical(sourceSignatures[i], targetSignatures[i], /*partialMatch*/ false, /*ignoreThisTypes*/ false, /*ignoreReturnTypes*/ false, isRelatedTo); + if (!related) { + return 0 /* Ternary.False */; + } + result &= related; + } + return result; + } + function membersRelatedToIndexInfo(source, targetInfo, reportErrors) { + var result = -1 /* Ternary.True */; + var keyType = targetInfo.keyType; + var props = source.flags & 2097152 /* TypeFlags.Intersection */ ? getPropertiesOfUnionOrIntersectionType(source) : getPropertiesOfObjectType(source); + for (var _i = 0, props_2 = props; _i < props_2.length; _i++) { + var prop = props_2[_i]; + // Skip over ignored JSX and symbol-named members + if (isIgnoredJsxProperty(source, prop)) { + continue; + } + if (isApplicableIndexType(getLiteralTypeFromProperty(prop, 8576 /* TypeFlags.StringOrNumberLiteralOrUnique */), keyType)) { + var propType = getNonMissingTypeOfSymbol(prop); + var type = exactOptionalPropertyTypes || propType.flags & 32768 /* TypeFlags.Undefined */ || keyType === numberType || !(prop.flags & 16777216 /* SymbolFlags.Optional */) + ? propType + : getTypeWithFacts(propType, 524288 /* TypeFacts.NEUndefined */); + var related = isRelatedTo(type, targetInfo.type, 3 /* RecursionFlags.Both */, reportErrors); + if (!related) { + if (reportErrors) { + reportError(ts.Diagnostics.Property_0_is_incompatible_with_index_signature, symbolToString(prop)); + } + return 0 /* Ternary.False */; + } + result &= related; + } + } + for (var _a = 0, _b = getIndexInfosOfType(source); _a < _b.length; _a++) { + var info = _b[_a]; + if (isApplicableIndexType(info.keyType, keyType)) { + var related = indexInfoRelatedTo(info, targetInfo, reportErrors); + if (!related) { + return 0 /* Ternary.False */; + } + result &= related; + } + } + return result; + } + function indexInfoRelatedTo(sourceInfo, targetInfo, reportErrors) { + var related = isRelatedTo(sourceInfo.type, targetInfo.type, 3 /* RecursionFlags.Both */, reportErrors); + if (!related && reportErrors) { + if (sourceInfo.keyType === targetInfo.keyType) { + reportError(ts.Diagnostics._0_index_signatures_are_incompatible, typeToString(sourceInfo.keyType)); + } + else { + reportError(ts.Diagnostics._0_and_1_index_signatures_are_incompatible, typeToString(sourceInfo.keyType), typeToString(targetInfo.keyType)); + } + } + return related; + } + function indexSignaturesRelatedTo(source, target, sourceIsPrimitive, reportErrors, intersectionState) { + if (relation === identityRelation) { + return indexSignaturesIdenticalTo(source, target); + } + var indexInfos = getIndexInfosOfType(target); + var targetHasStringIndex = ts.some(indexInfos, function (info) { return info.keyType === stringType; }); + var result = -1 /* Ternary.True */; + for (var _i = 0, indexInfos_5 = indexInfos; _i < indexInfos_5.length; _i++) { + var targetInfo = indexInfos_5[_i]; + var related = !sourceIsPrimitive && targetHasStringIndex && targetInfo.type.flags & 1 /* TypeFlags.Any */ ? -1 /* Ternary.True */ : + isGenericMappedType(source) && targetHasStringIndex ? isRelatedTo(getTemplateTypeFromMappedType(source), targetInfo.type, 3 /* RecursionFlags.Both */, reportErrors) : + typeRelatedToIndexInfo(source, targetInfo, reportErrors, intersectionState); + if (!related) { + return 0 /* Ternary.False */; + } + result &= related; + } + return result; + } + function typeRelatedToIndexInfo(source, targetInfo, reportErrors, intersectionState) { + var sourceInfo = getApplicableIndexInfo(source, targetInfo.keyType); + if (sourceInfo) { + return indexInfoRelatedTo(sourceInfo, targetInfo, reportErrors); + } + if (!(intersectionState & 1 /* IntersectionState.Source */) && isObjectTypeWithInferableIndex(source)) { + // Intersection constituents are never considered to have an inferred index signature + return membersRelatedToIndexInfo(source, targetInfo, reportErrors); + } + if (reportErrors) { + reportError(ts.Diagnostics.Index_signature_for_type_0_is_missing_in_type_1, typeToString(targetInfo.keyType), typeToString(source)); + } + return 0 /* Ternary.False */; + } + function indexSignaturesIdenticalTo(source, target) { + var sourceInfos = getIndexInfosOfType(source); + var targetInfos = getIndexInfosOfType(target); + if (sourceInfos.length !== targetInfos.length) { + return 0 /* Ternary.False */; + } + for (var _i = 0, targetInfos_1 = targetInfos; _i < targetInfos_1.length; _i++) { + var targetInfo = targetInfos_1[_i]; + var sourceInfo = getIndexInfoOfType(source, targetInfo.keyType); + if (!(sourceInfo && isRelatedTo(sourceInfo.type, targetInfo.type, 3 /* RecursionFlags.Both */) && sourceInfo.isReadonly === targetInfo.isReadonly)) { + return 0 /* Ternary.False */; + } + } + return -1 /* Ternary.True */; + } + function constructorVisibilitiesAreCompatible(sourceSignature, targetSignature, reportErrors) { + if (!sourceSignature.declaration || !targetSignature.declaration) { + return true; + } + var sourceAccessibility = ts.getSelectedEffectiveModifierFlags(sourceSignature.declaration, 24 /* ModifierFlags.NonPublicAccessibilityModifier */); + var targetAccessibility = ts.getSelectedEffectiveModifierFlags(targetSignature.declaration, 24 /* ModifierFlags.NonPublicAccessibilityModifier */); + // A public, protected and private signature is assignable to a private signature. + if (targetAccessibility === 8 /* ModifierFlags.Private */) { + return true; + } + // A public and protected signature is assignable to a protected signature. + if (targetAccessibility === 16 /* ModifierFlags.Protected */ && sourceAccessibility !== 8 /* ModifierFlags.Private */) { + return true; + } + // Only a public signature is assignable to public signature. + if (targetAccessibility !== 16 /* ModifierFlags.Protected */ && !sourceAccessibility) { + return true; + } + if (reportErrors) { + reportError(ts.Diagnostics.Cannot_assign_a_0_constructor_type_to_a_1_constructor_type, visibilityToString(sourceAccessibility), visibilityToString(targetAccessibility)); + } + return false; + } + } + function typeCouldHaveTopLevelSingletonTypes(type) { + // Okay, yes, 'boolean' is a union of 'true | false', but that's not useful + // in error reporting scenarios. If you need to use this function but that detail matters, + // feel free to add a flag. + if (type.flags & 16 /* TypeFlags.Boolean */) { + return false; + } + if (type.flags & 3145728 /* TypeFlags.UnionOrIntersection */) { + return !!ts.forEach(type.types, typeCouldHaveTopLevelSingletonTypes); + } + if (type.flags & 465829888 /* TypeFlags.Instantiable */) { + var constraint = getConstraintOfType(type); + if (constraint && constraint !== type) { + return typeCouldHaveTopLevelSingletonTypes(constraint); + } + } + return isUnitType(type) || !!(type.flags & 134217728 /* TypeFlags.TemplateLiteral */) || !!(type.flags & 268435456 /* TypeFlags.StringMapping */); + } + function getExactOptionalUnassignableProperties(source, target) { + if (isTupleType(source) && isTupleType(target)) + return ts.emptyArray; + return getPropertiesOfType(target) + .filter(function (targetProp) { return isExactOptionalPropertyMismatch(getTypeOfPropertyOfType(source, targetProp.escapedName), getTypeOfSymbol(targetProp)); }); + } + function isExactOptionalPropertyMismatch(source, target) { + return !!source && !!target && maybeTypeOfKind(source, 32768 /* TypeFlags.Undefined */) && !!containsMissingType(target); + } + function getExactOptionalProperties(type) { + return getPropertiesOfType(type).filter(function (targetProp) { return containsMissingType(getTypeOfSymbol(targetProp)); }); + } + function getBestMatchingType(source, target, isRelatedTo) { + if (isRelatedTo === void 0) { isRelatedTo = compareTypesAssignable; } + return findMatchingDiscriminantType(source, target, isRelatedTo, /*skipPartial*/ true) || + findMatchingTypeReferenceOrTypeAliasReference(source, target) || + findBestTypeForObjectLiteral(source, target) || + findBestTypeForInvokable(source, target) || + findMostOverlappyType(source, target); + } + function discriminateTypeByDiscriminableItems(target, discriminators, related, defaultValue, skipPartial) { + // undefined=unknown, true=discriminated, false=not discriminated + // The state of each type progresses from left to right. Discriminated types stop at 'true'. + var discriminable = target.types.map(function (_) { return undefined; }); + for (var _i = 0, discriminators_1 = discriminators; _i < discriminators_1.length; _i++) { + var _a = discriminators_1[_i], getDiscriminatingType = _a[0], propertyName = _a[1]; + var targetProp = getUnionOrIntersectionProperty(target, propertyName); + if (skipPartial && targetProp && ts.getCheckFlags(targetProp) & 16 /* CheckFlags.ReadPartial */) { + continue; + } + var i = 0; + for (var _b = 0, _c = target.types; _b < _c.length; _b++) { + var type = _c[_b]; + var targetType = getTypeOfPropertyOfType(type, propertyName); + if (targetType && related(getDiscriminatingType(), targetType)) { + discriminable[i] = discriminable[i] === undefined ? true : discriminable[i]; + } + else { + discriminable[i] = false; + } + i++; + } + } + var match = discriminable.indexOf(/*searchElement*/ true); + if (match === -1) { + return defaultValue; + } + // make sure exactly 1 matches before returning it + var nextMatch = discriminable.indexOf(/*searchElement*/ true, match + 1); + while (nextMatch !== -1) { + if (!isTypeIdenticalTo(target.types[match], target.types[nextMatch])) { + return defaultValue; + } + nextMatch = discriminable.indexOf(/*searchElement*/ true, nextMatch + 1); + } + return target.types[match]; + } + /** + * A type is 'weak' if it is an object type with at least one optional property + * and no required properties, call/construct signatures or index signatures + */ + function isWeakType(type) { + if (type.flags & 524288 /* TypeFlags.Object */) { + var resolved = resolveStructuredTypeMembers(type); + return resolved.callSignatures.length === 0 && resolved.constructSignatures.length === 0 && resolved.indexInfos.length === 0 && + resolved.properties.length > 0 && ts.every(resolved.properties, function (p) { return !!(p.flags & 16777216 /* SymbolFlags.Optional */); }); + } + if (type.flags & 2097152 /* TypeFlags.Intersection */) { + return ts.every(type.types, isWeakType); + } + return false; + } + function hasCommonProperties(source, target, isComparingJsxAttributes) { + for (var _i = 0, _a = getPropertiesOfType(source); _i < _a.length; _i++) { + var prop = _a[_i]; + if (isKnownProperty(target, prop.escapedName, isComparingJsxAttributes)) { + return true; + } + } + return false; + } + function getVariances(type) { + // Arrays and tuples are known to be covariant, no need to spend time computing this. + return type === globalArrayType || type === globalReadonlyArrayType || type.objectFlags & 8 /* ObjectFlags.Tuple */ ? + arrayVariances : + getVariancesWorker(type.symbol, type.typeParameters); + } + function getAliasVariances(symbol) { + return getVariancesWorker(symbol, getSymbolLinks(symbol).typeParameters); + } + // Return an array containing the variance of each type parameter. The variance is effectively + // a digest of the type comparisons that occur for each type argument when instantiations of the + // generic type are structurally compared. We infer the variance information by comparing + // instantiations of the generic type for type arguments with known relations. The function + // returns the emptyArray singleton when invoked recursively for the given generic type. + function getVariancesWorker(symbol, typeParameters) { + if (typeParameters === void 0) { typeParameters = ts.emptyArray; } + var links = getSymbolLinks(symbol); + if (!links.variances) { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("checkTypes" /* tracing.Phase.CheckTypes */, "getVariancesWorker", { arity: typeParameters.length, id: getTypeId(getDeclaredTypeOfSymbol(symbol)) }); + links.variances = ts.emptyArray; + var variances = []; + var _loop_23 = function (tp) { + var modifiers = getVarianceModifiers(tp); + var variance = modifiers & 65536 /* ModifierFlags.Out */ ? + modifiers & 32768 /* ModifierFlags.In */ ? 0 /* VarianceFlags.Invariant */ : 1 /* VarianceFlags.Covariant */ : + modifiers & 32768 /* ModifierFlags.In */ ? 2 /* VarianceFlags.Contravariant */ : undefined; + if (variance === undefined) { + var unmeasurable_1 = false; + var unreliable_1 = false; + var oldHandler = outofbandVarianceMarkerHandler; + outofbandVarianceMarkerHandler = function (onlyUnreliable) { return onlyUnreliable ? unreliable_1 = true : unmeasurable_1 = true; }; + // We first compare instantiations where the type parameter is replaced with + // marker types that have a known subtype relationship. From this we can infer + // invariance, covariance, contravariance or bivariance. + var typeWithSuper = createMarkerType(symbol, tp, markerSuperType); + var typeWithSub = createMarkerType(symbol, tp, markerSubType); + variance = (isTypeAssignableTo(typeWithSub, typeWithSuper) ? 1 /* VarianceFlags.Covariant */ : 0) | + (isTypeAssignableTo(typeWithSuper, typeWithSub) ? 2 /* VarianceFlags.Contravariant */ : 0); + // If the instantiations appear to be related bivariantly it may be because the + // type parameter is independent (i.e. it isn't witnessed anywhere in the generic + // type). To determine this we compare instantiations where the type parameter is + // replaced with marker types that are known to be unrelated. + if (variance === 3 /* VarianceFlags.Bivariant */ && isTypeAssignableTo(createMarkerType(symbol, tp, markerOtherType), typeWithSuper)) { + variance = 4 /* VarianceFlags.Independent */; + } + outofbandVarianceMarkerHandler = oldHandler; + if (unmeasurable_1 || unreliable_1) { + if (unmeasurable_1) { + variance |= 8 /* VarianceFlags.Unmeasurable */; + } + if (unreliable_1) { + variance |= 16 /* VarianceFlags.Unreliable */; + } + } + } + variances.push(variance); + }; + for (var _i = 0, typeParameters_2 = typeParameters; _i < typeParameters_2.length; _i++) { + var tp = typeParameters_2[_i]; + _loop_23(tp); + } + links.variances = variances; + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop({ variances: variances.map(ts.Debug.formatVariance) }); + } + return links.variances; + } + function createMarkerType(symbol, source, target) { + var mapper = makeUnaryTypeMapper(source, target); + var type = getDeclaredTypeOfSymbol(symbol); + if (isErrorType(type)) { + return type; + } + var result = symbol.flags & 524288 /* SymbolFlags.TypeAlias */ ? + getTypeAliasInstantiation(symbol, instantiateTypes(getSymbolLinks(symbol).typeParameters, mapper)) : + createTypeReference(type, instantiateTypes(type.typeParameters, mapper)); + markerTypes.add(getTypeId(result)); + return result; + } + function isMarkerType(type) { + return markerTypes.has(getTypeId(type)); + } + function getVarianceModifiers(tp) { + var _a, _b; + return (ts.some((_a = tp.symbol) === null || _a === void 0 ? void 0 : _a.declarations, function (d) { return ts.hasSyntacticModifier(d, 32768 /* ModifierFlags.In */); }) ? 32768 /* ModifierFlags.In */ : 0) | + (ts.some((_b = tp.symbol) === null || _b === void 0 ? void 0 : _b.declarations, function (d) { return ts.hasSyntacticModifier(d, 65536 /* ModifierFlags.Out */); }) ? 65536 /* ModifierFlags.Out */ : 0); + } + // Return true if the given type reference has a 'void' type argument for a covariant type parameter. + // See comment at call in recursiveTypeRelatedTo for when this case matters. + function hasCovariantVoidArgument(typeArguments, variances) { + for (var i = 0; i < variances.length; i++) { + if ((variances[i] & 7 /* VarianceFlags.VarianceMask */) === 1 /* VarianceFlags.Covariant */ && typeArguments[i].flags & 16384 /* TypeFlags.Void */) { + return true; + } + } + return false; + } + function isUnconstrainedTypeParameter(type) { + return type.flags & 262144 /* TypeFlags.TypeParameter */ && !getConstraintOfTypeParameter(type); + } + function isNonDeferredTypeReference(type) { + return !!(ts.getObjectFlags(type) & 4 /* ObjectFlags.Reference */) && !type.node; + } + function isTypeReferenceWithGenericArguments(type) { + return isNonDeferredTypeReference(type) && ts.some(getTypeArguments(type), function (t) { return !!(t.flags & 262144 /* TypeFlags.TypeParameter */) || isTypeReferenceWithGenericArguments(t); }); + } + function getGenericTypeReferenceRelationKey(source, target, postFix, ignoreConstraints) { + var typeParameters = []; + var constraintMarker = ""; + var sourceId = getTypeReferenceId(source, 0); + var targetId = getTypeReferenceId(target, 0); + return "".concat(constraintMarker).concat(sourceId, ",").concat(targetId).concat(postFix); + // getTypeReferenceId(A) returns "111=0-12=1" + // where A.id=111 and number.id=12 + function getTypeReferenceId(type, depth) { + if (depth === void 0) { depth = 0; } + var result = "" + type.target.id; + for (var _i = 0, _a = getTypeArguments(type); _i < _a.length; _i++) { + var t = _a[_i]; + if (t.flags & 262144 /* TypeFlags.TypeParameter */) { + if (ignoreConstraints || isUnconstrainedTypeParameter(t)) { + var index = typeParameters.indexOf(t); + if (index < 0) { + index = typeParameters.length; + typeParameters.push(t); + } + result += "=" + index; + continue; + } + // We mark type references that reference constrained type parameters such that we know to obtain + // and look for a "broadest equivalent key" in the cache. + constraintMarker = "*"; + } + else if (depth < 4 && isTypeReferenceWithGenericArguments(t)) { + result += "<" + getTypeReferenceId(t, depth + 1) + ">"; + continue; + } + result += "-" + t.id; + } + return result; + } + } + /** + * To improve caching, the relation key for two generic types uses the target's id plus ids of the type parameters. + * For other cases, the types ids are used. + */ + function getRelationKey(source, target, intersectionState, relation, ignoreConstraints) { + if (relation === identityRelation && source.id > target.id) { + var temp = source; + source = target; + target = temp; + } + var postFix = intersectionState ? ":" + intersectionState : ""; + return isTypeReferenceWithGenericArguments(source) && isTypeReferenceWithGenericArguments(target) ? + getGenericTypeReferenceRelationKey(source, target, postFix, ignoreConstraints) : + "".concat(source.id, ",").concat(target.id).concat(postFix); + } + // Invoke the callback for each underlying property symbol of the given symbol and return the first + // value that isn't undefined. + function forEachProperty(prop, callback) { + if (ts.getCheckFlags(prop) & 6 /* CheckFlags.Synthetic */) { + for (var _i = 0, _a = prop.containingType.types; _i < _a.length; _i++) { + var t = _a[_i]; + var p = getPropertyOfType(t, prop.escapedName); + var result = p && forEachProperty(p, callback); + if (result) { + return result; + } + } + return undefined; + } + return callback(prop); + } + // Return the declaring class type of a property or undefined if property not declared in class + function getDeclaringClass(prop) { + return prop.parent && prop.parent.flags & 32 /* SymbolFlags.Class */ ? getDeclaredTypeOfSymbol(getParentOfSymbol(prop)) : undefined; + } + // Return the inherited type of the given property or undefined if property doesn't exist in a base class. + function getTypeOfPropertyInBaseClass(property) { + var classType = getDeclaringClass(property); + var baseClassType = classType && getBaseTypes(classType)[0]; + return baseClassType && getTypeOfPropertyOfType(baseClassType, property.escapedName); + } + // Return true if some underlying source property is declared in a class that derives + // from the given base class. + function isPropertyInClassDerivedFrom(prop, baseClass) { + return forEachProperty(prop, function (sp) { + var sourceClass = getDeclaringClass(sp); + return sourceClass ? hasBaseType(sourceClass, baseClass) : false; + }); + } + // Return true if source property is a valid override of protected parts of target property. + function isValidOverrideOf(sourceProp, targetProp) { + return !forEachProperty(targetProp, function (tp) { return ts.getDeclarationModifierFlagsFromSymbol(tp) & 16 /* ModifierFlags.Protected */ ? + !isPropertyInClassDerivedFrom(sourceProp, getDeclaringClass(tp)) : false; }); + } + // Return true if the given class derives from each of the declaring classes of the protected + // constituents of the given property. + function isClassDerivedFromDeclaringClasses(checkClass, prop, writing) { + return forEachProperty(prop, function (p) { return ts.getDeclarationModifierFlagsFromSymbol(p, writing) & 16 /* ModifierFlags.Protected */ ? + !hasBaseType(checkClass, getDeclaringClass(p)) : false; }) ? undefined : checkClass; + } + // Return true if the given type is deeply nested. We consider this to be the case when structural type comparisons + // for maxDepth or more occurrences or instantiations of the type have been recorded on the given stack. It is possible, + // though highly unlikely, for this test to be true in a situation where a chain of instantiations is not infinitely + // expanding. Effectively, we will generate a false positive when two types are structurally equal to at least maxDepth + // levels, but unequal at some level beyond that. + // In addition, this will also detect when an indexed access has been chained off of maxDepth more times (which is + // essentially the dual of the structural comparison), and likewise mark the type as deeply nested, potentially adding + // false positives for finite but deeply expanding indexed accesses (eg, for `Q[P1][P2][P3][P4][P5]`). + // It also detects when a recursive type reference has expanded maxDepth or more times, e.g. if the true branch of + // `type A = null extends T ? [A>] : [T]` + // has expanded into `[A>>>>>]`. In such cases we need + // to terminate the expansion, and we do so here. + function isDeeplyNestedType(type, stack, depth, maxDepth) { + if (maxDepth === void 0) { maxDepth = 3; } + if (depth >= maxDepth) { + var identity_2 = getRecursionIdentity(type); + var count = 0; + var lastTypeId = 0; + for (var i = 0; i < depth; i++) { + var t = stack[i]; + if (getRecursionIdentity(t) === identity_2) { + // We only count occurrences with a higher type id than the previous occurrence, since higher + // type ids are an indicator of newer instantiations caused by recursion. + if (t.id >= lastTypeId) { + count++; + if (count >= maxDepth) { + return true; + } + } + lastTypeId = t.id; + } + } + } + return false; + } + // The recursion identity of a type is an object identity that is shared among multiple instantiations of the type. + // We track recursion identities in order to identify deeply nested and possibly infinite type instantiations with + // the same origin. For example, when type parameters are in scope in an object type such as { x: T }, all + // instantiations of that type have the same recursion identity. The default recursion identity is the object + // identity of the type, meaning that every type is unique. Generally, types with constituents that could circularly + // reference the type have a recursion identity that differs from the object identity. + function getRecursionIdentity(type) { + // Object and array literals are known not to contain recursive references and don't need a recursion identity. + if (type.flags & 524288 /* TypeFlags.Object */ && !isObjectOrArrayLiteralType(type)) { + if (ts.getObjectFlags(type) && 4 /* ObjectFlags.Reference */ && type.node) { + // Deferred type references are tracked through their associated AST node. This gives us finer + // granularity than using their associated target because each manifest type reference has a + // unique AST node. + return type.node; + } + if (type.symbol && !(ts.getObjectFlags(type) & 16 /* ObjectFlags.Anonymous */ && type.symbol.flags & 32 /* SymbolFlags.Class */)) { + // We track all object types that have an associated symbol (representing the origin of the type), but + // exclude the static side of classes from this check since it shares its symbol with the instance side. + return type.symbol; + } + if (isTupleType(type)) { + // Tuple types are tracked through their target type + return type.target; + } + } + if (type.flags & 262144 /* TypeFlags.TypeParameter */) { + return type.symbol; + } + if (type.flags & 8388608 /* TypeFlags.IndexedAccess */) { + // Identity is the leftmost object type in a chain of indexed accesses, eg, in A[P][Q] it is A + do { + type = type.objectType; + } while (type.flags & 8388608 /* TypeFlags.IndexedAccess */); + return type; + } + if (type.flags & 16777216 /* TypeFlags.Conditional */) { + // The root object represents the origin of the conditional type + return type.root; + } + return type; + } + function isPropertyIdenticalTo(sourceProp, targetProp) { + return compareProperties(sourceProp, targetProp, compareTypesIdentical) !== 0 /* Ternary.False */; + } + function compareProperties(sourceProp, targetProp, compareTypes) { + // Two members are considered identical when + // - they are public properties with identical names, optionality, and types, + // - they are private or protected properties originating in the same declaration and having identical types + if (sourceProp === targetProp) { + return -1 /* Ternary.True */; + } + var sourcePropAccessibility = ts.getDeclarationModifierFlagsFromSymbol(sourceProp) & 24 /* ModifierFlags.NonPublicAccessibilityModifier */; + var targetPropAccessibility = ts.getDeclarationModifierFlagsFromSymbol(targetProp) & 24 /* ModifierFlags.NonPublicAccessibilityModifier */; + if (sourcePropAccessibility !== targetPropAccessibility) { + return 0 /* Ternary.False */; + } + if (sourcePropAccessibility) { + if (getTargetSymbol(sourceProp) !== getTargetSymbol(targetProp)) { + return 0 /* Ternary.False */; + } + } + else { + if ((sourceProp.flags & 16777216 /* SymbolFlags.Optional */) !== (targetProp.flags & 16777216 /* SymbolFlags.Optional */)) { + return 0 /* Ternary.False */; + } + } + if (isReadonlySymbol(sourceProp) !== isReadonlySymbol(targetProp)) { + return 0 /* Ternary.False */; + } + return compareTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp)); + } + function isMatchingSignature(source, target, partialMatch) { + var sourceParameterCount = getParameterCount(source); + var targetParameterCount = getParameterCount(target); + var sourceMinArgumentCount = getMinArgumentCount(source); + var targetMinArgumentCount = getMinArgumentCount(target); + var sourceHasRestParameter = hasEffectiveRestParameter(source); + var targetHasRestParameter = hasEffectiveRestParameter(target); + // A source signature matches a target signature if the two signatures have the same number of required, + // optional, and rest parameters. + if (sourceParameterCount === targetParameterCount && + sourceMinArgumentCount === targetMinArgumentCount && + sourceHasRestParameter === targetHasRestParameter) { + return true; + } + // A source signature partially matches a target signature if the target signature has no fewer required + // parameters + if (partialMatch && sourceMinArgumentCount <= targetMinArgumentCount) { + return true; + } + return false; + } + /** + * See signatureRelatedTo, compareSignaturesIdentical + */ + function compareSignaturesIdentical(source, target, partialMatch, ignoreThisTypes, ignoreReturnTypes, compareTypes) { + // TODO (drosen): De-duplicate code between related functions. + if (source === target) { + return -1 /* Ternary.True */; + } + if (!(isMatchingSignature(source, target, partialMatch))) { + return 0 /* Ternary.False */; + } + // Check that the two signatures have the same number of type parameters. + if (ts.length(source.typeParameters) !== ts.length(target.typeParameters)) { + return 0 /* Ternary.False */; + } + // Check that type parameter constraints and defaults match. If they do, instantiate the source + // signature with the type parameters of the target signature and continue the comparison. + if (target.typeParameters) { + var mapper = createTypeMapper(source.typeParameters, target.typeParameters); + for (var i = 0; i < target.typeParameters.length; i++) { + var s = source.typeParameters[i]; + var t = target.typeParameters[i]; + if (!(s === t || compareTypes(instantiateType(getConstraintFromTypeParameter(s), mapper) || unknownType, getConstraintFromTypeParameter(t) || unknownType) && + compareTypes(instantiateType(getDefaultFromTypeParameter(s), mapper) || unknownType, getDefaultFromTypeParameter(t) || unknownType))) { + return 0 /* Ternary.False */; + } + } + source = instantiateSignature(source, mapper, /*eraseTypeParameters*/ true); + } + var result = -1 /* Ternary.True */; + if (!ignoreThisTypes) { + var sourceThisType = getThisTypeOfSignature(source); + if (sourceThisType) { + var targetThisType = getThisTypeOfSignature(target); + if (targetThisType) { + var related = compareTypes(sourceThisType, targetThisType); + if (!related) { + return 0 /* Ternary.False */; + } + result &= related; + } + } + } + var targetLen = getParameterCount(target); + for (var i = 0; i < targetLen; i++) { + var s = getTypeAtPosition(source, i); + var t = getTypeAtPosition(target, i); + var related = compareTypes(t, s); + if (!related) { + return 0 /* Ternary.False */; + } + result &= related; + } + if (!ignoreReturnTypes) { + var sourceTypePredicate = getTypePredicateOfSignature(source); + var targetTypePredicate = getTypePredicateOfSignature(target); + result &= sourceTypePredicate || targetTypePredicate ? + compareTypePredicatesIdentical(sourceTypePredicate, targetTypePredicate, compareTypes) : + compareTypes(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target)); + } + return result; + } + function compareTypePredicatesIdentical(source, target, compareTypes) { + return !(source && target && typePredicateKindsMatch(source, target)) ? 0 /* Ternary.False */ : + source.type === target.type ? -1 /* Ternary.True */ : + source.type && target.type ? compareTypes(source.type, target.type) : + 0 /* Ternary.False */; + } + function literalTypesWithSameBaseType(types) { + var commonBaseType; + for (var _i = 0, types_13 = types; _i < types_13.length; _i++) { + var t = types_13[_i]; + if (!(t.flags & 131072 /* TypeFlags.Never */)) { + var baseType = getBaseTypeOfLiteralType(t); + commonBaseType !== null && commonBaseType !== void 0 ? commonBaseType : (commonBaseType = baseType); + if (baseType === t || baseType !== commonBaseType) { + return false; + } + } + } + return true; + } + function getCombinedTypeFlags(types) { + return ts.reduceLeft(types, function (flags, t) { return flags | (t.flags & 1048576 /* TypeFlags.Union */ ? getCombinedTypeFlags(t.types) : t.flags); }, 0); + } + function getCommonSupertype(types) { + if (types.length === 1) { + return types[0]; + } + // Remove nullable types from each of the candidates. + var primaryTypes = strictNullChecks ? ts.sameMap(types, function (t) { return filterType(t, function (u) { return !(u.flags & 98304 /* TypeFlags.Nullable */); }); }) : types; + // When the candidate types are all literal types with the same base type, return a union + // of those literal types. Otherwise, return the leftmost type for which no type to the + // right is a supertype. + var superTypeOrUnion = literalTypesWithSameBaseType(primaryTypes) ? + getUnionType(primaryTypes) : + ts.reduceLeft(primaryTypes, function (s, t) { return isTypeSubtypeOf(s, t) ? t : s; }); + // Add any nullable types that occurred in the candidates back to the result. + return primaryTypes === types ? superTypeOrUnion : getNullableType(superTypeOrUnion, getCombinedTypeFlags(types) & 98304 /* TypeFlags.Nullable */); + } + // Return the leftmost type for which no type to the right is a subtype. + function getCommonSubtype(types) { + return ts.reduceLeft(types, function (s, t) { return isTypeSubtypeOf(t, s) ? t : s; }); + } + function isArrayType(type) { + return !!(ts.getObjectFlags(type) & 4 /* ObjectFlags.Reference */) && (type.target === globalArrayType || type.target === globalReadonlyArrayType); + } + function isReadonlyArrayType(type) { + return !!(ts.getObjectFlags(type) & 4 /* ObjectFlags.Reference */) && type.target === globalReadonlyArrayType; + } + function isArrayOrTupleType(type) { + return isArrayType(type) || isTupleType(type); + } + function isMutableArrayOrTuple(type) { + return isArrayType(type) && !isReadonlyArrayType(type) || isTupleType(type) && !type.target.readonly; + } + function getElementTypeOfArrayType(type) { + return isArrayType(type) ? getTypeArguments(type)[0] : undefined; + } + function isArrayLikeType(type) { + // A type is array-like if it is a reference to the global Array or global ReadonlyArray type, + // or if it is not the undefined or null type and if it is assignable to ReadonlyArray + return isArrayType(type) || !(type.flags & 98304 /* TypeFlags.Nullable */) && isTypeAssignableTo(type, anyReadonlyArrayType); + } + function getSingleBaseForNonAugmentingSubtype(type) { + if (!(ts.getObjectFlags(type) & 4 /* ObjectFlags.Reference */) || !(ts.getObjectFlags(type.target) & 3 /* ObjectFlags.ClassOrInterface */)) { + return undefined; + } + if (ts.getObjectFlags(type) & 33554432 /* ObjectFlags.IdenticalBaseTypeCalculated */) { + return ts.getObjectFlags(type) & 67108864 /* ObjectFlags.IdenticalBaseTypeExists */ ? type.cachedEquivalentBaseType : undefined; + } + type.objectFlags |= 33554432 /* ObjectFlags.IdenticalBaseTypeCalculated */; + var target = type.target; + if (ts.getObjectFlags(target) & 1 /* ObjectFlags.Class */) { + var baseTypeNode = getBaseTypeNodeOfClass(target); + // A base type expression may circularly reference the class itself (e.g. as an argument to function call), so we only + // check for base types specified as simple qualified names. + if (baseTypeNode && baseTypeNode.expression.kind !== 79 /* SyntaxKind.Identifier */ && baseTypeNode.expression.kind !== 208 /* SyntaxKind.PropertyAccessExpression */) { + return undefined; + } + } + var bases = getBaseTypes(target); + if (bases.length !== 1) { + return undefined; + } + if (getMembersOfSymbol(type.symbol).size) { + return undefined; // If the interface has any members, they may subtype members in the base, so we should do a full structural comparison + } + var instantiatedBase = !ts.length(target.typeParameters) ? bases[0] : instantiateType(bases[0], createTypeMapper(target.typeParameters, getTypeArguments(type).slice(0, target.typeParameters.length))); + if (ts.length(getTypeArguments(type)) > ts.length(target.typeParameters)) { + instantiatedBase = getTypeWithThisArgument(instantiatedBase, ts.last(getTypeArguments(type))); + } + type.objectFlags |= 67108864 /* ObjectFlags.IdenticalBaseTypeExists */; + return type.cachedEquivalentBaseType = instantiatedBase; + } + function isEmptyLiteralType(type) { + return strictNullChecks ? type === implicitNeverType : type === undefinedWideningType; + } + function isEmptyArrayLiteralType(type) { + var elementType = getElementTypeOfArrayType(type); + return !!elementType && isEmptyLiteralType(elementType); + } + function isTupleLikeType(type) { + return isTupleType(type) || !!getPropertyOfType(type, "0"); + } + function isArrayOrTupleLikeType(type) { + return isArrayLikeType(type) || isTupleLikeType(type); + } + function getTupleElementType(type, index) { + var propType = getTypeOfPropertyOfType(type, "" + index); + if (propType) { + return propType; + } + if (everyType(type, isTupleType)) { + return mapType(type, function (t) { return getRestTypeOfTupleType(t) || undefinedType; }); + } + return undefined; + } + function isNeitherUnitTypeNorNever(type) { + return !(type.flags & (109440 /* TypeFlags.Unit */ | 131072 /* TypeFlags.Never */)); + } + function isUnitType(type) { + return !!(type.flags & 109440 /* TypeFlags.Unit */); + } + function isUnitLikeType(type) { + return isUnitType(getBaseConstraintOrType(type)); + } + function extractUnitType(type) { + return type.flags & 2097152 /* TypeFlags.Intersection */ ? ts.find(type.types, isUnitType) || type : type; + } + function isLiteralType(type) { + return type.flags & 16 /* TypeFlags.Boolean */ ? true : + type.flags & 1048576 /* TypeFlags.Union */ ? type.flags & 1024 /* TypeFlags.EnumLiteral */ ? true : ts.every(type.types, isUnitType) : + isUnitType(type); + } + function getBaseTypeOfLiteralType(type) { + return type.flags & 1024 /* TypeFlags.EnumLiteral */ ? getBaseTypeOfEnumLiteralType(type) : + type.flags & (128 /* TypeFlags.StringLiteral */ | 134217728 /* TypeFlags.TemplateLiteral */ | 268435456 /* TypeFlags.StringMapping */) ? stringType : + type.flags & 256 /* TypeFlags.NumberLiteral */ ? numberType : + type.flags & 2048 /* TypeFlags.BigIntLiteral */ ? bigintType : + type.flags & 512 /* TypeFlags.BooleanLiteral */ ? booleanType : + type.flags & 1048576 /* TypeFlags.Union */ ? getBaseTypeOfLiteralTypeUnion(type) : + type; + } + function getBaseTypeOfLiteralTypeUnion(type) { + var _a; + var key = "B".concat(getTypeId(type)); + return (_a = getCachedType(key)) !== null && _a !== void 0 ? _a : setCachedType(key, mapType(type, getBaseTypeOfLiteralType)); + } + function getWidenedLiteralType(type) { + return type.flags & 1024 /* TypeFlags.EnumLiteral */ && isFreshLiteralType(type) ? getBaseTypeOfEnumLiteralType(type) : + type.flags & 128 /* TypeFlags.StringLiteral */ && isFreshLiteralType(type) ? stringType : + type.flags & 256 /* TypeFlags.NumberLiteral */ && isFreshLiteralType(type) ? numberType : + type.flags & 2048 /* TypeFlags.BigIntLiteral */ && isFreshLiteralType(type) ? bigintType : + type.flags & 512 /* TypeFlags.BooleanLiteral */ && isFreshLiteralType(type) ? booleanType : + type.flags & 1048576 /* TypeFlags.Union */ ? mapType(type, getWidenedLiteralType) : + type; + } + function getWidenedUniqueESSymbolType(type) { + return type.flags & 8192 /* TypeFlags.UniqueESSymbol */ ? esSymbolType : + type.flags & 1048576 /* TypeFlags.Union */ ? mapType(type, getWidenedUniqueESSymbolType) : + type; + } + function getWidenedLiteralLikeTypeForContextualType(type, contextualType) { + if (!isLiteralOfContextualType(type, contextualType)) { + type = getWidenedUniqueESSymbolType(getWidenedLiteralType(type)); + } + return getRegularTypeOfLiteralType(type); + } + function getWidenedLiteralLikeTypeForContextualReturnTypeIfNeeded(type, contextualSignatureReturnType, isAsync) { + if (type && isUnitType(type)) { + var contextualType = !contextualSignatureReturnType ? undefined : + isAsync ? getPromisedTypeOfPromise(contextualSignatureReturnType) : + contextualSignatureReturnType; + type = getWidenedLiteralLikeTypeForContextualType(type, contextualType); + } + return type; + } + function getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(type, contextualSignatureReturnType, kind, isAsyncGenerator) { + if (type && isUnitType(type)) { + var contextualType = !contextualSignatureReturnType ? undefined : + getIterationTypeOfGeneratorFunctionReturnType(kind, contextualSignatureReturnType, isAsyncGenerator); + type = getWidenedLiteralLikeTypeForContextualType(type, contextualType); + } + return type; + } + /** + * Check if a Type was written as a tuple type literal. + * Prefer using isTupleLikeType() unless the use of `elementTypes`/`getTypeArguments` is required. + */ + function isTupleType(type) { + return !!(ts.getObjectFlags(type) & 4 /* ObjectFlags.Reference */ && type.target.objectFlags & 8 /* ObjectFlags.Tuple */); + } + function isGenericTupleType(type) { + return isTupleType(type) && !!(type.target.combinedFlags & 8 /* ElementFlags.Variadic */); + } + function isSingleElementGenericTupleType(type) { + return isGenericTupleType(type) && type.target.elementFlags.length === 1; + } + function getRestTypeOfTupleType(type) { + return getElementTypeOfSliceOfTupleType(type, type.target.fixedLength); + } + function getRestArrayTypeOfTupleType(type) { + var restType = getRestTypeOfTupleType(type); + return restType && createArrayType(restType); + } + function getElementTypeOfSliceOfTupleType(type, index, endSkipCount, writing) { + if (endSkipCount === void 0) { endSkipCount = 0; } + if (writing === void 0) { writing = false; } + var length = getTypeReferenceArity(type) - endSkipCount; + if (index < length) { + var typeArguments = getTypeArguments(type); + var elementTypes = []; + for (var i = index; i < length; i++) { + var t = typeArguments[i]; + elementTypes.push(type.target.elementFlags[i] & 8 /* ElementFlags.Variadic */ ? getIndexedAccessType(t, numberType) : t); + } + return writing ? getIntersectionType(elementTypes) : getUnionType(elementTypes); + } + return undefined; + } + function isTupleTypeStructureMatching(t1, t2) { + return getTypeReferenceArity(t1) === getTypeReferenceArity(t2) && + ts.every(t1.target.elementFlags, function (f, i) { return (f & 12 /* ElementFlags.Variable */) === (t2.target.elementFlags[i] & 12 /* ElementFlags.Variable */); }); + } + function isZeroBigInt(_a) { + var value = _a.value; + return value.base10Value === "0"; + } + function removeDefinitelyFalsyTypes(type) { + return filterType(type, function (t) { return !!(getTypeFacts(t) & 4194304 /* TypeFacts.Truthy */); }); + } + function extractDefinitelyFalsyTypes(type) { + return mapType(type, getDefinitelyFalsyPartOfType); + } + function getDefinitelyFalsyPartOfType(type) { + return type.flags & 4 /* TypeFlags.String */ ? emptyStringType : + type.flags & 8 /* TypeFlags.Number */ ? zeroType : + type.flags & 64 /* TypeFlags.BigInt */ ? zeroBigIntType : + type === regularFalseType || + type === falseType || + type.flags & (16384 /* TypeFlags.Void */ | 32768 /* TypeFlags.Undefined */ | 65536 /* TypeFlags.Null */ | 3 /* TypeFlags.AnyOrUnknown */) || + type.flags & 128 /* TypeFlags.StringLiteral */ && type.value === "" || + type.flags & 256 /* TypeFlags.NumberLiteral */ && type.value === 0 || + type.flags & 2048 /* TypeFlags.BigIntLiteral */ && isZeroBigInt(type) ? type : + neverType; + } + /** + * Add undefined or null or both to a type if they are missing. + * @param type - type to add undefined and/or null to if not present + * @param flags - Either TypeFlags.Undefined or TypeFlags.Null, or both + */ + function getNullableType(type, flags) { + var missing = (flags & ~type.flags) & (32768 /* TypeFlags.Undefined */ | 65536 /* TypeFlags.Null */); + return missing === 0 ? type : + missing === 32768 /* TypeFlags.Undefined */ ? getUnionType([type, undefinedType]) : + missing === 65536 /* TypeFlags.Null */ ? getUnionType([type, nullType]) : + getUnionType([type, undefinedType, nullType]); + } + function getOptionalType(type, isProperty) { + if (isProperty === void 0) { isProperty = false; } + ts.Debug.assert(strictNullChecks); + var missingOrUndefined = isProperty ? missingType : undefinedType; + return type.flags & 32768 /* TypeFlags.Undefined */ || type.flags & 1048576 /* TypeFlags.Union */ && type.types[0] === missingOrUndefined ? type : getUnionType([type, missingOrUndefined]); + } + function getGlobalNonNullableTypeInstantiation(type) { + if (!deferredGlobalNonNullableTypeAlias) { + deferredGlobalNonNullableTypeAlias = getGlobalSymbol("NonNullable", 524288 /* SymbolFlags.TypeAlias */, /*diagnostic*/ undefined) || unknownSymbol; + } + return deferredGlobalNonNullableTypeAlias !== unknownSymbol ? + getTypeAliasInstantiation(deferredGlobalNonNullableTypeAlias, [type]) : + getIntersectionType([type, emptyObjectType]); + } + function getNonNullableType(type) { + return strictNullChecks ? getAdjustedTypeWithFacts(type, 2097152 /* TypeFacts.NEUndefinedOrNull */) : type; + } + function addOptionalTypeMarker(type) { + return strictNullChecks ? getUnionType([type, optionalType]) : type; + } + function removeOptionalTypeMarker(type) { + return strictNullChecks ? removeType(type, optionalType) : type; + } + function propagateOptionalTypeMarker(type, node, wasOptional) { + return wasOptional ? ts.isOutermostOptionalChain(node) ? getOptionalType(type) : addOptionalTypeMarker(type) : type; + } + function getOptionalExpressionType(exprType, expression) { + return ts.isExpressionOfOptionalChainRoot(expression) ? getNonNullableType(exprType) : + ts.isOptionalChain(expression) ? removeOptionalTypeMarker(exprType) : + exprType; + } + function removeMissingType(type, isOptional) { + return exactOptionalPropertyTypes && isOptional ? removeType(type, missingType) : type; + } + function containsMissingType(type) { + return exactOptionalPropertyTypes && (type === missingType || type.flags & 1048576 /* TypeFlags.Union */ && containsType(type.types, missingType)); + } + function removeMissingOrUndefinedType(type) { + return exactOptionalPropertyTypes ? removeType(type, missingType) : getTypeWithFacts(type, 524288 /* TypeFacts.NEUndefined */); + } + /** + * Is source potentially coercible to target type under `==`. + * Assumes that `source` is a constituent of a union, hence + * the boolean literal flag on the LHS, but not on the RHS. + * + * This does not fully replicate the semantics of `==`. The + * intention is to catch cases that are clearly not right. + * + * Comparing (string | number) to number should not remove the + * string element. + * + * Comparing (string | number) to 1 will remove the string + * element, though this is not sound. This is a pragmatic + * choice. + * + * @see narrowTypeByEquality + * + * @param source + * @param target + */ + function isCoercibleUnderDoubleEquals(source, target) { + return ((source.flags & (8 /* TypeFlags.Number */ | 4 /* TypeFlags.String */ | 512 /* TypeFlags.BooleanLiteral */)) !== 0) + && ((target.flags & (8 /* TypeFlags.Number */ | 4 /* TypeFlags.String */ | 16 /* TypeFlags.Boolean */)) !== 0); + } + /** + * Return true if type was inferred from an object literal, written as an object type literal, or is the shape of a module + * with no call or construct signatures. + */ + function isObjectTypeWithInferableIndex(type) { + var objectFlags = ts.getObjectFlags(type); + return type.flags & 2097152 /* TypeFlags.Intersection */ + ? ts.every(type.types, isObjectTypeWithInferableIndex) + : !!(type.symbol + && (type.symbol.flags & (4096 /* SymbolFlags.ObjectLiteral */ | 2048 /* SymbolFlags.TypeLiteral */ | 384 /* SymbolFlags.Enum */ | 512 /* SymbolFlags.ValueModule */)) !== 0 + && !(type.symbol.flags & 32 /* SymbolFlags.Class */) + && !typeHasCallOrConstructSignatures(type)) || !!(objectFlags & 4194304 /* ObjectFlags.ObjectRestType */) || !!(objectFlags & 1024 /* ObjectFlags.ReverseMapped */ && isObjectTypeWithInferableIndex(type.source)); + } + function createSymbolWithType(source, type) { + var symbol = createSymbol(source.flags, source.escapedName, ts.getCheckFlags(source) & 8 /* CheckFlags.Readonly */); + symbol.declarations = source.declarations; + symbol.parent = source.parent; + symbol.type = type; + symbol.target = source; + if (source.valueDeclaration) { + symbol.valueDeclaration = source.valueDeclaration; + } + var nameType = getSymbolLinks(source).nameType; + if (nameType) { + symbol.nameType = nameType; + } + return symbol; + } + function transformTypeOfMembers(type, f) { + var members = ts.createSymbolTable(); + for (var _i = 0, _a = getPropertiesOfObjectType(type); _i < _a.length; _i++) { + var property = _a[_i]; + var original = getTypeOfSymbol(property); + var updated = f(original); + members.set(property.escapedName, updated === original ? property : createSymbolWithType(property, updated)); + } + return members; + } + /** + * If the the provided object literal is subject to the excess properties check, + * create a new that is exempt. Recursively mark object literal members as exempt. + * Leave signatures alone since they are not subject to the check. + */ + function getRegularTypeOfObjectLiteral(type) { + if (!(isObjectLiteralType(type) && ts.getObjectFlags(type) & 8192 /* ObjectFlags.FreshLiteral */)) { + return type; + } + var regularType = type.regularType; + if (regularType) { + return regularType; + } + var resolved = type; + var members = transformTypeOfMembers(type, getRegularTypeOfObjectLiteral); + var regularNew = createAnonymousType(resolved.symbol, members, resolved.callSignatures, resolved.constructSignatures, resolved.indexInfos); + regularNew.flags = resolved.flags; + regularNew.objectFlags |= resolved.objectFlags & ~8192 /* ObjectFlags.FreshLiteral */; + type.regularType = regularNew; + return regularNew; + } + function createWideningContext(parent, propertyName, siblings) { + return { parent: parent, propertyName: propertyName, siblings: siblings, resolvedProperties: undefined }; + } + function getSiblingsOfContext(context) { + if (!context.siblings) { + var siblings_1 = []; + for (var _i = 0, _a = getSiblingsOfContext(context.parent); _i < _a.length; _i++) { + var type = _a[_i]; + if (isObjectLiteralType(type)) { + var prop = getPropertyOfObjectType(type, context.propertyName); + if (prop) { + forEachType(getTypeOfSymbol(prop), function (t) { + siblings_1.push(t); + }); + } + } + } + context.siblings = siblings_1; + } + return context.siblings; + } + function getPropertiesOfContext(context) { + if (!context.resolvedProperties) { + var names = new ts.Map(); + for (var _i = 0, _a = getSiblingsOfContext(context); _i < _a.length; _i++) { + var t = _a[_i]; + if (isObjectLiteralType(t) && !(ts.getObjectFlags(t) & 2097152 /* ObjectFlags.ContainsSpread */)) { + for (var _b = 0, _c = getPropertiesOfType(t); _b < _c.length; _b++) { + var prop = _c[_b]; + names.set(prop.escapedName, prop); + } + } + } + context.resolvedProperties = ts.arrayFrom(names.values()); + } + return context.resolvedProperties; + } + function getWidenedProperty(prop, context) { + if (!(prop.flags & 4 /* SymbolFlags.Property */)) { + // Since get accessors already widen their return value there is no need to + // widen accessor based properties here. + return prop; + } + var original = getTypeOfSymbol(prop); + var propContext = context && createWideningContext(context, prop.escapedName, /*siblings*/ undefined); + var widened = getWidenedTypeWithContext(original, propContext); + return widened === original ? prop : createSymbolWithType(prop, widened); + } + function getUndefinedProperty(prop) { + var cached = undefinedProperties.get(prop.escapedName); + if (cached) { + return cached; + } + var result = createSymbolWithType(prop, missingType); + result.flags |= 16777216 /* SymbolFlags.Optional */; + undefinedProperties.set(prop.escapedName, result); + return result; + } + function getWidenedTypeOfObjectLiteral(type, context) { + var members = ts.createSymbolTable(); + for (var _i = 0, _a = getPropertiesOfObjectType(type); _i < _a.length; _i++) { + var prop = _a[_i]; + members.set(prop.escapedName, getWidenedProperty(prop, context)); + } + if (context) { + for (var _b = 0, _c = getPropertiesOfContext(context); _b < _c.length; _b++) { + var prop = _c[_b]; + if (!members.has(prop.escapedName)) { + members.set(prop.escapedName, getUndefinedProperty(prop)); + } + } + } + var result = createAnonymousType(type.symbol, members, ts.emptyArray, ts.emptyArray, ts.sameMap(getIndexInfosOfType(type), function (info) { return createIndexInfo(info.keyType, getWidenedType(info.type), info.isReadonly); })); + result.objectFlags |= (ts.getObjectFlags(type) & (4096 /* ObjectFlags.JSLiteral */ | 262144 /* ObjectFlags.NonInferrableType */)); // Retain js literal flag through widening + return result; + } + function getWidenedType(type) { + return getWidenedTypeWithContext(type, /*context*/ undefined); + } + function getWidenedTypeWithContext(type, context) { + if (ts.getObjectFlags(type) & 196608 /* ObjectFlags.RequiresWidening */) { + if (context === undefined && type.widened) { + return type.widened; + } + var result = void 0; + if (type.flags & (1 /* TypeFlags.Any */ | 98304 /* TypeFlags.Nullable */)) { + result = anyType; + } + else if (isObjectLiteralType(type)) { + result = getWidenedTypeOfObjectLiteral(type, context); + } + else if (type.flags & 1048576 /* TypeFlags.Union */) { + var unionContext_1 = context || createWideningContext(/*parent*/ undefined, /*propertyName*/ undefined, type.types); + var widenedTypes = ts.sameMap(type.types, function (t) { return t.flags & 98304 /* TypeFlags.Nullable */ ? t : getWidenedTypeWithContext(t, unionContext_1); }); + // Widening an empty object literal transitions from a highly restrictive type to + // a highly inclusive one. For that reason we perform subtype reduction here if the + // union includes empty object types (e.g. reducing {} | string to just {}). + result = getUnionType(widenedTypes, ts.some(widenedTypes, isEmptyObjectType) ? 2 /* UnionReduction.Subtype */ : 1 /* UnionReduction.Literal */); + } + else if (type.flags & 2097152 /* TypeFlags.Intersection */) { + result = getIntersectionType(ts.sameMap(type.types, getWidenedType)); + } + else if (isArrayOrTupleType(type)) { + result = createTypeReference(type.target, ts.sameMap(getTypeArguments(type), getWidenedType)); + } + if (result && context === undefined) { + type.widened = result; + } + return result || type; + } + return type; + } + /** + * Reports implicit any errors that occur as a result of widening 'null' and 'undefined' + * to 'any'. A call to reportWideningErrorsInType is normally accompanied by a call to + * getWidenedType. But in some cases getWidenedType is called without reporting errors + * (type argument inference is an example). + * + * The return value indicates whether an error was in fact reported. The particular circumstances + * are on a best effort basis. Currently, if the null or undefined that causes widening is inside + * an object literal property (arbitrarily deeply), this function reports an error. If no error is + * reported, reportImplicitAnyError is a suitable fallback to report a general error. + */ + function reportWideningErrorsInType(type) { + var errorReported = false; + if (ts.getObjectFlags(type) & 65536 /* ObjectFlags.ContainsWideningType */) { + if (type.flags & 1048576 /* TypeFlags.Union */) { + if (ts.some(type.types, isEmptyObjectType)) { + errorReported = true; + } + else { + for (var _i = 0, _a = type.types; _i < _a.length; _i++) { + var t = _a[_i]; + if (reportWideningErrorsInType(t)) { + errorReported = true; + } + } + } + } + if (isArrayOrTupleType(type)) { + for (var _b = 0, _c = getTypeArguments(type); _b < _c.length; _b++) { + var t = _c[_b]; + if (reportWideningErrorsInType(t)) { + errorReported = true; + } + } + } + if (isObjectLiteralType(type)) { + for (var _d = 0, _e = getPropertiesOfObjectType(type); _d < _e.length; _d++) { + var p = _e[_d]; + var t = getTypeOfSymbol(p); + if (ts.getObjectFlags(t) & 65536 /* ObjectFlags.ContainsWideningType */) { + if (!reportWideningErrorsInType(t)) { + error(p.valueDeclaration, ts.Diagnostics.Object_literal_s_property_0_implicitly_has_an_1_type, symbolToString(p), typeToString(getWidenedType(t))); + } + errorReported = true; + } + } + } + } + return errorReported; + } + function reportImplicitAny(declaration, type, wideningKind) { + var typeAsString = typeToString(getWidenedType(type)); + if (ts.isInJSFile(declaration) && !ts.isCheckJsEnabledForFile(ts.getSourceFileOfNode(declaration), compilerOptions)) { + // Only report implicit any errors/suggestions in TS and ts-check JS files + return; + } + var diagnostic; + switch (declaration.kind) { + case 223 /* SyntaxKind.BinaryExpression */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 168 /* SyntaxKind.PropertySignature */: + diagnostic = noImplicitAny ? ts.Diagnostics.Member_0_implicitly_has_an_1_type : ts.Diagnostics.Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage; + break; + case 166 /* SyntaxKind.Parameter */: + var param = declaration; + if (ts.isIdentifier(param.name) && + (ts.isCallSignatureDeclaration(param.parent) || ts.isMethodSignature(param.parent) || ts.isFunctionTypeNode(param.parent)) && + param.parent.parameters.indexOf(param) > -1 && + (resolveName(param, param.name.escapedText, 788968 /* SymbolFlags.Type */, undefined, param.name.escapedText, /*isUse*/ true) || + param.name.originalKeywordKind && ts.isTypeNodeKind(param.name.originalKeywordKind))) { + var newName = "arg" + param.parent.parameters.indexOf(param); + var typeName = ts.declarationNameToString(param.name) + (param.dotDotDotToken ? "[]" : ""); + errorOrSuggestion(noImplicitAny, declaration, ts.Diagnostics.Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1, newName, typeName); + return; + } + diagnostic = declaration.dotDotDotToken ? + noImplicitAny ? ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type : ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage : + noImplicitAny ? ts.Diagnostics.Parameter_0_implicitly_has_an_1_type : ts.Diagnostics.Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage; + break; + case 205 /* SyntaxKind.BindingElement */: + diagnostic = ts.Diagnostics.Binding_element_0_implicitly_has_an_1_type; + if (!noImplicitAny) { + // Don't issue a suggestion for binding elements since the codefix doesn't yet support them. + return; + } + break; + case 320 /* SyntaxKind.JSDocFunctionType */: + error(declaration, ts.Diagnostics.Function_type_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeAsString); + return; + case 259 /* SyntaxKind.FunctionDeclaration */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + if (noImplicitAny && !declaration.name) { + if (wideningKind === 3 /* WideningKind.GeneratorYield */) { + error(declaration, ts.Diagnostics.Generator_implicitly_has_yield_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type_annotation, typeAsString); + } + else { + error(declaration, ts.Diagnostics.Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type, typeAsString); + } + return; + } + diagnostic = !noImplicitAny ? ts.Diagnostics._0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage : + wideningKind === 3 /* WideningKind.GeneratorYield */ ? ts.Diagnostics._0_which_lacks_return_type_annotation_implicitly_has_an_1_yield_type : + ts.Diagnostics._0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type; + break; + case 197 /* SyntaxKind.MappedType */: + if (noImplicitAny) { + error(declaration, ts.Diagnostics.Mapped_object_type_implicitly_has_an_any_template_type); + } + return; + default: + diagnostic = noImplicitAny ? ts.Diagnostics.Variable_0_implicitly_has_an_1_type : ts.Diagnostics.Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage; + } + errorOrSuggestion(noImplicitAny, declaration, diagnostic, ts.declarationNameToString(ts.getNameOfDeclaration(declaration)), typeAsString); + } + function reportErrorsFromWidening(declaration, type, wideningKind) { + addLazyDiagnostic(function () { + if (noImplicitAny && ts.getObjectFlags(type) & 65536 /* ObjectFlags.ContainsWideningType */ && (!wideningKind || !getContextualSignatureForFunctionLikeDeclaration(declaration))) { + // Report implicit any error within type if possible, otherwise report error on declaration + if (!reportWideningErrorsInType(type)) { + reportImplicitAny(declaration, type, wideningKind); + } + } + }); + } + function applyToParameterTypes(source, target, callback) { + var sourceCount = getParameterCount(source); + var targetCount = getParameterCount(target); + var sourceRestType = getEffectiveRestType(source); + var targetRestType = getEffectiveRestType(target); + var targetNonRestCount = targetRestType ? targetCount - 1 : targetCount; + var paramCount = sourceRestType ? targetNonRestCount : Math.min(sourceCount, targetNonRestCount); + var sourceThisType = getThisTypeOfSignature(source); + if (sourceThisType) { + var targetThisType = getThisTypeOfSignature(target); + if (targetThisType) { + callback(sourceThisType, targetThisType); + } + } + for (var i = 0; i < paramCount; i++) { + callback(getTypeAtPosition(source, i), getTypeAtPosition(target, i)); + } + if (targetRestType) { + callback(getRestTypeAtPosition(source, paramCount), targetRestType); + } + } + function applyToReturnTypes(source, target, callback) { + var sourceTypePredicate = getTypePredicateOfSignature(source); + var targetTypePredicate = getTypePredicateOfSignature(target); + if (sourceTypePredicate && targetTypePredicate && typePredicateKindsMatch(sourceTypePredicate, targetTypePredicate) && sourceTypePredicate.type && targetTypePredicate.type) { + callback(sourceTypePredicate.type, targetTypePredicate.type); + } + else { + callback(getReturnTypeOfSignature(source), getReturnTypeOfSignature(target)); + } + } + function createInferenceContext(typeParameters, signature, flags, compareTypes) { + return createInferenceContextWorker(typeParameters.map(createInferenceInfo), signature, flags, compareTypes || compareTypesAssignable); + } + function cloneInferenceContext(context, extraFlags) { + if (extraFlags === void 0) { extraFlags = 0; } + return context && createInferenceContextWorker(ts.map(context.inferences, cloneInferenceInfo), context.signature, context.flags | extraFlags, context.compareTypes); + } + function createInferenceContextWorker(inferences, signature, flags, compareTypes) { + var context = { + inferences: inferences, + signature: signature, + flags: flags, + compareTypes: compareTypes, + mapper: reportUnmeasurableMapper, + nonFixingMapper: reportUnmeasurableMapper, + }; + context.mapper = makeFixingMapperForContext(context); + context.nonFixingMapper = makeNonFixingMapperForContext(context); + return context; + } + function makeFixingMapperForContext(context) { + return makeDeferredTypeMapper(ts.map(context.inferences, function (i) { return i.typeParameter; }), ts.map(context.inferences, function (inference, i) { return function () { + if (!inference.isFixed) { + // Before we commit to a particular inference (and thus lock out any further inferences), + // we infer from any intra-expression inference sites we have collected. + inferFromIntraExpressionSites(context); + clearCachedInferences(context.inferences); + inference.isFixed = true; + } + return getInferredType(context, i); + }; })); + } + function makeNonFixingMapperForContext(context) { + return makeDeferredTypeMapper(ts.map(context.inferences, function (i) { return i.typeParameter; }), ts.map(context.inferences, function (_, i) { return function () { + return getInferredType(context, i); + }; })); + } + function clearCachedInferences(inferences) { + for (var _i = 0, inferences_1 = inferences; _i < inferences_1.length; _i++) { + var inference = inferences_1[_i]; + if (!inference.isFixed) { + inference.inferredType = undefined; + } + } + } + function addIntraExpressionInferenceSite(context, node, type) { + var _a; + ((_a = context.intraExpressionInferenceSites) !== null && _a !== void 0 ? _a : (context.intraExpressionInferenceSites = [])).push({ node: node, type: type }); + } + // We collect intra-expression inference sites within object and array literals to handle cases where + // inferred types flow between context sensitive element expressions. For example: + // + // declare function foo(arg: [(n: number) => T, (x: T) => void]): void; + // foo([_a => 0, n => n.toFixed()]); + // + // Above, both arrow functions in the tuple argument are context sensitive, thus both are omitted from the + // pass that collects inferences from the non-context sensitive parts of the arguments. In the subsequent + // pass where nothing is omitted, we need to commit to an inference for T in order to contextually type the + // parameter in the second arrow function, but we want to first infer from the return type of the first + // arrow function. This happens automatically when the arrow functions are discrete arguments (because we + // infer from each argument before processing the next), but when the arrow functions are elements of an + // object or array literal, we need to perform intra-expression inferences early. + function inferFromIntraExpressionSites(context) { + if (context.intraExpressionInferenceSites) { + for (var _i = 0, _a = context.intraExpressionInferenceSites; _i < _a.length; _i++) { + var _b = _a[_i], node = _b.node, type = _b.type; + var contextualType = node.kind === 171 /* SyntaxKind.MethodDeclaration */ ? + getContextualTypeForObjectLiteralMethod(node, 2 /* ContextFlags.NoConstraints */) : + getContextualType(node, 2 /* ContextFlags.NoConstraints */); + if (contextualType) { + inferTypes(context.inferences, type, contextualType); + } + } + context.intraExpressionInferenceSites = undefined; + } + } + function createInferenceInfo(typeParameter) { + return { + typeParameter: typeParameter, + candidates: undefined, + contraCandidates: undefined, + inferredType: undefined, + priority: undefined, + topLevel: true, + isFixed: false, + impliedArity: undefined + }; + } + function cloneInferenceInfo(inference) { + return { + typeParameter: inference.typeParameter, + candidates: inference.candidates && inference.candidates.slice(), + contraCandidates: inference.contraCandidates && inference.contraCandidates.slice(), + inferredType: inference.inferredType, + priority: inference.priority, + topLevel: inference.topLevel, + isFixed: inference.isFixed, + impliedArity: inference.impliedArity + }; + } + function cloneInferredPartOfContext(context) { + var inferences = ts.filter(context.inferences, hasInferenceCandidates); + return inferences.length ? + createInferenceContextWorker(ts.map(inferences, cloneInferenceInfo), context.signature, context.flags, context.compareTypes) : + undefined; + } + function getMapperFromContext(context) { + return context && context.mapper; + } + // Return true if the given type could possibly reference a type parameter for which + // we perform type inference (i.e. a type parameter of a generic function). We cache + // results for union and intersection types for performance reasons. + function couldContainTypeVariables(type) { + var objectFlags = ts.getObjectFlags(type); + if (objectFlags & 524288 /* ObjectFlags.CouldContainTypeVariablesComputed */) { + return !!(objectFlags & 1048576 /* ObjectFlags.CouldContainTypeVariables */); + } + var result = !!(type.flags & 465829888 /* TypeFlags.Instantiable */ || + type.flags & 524288 /* TypeFlags.Object */ && !isNonGenericTopLevelType(type) && (objectFlags & 4 /* ObjectFlags.Reference */ && (type.node || ts.forEach(getTypeArguments(type), couldContainTypeVariables)) || + objectFlags & 16 /* ObjectFlags.Anonymous */ && type.symbol && type.symbol.flags & (16 /* SymbolFlags.Function */ | 8192 /* SymbolFlags.Method */ | 32 /* SymbolFlags.Class */ | 2048 /* SymbolFlags.TypeLiteral */ | 4096 /* SymbolFlags.ObjectLiteral */) && type.symbol.declarations || + objectFlags & (32 /* ObjectFlags.Mapped */ | 1024 /* ObjectFlags.ReverseMapped */ | 4194304 /* ObjectFlags.ObjectRestType */ | 8388608 /* ObjectFlags.InstantiationExpressionType */)) || + type.flags & 3145728 /* TypeFlags.UnionOrIntersection */ && !(type.flags & 1024 /* TypeFlags.EnumLiteral */) && !isNonGenericTopLevelType(type) && ts.some(type.types, couldContainTypeVariables)); + if (type.flags & 3899393 /* TypeFlags.ObjectFlagsType */) { + type.objectFlags |= 524288 /* ObjectFlags.CouldContainTypeVariablesComputed */ | (result ? 1048576 /* ObjectFlags.CouldContainTypeVariables */ : 0); + } + return result; + } + function isNonGenericTopLevelType(type) { + if (type.aliasSymbol && !type.aliasTypeArguments) { + var declaration = ts.getDeclarationOfKind(type.aliasSymbol, 262 /* SyntaxKind.TypeAliasDeclaration */); + return !!(declaration && ts.findAncestor(declaration.parent, function (n) { return n.kind === 308 /* SyntaxKind.SourceFile */ ? true : n.kind === 264 /* SyntaxKind.ModuleDeclaration */ ? false : "quit"; })); + } + return false; + } + function isTypeParameterAtTopLevel(type, typeParameter) { + return !!(type === typeParameter || + type.flags & 3145728 /* TypeFlags.UnionOrIntersection */ && ts.some(type.types, function (t) { return isTypeParameterAtTopLevel(t, typeParameter); }) || + type.flags & 16777216 /* TypeFlags.Conditional */ && (getTrueTypeFromConditionalType(type) === typeParameter || getFalseTypeFromConditionalType(type) === typeParameter)); + } + /** Create an object with properties named in the string literal type. Every property has type `any` */ + function createEmptyObjectTypeFromStringLiteral(type) { + var members = ts.createSymbolTable(); + forEachType(type, function (t) { + if (!(t.flags & 128 /* TypeFlags.StringLiteral */)) { + return; + } + var name = ts.escapeLeadingUnderscores(t.value); + var literalProp = createSymbol(4 /* SymbolFlags.Property */, name); + literalProp.type = anyType; + if (t.symbol) { + literalProp.declarations = t.symbol.declarations; + literalProp.valueDeclaration = t.symbol.valueDeclaration; + } + members.set(name, literalProp); + }); + var indexInfos = type.flags & 4 /* TypeFlags.String */ ? [createIndexInfo(stringType, emptyObjectType, /*isReadonly*/ false)] : ts.emptyArray; + return createAnonymousType(undefined, members, ts.emptyArray, ts.emptyArray, indexInfos); + } + /** + * Infer a suitable input type for a homomorphic mapped type { [P in keyof T]: X }. We construct + * an object type with the same set of properties as the source type, where the type of each + * property is computed by inferring from the source property type to X for the type + * variable T[P] (i.e. we treat the type T[P] as the type variable we're inferring for). + */ + function inferTypeForHomomorphicMappedType(source, target, constraint) { + if (inInferTypeForHomomorphicMappedType) { + return undefined; + } + var key = source.id + "," + target.id + "," + constraint.id; + if (reverseMappedCache.has(key)) { + return reverseMappedCache.get(key); + } + inInferTypeForHomomorphicMappedType = true; + var type = createReverseMappedType(source, target, constraint); + inInferTypeForHomomorphicMappedType = false; + reverseMappedCache.set(key, type); + return type; + } + // We consider a type to be partially inferable if it isn't marked non-inferable or if it is + // an object literal type with at least one property of an inferable type. For example, an object + // literal { a: 123, b: x => true } is marked non-inferable because it contains a context sensitive + // arrow function, but is considered partially inferable because property 'a' has an inferable type. + function isPartiallyInferableType(type) { + return !(ts.getObjectFlags(type) & 262144 /* ObjectFlags.NonInferrableType */) || + isObjectLiteralType(type) && ts.some(getPropertiesOfType(type), function (prop) { return isPartiallyInferableType(getTypeOfSymbol(prop)); }) || + isTupleType(type) && ts.some(getTypeArguments(type), isPartiallyInferableType); + } + function createReverseMappedType(source, target, constraint) { + // We consider a source type reverse mappable if it has a string index signature or if + // it has one or more properties and is of a partially inferable type. + if (!(getIndexInfoOfType(source, stringType) || getPropertiesOfType(source).length !== 0 && isPartiallyInferableType(source))) { + return undefined; + } + // For arrays and tuples we infer new arrays and tuples where the reverse mapping has been + // applied to the element type(s). + if (isArrayType(source)) { + return createArrayType(inferReverseMappedType(getTypeArguments(source)[0], target, constraint), isReadonlyArrayType(source)); + } + if (isTupleType(source)) { + var elementTypes = ts.map(getTypeArguments(source), function (t) { return inferReverseMappedType(t, target, constraint); }); + var elementFlags = getMappedTypeModifiers(target) & 4 /* MappedTypeModifiers.IncludeOptional */ ? + ts.sameMap(source.target.elementFlags, function (f) { return f & 2 /* ElementFlags.Optional */ ? 1 /* ElementFlags.Required */ : f; }) : + source.target.elementFlags; + return createTupleType(elementTypes, elementFlags, source.target.readonly, source.target.labeledElementDeclarations); + } + // For all other object types we infer a new object type where the reverse mapping has been + // applied to the type of each property. + var reversed = createObjectType(1024 /* ObjectFlags.ReverseMapped */ | 16 /* ObjectFlags.Anonymous */, /*symbol*/ undefined); + reversed.source = source; + reversed.mappedType = target; + reversed.constraintType = constraint; + return reversed; + } + function getTypeOfReverseMappedSymbol(symbol) { + var links = getSymbolLinks(symbol); + if (!links.type) { + links.type = inferReverseMappedType(symbol.propertyType, symbol.mappedType, symbol.constraintType); + } + return links.type; + } + function inferReverseMappedType(sourceType, target, constraint) { + var typeParameter = getIndexedAccessType(constraint.type, getTypeParameterFromMappedType(target)); + var templateType = getTemplateTypeFromMappedType(target); + var inference = createInferenceInfo(typeParameter); + inferTypes([inference], sourceType, templateType); + return getTypeFromInference(inference) || unknownType; + } + function getUnmatchedProperties(source, target, requireOptionalProperties, matchDiscriminantProperties) { + var properties, _i, properties_2, targetProp, sourceProp, targetType, sourceType; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + properties = getPropertiesOfType(target); + _i = 0, properties_2 = properties; + _a.label = 1; + case 1: + if (!(_i < properties_2.length)) return [3 /*break*/, 6]; + targetProp = properties_2[_i]; + // TODO: remove this when we support static private identifier fields and find other solutions to get privateNamesAndStaticFields test to pass + if (isStaticPrivateIdentifierProperty(targetProp)) { + return [3 /*break*/, 5]; + } + if (!(requireOptionalProperties || !(targetProp.flags & 16777216 /* SymbolFlags.Optional */ || ts.getCheckFlags(targetProp) & 48 /* CheckFlags.Partial */))) return [3 /*break*/, 5]; + sourceProp = getPropertyOfType(source, targetProp.escapedName); + if (!!sourceProp) return [3 /*break*/, 3]; + return [4 /*yield*/, targetProp]; + case 2: + _a.sent(); + return [3 /*break*/, 5]; + case 3: + if (!matchDiscriminantProperties) return [3 /*break*/, 5]; + targetType = getTypeOfSymbol(targetProp); + if (!(targetType.flags & 109440 /* TypeFlags.Unit */)) return [3 /*break*/, 5]; + sourceType = getTypeOfSymbol(sourceProp); + if (!!(sourceType.flags & 1 /* TypeFlags.Any */ || getRegularTypeOfLiteralType(sourceType) === getRegularTypeOfLiteralType(targetType))) return [3 /*break*/, 5]; + return [4 /*yield*/, targetProp]; + case 4: + _a.sent(); + _a.label = 5; + case 5: + _i++; + return [3 /*break*/, 1]; + case 6: return [2 /*return*/]; + } + }); + } + function getUnmatchedProperty(source, target, requireOptionalProperties, matchDiscriminantProperties) { + var result = getUnmatchedProperties(source, target, requireOptionalProperties, matchDiscriminantProperties).next(); + if (!result.done) + return result.value; + } + function tupleTypesDefinitelyUnrelated(source, target) { + return !(target.target.combinedFlags & 8 /* ElementFlags.Variadic */) && target.target.minLength > source.target.minLength || + !target.target.hasRestElement && (source.target.hasRestElement || target.target.fixedLength < source.target.fixedLength); + } + function typesDefinitelyUnrelated(source, target) { + // Two tuple types with incompatible arities are definitely unrelated. + // Two object types that each have a property that is unmatched in the other are definitely unrelated. + return isTupleType(source) && isTupleType(target) ? tupleTypesDefinitelyUnrelated(source, target) : + !!getUnmatchedProperty(source, target, /*requireOptionalProperties*/ false, /*matchDiscriminantProperties*/ true) && + !!getUnmatchedProperty(target, source, /*requireOptionalProperties*/ false, /*matchDiscriminantProperties*/ false); + } + function getTypeFromInference(inference) { + return inference.candidates ? getUnionType(inference.candidates, 2 /* UnionReduction.Subtype */) : + inference.contraCandidates ? getIntersectionType(inference.contraCandidates) : + undefined; + } + function hasSkipDirectInferenceFlag(node) { + return !!getNodeLinks(node).skipDirectInference; + } + function isFromInferenceBlockedSource(type) { + return !!(type.symbol && ts.some(type.symbol.declarations, hasSkipDirectInferenceFlag)); + } + function templateLiteralTypesDefinitelyUnrelated(source, target) { + // Two template literal types with diffences in their starting or ending text spans are definitely unrelated. + var sourceStart = source.texts[0]; + var targetStart = target.texts[0]; + var sourceEnd = source.texts[source.texts.length - 1]; + var targetEnd = target.texts[target.texts.length - 1]; + var startLen = Math.min(sourceStart.length, targetStart.length); + var endLen = Math.min(sourceEnd.length, targetEnd.length); + return sourceStart.slice(0, startLen) !== targetStart.slice(0, startLen) || + sourceEnd.slice(sourceEnd.length - endLen) !== targetEnd.slice(targetEnd.length - endLen); + } + /** + * Tests whether the provided string can be parsed as a number. + * @param s The string to test. + * @param roundTripOnly Indicates the resulting number matches the input when converted back to a string. + */ + function isValidNumberString(s, roundTripOnly) { + if (s === "") + return false; + var n = +s; + return isFinite(n) && (!roundTripOnly || "" + n === s); + } + /** + * @param text a valid bigint string excluding a trailing `n`, but including a possible prefix `-`. Use `isValidBigIntString(text, roundTripOnly)` before calling this function. + */ + function parseBigIntLiteralType(text) { + var negative = text.startsWith("-"); + var base10Value = ts.parsePseudoBigInt("".concat(negative ? text.slice(1) : text, "n")); + return getBigIntLiteralType({ negative: negative, base10Value: base10Value }); + } + /** + * Tests whether the provided string can be parsed as a bigint. + * @param s The string to test. + * @param roundTripOnly Indicates the resulting bigint matches the input when converted back to a string. + */ + function isValidBigIntString(s, roundTripOnly) { + if (s === "") + return false; + var scanner = ts.createScanner(99 /* ScriptTarget.ESNext */, /*skipTrivia*/ false); + var success = true; + scanner.setOnError(function () { return success = false; }); + scanner.setText(s + "n"); + var result = scanner.scan(); + var negative = result === 40 /* SyntaxKind.MinusToken */; + if (negative) { + result = scanner.scan(); + } + var flags = scanner.getTokenFlags(); + // validate that + // * scanning proceeded without error + // * a bigint can be scanned, and that when it is scanned, it is + // * the full length of the input string (so the scanner is one character beyond the augmented input length) + // * it does not contain a numeric seperator (the `BigInt` constructor does not accept a numeric seperator in its input) + return success && result === 9 /* SyntaxKind.BigIntLiteral */ && scanner.getTextPos() === (s.length + 1) && !(flags & 512 /* TokenFlags.ContainsSeparator */) + && (!roundTripOnly || s === ts.pseudoBigIntToString({ negative: negative, base10Value: ts.parsePseudoBigInt(scanner.getTokenValue()) })); + } + function isMemberOfStringMapping(source, target) { + if (target.flags & (4 /* TypeFlags.String */ | 1 /* TypeFlags.Any */)) { + return true; + } + if (target.flags & 134217728 /* TypeFlags.TemplateLiteral */) { + return isTypeAssignableTo(source, target); + } + if (target.flags & 268435456 /* TypeFlags.StringMapping */) { + // We need to see whether applying the same mappings of the target + // onto the source would produce an identical type *and* that + // it's compatible with the inner-most non-string-mapped type. + // + // The intuition here is that if same mappings don't affect the source at all, + // and the source is compatible with the unmapped target, then they must + // still reside in the same domain. + var mappingStack = []; + while (target.flags & 268435456 /* TypeFlags.StringMapping */) { + mappingStack.unshift(target.symbol); + target = target.type; + } + var mappedSource = ts.reduceLeft(mappingStack, function (memo, value) { return getStringMappingType(value, memo); }, source); + return mappedSource === source && isMemberOfStringMapping(source, target); + } + return false; + } + function isValidTypeForTemplateLiteralPlaceholder(source, target) { + if (source === target || target.flags & (1 /* TypeFlags.Any */ | 4 /* TypeFlags.String */)) { + return true; + } + if (source.flags & 128 /* TypeFlags.StringLiteral */) { + var value = source.value; + return !!(target.flags & 8 /* TypeFlags.Number */ && isValidNumberString(value, /*roundTripOnly*/ false) || + target.flags & 64 /* TypeFlags.BigInt */ && isValidBigIntString(value, /*roundTripOnly*/ false) || + target.flags & (512 /* TypeFlags.BooleanLiteral */ | 98304 /* TypeFlags.Nullable */) && value === target.intrinsicName || + target.flags & 268435456 /* TypeFlags.StringMapping */ && isMemberOfStringMapping(getStringLiteralType(value), target)); + } + if (source.flags & 134217728 /* TypeFlags.TemplateLiteral */) { + var texts = source.texts; + return texts.length === 2 && texts[0] === "" && texts[1] === "" && isTypeAssignableTo(source.types[0], target); + } + return isTypeAssignableTo(source, target); + } + function inferTypesFromTemplateLiteralType(source, target) { + return source.flags & 128 /* TypeFlags.StringLiteral */ ? inferFromLiteralPartsToTemplateLiteral([source.value], ts.emptyArray, target) : + source.flags & 134217728 /* TypeFlags.TemplateLiteral */ ? + ts.arraysEqual(source.texts, target.texts) ? ts.map(source.types, getStringLikeTypeForType) : + inferFromLiteralPartsToTemplateLiteral(source.texts, source.types, target) : + undefined; + } + function isTypeMatchedByTemplateLiteralType(source, target) { + var inferences = inferTypesFromTemplateLiteralType(source, target); + return !!inferences && ts.every(inferences, function (r, i) { return isValidTypeForTemplateLiteralPlaceholder(r, target.types[i]); }); + } + function getStringLikeTypeForType(type) { + return type.flags & (1 /* TypeFlags.Any */ | 402653316 /* TypeFlags.StringLike */) ? type : getTemplateLiteralType(["", ""], [type]); + } + // This function infers from the text parts and type parts of a source literal to a target template literal. The number + // of text parts is always one more than the number of type parts, and a source string literal is treated as a source + // with one text part and zero type parts. The function returns an array of inferred string or template literal types + // corresponding to the placeholders in the target template literal, or undefined if the source doesn't match the target. + // + // We first check that the starting source text part matches the starting target text part, and that the ending source + // text part ends matches the ending target text part. We then iterate through the remaining target text parts, finding + // a match for each in the source and inferring string or template literal types created from the segments of the source + // that occur between the matches. During this iteration, seg holds the index of the current text part in the sourceTexts + // array and pos holds the current character position in the current text part. + // + // Consider inference from type `<<${string}>.<${number}-${number}>>` to type `<${string}.${string}>`, i.e. + // sourceTexts = ['<<', '>.<', '-', '>>'] + // sourceTypes = [string, number, number] + // target.texts = ['<', '.', '>'] + // We first match '<' in the target to the start of '<<' in the source and '>' in the target to the end of '>>' in + // the source. The first match for the '.' in target occurs at character 1 in the source text part at index 1, and thus + // the first inference is the template literal type `<${string}>`. The remainder of the source makes up the second + // inference, the template literal type `<${number}-${number}>`. + function inferFromLiteralPartsToTemplateLiteral(sourceTexts, sourceTypes, target) { + var lastSourceIndex = sourceTexts.length - 1; + var sourceStartText = sourceTexts[0]; + var sourceEndText = sourceTexts[lastSourceIndex]; + var targetTexts = target.texts; + var lastTargetIndex = targetTexts.length - 1; + var targetStartText = targetTexts[0]; + var targetEndText = targetTexts[lastTargetIndex]; + if (lastSourceIndex === 0 && sourceStartText.length < targetStartText.length + targetEndText.length || + !sourceStartText.startsWith(targetStartText) || !sourceEndText.endsWith(targetEndText)) + return undefined; + var remainingEndText = sourceEndText.slice(0, sourceEndText.length - targetEndText.length); + var matches = []; + var seg = 0; + var pos = targetStartText.length; + for (var i = 1; i < lastTargetIndex; i++) { + var delim = targetTexts[i]; + if (delim.length > 0) { + var s = seg; + var p = pos; + while (true) { + p = getSourceText(s).indexOf(delim, p); + if (p >= 0) + break; + s++; + if (s === sourceTexts.length) + return undefined; + p = 0; + } + addMatch(s, p); + pos += delim.length; + } + else if (pos < getSourceText(seg).length) { + addMatch(seg, pos + 1); + } + else if (seg < lastSourceIndex) { + addMatch(seg + 1, 0); + } + else { + return undefined; + } + } + addMatch(lastSourceIndex, getSourceText(lastSourceIndex).length); + return matches; + function getSourceText(index) { + return index < lastSourceIndex ? sourceTexts[index] : remainingEndText; + } + function addMatch(s, p) { + var matchType = s === seg ? + getStringLiteralType(getSourceText(s).slice(pos, p)) : + getTemplateLiteralType(__spreadArray(__spreadArray([sourceTexts[seg].slice(pos)], sourceTexts.slice(seg + 1, s), true), [getSourceText(s).slice(0, p)], false), sourceTypes.slice(seg, s)); + matches.push(matchType); + seg = s; + pos = p; + } + } + function inferTypes(inferences, originalSource, originalTarget, priority, contravariant) { + if (priority === void 0) { priority = 0; } + if (contravariant === void 0) { contravariant = false; } + var bivariant = false; + var propagationType; + var inferencePriority = 2048 /* InferencePriority.MaxValue */; + var allowComplexConstraintInference = true; + var visited; + var sourceStack; + var targetStack; + var expandingFlags = 0 /* ExpandingFlags.None */; + inferFromTypes(originalSource, originalTarget); + function inferFromTypes(source, target) { + if (!couldContainTypeVariables(target)) { + return; + } + if (source === wildcardType) { + // We are inferring from an 'any' type. We want to infer this type for every type parameter + // referenced in the target type, so we record it as the propagation type and infer from the + // target to itself. Then, as we find candidates we substitute the propagation type. + var savePropagationType = propagationType; + propagationType = source; + inferFromTypes(target, target); + propagationType = savePropagationType; + return; + } + if (source.aliasSymbol && source.aliasSymbol === target.aliasSymbol) { + if (source.aliasTypeArguments) { + // Source and target are types originating in the same generic type alias declaration. + // Simply infer from source type arguments to target type arguments. + inferFromTypeArguments(source.aliasTypeArguments, target.aliasTypeArguments, getAliasVariances(source.aliasSymbol)); + } + // And if there weren't any type arguments, there's no reason to run inference as the types must be the same. + return; + } + if (source === target && source.flags & 3145728 /* TypeFlags.UnionOrIntersection */) { + // When source and target are the same union or intersection type, just relate each constituent + // type to itself. + for (var _i = 0, _a = source.types; _i < _a.length; _i++) { + var t = _a[_i]; + inferFromTypes(t, t); + } + return; + } + if (target.flags & 1048576 /* TypeFlags.Union */) { + // First, infer between identically matching source and target constituents and remove the + // matching types. + var _b = inferFromMatchingTypes(source.flags & 1048576 /* TypeFlags.Union */ ? source.types : [source], target.types, isTypeOrBaseIdenticalTo), tempSources = _b[0], tempTargets = _b[1]; + // Next, infer between closely matching source and target constituents and remove + // the matching types. Types closely match when they are instantiations of the same + // object type or instantiations of the same type alias. + var _c = inferFromMatchingTypes(tempSources, tempTargets, isTypeCloselyMatchedBy), sources = _c[0], targets = _c[1]; + if (targets.length === 0) { + return; + } + target = getUnionType(targets); + if (sources.length === 0) { + // All source constituents have been matched and there is nothing further to infer from. + // However, simply making no inferences is undesirable because it could ultimately mean + // inferring a type parameter constraint. Instead, make a lower priority inference from + // the full source to whatever remains in the target. For example, when inferring from + // string to 'string | T', make a lower priority inference of string for T. + inferWithPriority(source, target, 1 /* InferencePriority.NakedTypeVariable */); + return; + } + source = getUnionType(sources); + } + else if (target.flags & 2097152 /* TypeFlags.Intersection */ && ts.some(target.types, function (t) { return !!getInferenceInfoForType(t) || (isGenericMappedType(t) && !!getInferenceInfoForType(getHomomorphicTypeVariable(t) || neverType)); })) { + // We reduce intersection types only when they contain naked type parameters. For example, when + // inferring from 'string[] & { extra: any }' to 'string[] & T' we want to remove string[] and + // infer { extra: any } for T. But when inferring to 'string[] & Iterable' we want to keep the + // string[] on the source side and infer string for T. + // Likewise, we consider a homomorphic mapped type constrainted to the target type parameter as similar to a "naked type variable" + // in such scenarios. + if (!(source.flags & 1048576 /* TypeFlags.Union */)) { + // Infer between identically matching source and target constituents and remove the matching types. + var _d = inferFromMatchingTypes(source.flags & 2097152 /* TypeFlags.Intersection */ ? source.types : [source], target.types, isTypeIdenticalTo), sources = _d[0], targets = _d[1]; + if (sources.length === 0 || targets.length === 0) { + return; + } + source = getIntersectionType(sources); + target = getIntersectionType(targets); + } + } + else if (target.flags & (8388608 /* TypeFlags.IndexedAccess */ | 33554432 /* TypeFlags.Substitution */)) { + target = getActualTypeVariable(target); + } + if (target.flags & 8650752 /* TypeFlags.TypeVariable */) { + // Skip inference if the source is "blocked", which is used by the language service to + // prevent inference on nodes currently being edited. + if (isFromInferenceBlockedSource(source)) { + return; + } + var inference = getInferenceInfoForType(target); + if (inference) { + // If target is a type parameter, make an inference, unless the source type contains + // a "non-inferrable" type. Types with this flag set are markers used to prevent inference. + // + // For example: + // - anyFunctionType is a wildcard type that's used to avoid contextually typing functions; + // it's internal, so should not be exposed to the user by adding it as a candidate. + // - autoType (and autoArrayType) is a special "any" used in control flow; like anyFunctionType, + // it's internal and should not be observable. + // - silentNeverType is returned by getInferredType when instantiating a generic function for + // inference (and a type variable has no mapping). + // + // This flag is infectious; if we produce Box (where never is silentNeverType), Box is + // also non-inferrable. + // + // As a special case, also ignore nonInferrableAnyType, which is a special form of the any type + // used as a stand-in for binding elements when they are being inferred. + if (ts.getObjectFlags(source) & 262144 /* ObjectFlags.NonInferrableType */ || source === nonInferrableAnyType) { + return; + } + if (!inference.isFixed) { + if (inference.priority === undefined || priority < inference.priority) { + inference.candidates = undefined; + inference.contraCandidates = undefined; + inference.topLevel = true; + inference.priority = priority; + } + if (priority === inference.priority) { + var candidate = propagationType || source; + // We make contravariant inferences only if we are in a pure contravariant position, + // i.e. only if we have not descended into a bivariant position. + if (contravariant && !bivariant) { + if (!ts.contains(inference.contraCandidates, candidate)) { + inference.contraCandidates = ts.append(inference.contraCandidates, candidate); + clearCachedInferences(inferences); + } + } + else if (!ts.contains(inference.candidates, candidate)) { + inference.candidates = ts.append(inference.candidates, candidate); + clearCachedInferences(inferences); + } + } + if (!(priority & 128 /* InferencePriority.ReturnType */) && target.flags & 262144 /* TypeFlags.TypeParameter */ && inference.topLevel && !isTypeParameterAtTopLevel(originalTarget, target)) { + inference.topLevel = false; + clearCachedInferences(inferences); + } + } + inferencePriority = Math.min(inferencePriority, priority); + return; + } + // Infer to the simplified version of an indexed access, if possible, to (hopefully) expose more bare type parameters to the inference engine + var simplified = getSimplifiedType(target, /*writing*/ false); + if (simplified !== target) { + inferFromTypes(source, simplified); + } + else if (target.flags & 8388608 /* TypeFlags.IndexedAccess */) { + var indexType = getSimplifiedType(target.indexType, /*writing*/ false); + // Generally simplifications of instantiable indexes are avoided to keep relationship checking correct, however if our target is an access, we can consider + // that key of that access to be "instantiated", since we're looking to find the infernce goal in any way we can. + if (indexType.flags & 465829888 /* TypeFlags.Instantiable */) { + var simplified_1 = distributeIndexOverObjectType(getSimplifiedType(target.objectType, /*writing*/ false), indexType, /*writing*/ false); + if (simplified_1 && simplified_1 !== target) { + inferFromTypes(source, simplified_1); + } + } + } + } + if (ts.getObjectFlags(source) & 4 /* ObjectFlags.Reference */ && ts.getObjectFlags(target) & 4 /* ObjectFlags.Reference */ && (source.target === target.target || isArrayType(source) && isArrayType(target)) && + !(source.node && target.node)) { + // If source and target are references to the same generic type, infer from type arguments + inferFromTypeArguments(getTypeArguments(source), getTypeArguments(target), getVariances(source.target)); + } + else if (source.flags & 4194304 /* TypeFlags.Index */ && target.flags & 4194304 /* TypeFlags.Index */) { + inferFromContravariantTypes(source.type, target.type); + } + else if ((isLiteralType(source) || source.flags & 4 /* TypeFlags.String */) && target.flags & 4194304 /* TypeFlags.Index */) { + var empty = createEmptyObjectTypeFromStringLiteral(source); + inferFromContravariantTypesWithPriority(empty, target.type, 256 /* InferencePriority.LiteralKeyof */); + } + else if (source.flags & 8388608 /* TypeFlags.IndexedAccess */ && target.flags & 8388608 /* TypeFlags.IndexedAccess */) { + inferFromTypes(source.objectType, target.objectType); + inferFromTypes(source.indexType, target.indexType); + } + else if (source.flags & 268435456 /* TypeFlags.StringMapping */ && target.flags & 268435456 /* TypeFlags.StringMapping */) { + if (source.symbol === target.symbol) { + inferFromTypes(source.type, target.type); + } + } + else if (source.flags & 33554432 /* TypeFlags.Substitution */) { + inferFromTypes(source.baseType, target); + inferWithPriority(getSubstitutionIntersection(source), target, 4 /* InferencePriority.SubstituteSource */); // Make substitute inference at a lower priority + } + else if (target.flags & 16777216 /* TypeFlags.Conditional */) { + invokeOnce(source, target, inferToConditionalType); + } + else if (target.flags & 3145728 /* TypeFlags.UnionOrIntersection */) { + inferToMultipleTypes(source, target.types, target.flags); + } + else if (source.flags & 1048576 /* TypeFlags.Union */) { + // Source is a union or intersection type, infer from each constituent type + var sourceTypes = source.types; + for (var _e = 0, sourceTypes_2 = sourceTypes; _e < sourceTypes_2.length; _e++) { + var sourceType = sourceTypes_2[_e]; + inferFromTypes(sourceType, target); + } + } + else if (target.flags & 134217728 /* TypeFlags.TemplateLiteral */) { + inferToTemplateLiteralType(source, target); + } + else { + source = getReducedType(source); + if (!(priority & 512 /* InferencePriority.NoConstraints */ && source.flags & (2097152 /* TypeFlags.Intersection */ | 465829888 /* TypeFlags.Instantiable */))) { + var apparentSource = getApparentType(source); + // getApparentType can return _any_ type, since an indexed access or conditional may simplify to any other type. + // If that occurs and it doesn't simplify to an object or intersection, we'll need to restart `inferFromTypes` + // with the simplified source. + if (apparentSource !== source && allowComplexConstraintInference && !(apparentSource.flags & (524288 /* TypeFlags.Object */ | 2097152 /* TypeFlags.Intersection */))) { + // TODO: The `allowComplexConstraintInference` flag is a hack! This forbids inference from complex constraints within constraints! + // This isn't required algorithmically, but rather is used to lower the memory burden caused by performing inference + // that is _too good_ in projects with complicated constraints (eg, fp-ts). In such cases, if we did not limit ourselves + // here, we might produce more valid inferences for types, causing us to do more checks and perform more instantiations + // (in addition to the extra stack depth here) which, in turn, can push the already close process over its limit. + // TL;DR: If we ever become generally more memory efficient (or our resource budget ever increases), we should just + // remove this `allowComplexConstraintInference` flag. + allowComplexConstraintInference = false; + return inferFromTypes(apparentSource, target); + } + source = apparentSource; + } + if (source.flags & (524288 /* TypeFlags.Object */ | 2097152 /* TypeFlags.Intersection */)) { + invokeOnce(source, target, inferFromObjectTypes); + } + } + } + function inferWithPriority(source, target, newPriority) { + var savePriority = priority; + priority |= newPriority; + inferFromTypes(source, target); + priority = savePriority; + } + function inferFromContravariantTypesWithPriority(source, target, newPriority) { + var savePriority = priority; + priority |= newPriority; + inferFromContravariantTypes(source, target); + priority = savePriority; + } + function inferToMultipleTypesWithPriority(source, targets, targetFlags, newPriority) { + var savePriority = priority; + priority |= newPriority; + inferToMultipleTypes(source, targets, targetFlags); + priority = savePriority; + } + function invokeOnce(source, target, action) { + var key = source.id + "," + target.id; + var status = visited && visited.get(key); + if (status !== undefined) { + inferencePriority = Math.min(inferencePriority, status); + return; + } + (visited || (visited = new ts.Map())).set(key, -1 /* InferencePriority.Circularity */); + var saveInferencePriority = inferencePriority; + inferencePriority = 2048 /* InferencePriority.MaxValue */; + // We stop inferring and report a circularity if we encounter duplicate recursion identities on both + // the source side and the target side. + var saveExpandingFlags = expandingFlags; + var sourceIdentity = getRecursionIdentity(source); + var targetIdentity = getRecursionIdentity(target); + if (ts.contains(sourceStack, sourceIdentity)) + expandingFlags |= 1 /* ExpandingFlags.Source */; + if (ts.contains(targetStack, targetIdentity)) + expandingFlags |= 2 /* ExpandingFlags.Target */; + if (expandingFlags !== 3 /* ExpandingFlags.Both */) { + (sourceStack || (sourceStack = [])).push(sourceIdentity); + (targetStack || (targetStack = [])).push(targetIdentity); + action(source, target); + targetStack.pop(); + sourceStack.pop(); + } + else { + inferencePriority = -1 /* InferencePriority.Circularity */; + } + expandingFlags = saveExpandingFlags; + visited.set(key, inferencePriority); + inferencePriority = Math.min(inferencePriority, saveInferencePriority); + } + function inferFromMatchingTypes(sources, targets, matches) { + var matchedSources; + var matchedTargets; + for (var _i = 0, targets_1 = targets; _i < targets_1.length; _i++) { + var t = targets_1[_i]; + for (var _a = 0, sources_1 = sources; _a < sources_1.length; _a++) { + var s = sources_1[_a]; + if (matches(s, t)) { + inferFromTypes(s, t); + matchedSources = ts.appendIfUnique(matchedSources, s); + matchedTargets = ts.appendIfUnique(matchedTargets, t); + } + } + } + return [ + matchedSources ? ts.filter(sources, function (t) { return !ts.contains(matchedSources, t); }) : sources, + matchedTargets ? ts.filter(targets, function (t) { return !ts.contains(matchedTargets, t); }) : targets, + ]; + } + function inferFromTypeArguments(sourceTypes, targetTypes, variances) { + var count = sourceTypes.length < targetTypes.length ? sourceTypes.length : targetTypes.length; + for (var i = 0; i < count; i++) { + if (i < variances.length && (variances[i] & 7 /* VarianceFlags.VarianceMask */) === 2 /* VarianceFlags.Contravariant */) { + inferFromContravariantTypes(sourceTypes[i], targetTypes[i]); + } + else { + inferFromTypes(sourceTypes[i], targetTypes[i]); + } + } + } + function inferFromContravariantTypes(source, target) { + contravariant = !contravariant; + inferFromTypes(source, target); + contravariant = !contravariant; + } + function inferFromContravariantTypesIfStrictFunctionTypes(source, target) { + if (strictFunctionTypes || priority & 1024 /* InferencePriority.AlwaysStrict */) { + inferFromContravariantTypes(source, target); + } + else { + inferFromTypes(source, target); + } + } + function getInferenceInfoForType(type) { + if (type.flags & 8650752 /* TypeFlags.TypeVariable */) { + for (var _i = 0, inferences_2 = inferences; _i < inferences_2.length; _i++) { + var inference = inferences_2[_i]; + if (type === inference.typeParameter) { + return inference; + } + } + } + return undefined; + } + function getSingleTypeVariableFromIntersectionTypes(types) { + var typeVariable; + for (var _i = 0, types_14 = types; _i < types_14.length; _i++) { + var type = types_14[_i]; + var t = type.flags & 2097152 /* TypeFlags.Intersection */ && ts.find(type.types, function (t) { return !!getInferenceInfoForType(t); }); + if (!t || typeVariable && t !== typeVariable) { + return undefined; + } + typeVariable = t; + } + return typeVariable; + } + function inferToMultipleTypes(source, targets, targetFlags) { + var typeVariableCount = 0; + if (targetFlags & 1048576 /* TypeFlags.Union */) { + var nakedTypeVariable = void 0; + var sources = source.flags & 1048576 /* TypeFlags.Union */ ? source.types : [source]; + var matched_1 = new Array(sources.length); + var inferenceCircularity = false; + // First infer to types that are not naked type variables. For each source type we + // track whether inferences were made from that particular type to some target with + // equal priority (i.e. of equal quality) to what we would infer for a naked type + // parameter. + for (var _i = 0, targets_2 = targets; _i < targets_2.length; _i++) { + var t = targets_2[_i]; + if (getInferenceInfoForType(t)) { + nakedTypeVariable = t; + typeVariableCount++; + } + else { + for (var i = 0; i < sources.length; i++) { + var saveInferencePriority = inferencePriority; + inferencePriority = 2048 /* InferencePriority.MaxValue */; + inferFromTypes(sources[i], t); + if (inferencePriority === priority) + matched_1[i] = true; + inferenceCircularity = inferenceCircularity || inferencePriority === -1 /* InferencePriority.Circularity */; + inferencePriority = Math.min(inferencePriority, saveInferencePriority); + } + } + } + if (typeVariableCount === 0) { + // If every target is an intersection of types containing a single naked type variable, + // make a lower priority inference to that type variable. This handles inferring from + // 'A | B' to 'T & (X | Y)' where we want to infer 'A | B' for T. + var intersectionTypeVariable = getSingleTypeVariableFromIntersectionTypes(targets); + if (intersectionTypeVariable) { + inferWithPriority(source, intersectionTypeVariable, 1 /* InferencePriority.NakedTypeVariable */); + } + return; + } + // If the target has a single naked type variable and no inference circularities were + // encountered above (meaning we explored the types fully), create a union of the source + // types from which no inferences have been made so far and infer from that union to the + // naked type variable. + if (typeVariableCount === 1 && !inferenceCircularity) { + var unmatched = ts.flatMap(sources, function (s, i) { return matched_1[i] ? undefined : s; }); + if (unmatched.length) { + inferFromTypes(getUnionType(unmatched), nakedTypeVariable); + return; + } + } + } + else { + // We infer from types that are not naked type variables first so that inferences we + // make from nested naked type variables and given slightly higher priority by virtue + // of being first in the candidates array. + for (var _a = 0, targets_3 = targets; _a < targets_3.length; _a++) { + var t = targets_3[_a]; + if (getInferenceInfoForType(t)) { + typeVariableCount++; + } + else { + inferFromTypes(source, t); + } + } + } + // Inferences directly to naked type variables are given lower priority as they are + // less specific. For example, when inferring from Promise to T | Promise, + // we want to infer string for T, not Promise | string. For intersection types + // we only infer to single naked type variables. + if (targetFlags & 2097152 /* TypeFlags.Intersection */ ? typeVariableCount === 1 : typeVariableCount > 0) { + for (var _b = 0, targets_4 = targets; _b < targets_4.length; _b++) { + var t = targets_4[_b]; + if (getInferenceInfoForType(t)) { + inferWithPriority(source, t, 1 /* InferencePriority.NakedTypeVariable */); + } + } + } + } + function inferToMappedType(source, target, constraintType) { + if (constraintType.flags & 1048576 /* TypeFlags.Union */) { + var result = false; + for (var _i = 0, _a = constraintType.types; _i < _a.length; _i++) { + var type = _a[_i]; + result = inferToMappedType(source, target, type) || result; + } + return result; + } + if (constraintType.flags & 4194304 /* TypeFlags.Index */) { + // We're inferring from some source type S to a homomorphic mapped type { [P in keyof T]: X }, + // where T is a type variable. Use inferTypeForHomomorphicMappedType to infer a suitable source + // type and then make a secondary inference from that type to T. We make a secondary inference + // such that direct inferences to T get priority over inferences to Partial, for example. + var inference = getInferenceInfoForType(constraintType.type); + if (inference && !inference.isFixed && !isFromInferenceBlockedSource(source)) { + var inferredType = inferTypeForHomomorphicMappedType(source, target, constraintType); + if (inferredType) { + // We assign a lower priority to inferences made from types containing non-inferrable + // types because we may only have a partial result (i.e. we may have failed to make + // reverse inferences for some properties). + inferWithPriority(inferredType, inference.typeParameter, ts.getObjectFlags(source) & 262144 /* ObjectFlags.NonInferrableType */ ? + 16 /* InferencePriority.PartialHomomorphicMappedType */ : + 8 /* InferencePriority.HomomorphicMappedType */); + } + } + return true; + } + if (constraintType.flags & 262144 /* TypeFlags.TypeParameter */) { + // We're inferring from some source type S to a mapped type { [P in K]: X }, where K is a type + // parameter. First infer from 'keyof S' to K. + inferWithPriority(getIndexType(source), constraintType, 32 /* InferencePriority.MappedTypeConstraint */); + // If K is constrained to a type C, also infer to C. Thus, for a mapped type { [P in K]: X }, + // where K extends keyof T, we make the same inferences as for a homomorphic mapped type + // { [P in keyof T]: X }. This enables us to make meaningful inferences when the target is a + // Pick. + var extendedConstraint = getConstraintOfType(constraintType); + if (extendedConstraint && inferToMappedType(source, target, extendedConstraint)) { + return true; + } + // If no inferences can be made to K's constraint, infer from a union of the property types + // in the source to the template type X. + var propTypes = ts.map(getPropertiesOfType(source), getTypeOfSymbol); + var indexTypes = ts.map(getIndexInfosOfType(source), function (info) { return info !== enumNumberIndexInfo ? info.type : neverType; }); + inferFromTypes(getUnionType(ts.concatenate(propTypes, indexTypes)), getTemplateTypeFromMappedType(target)); + return true; + } + return false; + } + function inferToConditionalType(source, target) { + if (source.flags & 16777216 /* TypeFlags.Conditional */) { + inferFromTypes(source.checkType, target.checkType); + inferFromTypes(source.extendsType, target.extendsType); + inferFromTypes(getTrueTypeFromConditionalType(source), getTrueTypeFromConditionalType(target)); + inferFromTypes(getFalseTypeFromConditionalType(source), getFalseTypeFromConditionalType(target)); + } + else { + var targetTypes = [getTrueTypeFromConditionalType(target), getFalseTypeFromConditionalType(target)]; + inferToMultipleTypesWithPriority(source, targetTypes, target.flags, contravariant ? 64 /* InferencePriority.ContravariantConditional */ : 0); + } + } + function inferToTemplateLiteralType(source, target) { + var matches = inferTypesFromTemplateLiteralType(source, target); + var types = target.types; + // When the target template literal contains only placeholders (meaning that inference is intended to extract + // single characters and remainder strings) and inference fails to produce matches, we want to infer 'never' for + // each placeholder such that instantiation with the inferred value(s) produces 'never', a type for which an + // assignment check will fail. If we make no inferences, we'll likely end up with the constraint 'string' which, + // upon instantiation, would collapse all the placeholders to just 'string', and an assignment check might + // succeed. That would be a pointless and confusing outcome. + if (matches || ts.every(target.texts, function (s) { return s.length === 0; })) { + var _loop_24 = function (i) { + var source_1 = matches ? matches[i] : neverType; + var target_3 = types[i]; + // If we are inferring from a string literal type to a type variable whose constraint includes one of the + // allowed template literal placeholder types, infer from a literal type corresponding to the constraint. + if (source_1.flags & 128 /* TypeFlags.StringLiteral */ && target_3.flags & 8650752 /* TypeFlags.TypeVariable */) { + var inferenceContext = getInferenceInfoForType(target_3); + var constraint = inferenceContext ? getBaseConstraintOfType(inferenceContext.typeParameter) : undefined; + if (constraint && !isTypeAny(constraint)) { + var constraintTypes = constraint.flags & 1048576 /* TypeFlags.Union */ ? constraint.types : [constraint]; + var allTypeFlags_1 = ts.reduceLeft(constraintTypes, function (flags, t) { return flags | t.flags; }, 0); + // If the constraint contains `string`, we don't need to look for a more preferred type + if (!(allTypeFlags_1 & 4 /* TypeFlags.String */)) { + var str_1 = source_1.value; + // If the type contains `number` or a number literal and the string isn't a valid number, exclude numbers + if (allTypeFlags_1 & 296 /* TypeFlags.NumberLike */ && !isValidNumberString(str_1, /*roundTripOnly*/ true)) { + allTypeFlags_1 &= ~296 /* TypeFlags.NumberLike */; + } + // If the type contains `bigint` or a bigint literal and the string isn't a valid bigint, exclude bigints + if (allTypeFlags_1 & 2112 /* TypeFlags.BigIntLike */ && !isValidBigIntString(str_1, /*roundTripOnly*/ true)) { + allTypeFlags_1 &= ~2112 /* TypeFlags.BigIntLike */; + } + // for each type in the constraint, find the highest priority matching type + var matchingType = ts.reduceLeft(constraintTypes, function (left, right) { + return !(right.flags & allTypeFlags_1) ? left : + left.flags & 4 /* TypeFlags.String */ ? left : right.flags & 4 /* TypeFlags.String */ ? source_1 : + left.flags & 134217728 /* TypeFlags.TemplateLiteral */ ? left : right.flags & 134217728 /* TypeFlags.TemplateLiteral */ && isTypeMatchedByTemplateLiteralType(source_1, right) ? source_1 : + left.flags & 268435456 /* TypeFlags.StringMapping */ ? left : right.flags & 268435456 /* TypeFlags.StringMapping */ && str_1 === applyStringMapping(right.symbol, str_1) ? source_1 : + left.flags & 128 /* TypeFlags.StringLiteral */ ? left : right.flags & 128 /* TypeFlags.StringLiteral */ && right.value === str_1 ? right : + left.flags & 8 /* TypeFlags.Number */ ? left : right.flags & 8 /* TypeFlags.Number */ ? getNumberLiteralType(+str_1) : + left.flags & 32 /* TypeFlags.Enum */ ? left : right.flags & 32 /* TypeFlags.Enum */ ? getNumberLiteralType(+str_1) : + left.flags & 256 /* TypeFlags.NumberLiteral */ ? left : right.flags & 256 /* TypeFlags.NumberLiteral */ && right.value === +str_1 ? right : + left.flags & 64 /* TypeFlags.BigInt */ ? left : right.flags & 64 /* TypeFlags.BigInt */ ? parseBigIntLiteralType(str_1) : + left.flags & 2048 /* TypeFlags.BigIntLiteral */ ? left : right.flags & 2048 /* TypeFlags.BigIntLiteral */ && ts.pseudoBigIntToString(right.value) === str_1 ? right : + left.flags & 16 /* TypeFlags.Boolean */ ? left : right.flags & 16 /* TypeFlags.Boolean */ ? str_1 === "true" ? trueType : str_1 === "false" ? falseType : booleanType : + left.flags & 512 /* TypeFlags.BooleanLiteral */ ? left : right.flags & 512 /* TypeFlags.BooleanLiteral */ && right.intrinsicName === str_1 ? right : + left.flags & 32768 /* TypeFlags.Undefined */ ? left : right.flags & 32768 /* TypeFlags.Undefined */ && right.intrinsicName === str_1 ? right : + left.flags & 65536 /* TypeFlags.Null */ ? left : right.flags & 65536 /* TypeFlags.Null */ && right.intrinsicName === str_1 ? right : + left; + }, neverType); + if (!(matchingType.flags & 131072 /* TypeFlags.Never */)) { + inferFromTypes(matchingType, target_3); + return "continue"; + } + } + } + } + inferFromTypes(source_1, target_3); + }; + for (var i = 0; i < types.length; i++) { + _loop_24(i); + } + } + } + function inferFromObjectTypes(source, target) { + if (ts.getObjectFlags(source) & 4 /* ObjectFlags.Reference */ && ts.getObjectFlags(target) & 4 /* ObjectFlags.Reference */ && (source.target === target.target || isArrayType(source) && isArrayType(target))) { + // If source and target are references to the same generic type, infer from type arguments + inferFromTypeArguments(getTypeArguments(source), getTypeArguments(target), getVariances(source.target)); + return; + } + if (isGenericMappedType(source) && isGenericMappedType(target)) { + // The source and target types are generic types { [P in S]: X } and { [P in T]: Y }, so we infer + // from S to T and from X to Y. + inferFromTypes(getConstraintTypeFromMappedType(source), getConstraintTypeFromMappedType(target)); + inferFromTypes(getTemplateTypeFromMappedType(source), getTemplateTypeFromMappedType(target)); + var sourceNameType = getNameTypeFromMappedType(source); + var targetNameType = getNameTypeFromMappedType(target); + if (sourceNameType && targetNameType) + inferFromTypes(sourceNameType, targetNameType); + } + if (ts.getObjectFlags(target) & 32 /* ObjectFlags.Mapped */ && !target.declaration.nameType) { + var constraintType = getConstraintTypeFromMappedType(target); + if (inferToMappedType(source, target, constraintType)) { + return; + } + } + // Infer from the members of source and target only if the two types are possibly related + if (!typesDefinitelyUnrelated(source, target)) { + if (isArrayOrTupleType(source)) { + if (isTupleType(target)) { + var sourceArity = getTypeReferenceArity(source); + var targetArity = getTypeReferenceArity(target); + var elementTypes = getTypeArguments(target); + var elementFlags = target.target.elementFlags; + // When source and target are tuple types with the same structure (fixed, variadic, and rest are matched + // to the same kind in each position), simply infer between the element types. + if (isTupleType(source) && isTupleTypeStructureMatching(source, target)) { + for (var i = 0; i < targetArity; i++) { + inferFromTypes(getTypeArguments(source)[i], elementTypes[i]); + } + return; + } + var startLength = isTupleType(source) ? Math.min(source.target.fixedLength, target.target.fixedLength) : 0; + var endLength = Math.min(isTupleType(source) ? getEndElementCount(source.target, 3 /* ElementFlags.Fixed */) : 0, target.target.hasRestElement ? getEndElementCount(target.target, 3 /* ElementFlags.Fixed */) : 0); + // Infer between starting fixed elements. + for (var i = 0; i < startLength; i++) { + inferFromTypes(getTypeArguments(source)[i], elementTypes[i]); + } + if (!isTupleType(source) || sourceArity - startLength - endLength === 1 && source.target.elementFlags[startLength] & 4 /* ElementFlags.Rest */) { + // Single rest element remains in source, infer from that to every element in target + var restType = getTypeArguments(source)[startLength]; + for (var i = startLength; i < targetArity - endLength; i++) { + inferFromTypes(elementFlags[i] & 8 /* ElementFlags.Variadic */ ? createArrayType(restType) : restType, elementTypes[i]); + } + } + else { + var middleLength = targetArity - startLength - endLength; + if (middleLength === 2 && elementFlags[startLength] & elementFlags[startLength + 1] & 8 /* ElementFlags.Variadic */ && isTupleType(source)) { + // Middle of target is [...T, ...U] and source is tuple type + var targetInfo = getInferenceInfoForType(elementTypes[startLength]); + if (targetInfo && targetInfo.impliedArity !== undefined) { + // Infer slices from source based on implied arity of T. + inferFromTypes(sliceTupleType(source, startLength, endLength + sourceArity - targetInfo.impliedArity), elementTypes[startLength]); + inferFromTypes(sliceTupleType(source, startLength + targetInfo.impliedArity, endLength), elementTypes[startLength + 1]); + } + } + else if (middleLength === 1 && elementFlags[startLength] & 8 /* ElementFlags.Variadic */) { + // Middle of target is exactly one variadic element. Infer the slice between the fixed parts in the source. + // If target ends in optional element(s), make a lower priority a speculative inference. + var endsInOptional = target.target.elementFlags[targetArity - 1] & 2 /* ElementFlags.Optional */; + var sourceSlice = isTupleType(source) ? sliceTupleType(source, startLength, endLength) : createArrayType(getTypeArguments(source)[0]); + inferWithPriority(sourceSlice, elementTypes[startLength], endsInOptional ? 2 /* InferencePriority.SpeculativeTuple */ : 0); + } + else if (middleLength === 1 && elementFlags[startLength] & 4 /* ElementFlags.Rest */) { + // Middle of target is exactly one rest element. If middle of source is not empty, infer union of middle element types. + var restType = isTupleType(source) ? getElementTypeOfSliceOfTupleType(source, startLength, endLength) : getTypeArguments(source)[0]; + if (restType) { + inferFromTypes(restType, elementTypes[startLength]); + } + } + } + // Infer between ending fixed elements + for (var i = 0; i < endLength; i++) { + inferFromTypes(getTypeArguments(source)[sourceArity - i - 1], elementTypes[targetArity - i - 1]); + } + return; + } + if (isArrayType(target)) { + inferFromIndexTypes(source, target); + return; + } + } + inferFromProperties(source, target); + inferFromSignatures(source, target, 0 /* SignatureKind.Call */); + inferFromSignatures(source, target, 1 /* SignatureKind.Construct */); + inferFromIndexTypes(source, target); + } + } + function inferFromProperties(source, target) { + var properties = getPropertiesOfObjectType(target); + for (var _i = 0, properties_3 = properties; _i < properties_3.length; _i++) { + var targetProp = properties_3[_i]; + var sourceProp = getPropertyOfType(source, targetProp.escapedName); + if (sourceProp && !ts.some(sourceProp.declarations, hasSkipDirectInferenceFlag)) { + inferFromTypes(getTypeOfSymbol(sourceProp), getTypeOfSymbol(targetProp)); + } + } + } + function inferFromSignatures(source, target, kind) { + var sourceSignatures = getSignaturesOfType(source, kind); + var targetSignatures = getSignaturesOfType(target, kind); + var sourceLen = sourceSignatures.length; + var targetLen = targetSignatures.length; + var len = sourceLen < targetLen ? sourceLen : targetLen; + for (var i = 0; i < len; i++) { + inferFromSignature(getBaseSignature(sourceSignatures[sourceLen - len + i]), getErasedSignature(targetSignatures[targetLen - len + i])); + } + } + function inferFromSignature(source, target) { + var saveBivariant = bivariant; + var kind = target.declaration ? target.declaration.kind : 0 /* SyntaxKind.Unknown */; + // Once we descend into a bivariant signature we remain bivariant for all nested inferences + bivariant = bivariant || kind === 171 /* SyntaxKind.MethodDeclaration */ || kind === 170 /* SyntaxKind.MethodSignature */ || kind === 173 /* SyntaxKind.Constructor */; + applyToParameterTypes(source, target, inferFromContravariantTypesIfStrictFunctionTypes); + bivariant = saveBivariant; + applyToReturnTypes(source, target, inferFromTypes); + } + function inferFromIndexTypes(source, target) { + // Inferences across mapped type index signatures are pretty much the same a inferences to homomorphic variables + var priority = (ts.getObjectFlags(source) & ts.getObjectFlags(target) & 32 /* ObjectFlags.Mapped */) ? 8 /* InferencePriority.HomomorphicMappedType */ : 0; + var indexInfos = getIndexInfosOfType(target); + if (isObjectTypeWithInferableIndex(source)) { + for (var _i = 0, indexInfos_6 = indexInfos; _i < indexInfos_6.length; _i++) { + var targetInfo = indexInfos_6[_i]; + var propTypes = []; + for (var _a = 0, _b = getPropertiesOfType(source); _a < _b.length; _a++) { + var prop = _b[_a]; + if (isApplicableIndexType(getLiteralTypeFromProperty(prop, 8576 /* TypeFlags.StringOrNumberLiteralOrUnique */), targetInfo.keyType)) { + var propType = getTypeOfSymbol(prop); + propTypes.push(prop.flags & 16777216 /* SymbolFlags.Optional */ ? removeMissingOrUndefinedType(propType) : propType); + } + } + for (var _c = 0, _d = getIndexInfosOfType(source); _c < _d.length; _c++) { + var info = _d[_c]; + if (isApplicableIndexType(info.keyType, targetInfo.keyType)) { + propTypes.push(info.type); + } + } + if (propTypes.length) { + inferWithPriority(getUnionType(propTypes), targetInfo.type, priority); + } + } + } + for (var _e = 0, indexInfos_7 = indexInfos; _e < indexInfos_7.length; _e++) { + var targetInfo = indexInfos_7[_e]; + var sourceInfo = getApplicableIndexInfo(source, targetInfo.keyType); + if (sourceInfo) { + inferWithPriority(sourceInfo.type, targetInfo.type, priority); + } + } + } + } + function isTypeOrBaseIdenticalTo(s, t) { + return exactOptionalPropertyTypes && t === missingType ? s === t : + (isTypeIdenticalTo(s, t) || !!(t.flags & 4 /* TypeFlags.String */ && s.flags & 128 /* TypeFlags.StringLiteral */ || t.flags & 8 /* TypeFlags.Number */ && s.flags & 256 /* TypeFlags.NumberLiteral */)); + } + function isTypeCloselyMatchedBy(s, t) { + return !!(s.flags & 524288 /* TypeFlags.Object */ && t.flags & 524288 /* TypeFlags.Object */ && s.symbol && s.symbol === t.symbol || + s.aliasSymbol && s.aliasTypeArguments && s.aliasSymbol === t.aliasSymbol); + } + function hasPrimitiveConstraint(type) { + var constraint = getConstraintOfTypeParameter(type); + return !!constraint && maybeTypeOfKind(constraint.flags & 16777216 /* TypeFlags.Conditional */ ? getDefaultConstraintOfConditionalType(constraint) : constraint, 131068 /* TypeFlags.Primitive */ | 4194304 /* TypeFlags.Index */ | 134217728 /* TypeFlags.TemplateLiteral */ | 268435456 /* TypeFlags.StringMapping */); + } + function isObjectLiteralType(type) { + return !!(ts.getObjectFlags(type) & 128 /* ObjectFlags.ObjectLiteral */); + } + function isObjectOrArrayLiteralType(type) { + return !!(ts.getObjectFlags(type) & (128 /* ObjectFlags.ObjectLiteral */ | 16384 /* ObjectFlags.ArrayLiteral */)); + } + function unionObjectAndArrayLiteralCandidates(candidates) { + if (candidates.length > 1) { + var objectLiterals = ts.filter(candidates, isObjectOrArrayLiteralType); + if (objectLiterals.length) { + var literalsType = getUnionType(objectLiterals, 2 /* UnionReduction.Subtype */); + return ts.concatenate(ts.filter(candidates, function (t) { return !isObjectOrArrayLiteralType(t); }), [literalsType]); + } + } + return candidates; + } + function getContravariantInference(inference) { + return inference.priority & 416 /* InferencePriority.PriorityImpliesCombination */ ? getIntersectionType(inference.contraCandidates) : getCommonSubtype(inference.contraCandidates); + } + function getCovariantInference(inference, signature) { + // Extract all object and array literal types and replace them with a single widened and normalized type. + var candidates = unionObjectAndArrayLiteralCandidates(inference.candidates); + // We widen inferred literal types if + // all inferences were made to top-level occurrences of the type parameter, and + // the type parameter has no constraint or its constraint includes no primitive or literal types, and + // the type parameter was fixed during inference or does not occur at top-level in the return type. + var primitiveConstraint = hasPrimitiveConstraint(inference.typeParameter); + var widenLiteralTypes = !primitiveConstraint && inference.topLevel && + (inference.isFixed || !isTypeParameterAtTopLevel(getReturnTypeOfSignature(signature), inference.typeParameter)); + var baseCandidates = primitiveConstraint ? ts.sameMap(candidates, getRegularTypeOfLiteralType) : + widenLiteralTypes ? ts.sameMap(candidates, getWidenedLiteralType) : + candidates; + // If all inferences were made from a position that implies a combined result, infer a union type. + // Otherwise, infer a common supertype. + var unwidenedType = inference.priority & 416 /* InferencePriority.PriorityImpliesCombination */ ? + getUnionType(baseCandidates, 2 /* UnionReduction.Subtype */) : + getCommonSupertype(baseCandidates); + return getWidenedType(unwidenedType); + } + function getInferredType(context, index) { + var inference = context.inferences[index]; + if (!inference.inferredType) { + var inferredType = void 0; + var signature = context.signature; + if (signature) { + var inferredCovariantType_1 = inference.candidates ? getCovariantInference(inference, signature) : undefined; + if (inference.contraCandidates) { + // If we have both co- and contra-variant inferences, we prefer the contra-variant inference + // unless the co-variant inference is a subtype of some contra-variant inference and not 'never'. + inferredType = inferredCovariantType_1 && !(inferredCovariantType_1.flags & 131072 /* TypeFlags.Never */) && + ts.some(inference.contraCandidates, function (t) { return isTypeSubtypeOf(inferredCovariantType_1, t); }) ? + inferredCovariantType_1 : getContravariantInference(inference); + } + else if (inferredCovariantType_1) { + inferredType = inferredCovariantType_1; + } + else if (context.flags & 1 /* InferenceFlags.NoDefault */) { + // We use silentNeverType as the wildcard that signals no inferences. + inferredType = silentNeverType; + } + else { + // Infer either the default or the empty object type when no inferences were + // made. It is important to remember that in this case, inference still + // succeeds, meaning there is no error for not having inference candidates. An + // inference error only occurs when there are *conflicting* candidates, i.e. + // candidates with no common supertype. + var defaultType = getDefaultFromTypeParameter(inference.typeParameter); + if (defaultType) { + // Instantiate the default type. Any forward reference to a type + // parameter should be instantiated to the empty object type. + inferredType = instantiateType(defaultType, mergeTypeMappers(createBackreferenceMapper(context, index), context.nonFixingMapper)); + } + } + } + else { + inferredType = getTypeFromInference(inference); + } + inference.inferredType = inferredType || getDefaultTypeArgumentType(!!(context.flags & 2 /* InferenceFlags.AnyDefault */)); + var constraint = getConstraintOfTypeParameter(inference.typeParameter); + if (constraint) { + var instantiatedConstraint = instantiateType(constraint, context.nonFixingMapper); + if (!inferredType || !context.compareTypes(inferredType, getTypeWithThisArgument(instantiatedConstraint, inferredType))) { + inference.inferredType = inferredType = instantiatedConstraint; + } + } + } + return inference.inferredType; + } + function getDefaultTypeArgumentType(isInJavaScriptFile) { + return isInJavaScriptFile ? anyType : unknownType; + } + function getInferredTypes(context) { + var result = []; + for (var i = 0; i < context.inferences.length; i++) { + result.push(getInferredType(context, i)); + } + return result; + } + // EXPRESSION TYPE CHECKING + function getCannotFindNameDiagnosticForName(node) { + switch (node.escapedText) { + case "document": + case "console": + return ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_include_dom; + case "$": + return compilerOptions.types + ? ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slashjquery_and_then_add_jquery_to_the_types_field_in_your_tsconfig + : ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slashjquery; + case "describe": + case "suite": + case "it": + case "test": + return compilerOptions.types + ? ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_types_Slashjest_or_npm_i_save_dev_types_Slashmocha_and_then_add_jest_or_mocha_to_the_types_field_in_your_tsconfig + : ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_types_Slashjest_or_npm_i_save_dev_types_Slashmocha; + case "process": + case "require": + case "Buffer": + case "module": + return compilerOptions.types + ? ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode_and_then_add_node_to_the_types_field_in_your_tsconfig + : ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode; + case "Map": + case "Set": + case "Promise": + case "Symbol": + case "WeakMap": + case "WeakSet": + case "Iterator": + case "AsyncIterator": + case "SharedArrayBuffer": + case "Atomics": + case "AsyncIterable": + case "AsyncIterableIterator": + case "AsyncGenerator": + case "AsyncGeneratorFunction": + case "BigInt": + case "Reflect": + case "BigInt64Array": + case "BigUint64Array": + return ts.Diagnostics.Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_1_or_later; + case "await": + if (ts.isCallExpression(node.parent)) { + return ts.Diagnostics.Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function; + } + // falls through + default: + if (node.parent.kind === 300 /* SyntaxKind.ShorthandPropertyAssignment */) { + return ts.Diagnostics.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer; + } + else { + return ts.Diagnostics.Cannot_find_name_0; + } + } + } + function getResolvedSymbol(node) { + var links = getNodeLinks(node); + if (!links.resolvedSymbol) { + links.resolvedSymbol = !ts.nodeIsMissing(node) && + resolveName(node, node.escapedText, 111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */, getCannotFindNameDiagnosticForName(node), node, !ts.isWriteOnlyAccess(node), + /*excludeGlobals*/ false) || unknownSymbol; + } + return links.resolvedSymbol; + } + function isInTypeQuery(node) { + // TypeScript 1.0 spec (April 2014): 3.6.3 + // A type query consists of the keyword typeof followed by an expression. + // The expression is restricted to a single identifier or a sequence of identifiers separated by periods + return !!ts.findAncestor(node, function (n) { return n.kind === 183 /* SyntaxKind.TypeQuery */ ? true : n.kind === 79 /* SyntaxKind.Identifier */ || n.kind === 163 /* SyntaxKind.QualifiedName */ ? false : "quit"; }); + } + // Return the flow cache key for a "dotted name" (i.e. a sequence of identifiers + // separated by dots). The key consists of the id of the symbol referenced by the + // leftmost identifier followed by zero or more property names separated by dots. + // The result is undefined if the reference isn't a dotted name. + function getFlowCacheKey(node, declaredType, initialType, flowContainer) { + switch (node.kind) { + case 79 /* SyntaxKind.Identifier */: + if (!ts.isThisInTypeQuery(node)) { + var symbol = getResolvedSymbol(node); + return symbol !== unknownSymbol ? "".concat(flowContainer ? getNodeId(flowContainer) : "-1", "|").concat(getTypeId(declaredType), "|").concat(getTypeId(initialType), "|").concat(getSymbolId(symbol)) : undefined; + } + // falls through + case 108 /* SyntaxKind.ThisKeyword */: + return "0|".concat(flowContainer ? getNodeId(flowContainer) : "-1", "|").concat(getTypeId(declaredType), "|").concat(getTypeId(initialType)); + case 232 /* SyntaxKind.NonNullExpression */: + case 214 /* SyntaxKind.ParenthesizedExpression */: + return getFlowCacheKey(node.expression, declaredType, initialType, flowContainer); + case 163 /* SyntaxKind.QualifiedName */: + var left = getFlowCacheKey(node.left, declaredType, initialType, flowContainer); + return left && left + "." + node.right.escapedText; + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 209 /* SyntaxKind.ElementAccessExpression */: + var propName = getAccessedPropertyName(node); + if (propName !== undefined) { + var key = getFlowCacheKey(node.expression, declaredType, initialType, flowContainer); + return key && key + "." + propName; + } + break; + case 203 /* SyntaxKind.ObjectBindingPattern */: + case 204 /* SyntaxKind.ArrayBindingPattern */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + case 171 /* SyntaxKind.MethodDeclaration */: + // Handle pseudo-references originating in getNarrowedTypeOfSymbol. + return "".concat(getNodeId(node), "#").concat(getTypeId(declaredType)); + } + return undefined; + } + function isMatchingReference(source, target) { + switch (target.kind) { + case 214 /* SyntaxKind.ParenthesizedExpression */: + case 232 /* SyntaxKind.NonNullExpression */: + return isMatchingReference(source, target.expression); + case 223 /* SyntaxKind.BinaryExpression */: + return (ts.isAssignmentExpression(target) && isMatchingReference(source, target.left)) || + (ts.isBinaryExpression(target) && target.operatorToken.kind === 27 /* SyntaxKind.CommaToken */ && isMatchingReference(source, target.right)); + } + switch (source.kind) { + case 233 /* SyntaxKind.MetaProperty */: + return target.kind === 233 /* SyntaxKind.MetaProperty */ + && source.keywordToken === target.keywordToken + && source.name.escapedText === target.name.escapedText; + case 79 /* SyntaxKind.Identifier */: + case 80 /* SyntaxKind.PrivateIdentifier */: + return ts.isThisInTypeQuery(source) ? + target.kind === 108 /* SyntaxKind.ThisKeyword */ : + target.kind === 79 /* SyntaxKind.Identifier */ && getResolvedSymbol(source) === getResolvedSymbol(target) || + (target.kind === 257 /* SyntaxKind.VariableDeclaration */ || target.kind === 205 /* SyntaxKind.BindingElement */) && + getExportSymbolOfValueSymbolIfExported(getResolvedSymbol(source)) === getSymbolOfNode(target); + case 108 /* SyntaxKind.ThisKeyword */: + return target.kind === 108 /* SyntaxKind.ThisKeyword */; + case 106 /* SyntaxKind.SuperKeyword */: + return target.kind === 106 /* SyntaxKind.SuperKeyword */; + case 232 /* SyntaxKind.NonNullExpression */: + case 214 /* SyntaxKind.ParenthesizedExpression */: + return isMatchingReference(source.expression, target); + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 209 /* SyntaxKind.ElementAccessExpression */: + var sourcePropertyName = getAccessedPropertyName(source); + var targetPropertyName = ts.isAccessExpression(target) ? getAccessedPropertyName(target) : undefined; + return sourcePropertyName !== undefined && targetPropertyName !== undefined && targetPropertyName === sourcePropertyName && + isMatchingReference(source.expression, target.expression); + case 163 /* SyntaxKind.QualifiedName */: + return ts.isAccessExpression(target) && + source.right.escapedText === getAccessedPropertyName(target) && + isMatchingReference(source.left, target.expression); + case 223 /* SyntaxKind.BinaryExpression */: + return (ts.isBinaryExpression(source) && source.operatorToken.kind === 27 /* SyntaxKind.CommaToken */ && isMatchingReference(source.right, target)); + } + return false; + } + function getAccessedPropertyName(access) { + if (ts.isPropertyAccessExpression(access)) { + return access.name.escapedText; + } + if (ts.isElementAccessExpression(access)) { + return tryGetElementAccessExpressionName(access); + } + if (ts.isBindingElement(access)) { + var name = getDestructuringPropertyName(access); + return name ? ts.escapeLeadingUnderscores(name) : undefined; + } + if (ts.isParameter(access)) { + return ("" + access.parent.parameters.indexOf(access)); + } + return undefined; + } + function tryGetNameFromType(type) { + return type.flags & 8192 /* TypeFlags.UniqueESSymbol */ ? type.escapedName : + type.flags & 384 /* TypeFlags.StringOrNumberLiteral */ ? ts.escapeLeadingUnderscores("" + type.value) : undefined; + } + function tryGetElementAccessExpressionName(node) { + if (ts.isStringOrNumericLiteralLike(node.argumentExpression)) { + return ts.escapeLeadingUnderscores(node.argumentExpression.text); + } + if (ts.isEntityNameExpression(node.argumentExpression)) { + var symbol = resolveEntityName(node.argumentExpression, 111551 /* SymbolFlags.Value */, /*ignoreErrors*/ true); + if (!symbol || !(isConstVariable(symbol) || (symbol.flags & 8 /* SymbolFlags.EnumMember */))) + return undefined; + var declaration = symbol.valueDeclaration; + if (declaration === undefined) + return undefined; + var type = tryGetTypeFromEffectiveTypeNode(declaration); + if (type) { + var name = tryGetNameFromType(type); + if (name !== undefined) { + return name; + } + } + if (ts.hasOnlyExpressionInitializer(declaration) && isBlockScopedNameDeclaredBeforeUse(declaration, node.argumentExpression)) { + var initializer = ts.getEffectiveInitializer(declaration); + if (initializer) { + return tryGetNameFromType(getTypeOfExpression(initializer)); + } + if (ts.isEnumMember(declaration)) { + return ts.getTextOfPropertyName(declaration.name); + } + } + } + return undefined; + } + function containsMatchingReference(source, target) { + while (ts.isAccessExpression(source)) { + source = source.expression; + if (isMatchingReference(source, target)) { + return true; + } + } + return false; + } + function optionalChainContainsReference(source, target) { + while (ts.isOptionalChain(source)) { + source = source.expression; + if (isMatchingReference(source, target)) { + return true; + } + } + return false; + } + function isDiscriminantProperty(type, name) { + if (type && type.flags & 1048576 /* TypeFlags.Union */) { + var prop = getUnionOrIntersectionProperty(type, name); + if (prop && ts.getCheckFlags(prop) & 2 /* CheckFlags.SyntheticProperty */) { + if (prop.isDiscriminantProperty === undefined) { + prop.isDiscriminantProperty = + (prop.checkFlags & 192 /* CheckFlags.Discriminant */) === 192 /* CheckFlags.Discriminant */ && + !isGenericType(getTypeOfSymbol(prop)); + } + return !!prop.isDiscriminantProperty; + } + } + return false; + } + function findDiscriminantProperties(sourceProperties, target) { + var result; + for (var _i = 0, sourceProperties_2 = sourceProperties; _i < sourceProperties_2.length; _i++) { + var sourceProperty = sourceProperties_2[_i]; + if (isDiscriminantProperty(target, sourceProperty.escapedName)) { + if (result) { + result.push(sourceProperty); + continue; + } + result = [sourceProperty]; + } + } + return result; + } + // Given a set of constituent types and a property name, create and return a map keyed by the literal + // types of the property by that name in each constituent type. No map is returned if some key property + // has a non-literal type or if less than 10 or less than 50% of the constituents have a unique key. + // Entries with duplicate keys have unknownType as the value. + function mapTypesByKeyProperty(types, name) { + var map = new ts.Map(); + var count = 0; + var _loop_25 = function (type) { + if (type.flags & (524288 /* TypeFlags.Object */ | 2097152 /* TypeFlags.Intersection */ | 58982400 /* TypeFlags.InstantiableNonPrimitive */)) { + var discriminant = getTypeOfPropertyOfType(type, name); + if (discriminant) { + if (!isLiteralType(discriminant)) { + return { value: undefined }; + } + var duplicate_1 = false; + forEachType(discriminant, function (t) { + var id = getTypeId(getRegularTypeOfLiteralType(t)); + var existing = map.get(id); + if (!existing) { + map.set(id, type); + } + else if (existing !== unknownType) { + map.set(id, unknownType); + duplicate_1 = true; + } + }); + if (!duplicate_1) + count++; + } + } + }; + for (var _i = 0, types_15 = types; _i < types_15.length; _i++) { + var type = types_15[_i]; + var state_9 = _loop_25(type); + if (typeof state_9 === "object") + return state_9.value; + } + return count >= 10 && count * 2 >= types.length ? map : undefined; + } + // Return the name of a discriminant property for which it was possible and feasible to construct a map of + // constituent types keyed by the literal types of the property by that name in each constituent type. + function getKeyPropertyName(unionType) { + var types = unionType.types; + // We only construct maps for unions with many non-primitive constituents. + if (types.length < 10 || ts.getObjectFlags(unionType) & 32768 /* ObjectFlags.PrimitiveUnion */ || + ts.countWhere(types, function (t) { return !!(t.flags & (524288 /* TypeFlags.Object */ | 58982400 /* TypeFlags.InstantiableNonPrimitive */)); }) < 10) { + return undefined; + } + if (unionType.keyPropertyName === undefined) { + // The candidate key property name is the name of the first property with a unit type in one of the + // constituent types. + var keyPropertyName = ts.forEach(types, function (t) { + return t.flags & (524288 /* TypeFlags.Object */ | 58982400 /* TypeFlags.InstantiableNonPrimitive */) ? + ts.forEach(getPropertiesOfType(t), function (p) { return isUnitType(getTypeOfSymbol(p)) ? p.escapedName : undefined; }) : + undefined; + }); + var mapByKeyProperty = keyPropertyName && mapTypesByKeyProperty(types, keyPropertyName); + unionType.keyPropertyName = mapByKeyProperty ? keyPropertyName : ""; + unionType.constituentMap = mapByKeyProperty; + } + return unionType.keyPropertyName.length ? unionType.keyPropertyName : undefined; + } + // Given a union type for which getKeyPropertyName returned a non-undefined result, return the constituent + // that corresponds to the given key type for that property name. + function getConstituentTypeForKeyType(unionType, keyType) { + var _a; + var result = (_a = unionType.constituentMap) === null || _a === void 0 ? void 0 : _a.get(getTypeId(getRegularTypeOfLiteralType(keyType))); + return result !== unknownType ? result : undefined; + } + function getMatchingUnionConstituentForType(unionType, type) { + var keyPropertyName = getKeyPropertyName(unionType); + var propType = keyPropertyName && getTypeOfPropertyOfType(type, keyPropertyName); + return propType && getConstituentTypeForKeyType(unionType, propType); + } + function getMatchingUnionConstituentForObjectLiteral(unionType, node) { + var keyPropertyName = getKeyPropertyName(unionType); + var propNode = keyPropertyName && ts.find(node.properties, function (p) { return p.symbol && p.kind === 299 /* SyntaxKind.PropertyAssignment */ && + p.symbol.escapedName === keyPropertyName && isPossiblyDiscriminantValue(p.initializer); }); + var propType = propNode && getContextFreeTypeOfExpression(propNode.initializer); + return propType && getConstituentTypeForKeyType(unionType, propType); + } + function isOrContainsMatchingReference(source, target) { + return isMatchingReference(source, target) || containsMatchingReference(source, target); + } + function hasMatchingArgument(expression, reference) { + if (expression.arguments) { + for (var _i = 0, _a = expression.arguments; _i < _a.length; _i++) { + var argument = _a[_i]; + if (isOrContainsMatchingReference(reference, argument)) { + return true; + } + } + } + if (expression.expression.kind === 208 /* SyntaxKind.PropertyAccessExpression */ && + isOrContainsMatchingReference(reference, expression.expression.expression)) { + return true; + } + return false; + } + function getFlowNodeId(flow) { + if (!flow.id || flow.id < 0) { + flow.id = nextFlowId; + nextFlowId++; + } + return flow.id; + } + function typeMaybeAssignableTo(source, target) { + if (!(source.flags & 1048576 /* TypeFlags.Union */)) { + return isTypeAssignableTo(source, target); + } + for (var _i = 0, _a = source.types; _i < _a.length; _i++) { + var t = _a[_i]; + if (isTypeAssignableTo(t, target)) { + return true; + } + } + return false; + } + // Remove those constituent types of declaredType to which no constituent type of assignedType is assignable. + // For example, when a variable of type number | string | boolean is assigned a value of type number | boolean, + // we remove type string. + function getAssignmentReducedType(declaredType, assignedType) { + var _a; + if (declaredType === assignedType) { + return declaredType; + } + if (assignedType.flags & 131072 /* TypeFlags.Never */) { + return assignedType; + } + var key = "A".concat(getTypeId(declaredType), ",").concat(getTypeId(assignedType)); + return (_a = getCachedType(key)) !== null && _a !== void 0 ? _a : setCachedType(key, getAssignmentReducedTypeWorker(declaredType, assignedType)); + } + function getAssignmentReducedTypeWorker(declaredType, assignedType) { + var filteredType = filterType(declaredType, function (t) { return typeMaybeAssignableTo(assignedType, t); }); + // Ensure that we narrow to fresh types if the assignment is a fresh boolean literal type. + var reducedType = assignedType.flags & 512 /* TypeFlags.BooleanLiteral */ && isFreshLiteralType(assignedType) ? mapType(filteredType, getFreshTypeOfLiteralType) : filteredType; + // Our crude heuristic produces an invalid result in some cases: see GH#26130. + // For now, when that happens, we give up and don't narrow at all. (This also + // means we'll never narrow for erroneous assignments where the assigned type + // is not assignable to the declared type.) + return isTypeAssignableTo(assignedType, reducedType) ? reducedType : declaredType; + } + function isFunctionObjectType(type) { + // We do a quick check for a "bind" property before performing the more expensive subtype + // check. This gives us a quicker out in the common case where an object type is not a function. + var resolved = resolveStructuredTypeMembers(type); + return !!(resolved.callSignatures.length || resolved.constructSignatures.length || + resolved.members.get("bind") && isTypeSubtypeOf(type, globalFunctionType)); + } + function getTypeFacts(type) { + if (type.flags & (2097152 /* TypeFlags.Intersection */ | 465829888 /* TypeFlags.Instantiable */)) { + type = getBaseConstraintOfType(type) || unknownType; + } + var flags = type.flags; + if (flags & (4 /* TypeFlags.String */ | 268435456 /* TypeFlags.StringMapping */)) { + return strictNullChecks ? 16317953 /* TypeFacts.StringStrictFacts */ : 16776705 /* TypeFacts.StringFacts */; + } + if (flags & (128 /* TypeFlags.StringLiteral */ | 134217728 /* TypeFlags.TemplateLiteral */)) { + var isEmpty = flags & 128 /* TypeFlags.StringLiteral */ && type.value === ""; + return strictNullChecks ? + isEmpty ? 12123649 /* TypeFacts.EmptyStringStrictFacts */ : 7929345 /* TypeFacts.NonEmptyStringStrictFacts */ : + isEmpty ? 12582401 /* TypeFacts.EmptyStringFacts */ : 16776705 /* TypeFacts.NonEmptyStringFacts */; + } + if (flags & (8 /* TypeFlags.Number */ | 32 /* TypeFlags.Enum */)) { + return strictNullChecks ? 16317698 /* TypeFacts.NumberStrictFacts */ : 16776450 /* TypeFacts.NumberFacts */; + } + if (flags & 256 /* TypeFlags.NumberLiteral */) { + var isZero = type.value === 0; + return strictNullChecks ? + isZero ? 12123394 /* TypeFacts.ZeroNumberStrictFacts */ : 7929090 /* TypeFacts.NonZeroNumberStrictFacts */ : + isZero ? 12582146 /* TypeFacts.ZeroNumberFacts */ : 16776450 /* TypeFacts.NonZeroNumberFacts */; + } + if (flags & 64 /* TypeFlags.BigInt */) { + return strictNullChecks ? 16317188 /* TypeFacts.BigIntStrictFacts */ : 16775940 /* TypeFacts.BigIntFacts */; + } + if (flags & 2048 /* TypeFlags.BigIntLiteral */) { + var isZero = isZeroBigInt(type); + return strictNullChecks ? + isZero ? 12122884 /* TypeFacts.ZeroBigIntStrictFacts */ : 7928580 /* TypeFacts.NonZeroBigIntStrictFacts */ : + isZero ? 12581636 /* TypeFacts.ZeroBigIntFacts */ : 16775940 /* TypeFacts.NonZeroBigIntFacts */; + } + if (flags & 16 /* TypeFlags.Boolean */) { + return strictNullChecks ? 16316168 /* TypeFacts.BooleanStrictFacts */ : 16774920 /* TypeFacts.BooleanFacts */; + } + if (flags & 528 /* TypeFlags.BooleanLike */) { + return strictNullChecks ? + (type === falseType || type === regularFalseType) ? 12121864 /* TypeFacts.FalseStrictFacts */ : 7927560 /* TypeFacts.TrueStrictFacts */ : + (type === falseType || type === regularFalseType) ? 12580616 /* TypeFacts.FalseFacts */ : 16774920 /* TypeFacts.TrueFacts */; + } + if (flags & 524288 /* TypeFlags.Object */) { + return ts.getObjectFlags(type) & 16 /* ObjectFlags.Anonymous */ && isEmptyObjectType(type) ? + strictNullChecks ? 83427327 /* TypeFacts.EmptyObjectStrictFacts */ : 83886079 /* TypeFacts.EmptyObjectFacts */ : + isFunctionObjectType(type) ? + strictNullChecks ? 7880640 /* TypeFacts.FunctionStrictFacts */ : 16728000 /* TypeFacts.FunctionFacts */ : + strictNullChecks ? 7888800 /* TypeFacts.ObjectStrictFacts */ : 16736160 /* TypeFacts.ObjectFacts */; + } + if (flags & 16384 /* TypeFlags.Void */) { + return 9830144 /* TypeFacts.VoidFacts */; + } + if (flags & 32768 /* TypeFlags.Undefined */) { + return 26607360 /* TypeFacts.UndefinedFacts */; + } + if (flags & 65536 /* TypeFlags.Null */) { + return 42917664 /* TypeFacts.NullFacts */; + } + if (flags & 12288 /* TypeFlags.ESSymbolLike */) { + return strictNullChecks ? 7925520 /* TypeFacts.SymbolStrictFacts */ : 16772880 /* TypeFacts.SymbolFacts */; + } + if (flags & 67108864 /* TypeFlags.NonPrimitive */) { + return strictNullChecks ? 7888800 /* TypeFacts.ObjectStrictFacts */ : 16736160 /* TypeFacts.ObjectFacts */; + } + if (flags & 131072 /* TypeFlags.Never */) { + return 0 /* TypeFacts.None */; + } + if (flags & 1048576 /* TypeFlags.Union */) { + return ts.reduceLeft(type.types, function (facts, t) { return facts | getTypeFacts(t); }, 0 /* TypeFacts.None */); + } + if (flags & 2097152 /* TypeFlags.Intersection */) { + return getIntersectionTypeFacts(type); + } + return 83886079 /* TypeFacts.UnknownFacts */; + } + function getIntersectionTypeFacts(type) { + // When an intersection contains a primitive type we ignore object type constituents as they are + // presumably type tags. For example, in string & { __kind__: "name" } we ignore the object type. + var ignoreObjects = maybeTypeOfKind(type, 131068 /* TypeFlags.Primitive */); + // When computing the type facts of an intersection type, certain type facts are computed as `and` + // and others are computed as `or`. + var oredFacts = 0 /* TypeFacts.None */; + var andedFacts = 134217727 /* TypeFacts.All */; + for (var _i = 0, _a = type.types; _i < _a.length; _i++) { + var t = _a[_i]; + if (!(ignoreObjects && t.flags & 524288 /* TypeFlags.Object */)) { + var f = getTypeFacts(t); + oredFacts |= f; + andedFacts &= f; + } + } + return oredFacts & 8256 /* TypeFacts.OrFactsMask */ | andedFacts & 134209471 /* TypeFacts.AndFactsMask */; + } + function getTypeWithFacts(type, include) { + return filterType(type, function (t) { return (getTypeFacts(t) & include) !== 0; }); + } + // This function is similar to getTypeWithFacts, except that in strictNullChecks mode it replaces type + // unknown with the union {} | null | undefined (and reduces that accordingly), and it intersects remaining + // instantiable types with {}, {} | null, or {} | undefined in order to remove null and/or undefined. + function getAdjustedTypeWithFacts(type, facts) { + var reduced = recombineUnknownType(getTypeWithFacts(strictNullChecks && type.flags & 2 /* TypeFlags.Unknown */ ? unknownUnionType : type, facts)); + if (strictNullChecks) { + switch (facts) { + case 524288 /* TypeFacts.NEUndefined */: + return mapType(reduced, function (t) { return getTypeFacts(t) & 65536 /* TypeFacts.EQUndefined */ ? getIntersectionType([t, getTypeFacts(t) & 131072 /* TypeFacts.EQNull */ && !maybeTypeOfKind(reduced, 65536 /* TypeFlags.Null */) ? getUnionType([emptyObjectType, nullType]) : emptyObjectType]) : t; }); + case 1048576 /* TypeFacts.NENull */: + return mapType(reduced, function (t) { return getTypeFacts(t) & 131072 /* TypeFacts.EQNull */ ? getIntersectionType([t, getTypeFacts(t) & 65536 /* TypeFacts.EQUndefined */ && !maybeTypeOfKind(reduced, 32768 /* TypeFlags.Undefined */) ? getUnionType([emptyObjectType, undefinedType]) : emptyObjectType]) : t; }); + case 2097152 /* TypeFacts.NEUndefinedOrNull */: + case 4194304 /* TypeFacts.Truthy */: + return mapType(reduced, function (t) { return getTypeFacts(t) & 262144 /* TypeFacts.EQUndefinedOrNull */ ? getGlobalNonNullableTypeInstantiation(t) : t; }); + } + } + return reduced; + } + function recombineUnknownType(type) { + return type === unknownUnionType ? unknownType : type; + } + function getTypeWithDefault(type, defaultExpression) { + return defaultExpression ? + getUnionType([getNonUndefinedType(type), getTypeOfExpression(defaultExpression)]) : + type; + } + function getTypeOfDestructuredProperty(type, name) { + var _a; + var nameType = getLiteralTypeFromPropertyName(name); + if (!isTypeUsableAsPropertyName(nameType)) + return errorType; + var text = getPropertyNameFromType(nameType); + return getTypeOfPropertyOfType(type, text) || includeUndefinedInIndexSignature((_a = getApplicableIndexInfoForName(type, text)) === null || _a === void 0 ? void 0 : _a.type) || errorType; + } + function getTypeOfDestructuredArrayElement(type, index) { + return everyType(type, isTupleLikeType) && getTupleElementType(type, index) || + includeUndefinedInIndexSignature(checkIteratedTypeOrElementType(65 /* IterationUse.Destructuring */, type, undefinedType, /*errorNode*/ undefined)) || + errorType; + } + function includeUndefinedInIndexSignature(type) { + if (!type) + return type; + return compilerOptions.noUncheckedIndexedAccess ? + getUnionType([type, undefinedType]) : + type; + } + function getTypeOfDestructuredSpreadExpression(type) { + return createArrayType(checkIteratedTypeOrElementType(65 /* IterationUse.Destructuring */, type, undefinedType, /*errorNode*/ undefined) || errorType); + } + function getAssignedTypeOfBinaryExpression(node) { + var isDestructuringDefaultAssignment = node.parent.kind === 206 /* SyntaxKind.ArrayLiteralExpression */ && isDestructuringAssignmentTarget(node.parent) || + node.parent.kind === 299 /* SyntaxKind.PropertyAssignment */ && isDestructuringAssignmentTarget(node.parent.parent); + return isDestructuringDefaultAssignment ? + getTypeWithDefault(getAssignedType(node), node.right) : + getTypeOfExpression(node.right); + } + function isDestructuringAssignmentTarget(parent) { + return parent.parent.kind === 223 /* SyntaxKind.BinaryExpression */ && parent.parent.left === parent || + parent.parent.kind === 247 /* SyntaxKind.ForOfStatement */ && parent.parent.initializer === parent; + } + function getAssignedTypeOfArrayLiteralElement(node, element) { + return getTypeOfDestructuredArrayElement(getAssignedType(node), node.elements.indexOf(element)); + } + function getAssignedTypeOfSpreadExpression(node) { + return getTypeOfDestructuredSpreadExpression(getAssignedType(node.parent)); + } + function getAssignedTypeOfPropertyAssignment(node) { + return getTypeOfDestructuredProperty(getAssignedType(node.parent), node.name); + } + function getAssignedTypeOfShorthandPropertyAssignment(node) { + return getTypeWithDefault(getAssignedTypeOfPropertyAssignment(node), node.objectAssignmentInitializer); + } + function getAssignedType(node) { + var parent = node.parent; + switch (parent.kind) { + case 246 /* SyntaxKind.ForInStatement */: + return stringType; + case 247 /* SyntaxKind.ForOfStatement */: + return checkRightHandSideOfForOf(parent) || errorType; + case 223 /* SyntaxKind.BinaryExpression */: + return getAssignedTypeOfBinaryExpression(parent); + case 217 /* SyntaxKind.DeleteExpression */: + return undefinedType; + case 206 /* SyntaxKind.ArrayLiteralExpression */: + return getAssignedTypeOfArrayLiteralElement(parent, node); + case 227 /* SyntaxKind.SpreadElement */: + return getAssignedTypeOfSpreadExpression(parent); + case 299 /* SyntaxKind.PropertyAssignment */: + return getAssignedTypeOfPropertyAssignment(parent); + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + return getAssignedTypeOfShorthandPropertyAssignment(parent); + } + return errorType; + } + function getInitialTypeOfBindingElement(node) { + var pattern = node.parent; + var parentType = getInitialType(pattern.parent); + var type = pattern.kind === 203 /* SyntaxKind.ObjectBindingPattern */ ? + getTypeOfDestructuredProperty(parentType, node.propertyName || node.name) : + !node.dotDotDotToken ? + getTypeOfDestructuredArrayElement(parentType, pattern.elements.indexOf(node)) : + getTypeOfDestructuredSpreadExpression(parentType); + return getTypeWithDefault(type, node.initializer); + } + function getTypeOfInitializer(node) { + // Return the cached type if one is available. If the type of the variable was inferred + // from its initializer, we'll already have cached the type. Otherwise we compute it now + // without caching such that transient types are reflected. + var links = getNodeLinks(node); + return links.resolvedType || getTypeOfExpression(node); + } + function getInitialTypeOfVariableDeclaration(node) { + if (node.initializer) { + return getTypeOfInitializer(node.initializer); + } + if (node.parent.parent.kind === 246 /* SyntaxKind.ForInStatement */) { + return stringType; + } + if (node.parent.parent.kind === 247 /* SyntaxKind.ForOfStatement */) { + return checkRightHandSideOfForOf(node.parent.parent) || errorType; + } + return errorType; + } + function getInitialType(node) { + return node.kind === 257 /* SyntaxKind.VariableDeclaration */ ? + getInitialTypeOfVariableDeclaration(node) : + getInitialTypeOfBindingElement(node); + } + function isEmptyArrayAssignment(node) { + return node.kind === 257 /* SyntaxKind.VariableDeclaration */ && node.initializer && + isEmptyArrayLiteral(node.initializer) || + node.kind !== 205 /* SyntaxKind.BindingElement */ && node.parent.kind === 223 /* SyntaxKind.BinaryExpression */ && + isEmptyArrayLiteral(node.parent.right); + } + function getReferenceCandidate(node) { + switch (node.kind) { + case 214 /* SyntaxKind.ParenthesizedExpression */: + return getReferenceCandidate(node.expression); + case 223 /* SyntaxKind.BinaryExpression */: + switch (node.operatorToken.kind) { + case 63 /* SyntaxKind.EqualsToken */: + case 75 /* SyntaxKind.BarBarEqualsToken */: + case 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */: + case 77 /* SyntaxKind.QuestionQuestionEqualsToken */: + return getReferenceCandidate(node.left); + case 27 /* SyntaxKind.CommaToken */: + return getReferenceCandidate(node.right); + } + } + return node; + } + function getReferenceRoot(node) { + var parent = node.parent; + return parent.kind === 214 /* SyntaxKind.ParenthesizedExpression */ || + parent.kind === 223 /* SyntaxKind.BinaryExpression */ && parent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ && parent.left === node || + parent.kind === 223 /* SyntaxKind.BinaryExpression */ && parent.operatorToken.kind === 27 /* SyntaxKind.CommaToken */ && parent.right === node ? + getReferenceRoot(parent) : node; + } + function getTypeOfSwitchClause(clause) { + if (clause.kind === 292 /* SyntaxKind.CaseClause */) { + return getRegularTypeOfLiteralType(getTypeOfExpression(clause.expression)); + } + return neverType; + } + function getSwitchClauseTypes(switchStatement) { + var links = getNodeLinks(switchStatement); + if (!links.switchTypes) { + links.switchTypes = []; + for (var _i = 0, _a = switchStatement.caseBlock.clauses; _i < _a.length; _i++) { + var clause = _a[_i]; + links.switchTypes.push(getTypeOfSwitchClause(clause)); + } + } + return links.switchTypes; + } + // Get the type names from all cases in a switch on `typeof`. The default clause and/or duplicate type names are + // represented as undefined. Return undefined if one or more case clause expressions are not string literals. + function getSwitchClauseTypeOfWitnesses(switchStatement) { + if (ts.some(switchStatement.caseBlock.clauses, function (clause) { return clause.kind === 292 /* SyntaxKind.CaseClause */ && !ts.isStringLiteralLike(clause.expression); })) { + return undefined; + } + var witnesses = []; + for (var _i = 0, _a = switchStatement.caseBlock.clauses; _i < _a.length; _i++) { + var clause = _a[_i]; + var text = clause.kind === 292 /* SyntaxKind.CaseClause */ ? clause.expression.text : undefined; + witnesses.push(text && !ts.contains(witnesses, text) ? text : undefined); + } + return witnesses; + } + function eachTypeContainedIn(source, types) { + return source.flags & 1048576 /* TypeFlags.Union */ ? !ts.forEach(source.types, function (t) { return !ts.contains(types, t); }) : ts.contains(types, source); + } + function isTypeSubsetOf(source, target) { + return source === target || target.flags & 1048576 /* TypeFlags.Union */ && isTypeSubsetOfUnion(source, target); + } + function isTypeSubsetOfUnion(source, target) { + if (source.flags & 1048576 /* TypeFlags.Union */) { + for (var _i = 0, _a = source.types; _i < _a.length; _i++) { + var t = _a[_i]; + if (!containsType(target.types, t)) { + return false; + } + } + return true; + } + if (source.flags & 1024 /* TypeFlags.EnumLiteral */ && getBaseTypeOfEnumLiteralType(source) === target) { + return true; + } + return containsType(target.types, source); + } + function forEachType(type, f) { + return type.flags & 1048576 /* TypeFlags.Union */ ? ts.forEach(type.types, f) : f(type); + } + function someType(type, f) { + return type.flags & 1048576 /* TypeFlags.Union */ ? ts.some(type.types, f) : f(type); + } + function everyType(type, f) { + return type.flags & 1048576 /* TypeFlags.Union */ ? ts.every(type.types, f) : f(type); + } + function everyContainedType(type, f) { + return type.flags & 3145728 /* TypeFlags.UnionOrIntersection */ ? ts.every(type.types, f) : f(type); + } + function filterType(type, f) { + if (type.flags & 1048576 /* TypeFlags.Union */) { + var types = type.types; + var filtered = ts.filter(types, f); + if (filtered === types) { + return type; + } + var origin = type.origin; + var newOrigin = void 0; + if (origin && origin.flags & 1048576 /* TypeFlags.Union */) { + // If the origin type is a (denormalized) union type, filter its non-union constituents. If that ends + // up removing a smaller number of types than in the normalized constituent set (meaning some of the + // filtered types are within nested unions in the origin), then we can't construct a new origin type. + // Otherwise, if we have exactly one type left in the origin set, return that as the filtered type. + // Otherwise, construct a new filtered origin type. + var originTypes = origin.types; + var originFiltered = ts.filter(originTypes, function (t) { return !!(t.flags & 1048576 /* TypeFlags.Union */) || f(t); }); + if (originTypes.length - originFiltered.length === types.length - filtered.length) { + if (originFiltered.length === 1) { + return originFiltered[0]; + } + newOrigin = createOriginUnionOrIntersectionType(1048576 /* TypeFlags.Union */, originFiltered); + } + } + return getUnionTypeFromSortedList(filtered, type.objectFlags, /*aliasSymbol*/ undefined, /*aliasTypeArguments*/ undefined, newOrigin); + } + return type.flags & 131072 /* TypeFlags.Never */ || f(type) ? type : neverType; + } + function removeType(type, targetType) { + return filterType(type, function (t) { return t !== targetType; }); + } + function countTypes(type) { + return type.flags & 1048576 /* TypeFlags.Union */ ? type.types.length : 1; + } + function mapType(type, mapper, noReductions) { + if (type.flags & 131072 /* TypeFlags.Never */) { + return type; + } + if (!(type.flags & 1048576 /* TypeFlags.Union */)) { + return mapper(type); + } + var origin = type.origin; + var types = origin && origin.flags & 1048576 /* TypeFlags.Union */ ? origin.types : type.types; + var mappedTypes; + var changed = false; + for (var _i = 0, types_16 = types; _i < types_16.length; _i++) { + var t = types_16[_i]; + var mapped = t.flags & 1048576 /* TypeFlags.Union */ ? mapType(t, mapper, noReductions) : mapper(t); + changed || (changed = t !== mapped); + if (mapped) { + if (!mappedTypes) { + mappedTypes = [mapped]; + } + else { + mappedTypes.push(mapped); + } + } + } + return changed ? mappedTypes && getUnionType(mappedTypes, noReductions ? 0 /* UnionReduction.None */ : 1 /* UnionReduction.Literal */) : type; + } + function mapTypeWithAlias(type, mapper, aliasSymbol, aliasTypeArguments) { + return type.flags & 1048576 /* TypeFlags.Union */ && aliasSymbol ? + getUnionType(ts.map(type.types, mapper), 1 /* UnionReduction.Literal */, aliasSymbol, aliasTypeArguments) : + mapType(type, mapper); + } + function extractTypesOfKind(type, kind) { + return filterType(type, function (t) { return (t.flags & kind) !== 0; }); + } + // Return a new type in which occurrences of the string, number and bigint primitives and placeholder template + // literal types in typeWithPrimitives have been replaced with occurrences of compatible and more specific types + // from typeWithLiterals. This is essentially a limited form of intersection between the two types. We avoid a + // true intersection because it is more costly and, when applied to union types, generates a large number of + // types we don't actually care about. + function replacePrimitivesWithLiterals(typeWithPrimitives, typeWithLiterals) { + if (maybeTypeOfKind(typeWithPrimitives, 4 /* TypeFlags.String */ | 134217728 /* TypeFlags.TemplateLiteral */ | 8 /* TypeFlags.Number */ | 64 /* TypeFlags.BigInt */) && + maybeTypeOfKind(typeWithLiterals, 128 /* TypeFlags.StringLiteral */ | 134217728 /* TypeFlags.TemplateLiteral */ | 268435456 /* TypeFlags.StringMapping */ | 256 /* TypeFlags.NumberLiteral */ | 2048 /* TypeFlags.BigIntLiteral */)) { + return mapType(typeWithPrimitives, function (t) { + return t.flags & 4 /* TypeFlags.String */ ? extractTypesOfKind(typeWithLiterals, 4 /* TypeFlags.String */ | 128 /* TypeFlags.StringLiteral */ | 134217728 /* TypeFlags.TemplateLiteral */ | 268435456 /* TypeFlags.StringMapping */) : + isPatternLiteralType(t) && !maybeTypeOfKind(typeWithLiterals, 4 /* TypeFlags.String */ | 134217728 /* TypeFlags.TemplateLiteral */ | 268435456 /* TypeFlags.StringMapping */) ? extractTypesOfKind(typeWithLiterals, 128 /* TypeFlags.StringLiteral */) : + t.flags & 8 /* TypeFlags.Number */ ? extractTypesOfKind(typeWithLiterals, 8 /* TypeFlags.Number */ | 256 /* TypeFlags.NumberLiteral */) : + t.flags & 64 /* TypeFlags.BigInt */ ? extractTypesOfKind(typeWithLiterals, 64 /* TypeFlags.BigInt */ | 2048 /* TypeFlags.BigIntLiteral */) : t; + }); + } + return typeWithPrimitives; + } + function isIncomplete(flowType) { + return flowType.flags === 0; + } + function getTypeFromFlowType(flowType) { + return flowType.flags === 0 ? flowType.type : flowType; + } + function createFlowType(type, incomplete) { + return incomplete ? { flags: 0, type: type.flags & 131072 /* TypeFlags.Never */ ? silentNeverType : type } : type; + } + // An evolving array type tracks the element types that have so far been seen in an + // 'x.push(value)' or 'x[n] = value' operation along the control flow graph. Evolving + // array types are ultimately converted into manifest array types (using getFinalArrayType) + // and never escape the getFlowTypeOfReference function. + function createEvolvingArrayType(elementType) { + var result = createObjectType(256 /* ObjectFlags.EvolvingArray */); + result.elementType = elementType; + return result; + } + function getEvolvingArrayType(elementType) { + return evolvingArrayTypes[elementType.id] || (evolvingArrayTypes[elementType.id] = createEvolvingArrayType(elementType)); + } + // When adding evolving array element types we do not perform subtype reduction. Instead, + // we defer subtype reduction until the evolving array type is finalized into a manifest + // array type. + function addEvolvingArrayElementType(evolvingArrayType, node) { + var elementType = getRegularTypeOfObjectLiteral(getBaseTypeOfLiteralType(getContextFreeTypeOfExpression(node))); + return isTypeSubsetOf(elementType, evolvingArrayType.elementType) ? evolvingArrayType : getEvolvingArrayType(getUnionType([evolvingArrayType.elementType, elementType])); + } + function createFinalArrayType(elementType) { + return elementType.flags & 131072 /* TypeFlags.Never */ ? + autoArrayType : + createArrayType(elementType.flags & 1048576 /* TypeFlags.Union */ ? + getUnionType(elementType.types, 2 /* UnionReduction.Subtype */) : + elementType); + } + // We perform subtype reduction upon obtaining the final array type from an evolving array type. + function getFinalArrayType(evolvingArrayType) { + return evolvingArrayType.finalArrayType || (evolvingArrayType.finalArrayType = createFinalArrayType(evolvingArrayType.elementType)); + } + function finalizeEvolvingArrayType(type) { + return ts.getObjectFlags(type) & 256 /* ObjectFlags.EvolvingArray */ ? getFinalArrayType(type) : type; + } + function getElementTypeOfEvolvingArrayType(type) { + return ts.getObjectFlags(type) & 256 /* ObjectFlags.EvolvingArray */ ? type.elementType : neverType; + } + function isEvolvingArrayTypeList(types) { + var hasEvolvingArrayType = false; + for (var _i = 0, types_17 = types; _i < types_17.length; _i++) { + var t = types_17[_i]; + if (!(t.flags & 131072 /* TypeFlags.Never */)) { + if (!(ts.getObjectFlags(t) & 256 /* ObjectFlags.EvolvingArray */)) { + return false; + } + hasEvolvingArrayType = true; + } + } + return hasEvolvingArrayType; + } + // Return true if the given node is 'x' in an 'x.length', x.push(value)', 'x.unshift(value)' or + // 'x[n] = value' operation, where 'n' is an expression of type any, undefined, or a number-like type. + function isEvolvingArrayOperationTarget(node) { + var root = getReferenceRoot(node); + var parent = root.parent; + var isLengthPushOrUnshift = ts.isPropertyAccessExpression(parent) && (parent.name.escapedText === "length" || + parent.parent.kind === 210 /* SyntaxKind.CallExpression */ + && ts.isIdentifier(parent.name) + && ts.isPushOrUnshiftIdentifier(parent.name)); + var isElementAssignment = parent.kind === 209 /* SyntaxKind.ElementAccessExpression */ && + parent.expression === root && + parent.parent.kind === 223 /* SyntaxKind.BinaryExpression */ && + parent.parent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ && + parent.parent.left === parent && + !ts.isAssignmentTarget(parent.parent) && + isTypeAssignableToKind(getTypeOfExpression(parent.argumentExpression), 296 /* TypeFlags.NumberLike */); + return isLengthPushOrUnshift || isElementAssignment; + } + function isDeclarationWithExplicitTypeAnnotation(node) { + return (ts.isVariableDeclaration(node) || ts.isPropertyDeclaration(node) || ts.isPropertySignature(node) || ts.isParameter(node)) && + !!(ts.getEffectiveTypeAnnotationNode(node) || + ts.isInJSFile(node) && ts.hasInitializer(node) && node.initializer && ts.isFunctionExpressionOrArrowFunction(node.initializer) && ts.getEffectiveReturnTypeNode(node.initializer)); + } + function getExplicitTypeOfSymbol(symbol, diagnostic) { + symbol = resolveSymbol(symbol); + if (symbol.flags & (16 /* SymbolFlags.Function */ | 8192 /* SymbolFlags.Method */ | 32 /* SymbolFlags.Class */ | 512 /* SymbolFlags.ValueModule */)) { + return getTypeOfSymbol(symbol); + } + if (symbol.flags & (3 /* SymbolFlags.Variable */ | 4 /* SymbolFlags.Property */)) { + if (ts.getCheckFlags(symbol) & 262144 /* CheckFlags.Mapped */) { + var origin = symbol.syntheticOrigin; + if (origin && getExplicitTypeOfSymbol(origin)) { + return getTypeOfSymbol(symbol); + } + } + var declaration = symbol.valueDeclaration; + if (declaration) { + if (isDeclarationWithExplicitTypeAnnotation(declaration)) { + return getTypeOfSymbol(symbol); + } + if (ts.isVariableDeclaration(declaration) && declaration.parent.parent.kind === 247 /* SyntaxKind.ForOfStatement */) { + var statement = declaration.parent.parent; + var expressionType = getTypeOfDottedName(statement.expression, /*diagnostic*/ undefined); + if (expressionType) { + var use = statement.awaitModifier ? 15 /* IterationUse.ForAwaitOf */ : 13 /* IterationUse.ForOf */; + return checkIteratedTypeOrElementType(use, expressionType, undefinedType, /*errorNode*/ undefined); + } + } + if (diagnostic) { + ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(declaration, ts.Diagnostics._0_needs_an_explicit_type_annotation, symbolToString(symbol))); + } + } + } + } + // We require the dotted function name in an assertion expression to be comprised of identifiers + // that reference function, method, class or value module symbols; or variable, property or + // parameter symbols with declarations that have explicit type annotations. Such references are + // resolvable with no possibility of triggering circularities in control flow analysis. + function getTypeOfDottedName(node, diagnostic) { + if (!(node.flags & 33554432 /* NodeFlags.InWithStatement */)) { + switch (node.kind) { + case 79 /* SyntaxKind.Identifier */: + var symbol = getExportSymbolOfValueSymbolIfExported(getResolvedSymbol(node)); + return getExplicitTypeOfSymbol(symbol, diagnostic); + case 108 /* SyntaxKind.ThisKeyword */: + return getExplicitThisType(node); + case 106 /* SyntaxKind.SuperKeyword */: + return checkSuperExpression(node); + case 208 /* SyntaxKind.PropertyAccessExpression */: { + var type = getTypeOfDottedName(node.expression, diagnostic); + if (type) { + var name = node.name; + var prop = void 0; + if (ts.isPrivateIdentifier(name)) { + if (!type.symbol) { + return undefined; + } + prop = getPropertyOfType(type, ts.getSymbolNameForPrivateIdentifier(type.symbol, name.escapedText)); + } + else { + prop = getPropertyOfType(type, name.escapedText); + } + return prop && getExplicitTypeOfSymbol(prop, diagnostic); + } + return undefined; + } + case 214 /* SyntaxKind.ParenthesizedExpression */: + return getTypeOfDottedName(node.expression, diagnostic); + } + } + } + function getEffectsSignature(node) { + var links = getNodeLinks(node); + var signature = links.effectsSignature; + if (signature === undefined) { + // A call expression parented by an expression statement is a potential assertion. Other call + // expressions are potential type predicate function calls. In order to avoid triggering + // circularities in control flow analysis, we use getTypeOfDottedName when resolving the call + // target expression of an assertion. + var funcType = void 0; + if (node.parent.kind === 241 /* SyntaxKind.ExpressionStatement */) { + funcType = getTypeOfDottedName(node.expression, /*diagnostic*/ undefined); + } + else if (node.expression.kind !== 106 /* SyntaxKind.SuperKeyword */) { + if (ts.isOptionalChain(node)) { + funcType = checkNonNullType(getOptionalExpressionType(checkExpression(node.expression), node.expression), node.expression); + } + else { + funcType = checkNonNullExpression(node.expression); + } + } + var signatures = getSignaturesOfType(funcType && getApparentType(funcType) || unknownType, 0 /* SignatureKind.Call */); + var candidate = signatures.length === 1 && !signatures[0].typeParameters ? signatures[0] : + ts.some(signatures, hasTypePredicateOrNeverReturnType) ? getResolvedSignature(node) : + undefined; + signature = links.effectsSignature = candidate && hasTypePredicateOrNeverReturnType(candidate) ? candidate : unknownSignature; + } + return signature === unknownSignature ? undefined : signature; + } + function hasTypePredicateOrNeverReturnType(signature) { + return !!(getTypePredicateOfSignature(signature) || + signature.declaration && (getReturnTypeFromAnnotation(signature.declaration) || unknownType).flags & 131072 /* TypeFlags.Never */); + } + function getTypePredicateArgument(predicate, callExpression) { + if (predicate.kind === 1 /* TypePredicateKind.Identifier */ || predicate.kind === 3 /* TypePredicateKind.AssertsIdentifier */) { + return callExpression.arguments[predicate.parameterIndex]; + } + var invokedExpression = ts.skipParentheses(callExpression.expression); + return ts.isAccessExpression(invokedExpression) ? ts.skipParentheses(invokedExpression.expression) : undefined; + } + function reportFlowControlError(node) { + var block = ts.findAncestor(node, ts.isFunctionOrModuleBlock); + var sourceFile = ts.getSourceFileOfNode(node); + var span = ts.getSpanOfTokenAtPosition(sourceFile, block.statements.pos); + diagnostics.add(ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.The_containing_function_or_module_body_is_too_large_for_control_flow_analysis)); + } + function isReachableFlowNode(flow) { + var result = isReachableFlowNodeWorker(flow, /*noCacheCheck*/ false); + lastFlowNode = flow; + lastFlowNodeReachable = result; + return result; + } + function isFalseExpression(expr) { + var node = ts.skipParentheses(expr, /*excludeJSDocTypeAssertions*/ true); + return node.kind === 95 /* SyntaxKind.FalseKeyword */ || node.kind === 223 /* SyntaxKind.BinaryExpression */ && (node.operatorToken.kind === 55 /* SyntaxKind.AmpersandAmpersandToken */ && (isFalseExpression(node.left) || isFalseExpression(node.right)) || + node.operatorToken.kind === 56 /* SyntaxKind.BarBarToken */ && isFalseExpression(node.left) && isFalseExpression(node.right)); + } + function isReachableFlowNodeWorker(flow, noCacheCheck) { + while (true) { + if (flow === lastFlowNode) { + return lastFlowNodeReachable; + } + var flags = flow.flags; + if (flags & 4096 /* FlowFlags.Shared */) { + if (!noCacheCheck) { + var id = getFlowNodeId(flow); + var reachable = flowNodeReachable[id]; + return reachable !== undefined ? reachable : (flowNodeReachable[id] = isReachableFlowNodeWorker(flow, /*noCacheCheck*/ true)); + } + noCacheCheck = false; + } + if (flags & (16 /* FlowFlags.Assignment */ | 96 /* FlowFlags.Condition */ | 256 /* FlowFlags.ArrayMutation */)) { + flow = flow.antecedent; + } + else if (flags & 512 /* FlowFlags.Call */) { + var signature = getEffectsSignature(flow.node); + if (signature) { + var predicate = getTypePredicateOfSignature(signature); + if (predicate && predicate.kind === 3 /* TypePredicateKind.AssertsIdentifier */ && !predicate.type) { + var predicateArgument = flow.node.arguments[predicate.parameterIndex]; + if (predicateArgument && isFalseExpression(predicateArgument)) { + return false; + } + } + if (getReturnTypeOfSignature(signature).flags & 131072 /* TypeFlags.Never */) { + return false; + } + } + flow = flow.antecedent; + } + else if (flags & 4 /* FlowFlags.BranchLabel */) { + // A branching point is reachable if any branch is reachable. + return ts.some(flow.antecedents, function (f) { return isReachableFlowNodeWorker(f, /*noCacheCheck*/ false); }); + } + else if (flags & 8 /* FlowFlags.LoopLabel */) { + var antecedents = flow.antecedents; + if (antecedents === undefined || antecedents.length === 0) { + return false; + } + // A loop is reachable if the control flow path that leads to the top is reachable. + flow = antecedents[0]; + } + else if (flags & 128 /* FlowFlags.SwitchClause */) { + // The control flow path representing an unmatched value in a switch statement with + // no default clause is unreachable if the switch statement is exhaustive. + if (flow.clauseStart === flow.clauseEnd && isExhaustiveSwitchStatement(flow.switchStatement)) { + return false; + } + flow = flow.antecedent; + } + else if (flags & 1024 /* FlowFlags.ReduceLabel */) { + // Cache is unreliable once we start adjusting labels + lastFlowNode = undefined; + var target = flow.target; + var saveAntecedents = target.antecedents; + target.antecedents = flow.antecedents; + var result = isReachableFlowNodeWorker(flow.antecedent, /*noCacheCheck*/ false); + target.antecedents = saveAntecedents; + return result; + } + else { + return !(flags & 1 /* FlowFlags.Unreachable */); + } + } + } + // Return true if the given flow node is preceded by a 'super(...)' call in every possible code path + // leading to the node. + function isPostSuperFlowNode(flow, noCacheCheck) { + while (true) { + var flags = flow.flags; + if (flags & 4096 /* FlowFlags.Shared */) { + if (!noCacheCheck) { + var id = getFlowNodeId(flow); + var postSuper = flowNodePostSuper[id]; + return postSuper !== undefined ? postSuper : (flowNodePostSuper[id] = isPostSuperFlowNode(flow, /*noCacheCheck*/ true)); + } + noCacheCheck = false; + } + if (flags & (16 /* FlowFlags.Assignment */ | 96 /* FlowFlags.Condition */ | 256 /* FlowFlags.ArrayMutation */ | 128 /* FlowFlags.SwitchClause */)) { + flow = flow.antecedent; + } + else if (flags & 512 /* FlowFlags.Call */) { + if (flow.node.expression.kind === 106 /* SyntaxKind.SuperKeyword */) { + return true; + } + flow = flow.antecedent; + } + else if (flags & 4 /* FlowFlags.BranchLabel */) { + // A branching point is post-super if every branch is post-super. + return ts.every(flow.antecedents, function (f) { return isPostSuperFlowNode(f, /*noCacheCheck*/ false); }); + } + else if (flags & 8 /* FlowFlags.LoopLabel */) { + // A loop is post-super if the control flow path that leads to the top is post-super. + flow = flow.antecedents[0]; + } + else if (flags & 1024 /* FlowFlags.ReduceLabel */) { + var target = flow.target; + var saveAntecedents = target.antecedents; + target.antecedents = flow.antecedents; + var result = isPostSuperFlowNode(flow.antecedent, /*noCacheCheck*/ false); + target.antecedents = saveAntecedents; + return result; + } + else { + // Unreachable nodes are considered post-super to silence errors + return !!(flags & 1 /* FlowFlags.Unreachable */); + } + } + } + function isConstantReference(node) { + switch (node.kind) { + case 79 /* SyntaxKind.Identifier */: { + var symbol = getResolvedSymbol(node); + return isConstVariable(symbol) || ts.isParameterOrCatchClauseVariable(symbol) && !isSymbolAssigned(symbol); + } + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 209 /* SyntaxKind.ElementAccessExpression */: + // The resolvedSymbol property is initialized by checkPropertyAccess or checkElementAccess before we get here. + return isConstantReference(node.expression) && isReadonlySymbol(getNodeLinks(node).resolvedSymbol || unknownSymbol); + } + return false; + } + function getFlowTypeOfReference(reference, declaredType, initialType, flowContainer, flowNode) { + if (initialType === void 0) { initialType = declaredType; } + if (flowNode === void 0) { flowNode = reference.flowNode; } + var key; + var isKeySet = false; + var flowDepth = 0; + if (flowAnalysisDisabled) { + return errorType; + } + if (!flowNode) { + return declaredType; + } + flowInvocationCount++; + var sharedFlowStart = sharedFlowCount; + var evolvedType = getTypeFromFlowType(getTypeAtFlowNode(flowNode)); + sharedFlowCount = sharedFlowStart; + // When the reference is 'x' in an 'x.length', 'x.push(value)', 'x.unshift(value)' or x[n] = value' operation, + // we give type 'any[]' to 'x' instead of using the type determined by control flow analysis such that operations + // on empty arrays are possible without implicit any errors and new element types can be inferred without + // type mismatch errors. + var resultType = ts.getObjectFlags(evolvedType) & 256 /* ObjectFlags.EvolvingArray */ && isEvolvingArrayOperationTarget(reference) ? autoArrayType : finalizeEvolvingArrayType(evolvedType); + if (resultType === unreachableNeverType || reference.parent && reference.parent.kind === 232 /* SyntaxKind.NonNullExpression */ && !(resultType.flags & 131072 /* TypeFlags.Never */) && getTypeWithFacts(resultType, 2097152 /* TypeFacts.NEUndefinedOrNull */).flags & 131072 /* TypeFlags.Never */) { + return declaredType; + } + // The non-null unknown type should never escape control flow analysis. + return resultType === nonNullUnknownType ? unknownType : resultType; + function getOrSetCacheKey() { + if (isKeySet) { + return key; + } + isKeySet = true; + return key = getFlowCacheKey(reference, declaredType, initialType, flowContainer); + } + function getTypeAtFlowNode(flow) { + if (flowDepth === 2000) { + // We have made 2000 recursive invocations. To avoid overflowing the call stack we report an error + // and disable further control flow analysis in the containing function or module body. + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("checkTypes" /* tracing.Phase.CheckTypes */, "getTypeAtFlowNode_DepthLimit", { flowId: flow.id }); + flowAnalysisDisabled = true; + reportFlowControlError(reference); + return errorType; + } + flowDepth++; + var sharedFlow; + while (true) { + var flags = flow.flags; + if (flags & 4096 /* FlowFlags.Shared */) { + // We cache results of flow type resolution for shared nodes that were previously visited in + // the same getFlowTypeOfReference invocation. A node is considered shared when it is the + // antecedent of more than one node. + for (var i = sharedFlowStart; i < sharedFlowCount; i++) { + if (sharedFlowNodes[i] === flow) { + flowDepth--; + return sharedFlowTypes[i]; + } + } + sharedFlow = flow; + } + var type = void 0; + if (flags & 16 /* FlowFlags.Assignment */) { + type = getTypeAtFlowAssignment(flow); + if (!type) { + flow = flow.antecedent; + continue; + } + } + else if (flags & 512 /* FlowFlags.Call */) { + type = getTypeAtFlowCall(flow); + if (!type) { + flow = flow.antecedent; + continue; + } + } + else if (flags & 96 /* FlowFlags.Condition */) { + type = getTypeAtFlowCondition(flow); + } + else if (flags & 128 /* FlowFlags.SwitchClause */) { + type = getTypeAtSwitchClause(flow); + } + else if (flags & 12 /* FlowFlags.Label */) { + if (flow.antecedents.length === 1) { + flow = flow.antecedents[0]; + continue; + } + type = flags & 4 /* FlowFlags.BranchLabel */ ? + getTypeAtFlowBranchLabel(flow) : + getTypeAtFlowLoopLabel(flow); + } + else if (flags & 256 /* FlowFlags.ArrayMutation */) { + type = getTypeAtFlowArrayMutation(flow); + if (!type) { + flow = flow.antecedent; + continue; + } + } + else if (flags & 1024 /* FlowFlags.ReduceLabel */) { + var target = flow.target; + var saveAntecedents = target.antecedents; + target.antecedents = flow.antecedents; + type = getTypeAtFlowNode(flow.antecedent); + target.antecedents = saveAntecedents; + } + else if (flags & 2 /* FlowFlags.Start */) { + // Check if we should continue with the control flow of the containing function. + var container = flow.node; + if (container && container !== flowContainer && + reference.kind !== 208 /* SyntaxKind.PropertyAccessExpression */ && + reference.kind !== 209 /* SyntaxKind.ElementAccessExpression */ && + reference.kind !== 108 /* SyntaxKind.ThisKeyword */) { + flow = container.flowNode; + continue; + } + // At the top of the flow we have the initial type. + type = initialType; + } + else { + // Unreachable code errors are reported in the binding phase. Here we + // simply return the non-auto declared type to reduce follow-on errors. + type = convertAutoToAny(declaredType); + } + if (sharedFlow) { + // Record visited node and the associated type in the cache. + sharedFlowNodes[sharedFlowCount] = sharedFlow; + sharedFlowTypes[sharedFlowCount] = type; + sharedFlowCount++; + } + flowDepth--; + return type; + } + } + function getInitialOrAssignedType(flow) { + var node = flow.node; + return getNarrowableTypeForReference(node.kind === 257 /* SyntaxKind.VariableDeclaration */ || node.kind === 205 /* SyntaxKind.BindingElement */ ? + getInitialType(node) : + getAssignedType(node), reference); + } + function getTypeAtFlowAssignment(flow) { + var node = flow.node; + // Assignments only narrow the computed type if the declared type is a union type. Thus, we + // only need to evaluate the assigned type if the declared type is a union type. + if (isMatchingReference(reference, node)) { + if (!isReachableFlowNode(flow)) { + return unreachableNeverType; + } + if (ts.getAssignmentTargetKind(node) === 2 /* AssignmentKind.Compound */) { + var flowType = getTypeAtFlowNode(flow.antecedent); + return createFlowType(getBaseTypeOfLiteralType(getTypeFromFlowType(flowType)), isIncomplete(flowType)); + } + if (declaredType === autoType || declaredType === autoArrayType) { + if (isEmptyArrayAssignment(node)) { + return getEvolvingArrayType(neverType); + } + var assignedType = getWidenedLiteralType(getInitialOrAssignedType(flow)); + return isTypeAssignableTo(assignedType, declaredType) ? assignedType : anyArrayType; + } + if (declaredType.flags & 1048576 /* TypeFlags.Union */) { + return getAssignmentReducedType(declaredType, getInitialOrAssignedType(flow)); + } + return declaredType; + } + // We didn't have a direct match. However, if the reference is a dotted name, this + // may be an assignment to a left hand part of the reference. For example, for a + // reference 'x.y.z', we may be at an assignment to 'x.y' or 'x'. In that case, + // return the declared type. + if (containsMatchingReference(reference, node)) { + if (!isReachableFlowNode(flow)) { + return unreachableNeverType; + } + // A matching dotted name might also be an expando property on a function *expression*, + // in which case we continue control flow analysis back to the function's declaration + if (ts.isVariableDeclaration(node) && (ts.isInJSFile(node) || ts.isVarConst(node))) { + var init = ts.getDeclaredExpandoInitializer(node); + if (init && (init.kind === 215 /* SyntaxKind.FunctionExpression */ || init.kind === 216 /* SyntaxKind.ArrowFunction */)) { + return getTypeAtFlowNode(flow.antecedent); + } + } + return declaredType; + } + // for (const _ in ref) acts as a nonnull on ref + if (ts.isVariableDeclaration(node) && node.parent.parent.kind === 246 /* SyntaxKind.ForInStatement */ && isMatchingReference(reference, node.parent.parent.expression)) { + return getNonNullableTypeIfNeeded(finalizeEvolvingArrayType(getTypeFromFlowType(getTypeAtFlowNode(flow.antecedent)))); + } + // Assignment doesn't affect reference + return undefined; + } + function narrowTypeByAssertion(type, expr) { + var node = ts.skipParentheses(expr, /*excludeJSDocTypeAssertions*/ true); + if (node.kind === 95 /* SyntaxKind.FalseKeyword */) { + return unreachableNeverType; + } + if (node.kind === 223 /* SyntaxKind.BinaryExpression */) { + if (node.operatorToken.kind === 55 /* SyntaxKind.AmpersandAmpersandToken */) { + return narrowTypeByAssertion(narrowTypeByAssertion(type, node.left), node.right); + } + if (node.operatorToken.kind === 56 /* SyntaxKind.BarBarToken */) { + return getUnionType([narrowTypeByAssertion(type, node.left), narrowTypeByAssertion(type, node.right)]); + } + } + return narrowType(type, node, /*assumeTrue*/ true); + } + function getTypeAtFlowCall(flow) { + var signature = getEffectsSignature(flow.node); + if (signature) { + var predicate = getTypePredicateOfSignature(signature); + if (predicate && (predicate.kind === 2 /* TypePredicateKind.AssertsThis */ || predicate.kind === 3 /* TypePredicateKind.AssertsIdentifier */)) { + var flowType = getTypeAtFlowNode(flow.antecedent); + var type = finalizeEvolvingArrayType(getTypeFromFlowType(flowType)); + var narrowedType = predicate.type ? narrowTypeByTypePredicate(type, predicate, flow.node, /*assumeTrue*/ true) : + predicate.kind === 3 /* TypePredicateKind.AssertsIdentifier */ && predicate.parameterIndex >= 0 && predicate.parameterIndex < flow.node.arguments.length ? narrowTypeByAssertion(type, flow.node.arguments[predicate.parameterIndex]) : + type; + return narrowedType === type ? flowType : createFlowType(narrowedType, isIncomplete(flowType)); + } + if (getReturnTypeOfSignature(signature).flags & 131072 /* TypeFlags.Never */) { + return unreachableNeverType; + } + } + return undefined; + } + function getTypeAtFlowArrayMutation(flow) { + if (declaredType === autoType || declaredType === autoArrayType) { + var node = flow.node; + var expr = node.kind === 210 /* SyntaxKind.CallExpression */ ? + node.expression.expression : + node.left.expression; + if (isMatchingReference(reference, getReferenceCandidate(expr))) { + var flowType = getTypeAtFlowNode(flow.antecedent); + var type = getTypeFromFlowType(flowType); + if (ts.getObjectFlags(type) & 256 /* ObjectFlags.EvolvingArray */) { + var evolvedType_1 = type; + if (node.kind === 210 /* SyntaxKind.CallExpression */) { + for (var _i = 0, _a = node.arguments; _i < _a.length; _i++) { + var arg = _a[_i]; + evolvedType_1 = addEvolvingArrayElementType(evolvedType_1, arg); + } + } + else { + // We must get the context free expression type so as to not recur in an uncached fashion on the LHS (which causes exponential blowup in compile time) + var indexType = getContextFreeTypeOfExpression(node.left.argumentExpression); + if (isTypeAssignableToKind(indexType, 296 /* TypeFlags.NumberLike */)) { + evolvedType_1 = addEvolvingArrayElementType(evolvedType_1, node.right); + } + } + return evolvedType_1 === type ? flowType : createFlowType(evolvedType_1, isIncomplete(flowType)); + } + return flowType; + } + } + return undefined; + } + function getTypeAtFlowCondition(flow) { + var flowType = getTypeAtFlowNode(flow.antecedent); + var type = getTypeFromFlowType(flowType); + if (type.flags & 131072 /* TypeFlags.Never */) { + return flowType; + } + // If we have an antecedent type (meaning we're reachable in some way), we first + // attempt to narrow the antecedent type. If that produces the never type, and if + // the antecedent type is incomplete (i.e. a transient type in a loop), then we + // take the type guard as an indication that control *could* reach here once we + // have the complete type. We proceed by switching to the silent never type which + // doesn't report errors when operators are applied to it. Note that this is the + // *only* place a silent never type is ever generated. + var assumeTrue = (flow.flags & 32 /* FlowFlags.TrueCondition */) !== 0; + var nonEvolvingType = finalizeEvolvingArrayType(type); + var narrowedType = narrowType(nonEvolvingType, flow.node, assumeTrue); + if (narrowedType === nonEvolvingType) { + return flowType; + } + return createFlowType(narrowedType, isIncomplete(flowType)); + } + function getTypeAtSwitchClause(flow) { + var expr = flow.switchStatement.expression; + var flowType = getTypeAtFlowNode(flow.antecedent); + var type = getTypeFromFlowType(flowType); + if (isMatchingReference(reference, expr)) { + type = narrowTypeBySwitchOnDiscriminant(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd); + } + else if (expr.kind === 218 /* SyntaxKind.TypeOfExpression */ && isMatchingReference(reference, expr.expression)) { + type = narrowTypeBySwitchOnTypeOf(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd); + } + else { + if (strictNullChecks) { + if (optionalChainContainsReference(expr, reference)) { + type = narrowTypeBySwitchOptionalChainContainment(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd, function (t) { return !(t.flags & (32768 /* TypeFlags.Undefined */ | 131072 /* TypeFlags.Never */)); }); + } + else if (expr.kind === 218 /* SyntaxKind.TypeOfExpression */ && optionalChainContainsReference(expr.expression, reference)) { + type = narrowTypeBySwitchOptionalChainContainment(type, flow.switchStatement, flow.clauseStart, flow.clauseEnd, function (t) { return !(t.flags & 131072 /* TypeFlags.Never */ || t.flags & 128 /* TypeFlags.StringLiteral */ && t.value === "undefined"); }); + } + } + var access = getDiscriminantPropertyAccess(expr, type); + if (access) { + type = narrowTypeBySwitchOnDiscriminantProperty(type, access, flow.switchStatement, flow.clauseStart, flow.clauseEnd); + } + } + return createFlowType(type, isIncomplete(flowType)); + } + function getTypeAtFlowBranchLabel(flow) { + var antecedentTypes = []; + var subtypeReduction = false; + var seenIncomplete = false; + var bypassFlow; + for (var _i = 0, _a = flow.antecedents; _i < _a.length; _i++) { + var antecedent = _a[_i]; + if (!bypassFlow && antecedent.flags & 128 /* FlowFlags.SwitchClause */ && antecedent.clauseStart === antecedent.clauseEnd) { + // The antecedent is the bypass branch of a potentially exhaustive switch statement. + bypassFlow = antecedent; + continue; + } + var flowType = getTypeAtFlowNode(antecedent); + var type = getTypeFromFlowType(flowType); + // If the type at a particular antecedent path is the declared type and the + // reference is known to always be assigned (i.e. when declared and initial types + // are the same), there is no reason to process more antecedents since the only + // possible outcome is subtypes that will be removed in the final union type anyway. + if (type === declaredType && declaredType === initialType) { + return type; + } + ts.pushIfUnique(antecedentTypes, type); + // If an antecedent type is not a subset of the declared type, we need to perform + // subtype reduction. This happens when a "foreign" type is injected into the control + // flow using the instanceof operator or a user defined type predicate. + if (!isTypeSubsetOf(type, declaredType)) { + subtypeReduction = true; + } + if (isIncomplete(flowType)) { + seenIncomplete = true; + } + } + if (bypassFlow) { + var flowType = getTypeAtFlowNode(bypassFlow); + var type = getTypeFromFlowType(flowType); + // If the bypass flow contributes a type we haven't seen yet and the switch statement + // isn't exhaustive, process the bypass flow type. Since exhaustiveness checks increase + // the risk of circularities, we only want to perform them when they make a difference. + if (!ts.contains(antecedentTypes, type) && !isExhaustiveSwitchStatement(bypassFlow.switchStatement)) { + if (type === declaredType && declaredType === initialType) { + return type; + } + antecedentTypes.push(type); + if (!isTypeSubsetOf(type, declaredType)) { + subtypeReduction = true; + } + if (isIncomplete(flowType)) { + seenIncomplete = true; + } + } + } + return createFlowType(getUnionOrEvolvingArrayType(antecedentTypes, subtypeReduction ? 2 /* UnionReduction.Subtype */ : 1 /* UnionReduction.Literal */), seenIncomplete); + } + function getTypeAtFlowLoopLabel(flow) { + // If we have previously computed the control flow type for the reference at + // this flow loop junction, return the cached type. + var id = getFlowNodeId(flow); + var cache = flowLoopCaches[id] || (flowLoopCaches[id] = new ts.Map()); + var key = getOrSetCacheKey(); + if (!key) { + // No cache key is generated when binding patterns are in unnarrowable situations + return declaredType; + } + var cached = cache.get(key); + if (cached) { + return cached; + } + // If this flow loop junction and reference are already being processed, return + // the union of the types computed for each branch so far, marked as incomplete. + // It is possible to see an empty array in cases where loops are nested and the + // back edge of the outer loop reaches an inner loop that is already being analyzed. + // In such cases we restart the analysis of the inner loop, which will then see + // a non-empty in-process array for the outer loop and eventually terminate because + // the first antecedent of a loop junction is always the non-looping control flow + // path that leads to the top. + for (var i = flowLoopStart; i < flowLoopCount; i++) { + if (flowLoopNodes[i] === flow && flowLoopKeys[i] === key && flowLoopTypes[i].length) { + return createFlowType(getUnionOrEvolvingArrayType(flowLoopTypes[i], 1 /* UnionReduction.Literal */), /*incomplete*/ true); + } + } + // Add the flow loop junction and reference to the in-process stack and analyze + // each antecedent code path. + var antecedentTypes = []; + var subtypeReduction = false; + var firstAntecedentType; + for (var _i = 0, _a = flow.antecedents; _i < _a.length; _i++) { + var antecedent = _a[_i]; + var flowType = void 0; + if (!firstAntecedentType) { + // The first antecedent of a loop junction is always the non-looping control + // flow path that leads to the top. + flowType = firstAntecedentType = getTypeAtFlowNode(antecedent); + } + else { + // All but the first antecedent are the looping control flow paths that lead + // back to the loop junction. We track these on the flow loop stack. + flowLoopNodes[flowLoopCount] = flow; + flowLoopKeys[flowLoopCount] = key; + flowLoopTypes[flowLoopCount] = antecedentTypes; + flowLoopCount++; + var saveFlowTypeCache = flowTypeCache; + flowTypeCache = undefined; + flowType = getTypeAtFlowNode(antecedent); + flowTypeCache = saveFlowTypeCache; + flowLoopCount--; + // If we see a value appear in the cache it is a sign that control flow analysis + // was restarted and completed by checkExpressionCached. We can simply pick up + // the resulting type and bail out. + var cached_1 = cache.get(key); + if (cached_1) { + return cached_1; + } + } + var type = getTypeFromFlowType(flowType); + ts.pushIfUnique(antecedentTypes, type); + // If an antecedent type is not a subset of the declared type, we need to perform + // subtype reduction. This happens when a "foreign" type is injected into the control + // flow using the instanceof operator or a user defined type predicate. + if (!isTypeSubsetOf(type, declaredType)) { + subtypeReduction = true; + } + // If the type at a particular antecedent path is the declared type there is no + // reason to process more antecedents since the only possible outcome is subtypes + // that will be removed in the final union type anyway. + if (type === declaredType) { + break; + } + } + // The result is incomplete if the first antecedent (the non-looping control flow path) + // is incomplete. + var result = getUnionOrEvolvingArrayType(antecedentTypes, subtypeReduction ? 2 /* UnionReduction.Subtype */ : 1 /* UnionReduction.Literal */); + if (isIncomplete(firstAntecedentType)) { + return createFlowType(result, /*incomplete*/ true); + } + cache.set(key, result); + return result; + } + // At flow control branch or loop junctions, if the type along every antecedent code path + // is an evolving array type, we construct a combined evolving array type. Otherwise we + // finalize all evolving array types. + function getUnionOrEvolvingArrayType(types, subtypeReduction) { + if (isEvolvingArrayTypeList(types)) { + return getEvolvingArrayType(getUnionType(ts.map(types, getElementTypeOfEvolvingArrayType))); + } + var result = recombineUnknownType(getUnionType(ts.sameMap(types, finalizeEvolvingArrayType), subtypeReduction)); + if (result !== declaredType && result.flags & declaredType.flags & 1048576 /* TypeFlags.Union */ && ts.arraysEqual(result.types, declaredType.types)) { + return declaredType; + } + return result; + } + function getCandidateDiscriminantPropertyAccess(expr) { + if (ts.isBindingPattern(reference) || ts.isFunctionExpressionOrArrowFunction(reference) || ts.isObjectLiteralMethod(reference)) { + // When the reference is a binding pattern or function or arrow expression, we are narrowing a pesudo-reference in + // getNarrowedTypeOfSymbol. An identifier for a destructuring variable declared in the same binding pattern or + // parameter declared in the same parameter list is a candidate. + if (ts.isIdentifier(expr)) { + var symbol = getResolvedSymbol(expr); + var declaration = symbol.valueDeclaration; + if (declaration && (ts.isBindingElement(declaration) || ts.isParameter(declaration)) && reference === declaration.parent && !declaration.initializer && !declaration.dotDotDotToken) { + return declaration; + } + } + } + else if (ts.isAccessExpression(expr)) { + // An access expression is a candidate if the reference matches the left hand expression. + if (isMatchingReference(reference, expr.expression)) { + return expr; + } + } + else if (ts.isIdentifier(expr)) { + var symbol = getResolvedSymbol(expr); + if (isConstVariable(symbol)) { + var declaration = symbol.valueDeclaration; + // Given 'const x = obj.kind', allow 'x' as an alias for 'obj.kind' + if (ts.isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && ts.isAccessExpression(declaration.initializer) && + isMatchingReference(reference, declaration.initializer.expression)) { + return declaration.initializer; + } + // Given 'const { kind: x } = obj', allow 'x' as an alias for 'obj.kind' + if (ts.isBindingElement(declaration) && !declaration.initializer) { + var parent = declaration.parent.parent; + if (ts.isVariableDeclaration(parent) && !parent.type && parent.initializer && (ts.isIdentifier(parent.initializer) || ts.isAccessExpression(parent.initializer)) && + isMatchingReference(reference, parent.initializer)) { + return declaration; + } + } + } + } + return undefined; + } + function getDiscriminantPropertyAccess(expr, computedType) { + var type = declaredType.flags & 1048576 /* TypeFlags.Union */ ? declaredType : computedType; + if (type.flags & 1048576 /* TypeFlags.Union */) { + var access = getCandidateDiscriminantPropertyAccess(expr); + if (access) { + var name = getAccessedPropertyName(access); + if (name && isDiscriminantProperty(type, name)) { + return access; + } + } + } + return undefined; + } + function narrowTypeByDiscriminant(type, access, narrowType) { + var propName = getAccessedPropertyName(access); + if (propName === undefined) { + return type; + } + var removeNullable = strictNullChecks && ts.isOptionalChain(access) && maybeTypeOfKind(type, 98304 /* TypeFlags.Nullable */); + var propType = getTypeOfPropertyOfType(removeNullable ? getTypeWithFacts(type, 2097152 /* TypeFacts.NEUndefinedOrNull */) : type, propName); + if (!propType) { + return type; + } + propType = removeNullable ? getOptionalType(propType) : propType; + var narrowedPropType = narrowType(propType); + return filterType(type, function (t) { + var discriminantType = getTypeOfPropertyOrIndexSignature(t, propName); + return !(discriminantType.flags & 131072 /* TypeFlags.Never */) && !(narrowedPropType.flags & 131072 /* TypeFlags.Never */) && areTypesComparable(narrowedPropType, discriminantType); + }); + } + function narrowTypeByDiscriminantProperty(type, access, operator, value, assumeTrue) { + if ((operator === 36 /* SyntaxKind.EqualsEqualsEqualsToken */ || operator === 37 /* SyntaxKind.ExclamationEqualsEqualsToken */) && type.flags & 1048576 /* TypeFlags.Union */) { + var keyPropertyName = getKeyPropertyName(type); + if (keyPropertyName && keyPropertyName === getAccessedPropertyName(access)) { + var candidate = getConstituentTypeForKeyType(type, getTypeOfExpression(value)); + if (candidate) { + return operator === (assumeTrue ? 36 /* SyntaxKind.EqualsEqualsEqualsToken */ : 37 /* SyntaxKind.ExclamationEqualsEqualsToken */) ? candidate : + isUnitType(getTypeOfPropertyOfType(candidate, keyPropertyName) || unknownType) ? removeType(type, candidate) : + type; + } + } + } + return narrowTypeByDiscriminant(type, access, function (t) { return narrowTypeByEquality(t, operator, value, assumeTrue); }); + } + function narrowTypeBySwitchOnDiscriminantProperty(type, access, switchStatement, clauseStart, clauseEnd) { + if (clauseStart < clauseEnd && type.flags & 1048576 /* TypeFlags.Union */ && getKeyPropertyName(type) === getAccessedPropertyName(access)) { + var clauseTypes = getSwitchClauseTypes(switchStatement).slice(clauseStart, clauseEnd); + var candidate = getUnionType(ts.map(clauseTypes, function (t) { return getConstituentTypeForKeyType(type, t) || unknownType; })); + if (candidate !== unknownType) { + return candidate; + } + } + return narrowTypeByDiscriminant(type, access, function (t) { return narrowTypeBySwitchOnDiscriminant(t, switchStatement, clauseStart, clauseEnd); }); + } + function narrowTypeByTruthiness(type, expr, assumeTrue) { + if (isMatchingReference(reference, expr)) { + return getAdjustedTypeWithFacts(type, assumeTrue ? 4194304 /* TypeFacts.Truthy */ : 8388608 /* TypeFacts.Falsy */); + } + if (strictNullChecks && assumeTrue && optionalChainContainsReference(expr, reference)) { + type = getAdjustedTypeWithFacts(type, 2097152 /* TypeFacts.NEUndefinedOrNull */); + } + var access = getDiscriminantPropertyAccess(expr, type); + if (access) { + return narrowTypeByDiscriminant(type, access, function (t) { return getTypeWithFacts(t, assumeTrue ? 4194304 /* TypeFacts.Truthy */ : 8388608 /* TypeFacts.Falsy */); }); + } + return type; + } + function isTypePresencePossible(type, propName, assumeTrue) { + var prop = getPropertyOfType(type, propName); + return prop ? + !!(prop.flags & 16777216 /* SymbolFlags.Optional */) || assumeTrue : + !!getApplicableIndexInfoForName(type, propName) || !assumeTrue; + } + function narrowTypeByInKeyword(type, nameType, assumeTrue) { + var name = getPropertyNameFromType(nameType); + var isKnownProperty = someType(type, function (t) { return isTypePresencePossible(t, name, /*assumeTrue*/ true); }); + if (isKnownProperty) { + // If the check is for a known property (i.e. a property declared in some constituent of + // the target type), we filter the target type by presence of absence of the property. + return filterType(type, function (t) { return isTypePresencePossible(t, name, assumeTrue); }); + } + if (assumeTrue) { + // If the check is for an unknown property, we intersect the target type with `Record`, + // where X is the name of the property. + var recordSymbol = getGlobalRecordSymbol(); + if (recordSymbol) { + return getIntersectionType([type, getTypeAliasInstantiation(recordSymbol, [nameType, unknownType])]); + } + } + return type; + } + function narrowTypeByBinaryExpression(type, expr, assumeTrue) { + switch (expr.operatorToken.kind) { + case 63 /* SyntaxKind.EqualsToken */: + case 75 /* SyntaxKind.BarBarEqualsToken */: + case 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */: + case 77 /* SyntaxKind.QuestionQuestionEqualsToken */: + return narrowTypeByTruthiness(narrowType(type, expr.right, assumeTrue), expr.left, assumeTrue); + case 34 /* SyntaxKind.EqualsEqualsToken */: + case 35 /* SyntaxKind.ExclamationEqualsToken */: + case 36 /* SyntaxKind.EqualsEqualsEqualsToken */: + case 37 /* SyntaxKind.ExclamationEqualsEqualsToken */: + var operator = expr.operatorToken.kind; + var left = getReferenceCandidate(expr.left); + var right = getReferenceCandidate(expr.right); + if (left.kind === 218 /* SyntaxKind.TypeOfExpression */ && ts.isStringLiteralLike(right)) { + return narrowTypeByTypeof(type, left, operator, right, assumeTrue); + } + if (right.kind === 218 /* SyntaxKind.TypeOfExpression */ && ts.isStringLiteralLike(left)) { + return narrowTypeByTypeof(type, right, operator, left, assumeTrue); + } + if (isMatchingReference(reference, left)) { + return narrowTypeByEquality(type, operator, right, assumeTrue); + } + if (isMatchingReference(reference, right)) { + return narrowTypeByEquality(type, operator, left, assumeTrue); + } + if (strictNullChecks) { + if (optionalChainContainsReference(left, reference)) { + type = narrowTypeByOptionalChainContainment(type, operator, right, assumeTrue); + } + else if (optionalChainContainsReference(right, reference)) { + type = narrowTypeByOptionalChainContainment(type, operator, left, assumeTrue); + } + } + var leftAccess = getDiscriminantPropertyAccess(left, type); + if (leftAccess) { + return narrowTypeByDiscriminantProperty(type, leftAccess, operator, right, assumeTrue); + } + var rightAccess = getDiscriminantPropertyAccess(right, type); + if (rightAccess) { + return narrowTypeByDiscriminantProperty(type, rightAccess, operator, left, assumeTrue); + } + if (isMatchingConstructorReference(left)) { + return narrowTypeByConstructor(type, operator, right, assumeTrue); + } + if (isMatchingConstructorReference(right)) { + return narrowTypeByConstructor(type, operator, left, assumeTrue); + } + break; + case 102 /* SyntaxKind.InstanceOfKeyword */: + return narrowTypeByInstanceof(type, expr, assumeTrue); + case 101 /* SyntaxKind.InKeyword */: + if (ts.isPrivateIdentifier(expr.left)) { + return narrowTypeByPrivateIdentifierInInExpression(type, expr, assumeTrue); + } + var target = getReferenceCandidate(expr.right); + var leftType = getTypeOfExpression(expr.left); + if (leftType.flags & 8576 /* TypeFlags.StringOrNumberLiteralOrUnique */) { + if (containsMissingType(type) && ts.isAccessExpression(reference) && isMatchingReference(reference.expression, target) && + getAccessedPropertyName(reference) === getPropertyNameFromType(leftType)) { + return getTypeWithFacts(type, assumeTrue ? 524288 /* TypeFacts.NEUndefined */ : 65536 /* TypeFacts.EQUndefined */); + } + if (isMatchingReference(reference, target)) { + return narrowTypeByInKeyword(type, leftType, assumeTrue); + } + } + break; + case 27 /* SyntaxKind.CommaToken */: + return narrowType(type, expr.right, assumeTrue); + // Ordinarily we won't see && and || expressions in control flow analysis because the Binder breaks those + // expressions down to individual conditional control flows. However, we may encounter them when analyzing + // aliased conditional expressions. + case 55 /* SyntaxKind.AmpersandAmpersandToken */: + return assumeTrue ? + narrowType(narrowType(type, expr.left, /*assumeTrue*/ true), expr.right, /*assumeTrue*/ true) : + getUnionType([narrowType(type, expr.left, /*assumeTrue*/ false), narrowType(type, expr.right, /*assumeTrue*/ false)]); + case 56 /* SyntaxKind.BarBarToken */: + return assumeTrue ? + getUnionType([narrowType(type, expr.left, /*assumeTrue*/ true), narrowType(type, expr.right, /*assumeTrue*/ true)]) : + narrowType(narrowType(type, expr.left, /*assumeTrue*/ false), expr.right, /*assumeTrue*/ false); + } + return type; + } + function narrowTypeByPrivateIdentifierInInExpression(type, expr, assumeTrue) { + var target = getReferenceCandidate(expr.right); + if (!isMatchingReference(reference, target)) { + return type; + } + ts.Debug.assertNode(expr.left, ts.isPrivateIdentifier); + var symbol = getSymbolForPrivateIdentifierExpression(expr.left); + if (symbol === undefined) { + return type; + } + var classSymbol = symbol.parent; + var targetType = ts.hasStaticModifier(ts.Debug.checkDefined(symbol.valueDeclaration, "should always have a declaration")) + ? getTypeOfSymbol(classSymbol) + : getDeclaredTypeOfSymbol(classSymbol); + return getNarrowedType(type, targetType, assumeTrue, /*checkDerived*/ true); + } + function narrowTypeByOptionalChainContainment(type, operator, value, assumeTrue) { + // We are in a branch of obj?.foo === value (or any one of the other equality operators). We narrow obj as follows: + // When operator is === and type of value excludes undefined, null and undefined is removed from type of obj in true branch. + // When operator is !== and type of value excludes undefined, null and undefined is removed from type of obj in false branch. + // When operator is == and type of value excludes null and undefined, null and undefined is removed from type of obj in true branch. + // When operator is != and type of value excludes null and undefined, null and undefined is removed from type of obj in false branch. + // When operator is === and type of value is undefined, null and undefined is removed from type of obj in false branch. + // When operator is !== and type of value is undefined, null and undefined is removed from type of obj in true branch. + // When operator is == and type of value is null or undefined, null and undefined is removed from type of obj in false branch. + // When operator is != and type of value is null or undefined, null and undefined is removed from type of obj in true branch. + var equalsOperator = operator === 34 /* SyntaxKind.EqualsEqualsToken */ || operator === 36 /* SyntaxKind.EqualsEqualsEqualsToken */; + var nullableFlags = operator === 34 /* SyntaxKind.EqualsEqualsToken */ || operator === 35 /* SyntaxKind.ExclamationEqualsToken */ ? 98304 /* TypeFlags.Nullable */ : 32768 /* TypeFlags.Undefined */; + var valueType = getTypeOfExpression(value); + // Note that we include any and unknown in the exclusion test because their domain includes null and undefined. + var removeNullable = equalsOperator !== assumeTrue && everyType(valueType, function (t) { return !!(t.flags & nullableFlags); }) || + equalsOperator === assumeTrue && everyType(valueType, function (t) { return !(t.flags & (3 /* TypeFlags.AnyOrUnknown */ | nullableFlags)); }); + return removeNullable ? getAdjustedTypeWithFacts(type, 2097152 /* TypeFacts.NEUndefinedOrNull */) : type; + } + function narrowTypeByEquality(type, operator, value, assumeTrue) { + if (type.flags & 1 /* TypeFlags.Any */) { + return type; + } + if (operator === 35 /* SyntaxKind.ExclamationEqualsToken */ || operator === 37 /* SyntaxKind.ExclamationEqualsEqualsToken */) { + assumeTrue = !assumeTrue; + } + var valueType = getTypeOfExpression(value); + var doubleEquals = operator === 34 /* SyntaxKind.EqualsEqualsToken */ || operator === 35 /* SyntaxKind.ExclamationEqualsToken */; + if (valueType.flags & 98304 /* TypeFlags.Nullable */) { + if (!strictNullChecks) { + return type; + } + var facts = doubleEquals ? + assumeTrue ? 262144 /* TypeFacts.EQUndefinedOrNull */ : 2097152 /* TypeFacts.NEUndefinedOrNull */ : + valueType.flags & 65536 /* TypeFlags.Null */ ? + assumeTrue ? 131072 /* TypeFacts.EQNull */ : 1048576 /* TypeFacts.NENull */ : + assumeTrue ? 65536 /* TypeFacts.EQUndefined */ : 524288 /* TypeFacts.NEUndefined */; + return getAdjustedTypeWithFacts(type, facts); + } + if (assumeTrue) { + if (!doubleEquals && (type.flags & 2 /* TypeFlags.Unknown */ || someType(type, isEmptyAnonymousObjectType))) { + if (valueType.flags & (131068 /* TypeFlags.Primitive */ | 67108864 /* TypeFlags.NonPrimitive */) || isEmptyAnonymousObjectType(valueType)) { + return valueType; + } + if (valueType.flags & 524288 /* TypeFlags.Object */) { + return nonPrimitiveType; + } + } + var filteredType = filterType(type, function (t) { return areTypesComparable(t, valueType) || doubleEquals && isCoercibleUnderDoubleEquals(t, valueType); }); + return replacePrimitivesWithLiterals(filteredType, valueType); + } + if (isUnitType(valueType)) { + return filterType(type, function (t) { return !(isUnitLikeType(t) && areTypesComparable(t, valueType)); }); + } + return type; + } + function narrowTypeByTypeof(type, typeOfExpr, operator, literal, assumeTrue) { + // We have '==', '!=', '===', or !==' operator with 'typeof xxx' and string literal operands + if (operator === 35 /* SyntaxKind.ExclamationEqualsToken */ || operator === 37 /* SyntaxKind.ExclamationEqualsEqualsToken */) { + assumeTrue = !assumeTrue; + } + var target = getReferenceCandidate(typeOfExpr.expression); + if (!isMatchingReference(reference, target)) { + var propertyAccess = getDiscriminantPropertyAccess(typeOfExpr.expression, type); + if (propertyAccess) { + return narrowTypeByDiscriminant(type, propertyAccess, function (t) { return narrowTypeByLiteralExpression(t, literal, assumeTrue); }); + } + if (strictNullChecks && optionalChainContainsReference(target, reference) && assumeTrue === (literal.text !== "undefined")) { + return getAdjustedTypeWithFacts(type, 2097152 /* TypeFacts.NEUndefinedOrNull */); + } + return type; + } + return narrowTypeByLiteralExpression(type, literal, assumeTrue); + } + function narrowTypeByLiteralExpression(type, literal, assumeTrue) { + return assumeTrue ? + narrowTypeByTypeName(type, literal.text) : + getTypeWithFacts(type, typeofNEFacts.get(literal.text) || 32768 /* TypeFacts.TypeofNEHostObject */); + } + function narrowTypeBySwitchOptionalChainContainment(type, switchStatement, clauseStart, clauseEnd, clauseCheck) { + var everyClauseChecks = clauseStart !== clauseEnd && ts.every(getSwitchClauseTypes(switchStatement).slice(clauseStart, clauseEnd), clauseCheck); + return everyClauseChecks ? getTypeWithFacts(type, 2097152 /* TypeFacts.NEUndefinedOrNull */) : type; + } + function narrowTypeBySwitchOnDiscriminant(type, switchStatement, clauseStart, clauseEnd) { + // We only narrow if all case expressions specify + // values with unit types, except for the case where + // `type` is unknown. In this instance we map object + // types to the nonPrimitive type and narrow with that. + var switchTypes = getSwitchClauseTypes(switchStatement); + if (!switchTypes.length) { + return type; + } + var clauseTypes = switchTypes.slice(clauseStart, clauseEnd); + var hasDefaultClause = clauseStart === clauseEnd || ts.contains(clauseTypes, neverType); + if ((type.flags & 2 /* TypeFlags.Unknown */) && !hasDefaultClause) { + var groundClauseTypes = void 0; + for (var i = 0; i < clauseTypes.length; i += 1) { + var t = clauseTypes[i]; + if (t.flags & (131068 /* TypeFlags.Primitive */ | 67108864 /* TypeFlags.NonPrimitive */)) { + if (groundClauseTypes !== undefined) { + groundClauseTypes.push(t); + } + } + else if (t.flags & 524288 /* TypeFlags.Object */) { + if (groundClauseTypes === undefined) { + groundClauseTypes = clauseTypes.slice(0, i); + } + groundClauseTypes.push(nonPrimitiveType); + } + else { + return type; + } + } + return getUnionType(groundClauseTypes === undefined ? clauseTypes : groundClauseTypes); + } + var discriminantType = getUnionType(clauseTypes); + var caseType = discriminantType.flags & 131072 /* TypeFlags.Never */ ? neverType : + replacePrimitivesWithLiterals(filterType(type, function (t) { return areTypesComparable(discriminantType, t); }), discriminantType); + if (!hasDefaultClause) { + return caseType; + } + var defaultType = filterType(type, function (t) { return !(isUnitLikeType(t) && ts.contains(switchTypes, getRegularTypeOfLiteralType(extractUnitType(t)))); }); + return caseType.flags & 131072 /* TypeFlags.Never */ ? defaultType : getUnionType([caseType, defaultType]); + } + function narrowTypeByTypeName(type, typeName) { + switch (typeName) { + case "string": return narrowTypeByTypeFacts(type, stringType, 1 /* TypeFacts.TypeofEQString */); + case "number": return narrowTypeByTypeFacts(type, numberType, 2 /* TypeFacts.TypeofEQNumber */); + case "bigint": return narrowTypeByTypeFacts(type, bigintType, 4 /* TypeFacts.TypeofEQBigInt */); + case "boolean": return narrowTypeByTypeFacts(type, booleanType, 8 /* TypeFacts.TypeofEQBoolean */); + case "symbol": return narrowTypeByTypeFacts(type, esSymbolType, 16 /* TypeFacts.TypeofEQSymbol */); + case "object": return type.flags & 1 /* TypeFlags.Any */ ? type : getUnionType([narrowTypeByTypeFacts(type, nonPrimitiveType, 32 /* TypeFacts.TypeofEQObject */), narrowTypeByTypeFacts(type, nullType, 131072 /* TypeFacts.EQNull */)]); + case "function": return type.flags & 1 /* TypeFlags.Any */ ? type : narrowTypeByTypeFacts(type, globalFunctionType, 64 /* TypeFacts.TypeofEQFunction */); + case "undefined": return narrowTypeByTypeFacts(type, undefinedType, 65536 /* TypeFacts.EQUndefined */); + } + return narrowTypeByTypeFacts(type, nonPrimitiveType, 128 /* TypeFacts.TypeofEQHostObject */); + } + function narrowTypeByTypeFacts(type, impliedType, facts) { + return mapType(type, function (t) { + // We first check if a constituent is a subtype of the implied type. If so, we either keep or eliminate + // the constituent based on its type facts. We use the strict subtype relation because it treats `object` + // as a subtype of `{}`, and we need the type facts check because function types are subtypes of `object`, + // but are classified as "function" according to `typeof`. + return isTypeRelatedTo(t, impliedType, strictSubtypeRelation) ? getTypeFacts(t) & facts ? t : neverType : + // We next check if the consituent is a supertype of the implied type. If so, we substitute the implied + // type. This handles top types like `unknown` and `{}`, and supertypes like `{ toString(): string }`. + isTypeSubtypeOf(impliedType, t) ? impliedType : + // Neither the constituent nor the implied type is a subtype of the other, however their domains may still + // overlap. For example, an unconstrained type parameter and type `string`. If the type facts indicate + // possible overlap, we form an intersection. Otherwise, we eliminate the constituent. + getTypeFacts(t) & facts ? getIntersectionType([t, impliedType]) : + neverType; + }); + } + function narrowTypeBySwitchOnTypeOf(type, switchStatement, clauseStart, clauseEnd) { + var witnesses = getSwitchClauseTypeOfWitnesses(switchStatement); + if (!witnesses) { + return type; + } + // Equal start and end denotes implicit fallthrough; undefined marks explicit default clause. + var defaultIndex = ts.findIndex(switchStatement.caseBlock.clauses, function (clause) { return clause.kind === 293 /* SyntaxKind.DefaultClause */; }); + var hasDefaultClause = clauseStart === clauseEnd || (defaultIndex >= clauseStart && defaultIndex < clauseEnd); + if (hasDefaultClause) { + // In the default clause we filter constituents down to those that are not-equal to all handled cases. + var notEqualFacts_1 = getNotEqualFactsFromTypeofSwitch(clauseStart, clauseEnd, witnesses); + return filterType(type, function (t) { return (getTypeFacts(t) & notEqualFacts_1) === notEqualFacts_1; }); + } + // In the non-default cause we create a union of the type narrowed by each of the listed cases. + var clauseWitnesses = witnesses.slice(clauseStart, clauseEnd); + return getUnionType(ts.map(clauseWitnesses, function (text) { return text ? narrowTypeByTypeName(type, text) : neverType; })); + } + function isMatchingConstructorReference(expr) { + return (ts.isPropertyAccessExpression(expr) && ts.idText(expr.name) === "constructor" || + ts.isElementAccessExpression(expr) && ts.isStringLiteralLike(expr.argumentExpression) && expr.argumentExpression.text === "constructor") && + isMatchingReference(reference, expr.expression); + } + function narrowTypeByConstructor(type, operator, identifier, assumeTrue) { + // Do not narrow when checking inequality. + if (assumeTrue ? (operator !== 34 /* SyntaxKind.EqualsEqualsToken */ && operator !== 36 /* SyntaxKind.EqualsEqualsEqualsToken */) : (operator !== 35 /* SyntaxKind.ExclamationEqualsToken */ && operator !== 37 /* SyntaxKind.ExclamationEqualsEqualsToken */)) { + return type; + } + // Get the type of the constructor identifier expression, if it is not a function then do not narrow. + var identifierType = getTypeOfExpression(identifier); + if (!isFunctionType(identifierType) && !isConstructorType(identifierType)) { + return type; + } + // Get the prototype property of the type identifier so we can find out its type. + var prototypeProperty = getPropertyOfType(identifierType, "prototype"); + if (!prototypeProperty) { + return type; + } + // Get the type of the prototype, if it is undefined, or the global `Object` or `Function` types then do not narrow. + var prototypeType = getTypeOfSymbol(prototypeProperty); + var candidate = !isTypeAny(prototypeType) ? prototypeType : undefined; + if (!candidate || candidate === globalObjectType || candidate === globalFunctionType) { + return type; + } + // If the type that is being narrowed is `any` then just return the `candidate` type since every type is a subtype of `any`. + if (isTypeAny(type)) { + return candidate; + } + // Filter out types that are not considered to be "constructed by" the `candidate` type. + return filterType(type, function (t) { return isConstructedBy(t, candidate); }); + function isConstructedBy(source, target) { + // If either the source or target type are a class type then we need to check that they are the same exact type. + // This is because you may have a class `A` that defines some set of properties, and another class `B` + // that defines the same set of properties as class `A`, in that case they are structurally the same + // type, but when you do something like `instanceOfA.constructor === B` it will return false. + if (source.flags & 524288 /* TypeFlags.Object */ && ts.getObjectFlags(source) & 1 /* ObjectFlags.Class */ || + target.flags & 524288 /* TypeFlags.Object */ && ts.getObjectFlags(target) & 1 /* ObjectFlags.Class */) { + return source.symbol === target.symbol; + } + // For all other types just check that the `source` type is a subtype of the `target` type. + return isTypeSubtypeOf(source, target); + } + } + function narrowTypeByInstanceof(type, expr, assumeTrue) { + var left = getReferenceCandidate(expr.left); + if (!isMatchingReference(reference, left)) { + if (assumeTrue && strictNullChecks && optionalChainContainsReference(left, reference)) { + return getAdjustedTypeWithFacts(type, 2097152 /* TypeFacts.NEUndefinedOrNull */); + } + return type; + } + // Check that right operand is a function type with a prototype property + var rightType = getTypeOfExpression(expr.right); + if (!isTypeDerivedFrom(rightType, globalFunctionType)) { + return type; + } + var targetType; + var prototypeProperty = getPropertyOfType(rightType, "prototype"); + if (prototypeProperty) { + // Target type is type of the prototype property + var prototypePropertyType = getTypeOfSymbol(prototypeProperty); + if (!isTypeAny(prototypePropertyType)) { + targetType = prototypePropertyType; + } + } + // Don't narrow from 'any' if the target type is exactly 'Object' or 'Function' + if (isTypeAny(type) && (targetType === globalObjectType || targetType === globalFunctionType)) { + return type; + } + if (!targetType) { + var constructSignatures = getSignaturesOfType(rightType, 1 /* SignatureKind.Construct */); + targetType = constructSignatures.length ? + getUnionType(ts.map(constructSignatures, function (signature) { return getReturnTypeOfSignature(getErasedSignature(signature)); })) : + emptyObjectType; + } + // We can't narrow a union based off instanceof without negated types see #31576 for more info + if (!assumeTrue && rightType.flags & 1048576 /* TypeFlags.Union */) { + var nonConstructorTypeInUnion = ts.find(rightType.types, function (t) { return !isConstructorType(t); }); + if (!nonConstructorTypeInUnion) + return type; + } + return getNarrowedType(type, targetType, assumeTrue, /*checkDerived*/ true); + } + function getNarrowedType(type, candidate, assumeTrue, checkDerived) { + var _a; + var key = type.flags & 1048576 /* TypeFlags.Union */ ? "N".concat(getTypeId(type), ",").concat(getTypeId(candidate), ",").concat((assumeTrue ? 1 : 0) | (checkDerived ? 2 : 0)) : undefined; + return (_a = getCachedType(key)) !== null && _a !== void 0 ? _a : setCachedType(key, getNarrowedTypeWorker(type, candidate, assumeTrue, checkDerived)); + } + function getNarrowedTypeWorker(type, candidate, assumeTrue, checkDerived) { + var isRelated = checkDerived ? isTypeDerivedFrom : isTypeSubtypeOf; + if (!assumeTrue) { + return filterType(type, function (t) { return !isRelated(t, candidate); }); + } + if (type.flags & 3 /* TypeFlags.AnyOrUnknown */) { + return candidate; + } + // We first attempt to filter the current type, narrowing constituents as appropriate and removing + // constituents that are unrelated to the candidate. + var keyPropertyName = type.flags & 1048576 /* TypeFlags.Union */ ? getKeyPropertyName(type) : undefined; + var narrowedType = mapType(candidate, function (c) { + // If a discriminant property is available, use that to reduce the type. + var discriminant = keyPropertyName && getTypeOfPropertyOfType(c, keyPropertyName); + var matching = discriminant && getConstituentTypeForKeyType(type, discriminant); + // For each constituent t in the current type, if t and and c are directly related, pick the most + // specific of the two. When t and c are related in both directions, we prefer c for type predicates + // because that is the asserted type, but t for `instanceof` because generics aren't reflected in + // prototype object types. + var directlyRelated = mapType(matching || type, checkDerived ? + function (t) { return isTypeDerivedFrom(t, c) ? t : isTypeDerivedFrom(c, t) ? c : neverType; } : + function (t) { return isTypeSubtypeOf(c, t) ? c : isTypeSubtypeOf(t, c) ? t : neverType; }); + // If no constituents are directly related, create intersections for any generic constituents that + // are related by constraint. + return directlyRelated.flags & 131072 /* TypeFlags.Never */ ? + mapType(type, function (t) { return maybeTypeOfKind(t, 465829888 /* TypeFlags.Instantiable */) && isRelated(c, getBaseConstraintOfType(t) || unknownType) ? getIntersectionType([t, c]) : neverType; }) : + directlyRelated; + }); + // If filtering produced a non-empty type, return that. Otherwise, pick the most specific of the two + // based on assignability, or as a last resort produce an intersection. + return !(narrowedType.flags & 131072 /* TypeFlags.Never */) ? narrowedType : + isTypeSubtypeOf(candidate, type) ? candidate : + isTypeAssignableTo(type, candidate) ? type : + isTypeAssignableTo(candidate, type) ? candidate : + getIntersectionType([type, candidate]); + } + function narrowTypeByCallExpression(type, callExpression, assumeTrue) { + if (hasMatchingArgument(callExpression, reference)) { + var signature = assumeTrue || !ts.isCallChain(callExpression) ? getEffectsSignature(callExpression) : undefined; + var predicate = signature && getTypePredicateOfSignature(signature); + if (predicate && (predicate.kind === 0 /* TypePredicateKind.This */ || predicate.kind === 1 /* TypePredicateKind.Identifier */)) { + return narrowTypeByTypePredicate(type, predicate, callExpression, assumeTrue); + } + } + if (containsMissingType(type) && ts.isAccessExpression(reference) && ts.isPropertyAccessExpression(callExpression.expression)) { + var callAccess = callExpression.expression; + if (isMatchingReference(reference.expression, getReferenceCandidate(callAccess.expression)) && + ts.isIdentifier(callAccess.name) && callAccess.name.escapedText === "hasOwnProperty" && callExpression.arguments.length === 1) { + var argument = callExpression.arguments[0]; + if (ts.isStringLiteralLike(argument) && getAccessedPropertyName(reference) === ts.escapeLeadingUnderscores(argument.text)) { + return getTypeWithFacts(type, assumeTrue ? 524288 /* TypeFacts.NEUndefined */ : 65536 /* TypeFacts.EQUndefined */); + } + } + } + return type; + } + function narrowTypeByTypePredicate(type, predicate, callExpression, assumeTrue) { + // Don't narrow from 'any' if the predicate type is exactly 'Object' or 'Function' + if (predicate.type && !(isTypeAny(type) && (predicate.type === globalObjectType || predicate.type === globalFunctionType))) { + var predicateArgument = getTypePredicateArgument(predicate, callExpression); + if (predicateArgument) { + if (isMatchingReference(reference, predicateArgument)) { + return getNarrowedType(type, predicate.type, assumeTrue, /*checkDerived*/ false); + } + if (strictNullChecks && assumeTrue && optionalChainContainsReference(predicateArgument, reference) && + !(getTypeFacts(predicate.type) & 65536 /* TypeFacts.EQUndefined */)) { + type = getAdjustedTypeWithFacts(type, 2097152 /* TypeFacts.NEUndefinedOrNull */); + } + var access = getDiscriminantPropertyAccess(predicateArgument, type); + if (access) { + return narrowTypeByDiscriminant(type, access, function (t) { return getNarrowedType(t, predicate.type, assumeTrue, /*checkDerived*/ false); }); + } + } + } + return type; + } + // Narrow the given type based on the given expression having the assumed boolean value. The returned type + // will be a subtype or the same type as the argument. + function narrowType(type, expr, assumeTrue) { + // for `a?.b`, we emulate a synthetic `a !== null && a !== undefined` condition for `a` + if (ts.isExpressionOfOptionalChainRoot(expr) || + ts.isBinaryExpression(expr.parent) && expr.parent.operatorToken.kind === 60 /* SyntaxKind.QuestionQuestionToken */ && expr.parent.left === expr) { + return narrowTypeByOptionality(type, expr, assumeTrue); + } + switch (expr.kind) { + case 79 /* SyntaxKind.Identifier */: + // When narrowing a reference to a const variable, non-assigned parameter, or readonly property, we inline + // up to five levels of aliased conditional expressions that are themselves declared as const variables. + if (!isMatchingReference(reference, expr) && inlineLevel < 5) { + var symbol = getResolvedSymbol(expr); + if (isConstVariable(symbol)) { + var declaration = symbol.valueDeclaration; + if (declaration && ts.isVariableDeclaration(declaration) && !declaration.type && declaration.initializer && isConstantReference(reference)) { + inlineLevel++; + var result = narrowType(type, declaration.initializer, assumeTrue); + inlineLevel--; + return result; + } + } + } + // falls through + case 108 /* SyntaxKind.ThisKeyword */: + case 106 /* SyntaxKind.SuperKeyword */: + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 209 /* SyntaxKind.ElementAccessExpression */: + return narrowTypeByTruthiness(type, expr, assumeTrue); + case 210 /* SyntaxKind.CallExpression */: + return narrowTypeByCallExpression(type, expr, assumeTrue); + case 214 /* SyntaxKind.ParenthesizedExpression */: + case 232 /* SyntaxKind.NonNullExpression */: + return narrowType(type, expr.expression, assumeTrue); + case 223 /* SyntaxKind.BinaryExpression */: + return narrowTypeByBinaryExpression(type, expr, assumeTrue); + case 221 /* SyntaxKind.PrefixUnaryExpression */: + if (expr.operator === 53 /* SyntaxKind.ExclamationToken */) { + return narrowType(type, expr.operand, !assumeTrue); + } + break; + } + return type; + } + function narrowTypeByOptionality(type, expr, assumePresent) { + if (isMatchingReference(reference, expr)) { + return getAdjustedTypeWithFacts(type, assumePresent ? 2097152 /* TypeFacts.NEUndefinedOrNull */ : 262144 /* TypeFacts.EQUndefinedOrNull */); + } + var access = getDiscriminantPropertyAccess(expr, type); + if (access) { + return narrowTypeByDiscriminant(type, access, function (t) { return getTypeWithFacts(t, assumePresent ? 2097152 /* TypeFacts.NEUndefinedOrNull */ : 262144 /* TypeFacts.EQUndefinedOrNull */); }); + } + return type; + } + } + function getTypeOfSymbolAtLocation(symbol, location) { + symbol = symbol.exportSymbol || symbol; + // If we have an identifier or a property access at the given location, if the location is + // an dotted name expression, and if the location is not an assignment target, obtain the type + // of the expression (which will reflect control flow analysis). If the expression indeed + // resolved to the given symbol, return the narrowed type. + if (location.kind === 79 /* SyntaxKind.Identifier */ || location.kind === 80 /* SyntaxKind.PrivateIdentifier */) { + if (ts.isRightSideOfQualifiedNameOrPropertyAccess(location)) { + location = location.parent; + } + if (ts.isExpressionNode(location) && (!ts.isAssignmentTarget(location) || ts.isWriteAccess(location))) { + var type = getTypeOfExpression(location); + if (getExportSymbolOfValueSymbolIfExported(getNodeLinks(location).resolvedSymbol) === symbol) { + return type; + } + } + } + if (ts.isDeclarationName(location) && ts.isSetAccessor(location.parent) && getAnnotatedAccessorTypeNode(location.parent)) { + return getWriteTypeOfAccessors(location.parent.symbol); + } + // The location isn't a reference to the given symbol, meaning we're being asked + // a hypothetical question of what type the symbol would have if there was a reference + // to it at the given location. Since we have no control flow information for the + // hypothetical reference (control flow information is created and attached by the + // binder), we simply return the declared type of the symbol. + return getNonMissingTypeOfSymbol(symbol); + } + function getControlFlowContainer(node) { + return ts.findAncestor(node.parent, function (node) { + return ts.isFunctionLike(node) && !ts.getImmediatelyInvokedFunctionExpression(node) || + node.kind === 265 /* SyntaxKind.ModuleBlock */ || + node.kind === 308 /* SyntaxKind.SourceFile */ || + node.kind === 169 /* SyntaxKind.PropertyDeclaration */; + }); + } + // Check if a parameter or catch variable is assigned anywhere + function isSymbolAssigned(symbol) { + if (!symbol.valueDeclaration) { + return false; + } + var parent = ts.getRootDeclaration(symbol.valueDeclaration).parent; + var links = getNodeLinks(parent); + if (!(links.flags & 8388608 /* NodeCheckFlags.AssignmentsMarked */)) { + links.flags |= 8388608 /* NodeCheckFlags.AssignmentsMarked */; + if (!hasParentWithAssignmentsMarked(parent)) { + markNodeAssignments(parent); + } + } + return symbol.isAssigned || false; + } + function hasParentWithAssignmentsMarked(node) { + return !!ts.findAncestor(node.parent, function (node) { + return (ts.isFunctionLike(node) || ts.isCatchClause(node)) && !!(getNodeLinks(node).flags & 8388608 /* NodeCheckFlags.AssignmentsMarked */); + }); + } + function markNodeAssignments(node) { + if (node.kind === 79 /* SyntaxKind.Identifier */) { + if (ts.isAssignmentTarget(node)) { + var symbol = getResolvedSymbol(node); + if (ts.isParameterOrCatchClauseVariable(symbol)) { + symbol.isAssigned = true; + } + } + } + else { + ts.forEachChild(node, markNodeAssignments); + } + } + function isConstVariable(symbol) { + return symbol.flags & 3 /* SymbolFlags.Variable */ && (getDeclarationNodeFlagsFromSymbol(symbol) & 2 /* NodeFlags.Const */) !== 0; + } + /** remove undefined from the annotated type of a parameter when there is an initializer (that doesn't include undefined) */ + function removeOptionalityFromDeclaredType(declaredType, declaration) { + if (pushTypeResolution(declaration.symbol, 2 /* TypeSystemPropertyName.DeclaredType */)) { + var annotationIncludesUndefined = strictNullChecks && + declaration.kind === 166 /* SyntaxKind.Parameter */ && + declaration.initializer && + getTypeFacts(declaredType) & 16777216 /* TypeFacts.IsUndefined */ && + !(getTypeFacts(checkExpression(declaration.initializer)) & 16777216 /* TypeFacts.IsUndefined */); + popTypeResolution(); + return annotationIncludesUndefined ? getTypeWithFacts(declaredType, 524288 /* TypeFacts.NEUndefined */) : declaredType; + } + else { + reportCircularityError(declaration.symbol); + return declaredType; + } + } + function isConstraintPosition(type, node) { + var parent = node.parent; + // In an element access obj[x], we consider obj to be in a constraint position, except when obj is of + // a generic type without a nullable constraint and x is a generic type. This is because when both obj + // and x are of generic types T and K, we want the resulting type to be T[K]. + return parent.kind === 208 /* SyntaxKind.PropertyAccessExpression */ || + parent.kind === 163 /* SyntaxKind.QualifiedName */ || + parent.kind === 210 /* SyntaxKind.CallExpression */ && parent.expression === node || + parent.kind === 209 /* SyntaxKind.ElementAccessExpression */ && parent.expression === node && + !(someType(type, isGenericTypeWithoutNullableConstraint) && isGenericIndexType(getTypeOfExpression(parent.argumentExpression))); + } + function isGenericTypeWithUnionConstraint(type) { + return type.flags & 2097152 /* TypeFlags.Intersection */ ? + ts.some(type.types, isGenericTypeWithUnionConstraint) : + !!(type.flags & 465829888 /* TypeFlags.Instantiable */ && getBaseConstraintOrType(type).flags & (98304 /* TypeFlags.Nullable */ | 1048576 /* TypeFlags.Union */)); + } + function isGenericTypeWithoutNullableConstraint(type) { + return type.flags & 2097152 /* TypeFlags.Intersection */ ? + ts.some(type.types, isGenericTypeWithoutNullableConstraint) : + !!(type.flags & 465829888 /* TypeFlags.Instantiable */ && !maybeTypeOfKind(getBaseConstraintOrType(type), 98304 /* TypeFlags.Nullable */)); + } + function hasContextualTypeWithNoGenericTypes(node, checkMode) { + // Computing the contextual type for a child of a JSX element involves resolving the type of the + // element's tag name, so we exclude that here to avoid circularities. + // If check mode has `CheckMode.RestBindingElement`, we skip binding pattern contextual types, + // as we want the type of a rest element to be generic when possible. + var contextualType = (ts.isIdentifier(node) || ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) && + !((ts.isJsxOpeningElement(node.parent) || ts.isJsxSelfClosingElement(node.parent)) && node.parent.tagName === node) && + (checkMode && checkMode & 64 /* CheckMode.RestBindingElement */ ? + getContextualType(node, 8 /* ContextFlags.SkipBindingPatterns */) + : getContextualType(node, /*contextFlags*/ undefined)); + return contextualType && !isGenericType(contextualType); + } + function getNarrowableTypeForReference(type, reference, checkMode) { + // When the type of a reference is or contains an instantiable type with a union type constraint, and + // when the reference is in a constraint position (where it is known we'll obtain the apparent type) or + // has a contextual type containing no top-level instantiables (meaning constraints will determine + // assignability), we substitute constraints for all instantiables in the type of the reference to give + // control flow analysis an opportunity to narrow it further. For example, for a reference of a type + // parameter type 'T extends string | undefined' with a contextual type 'string', we substitute + // 'string | undefined' to give control flow analysis the opportunity to narrow to type 'string'. + var substituteConstraints = !(checkMode && checkMode & 2 /* CheckMode.Inferential */) && + someType(type, isGenericTypeWithUnionConstraint) && + (isConstraintPosition(type, reference) || hasContextualTypeWithNoGenericTypes(reference, checkMode)); + return substituteConstraints ? mapType(type, getBaseConstraintOrType) : type; + } + function isExportOrExportExpression(location) { + return !!ts.findAncestor(location, function (n) { + var parent = n.parent; + if (parent === undefined) { + return "quit"; + } + if (ts.isExportAssignment(parent)) { + return parent.expression === n && ts.isEntityNameExpression(n); + } + if (ts.isExportSpecifier(parent)) { + return parent.name === n || parent.propertyName === n; + } + return false; + }); + } + function markAliasReferenced(symbol, location) { + if (isNonLocalAlias(symbol, /*excludes*/ 111551 /* SymbolFlags.Value */) && !isInTypeQuery(location) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* SymbolFlags.Value */)) { + var target = resolveAlias(symbol); + if (getAllSymbolFlags(target) & (111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */)) { + // An alias resolving to a const enum cannot be elided if (1) 'isolatedModules' is enabled + // (because the const enum value will not be inlined), or if (2) the alias is an export + // of a const enum declaration that will be preserved. + if (compilerOptions.isolatedModules || + ts.shouldPreserveConstEnums(compilerOptions) && isExportOrExportExpression(location) || + !isConstEnumOrConstEnumOnlyModule(getExportSymbolOfValueSymbolIfExported(target))) { + markAliasSymbolAsReferenced(symbol); + } + else { + markConstEnumAliasAsReferenced(symbol); + } + } + } + } + function getNarrowedTypeOfSymbol(symbol, location) { + var declaration = symbol.valueDeclaration; + if (declaration) { + // If we have a non-rest binding element with no initializer declared as a const variable or a const-like + // parameter (a parameter for which there are no assignments in the function body), and if the parent type + // for the destructuring is a union type, one or more of the binding elements may represent discriminant + // properties, and we want the effects of conditional checks on such discriminants to affect the types of + // other binding elements from the same destructuring. Consider: + // + // type Action = + // | { kind: 'A', payload: number } + // | { kind: 'B', payload: string }; + // + // function f({ kind, payload }: Action) { + // if (kind === 'A') { + // payload.toFixed(); + // } + // if (kind === 'B') { + // payload.toUpperCase(); + // } + // } + // + // Above, we want the conditional checks on 'kind' to affect the type of 'payload'. To facilitate this, we use + // the binding pattern AST instance for '{ kind, payload }' as a pseudo-reference and narrow this reference + // as if it occurred in the specified location. We then recompute the narrowed binding element type by + // destructuring from the narrowed parent type. + if (ts.isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && declaration.parent.elements.length >= 2) { + var parent = declaration.parent.parent; + if (parent.kind === 257 /* SyntaxKind.VariableDeclaration */ && ts.getCombinedNodeFlags(declaration) & 2 /* NodeFlags.Const */ || parent.kind === 166 /* SyntaxKind.Parameter */) { + var links = getNodeLinks(parent); + if (!(links.flags & 268435456 /* NodeCheckFlags.InCheckIdentifier */)) { + links.flags |= 268435456 /* NodeCheckFlags.InCheckIdentifier */; + var parentType = getTypeForBindingElementParent(parent, 0 /* CheckMode.Normal */); + var parentTypeConstraint = parentType && mapType(parentType, getBaseConstraintOrType); + links.flags &= ~268435456 /* NodeCheckFlags.InCheckIdentifier */; + if (parentTypeConstraint && parentTypeConstraint.flags & 1048576 /* TypeFlags.Union */ && !(parent.kind === 166 /* SyntaxKind.Parameter */ && isSymbolAssigned(symbol))) { + var pattern = declaration.parent; + var narrowedType = getFlowTypeOfReference(pattern, parentTypeConstraint, parentTypeConstraint, /*flowContainer*/ undefined, location.flowNode); + if (narrowedType.flags & 131072 /* TypeFlags.Never */) { + return neverType; + } + return getBindingElementTypeFromParentType(declaration, narrowedType); + } + } + } + } + // If we have a const-like parameter with no type annotation or initializer, and if the parameter is contextually + // typed by a signature with a single rest parameter of a union of tuple types, one or more of the parameters may + // represent discriminant tuple elements, and we want the effects of conditional checks on such discriminants to + // affect the types of other parameters in the same parameter list. Consider: + // + // type Action = [kind: 'A', payload: number] | [kind: 'B', payload: string]; + // + // const f: (...args: Action) => void = (kind, payload) => { + // if (kind === 'A') { + // payload.toFixed(); + // } + // if (kind === 'B') { + // payload.toUpperCase(); + // } + // } + // + // Above, we want the conditional checks on 'kind' to affect the type of 'payload'. To facilitate this, we use + // the arrow function AST node for '(kind, payload) => ...' as a pseudo-reference and narrow this reference as + // if it occurred in the specified location. We then recompute the narrowed parameter type by indexing into the + // narrowed tuple type. + if (ts.isParameter(declaration) && !declaration.type && !declaration.initializer && !declaration.dotDotDotToken) { + var func = declaration.parent; + if (func.parameters.length >= 2 && isContextSensitiveFunctionOrObjectLiteralMethod(func)) { + var contextualSignature = getContextualSignature(func); + if (contextualSignature && contextualSignature.parameters.length === 1 && signatureHasRestParameter(contextualSignature)) { + var restType = getReducedApparentType(getTypeOfSymbol(contextualSignature.parameters[0])); + if (restType.flags & 1048576 /* TypeFlags.Union */ && everyType(restType, isTupleType) && !isSymbolAssigned(symbol)) { + var narrowedType = getFlowTypeOfReference(func, restType, restType, /*flowContainer*/ undefined, location.flowNode); + var index = func.parameters.indexOf(declaration) - (ts.getThisParameter(func) ? 1 : 0); + return getIndexedAccessType(narrowedType, getNumberLiteralType(index)); + } + } + } + } + } + return getTypeOfSymbol(symbol); + } + function checkIdentifier(node, checkMode) { + if (ts.isThisInTypeQuery(node)) { + return checkThisExpression(node); + } + var symbol = getResolvedSymbol(node); + if (symbol === unknownSymbol) { + return errorType; + } + // As noted in ECMAScript 6 language spec, arrow functions never have an arguments objects. + // Although in down-level emit of arrow function, we emit it using function expression which means that + // arguments objects will be bound to the inner object; emitting arrow function natively in ES6, arguments objects + // will be bound to non-arrow function that contain this arrow function. This results in inconsistent behavior. + // To avoid that we will give an error to users if they use arguments objects in arrow function so that they + // can explicitly bound arguments objects + if (symbol === argumentsSymbol) { + if (isInPropertyInitializerOrClassStaticBlock(node)) { + error(node, ts.Diagnostics.arguments_cannot_be_referenced_in_property_initializers); + return errorType; + } + var container = ts.getContainingFunction(node); + if (languageVersion < 2 /* ScriptTarget.ES2015 */) { + if (container.kind === 216 /* SyntaxKind.ArrowFunction */) { + error(node, ts.Diagnostics.The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression); + } + else if (ts.hasSyntacticModifier(container, 512 /* ModifierFlags.Async */)) { + error(node, ts.Diagnostics.The_arguments_object_cannot_be_referenced_in_an_async_function_or_method_in_ES3_and_ES5_Consider_using_a_standard_function_or_method); + } + } + getNodeLinks(container).flags |= 8192 /* NodeCheckFlags.CaptureArguments */; + return getTypeOfSymbol(symbol); + } + if (shouldMarkIdentifierAliasReferenced(node)) { + markAliasReferenced(symbol, node); + } + var localOrExportSymbol = getExportSymbolOfValueSymbolIfExported(symbol); + var targetSymbol = checkDeprecatedAliasedSymbol(localOrExportSymbol, node); + if (isDeprecatedSymbol(targetSymbol) && isUncalledFunctionReference(node, targetSymbol) && targetSymbol.declarations) { + addDeprecatedSuggestion(node, targetSymbol.declarations, node.escapedText); + } + var declaration = localOrExportSymbol.valueDeclaration; + if (declaration && localOrExportSymbol.flags & 32 /* SymbolFlags.Class */) { + // Due to the emit for class decorators, any reference to the class from inside of the class body + // must instead be rewritten to point to a temporary variable to avoid issues with the double-bind + // behavior of class names in ES6. + if (declaration.kind === 260 /* SyntaxKind.ClassDeclaration */ + && ts.nodeIsDecorated(declaration)) { + var container = ts.getContainingClass(node); + while (container !== undefined) { + if (container === declaration && container.name !== node) { + getNodeLinks(declaration).flags |= 16777216 /* NodeCheckFlags.ClassWithConstructorReference */; + getNodeLinks(node).flags |= 33554432 /* NodeCheckFlags.ConstructorReferenceInClass */; + break; + } + container = ts.getContainingClass(container); + } + } + else if (declaration.kind === 228 /* SyntaxKind.ClassExpression */) { + // When we emit a class expression with static members that contain a reference + // to the constructor in the initializer, we will need to substitute that + // binding with an alias as the class name is not in scope. + var container = ts.getThisContainer(node, /*includeArrowFunctions*/ false); + while (container.kind !== 308 /* SyntaxKind.SourceFile */) { + if (container.parent === declaration) { + if (ts.isPropertyDeclaration(container) && ts.isStatic(container) || ts.isClassStaticBlockDeclaration(container)) { + getNodeLinks(declaration).flags |= 16777216 /* NodeCheckFlags.ClassWithConstructorReference */; + getNodeLinks(node).flags |= 33554432 /* NodeCheckFlags.ConstructorReferenceInClass */; + } + break; + } + container = ts.getThisContainer(container, /*includeArrowFunctions*/ false); + } + } + } + checkNestedBlockScopedBinding(node, symbol); + var type = getNarrowedTypeOfSymbol(localOrExportSymbol, node); + var assignmentKind = ts.getAssignmentTargetKind(node); + if (assignmentKind) { + if (!(localOrExportSymbol.flags & 3 /* SymbolFlags.Variable */) && + !(ts.isInJSFile(node) && localOrExportSymbol.flags & 512 /* SymbolFlags.ValueModule */)) { + var assignmentError = localOrExportSymbol.flags & 384 /* SymbolFlags.Enum */ ? ts.Diagnostics.Cannot_assign_to_0_because_it_is_an_enum + : localOrExportSymbol.flags & 32 /* SymbolFlags.Class */ ? ts.Diagnostics.Cannot_assign_to_0_because_it_is_a_class + : localOrExportSymbol.flags & 1536 /* SymbolFlags.Module */ ? ts.Diagnostics.Cannot_assign_to_0_because_it_is_a_namespace + : localOrExportSymbol.flags & 16 /* SymbolFlags.Function */ ? ts.Diagnostics.Cannot_assign_to_0_because_it_is_a_function + : localOrExportSymbol.flags & 2097152 /* SymbolFlags.Alias */ ? ts.Diagnostics.Cannot_assign_to_0_because_it_is_an_import + : ts.Diagnostics.Cannot_assign_to_0_because_it_is_not_a_variable; + error(node, assignmentError, symbolToString(symbol)); + return errorType; + } + if (isReadonlySymbol(localOrExportSymbol)) { + if (localOrExportSymbol.flags & 3 /* SymbolFlags.Variable */) { + error(node, ts.Diagnostics.Cannot_assign_to_0_because_it_is_a_constant, symbolToString(symbol)); + } + else { + error(node, ts.Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property, symbolToString(symbol)); + } + return errorType; + } + } + var isAlias = localOrExportSymbol.flags & 2097152 /* SymbolFlags.Alias */; + // We only narrow variables and parameters occurring in a non-assignment position. For all other + // entities we simply return the declared type. + if (localOrExportSymbol.flags & 3 /* SymbolFlags.Variable */) { + if (assignmentKind === 1 /* AssignmentKind.Definite */) { + return type; + } + } + else if (isAlias) { + declaration = getDeclarationOfAliasSymbol(symbol); + } + else { + return type; + } + if (!declaration) { + return type; + } + type = getNarrowableTypeForReference(type, node, checkMode); + // The declaration container is the innermost function that encloses the declaration of the variable + // or parameter. The flow container is the innermost function starting with which we analyze the control + // flow graph to determine the control flow based type. + var isParameter = ts.getRootDeclaration(declaration).kind === 166 /* SyntaxKind.Parameter */; + var declarationContainer = getControlFlowContainer(declaration); + var flowContainer = getControlFlowContainer(node); + var isOuterVariable = flowContainer !== declarationContainer; + var isSpreadDestructuringAssignmentTarget = node.parent && node.parent.parent && ts.isSpreadAssignment(node.parent) && isDestructuringAssignmentTarget(node.parent.parent); + var isModuleExports = symbol.flags & 134217728 /* SymbolFlags.ModuleExports */; + // When the control flow originates in a function expression or arrow function and we are referencing + // a const variable or parameter from an outer function, we extend the origin of the control flow + // analysis to include the immediately enclosing function. + while (flowContainer !== declarationContainer && (flowContainer.kind === 215 /* SyntaxKind.FunctionExpression */ || + flowContainer.kind === 216 /* SyntaxKind.ArrowFunction */ || ts.isObjectLiteralOrClassExpressionMethodOrAccessor(flowContainer)) && + (isConstVariable(localOrExportSymbol) && type !== autoArrayType || isParameter && !isSymbolAssigned(localOrExportSymbol))) { + flowContainer = getControlFlowContainer(flowContainer); + } + // We only look for uninitialized variables in strict null checking mode, and only when we can analyze + // the entire control flow graph from the variable's declaration (i.e. when the flow container and + // declaration container are the same). + var assumeInitialized = isParameter || isAlias || isOuterVariable || isSpreadDestructuringAssignmentTarget || isModuleExports || isSameScopedBindingElement(node, declaration) || + type !== autoType && type !== autoArrayType && (!strictNullChecks || (type.flags & (3 /* TypeFlags.AnyOrUnknown */ | 16384 /* TypeFlags.Void */)) !== 0 || + isInTypeQuery(node) || node.parent.kind === 278 /* SyntaxKind.ExportSpecifier */) || + node.parent.kind === 232 /* SyntaxKind.NonNullExpression */ || + declaration.kind === 257 /* SyntaxKind.VariableDeclaration */ && declaration.exclamationToken || + declaration.flags & 16777216 /* NodeFlags.Ambient */; + var initialType = assumeInitialized ? (isParameter ? removeOptionalityFromDeclaredType(type, declaration) : type) : + type === autoType || type === autoArrayType ? undefinedType : + getOptionalType(type); + var flowType = getFlowTypeOfReference(node, type, initialType, flowContainer); + // A variable is considered uninitialized when it is possible to analyze the entire control flow graph + // from declaration to use, and when the variable's declared type doesn't include undefined but the + // control flow based type does include undefined. + if (!isEvolvingArrayOperationTarget(node) && (type === autoType || type === autoArrayType)) { + if (flowType === autoType || flowType === autoArrayType) { + if (noImplicitAny) { + error(ts.getNameOfDeclaration(declaration), ts.Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined, symbolToString(symbol), typeToString(flowType)); + error(node, ts.Diagnostics.Variable_0_implicitly_has_an_1_type, symbolToString(symbol), typeToString(flowType)); + } + return convertAutoToAny(flowType); + } + } + else if (!assumeInitialized && !containsUndefinedType(type) && containsUndefinedType(flowType)) { + error(node, ts.Diagnostics.Variable_0_is_used_before_being_assigned, symbolToString(symbol)); + // Return the declared type to reduce follow-on errors + return type; + } + return assignmentKind ? getBaseTypeOfLiteralType(flowType) : flowType; + } + function isSameScopedBindingElement(node, declaration) { + if (ts.isBindingElement(declaration)) { + var bindingElement = ts.findAncestor(node, ts.isBindingElement); + return bindingElement && ts.getRootDeclaration(bindingElement) === ts.getRootDeclaration(declaration); + } + } + function shouldMarkIdentifierAliasReferenced(node) { + var _a; + var parent = node.parent; + if (parent) { + // A property access expression LHS? checkPropertyAccessExpression will handle that. + if (ts.isPropertyAccessExpression(parent) && parent.expression === node) { + return false; + } + // Next two check for an identifier inside a type only export. + if (ts.isExportSpecifier(parent) && parent.isTypeOnly) { + return false; + } + var greatGrandparent = (_a = parent.parent) === null || _a === void 0 ? void 0 : _a.parent; + if (greatGrandparent && ts.isExportDeclaration(greatGrandparent) && greatGrandparent.isTypeOnly) { + return false; + } + } + return true; + } + function isInsideFunctionOrInstancePropertyInitializer(node, threshold) { + return !!ts.findAncestor(node, function (n) { return n === threshold ? "quit" : ts.isFunctionLike(n) || (n.parent && ts.isPropertyDeclaration(n.parent) && !ts.hasStaticModifier(n.parent) && n.parent.initializer === n); }); + } + function getPartOfForStatementContainingNode(node, container) { + return ts.findAncestor(node, function (n) { return n === container ? "quit" : n === container.initializer || n === container.condition || n === container.incrementor || n === container.statement; }); + } + function getEnclosingIterationStatement(node) { + return ts.findAncestor(node, function (n) { return (!n || ts.nodeStartsNewLexicalEnvironment(n)) ? "quit" : ts.isIterationStatement(n, /*lookInLabeledStatements*/ false); }); + } + function checkNestedBlockScopedBinding(node, symbol) { + if (languageVersion >= 2 /* ScriptTarget.ES2015 */ || + (symbol.flags & (2 /* SymbolFlags.BlockScopedVariable */ | 32 /* SymbolFlags.Class */)) === 0 || + !symbol.valueDeclaration || + ts.isSourceFile(symbol.valueDeclaration) || + symbol.valueDeclaration.parent.kind === 295 /* SyntaxKind.CatchClause */) { + return; + } + // 1. walk from the use site up to the declaration and check + // if there is anything function like between declaration and use-site (is binding/class is captured in function). + // 2. walk from the declaration up to the boundary of lexical environment and check + // if there is an iteration statement in between declaration and boundary (is binding/class declared inside iteration statement) + var container = ts.getEnclosingBlockScopeContainer(symbol.valueDeclaration); + var isCaptured = isInsideFunctionOrInstancePropertyInitializer(node, container); + var enclosingIterationStatement = getEnclosingIterationStatement(container); + if (enclosingIterationStatement) { + if (isCaptured) { + // mark iteration statement as containing block-scoped binding captured in some function + var capturesBlockScopeBindingInLoopBody = true; + if (ts.isForStatement(container)) { + var varDeclList = ts.getAncestor(symbol.valueDeclaration, 258 /* SyntaxKind.VariableDeclarationList */); + if (varDeclList && varDeclList.parent === container) { + var part = getPartOfForStatementContainingNode(node.parent, container); + if (part) { + var links = getNodeLinks(part); + links.flags |= 131072 /* NodeCheckFlags.ContainsCapturedBlockScopeBinding */; + var capturedBindings = links.capturedBlockScopeBindings || (links.capturedBlockScopeBindings = []); + ts.pushIfUnique(capturedBindings, symbol); + if (part === container.initializer) { + capturesBlockScopeBindingInLoopBody = false; // Initializer is outside of loop body + } + } + } + } + if (capturesBlockScopeBindingInLoopBody) { + getNodeLinks(enclosingIterationStatement).flags |= 65536 /* NodeCheckFlags.LoopWithCapturedBlockScopedBinding */; + } + } + // mark variables that are declared in loop initializer and reassigned inside the body of ForStatement. + // if body of ForStatement will be converted to function then we'll need a extra machinery to propagate reassigned values back. + if (ts.isForStatement(container)) { + var varDeclList = ts.getAncestor(symbol.valueDeclaration, 258 /* SyntaxKind.VariableDeclarationList */); + if (varDeclList && varDeclList.parent === container && isAssignedInBodyOfForStatement(node, container)) { + getNodeLinks(symbol.valueDeclaration).flags |= 4194304 /* NodeCheckFlags.NeedsLoopOutParameter */; + } + } + // set 'declared inside loop' bit on the block-scoped binding + getNodeLinks(symbol.valueDeclaration).flags |= 524288 /* NodeCheckFlags.BlockScopedBindingInLoop */; + } + if (isCaptured) { + getNodeLinks(symbol.valueDeclaration).flags |= 262144 /* NodeCheckFlags.CapturedBlockScopedBinding */; + } + } + function isBindingCapturedByNode(node, decl) { + var links = getNodeLinks(node); + return !!links && ts.contains(links.capturedBlockScopeBindings, getSymbolOfNode(decl)); + } + function isAssignedInBodyOfForStatement(node, container) { + // skip parenthesized nodes + var current = node; + while (current.parent.kind === 214 /* SyntaxKind.ParenthesizedExpression */) { + current = current.parent; + } + // check if node is used as LHS in some assignment expression + var isAssigned = false; + if (ts.isAssignmentTarget(current)) { + isAssigned = true; + } + else if ((current.parent.kind === 221 /* SyntaxKind.PrefixUnaryExpression */ || current.parent.kind === 222 /* SyntaxKind.PostfixUnaryExpression */)) { + var expr = current.parent; + isAssigned = expr.operator === 45 /* SyntaxKind.PlusPlusToken */ || expr.operator === 46 /* SyntaxKind.MinusMinusToken */; + } + if (!isAssigned) { + return false; + } + // at this point we know that node is the target of assignment + // now check that modification happens inside the statement part of the ForStatement + return !!ts.findAncestor(current, function (n) { return n === container ? "quit" : n === container.statement; }); + } + function captureLexicalThis(node, container) { + getNodeLinks(node).flags |= 2 /* NodeCheckFlags.LexicalThis */; + if (container.kind === 169 /* SyntaxKind.PropertyDeclaration */ || container.kind === 173 /* SyntaxKind.Constructor */) { + var classNode = container.parent; + getNodeLinks(classNode).flags |= 4 /* NodeCheckFlags.CaptureThis */; + } + else { + getNodeLinks(container).flags |= 4 /* NodeCheckFlags.CaptureThis */; + } + } + function findFirstSuperCall(node) { + return ts.isSuperCall(node) ? node : + ts.isFunctionLike(node) ? undefined : + ts.forEachChild(node, findFirstSuperCall); + } + /** + * Check if the given class-declaration extends null then return true. + * Otherwise, return false + * @param classDecl a class declaration to check if it extends null + */ + function classDeclarationExtendsNull(classDecl) { + var classSymbol = getSymbolOfNode(classDecl); + var classInstanceType = getDeclaredTypeOfSymbol(classSymbol); + var baseConstructorType = getBaseConstructorTypeOfClass(classInstanceType); + return baseConstructorType === nullWideningType; + } + function checkThisBeforeSuper(node, container, diagnosticMessage) { + var containingClassDecl = container.parent; + var baseTypeNode = ts.getClassExtendsHeritageElement(containingClassDecl); + // If a containing class does not have extends clause or the class extends null + // skip checking whether super statement is called before "this" accessing. + if (baseTypeNode && !classDeclarationExtendsNull(containingClassDecl)) { + if (node.flowNode && !isPostSuperFlowNode(node.flowNode, /*noCacheCheck*/ false)) { + error(node, diagnosticMessage); + } + } + } + function checkThisInStaticClassFieldInitializerInDecoratedClass(thisExpression, container) { + if (ts.isPropertyDeclaration(container) && ts.hasStaticModifier(container) && + container.initializer && ts.textRangeContainsPositionInclusive(container.initializer, thisExpression.pos) && ts.hasDecorators(container.parent)) { + error(thisExpression, ts.Diagnostics.Cannot_use_this_in_a_static_property_initializer_of_a_decorated_class); + } + } + function checkThisExpression(node) { + var isNodeInTypeQuery = isInTypeQuery(node); + // Stop at the first arrow function so that we can + // tell whether 'this' needs to be captured. + var container = ts.getThisContainer(node, /* includeArrowFunctions */ true); + var capturedByArrowFunction = false; + if (container.kind === 173 /* SyntaxKind.Constructor */) { + checkThisBeforeSuper(node, container, ts.Diagnostics.super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class); + } + // Now skip arrow functions to get the "real" owner of 'this'. + if (container.kind === 216 /* SyntaxKind.ArrowFunction */) { + container = ts.getThisContainer(container, /* includeArrowFunctions */ false); + capturedByArrowFunction = true; + } + checkThisInStaticClassFieldInitializerInDecoratedClass(node, container); + switch (container.kind) { + case 264 /* SyntaxKind.ModuleDeclaration */: + error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_module_or_namespace_body); + // do not return here so in case if lexical this is captured - it will be reflected in flags on NodeLinks + break; + case 263 /* SyntaxKind.EnumDeclaration */: + error(node, ts.Diagnostics.this_cannot_be_referenced_in_current_location); + // do not return here so in case if lexical this is captured - it will be reflected in flags on NodeLinks + break; + case 173 /* SyntaxKind.Constructor */: + if (isInConstructorArgumentInitializer(node, container)) { + error(node, ts.Diagnostics.this_cannot_be_referenced_in_constructor_arguments); + // do not return here so in case if lexical this is captured - it will be reflected in flags on NodeLinks + } + break; + case 164 /* SyntaxKind.ComputedPropertyName */: + error(node, ts.Diagnostics.this_cannot_be_referenced_in_a_computed_property_name); + break; + } + // When targeting es6, mark that we'll need to capture `this` in its lexically bound scope. + if (!isNodeInTypeQuery && capturedByArrowFunction && languageVersion < 2 /* ScriptTarget.ES2015 */) { + captureLexicalThis(node, container); + } + var type = tryGetThisTypeAt(node, /*includeGlobalThis*/ true, container); + if (noImplicitThis) { + var globalThisType_1 = getTypeOfSymbol(globalThisSymbol); + if (type === globalThisType_1 && capturedByArrowFunction) { + error(node, ts.Diagnostics.The_containing_arrow_function_captures_the_global_value_of_this); + } + else if (!type) { + // With noImplicitThis, functions may not reference 'this' if it has type 'any' + var diag = error(node, ts.Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation); + if (!ts.isSourceFile(container)) { + var outsideThis = tryGetThisTypeAt(container); + if (outsideThis && outsideThis !== globalThisType_1) { + ts.addRelatedInfo(diag, ts.createDiagnosticForNode(container, ts.Diagnostics.An_outer_value_of_this_is_shadowed_by_this_container)); + } + } + } + } + return type || anyType; + } + function tryGetThisTypeAt(node, includeGlobalThis, container) { + if (includeGlobalThis === void 0) { includeGlobalThis = true; } + if (container === void 0) { container = ts.getThisContainer(node, /*includeArrowFunctions*/ false); } + var isInJS = ts.isInJSFile(node); + if (ts.isFunctionLike(container) && + (!isInParameterInitializerBeforeContainingFunction(node) || ts.getThisParameter(container))) { + var thisType = getThisTypeOfDeclaration(container) || isInJS && getTypeForThisExpressionFromJSDoc(container); + // Note: a parameter initializer should refer to class-this unless function-this is explicitly annotated. + // If this is a function in a JS file, it might be a class method. + if (!thisType) { + var className = getClassNameFromPrototypeMethod(container); + if (isInJS && className) { + var classSymbol = checkExpression(className).symbol; + if (classSymbol && classSymbol.members && (classSymbol.flags & 16 /* SymbolFlags.Function */)) { + thisType = getDeclaredTypeOfSymbol(classSymbol).thisType; + } + } + else if (isJSConstructor(container)) { + thisType = getDeclaredTypeOfSymbol(getMergedSymbol(container.symbol)).thisType; + } + thisType || (thisType = getContextualThisParameterType(container)); + } + if (thisType) { + return getFlowTypeOfReference(node, thisType); + } + } + if (ts.isClassLike(container.parent)) { + var symbol = getSymbolOfNode(container.parent); + var type = ts.isStatic(container) ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol).thisType; + return getFlowTypeOfReference(node, type); + } + if (ts.isSourceFile(container)) { + // look up in the source file's locals or exports + if (container.commonJsModuleIndicator) { + var fileSymbol = getSymbolOfNode(container); + return fileSymbol && getTypeOfSymbol(fileSymbol); + } + else if (container.externalModuleIndicator) { + // TODO: Maybe issue a better error than 'object is possibly undefined' + return undefinedType; + } + else if (includeGlobalThis) { + return getTypeOfSymbol(globalThisSymbol); + } + } + } + function getExplicitThisType(node) { + var container = ts.getThisContainer(node, /*includeArrowFunctions*/ false); + if (ts.isFunctionLike(container)) { + var signature = getSignatureFromDeclaration(container); + if (signature.thisParameter) { + return getExplicitTypeOfSymbol(signature.thisParameter); + } + } + if (ts.isClassLike(container.parent)) { + var symbol = getSymbolOfNode(container.parent); + return ts.isStatic(container) ? getTypeOfSymbol(symbol) : getDeclaredTypeOfSymbol(symbol).thisType; + } + } + function getClassNameFromPrototypeMethod(container) { + // Check if it's the RHS of a x.prototype.y = function [name]() { .... } + if (container.kind === 215 /* SyntaxKind.FunctionExpression */ && + ts.isBinaryExpression(container.parent) && + ts.getAssignmentDeclarationKind(container.parent) === 3 /* AssignmentDeclarationKind.PrototypeProperty */) { + // Get the 'x' of 'x.prototype.y = container' + return container.parent // x.prototype.y = container + .left // x.prototype.y + .expression // x.prototype + .expression; // x + } + // x.prototype = { method() { } } + else if (container.kind === 171 /* SyntaxKind.MethodDeclaration */ && + container.parent.kind === 207 /* SyntaxKind.ObjectLiteralExpression */ && + ts.isBinaryExpression(container.parent.parent) && + ts.getAssignmentDeclarationKind(container.parent.parent) === 6 /* AssignmentDeclarationKind.Prototype */) { + return container.parent.parent.left.expression; + } + // x.prototype = { method: function() { } } + else if (container.kind === 215 /* SyntaxKind.FunctionExpression */ && + container.parent.kind === 299 /* SyntaxKind.PropertyAssignment */ && + container.parent.parent.kind === 207 /* SyntaxKind.ObjectLiteralExpression */ && + ts.isBinaryExpression(container.parent.parent.parent) && + ts.getAssignmentDeclarationKind(container.parent.parent.parent) === 6 /* AssignmentDeclarationKind.Prototype */) { + return container.parent.parent.parent.left.expression; + } + // Object.defineProperty(x, "method", { value: function() { } }); + // Object.defineProperty(x, "method", { set: (x: () => void) => void }); + // Object.defineProperty(x, "method", { get: () => function() { }) }); + else if (container.kind === 215 /* SyntaxKind.FunctionExpression */ && + ts.isPropertyAssignment(container.parent) && + ts.isIdentifier(container.parent.name) && + (container.parent.name.escapedText === "value" || container.parent.name.escapedText === "get" || container.parent.name.escapedText === "set") && + ts.isObjectLiteralExpression(container.parent.parent) && + ts.isCallExpression(container.parent.parent.parent) && + container.parent.parent.parent.arguments[2] === container.parent.parent && + ts.getAssignmentDeclarationKind(container.parent.parent.parent) === 9 /* AssignmentDeclarationKind.ObjectDefinePrototypeProperty */) { + return container.parent.parent.parent.arguments[0].expression; + } + // Object.defineProperty(x, "method", { value() { } }); + // Object.defineProperty(x, "method", { set(x: () => void) {} }); + // Object.defineProperty(x, "method", { get() { return () => {} } }); + else if (ts.isMethodDeclaration(container) && + ts.isIdentifier(container.name) && + (container.name.escapedText === "value" || container.name.escapedText === "get" || container.name.escapedText === "set") && + ts.isObjectLiteralExpression(container.parent) && + ts.isCallExpression(container.parent.parent) && + container.parent.parent.arguments[2] === container.parent && + ts.getAssignmentDeclarationKind(container.parent.parent) === 9 /* AssignmentDeclarationKind.ObjectDefinePrototypeProperty */) { + return container.parent.parent.arguments[0].expression; + } + } + function getTypeForThisExpressionFromJSDoc(node) { + var jsdocType = ts.getJSDocType(node); + if (jsdocType && jsdocType.kind === 320 /* SyntaxKind.JSDocFunctionType */) { + var jsDocFunctionType = jsdocType; + if (jsDocFunctionType.parameters.length > 0 && + jsDocFunctionType.parameters[0].name && + jsDocFunctionType.parameters[0].name.escapedText === "this" /* InternalSymbolName.This */) { + return getTypeFromTypeNode(jsDocFunctionType.parameters[0].type); + } + } + var thisTag = ts.getJSDocThisTag(node); + if (thisTag && thisTag.typeExpression) { + return getTypeFromTypeNode(thisTag.typeExpression); + } + } + function isInConstructorArgumentInitializer(node, constructorDecl) { + return !!ts.findAncestor(node, function (n) { return ts.isFunctionLikeDeclaration(n) ? "quit" : n.kind === 166 /* SyntaxKind.Parameter */ && n.parent === constructorDecl; }); + } + function checkSuperExpression(node) { + var isCallExpression = node.parent.kind === 210 /* SyntaxKind.CallExpression */ && node.parent.expression === node; + var immediateContainer = ts.getSuperContainer(node, /*stopOnFunctions*/ true); + var container = immediateContainer; + var needToCaptureLexicalThis = false; + var inAsyncFunction = false; + // adjust the container reference in case if super is used inside arrow functions with arbitrarily deep nesting + if (!isCallExpression) { + while (container && container.kind === 216 /* SyntaxKind.ArrowFunction */) { + if (ts.hasSyntacticModifier(container, 512 /* ModifierFlags.Async */)) + inAsyncFunction = true; + container = ts.getSuperContainer(container, /*stopOnFunctions*/ true); + needToCaptureLexicalThis = languageVersion < 2 /* ScriptTarget.ES2015 */; + } + if (container && ts.hasSyntacticModifier(container, 512 /* ModifierFlags.Async */)) + inAsyncFunction = true; + } + var canUseSuperExpression = isLegalUsageOfSuperExpression(container); + var nodeCheckFlag = 0; + if (!canUseSuperExpression) { + // issue more specific error if super is used in computed property name + // class A { foo() { return "1" }} + // class B { + // [super.foo()]() {} + // } + var current = ts.findAncestor(node, function (n) { return n === container ? "quit" : n.kind === 164 /* SyntaxKind.ComputedPropertyName */; }); + if (current && current.kind === 164 /* SyntaxKind.ComputedPropertyName */) { + error(node, ts.Diagnostics.super_cannot_be_referenced_in_a_computed_property_name); + } + else if (isCallExpression) { + error(node, ts.Diagnostics.Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors); + } + else if (!container || !container.parent || !(ts.isClassLike(container.parent) || container.parent.kind === 207 /* SyntaxKind.ObjectLiteralExpression */)) { + error(node, ts.Diagnostics.super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions); + } + else { + error(node, ts.Diagnostics.super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class); + } + return errorType; + } + if (!isCallExpression && immediateContainer.kind === 173 /* SyntaxKind.Constructor */) { + checkThisBeforeSuper(node, container, ts.Diagnostics.super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class); + } + if (ts.isStatic(container) || isCallExpression) { + nodeCheckFlag = 512 /* NodeCheckFlags.SuperStatic */; + if (!isCallExpression && + languageVersion >= 2 /* ScriptTarget.ES2015 */ && languageVersion <= 8 /* ScriptTarget.ES2021 */ && + (ts.isPropertyDeclaration(container) || ts.isClassStaticBlockDeclaration(container))) { + // for `super.x` or `super[x]` in a static initializer, mark all enclosing + // block scope containers so that we can report potential collisions with + // `Reflect`. + ts.forEachEnclosingBlockScopeContainer(node.parent, function (current) { + if (!ts.isSourceFile(current) || ts.isExternalOrCommonJsModule(current)) { + getNodeLinks(current).flags |= 134217728 /* NodeCheckFlags.ContainsSuperPropertyInStaticInitializer */; + } + }); + } + } + else { + nodeCheckFlag = 256 /* NodeCheckFlags.SuperInstance */; + } + getNodeLinks(node).flags |= nodeCheckFlag; + // Due to how we emit async functions, we need to specialize the emit for an async method that contains a `super` reference. + // This is due to the fact that we emit the body of an async function inside of a generator function. As generator + // functions cannot reference `super`, we emit a helper inside of the method body, but outside of the generator. This helper + // uses an arrow function, which is permitted to reference `super`. + // + // There are two primary ways we can access `super` from within an async method. The first is getting the value of a property + // or indexed access on super, either as part of a right-hand-side expression or call expression. The second is when setting the value + // of a property or indexed access, either as part of an assignment expression or destructuring assignment. + // + // The simplest case is reading a value, in which case we will emit something like the following: + // + // // ts + // ... + // async asyncMethod() { + // let x = await super.asyncMethod(); + // return x; + // } + // ... + // + // // js + // ... + // asyncMethod() { + // const _super = Object.create(null, { + // asyncMethod: { get: () => super.asyncMethod }, + // }); + // return __awaiter(this, arguments, Promise, function *() { + // let x = yield _super.asyncMethod.call(this); + // return x; + // }); + // } + // ... + // + // The more complex case is when we wish to assign a value, especially as part of a destructuring assignment. As both cases + // are legal in ES6, but also likely less frequent, we only emit setters if there is an assignment: + // + // // ts + // ... + // async asyncMethod(ar: Promise) { + // [super.a, super.b] = await ar; + // } + // ... + // + // // js + // ... + // asyncMethod(ar) { + // const _super = Object.create(null, { + // a: { get: () => super.a, set: (v) => super.a = v }, + // b: { get: () => super.b, set: (v) => super.b = v } + // }; + // return __awaiter(this, arguments, Promise, function *() { + // [_super.a, _super.b] = yield ar; + // }); + // } + // ... + // + // Creating an object that has getter and setters instead of just an accessor function is required for destructuring assignments + // as a call expression cannot be used as the target of a destructuring assignment while a property access can. + // + // For element access expressions (`super[x]`), we emit a generic helper that forwards the element access in both situations. + if (container.kind === 171 /* SyntaxKind.MethodDeclaration */ && inAsyncFunction) { + if (ts.isSuperProperty(node.parent) && ts.isAssignmentTarget(node.parent)) { + getNodeLinks(container).flags |= 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */; + } + else { + getNodeLinks(container).flags |= 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */; + } + } + if (needToCaptureLexicalThis) { + // call expressions are allowed only in constructors so they should always capture correct 'this' + // super property access expressions can also appear in arrow functions - + // in this case they should also use correct lexical this + captureLexicalThis(node.parent, container); + } + if (container.parent.kind === 207 /* SyntaxKind.ObjectLiteralExpression */) { + if (languageVersion < 2 /* ScriptTarget.ES2015 */) { + error(node, ts.Diagnostics.super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_higher); + return errorType; + } + else { + // for object literal assume that type of 'super' is 'any' + return anyType; + } + } + // at this point the only legal case for parent is ClassLikeDeclaration + var classLikeDeclaration = container.parent; + if (!ts.getClassExtendsHeritageElement(classLikeDeclaration)) { + error(node, ts.Diagnostics.super_can_only_be_referenced_in_a_derived_class); + return errorType; + } + var classType = getDeclaredTypeOfSymbol(getSymbolOfNode(classLikeDeclaration)); + var baseClassType = classType && getBaseTypes(classType)[0]; + if (!baseClassType) { + return errorType; + } + if (container.kind === 173 /* SyntaxKind.Constructor */ && isInConstructorArgumentInitializer(node, container)) { + // issue custom error message for super property access in constructor arguments (to be aligned with old compiler) + error(node, ts.Diagnostics.super_cannot_be_referenced_in_constructor_arguments); + return errorType; + } + return nodeCheckFlag === 512 /* NodeCheckFlags.SuperStatic */ + ? getBaseConstructorTypeOfClass(classType) + : getTypeWithThisArgument(baseClassType, classType.thisType); + function isLegalUsageOfSuperExpression(container) { + if (!container) { + return false; + } + if (isCallExpression) { + // TS 1.0 SPEC (April 2014): 4.8.1 + // Super calls are only permitted in constructors of derived classes + return container.kind === 173 /* SyntaxKind.Constructor */; + } + else { + // TS 1.0 SPEC (April 2014) + // 'super' property access is allowed + // - In a constructor, instance member function, instance member accessor, or instance member variable initializer where this references a derived class instance + // - In a static member function or static member accessor + // topmost container must be something that is directly nested in the class declaration\object literal expression + if (ts.isClassLike(container.parent) || container.parent.kind === 207 /* SyntaxKind.ObjectLiteralExpression */) { + if (ts.isStatic(container)) { + return container.kind === 171 /* SyntaxKind.MethodDeclaration */ || + container.kind === 170 /* SyntaxKind.MethodSignature */ || + container.kind === 174 /* SyntaxKind.GetAccessor */ || + container.kind === 175 /* SyntaxKind.SetAccessor */ || + container.kind === 169 /* SyntaxKind.PropertyDeclaration */ || + container.kind === 172 /* SyntaxKind.ClassStaticBlockDeclaration */; + } + else { + return container.kind === 171 /* SyntaxKind.MethodDeclaration */ || + container.kind === 170 /* SyntaxKind.MethodSignature */ || + container.kind === 174 /* SyntaxKind.GetAccessor */ || + container.kind === 175 /* SyntaxKind.SetAccessor */ || + container.kind === 169 /* SyntaxKind.PropertyDeclaration */ || + container.kind === 168 /* SyntaxKind.PropertySignature */ || + container.kind === 173 /* SyntaxKind.Constructor */; + } + } + } + return false; + } + } + function getContainingObjectLiteral(func) { + return (func.kind === 171 /* SyntaxKind.MethodDeclaration */ || + func.kind === 174 /* SyntaxKind.GetAccessor */ || + func.kind === 175 /* SyntaxKind.SetAccessor */) && func.parent.kind === 207 /* SyntaxKind.ObjectLiteralExpression */ ? func.parent : + func.kind === 215 /* SyntaxKind.FunctionExpression */ && func.parent.kind === 299 /* SyntaxKind.PropertyAssignment */ ? func.parent.parent : + undefined; + } + function getThisTypeArgument(type) { + return ts.getObjectFlags(type) & 4 /* ObjectFlags.Reference */ && type.target === globalThisType ? getTypeArguments(type)[0] : undefined; + } + function getThisTypeFromContextualType(type) { + return mapType(type, function (t) { + return t.flags & 2097152 /* TypeFlags.Intersection */ ? ts.forEach(t.types, getThisTypeArgument) : getThisTypeArgument(t); + }); + } + function getContextualThisParameterType(func) { + if (func.kind === 216 /* SyntaxKind.ArrowFunction */) { + return undefined; + } + if (isContextSensitiveFunctionOrObjectLiteralMethod(func)) { + var contextualSignature = getContextualSignature(func); + if (contextualSignature) { + var thisParameter = contextualSignature.thisParameter; + if (thisParameter) { + return getTypeOfSymbol(thisParameter); + } + } + } + var inJs = ts.isInJSFile(func); + if (noImplicitThis || inJs) { + var containingLiteral = getContainingObjectLiteral(func); + if (containingLiteral) { + // We have an object literal method. Check if the containing object literal has a contextual type + // that includes a ThisType. If so, T is the contextual type for 'this'. We continue looking in + // any directly enclosing object literals. + var contextualType = getApparentTypeOfContextualType(containingLiteral, /*contextFlags*/ undefined); + var literal = containingLiteral; + var type = contextualType; + while (type) { + var thisType = getThisTypeFromContextualType(type); + if (thisType) { + return instantiateType(thisType, getMapperFromContext(getInferenceContext(containingLiteral))); + } + if (literal.parent.kind !== 299 /* SyntaxKind.PropertyAssignment */) { + break; + } + literal = literal.parent.parent; + type = getApparentTypeOfContextualType(literal, /*contextFlags*/ undefined); + } + // There was no contextual ThisType for the containing object literal, so the contextual type + // for 'this' is the non-null form of the contextual type for the containing object literal or + // the type of the object literal itself. + return getWidenedType(contextualType ? getNonNullableType(contextualType) : checkExpressionCached(containingLiteral)); + } + // In an assignment of the form 'obj.xxx = function(...)' or 'obj[xxx] = function(...)', the + // contextual type for 'this' is 'obj'. + var parent = ts.walkUpParenthesizedExpressions(func.parent); + if (parent.kind === 223 /* SyntaxKind.BinaryExpression */ && parent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */) { + var target = parent.left; + if (ts.isAccessExpression(target)) { + var expression = target.expression; + // Don't contextually type `this` as `exports` in `exports.Point = function(x, y) { this.x = x; this.y = y; }` + if (inJs && ts.isIdentifier(expression)) { + var sourceFile = ts.getSourceFileOfNode(parent); + if (sourceFile.commonJsModuleIndicator && getResolvedSymbol(expression) === sourceFile.symbol) { + return undefined; + } + } + return getWidenedType(checkExpressionCached(expression)); + } + } + } + return undefined; + } + // Return contextual type of parameter or undefined if no contextual type is available + function getContextuallyTypedParameterType(parameter) { + var func = parameter.parent; + if (!isContextSensitiveFunctionOrObjectLiteralMethod(func)) { + return undefined; + } + var iife = ts.getImmediatelyInvokedFunctionExpression(func); + if (iife && iife.arguments) { + var args = getEffectiveCallArguments(iife); + var indexOfParameter = func.parameters.indexOf(parameter); + if (parameter.dotDotDotToken) { + return getSpreadArgumentType(args, indexOfParameter, args.length, anyType, /*context*/ undefined, 0 /* CheckMode.Normal */); + } + var links = getNodeLinks(iife); + var cached = links.resolvedSignature; + links.resolvedSignature = anySignature; + var type = indexOfParameter < args.length ? + getWidenedLiteralType(checkExpression(args[indexOfParameter])) : + parameter.initializer ? undefined : undefinedWideningType; + links.resolvedSignature = cached; + return type; + } + var contextualSignature = getContextualSignature(func); + if (contextualSignature) { + var index = func.parameters.indexOf(parameter) - (ts.getThisParameter(func) ? 1 : 0); + return parameter.dotDotDotToken && ts.lastOrUndefined(func.parameters) === parameter ? + getRestTypeAtPosition(contextualSignature, index) : + tryGetTypeAtPosition(contextualSignature, index); + } + } + function getContextualTypeForVariableLikeDeclaration(declaration, contextFlags) { + var typeNode = ts.getEffectiveTypeAnnotationNode(declaration); + if (typeNode) { + return getTypeFromTypeNode(typeNode); + } + switch (declaration.kind) { + case 166 /* SyntaxKind.Parameter */: + return getContextuallyTypedParameterType(declaration); + case 205 /* SyntaxKind.BindingElement */: + return getContextualTypeForBindingElement(declaration, contextFlags); + case 169 /* SyntaxKind.PropertyDeclaration */: + if (ts.isStatic(declaration)) { + return getContextualTypeForStaticPropertyDeclaration(declaration, contextFlags); + } + // By default, do nothing and return undefined - only the above cases have context implied by a parent + } + } + function getContextualTypeForBindingElement(declaration, contextFlags) { + var parent = declaration.parent.parent; + var name = declaration.propertyName || declaration.name; + var parentType = getContextualTypeForVariableLikeDeclaration(parent, contextFlags) || + parent.kind !== 205 /* SyntaxKind.BindingElement */ && parent.initializer && checkDeclarationInitializer(parent, declaration.dotDotDotToken ? 64 /* CheckMode.RestBindingElement */ : 0 /* CheckMode.Normal */); + if (!parentType || ts.isBindingPattern(name) || ts.isComputedNonLiteralName(name)) + return undefined; + if (parent.name.kind === 204 /* SyntaxKind.ArrayBindingPattern */) { + var index = ts.indexOfNode(declaration.parent.elements, declaration); + if (index < 0) + return undefined; + return getContextualTypeForElementExpression(parentType, index); + } + var nameType = getLiteralTypeFromPropertyName(name); + if (isTypeUsableAsPropertyName(nameType)) { + var text = getPropertyNameFromType(nameType); + return getTypeOfPropertyOfType(parentType, text); + } + } + function getContextualTypeForStaticPropertyDeclaration(declaration, contextFlags) { + var parentType = ts.isExpression(declaration.parent) && getContextualType(declaration.parent, contextFlags); + if (!parentType) + return undefined; + return getTypeOfPropertyOfContextualType(parentType, getSymbolOfNode(declaration).escapedName); + } + // In a variable, parameter or property declaration with a type annotation, + // the contextual type of an initializer expression is the type of the variable, parameter or property. + // Otherwise, in a parameter declaration of a contextually typed function expression, + // the contextual type of an initializer expression is the contextual type of the parameter. + // Otherwise, in a variable or parameter declaration with a binding pattern name, + // the contextual type of an initializer expression is the type implied by the binding pattern. + // Otherwise, in a binding pattern inside a variable or parameter declaration, + // the contextual type of an initializer expression is the type annotation of the containing declaration, if present. + function getContextualTypeForInitializerExpression(node, contextFlags) { + var declaration = node.parent; + if (ts.hasInitializer(declaration) && node === declaration.initializer) { + var result = getContextualTypeForVariableLikeDeclaration(declaration, contextFlags); + if (result) { + return result; + } + if (!(contextFlags & 8 /* ContextFlags.SkipBindingPatterns */) && ts.isBindingPattern(declaration.name) && declaration.name.elements.length > 0) { + return getTypeFromBindingPattern(declaration.name, /*includePatternInType*/ true, /*reportErrors*/ false); + } + } + return undefined; + } + function getContextualTypeForReturnExpression(node, contextFlags) { + var func = ts.getContainingFunction(node); + if (func) { + var contextualReturnType = getContextualReturnType(func, contextFlags); + if (contextualReturnType) { + var functionFlags = ts.getFunctionFlags(func); + if (functionFlags & 1 /* FunctionFlags.Generator */) { // Generator or AsyncGenerator function + var isAsyncGenerator_1 = (functionFlags & 2 /* FunctionFlags.Async */) !== 0; + if (contextualReturnType.flags & 1048576 /* TypeFlags.Union */) { + contextualReturnType = filterType(contextualReturnType, function (type) { return !!getIterationTypeOfGeneratorFunctionReturnType(1 /* IterationTypeKind.Return */, type, isAsyncGenerator_1); }); + } + var iterationReturnType = getIterationTypeOfGeneratorFunctionReturnType(1 /* IterationTypeKind.Return */, contextualReturnType, (functionFlags & 2 /* FunctionFlags.Async */) !== 0); + if (!iterationReturnType) { + return undefined; + } + contextualReturnType = iterationReturnType; + // falls through to unwrap Promise for AsyncGenerators + } + if (functionFlags & 2 /* FunctionFlags.Async */) { // Async function or AsyncGenerator function + // Get the awaited type without the `Awaited` alias + var contextualAwaitedType = mapType(contextualReturnType, getAwaitedTypeNoAlias); + return contextualAwaitedType && getUnionType([contextualAwaitedType, createPromiseLikeType(contextualAwaitedType)]); + } + return contextualReturnType; // Regular function or Generator function + } + } + return undefined; + } + function getContextualTypeForAwaitOperand(node, contextFlags) { + var contextualType = getContextualType(node, contextFlags); + if (contextualType) { + var contextualAwaitedType = getAwaitedTypeNoAlias(contextualType); + return contextualAwaitedType && getUnionType([contextualAwaitedType, createPromiseLikeType(contextualAwaitedType)]); + } + return undefined; + } + function getContextualTypeForYieldOperand(node, contextFlags) { + var func = ts.getContainingFunction(node); + if (func) { + var functionFlags = ts.getFunctionFlags(func); + var contextualReturnType = getContextualReturnType(func, contextFlags); + if (contextualReturnType) { + var isAsyncGenerator_2 = (functionFlags & 2 /* FunctionFlags.Async */) !== 0; + if (!node.asteriskToken && contextualReturnType.flags & 1048576 /* TypeFlags.Union */) { + contextualReturnType = filterType(contextualReturnType, function (type) { return !!getIterationTypeOfGeneratorFunctionReturnType(1 /* IterationTypeKind.Return */, type, isAsyncGenerator_2); }); + } + return node.asteriskToken + ? contextualReturnType + : getIterationTypeOfGeneratorFunctionReturnType(0 /* IterationTypeKind.Yield */, contextualReturnType, isAsyncGenerator_2); + } + } + return undefined; + } + function isInParameterInitializerBeforeContainingFunction(node) { + var inBindingInitializer = false; + while (node.parent && !ts.isFunctionLike(node.parent)) { + if (ts.isParameter(node.parent) && (inBindingInitializer || node.parent.initializer === node)) { + return true; + } + if (ts.isBindingElement(node.parent) && node.parent.initializer === node) { + inBindingInitializer = true; + } + node = node.parent; + } + return false; + } + function getContextualIterationType(kind, functionDecl) { + var isAsync = !!(ts.getFunctionFlags(functionDecl) & 2 /* FunctionFlags.Async */); + var contextualReturnType = getContextualReturnType(functionDecl, /*contextFlags*/ undefined); + if (contextualReturnType) { + return getIterationTypeOfGeneratorFunctionReturnType(kind, contextualReturnType, isAsync) + || undefined; + } + return undefined; + } + function getContextualReturnType(functionDecl, contextFlags) { + // If the containing function has a return type annotation, is a constructor, or is a get accessor whose + // corresponding set accessor has a type annotation, return statements in the function are contextually typed + var returnType = getReturnTypeFromAnnotation(functionDecl); + if (returnType) { + return returnType; + } + // Otherwise, if the containing function is contextually typed by a function type with exactly one call signature + // and that call signature is non-generic, return statements are contextually typed by the return type of the signature + var signature = getContextualSignatureForFunctionLikeDeclaration(functionDecl); + if (signature && !isResolvingReturnTypeOfSignature(signature)) { + return getReturnTypeOfSignature(signature); + } + var iife = ts.getImmediatelyInvokedFunctionExpression(functionDecl); + if (iife) { + return getContextualType(iife, contextFlags); + } + return undefined; + } + // In a typed function call, an argument or substitution expression is contextually typed by the type of the corresponding parameter. + function getContextualTypeForArgument(callTarget, arg) { + var args = getEffectiveCallArguments(callTarget); + var argIndex = args.indexOf(arg); // -1 for e.g. the expression of a CallExpression, or the tag of a TaggedTemplateExpression + return argIndex === -1 ? undefined : getContextualTypeForArgumentAtIndex(callTarget, argIndex); + } + function getContextualTypeForArgumentAtIndex(callTarget, argIndex) { + if (ts.isImportCall(callTarget)) { + return argIndex === 0 ? stringType : + argIndex === 1 ? getGlobalImportCallOptionsType(/*reportErrors*/ false) : + anyType; + } + // If we're already in the process of resolving the given signature, don't resolve again as + // that could cause infinite recursion. Instead, return anySignature. + var signature = getNodeLinks(callTarget).resolvedSignature === resolvingSignature ? resolvingSignature : getResolvedSignature(callTarget); + if (ts.isJsxOpeningLikeElement(callTarget) && argIndex === 0) { + return getEffectiveFirstArgumentForJsxSignature(signature, callTarget); + } + var restIndex = signature.parameters.length - 1; + return signatureHasRestParameter(signature) && argIndex >= restIndex ? + getIndexedAccessType(getTypeOfSymbol(signature.parameters[restIndex]), getNumberLiteralType(argIndex - restIndex), 256 /* AccessFlags.Contextual */) : + getTypeAtPosition(signature, argIndex); + } + function getContextualTypeForSubstitutionExpression(template, substitutionExpression) { + if (template.parent.kind === 212 /* SyntaxKind.TaggedTemplateExpression */) { + return getContextualTypeForArgument(template.parent, substitutionExpression); + } + return undefined; + } + function getContextualTypeForBinaryOperand(node, contextFlags) { + var binaryExpression = node.parent; + var left = binaryExpression.left, operatorToken = binaryExpression.operatorToken, right = binaryExpression.right; + switch (operatorToken.kind) { + case 63 /* SyntaxKind.EqualsToken */: + case 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */: + case 75 /* SyntaxKind.BarBarEqualsToken */: + case 77 /* SyntaxKind.QuestionQuestionEqualsToken */: + return node === right ? getContextualTypeForAssignmentDeclaration(binaryExpression) : undefined; + case 56 /* SyntaxKind.BarBarToken */: + case 60 /* SyntaxKind.QuestionQuestionToken */: + // When an || expression has a contextual type, the operands are contextually typed by that type, except + // when that type originates in a binding pattern, the right operand is contextually typed by the type of + // the left operand. When an || expression has no contextual type, the right operand is contextually typed + // by the type of the left operand, except for the special case of Javascript declarations of the form + // `namespace.prop = namespace.prop || {}`. + var type = getContextualType(binaryExpression, contextFlags); + return node === right && (type && type.pattern || !type && !ts.isDefaultedExpandoInitializer(binaryExpression)) ? + getTypeOfExpression(left) : type; + case 55 /* SyntaxKind.AmpersandAmpersandToken */: + case 27 /* SyntaxKind.CommaToken */: + return node === right ? getContextualType(binaryExpression, contextFlags) : undefined; + default: + return undefined; + } + } + /** + * Try to find a resolved symbol for an expression without also resolving its type, as + * getSymbolAtLocation would (as that could be reentrant into contextual typing) + */ + function getSymbolForExpression(e) { + if (e.symbol) { + return e.symbol; + } + if (ts.isIdentifier(e)) { + return getResolvedSymbol(e); + } + if (ts.isPropertyAccessExpression(e)) { + var lhsType = getTypeOfExpression(e.expression); + return ts.isPrivateIdentifier(e.name) ? tryGetPrivateIdentifierPropertyOfType(lhsType, e.name) : getPropertyOfType(lhsType, e.name.escapedText); + } + if (ts.isElementAccessExpression(e)) { + var propType = checkExpressionCached(e.argumentExpression); + if (!isTypeUsableAsPropertyName(propType)) { + return undefined; + } + var lhsType = getTypeOfExpression(e.expression); + return getPropertyOfType(lhsType, getPropertyNameFromType(propType)); + } + return undefined; + function tryGetPrivateIdentifierPropertyOfType(type, id) { + var lexicallyScopedSymbol = lookupSymbolForPrivateIdentifierDeclaration(id.escapedText, id); + return lexicallyScopedSymbol && getPrivateIdentifierPropertyOfType(type, lexicallyScopedSymbol); + } + } + // In an assignment expression, the right operand is contextually typed by the type of the left operand. + // Don't do this for assignment declarations unless there is a type tag on the assignment, to avoid circularity from checking the right operand. + function getContextualTypeForAssignmentDeclaration(binaryExpression) { + var _a, _b; + var kind = ts.getAssignmentDeclarationKind(binaryExpression); + switch (kind) { + case 0 /* AssignmentDeclarationKind.None */: + case 4 /* AssignmentDeclarationKind.ThisProperty */: + var lhsSymbol = getSymbolForExpression(binaryExpression.left); + var decl = lhsSymbol && lhsSymbol.valueDeclaration; + // Unannotated, uninitialized property declarations have a type implied by their usage in the constructor. + // We avoid calling back into `getTypeOfExpression` and reentering contextual typing to avoid a bogus circularity error in that case. + if (decl && (ts.isPropertyDeclaration(decl) || ts.isPropertySignature(decl))) { + var overallAnnotation = ts.getEffectiveTypeAnnotationNode(decl); + return (overallAnnotation && instantiateType(getTypeFromTypeNode(overallAnnotation), getSymbolLinks(lhsSymbol).mapper)) || + (ts.isPropertyDeclaration(decl) ? decl.initializer && getTypeOfExpression(binaryExpression.left) : undefined); + } + if (kind === 0 /* AssignmentDeclarationKind.None */) { + return getTypeOfExpression(binaryExpression.left); + } + return getContextualTypeForThisPropertyAssignment(binaryExpression); + case 5 /* AssignmentDeclarationKind.Property */: + if (isPossiblyAliasedThisProperty(binaryExpression, kind)) { + return getContextualTypeForThisPropertyAssignment(binaryExpression); + } + // If `binaryExpression.left` was assigned a symbol, then this is a new declaration; otherwise it is an assignment to an existing declaration. + // See `bindStaticPropertyAssignment` in `binder.ts`. + else if (!binaryExpression.left.symbol) { + return getTypeOfExpression(binaryExpression.left); + } + else { + var decl_1 = binaryExpression.left.symbol.valueDeclaration; + if (!decl_1) { + return undefined; + } + var lhs = ts.cast(binaryExpression.left, ts.isAccessExpression); + var overallAnnotation = ts.getEffectiveTypeAnnotationNode(decl_1); + if (overallAnnotation) { + return getTypeFromTypeNode(overallAnnotation); + } + else if (ts.isIdentifier(lhs.expression)) { + var id = lhs.expression; + var parentSymbol = resolveName(id, id.escapedText, 111551 /* SymbolFlags.Value */, undefined, id.escapedText, /*isUse*/ true); + if (parentSymbol) { + var annotated_1 = parentSymbol.valueDeclaration && ts.getEffectiveTypeAnnotationNode(parentSymbol.valueDeclaration); + if (annotated_1) { + var nameStr = ts.getElementOrPropertyAccessName(lhs); + if (nameStr !== undefined) { + return getTypeOfPropertyOfContextualType(getTypeFromTypeNode(annotated_1), nameStr); + } + } + return undefined; + } + } + return ts.isInJSFile(decl_1) ? undefined : getTypeOfExpression(binaryExpression.left); + } + case 1 /* AssignmentDeclarationKind.ExportsProperty */: + case 6 /* AssignmentDeclarationKind.Prototype */: + case 3 /* AssignmentDeclarationKind.PrototypeProperty */: + case 2 /* AssignmentDeclarationKind.ModuleExports */: + var valueDeclaration = void 0; + if (kind !== 2 /* AssignmentDeclarationKind.ModuleExports */) { + valueDeclaration = (_a = binaryExpression.left.symbol) === null || _a === void 0 ? void 0 : _a.valueDeclaration; + } + valueDeclaration || (valueDeclaration = (_b = binaryExpression.symbol) === null || _b === void 0 ? void 0 : _b.valueDeclaration); + var annotated = valueDeclaration && ts.getEffectiveTypeAnnotationNode(valueDeclaration); + return annotated ? getTypeFromTypeNode(annotated) : undefined; + case 7 /* AssignmentDeclarationKind.ObjectDefinePropertyValue */: + case 8 /* AssignmentDeclarationKind.ObjectDefinePropertyExports */: + case 9 /* AssignmentDeclarationKind.ObjectDefinePrototypeProperty */: + return ts.Debug.fail("Does not apply"); + default: + return ts.Debug.assertNever(kind); + } + } + function isPossiblyAliasedThisProperty(declaration, kind) { + if (kind === void 0) { kind = ts.getAssignmentDeclarationKind(declaration); } + if (kind === 4 /* AssignmentDeclarationKind.ThisProperty */) { + return true; + } + if (!ts.isInJSFile(declaration) || kind !== 5 /* AssignmentDeclarationKind.Property */ || !ts.isIdentifier(declaration.left.expression)) { + return false; + } + var name = declaration.left.expression.escapedText; + var symbol = resolveName(declaration.left, name, 111551 /* SymbolFlags.Value */, undefined, undefined, /*isUse*/ true, /*excludeGlobals*/ true); + return ts.isThisInitializedDeclaration(symbol === null || symbol === void 0 ? void 0 : symbol.valueDeclaration); + } + function getContextualTypeForThisPropertyAssignment(binaryExpression) { + if (!binaryExpression.symbol) + return getTypeOfExpression(binaryExpression.left); + if (binaryExpression.symbol.valueDeclaration) { + var annotated = ts.getEffectiveTypeAnnotationNode(binaryExpression.symbol.valueDeclaration); + if (annotated) { + var type = getTypeFromTypeNode(annotated); + if (type) { + return type; + } + } + } + var thisAccess = ts.cast(binaryExpression.left, ts.isAccessExpression); + if (!ts.isObjectLiteralMethod(ts.getThisContainer(thisAccess.expression, /*includeArrowFunctions*/ false))) { + return undefined; + } + var thisType = checkThisExpression(thisAccess.expression); + var nameStr = ts.getElementOrPropertyAccessName(thisAccess); + return nameStr !== undefined && getTypeOfPropertyOfContextualType(thisType, nameStr) || undefined; + } + function isCircularMappedProperty(symbol) { + return !!(ts.getCheckFlags(symbol) & 262144 /* CheckFlags.Mapped */ && !symbol.type && findResolutionCycleStartIndex(symbol, 0 /* TypeSystemPropertyName.Type */) >= 0); + } + function getTypeOfPropertyOfContextualType(type, name, nameType) { + return mapType(type, function (t) { + var _a; + if (isGenericMappedType(t) && !t.declaration.nameType) { + var constraint = getConstraintTypeFromMappedType(t); + var constraintOfConstraint = getBaseConstraintOfType(constraint) || constraint; + var propertyNameType = nameType || getStringLiteralType(ts.unescapeLeadingUnderscores(name)); + if (isTypeAssignableTo(propertyNameType, constraintOfConstraint)) { + return substituteIndexedMappedType(t, propertyNameType); + } + } + else if (t.flags & 3670016 /* TypeFlags.StructuredType */) { + var prop = getPropertyOfType(t, name); + if (prop) { + return isCircularMappedProperty(prop) ? undefined : getTypeOfSymbol(prop); + } + if (isTupleType(t)) { + var restType = getRestTypeOfTupleType(t); + if (restType && ts.isNumericLiteralName(name) && +name >= 0) { + return restType; + } + } + return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType || getStringLiteralType(ts.unescapeLeadingUnderscores(name)))) === null || _a === void 0 ? void 0 : _a.type; + } + return undefined; + }, /*noReductions*/ true); + } + // In an object literal contextually typed by a type T, the contextual type of a property assignment is the type of + // the matching property in T, if one exists. Otherwise, it is the type of the numeric index signature in T, if one + // exists. Otherwise, it is the type of the string index signature in T, if one exists. + function getContextualTypeForObjectLiteralMethod(node, contextFlags) { + ts.Debug.assert(ts.isObjectLiteralMethod(node)); + if (node.flags & 33554432 /* NodeFlags.InWithStatement */) { + // We cannot answer semantic questions within a with block, do not proceed any further + return undefined; + } + return getContextualTypeForObjectLiteralElement(node, contextFlags); + } + function getContextualTypeForObjectLiteralElement(element, contextFlags) { + var objectLiteral = element.parent; + var propertyAssignmentType = ts.isPropertyAssignment(element) && getContextualTypeForVariableLikeDeclaration(element, contextFlags); + if (propertyAssignmentType) { + return propertyAssignmentType; + } + var type = getApparentTypeOfContextualType(objectLiteral, contextFlags); + if (type) { + if (hasBindableName(element)) { + // For a (non-symbol) computed property, there is no reason to look up the name + // in the type. It will just be "__computed", which does not appear in any + // SymbolTable. + var symbol = getSymbolOfNode(element); + return getTypeOfPropertyOfContextualType(type, symbol.escapedName, getSymbolLinks(symbol).nameType); + } + if (element.name) { + var nameType_2 = getLiteralTypeFromPropertyName(element.name); + // We avoid calling getApplicableIndexInfo here because it performs potentially expensive intersection reduction. + return mapType(type, function (t) { var _a; return (_a = findApplicableIndexInfo(getIndexInfosOfStructuredType(t), nameType_2)) === null || _a === void 0 ? void 0 : _a.type; }, /*noReductions*/ true); + } + } + return undefined; + } + // In an array literal contextually typed by a type T, the contextual type of an element expression at index N is + // the type of the property with the numeric name N in T, if one exists. Otherwise, if T has a numeric index signature, + // it is the type of the numeric index signature in T. Otherwise, in ES6 and higher, the contextual type is the iterated + // type of T. + function getContextualTypeForElementExpression(arrayContextualType, index) { + return arrayContextualType && (getTypeOfPropertyOfContextualType(arrayContextualType, "" + index) + || mapType(arrayContextualType, function (t) { return getIteratedTypeOrElementType(1 /* IterationUse.Element */, t, undefinedType, /*errorNode*/ undefined, /*checkAssignability*/ false); }, + /*noReductions*/ true)); + } + // In a contextually typed conditional expression, the true/false expressions are contextually typed by the same type. + function getContextualTypeForConditionalOperand(node, contextFlags) { + var conditional = node.parent; + return node === conditional.whenTrue || node === conditional.whenFalse ? getContextualType(conditional, contextFlags) : undefined; + } + function getContextualTypeForChildJsxExpression(node, child, contextFlags) { + var attributesType = getApparentTypeOfContextualType(node.openingElement.tagName, contextFlags); + // JSX expression is in children of JSX Element, we will look for an "children" attribute (we get the name from JSX.ElementAttributesProperty) + var jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(node)); + if (!(attributesType && !isTypeAny(attributesType) && jsxChildrenPropertyName && jsxChildrenPropertyName !== "")) { + return undefined; + } + var realChildren = ts.getSemanticJsxChildren(node.children); + var childIndex = realChildren.indexOf(child); + var childFieldType = getTypeOfPropertyOfContextualType(attributesType, jsxChildrenPropertyName); + return childFieldType && (realChildren.length === 1 ? childFieldType : mapType(childFieldType, function (t) { + if (isArrayLikeType(t)) { + return getIndexedAccessType(t, getNumberLiteralType(childIndex)); + } + else { + return t; + } + }, /*noReductions*/ true)); + } + function getContextualTypeForJsxExpression(node, contextFlags) { + var exprParent = node.parent; + return ts.isJsxAttributeLike(exprParent) + ? getContextualType(node, contextFlags) + : ts.isJsxElement(exprParent) + ? getContextualTypeForChildJsxExpression(exprParent, node, contextFlags) + : undefined; + } + function getContextualTypeForJsxAttribute(attribute, contextFlags) { + // When we trying to resolve JsxOpeningLikeElement as a stateless function element, we will already give its attributes a contextual type + // which is a type of the parameter of the signature we are trying out. + // If there is no contextual type (e.g. we are trying to resolve stateful component), get attributes type from resolving element's tagName + if (ts.isJsxAttribute(attribute)) { + var attributesType = getApparentTypeOfContextualType(attribute.parent, contextFlags); + if (!attributesType || isTypeAny(attributesType)) { + return undefined; + } + return getTypeOfPropertyOfContextualType(attributesType, attribute.name.escapedText); + } + else { + return getContextualType(attribute.parent, contextFlags); + } + } + // Return true if the given expression is possibly a discriminant value. We limit the kinds of + // expressions we check to those that don't depend on their contextual type in order not to cause + // recursive (and possibly infinite) invocations of getContextualType. + function isPossiblyDiscriminantValue(node) { + switch (node.kind) { + case 10 /* SyntaxKind.StringLiteral */: + case 8 /* SyntaxKind.NumericLiteral */: + case 9 /* SyntaxKind.BigIntLiteral */: + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + case 110 /* SyntaxKind.TrueKeyword */: + case 95 /* SyntaxKind.FalseKeyword */: + case 104 /* SyntaxKind.NullKeyword */: + case 79 /* SyntaxKind.Identifier */: + case 155 /* SyntaxKind.UndefinedKeyword */: + return true; + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 214 /* SyntaxKind.ParenthesizedExpression */: + return isPossiblyDiscriminantValue(node.expression); + case 291 /* SyntaxKind.JsxExpression */: + return !node.expression || isPossiblyDiscriminantValue(node.expression); + } + return false; + } + function discriminateContextualTypeByObjectMembers(node, contextualType) { + return getMatchingUnionConstituentForObjectLiteral(contextualType, node) || discriminateTypeByDiscriminableItems(contextualType, ts.concatenate(ts.map(ts.filter(node.properties, function (p) { return !!p.symbol && p.kind === 299 /* SyntaxKind.PropertyAssignment */ && isPossiblyDiscriminantValue(p.initializer) && isDiscriminantProperty(contextualType, p.symbol.escapedName); }), function (prop) { return [function () { return getContextFreeTypeOfExpression(prop.initializer); }, prop.symbol.escapedName]; }), ts.map(ts.filter(getPropertiesOfType(contextualType), function (s) { var _a; return !!(s.flags & 16777216 /* SymbolFlags.Optional */) && !!((_a = node === null || node === void 0 ? void 0 : node.symbol) === null || _a === void 0 ? void 0 : _a.members) && !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName); }), function (s) { return [function () { return undefinedType; }, s.escapedName]; })), isTypeAssignableTo, contextualType); + } + function discriminateContextualTypeByJSXAttributes(node, contextualType) { + return discriminateTypeByDiscriminableItems(contextualType, ts.concatenate(ts.map(ts.filter(node.properties, function (p) { return !!p.symbol && p.kind === 288 /* SyntaxKind.JsxAttribute */ && isDiscriminantProperty(contextualType, p.symbol.escapedName) && (!p.initializer || isPossiblyDiscriminantValue(p.initializer)); }), function (prop) { return [!prop.initializer ? (function () { return trueType; }) : (function () { return getContextFreeTypeOfExpression(prop.initializer); }), prop.symbol.escapedName]; }), ts.map(ts.filter(getPropertiesOfType(contextualType), function (s) { var _a; return !!(s.flags & 16777216 /* SymbolFlags.Optional */) && !!((_a = node === null || node === void 0 ? void 0 : node.symbol) === null || _a === void 0 ? void 0 : _a.members) && !node.symbol.members.has(s.escapedName) && isDiscriminantProperty(contextualType, s.escapedName); }), function (s) { return [function () { return undefinedType; }, s.escapedName]; })), isTypeAssignableTo, contextualType); + } + // Return the contextual type for a given expression node. During overload resolution, a contextual type may temporarily + // be "pushed" onto a node using the contextualType property. + function getApparentTypeOfContextualType(node, contextFlags) { + var contextualType = ts.isObjectLiteralMethod(node) ? + getContextualTypeForObjectLiteralMethod(node, contextFlags) : + getContextualType(node, contextFlags); + var instantiatedType = instantiateContextualType(contextualType, node, contextFlags); + if (instantiatedType && !(contextFlags && contextFlags & 2 /* ContextFlags.NoConstraints */ && instantiatedType.flags & 8650752 /* TypeFlags.TypeVariable */)) { + var apparentType = mapType(instantiatedType, getApparentType, /*noReductions*/ true); + return apparentType.flags & 1048576 /* TypeFlags.Union */ && ts.isObjectLiteralExpression(node) ? discriminateContextualTypeByObjectMembers(node, apparentType) : + apparentType.flags & 1048576 /* TypeFlags.Union */ && ts.isJsxAttributes(node) ? discriminateContextualTypeByJSXAttributes(node, apparentType) : + apparentType; + } + } + // If the given contextual type contains instantiable types and if a mapper representing + // return type inferences is available, instantiate those types using that mapper. + function instantiateContextualType(contextualType, node, contextFlags) { + if (contextualType && maybeTypeOfKind(contextualType, 465829888 /* TypeFlags.Instantiable */)) { + var inferenceContext = getInferenceContext(node); + // If no inferences have been made, and none of the type parameters for which we are inferring + // specify default types, nothing is gained from instantiating as type parameters would just be + // replaced with their constraints similar to the apparent type. + if (inferenceContext && contextFlags & 1 /* ContextFlags.Signature */ && ts.some(inferenceContext.inferences, hasInferenceCandidatesOrDefault)) { + // For contextual signatures we incorporate all inferences made so far, e.g. from return + // types as well as arguments to the left in a function call. + return instantiateInstantiableTypes(contextualType, inferenceContext.nonFixingMapper); + } + if (inferenceContext === null || inferenceContext === void 0 ? void 0 : inferenceContext.returnMapper) { + // For other purposes (e.g. determining whether to produce literal types) we only + // incorporate inferences made from the return type in a function call. We remove + // the 'boolean' type from the contextual type such that contextually typed boolean + // literals actually end up widening to 'boolean' (see #48363). + var type = instantiateInstantiableTypes(contextualType, inferenceContext.returnMapper); + return type.flags & 1048576 /* TypeFlags.Union */ && containsType(type.types, regularFalseType) && containsType(type.types, regularTrueType) ? + filterType(type, function (t) { return t !== regularFalseType && t !== regularTrueType; }) : + type; + } + } + return contextualType; + } + // This function is similar to instantiateType, except that (a) it only instantiates types that + // are classified as instantiable (i.e. it doesn't instantiate object types), and (b) it performs + // no reductions on instantiated union types. + function instantiateInstantiableTypes(type, mapper) { + if (type.flags & 465829888 /* TypeFlags.Instantiable */) { + return instantiateType(type, mapper); + } + if (type.flags & 1048576 /* TypeFlags.Union */) { + return getUnionType(ts.map(type.types, function (t) { return instantiateInstantiableTypes(t, mapper); }), 0 /* UnionReduction.None */); + } + if (type.flags & 2097152 /* TypeFlags.Intersection */) { + return getIntersectionType(ts.map(type.types, function (t) { return instantiateInstantiableTypes(t, mapper); })); + } + return type; + } + /** + * Whoa! Do you really want to use this function? + * + * Unless you're trying to get the *non-apparent* type for a + * value-literal type or you're authoring relevant portions of this algorithm, + * you probably meant to use 'getApparentTypeOfContextualType'. + * Otherwise this may not be very useful. + * + * In cases where you *are* working on this function, you should understand + * when it is appropriate to use 'getContextualType' and 'getApparentTypeOfContextualType'. + * + * - Use 'getContextualType' when you are simply going to propagate the result to the expression. + * - Use 'getApparentTypeOfContextualType' when you're going to need the members of the type. + * + * @param node the expression whose contextual type will be returned. + * @returns the contextual type of an expression. + */ + function getContextualType(node, contextFlags) { + if (node.flags & 33554432 /* NodeFlags.InWithStatement */) { + // We cannot answer semantic questions within a with block, do not proceed any further + return undefined; + } + if (node.contextualType) { + return node.contextualType; + } + var parent = node.parent; + switch (parent.kind) { + case 257 /* SyntaxKind.VariableDeclaration */: + case 166 /* SyntaxKind.Parameter */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 168 /* SyntaxKind.PropertySignature */: + case 205 /* SyntaxKind.BindingElement */: + return getContextualTypeForInitializerExpression(node, contextFlags); + case 216 /* SyntaxKind.ArrowFunction */: + case 250 /* SyntaxKind.ReturnStatement */: + return getContextualTypeForReturnExpression(node, contextFlags); + case 226 /* SyntaxKind.YieldExpression */: + return getContextualTypeForYieldOperand(parent, contextFlags); + case 220 /* SyntaxKind.AwaitExpression */: + return getContextualTypeForAwaitOperand(parent, contextFlags); + case 210 /* SyntaxKind.CallExpression */: + case 211 /* SyntaxKind.NewExpression */: + return getContextualTypeForArgument(parent, node); + case 213 /* SyntaxKind.TypeAssertionExpression */: + case 231 /* SyntaxKind.AsExpression */: + return ts.isConstTypeReference(parent.type) ? tryFindWhenConstTypeReference(parent) : getTypeFromTypeNode(parent.type); + case 223 /* SyntaxKind.BinaryExpression */: + return getContextualTypeForBinaryOperand(node, contextFlags); + case 299 /* SyntaxKind.PropertyAssignment */: + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + return getContextualTypeForObjectLiteralElement(parent, contextFlags); + case 301 /* SyntaxKind.SpreadAssignment */: + return getContextualType(parent.parent, contextFlags); + case 206 /* SyntaxKind.ArrayLiteralExpression */: { + var arrayLiteral = parent; + var type = getApparentTypeOfContextualType(arrayLiteral, contextFlags); + return getContextualTypeForElementExpression(type, ts.indexOfNode(arrayLiteral.elements, node)); + } + case 224 /* SyntaxKind.ConditionalExpression */: + return getContextualTypeForConditionalOperand(node, contextFlags); + case 236 /* SyntaxKind.TemplateSpan */: + ts.Debug.assert(parent.parent.kind === 225 /* SyntaxKind.TemplateExpression */); + return getContextualTypeForSubstitutionExpression(parent.parent, node); + case 214 /* SyntaxKind.ParenthesizedExpression */: { + // Like in `checkParenthesizedExpression`, an `/** @type {xyz} */` comment before a parenthesized expression acts as a type cast. + var tag = ts.isInJSFile(parent) ? ts.getJSDocTypeTag(parent) : undefined; + return !tag ? getContextualType(parent, contextFlags) : + ts.isJSDocTypeTag(tag) && ts.isConstTypeReference(tag.typeExpression.type) ? tryFindWhenConstTypeReference(parent) : + getTypeFromTypeNode(tag.typeExpression.type); + } + case 232 /* SyntaxKind.NonNullExpression */: + return getContextualType(parent, contextFlags); + case 235 /* SyntaxKind.SatisfiesExpression */: + return getTypeFromTypeNode(parent.type); + case 274 /* SyntaxKind.ExportAssignment */: + return tryGetTypeFromEffectiveTypeNode(parent); + case 291 /* SyntaxKind.JsxExpression */: + return getContextualTypeForJsxExpression(parent, contextFlags); + case 288 /* SyntaxKind.JsxAttribute */: + case 290 /* SyntaxKind.JsxSpreadAttribute */: + return getContextualTypeForJsxAttribute(parent, contextFlags); + case 283 /* SyntaxKind.JsxOpeningElement */: + case 282 /* SyntaxKind.JsxSelfClosingElement */: + return getContextualJsxElementAttributesType(parent, contextFlags); + } + return undefined; + function tryFindWhenConstTypeReference(node) { + return getContextualType(node, contextFlags); + } + } + function getInferenceContext(node) { + var ancestor = ts.findAncestor(node, function (n) { return !!n.inferenceContext; }); + return ancestor && ancestor.inferenceContext; + } + function getContextualJsxElementAttributesType(node, contextFlags) { + if (ts.isJsxOpeningElement(node) && node.parent.contextualType && contextFlags !== 4 /* ContextFlags.Completions */) { + // Contextually applied type is moved from attributes up to the outer jsx attributes so when walking up from the children they get hit + // _However_ to hit them from the _attributes_ we must look for them here; otherwise we'll used the declared type + // (as below) instead! + return node.parent.contextualType; + } + return getContextualTypeForArgumentAtIndex(node, 0); + } + function getEffectiveFirstArgumentForJsxSignature(signature, node) { + return getJsxReferenceKind(node) !== 0 /* JsxReferenceKind.Component */ + ? getJsxPropsTypeFromCallSignature(signature, node) + : getJsxPropsTypeFromClassType(signature, node); + } + function getJsxPropsTypeFromCallSignature(sig, context) { + var propsType = getTypeOfFirstParameterOfSignatureWithFallback(sig, unknownType); + propsType = getJsxManagedAttributesFromLocatedAttributes(context, getJsxNamespaceAt(context), propsType); + var intrinsicAttribs = getJsxType(JsxNames.IntrinsicAttributes, context); + if (!isErrorType(intrinsicAttribs)) { + propsType = intersectTypes(intrinsicAttribs, propsType); + } + return propsType; + } + function getJsxPropsTypeForSignatureFromMember(sig, forcedLookupLocation) { + if (sig.compositeSignatures) { + // JSX Elements using the legacy `props`-field based lookup (eg, react class components) need to treat the `props` member as an input + // instead of an output position when resolving the signature. We need to go back to the input signatures of the composite signature, + // get the type of `props` on each return type individually, and then _intersect them_, rather than union them (as would normally occur + // for a union signature). It's an unfortunate quirk of looking in the output of the signature for the type we want to use for the input. + // The default behavior of `getTypeOfFirstParameterOfSignatureWithFallback` when no `props` member name is defined is much more sane. + var results = []; + for (var _i = 0, _a = sig.compositeSignatures; _i < _a.length; _i++) { + var signature = _a[_i]; + var instance = getReturnTypeOfSignature(signature); + if (isTypeAny(instance)) { + return instance; + } + var propType = getTypeOfPropertyOfType(instance, forcedLookupLocation); + if (!propType) { + return; + } + results.push(propType); + } + return getIntersectionType(results); // Same result for both union and intersection signatures + } + var instanceType = getReturnTypeOfSignature(sig); + return isTypeAny(instanceType) ? instanceType : getTypeOfPropertyOfType(instanceType, forcedLookupLocation); + } + function getStaticTypeOfReferencedJsxConstructor(context) { + if (isJsxIntrinsicIdentifier(context.tagName)) { + var result = getIntrinsicAttributesTypeFromJsxOpeningLikeElement(context); + var fakeSignature = createSignatureForJSXIntrinsic(context, result); + return getOrCreateTypeFromSignature(fakeSignature); + } + var tagType = checkExpressionCached(context.tagName); + if (tagType.flags & 128 /* TypeFlags.StringLiteral */) { + var result = getIntrinsicAttributesTypeFromStringLiteralType(tagType, context); + if (!result) { + return errorType; + } + var fakeSignature = createSignatureForJSXIntrinsic(context, result); + return getOrCreateTypeFromSignature(fakeSignature); + } + return tagType; + } + function getJsxManagedAttributesFromLocatedAttributes(context, ns, attributesType) { + var managedSym = getJsxLibraryManagedAttributes(ns); + if (managedSym) { + var declaredManagedType = getDeclaredTypeOfSymbol(managedSym); // fetches interface type, or initializes symbol links type parmaeters + var ctorType = getStaticTypeOfReferencedJsxConstructor(context); + if (managedSym.flags & 524288 /* SymbolFlags.TypeAlias */) { + var params = getSymbolLinks(managedSym).typeParameters; + if (ts.length(params) >= 2) { + var args = fillMissingTypeArguments([ctorType, attributesType], params, 2, ts.isInJSFile(context)); + return getTypeAliasInstantiation(managedSym, args); + } + } + if (ts.length(declaredManagedType.typeParameters) >= 2) { + var args = fillMissingTypeArguments([ctorType, attributesType], declaredManagedType.typeParameters, 2, ts.isInJSFile(context)); + return createTypeReference(declaredManagedType, args); + } + } + return attributesType; + } + function getJsxPropsTypeFromClassType(sig, context) { + var ns = getJsxNamespaceAt(context); + var forcedLookupLocation = getJsxElementPropertiesName(ns); + var attributesType = forcedLookupLocation === undefined + // If there is no type ElementAttributesProperty, return the type of the first parameter of the signature, which should be the props type + ? getTypeOfFirstParameterOfSignatureWithFallback(sig, unknownType) + : forcedLookupLocation === "" + // If there is no e.g. 'props' member in ElementAttributesProperty, use the element class type instead + ? getReturnTypeOfSignature(sig) + // Otherwise get the type of the property on the signature return type + : getJsxPropsTypeForSignatureFromMember(sig, forcedLookupLocation); + if (!attributesType) { + // There is no property named 'props' on this instance type + if (!!forcedLookupLocation && !!ts.length(context.attributes.properties)) { + error(context, ts.Diagnostics.JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property, ts.unescapeLeadingUnderscores(forcedLookupLocation)); + } + return unknownType; + } + attributesType = getJsxManagedAttributesFromLocatedAttributes(context, ns, attributesType); + if (isTypeAny(attributesType)) { + // Props is of type 'any' or unknown + return attributesType; + } + else { + // Normal case -- add in IntrinsicClassElements and IntrinsicElements + var apparentAttributesType = attributesType; + var intrinsicClassAttribs = getJsxType(JsxNames.IntrinsicClassAttributes, context); + if (!isErrorType(intrinsicClassAttribs)) { + var typeParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(intrinsicClassAttribs.symbol); + var hostClassType = getReturnTypeOfSignature(sig); + var libraryManagedAttributeType = void 0; + if (typeParams) { + // apply JSX.IntrinsicClassElements + var inferredArgs = fillMissingTypeArguments([hostClassType], typeParams, getMinTypeArgumentCount(typeParams), ts.isInJSFile(context)); + libraryManagedAttributeType = instantiateType(intrinsicClassAttribs, createTypeMapper(typeParams, inferredArgs)); + } + // or JSX.IntrinsicClassElements has no generics. + else + libraryManagedAttributeType = intrinsicClassAttribs; + apparentAttributesType = intersectTypes(libraryManagedAttributeType, apparentAttributesType); + } + var intrinsicAttribs = getJsxType(JsxNames.IntrinsicAttributes, context); + if (!isErrorType(intrinsicAttribs)) { + apparentAttributesType = intersectTypes(intrinsicAttribs, apparentAttributesType); + } + return apparentAttributesType; + } + } + function getIntersectedSignatures(signatures) { + return ts.getStrictOptionValue(compilerOptions, "noImplicitAny") + ? ts.reduceLeft(signatures, function (left, right) { + return left === right || !left ? left + : compareTypeParametersIdentical(left.typeParameters, right.typeParameters) ? combineSignaturesOfIntersectionMembers(left, right) + : undefined; + }) + : undefined; + } + function combineIntersectionThisParam(left, right, mapper) { + if (!left || !right) { + return left || right; + } + // A signature `this` type might be a read or a write position... It's very possible that it should be invariant + // and we should refuse to merge signatures if there are `this` types and they do not match. However, so as to be + // pessimistic when contextual typing, for now, we'll union the `this` types. + var thisType = getUnionType([getTypeOfSymbol(left), instantiateType(getTypeOfSymbol(right), mapper)]); + return createSymbolWithType(left, thisType); + } + function combineIntersectionParameters(left, right, mapper) { + var leftCount = getParameterCount(left); + var rightCount = getParameterCount(right); + var longest = leftCount >= rightCount ? left : right; + var shorter = longest === left ? right : left; + var longestCount = longest === left ? leftCount : rightCount; + var eitherHasEffectiveRest = (hasEffectiveRestParameter(left) || hasEffectiveRestParameter(right)); + var needsExtraRestElement = eitherHasEffectiveRest && !hasEffectiveRestParameter(longest); + var params = new Array(longestCount + (needsExtraRestElement ? 1 : 0)); + for (var i = 0; i < longestCount; i++) { + var longestParamType = tryGetTypeAtPosition(longest, i); + if (longest === right) { + longestParamType = instantiateType(longestParamType, mapper); + } + var shorterParamType = tryGetTypeAtPosition(shorter, i) || unknownType; + if (shorter === right) { + shorterParamType = instantiateType(shorterParamType, mapper); + } + var unionParamType = getUnionType([longestParamType, shorterParamType]); + var isRestParam = eitherHasEffectiveRest && !needsExtraRestElement && i === (longestCount - 1); + var isOptional = i >= getMinArgumentCount(longest) && i >= getMinArgumentCount(shorter); + var leftName = i >= leftCount ? undefined : getParameterNameAtPosition(left, i); + var rightName = i >= rightCount ? undefined : getParameterNameAtPosition(right, i); + var paramName = leftName === rightName ? leftName : + !leftName ? rightName : + !rightName ? leftName : + undefined; + var paramSymbol = createSymbol(1 /* SymbolFlags.FunctionScopedVariable */ | (isOptional && !isRestParam ? 16777216 /* SymbolFlags.Optional */ : 0), paramName || "arg".concat(i)); + paramSymbol.type = isRestParam ? createArrayType(unionParamType) : unionParamType; + params[i] = paramSymbol; + } + if (needsExtraRestElement) { + var restParamSymbol = createSymbol(1 /* SymbolFlags.FunctionScopedVariable */, "args"); + restParamSymbol.type = createArrayType(getTypeAtPosition(shorter, longestCount)); + if (shorter === right) { + restParamSymbol.type = instantiateType(restParamSymbol.type, mapper); + } + params[longestCount] = restParamSymbol; + } + return params; + } + function combineSignaturesOfIntersectionMembers(left, right) { + var typeParams = left.typeParameters || right.typeParameters; + var paramMapper; + if (left.typeParameters && right.typeParameters) { + paramMapper = createTypeMapper(right.typeParameters, left.typeParameters); + // We just use the type parameter defaults from the first signature + } + var declaration = left.declaration; + var params = combineIntersectionParameters(left, right, paramMapper); + var thisParam = combineIntersectionThisParam(left.thisParameter, right.thisParameter, paramMapper); + var minArgCount = Math.max(left.minArgumentCount, right.minArgumentCount); + var result = createSignature(declaration, typeParams, thisParam, params, + /*resolvedReturnType*/ undefined, + /*resolvedTypePredicate*/ undefined, minArgCount, (left.flags | right.flags) & 39 /* SignatureFlags.PropagatingFlags */); + result.compositeKind = 2097152 /* TypeFlags.Intersection */; + result.compositeSignatures = ts.concatenate(left.compositeKind === 2097152 /* TypeFlags.Intersection */ && left.compositeSignatures || [left], [right]); + if (paramMapper) { + result.mapper = left.compositeKind === 2097152 /* TypeFlags.Intersection */ && left.mapper && left.compositeSignatures ? combineTypeMappers(left.mapper, paramMapper) : paramMapper; + } + return result; + } + // If the given type is an object or union type with a single signature, and if that signature has at + // least as many parameters as the given function, return the signature. Otherwise return undefined. + function getContextualCallSignature(type, node) { + var signatures = getSignaturesOfType(type, 0 /* SignatureKind.Call */); + var applicableByArity = ts.filter(signatures, function (s) { return !isAritySmaller(s, node); }); + return applicableByArity.length === 1 ? applicableByArity[0] : getIntersectedSignatures(applicableByArity); + } + /** If the contextual signature has fewer parameters than the function expression, do not use it */ + function isAritySmaller(signature, target) { + var targetParameterCount = 0; + for (; targetParameterCount < target.parameters.length; targetParameterCount++) { + var param = target.parameters[targetParameterCount]; + if (param.initializer || param.questionToken || param.dotDotDotToken || isJSDocOptionalParameter(param)) { + break; + } + } + if (target.parameters.length && ts.parameterIsThisKeyword(target.parameters[0])) { + targetParameterCount--; + } + return !hasEffectiveRestParameter(signature) && getParameterCount(signature) < targetParameterCount; + } + function getContextualSignatureForFunctionLikeDeclaration(node) { + // Only function expressions, arrow functions, and object literal methods are contextually typed. + return ts.isFunctionExpressionOrArrowFunction(node) || ts.isObjectLiteralMethod(node) + ? getContextualSignature(node) + : undefined; + } + // Return the contextual signature for a given expression node. A contextual type provides a + // contextual signature if it has a single call signature and if that call signature is non-generic. + // If the contextual type is a union type, get the signature from each type possible and if they are + // all identical ignoring their return type, the result is same signature but with return type as + // union type of return types from these signatures + function getContextualSignature(node) { + ts.Debug.assert(node.kind !== 171 /* SyntaxKind.MethodDeclaration */ || ts.isObjectLiteralMethod(node)); + var typeTagSignature = getSignatureOfTypeTag(node); + if (typeTagSignature) { + return typeTagSignature; + } + var type = getApparentTypeOfContextualType(node, 1 /* ContextFlags.Signature */); + if (!type) { + return undefined; + } + if (!(type.flags & 1048576 /* TypeFlags.Union */)) { + return getContextualCallSignature(type, node); + } + var signatureList; + var types = type.types; + for (var _i = 0, types_18 = types; _i < types_18.length; _i++) { + var current = types_18[_i]; + var signature = getContextualCallSignature(current, node); + if (signature) { + if (!signatureList) { + // This signature will contribute to contextual union signature + signatureList = [signature]; + } + else if (!compareSignaturesIdentical(signatureList[0], signature, /*partialMatch*/ false, /*ignoreThisTypes*/ true, /*ignoreReturnTypes*/ true, compareTypesIdentical)) { + // Signatures aren't identical, do not use + return undefined; + } + else { + // Use this signature for contextual union signature + signatureList.push(signature); + } + } + } + // Result is union of signatures collected (return type is union of return types of this signature set) + if (signatureList) { + return signatureList.length === 1 ? signatureList[0] : createUnionSignature(signatureList[0], signatureList); + } + } + function checkSpreadExpression(node, checkMode) { + if (languageVersion < 2 /* ScriptTarget.ES2015 */) { + checkExternalEmitHelpers(node, compilerOptions.downlevelIteration ? 1536 /* ExternalEmitHelpers.SpreadIncludes */ : 1024 /* ExternalEmitHelpers.SpreadArray */); + } + var arrayOrIterableType = checkExpression(node.expression, checkMode); + return checkIteratedTypeOrElementType(33 /* IterationUse.Spread */, arrayOrIterableType, undefinedType, node.expression); + } + function checkSyntheticExpression(node) { + return node.isSpread ? getIndexedAccessType(node.type, numberType) : node.type; + } + function hasDefaultValue(node) { + return (node.kind === 205 /* SyntaxKind.BindingElement */ && !!node.initializer) || + (node.kind === 223 /* SyntaxKind.BinaryExpression */ && node.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */); + } + function checkArrayLiteral(node, checkMode, forceTuple) { + var elements = node.elements; + var elementCount = elements.length; + var elementTypes = []; + var elementFlags = []; + var contextualType = getApparentTypeOfContextualType(node, /*contextFlags*/ undefined); + var inDestructuringPattern = ts.isAssignmentTarget(node); + var inConstContext = isConstContext(node); + var hasOmittedExpression = false; + for (var i = 0; i < elementCount; i++) { + var e = elements[i]; + if (e.kind === 227 /* SyntaxKind.SpreadElement */) { + if (languageVersion < 2 /* ScriptTarget.ES2015 */) { + checkExternalEmitHelpers(e, compilerOptions.downlevelIteration ? 1536 /* ExternalEmitHelpers.SpreadIncludes */ : 1024 /* ExternalEmitHelpers.SpreadArray */); + } + var spreadType = checkExpression(e.expression, checkMode, forceTuple); + if (isArrayLikeType(spreadType)) { + elementTypes.push(spreadType); + elementFlags.push(8 /* ElementFlags.Variadic */); + } + else if (inDestructuringPattern) { + // Given the following situation: + // var c: {}; + // [...c] = ["", 0]; + // + // c is represented in the tree as a spread element in an array literal. + // But c really functions as a rest element, and its purpose is to provide + // a contextual type for the right hand side of the assignment. Therefore, + // instead of calling checkExpression on "...c", which will give an error + // if c is not iterable/array-like, we need to act as if we are trying to + // get the contextual element type from it. So we do something similar to + // getContextualTypeForElementExpression, which will crucially not error + // if there is no index type / iterated type. + var restElementType = getIndexTypeOfType(spreadType, numberType) || + getIteratedTypeOrElementType(65 /* IterationUse.Destructuring */, spreadType, undefinedType, /*errorNode*/ undefined, /*checkAssignability*/ false) || + unknownType; + elementTypes.push(restElementType); + elementFlags.push(4 /* ElementFlags.Rest */); + } + else { + elementTypes.push(checkIteratedTypeOrElementType(33 /* IterationUse.Spread */, spreadType, undefinedType, e.expression)); + elementFlags.push(4 /* ElementFlags.Rest */); + } + } + else if (exactOptionalPropertyTypes && e.kind === 229 /* SyntaxKind.OmittedExpression */) { + hasOmittedExpression = true; + elementTypes.push(missingType); + elementFlags.push(2 /* ElementFlags.Optional */); + } + else { + var elementContextualType = getContextualTypeForElementExpression(contextualType, elementTypes.length); + var type = checkExpressionForMutableLocation(e, checkMode, elementContextualType, forceTuple); + elementTypes.push(addOptionality(type, /*isProperty*/ true, hasOmittedExpression)); + elementFlags.push(hasOmittedExpression ? 2 /* ElementFlags.Optional */ : 1 /* ElementFlags.Required */); + if (contextualType && someType(contextualType, isTupleLikeType) && checkMode && checkMode & 2 /* CheckMode.Inferential */ && !(checkMode & 4 /* CheckMode.SkipContextSensitive */) && isContextSensitive(e)) { + var inferenceContext = getInferenceContext(node); + ts.Debug.assert(inferenceContext); // In CheckMode.Inferential we should always have an inference context + addIntraExpressionInferenceSite(inferenceContext, e, type); + } + } + } + if (inDestructuringPattern) { + return createTupleType(elementTypes, elementFlags); + } + if (forceTuple || inConstContext || contextualType && someType(contextualType, isTupleLikeType)) { + return createArrayLiteralType(createTupleType(elementTypes, elementFlags, /*readonly*/ inConstContext)); + } + return createArrayLiteralType(createArrayType(elementTypes.length ? + getUnionType(ts.sameMap(elementTypes, function (t, i) { return elementFlags[i] & 8 /* ElementFlags.Variadic */ ? getIndexedAccessTypeOrUndefined(t, numberType) || anyType : t; }), 2 /* UnionReduction.Subtype */) : + strictNullChecks ? implicitNeverType : undefinedWideningType, inConstContext)); + } + function createArrayLiteralType(type) { + if (!(ts.getObjectFlags(type) & 4 /* ObjectFlags.Reference */)) { + return type; + } + var literalType = type.literalType; + if (!literalType) { + literalType = type.literalType = cloneTypeReference(type); + literalType.objectFlags |= 16384 /* ObjectFlags.ArrayLiteral */ | 131072 /* ObjectFlags.ContainsObjectOrArrayLiteral */; + } + return literalType; + } + function isNumericName(name) { + switch (name.kind) { + case 164 /* SyntaxKind.ComputedPropertyName */: + return isNumericComputedName(name); + case 79 /* SyntaxKind.Identifier */: + return ts.isNumericLiteralName(name.escapedText); + case 8 /* SyntaxKind.NumericLiteral */: + case 10 /* SyntaxKind.StringLiteral */: + return ts.isNumericLiteralName(name.text); + default: + return false; + } + } + function isNumericComputedName(name) { + // It seems odd to consider an expression of type Any to result in a numeric name, + // but this behavior is consistent with checkIndexedAccess + return isTypeAssignableToKind(checkComputedPropertyName(name), 296 /* TypeFlags.NumberLike */); + } + function checkComputedPropertyName(node) { + var links = getNodeLinks(node.expression); + if (!links.resolvedType) { + if ((ts.isTypeLiteralNode(node.parent.parent) || ts.isClassLike(node.parent.parent) || ts.isInterfaceDeclaration(node.parent.parent)) + && ts.isBinaryExpression(node.expression) && node.expression.operatorToken.kind === 101 /* SyntaxKind.InKeyword */ + && node.parent.kind !== 174 /* SyntaxKind.GetAccessor */ && node.parent.kind !== 175 /* SyntaxKind.SetAccessor */) { + return links.resolvedType = errorType; + } + links.resolvedType = checkExpression(node.expression); + // The computed property name of a non-static class field within a loop must be stored in a block-scoped binding. + // (It needs to be bound at class evaluation time.) + if (ts.isPropertyDeclaration(node.parent) && !ts.hasStaticModifier(node.parent) && ts.isClassExpression(node.parent.parent)) { + var container = ts.getEnclosingBlockScopeContainer(node.parent.parent); + var enclosingIterationStatement = getEnclosingIterationStatement(container); + if (enclosingIterationStatement) { + // The computed field name will use a block scoped binding which can be unique for each iteration of the loop. + getNodeLinks(enclosingIterationStatement).flags |= 65536 /* NodeCheckFlags.LoopWithCapturedBlockScopedBinding */; + // The generated variable which stores the computed field name must be block-scoped. + getNodeLinks(node).flags |= 524288 /* NodeCheckFlags.BlockScopedBindingInLoop */; + // The generated variable which stores the class must be block-scoped. + getNodeLinks(node.parent.parent).flags |= 524288 /* NodeCheckFlags.BlockScopedBindingInLoop */; + } + } + // This will allow types number, string, symbol or any. It will also allow enums, the unknown + // type, and any union of these types (like string | number). + if (links.resolvedType.flags & 98304 /* TypeFlags.Nullable */ || + !isTypeAssignableToKind(links.resolvedType, 402653316 /* TypeFlags.StringLike */ | 296 /* TypeFlags.NumberLike */ | 12288 /* TypeFlags.ESSymbolLike */) && + !isTypeAssignableTo(links.resolvedType, stringNumberSymbolType)) { + error(node, ts.Diagnostics.A_computed_property_name_must_be_of_type_string_number_symbol_or_any); + } + } + return links.resolvedType; + } + function isSymbolWithNumericName(symbol) { + var _a; + var firstDecl = (_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a[0]; + return ts.isNumericLiteralName(symbol.escapedName) || (firstDecl && ts.isNamedDeclaration(firstDecl) && isNumericName(firstDecl.name)); + } + function isSymbolWithSymbolName(symbol) { + var _a; + var firstDecl = (_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a[0]; + return ts.isKnownSymbol(symbol) || (firstDecl && ts.isNamedDeclaration(firstDecl) && ts.isComputedPropertyName(firstDecl.name) && + isTypeAssignableToKind(checkComputedPropertyName(firstDecl.name), 4096 /* TypeFlags.ESSymbol */)); + } + function getObjectLiteralIndexInfo(node, offset, properties, keyType) { + var propTypes = []; + for (var i = offset; i < properties.length; i++) { + var prop = properties[i]; + if (keyType === stringType && !isSymbolWithSymbolName(prop) || + keyType === numberType && isSymbolWithNumericName(prop) || + keyType === esSymbolType && isSymbolWithSymbolName(prop)) { + propTypes.push(getTypeOfSymbol(properties[i])); + } + } + var unionType = propTypes.length ? getUnionType(propTypes, 2 /* UnionReduction.Subtype */) : undefinedType; + return createIndexInfo(keyType, unionType, isConstContext(node)); + } + function getImmediateAliasedSymbol(symbol) { + ts.Debug.assert((symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0, "Should only get Alias here."); + var links = getSymbolLinks(symbol); + if (!links.immediateTarget) { + var node = getDeclarationOfAliasSymbol(symbol); + if (!node) + return ts.Debug.fail(); + links.immediateTarget = getTargetOfAliasDeclaration(node, /*dontRecursivelyResolve*/ true); + } + return links.immediateTarget; + } + function checkObjectLiteral(node, checkMode) { + var inDestructuringPattern = ts.isAssignmentTarget(node); + // Grammar checking + checkGrammarObjectLiteralExpression(node, inDestructuringPattern); + var allPropertiesTable = strictNullChecks ? ts.createSymbolTable() : undefined; + var propertiesTable = ts.createSymbolTable(); + var propertiesArray = []; + var spread = emptyObjectType; + var contextualType = getApparentTypeOfContextualType(node, /*contextFlags*/ undefined); + var contextualTypeHasPattern = contextualType && contextualType.pattern && + (contextualType.pattern.kind === 203 /* SyntaxKind.ObjectBindingPattern */ || contextualType.pattern.kind === 207 /* SyntaxKind.ObjectLiteralExpression */); + var inConstContext = isConstContext(node); + var checkFlags = inConstContext ? 8 /* CheckFlags.Readonly */ : 0; + var isInJavascript = ts.isInJSFile(node) && !ts.isInJsonFile(node); + var enumTag = ts.getJSDocEnumTag(node); + var isJSObjectLiteral = !contextualType && isInJavascript && !enumTag; + var objectFlags = freshObjectLiteralFlag; + var patternWithComputedProperties = false; + var hasComputedStringProperty = false; + var hasComputedNumberProperty = false; + var hasComputedSymbolProperty = false; + // Spreads may cause an early bail; ensure computed names are always checked (this is cached) + // As otherwise they may not be checked until exports for the type at this position are retrieved, + // which may never occur. + for (var _i = 0, _a = node.properties; _i < _a.length; _i++) { + var elem = _a[_i]; + if (elem.name && ts.isComputedPropertyName(elem.name)) { + checkComputedPropertyName(elem.name); + } + } + var offset = 0; + for (var _b = 0, _c = node.properties; _b < _c.length; _b++) { + var memberDecl = _c[_b]; + var member = getSymbolOfNode(memberDecl); + var computedNameType = memberDecl.name && memberDecl.name.kind === 164 /* SyntaxKind.ComputedPropertyName */ ? + checkComputedPropertyName(memberDecl.name) : undefined; + if (memberDecl.kind === 299 /* SyntaxKind.PropertyAssignment */ || + memberDecl.kind === 300 /* SyntaxKind.ShorthandPropertyAssignment */ || + ts.isObjectLiteralMethod(memberDecl)) { + var type = memberDecl.kind === 299 /* SyntaxKind.PropertyAssignment */ ? checkPropertyAssignment(memberDecl, checkMode) : + // avoid resolving the left side of the ShorthandPropertyAssignment outside of the destructuring + // for error recovery purposes. For example, if a user wrote `{ a = 100 }` instead of `{ a: 100 }`. + // we don't want to say "could not find 'a'". + memberDecl.kind === 300 /* SyntaxKind.ShorthandPropertyAssignment */ ? checkExpressionForMutableLocation(!inDestructuringPattern && memberDecl.objectAssignmentInitializer ? memberDecl.objectAssignmentInitializer : memberDecl.name, checkMode) : + checkObjectLiteralMethod(memberDecl, checkMode); + if (isInJavascript) { + var jsDocType = getTypeForDeclarationFromJSDocComment(memberDecl); + if (jsDocType) { + checkTypeAssignableTo(type, jsDocType, memberDecl); + type = jsDocType; + } + else if (enumTag && enumTag.typeExpression) { + checkTypeAssignableTo(type, getTypeFromTypeNode(enumTag.typeExpression), memberDecl); + } + } + objectFlags |= ts.getObjectFlags(type) & 458752 /* ObjectFlags.PropagatingFlags */; + var nameType = computedNameType && isTypeUsableAsPropertyName(computedNameType) ? computedNameType : undefined; + var prop = nameType ? + createSymbol(4 /* SymbolFlags.Property */ | member.flags, getPropertyNameFromType(nameType), checkFlags | 4096 /* CheckFlags.Late */) : + createSymbol(4 /* SymbolFlags.Property */ | member.flags, member.escapedName, checkFlags); + if (nameType) { + prop.nameType = nameType; + } + if (inDestructuringPattern) { + // If object literal is an assignment pattern and if the assignment pattern specifies a default value + // for the property, make the property optional. + var isOptional = (memberDecl.kind === 299 /* SyntaxKind.PropertyAssignment */ && hasDefaultValue(memberDecl.initializer)) || + (memberDecl.kind === 300 /* SyntaxKind.ShorthandPropertyAssignment */ && memberDecl.objectAssignmentInitializer); + if (isOptional) { + prop.flags |= 16777216 /* SymbolFlags.Optional */; + } + } + else if (contextualTypeHasPattern && !(ts.getObjectFlags(contextualType) & 512 /* ObjectFlags.ObjectLiteralPatternWithComputedProperties */)) { + // If object literal is contextually typed by the implied type of a binding pattern, and if the + // binding pattern specifies a default value for the property, make the property optional. + var impliedProp = getPropertyOfType(contextualType, member.escapedName); + if (impliedProp) { + prop.flags |= impliedProp.flags & 16777216 /* SymbolFlags.Optional */; + } + else if (!compilerOptions.suppressExcessPropertyErrors && !getIndexInfoOfType(contextualType, stringType)) { + error(memberDecl.name, ts.Diagnostics.Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1, symbolToString(member), typeToString(contextualType)); + } + } + prop.declarations = member.declarations; + prop.parent = member.parent; + if (member.valueDeclaration) { + prop.valueDeclaration = member.valueDeclaration; + } + prop.type = type; + prop.target = member; + member = prop; + allPropertiesTable === null || allPropertiesTable === void 0 ? void 0 : allPropertiesTable.set(prop.escapedName, prop); + if (contextualType && checkMode && checkMode & 2 /* CheckMode.Inferential */ && !(checkMode & 4 /* CheckMode.SkipContextSensitive */) && + (memberDecl.kind === 299 /* SyntaxKind.PropertyAssignment */ || memberDecl.kind === 171 /* SyntaxKind.MethodDeclaration */) && isContextSensitive(memberDecl)) { + var inferenceContext = getInferenceContext(node); + ts.Debug.assert(inferenceContext); // In CheckMode.Inferential we should always have an inference context + var inferenceNode = memberDecl.kind === 299 /* SyntaxKind.PropertyAssignment */ ? memberDecl.initializer : memberDecl; + addIntraExpressionInferenceSite(inferenceContext, inferenceNode, type); + } + } + else if (memberDecl.kind === 301 /* SyntaxKind.SpreadAssignment */) { + if (languageVersion < 2 /* ScriptTarget.ES2015 */) { + checkExternalEmitHelpers(memberDecl, 2 /* ExternalEmitHelpers.Assign */); + } + if (propertiesArray.length > 0) { + spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, objectFlags, inConstContext); + propertiesArray = []; + propertiesTable = ts.createSymbolTable(); + hasComputedStringProperty = false; + hasComputedNumberProperty = false; + hasComputedSymbolProperty = false; + } + var type = getReducedType(checkExpression(memberDecl.expression)); + if (isValidSpreadType(type)) { + var mergedType = tryMergeUnionOfObjectTypeAndEmptyObject(type, inConstContext); + if (allPropertiesTable) { + checkSpreadPropOverrides(mergedType, allPropertiesTable, memberDecl); + } + offset = propertiesArray.length; + if (isErrorType(spread)) { + continue; + } + spread = getSpreadType(spread, mergedType, node.symbol, objectFlags, inConstContext); + } + else { + error(memberDecl, ts.Diagnostics.Spread_types_may_only_be_created_from_object_types); + spread = errorType; + } + continue; + } + else { + // TypeScript 1.0 spec (April 2014) + // A get accessor declaration is processed in the same manner as + // an ordinary function declaration(section 6.1) with no parameters. + // A set accessor declaration is processed in the same manner + // as an ordinary function declaration with a single parameter and a Void return type. + ts.Debug.assert(memberDecl.kind === 174 /* SyntaxKind.GetAccessor */ || memberDecl.kind === 175 /* SyntaxKind.SetAccessor */); + checkNodeDeferred(memberDecl); + } + if (computedNameType && !(computedNameType.flags & 8576 /* TypeFlags.StringOrNumberLiteralOrUnique */)) { + if (isTypeAssignableTo(computedNameType, stringNumberSymbolType)) { + if (isTypeAssignableTo(computedNameType, numberType)) { + hasComputedNumberProperty = true; + } + else if (isTypeAssignableTo(computedNameType, esSymbolType)) { + hasComputedSymbolProperty = true; + } + else { + hasComputedStringProperty = true; + } + if (inDestructuringPattern) { + patternWithComputedProperties = true; + } + } + } + else { + propertiesTable.set(member.escapedName, member); + } + propertiesArray.push(member); + } + // If object literal is contextually typed by the implied type of a binding pattern, augment the result + // type with those properties for which the binding pattern specifies a default value. + // If the object literal is spread into another object literal, skip this step and let the top-level object + // literal handle it instead. Note that this might require full traversal to the root pattern's parent + // as it's the guaranteed to be the common ancestor of the pattern node and the current object node. + // It's not possible to check if the immediate parent node is a spread assignment + // since the type flows in non-obvious ways through conditional expressions, IIFEs and more. + if (contextualTypeHasPattern) { + var rootPatternParent_1 = ts.findAncestor(contextualType.pattern.parent, function (n) { + return n.kind === 257 /* SyntaxKind.VariableDeclaration */ || + n.kind === 223 /* SyntaxKind.BinaryExpression */ || + n.kind === 166 /* SyntaxKind.Parameter */; + }); + var spreadOrOutsideRootObject = ts.findAncestor(node, function (n) { + return n === rootPatternParent_1 || + n.kind === 301 /* SyntaxKind.SpreadAssignment */; + }); + if (spreadOrOutsideRootObject.kind !== 301 /* SyntaxKind.SpreadAssignment */) { + for (var _d = 0, _e = getPropertiesOfType(contextualType); _d < _e.length; _d++) { + var prop = _e[_d]; + if (!propertiesTable.get(prop.escapedName) && !getPropertyOfType(spread, prop.escapedName)) { + if (!(prop.flags & 16777216 /* SymbolFlags.Optional */)) { + error(prop.valueDeclaration || prop.bindingElement, ts.Diagnostics.Initializer_provides_no_value_for_this_binding_element_and_the_binding_element_has_no_default_value); + } + propertiesTable.set(prop.escapedName, prop); + propertiesArray.push(prop); + } + } + } + } + if (isErrorType(spread)) { + return errorType; + } + if (spread !== emptyObjectType) { + if (propertiesArray.length > 0) { + spread = getSpreadType(spread, createObjectLiteralType(), node.symbol, objectFlags, inConstContext); + propertiesArray = []; + propertiesTable = ts.createSymbolTable(); + hasComputedStringProperty = false; + hasComputedNumberProperty = false; + } + // remap the raw emptyObjectType fed in at the top into a fresh empty object literal type, unique to this use site + return mapType(spread, function (t) { return t === emptyObjectType ? createObjectLiteralType() : t; }); + } + return createObjectLiteralType(); + function createObjectLiteralType() { + var indexInfos = []; + if (hasComputedStringProperty) + indexInfos.push(getObjectLiteralIndexInfo(node, offset, propertiesArray, stringType)); + if (hasComputedNumberProperty) + indexInfos.push(getObjectLiteralIndexInfo(node, offset, propertiesArray, numberType)); + if (hasComputedSymbolProperty) + indexInfos.push(getObjectLiteralIndexInfo(node, offset, propertiesArray, esSymbolType)); + var result = createAnonymousType(node.symbol, propertiesTable, ts.emptyArray, ts.emptyArray, indexInfos); + result.objectFlags |= objectFlags | 128 /* ObjectFlags.ObjectLiteral */ | 131072 /* ObjectFlags.ContainsObjectOrArrayLiteral */; + if (isJSObjectLiteral) { + result.objectFlags |= 4096 /* ObjectFlags.JSLiteral */; + } + if (patternWithComputedProperties) { + result.objectFlags |= 512 /* ObjectFlags.ObjectLiteralPatternWithComputedProperties */; + } + if (inDestructuringPattern) { + result.pattern = node; + } + return result; + } + } + function isValidSpreadType(type) { + var t = removeDefinitelyFalsyTypes(mapType(type, getBaseConstraintOrType)); + return !!(t.flags & (1 /* TypeFlags.Any */ | 67108864 /* TypeFlags.NonPrimitive */ | 524288 /* TypeFlags.Object */ | 58982400 /* TypeFlags.InstantiableNonPrimitive */) || + t.flags & 3145728 /* TypeFlags.UnionOrIntersection */ && ts.every(t.types, isValidSpreadType)); + } + function checkJsxSelfClosingElementDeferred(node) { + checkJsxOpeningLikeElementOrOpeningFragment(node); + } + function checkJsxSelfClosingElement(node, _checkMode) { + checkNodeDeferred(node); + return getJsxElementTypeAt(node) || anyType; + } + function checkJsxElementDeferred(node) { + // Check attributes + checkJsxOpeningLikeElementOrOpeningFragment(node.openingElement); + // Perform resolution on the closing tag so that rename/go to definition/etc work + if (isJsxIntrinsicIdentifier(node.closingElement.tagName)) { + getIntrinsicTagSymbol(node.closingElement); + } + else { + checkExpression(node.closingElement.tagName); + } + checkJsxChildren(node); + } + function checkJsxElement(node, _checkMode) { + checkNodeDeferred(node); + return getJsxElementTypeAt(node) || anyType; + } + function checkJsxFragment(node) { + checkJsxOpeningLikeElementOrOpeningFragment(node.openingFragment); + // by default, jsx:'react' will use jsxFactory = React.createElement and jsxFragmentFactory = React.Fragment + // if jsxFactory compiler option is provided, ensure jsxFragmentFactory compiler option or @jsxFrag pragma is provided too + var nodeSourceFile = ts.getSourceFileOfNode(node); + if (ts.getJSXTransformEnabled(compilerOptions) && (compilerOptions.jsxFactory || nodeSourceFile.pragmas.has("jsx")) + && !compilerOptions.jsxFragmentFactory && !nodeSourceFile.pragmas.has("jsxfrag")) { + error(node, compilerOptions.jsxFactory + ? ts.Diagnostics.The_jsxFragmentFactory_compiler_option_must_be_provided_to_use_JSX_fragments_with_the_jsxFactory_compiler_option + : ts.Diagnostics.An_jsxFrag_pragma_is_required_when_using_an_jsx_pragma_with_JSX_fragments); + } + checkJsxChildren(node); + return getJsxElementTypeAt(node) || anyType; + } + function isHyphenatedJsxName(name) { + return ts.stringContains(name, "-"); + } + /** + * Returns true iff React would emit this tag name as a string rather than an identifier or qualified name + */ + function isJsxIntrinsicIdentifier(tagName) { + return tagName.kind === 79 /* SyntaxKind.Identifier */ && ts.isIntrinsicJsxName(tagName.escapedText); + } + function checkJsxAttribute(node, checkMode) { + return node.initializer + ? checkExpressionForMutableLocation(node.initializer, checkMode) + : trueType; // is sugar for + } + /** + * Get attributes type of the JSX opening-like element. The result is from resolving "attributes" property of the opening-like element. + * + * @param openingLikeElement a JSX opening-like element + * @param filter a function to remove attributes that will not participate in checking whether attributes are assignable + * @return an anonymous type (similar to the one returned by checkObjectLiteral) in which its properties are attributes property. + * @remarks Because this function calls getSpreadType, it needs to use the same checks as checkObjectLiteral, + * which also calls getSpreadType. + */ + function createJsxAttributesTypeFromAttributesProperty(openingLikeElement, checkMode) { + var attributes = openingLikeElement.attributes; + var attributesType = getContextualType(attributes, 0 /* ContextFlags.None */); + var allAttributesTable = strictNullChecks ? ts.createSymbolTable() : undefined; + var attributesTable = ts.createSymbolTable(); + var spread = emptyJsxObjectType; + var hasSpreadAnyType = false; + var typeToIntersect; + var explicitlySpecifyChildrenAttribute = false; + var objectFlags = 2048 /* ObjectFlags.JsxAttributes */; + var jsxChildrenPropertyName = getJsxElementChildrenPropertyName(getJsxNamespaceAt(openingLikeElement)); + for (var _i = 0, _a = attributes.properties; _i < _a.length; _i++) { + var attributeDecl = _a[_i]; + var member = attributeDecl.symbol; + if (ts.isJsxAttribute(attributeDecl)) { + var exprType = checkJsxAttribute(attributeDecl, checkMode); + objectFlags |= ts.getObjectFlags(exprType) & 458752 /* ObjectFlags.PropagatingFlags */; + var attributeSymbol = createSymbol(4 /* SymbolFlags.Property */ | member.flags, member.escapedName); + attributeSymbol.declarations = member.declarations; + attributeSymbol.parent = member.parent; + if (member.valueDeclaration) { + attributeSymbol.valueDeclaration = member.valueDeclaration; + } + attributeSymbol.type = exprType; + attributeSymbol.target = member; + attributesTable.set(attributeSymbol.escapedName, attributeSymbol); + allAttributesTable === null || allAttributesTable === void 0 ? void 0 : allAttributesTable.set(attributeSymbol.escapedName, attributeSymbol); + if (attributeDecl.name.escapedText === jsxChildrenPropertyName) { + explicitlySpecifyChildrenAttribute = true; + } + if (attributesType) { + var prop = getPropertyOfType(attributesType, member.escapedName); + if (prop && prop.declarations && isDeprecatedSymbol(prop)) { + addDeprecatedSuggestion(attributeDecl.name, prop.declarations, attributeDecl.name.escapedText); + } + } + } + else { + ts.Debug.assert(attributeDecl.kind === 290 /* SyntaxKind.JsxSpreadAttribute */); + if (attributesTable.size > 0) { + spread = getSpreadType(spread, createJsxAttributesType(), attributes.symbol, objectFlags, /*readonly*/ false); + attributesTable = ts.createSymbolTable(); + } + var exprType = getReducedType(checkExpressionCached(attributeDecl.expression, checkMode)); + if (isTypeAny(exprType)) { + hasSpreadAnyType = true; + } + if (isValidSpreadType(exprType)) { + spread = getSpreadType(spread, exprType, attributes.symbol, objectFlags, /*readonly*/ false); + if (allAttributesTable) { + checkSpreadPropOverrides(exprType, allAttributesTable, attributeDecl); + } + } + else { + error(attributeDecl.expression, ts.Diagnostics.Spread_types_may_only_be_created_from_object_types); + typeToIntersect = typeToIntersect ? getIntersectionType([typeToIntersect, exprType]) : exprType; + } + } + } + if (!hasSpreadAnyType) { + if (attributesTable.size > 0) { + spread = getSpreadType(spread, createJsxAttributesType(), attributes.symbol, objectFlags, /*readonly*/ false); + } + } + // Handle children attribute + var parent = openingLikeElement.parent.kind === 281 /* SyntaxKind.JsxElement */ ? openingLikeElement.parent : undefined; + // We have to check that openingElement of the parent is the one we are visiting as this may not be true for selfClosingElement + if (parent && parent.openingElement === openingLikeElement && parent.children.length > 0) { + var childrenTypes = checkJsxChildren(parent, checkMode); + if (!hasSpreadAnyType && jsxChildrenPropertyName && jsxChildrenPropertyName !== "") { + // Error if there is a attribute named "children" explicitly specified and children element. + // This is because children element will overwrite the value from attributes. + // Note: we will not warn "children" attribute overwritten if "children" attribute is specified in object spread. + if (explicitlySpecifyChildrenAttribute) { + error(attributes, ts.Diagnostics._0_are_specified_twice_The_attribute_named_0_will_be_overwritten, ts.unescapeLeadingUnderscores(jsxChildrenPropertyName)); + } + var contextualType = getApparentTypeOfContextualType(openingLikeElement.attributes, /*contextFlags*/ undefined); + var childrenContextualType = contextualType && getTypeOfPropertyOfContextualType(contextualType, jsxChildrenPropertyName); + // If there are children in the body of JSX element, create dummy attribute "children" with the union of children types so that it will pass the attribute checking process + var childrenPropSymbol = createSymbol(4 /* SymbolFlags.Property */, jsxChildrenPropertyName); + childrenPropSymbol.type = childrenTypes.length === 1 ? childrenTypes[0] : + childrenContextualType && someType(childrenContextualType, isTupleLikeType) ? createTupleType(childrenTypes) : + createArrayType(getUnionType(childrenTypes)); + // Fake up a property declaration for the children + childrenPropSymbol.valueDeclaration = ts.factory.createPropertySignature(/*modifiers*/ undefined, ts.unescapeLeadingUnderscores(jsxChildrenPropertyName), /*questionToken*/ undefined, /*type*/ undefined); + ts.setParent(childrenPropSymbol.valueDeclaration, attributes); + childrenPropSymbol.valueDeclaration.symbol = childrenPropSymbol; + var childPropMap = ts.createSymbolTable(); + childPropMap.set(jsxChildrenPropertyName, childrenPropSymbol); + spread = getSpreadType(spread, createAnonymousType(attributes.symbol, childPropMap, ts.emptyArray, ts.emptyArray, ts.emptyArray), attributes.symbol, objectFlags, /*readonly*/ false); + } + } + if (hasSpreadAnyType) { + return anyType; + } + if (typeToIntersect && spread !== emptyJsxObjectType) { + return getIntersectionType([typeToIntersect, spread]); + } + return typeToIntersect || (spread === emptyJsxObjectType ? createJsxAttributesType() : spread); + /** + * Create anonymous type from given attributes symbol table. + * @param symbol a symbol of JsxAttributes containing attributes corresponding to attributesTable + * @param attributesTable a symbol table of attributes property + */ + function createJsxAttributesType() { + objectFlags |= freshObjectLiteralFlag; + var result = createAnonymousType(attributes.symbol, attributesTable, ts.emptyArray, ts.emptyArray, ts.emptyArray); + result.objectFlags |= objectFlags | 128 /* ObjectFlags.ObjectLiteral */ | 131072 /* ObjectFlags.ContainsObjectOrArrayLiteral */; + return result; + } + } + function checkJsxChildren(node, checkMode) { + var childrenTypes = []; + for (var _i = 0, _a = node.children; _i < _a.length; _i++) { + var child = _a[_i]; + // In React, JSX text that contains only whitespaces will be ignored so we don't want to type-check that + // because then type of children property will have constituent of string type. + if (child.kind === 11 /* SyntaxKind.JsxText */) { + if (!child.containsOnlyTriviaWhiteSpaces) { + childrenTypes.push(stringType); + } + } + else if (child.kind === 291 /* SyntaxKind.JsxExpression */ && !child.expression) { + continue; // empty jsx expressions don't *really* count as present children + } + else { + childrenTypes.push(checkExpressionForMutableLocation(child, checkMode)); + } + } + return childrenTypes; + } + function checkSpreadPropOverrides(type, props, spread) { + for (var _i = 0, _a = getPropertiesOfType(type); _i < _a.length; _i++) { + var right = _a[_i]; + if (!(right.flags & 16777216 /* SymbolFlags.Optional */)) { + var left = props.get(right.escapedName); + if (left) { + var diagnostic = error(left.valueDeclaration, ts.Diagnostics._0_is_specified_more_than_once_so_this_usage_will_be_overwritten, ts.unescapeLeadingUnderscores(left.escapedName)); + ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(spread, ts.Diagnostics.This_spread_always_overwrites_this_property)); + } + } + } + } + /** + * Check attributes property of opening-like element. This function is called during chooseOverload to get call signature of a JSX opening-like element. + * (See "checkApplicableSignatureForJsxOpeningLikeElement" for how the function is used) + * @param node a JSXAttributes to be resolved of its type + */ + function checkJsxAttributes(node, checkMode) { + return createJsxAttributesTypeFromAttributesProperty(node.parent, checkMode); + } + function getJsxType(name, location) { + var namespace = getJsxNamespaceAt(location); + var exports = namespace && getExportsOfSymbol(namespace); + var typeSymbol = exports && getSymbol(exports, name, 788968 /* SymbolFlags.Type */); + return typeSymbol ? getDeclaredTypeOfSymbol(typeSymbol) : errorType; + } + /** + * Looks up an intrinsic tag name and returns a symbol that either points to an intrinsic + * property (in which case nodeLinks.jsxFlags will be IntrinsicNamedElement) or an intrinsic + * string index signature (in which case nodeLinks.jsxFlags will be IntrinsicIndexedElement). + * May also return unknownSymbol if both of these lookups fail. + */ + function getIntrinsicTagSymbol(node) { + var links = getNodeLinks(node); + if (!links.resolvedSymbol) { + var intrinsicElementsType = getJsxType(JsxNames.IntrinsicElements, node); + if (!isErrorType(intrinsicElementsType)) { + // Property case + if (!ts.isIdentifier(node.tagName)) + return ts.Debug.fail(); + var intrinsicProp = getPropertyOfType(intrinsicElementsType, node.tagName.escapedText); + if (intrinsicProp) { + links.jsxFlags |= 1 /* JsxFlags.IntrinsicNamedElement */; + return links.resolvedSymbol = intrinsicProp; + } + // Intrinsic string indexer case + var indexSignatureType = getIndexTypeOfType(intrinsicElementsType, stringType); + if (indexSignatureType) { + links.jsxFlags |= 2 /* JsxFlags.IntrinsicIndexedElement */; + return links.resolvedSymbol = intrinsicElementsType.symbol; + } + // Wasn't found + error(node, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.idText(node.tagName), "JSX." + JsxNames.IntrinsicElements); + return links.resolvedSymbol = unknownSymbol; + } + else { + if (noImplicitAny) { + error(node, ts.Diagnostics.JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists, ts.unescapeLeadingUnderscores(JsxNames.IntrinsicElements)); + } + return links.resolvedSymbol = unknownSymbol; + } + } + return links.resolvedSymbol; + } + function getJsxNamespaceContainerForImplicitImport(location) { + var file = location && ts.getSourceFileOfNode(location); + var links = file && getNodeLinks(file); + if (links && links.jsxImplicitImportContainer === false) { + return undefined; + } + if (links && links.jsxImplicitImportContainer) { + return links.jsxImplicitImportContainer; + } + var runtimeImportSpecifier = ts.getJSXRuntimeImport(ts.getJSXImplicitImportBase(compilerOptions, file), compilerOptions); + if (!runtimeImportSpecifier) { + return undefined; + } + var isClassic = ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.Classic; + var errorMessage = isClassic + ? ts.Diagnostics.Cannot_find_module_0_Did_you_mean_to_set_the_moduleResolution_option_to_node_or_to_add_aliases_to_the_paths_option + : ts.Diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations; + var mod = resolveExternalModule(location, runtimeImportSpecifier, errorMessage, location); + var result = mod && mod !== unknownSymbol ? getMergedSymbol(resolveSymbol(mod)) : undefined; + if (links) { + links.jsxImplicitImportContainer = result || false; + } + return result; + } + function getJsxNamespaceAt(location) { + var links = location && getNodeLinks(location); + if (links && links.jsxNamespace) { + return links.jsxNamespace; + } + if (!links || links.jsxNamespace !== false) { + var resolvedNamespace = getJsxNamespaceContainerForImplicitImport(location); + if (!resolvedNamespace || resolvedNamespace === unknownSymbol) { + var namespaceName = getJsxNamespace(location); + resolvedNamespace = resolveName(location, namespaceName, 1920 /* SymbolFlags.Namespace */, /*diagnosticMessage*/ undefined, namespaceName, /*isUse*/ false); + } + if (resolvedNamespace) { + var candidate = resolveSymbol(getSymbol(getExportsOfSymbol(resolveSymbol(resolvedNamespace)), JsxNames.JSX, 1920 /* SymbolFlags.Namespace */)); + if (candidate && candidate !== unknownSymbol) { + if (links) { + links.jsxNamespace = candidate; + } + return candidate; + } + } + if (links) { + links.jsxNamespace = false; + } + } + // JSX global fallback + var s = resolveSymbol(getGlobalSymbol(JsxNames.JSX, 1920 /* SymbolFlags.Namespace */, /*diagnosticMessage*/ undefined)); + if (s === unknownSymbol) { + return undefined; // TODO: GH#18217 + } + return s; // TODO: GH#18217 + } + /** + * Look into JSX namespace and then look for container with matching name as nameOfAttribPropContainer. + * Get a single property from that container if existed. Report an error if there are more than one property. + * + * @param nameOfAttribPropContainer a string of value JsxNames.ElementAttributesPropertyNameContainer or JsxNames.ElementChildrenAttributeNameContainer + * if other string is given or the container doesn't exist, return undefined. + */ + function getNameFromJsxElementAttributesContainer(nameOfAttribPropContainer, jsxNamespace) { + // JSX.ElementAttributesProperty | JSX.ElementChildrenAttribute [symbol] + var jsxElementAttribPropInterfaceSym = jsxNamespace && getSymbol(jsxNamespace.exports, nameOfAttribPropContainer, 788968 /* SymbolFlags.Type */); + // JSX.ElementAttributesProperty | JSX.ElementChildrenAttribute [type] + var jsxElementAttribPropInterfaceType = jsxElementAttribPropInterfaceSym && getDeclaredTypeOfSymbol(jsxElementAttribPropInterfaceSym); + // The properties of JSX.ElementAttributesProperty | JSX.ElementChildrenAttribute + var propertiesOfJsxElementAttribPropInterface = jsxElementAttribPropInterfaceType && getPropertiesOfType(jsxElementAttribPropInterfaceType); + if (propertiesOfJsxElementAttribPropInterface) { + // Element Attributes has zero properties, so the element attributes type will be the class instance type + if (propertiesOfJsxElementAttribPropInterface.length === 0) { + return ""; + } + // Element Attributes has one property, so the element attributes type will be the type of the corresponding + // property of the class instance type + else if (propertiesOfJsxElementAttribPropInterface.length === 1) { + return propertiesOfJsxElementAttribPropInterface[0].escapedName; + } + else if (propertiesOfJsxElementAttribPropInterface.length > 1 && jsxElementAttribPropInterfaceSym.declarations) { + // More than one property on ElementAttributesProperty is an error + error(jsxElementAttribPropInterfaceSym.declarations[0], ts.Diagnostics.The_global_type_JSX_0_may_not_have_more_than_one_property, ts.unescapeLeadingUnderscores(nameOfAttribPropContainer)); + } + } + return undefined; + } + function getJsxLibraryManagedAttributes(jsxNamespace) { + // JSX.LibraryManagedAttributes [symbol] + return jsxNamespace && getSymbol(jsxNamespace.exports, JsxNames.LibraryManagedAttributes, 788968 /* SymbolFlags.Type */); + } + /// e.g. "props" for React.d.ts, + /// or 'undefined' if ElementAttributesProperty doesn't exist (which means all + /// non-intrinsic elements' attributes type is 'any'), + /// or '' if it has 0 properties (which means every + /// non-intrinsic elements' attributes type is the element instance type) + function getJsxElementPropertiesName(jsxNamespace) { + return getNameFromJsxElementAttributesContainer(JsxNames.ElementAttributesPropertyNameContainer, jsxNamespace); + } + function getJsxElementChildrenPropertyName(jsxNamespace) { + return getNameFromJsxElementAttributesContainer(JsxNames.ElementChildrenAttributeNameContainer, jsxNamespace); + } + function getUninstantiatedJsxSignaturesOfType(elementType, caller) { + if (elementType.flags & 4 /* TypeFlags.String */) { + return [anySignature]; + } + else if (elementType.flags & 128 /* TypeFlags.StringLiteral */) { + var intrinsicType = getIntrinsicAttributesTypeFromStringLiteralType(elementType, caller); + if (!intrinsicType) { + error(caller, ts.Diagnostics.Property_0_does_not_exist_on_type_1, elementType.value, "JSX." + JsxNames.IntrinsicElements); + return ts.emptyArray; + } + else { + var fakeSignature = createSignatureForJSXIntrinsic(caller, intrinsicType); + return [fakeSignature]; + } + } + var apparentElemType = getApparentType(elementType); + // Resolve the signatures, preferring constructor + var signatures = getSignaturesOfType(apparentElemType, 1 /* SignatureKind.Construct */); + if (signatures.length === 0) { + // No construct signatures, try call signatures + signatures = getSignaturesOfType(apparentElemType, 0 /* SignatureKind.Call */); + } + if (signatures.length === 0 && apparentElemType.flags & 1048576 /* TypeFlags.Union */) { + // If each member has some combination of new/call signatures; make a union signature list for those + signatures = getUnionSignatures(ts.map(apparentElemType.types, function (t) { return getUninstantiatedJsxSignaturesOfType(t, caller); })); + } + return signatures; + } + function getIntrinsicAttributesTypeFromStringLiteralType(type, location) { + // If the elemType is a stringLiteral type, we can then provide a check to make sure that the string literal type is one of the Jsx intrinsic element type + // For example: + // var CustomTag: "h1" = "h1"; + // Hello World + var intrinsicElementsType = getJsxType(JsxNames.IntrinsicElements, location); + if (!isErrorType(intrinsicElementsType)) { + var stringLiteralTypeName = type.value; + var intrinsicProp = getPropertyOfType(intrinsicElementsType, ts.escapeLeadingUnderscores(stringLiteralTypeName)); + if (intrinsicProp) { + return getTypeOfSymbol(intrinsicProp); + } + var indexSignatureType = getIndexTypeOfType(intrinsicElementsType, stringType); + if (indexSignatureType) { + return indexSignatureType; + } + return undefined; + } + // If we need to report an error, we already done so here. So just return any to prevent any more error downstream + return anyType; + } + function checkJsxReturnAssignableToAppropriateBound(refKind, elemInstanceType, openingLikeElement) { + if (refKind === 1 /* JsxReferenceKind.Function */) { + var sfcReturnConstraint = getJsxStatelessElementTypeAt(openingLikeElement); + if (sfcReturnConstraint) { + checkTypeRelatedTo(elemInstanceType, sfcReturnConstraint, assignableRelation, openingLikeElement.tagName, ts.Diagnostics.Its_return_type_0_is_not_a_valid_JSX_element, generateInitialErrorChain); + } + } + else if (refKind === 0 /* JsxReferenceKind.Component */) { + var classConstraint = getJsxElementClassTypeAt(openingLikeElement); + if (classConstraint) { + // Issue an error if this return type isn't assignable to JSX.ElementClass, failing that + checkTypeRelatedTo(elemInstanceType, classConstraint, assignableRelation, openingLikeElement.tagName, ts.Diagnostics.Its_instance_type_0_is_not_a_valid_JSX_element, generateInitialErrorChain); + } + } + else { // Mixed + var sfcReturnConstraint = getJsxStatelessElementTypeAt(openingLikeElement); + var classConstraint = getJsxElementClassTypeAt(openingLikeElement); + if (!sfcReturnConstraint || !classConstraint) { + return; + } + var combined = getUnionType([sfcReturnConstraint, classConstraint]); + checkTypeRelatedTo(elemInstanceType, combined, assignableRelation, openingLikeElement.tagName, ts.Diagnostics.Its_element_type_0_is_not_a_valid_JSX_element, generateInitialErrorChain); + } + function generateInitialErrorChain() { + var componentName = ts.getTextOfNode(openingLikeElement.tagName); + return ts.chainDiagnosticMessages(/* details */ undefined, ts.Diagnostics._0_cannot_be_used_as_a_JSX_component, componentName); + } + } + /** + * Get attributes type of the given intrinsic opening-like Jsx element by resolving the tag name. + * The function is intended to be called from a function which has checked that the opening element is an intrinsic element. + * @param node an intrinsic JSX opening-like element + */ + function getIntrinsicAttributesTypeFromJsxOpeningLikeElement(node) { + ts.Debug.assert(isJsxIntrinsicIdentifier(node.tagName)); + var links = getNodeLinks(node); + if (!links.resolvedJsxElementAttributesType) { + var symbol = getIntrinsicTagSymbol(node); + if (links.jsxFlags & 1 /* JsxFlags.IntrinsicNamedElement */) { + return links.resolvedJsxElementAttributesType = getTypeOfSymbol(symbol) || errorType; + } + else if (links.jsxFlags & 2 /* JsxFlags.IntrinsicIndexedElement */) { + return links.resolvedJsxElementAttributesType = + getIndexTypeOfType(getJsxType(JsxNames.IntrinsicElements, node), stringType) || errorType; + } + else { + return links.resolvedJsxElementAttributesType = errorType; + } + } + return links.resolvedJsxElementAttributesType; + } + function getJsxElementClassTypeAt(location) { + var type = getJsxType(JsxNames.ElementClass, location); + if (isErrorType(type)) + return undefined; + return type; + } + function getJsxElementTypeAt(location) { + return getJsxType(JsxNames.Element, location); + } + function getJsxStatelessElementTypeAt(location) { + var jsxElementType = getJsxElementTypeAt(location); + if (jsxElementType) { + return getUnionType([jsxElementType, nullType]); + } + } + /** + * Returns all the properties of the Jsx.IntrinsicElements interface + */ + function getJsxIntrinsicTagNamesAt(location) { + var intrinsics = getJsxType(JsxNames.IntrinsicElements, location); + return intrinsics ? getPropertiesOfType(intrinsics) : ts.emptyArray; + } + function checkJsxPreconditions(errorNode) { + // Preconditions for using JSX + if ((compilerOptions.jsx || 0 /* JsxEmit.None */) === 0 /* JsxEmit.None */) { + error(errorNode, ts.Diagnostics.Cannot_use_JSX_unless_the_jsx_flag_is_provided); + } + if (getJsxElementTypeAt(errorNode) === undefined) { + if (noImplicitAny) { + error(errorNode, ts.Diagnostics.JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist); + } + } + } + function checkJsxOpeningLikeElementOrOpeningFragment(node) { + var isNodeOpeningLikeElement = ts.isJsxOpeningLikeElement(node); + if (isNodeOpeningLikeElement) { + checkGrammarJsxElement(node); + } + checkJsxPreconditions(node); + if (!getJsxNamespaceContainerForImplicitImport(node)) { + // The reactNamespace/jsxFactory's root symbol should be marked as 'used' so we don't incorrectly elide its import. + // And if there is no reactNamespace/jsxFactory's symbol in scope when targeting React emit, we should issue an error. + var jsxFactoryRefErr = diagnostics && compilerOptions.jsx === 2 /* JsxEmit.React */ ? ts.Diagnostics.Cannot_find_name_0 : undefined; + var jsxFactoryNamespace = getJsxNamespace(node); + var jsxFactoryLocation = isNodeOpeningLikeElement ? node.tagName : node; + // allow null as jsxFragmentFactory + var jsxFactorySym = void 0; + if (!(ts.isJsxOpeningFragment(node) && jsxFactoryNamespace === "null")) { + jsxFactorySym = resolveName(jsxFactoryLocation, jsxFactoryNamespace, 111551 /* SymbolFlags.Value */, jsxFactoryRefErr, jsxFactoryNamespace, /*isUse*/ true); + } + if (jsxFactorySym) { + // Mark local symbol as referenced here because it might not have been marked + // if jsx emit was not jsxFactory as there wont be error being emitted + jsxFactorySym.isReferenced = 67108863 /* SymbolFlags.All */; + // If react/jsxFactory symbol is alias, mark it as refereced + if (jsxFactorySym.flags & 2097152 /* SymbolFlags.Alias */ && !getTypeOnlyAliasDeclaration(jsxFactorySym)) { + markAliasSymbolAsReferenced(jsxFactorySym); + } + } + // For JsxFragment, mark jsx pragma as referenced via resolveName + if (ts.isJsxOpeningFragment(node)) { + var file = ts.getSourceFileOfNode(node); + var localJsxNamespace = getLocalJsxNamespace(file); + if (localJsxNamespace) { + resolveName(jsxFactoryLocation, localJsxNamespace, 111551 /* SymbolFlags.Value */, jsxFactoryRefErr, localJsxNamespace, /*isUse*/ true); + } + } + } + if (isNodeOpeningLikeElement) { + var jsxOpeningLikeNode = node; + var sig = getResolvedSignature(jsxOpeningLikeNode); + checkDeprecatedSignature(sig, node); + checkJsxReturnAssignableToAppropriateBound(getJsxReferenceKind(jsxOpeningLikeNode), getReturnTypeOfSignature(sig), jsxOpeningLikeNode); + } + } + /** + * Check if a property with the given name is known anywhere in the given type. In an object type, a property + * is considered known if + * 1. the object type is empty and the check is for assignability, or + * 2. if the object type has index signatures, or + * 3. if the property is actually declared in the object type + * (this means that 'toString', for example, is not usually a known property). + * 4. In a union or intersection type, + * a property is considered known if it is known in any constituent type. + * @param targetType a type to search a given name in + * @param name a property name to search + * @param isComparingJsxAttributes a boolean flag indicating whether we are searching in JsxAttributesType + */ + function isKnownProperty(targetType, name, isComparingJsxAttributes) { + if (targetType.flags & 524288 /* TypeFlags.Object */) { + // For backwards compatibility a symbol-named property is satisfied by a string index signature. This + // is incorrect and inconsistent with element access expressions, where it is an error, so eventually + // we should remove this exception. + if (getPropertyOfObjectType(targetType, name) || + getApplicableIndexInfoForName(targetType, name) || + isLateBoundName(name) && getIndexInfoOfType(targetType, stringType) || + isComparingJsxAttributes && isHyphenatedJsxName(name)) { + // For JSXAttributes, if the attribute has a hyphenated name, consider that the attribute to be known. + return true; + } + } + else if (targetType.flags & 3145728 /* TypeFlags.UnionOrIntersection */ && isExcessPropertyCheckTarget(targetType)) { + for (var _i = 0, _a = targetType.types; _i < _a.length; _i++) { + var t = _a[_i]; + if (isKnownProperty(t, name, isComparingJsxAttributes)) { + return true; + } + } + } + return false; + } + function isExcessPropertyCheckTarget(type) { + return !!(type.flags & 524288 /* TypeFlags.Object */ && !(ts.getObjectFlags(type) & 512 /* ObjectFlags.ObjectLiteralPatternWithComputedProperties */) || + type.flags & 67108864 /* TypeFlags.NonPrimitive */ || + type.flags & 1048576 /* TypeFlags.Union */ && ts.some(type.types, isExcessPropertyCheckTarget) || + type.flags & 2097152 /* TypeFlags.Intersection */ && ts.every(type.types, isExcessPropertyCheckTarget)); + } + function checkJsxExpression(node, checkMode) { + checkGrammarJsxExpression(node); + if (node.expression) { + var type = checkExpression(node.expression, checkMode); + if (node.dotDotDotToken && type !== anyType && !isArrayType(type)) { + error(node, ts.Diagnostics.JSX_spread_child_must_be_an_array_type); + } + return type; + } + else { + return errorType; + } + } + function getDeclarationNodeFlagsFromSymbol(s) { + return s.valueDeclaration ? ts.getCombinedNodeFlags(s.valueDeclaration) : 0; + } + /** + * Return whether this symbol is a member of a prototype somewhere + * Note that this is not tracked well within the compiler, so the answer may be incorrect. + */ + function isPrototypeProperty(symbol) { + if (symbol.flags & 8192 /* SymbolFlags.Method */ || ts.getCheckFlags(symbol) & 4 /* CheckFlags.SyntheticMethod */) { + return true; + } + if (ts.isInJSFile(symbol.valueDeclaration)) { + var parent = symbol.valueDeclaration.parent; + return parent && ts.isBinaryExpression(parent) && + ts.getAssignmentDeclarationKind(parent) === 3 /* AssignmentDeclarationKind.PrototypeProperty */; + } + } + /** + * Check whether the requested property access is valid. + * Returns true if node is a valid property access, and false otherwise. + * @param node The node to be checked. + * @param isSuper True if the access is from `super.`. + * @param type The type of the object whose property is being accessed. (Not the type of the property.) + * @param prop The symbol for the property being accessed. + */ + function checkPropertyAccessibility(node, isSuper, writing, type, prop, reportError) { + if (reportError === void 0) { reportError = true; } + var errorNode = !reportError ? undefined : + node.kind === 163 /* SyntaxKind.QualifiedName */ ? node.right : + node.kind === 202 /* SyntaxKind.ImportType */ ? node : + node.kind === 205 /* SyntaxKind.BindingElement */ && node.propertyName ? node.propertyName : node.name; + return checkPropertyAccessibilityAtLocation(node, isSuper, writing, type, prop, errorNode); + } + /** + * Check whether the requested property can be accessed at the requested location. + * Returns true if node is a valid property access, and false otherwise. + * @param location The location node where we want to check if the property is accessible. + * @param isSuper True if the access is from `super.`. + * @param writing True if this is a write property access, false if it is a read property access. + * @param containingType The type of the object whose property is being accessed. (Not the type of the property.) + * @param prop The symbol for the property being accessed. + * @param errorNode The node where we should report an invalid property access error, or undefined if we should not report errors. + */ + function checkPropertyAccessibilityAtLocation(location, isSuper, writing, containingType, prop, errorNode) { + var flags = ts.getDeclarationModifierFlagsFromSymbol(prop, writing); + if (isSuper) { + // TS 1.0 spec (April 2014): 4.8.2 + // - In a constructor, instance member function, instance member accessor, or + // instance member variable initializer where this references a derived class instance, + // a super property access is permitted and must specify a public instance member function of the base class. + // - In a static member function or static member accessor + // where this references the constructor function object of a derived class, + // a super property access is permitted and must specify a public static member function of the base class. + if (languageVersion < 2 /* ScriptTarget.ES2015 */) { + if (symbolHasNonMethodDeclaration(prop)) { + if (errorNode) { + error(errorNode, ts.Diagnostics.Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword); + } + return false; + } + } + if (flags & 256 /* ModifierFlags.Abstract */) { + // A method cannot be accessed in a super property access if the method is abstract. + // This error could mask a private property access error. But, a member + // cannot simultaneously be private and abstract, so this will trigger an + // additional error elsewhere. + if (errorNode) { + error(errorNode, ts.Diagnostics.Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression, symbolToString(prop), typeToString(getDeclaringClass(prop))); + } + return false; + } + } + // Referencing abstract properties within their own constructors is not allowed + if ((flags & 256 /* ModifierFlags.Abstract */) && symbolHasNonMethodDeclaration(prop) && + (ts.isThisProperty(location) || ts.isThisInitializedObjectBindingExpression(location) || ts.isObjectBindingPattern(location.parent) && ts.isThisInitializedDeclaration(location.parent.parent))) { + var declaringClassDeclaration = ts.getClassLikeDeclarationOfSymbol(getParentOfSymbol(prop)); + if (declaringClassDeclaration && isNodeUsedDuringClassInitialization(location)) { + if (errorNode) { + error(errorNode, ts.Diagnostics.Abstract_property_0_in_class_1_cannot_be_accessed_in_the_constructor, symbolToString(prop), ts.getTextOfIdentifierOrLiteral(declaringClassDeclaration.name)); + } + return false; + } + } + // Public properties are otherwise accessible. + if (!(flags & 24 /* ModifierFlags.NonPublicAccessibilityModifier */)) { + return true; + } + // Property is known to be private or protected at this point + // Private property is accessible if the property is within the declaring class + if (flags & 8 /* ModifierFlags.Private */) { + var declaringClassDeclaration = ts.getClassLikeDeclarationOfSymbol(getParentOfSymbol(prop)); + if (!isNodeWithinClass(location, declaringClassDeclaration)) { + if (errorNode) { + error(errorNode, ts.Diagnostics.Property_0_is_private_and_only_accessible_within_class_1, symbolToString(prop), typeToString(getDeclaringClass(prop))); + } + return false; + } + return true; + } + // Property is known to be protected at this point + // All protected properties of a supertype are accessible in a super access + if (isSuper) { + return true; + } + // Find the first enclosing class that has the declaring classes of the protected constituents + // of the property as base classes + var enclosingClass = forEachEnclosingClass(location, function (enclosingDeclaration) { + var enclosingClass = getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingDeclaration)); + return isClassDerivedFromDeclaringClasses(enclosingClass, prop, writing); + }); + // A protected property is accessible if the property is within the declaring class or classes derived from it + if (!enclosingClass) { + // allow PropertyAccessibility if context is in function with this parameter + // static member access is disallowed + enclosingClass = getEnclosingClassFromThisParameter(location); + enclosingClass = enclosingClass && isClassDerivedFromDeclaringClasses(enclosingClass, prop, writing); + if (flags & 32 /* ModifierFlags.Static */ || !enclosingClass) { + if (errorNode) { + error(errorNode, ts.Diagnostics.Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses, symbolToString(prop), typeToString(getDeclaringClass(prop) || containingType)); + } + return false; + } + } + // No further restrictions for static properties + if (flags & 32 /* ModifierFlags.Static */) { + return true; + } + if (containingType.flags & 262144 /* TypeFlags.TypeParameter */) { + // get the original type -- represented as the type constraint of the 'this' type + containingType = containingType.isThisType ? getConstraintOfTypeParameter(containingType) : getBaseConstraintOfType(containingType); // TODO: GH#18217 Use a different variable that's allowed to be undefined + } + if (!containingType || !hasBaseType(containingType, enclosingClass)) { + if (errorNode) { + error(errorNode, ts.Diagnostics.Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1_This_is_an_instance_of_class_2, symbolToString(prop), typeToString(enclosingClass), typeToString(containingType)); + } + return false; + } + return true; + } + function getEnclosingClassFromThisParameter(node) { + var thisParameter = getThisParameterFromNodeContext(node); + var thisType = (thisParameter === null || thisParameter === void 0 ? void 0 : thisParameter.type) && getTypeFromTypeNode(thisParameter.type); + if (thisType && thisType.flags & 262144 /* TypeFlags.TypeParameter */) { + thisType = getConstraintOfTypeParameter(thisType); + } + if (thisType && ts.getObjectFlags(thisType) & (3 /* ObjectFlags.ClassOrInterface */ | 4 /* ObjectFlags.Reference */)) { + return getTargetType(thisType); + } + return undefined; + } + function getThisParameterFromNodeContext(node) { + var thisContainer = ts.getThisContainer(node, /* includeArrowFunctions */ false); + return thisContainer && ts.isFunctionLike(thisContainer) ? ts.getThisParameter(thisContainer) : undefined; + } + function symbolHasNonMethodDeclaration(symbol) { + return !!forEachProperty(symbol, function (prop) { return !(prop.flags & 8192 /* SymbolFlags.Method */); }); + } + function checkNonNullExpression(node) { + return checkNonNullType(checkExpression(node), node); + } + function isNullableType(type) { + return !!(getTypeFacts(type) & 50331648 /* TypeFacts.IsUndefinedOrNull */); + } + function getNonNullableTypeIfNeeded(type) { + return isNullableType(type) ? getNonNullableType(type) : type; + } + function reportObjectPossiblyNullOrUndefinedError(node, facts) { + var nodeText = ts.isEntityNameExpression(node) ? ts.entityNameToString(node) : undefined; + if (node.kind === 104 /* SyntaxKind.NullKeyword */) { + error(node, ts.Diagnostics.The_value_0_cannot_be_used_here, "null"); + return; + } + if (nodeText !== undefined && nodeText.length < 100) { + if (ts.isIdentifier(node) && nodeText === "undefined") { + error(node, ts.Diagnostics.The_value_0_cannot_be_used_here, "undefined"); + return; + } + error(node, facts & 16777216 /* TypeFacts.IsUndefined */ ? facts & 33554432 /* TypeFacts.IsNull */ ? + ts.Diagnostics._0_is_possibly_null_or_undefined : + ts.Diagnostics._0_is_possibly_undefined : + ts.Diagnostics._0_is_possibly_null, nodeText); + } + else { + error(node, facts & 16777216 /* TypeFacts.IsUndefined */ ? facts & 33554432 /* TypeFacts.IsNull */ ? + ts.Diagnostics.Object_is_possibly_null_or_undefined : + ts.Diagnostics.Object_is_possibly_undefined : + ts.Diagnostics.Object_is_possibly_null); + } + } + function reportCannotInvokePossiblyNullOrUndefinedError(node, facts) { + error(node, facts & 16777216 /* TypeFacts.IsUndefined */ ? facts & 33554432 /* TypeFacts.IsNull */ ? + ts.Diagnostics.Cannot_invoke_an_object_which_is_possibly_null_or_undefined : + ts.Diagnostics.Cannot_invoke_an_object_which_is_possibly_undefined : + ts.Diagnostics.Cannot_invoke_an_object_which_is_possibly_null); + } + function checkNonNullTypeWithReporter(type, node, reportError) { + if (strictNullChecks && type.flags & 2 /* TypeFlags.Unknown */) { + if (ts.isEntityNameExpression(node)) { + var nodeText = ts.entityNameToString(node); + if (nodeText.length < 100) { + error(node, ts.Diagnostics._0_is_of_type_unknown, nodeText); + return errorType; + } + } + error(node, ts.Diagnostics.Object_is_of_type_unknown); + return errorType; + } + var facts = getTypeFacts(type); + if (facts & 50331648 /* TypeFacts.IsUndefinedOrNull */) { + reportError(node, facts); + var t = getNonNullableType(type); + return t.flags & (98304 /* TypeFlags.Nullable */ | 131072 /* TypeFlags.Never */) ? errorType : t; + } + return type; + } + function checkNonNullType(type, node) { + return checkNonNullTypeWithReporter(type, node, reportObjectPossiblyNullOrUndefinedError); + } + function checkNonNullNonVoidType(type, node) { + var nonNullType = checkNonNullType(type, node); + if (nonNullType.flags & 16384 /* TypeFlags.Void */) { + if (ts.isEntityNameExpression(node)) { + var nodeText = ts.entityNameToString(node); + if (ts.isIdentifier(node) && nodeText === "undefined") { + error(node, ts.Diagnostics.The_value_0_cannot_be_used_here, nodeText); + return nonNullType; + } + if (nodeText.length < 100) { + error(node, ts.Diagnostics._0_is_possibly_undefined, nodeText); + return nonNullType; + } + } + error(node, ts.Diagnostics.Object_is_possibly_undefined); + } + return nonNullType; + } + function checkPropertyAccessExpression(node, checkMode) { + return node.flags & 32 /* NodeFlags.OptionalChain */ ? checkPropertyAccessChain(node, checkMode) : + checkPropertyAccessExpressionOrQualifiedName(node, node.expression, checkNonNullExpression(node.expression), node.name, checkMode); + } + function checkPropertyAccessChain(node, checkMode) { + var leftType = checkExpression(node.expression); + var nonOptionalType = getOptionalExpressionType(leftType, node.expression); + return propagateOptionalTypeMarker(checkPropertyAccessExpressionOrQualifiedName(node, node.expression, checkNonNullType(nonOptionalType, node.expression), node.name, checkMode), node, nonOptionalType !== leftType); + } + function checkQualifiedName(node, checkMode) { + var leftType = ts.isPartOfTypeQuery(node) && ts.isThisIdentifier(node.left) ? checkNonNullType(checkThisExpression(node.left), node.left) : checkNonNullExpression(node.left); + return checkPropertyAccessExpressionOrQualifiedName(node, node.left, leftType, node.right, checkMode); + } + function isMethodAccessForCall(node) { + while (node.parent.kind === 214 /* SyntaxKind.ParenthesizedExpression */) { + node = node.parent; + } + return ts.isCallOrNewExpression(node.parent) && node.parent.expression === node; + } + // Lookup the private identifier lexically. + function lookupSymbolForPrivateIdentifierDeclaration(propName, location) { + for (var containingClass = ts.getContainingClass(location); !!containingClass; containingClass = ts.getContainingClass(containingClass)) { + var symbol = containingClass.symbol; + var name = ts.getSymbolNameForPrivateIdentifier(symbol, propName); + var prop = (symbol.members && symbol.members.get(name)) || (symbol.exports && symbol.exports.get(name)); + if (prop) { + return prop; + } + } + } + function checkGrammarPrivateIdentifierExpression(privId) { + if (!ts.getContainingClass(privId)) { + return grammarErrorOnNode(privId, ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies); + } + if (!ts.isForInStatement(privId.parent)) { + if (!ts.isExpressionNode(privId)) { + return grammarErrorOnNode(privId, ts.Diagnostics.Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member_declaration_property_access_or_on_the_left_hand_side_of_an_in_expression); + } + var isInOperation = ts.isBinaryExpression(privId.parent) && privId.parent.operatorToken.kind === 101 /* SyntaxKind.InKeyword */; + if (!getSymbolForPrivateIdentifierExpression(privId) && !isInOperation) { + return grammarErrorOnNode(privId, ts.Diagnostics.Cannot_find_name_0, ts.idText(privId)); + } + } + return false; + } + function checkPrivateIdentifierExpression(privId) { + checkGrammarPrivateIdentifierExpression(privId); + var symbol = getSymbolForPrivateIdentifierExpression(privId); + if (symbol) { + markPropertyAsReferenced(symbol, /* nodeForCheckWriteOnly: */ undefined, /* isThisAccess: */ false); + } + return anyType; + } + function getSymbolForPrivateIdentifierExpression(privId) { + if (!ts.isExpressionNode(privId)) { + return undefined; + } + var links = getNodeLinks(privId); + if (links.resolvedSymbol === undefined) { + links.resolvedSymbol = lookupSymbolForPrivateIdentifierDeclaration(privId.escapedText, privId); + } + return links.resolvedSymbol; + } + function getPrivateIdentifierPropertyOfType(leftType, lexicallyScopedIdentifier) { + return getPropertyOfType(leftType, lexicallyScopedIdentifier.escapedName); + } + function checkPrivateIdentifierPropertyAccess(leftType, right, lexicallyScopedIdentifier) { + // Either the identifier could not be looked up in the lexical scope OR the lexically scoped identifier did not exist on the type. + // Find a private identifier with the same description on the type. + var propertyOnType; + var properties = getPropertiesOfType(leftType); + if (properties) { + ts.forEach(properties, function (symbol) { + var decl = symbol.valueDeclaration; + if (decl && ts.isNamedDeclaration(decl) && ts.isPrivateIdentifier(decl.name) && decl.name.escapedText === right.escapedText) { + propertyOnType = symbol; + return true; + } + }); + } + var diagName = diagnosticName(right); + if (propertyOnType) { + var typeValueDecl = ts.Debug.checkDefined(propertyOnType.valueDeclaration); + var typeClass_1 = ts.Debug.checkDefined(ts.getContainingClass(typeValueDecl)); + // We found a private identifier property with the same description. + // Either: + // - There is a lexically scoped private identifier AND it shadows the one we found on the type. + // - It is an attempt to access the private identifier outside of the class. + if (lexicallyScopedIdentifier === null || lexicallyScopedIdentifier === void 0 ? void 0 : lexicallyScopedIdentifier.valueDeclaration) { + var lexicalValueDecl = lexicallyScopedIdentifier.valueDeclaration; + var lexicalClass = ts.getContainingClass(lexicalValueDecl); + ts.Debug.assert(!!lexicalClass); + if (ts.findAncestor(lexicalClass, function (n) { return typeClass_1 === n; })) { + var diagnostic = error(right, ts.Diagnostics.The_property_0_cannot_be_accessed_on_type_1_within_this_class_because_it_is_shadowed_by_another_private_identifier_with_the_same_spelling, diagName, typeToString(leftType)); + ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(lexicalValueDecl, ts.Diagnostics.The_shadowing_declaration_of_0_is_defined_here, diagName), ts.createDiagnosticForNode(typeValueDecl, ts.Diagnostics.The_declaration_of_0_that_you_probably_intended_to_use_is_defined_here, diagName)); + return true; + } + } + error(right, ts.Diagnostics.Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_identifier, diagName, diagnosticName(typeClass_1.name || anon)); + return true; + } + return false; + } + function isThisPropertyAccessInConstructor(node, prop) { + return (isConstructorDeclaredProperty(prop) || ts.isThisProperty(node) && isAutoTypedProperty(prop)) + && ts.getThisContainer(node, /*includeArrowFunctions*/ true) === getDeclaringConstructor(prop); + } + function checkPropertyAccessExpressionOrQualifiedName(node, left, leftType, right, checkMode) { + var parentSymbol = getNodeLinks(left).resolvedSymbol; + var assignmentKind = ts.getAssignmentTargetKind(node); + var apparentType = getApparentType(assignmentKind !== 0 /* AssignmentKind.None */ || isMethodAccessForCall(node) ? getWidenedType(leftType) : leftType); + var isAnyLike = isTypeAny(apparentType) || apparentType === silentNeverType; + var prop; + if (ts.isPrivateIdentifier(right)) { + if (languageVersion < 99 /* ScriptTarget.ESNext */) { + if (assignmentKind !== 0 /* AssignmentKind.None */) { + checkExternalEmitHelpers(node, 1048576 /* ExternalEmitHelpers.ClassPrivateFieldSet */); + } + if (assignmentKind !== 1 /* AssignmentKind.Definite */) { + checkExternalEmitHelpers(node, 524288 /* ExternalEmitHelpers.ClassPrivateFieldGet */); + } + } + var lexicallyScopedSymbol = lookupSymbolForPrivateIdentifierDeclaration(right.escapedText, right); + if (assignmentKind && lexicallyScopedSymbol && lexicallyScopedSymbol.valueDeclaration && ts.isMethodDeclaration(lexicallyScopedSymbol.valueDeclaration)) { + grammarErrorOnNode(right, ts.Diagnostics.Cannot_assign_to_private_method_0_Private_methods_are_not_writable, ts.idText(right)); + } + if (isAnyLike) { + if (lexicallyScopedSymbol) { + return isErrorType(apparentType) ? errorType : apparentType; + } + if (!ts.getContainingClass(right)) { + grammarErrorOnNode(right, ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies); + return anyType; + } + } + prop = lexicallyScopedSymbol ? getPrivateIdentifierPropertyOfType(leftType, lexicallyScopedSymbol) : undefined; + // Check for private-identifier-specific shadowing and lexical-scoping errors. + if (!prop && checkPrivateIdentifierPropertyAccess(leftType, right, lexicallyScopedSymbol)) { + return errorType; + } + else { + var isSetonlyAccessor = prop && prop.flags & 65536 /* SymbolFlags.SetAccessor */ && !(prop.flags & 32768 /* SymbolFlags.GetAccessor */); + if (isSetonlyAccessor && assignmentKind !== 1 /* AssignmentKind.Definite */) { + error(node, ts.Diagnostics.Private_accessor_was_defined_without_a_getter); + } + } + } + else { + if (isAnyLike) { + if (ts.isIdentifier(left) && parentSymbol) { + markAliasReferenced(parentSymbol, node); + } + return isErrorType(apparentType) ? errorType : apparentType; + } + prop = getPropertyOfType(apparentType, right.escapedText, /*skipObjectFunctionPropertyAugment*/ false, /*includeTypeOnlyMembers*/ node.kind === 163 /* SyntaxKind.QualifiedName */); + } + // In `Foo.Bar.Baz`, 'Foo' is not referenced if 'Bar' is a const enum or a module containing only const enums. + // `Foo` is also not referenced in `enum FooCopy { Bar = Foo.Bar }`, because the enum member value gets inlined + // here even if `Foo` is not a const enum. + // + // The exceptions are: + // 1. if 'isolatedModules' is enabled, because the const enum value will not be inlined, and + // 2. if 'preserveConstEnums' is enabled and the expression is itself an export, e.g. `export = Foo.Bar.Baz`. + if (ts.isIdentifier(left) && parentSymbol && (compilerOptions.isolatedModules || + !(prop && (isConstEnumOrConstEnumOnlyModule(prop) || prop.flags & 8 /* SymbolFlags.EnumMember */ && node.parent.kind === 302 /* SyntaxKind.EnumMember */)) || + ts.shouldPreserveConstEnums(compilerOptions) && isExportOrExportExpression(node))) { + markAliasReferenced(parentSymbol, node); + } + var propType; + if (!prop) { + var indexInfo = !ts.isPrivateIdentifier(right) && (assignmentKind === 0 /* AssignmentKind.None */ || !isGenericObjectType(leftType) || ts.isThisTypeParameter(leftType)) ? + getApplicableIndexInfoForName(apparentType, right.escapedText) : undefined; + if (!(indexInfo && indexInfo.type)) { + var isUncheckedJS = isUncheckedJSSuggestion(node, leftType.symbol, /*excludeClasses*/ true); + if (!isUncheckedJS && isJSLiteralType(leftType)) { + return anyType; + } + if (leftType.symbol === globalThisSymbol) { + if (globalThisSymbol.exports.has(right.escapedText) && (globalThisSymbol.exports.get(right.escapedText).flags & 418 /* SymbolFlags.BlockScoped */)) { + error(right, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.unescapeLeadingUnderscores(right.escapedText), typeToString(leftType)); + } + else if (noImplicitAny) { + error(right, ts.Diagnostics.Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature, typeToString(leftType)); + } + return anyType; + } + if (right.escapedText && !checkAndReportErrorForExtendingInterface(node)) { + reportNonexistentProperty(right, ts.isThisTypeParameter(leftType) ? apparentType : leftType, isUncheckedJS); + } + return errorType; + } + if (indexInfo.isReadonly && (ts.isAssignmentTarget(node) || ts.isDeleteTarget(node))) { + error(node, ts.Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(apparentType)); + } + propType = (compilerOptions.noUncheckedIndexedAccess && !ts.isAssignmentTarget(node)) ? getUnionType([indexInfo.type, undefinedType]) : indexInfo.type; + if (compilerOptions.noPropertyAccessFromIndexSignature && ts.isPropertyAccessExpression(node)) { + error(right, ts.Diagnostics.Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0, ts.unescapeLeadingUnderscores(right.escapedText)); + } + if (indexInfo.declaration && ts.getCombinedNodeFlags(indexInfo.declaration) & 268435456 /* NodeFlags.Deprecated */) { + addDeprecatedSuggestion(right, [indexInfo.declaration], right.escapedText); + } + } + else { + if (isDeprecatedSymbol(prop) && isUncalledFunctionReference(node, prop) && prop.declarations) { + addDeprecatedSuggestion(right, prop.declarations, right.escapedText); + } + checkPropertyNotUsedBeforeDeclaration(prop, node, right); + markPropertyAsReferenced(prop, node, isSelfTypeAccess(left, parentSymbol)); + getNodeLinks(node).resolvedSymbol = prop; + var writing = ts.isWriteAccess(node); + checkPropertyAccessibility(node, left.kind === 106 /* SyntaxKind.SuperKeyword */, writing, apparentType, prop); + if (isAssignmentToReadonlyEntity(node, prop, assignmentKind)) { + error(right, ts.Diagnostics.Cannot_assign_to_0_because_it_is_a_read_only_property, ts.idText(right)); + return errorType; + } + propType = isThisPropertyAccessInConstructor(node, prop) ? autoType : writing ? getWriteTypeOfSymbol(prop) : getTypeOfSymbol(prop); + } + return getFlowTypeOfAccessExpression(node, prop, propType, right, checkMode); + } + /** + * Determines whether a did-you-mean error should be a suggestion in an unchecked JS file. + * Only applies to unchecked JS files without checkJS, // @ts-check or // @ts-nocheck + * It does not suggest when the suggestion: + * - Is from a global file that is different from the reference file, or + * - (optionally) Is a class, or is a this.x property access expression + */ + function isUncheckedJSSuggestion(node, suggestion, excludeClasses) { + var file = ts.getSourceFileOfNode(node); + if (file) { + if (compilerOptions.checkJs === undefined && file.checkJsDirective === undefined && (file.scriptKind === 1 /* ScriptKind.JS */ || file.scriptKind === 2 /* ScriptKind.JSX */)) { + var declarationFile = ts.forEach(suggestion === null || suggestion === void 0 ? void 0 : suggestion.declarations, ts.getSourceFileOfNode); + return !(file !== declarationFile && !!declarationFile && isGlobalSourceFile(declarationFile)) + && !(excludeClasses && suggestion && suggestion.flags & 32 /* SymbolFlags.Class */) + && !(!!node && excludeClasses && ts.isPropertyAccessExpression(node) && node.expression.kind === 108 /* SyntaxKind.ThisKeyword */); + } + } + return false; + } + function getFlowTypeOfAccessExpression(node, prop, propType, errorNode, checkMode) { + // Only compute control flow type if this is a property access expression that isn't an + // assignment target, and the referenced property was declared as a variable, property, + // accessor, or optional method. + var assignmentKind = ts.getAssignmentTargetKind(node); + if (assignmentKind === 1 /* AssignmentKind.Definite */) { + return removeMissingType(propType, !!(prop && prop.flags & 16777216 /* SymbolFlags.Optional */)); + } + if (prop && + !(prop.flags & (3 /* SymbolFlags.Variable */ | 4 /* SymbolFlags.Property */ | 98304 /* SymbolFlags.Accessor */)) + && !(prop.flags & 8192 /* SymbolFlags.Method */ && propType.flags & 1048576 /* TypeFlags.Union */) + && !isDuplicatedCommonJSExport(prop.declarations)) { + return propType; + } + if (propType === autoType) { + return getFlowTypeOfProperty(node, prop); + } + propType = getNarrowableTypeForReference(propType, node, checkMode); + // If strict null checks and strict property initialization checks are enabled, if we have + // a this.xxx property access, if the property is an instance property without an initializer, + // and if we are in a constructor of the same class as the property declaration, assume that + // the property is uninitialized at the top of the control flow. + var assumeUninitialized = false; + if (strictNullChecks && strictPropertyInitialization && ts.isAccessExpression(node) && node.expression.kind === 108 /* SyntaxKind.ThisKeyword */) { + var declaration = prop && prop.valueDeclaration; + if (declaration && isPropertyWithoutInitializer(declaration)) { + if (!ts.isStatic(declaration)) { + var flowContainer = getControlFlowContainer(node); + if (flowContainer.kind === 173 /* SyntaxKind.Constructor */ && flowContainer.parent === declaration.parent && !(declaration.flags & 16777216 /* NodeFlags.Ambient */)) { + assumeUninitialized = true; + } + } + } + } + else if (strictNullChecks && prop && prop.valueDeclaration && + ts.isPropertyAccessExpression(prop.valueDeclaration) && + ts.getAssignmentDeclarationPropertyAccessKind(prop.valueDeclaration) && + getControlFlowContainer(node) === getControlFlowContainer(prop.valueDeclaration)) { + assumeUninitialized = true; + } + var flowType = getFlowTypeOfReference(node, propType, assumeUninitialized ? getOptionalType(propType) : propType); + if (assumeUninitialized && !containsUndefinedType(propType) && containsUndefinedType(flowType)) { + error(errorNode, ts.Diagnostics.Property_0_is_used_before_being_assigned, symbolToString(prop)); // TODO: GH#18217 + // Return the declared type to reduce follow-on errors + return propType; + } + return assignmentKind ? getBaseTypeOfLiteralType(flowType) : flowType; + } + function checkPropertyNotUsedBeforeDeclaration(prop, node, right) { + var valueDeclaration = prop.valueDeclaration; + if (!valueDeclaration || ts.getSourceFileOfNode(node).isDeclarationFile) { + return; + } + var diagnosticMessage; + var declarationName = ts.idText(right); + if (isInPropertyInitializerOrClassStaticBlock(node) + && !isOptionalPropertyDeclaration(valueDeclaration) + && !(ts.isAccessExpression(node) && ts.isAccessExpression(node.expression)) + && !isBlockScopedNameDeclaredBeforeUse(valueDeclaration, right) + && !(ts.isMethodDeclaration(valueDeclaration) && ts.getCombinedModifierFlags(valueDeclaration) & 32 /* ModifierFlags.Static */) + && (compilerOptions.useDefineForClassFields || !isPropertyDeclaredInAncestorClass(prop))) { + diagnosticMessage = error(right, ts.Diagnostics.Property_0_is_used_before_its_initialization, declarationName); + } + else if (valueDeclaration.kind === 260 /* SyntaxKind.ClassDeclaration */ && + node.parent.kind !== 180 /* SyntaxKind.TypeReference */ && + !(valueDeclaration.flags & 16777216 /* NodeFlags.Ambient */) && + !isBlockScopedNameDeclaredBeforeUse(valueDeclaration, right)) { + diagnosticMessage = error(right, ts.Diagnostics.Class_0_used_before_its_declaration, declarationName); + } + if (diagnosticMessage) { + ts.addRelatedInfo(diagnosticMessage, ts.createDiagnosticForNode(valueDeclaration, ts.Diagnostics._0_is_declared_here, declarationName)); + } + } + function isInPropertyInitializerOrClassStaticBlock(node) { + return !!ts.findAncestor(node, function (node) { + switch (node.kind) { + case 169 /* SyntaxKind.PropertyDeclaration */: + return true; + case 299 /* SyntaxKind.PropertyAssignment */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 301 /* SyntaxKind.SpreadAssignment */: + case 164 /* SyntaxKind.ComputedPropertyName */: + case 236 /* SyntaxKind.TemplateSpan */: + case 291 /* SyntaxKind.JsxExpression */: + case 288 /* SyntaxKind.JsxAttribute */: + case 289 /* SyntaxKind.JsxAttributes */: + case 290 /* SyntaxKind.JsxSpreadAttribute */: + case 283 /* SyntaxKind.JsxOpeningElement */: + case 230 /* SyntaxKind.ExpressionWithTypeArguments */: + case 294 /* SyntaxKind.HeritageClause */: + return false; + case 216 /* SyntaxKind.ArrowFunction */: + case 241 /* SyntaxKind.ExpressionStatement */: + return ts.isBlock(node.parent) && ts.isClassStaticBlockDeclaration(node.parent.parent) ? true : "quit"; + default: + return ts.isExpressionNode(node) ? false : "quit"; + } + }); + } + /** + * It's possible that "prop.valueDeclaration" is a local declaration, but the property was also declared in a superclass. + * In that case we won't consider it used before its declaration, because it gets its value from the superclass' declaration. + */ + function isPropertyDeclaredInAncestorClass(prop) { + if (!(prop.parent.flags & 32 /* SymbolFlags.Class */)) { + return false; + } + var classType = getTypeOfSymbol(prop.parent); + while (true) { + classType = classType.symbol && getSuperClass(classType); + if (!classType) { + return false; + } + var superProperty = getPropertyOfType(classType, prop.escapedName); + if (superProperty && superProperty.valueDeclaration) { + return true; + } + } + } + function getSuperClass(classType) { + var x = getBaseTypes(classType); + if (x.length === 0) { + return undefined; + } + return getIntersectionType(x); + } + function reportNonexistentProperty(propNode, containingType, isUncheckedJS) { + var errorInfo; + var relatedInfo; + if (!ts.isPrivateIdentifier(propNode) && containingType.flags & 1048576 /* TypeFlags.Union */ && !(containingType.flags & 131068 /* TypeFlags.Primitive */)) { + for (var _i = 0, _a = containingType.types; _i < _a.length; _i++) { + var subtype = _a[_i]; + if (!getPropertyOfType(subtype, propNode.escapedText) && !getApplicableIndexInfoForName(subtype, propNode.escapedText)) { + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.declarationNameToString(propNode), typeToString(subtype)); + break; + } + } + } + if (typeHasStaticProperty(propNode.escapedText, containingType)) { + var propName = ts.declarationNameToString(propNode); + var typeName = typeToString(containingType); + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_to_access_the_static_member_2_instead, propName, typeName, typeName + "." + propName); + } + else { + var promisedType = getPromisedTypeOfPromise(containingType); + if (promisedType && getPropertyOfType(promisedType, propNode.escapedText)) { + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Property_0_does_not_exist_on_type_1, ts.declarationNameToString(propNode), typeToString(containingType)); + relatedInfo = ts.createDiagnosticForNode(propNode, ts.Diagnostics.Did_you_forget_to_use_await); + } + else { + var missingProperty = ts.declarationNameToString(propNode); + var container = typeToString(containingType); + var libSuggestion = getSuggestedLibForNonExistentProperty(missingProperty, containingType); + if (libSuggestion !== undefined) { + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Property_0_does_not_exist_on_type_1_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_2_or_later, missingProperty, container, libSuggestion); + } + else { + var suggestion = getSuggestedSymbolForNonexistentProperty(propNode, containingType); + if (suggestion !== undefined) { + var suggestedName = ts.symbolName(suggestion); + var message = isUncheckedJS ? ts.Diagnostics.Property_0_may_not_exist_on_type_1_Did_you_mean_2 : ts.Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2; + errorInfo = ts.chainDiagnosticMessages(errorInfo, message, missingProperty, container, suggestedName); + relatedInfo = suggestion.valueDeclaration && ts.createDiagnosticForNode(suggestion.valueDeclaration, ts.Diagnostics._0_is_declared_here, suggestedName); + } + else { + var diagnostic = containerSeemsToBeEmptyDomElement(containingType) + ? ts.Diagnostics.Property_0_does_not_exist_on_type_1_Try_changing_the_lib_compiler_option_to_include_dom + : ts.Diagnostics.Property_0_does_not_exist_on_type_1; + errorInfo = ts.chainDiagnosticMessages(elaborateNeverIntersection(errorInfo, containingType), diagnostic, missingProperty, container); + } + } + } + } + var resultDiagnostic = ts.createDiagnosticForNodeFromMessageChain(propNode, errorInfo); + if (relatedInfo) { + ts.addRelatedInfo(resultDiagnostic, relatedInfo); + } + addErrorOrSuggestion(!isUncheckedJS || errorInfo.code !== ts.Diagnostics.Property_0_may_not_exist_on_type_1_Did_you_mean_2.code, resultDiagnostic); + } + function containerSeemsToBeEmptyDomElement(containingType) { + return (compilerOptions.lib && !compilerOptions.lib.includes("dom")) && + everyContainedType(containingType, function (type) { return type.symbol && /^(EventTarget|Node|((HTML[a-zA-Z]*)?Element))$/.test(ts.unescapeLeadingUnderscores(type.symbol.escapedName)); }) && + isEmptyObjectType(containingType); + } + function typeHasStaticProperty(propName, containingType) { + var prop = containingType.symbol && getPropertyOfType(getTypeOfSymbol(containingType.symbol), propName); + return prop !== undefined && !!prop.valueDeclaration && ts.isStatic(prop.valueDeclaration); + } + function getSuggestedLibForNonExistentName(name) { + var missingName = diagnosticName(name); + var allFeatures = ts.getScriptTargetFeatures(); + var libTargets = ts.getOwnKeys(allFeatures); + for (var _i = 0, libTargets_1 = libTargets; _i < libTargets_1.length; _i++) { + var libTarget = libTargets_1[_i]; + var containingTypes = ts.getOwnKeys(allFeatures[libTarget]); + if (containingTypes !== undefined && ts.contains(containingTypes, missingName)) { + return libTarget; + } + } + } + function getSuggestedLibForNonExistentProperty(missingProperty, containingType) { + var container = getApparentType(containingType).symbol; + if (!container) { + return undefined; + } + var allFeatures = ts.getScriptTargetFeatures(); + var libTargets = ts.getOwnKeys(allFeatures); + for (var _i = 0, libTargets_2 = libTargets; _i < libTargets_2.length; _i++) { + var libTarget = libTargets_2[_i]; + var featuresOfLib = allFeatures[libTarget]; + var featuresOfContainingType = featuresOfLib[ts.symbolName(container)]; + if (featuresOfContainingType !== undefined && ts.contains(featuresOfContainingType, missingProperty)) { + return libTarget; + } + } + } + function getSuggestedSymbolForNonexistentClassMember(name, baseType) { + return getSpellingSuggestionForName(name, getPropertiesOfType(baseType), 106500 /* SymbolFlags.ClassMember */); + } + function getSuggestedSymbolForNonexistentProperty(name, containingType) { + var props = getPropertiesOfType(containingType); + if (typeof name !== "string") { + var parent_3 = name.parent; + if (ts.isPropertyAccessExpression(parent_3)) { + props = ts.filter(props, function (prop) { return isValidPropertyAccessForCompletions(parent_3, containingType, prop); }); + } + name = ts.idText(name); + } + return getSpellingSuggestionForName(name, props, 111551 /* SymbolFlags.Value */); + } + function getSuggestedSymbolForNonexistentJSXAttribute(name, containingType) { + var strName = ts.isString(name) ? name : ts.idText(name); + var properties = getPropertiesOfType(containingType); + var jsxSpecific = strName === "for" ? ts.find(properties, function (x) { return ts.symbolName(x) === "htmlFor"; }) + : strName === "class" ? ts.find(properties, function (x) { return ts.symbolName(x) === "className"; }) + : undefined; + return jsxSpecific !== null && jsxSpecific !== void 0 ? jsxSpecific : getSpellingSuggestionForName(strName, properties, 111551 /* SymbolFlags.Value */); + } + function getSuggestionForNonexistentProperty(name, containingType) { + var suggestion = getSuggestedSymbolForNonexistentProperty(name, containingType); + return suggestion && ts.symbolName(suggestion); + } + function getSuggestedSymbolForNonexistentSymbol(location, outerName, meaning) { + ts.Debug.assert(outerName !== undefined, "outername should always be defined"); + var result = resolveNameHelper(location, outerName, meaning, /*nameNotFoundMessage*/ undefined, outerName, /*isUse*/ false, /*excludeGlobals*/ false, /*getSpellingSuggestions*/ true, function (symbols, name, meaning) { + ts.Debug.assertEqual(outerName, name, "name should equal outerName"); + var symbol = getSymbol(symbols, name, meaning); + // Sometimes the symbol is found when location is a return type of a function: `typeof x` and `x` is declared in the body of the function + // So the table *contains* `x` but `x` isn't actually in scope. + // However, resolveNameHelper will continue and call this callback again, so we'll eventually get a correct suggestion. + if (symbol) + return symbol; + var candidates; + if (symbols === globals) { + var primitives = ts.mapDefined(["string", "number", "boolean", "object", "bigint", "symbol"], function (s) { return symbols.has((s.charAt(0).toUpperCase() + s.slice(1))) + ? createSymbol(524288 /* SymbolFlags.TypeAlias */, s) + : undefined; }); + candidates = primitives.concat(ts.arrayFrom(symbols.values())); + } + else { + candidates = ts.arrayFrom(symbols.values()); + } + return getSpellingSuggestionForName(ts.unescapeLeadingUnderscores(name), candidates, meaning); + }); + return result; + } + function getSuggestionForNonexistentSymbol(location, outerName, meaning) { + var symbolResult = getSuggestedSymbolForNonexistentSymbol(location, outerName, meaning); + return symbolResult && ts.symbolName(symbolResult); + } + function getSuggestedSymbolForNonexistentModule(name, targetModule) { + return targetModule.exports && getSpellingSuggestionForName(ts.idText(name), getExportsOfModuleAsArray(targetModule), 2623475 /* SymbolFlags.ModuleMember */); + } + function getSuggestionForNonexistentExport(name, targetModule) { + var suggestion = getSuggestedSymbolForNonexistentModule(name, targetModule); + return suggestion && ts.symbolName(suggestion); + } + function getSuggestionForNonexistentIndexSignature(objectType, expr, keyedType) { + // check if object type has setter or getter + function hasProp(name) { + var prop = getPropertyOfObjectType(objectType, name); + if (prop) { + var s = getSingleCallSignature(getTypeOfSymbol(prop)); + return !!s && getMinArgumentCount(s) >= 1 && isTypeAssignableTo(keyedType, getTypeAtPosition(s, 0)); + } + return false; + } + var suggestedMethod = ts.isAssignmentTarget(expr) ? "set" : "get"; + if (!hasProp(suggestedMethod)) { + return undefined; + } + var suggestion = ts.tryGetPropertyAccessOrIdentifierToString(expr.expression); + if (suggestion === undefined) { + suggestion = suggestedMethod; + } + else { + suggestion += "." + suggestedMethod; + } + return suggestion; + } + function getSuggestedTypeForNonexistentStringLiteralType(source, target) { + var candidates = target.types.filter(function (type) { return !!(type.flags & 128 /* TypeFlags.StringLiteral */); }); + return ts.getSpellingSuggestion(source.value, candidates, function (type) { return type.value; }); + } + /** + * Given a name and a list of symbols whose names are *not* equal to the name, return a spelling suggestion if there is one that is close enough. + * Names less than length 3 only check for case-insensitive equality, not levenshtein distance. + * + * If there is a candidate that's the same except for case, return that. + * If there is a candidate that's within one edit of the name, return that. + * Otherwise, return the candidate with the smallest Levenshtein distance, + * except for candidates: + * * With no name + * * Whose meaning doesn't match the `meaning` parameter. + * * Whose length differs from the target name by more than 0.34 of the length of the name. + * * Whose levenshtein distance is more than 0.4 of the length of the name + * (0.4 allows 1 substitution/transposition for every 5 characters, + * and 1 insertion/deletion at 3 characters) + */ + function getSpellingSuggestionForName(name, symbols, meaning) { + return ts.getSpellingSuggestion(name, symbols, getCandidateName); + function getCandidateName(candidate) { + var candidateName = ts.symbolName(candidate); + if (ts.startsWith(candidateName, "\"")) { + return undefined; + } + if (candidate.flags & meaning) { + return candidateName; + } + if (candidate.flags & 2097152 /* SymbolFlags.Alias */) { + var alias = tryResolveAlias(candidate); + if (alias && alias.flags & meaning) { + return candidateName; + } + } + return undefined; + } + } + function markPropertyAsReferenced(prop, nodeForCheckWriteOnly, isSelfTypeAccess) { + var valueDeclaration = prop && (prop.flags & 106500 /* SymbolFlags.ClassMember */) && prop.valueDeclaration; + if (!valueDeclaration) { + return; + } + var hasPrivateModifier = ts.hasEffectiveModifier(valueDeclaration, 8 /* ModifierFlags.Private */); + var hasPrivateIdentifier = prop.valueDeclaration && ts.isNamedDeclaration(prop.valueDeclaration) && ts.isPrivateIdentifier(prop.valueDeclaration.name); + if (!hasPrivateModifier && !hasPrivateIdentifier) { + return; + } + if (nodeForCheckWriteOnly && ts.isWriteOnlyAccess(nodeForCheckWriteOnly) && !(prop.flags & 65536 /* SymbolFlags.SetAccessor */)) { + return; + } + if (isSelfTypeAccess) { + // Find any FunctionLikeDeclaration because those create a new 'this' binding. But this should only matter for methods (or getters/setters). + var containingMethod = ts.findAncestor(nodeForCheckWriteOnly, ts.isFunctionLikeDeclaration); + if (containingMethod && containingMethod.symbol === prop) { + return; + } + } + (ts.getCheckFlags(prop) & 1 /* CheckFlags.Instantiated */ ? getSymbolLinks(prop).target : prop).isReferenced = 67108863 /* SymbolFlags.All */; + } + function isSelfTypeAccess(name, parent) { + return name.kind === 108 /* SyntaxKind.ThisKeyword */ + || !!parent && ts.isEntityNameExpression(name) && parent === getResolvedSymbol(ts.getFirstIdentifier(name)); + } + function isValidPropertyAccess(node, propertyName) { + switch (node.kind) { + case 208 /* SyntaxKind.PropertyAccessExpression */: + return isValidPropertyAccessWithType(node, node.expression.kind === 106 /* SyntaxKind.SuperKeyword */, propertyName, getWidenedType(checkExpression(node.expression))); + case 163 /* SyntaxKind.QualifiedName */: + return isValidPropertyAccessWithType(node, /*isSuper*/ false, propertyName, getWidenedType(checkExpression(node.left))); + case 202 /* SyntaxKind.ImportType */: + return isValidPropertyAccessWithType(node, /*isSuper*/ false, propertyName, getTypeFromTypeNode(node)); + } + } + /** + * Checks if an existing property access is valid for completions purposes. + * @param node a property access-like node where we want to check if we can access a property. + * This node does not need to be an access of the property we are checking. + * e.g. in completions, this node will often be an incomplete property access node, as in `foo.`. + * Besides providing a location (i.e. scope) used to check property accessibility, we use this node for + * computing whether this is a `super` property access. + * @param type the type whose property we are checking. + * @param property the accessed property's symbol. + */ + function isValidPropertyAccessForCompletions(node, type, property) { + return isPropertyAccessible(node, node.kind === 208 /* SyntaxKind.PropertyAccessExpression */ && node.expression.kind === 106 /* SyntaxKind.SuperKeyword */, + /* isWrite */ false, type, property); + // Previously we validated the 'this' type of methods but this adversely affected performance. See #31377 for more context. + } + function isValidPropertyAccessWithType(node, isSuper, propertyName, type) { + // Short-circuiting for improved performance. + if (isTypeAny(type)) { + return true; + } + var prop = getPropertyOfType(type, propertyName); + return !!prop && isPropertyAccessible(node, isSuper, /* isWrite */ false, type, prop); + } + /** + * Checks if a property can be accessed in a location. + * The location is given by the `node` parameter. + * The node does not need to be a property access. + * @param node location where to check property accessibility + * @param isSuper whether to consider this a `super` property access, e.g. `super.foo`. + * @param isWrite whether this is a write access, e.g. `++foo.x`. + * @param containingType type where the property comes from. + * @param property property symbol. + */ + function isPropertyAccessible(node, isSuper, isWrite, containingType, property) { + // Short-circuiting for improved performance. + if (isTypeAny(containingType)) { + return true; + } + // A #private property access in an optional chain is an error dealt with by the parser. + // The checker does not check for it, so we need to do our own check here. + if (property.valueDeclaration && ts.isPrivateIdentifierClassElementDeclaration(property.valueDeclaration)) { + var declClass_1 = ts.getContainingClass(property.valueDeclaration); + return !ts.isOptionalChain(node) && !!ts.findAncestor(node, function (parent) { return parent === declClass_1; }); + } + return checkPropertyAccessibilityAtLocation(node, isSuper, isWrite, containingType, property); + } + /** + * Return the symbol of the for-in variable declared or referenced by the given for-in statement. + */ + function getForInVariableSymbol(node) { + var initializer = node.initializer; + if (initializer.kind === 258 /* SyntaxKind.VariableDeclarationList */) { + var variable = initializer.declarations[0]; + if (variable && !ts.isBindingPattern(variable.name)) { + return getSymbolOfNode(variable); + } + } + else if (initializer.kind === 79 /* SyntaxKind.Identifier */) { + return getResolvedSymbol(initializer); + } + return undefined; + } + /** + * Return true if the given type is considered to have numeric property names. + */ + function hasNumericPropertyNames(type) { + return getIndexInfosOfType(type).length === 1 && !!getIndexInfoOfType(type, numberType); + } + /** + * Return true if given node is an expression consisting of an identifier (possibly parenthesized) + * that references a for-in variable for an object with numeric property names. + */ + function isForInVariableForNumericPropertyNames(expr) { + var e = ts.skipParentheses(expr); + if (e.kind === 79 /* SyntaxKind.Identifier */) { + var symbol = getResolvedSymbol(e); + if (symbol.flags & 3 /* SymbolFlags.Variable */) { + var child = expr; + var node = expr.parent; + while (node) { + if (node.kind === 246 /* SyntaxKind.ForInStatement */ && + child === node.statement && + getForInVariableSymbol(node) === symbol && + hasNumericPropertyNames(getTypeOfExpression(node.expression))) { + return true; + } + child = node; + node = node.parent; + } + } + } + return false; + } + function checkIndexedAccess(node, checkMode) { + return node.flags & 32 /* NodeFlags.OptionalChain */ ? checkElementAccessChain(node, checkMode) : + checkElementAccessExpression(node, checkNonNullExpression(node.expression), checkMode); + } + function checkElementAccessChain(node, checkMode) { + var exprType = checkExpression(node.expression); + var nonOptionalType = getOptionalExpressionType(exprType, node.expression); + return propagateOptionalTypeMarker(checkElementAccessExpression(node, checkNonNullType(nonOptionalType, node.expression), checkMode), node, nonOptionalType !== exprType); + } + function checkElementAccessExpression(node, exprType, checkMode) { + var objectType = ts.getAssignmentTargetKind(node) !== 0 /* AssignmentKind.None */ || isMethodAccessForCall(node) ? getWidenedType(exprType) : exprType; + var indexExpression = node.argumentExpression; + var indexType = checkExpression(indexExpression); + if (isErrorType(objectType) || objectType === silentNeverType) { + return objectType; + } + if (isConstEnumObjectType(objectType) && !ts.isStringLiteralLike(indexExpression)) { + error(indexExpression, ts.Diagnostics.A_const_enum_member_can_only_be_accessed_using_a_string_literal); + return errorType; + } + var effectiveIndexType = isForInVariableForNumericPropertyNames(indexExpression) ? numberType : indexType; + var accessFlags = ts.isAssignmentTarget(node) ? + 4 /* AccessFlags.Writing */ | (isGenericObjectType(objectType) && !ts.isThisTypeParameter(objectType) ? 2 /* AccessFlags.NoIndexSignatures */ : 0) : + 32 /* AccessFlags.ExpressionPosition */; + var indexedAccessType = getIndexedAccessTypeOrUndefined(objectType, effectiveIndexType, accessFlags, node) || errorType; + return checkIndexedAccessIndexType(getFlowTypeOfAccessExpression(node, getNodeLinks(node).resolvedSymbol, indexedAccessType, indexExpression, checkMode), node); + } + function callLikeExpressionMayHaveTypeArguments(node) { + return ts.isCallOrNewExpression(node) || ts.isTaggedTemplateExpression(node) || ts.isJsxOpeningLikeElement(node); + } + function resolveUntypedCall(node) { + if (callLikeExpressionMayHaveTypeArguments(node)) { + // Check type arguments even though we will give an error that untyped calls may not accept type arguments. + // This gets us diagnostics for the type arguments and marks them as referenced. + ts.forEach(node.typeArguments, checkSourceElement); + } + if (node.kind === 212 /* SyntaxKind.TaggedTemplateExpression */) { + checkExpression(node.template); + } + else if (ts.isJsxOpeningLikeElement(node)) { + checkExpression(node.attributes); + } + else if (node.kind !== 167 /* SyntaxKind.Decorator */) { + ts.forEach(node.arguments, function (argument) { + checkExpression(argument); + }); + } + return anySignature; + } + function resolveErrorCall(node) { + resolveUntypedCall(node); + return unknownSignature; + } + // Re-order candidate signatures into the result array. Assumes the result array to be empty. + // The candidate list orders groups in reverse, but within a group signatures are kept in declaration order + // A nit here is that we reorder only signatures that belong to the same symbol, + // so order how inherited signatures are processed is still preserved. + // interface A { (x: string): void } + // interface B extends A { (x: 'foo'): string } + // const b: B; + // b('foo') // <- here overloads should be processed as [(x:'foo'): string, (x: string): void] + function reorderCandidates(signatures, result, callChainFlags) { + var lastParent; + var lastSymbol; + var cutoffIndex = 0; + var index; + var specializedIndex = -1; + var spliceIndex; + ts.Debug.assert(!result.length); + for (var _i = 0, signatures_7 = signatures; _i < signatures_7.length; _i++) { + var signature = signatures_7[_i]; + var symbol = signature.declaration && getSymbolOfNode(signature.declaration); + var parent = signature.declaration && signature.declaration.parent; + if (!lastSymbol || symbol === lastSymbol) { + if (lastParent && parent === lastParent) { + index = index + 1; + } + else { + lastParent = parent; + index = cutoffIndex; + } + } + else { + // current declaration belongs to a different symbol + // set cutoffIndex so re-orderings in the future won't change result set from 0 to cutoffIndex + index = cutoffIndex = result.length; + lastParent = parent; + } + lastSymbol = symbol; + // specialized signatures always need to be placed before non-specialized signatures regardless + // of the cutoff position; see GH#1133 + if (signatureHasLiteralTypes(signature)) { + specializedIndex++; + spliceIndex = specializedIndex; + // The cutoff index always needs to be greater than or equal to the specialized signature index + // in order to prevent non-specialized signatures from being added before a specialized + // signature. + cutoffIndex++; + } + else { + spliceIndex = index; + } + result.splice(spliceIndex, 0, callChainFlags ? getOptionalCallSignature(signature, callChainFlags) : signature); + } + } + function isSpreadArgument(arg) { + return !!arg && (arg.kind === 227 /* SyntaxKind.SpreadElement */ || arg.kind === 234 /* SyntaxKind.SyntheticExpression */ && arg.isSpread); + } + function getSpreadArgumentIndex(args) { + return ts.findIndex(args, isSpreadArgument); + } + function acceptsVoid(t) { + return !!(t.flags & 16384 /* TypeFlags.Void */); + } + function acceptsVoidUndefinedUnknownOrAny(t) { + return !!(t.flags & (16384 /* TypeFlags.Void */ | 32768 /* TypeFlags.Undefined */ | 2 /* TypeFlags.Unknown */ | 1 /* TypeFlags.Any */)); + } + function hasCorrectArity(node, args, signature, signatureHelpTrailingComma) { + if (signatureHelpTrailingComma === void 0) { signatureHelpTrailingComma = false; } + var argCount; + var callIsIncomplete = false; // In incomplete call we want to be lenient when we have too few arguments + var effectiveParameterCount = getParameterCount(signature); + var effectiveMinimumArguments = getMinArgumentCount(signature); + if (node.kind === 212 /* SyntaxKind.TaggedTemplateExpression */) { + argCount = args.length; + if (node.template.kind === 225 /* SyntaxKind.TemplateExpression */) { + // If a tagged template expression lacks a tail literal, the call is incomplete. + // Specifically, a template only can end in a TemplateTail or a Missing literal. + var lastSpan = ts.last(node.template.templateSpans); // we should always have at least one span. + callIsIncomplete = ts.nodeIsMissing(lastSpan.literal) || !!lastSpan.literal.isUnterminated; + } + else { + // If the template didn't end in a backtick, or its beginning occurred right prior to EOF, + // then this might actually turn out to be a TemplateHead in the future; + // so we consider the call to be incomplete. + var templateLiteral = node.template; + ts.Debug.assert(templateLiteral.kind === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */); + callIsIncomplete = !!templateLiteral.isUnterminated; + } + } + else if (node.kind === 167 /* SyntaxKind.Decorator */) { + argCount = getDecoratorArgumentCount(node, signature); + } + else if (ts.isJsxOpeningLikeElement(node)) { + callIsIncomplete = node.attributes.end === node.end; + if (callIsIncomplete) { + return true; + } + argCount = effectiveMinimumArguments === 0 ? args.length : 1; + effectiveParameterCount = args.length === 0 ? effectiveParameterCount : 1; // class may have argumentless ctor functions - still resolve ctor and compare vs props member type + effectiveMinimumArguments = Math.min(effectiveMinimumArguments, 1); // sfc may specify context argument - handled by framework and not typechecked + } + else if (!node.arguments) { + // This only happens when we have something of the form: 'new C' + ts.Debug.assert(node.kind === 211 /* SyntaxKind.NewExpression */); + return getMinArgumentCount(signature) === 0; + } + else { + argCount = signatureHelpTrailingComma ? args.length + 1 : args.length; + // If we are missing the close parenthesis, the call is incomplete. + callIsIncomplete = node.arguments.end === node.end; + // If a spread argument is present, check that it corresponds to a rest parameter or at least that it's in the valid range. + var spreadArgIndex = getSpreadArgumentIndex(args); + if (spreadArgIndex >= 0) { + return spreadArgIndex >= getMinArgumentCount(signature) && (hasEffectiveRestParameter(signature) || spreadArgIndex < getParameterCount(signature)); + } + } + // Too many arguments implies incorrect arity. + if (!hasEffectiveRestParameter(signature) && argCount > effectiveParameterCount) { + return false; + } + // If the call is incomplete, we should skip the lower bound check. + // JSX signatures can have extra parameters provided by the library which we don't check + if (callIsIncomplete || argCount >= effectiveMinimumArguments) { + return true; + } + for (var i = argCount; i < effectiveMinimumArguments; i++) { + var type = getTypeAtPosition(signature, i); + if (filterType(type, ts.isInJSFile(node) && !strictNullChecks ? acceptsVoidUndefinedUnknownOrAny : acceptsVoid).flags & 131072 /* TypeFlags.Never */) { + return false; + } + } + return true; + } + function hasCorrectTypeArgumentArity(signature, typeArguments) { + // If the user supplied type arguments, but the number of type arguments does not match + // the declared number of type parameters, the call has an incorrect arity. + var numTypeParameters = ts.length(signature.typeParameters); + var minTypeArgumentCount = getMinTypeArgumentCount(signature.typeParameters); + return !ts.some(typeArguments) || + (typeArguments.length >= minTypeArgumentCount && typeArguments.length <= numTypeParameters); + } + // If type has a single call signature and no other members, return that signature. Otherwise, return undefined. + function getSingleCallSignature(type) { + return getSingleSignature(type, 0 /* SignatureKind.Call */, /*allowMembers*/ false); + } + function getSingleCallOrConstructSignature(type) { + return getSingleSignature(type, 0 /* SignatureKind.Call */, /*allowMembers*/ false) || + getSingleSignature(type, 1 /* SignatureKind.Construct */, /*allowMembers*/ false); + } + function getSingleSignature(type, kind, allowMembers) { + if (type.flags & 524288 /* TypeFlags.Object */) { + var resolved = resolveStructuredTypeMembers(type); + if (allowMembers || resolved.properties.length === 0 && resolved.indexInfos.length === 0) { + if (kind === 0 /* SignatureKind.Call */ && resolved.callSignatures.length === 1 && resolved.constructSignatures.length === 0) { + return resolved.callSignatures[0]; + } + if (kind === 1 /* SignatureKind.Construct */ && resolved.constructSignatures.length === 1 && resolved.callSignatures.length === 0) { + return resolved.constructSignatures[0]; + } + } + } + return undefined; + } + // Instantiate a generic signature in the context of a non-generic signature (section 3.8.5 in TypeScript spec) + function instantiateSignatureInContextOf(signature, contextualSignature, inferenceContext, compareTypes) { + var context = createInferenceContext(signature.typeParameters, signature, 0 /* InferenceFlags.None */, compareTypes); + // We clone the inferenceContext to avoid fixing. For example, when the source signature is (x: T) => T[] and + // the contextual signature is (...args: A) => B, we want to infer the element type of A's constraint (say 'any') + // for T but leave it possible to later infer '[any]' back to A. + var restType = getEffectiveRestType(contextualSignature); + var mapper = inferenceContext && (restType && restType.flags & 262144 /* TypeFlags.TypeParameter */ ? inferenceContext.nonFixingMapper : inferenceContext.mapper); + var sourceSignature = mapper ? instantiateSignature(contextualSignature, mapper) : contextualSignature; + applyToParameterTypes(sourceSignature, signature, function (source, target) { + // Type parameters from outer context referenced by source type are fixed by instantiation of the source type + inferTypes(context.inferences, source, target); + }); + if (!inferenceContext) { + applyToReturnTypes(contextualSignature, signature, function (source, target) { + inferTypes(context.inferences, source, target, 128 /* InferencePriority.ReturnType */); + }); + } + return getSignatureInstantiation(signature, getInferredTypes(context), ts.isInJSFile(contextualSignature.declaration)); + } + function inferJsxTypeArguments(node, signature, checkMode, context) { + var paramType = getEffectiveFirstArgumentForJsxSignature(signature, node); + var checkAttrType = checkExpressionWithContextualType(node.attributes, paramType, context, checkMode); + inferTypes(context.inferences, checkAttrType, paramType); + return getInferredTypes(context); + } + function getThisArgumentType(thisArgumentNode) { + if (!thisArgumentNode) { + return voidType; + } + var thisArgumentType = checkExpression(thisArgumentNode); + return ts.isOptionalChainRoot(thisArgumentNode.parent) ? getNonNullableType(thisArgumentType) : + ts.isOptionalChain(thisArgumentNode.parent) ? removeOptionalTypeMarker(thisArgumentType) : + thisArgumentType; + } + function inferTypeArguments(node, signature, args, checkMode, context) { + if (ts.isJsxOpeningLikeElement(node)) { + return inferJsxTypeArguments(node, signature, checkMode, context); + } + // If a contextual type is available, infer from that type to the return type of the call expression. For + // example, given a 'function wrap(cb: (x: T) => U): (x: T) => U' and a call expression + // 'let f: (x: string) => number = wrap(s => s.length)', we infer from the declared type of 'f' to the + // return type of 'wrap'. + if (node.kind !== 167 /* SyntaxKind.Decorator */) { + var skipBindingPatterns = ts.every(signature.typeParameters, function (p) { return !!getDefaultFromTypeParameter(p); }); + var contextualType = getContextualType(node, skipBindingPatterns ? 8 /* ContextFlags.SkipBindingPatterns */ : 0 /* ContextFlags.None */); + if (contextualType) { + var inferenceTargetType = getReturnTypeOfSignature(signature); + if (couldContainTypeVariables(inferenceTargetType)) { + var outerContext = getInferenceContext(node); + var isFromBindingPattern = !skipBindingPatterns && getContextualType(node, 8 /* ContextFlags.SkipBindingPatterns */) !== contextualType; + // A return type inference from a binding pattern can be used in instantiating the contextual + // type of an argument later in inference, but cannot stand on its own as the final return type. + // It is incorporated into `context.returnMapper` which is used in `instantiateContextualType`, + // but doesn't need to go into `context.inferences`. This allows a an array binding pattern to + // produce a tuple for `T` in + // declare function f(cb: () => T): T; + // const [e1, e2, e3] = f(() => [1, "hi", true]); + // but does not produce any inference for `T` in + // declare function f(): T; + // const [e1, e2, e3] = f(); + if (!isFromBindingPattern) { + // We clone the inference context to avoid disturbing a resolution in progress for an + // outer call expression. Effectively we just want a snapshot of whatever has been + // inferred for any outer call expression so far. + var outerMapper = getMapperFromContext(cloneInferenceContext(outerContext, 1 /* InferenceFlags.NoDefault */)); + var instantiatedType = instantiateType(contextualType, outerMapper); + // If the contextual type is a generic function type with a single call signature, we + // instantiate the type with its own type parameters and type arguments. This ensures that + // the type parameters are not erased to type any during type inference such that they can + // be inferred as actual types from the contextual type. For example: + // declare function arrayMap(f: (x: T) => U): (a: T[]) => U[]; + // const boxElements: (a: A[]) => { value: A }[] = arrayMap(value => ({ value })); + // Above, the type of the 'value' parameter is inferred to be 'A'. + var contextualSignature = getSingleCallSignature(instantiatedType); + var inferenceSourceType = contextualSignature && contextualSignature.typeParameters ? + getOrCreateTypeFromSignature(getSignatureInstantiationWithoutFillingInTypeArguments(contextualSignature, contextualSignature.typeParameters)) : + instantiatedType; + // Inferences made from return types have lower priority than all other inferences. + inferTypes(context.inferences, inferenceSourceType, inferenceTargetType, 128 /* InferencePriority.ReturnType */); + } + // Create a type mapper for instantiating generic contextual types using the inferences made + // from the return type. We need a separate inference pass here because (a) instantiation of + // the source type uses the outer context's return mapper (which excludes inferences made from + // outer arguments), and (b) we don't want any further inferences going into this context. + var returnContext = createInferenceContext(signature.typeParameters, signature, context.flags); + var returnSourceType = instantiateType(contextualType, outerContext && outerContext.returnMapper); + inferTypes(returnContext.inferences, returnSourceType, inferenceTargetType); + context.returnMapper = ts.some(returnContext.inferences, hasInferenceCandidates) ? getMapperFromContext(cloneInferredPartOfContext(returnContext)) : undefined; + } + } + } + var restType = getNonArrayRestType(signature); + var argCount = restType ? Math.min(getParameterCount(signature) - 1, args.length) : args.length; + if (restType && restType.flags & 262144 /* TypeFlags.TypeParameter */) { + var info = ts.find(context.inferences, function (info) { return info.typeParameter === restType; }); + if (info) { + info.impliedArity = ts.findIndex(args, isSpreadArgument, argCount) < 0 ? args.length - argCount : undefined; + } + } + var thisType = getThisTypeOfSignature(signature); + if (thisType && couldContainTypeVariables(thisType)) { + var thisArgumentNode = getThisArgumentOfCall(node); + inferTypes(context.inferences, getThisArgumentType(thisArgumentNode), thisType); + } + for (var i = 0; i < argCount; i++) { + var arg = args[i]; + if (arg.kind !== 229 /* SyntaxKind.OmittedExpression */ && !(checkMode & 32 /* CheckMode.IsForStringLiteralArgumentCompletions */ && hasSkipDirectInferenceFlag(arg))) { + var paramType = getTypeAtPosition(signature, i); + if (couldContainTypeVariables(paramType)) { + var argType = checkExpressionWithContextualType(arg, paramType, context, checkMode); + inferTypes(context.inferences, argType, paramType); + } + } + } + if (restType && couldContainTypeVariables(restType)) { + var spreadType = getSpreadArgumentType(args, argCount, args.length, restType, context, checkMode); + inferTypes(context.inferences, spreadType, restType); + } + return getInferredTypes(context); + } + function getMutableArrayOrTupleType(type) { + return type.flags & 1048576 /* TypeFlags.Union */ ? mapType(type, getMutableArrayOrTupleType) : + type.flags & 1 /* TypeFlags.Any */ || isMutableArrayOrTuple(getBaseConstraintOfType(type) || type) ? type : + isTupleType(type) ? createTupleType(getTypeArguments(type), type.target.elementFlags, /*readonly*/ false, type.target.labeledElementDeclarations) : + createTupleType([type], [8 /* ElementFlags.Variadic */]); + } + function getSpreadArgumentType(args, index, argCount, restType, context, checkMode) { + if (index >= argCount - 1) { + var arg = args[argCount - 1]; + if (isSpreadArgument(arg)) { + // We are inferring from a spread expression in the last argument position, i.e. both the parameter + // and the argument are ...x forms. + return getMutableArrayOrTupleType(arg.kind === 234 /* SyntaxKind.SyntheticExpression */ ? arg.type : + checkExpressionWithContextualType(arg.expression, restType, context, checkMode)); + } + } + var types = []; + var flags = []; + var names = []; + for (var i = index; i < argCount; i++) { + var arg = args[i]; + if (isSpreadArgument(arg)) { + var spreadType = arg.kind === 234 /* SyntaxKind.SyntheticExpression */ ? arg.type : checkExpression(arg.expression); + if (isArrayLikeType(spreadType)) { + types.push(spreadType); + flags.push(8 /* ElementFlags.Variadic */); + } + else { + types.push(checkIteratedTypeOrElementType(33 /* IterationUse.Spread */, spreadType, undefinedType, arg.kind === 227 /* SyntaxKind.SpreadElement */ ? arg.expression : arg)); + flags.push(4 /* ElementFlags.Rest */); + } + } + else { + var contextualType = getIndexedAccessType(restType, getNumberLiteralType(i - index), 256 /* AccessFlags.Contextual */); + var argType = checkExpressionWithContextualType(arg, contextualType, context, checkMode); + var hasPrimitiveContextualType = maybeTypeOfKind(contextualType, 131068 /* TypeFlags.Primitive */ | 4194304 /* TypeFlags.Index */ | 134217728 /* TypeFlags.TemplateLiteral */ | 268435456 /* TypeFlags.StringMapping */); + types.push(hasPrimitiveContextualType ? getRegularTypeOfLiteralType(argType) : getWidenedLiteralType(argType)); + flags.push(1 /* ElementFlags.Required */); + } + if (arg.kind === 234 /* SyntaxKind.SyntheticExpression */ && arg.tupleNameSource) { + names.push(arg.tupleNameSource); + } + } + return createTupleType(types, flags, /*readonly*/ false, ts.length(names) === ts.length(types) ? names : undefined); + } + function checkTypeArguments(signature, typeArgumentNodes, reportErrors, headMessage) { + var isJavascript = ts.isInJSFile(signature.declaration); + var typeParameters = signature.typeParameters; + var typeArgumentTypes = fillMissingTypeArguments(ts.map(typeArgumentNodes, getTypeFromTypeNode), typeParameters, getMinTypeArgumentCount(typeParameters), isJavascript); + var mapper; + for (var i = 0; i < typeArgumentNodes.length; i++) { + ts.Debug.assert(typeParameters[i] !== undefined, "Should not call checkTypeArguments with too many type arguments"); + var constraint = getConstraintOfTypeParameter(typeParameters[i]); + if (constraint) { + var errorInfo = reportErrors && headMessage ? (function () { return ts.chainDiagnosticMessages(/*details*/ undefined, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1); }) : undefined; + var typeArgumentHeadMessage = headMessage || ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1; + if (!mapper) { + mapper = createTypeMapper(typeParameters, typeArgumentTypes); + } + var typeArgument = typeArgumentTypes[i]; + if (!checkTypeAssignableTo(typeArgument, getTypeWithThisArgument(instantiateType(constraint, mapper), typeArgument), reportErrors ? typeArgumentNodes[i] : undefined, typeArgumentHeadMessage, errorInfo)) { + return undefined; + } + } + } + return typeArgumentTypes; + } + function getJsxReferenceKind(node) { + if (isJsxIntrinsicIdentifier(node.tagName)) { + return 2 /* JsxReferenceKind.Mixed */; + } + var tagType = getApparentType(checkExpression(node.tagName)); + if (ts.length(getSignaturesOfType(tagType, 1 /* SignatureKind.Construct */))) { + return 0 /* JsxReferenceKind.Component */; + } + if (ts.length(getSignaturesOfType(tagType, 0 /* SignatureKind.Call */))) { + return 1 /* JsxReferenceKind.Function */; + } + return 2 /* JsxReferenceKind.Mixed */; + } + /** + * Check if the given signature can possibly be a signature called by the JSX opening-like element. + * @param node a JSX opening-like element we are trying to figure its call signature + * @param signature a candidate signature we are trying whether it is a call signature + * @param relation a relationship to check parameter and argument type + */ + function checkApplicableSignatureForJsxOpeningLikeElement(node, signature, relation, checkMode, reportErrors, containingMessageChain, errorOutputContainer) { + // Stateless function components can have maximum of three arguments: "props", "context", and "updater". + // However "context" and "updater" are implicit and can't be specify by users. Only the first parameter, props, + // can be specified by users through attributes property. + var paramType = getEffectiveFirstArgumentForJsxSignature(signature, node); + var attributesType = checkExpressionWithContextualType(node.attributes, paramType, /*inferenceContext*/ undefined, checkMode); + return checkTagNameDoesNotExpectTooManyArguments() && checkTypeRelatedToAndOptionallyElaborate(attributesType, paramType, relation, reportErrors ? node.tagName : undefined, node.attributes, + /*headMessage*/ undefined, containingMessageChain, errorOutputContainer); + function checkTagNameDoesNotExpectTooManyArguments() { + var _a; + if (getJsxNamespaceContainerForImplicitImport(node)) { + return true; // factory is implicitly jsx/jsxdev - assume it fits the bill, since we don't strongly look for the jsx/jsxs/jsxDEV factory APIs anywhere else (at least not yet) + } + var tagType = ts.isJsxOpeningElement(node) || ts.isJsxSelfClosingElement(node) && !isJsxIntrinsicIdentifier(node.tagName) ? checkExpression(node.tagName) : undefined; + if (!tagType) { + return true; + } + var tagCallSignatures = getSignaturesOfType(tagType, 0 /* SignatureKind.Call */); + if (!ts.length(tagCallSignatures)) { + return true; + } + var factory = getJsxFactoryEntity(node); + if (!factory) { + return true; + } + var factorySymbol = resolveEntityName(factory, 111551 /* SymbolFlags.Value */, /*ignoreErrors*/ true, /*dontResolveAlias*/ false, node); + if (!factorySymbol) { + return true; + } + var factoryType = getTypeOfSymbol(factorySymbol); + var callSignatures = getSignaturesOfType(factoryType, 0 /* SignatureKind.Call */); + if (!ts.length(callSignatures)) { + return true; + } + var hasFirstParamSignatures = false; + var maxParamCount = 0; + // Check that _some_ first parameter expects a FC-like thing, and that some overload of the SFC expects an acceptable number of arguments + for (var _i = 0, callSignatures_1 = callSignatures; _i < callSignatures_1.length; _i++) { + var sig = callSignatures_1[_i]; + var firstparam = getTypeAtPosition(sig, 0); + var signaturesOfParam = getSignaturesOfType(firstparam, 0 /* SignatureKind.Call */); + if (!ts.length(signaturesOfParam)) + continue; + for (var _b = 0, signaturesOfParam_1 = signaturesOfParam; _b < signaturesOfParam_1.length; _b++) { + var paramSig = signaturesOfParam_1[_b]; + hasFirstParamSignatures = true; + if (hasEffectiveRestParameter(paramSig)) { + return true; // some signature has a rest param, so function components can have an arbitrary number of arguments + } + var paramCount = getParameterCount(paramSig); + if (paramCount > maxParamCount) { + maxParamCount = paramCount; + } + } + } + if (!hasFirstParamSignatures) { + // Not a single signature had a first parameter which expected a signature - for back compat, and + // to guard against generic factories which won't have signatures directly, do not error + return true; + } + var absoluteMinArgCount = Infinity; + for (var _c = 0, tagCallSignatures_1 = tagCallSignatures; _c < tagCallSignatures_1.length; _c++) { + var tagSig = tagCallSignatures_1[_c]; + var tagRequiredArgCount = getMinArgumentCount(tagSig); + if (tagRequiredArgCount < absoluteMinArgCount) { + absoluteMinArgCount = tagRequiredArgCount; + } + } + if (absoluteMinArgCount <= maxParamCount) { + return true; // some signature accepts the number of arguments the function component provides + } + if (reportErrors) { + var diag = ts.createDiagnosticForNode(node.tagName, ts.Diagnostics.Tag_0_expects_at_least_1_arguments_but_the_JSX_factory_2_provides_at_most_3, ts.entityNameToString(node.tagName), absoluteMinArgCount, ts.entityNameToString(factory), maxParamCount); + var tagNameDeclaration = (_a = getSymbolAtLocation(node.tagName)) === null || _a === void 0 ? void 0 : _a.valueDeclaration; + if (tagNameDeclaration) { + ts.addRelatedInfo(diag, ts.createDiagnosticForNode(tagNameDeclaration, ts.Diagnostics._0_is_declared_here, ts.entityNameToString(node.tagName))); + } + if (errorOutputContainer && errorOutputContainer.skipLogging) { + (errorOutputContainer.errors || (errorOutputContainer.errors = [])).push(diag); + } + if (!errorOutputContainer.skipLogging) { + diagnostics.add(diag); + } + } + return false; + } + } + function getSignatureApplicabilityError(node, args, signature, relation, checkMode, reportErrors, containingMessageChain) { + var errorOutputContainer = { errors: undefined, skipLogging: true }; + if (ts.isJsxOpeningLikeElement(node)) { + if (!checkApplicableSignatureForJsxOpeningLikeElement(node, signature, relation, checkMode, reportErrors, containingMessageChain, errorOutputContainer)) { + ts.Debug.assert(!reportErrors || !!errorOutputContainer.errors, "jsx should have errors when reporting errors"); + return errorOutputContainer.errors || ts.emptyArray; + } + return undefined; + } + var thisType = getThisTypeOfSignature(signature); + if (thisType && thisType !== voidType && node.kind !== 211 /* SyntaxKind.NewExpression */) { + // If the called expression is not of the form `x.f` or `x["f"]`, then sourceType = voidType + // If the signature's 'this' type is voidType, then the check is skipped -- anything is compatible. + // If the expression is a new expression, then the check is skipped. + var thisArgumentNode = getThisArgumentOfCall(node); + var thisArgumentType = getThisArgumentType(thisArgumentNode); + var errorNode = reportErrors ? (thisArgumentNode || node) : undefined; + var headMessage_1 = ts.Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1; + if (!checkTypeRelatedTo(thisArgumentType, thisType, relation, errorNode, headMessage_1, containingMessageChain, errorOutputContainer)) { + ts.Debug.assert(!reportErrors || !!errorOutputContainer.errors, "this parameter should have errors when reporting errors"); + return errorOutputContainer.errors || ts.emptyArray; + } + } + var headMessage = ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1; + var restType = getNonArrayRestType(signature); + var argCount = restType ? Math.min(getParameterCount(signature) - 1, args.length) : args.length; + for (var i = 0; i < argCount; i++) { + var arg = args[i]; + if (arg.kind !== 229 /* SyntaxKind.OmittedExpression */) { + var paramType = getTypeAtPosition(signature, i); + var argType = checkExpressionWithContextualType(arg, paramType, /*inferenceContext*/ undefined, checkMode); + // If one or more arguments are still excluded (as indicated by CheckMode.SkipContextSensitive), + // we obtain the regular type of any object literal arguments because we may not have inferred complete + // parameter types yet and therefore excess property checks may yield false positives (see #17041). + var checkArgType = checkMode & 4 /* CheckMode.SkipContextSensitive */ ? getRegularTypeOfObjectLiteral(argType) : argType; + if (!checkTypeRelatedToAndOptionallyElaborate(checkArgType, paramType, relation, reportErrors ? arg : undefined, arg, headMessage, containingMessageChain, errorOutputContainer)) { + ts.Debug.assert(!reportErrors || !!errorOutputContainer.errors, "parameter should have errors when reporting errors"); + maybeAddMissingAwaitInfo(arg, checkArgType, paramType); + return errorOutputContainer.errors || ts.emptyArray; + } + } + } + if (restType) { + var spreadType = getSpreadArgumentType(args, argCount, args.length, restType, /*context*/ undefined, checkMode); + var restArgCount = args.length - argCount; + var errorNode = !reportErrors ? undefined : + restArgCount === 0 ? node : + restArgCount === 1 ? args[argCount] : + ts.setTextRangePosEnd(createSyntheticExpression(node, spreadType), args[argCount].pos, args[args.length - 1].end); + if (!checkTypeRelatedTo(spreadType, restType, relation, errorNode, headMessage, /*containingMessageChain*/ undefined, errorOutputContainer)) { + ts.Debug.assert(!reportErrors || !!errorOutputContainer.errors, "rest parameter should have errors when reporting errors"); + maybeAddMissingAwaitInfo(errorNode, spreadType, restType); + return errorOutputContainer.errors || ts.emptyArray; + } + } + return undefined; + function maybeAddMissingAwaitInfo(errorNode, source, target) { + if (errorNode && reportErrors && errorOutputContainer.errors && errorOutputContainer.errors.length) { + // Bail if target is Promise-like---something else is wrong + if (getAwaitedTypeOfPromise(target)) { + return; + } + var awaitedTypeOfSource = getAwaitedTypeOfPromise(source); + if (awaitedTypeOfSource && isTypeRelatedTo(awaitedTypeOfSource, target, relation)) { + ts.addRelatedInfo(errorOutputContainer.errors[0], ts.createDiagnosticForNode(errorNode, ts.Diagnostics.Did_you_forget_to_use_await)); + } + } + } + } + /** + * Returns the this argument in calls like x.f(...) and x[f](...). Undefined otherwise. + */ + function getThisArgumentOfCall(node) { + var expression = node.kind === 210 /* SyntaxKind.CallExpression */ ? node.expression : + node.kind === 212 /* SyntaxKind.TaggedTemplateExpression */ ? node.tag : undefined; + if (expression) { + var callee = ts.skipOuterExpressions(expression); + if (ts.isAccessExpression(callee)) { + return callee.expression; + } + } + } + function createSyntheticExpression(parent, type, isSpread, tupleNameSource) { + var result = ts.parseNodeFactory.createSyntheticExpression(type, isSpread, tupleNameSource); + ts.setTextRange(result, parent); + ts.setParent(result, parent); + return result; + } + /** + * Returns the effective arguments for an expression that works like a function invocation. + */ + function getEffectiveCallArguments(node) { + if (node.kind === 212 /* SyntaxKind.TaggedTemplateExpression */) { + var template = node.template; + var args_3 = [createSyntheticExpression(template, getGlobalTemplateStringsArrayType())]; + if (template.kind === 225 /* SyntaxKind.TemplateExpression */) { + ts.forEach(template.templateSpans, function (span) { + args_3.push(span.expression); + }); + } + return args_3; + } + if (node.kind === 167 /* SyntaxKind.Decorator */) { + return getEffectiveDecoratorArguments(node); + } + if (ts.isJsxOpeningLikeElement(node)) { + return node.attributes.properties.length > 0 || (ts.isJsxOpeningElement(node) && node.parent.children.length > 0) ? [node.attributes] : ts.emptyArray; + } + var args = node.arguments || ts.emptyArray; + var spreadIndex = getSpreadArgumentIndex(args); + if (spreadIndex >= 0) { + // Create synthetic arguments from spreads of tuple types. + var effectiveArgs_1 = args.slice(0, spreadIndex); + var _loop_26 = function (i) { + var arg = args[i]; + // We can call checkExpressionCached because spread expressions never have a contextual type. + var spreadType = arg.kind === 227 /* SyntaxKind.SpreadElement */ && (flowLoopCount ? checkExpression(arg.expression) : checkExpressionCached(arg.expression)); + if (spreadType && isTupleType(spreadType)) { + ts.forEach(getTypeArguments(spreadType), function (t, i) { + var _a; + var flags = spreadType.target.elementFlags[i]; + var syntheticArg = createSyntheticExpression(arg, flags & 4 /* ElementFlags.Rest */ ? createArrayType(t) : t, !!(flags & 12 /* ElementFlags.Variable */), (_a = spreadType.target.labeledElementDeclarations) === null || _a === void 0 ? void 0 : _a[i]); + effectiveArgs_1.push(syntheticArg); + }); + } + else { + effectiveArgs_1.push(arg); + } + }; + for (var i = spreadIndex; i < args.length; i++) { + _loop_26(i); + } + return effectiveArgs_1; + } + return args; + } + /** + * Returns the synthetic argument list for a decorator invocation. + */ + function getEffectiveDecoratorArguments(node) { + var parent = node.parent; + var expr = node.expression; + switch (parent.kind) { + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + // For a class decorator, the `target` is the type of the class (e.g. the + // "static" or "constructor" side of the class). + return [ + createSyntheticExpression(expr, getTypeOfSymbol(getSymbolOfNode(parent))) + ]; + case 166 /* SyntaxKind.Parameter */: + // A parameter declaration decorator will have three arguments (see + // `ParameterDecorator` in core.d.ts). + var func = parent.parent; + return [ + createSyntheticExpression(expr, parent.parent.kind === 173 /* SyntaxKind.Constructor */ ? getTypeOfSymbol(getSymbolOfNode(func)) : errorType), + createSyntheticExpression(expr, anyType), + createSyntheticExpression(expr, numberType) + ]; + case 169 /* SyntaxKind.PropertyDeclaration */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + // A method or accessor declaration decorator will have two or three arguments (see + // `PropertyDecorator` and `MethodDecorator` in core.d.ts). If we are emitting decorators + // for ES3, we will only pass two arguments. + var hasPropDesc = languageVersion !== 0 /* ScriptTarget.ES3 */ && (!ts.isPropertyDeclaration(parent) || ts.hasAccessorModifier(parent)); + return [ + createSyntheticExpression(expr, getParentTypeOfClassElement(parent)), + createSyntheticExpression(expr, getClassElementPropertyKeyType(parent)), + createSyntheticExpression(expr, hasPropDesc ? createTypedPropertyDescriptorType(getTypeOfNode(parent)) : anyType) + ]; + } + return ts.Debug.fail(); + } + /** + * Returns the argument count for a decorator node that works like a function invocation. + */ + function getDecoratorArgumentCount(node, signature) { + switch (node.parent.kind) { + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + return 1; + case 169 /* SyntaxKind.PropertyDeclaration */: + return ts.hasAccessorModifier(node.parent) ? 3 : 2; + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + // For ES3 or decorators with only two parameters we supply only two arguments + return languageVersion === 0 /* ScriptTarget.ES3 */ || signature.parameters.length <= 2 ? 2 : 3; + case 166 /* SyntaxKind.Parameter */: + return 3; + default: + return ts.Debug.fail(); + } + } + function getDiagnosticSpanForCallNode(node, doNotIncludeArguments) { + var start; + var length; + var sourceFile = ts.getSourceFileOfNode(node); + if (ts.isPropertyAccessExpression(node.expression)) { + var nameSpan = ts.getErrorSpanForNode(sourceFile, node.expression.name); + start = nameSpan.start; + length = doNotIncludeArguments ? nameSpan.length : node.end - start; + } + else { + var expressionSpan = ts.getErrorSpanForNode(sourceFile, node.expression); + start = expressionSpan.start; + length = doNotIncludeArguments ? expressionSpan.length : node.end - start; + } + return { start: start, length: length, sourceFile: sourceFile }; + } + function getDiagnosticForCallNode(node, message, arg0, arg1, arg2, arg3) { + if (ts.isCallExpression(node)) { + var _a = getDiagnosticSpanForCallNode(node), sourceFile = _a.sourceFile, start = _a.start, length_6 = _a.length; + return ts.createFileDiagnostic(sourceFile, start, length_6, message, arg0, arg1, arg2, arg3); + } + else { + return ts.createDiagnosticForNode(node, message, arg0, arg1, arg2, arg3); + } + } + function isPromiseResolveArityError(node) { + if (!ts.isCallExpression(node) || !ts.isIdentifier(node.expression)) + return false; + var symbol = resolveName(node.expression, node.expression.escapedText, 111551 /* SymbolFlags.Value */, undefined, undefined, false); + var decl = symbol === null || symbol === void 0 ? void 0 : symbol.valueDeclaration; + if (!decl || !ts.isParameter(decl) || !ts.isFunctionExpressionOrArrowFunction(decl.parent) || !ts.isNewExpression(decl.parent.parent) || !ts.isIdentifier(decl.parent.parent.expression)) { + return false; + } + var globalPromiseSymbol = getGlobalPromiseConstructorSymbol(/*reportErrors*/ false); + if (!globalPromiseSymbol) + return false; + var constructorSymbol = getSymbolAtLocation(decl.parent.parent.expression, /*ignoreErrors*/ true); + return constructorSymbol === globalPromiseSymbol; + } + function getArgumentArityError(node, signatures, args) { + var _a; + var spreadIndex = getSpreadArgumentIndex(args); + if (spreadIndex > -1) { + return ts.createDiagnosticForNode(args[spreadIndex], ts.Diagnostics.A_spread_argument_must_either_have_a_tuple_type_or_be_passed_to_a_rest_parameter); + } + var min = Number.POSITIVE_INFINITY; // smallest parameter count + var max = Number.NEGATIVE_INFINITY; // largest parameter count + var maxBelow = Number.NEGATIVE_INFINITY; // largest parameter count that is smaller than the number of arguments + var minAbove = Number.POSITIVE_INFINITY; // smallest parameter count that is larger than the number of arguments + var closestSignature; + for (var _i = 0, signatures_8 = signatures; _i < signatures_8.length; _i++) { + var sig = signatures_8[_i]; + var minParameter = getMinArgumentCount(sig); + var maxParameter = getParameterCount(sig); + // smallest/largest parameter counts + if (minParameter < min) { + min = minParameter; + closestSignature = sig; + } + max = Math.max(max, maxParameter); + // shortest parameter count *longer than the call*/longest parameter count *shorter than the call* + if (minParameter < args.length && minParameter > maxBelow) + maxBelow = minParameter; + if (args.length < maxParameter && maxParameter < minAbove) + minAbove = maxParameter; + } + var hasRestParameter = ts.some(signatures, hasEffectiveRestParameter); + var parameterRange = hasRestParameter ? min + : min < max ? min + "-" + max + : min; + var isVoidPromiseError = !hasRestParameter && parameterRange === 1 && args.length === 0 && isPromiseResolveArityError(node); + if (isVoidPromiseError && ts.isInJSFile(node)) { + return getDiagnosticForCallNode(node, ts.Diagnostics.Expected_1_argument_but_got_0_new_Promise_needs_a_JSDoc_hint_to_produce_a_resolve_that_can_be_called_without_arguments); + } + var error = hasRestParameter + ? ts.Diagnostics.Expected_at_least_0_arguments_but_got_1 + : isVoidPromiseError + ? ts.Diagnostics.Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise + : ts.Diagnostics.Expected_0_arguments_but_got_1; + if (min < args.length && args.length < max) { + // between min and max, but with no matching overload + return getDiagnosticForCallNode(node, ts.Diagnostics.No_overload_expects_0_arguments_but_overloads_do_exist_that_expect_either_1_or_2_arguments, args.length, maxBelow, minAbove); + } + else if (args.length < min) { + // too short: put the error span on the call expression, not any of the args + var diagnostic = getDiagnosticForCallNode(node, error, parameterRange, args.length); + var parameter = (_a = closestSignature === null || closestSignature === void 0 ? void 0 : closestSignature.declaration) === null || _a === void 0 ? void 0 : _a.parameters[closestSignature.thisParameter ? args.length + 1 : args.length]; + if (parameter) { + var parameterError = ts.createDiagnosticForNode(parameter, ts.isBindingPattern(parameter.name) ? ts.Diagnostics.An_argument_matching_this_binding_pattern_was_not_provided + : ts.isRestParameter(parameter) ? ts.Diagnostics.Arguments_for_the_rest_parameter_0_were_not_provided + : ts.Diagnostics.An_argument_for_0_was_not_provided, !parameter.name ? args.length : !ts.isBindingPattern(parameter.name) ? ts.idText(ts.getFirstIdentifier(parameter.name)) : undefined); + return ts.addRelatedInfo(diagnostic, parameterError); + } + return diagnostic; + } + else { + // too long; error goes on the excess parameters + var errorSpan = ts.factory.createNodeArray(args.slice(max)); + var pos = ts.first(errorSpan).pos; + var end = ts.last(errorSpan).end; + if (end === pos) { + end++; + } + ts.setTextRangePosEnd(errorSpan, pos, end); + return ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), errorSpan, error, parameterRange, args.length); + } + } + function getTypeArgumentArityError(node, signatures, typeArguments) { + var argCount = typeArguments.length; + // No overloads exist + if (signatures.length === 1) { + var sig = signatures[0]; + var min_1 = getMinTypeArgumentCount(sig.typeParameters); + var max = ts.length(sig.typeParameters); + return ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), typeArguments, ts.Diagnostics.Expected_0_type_arguments_but_got_1, min_1 < max ? min_1 + "-" + max : min_1, argCount); + } + // Overloads exist + var belowArgCount = -Infinity; + var aboveArgCount = Infinity; + for (var _i = 0, signatures_9 = signatures; _i < signatures_9.length; _i++) { + var sig = signatures_9[_i]; + var min_2 = getMinTypeArgumentCount(sig.typeParameters); + var max = ts.length(sig.typeParameters); + if (min_2 > argCount) { + aboveArgCount = Math.min(aboveArgCount, min_2); + } + else if (max < argCount) { + belowArgCount = Math.max(belowArgCount, max); + } + } + if (belowArgCount !== -Infinity && aboveArgCount !== Infinity) { + return ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), typeArguments, ts.Diagnostics.No_overload_expects_0_type_arguments_but_overloads_do_exist_that_expect_either_1_or_2_type_arguments, argCount, belowArgCount, aboveArgCount); + } + return ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), typeArguments, ts.Diagnostics.Expected_0_type_arguments_but_got_1, belowArgCount === -Infinity ? aboveArgCount : belowArgCount, argCount); + } + function resolveCall(node, signatures, candidatesOutArray, checkMode, callChainFlags, fallbackError) { + var isTaggedTemplate = node.kind === 212 /* SyntaxKind.TaggedTemplateExpression */; + var isDecorator = node.kind === 167 /* SyntaxKind.Decorator */; + var isJsxOpeningOrSelfClosingElement = ts.isJsxOpeningLikeElement(node); + var reportErrors = !candidatesOutArray; + var typeArguments; + if (!isDecorator && !ts.isSuperCall(node)) { + typeArguments = node.typeArguments; + // We already perform checking on the type arguments on the class declaration itself. + if (isTaggedTemplate || isJsxOpeningOrSelfClosingElement || node.expression.kind !== 106 /* SyntaxKind.SuperKeyword */) { + ts.forEach(typeArguments, checkSourceElement); + } + } + var candidates = candidatesOutArray || []; + // reorderCandidates fills up the candidates array directly + reorderCandidates(signatures, candidates, callChainFlags); + if (!candidates.length) { + if (reportErrors) { + diagnostics.add(getDiagnosticForCallNode(node, ts.Diagnostics.Call_target_does_not_contain_any_signatures)); + } + return resolveErrorCall(node); + } + var args = getEffectiveCallArguments(node); + // The excludeArgument array contains true for each context sensitive argument (an argument + // is context sensitive it is susceptible to a one-time permanent contextual typing). + // + // The idea is that we will perform type argument inference & assignability checking once + // without using the susceptible parameters that are functions, and once more for those + // parameters, contextually typing each as we go along. + // + // For a tagged template, then the first argument be 'undefined' if necessary because it + // represents a TemplateStringsArray. + // + // For a decorator, no arguments are susceptible to contextual typing due to the fact + // decorators are applied to a declaration by the emitter, and not to an expression. + var isSingleNonGenericCandidate = candidates.length === 1 && !candidates[0].typeParameters; + var argCheckMode = !isDecorator && !isSingleNonGenericCandidate && ts.some(args, isContextSensitive) ? 4 /* CheckMode.SkipContextSensitive */ : 0 /* CheckMode.Normal */; + argCheckMode |= checkMode & 32 /* CheckMode.IsForStringLiteralArgumentCompletions */; + // The following variables are captured and modified by calls to chooseOverload. + // If overload resolution or type argument inference fails, we want to report the + // best error possible. The best error is one which says that an argument was not + // assignable to a parameter. This implies that everything else about the overload + // was fine. So if there is any overload that is only incorrect because of an + // argument, we will report an error on that one. + // + // function foo(s: string): void; + // function foo(n: number): void; // Report argument error on this overload + // function foo(): void; + // foo(true); + // + // If none of the overloads even made it that far, there are two possibilities. + // There was a problem with type arguments for some overload, in which case + // report an error on that. Or none of the overloads even had correct arity, + // in which case give an arity error. + // + // function foo(x: T): void; // Report type argument error + // function foo(): void; + // foo(0); + // + var candidatesForArgumentError; + var candidateForArgumentArityError; + var candidateForTypeArgumentError; + var result; + // If we are in signature help, a trailing comma indicates that we intend to provide another argument, + // so we will only accept overloads with arity at least 1 higher than the current number of provided arguments. + var signatureHelpTrailingComma = !!(checkMode & 16 /* CheckMode.IsForSignatureHelp */) && node.kind === 210 /* SyntaxKind.CallExpression */ && node.arguments.hasTrailingComma; + // Section 4.12.1: + // if the candidate list contains one or more signatures for which the type of each argument + // expression is a subtype of each corresponding parameter type, the return type of the first + // of those signatures becomes the return type of the function call. + // Otherwise, the return type of the first signature in the candidate list becomes the return + // type of the function call. + // + // Whether the call is an error is determined by assignability of the arguments. The subtype pass + // is just important for choosing the best signature. So in the case where there is only one + // signature, the subtype pass is useless. So skipping it is an optimization. + if (candidates.length > 1) { + result = chooseOverload(candidates, subtypeRelation, isSingleNonGenericCandidate, signatureHelpTrailingComma); + } + if (!result) { + result = chooseOverload(candidates, assignableRelation, isSingleNonGenericCandidate, signatureHelpTrailingComma); + } + if (result) { + return result; + } + result = getCandidateForOverloadFailure(node, candidates, args, !!candidatesOutArray, checkMode); + // Preemptively cache the result; getResolvedSignature will do this after we return, but + // we need to ensure that the result is present for the error checks below so that if + // this signature is encountered again, we handle the circularity (rather than producing a + // different result which may produce no errors and assert). Callers of getResolvedSignature + // don't hit this issue because they only observe this result after it's had a chance to + // be cached, but the error reporting code below executes before getResolvedSignature sets + // resolvedSignature. + getNodeLinks(node).resolvedSignature = result; + // No signatures were applicable. Now report errors based on the last applicable signature with + // no arguments excluded from assignability checks. + // If candidate is undefined, it means that no candidates had a suitable arity. In that case, + // skip the checkApplicableSignature check. + if (reportErrors) { + if (candidatesForArgumentError) { + if (candidatesForArgumentError.length === 1 || candidatesForArgumentError.length > 3) { + var last_2 = candidatesForArgumentError[candidatesForArgumentError.length - 1]; + var chain_1; + if (candidatesForArgumentError.length > 3) { + chain_1 = ts.chainDiagnosticMessages(chain_1, ts.Diagnostics.The_last_overload_gave_the_following_error); + chain_1 = ts.chainDiagnosticMessages(chain_1, ts.Diagnostics.No_overload_matches_this_call); + } + var diags = getSignatureApplicabilityError(node, args, last_2, assignableRelation, 0 /* CheckMode.Normal */, /*reportErrors*/ true, function () { return chain_1; }); + if (diags) { + for (var _i = 0, diags_1 = diags; _i < diags_1.length; _i++) { + var d = diags_1[_i]; + if (last_2.declaration && candidatesForArgumentError.length > 3) { + ts.addRelatedInfo(d, ts.createDiagnosticForNode(last_2.declaration, ts.Diagnostics.The_last_overload_is_declared_here)); + } + addImplementationSuccessElaboration(last_2, d); + diagnostics.add(d); + } + } + else { + ts.Debug.fail("No error for last overload signature"); + } + } + else { + var allDiagnostics = []; + var max = 0; + var min_3 = Number.MAX_VALUE; + var minIndex = 0; + var i_1 = 0; + var _loop_27 = function (c) { + var chain_2 = function () { return ts.chainDiagnosticMessages(/*details*/ undefined, ts.Diagnostics.Overload_0_of_1_2_gave_the_following_error, i_1 + 1, candidates.length, signatureToString(c)); }; + var diags_2 = getSignatureApplicabilityError(node, args, c, assignableRelation, 0 /* CheckMode.Normal */, /*reportErrors*/ true, chain_2); + if (diags_2) { + if (diags_2.length <= min_3) { + min_3 = diags_2.length; + minIndex = i_1; + } + max = Math.max(max, diags_2.length); + allDiagnostics.push(diags_2); + } + else { + ts.Debug.fail("No error for 3 or fewer overload signatures"); + } + i_1++; + }; + for (var _a = 0, candidatesForArgumentError_1 = candidatesForArgumentError; _a < candidatesForArgumentError_1.length; _a++) { + var c = candidatesForArgumentError_1[_a]; + _loop_27(c); + } + var diags_3 = max > 1 ? allDiagnostics[minIndex] : ts.flatten(allDiagnostics); + ts.Debug.assert(diags_3.length > 0, "No errors reported for 3 or fewer overload signatures"); + var chain = ts.chainDiagnosticMessages(ts.map(diags_3, ts.createDiagnosticMessageChainFromDiagnostic), ts.Diagnostics.No_overload_matches_this_call); + // The below is a spread to guarantee we get a new (mutable) array - our `flatMap` helper tries to do "smart" optimizations where it reuses input + // arrays and the emptyArray singleton where possible, which is decidedly not what we want while we're still constructing this diagnostic + var related = __spreadArray([], ts.flatMap(diags_3, function (d) { return d.relatedInformation; }), true); + var diag = void 0; + if (ts.every(diags_3, function (d) { return d.start === diags_3[0].start && d.length === diags_3[0].length && d.file === diags_3[0].file; })) { + var _b = diags_3[0], file = _b.file, start = _b.start, length_7 = _b.length; + diag = { file: file, start: start, length: length_7, code: chain.code, category: chain.category, messageText: chain, relatedInformation: related }; + } + else { + diag = ts.createDiagnosticForNodeFromMessageChain(node, chain, related); + } + addImplementationSuccessElaboration(candidatesForArgumentError[0], diag); + diagnostics.add(diag); + } + } + else if (candidateForArgumentArityError) { + diagnostics.add(getArgumentArityError(node, [candidateForArgumentArityError], args)); + } + else if (candidateForTypeArgumentError) { + checkTypeArguments(candidateForTypeArgumentError, node.typeArguments, /*reportErrors*/ true, fallbackError); + } + else { + var signaturesWithCorrectTypeArgumentArity = ts.filter(signatures, function (s) { return hasCorrectTypeArgumentArity(s, typeArguments); }); + if (signaturesWithCorrectTypeArgumentArity.length === 0) { + diagnostics.add(getTypeArgumentArityError(node, signatures, typeArguments)); + } + else if (!isDecorator) { + diagnostics.add(getArgumentArityError(node, signaturesWithCorrectTypeArgumentArity, args)); + } + else if (fallbackError) { + diagnostics.add(getDiagnosticForCallNode(node, fallbackError)); + } + } + } + return result; + function addImplementationSuccessElaboration(failed, diagnostic) { + var _a, _b; + var oldCandidatesForArgumentError = candidatesForArgumentError; + var oldCandidateForArgumentArityError = candidateForArgumentArityError; + var oldCandidateForTypeArgumentError = candidateForTypeArgumentError; + var failedSignatureDeclarations = ((_b = (_a = failed.declaration) === null || _a === void 0 ? void 0 : _a.symbol) === null || _b === void 0 ? void 0 : _b.declarations) || ts.emptyArray; + var isOverload = failedSignatureDeclarations.length > 1; + var implDecl = isOverload ? ts.find(failedSignatureDeclarations, function (d) { return ts.isFunctionLikeDeclaration(d) && ts.nodeIsPresent(d.body); }) : undefined; + if (implDecl) { + var candidate = getSignatureFromDeclaration(implDecl); + var isSingleNonGenericCandidate_1 = !candidate.typeParameters; + if (chooseOverload([candidate], assignableRelation, isSingleNonGenericCandidate_1)) { + ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(implDecl, ts.Diagnostics.The_call_would_have_succeeded_against_this_implementation_but_implementation_signatures_of_overloads_are_not_externally_visible)); + } + } + candidatesForArgumentError = oldCandidatesForArgumentError; + candidateForArgumentArityError = oldCandidateForArgumentArityError; + candidateForTypeArgumentError = oldCandidateForTypeArgumentError; + } + function chooseOverload(candidates, relation, isSingleNonGenericCandidate, signatureHelpTrailingComma) { + if (signatureHelpTrailingComma === void 0) { signatureHelpTrailingComma = false; } + candidatesForArgumentError = undefined; + candidateForArgumentArityError = undefined; + candidateForTypeArgumentError = undefined; + if (isSingleNonGenericCandidate) { + var candidate = candidates[0]; + if (ts.some(typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma)) { + return undefined; + } + if (getSignatureApplicabilityError(node, args, candidate, relation, 0 /* CheckMode.Normal */, /*reportErrors*/ false, /*containingMessageChain*/ undefined)) { + candidatesForArgumentError = [candidate]; + return undefined; + } + return candidate; + } + for (var candidateIndex = 0; candidateIndex < candidates.length; candidateIndex++) { + var candidate = candidates[candidateIndex]; + if (!hasCorrectTypeArgumentArity(candidate, typeArguments) || !hasCorrectArity(node, args, candidate, signatureHelpTrailingComma)) { + continue; + } + var checkCandidate = void 0; + var inferenceContext = void 0; + if (candidate.typeParameters) { + var typeArgumentTypes = void 0; + if (ts.some(typeArguments)) { + typeArgumentTypes = checkTypeArguments(candidate, typeArguments, /*reportErrors*/ false); + if (!typeArgumentTypes) { + candidateForTypeArgumentError = candidate; + continue; + } + } + else { + inferenceContext = createInferenceContext(candidate.typeParameters, candidate, /*flags*/ ts.isInJSFile(node) ? 2 /* InferenceFlags.AnyDefault */ : 0 /* InferenceFlags.None */); + typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode | 8 /* CheckMode.SkipGenericFunctions */, inferenceContext); + argCheckMode |= inferenceContext.flags & 4 /* InferenceFlags.SkippedGenericFunction */ ? 8 /* CheckMode.SkipGenericFunctions */ : 0 /* CheckMode.Normal */; + } + checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, ts.isInJSFile(candidate.declaration), inferenceContext && inferenceContext.inferredTypeParameters); + // If the original signature has a generic rest type, instantiation may produce a + // signature with different arity and we need to perform another arity check. + if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma)) { + candidateForArgumentArityError = checkCandidate; + continue; + } + } + else { + checkCandidate = candidate; + } + if (getSignatureApplicabilityError(node, args, checkCandidate, relation, argCheckMode, /*reportErrors*/ false, /*containingMessageChain*/ undefined)) { + // Give preference to error candidates that have no rest parameters (as they are more specific) + (candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate); + continue; + } + if (argCheckMode) { + // If one or more context sensitive arguments were excluded, we start including + // them now (and keeping do so for any subsequent candidates) and perform a second + // round of type inference and applicability checking for this particular candidate. + argCheckMode = checkMode & 32 /* CheckMode.IsForStringLiteralArgumentCompletions */; + if (inferenceContext) { + var typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext); + checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, ts.isInJSFile(candidate.declaration), inferenceContext.inferredTypeParameters); + // If the original signature has a generic rest type, instantiation may produce a + // signature with different arity and we need to perform another arity check. + if (getNonArrayRestType(candidate) && !hasCorrectArity(node, args, checkCandidate, signatureHelpTrailingComma)) { + candidateForArgumentArityError = checkCandidate; + continue; + } + } + if (getSignatureApplicabilityError(node, args, checkCandidate, relation, argCheckMode, /*reportErrors*/ false, /*containingMessageChain*/ undefined)) { + // Give preference to error candidates that have no rest parameters (as they are more specific) + (candidatesForArgumentError || (candidatesForArgumentError = [])).push(checkCandidate); + continue; + } + } + candidates[candidateIndex] = checkCandidate; + return checkCandidate; + } + return undefined; + } + } + // No signature was applicable. We have already reported the errors for the invalid signature. + function getCandidateForOverloadFailure(node, candidates, args, hasCandidatesOutArray, checkMode) { + ts.Debug.assert(candidates.length > 0); // Else should not have called this. + checkNodeDeferred(node); + // Normally we will combine overloads. Skip this if they have type parameters since that's hard to combine. + // Don't do this if there is a `candidatesOutArray`, + // because then we want the chosen best candidate to be one of the overloads, not a combination. + return hasCandidatesOutArray || candidates.length === 1 || candidates.some(function (c) { return !!c.typeParameters; }) + ? pickLongestCandidateSignature(node, candidates, args, checkMode) + : createUnionOfSignaturesForOverloadFailure(candidates); + } + function createUnionOfSignaturesForOverloadFailure(candidates) { + var thisParameters = ts.mapDefined(candidates, function (c) { return c.thisParameter; }); + var thisParameter; + if (thisParameters.length) { + thisParameter = createCombinedSymbolFromTypes(thisParameters, thisParameters.map(getTypeOfParameter)); + } + var _a = ts.minAndMax(candidates, getNumNonRestParameters), minArgumentCount = _a.min, maxNonRestParam = _a.max; + var parameters = []; + var _loop_28 = function (i) { + var symbols = ts.mapDefined(candidates, function (s) { return signatureHasRestParameter(s) ? + i < s.parameters.length - 1 ? s.parameters[i] : ts.last(s.parameters) : + i < s.parameters.length ? s.parameters[i] : undefined; }); + ts.Debug.assert(symbols.length !== 0); + parameters.push(createCombinedSymbolFromTypes(symbols, ts.mapDefined(candidates, function (candidate) { return tryGetTypeAtPosition(candidate, i); }))); + }; + for (var i = 0; i < maxNonRestParam; i++) { + _loop_28(i); + } + var restParameterSymbols = ts.mapDefined(candidates, function (c) { return signatureHasRestParameter(c) ? ts.last(c.parameters) : undefined; }); + var flags = 0 /* SignatureFlags.None */; + if (restParameterSymbols.length !== 0) { + var type = createArrayType(getUnionType(ts.mapDefined(candidates, tryGetRestTypeOfSignature), 2 /* UnionReduction.Subtype */)); + parameters.push(createCombinedSymbolForOverloadFailure(restParameterSymbols, type)); + flags |= 1 /* SignatureFlags.HasRestParameter */; + } + if (candidates.some(signatureHasLiteralTypes)) { + flags |= 2 /* SignatureFlags.HasLiteralTypes */; + } + return createSignature(candidates[0].declaration, + /*typeParameters*/ undefined, // Before calling this we tested for `!candidates.some(c => !!c.typeParameters)`. + thisParameter, parameters, + /*resolvedReturnType*/ getIntersectionType(candidates.map(getReturnTypeOfSignature)), + /*typePredicate*/ undefined, minArgumentCount, flags); + } + function getNumNonRestParameters(signature) { + var numParams = signature.parameters.length; + return signatureHasRestParameter(signature) ? numParams - 1 : numParams; + } + function createCombinedSymbolFromTypes(sources, types) { + return createCombinedSymbolForOverloadFailure(sources, getUnionType(types, 2 /* UnionReduction.Subtype */)); + } + function createCombinedSymbolForOverloadFailure(sources, type) { + // This function is currently only used for erroneous overloads, so it's good enough to just use the first source. + return createSymbolWithType(ts.first(sources), type); + } + function pickLongestCandidateSignature(node, candidates, args, checkMode) { + // Pick the longest signature. This way we can get a contextual type for cases like: + // declare function f(a: { xa: number; xb: number; }, b: number); + // f({ | + // Also, use explicitly-supplied type arguments if they are provided, so we can get a contextual signature in cases like: + // declare function f(k: keyof T); + // f(" + var bestIndex = getLongestCandidateIndex(candidates, apparentArgumentCount === undefined ? args.length : apparentArgumentCount); + var candidate = candidates[bestIndex]; + var typeParameters = candidate.typeParameters; + if (!typeParameters) { + return candidate; + } + var typeArgumentNodes = callLikeExpressionMayHaveTypeArguments(node) ? node.typeArguments : undefined; + var instantiated = typeArgumentNodes + ? createSignatureInstantiation(candidate, getTypeArgumentsFromNodes(typeArgumentNodes, typeParameters, ts.isInJSFile(node))) + : inferSignatureInstantiationForOverloadFailure(node, typeParameters, candidate, args, checkMode); + candidates[bestIndex] = instantiated; + return instantiated; + } + function getTypeArgumentsFromNodes(typeArgumentNodes, typeParameters, isJs) { + var typeArguments = typeArgumentNodes.map(getTypeOfNode); + while (typeArguments.length > typeParameters.length) { + typeArguments.pop(); + } + while (typeArguments.length < typeParameters.length) { + typeArguments.push(getDefaultFromTypeParameter(typeParameters[typeArguments.length]) || getConstraintOfTypeParameter(typeParameters[typeArguments.length]) || getDefaultTypeArgumentType(isJs)); + } + return typeArguments; + } + function inferSignatureInstantiationForOverloadFailure(node, typeParameters, candidate, args, checkMode) { + var inferenceContext = createInferenceContext(typeParameters, candidate, /*flags*/ ts.isInJSFile(node) ? 2 /* InferenceFlags.AnyDefault */ : 0 /* InferenceFlags.None */); + var typeArgumentTypes = inferTypeArguments(node, candidate, args, checkMode | 4 /* CheckMode.SkipContextSensitive */ | 8 /* CheckMode.SkipGenericFunctions */, inferenceContext); + return createSignatureInstantiation(candidate, typeArgumentTypes); + } + function getLongestCandidateIndex(candidates, argsCount) { + var maxParamsIndex = -1; + var maxParams = -1; + for (var i = 0; i < candidates.length; i++) { + var candidate = candidates[i]; + var paramCount = getParameterCount(candidate); + if (hasEffectiveRestParameter(candidate) || paramCount >= argsCount) { + return i; + } + if (paramCount > maxParams) { + maxParams = paramCount; + maxParamsIndex = i; + } + } + return maxParamsIndex; + } + function resolveCallExpression(node, candidatesOutArray, checkMode) { + if (node.expression.kind === 106 /* SyntaxKind.SuperKeyword */) { + var superType = checkSuperExpression(node.expression); + if (isTypeAny(superType)) { + for (var _i = 0, _a = node.arguments; _i < _a.length; _i++) { + var arg = _a[_i]; + checkExpression(arg); // Still visit arguments so they get marked for visibility, etc + } + return anySignature; + } + if (!isErrorType(superType)) { + // In super call, the candidate signatures are the matching arity signatures of the base constructor function instantiated + // with the type arguments specified in the extends clause. + var baseTypeNode = ts.getEffectiveBaseTypeNode(ts.getContainingClass(node)); + if (baseTypeNode) { + var baseConstructors = getInstantiatedConstructorsForTypeArguments(superType, baseTypeNode.typeArguments, baseTypeNode); + return resolveCall(node, baseConstructors, candidatesOutArray, checkMode, 0 /* SignatureFlags.None */); + } + } + return resolveUntypedCall(node); + } + var callChainFlags; + var funcType = checkExpression(node.expression); + if (ts.isCallChain(node)) { + var nonOptionalType = getOptionalExpressionType(funcType, node.expression); + callChainFlags = nonOptionalType === funcType ? 0 /* SignatureFlags.None */ : + ts.isOutermostOptionalChain(node) ? 16 /* SignatureFlags.IsOuterCallChain */ : + 8 /* SignatureFlags.IsInnerCallChain */; + funcType = nonOptionalType; + } + else { + callChainFlags = 0 /* SignatureFlags.None */; + } + funcType = checkNonNullTypeWithReporter(funcType, node.expression, reportCannotInvokePossiblyNullOrUndefinedError); + if (funcType === silentNeverType) { + return silentNeverSignature; + } + var apparentType = getApparentType(funcType); + if (isErrorType(apparentType)) { + // Another error has already been reported + return resolveErrorCall(node); + } + // Technically, this signatures list may be incomplete. We are taking the apparent type, + // but we are not including call signatures that may have been added to the Object or + // Function interface, since they have none by default. This is a bit of a leap of faith + // that the user will not add any. + var callSignatures = getSignaturesOfType(apparentType, 0 /* SignatureKind.Call */); + var numConstructSignatures = getSignaturesOfType(apparentType, 1 /* SignatureKind.Construct */).length; + // TS 1.0 Spec: 4.12 + // In an untyped function call no TypeArgs are permitted, Args can be any argument list, no contextual + // types are provided for the argument expressions, and the result is always of type Any. + if (isUntypedFunctionCall(funcType, apparentType, callSignatures.length, numConstructSignatures)) { + // The unknownType indicates that an error already occurred (and was reported). No + // need to report another error in this case. + if (!isErrorType(funcType) && node.typeArguments) { + error(node, ts.Diagnostics.Untyped_function_calls_may_not_accept_type_arguments); + } + return resolveUntypedCall(node); + } + // If FuncExpr's apparent type(section 3.8.1) is a function type, the call is a typed function call. + // TypeScript employs overload resolution in typed function calls in order to support functions + // with multiple call signatures. + if (!callSignatures.length) { + if (numConstructSignatures) { + error(node, ts.Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new, typeToString(funcType)); + } + else { + var relatedInformation = void 0; + if (node.arguments.length === 1) { + var text = ts.getSourceFileOfNode(node).text; + if (ts.isLineBreak(text.charCodeAt(ts.skipTrivia(text, node.expression.end, /* stopAfterLineBreak */ true) - 1))) { + relatedInformation = ts.createDiagnosticForNode(node.expression, ts.Diagnostics.Are_you_missing_a_semicolon); + } + } + invocationError(node.expression, apparentType, 0 /* SignatureKind.Call */, relatedInformation); + } + return resolveErrorCall(node); + } + // When a call to a generic function is an argument to an outer call to a generic function for which + // inference is in process, we have a choice to make. If the inner call relies on inferences made from + // its contextual type to its return type, deferring the inner call processing allows the best possible + // contextual type to accumulate. But if the outer call relies on inferences made from the return type of + // the inner call, the inner call should be processed early. There's no sure way to know which choice is + // right (only a full unification algorithm can determine that), so we resort to the following heuristic: + // If no type arguments are specified in the inner call and at least one call signature is generic and + // returns a function type, we choose to defer processing. This narrowly permits function composition + // operators to flow inferences through return types, but otherwise processes calls right away. We + // use the resolvingSignature singleton to indicate that we deferred processing. This result will be + // propagated out and eventually turned into silentNeverType (a type that is assignable to anything and + // from which we never make inferences). + if (checkMode & 8 /* CheckMode.SkipGenericFunctions */ && !node.typeArguments && callSignatures.some(isGenericFunctionReturningFunction)) { + skippedGenericFunction(node, checkMode); + return resolvingSignature; + } + // If the function is explicitly marked with `@class`, then it must be constructed. + if (callSignatures.some(function (sig) { return ts.isInJSFile(sig.declaration) && !!ts.getJSDocClassTag(sig.declaration); })) { + error(node, ts.Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new, typeToString(funcType)); + return resolveErrorCall(node); + } + return resolveCall(node, callSignatures, candidatesOutArray, checkMode, callChainFlags); + } + function isGenericFunctionReturningFunction(signature) { + return !!(signature.typeParameters && isFunctionType(getReturnTypeOfSignature(signature))); + } + /** + * TS 1.0 spec: 4.12 + * If FuncExpr is of type Any, or of an object type that has no call or construct signatures + * but is a subtype of the Function interface, the call is an untyped function call. + */ + function isUntypedFunctionCall(funcType, apparentFuncType, numCallSignatures, numConstructSignatures) { + // We exclude union types because we may have a union of function types that happen to have no common signatures. + return isTypeAny(funcType) || isTypeAny(apparentFuncType) && !!(funcType.flags & 262144 /* TypeFlags.TypeParameter */) || + !numCallSignatures && !numConstructSignatures && !(apparentFuncType.flags & 1048576 /* TypeFlags.Union */) && !(getReducedType(apparentFuncType).flags & 131072 /* TypeFlags.Never */) && isTypeAssignableTo(funcType, globalFunctionType); + } + function resolveNewExpression(node, candidatesOutArray, checkMode) { + if (node.arguments && languageVersion < 1 /* ScriptTarget.ES5 */) { + var spreadIndex = getSpreadArgumentIndex(node.arguments); + if (spreadIndex >= 0) { + error(node.arguments[spreadIndex], ts.Diagnostics.Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher); + } + } + var expressionType = checkNonNullExpression(node.expression); + if (expressionType === silentNeverType) { + return silentNeverSignature; + } + // If expressionType's apparent type(section 3.8.1) is an object type with one or + // more construct signatures, the expression is processed in the same manner as a + // function call, but using the construct signatures as the initial set of candidate + // signatures for overload resolution. The result type of the function call becomes + // the result type of the operation. + expressionType = getApparentType(expressionType); + if (isErrorType(expressionType)) { + // Another error has already been reported + return resolveErrorCall(node); + } + // TS 1.0 spec: 4.11 + // If expressionType is of type Any, Args can be any argument + // list and the result of the operation is of type Any. + if (isTypeAny(expressionType)) { + if (node.typeArguments) { + error(node, ts.Diagnostics.Untyped_function_calls_may_not_accept_type_arguments); + } + return resolveUntypedCall(node); + } + // Technically, this signatures list may be incomplete. We are taking the apparent type, + // but we are not including construct signatures that may have been added to the Object or + // Function interface, since they have none by default. This is a bit of a leap of faith + // that the user will not add any. + var constructSignatures = getSignaturesOfType(expressionType, 1 /* SignatureKind.Construct */); + if (constructSignatures.length) { + if (!isConstructorAccessible(node, constructSignatures[0])) { + return resolveErrorCall(node); + } + // If the expression is a class of abstract type, or an abstract construct signature, + // then it cannot be instantiated. + // In the case of a merged class-module or class-interface declaration, + // only the class declaration node will have the Abstract flag set. + if (someSignature(constructSignatures, function (signature) { return !!(signature.flags & 4 /* SignatureFlags.Abstract */); })) { + error(node, ts.Diagnostics.Cannot_create_an_instance_of_an_abstract_class); + return resolveErrorCall(node); + } + var valueDecl = expressionType.symbol && ts.getClassLikeDeclarationOfSymbol(expressionType.symbol); + if (valueDecl && ts.hasSyntacticModifier(valueDecl, 256 /* ModifierFlags.Abstract */)) { + error(node, ts.Diagnostics.Cannot_create_an_instance_of_an_abstract_class); + return resolveErrorCall(node); + } + return resolveCall(node, constructSignatures, candidatesOutArray, checkMode, 0 /* SignatureFlags.None */); + } + // If expressionType's apparent type is an object type with no construct signatures but + // one or more call signatures, the expression is processed as a function call. A compile-time + // error occurs if the result of the function call is not Void. The type of the result of the + // operation is Any. It is an error to have a Void this type. + var callSignatures = getSignaturesOfType(expressionType, 0 /* SignatureKind.Call */); + if (callSignatures.length) { + var signature = resolveCall(node, callSignatures, candidatesOutArray, checkMode, 0 /* SignatureFlags.None */); + if (!noImplicitAny) { + if (signature.declaration && !isJSConstructor(signature.declaration) && getReturnTypeOfSignature(signature) !== voidType) { + error(node, ts.Diagnostics.Only_a_void_function_can_be_called_with_the_new_keyword); + } + if (getThisTypeOfSignature(signature) === voidType) { + error(node, ts.Diagnostics.A_function_that_is_called_with_the_new_keyword_cannot_have_a_this_type_that_is_void); + } + } + return signature; + } + invocationError(node.expression, expressionType, 1 /* SignatureKind.Construct */); + return resolveErrorCall(node); + } + function someSignature(signatures, f) { + if (ts.isArray(signatures)) { + return ts.some(signatures, function (signature) { return someSignature(signature, f); }); + } + return signatures.compositeKind === 1048576 /* TypeFlags.Union */ ? ts.some(signatures.compositeSignatures, f) : f(signatures); + } + function typeHasProtectedAccessibleBase(target, type) { + var baseTypes = getBaseTypes(type); + if (!ts.length(baseTypes)) { + return false; + } + var firstBase = baseTypes[0]; + if (firstBase.flags & 2097152 /* TypeFlags.Intersection */) { + var types = firstBase.types; + var mixinFlags = findMixins(types); + var i = 0; + for (var _i = 0, _a = firstBase.types; _i < _a.length; _i++) { + var intersectionMember = _a[_i]; + // We want to ignore mixin ctors + if (!mixinFlags[i]) { + if (ts.getObjectFlags(intersectionMember) & (1 /* ObjectFlags.Class */ | 2 /* ObjectFlags.Interface */)) { + if (intersectionMember.symbol === target) { + return true; + } + if (typeHasProtectedAccessibleBase(target, intersectionMember)) { + return true; + } + } + } + i++; + } + return false; + } + if (firstBase.symbol === target) { + return true; + } + return typeHasProtectedAccessibleBase(target, firstBase); + } + function isConstructorAccessible(node, signature) { + if (!signature || !signature.declaration) { + return true; + } + var declaration = signature.declaration; + var modifiers = ts.getSelectedEffectiveModifierFlags(declaration, 24 /* ModifierFlags.NonPublicAccessibilityModifier */); + // (1) Public constructors and (2) constructor functions are always accessible. + if (!modifiers || declaration.kind !== 173 /* SyntaxKind.Constructor */) { + return true; + } + var declaringClassDeclaration = ts.getClassLikeDeclarationOfSymbol(declaration.parent.symbol); + var declaringClass = getDeclaredTypeOfSymbol(declaration.parent.symbol); + // A private or protected constructor can only be instantiated within its own class (or a subclass, for protected) + if (!isNodeWithinClass(node, declaringClassDeclaration)) { + var containingClass = ts.getContainingClass(node); + if (containingClass && modifiers & 16 /* ModifierFlags.Protected */) { + var containingType = getTypeOfNode(containingClass); + if (typeHasProtectedAccessibleBase(declaration.parent.symbol, containingType)) { + return true; + } + } + if (modifiers & 8 /* ModifierFlags.Private */) { + error(node, ts.Diagnostics.Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration, typeToString(declaringClass)); + } + if (modifiers & 16 /* ModifierFlags.Protected */) { + error(node, ts.Diagnostics.Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration, typeToString(declaringClass)); + } + return false; + } + return true; + } + function invocationErrorDetails(errorTarget, apparentType, kind) { + var errorInfo; + var isCall = kind === 0 /* SignatureKind.Call */; + var awaitedType = getAwaitedType(apparentType); + var maybeMissingAwait = awaitedType && getSignaturesOfType(awaitedType, kind).length > 0; + if (apparentType.flags & 1048576 /* TypeFlags.Union */) { + var types = apparentType.types; + var hasSignatures = false; + for (var _i = 0, types_19 = types; _i < types_19.length; _i++) { + var constituent = types_19[_i]; + var signatures = getSignaturesOfType(constituent, kind); + if (signatures.length !== 0) { + hasSignatures = true; + if (errorInfo) { + // Bail early if we already have an error, no chance of "No constituent of type is callable" + break; + } + } + else { + // Error on the first non callable constituent only + if (!errorInfo) { + errorInfo = ts.chainDiagnosticMessages(errorInfo, isCall ? + ts.Diagnostics.Type_0_has_no_call_signatures : + ts.Diagnostics.Type_0_has_no_construct_signatures, typeToString(constituent)); + errorInfo = ts.chainDiagnosticMessages(errorInfo, isCall ? + ts.Diagnostics.Not_all_constituents_of_type_0_are_callable : + ts.Diagnostics.Not_all_constituents_of_type_0_are_constructable, typeToString(apparentType)); + } + if (hasSignatures) { + // Bail early if we already found a siganture, no chance of "No constituent of type is callable" + break; + } + } + } + if (!hasSignatures) { + errorInfo = ts.chainDiagnosticMessages( + /* detials */ undefined, isCall ? + ts.Diagnostics.No_constituent_of_type_0_is_callable : + ts.Diagnostics.No_constituent_of_type_0_is_constructable, typeToString(apparentType)); + } + if (!errorInfo) { + errorInfo = ts.chainDiagnosticMessages(errorInfo, isCall ? + ts.Diagnostics.Each_member_of_the_union_type_0_has_signatures_but_none_of_those_signatures_are_compatible_with_each_other : + ts.Diagnostics.Each_member_of_the_union_type_0_has_construct_signatures_but_none_of_those_signatures_are_compatible_with_each_other, typeToString(apparentType)); + } + } + else { + errorInfo = ts.chainDiagnosticMessages(errorInfo, isCall ? + ts.Diagnostics.Type_0_has_no_call_signatures : + ts.Diagnostics.Type_0_has_no_construct_signatures, typeToString(apparentType)); + } + var headMessage = isCall ? ts.Diagnostics.This_expression_is_not_callable : ts.Diagnostics.This_expression_is_not_constructable; + // Diagnose get accessors incorrectly called as functions + if (ts.isCallExpression(errorTarget.parent) && errorTarget.parent.arguments.length === 0) { + var resolvedSymbol = getNodeLinks(errorTarget).resolvedSymbol; + if (resolvedSymbol && resolvedSymbol.flags & 32768 /* SymbolFlags.GetAccessor */) { + headMessage = ts.Diagnostics.This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without; + } + } + return { + messageChain: ts.chainDiagnosticMessages(errorInfo, headMessage), + relatedMessage: maybeMissingAwait ? ts.Diagnostics.Did_you_forget_to_use_await : undefined, + }; + } + function invocationError(errorTarget, apparentType, kind, relatedInformation) { + var _a = invocationErrorDetails(errorTarget, apparentType, kind), messageChain = _a.messageChain, relatedInfo = _a.relatedMessage; + var diagnostic = ts.createDiagnosticForNodeFromMessageChain(errorTarget, messageChain); + if (relatedInfo) { + ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(errorTarget, relatedInfo)); + } + if (ts.isCallExpression(errorTarget.parent)) { + var _b = getDiagnosticSpanForCallNode(errorTarget.parent, /* doNotIncludeArguments */ true), start = _b.start, length_8 = _b.length; + diagnostic.start = start; + diagnostic.length = length_8; + } + diagnostics.add(diagnostic); + invocationErrorRecovery(apparentType, kind, relatedInformation ? ts.addRelatedInfo(diagnostic, relatedInformation) : diagnostic); + } + function invocationErrorRecovery(apparentType, kind, diagnostic) { + if (!apparentType.symbol) { + return; + } + var importNode = getSymbolLinks(apparentType.symbol).originatingImport; + // Create a diagnostic on the originating import if possible onto which we can attach a quickfix + // An import call expression cannot be rewritten into another form to correct the error - the only solution is to use `.default` at the use-site + if (importNode && !ts.isImportCall(importNode)) { + var sigs = getSignaturesOfType(getTypeOfSymbol(getSymbolLinks(apparentType.symbol).target), kind); + if (!sigs || !sigs.length) + return; + ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(importNode, ts.Diagnostics.Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cause_a_failure_at_runtime_Consider_using_a_default_import_or_import_require_here_instead)); + } + } + function resolveTaggedTemplateExpression(node, candidatesOutArray, checkMode) { + var tagType = checkExpression(node.tag); + var apparentType = getApparentType(tagType); + if (isErrorType(apparentType)) { + // Another error has already been reported + return resolveErrorCall(node); + } + var callSignatures = getSignaturesOfType(apparentType, 0 /* SignatureKind.Call */); + var numConstructSignatures = getSignaturesOfType(apparentType, 1 /* SignatureKind.Construct */).length; + if (isUntypedFunctionCall(tagType, apparentType, callSignatures.length, numConstructSignatures)) { + return resolveUntypedCall(node); + } + if (!callSignatures.length) { + if (ts.isArrayLiteralExpression(node.parent)) { + var diagnostic = ts.createDiagnosticForNode(node.tag, ts.Diagnostics.It_is_likely_that_you_are_missing_a_comma_to_separate_these_two_template_expressions_They_form_a_tagged_template_expression_which_cannot_be_invoked); + diagnostics.add(diagnostic); + return resolveErrorCall(node); + } + invocationError(node.tag, apparentType, 0 /* SignatureKind.Call */); + return resolveErrorCall(node); + } + return resolveCall(node, callSignatures, candidatesOutArray, checkMode, 0 /* SignatureFlags.None */); + } + /** + * Gets the localized diagnostic head message to use for errors when resolving a decorator as a call expression. + */ + function getDiagnosticHeadMessageForDecoratorResolution(node) { + switch (node.parent.kind) { + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + return ts.Diagnostics.Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression; + case 166 /* SyntaxKind.Parameter */: + return ts.Diagnostics.Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression; + case 169 /* SyntaxKind.PropertyDeclaration */: + return ts.Diagnostics.Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression; + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + return ts.Diagnostics.Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression; + default: + return ts.Debug.fail(); + } + } + /** + * Resolves a decorator as if it were a call expression. + */ + function resolveDecorator(node, candidatesOutArray, checkMode) { + var funcType = checkExpression(node.expression); + var apparentType = getApparentType(funcType); + if (isErrorType(apparentType)) { + return resolveErrorCall(node); + } + var callSignatures = getSignaturesOfType(apparentType, 0 /* SignatureKind.Call */); + var numConstructSignatures = getSignaturesOfType(apparentType, 1 /* SignatureKind.Construct */).length; + if (isUntypedFunctionCall(funcType, apparentType, callSignatures.length, numConstructSignatures)) { + return resolveUntypedCall(node); + } + if (isPotentiallyUncalledDecorator(node, callSignatures)) { + var nodeStr = ts.getTextOfNode(node.expression, /*includeTrivia*/ false); + error(node, ts.Diagnostics._0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write_0, nodeStr); + return resolveErrorCall(node); + } + var headMessage = getDiagnosticHeadMessageForDecoratorResolution(node); + if (!callSignatures.length) { + var errorDetails = invocationErrorDetails(node.expression, apparentType, 0 /* SignatureKind.Call */); + var messageChain = ts.chainDiagnosticMessages(errorDetails.messageChain, headMessage); + var diag = ts.createDiagnosticForNodeFromMessageChain(node.expression, messageChain); + if (errorDetails.relatedMessage) { + ts.addRelatedInfo(diag, ts.createDiagnosticForNode(node.expression, errorDetails.relatedMessage)); + } + diagnostics.add(diag); + invocationErrorRecovery(apparentType, 0 /* SignatureKind.Call */, diag); + return resolveErrorCall(node); + } + return resolveCall(node, callSignatures, candidatesOutArray, checkMode, 0 /* SignatureFlags.None */, headMessage); + } + function createSignatureForJSXIntrinsic(node, result) { + var namespace = getJsxNamespaceAt(node); + var exports = namespace && getExportsOfSymbol(namespace); + // We fake up a SFC signature for each intrinsic, however a more specific per-element signature drawn from the JSX declaration + // file would probably be preferable. + var typeSymbol = exports && getSymbol(exports, JsxNames.Element, 788968 /* SymbolFlags.Type */); + var returnNode = typeSymbol && nodeBuilder.symbolToEntityName(typeSymbol, 788968 /* SymbolFlags.Type */, node); + var declaration = ts.factory.createFunctionTypeNode(/*typeParameters*/ undefined, [ts.factory.createParameterDeclaration(/*modifiers*/ undefined, /*dotdotdot*/ undefined, "props", /*questionMark*/ undefined, nodeBuilder.typeToTypeNode(result, node))], returnNode ? ts.factory.createTypeReferenceNode(returnNode, /*typeArguments*/ undefined) : ts.factory.createKeywordTypeNode(131 /* SyntaxKind.AnyKeyword */)); + var parameterSymbol = createSymbol(1 /* SymbolFlags.FunctionScopedVariable */, "props"); + parameterSymbol.type = result; + return createSignature(declaration, + /*typeParameters*/ undefined, + /*thisParameter*/ undefined, [parameterSymbol], typeSymbol ? getDeclaredTypeOfSymbol(typeSymbol) : errorType, + /*returnTypePredicate*/ undefined, 1, 0 /* SignatureFlags.None */); + } + function resolveJsxOpeningLikeElement(node, candidatesOutArray, checkMode) { + if (isJsxIntrinsicIdentifier(node.tagName)) { + var result = getIntrinsicAttributesTypeFromJsxOpeningLikeElement(node); + var fakeSignature = createSignatureForJSXIntrinsic(node, result); + checkTypeAssignableToAndOptionallyElaborate(checkExpressionWithContextualType(node.attributes, getEffectiveFirstArgumentForJsxSignature(fakeSignature, node), /*mapper*/ undefined, 0 /* CheckMode.Normal */), result, node.tagName, node.attributes); + if (ts.length(node.typeArguments)) { + ts.forEach(node.typeArguments, checkSourceElement); + diagnostics.add(ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), node.typeArguments, ts.Diagnostics.Expected_0_type_arguments_but_got_1, 0, ts.length(node.typeArguments))); + } + return fakeSignature; + } + var exprTypes = checkExpression(node.tagName); + var apparentType = getApparentType(exprTypes); + if (isErrorType(apparentType)) { + return resolveErrorCall(node); + } + var signatures = getUninstantiatedJsxSignaturesOfType(exprTypes, node); + if (isUntypedFunctionCall(exprTypes, apparentType, signatures.length, /*constructSignatures*/ 0)) { + return resolveUntypedCall(node); + } + if (signatures.length === 0) { + // We found no signatures at all, which is an error + error(node.tagName, ts.Diagnostics.JSX_element_type_0_does_not_have_any_construct_or_call_signatures, ts.getTextOfNode(node.tagName)); + return resolveErrorCall(node); + } + return resolveCall(node, signatures, candidatesOutArray, checkMode, 0 /* SignatureFlags.None */); + } + /** + * Sometimes, we have a decorator that could accept zero arguments, + * but is receiving too many arguments as part of the decorator invocation. + * In those cases, a user may have meant to *call* the expression before using it as a decorator. + */ + function isPotentiallyUncalledDecorator(decorator, signatures) { + return signatures.length && ts.every(signatures, function (signature) { + return signature.minArgumentCount === 0 && + !signatureHasRestParameter(signature) && + signature.parameters.length < getDecoratorArgumentCount(decorator, signature); + }); + } + function resolveSignature(node, candidatesOutArray, checkMode) { + switch (node.kind) { + case 210 /* SyntaxKind.CallExpression */: + return resolveCallExpression(node, candidatesOutArray, checkMode); + case 211 /* SyntaxKind.NewExpression */: + return resolveNewExpression(node, candidatesOutArray, checkMode); + case 212 /* SyntaxKind.TaggedTemplateExpression */: + return resolveTaggedTemplateExpression(node, candidatesOutArray, checkMode); + case 167 /* SyntaxKind.Decorator */: + return resolveDecorator(node, candidatesOutArray, checkMode); + case 283 /* SyntaxKind.JsxOpeningElement */: + case 282 /* SyntaxKind.JsxSelfClosingElement */: + return resolveJsxOpeningLikeElement(node, candidatesOutArray, checkMode); + } + throw ts.Debug.assertNever(node, "Branch in 'resolveSignature' should be unreachable."); + } + /** + * Resolve a signature of a given call-like expression. + * @param node a call-like expression to try resolve a signature for + * @param candidatesOutArray an array of signature to be filled in by the function. It is passed by signature help in the language service; + * the function will fill it up with appropriate candidate signatures + * @return a signature of the call-like expression or undefined if one can't be found + */ + function getResolvedSignature(node, candidatesOutArray, checkMode) { + var links = getNodeLinks(node); + // If getResolvedSignature has already been called, we will have cached the resolvedSignature. + // However, it is possible that either candidatesOutArray was not passed in the first time, + // or that a different candidatesOutArray was passed in. Therefore, we need to redo the work + // to correctly fill the candidatesOutArray. + var cached = links.resolvedSignature; + if (cached && cached !== resolvingSignature && !candidatesOutArray) { + return cached; + } + links.resolvedSignature = resolvingSignature; + var result = resolveSignature(node, candidatesOutArray, checkMode || 0 /* CheckMode.Normal */); + // When CheckMode.SkipGenericFunctions is set we use resolvingSignature to indicate that call + // resolution should be deferred. + if (result !== resolvingSignature) { + // If signature resolution originated in control flow type analysis (for example to compute the + // assigned type in a flow assignment) we don't cache the result as it may be based on temporary + // types from the control flow analysis. + links.resolvedSignature = flowLoopStart === flowLoopCount ? result : cached; + } + return result; + } + /** + * Indicates whether a declaration can be treated as a constructor in a JavaScript + * file. + */ + function isJSConstructor(node) { + var _a; + if (!node || !ts.isInJSFile(node)) { + return false; + } + var func = ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) ? node : + (ts.isVariableDeclaration(node) || ts.isPropertyAssignment(node)) && node.initializer && ts.isFunctionExpression(node.initializer) ? node.initializer : + undefined; + if (func) { + // If the node has a @class or @constructor tag, treat it like a constructor. + if (ts.getJSDocClassTag(node)) + return true; + // If the node is a property of an object literal. + if (ts.isPropertyAssignment(ts.walkUpParenthesizedExpressions(func.parent))) + return false; + // If the symbol of the node has members, treat it like a constructor. + var symbol = getSymbolOfNode(func); + return !!((_a = symbol === null || symbol === void 0 ? void 0 : symbol.members) === null || _a === void 0 ? void 0 : _a.size); + } + return false; + } + function mergeJSSymbols(target, source) { + var _a, _b; + if (source) { + var links = getSymbolLinks(source); + if (!links.inferredClassSymbol || !links.inferredClassSymbol.has(getSymbolId(target))) { + var inferred = ts.isTransientSymbol(target) ? target : cloneSymbol(target); + inferred.exports = inferred.exports || ts.createSymbolTable(); + inferred.members = inferred.members || ts.createSymbolTable(); + inferred.flags |= source.flags & 32 /* SymbolFlags.Class */; + if ((_a = source.exports) === null || _a === void 0 ? void 0 : _a.size) { + mergeSymbolTable(inferred.exports, source.exports); + } + if ((_b = source.members) === null || _b === void 0 ? void 0 : _b.size) { + mergeSymbolTable(inferred.members, source.members); + } + (links.inferredClassSymbol || (links.inferredClassSymbol = new ts.Map())).set(getSymbolId(inferred), inferred); + return inferred; + } + return links.inferredClassSymbol.get(getSymbolId(target)); + } + } + function getAssignedClassSymbol(decl) { + var _a; + var assignmentSymbol = decl && getSymbolOfExpando(decl, /*allowDeclaration*/ true); + var prototype = (_a = assignmentSymbol === null || assignmentSymbol === void 0 ? void 0 : assignmentSymbol.exports) === null || _a === void 0 ? void 0 : _a.get("prototype"); + var init = (prototype === null || prototype === void 0 ? void 0 : prototype.valueDeclaration) && getAssignedJSPrototype(prototype.valueDeclaration); + return init ? getSymbolOfNode(init) : undefined; + } + function getSymbolOfExpando(node, allowDeclaration) { + if (!node.parent) { + return undefined; + } + var name; + var decl; + if (ts.isVariableDeclaration(node.parent) && node.parent.initializer === node) { + if (!ts.isInJSFile(node) && !(ts.isVarConst(node.parent) && ts.isFunctionLikeDeclaration(node))) { + return undefined; + } + name = node.parent.name; + decl = node.parent; + } + else if (ts.isBinaryExpression(node.parent)) { + var parentNode = node.parent; + var parentNodeOperator = node.parent.operatorToken.kind; + if (parentNodeOperator === 63 /* SyntaxKind.EqualsToken */ && (allowDeclaration || parentNode.right === node)) { + name = parentNode.left; + decl = name; + } + else if (parentNodeOperator === 56 /* SyntaxKind.BarBarToken */ || parentNodeOperator === 60 /* SyntaxKind.QuestionQuestionToken */) { + if (ts.isVariableDeclaration(parentNode.parent) && parentNode.parent.initializer === parentNode) { + name = parentNode.parent.name; + decl = parentNode.parent; + } + else if (ts.isBinaryExpression(parentNode.parent) && parentNode.parent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ && (allowDeclaration || parentNode.parent.right === parentNode)) { + name = parentNode.parent.left; + decl = name; + } + if (!name || !ts.isBindableStaticNameExpression(name) || !ts.isSameEntityName(name, parentNode.left)) { + return undefined; + } + } + } + else if (allowDeclaration && ts.isFunctionDeclaration(node)) { + name = node.name; + decl = node; + } + if (!decl || !name || (!allowDeclaration && !ts.getExpandoInitializer(node, ts.isPrototypeAccess(name)))) { + return undefined; + } + return getSymbolOfNode(decl); + } + function getAssignedJSPrototype(node) { + if (!node.parent) { + return false; + } + var parent = node.parent; + while (parent && parent.kind === 208 /* SyntaxKind.PropertyAccessExpression */) { + parent = parent.parent; + } + if (parent && ts.isBinaryExpression(parent) && ts.isPrototypeAccess(parent.left) && parent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */) { + var right = ts.getInitializerOfBinaryExpression(parent); + return ts.isObjectLiteralExpression(right) && right; + } + } + /** + * Syntactically and semantically checks a call or new expression. + * @param node The call/new expression to be checked. + * @returns On success, the expression's signature's return type. On failure, anyType. + */ + function checkCallExpression(node, checkMode) { + var _a; + checkGrammarTypeArguments(node, node.typeArguments); + var signature = getResolvedSignature(node, /*candidatesOutArray*/ undefined, checkMode); + if (signature === resolvingSignature) { + // CheckMode.SkipGenericFunctions is enabled and this is a call to a generic function that + // returns a function type. We defer checking and return silentNeverType. + return silentNeverType; + } + checkDeprecatedSignature(signature, node); + if (node.expression.kind === 106 /* SyntaxKind.SuperKeyword */) { + return voidType; + } + if (node.kind === 211 /* SyntaxKind.NewExpression */) { + var declaration = signature.declaration; + if (declaration && + declaration.kind !== 173 /* SyntaxKind.Constructor */ && + declaration.kind !== 177 /* SyntaxKind.ConstructSignature */ && + declaration.kind !== 182 /* SyntaxKind.ConstructorType */ && + !ts.isJSDocConstructSignature(declaration) && + !isJSConstructor(declaration)) { + // When resolved signature is a call signature (and not a construct signature) the result type is any + if (noImplicitAny) { + error(node, ts.Diagnostics.new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type); + } + return anyType; + } + } + // In JavaScript files, calls to any identifier 'require' are treated as external module imports + if (ts.isInJSFile(node) && isCommonJsRequire(node)) { + return resolveExternalModuleTypeByLiteral(node.arguments[0]); + } + var returnType = getReturnTypeOfSignature(signature); + // Treat any call to the global 'Symbol' function that is part of a const variable or readonly property + // as a fresh unique symbol literal type. + if (returnType.flags & 12288 /* TypeFlags.ESSymbolLike */ && isSymbolOrSymbolForCall(node)) { + return getESSymbolLikeTypeForNode(ts.walkUpParenthesizedExpressions(node.parent)); + } + if (node.kind === 210 /* SyntaxKind.CallExpression */ && !node.questionDotToken && node.parent.kind === 241 /* SyntaxKind.ExpressionStatement */ && + returnType.flags & 16384 /* TypeFlags.Void */ && getTypePredicateOfSignature(signature)) { + if (!ts.isDottedName(node.expression)) { + error(node.expression, ts.Diagnostics.Assertions_require_the_call_target_to_be_an_identifier_or_qualified_name); + } + else if (!getEffectsSignature(node)) { + var diagnostic = error(node.expression, ts.Diagnostics.Assertions_require_every_name_in_the_call_target_to_be_declared_with_an_explicit_type_annotation); + getTypeOfDottedName(node.expression, diagnostic); + } + } + if (ts.isInJSFile(node)) { + var jsSymbol = getSymbolOfExpando(node, /*allowDeclaration*/ false); + if ((_a = jsSymbol === null || jsSymbol === void 0 ? void 0 : jsSymbol.exports) === null || _a === void 0 ? void 0 : _a.size) { + var jsAssignmentType = createAnonymousType(jsSymbol, jsSymbol.exports, ts.emptyArray, ts.emptyArray, ts.emptyArray); + jsAssignmentType.objectFlags |= 4096 /* ObjectFlags.JSLiteral */; + return getIntersectionType([returnType, jsAssignmentType]); + } + } + return returnType; + } + function checkDeprecatedSignature(signature, node) { + if (signature.declaration && signature.declaration.flags & 268435456 /* NodeFlags.Deprecated */) { + var suggestionNode = getDeprecatedSuggestionNode(node); + var name = ts.tryGetPropertyAccessOrIdentifierToString(ts.getInvokedExpression(node)); + addDeprecatedSuggestionWithSignature(suggestionNode, signature.declaration, name, signatureToString(signature)); + } + } + function getDeprecatedSuggestionNode(node) { + node = ts.skipParentheses(node); + switch (node.kind) { + case 210 /* SyntaxKind.CallExpression */: + case 167 /* SyntaxKind.Decorator */: + case 211 /* SyntaxKind.NewExpression */: + return getDeprecatedSuggestionNode(node.expression); + case 212 /* SyntaxKind.TaggedTemplateExpression */: + return getDeprecatedSuggestionNode(node.tag); + case 283 /* SyntaxKind.JsxOpeningElement */: + case 282 /* SyntaxKind.JsxSelfClosingElement */: + return getDeprecatedSuggestionNode(node.tagName); + case 209 /* SyntaxKind.ElementAccessExpression */: + return node.argumentExpression; + case 208 /* SyntaxKind.PropertyAccessExpression */: + return node.name; + case 180 /* SyntaxKind.TypeReference */: + var typeReference = node; + return ts.isQualifiedName(typeReference.typeName) ? typeReference.typeName.right : typeReference; + default: + return node; + } + } + function isSymbolOrSymbolForCall(node) { + if (!ts.isCallExpression(node)) + return false; + var left = node.expression; + if (ts.isPropertyAccessExpression(left) && left.name.escapedText === "for") { + left = left.expression; + } + if (!ts.isIdentifier(left) || left.escapedText !== "Symbol") { + return false; + } + // make sure `Symbol` is the global symbol + var globalESSymbol = getGlobalESSymbolConstructorSymbol(/*reportErrors*/ false); + if (!globalESSymbol) { + return false; + } + return globalESSymbol === resolveName(left, "Symbol", 111551 /* SymbolFlags.Value */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false); + } + function checkImportCallExpression(node) { + // Check grammar of dynamic import + checkGrammarImportCallExpression(node); + if (node.arguments.length === 0) { + return createPromiseReturnType(node, anyType); + } + var specifier = node.arguments[0]; + var specifierType = checkExpressionCached(specifier); + var optionsType = node.arguments.length > 1 ? checkExpressionCached(node.arguments[1]) : undefined; + // Even though multiple arguments is grammatically incorrect, type-check extra arguments for completion + for (var i = 2; i < node.arguments.length; ++i) { + checkExpressionCached(node.arguments[i]); + } + if (specifierType.flags & 32768 /* TypeFlags.Undefined */ || specifierType.flags & 65536 /* TypeFlags.Null */ || !isTypeAssignableTo(specifierType, stringType)) { + error(specifier, ts.Diagnostics.Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0, typeToString(specifierType)); + } + if (optionsType) { + var importCallOptionsType = getGlobalImportCallOptionsType(/*reportErrors*/ true); + if (importCallOptionsType !== emptyObjectType) { + checkTypeAssignableTo(optionsType, getNullableType(importCallOptionsType, 32768 /* TypeFlags.Undefined */), node.arguments[1]); + } + } + // resolveExternalModuleName will return undefined if the moduleReferenceExpression is not a string literal + var moduleSymbol = resolveExternalModuleName(node, specifier); + if (moduleSymbol) { + var esModuleSymbol = resolveESModuleSymbol(moduleSymbol, specifier, /*dontRecursivelyResolve*/ true, /*suppressUsageError*/ false); + if (esModuleSymbol) { + return createPromiseReturnType(node, getTypeWithSyntheticDefaultOnly(getTypeOfSymbol(esModuleSymbol), esModuleSymbol, moduleSymbol, specifier) || + getTypeWithSyntheticDefaultImportType(getTypeOfSymbol(esModuleSymbol), esModuleSymbol, moduleSymbol, specifier)); + } + } + return createPromiseReturnType(node, anyType); + } + function createDefaultPropertyWrapperForModule(symbol, originalSymbol, anonymousSymbol) { + var memberTable = ts.createSymbolTable(); + var newSymbol = createSymbol(2097152 /* SymbolFlags.Alias */, "default" /* InternalSymbolName.Default */); + newSymbol.parent = originalSymbol; + newSymbol.nameType = getStringLiteralType("default"); + newSymbol.aliasTarget = resolveSymbol(symbol); + memberTable.set("default" /* InternalSymbolName.Default */, newSymbol); + return createAnonymousType(anonymousSymbol, memberTable, ts.emptyArray, ts.emptyArray, ts.emptyArray); + } + function getTypeWithSyntheticDefaultOnly(type, symbol, originalSymbol, moduleSpecifier) { + var hasDefaultOnly = isOnlyImportedAsDefault(moduleSpecifier); + if (hasDefaultOnly && type && !isErrorType(type)) { + var synthType = type; + if (!synthType.defaultOnlyType) { + var type_4 = createDefaultPropertyWrapperForModule(symbol, originalSymbol); + synthType.defaultOnlyType = type_4; + } + return synthType.defaultOnlyType; + } + return undefined; + } + function getTypeWithSyntheticDefaultImportType(type, symbol, originalSymbol, moduleSpecifier) { + var _a; + if (allowSyntheticDefaultImports && type && !isErrorType(type)) { + var synthType = type; + if (!synthType.syntheticType) { + var file = (_a = originalSymbol.declarations) === null || _a === void 0 ? void 0 : _a.find(ts.isSourceFile); + var hasSyntheticDefault = canHaveSyntheticDefault(file, originalSymbol, /*dontResolveAlias*/ false, moduleSpecifier); + if (hasSyntheticDefault) { + var anonymousSymbol = createSymbol(2048 /* SymbolFlags.TypeLiteral */, "__type" /* InternalSymbolName.Type */); + var defaultContainingObject = createDefaultPropertyWrapperForModule(symbol, originalSymbol, anonymousSymbol); + anonymousSymbol.type = defaultContainingObject; + synthType.syntheticType = isValidSpreadType(type) ? getSpreadType(type, defaultContainingObject, anonymousSymbol, /*objectFlags*/ 0, /*readonly*/ false) : defaultContainingObject; + } + else { + synthType.syntheticType = type; + } + } + return synthType.syntheticType; + } + return type; + } + function isCommonJsRequire(node) { + if (!ts.isRequireCall(node, /*checkArgumentIsStringLiteralLike*/ true)) { + return false; + } + // Make sure require is not a local function + if (!ts.isIdentifier(node.expression)) + return ts.Debug.fail(); + var resolvedRequire = resolveName(node.expression, node.expression.escapedText, 111551 /* SymbolFlags.Value */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ true); // TODO: GH#18217 + if (resolvedRequire === requireSymbol) { + return true; + } + // project includes symbol named 'require' - make sure that it is ambient and local non-alias + if (resolvedRequire.flags & 2097152 /* SymbolFlags.Alias */) { + return false; + } + var targetDeclarationKind = resolvedRequire.flags & 16 /* SymbolFlags.Function */ + ? 259 /* SyntaxKind.FunctionDeclaration */ + : resolvedRequire.flags & 3 /* SymbolFlags.Variable */ + ? 257 /* SyntaxKind.VariableDeclaration */ + : 0 /* SyntaxKind.Unknown */; + if (targetDeclarationKind !== 0 /* SyntaxKind.Unknown */) { + var decl = ts.getDeclarationOfKind(resolvedRequire, targetDeclarationKind); + // function/variable declaration should be ambient + return !!decl && !!(decl.flags & 16777216 /* NodeFlags.Ambient */); + } + return false; + } + function checkTaggedTemplateExpression(node) { + if (!checkGrammarTaggedTemplateChain(node)) + checkGrammarTypeArguments(node, node.typeArguments); + if (languageVersion < 2 /* ScriptTarget.ES2015 */) { + checkExternalEmitHelpers(node, 262144 /* ExternalEmitHelpers.MakeTemplateObject */); + } + var signature = getResolvedSignature(node); + checkDeprecatedSignature(signature, node); + return getReturnTypeOfSignature(signature); + } + function checkAssertion(node) { + if (node.kind === 213 /* SyntaxKind.TypeAssertionExpression */) { + var file = ts.getSourceFileOfNode(node); + if (file && ts.fileExtensionIsOneOf(file.fileName, [".cts" /* Extension.Cts */, ".mts" /* Extension.Mts */])) { + grammarErrorOnNode(node, ts.Diagnostics.This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Use_an_as_expression_instead); + } + } + return checkAssertionWorker(node, node.type, node.expression); + } + function isValidConstAssertionArgument(node) { + switch (node.kind) { + case 10 /* SyntaxKind.StringLiteral */: + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + case 8 /* SyntaxKind.NumericLiteral */: + case 9 /* SyntaxKind.BigIntLiteral */: + case 110 /* SyntaxKind.TrueKeyword */: + case 95 /* SyntaxKind.FalseKeyword */: + case 206 /* SyntaxKind.ArrayLiteralExpression */: + case 207 /* SyntaxKind.ObjectLiteralExpression */: + case 225 /* SyntaxKind.TemplateExpression */: + return true; + case 214 /* SyntaxKind.ParenthesizedExpression */: + return isValidConstAssertionArgument(node.expression); + case 221 /* SyntaxKind.PrefixUnaryExpression */: + var op = node.operator; + var arg = node.operand; + return op === 40 /* SyntaxKind.MinusToken */ && (arg.kind === 8 /* SyntaxKind.NumericLiteral */ || arg.kind === 9 /* SyntaxKind.BigIntLiteral */) || + op === 39 /* SyntaxKind.PlusToken */ && arg.kind === 8 /* SyntaxKind.NumericLiteral */; + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 209 /* SyntaxKind.ElementAccessExpression */: + var expr = node.expression; + var symbol = getTypeOfNode(expr).symbol; + if (symbol && symbol.flags & 2097152 /* SymbolFlags.Alias */) { + symbol = resolveAlias(symbol); + } + return !!(symbol && (getAllSymbolFlags(symbol) & 384 /* SymbolFlags.Enum */) && getEnumKind(symbol) === 1 /* EnumKind.Literal */); + } + return false; + } + function checkAssertionWorker(errNode, type, expression, checkMode) { + var exprType = checkExpression(expression, checkMode); + if (ts.isConstTypeReference(type)) { + if (!isValidConstAssertionArgument(expression)) { + error(expression, ts.Diagnostics.A_const_assertions_can_only_be_applied_to_references_to_enum_members_or_string_number_boolean_array_or_object_literals); + } + return getRegularTypeOfLiteralType(exprType); + } + checkSourceElement(type); + exprType = getRegularTypeOfObjectLiteral(getBaseTypeOfLiteralType(exprType)); + var targetType = getTypeFromTypeNode(type); + if (!isErrorType(targetType)) { + addLazyDiagnostic(function () { + var widenedType = getWidenedType(exprType); + if (!isTypeComparableTo(targetType, widenedType)) { + checkTypeComparableTo(exprType, targetType, errNode, ts.Diagnostics.Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first); + } + }); + } + return targetType; + } + function checkNonNullChain(node) { + var leftType = checkExpression(node.expression); + var nonOptionalType = getOptionalExpressionType(leftType, node.expression); + return propagateOptionalTypeMarker(getNonNullableType(nonOptionalType), node, nonOptionalType !== leftType); + } + function checkNonNullAssertion(node) { + return node.flags & 32 /* NodeFlags.OptionalChain */ ? checkNonNullChain(node) : + getNonNullableType(checkExpression(node.expression)); + } + function checkExpressionWithTypeArguments(node) { + checkGrammarExpressionWithTypeArguments(node); + var exprType = node.kind === 230 /* SyntaxKind.ExpressionWithTypeArguments */ ? checkExpression(node.expression) : + ts.isThisIdentifier(node.exprName) ? checkThisExpression(node.exprName) : + checkExpression(node.exprName); + var typeArguments = node.typeArguments; + if (exprType === silentNeverType || isErrorType(exprType) || !ts.some(typeArguments)) { + return exprType; + } + var hasSomeApplicableSignature = false; + var nonApplicableType; + var result = getInstantiatedType(exprType); + var errorType = hasSomeApplicableSignature ? nonApplicableType : exprType; + if (errorType) { + diagnostics.add(ts.createDiagnosticForNodeArray(ts.getSourceFileOfNode(node), typeArguments, ts.Diagnostics.Type_0_has_no_signatures_for_which_the_type_argument_list_is_applicable, typeToString(errorType))); + } + return result; + function getInstantiatedType(type) { + var hasSignatures = false; + var hasApplicableSignature = false; + var result = getInstantiatedTypePart(type); + hasSomeApplicableSignature || (hasSomeApplicableSignature = hasApplicableSignature); + if (hasSignatures && !hasApplicableSignature) { + nonApplicableType !== null && nonApplicableType !== void 0 ? nonApplicableType : (nonApplicableType = type); + } + return result; + function getInstantiatedTypePart(type) { + if (type.flags & 524288 /* TypeFlags.Object */) { + var resolved = resolveStructuredTypeMembers(type); + var callSignatures = getInstantiatedSignatures(resolved.callSignatures); + var constructSignatures = getInstantiatedSignatures(resolved.constructSignatures); + hasSignatures || (hasSignatures = resolved.callSignatures.length !== 0 || resolved.constructSignatures.length !== 0); + hasApplicableSignature || (hasApplicableSignature = callSignatures.length !== 0 || constructSignatures.length !== 0); + if (callSignatures !== resolved.callSignatures || constructSignatures !== resolved.constructSignatures) { + var result_11 = createAnonymousType(undefined, resolved.members, callSignatures, constructSignatures, resolved.indexInfos); + result_11.objectFlags |= 8388608 /* ObjectFlags.InstantiationExpressionType */; + result_11.node = node; + return result_11; + } + } + else if (type.flags & 58982400 /* TypeFlags.InstantiableNonPrimitive */) { + var constraint = getBaseConstraintOfType(type); + if (constraint) { + var instantiated = getInstantiatedTypePart(constraint); + if (instantiated !== constraint) { + return instantiated; + } + } + } + else if (type.flags & 1048576 /* TypeFlags.Union */) { + return mapType(type, getInstantiatedType); + } + else if (type.flags & 2097152 /* TypeFlags.Intersection */) { + return getIntersectionType(ts.sameMap(type.types, getInstantiatedTypePart)); + } + return type; + } + } + function getInstantiatedSignatures(signatures) { + var applicableSignatures = ts.filter(signatures, function (sig) { return !!sig.typeParameters && hasCorrectTypeArgumentArity(sig, typeArguments); }); + return ts.sameMap(applicableSignatures, function (sig) { + var typeArgumentTypes = checkTypeArguments(sig, typeArguments, /*reportErrors*/ true); + return typeArgumentTypes ? getSignatureInstantiation(sig, typeArgumentTypes, ts.isInJSFile(sig.declaration)) : sig; + }); + } + } + function checkSatisfiesExpression(node) { + checkSourceElement(node.type); + var targetType = getTypeFromTypeNode(node.type); + if (isErrorType(targetType)) { + return targetType; + } + var exprType = checkExpression(node.expression); + checkTypeAssignableToAndOptionallyElaborate(exprType, targetType, node.type, node.expression, ts.Diagnostics.Type_0_does_not_satisfy_the_expected_type_1); + return exprType; + } + function checkMetaProperty(node) { + checkGrammarMetaProperty(node); + if (node.keywordToken === 103 /* SyntaxKind.NewKeyword */) { + return checkNewTargetMetaProperty(node); + } + if (node.keywordToken === 100 /* SyntaxKind.ImportKeyword */) { + return checkImportMetaProperty(node); + } + return ts.Debug.assertNever(node.keywordToken); + } + function checkMetaPropertyKeyword(node) { + switch (node.keywordToken) { + case 100 /* SyntaxKind.ImportKeyword */: + return getGlobalImportMetaExpressionType(); + case 103 /* SyntaxKind.NewKeyword */: + var type = checkNewTargetMetaProperty(node); + return isErrorType(type) ? errorType : createNewTargetExpressionType(type); + default: + ts.Debug.assertNever(node.keywordToken); + } + } + function checkNewTargetMetaProperty(node) { + var container = ts.getNewTargetContainer(node); + if (!container) { + error(node, ts.Diagnostics.Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constructor, "new.target"); + return errorType; + } + else if (container.kind === 173 /* SyntaxKind.Constructor */) { + var symbol = getSymbolOfNode(container.parent); + return getTypeOfSymbol(symbol); + } + else { + var symbol = getSymbolOfNode(container); + return getTypeOfSymbol(symbol); + } + } + function checkImportMetaProperty(node) { + if (moduleKind === ts.ModuleKind.Node16 || moduleKind === ts.ModuleKind.NodeNext) { + if (ts.getSourceFileOfNode(node).impliedNodeFormat !== ts.ModuleKind.ESNext) { + error(node, ts.Diagnostics.The_import_meta_meta_property_is_not_allowed_in_files_which_will_build_into_CommonJS_output); + } + } + else if (moduleKind < ts.ModuleKind.ES2020 && moduleKind !== ts.ModuleKind.System) { + error(node, ts.Diagnostics.The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_es2020_es2022_esnext_system_node16_or_nodenext); + } + var file = ts.getSourceFileOfNode(node); + ts.Debug.assert(!!(file.flags & 4194304 /* NodeFlags.PossiblyContainsImportMeta */), "Containing file is missing import meta node flag."); + return node.name.escapedText === "meta" ? getGlobalImportMetaType() : errorType; + } + function getTypeOfParameter(symbol) { + var type = getTypeOfSymbol(symbol); + if (strictNullChecks) { + var declaration = symbol.valueDeclaration; + if (declaration && ts.hasInitializer(declaration)) { + return getOptionalType(type); + } + } + return type; + } + function getTupleElementLabel(d) { + ts.Debug.assert(ts.isIdentifier(d.name)); // Parameter declarations could be binding patterns, but we only allow identifier names + return d.name.escapedText; + } + function getParameterNameAtPosition(signature, pos, overrideRestType) { + var paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0); + if (pos < paramCount) { + return signature.parameters[pos].escapedName; + } + var restParameter = signature.parameters[paramCount] || unknownSymbol; + var restType = overrideRestType || getTypeOfSymbol(restParameter); + if (isTupleType(restType)) { + var associatedNames = restType.target.labeledElementDeclarations; + var index = pos - paramCount; + return associatedNames && getTupleElementLabel(associatedNames[index]) || restParameter.escapedName + "_" + index; + } + return restParameter.escapedName; + } + function getParameterIdentifierNameAtPosition(signature, pos) { + var _a; + if (((_a = signature.declaration) === null || _a === void 0 ? void 0 : _a.kind) === 320 /* SyntaxKind.JSDocFunctionType */) { + return undefined; + } + var paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0); + if (pos < paramCount) { + var param = signature.parameters[pos]; + return isParameterDeclarationWithIdentifierName(param) ? [param.escapedName, false] : undefined; + } + var restParameter = signature.parameters[paramCount] || unknownSymbol; + if (!isParameterDeclarationWithIdentifierName(restParameter)) { + return undefined; + } + var restType = getTypeOfSymbol(restParameter); + if (isTupleType(restType)) { + var associatedNames = restType.target.labeledElementDeclarations; + var index = pos - paramCount; + var associatedName = associatedNames === null || associatedNames === void 0 ? void 0 : associatedNames[index]; + var isRestTupleElement = !!(associatedName === null || associatedName === void 0 ? void 0 : associatedName.dotDotDotToken); + return associatedName ? [ + getTupleElementLabel(associatedName), + isRestTupleElement + ] : undefined; + } + if (pos === paramCount) { + return [restParameter.escapedName, true]; + } + return undefined; + } + function isParameterDeclarationWithIdentifierName(symbol) { + return symbol.valueDeclaration && ts.isParameter(symbol.valueDeclaration) && ts.isIdentifier(symbol.valueDeclaration.name); + } + function isValidDeclarationForTupleLabel(d) { + return d.kind === 199 /* SyntaxKind.NamedTupleMember */ || (ts.isParameter(d) && d.name && ts.isIdentifier(d.name)); + } + function getNameableDeclarationAtPosition(signature, pos) { + var paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0); + if (pos < paramCount) { + var decl = signature.parameters[pos].valueDeclaration; + return decl && isValidDeclarationForTupleLabel(decl) ? decl : undefined; + } + var restParameter = signature.parameters[paramCount] || unknownSymbol; + var restType = getTypeOfSymbol(restParameter); + if (isTupleType(restType)) { + var associatedNames = restType.target.labeledElementDeclarations; + var index = pos - paramCount; + return associatedNames && associatedNames[index]; + } + return restParameter.valueDeclaration && isValidDeclarationForTupleLabel(restParameter.valueDeclaration) ? restParameter.valueDeclaration : undefined; + } + function getTypeAtPosition(signature, pos) { + return tryGetTypeAtPosition(signature, pos) || anyType; + } + function tryGetTypeAtPosition(signature, pos) { + var paramCount = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0); + if (pos < paramCount) { + return getTypeOfParameter(signature.parameters[pos]); + } + if (signatureHasRestParameter(signature)) { + // We want to return the value undefined for an out of bounds parameter position, + // so we need to check bounds here before calling getIndexedAccessType (which + // otherwise would return the type 'undefined'). + var restType = getTypeOfSymbol(signature.parameters[paramCount]); + var index = pos - paramCount; + if (!isTupleType(restType) || restType.target.hasRestElement || index < restType.target.fixedLength) { + return getIndexedAccessType(restType, getNumberLiteralType(index)); + } + } + return undefined; + } + function getRestTypeAtPosition(source, pos) { + var parameterCount = getParameterCount(source); + var minArgumentCount = getMinArgumentCount(source); + var restType = getEffectiveRestType(source); + if (restType && pos >= parameterCount - 1) { + return pos === parameterCount - 1 ? restType : createArrayType(getIndexedAccessType(restType, numberType)); + } + var types = []; + var flags = []; + var names = []; + for (var i = pos; i < parameterCount; i++) { + if (!restType || i < parameterCount - 1) { + types.push(getTypeAtPosition(source, i)); + flags.push(i < minArgumentCount ? 1 /* ElementFlags.Required */ : 2 /* ElementFlags.Optional */); + } + else { + types.push(restType); + flags.push(8 /* ElementFlags.Variadic */); + } + var name = getNameableDeclarationAtPosition(source, i); + if (name) { + names.push(name); + } + } + return createTupleType(types, flags, /*readonly*/ false, ts.length(names) === ts.length(types) ? names : undefined); + } + // Return the number of parameters in a signature. The rest parameter, if present, counts as one + // parameter. For example, the parameter count of (x: number, y: number, ...z: string[]) is 3 and + // the parameter count of (x: number, ...args: [number, ...string[], boolean])) is also 3. In the + // latter example, the effective rest type is [...string[], boolean]. + function getParameterCount(signature) { + var length = signature.parameters.length; + if (signatureHasRestParameter(signature)) { + var restType = getTypeOfSymbol(signature.parameters[length - 1]); + if (isTupleType(restType)) { + return length + restType.target.fixedLength - (restType.target.hasRestElement ? 0 : 1); + } + } + return length; + } + function getMinArgumentCount(signature, flags) { + var strongArityForUntypedJS = flags & 1 /* MinArgumentCountFlags.StrongArityForUntypedJS */; + var voidIsNonOptional = flags & 2 /* MinArgumentCountFlags.VoidIsNonOptional */; + if (voidIsNonOptional || signature.resolvedMinArgumentCount === undefined) { + var minArgumentCount = void 0; + if (signatureHasRestParameter(signature)) { + var restType = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]); + if (isTupleType(restType)) { + var firstOptionalIndex = ts.findIndex(restType.target.elementFlags, function (f) { return !(f & 1 /* ElementFlags.Required */); }); + var requiredCount = firstOptionalIndex < 0 ? restType.target.fixedLength : firstOptionalIndex; + if (requiredCount > 0) { + minArgumentCount = signature.parameters.length - 1 + requiredCount; + } + } + } + if (minArgumentCount === undefined) { + if (!strongArityForUntypedJS && signature.flags & 32 /* SignatureFlags.IsUntypedSignatureInJSFile */) { + return 0; + } + minArgumentCount = signature.minArgumentCount; + } + if (voidIsNonOptional) { + return minArgumentCount; + } + for (var i = minArgumentCount - 1; i >= 0; i--) { + var type = getTypeAtPosition(signature, i); + if (filterType(type, acceptsVoid).flags & 131072 /* TypeFlags.Never */) { + break; + } + minArgumentCount = i; + } + signature.resolvedMinArgumentCount = minArgumentCount; + } + return signature.resolvedMinArgumentCount; + } + function hasEffectiveRestParameter(signature) { + if (signatureHasRestParameter(signature)) { + var restType = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]); + return !isTupleType(restType) || restType.target.hasRestElement; + } + return false; + } + function getEffectiveRestType(signature) { + if (signatureHasRestParameter(signature)) { + var restType = getTypeOfSymbol(signature.parameters[signature.parameters.length - 1]); + if (!isTupleType(restType)) { + return restType; + } + if (restType.target.hasRestElement) { + return sliceTupleType(restType, restType.target.fixedLength); + } + } + return undefined; + } + function getNonArrayRestType(signature) { + var restType = getEffectiveRestType(signature); + return restType && !isArrayType(restType) && !isTypeAny(restType) && (getReducedType(restType).flags & 131072 /* TypeFlags.Never */) === 0 ? restType : undefined; + } + function getTypeOfFirstParameterOfSignature(signature) { + return getTypeOfFirstParameterOfSignatureWithFallback(signature, neverType); + } + function getTypeOfFirstParameterOfSignatureWithFallback(signature, fallbackType) { + return signature.parameters.length > 0 ? getTypeAtPosition(signature, 0) : fallbackType; + } + function inferFromAnnotatedParameters(signature, context, inferenceContext) { + var len = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0); + for (var i = 0; i < len; i++) { + var declaration = signature.parameters[i].valueDeclaration; + if (declaration.type) { + var typeNode = ts.getEffectiveTypeAnnotationNode(declaration); + if (typeNode) { + inferTypes(inferenceContext.inferences, getTypeFromTypeNode(typeNode), getTypeAtPosition(context, i)); + } + } + } + } + function assignContextualParameterTypes(signature, context) { + if (context.typeParameters) { + if (!signature.typeParameters) { + signature.typeParameters = context.typeParameters; + } + else { + return; // This signature has already has a contextual inference performed and cached on it! + } + } + if (context.thisParameter) { + var parameter = signature.thisParameter; + if (!parameter || parameter.valueDeclaration && !parameter.valueDeclaration.type) { + if (!parameter) { + signature.thisParameter = createSymbolWithType(context.thisParameter, /*type*/ undefined); + } + assignParameterType(signature.thisParameter, getTypeOfSymbol(context.thisParameter)); + } + } + var len = signature.parameters.length - (signatureHasRestParameter(signature) ? 1 : 0); + for (var i = 0; i < len; i++) { + var parameter = signature.parameters[i]; + if (!ts.getEffectiveTypeAnnotationNode(parameter.valueDeclaration)) { + var contextualParameterType = tryGetTypeAtPosition(context, i); + assignParameterType(parameter, contextualParameterType); + } + } + if (signatureHasRestParameter(signature)) { + // parameter might be a transient symbol generated by use of `arguments` in the function body. + var parameter = ts.last(signature.parameters); + if (parameter.valueDeclaration + ? !ts.getEffectiveTypeAnnotationNode(parameter.valueDeclaration) + // a declarationless parameter may still have a `.type` already set by its construction logic + // (which may pull a type from a jsdoc) - only allow fixing on `DeferredType` parameters with a fallback type + : !!(ts.getCheckFlags(parameter) & 65536 /* CheckFlags.DeferredType */)) { + var contextualParameterType = getRestTypeAtPosition(context, len); + assignParameterType(parameter, contextualParameterType); + } + } + } + function assignNonContextualParameterTypes(signature) { + if (signature.thisParameter) { + assignParameterType(signature.thisParameter); + } + for (var _i = 0, _a = signature.parameters; _i < _a.length; _i++) { + var parameter = _a[_i]; + assignParameterType(parameter); + } + } + function assignParameterType(parameter, type) { + var links = getSymbolLinks(parameter); + if (!links.type) { + var declaration = parameter.valueDeclaration; + links.type = type || (declaration ? getWidenedTypeForVariableLikeDeclaration(declaration, /*reportErrors*/ true) : getTypeOfSymbol(parameter)); + if (declaration && declaration.name.kind !== 79 /* SyntaxKind.Identifier */) { + // if inference didn't come up with anything but unknown, fall back to the binding pattern if present. + if (links.type === unknownType) { + links.type = getTypeFromBindingPattern(declaration.name); + } + assignBindingElementTypes(declaration.name, links.type); + } + } + else if (type) { + ts.Debug.assertEqual(links.type, type, "Parameter symbol already has a cached type which differs from newly assigned type"); + } + } + // When contextual typing assigns a type to a parameter that contains a binding pattern, we also need to push + // the destructured type into the contained binding elements. + function assignBindingElementTypes(pattern, parentType) { + for (var _i = 0, _a = pattern.elements; _i < _a.length; _i++) { + var element = _a[_i]; + if (!ts.isOmittedExpression(element)) { + var type = getBindingElementTypeFromParentType(element, parentType); + if (element.name.kind === 79 /* SyntaxKind.Identifier */) { + getSymbolLinks(getSymbolOfNode(element)).type = type; + } + else { + assignBindingElementTypes(element.name, type); + } + } + } + } + function createPromiseType(promisedType) { + // creates a `Promise` type where `T` is the promisedType argument + var globalPromiseType = getGlobalPromiseType(/*reportErrors*/ true); + if (globalPromiseType !== emptyGenericType) { + // if the promised type is itself a promise, get the underlying type; otherwise, fallback to the promised type + // Unwrap an `Awaited` to `T` to improve inference. + promisedType = getAwaitedTypeNoAlias(unwrapAwaitedType(promisedType)) || unknownType; + return createTypeReference(globalPromiseType, [promisedType]); + } + return unknownType; + } + function createPromiseLikeType(promisedType) { + // creates a `PromiseLike` type where `T` is the promisedType argument + var globalPromiseLikeType = getGlobalPromiseLikeType(/*reportErrors*/ true); + if (globalPromiseLikeType !== emptyGenericType) { + // if the promised type is itself a promise, get the underlying type; otherwise, fallback to the promised type + // Unwrap an `Awaited` to `T` to improve inference. + promisedType = getAwaitedTypeNoAlias(unwrapAwaitedType(promisedType)) || unknownType; + return createTypeReference(globalPromiseLikeType, [promisedType]); + } + return unknownType; + } + function createPromiseReturnType(func, promisedType) { + var promiseType = createPromiseType(promisedType); + if (promiseType === unknownType) { + error(func, ts.isImportCall(func) ? + ts.Diagnostics.A_dynamic_import_call_returns_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option : + ts.Diagnostics.An_async_function_or_method_must_return_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option); + return errorType; + } + else if (!getGlobalPromiseConstructorSymbol(/*reportErrors*/ true)) { + error(func, ts.isImportCall(func) ? + ts.Diagnostics.A_dynamic_import_call_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option : + ts.Diagnostics.An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option); + } + return promiseType; + } + function createNewTargetExpressionType(targetType) { + // Create a synthetic type `NewTargetExpression { target: TargetType; }` + var symbol = createSymbol(0 /* SymbolFlags.None */, "NewTargetExpression"); + var targetPropertySymbol = createSymbol(4 /* SymbolFlags.Property */, "target", 8 /* CheckFlags.Readonly */); + targetPropertySymbol.parent = symbol; + targetPropertySymbol.type = targetType; + var members = ts.createSymbolTable([targetPropertySymbol]); + symbol.members = members; + return createAnonymousType(symbol, members, ts.emptyArray, ts.emptyArray, ts.emptyArray); + } + function getReturnTypeFromBody(func, checkMode) { + if (!func.body) { + return errorType; + } + var functionFlags = ts.getFunctionFlags(func); + var isAsync = (functionFlags & 2 /* FunctionFlags.Async */) !== 0; + var isGenerator = (functionFlags & 1 /* FunctionFlags.Generator */) !== 0; + var returnType; + var yieldType; + var nextType; + var fallbackReturnType = voidType; + if (func.body.kind !== 238 /* SyntaxKind.Block */) { // Async or normal arrow function + returnType = checkExpressionCached(func.body, checkMode && checkMode & ~8 /* CheckMode.SkipGenericFunctions */); + if (isAsync) { + // From within an async function you can return either a non-promise value or a promise. Any + // Promise/A+ compatible implementation will always assimilate any foreign promise, so the + // return type of the body should be unwrapped to its awaited type, which we will wrap in + // the native Promise type later in this function. + returnType = unwrapAwaitedType(checkAwaitedType(returnType, /*withAlias*/ false, /*errorNode*/ func, ts.Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member)); + } + } + else if (isGenerator) { // Generator or AsyncGenerator function + var returnTypes = checkAndAggregateReturnExpressionTypes(func, checkMode); + if (!returnTypes) { + fallbackReturnType = neverType; + } + else if (returnTypes.length > 0) { + returnType = getUnionType(returnTypes, 2 /* UnionReduction.Subtype */); + } + var _a = checkAndAggregateYieldOperandTypes(func, checkMode), yieldTypes = _a.yieldTypes, nextTypes = _a.nextTypes; + yieldType = ts.some(yieldTypes) ? getUnionType(yieldTypes, 2 /* UnionReduction.Subtype */) : undefined; + nextType = ts.some(nextTypes) ? getIntersectionType(nextTypes) : undefined; + } + else { // Async or normal function + var types = checkAndAggregateReturnExpressionTypes(func, checkMode); + if (!types) { + // For an async function, the return type will not be never, but rather a Promise for never. + return functionFlags & 2 /* FunctionFlags.Async */ + ? createPromiseReturnType(func, neverType) // Async function + : neverType; // Normal function + } + if (types.length === 0) { + // For an async function, the return type will not be void, but rather a Promise for void. + return functionFlags & 2 /* FunctionFlags.Async */ + ? createPromiseReturnType(func, voidType) // Async function + : voidType; // Normal function + } + // Return a union of the return expression types. + returnType = getUnionType(types, 2 /* UnionReduction.Subtype */); + } + if (returnType || yieldType || nextType) { + if (yieldType) + reportErrorsFromWidening(func, yieldType, 3 /* WideningKind.GeneratorYield */); + if (returnType) + reportErrorsFromWidening(func, returnType, 1 /* WideningKind.FunctionReturn */); + if (nextType) + reportErrorsFromWidening(func, nextType, 2 /* WideningKind.GeneratorNext */); + if (returnType && isUnitType(returnType) || + yieldType && isUnitType(yieldType) || + nextType && isUnitType(nextType)) { + var contextualSignature = getContextualSignatureForFunctionLikeDeclaration(func); + var contextualType = !contextualSignature ? undefined : + contextualSignature === getSignatureFromDeclaration(func) ? isGenerator ? undefined : returnType : + instantiateContextualType(getReturnTypeOfSignature(contextualSignature), func, /*contextFlags*/ undefined); + if (isGenerator) { + yieldType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(yieldType, contextualType, 0 /* IterationTypeKind.Yield */, isAsync); + returnType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(returnType, contextualType, 1 /* IterationTypeKind.Return */, isAsync); + nextType = getWidenedLiteralLikeTypeForContextualIterationTypeIfNeeded(nextType, contextualType, 2 /* IterationTypeKind.Next */, isAsync); + } + else { + returnType = getWidenedLiteralLikeTypeForContextualReturnTypeIfNeeded(returnType, contextualType, isAsync); + } + } + if (yieldType) + yieldType = getWidenedType(yieldType); + if (returnType) + returnType = getWidenedType(returnType); + if (nextType) + nextType = getWidenedType(nextType); + } + if (isGenerator) { + return createGeneratorReturnType(yieldType || neverType, returnType || fallbackReturnType, nextType || getContextualIterationType(2 /* IterationTypeKind.Next */, func) || unknownType, isAsync); + } + else { + // From within an async function you can return either a non-promise value or a promise. Any + // Promise/A+ compatible implementation will always assimilate any foreign promise, so the + // return type of the body is awaited type of the body, wrapped in a native Promise type. + return isAsync + ? createPromiseType(returnType || fallbackReturnType) + : returnType || fallbackReturnType; + } + } + function createGeneratorReturnType(yieldType, returnType, nextType, isAsyncGenerator) { + var resolver = isAsyncGenerator ? asyncIterationTypesResolver : syncIterationTypesResolver; + var globalGeneratorType = resolver.getGlobalGeneratorType(/*reportErrors*/ false); + yieldType = resolver.resolveIterationType(yieldType, /*errorNode*/ undefined) || unknownType; + returnType = resolver.resolveIterationType(returnType, /*errorNode*/ undefined) || unknownType; + nextType = resolver.resolveIterationType(nextType, /*errorNode*/ undefined) || unknownType; + if (globalGeneratorType === emptyGenericType) { + // Fall back to the global IterableIterator if returnType is assignable to the expected return iteration + // type of IterableIterator, and the expected next iteration type of IterableIterator is assignable to + // nextType. + var globalType = resolver.getGlobalIterableIteratorType(/*reportErrors*/ false); + var iterationTypes = globalType !== emptyGenericType ? getIterationTypesOfGlobalIterableType(globalType, resolver) : undefined; + var iterableIteratorReturnType = iterationTypes ? iterationTypes.returnType : anyType; + var iterableIteratorNextType = iterationTypes ? iterationTypes.nextType : undefinedType; + if (isTypeAssignableTo(returnType, iterableIteratorReturnType) && + isTypeAssignableTo(iterableIteratorNextType, nextType)) { + if (globalType !== emptyGenericType) { + return createTypeFromGenericGlobalType(globalType, [yieldType]); + } + // The global IterableIterator type doesn't exist, so report an error + resolver.getGlobalIterableIteratorType(/*reportErrors*/ true); + return emptyObjectType; + } + // The global Generator type doesn't exist, so report an error + resolver.getGlobalGeneratorType(/*reportErrors*/ true); + return emptyObjectType; + } + return createTypeFromGenericGlobalType(globalGeneratorType, [yieldType, returnType, nextType]); + } + function checkAndAggregateYieldOperandTypes(func, checkMode) { + var yieldTypes = []; + var nextTypes = []; + var isAsync = (ts.getFunctionFlags(func) & 2 /* FunctionFlags.Async */) !== 0; + ts.forEachYieldExpression(func.body, function (yieldExpression) { + var yieldExpressionType = yieldExpression.expression ? checkExpression(yieldExpression.expression, checkMode) : undefinedWideningType; + ts.pushIfUnique(yieldTypes, getYieldedTypeOfYieldExpression(yieldExpression, yieldExpressionType, anyType, isAsync)); + var nextType; + if (yieldExpression.asteriskToken) { + var iterationTypes = getIterationTypesOfIterable(yieldExpressionType, isAsync ? 19 /* IterationUse.AsyncYieldStar */ : 17 /* IterationUse.YieldStar */, yieldExpression.expression); + nextType = iterationTypes && iterationTypes.nextType; + } + else { + nextType = getContextualType(yieldExpression, /*contextFlags*/ undefined); + } + if (nextType) + ts.pushIfUnique(nextTypes, nextType); + }); + return { yieldTypes: yieldTypes, nextTypes: nextTypes }; + } + function getYieldedTypeOfYieldExpression(node, expressionType, sentType, isAsync) { + var errorNode = node.expression || node; + // A `yield*` expression effectively yields everything that its operand yields + var yieldedType = node.asteriskToken ? checkIteratedTypeOrElementType(isAsync ? 19 /* IterationUse.AsyncYieldStar */ : 17 /* IterationUse.YieldStar */, expressionType, sentType, errorNode) : expressionType; + return !isAsync ? yieldedType : getAwaitedType(yieldedType, errorNode, node.asteriskToken + ? ts.Diagnostics.Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member + : ts.Diagnostics.Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member); + } + // Return the combined not-equal type facts for all cases except those between the start and end indices. + function getNotEqualFactsFromTypeofSwitch(start, end, witnesses) { + var facts = 0 /* TypeFacts.None */; + for (var i = 0; i < witnesses.length; i++) { + var witness = i < start || i >= end ? witnesses[i] : undefined; + facts |= witness !== undefined ? typeofNEFacts.get(witness) || 32768 /* TypeFacts.TypeofNEHostObject */ : 0; + } + return facts; + } + function isExhaustiveSwitchStatement(node) { + var links = getNodeLinks(node); + if (links.isExhaustive === undefined) { + links.isExhaustive = 0; // Indicate resolution is in process + var exhaustive = computeExhaustiveSwitchStatement(node); + if (links.isExhaustive === 0) { + links.isExhaustive = exhaustive; + } + } + else if (links.isExhaustive === 0) { + links.isExhaustive = false; // Resolve circularity to false + } + return links.isExhaustive; + } + function computeExhaustiveSwitchStatement(node) { + if (node.expression.kind === 218 /* SyntaxKind.TypeOfExpression */) { + var witnesses = getSwitchClauseTypeOfWitnesses(node); + if (!witnesses) { + return false; + } + var operandConstraint = getBaseConstraintOrType(checkExpressionCached(node.expression.expression)); + // Get the not-equal flags for all handled cases. + var notEqualFacts_2 = getNotEqualFactsFromTypeofSwitch(0, 0, witnesses); + if (operandConstraint.flags & 3 /* TypeFlags.AnyOrUnknown */) { + // We special case the top types to be exhaustive when all cases are handled. + return (556800 /* TypeFacts.AllTypeofNE */ & notEqualFacts_2) === 556800 /* TypeFacts.AllTypeofNE */; + } + // A missing not-equal flag indicates that the type wasn't handled by some case. + return !someType(operandConstraint, function (t) { return (getTypeFacts(t) & notEqualFacts_2) === notEqualFacts_2; }); + } + var type = checkExpressionCached(node.expression); + if (!isLiteralType(type)) { + return false; + } + var switchTypes = getSwitchClauseTypes(node); + if (!switchTypes.length || ts.some(switchTypes, isNeitherUnitTypeNorNever)) { + return false; + } + return eachTypeContainedIn(mapType(type, getRegularTypeOfLiteralType), switchTypes); + } + function functionHasImplicitReturn(func) { + return func.endFlowNode && isReachableFlowNode(func.endFlowNode); + } + /** NOTE: Return value of `[]` means a different thing than `undefined`. `[]` means func returns `void`, `undefined` means it returns `never`. */ + function checkAndAggregateReturnExpressionTypes(func, checkMode) { + var functionFlags = ts.getFunctionFlags(func); + var aggregatedTypes = []; + var hasReturnWithNoExpression = functionHasImplicitReturn(func); + var hasReturnOfTypeNever = false; + ts.forEachReturnStatement(func.body, function (returnStatement) { + var expr = returnStatement.expression; + if (expr) { + var type = checkExpressionCached(expr, checkMode && checkMode & ~8 /* CheckMode.SkipGenericFunctions */); + if (functionFlags & 2 /* FunctionFlags.Async */) { + // From within an async function you can return either a non-promise value or a promise. Any + // Promise/A+ compatible implementation will always assimilate any foreign promise, so the + // return type of the body should be unwrapped to its awaited type, which should be wrapped in + // the native Promise type by the caller. + type = unwrapAwaitedType(checkAwaitedType(type, /*withAlias*/ false, func, ts.Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member)); + } + if (type.flags & 131072 /* TypeFlags.Never */) { + hasReturnOfTypeNever = true; + } + ts.pushIfUnique(aggregatedTypes, type); + } + else { + hasReturnWithNoExpression = true; + } + }); + if (aggregatedTypes.length === 0 && !hasReturnWithNoExpression && (hasReturnOfTypeNever || mayReturnNever(func))) { + return undefined; + } + if (strictNullChecks && aggregatedTypes.length && hasReturnWithNoExpression && + !(isJSConstructor(func) && aggregatedTypes.some(function (t) { return t.symbol === func.symbol; }))) { + // Javascript "callable constructors", containing eg `if (!(this instanceof A)) return new A()` should not add undefined + ts.pushIfUnique(aggregatedTypes, undefinedType); + } + return aggregatedTypes; + } + function mayReturnNever(func) { + switch (func.kind) { + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + return true; + case 171 /* SyntaxKind.MethodDeclaration */: + return func.parent.kind === 207 /* SyntaxKind.ObjectLiteralExpression */; + default: + return false; + } + } + /** + * TypeScript Specification 1.0 (6.3) - July 2014 + * An explicitly typed function whose return type isn't the Void type, + * the Any type, or a union type containing the Void or Any type as a constituent + * must have at least one return statement somewhere in its body. + * An exception to this rule is if the function implementation consists of a single 'throw' statement. + * + * @param returnType - return type of the function, can be undefined if return type is not explicitly specified + */ + function checkAllCodePathsInNonVoidFunctionReturnOrThrow(func, returnType) { + addLazyDiagnostic(checkAllCodePathsInNonVoidFunctionReturnOrThrowDiagnostics); + return; + function checkAllCodePathsInNonVoidFunctionReturnOrThrowDiagnostics() { + var functionFlags = ts.getFunctionFlags(func); + var type = returnType && unwrapReturnType(returnType, functionFlags); + // Functions with with an explicitly specified 'void' or 'any' return type don't need any return expressions. + if (type && maybeTypeOfKind(type, 1 /* TypeFlags.Any */ | 16384 /* TypeFlags.Void */)) { + return; + } + // If all we have is a function signature, or an arrow function with an expression body, then there is nothing to check. + // also if HasImplicitReturn flag is not set this means that all codepaths in function body end with return or throw + if (func.kind === 170 /* SyntaxKind.MethodSignature */ || ts.nodeIsMissing(func.body) || func.body.kind !== 238 /* SyntaxKind.Block */ || !functionHasImplicitReturn(func)) { + return; + } + var hasExplicitReturn = func.flags & 512 /* NodeFlags.HasExplicitReturn */; + var errorNode = ts.getEffectiveReturnTypeNode(func) || func; + if (type && type.flags & 131072 /* TypeFlags.Never */) { + error(errorNode, ts.Diagnostics.A_function_returning_never_cannot_have_a_reachable_end_point); + } + else if (type && !hasExplicitReturn) { + // minimal check: function has syntactic return type annotation and no explicit return statements in the body + // this function does not conform to the specification. + error(errorNode, ts.Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value); + } + else if (type && strictNullChecks && !isTypeAssignableTo(undefinedType, type)) { + error(errorNode, ts.Diagnostics.Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined); + } + else if (compilerOptions.noImplicitReturns) { + if (!type) { + // If return type annotation is omitted check if function has any explicit return statements. + // If it does not have any - its inferred return type is void - don't do any checks. + // Otherwise get inferred return type from function body and report error only if it is not void / anytype + if (!hasExplicitReturn) { + return; + } + var inferredReturnType = getReturnTypeOfSignature(getSignatureFromDeclaration(func)); + if (isUnwrappedReturnTypeVoidOrAny(func, inferredReturnType)) { + return; + } + } + error(errorNode, ts.Diagnostics.Not_all_code_paths_return_a_value); + } + } + } + function checkFunctionExpressionOrObjectLiteralMethod(node, checkMode) { + ts.Debug.assert(node.kind !== 171 /* SyntaxKind.MethodDeclaration */ || ts.isObjectLiteralMethod(node)); + checkNodeDeferred(node); + if (ts.isFunctionExpression(node)) { + checkCollisionsForDeclarationName(node, node.name); + } + // The identityMapper object is used to indicate that function expressions are wildcards + if (checkMode && checkMode & 4 /* CheckMode.SkipContextSensitive */ && isContextSensitive(node)) { + // Skip parameters, return signature with return type that retains noncontextual parts so inferences can still be drawn in an early stage + if (!ts.getEffectiveReturnTypeNode(node) && !ts.hasContextSensitiveParameters(node)) { + // Return plain anyFunctionType if there is no possibility we'll make inferences from the return type + var contextualSignature = getContextualSignature(node); + if (contextualSignature && couldContainTypeVariables(getReturnTypeOfSignature(contextualSignature))) { + var links = getNodeLinks(node); + if (links.contextFreeType) { + return links.contextFreeType; + } + var returnType = getReturnTypeFromBody(node, checkMode); + var returnOnlySignature = createSignature(undefined, undefined, undefined, ts.emptyArray, returnType, /*resolvedTypePredicate*/ undefined, 0, 0 /* SignatureFlags.None */); + var returnOnlyType = createAnonymousType(node.symbol, emptySymbols, [returnOnlySignature], ts.emptyArray, ts.emptyArray); + returnOnlyType.objectFlags |= 262144 /* ObjectFlags.NonInferrableType */; + return links.contextFreeType = returnOnlyType; + } + } + return anyFunctionType; + } + // Grammar checking + var hasGrammarError = checkGrammarFunctionLikeDeclaration(node); + if (!hasGrammarError && node.kind === 215 /* SyntaxKind.FunctionExpression */) { + checkGrammarForGenerator(node); + } + contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node, checkMode); + return getTypeOfSymbol(getSymbolOfNode(node)); + } + function contextuallyCheckFunctionExpressionOrObjectLiteralMethod(node, checkMode) { + var links = getNodeLinks(node); + // Check if function expression is contextually typed and assign parameter types if so. + if (!(links.flags & 1024 /* NodeCheckFlags.ContextChecked */)) { + var contextualSignature = getContextualSignature(node); + // If a type check is started at a function expression that is an argument of a function call, obtaining the + // contextual type may recursively get back to here during overload resolution of the call. If so, we will have + // already assigned contextual types. + if (!(links.flags & 1024 /* NodeCheckFlags.ContextChecked */)) { + links.flags |= 1024 /* NodeCheckFlags.ContextChecked */; + var signature = ts.firstOrUndefined(getSignaturesOfType(getTypeOfSymbol(getSymbolOfNode(node)), 0 /* SignatureKind.Call */)); + if (!signature) { + return; + } + if (isContextSensitive(node)) { + if (contextualSignature) { + var inferenceContext = getInferenceContext(node); + var instantiatedContextualSignature = void 0; + if (checkMode && checkMode & 2 /* CheckMode.Inferential */) { + inferFromAnnotatedParameters(signature, contextualSignature, inferenceContext); + var restType = getEffectiveRestType(contextualSignature); + if (restType && restType.flags & 262144 /* TypeFlags.TypeParameter */) { + instantiatedContextualSignature = instantiateSignature(contextualSignature, inferenceContext.nonFixingMapper); + } + } + instantiatedContextualSignature || (instantiatedContextualSignature = inferenceContext ? + instantiateSignature(contextualSignature, inferenceContext.mapper) : contextualSignature); + assignContextualParameterTypes(signature, instantiatedContextualSignature); + } + else { + // Force resolution of all parameter types such that the absence of a contextual type is consistently reflected. + assignNonContextualParameterTypes(signature); + } + } + if (contextualSignature && !getReturnTypeFromAnnotation(node) && !signature.resolvedReturnType) { + var returnType = getReturnTypeFromBody(node, checkMode); + if (!signature.resolvedReturnType) { + signature.resolvedReturnType = returnType; + } + } + checkSignatureDeclaration(node); + } + } + } + function checkFunctionExpressionOrObjectLiteralMethodDeferred(node) { + ts.Debug.assert(node.kind !== 171 /* SyntaxKind.MethodDeclaration */ || ts.isObjectLiteralMethod(node)); + var functionFlags = ts.getFunctionFlags(node); + var returnType = getReturnTypeFromAnnotation(node); + checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnType); + if (node.body) { + if (!ts.getEffectiveReturnTypeNode(node)) { + // There are some checks that are only performed in getReturnTypeFromBody, that may produce errors + // we need. An example is the noImplicitAny errors resulting from widening the return expression + // of a function. Because checking of function expression bodies is deferred, there was never an + // appropriate time to do this during the main walk of the file (see the comment at the top of + // checkFunctionExpressionBodies). So it must be done now. + getReturnTypeOfSignature(getSignatureFromDeclaration(node)); + } + if (node.body.kind === 238 /* SyntaxKind.Block */) { + checkSourceElement(node.body); + } + else { + // From within an async function you can return either a non-promise value or a promise. Any + // Promise/A+ compatible implementation will always assimilate any foreign promise, so we + // should not be checking assignability of a promise to the return type. Instead, we need to + // check assignability of the awaited type of the expression body against the promised type of + // its return type annotation. + var exprType = checkExpression(node.body); + var returnOrPromisedType = returnType && unwrapReturnType(returnType, functionFlags); + if (returnOrPromisedType) { + if ((functionFlags & 3 /* FunctionFlags.AsyncGenerator */) === 2 /* FunctionFlags.Async */) { // Async function + var awaitedType = checkAwaitedType(exprType, /*withAlias*/ false, node.body, ts.Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member); + checkTypeAssignableToAndOptionallyElaborate(awaitedType, returnOrPromisedType, node.body, node.body); + } + else { // Normal function + checkTypeAssignableToAndOptionallyElaborate(exprType, returnOrPromisedType, node.body, node.body); + } + } + } + } + } + function checkArithmeticOperandType(operand, type, diagnostic, isAwaitValid) { + if (isAwaitValid === void 0) { isAwaitValid = false; } + if (!isTypeAssignableTo(type, numberOrBigIntType)) { + var awaitedType = isAwaitValid && getAwaitedTypeOfPromise(type); + errorAndMaybeSuggestAwait(operand, !!awaitedType && isTypeAssignableTo(awaitedType, numberOrBigIntType), diagnostic); + return false; + } + return true; + } + function isReadonlyAssignmentDeclaration(d) { + if (!ts.isCallExpression(d)) { + return false; + } + if (!ts.isBindableObjectDefinePropertyCall(d)) { + return false; + } + var objectLitType = checkExpressionCached(d.arguments[2]); + var valueType = getTypeOfPropertyOfType(objectLitType, "value"); + if (valueType) { + var writableProp = getPropertyOfType(objectLitType, "writable"); + var writableType = writableProp && getTypeOfSymbol(writableProp); + if (!writableType || writableType === falseType || writableType === regularFalseType) { + return true; + } + // We include this definition whereupon we walk back and check the type at the declaration because + // The usual definition of `Object.defineProperty` will _not_ cause literal types to be preserved in the + // argument types, should the type be contextualized by the call itself. + if (writableProp && writableProp.valueDeclaration && ts.isPropertyAssignment(writableProp.valueDeclaration)) { + var initializer = writableProp.valueDeclaration.initializer; + var rawOriginalType = checkExpression(initializer); + if (rawOriginalType === falseType || rawOriginalType === regularFalseType) { + return true; + } + } + return false; + } + var setProp = getPropertyOfType(objectLitType, "set"); + return !setProp; + } + function isReadonlySymbol(symbol) { + // The following symbols are considered read-only: + // Properties with a 'readonly' modifier + // Variables declared with 'const' + // Get accessors without matching set accessors + // Enum members + // Object.defineProperty assignments with writable false or no setter + // Unions and intersections of the above (unions and intersections eagerly set isReadonly on creation) + return !!(ts.getCheckFlags(symbol) & 8 /* CheckFlags.Readonly */ || + symbol.flags & 4 /* SymbolFlags.Property */ && ts.getDeclarationModifierFlagsFromSymbol(symbol) & 64 /* ModifierFlags.Readonly */ || + symbol.flags & 3 /* SymbolFlags.Variable */ && getDeclarationNodeFlagsFromSymbol(symbol) & 2 /* NodeFlags.Const */ || + symbol.flags & 98304 /* SymbolFlags.Accessor */ && !(symbol.flags & 65536 /* SymbolFlags.SetAccessor */) || + symbol.flags & 8 /* SymbolFlags.EnumMember */ || + ts.some(symbol.declarations, isReadonlyAssignmentDeclaration)); + } + function isAssignmentToReadonlyEntity(expr, symbol, assignmentKind) { + var _a, _b; + if (assignmentKind === 0 /* AssignmentKind.None */) { + // no assigment means it doesn't matter whether the entity is readonly + return false; + } + if (isReadonlySymbol(symbol)) { + // Allow assignments to readonly properties within constructors of the same class declaration. + if (symbol.flags & 4 /* SymbolFlags.Property */ && + ts.isAccessExpression(expr) && + expr.expression.kind === 108 /* SyntaxKind.ThisKeyword */) { + // Look for if this is the constructor for the class that `symbol` is a property of. + var ctor = ts.getContainingFunction(expr); + if (!(ctor && (ctor.kind === 173 /* SyntaxKind.Constructor */ || isJSConstructor(ctor)))) { + return true; + } + if (symbol.valueDeclaration) { + var isAssignmentDeclaration_1 = ts.isBinaryExpression(symbol.valueDeclaration); + var isLocalPropertyDeclaration = ctor.parent === symbol.valueDeclaration.parent; + var isLocalParameterProperty = ctor === symbol.valueDeclaration.parent; + var isLocalThisPropertyAssignment = isAssignmentDeclaration_1 && ((_a = symbol.parent) === null || _a === void 0 ? void 0 : _a.valueDeclaration) === ctor.parent; + var isLocalThisPropertyAssignmentConstructorFunction = isAssignmentDeclaration_1 && ((_b = symbol.parent) === null || _b === void 0 ? void 0 : _b.valueDeclaration) === ctor; + var isWriteableSymbol = isLocalPropertyDeclaration + || isLocalParameterProperty + || isLocalThisPropertyAssignment + || isLocalThisPropertyAssignmentConstructorFunction; + return !isWriteableSymbol; + } + } + return true; + } + if (ts.isAccessExpression(expr)) { + // references through namespace import should be readonly + var node = ts.skipParentheses(expr.expression); + if (node.kind === 79 /* SyntaxKind.Identifier */) { + var symbol_2 = getNodeLinks(node).resolvedSymbol; + if (symbol_2.flags & 2097152 /* SymbolFlags.Alias */) { + var declaration = getDeclarationOfAliasSymbol(symbol_2); + return !!declaration && declaration.kind === 271 /* SyntaxKind.NamespaceImport */; + } + } + } + return false; + } + function checkReferenceExpression(expr, invalidReferenceMessage, invalidOptionalChainMessage) { + // References are combinations of identifiers, parentheses, and property accesses. + var node = ts.skipOuterExpressions(expr, 6 /* OuterExpressionKinds.Assertions */ | 1 /* OuterExpressionKinds.Parentheses */); + if (node.kind !== 79 /* SyntaxKind.Identifier */ && !ts.isAccessExpression(node)) { + error(expr, invalidReferenceMessage); + return false; + } + if (node.flags & 32 /* NodeFlags.OptionalChain */) { + error(expr, invalidOptionalChainMessage); + return false; + } + return true; + } + function checkDeleteExpression(node) { + checkExpression(node.expression); + var expr = ts.skipParentheses(node.expression); + if (!ts.isAccessExpression(expr)) { + error(expr, ts.Diagnostics.The_operand_of_a_delete_operator_must_be_a_property_reference); + return booleanType; + } + if (ts.isPropertyAccessExpression(expr) && ts.isPrivateIdentifier(expr.name)) { + error(expr, ts.Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_private_identifier); + } + var links = getNodeLinks(expr); + var symbol = getExportSymbolOfValueSymbolIfExported(links.resolvedSymbol); + if (symbol) { + if (isReadonlySymbol(symbol)) { + error(expr, ts.Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_read_only_property); + } + checkDeleteExpressionMustBeOptional(expr, symbol); + } + return booleanType; + } + function checkDeleteExpressionMustBeOptional(expr, symbol) { + var type = getTypeOfSymbol(symbol); + if (strictNullChecks && + !(type.flags & (3 /* TypeFlags.AnyOrUnknown */ | 131072 /* TypeFlags.Never */)) && + !(exactOptionalPropertyTypes ? symbol.flags & 16777216 /* SymbolFlags.Optional */ : getTypeFacts(type) & 16777216 /* TypeFacts.IsUndefined */)) { + error(expr, ts.Diagnostics.The_operand_of_a_delete_operator_must_be_optional); + } + } + function checkTypeOfExpression(node) { + checkExpression(node.expression); + return typeofType; + } + function checkVoidExpression(node) { + checkExpression(node.expression); + return undefinedWideningType; + } + function checkAwaitExpressionGrammar(node) { + // Grammar checking + var container = ts.getContainingFunctionOrClassStaticBlock(node); + if (container && ts.isClassStaticBlockDeclaration(container)) { + error(node, ts.Diagnostics.Await_expression_cannot_be_used_inside_a_class_static_block); + } + else if (!(node.flags & 32768 /* NodeFlags.AwaitContext */)) { + if (ts.isInTopLevelContext(node)) { + var sourceFile = ts.getSourceFileOfNode(node); + if (!hasParseDiagnostics(sourceFile)) { + var span = void 0; + if (!ts.isEffectiveExternalModule(sourceFile, compilerOptions)) { + span !== null && span !== void 0 ? span : (span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos)); + var diagnostic = ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module); + diagnostics.add(diagnostic); + } + switch (moduleKind) { + case ts.ModuleKind.Node16: + case ts.ModuleKind.NodeNext: + if (sourceFile.impliedNodeFormat === ts.ModuleKind.CommonJS) { + span !== null && span !== void 0 ? span : (span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos)); + diagnostics.add(ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level)); + break; + } + // fallthrough + case ts.ModuleKind.ES2022: + case ts.ModuleKind.ESNext: + case ts.ModuleKind.System: + if (languageVersion >= 4 /* ScriptTarget.ES2017 */) { + break; + } + // fallthrough + default: + span !== null && span !== void 0 ? span : (span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos)); + diagnostics.add(ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher)); + break; + } + } + } + else { + // use of 'await' in non-async function + var sourceFile = ts.getSourceFileOfNode(node); + if (!hasParseDiagnostics(sourceFile)) { + var span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos); + var diagnostic = ts.createFileDiagnostic(sourceFile, span.start, span.length, ts.Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules); + if (container && container.kind !== 173 /* SyntaxKind.Constructor */ && (ts.getFunctionFlags(container) & 2 /* FunctionFlags.Async */) === 0) { + var relatedInfo = ts.createDiagnosticForNode(container, ts.Diagnostics.Did_you_mean_to_mark_this_function_as_async); + ts.addRelatedInfo(diagnostic, relatedInfo); + } + diagnostics.add(diagnostic); + } + } + } + if (isInParameterInitializerBeforeContainingFunction(node)) { + error(node, ts.Diagnostics.await_expressions_cannot_be_used_in_a_parameter_initializer); + } + } + function checkAwaitExpression(node) { + addLazyDiagnostic(function () { return checkAwaitExpressionGrammar(node); }); + var operandType = checkExpression(node.expression); + var awaitedType = checkAwaitedType(operandType, /*withAlias*/ true, node, ts.Diagnostics.Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member); + if (awaitedType === operandType && !isErrorType(awaitedType) && !(operandType.flags & 3 /* TypeFlags.AnyOrUnknown */)) { + addErrorOrSuggestion(/*isError*/ false, ts.createDiagnosticForNode(node, ts.Diagnostics.await_has_no_effect_on_the_type_of_this_expression)); + } + return awaitedType; + } + function checkPrefixUnaryExpression(node) { + var operandType = checkExpression(node.operand); + if (operandType === silentNeverType) { + return silentNeverType; + } + switch (node.operand.kind) { + case 8 /* SyntaxKind.NumericLiteral */: + switch (node.operator) { + case 40 /* SyntaxKind.MinusToken */: + return getFreshTypeOfLiteralType(getNumberLiteralType(-node.operand.text)); + case 39 /* SyntaxKind.PlusToken */: + return getFreshTypeOfLiteralType(getNumberLiteralType(+node.operand.text)); + } + break; + case 9 /* SyntaxKind.BigIntLiteral */: + if (node.operator === 40 /* SyntaxKind.MinusToken */) { + return getFreshTypeOfLiteralType(getBigIntLiteralType({ + negative: true, + base10Value: ts.parsePseudoBigInt(node.operand.text) + })); + } + } + switch (node.operator) { + case 39 /* SyntaxKind.PlusToken */: + case 40 /* SyntaxKind.MinusToken */: + case 54 /* SyntaxKind.TildeToken */: + checkNonNullType(operandType, node.operand); + if (maybeTypeOfKindConsideringBaseConstraint(operandType, 12288 /* TypeFlags.ESSymbolLike */)) { + error(node.operand, ts.Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, ts.tokenToString(node.operator)); + } + if (node.operator === 39 /* SyntaxKind.PlusToken */) { + if (maybeTypeOfKindConsideringBaseConstraint(operandType, 2112 /* TypeFlags.BigIntLike */)) { + error(node.operand, ts.Diagnostics.Operator_0_cannot_be_applied_to_type_1, ts.tokenToString(node.operator), typeToString(getBaseTypeOfLiteralType(operandType))); + } + return numberType; + } + return getUnaryResultType(operandType); + case 53 /* SyntaxKind.ExclamationToken */: + checkTruthinessExpression(node.operand); + var facts = getTypeFacts(operandType) & (4194304 /* TypeFacts.Truthy */ | 8388608 /* TypeFacts.Falsy */); + return facts === 4194304 /* TypeFacts.Truthy */ ? falseType : + facts === 8388608 /* TypeFacts.Falsy */ ? trueType : + booleanType; + case 45 /* SyntaxKind.PlusPlusToken */: + case 46 /* SyntaxKind.MinusMinusToken */: + var ok = checkArithmeticOperandType(node.operand, checkNonNullType(operandType, node.operand), ts.Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type); + if (ok) { + // run check only if former checks succeeded to avoid reporting cascading errors + checkReferenceExpression(node.operand, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_may_not_be_an_optional_property_access); + } + return getUnaryResultType(operandType); + } + return errorType; + } + function checkPostfixUnaryExpression(node) { + var operandType = checkExpression(node.operand); + if (operandType === silentNeverType) { + return silentNeverType; + } + var ok = checkArithmeticOperandType(node.operand, checkNonNullType(operandType, node.operand), ts.Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type); + if (ok) { + // run check only if former checks succeeded to avoid reporting cascading errors + checkReferenceExpression(node.operand, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access, ts.Diagnostics.The_operand_of_an_increment_or_decrement_operator_may_not_be_an_optional_property_access); + } + return getUnaryResultType(operandType); + } + function getUnaryResultType(operandType) { + if (maybeTypeOfKind(operandType, 2112 /* TypeFlags.BigIntLike */)) { + return isTypeAssignableToKind(operandType, 3 /* TypeFlags.AnyOrUnknown */) || maybeTypeOfKind(operandType, 296 /* TypeFlags.NumberLike */) + ? numberOrBigIntType + : bigintType; + } + // If it's not a bigint type, implicit coercion will result in a number + return numberType; + } + function maybeTypeOfKindConsideringBaseConstraint(type, kind) { + if (maybeTypeOfKind(type, kind)) { + return true; + } + var baseConstraint = getBaseConstraintOrType(type); + return !!baseConstraint && maybeTypeOfKind(baseConstraint, kind); + } + // Return true if type might be of the given kind. A union or intersection type might be of a given + // kind if at least one constituent type is of the given kind. + function maybeTypeOfKind(type, kind) { + if (type.flags & kind) { + return true; + } + if (type.flags & 3145728 /* TypeFlags.UnionOrIntersection */) { + var types = type.types; + for (var _i = 0, types_20 = types; _i < types_20.length; _i++) { + var t = types_20[_i]; + if (maybeTypeOfKind(t, kind)) { + return true; + } + } + } + return false; + } + function isTypeAssignableToKind(source, kind, strict) { + if (source.flags & kind) { + return true; + } + if (strict && source.flags & (3 /* TypeFlags.AnyOrUnknown */ | 16384 /* TypeFlags.Void */ | 32768 /* TypeFlags.Undefined */ | 65536 /* TypeFlags.Null */)) { + return false; + } + return !!(kind & 296 /* TypeFlags.NumberLike */) && isTypeAssignableTo(source, numberType) || + !!(kind & 2112 /* TypeFlags.BigIntLike */) && isTypeAssignableTo(source, bigintType) || + !!(kind & 402653316 /* TypeFlags.StringLike */) && isTypeAssignableTo(source, stringType) || + !!(kind & 528 /* TypeFlags.BooleanLike */) && isTypeAssignableTo(source, booleanType) || + !!(kind & 16384 /* TypeFlags.Void */) && isTypeAssignableTo(source, voidType) || + !!(kind & 131072 /* TypeFlags.Never */) && isTypeAssignableTo(source, neverType) || + !!(kind & 65536 /* TypeFlags.Null */) && isTypeAssignableTo(source, nullType) || + !!(kind & 32768 /* TypeFlags.Undefined */) && isTypeAssignableTo(source, undefinedType) || + !!(kind & 4096 /* TypeFlags.ESSymbol */) && isTypeAssignableTo(source, esSymbolType) || + !!(kind & 67108864 /* TypeFlags.NonPrimitive */) && isTypeAssignableTo(source, nonPrimitiveType); + } + function allTypesAssignableToKind(source, kind, strict) { + return source.flags & 1048576 /* TypeFlags.Union */ ? + ts.every(source.types, function (subType) { return allTypesAssignableToKind(subType, kind, strict); }) : + isTypeAssignableToKind(source, kind, strict); + } + function isConstEnumObjectType(type) { + return !!(ts.getObjectFlags(type) & 16 /* ObjectFlags.Anonymous */) && !!type.symbol && isConstEnumSymbol(type.symbol); + } + function isConstEnumSymbol(symbol) { + return (symbol.flags & 128 /* SymbolFlags.ConstEnum */) !== 0; + } + function checkInstanceOfExpression(left, right, leftType, rightType) { + if (leftType === silentNeverType || rightType === silentNeverType) { + return silentNeverType; + } + // TypeScript 1.0 spec (April 2014): 4.15.4 + // The instanceof operator requires the left operand to be of type Any, an object type, or a type parameter type, + // and the right operand to be of type Any, a subtype of the 'Function' interface type, or have a call or construct signature. + // The result is always of the Boolean primitive type. + // NOTE: do not raise error if leftType is unknown as related error was already reported + if (!isTypeAny(leftType) && + allTypesAssignableToKind(leftType, 131068 /* TypeFlags.Primitive */)) { + error(left, ts.Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter); + } + // NOTE: do not raise error if right is unknown as related error was already reported + if (!(isTypeAny(rightType) || typeHasCallOrConstructSignatures(rightType) || isTypeSubtypeOf(rightType, globalFunctionType))) { + error(right, ts.Diagnostics.The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type); + } + return booleanType; + } + function hasEmptyObjectIntersection(type) { + return someType(type, function (t) { return t === unknownEmptyObjectType || !!(t.flags & 2097152 /* TypeFlags.Intersection */) && ts.some(t.types, isEmptyAnonymousObjectType); }); + } + function checkInExpression(left, right, leftType, rightType) { + if (leftType === silentNeverType || rightType === silentNeverType) { + return silentNeverType; + } + if (ts.isPrivateIdentifier(left)) { + if (languageVersion < 99 /* ScriptTarget.ESNext */) { + checkExternalEmitHelpers(left, 2097152 /* ExternalEmitHelpers.ClassPrivateFieldIn */); + } + // Unlike in 'checkPrivateIdentifierExpression' we now have access to the RHS type + // which provides us with the opportunity to emit more detailed errors + if (!getNodeLinks(left).resolvedSymbol && ts.getContainingClass(left)) { + var isUncheckedJS = isUncheckedJSSuggestion(left, rightType.symbol, /*excludeClasses*/ true); + reportNonexistentProperty(left, rightType, isUncheckedJS); + } + } + else { + // The type of the lef operand must be assignable to string, number, or symbol. + checkTypeAssignableTo(checkNonNullType(leftType, left), stringNumberSymbolType, left); + } + // The type of the right operand must be assignable to 'object'. + if (checkTypeAssignableTo(checkNonNullType(rightType, right), nonPrimitiveType, right)) { + // The {} type is assignable to the object type, yet {} might represent a primitive type. Here we + // detect and error on {} that results from narrowing the unknown type, as well as intersections + // that include {} (we know that the other types in such intersections are assignable to object + // since we already checked for that). + if (hasEmptyObjectIntersection(rightType)) { + error(right, ts.Diagnostics.Type_0_may_represent_a_primitive_value_which_is_not_permitted_as_the_right_operand_of_the_in_operator, typeToString(rightType)); + } + } + // The result is always of the Boolean primitive type. + return booleanType; + } + function checkObjectLiteralAssignment(node, sourceType, rightIsThis) { + var properties = node.properties; + if (strictNullChecks && properties.length === 0) { + return checkNonNullType(sourceType, node); + } + for (var i = 0; i < properties.length; i++) { + checkObjectLiteralDestructuringPropertyAssignment(node, sourceType, i, properties, rightIsThis); + } + return sourceType; + } + /** Note: If property cannot be a SpreadAssignment, then allProperties does not need to be provided */ + function checkObjectLiteralDestructuringPropertyAssignment(node, objectLiteralType, propertyIndex, allProperties, rightIsThis) { + if (rightIsThis === void 0) { rightIsThis = false; } + var properties = node.properties; + var property = properties[propertyIndex]; + if (property.kind === 299 /* SyntaxKind.PropertyAssignment */ || property.kind === 300 /* SyntaxKind.ShorthandPropertyAssignment */) { + var name = property.name; + var exprType = getLiteralTypeFromPropertyName(name); + if (isTypeUsableAsPropertyName(exprType)) { + var text = getPropertyNameFromType(exprType); + var prop = getPropertyOfType(objectLiteralType, text); + if (prop) { + markPropertyAsReferenced(prop, property, rightIsThis); + checkPropertyAccessibility(property, /*isSuper*/ false, /*writing*/ true, objectLiteralType, prop); + } + } + var elementType = getIndexedAccessType(objectLiteralType, exprType, 32 /* AccessFlags.ExpressionPosition */, name); + var type = getFlowTypeOfDestructuring(property, elementType); + return checkDestructuringAssignment(property.kind === 300 /* SyntaxKind.ShorthandPropertyAssignment */ ? property : property.initializer, type); + } + else if (property.kind === 301 /* SyntaxKind.SpreadAssignment */) { + if (propertyIndex < properties.length - 1) { + error(property, ts.Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern); + } + else { + if (languageVersion < 99 /* ScriptTarget.ESNext */) { + checkExternalEmitHelpers(property, 4 /* ExternalEmitHelpers.Rest */); + } + var nonRestNames = []; + if (allProperties) { + for (var _i = 0, allProperties_1 = allProperties; _i < allProperties_1.length; _i++) { + var otherProperty = allProperties_1[_i]; + if (!ts.isSpreadAssignment(otherProperty)) { + nonRestNames.push(otherProperty.name); + } + } + } + var type = getRestType(objectLiteralType, nonRestNames, objectLiteralType.symbol); + checkGrammarForDisallowedTrailingComma(allProperties, ts.Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma); + return checkDestructuringAssignment(property.expression, type); + } + } + else { + error(property, ts.Diagnostics.Property_assignment_expected); + } + } + function checkArrayLiteralAssignment(node, sourceType, checkMode) { + var elements = node.elements; + if (languageVersion < 2 /* ScriptTarget.ES2015 */ && compilerOptions.downlevelIteration) { + checkExternalEmitHelpers(node, 512 /* ExternalEmitHelpers.Read */); + } + // This elementType will be used if the specific property corresponding to this index is not + // present (aka the tuple element property). This call also checks that the parentType is in + // fact an iterable or array (depending on target language). + var possiblyOutOfBoundsType = checkIteratedTypeOrElementType(65 /* IterationUse.Destructuring */ | 128 /* IterationUse.PossiblyOutOfBounds */, sourceType, undefinedType, node) || errorType; + var inBoundsType = compilerOptions.noUncheckedIndexedAccess ? undefined : possiblyOutOfBoundsType; + for (var i = 0; i < elements.length; i++) { + var type = possiblyOutOfBoundsType; + if (node.elements[i].kind === 227 /* SyntaxKind.SpreadElement */) { + type = inBoundsType = inBoundsType !== null && inBoundsType !== void 0 ? inBoundsType : (checkIteratedTypeOrElementType(65 /* IterationUse.Destructuring */, sourceType, undefinedType, node) || errorType); + } + checkArrayLiteralDestructuringElementAssignment(node, sourceType, i, type, checkMode); + } + return sourceType; + } + function checkArrayLiteralDestructuringElementAssignment(node, sourceType, elementIndex, elementType, checkMode) { + var elements = node.elements; + var element = elements[elementIndex]; + if (element.kind !== 229 /* SyntaxKind.OmittedExpression */) { + if (element.kind !== 227 /* SyntaxKind.SpreadElement */) { + var indexType = getNumberLiteralType(elementIndex); + if (isArrayLikeType(sourceType)) { + // We create a synthetic expression so that getIndexedAccessType doesn't get confused + // when the element is a SyntaxKind.ElementAccessExpression. + var accessFlags = 32 /* AccessFlags.ExpressionPosition */ | (hasDefaultValue(element) ? 16 /* AccessFlags.NoTupleBoundsCheck */ : 0); + var elementType_2 = getIndexedAccessTypeOrUndefined(sourceType, indexType, accessFlags, createSyntheticExpression(element, indexType)) || errorType; + var assignedType = hasDefaultValue(element) ? getTypeWithFacts(elementType_2, 524288 /* TypeFacts.NEUndefined */) : elementType_2; + var type = getFlowTypeOfDestructuring(element, assignedType); + return checkDestructuringAssignment(element, type, checkMode); + } + return checkDestructuringAssignment(element, elementType, checkMode); + } + if (elementIndex < elements.length - 1) { + error(element, ts.Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern); + } + else { + var restExpression = element.expression; + if (restExpression.kind === 223 /* SyntaxKind.BinaryExpression */ && restExpression.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */) { + error(restExpression.operatorToken, ts.Diagnostics.A_rest_element_cannot_have_an_initializer); + } + else { + checkGrammarForDisallowedTrailingComma(node.elements, ts.Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma); + var type = everyType(sourceType, isTupleType) ? + mapType(sourceType, function (t) { return sliceTupleType(t, elementIndex); }) : + createArrayType(elementType); + return checkDestructuringAssignment(restExpression, type, checkMode); + } + } + } + return undefined; + } + function checkDestructuringAssignment(exprOrAssignment, sourceType, checkMode, rightIsThis) { + var target; + if (exprOrAssignment.kind === 300 /* SyntaxKind.ShorthandPropertyAssignment */) { + var prop = exprOrAssignment; + if (prop.objectAssignmentInitializer) { + // In strict null checking mode, if a default value of a non-undefined type is specified, remove + // undefined from the final type. + if (strictNullChecks && + !(getTypeFacts(checkExpression(prop.objectAssignmentInitializer)) & 16777216 /* TypeFacts.IsUndefined */)) { + sourceType = getTypeWithFacts(sourceType, 524288 /* TypeFacts.NEUndefined */); + } + checkBinaryLikeExpression(prop.name, prop.equalsToken, prop.objectAssignmentInitializer, checkMode); + } + target = exprOrAssignment.name; + } + else { + target = exprOrAssignment; + } + if (target.kind === 223 /* SyntaxKind.BinaryExpression */ && target.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */) { + checkBinaryExpression(target, checkMode); + target = target.left; + // A default value is specified, so remove undefined from the final type. + if (strictNullChecks) { + sourceType = getTypeWithFacts(sourceType, 524288 /* TypeFacts.NEUndefined */); + } + } + if (target.kind === 207 /* SyntaxKind.ObjectLiteralExpression */) { + return checkObjectLiteralAssignment(target, sourceType, rightIsThis); + } + if (target.kind === 206 /* SyntaxKind.ArrayLiteralExpression */) { + return checkArrayLiteralAssignment(target, sourceType, checkMode); + } + return checkReferenceAssignment(target, sourceType, checkMode); + } + function checkReferenceAssignment(target, sourceType, checkMode) { + var targetType = checkExpression(target, checkMode); + var error = target.parent.kind === 301 /* SyntaxKind.SpreadAssignment */ ? + ts.Diagnostics.The_target_of_an_object_rest_assignment_must_be_a_variable_or_a_property_access : + ts.Diagnostics.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access; + var optionalError = target.parent.kind === 301 /* SyntaxKind.SpreadAssignment */ ? + ts.Diagnostics.The_target_of_an_object_rest_assignment_may_not_be_an_optional_property_access : + ts.Diagnostics.The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access; + if (checkReferenceExpression(target, error, optionalError)) { + checkTypeAssignableToAndOptionallyElaborate(sourceType, targetType, target, target); + } + if (ts.isPrivateIdentifierPropertyAccessExpression(target)) { + checkExternalEmitHelpers(target.parent, 1048576 /* ExternalEmitHelpers.ClassPrivateFieldSet */); + } + return sourceType; + } + /** + * This is a *shallow* check: An expression is side-effect-free if the + * evaluation of the expression *itself* cannot produce side effects. + * For example, x++ / 3 is side-effect free because the / operator + * does not have side effects. + * The intent is to "smell test" an expression for correctness in positions where + * its value is discarded (e.g. the left side of the comma operator). + */ + function isSideEffectFree(node) { + node = ts.skipParentheses(node); + switch (node.kind) { + case 79 /* SyntaxKind.Identifier */: + case 10 /* SyntaxKind.StringLiteral */: + case 13 /* SyntaxKind.RegularExpressionLiteral */: + case 212 /* SyntaxKind.TaggedTemplateExpression */: + case 225 /* SyntaxKind.TemplateExpression */: + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + case 8 /* SyntaxKind.NumericLiteral */: + case 9 /* SyntaxKind.BigIntLiteral */: + case 110 /* SyntaxKind.TrueKeyword */: + case 95 /* SyntaxKind.FalseKeyword */: + case 104 /* SyntaxKind.NullKeyword */: + case 155 /* SyntaxKind.UndefinedKeyword */: + case 215 /* SyntaxKind.FunctionExpression */: + case 228 /* SyntaxKind.ClassExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + case 206 /* SyntaxKind.ArrayLiteralExpression */: + case 207 /* SyntaxKind.ObjectLiteralExpression */: + case 218 /* SyntaxKind.TypeOfExpression */: + case 232 /* SyntaxKind.NonNullExpression */: + case 282 /* SyntaxKind.JsxSelfClosingElement */: + case 281 /* SyntaxKind.JsxElement */: + return true; + case 224 /* SyntaxKind.ConditionalExpression */: + return isSideEffectFree(node.whenTrue) && + isSideEffectFree(node.whenFalse); + case 223 /* SyntaxKind.BinaryExpression */: + if (ts.isAssignmentOperator(node.operatorToken.kind)) { + return false; + } + return isSideEffectFree(node.left) && + isSideEffectFree(node.right); + case 221 /* SyntaxKind.PrefixUnaryExpression */: + case 222 /* SyntaxKind.PostfixUnaryExpression */: + // Unary operators ~, !, +, and - have no side effects. + // The rest do. + switch (node.operator) { + case 53 /* SyntaxKind.ExclamationToken */: + case 39 /* SyntaxKind.PlusToken */: + case 40 /* SyntaxKind.MinusToken */: + case 54 /* SyntaxKind.TildeToken */: + return true; + } + return false; + // Some forms listed here for clarity + case 219 /* SyntaxKind.VoidExpression */: // Explicit opt-out + case 213 /* SyntaxKind.TypeAssertionExpression */: // Not SEF, but can produce useful type warnings + case 231 /* SyntaxKind.AsExpression */: // Not SEF, but can produce useful type warnings + default: + return false; + } + } + function isTypeEqualityComparableTo(source, target) { + return (target.flags & 98304 /* TypeFlags.Nullable */) !== 0 || isTypeComparableTo(source, target); + } + function createCheckBinaryExpression() { + var trampoline = ts.createBinaryExpressionTrampoline(onEnter, onLeft, onOperator, onRight, onExit, foldState); + return function (node, checkMode) { + var result = trampoline(node, checkMode); + ts.Debug.assertIsDefined(result); + return result; + }; + function onEnter(node, state, checkMode) { + if (state) { + state.stackIndex++; + state.skip = false; + setLeftType(state, /*type*/ undefined); + setLastResult(state, /*type*/ undefined); + } + else { + state = { + checkMode: checkMode, + skip: false, + stackIndex: 0, + typeStack: [undefined, undefined], + }; + } + if (ts.isInJSFile(node) && ts.getAssignedExpandoInitializer(node)) { + state.skip = true; + setLastResult(state, checkExpression(node.right, checkMode)); + return state; + } + checkGrammarNullishCoalesceWithLogicalExpression(node); + var operator = node.operatorToken.kind; + if (operator === 63 /* SyntaxKind.EqualsToken */ && (node.left.kind === 207 /* SyntaxKind.ObjectLiteralExpression */ || node.left.kind === 206 /* SyntaxKind.ArrayLiteralExpression */)) { + state.skip = true; + setLastResult(state, checkDestructuringAssignment(node.left, checkExpression(node.right, checkMode), checkMode, node.right.kind === 108 /* SyntaxKind.ThisKeyword */)); + return state; + } + return state; + } + function onLeft(left, state, _node) { + if (!state.skip) { + return maybeCheckExpression(state, left); + } + } + function onOperator(operatorToken, state, node) { + if (!state.skip) { + var leftType = getLastResult(state); + ts.Debug.assertIsDefined(leftType); + setLeftType(state, leftType); + setLastResult(state, /*type*/ undefined); + var operator = operatorToken.kind; + if (operator === 55 /* SyntaxKind.AmpersandAmpersandToken */ || operator === 56 /* SyntaxKind.BarBarToken */ || operator === 60 /* SyntaxKind.QuestionQuestionToken */) { + if (operator === 55 /* SyntaxKind.AmpersandAmpersandToken */) { + var parent = node.parent; + while (parent.kind === 214 /* SyntaxKind.ParenthesizedExpression */ + || ts.isBinaryExpression(parent) && (parent.operatorToken.kind === 55 /* SyntaxKind.AmpersandAmpersandToken */ || parent.operatorToken.kind === 56 /* SyntaxKind.BarBarToken */)) { + parent = parent.parent; + } + checkTestingKnownTruthyCallableOrAwaitableType(node.left, leftType, ts.isIfStatement(parent) ? parent.thenStatement : undefined); + } + checkTruthinessOfType(leftType, node.left); + } + } + } + function onRight(right, state, _node) { + if (!state.skip) { + return maybeCheckExpression(state, right); + } + } + function onExit(node, state) { + var result; + if (state.skip) { + result = getLastResult(state); + } + else { + var leftType = getLeftType(state); + ts.Debug.assertIsDefined(leftType); + var rightType = getLastResult(state); + ts.Debug.assertIsDefined(rightType); + result = checkBinaryLikeExpressionWorker(node.left, node.operatorToken, node.right, leftType, rightType, node); + } + state.skip = false; + setLeftType(state, /*type*/ undefined); + setLastResult(state, /*type*/ undefined); + state.stackIndex--; + return result; + } + function foldState(state, result, _side) { + setLastResult(state, result); + return state; + } + function maybeCheckExpression(state, node) { + if (ts.isBinaryExpression(node)) { + return node; + } + setLastResult(state, checkExpression(node, state.checkMode)); + } + function getLeftType(state) { + return state.typeStack[state.stackIndex]; + } + function setLeftType(state, type) { + state.typeStack[state.stackIndex] = type; + } + function getLastResult(state) { + return state.typeStack[state.stackIndex + 1]; + } + function setLastResult(state, type) { + // To reduce overhead, reuse the next stack entry to store the + // last result. This avoids the overhead of an additional property + // on `WorkArea` and reuses empty stack entries as we walk back up + // the stack. + state.typeStack[state.stackIndex + 1] = type; + } + } + function checkGrammarNullishCoalesceWithLogicalExpression(node) { + var left = node.left, operatorToken = node.operatorToken, right = node.right; + if (operatorToken.kind === 60 /* SyntaxKind.QuestionQuestionToken */) { + if (ts.isBinaryExpression(left) && (left.operatorToken.kind === 56 /* SyntaxKind.BarBarToken */ || left.operatorToken.kind === 55 /* SyntaxKind.AmpersandAmpersandToken */)) { + grammarErrorOnNode(left, ts.Diagnostics._0_and_1_operations_cannot_be_mixed_without_parentheses, ts.tokenToString(left.operatorToken.kind), ts.tokenToString(operatorToken.kind)); + } + if (ts.isBinaryExpression(right) && (right.operatorToken.kind === 56 /* SyntaxKind.BarBarToken */ || right.operatorToken.kind === 55 /* SyntaxKind.AmpersandAmpersandToken */)) { + grammarErrorOnNode(right, ts.Diagnostics._0_and_1_operations_cannot_be_mixed_without_parentheses, ts.tokenToString(right.operatorToken.kind), ts.tokenToString(operatorToken.kind)); + } + } + } + // Note that this and `checkBinaryExpression` above should behave mostly the same, except this elides some + // expression-wide checks and does not use a work stack to fold nested binary expressions into the same callstack frame + function checkBinaryLikeExpression(left, operatorToken, right, checkMode, errorNode) { + var operator = operatorToken.kind; + if (operator === 63 /* SyntaxKind.EqualsToken */ && (left.kind === 207 /* SyntaxKind.ObjectLiteralExpression */ || left.kind === 206 /* SyntaxKind.ArrayLiteralExpression */)) { + return checkDestructuringAssignment(left, checkExpression(right, checkMode), checkMode, right.kind === 108 /* SyntaxKind.ThisKeyword */); + } + var leftType; + if (operator === 55 /* SyntaxKind.AmpersandAmpersandToken */ || operator === 56 /* SyntaxKind.BarBarToken */ || operator === 60 /* SyntaxKind.QuestionQuestionToken */) { + leftType = checkTruthinessExpression(left, checkMode); + } + else { + leftType = checkExpression(left, checkMode); + } + var rightType = checkExpression(right, checkMode); + return checkBinaryLikeExpressionWorker(left, operatorToken, right, leftType, rightType, errorNode); + } + function checkBinaryLikeExpressionWorker(left, operatorToken, right, leftType, rightType, errorNode) { + var operator = operatorToken.kind; + switch (operator) { + case 41 /* SyntaxKind.AsteriskToken */: + case 42 /* SyntaxKind.AsteriskAsteriskToken */: + case 66 /* SyntaxKind.AsteriskEqualsToken */: + case 67 /* SyntaxKind.AsteriskAsteriskEqualsToken */: + case 43 /* SyntaxKind.SlashToken */: + case 68 /* SyntaxKind.SlashEqualsToken */: + case 44 /* SyntaxKind.PercentToken */: + case 69 /* SyntaxKind.PercentEqualsToken */: + case 40 /* SyntaxKind.MinusToken */: + case 65 /* SyntaxKind.MinusEqualsToken */: + case 47 /* SyntaxKind.LessThanLessThanToken */: + case 70 /* SyntaxKind.LessThanLessThanEqualsToken */: + case 48 /* SyntaxKind.GreaterThanGreaterThanToken */: + case 71 /* SyntaxKind.GreaterThanGreaterThanEqualsToken */: + case 49 /* SyntaxKind.GreaterThanGreaterThanGreaterThanToken */: + case 72 /* SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken */: + case 51 /* SyntaxKind.BarToken */: + case 74 /* SyntaxKind.BarEqualsToken */: + case 52 /* SyntaxKind.CaretToken */: + case 78 /* SyntaxKind.CaretEqualsToken */: + case 50 /* SyntaxKind.AmpersandToken */: + case 73 /* SyntaxKind.AmpersandEqualsToken */: + if (leftType === silentNeverType || rightType === silentNeverType) { + return silentNeverType; + } + leftType = checkNonNullType(leftType, left); + rightType = checkNonNullType(rightType, right); + var suggestedOperator = void 0; + // if a user tries to apply a bitwise operator to 2 boolean operands + // try and return them a helpful suggestion + if ((leftType.flags & 528 /* TypeFlags.BooleanLike */) && + (rightType.flags & 528 /* TypeFlags.BooleanLike */) && + (suggestedOperator = getSuggestedBooleanOperator(operatorToken.kind)) !== undefined) { + error(errorNode || operatorToken, ts.Diagnostics.The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead, ts.tokenToString(operatorToken.kind), ts.tokenToString(suggestedOperator)); + return numberType; + } + else { + // otherwise just check each operand separately and report errors as normal + var leftOk = checkArithmeticOperandType(left, leftType, ts.Diagnostics.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type, /*isAwaitValid*/ true); + var rightOk = checkArithmeticOperandType(right, rightType, ts.Diagnostics.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type, /*isAwaitValid*/ true); + var resultType_1; + // If both are any or unknown, allow operation; assume it will resolve to number + if ((isTypeAssignableToKind(leftType, 3 /* TypeFlags.AnyOrUnknown */) && isTypeAssignableToKind(rightType, 3 /* TypeFlags.AnyOrUnknown */)) || + // Or, if neither could be bigint, implicit coercion results in a number result + !(maybeTypeOfKind(leftType, 2112 /* TypeFlags.BigIntLike */) || maybeTypeOfKind(rightType, 2112 /* TypeFlags.BigIntLike */))) { + resultType_1 = numberType; + } + // At least one is assignable to bigint, so check that both are + else if (bothAreBigIntLike(leftType, rightType)) { + switch (operator) { + case 49 /* SyntaxKind.GreaterThanGreaterThanGreaterThanToken */: + case 72 /* SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken */: + reportOperatorError(); + break; + case 42 /* SyntaxKind.AsteriskAsteriskToken */: + case 67 /* SyntaxKind.AsteriskAsteriskEqualsToken */: + if (languageVersion < 3 /* ScriptTarget.ES2016 */) { + error(errorNode, ts.Diagnostics.Exponentiation_cannot_be_performed_on_bigint_values_unless_the_target_option_is_set_to_es2016_or_later); + } + } + resultType_1 = bigintType; + } + // Exactly one of leftType/rightType is assignable to bigint + else { + reportOperatorError(bothAreBigIntLike); + resultType_1 = errorType; + } + if (leftOk && rightOk) { + checkAssignmentOperator(resultType_1); + } + return resultType_1; + } + case 39 /* SyntaxKind.PlusToken */: + case 64 /* SyntaxKind.PlusEqualsToken */: + if (leftType === silentNeverType || rightType === silentNeverType) { + return silentNeverType; + } + if (!isTypeAssignableToKind(leftType, 402653316 /* TypeFlags.StringLike */) && !isTypeAssignableToKind(rightType, 402653316 /* TypeFlags.StringLike */)) { + leftType = checkNonNullType(leftType, left); + rightType = checkNonNullType(rightType, right); + } + var resultType = void 0; + if (isTypeAssignableToKind(leftType, 296 /* TypeFlags.NumberLike */, /*strict*/ true) && isTypeAssignableToKind(rightType, 296 /* TypeFlags.NumberLike */, /*strict*/ true)) { + // Operands of an enum type are treated as having the primitive type Number. + // If both operands are of the Number primitive type, the result is of the Number primitive type. + resultType = numberType; + } + else if (isTypeAssignableToKind(leftType, 2112 /* TypeFlags.BigIntLike */, /*strict*/ true) && isTypeAssignableToKind(rightType, 2112 /* TypeFlags.BigIntLike */, /*strict*/ true)) { + // If both operands are of the BigInt primitive type, the result is of the BigInt primitive type. + resultType = bigintType; + } + else if (isTypeAssignableToKind(leftType, 402653316 /* TypeFlags.StringLike */, /*strict*/ true) || isTypeAssignableToKind(rightType, 402653316 /* TypeFlags.StringLike */, /*strict*/ true)) { + // If one or both operands are of the String primitive type, the result is of the String primitive type. + resultType = stringType; + } + else if (isTypeAny(leftType) || isTypeAny(rightType)) { + // Otherwise, the result is of type Any. + // NOTE: unknown type here denotes error type. Old compiler treated this case as any type so do we. + resultType = isErrorType(leftType) || isErrorType(rightType) ? errorType : anyType; + } + // Symbols are not allowed at all in arithmetic expressions + if (resultType && !checkForDisallowedESSymbolOperand(operator)) { + return resultType; + } + if (!resultType) { + // Types that have a reasonably good chance of being a valid operand type. + // If both types have an awaited type of one of these, we'll assume the user + // might be missing an await without doing an exhaustive check that inserting + // await(s) will actually be a completely valid binary expression. + var closeEnoughKind_1 = 296 /* TypeFlags.NumberLike */ | 2112 /* TypeFlags.BigIntLike */ | 402653316 /* TypeFlags.StringLike */ | 3 /* TypeFlags.AnyOrUnknown */; + reportOperatorError(function (left, right) { + return isTypeAssignableToKind(left, closeEnoughKind_1) && + isTypeAssignableToKind(right, closeEnoughKind_1); + }); + return anyType; + } + if (operator === 64 /* SyntaxKind.PlusEqualsToken */) { + checkAssignmentOperator(resultType); + } + return resultType; + case 29 /* SyntaxKind.LessThanToken */: + case 31 /* SyntaxKind.GreaterThanToken */: + case 32 /* SyntaxKind.LessThanEqualsToken */: + case 33 /* SyntaxKind.GreaterThanEqualsToken */: + if (checkForDisallowedESSymbolOperand(operator)) { + leftType = getBaseTypeOfLiteralType(checkNonNullType(leftType, left)); + rightType = getBaseTypeOfLiteralType(checkNonNullType(rightType, right)); + reportOperatorErrorUnless(function (left, right) { + return isTypeComparableTo(left, right) || isTypeComparableTo(right, left) || (isTypeAssignableTo(left, numberOrBigIntType) && isTypeAssignableTo(right, numberOrBigIntType)); + }); + } + return booleanType; + case 34 /* SyntaxKind.EqualsEqualsToken */: + case 35 /* SyntaxKind.ExclamationEqualsToken */: + case 36 /* SyntaxKind.EqualsEqualsEqualsToken */: + case 37 /* SyntaxKind.ExclamationEqualsEqualsToken */: + if (ts.isLiteralExpressionOfObject(left) || ts.isLiteralExpressionOfObject(right)) { + var eqType = operator === 34 /* SyntaxKind.EqualsEqualsToken */ || operator === 36 /* SyntaxKind.EqualsEqualsEqualsToken */; + error(errorNode, ts.Diagnostics.This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value, eqType ? "false" : "true"); + } + checkNaNEquality(errorNode, operator, left, right); + reportOperatorErrorUnless(function (left, right) { return isTypeEqualityComparableTo(left, right) || isTypeEqualityComparableTo(right, left); }); + return booleanType; + case 102 /* SyntaxKind.InstanceOfKeyword */: + return checkInstanceOfExpression(left, right, leftType, rightType); + case 101 /* SyntaxKind.InKeyword */: + return checkInExpression(left, right, leftType, rightType); + case 55 /* SyntaxKind.AmpersandAmpersandToken */: + case 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */: { + var resultType_2 = getTypeFacts(leftType) & 4194304 /* TypeFacts.Truthy */ ? + getUnionType([extractDefinitelyFalsyTypes(strictNullChecks ? leftType : getBaseTypeOfLiteralType(rightType)), rightType]) : + leftType; + if (operator === 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */) { + checkAssignmentOperator(rightType); + } + return resultType_2; + } + case 56 /* SyntaxKind.BarBarToken */: + case 75 /* SyntaxKind.BarBarEqualsToken */: { + var resultType_3 = getTypeFacts(leftType) & 8388608 /* TypeFacts.Falsy */ ? + getUnionType([getNonNullableType(removeDefinitelyFalsyTypes(leftType)), rightType], 2 /* UnionReduction.Subtype */) : + leftType; + if (operator === 75 /* SyntaxKind.BarBarEqualsToken */) { + checkAssignmentOperator(rightType); + } + return resultType_3; + } + case 60 /* SyntaxKind.QuestionQuestionToken */: + case 77 /* SyntaxKind.QuestionQuestionEqualsToken */: { + var resultType_4 = getTypeFacts(leftType) & 262144 /* TypeFacts.EQUndefinedOrNull */ ? + getUnionType([getNonNullableType(leftType), rightType], 2 /* UnionReduction.Subtype */) : + leftType; + if (operator === 77 /* SyntaxKind.QuestionQuestionEqualsToken */) { + checkAssignmentOperator(rightType); + } + return resultType_4; + } + case 63 /* SyntaxKind.EqualsToken */: + var declKind = ts.isBinaryExpression(left.parent) ? ts.getAssignmentDeclarationKind(left.parent) : 0 /* AssignmentDeclarationKind.None */; + checkAssignmentDeclaration(declKind, rightType); + if (isAssignmentDeclaration(declKind)) { + if (!(rightType.flags & 524288 /* TypeFlags.Object */) || + declKind !== 2 /* AssignmentDeclarationKind.ModuleExports */ && + declKind !== 6 /* AssignmentDeclarationKind.Prototype */ && + !isEmptyObjectType(rightType) && + !isFunctionObjectType(rightType) && + !(ts.getObjectFlags(rightType) & 1 /* ObjectFlags.Class */)) { + // don't check assignability of module.exports=, C.prototype=, or expando types because they will necessarily be incomplete + checkAssignmentOperator(rightType); + } + return leftType; + } + else { + checkAssignmentOperator(rightType); + return getRegularTypeOfObjectLiteral(rightType); + } + case 27 /* SyntaxKind.CommaToken */: + if (!compilerOptions.allowUnreachableCode && isSideEffectFree(left) && !isEvalNode(right)) { + var sf = ts.getSourceFileOfNode(left); + var sourceText = sf.text; + var start_3 = ts.skipTrivia(sourceText, left.pos); + var isInDiag2657 = sf.parseDiagnostics.some(function (diag) { + if (diag.code !== ts.Diagnostics.JSX_expressions_must_have_one_parent_element.code) + return false; + return ts.textSpanContainsPosition(diag, start_3); + }); + if (!isInDiag2657) + error(left, ts.Diagnostics.Left_side_of_comma_operator_is_unused_and_has_no_side_effects); + } + return rightType; + default: + return ts.Debug.fail(); + } + function bothAreBigIntLike(left, right) { + return isTypeAssignableToKind(left, 2112 /* TypeFlags.BigIntLike */) && isTypeAssignableToKind(right, 2112 /* TypeFlags.BigIntLike */); + } + function checkAssignmentDeclaration(kind, rightType) { + if (kind === 2 /* AssignmentDeclarationKind.ModuleExports */) { + for (var _i = 0, _a = getPropertiesOfObjectType(rightType); _i < _a.length; _i++) { + var prop = _a[_i]; + var propType = getTypeOfSymbol(prop); + if (propType.symbol && propType.symbol.flags & 32 /* SymbolFlags.Class */) { + var name = prop.escapedName; + var symbol = resolveName(prop.valueDeclaration, name, 788968 /* SymbolFlags.Type */, undefined, name, /*isUse*/ false); + if ((symbol === null || symbol === void 0 ? void 0 : symbol.declarations) && symbol.declarations.some(ts.isJSDocTypedefTag)) { + addDuplicateDeclarationErrorsForSymbols(symbol, ts.Diagnostics.Duplicate_identifier_0, ts.unescapeLeadingUnderscores(name), prop); + addDuplicateDeclarationErrorsForSymbols(prop, ts.Diagnostics.Duplicate_identifier_0, ts.unescapeLeadingUnderscores(name), symbol); + } + } + } + } + } + function isEvalNode(node) { + return node.kind === 79 /* SyntaxKind.Identifier */ && node.escapedText === "eval"; + } + // Return true if there was no error, false if there was an error. + function checkForDisallowedESSymbolOperand(operator) { + var offendingSymbolOperand = maybeTypeOfKindConsideringBaseConstraint(leftType, 12288 /* TypeFlags.ESSymbolLike */) ? left : + maybeTypeOfKindConsideringBaseConstraint(rightType, 12288 /* TypeFlags.ESSymbolLike */) ? right : + undefined; + if (offendingSymbolOperand) { + error(offendingSymbolOperand, ts.Diagnostics.The_0_operator_cannot_be_applied_to_type_symbol, ts.tokenToString(operator)); + return false; + } + return true; + } + function getSuggestedBooleanOperator(operator) { + switch (operator) { + case 51 /* SyntaxKind.BarToken */: + case 74 /* SyntaxKind.BarEqualsToken */: + return 56 /* SyntaxKind.BarBarToken */; + case 52 /* SyntaxKind.CaretToken */: + case 78 /* SyntaxKind.CaretEqualsToken */: + return 37 /* SyntaxKind.ExclamationEqualsEqualsToken */; + case 50 /* SyntaxKind.AmpersandToken */: + case 73 /* SyntaxKind.AmpersandEqualsToken */: + return 55 /* SyntaxKind.AmpersandAmpersandToken */; + default: + return undefined; + } + } + function checkAssignmentOperator(valueType) { + if (ts.isAssignmentOperator(operator)) { + addLazyDiagnostic(checkAssignmentOperatorWorker); + } + function checkAssignmentOperatorWorker() { + // TypeScript 1.0 spec (April 2014): 4.17 + // An assignment of the form + // VarExpr = ValueExpr + // requires VarExpr to be classified as a reference + // A compound assignment furthermore requires VarExpr to be classified as a reference (section 4.1) + // and the type of the non-compound operation to be assignable to the type of VarExpr. + if (checkReferenceExpression(left, ts.Diagnostics.The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access, ts.Diagnostics.The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access) + && (!ts.isIdentifier(left) || ts.unescapeLeadingUnderscores(left.escapedText) !== "exports")) { + var headMessage = void 0; + if (exactOptionalPropertyTypes && ts.isPropertyAccessExpression(left) && maybeTypeOfKind(valueType, 32768 /* TypeFlags.Undefined */)) { + var target = getTypeOfPropertyOfType(getTypeOfExpression(left.expression), left.name.escapedText); + if (isExactOptionalPropertyMismatch(valueType, target)) { + headMessage = ts.Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_type_of_the_target; + } + } + // to avoid cascading errors check assignability only if 'isReference' check succeeded and no errors were reported + checkTypeAssignableToAndOptionallyElaborate(valueType, leftType, left, right, headMessage); + } + } + } + function isAssignmentDeclaration(kind) { + var _a; + switch (kind) { + case 2 /* AssignmentDeclarationKind.ModuleExports */: + return true; + case 1 /* AssignmentDeclarationKind.ExportsProperty */: + case 5 /* AssignmentDeclarationKind.Property */: + case 6 /* AssignmentDeclarationKind.Prototype */: + case 3 /* AssignmentDeclarationKind.PrototypeProperty */: + case 4 /* AssignmentDeclarationKind.ThisProperty */: + var symbol = getSymbolOfNode(left); + var init = ts.getAssignedExpandoInitializer(right); + return !!init && ts.isObjectLiteralExpression(init) && + !!((_a = symbol === null || symbol === void 0 ? void 0 : symbol.exports) === null || _a === void 0 ? void 0 : _a.size); + default: + return false; + } + } + /** + * Returns true if an error is reported + */ + function reportOperatorErrorUnless(typesAreCompatible) { + if (!typesAreCompatible(leftType, rightType)) { + reportOperatorError(typesAreCompatible); + return true; + } + return false; + } + function reportOperatorError(isRelated) { + var _a; + var wouldWorkWithAwait = false; + var errNode = errorNode || operatorToken; + if (isRelated) { + var awaitedLeftType = getAwaitedTypeNoAlias(leftType); + var awaitedRightType = getAwaitedTypeNoAlias(rightType); + wouldWorkWithAwait = !(awaitedLeftType === leftType && awaitedRightType === rightType) + && !!(awaitedLeftType && awaitedRightType) + && isRelated(awaitedLeftType, awaitedRightType); + } + var effectiveLeft = leftType; + var effectiveRight = rightType; + if (!wouldWorkWithAwait && isRelated) { + _a = getBaseTypesIfUnrelated(leftType, rightType, isRelated), effectiveLeft = _a[0], effectiveRight = _a[1]; + } + var _b = getTypeNamesForErrorDisplay(effectiveLeft, effectiveRight), leftStr = _b[0], rightStr = _b[1]; + if (!tryGiveBetterPrimaryError(errNode, wouldWorkWithAwait, leftStr, rightStr)) { + errorAndMaybeSuggestAwait(errNode, wouldWorkWithAwait, ts.Diagnostics.Operator_0_cannot_be_applied_to_types_1_and_2, ts.tokenToString(operatorToken.kind), leftStr, rightStr); + } + } + function tryGiveBetterPrimaryError(errNode, maybeMissingAwait, leftStr, rightStr) { + switch (operatorToken.kind) { + case 36 /* SyntaxKind.EqualsEqualsEqualsToken */: + case 34 /* SyntaxKind.EqualsEqualsToken */: + case 37 /* SyntaxKind.ExclamationEqualsEqualsToken */: + case 35 /* SyntaxKind.ExclamationEqualsToken */: + return errorAndMaybeSuggestAwait(errNode, maybeMissingAwait, ts.Diagnostics.This_comparison_appears_to_be_unintentional_because_the_types_0_and_1_have_no_overlap, leftStr, rightStr); + default: + return undefined; + } + } + function checkNaNEquality(errorNode, operator, left, right) { + var isLeftNaN = isGlobalNaN(ts.skipParentheses(left)); + var isRightNaN = isGlobalNaN(ts.skipParentheses(right)); + if (isLeftNaN || isRightNaN) { + var err = error(errorNode, ts.Diagnostics.This_condition_will_always_return_0, ts.tokenToString(operator === 36 /* SyntaxKind.EqualsEqualsEqualsToken */ || operator === 34 /* SyntaxKind.EqualsEqualsToken */ ? 95 /* SyntaxKind.FalseKeyword */ : 110 /* SyntaxKind.TrueKeyword */)); + if (isLeftNaN && isRightNaN) + return; + var operatorString = operator === 37 /* SyntaxKind.ExclamationEqualsEqualsToken */ || operator === 35 /* SyntaxKind.ExclamationEqualsToken */ ? ts.tokenToString(53 /* SyntaxKind.ExclamationToken */) : ""; + var location = isLeftNaN ? right : left; + var expression = ts.skipParentheses(location); + ts.addRelatedInfo(err, ts.createDiagnosticForNode(location, ts.Diagnostics.Did_you_mean_0, "".concat(operatorString, "Number.isNaN(").concat(ts.isEntityNameExpression(expression) ? ts.entityNameToString(expression) : "...", ")"))); + } + } + function isGlobalNaN(expr) { + if (ts.isIdentifier(expr) && expr.escapedText === "NaN") { + var globalNaNSymbol = getGlobalNaNSymbol(); + return !!globalNaNSymbol && globalNaNSymbol === getResolvedSymbol(expr); + } + return false; + } + } + function getBaseTypesIfUnrelated(leftType, rightType, isRelated) { + var effectiveLeft = leftType; + var effectiveRight = rightType; + var leftBase = getBaseTypeOfLiteralType(leftType); + var rightBase = getBaseTypeOfLiteralType(rightType); + if (!isRelated(leftBase, rightBase)) { + effectiveLeft = leftBase; + effectiveRight = rightBase; + } + return [effectiveLeft, effectiveRight]; + } + function checkYieldExpression(node) { + addLazyDiagnostic(checkYieldExpressionGrammar); + var func = ts.getContainingFunction(node); + if (!func) + return anyType; + var functionFlags = ts.getFunctionFlags(func); + if (!(functionFlags & 1 /* FunctionFlags.Generator */)) { + // If the user's code is syntactically correct, the func should always have a star. After all, we are in a yield context. + return anyType; + } + var isAsync = (functionFlags & 2 /* FunctionFlags.Async */) !== 0; + if (node.asteriskToken) { + // Async generator functions prior to ESNext require the __await, __asyncDelegator, + // and __asyncValues helpers + if (isAsync && languageVersion < 99 /* ScriptTarget.ESNext */) { + checkExternalEmitHelpers(node, 26624 /* ExternalEmitHelpers.AsyncDelegatorIncludes */); + } + // Generator functions prior to ES2015 require the __values helper + if (!isAsync && languageVersion < 2 /* ScriptTarget.ES2015 */ && compilerOptions.downlevelIteration) { + checkExternalEmitHelpers(node, 256 /* ExternalEmitHelpers.Values */); + } + } + // There is no point in doing an assignability check if the function + // has no explicit return type because the return type is directly computed + // from the yield expressions. + var returnType = getReturnTypeFromAnnotation(func); + var iterationTypes = returnType && getIterationTypesOfGeneratorFunctionReturnType(returnType, isAsync); + var signatureYieldType = iterationTypes && iterationTypes.yieldType || anyType; + var signatureNextType = iterationTypes && iterationTypes.nextType || anyType; + var resolvedSignatureNextType = isAsync ? getAwaitedType(signatureNextType) || anyType : signatureNextType; + var yieldExpressionType = node.expression ? checkExpression(node.expression) : undefinedWideningType; + var yieldedType = getYieldedTypeOfYieldExpression(node, yieldExpressionType, resolvedSignatureNextType, isAsync); + if (returnType && yieldedType) { + checkTypeAssignableToAndOptionallyElaborate(yieldedType, signatureYieldType, node.expression || node, node.expression); + } + if (node.asteriskToken) { + var use = isAsync ? 19 /* IterationUse.AsyncYieldStar */ : 17 /* IterationUse.YieldStar */; + return getIterationTypeOfIterable(use, 1 /* IterationTypeKind.Return */, yieldExpressionType, node.expression) + || anyType; + } + else if (returnType) { + return getIterationTypeOfGeneratorFunctionReturnType(2 /* IterationTypeKind.Next */, returnType, isAsync) + || anyType; + } + var type = getContextualIterationType(2 /* IterationTypeKind.Next */, func); + if (!type) { + type = anyType; + addLazyDiagnostic(function () { + if (noImplicitAny && !ts.expressionResultIsUnused(node)) { + var contextualType = getContextualType(node, /*contextFlags*/ undefined); + if (!contextualType || isTypeAny(contextualType)) { + error(node, ts.Diagnostics.yield_expression_implicitly_results_in_an_any_type_because_its_containing_generator_lacks_a_return_type_annotation); + } + } + }); + } + return type; + function checkYieldExpressionGrammar() { + if (!(node.flags & 8192 /* NodeFlags.YieldContext */)) { + grammarErrorOnFirstToken(node, ts.Diagnostics.A_yield_expression_is_only_allowed_in_a_generator_body); + } + if (isInParameterInitializerBeforeContainingFunction(node)) { + error(node, ts.Diagnostics.yield_expressions_cannot_be_used_in_a_parameter_initializer); + } + } + } + function checkConditionalExpression(node, checkMode) { + var type = checkTruthinessExpression(node.condition); + checkTestingKnownTruthyCallableOrAwaitableType(node.condition, type, node.whenTrue); + var type1 = checkExpression(node.whenTrue, checkMode); + var type2 = checkExpression(node.whenFalse, checkMode); + return getUnionType([type1, type2], 2 /* UnionReduction.Subtype */); + } + function isTemplateLiteralContext(node) { + var parent = node.parent; + return ts.isParenthesizedExpression(parent) && isTemplateLiteralContext(parent) || + ts.isElementAccessExpression(parent) && parent.argumentExpression === node; + } + function checkTemplateExpression(node) { + var texts = [node.head.text]; + var types = []; + for (var _i = 0, _a = node.templateSpans; _i < _a.length; _i++) { + var span = _a[_i]; + var type = checkExpression(span.expression); + if (maybeTypeOfKindConsideringBaseConstraint(type, 12288 /* TypeFlags.ESSymbolLike */)) { + error(span.expression, ts.Diagnostics.Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_in_String); + } + texts.push(span.literal.text); + types.push(isTypeAssignableTo(type, templateConstraintType) ? type : stringType); + } + return isConstContext(node) || isTemplateLiteralContext(node) || someType(getContextualType(node, /*contextFlags*/ undefined) || unknownType, isTemplateLiteralContextualType) ? getTemplateLiteralType(texts, types) : stringType; + } + function isTemplateLiteralContextualType(type) { + return !!(type.flags & (128 /* TypeFlags.StringLiteral */ | 134217728 /* TypeFlags.TemplateLiteral */) || + type.flags & 58982400 /* TypeFlags.InstantiableNonPrimitive */ && maybeTypeOfKind(getBaseConstraintOfType(type) || unknownType, 402653316 /* TypeFlags.StringLike */)); + } + function getContextNode(node) { + if (node.kind === 289 /* SyntaxKind.JsxAttributes */ && !ts.isJsxSelfClosingElement(node.parent)) { + return node.parent.parent; // Needs to be the root JsxElement, so it encompasses the attributes _and_ the children (which are essentially part of the attributes) + } + return node; + } + function checkExpressionWithContextualType(node, contextualType, inferenceContext, checkMode) { + var context = getContextNode(node); + var saveContextualType = context.contextualType; + var saveInferenceContext = context.inferenceContext; + try { + context.contextualType = contextualType; + context.inferenceContext = inferenceContext; + var type = checkExpression(node, checkMode | 1 /* CheckMode.Contextual */ | (inferenceContext ? 2 /* CheckMode.Inferential */ : 0)); + // In CheckMode.Inferential we collect intra-expression inference sites to process before fixing any type + // parameters. This information is no longer needed after the call to checkExpression. + if (inferenceContext && inferenceContext.intraExpressionInferenceSites) { + inferenceContext.intraExpressionInferenceSites = undefined; + } + // We strip literal freshness when an appropriate contextual type is present such that contextually typed + // literals always preserve their literal types (otherwise they might widen during type inference). An alternative + // here would be to not mark contextually typed literals as fresh in the first place. + var result = maybeTypeOfKind(type, 2944 /* TypeFlags.Literal */) && isLiteralOfContextualType(type, instantiateContextualType(contextualType, node, /*contextFlags*/ undefined)) ? + getRegularTypeOfLiteralType(type) : type; + return result; + } + finally { + // In the event our operation is canceled or some other exception occurs, reset the contextual type + // so that we do not accidentally hold onto an instance of the checker, as a Type created in the services layer + // may hold onto the checker that created it. + context.contextualType = saveContextualType; + context.inferenceContext = saveInferenceContext; + } + } + function checkExpressionCached(node, checkMode) { + if (checkMode && checkMode !== 0 /* CheckMode.Normal */) { + return checkExpression(node, checkMode); + } + var links = getNodeLinks(node); + if (!links.resolvedType) { + // When computing a type that we're going to cache, we need to ignore any ongoing control flow + // analysis because variables may have transient types in indeterminable states. Moving flowLoopStart + // to the top of the stack ensures all transient types are computed from a known point. + var saveFlowLoopStart = flowLoopStart; + var saveFlowTypeCache = flowTypeCache; + flowLoopStart = flowLoopCount; + flowTypeCache = undefined; + links.resolvedType = checkExpression(node, checkMode); + flowTypeCache = saveFlowTypeCache; + flowLoopStart = saveFlowLoopStart; + } + return links.resolvedType; + } + function isTypeAssertion(node) { + node = ts.skipParentheses(node, /*excludeJSDocTypeAssertions*/ true); + return node.kind === 213 /* SyntaxKind.TypeAssertionExpression */ || + node.kind === 231 /* SyntaxKind.AsExpression */ || + ts.isJSDocTypeAssertion(node); + } + function checkDeclarationInitializer(declaration, checkMode, contextualType) { + var initializer = ts.getEffectiveInitializer(declaration); + var type = getQuickTypeOfExpression(initializer) || + (contextualType ? + checkExpressionWithContextualType(initializer, contextualType, /*inferenceContext*/ undefined, checkMode || 0 /* CheckMode.Normal */) + : checkExpressionCached(initializer, checkMode)); + return ts.isParameter(declaration) && declaration.name.kind === 204 /* SyntaxKind.ArrayBindingPattern */ && + isTupleType(type) && !type.target.hasRestElement && getTypeReferenceArity(type) < declaration.name.elements.length ? + padTupleType(type, declaration.name) : type; + } + function padTupleType(type, pattern) { + var patternElements = pattern.elements; + var elementTypes = getTypeArguments(type).slice(); + var elementFlags = type.target.elementFlags.slice(); + for (var i = getTypeReferenceArity(type); i < patternElements.length; i++) { + var e = patternElements[i]; + if (i < patternElements.length - 1 || !(e.kind === 205 /* SyntaxKind.BindingElement */ && e.dotDotDotToken)) { + elementTypes.push(!ts.isOmittedExpression(e) && hasDefaultValue(e) ? getTypeFromBindingElement(e, /*includePatternInType*/ false, /*reportErrors*/ false) : anyType); + elementFlags.push(2 /* ElementFlags.Optional */); + if (!ts.isOmittedExpression(e) && !hasDefaultValue(e)) { + reportImplicitAny(e, anyType); + } + } + } + return createTupleType(elementTypes, elementFlags, type.target.readonly); + } + function widenTypeInferredFromInitializer(declaration, type) { + var widened = ts.getCombinedNodeFlags(declaration) & 2 /* NodeFlags.Const */ || ts.isDeclarationReadonly(declaration) ? type : getWidenedLiteralType(type); + if (ts.isInJSFile(declaration)) { + if (isEmptyLiteralType(widened)) { + reportImplicitAny(declaration, anyType); + return anyType; + } + else if (isEmptyArrayLiteralType(widened)) { + reportImplicitAny(declaration, anyArrayType); + return anyArrayType; + } + } + return widened; + } + function isLiteralOfContextualType(candidateType, contextualType) { + if (contextualType) { + if (contextualType.flags & 3145728 /* TypeFlags.UnionOrIntersection */) { + var types = contextualType.types; + return ts.some(types, function (t) { return isLiteralOfContextualType(candidateType, t); }); + } + if (contextualType.flags & 58982400 /* TypeFlags.InstantiableNonPrimitive */) { + // If the contextual type is a type variable constrained to a primitive type, consider + // this a literal context for literals of that primitive type. For example, given a + // type parameter 'T extends string', infer string literal types for T. + var constraint = getBaseConstraintOfType(contextualType) || unknownType; + return maybeTypeOfKind(constraint, 4 /* TypeFlags.String */) && maybeTypeOfKind(candidateType, 128 /* TypeFlags.StringLiteral */) || + maybeTypeOfKind(constraint, 8 /* TypeFlags.Number */) && maybeTypeOfKind(candidateType, 256 /* TypeFlags.NumberLiteral */) || + maybeTypeOfKind(constraint, 64 /* TypeFlags.BigInt */) && maybeTypeOfKind(candidateType, 2048 /* TypeFlags.BigIntLiteral */) || + maybeTypeOfKind(constraint, 4096 /* TypeFlags.ESSymbol */) && maybeTypeOfKind(candidateType, 8192 /* TypeFlags.UniqueESSymbol */) || + isLiteralOfContextualType(candidateType, constraint); + } + // If the contextual type is a literal of a particular primitive type, we consider this a + // literal context for all literals of that primitive type. + return !!(contextualType.flags & (128 /* TypeFlags.StringLiteral */ | 4194304 /* TypeFlags.Index */ | 134217728 /* TypeFlags.TemplateLiteral */ | 268435456 /* TypeFlags.StringMapping */) && maybeTypeOfKind(candidateType, 128 /* TypeFlags.StringLiteral */) || + contextualType.flags & 256 /* TypeFlags.NumberLiteral */ && maybeTypeOfKind(candidateType, 256 /* TypeFlags.NumberLiteral */) || + contextualType.flags & 2048 /* TypeFlags.BigIntLiteral */ && maybeTypeOfKind(candidateType, 2048 /* TypeFlags.BigIntLiteral */) || + contextualType.flags & 512 /* TypeFlags.BooleanLiteral */ && maybeTypeOfKind(candidateType, 512 /* TypeFlags.BooleanLiteral */) || + contextualType.flags & 8192 /* TypeFlags.UniqueESSymbol */ && maybeTypeOfKind(candidateType, 8192 /* TypeFlags.UniqueESSymbol */)); + } + return false; + } + function isConstContext(node) { + var parent = node.parent; + return ts.isAssertionExpression(parent) && ts.isConstTypeReference(parent.type) || + ts.isJSDocTypeAssertion(parent) && ts.isConstTypeReference(ts.getJSDocTypeAssertionType(parent)) || + (ts.isParenthesizedExpression(parent) || ts.isArrayLiteralExpression(parent) || ts.isSpreadElement(parent)) && isConstContext(parent) || + (ts.isPropertyAssignment(parent) || ts.isShorthandPropertyAssignment(parent) || ts.isTemplateSpan(parent)) && isConstContext(parent.parent); + } + function checkExpressionForMutableLocation(node, checkMode, contextualType, forceTuple) { + var type = checkExpression(node, checkMode, forceTuple); + return isConstContext(node) || ts.isCommonJsExportedExpression(node) ? getRegularTypeOfLiteralType(type) : + isTypeAssertion(node) ? type : + getWidenedLiteralLikeTypeForContextualType(type, instantiateContextualType(arguments.length === 2 ? getContextualType(node, /*contextFlags*/ undefined) : contextualType, node, /*contextFlags*/ undefined)); + } + function checkPropertyAssignment(node, checkMode) { + // Do not use hasDynamicName here, because that returns false for well known symbols. + // We want to perform checkComputedPropertyName for all computed properties, including + // well known symbols. + if (node.name.kind === 164 /* SyntaxKind.ComputedPropertyName */) { + checkComputedPropertyName(node.name); + } + return checkExpressionForMutableLocation(node.initializer, checkMode); + } + function checkObjectLiteralMethod(node, checkMode) { + // Grammar checking + checkGrammarMethod(node); + // Do not use hasDynamicName here, because that returns false for well known symbols. + // We want to perform checkComputedPropertyName for all computed properties, including + // well known symbols. + if (node.name.kind === 164 /* SyntaxKind.ComputedPropertyName */) { + checkComputedPropertyName(node.name); + } + var uninstantiatedType = checkFunctionExpressionOrObjectLiteralMethod(node, checkMode); + return instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, checkMode); + } + function instantiateTypeWithSingleGenericCallSignature(node, type, checkMode) { + if (checkMode && checkMode & (2 /* CheckMode.Inferential */ | 8 /* CheckMode.SkipGenericFunctions */)) { + var callSignature = getSingleSignature(type, 0 /* SignatureKind.Call */, /*allowMembers*/ true); + var constructSignature = getSingleSignature(type, 1 /* SignatureKind.Construct */, /*allowMembers*/ true); + var signature = callSignature || constructSignature; + if (signature && signature.typeParameters) { + var contextualType = getApparentTypeOfContextualType(node, 2 /* ContextFlags.NoConstraints */); + if (contextualType) { + var contextualSignature = getSingleSignature(getNonNullableType(contextualType), callSignature ? 0 /* SignatureKind.Call */ : 1 /* SignatureKind.Construct */, /*allowMembers*/ false); + if (contextualSignature && !contextualSignature.typeParameters) { + if (checkMode & 8 /* CheckMode.SkipGenericFunctions */) { + skippedGenericFunction(node, checkMode); + return anyFunctionType; + } + var context = getInferenceContext(node); + // We have an expression that is an argument of a generic function for which we are performing + // type argument inference. The expression is of a function type with a single generic call + // signature and a contextual function type with a single non-generic call signature. Now check + // if the outer function returns a function type with a single non-generic call signature and + // if some of the outer function type parameters have no inferences so far. If so, we can + // potentially add inferred type parameters to the outer function return type. + var returnType = context.signature && getReturnTypeOfSignature(context.signature); + var returnSignature = returnType && getSingleCallOrConstructSignature(returnType); + if (returnSignature && !returnSignature.typeParameters && !ts.every(context.inferences, hasInferenceCandidates)) { + // Instantiate the signature with its own type parameters as type arguments, possibly + // renaming the type parameters to ensure they have unique names. + var uniqueTypeParameters = getUniqueTypeParameters(context, signature.typeParameters); + var instantiatedSignature = getSignatureInstantiationWithoutFillingInTypeArguments(signature, uniqueTypeParameters); + // Infer from the parameters of the instantiated signature to the parameters of the + // contextual signature starting with an empty set of inference candidates. + var inferences_3 = ts.map(context.inferences, function (info) { return createInferenceInfo(info.typeParameter); }); + applyToParameterTypes(instantiatedSignature, contextualSignature, function (source, target) { + inferTypes(inferences_3, source, target, /*priority*/ 0, /*contravariant*/ true); + }); + if (ts.some(inferences_3, hasInferenceCandidates)) { + // We have inference candidates, indicating that one or more type parameters are referenced + // in the parameter types of the contextual signature. Now also infer from the return type. + applyToReturnTypes(instantiatedSignature, contextualSignature, function (source, target) { + inferTypes(inferences_3, source, target); + }); + // If the type parameters for which we produced candidates do not have any inferences yet, + // we adopt the new inference candidates and add the type parameters of the expression type + // to the set of inferred type parameters for the outer function return type. + if (!hasOverlappingInferences(context.inferences, inferences_3)) { + mergeInferences(context.inferences, inferences_3); + context.inferredTypeParameters = ts.concatenate(context.inferredTypeParameters, uniqueTypeParameters); + return getOrCreateTypeFromSignature(instantiatedSignature); + } + } + } + return getOrCreateTypeFromSignature(instantiateSignatureInContextOf(signature, contextualSignature, context)); + } + } + } + } + return type; + } + function skippedGenericFunction(node, checkMode) { + if (checkMode & 2 /* CheckMode.Inferential */) { + // We have skipped a generic function during inferential typing. Obtain the inference context and + // indicate this has occurred such that we know a second pass of inference is be needed. + var context = getInferenceContext(node); + context.flags |= 4 /* InferenceFlags.SkippedGenericFunction */; + } + } + function hasInferenceCandidates(info) { + return !!(info.candidates || info.contraCandidates); + } + function hasInferenceCandidatesOrDefault(info) { + return !!(info.candidates || info.contraCandidates || hasTypeParameterDefault(info.typeParameter)); + } + function hasOverlappingInferences(a, b) { + for (var i = 0; i < a.length; i++) { + if (hasInferenceCandidates(a[i]) && hasInferenceCandidates(b[i])) { + return true; + } + } + return false; + } + function mergeInferences(target, source) { + for (var i = 0; i < target.length; i++) { + if (!hasInferenceCandidates(target[i]) && hasInferenceCandidates(source[i])) { + target[i] = source[i]; + } + } + } + function getUniqueTypeParameters(context, typeParameters) { + var result = []; + var oldTypeParameters; + var newTypeParameters; + for (var _i = 0, typeParameters_3 = typeParameters; _i < typeParameters_3.length; _i++) { + var tp = typeParameters_3[_i]; + var name = tp.symbol.escapedName; + if (hasTypeParameterByName(context.inferredTypeParameters, name) || hasTypeParameterByName(result, name)) { + var newName = getUniqueTypeParameterName(ts.concatenate(context.inferredTypeParameters, result), name); + var symbol = createSymbol(262144 /* SymbolFlags.TypeParameter */, newName); + var newTypeParameter = createTypeParameter(symbol); + newTypeParameter.target = tp; + oldTypeParameters = ts.append(oldTypeParameters, tp); + newTypeParameters = ts.append(newTypeParameters, newTypeParameter); + result.push(newTypeParameter); + } + else { + result.push(tp); + } + } + if (newTypeParameters) { + var mapper = createTypeMapper(oldTypeParameters, newTypeParameters); + for (var _a = 0, newTypeParameters_1 = newTypeParameters; _a < newTypeParameters_1.length; _a++) { + var tp = newTypeParameters_1[_a]; + tp.mapper = mapper; + } + } + return result; + } + function hasTypeParameterByName(typeParameters, name) { + return ts.some(typeParameters, function (tp) { return tp.symbol.escapedName === name; }); + } + function getUniqueTypeParameterName(typeParameters, baseName) { + var len = baseName.length; + while (len > 1 && baseName.charCodeAt(len - 1) >= 48 /* CharacterCodes._0 */ && baseName.charCodeAt(len - 1) <= 57 /* CharacterCodes._9 */) + len--; + var s = baseName.slice(0, len); + for (var index = 1; true; index++) { + var augmentedName = s + index; + if (!hasTypeParameterByName(typeParameters, augmentedName)) { + return augmentedName; + } + } + } + function getReturnTypeOfSingleNonGenericCallSignature(funcType) { + var signature = getSingleCallSignature(funcType); + if (signature && !signature.typeParameters) { + return getReturnTypeOfSignature(signature); + } + } + function getReturnTypeOfSingleNonGenericSignatureOfCallChain(expr) { + var funcType = checkExpression(expr.expression); + var nonOptionalType = getOptionalExpressionType(funcType, expr.expression); + var returnType = getReturnTypeOfSingleNonGenericCallSignature(funcType); + return returnType && propagateOptionalTypeMarker(returnType, expr, nonOptionalType !== funcType); + } + /** + * Returns the type of an expression. Unlike checkExpression, this function is simply concerned + * with computing the type and may not fully check all contained sub-expressions for errors. + */ + function getTypeOfExpression(node) { + // Don't bother caching types that require no flow analysis and are quick to compute. + var quickType = getQuickTypeOfExpression(node); + if (quickType) { + return quickType; + } + // If a type has been cached for the node, return it. + if (node.flags & 134217728 /* NodeFlags.TypeCached */ && flowTypeCache) { + var cachedType = flowTypeCache[getNodeId(node)]; + if (cachedType) { + return cachedType; + } + } + var startInvocationCount = flowInvocationCount; + var type = checkExpression(node); + // If control flow analysis was required to determine the type, it is worth caching. + if (flowInvocationCount !== startInvocationCount) { + var cache = flowTypeCache || (flowTypeCache = []); + cache[getNodeId(node)] = type; + ts.setNodeFlags(node, node.flags | 134217728 /* NodeFlags.TypeCached */); + } + return type; + } + function getQuickTypeOfExpression(node) { + var expr = ts.skipParentheses(node, /*excludeJSDocTypeAssertions*/ true); + if (ts.isJSDocTypeAssertion(expr)) { + var type = ts.getJSDocTypeAssertionType(expr); + if (!ts.isConstTypeReference(type)) { + return getTypeFromTypeNode(type); + } + } + expr = ts.skipParentheses(node); + // Optimize for the common case of a call to a function with a single non-generic call + // signature where we can just fetch the return type without checking the arguments. + if (ts.isCallExpression(expr) && expr.expression.kind !== 106 /* SyntaxKind.SuperKeyword */ && !ts.isRequireCall(expr, /*checkArgumentIsStringLiteralLike*/ true) && !isSymbolOrSymbolForCall(expr)) { + var type = ts.isCallChain(expr) ? getReturnTypeOfSingleNonGenericSignatureOfCallChain(expr) : + getReturnTypeOfSingleNonGenericCallSignature(checkNonNullExpression(expr.expression)); + if (type) { + return type; + } + } + else if (ts.isAssertionExpression(expr) && !ts.isConstTypeReference(expr.type)) { + return getTypeFromTypeNode(expr.type); + } + else if (node.kind === 8 /* SyntaxKind.NumericLiteral */ || node.kind === 10 /* SyntaxKind.StringLiteral */ || + node.kind === 110 /* SyntaxKind.TrueKeyword */ || node.kind === 95 /* SyntaxKind.FalseKeyword */) { + return checkExpression(node); + } + return undefined; + } + /** + * Returns the type of an expression. Unlike checkExpression, this function is simply concerned + * with computing the type and may not fully check all contained sub-expressions for errors. + * It is intended for uses where you know there is no contextual type, + * and requesting the contextual type might cause a circularity or other bad behaviour. + * It sets the contextual type of the node to any before calling getTypeOfExpression. + */ + function getContextFreeTypeOfExpression(node) { + var links = getNodeLinks(node); + if (links.contextFreeType) { + return links.contextFreeType; + } + var saveContextualType = node.contextualType; + node.contextualType = anyType; + try { + var type = links.contextFreeType = checkExpression(node, 4 /* CheckMode.SkipContextSensitive */); + return type; + } + finally { + // In the event our operation is canceled or some other exception occurs, reset the contextual type + // so that we do not accidentally hold onto an instance of the checker, as a Type created in the services layer + // may hold onto the checker that created it. + node.contextualType = saveContextualType; + } + } + function checkExpression(node, checkMode, forceTuple) { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("check" /* tracing.Phase.Check */, "checkExpression", { kind: node.kind, pos: node.pos, end: node.end, path: node.tracingPath }); + var saveCurrentNode = currentNode; + currentNode = node; + instantiationCount = 0; + var uninstantiatedType = checkExpressionWorker(node, checkMode, forceTuple); + var type = instantiateTypeWithSingleGenericCallSignature(node, uninstantiatedType, checkMode); + if (isConstEnumObjectType(type)) { + checkConstEnumAccess(node, type); + } + currentNode = saveCurrentNode; + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + return type; + } + function checkConstEnumAccess(node, type) { + // enum object type for const enums are only permitted in: + // - 'left' in property access + // - 'object' in indexed access + // - target in rhs of import statement + var ok = (node.parent.kind === 208 /* SyntaxKind.PropertyAccessExpression */ && node.parent.expression === node) || + (node.parent.kind === 209 /* SyntaxKind.ElementAccessExpression */ && node.parent.expression === node) || + ((node.kind === 79 /* SyntaxKind.Identifier */ || node.kind === 163 /* SyntaxKind.QualifiedName */) && isInRightSideOfImportOrExportAssignment(node) || + (node.parent.kind === 183 /* SyntaxKind.TypeQuery */ && node.parent.exprName === node)) || + (node.parent.kind === 278 /* SyntaxKind.ExportSpecifier */); // We allow reexporting const enums + if (!ok) { + error(node, ts.Diagnostics.const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment_or_type_query); + } + if (compilerOptions.isolatedModules) { + ts.Debug.assert(!!(type.symbol.flags & 128 /* SymbolFlags.ConstEnum */)); + var constEnumDeclaration = type.symbol.valueDeclaration; + if (constEnumDeclaration.flags & 16777216 /* NodeFlags.Ambient */) { + error(node, ts.Diagnostics.Cannot_access_ambient_const_enums_when_the_isolatedModules_flag_is_provided); + } + } + } + function checkParenthesizedExpression(node, checkMode) { + if (ts.hasJSDocNodes(node) && ts.isJSDocTypeAssertion(node)) { + var type = ts.getJSDocTypeAssertionType(node); + return checkAssertionWorker(type, type, node.expression, checkMode); + } + return checkExpression(node.expression, checkMode); + } + function checkExpressionWorker(node, checkMode, forceTuple) { + var kind = node.kind; + if (cancellationToken) { + // Only bother checking on a few construct kinds. We don't want to be excessively + // hitting the cancellation token on every node we check. + switch (kind) { + case 228 /* SyntaxKind.ClassExpression */: + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + cancellationToken.throwIfCancellationRequested(); + } + } + switch (kind) { + case 79 /* SyntaxKind.Identifier */: + return checkIdentifier(node, checkMode); + case 80 /* SyntaxKind.PrivateIdentifier */: + return checkPrivateIdentifierExpression(node); + case 108 /* SyntaxKind.ThisKeyword */: + return checkThisExpression(node); + case 106 /* SyntaxKind.SuperKeyword */: + return checkSuperExpression(node); + case 104 /* SyntaxKind.NullKeyword */: + return nullWideningType; + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + case 10 /* SyntaxKind.StringLiteral */: + return getFreshTypeOfLiteralType(getStringLiteralType(node.text)); + case 8 /* SyntaxKind.NumericLiteral */: + checkGrammarNumericLiteral(node); + return getFreshTypeOfLiteralType(getNumberLiteralType(+node.text)); + case 9 /* SyntaxKind.BigIntLiteral */: + checkGrammarBigIntLiteral(node); + return getFreshTypeOfLiteralType(getBigIntLiteralType({ + negative: false, + base10Value: ts.parsePseudoBigInt(node.text) + })); + case 110 /* SyntaxKind.TrueKeyword */: + return trueType; + case 95 /* SyntaxKind.FalseKeyword */: + return falseType; + case 225 /* SyntaxKind.TemplateExpression */: + return checkTemplateExpression(node); + case 13 /* SyntaxKind.RegularExpressionLiteral */: + return globalRegExpType; + case 206 /* SyntaxKind.ArrayLiteralExpression */: + return checkArrayLiteral(node, checkMode, forceTuple); + case 207 /* SyntaxKind.ObjectLiteralExpression */: + return checkObjectLiteral(node, checkMode); + case 208 /* SyntaxKind.PropertyAccessExpression */: + return checkPropertyAccessExpression(node, checkMode); + case 163 /* SyntaxKind.QualifiedName */: + return checkQualifiedName(node, checkMode); + case 209 /* SyntaxKind.ElementAccessExpression */: + return checkIndexedAccess(node, checkMode); + case 210 /* SyntaxKind.CallExpression */: + if (node.expression.kind === 100 /* SyntaxKind.ImportKeyword */) { + return checkImportCallExpression(node); + } + // falls through + case 211 /* SyntaxKind.NewExpression */: + return checkCallExpression(node, checkMode); + case 212 /* SyntaxKind.TaggedTemplateExpression */: + return checkTaggedTemplateExpression(node); + case 214 /* SyntaxKind.ParenthesizedExpression */: + return checkParenthesizedExpression(node, checkMode); + case 228 /* SyntaxKind.ClassExpression */: + return checkClassExpression(node); + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + return checkFunctionExpressionOrObjectLiteralMethod(node, checkMode); + case 218 /* SyntaxKind.TypeOfExpression */: + return checkTypeOfExpression(node); + case 213 /* SyntaxKind.TypeAssertionExpression */: + case 231 /* SyntaxKind.AsExpression */: + return checkAssertion(node); + case 232 /* SyntaxKind.NonNullExpression */: + return checkNonNullAssertion(node); + case 230 /* SyntaxKind.ExpressionWithTypeArguments */: + return checkExpressionWithTypeArguments(node); + case 235 /* SyntaxKind.SatisfiesExpression */: + return checkSatisfiesExpression(node); + case 233 /* SyntaxKind.MetaProperty */: + return checkMetaProperty(node); + case 217 /* SyntaxKind.DeleteExpression */: + return checkDeleteExpression(node); + case 219 /* SyntaxKind.VoidExpression */: + return checkVoidExpression(node); + case 220 /* SyntaxKind.AwaitExpression */: + return checkAwaitExpression(node); + case 221 /* SyntaxKind.PrefixUnaryExpression */: + return checkPrefixUnaryExpression(node); + case 222 /* SyntaxKind.PostfixUnaryExpression */: + return checkPostfixUnaryExpression(node); + case 223 /* SyntaxKind.BinaryExpression */: + return checkBinaryExpression(node, checkMode); + case 224 /* SyntaxKind.ConditionalExpression */: + return checkConditionalExpression(node, checkMode); + case 227 /* SyntaxKind.SpreadElement */: + return checkSpreadExpression(node, checkMode); + case 229 /* SyntaxKind.OmittedExpression */: + return undefinedWideningType; + case 226 /* SyntaxKind.YieldExpression */: + return checkYieldExpression(node); + case 234 /* SyntaxKind.SyntheticExpression */: + return checkSyntheticExpression(node); + case 291 /* SyntaxKind.JsxExpression */: + return checkJsxExpression(node, checkMode); + case 281 /* SyntaxKind.JsxElement */: + return checkJsxElement(node, checkMode); + case 282 /* SyntaxKind.JsxSelfClosingElement */: + return checkJsxSelfClosingElement(node, checkMode); + case 285 /* SyntaxKind.JsxFragment */: + return checkJsxFragment(node); + case 289 /* SyntaxKind.JsxAttributes */: + return checkJsxAttributes(node, checkMode); + case 283 /* SyntaxKind.JsxOpeningElement */: + ts.Debug.fail("Shouldn't ever directly check a JsxOpeningElement"); + } + return errorType; + } + // DECLARATION AND STATEMENT TYPE CHECKING + function checkTypeParameter(node) { + // Grammar Checking + checkGrammarModifiers(node); + if (node.expression) { + grammarErrorOnFirstToken(node.expression, ts.Diagnostics.Type_expected); + } + checkSourceElement(node.constraint); + checkSourceElement(node.default); + var typeParameter = getDeclaredTypeOfTypeParameter(getSymbolOfNode(node)); + // Resolve base constraint to reveal circularity errors + getBaseConstraintOfType(typeParameter); + if (!hasNonCircularTypeParameterDefault(typeParameter)) { + error(node.default, ts.Diagnostics.Type_parameter_0_has_a_circular_default, typeToString(typeParameter)); + } + var constraintType = getConstraintOfTypeParameter(typeParameter); + var defaultType = getDefaultFromTypeParameter(typeParameter); + if (constraintType && defaultType) { + checkTypeAssignableTo(defaultType, getTypeWithThisArgument(instantiateType(constraintType, makeUnaryTypeMapper(typeParameter, defaultType)), defaultType), node.default, ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1); + } + checkNodeDeferred(node); + addLazyDiagnostic(function () { return checkTypeNameIsReserved(node.name, ts.Diagnostics.Type_parameter_name_cannot_be_0); }); + } + function checkTypeParameterDeferred(node) { + if (ts.isInterfaceDeclaration(node.parent) || ts.isClassLike(node.parent) || ts.isTypeAliasDeclaration(node.parent)) { + var typeParameter = getDeclaredTypeOfTypeParameter(getSymbolOfNode(node)); + var modifiers = getVarianceModifiers(typeParameter); + if (modifiers) { + var symbol = getSymbolOfNode(node.parent); + if (ts.isTypeAliasDeclaration(node.parent) && !(ts.getObjectFlags(getDeclaredTypeOfSymbol(symbol)) & (16 /* ObjectFlags.Anonymous */ | 32 /* ObjectFlags.Mapped */))) { + error(node, ts.Diagnostics.Variance_annotations_are_only_supported_in_type_aliases_for_object_function_constructor_and_mapped_types); + } + else if (modifiers === 32768 /* ModifierFlags.In */ || modifiers === 65536 /* ModifierFlags.Out */) { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("checkTypes" /* tracing.Phase.CheckTypes */, "checkTypeParameterDeferred", { parent: getTypeId(getDeclaredTypeOfSymbol(symbol)), id: getTypeId(typeParameter) }); + var source = createMarkerType(symbol, typeParameter, modifiers === 65536 /* ModifierFlags.Out */ ? markerSubTypeForCheck : markerSuperTypeForCheck); + var target = createMarkerType(symbol, typeParameter, modifiers === 65536 /* ModifierFlags.Out */ ? markerSuperTypeForCheck : markerSubTypeForCheck); + var saveVarianceTypeParameter = typeParameter; + varianceTypeParameter = typeParameter; + checkTypeAssignableTo(source, target, node, ts.Diagnostics.Type_0_is_not_assignable_to_type_1_as_implied_by_variance_annotation); + varianceTypeParameter = saveVarianceTypeParameter; + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + } + } + } + } + function checkParameter(node) { + // Grammar checking + // It is a SyntaxError if the Identifier "eval" or the Identifier "arguments" occurs as the + // Identifier in a PropertySetParameterList of a PropertyAssignment that is contained in strict code + // or if its FunctionBody is strict code(11.1.5). + checkGrammarDecoratorsAndModifiers(node); + checkVariableLikeDeclaration(node); + var func = ts.getContainingFunction(node); + if (ts.hasSyntacticModifier(node, 16476 /* ModifierFlags.ParameterPropertyModifier */)) { + if (!(func.kind === 173 /* SyntaxKind.Constructor */ && ts.nodeIsPresent(func.body))) { + error(node, ts.Diagnostics.A_parameter_property_is_only_allowed_in_a_constructor_implementation); + } + if (func.kind === 173 /* SyntaxKind.Constructor */ && ts.isIdentifier(node.name) && node.name.escapedText === "constructor") { + error(node.name, ts.Diagnostics.constructor_cannot_be_used_as_a_parameter_property_name); + } + } + if ((node.questionToken || isJSDocOptionalParameter(node)) && ts.isBindingPattern(node.name) && func.body) { + error(node, ts.Diagnostics.A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature); + } + if (node.name && ts.isIdentifier(node.name) && (node.name.escapedText === "this" || node.name.escapedText === "new")) { + if (func.parameters.indexOf(node) !== 0) { + error(node, ts.Diagnostics.A_0_parameter_must_be_the_first_parameter, node.name.escapedText); + } + if (func.kind === 173 /* SyntaxKind.Constructor */ || func.kind === 177 /* SyntaxKind.ConstructSignature */ || func.kind === 182 /* SyntaxKind.ConstructorType */) { + error(node, ts.Diagnostics.A_constructor_cannot_have_a_this_parameter); + } + if (func.kind === 216 /* SyntaxKind.ArrowFunction */) { + error(node, ts.Diagnostics.An_arrow_function_cannot_have_a_this_parameter); + } + if (func.kind === 174 /* SyntaxKind.GetAccessor */ || func.kind === 175 /* SyntaxKind.SetAccessor */) { + error(node, ts.Diagnostics.get_and_set_accessors_cannot_declare_this_parameters); + } + } + // Only check rest parameter type if it's not a binding pattern. Since binding patterns are + // not allowed in a rest parameter, we already have an error from checkGrammarParameterList. + if (node.dotDotDotToken && !ts.isBindingPattern(node.name) && !isTypeAssignableTo(getReducedType(getTypeOfSymbol(node.symbol)), anyReadonlyArrayType)) { + error(node, ts.Diagnostics.A_rest_parameter_must_be_of_an_array_type); + } + } + function checkTypePredicate(node) { + var parent = getTypePredicateParent(node); + if (!parent) { + // The parent must not be valid. + error(node, ts.Diagnostics.A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods); + return; + } + var signature = getSignatureFromDeclaration(parent); + var typePredicate = getTypePredicateOfSignature(signature); + if (!typePredicate) { + return; + } + checkSourceElement(node.type); + var parameterName = node.parameterName; + if (typePredicate.kind === 0 /* TypePredicateKind.This */ || typePredicate.kind === 2 /* TypePredicateKind.AssertsThis */) { + getTypeFromThisTypeNode(parameterName); + } + else { + if (typePredicate.parameterIndex >= 0) { + if (signatureHasRestParameter(signature) && typePredicate.parameterIndex === signature.parameters.length - 1) { + error(parameterName, ts.Diagnostics.A_type_predicate_cannot_reference_a_rest_parameter); + } + else { + if (typePredicate.type) { + var leadingError = function () { return ts.chainDiagnosticMessages(/*details*/ undefined, ts.Diagnostics.A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type); }; + checkTypeAssignableTo(typePredicate.type, getTypeOfSymbol(signature.parameters[typePredicate.parameterIndex]), node.type, + /*headMessage*/ undefined, leadingError); + } + } + } + else if (parameterName) { + var hasReportedError = false; + for (var _i = 0, _a = parent.parameters; _i < _a.length; _i++) { + var name = _a[_i].name; + if (ts.isBindingPattern(name) && + checkIfTypePredicateVariableIsDeclaredInBindingPattern(name, parameterName, typePredicate.parameterName)) { + hasReportedError = true; + break; + } + } + if (!hasReportedError) { + error(node.parameterName, ts.Diagnostics.Cannot_find_parameter_0, typePredicate.parameterName); + } + } + } + } + function getTypePredicateParent(node) { + switch (node.parent.kind) { + case 216 /* SyntaxKind.ArrowFunction */: + case 176 /* SyntaxKind.CallSignature */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 181 /* SyntaxKind.FunctionType */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + var parent = node.parent; + if (node === parent.type) { + return parent; + } + } + } + function checkIfTypePredicateVariableIsDeclaredInBindingPattern(pattern, predicateVariableNode, predicateVariableName) { + for (var _i = 0, _a = pattern.elements; _i < _a.length; _i++) { + var element = _a[_i]; + if (ts.isOmittedExpression(element)) { + continue; + } + var name = element.name; + if (name.kind === 79 /* SyntaxKind.Identifier */ && name.escapedText === predicateVariableName) { + error(predicateVariableNode, ts.Diagnostics.A_type_predicate_cannot_reference_element_0_in_a_binding_pattern, predicateVariableName); + return true; + } + else if (name.kind === 204 /* SyntaxKind.ArrayBindingPattern */ || name.kind === 203 /* SyntaxKind.ObjectBindingPattern */) { + if (checkIfTypePredicateVariableIsDeclaredInBindingPattern(name, predicateVariableNode, predicateVariableName)) { + return true; + } + } + } + } + function checkSignatureDeclaration(node) { + // Grammar checking + if (node.kind === 178 /* SyntaxKind.IndexSignature */) { + checkGrammarIndexSignature(node); + } + // TODO (yuisu): Remove this check in else-if when SyntaxKind.Construct is moved and ambient context is handled + else if (node.kind === 181 /* SyntaxKind.FunctionType */ || node.kind === 259 /* SyntaxKind.FunctionDeclaration */ || node.kind === 182 /* SyntaxKind.ConstructorType */ || + node.kind === 176 /* SyntaxKind.CallSignature */ || node.kind === 173 /* SyntaxKind.Constructor */ || + node.kind === 177 /* SyntaxKind.ConstructSignature */) { + checkGrammarFunctionLikeDeclaration(node); + } + var functionFlags = ts.getFunctionFlags(node); + if (!(functionFlags & 4 /* FunctionFlags.Invalid */)) { + // Async generators prior to ESNext require the __await and __asyncGenerator helpers + if ((functionFlags & 3 /* FunctionFlags.AsyncGenerator */) === 3 /* FunctionFlags.AsyncGenerator */ && languageVersion < 99 /* ScriptTarget.ESNext */) { + checkExternalEmitHelpers(node, 6144 /* ExternalEmitHelpers.AsyncGeneratorIncludes */); + } + // Async functions prior to ES2017 require the __awaiter helper + if ((functionFlags & 3 /* FunctionFlags.AsyncGenerator */) === 2 /* FunctionFlags.Async */ && languageVersion < 4 /* ScriptTarget.ES2017 */) { + checkExternalEmitHelpers(node, 64 /* ExternalEmitHelpers.Awaiter */); + } + // Generator functions, Async functions, and Async Generator functions prior to + // ES2015 require the __generator helper + if ((functionFlags & 3 /* FunctionFlags.AsyncGenerator */) !== 0 /* FunctionFlags.Normal */ && languageVersion < 2 /* ScriptTarget.ES2015 */) { + checkExternalEmitHelpers(node, 128 /* ExternalEmitHelpers.Generator */); + } + } + checkTypeParameters(ts.getEffectiveTypeParameterDeclarations(node)); + checkUnmatchedJSDocParameters(node); + ts.forEach(node.parameters, checkParameter); + // TODO(rbuckton): Should we start checking JSDoc types? + if (node.type) { + checkSourceElement(node.type); + } + addLazyDiagnostic(checkSignatureDeclarationDiagnostics); + function checkSignatureDeclarationDiagnostics() { + checkCollisionWithArgumentsInGeneratedCode(node); + var returnTypeNode = ts.getEffectiveReturnTypeNode(node); + if (noImplicitAny && !returnTypeNode) { + switch (node.kind) { + case 177 /* SyntaxKind.ConstructSignature */: + error(node, ts.Diagnostics.Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type); + break; + case 176 /* SyntaxKind.CallSignature */: + error(node, ts.Diagnostics.Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type); + break; + } + } + if (returnTypeNode) { + var functionFlags_1 = ts.getFunctionFlags(node); + if ((functionFlags_1 & (4 /* FunctionFlags.Invalid */ | 1 /* FunctionFlags.Generator */)) === 1 /* FunctionFlags.Generator */) { + var returnType = getTypeFromTypeNode(returnTypeNode); + if (returnType === voidType) { + error(returnTypeNode, ts.Diagnostics.A_generator_cannot_have_a_void_type_annotation); + } + else { + // Naively, one could check that Generator is assignable to the return type annotation. + // However, that would not catch the error in the following case. + // + // interface BadGenerator extends Iterable, Iterator { } + // function* g(): BadGenerator { } // Iterable and Iterator have different types! + // + var generatorYieldType = getIterationTypeOfGeneratorFunctionReturnType(0 /* IterationTypeKind.Yield */, returnType, (functionFlags_1 & 2 /* FunctionFlags.Async */) !== 0) || anyType; + var generatorReturnType = getIterationTypeOfGeneratorFunctionReturnType(1 /* IterationTypeKind.Return */, returnType, (functionFlags_1 & 2 /* FunctionFlags.Async */) !== 0) || generatorYieldType; + var generatorNextType = getIterationTypeOfGeneratorFunctionReturnType(2 /* IterationTypeKind.Next */, returnType, (functionFlags_1 & 2 /* FunctionFlags.Async */) !== 0) || unknownType; + var generatorInstantiation = createGeneratorReturnType(generatorYieldType, generatorReturnType, generatorNextType, !!(functionFlags_1 & 2 /* FunctionFlags.Async */)); + checkTypeAssignableTo(generatorInstantiation, returnType, returnTypeNode); + } + } + else if ((functionFlags_1 & 3 /* FunctionFlags.AsyncGenerator */) === 2 /* FunctionFlags.Async */) { + checkAsyncFunctionReturnType(node, returnTypeNode); + } + } + if (node.kind !== 178 /* SyntaxKind.IndexSignature */ && node.kind !== 320 /* SyntaxKind.JSDocFunctionType */) { + registerForUnusedIdentifiersCheck(node); + } + } + } + function checkClassForDuplicateDeclarations(node) { + var instanceNames = new ts.Map(); + var staticNames = new ts.Map(); + // instance and static private identifiers share the same scope + var privateIdentifiers = new ts.Map(); + for (var _i = 0, _a = node.members; _i < _a.length; _i++) { + var member = _a[_i]; + if (member.kind === 173 /* SyntaxKind.Constructor */) { + for (var _b = 0, _c = member.parameters; _b < _c.length; _b++) { + var param = _c[_b]; + if (ts.isParameterPropertyDeclaration(param, member) && !ts.isBindingPattern(param.name)) { + addName(instanceNames, param.name, param.name.escapedText, 3 /* DeclarationMeaning.GetOrSetAccessor */); + } + } + } + else { + var isStaticMember = ts.isStatic(member); + var name = member.name; + if (!name) { + continue; + } + var isPrivate = ts.isPrivateIdentifier(name); + var privateStaticFlags = isPrivate && isStaticMember ? 16 /* DeclarationMeaning.PrivateStatic */ : 0; + var names = isPrivate ? privateIdentifiers : + isStaticMember ? staticNames : + instanceNames; + var memberName = name && ts.getPropertyNameForPropertyNameNode(name); + if (memberName) { + switch (member.kind) { + case 174 /* SyntaxKind.GetAccessor */: + addName(names, name, memberName, 1 /* DeclarationMeaning.GetAccessor */ | privateStaticFlags); + break; + case 175 /* SyntaxKind.SetAccessor */: + addName(names, name, memberName, 2 /* DeclarationMeaning.SetAccessor */ | privateStaticFlags); + break; + case 169 /* SyntaxKind.PropertyDeclaration */: + addName(names, name, memberName, 3 /* DeclarationMeaning.GetOrSetAccessor */ | privateStaticFlags); + break; + case 171 /* SyntaxKind.MethodDeclaration */: + addName(names, name, memberName, 8 /* DeclarationMeaning.Method */ | privateStaticFlags); + break; + } + } + } + } + function addName(names, location, name, meaning) { + var prev = names.get(name); + if (prev) { + // For private identifiers, do not allow mixing of static and instance members with the same name + if ((prev & 16 /* DeclarationMeaning.PrivateStatic */) !== (meaning & 16 /* DeclarationMeaning.PrivateStatic */)) { + error(location, ts.Diagnostics.Duplicate_identifier_0_Static_and_instance_elements_cannot_share_the_same_private_name, ts.getTextOfNode(location)); + } + else { + var prevIsMethod = !!(prev & 8 /* DeclarationMeaning.Method */); + var isMethod = !!(meaning & 8 /* DeclarationMeaning.Method */); + if (prevIsMethod || isMethod) { + if (prevIsMethod !== isMethod) { + error(location, ts.Diagnostics.Duplicate_identifier_0, ts.getTextOfNode(location)); + } + // If this is a method/method duplication is might be an overload, so this will be handled when overloads are considered + } + else if (prev & meaning & ~16 /* DeclarationMeaning.PrivateStatic */) { + error(location, ts.Diagnostics.Duplicate_identifier_0, ts.getTextOfNode(location)); + } + else { + names.set(name, prev | meaning); + } + } + } + else { + names.set(name, meaning); + } + } + } + /** + * Static members being set on a constructor function may conflict with built-in properties + * of Function. Esp. in ECMAScript 5 there are non-configurable and non-writable + * built-in properties. This check issues a transpile error when a class has a static + * member with the same name as a non-writable built-in property. + * + * @see http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.3 + * @see http://www.ecma-international.org/ecma-262/5.1/#sec-15.3.5 + * @see http://www.ecma-international.org/ecma-262/6.0/#sec-properties-of-the-function-constructor + * @see http://www.ecma-international.org/ecma-262/6.0/#sec-function-instances + */ + function checkClassForStaticPropertyNameConflicts(node) { + for (var _i = 0, _a = node.members; _i < _a.length; _i++) { + var member = _a[_i]; + var memberNameNode = member.name; + var isStaticMember = ts.isStatic(member); + if (isStaticMember && memberNameNode) { + var memberName = ts.getPropertyNameForPropertyNameNode(memberNameNode); + switch (memberName) { + case "name": + case "length": + case "caller": + case "arguments": + case "prototype": + var message = ts.Diagnostics.Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1; + var className = getNameOfSymbolAsWritten(getSymbolOfNode(node)); + error(memberNameNode, message, memberName, className); + break; + } + } + } + } + function checkObjectTypeForDuplicateDeclarations(node) { + var names = new ts.Map(); + for (var _i = 0, _a = node.members; _i < _a.length; _i++) { + var member = _a[_i]; + if (member.kind === 168 /* SyntaxKind.PropertySignature */) { + var memberName = void 0; + var name = member.name; + switch (name.kind) { + case 10 /* SyntaxKind.StringLiteral */: + case 8 /* SyntaxKind.NumericLiteral */: + memberName = name.text; + break; + case 79 /* SyntaxKind.Identifier */: + memberName = ts.idText(name); + break; + default: + continue; + } + if (names.get(memberName)) { + error(ts.getNameOfDeclaration(member.symbol.valueDeclaration), ts.Diagnostics.Duplicate_identifier_0, memberName); + error(member.name, ts.Diagnostics.Duplicate_identifier_0, memberName); + } + else { + names.set(memberName, true); + } + } + } + } + function checkTypeForDuplicateIndexSignatures(node) { + if (node.kind === 261 /* SyntaxKind.InterfaceDeclaration */) { + var nodeSymbol = getSymbolOfNode(node); + // in case of merging interface declaration it is possible that we'll enter this check procedure several times for every declaration + // to prevent this run check only for the first declaration of a given kind + if (nodeSymbol.declarations && nodeSymbol.declarations.length > 0 && nodeSymbol.declarations[0] !== node) { + return; + } + } + // TypeScript 1.0 spec (April 2014) + // 3.7.4: An object type can contain at most one string index signature and one numeric index signature. + // 8.5: A class declaration can have at most one string index member declaration and one numeric index member declaration + var indexSymbol = getIndexSymbol(getSymbolOfNode(node)); + if (indexSymbol === null || indexSymbol === void 0 ? void 0 : indexSymbol.declarations) { + var indexSignatureMap_1 = new ts.Map(); + var _loop_29 = function (declaration) { + if (declaration.parameters.length === 1 && declaration.parameters[0].type) { + forEachType(getTypeFromTypeNode(declaration.parameters[0].type), function (type) { + var entry = indexSignatureMap_1.get(getTypeId(type)); + if (entry) { + entry.declarations.push(declaration); + } + else { + indexSignatureMap_1.set(getTypeId(type), { type: type, declarations: [declaration] }); + } + }); + } + }; + for (var _i = 0, _a = indexSymbol.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + _loop_29(declaration); + } + indexSignatureMap_1.forEach(function (entry) { + if (entry.declarations.length > 1) { + for (var _i = 0, _a = entry.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + error(declaration, ts.Diagnostics.Duplicate_index_signature_for_type_0, typeToString(entry.type)); + } + } + }); + } + } + function checkPropertyDeclaration(node) { + // Grammar checking + if (!checkGrammarDecoratorsAndModifiers(node) && !checkGrammarProperty(node)) + checkGrammarComputedPropertyName(node.name); + checkVariableLikeDeclaration(node); + setNodeLinksForPrivateIdentifierScope(node); + // property signatures already report "initializer not allowed in ambient context" elsewhere + if (ts.hasSyntacticModifier(node, 256 /* ModifierFlags.Abstract */) && node.kind === 169 /* SyntaxKind.PropertyDeclaration */ && node.initializer) { + error(node, ts.Diagnostics.Property_0_cannot_have_an_initializer_because_it_is_marked_abstract, ts.declarationNameToString(node.name)); + } + } + function checkPropertySignature(node) { + if (ts.isPrivateIdentifier(node.name)) { + error(node, ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies); + } + return checkPropertyDeclaration(node); + } + function checkMethodDeclaration(node) { + // Grammar checking + if (!checkGrammarMethod(node)) + checkGrammarComputedPropertyName(node.name); + if (ts.isMethodDeclaration(node) && node.asteriskToken && ts.isIdentifier(node.name) && ts.idText(node.name) === "constructor") { + error(node.name, ts.Diagnostics.Class_constructor_may_not_be_a_generator); + } + // Grammar checking for modifiers is done inside the function checkGrammarFunctionLikeDeclaration + checkFunctionOrMethodDeclaration(node); + // method signatures already report "implementation not allowed in ambient context" elsewhere + if (ts.hasSyntacticModifier(node, 256 /* ModifierFlags.Abstract */) && node.kind === 171 /* SyntaxKind.MethodDeclaration */ && node.body) { + error(node, ts.Diagnostics.Method_0_cannot_have_an_implementation_because_it_is_marked_abstract, ts.declarationNameToString(node.name)); + } + // Private named methods are only allowed in class declarations + if (ts.isPrivateIdentifier(node.name) && !ts.getContainingClass(node)) { + error(node, ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies); + } + setNodeLinksForPrivateIdentifierScope(node); + } + function setNodeLinksForPrivateIdentifierScope(node) { + if (ts.isPrivateIdentifier(node.name) && languageVersion < 99 /* ScriptTarget.ESNext */) { + for (var lexicalScope = ts.getEnclosingBlockScopeContainer(node); !!lexicalScope; lexicalScope = ts.getEnclosingBlockScopeContainer(lexicalScope)) { + getNodeLinks(lexicalScope).flags |= 67108864 /* NodeCheckFlags.ContainsClassWithPrivateIdentifiers */; + } + // If this is a private element in a class expression inside the body of a loop, + // then we must use a block-scoped binding to store the additional variables required + // to transform private elements. + if (ts.isClassExpression(node.parent)) { + var enclosingIterationStatement = getEnclosingIterationStatement(node.parent); + if (enclosingIterationStatement) { + getNodeLinks(node.name).flags |= 524288 /* NodeCheckFlags.BlockScopedBindingInLoop */; + getNodeLinks(enclosingIterationStatement).flags |= 65536 /* NodeCheckFlags.LoopWithCapturedBlockScopedBinding */; + } + } + } + } + function checkClassStaticBlockDeclaration(node) { + checkGrammarDecoratorsAndModifiers(node); + ts.forEachChild(node, checkSourceElement); + } + function checkConstructorDeclaration(node) { + // Grammar check on signature of constructor and modifier of the constructor is done in checkSignatureDeclaration function. + checkSignatureDeclaration(node); + // Grammar check for checking only related to constructorDeclaration + if (!checkGrammarConstructorTypeParameters(node)) + checkGrammarConstructorTypeAnnotation(node); + checkSourceElement(node.body); + var symbol = getSymbolOfNode(node); + var firstDeclaration = ts.getDeclarationOfKind(symbol, node.kind); + // Only type check the symbol once + if (node === firstDeclaration) { + checkFunctionOrConstructorSymbol(symbol); + } + // exit early in the case of signature - super checks are not relevant to them + if (ts.nodeIsMissing(node.body)) { + return; + } + addLazyDiagnostic(checkConstructorDeclarationDiagnostics); + return; + function isInstancePropertyWithInitializerOrPrivateIdentifierProperty(n) { + if (ts.isPrivateIdentifierClassElementDeclaration(n)) { + return true; + } + return n.kind === 169 /* SyntaxKind.PropertyDeclaration */ && + !ts.isStatic(n) && + !!n.initializer; + } + function checkConstructorDeclarationDiagnostics() { + // TS 1.0 spec (April 2014): 8.3.2 + // Constructors of classes with no extends clause may not contain super calls, whereas + // constructors of derived classes must contain at least one super call somewhere in their function body. + var containingClassDecl = node.parent; + if (ts.getClassExtendsHeritageElement(containingClassDecl)) { + captureLexicalThis(node.parent, containingClassDecl); + var classExtendsNull = classDeclarationExtendsNull(containingClassDecl); + var superCall = findFirstSuperCall(node.body); + if (superCall) { + if (classExtendsNull) { + error(superCall, ts.Diagnostics.A_constructor_cannot_contain_a_super_call_when_its_class_extends_null); + } + // A super call must be root-level in a constructor if both of the following are true: + // - The containing class is a derived class. + // - The constructor declares parameter properties + // or the containing class declares instance member variables with initializers. + var superCallShouldBeRootLevel = (ts.getEmitScriptTarget(compilerOptions) !== 99 /* ScriptTarget.ESNext */ || !useDefineForClassFields) && + (ts.some(node.parent.members, isInstancePropertyWithInitializerOrPrivateIdentifierProperty) || + ts.some(node.parameters, function (p) { return ts.hasSyntacticModifier(p, 16476 /* ModifierFlags.ParameterPropertyModifier */); })); + if (superCallShouldBeRootLevel) { + // Until we have better flow analysis, it is an error to place the super call within any kind of block or conditional + // See GH #8277 + if (!superCallIsRootLevelInConstructor(superCall, node.body)) { + error(superCall, ts.Diagnostics.A_super_call_must_be_a_root_level_statement_within_a_constructor_of_a_derived_class_that_contains_initialized_properties_parameter_properties_or_private_identifiers); + } + // Skip past any prologue directives to check statements for referring to 'super' or 'this' before a super call + else { + var superCallStatement = void 0; + for (var _i = 0, _a = node.body.statements; _i < _a.length; _i++) { + var statement = _a[_i]; + if (ts.isExpressionStatement(statement) && ts.isSuperCall(ts.skipOuterExpressions(statement.expression))) { + superCallStatement = statement; + break; + } + if (nodeImmediatelyReferencesSuperOrThis(statement)) { + break; + } + } + // Until we have better flow analysis, it is an error to place the super call within any kind of block or conditional + // See GH #8277 + if (superCallStatement === undefined) { + error(node, ts.Diagnostics.A_super_call_must_be_the_first_statement_in_the_constructor_to_refer_to_super_or_this_when_a_derived_class_contains_initialized_properties_parameter_properties_or_private_identifiers); + } + } + } + } + else if (!classExtendsNull) { + error(node, ts.Diagnostics.Constructors_for_derived_classes_must_contain_a_super_call); + } + } + } + } + function superCallIsRootLevelInConstructor(superCall, body) { + var superCallParent = ts.walkUpParenthesizedExpressions(superCall.parent); + return ts.isExpressionStatement(superCallParent) && superCallParent.parent === body; + } + function nodeImmediatelyReferencesSuperOrThis(node) { + if (node.kind === 106 /* SyntaxKind.SuperKeyword */ || node.kind === 108 /* SyntaxKind.ThisKeyword */) { + return true; + } + if (ts.isThisContainerOrFunctionBlock(node)) { + return false; + } + return !!ts.forEachChild(node, nodeImmediatelyReferencesSuperOrThis); + } + function checkAccessorDeclaration(node) { + if (ts.isIdentifier(node.name) && ts.idText(node.name) === "constructor") { + error(node.name, ts.Diagnostics.Class_constructor_may_not_be_an_accessor); + } + addLazyDiagnostic(checkAccessorDeclarationDiagnostics); + checkSourceElement(node.body); + setNodeLinksForPrivateIdentifierScope(node); + function checkAccessorDeclarationDiagnostics() { + // Grammar checking accessors + if (!checkGrammarFunctionLikeDeclaration(node) && !checkGrammarAccessor(node)) + checkGrammarComputedPropertyName(node.name); + checkDecorators(node); + checkSignatureDeclaration(node); + if (node.kind === 174 /* SyntaxKind.GetAccessor */) { + if (!(node.flags & 16777216 /* NodeFlags.Ambient */) && ts.nodeIsPresent(node.body) && (node.flags & 256 /* NodeFlags.HasImplicitReturn */)) { + if (!(node.flags & 512 /* NodeFlags.HasExplicitReturn */)) { + error(node.name, ts.Diagnostics.A_get_accessor_must_return_a_value); + } + } + } + // Do not use hasDynamicName here, because that returns false for well known symbols. + // We want to perform checkComputedPropertyName for all computed properties, including + // well known symbols. + if (node.name.kind === 164 /* SyntaxKind.ComputedPropertyName */) { + checkComputedPropertyName(node.name); + } + if (hasBindableName(node)) { + // TypeScript 1.0 spec (April 2014): 8.4.3 + // Accessors for the same member name must specify the same accessibility. + var symbol = getSymbolOfNode(node); + var getter = ts.getDeclarationOfKind(symbol, 174 /* SyntaxKind.GetAccessor */); + var setter = ts.getDeclarationOfKind(symbol, 175 /* SyntaxKind.SetAccessor */); + if (getter && setter && !(getNodeCheckFlags(getter) & 1 /* NodeCheckFlags.TypeChecked */)) { + getNodeLinks(getter).flags |= 1 /* NodeCheckFlags.TypeChecked */; + var getterFlags = ts.getEffectiveModifierFlags(getter); + var setterFlags = ts.getEffectiveModifierFlags(setter); + if ((getterFlags & 256 /* ModifierFlags.Abstract */) !== (setterFlags & 256 /* ModifierFlags.Abstract */)) { + error(getter.name, ts.Diagnostics.Accessors_must_both_be_abstract_or_non_abstract); + error(setter.name, ts.Diagnostics.Accessors_must_both_be_abstract_or_non_abstract); + } + if (((getterFlags & 16 /* ModifierFlags.Protected */) && !(setterFlags & (16 /* ModifierFlags.Protected */ | 8 /* ModifierFlags.Private */))) || + ((getterFlags & 8 /* ModifierFlags.Private */) && !(setterFlags & 8 /* ModifierFlags.Private */))) { + error(getter.name, ts.Diagnostics.A_get_accessor_must_be_at_least_as_accessible_as_the_setter); + error(setter.name, ts.Diagnostics.A_get_accessor_must_be_at_least_as_accessible_as_the_setter); + } + var getterType = getAnnotatedAccessorType(getter); + var setterType = getAnnotatedAccessorType(setter); + if (getterType && setterType) { + checkTypeAssignableTo(getterType, setterType, getter, ts.Diagnostics.The_return_type_of_a_get_accessor_must_be_assignable_to_its_set_accessor_type); + } + } + } + var returnType = getTypeOfAccessors(getSymbolOfNode(node)); + if (node.kind === 174 /* SyntaxKind.GetAccessor */) { + checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, returnType); + } + } + } + function checkMissingDeclaration(node) { + checkDecorators(node); + } + function getEffectiveTypeArgumentAtIndex(node, typeParameters, index) { + if (node.typeArguments && index < node.typeArguments.length) { + return getTypeFromTypeNode(node.typeArguments[index]); + } + return getEffectiveTypeArguments(node, typeParameters)[index]; + } + function getEffectiveTypeArguments(node, typeParameters) { + return fillMissingTypeArguments(ts.map(node.typeArguments, getTypeFromTypeNode), typeParameters, getMinTypeArgumentCount(typeParameters), ts.isInJSFile(node)); + } + function checkTypeArgumentConstraints(node, typeParameters) { + var typeArguments; + var mapper; + var result = true; + for (var i = 0; i < typeParameters.length; i++) { + var constraint = getConstraintOfTypeParameter(typeParameters[i]); + if (constraint) { + if (!typeArguments) { + typeArguments = getEffectiveTypeArguments(node, typeParameters); + mapper = createTypeMapper(typeParameters, typeArguments); + } + result = result && checkTypeAssignableTo(typeArguments[i], instantiateType(constraint, mapper), node.typeArguments[i], ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1); + } + } + return result; + } + function getTypeParametersForTypeReference(node) { + var type = getTypeFromTypeReference(node); + if (!isErrorType(type)) { + var symbol = getNodeLinks(node).resolvedSymbol; + if (symbol) { + return symbol.flags & 524288 /* SymbolFlags.TypeAlias */ && getSymbolLinks(symbol).typeParameters || + (ts.getObjectFlags(type) & 4 /* ObjectFlags.Reference */ ? type.target.localTypeParameters : undefined); + } + } + return undefined; + } + function checkTypeReferenceNode(node) { + checkGrammarTypeArguments(node, node.typeArguments); + if (node.kind === 180 /* SyntaxKind.TypeReference */ && node.typeName.jsdocDotPos !== undefined && !ts.isInJSFile(node) && !ts.isInJSDoc(node)) { + grammarErrorAtPos(node, node.typeName.jsdocDotPos, 1, ts.Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments); + } + ts.forEach(node.typeArguments, checkSourceElement); + var type = getTypeFromTypeReference(node); + if (!isErrorType(type)) { + if (node.typeArguments) { + addLazyDiagnostic(function () { + var typeParameters = getTypeParametersForTypeReference(node); + if (typeParameters) { + checkTypeArgumentConstraints(node, typeParameters); + } + }); + } + var symbol = getNodeLinks(node).resolvedSymbol; + if (symbol) { + if (ts.some(symbol.declarations, function (d) { return ts.isTypeDeclaration(d) && !!(d.flags & 268435456 /* NodeFlags.Deprecated */); })) { + addDeprecatedSuggestion(getDeprecatedSuggestionNode(node), symbol.declarations, symbol.escapedName); + } + if (type.flags & 32 /* TypeFlags.Enum */ && symbol.flags & 8 /* SymbolFlags.EnumMember */) { + error(node, ts.Diagnostics.Enum_type_0_has_members_with_initializers_that_are_not_literals, typeToString(type)); + } + } + } + } + function getTypeArgumentConstraint(node) { + var typeReferenceNode = ts.tryCast(node.parent, ts.isTypeReferenceType); + if (!typeReferenceNode) + return undefined; + var typeParameters = getTypeParametersForTypeReference(typeReferenceNode); + if (!typeParameters) + return undefined; + var constraint = getConstraintOfTypeParameter(typeParameters[typeReferenceNode.typeArguments.indexOf(node)]); + return constraint && instantiateType(constraint, createTypeMapper(typeParameters, getEffectiveTypeArguments(typeReferenceNode, typeParameters))); + } + function checkTypeQuery(node) { + getTypeFromTypeQueryNode(node); + } + function checkTypeLiteral(node) { + ts.forEach(node.members, checkSourceElement); + addLazyDiagnostic(checkTypeLiteralDiagnostics); + function checkTypeLiteralDiagnostics() { + var type = getTypeFromTypeLiteralOrFunctionOrConstructorTypeNode(node); + checkIndexConstraints(type, type.symbol); + checkTypeForDuplicateIndexSignatures(node); + checkObjectTypeForDuplicateDeclarations(node); + } + } + function checkArrayType(node) { + checkSourceElement(node.elementType); + } + function checkTupleType(node) { + var elementTypes = node.elements; + var seenOptionalElement = false; + var seenRestElement = false; + var hasNamedElement = ts.some(elementTypes, ts.isNamedTupleMember); + for (var _i = 0, elementTypes_1 = elementTypes; _i < elementTypes_1.length; _i++) { + var e = elementTypes_1[_i]; + if (e.kind !== 199 /* SyntaxKind.NamedTupleMember */ && hasNamedElement) { + grammarErrorOnNode(e, ts.Diagnostics.Tuple_members_must_all_have_names_or_all_not_have_names); + break; + } + var flags = getTupleElementFlags(e); + if (flags & 8 /* ElementFlags.Variadic */) { + var type = getTypeFromTypeNode(e.type); + if (!isArrayLikeType(type)) { + error(e, ts.Diagnostics.A_rest_element_type_must_be_an_array_type); + break; + } + if (isArrayType(type) || isTupleType(type) && type.target.combinedFlags & 4 /* ElementFlags.Rest */) { + seenRestElement = true; + } + } + else if (flags & 4 /* ElementFlags.Rest */) { + if (seenRestElement) { + grammarErrorOnNode(e, ts.Diagnostics.A_rest_element_cannot_follow_another_rest_element); + break; + } + seenRestElement = true; + } + else if (flags & 2 /* ElementFlags.Optional */) { + if (seenRestElement) { + grammarErrorOnNode(e, ts.Diagnostics.An_optional_element_cannot_follow_a_rest_element); + break; + } + seenOptionalElement = true; + } + else if (seenOptionalElement) { + grammarErrorOnNode(e, ts.Diagnostics.A_required_element_cannot_follow_an_optional_element); + break; + } + } + ts.forEach(node.elements, checkSourceElement); + getTypeFromTypeNode(node); + } + function checkUnionOrIntersectionType(node) { + ts.forEach(node.types, checkSourceElement); + getTypeFromTypeNode(node); + } + function checkIndexedAccessIndexType(type, accessNode) { + if (!(type.flags & 8388608 /* TypeFlags.IndexedAccess */)) { + return type; + } + // Check if the index type is assignable to 'keyof T' for the object type. + var objectType = type.objectType; + var indexType = type.indexType; + if (isTypeAssignableTo(indexType, getIndexType(objectType, /*stringsOnly*/ false))) { + if (accessNode.kind === 209 /* SyntaxKind.ElementAccessExpression */ && ts.isAssignmentTarget(accessNode) && + ts.getObjectFlags(objectType) & 32 /* ObjectFlags.Mapped */ && getMappedTypeModifiers(objectType) & 1 /* MappedTypeModifiers.IncludeReadonly */) { + error(accessNode, ts.Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(objectType)); + } + return type; + } + // Check if we're indexing with a numeric type and if either object or index types + // is a generic type with a constraint that has a numeric index signature. + var apparentObjectType = getApparentType(objectType); + if (getIndexInfoOfType(apparentObjectType, numberType) && isTypeAssignableToKind(indexType, 296 /* TypeFlags.NumberLike */)) { + return type; + } + if (isGenericObjectType(objectType)) { + var propertyName_1 = getPropertyNameFromIndex(indexType, accessNode); + if (propertyName_1) { + var propertySymbol = forEachType(apparentObjectType, function (t) { return getPropertyOfType(t, propertyName_1); }); + if (propertySymbol && ts.getDeclarationModifierFlagsFromSymbol(propertySymbol) & 24 /* ModifierFlags.NonPublicAccessibilityModifier */) { + error(accessNode, ts.Diagnostics.Private_or_protected_member_0_cannot_be_accessed_on_a_type_parameter, ts.unescapeLeadingUnderscores(propertyName_1)); + return errorType; + } + } + } + error(accessNode, ts.Diagnostics.Type_0_cannot_be_used_to_index_type_1, typeToString(indexType), typeToString(objectType)); + return errorType; + } + function checkIndexedAccessType(node) { + checkSourceElement(node.objectType); + checkSourceElement(node.indexType); + checkIndexedAccessIndexType(getTypeFromIndexedAccessTypeNode(node), node); + } + function checkMappedType(node) { + checkGrammarMappedType(node); + checkSourceElement(node.typeParameter); + checkSourceElement(node.nameType); + checkSourceElement(node.type); + if (!node.type) { + reportImplicitAny(node, anyType); + } + var type = getTypeFromMappedTypeNode(node); + var nameType = getNameTypeFromMappedType(type); + if (nameType) { + checkTypeAssignableTo(nameType, keyofConstraintType, node.nameType); + } + else { + var constraintType = getConstraintTypeFromMappedType(type); + checkTypeAssignableTo(constraintType, keyofConstraintType, ts.getEffectiveConstraintOfTypeParameter(node.typeParameter)); + } + } + function checkGrammarMappedType(node) { + var _a; + if ((_a = node.members) === null || _a === void 0 ? void 0 : _a.length) { + return grammarErrorOnNode(node.members[0], ts.Diagnostics.A_mapped_type_may_not_declare_properties_or_methods); + } + } + function checkThisType(node) { + getTypeFromThisTypeNode(node); + } + function checkTypeOperator(node) { + checkGrammarTypeOperatorNode(node); + checkSourceElement(node.type); + } + function checkConditionalType(node) { + ts.forEachChild(node, checkSourceElement); + } + function checkInferType(node) { + if (!ts.findAncestor(node, function (n) { return n.parent && n.parent.kind === 191 /* SyntaxKind.ConditionalType */ && n.parent.extendsType === n; })) { + grammarErrorOnNode(node, ts.Diagnostics.infer_declarations_are_only_permitted_in_the_extends_clause_of_a_conditional_type); + } + checkSourceElement(node.typeParameter); + var symbol = getSymbolOfNode(node.typeParameter); + if (symbol.declarations && symbol.declarations.length > 1) { + var links = getSymbolLinks(symbol); + if (!links.typeParametersChecked) { + links.typeParametersChecked = true; + var typeParameter = getDeclaredTypeOfTypeParameter(symbol); + var declarations = ts.getDeclarationsOfKind(symbol, 165 /* SyntaxKind.TypeParameter */); + if (!areTypeParametersIdentical(declarations, [typeParameter], function (decl) { return [decl]; })) { + // Report an error on every conflicting declaration. + var name = symbolToString(symbol); + for (var _i = 0, declarations_4 = declarations; _i < declarations_4.length; _i++) { + var declaration = declarations_4[_i]; + error(declaration.name, ts.Diagnostics.All_declarations_of_0_must_have_identical_constraints, name); + } + } + } + } + registerForUnusedIdentifiersCheck(node); + } + function checkTemplateLiteralType(node) { + for (var _i = 0, _a = node.templateSpans; _i < _a.length; _i++) { + var span = _a[_i]; + checkSourceElement(span.type); + var type = getTypeFromTypeNode(span.type); + checkTypeAssignableTo(type, templateConstraintType, span.type); + } + getTypeFromTypeNode(node); + } + function checkImportType(node) { + checkSourceElement(node.argument); + if (node.assertions) { + var override = ts.getResolutionModeOverrideForClause(node.assertions.assertClause, grammarErrorOnNode); + if (override) { + if (!ts.isNightly()) { + grammarErrorOnNode(node.assertions.assertClause, ts.Diagnostics.resolution_mode_assertions_are_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next); + } + if (ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.Node16 && ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.NodeNext) { + grammarErrorOnNode(node.assertions.assertClause, ts.Diagnostics.resolution_mode_assertions_are_only_supported_when_moduleResolution_is_node16_or_nodenext); + } + } + } + getTypeFromTypeNode(node); + } + function checkNamedTupleMember(node) { + if (node.dotDotDotToken && node.questionToken) { + grammarErrorOnNode(node, ts.Diagnostics.A_tuple_member_cannot_be_both_optional_and_rest); + } + if (node.type.kind === 187 /* SyntaxKind.OptionalType */) { + grammarErrorOnNode(node.type, ts.Diagnostics.A_labeled_tuple_element_is_declared_as_optional_with_a_question_mark_after_the_name_and_before_the_colon_rather_than_after_the_type); + } + if (node.type.kind === 188 /* SyntaxKind.RestType */) { + grammarErrorOnNode(node.type, ts.Diagnostics.A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type); + } + checkSourceElement(node.type); + getTypeFromTypeNode(node); + } + function isPrivateWithinAmbient(node) { + return (ts.hasEffectiveModifier(node, 8 /* ModifierFlags.Private */) || ts.isPrivateIdentifierClassElementDeclaration(node)) && !!(node.flags & 16777216 /* NodeFlags.Ambient */); + } + function getEffectiveDeclarationFlags(n, flagsToCheck) { + var flags = ts.getCombinedModifierFlags(n); + // children of classes (even ambient classes) should not be marked as ambient or export + // because those flags have no useful semantics there. + if (n.parent.kind !== 261 /* SyntaxKind.InterfaceDeclaration */ && + n.parent.kind !== 260 /* SyntaxKind.ClassDeclaration */ && + n.parent.kind !== 228 /* SyntaxKind.ClassExpression */ && + n.flags & 16777216 /* NodeFlags.Ambient */) { + if (!(flags & 2 /* ModifierFlags.Ambient */) && !(ts.isModuleBlock(n.parent) && ts.isModuleDeclaration(n.parent.parent) && ts.isGlobalScopeAugmentation(n.parent.parent))) { + // It is nested in an ambient context, which means it is automatically exported + flags |= 1 /* ModifierFlags.Export */; + } + flags |= 2 /* ModifierFlags.Ambient */; + } + return flags & flagsToCheck; + } + function checkFunctionOrConstructorSymbol(symbol) { + addLazyDiagnostic(function () { return checkFunctionOrConstructorSymbolWorker(symbol); }); + } + function checkFunctionOrConstructorSymbolWorker(symbol) { + function getCanonicalOverload(overloads, implementation) { + // Consider the canonical set of flags to be the flags of the bodyDeclaration or the first declaration + // Error on all deviations from this canonical set of flags + // The caveat is that if some overloads are defined in lib.d.ts, we don't want to + // report the errors on those. To achieve this, we will say that the implementation is + // the canonical signature only if it is in the same container as the first overload + var implementationSharesContainerWithFirstOverload = implementation !== undefined && implementation.parent === overloads[0].parent; + return implementationSharesContainerWithFirstOverload ? implementation : overloads[0]; + } + function checkFlagAgreementBetweenOverloads(overloads, implementation, flagsToCheck, someOverloadFlags, allOverloadFlags) { + // Error if some overloads have a flag that is not shared by all overloads. To find the + // deviations, we XOR someOverloadFlags with allOverloadFlags + var someButNotAllOverloadFlags = someOverloadFlags ^ allOverloadFlags; + if (someButNotAllOverloadFlags !== 0) { + var canonicalFlags_1 = getEffectiveDeclarationFlags(getCanonicalOverload(overloads, implementation), flagsToCheck); + ts.forEach(overloads, function (o) { + var deviation = getEffectiveDeclarationFlags(o, flagsToCheck) ^ canonicalFlags_1; + if (deviation & 1 /* ModifierFlags.Export */) { + error(ts.getNameOfDeclaration(o), ts.Diagnostics.Overload_signatures_must_all_be_exported_or_non_exported); + } + else if (deviation & 2 /* ModifierFlags.Ambient */) { + error(ts.getNameOfDeclaration(o), ts.Diagnostics.Overload_signatures_must_all_be_ambient_or_non_ambient); + } + else if (deviation & (8 /* ModifierFlags.Private */ | 16 /* ModifierFlags.Protected */)) { + error(ts.getNameOfDeclaration(o) || o, ts.Diagnostics.Overload_signatures_must_all_be_public_private_or_protected); + } + else if (deviation & 256 /* ModifierFlags.Abstract */) { + error(ts.getNameOfDeclaration(o), ts.Diagnostics.Overload_signatures_must_all_be_abstract_or_non_abstract); + } + }); + } + } + function checkQuestionTokenAgreementBetweenOverloads(overloads, implementation, someHaveQuestionToken, allHaveQuestionToken) { + if (someHaveQuestionToken !== allHaveQuestionToken) { + var canonicalHasQuestionToken_1 = ts.hasQuestionToken(getCanonicalOverload(overloads, implementation)); + ts.forEach(overloads, function (o) { + var deviation = ts.hasQuestionToken(o) !== canonicalHasQuestionToken_1; + if (deviation) { + error(ts.getNameOfDeclaration(o), ts.Diagnostics.Overload_signatures_must_all_be_optional_or_required); + } + }); + } + } + var flagsToCheck = 1 /* ModifierFlags.Export */ | 2 /* ModifierFlags.Ambient */ | 8 /* ModifierFlags.Private */ | 16 /* ModifierFlags.Protected */ | 256 /* ModifierFlags.Abstract */; + var someNodeFlags = 0 /* ModifierFlags.None */; + var allNodeFlags = flagsToCheck; + var someHaveQuestionToken = false; + var allHaveQuestionToken = true; + var hasOverloads = false; + var bodyDeclaration; + var lastSeenNonAmbientDeclaration; + var previousDeclaration; + var declarations = symbol.declarations; + var isConstructor = (symbol.flags & 16384 /* SymbolFlags.Constructor */) !== 0; + function reportImplementationExpectedError(node) { + if (node.name && ts.nodeIsMissing(node.name)) { + return; + } + var seen = false; + var subsequentNode = ts.forEachChild(node.parent, function (c) { + if (seen) { + return c; + } + else { + seen = c === node; + } + }); + // We may be here because of some extra nodes between overloads that could not be parsed into a valid node. + // In this case the subsequent node is not really consecutive (.pos !== node.end), and we must ignore it here. + if (subsequentNode && subsequentNode.pos === node.end) { + if (subsequentNode.kind === node.kind) { + var errorNode_1 = subsequentNode.name || subsequentNode; + var subsequentName = subsequentNode.name; + if (node.name && subsequentName && ( + // both are private identifiers + ts.isPrivateIdentifier(node.name) && ts.isPrivateIdentifier(subsequentName) && node.name.escapedText === subsequentName.escapedText || + // Both are computed property names + // TODO: GH#17345: These are methods, so handle computed name case. (`Always allowing computed property names is *not* the correct behavior!) + ts.isComputedPropertyName(node.name) && ts.isComputedPropertyName(subsequentName) || + // Both are literal property names that are the same. + ts.isPropertyNameLiteral(node.name) && ts.isPropertyNameLiteral(subsequentName) && + ts.getEscapedTextOfIdentifierOrLiteral(node.name) === ts.getEscapedTextOfIdentifierOrLiteral(subsequentName))) { + var reportError = (node.kind === 171 /* SyntaxKind.MethodDeclaration */ || node.kind === 170 /* SyntaxKind.MethodSignature */) && + ts.isStatic(node) !== ts.isStatic(subsequentNode); + // we can get here in two cases + // 1. mixed static and instance class members + // 2. something with the same name was defined before the set of overloads that prevents them from merging + // here we'll report error only for the first case since for second we should already report error in binder + if (reportError) { + var diagnostic = ts.isStatic(node) ? ts.Diagnostics.Function_overload_must_be_static : ts.Diagnostics.Function_overload_must_not_be_static; + error(errorNode_1, diagnostic); + } + return; + } + if (ts.nodeIsPresent(subsequentNode.body)) { + error(errorNode_1, ts.Diagnostics.Function_implementation_name_must_be_0, ts.declarationNameToString(node.name)); + return; + } + } + } + var errorNode = node.name || node; + if (isConstructor) { + error(errorNode, ts.Diagnostics.Constructor_implementation_is_missing); + } + else { + // Report different errors regarding non-consecutive blocks of declarations depending on whether + // the node in question is abstract. + if (ts.hasSyntacticModifier(node, 256 /* ModifierFlags.Abstract */)) { + error(errorNode, ts.Diagnostics.All_declarations_of_an_abstract_method_must_be_consecutive); + } + else { + error(errorNode, ts.Diagnostics.Function_implementation_is_missing_or_not_immediately_following_the_declaration); + } + } + } + var duplicateFunctionDeclaration = false; + var multipleConstructorImplementation = false; + var hasNonAmbientClass = false; + var functionDeclarations = []; + if (declarations) { + for (var _i = 0, declarations_5 = declarations; _i < declarations_5.length; _i++) { + var current = declarations_5[_i]; + var node = current; + var inAmbientContext = node.flags & 16777216 /* NodeFlags.Ambient */; + var inAmbientContextOrInterface = node.parent && (node.parent.kind === 261 /* SyntaxKind.InterfaceDeclaration */ || node.parent.kind === 184 /* SyntaxKind.TypeLiteral */) || inAmbientContext; + if (inAmbientContextOrInterface) { + // check if declarations are consecutive only if they are non-ambient + // 1. ambient declarations can be interleaved + // i.e. this is legal + // declare function foo(); + // declare function bar(); + // declare function foo(); + // 2. mixing ambient and non-ambient declarations is a separate error that will be reported - do not want to report an extra one + previousDeclaration = undefined; + } + if ((node.kind === 260 /* SyntaxKind.ClassDeclaration */ || node.kind === 228 /* SyntaxKind.ClassExpression */) && !inAmbientContext) { + hasNonAmbientClass = true; + } + if (node.kind === 259 /* SyntaxKind.FunctionDeclaration */ || node.kind === 171 /* SyntaxKind.MethodDeclaration */ || node.kind === 170 /* SyntaxKind.MethodSignature */ || node.kind === 173 /* SyntaxKind.Constructor */) { + functionDeclarations.push(node); + var currentNodeFlags = getEffectiveDeclarationFlags(node, flagsToCheck); + someNodeFlags |= currentNodeFlags; + allNodeFlags &= currentNodeFlags; + someHaveQuestionToken = someHaveQuestionToken || ts.hasQuestionToken(node); + allHaveQuestionToken = allHaveQuestionToken && ts.hasQuestionToken(node); + var bodyIsPresent = ts.nodeIsPresent(node.body); + if (bodyIsPresent && bodyDeclaration) { + if (isConstructor) { + multipleConstructorImplementation = true; + } + else { + duplicateFunctionDeclaration = true; + } + } + else if ((previousDeclaration === null || previousDeclaration === void 0 ? void 0 : previousDeclaration.parent) === node.parent && previousDeclaration.end !== node.pos) { + reportImplementationExpectedError(previousDeclaration); + } + if (bodyIsPresent) { + if (!bodyDeclaration) { + bodyDeclaration = node; + } + } + else { + hasOverloads = true; + } + previousDeclaration = node; + if (!inAmbientContextOrInterface) { + lastSeenNonAmbientDeclaration = node; + } + } + } + } + if (multipleConstructorImplementation) { + ts.forEach(functionDeclarations, function (declaration) { + error(declaration, ts.Diagnostics.Multiple_constructor_implementations_are_not_allowed); + }); + } + if (duplicateFunctionDeclaration) { + ts.forEach(functionDeclarations, function (declaration) { + error(ts.getNameOfDeclaration(declaration) || declaration, ts.Diagnostics.Duplicate_function_implementation); + }); + } + if (hasNonAmbientClass && !isConstructor && symbol.flags & 16 /* SymbolFlags.Function */ && declarations) { + var relatedDiagnostics_1 = ts.filter(declarations, function (d) { return d.kind === 260 /* SyntaxKind.ClassDeclaration */; }) + .map(function (d) { return ts.createDiagnosticForNode(d, ts.Diagnostics.Consider_adding_a_declare_modifier_to_this_class); }); + ts.forEach(declarations, function (declaration) { + var diagnostic = declaration.kind === 260 /* SyntaxKind.ClassDeclaration */ + ? ts.Diagnostics.Class_declaration_cannot_implement_overload_list_for_0 + : declaration.kind === 259 /* SyntaxKind.FunctionDeclaration */ + ? ts.Diagnostics.Function_with_bodies_can_only_merge_with_classes_that_are_ambient + : undefined; + if (diagnostic) { + ts.addRelatedInfo.apply(void 0, __spreadArray([error(ts.getNameOfDeclaration(declaration) || declaration, diagnostic, ts.symbolName(symbol))], relatedDiagnostics_1, false)); + } + }); + } + // Abstract methods can't have an implementation -- in particular, they don't need one. + if (lastSeenNonAmbientDeclaration && !lastSeenNonAmbientDeclaration.body && + !ts.hasSyntacticModifier(lastSeenNonAmbientDeclaration, 256 /* ModifierFlags.Abstract */) && !lastSeenNonAmbientDeclaration.questionToken) { + reportImplementationExpectedError(lastSeenNonAmbientDeclaration); + } + if (hasOverloads) { + if (declarations) { + checkFlagAgreementBetweenOverloads(declarations, bodyDeclaration, flagsToCheck, someNodeFlags, allNodeFlags); + checkQuestionTokenAgreementBetweenOverloads(declarations, bodyDeclaration, someHaveQuestionToken, allHaveQuestionToken); + } + if (bodyDeclaration) { + var signatures = getSignaturesOfSymbol(symbol); + var bodySignature = getSignatureFromDeclaration(bodyDeclaration); + for (var _a = 0, signatures_10 = signatures; _a < signatures_10.length; _a++) { + var signature = signatures_10[_a]; + if (!isImplementationCompatibleWithOverload(bodySignature, signature)) { + ts.addRelatedInfo(error(signature.declaration, ts.Diagnostics.This_overload_signature_is_not_compatible_with_its_implementation_signature), ts.createDiagnosticForNode(bodyDeclaration, ts.Diagnostics.The_implementation_signature_is_declared_here)); + break; + } + } + } + } + } + function checkExportsOnMergedDeclarations(node) { + addLazyDiagnostic(function () { return checkExportsOnMergedDeclarationsWorker(node); }); + } + function checkExportsOnMergedDeclarationsWorker(node) { + // if localSymbol is defined on node then node itself is exported - check is required + var symbol = node.localSymbol; + if (!symbol) { + // local symbol is undefined => this declaration is non-exported. + // however symbol might contain other declarations that are exported + symbol = getSymbolOfNode(node); + if (!symbol.exportSymbol) { + // this is a pure local symbol (all declarations are non-exported) - no need to check anything + return; + } + } + // run the check only for the first declaration in the list + if (ts.getDeclarationOfKind(symbol, node.kind) !== node) { + return; + } + var exportedDeclarationSpaces = 0 /* DeclarationSpaces.None */; + var nonExportedDeclarationSpaces = 0 /* DeclarationSpaces.None */; + var defaultExportedDeclarationSpaces = 0 /* DeclarationSpaces.None */; + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var d = _a[_i]; + var declarationSpaces = getDeclarationSpaces(d); + var effectiveDeclarationFlags = getEffectiveDeclarationFlags(d, 1 /* ModifierFlags.Export */ | 1024 /* ModifierFlags.Default */); + if (effectiveDeclarationFlags & 1 /* ModifierFlags.Export */) { + if (effectiveDeclarationFlags & 1024 /* ModifierFlags.Default */) { + defaultExportedDeclarationSpaces |= declarationSpaces; + } + else { + exportedDeclarationSpaces |= declarationSpaces; + } + } + else { + nonExportedDeclarationSpaces |= declarationSpaces; + } + } + // Spaces for anything not declared a 'default export'. + var nonDefaultExportedDeclarationSpaces = exportedDeclarationSpaces | nonExportedDeclarationSpaces; + var commonDeclarationSpacesForExportsAndLocals = exportedDeclarationSpaces & nonExportedDeclarationSpaces; + var commonDeclarationSpacesForDefaultAndNonDefault = defaultExportedDeclarationSpaces & nonDefaultExportedDeclarationSpaces; + if (commonDeclarationSpacesForExportsAndLocals || commonDeclarationSpacesForDefaultAndNonDefault) { + // declaration spaces for exported and non-exported declarations intersect + for (var _b = 0, _c = symbol.declarations; _b < _c.length; _b++) { + var d = _c[_b]; + var declarationSpaces = getDeclarationSpaces(d); + var name = ts.getNameOfDeclaration(d); + // Only error on the declarations that contributed to the intersecting spaces. + if (declarationSpaces & commonDeclarationSpacesForDefaultAndNonDefault) { + error(name, ts.Diagnostics.Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead, ts.declarationNameToString(name)); + } + else if (declarationSpaces & commonDeclarationSpacesForExportsAndLocals) { + error(name, ts.Diagnostics.Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local, ts.declarationNameToString(name)); + } + } + } + function getDeclarationSpaces(decl) { + var d = decl; + switch (d.kind) { + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + // A jsdoc typedef and callback are, by definition, type aliases. + // falls through + case 348 /* SyntaxKind.JSDocTypedefTag */: + case 341 /* SyntaxKind.JSDocCallbackTag */: + case 342 /* SyntaxKind.JSDocEnumTag */: + return 2 /* DeclarationSpaces.ExportType */; + case 264 /* SyntaxKind.ModuleDeclaration */: + return ts.isAmbientModule(d) || ts.getModuleInstanceState(d) !== 0 /* ModuleInstanceState.NonInstantiated */ + ? 4 /* DeclarationSpaces.ExportNamespace */ | 1 /* DeclarationSpaces.ExportValue */ + : 4 /* DeclarationSpaces.ExportNamespace */; + case 260 /* SyntaxKind.ClassDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 302 /* SyntaxKind.EnumMember */: + return 2 /* DeclarationSpaces.ExportType */ | 1 /* DeclarationSpaces.ExportValue */; + case 308 /* SyntaxKind.SourceFile */: + return 2 /* DeclarationSpaces.ExportType */ | 1 /* DeclarationSpaces.ExportValue */ | 4 /* DeclarationSpaces.ExportNamespace */; + case 274 /* SyntaxKind.ExportAssignment */: + case 223 /* SyntaxKind.BinaryExpression */: + var node_2 = d; + var expression = ts.isExportAssignment(node_2) ? node_2.expression : node_2.right; + // Export assigned entity name expressions act as aliases and should fall through, otherwise they export values + if (!ts.isEntityNameExpression(expression)) { + return 1 /* DeclarationSpaces.ExportValue */; + } + d = expression; + // The below options all declare an Alias, which is allowed to merge with other values within the importing module. + // falls through + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + case 271 /* SyntaxKind.NamespaceImport */: + case 270 /* SyntaxKind.ImportClause */: + var result_12 = 0 /* DeclarationSpaces.None */; + var target = resolveAlias(getSymbolOfNode(d)); + ts.forEach(target.declarations, function (d) { + result_12 |= getDeclarationSpaces(d); + }); + return result_12; + case 257 /* SyntaxKind.VariableDeclaration */: + case 205 /* SyntaxKind.BindingElement */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 273 /* SyntaxKind.ImportSpecifier */: // https://github.com/Microsoft/TypeScript/pull/7591 + case 79 /* SyntaxKind.Identifier */: // https://github.com/microsoft/TypeScript/issues/36098 + // Identifiers are used as declarations of assignment declarations whose parents may be + // SyntaxKind.CallExpression - `Object.defineProperty(thing, "aField", {value: 42});` + // SyntaxKind.ElementAccessExpression - `thing["aField"] = 42;` or `thing["aField"];` (with a doc comment on it) + // or SyntaxKind.PropertyAccessExpression - `thing.aField = 42;` + // all of which are pretty much always values, or at least imply a value meaning. + // It may be apprpriate to treat these as aliases in the future. + return 1 /* DeclarationSpaces.ExportValue */; + default: + return ts.Debug.failBadSyntaxKind(d); + } + } + } + function getAwaitedTypeOfPromise(type, errorNode, diagnosticMessage, arg0) { + var promisedType = getPromisedTypeOfPromise(type, errorNode); + return promisedType && getAwaitedType(promisedType, errorNode, diagnosticMessage, arg0); + } + /** + * Gets the "promised type" of a promise. + * @param type The type of the promise. + * @remarks The "promised type" of a type is the type of the "value" parameter of the "onfulfilled" callback. + */ + function getPromisedTypeOfPromise(type, errorNode, thisTypeForErrorOut) { + // + // { // type + // then( // thenFunction + // onfulfilled: ( // onfulfilledParameterType + // value: T // valueParameterType + // ) => any + // ): any; + // } + // + if (isTypeAny(type)) { + return undefined; + } + var typeAsPromise = type; + if (typeAsPromise.promisedTypeOfPromise) { + return typeAsPromise.promisedTypeOfPromise; + } + if (isReferenceToType(type, getGlobalPromiseType(/*reportErrors*/ false))) { + return typeAsPromise.promisedTypeOfPromise = getTypeArguments(type)[0]; + } + // primitives with a `{ then() }` won't be unwrapped/adopted. + if (allTypesAssignableToKind(getBaseConstraintOrType(type), 131068 /* TypeFlags.Primitive */ | 131072 /* TypeFlags.Never */)) { + return undefined; + } + var thenFunction = getTypeOfPropertyOfType(type, "then"); // TODO: GH#18217 + if (isTypeAny(thenFunction)) { + return undefined; + } + var thenSignatures = thenFunction ? getSignaturesOfType(thenFunction, 0 /* SignatureKind.Call */) : ts.emptyArray; + if (thenSignatures.length === 0) { + if (errorNode) { + error(errorNode, ts.Diagnostics.A_promise_must_have_a_then_method); + } + return undefined; + } + var thisTypeForError; + var candidates; + for (var _i = 0, thenSignatures_1 = thenSignatures; _i < thenSignatures_1.length; _i++) { + var thenSignature = thenSignatures_1[_i]; + var thisType = getThisTypeOfSignature(thenSignature); + if (thisType && thisType !== voidType && !isTypeRelatedTo(type, thisType, subtypeRelation)) { + thisTypeForError = thisType; + } + else { + candidates = ts.append(candidates, thenSignature); + } + } + if (!candidates) { + ts.Debug.assertIsDefined(thisTypeForError); + if (thisTypeForErrorOut) { + thisTypeForErrorOut.value = thisTypeForError; + } + if (errorNode) { + error(errorNode, ts.Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1, typeToString(type), typeToString(thisTypeForError)); + } + return undefined; + } + var onfulfilledParameterType = getTypeWithFacts(getUnionType(ts.map(candidates, getTypeOfFirstParameterOfSignature)), 2097152 /* TypeFacts.NEUndefinedOrNull */); + if (isTypeAny(onfulfilledParameterType)) { + return undefined; + } + var onfulfilledParameterSignatures = getSignaturesOfType(onfulfilledParameterType, 0 /* SignatureKind.Call */); + if (onfulfilledParameterSignatures.length === 0) { + if (errorNode) { + error(errorNode, ts.Diagnostics.The_first_parameter_of_the_then_method_of_a_promise_must_be_a_callback); + } + return undefined; + } + return typeAsPromise.promisedTypeOfPromise = getUnionType(ts.map(onfulfilledParameterSignatures, getTypeOfFirstParameterOfSignature), 2 /* UnionReduction.Subtype */); + } + /** + * Gets the "awaited type" of a type. + * @param type The type to await. + * @param withAlias When `true`, wraps the "awaited type" in `Awaited` if needed. + * @remarks The "awaited type" of an expression is its "promised type" if the expression is a + * Promise-like type; otherwise, it is the type of the expression. This is used to reflect + * The runtime behavior of the `await` keyword. + */ + function checkAwaitedType(type, withAlias, errorNode, diagnosticMessage, arg0) { + var awaitedType = withAlias ? + getAwaitedType(type, errorNode, diagnosticMessage, arg0) : + getAwaitedTypeNoAlias(type, errorNode, diagnosticMessage, arg0); + return awaitedType || errorType; + } + /** + * Determines whether a type is an object with a callable `then` member. + */ + function isThenableType(type) { + if (allTypesAssignableToKind(getBaseConstraintOrType(type), 131068 /* TypeFlags.Primitive */ | 131072 /* TypeFlags.Never */)) { + // primitive types cannot be considered "thenable" since they are not objects. + return false; + } + var thenFunction = getTypeOfPropertyOfType(type, "then"); + return !!thenFunction && getSignaturesOfType(getTypeWithFacts(thenFunction, 2097152 /* TypeFacts.NEUndefinedOrNull */), 0 /* SignatureKind.Call */).length > 0; + } + function isAwaitedTypeInstantiation(type) { + var _a; + if (type.flags & 16777216 /* TypeFlags.Conditional */) { + var awaitedSymbol = getGlobalAwaitedSymbol(/*reportErrors*/ false); + return !!awaitedSymbol && type.aliasSymbol === awaitedSymbol && ((_a = type.aliasTypeArguments) === null || _a === void 0 ? void 0 : _a.length) === 1; + } + return false; + } + /** + * For a generic `Awaited`, gets `T`. + */ + function unwrapAwaitedType(type) { + return type.flags & 1048576 /* TypeFlags.Union */ ? mapType(type, unwrapAwaitedType) : + isAwaitedTypeInstantiation(type) ? type.aliasTypeArguments[0] : + type; + } + function isAwaitedTypeNeeded(type) { + // If this is already an `Awaited`, we shouldn't wrap it. This helps to avoid `Awaited>` in higher-order. + if (isTypeAny(type) || isAwaitedTypeInstantiation(type)) { + return false; + } + // We only need `Awaited` if `T` contains possibly non-primitive types. + if (isGenericObjectType(type)) { + var baseConstraint = getBaseConstraintOfType(type); + // We only need `Awaited` if `T` is a type variable that has no base constraint, or the base constraint of `T` is `any`, `unknown`, `{}`, `object`, + // or is promise-like. + if (baseConstraint ? + baseConstraint.flags & 3 /* TypeFlags.AnyOrUnknown */ || isEmptyObjectType(baseConstraint) || someType(baseConstraint, isThenableType) : + maybeTypeOfKind(type, 8650752 /* TypeFlags.TypeVariable */)) { + return true; + } + } + return false; + } + function tryCreateAwaitedType(type) { + // Nothing to do if `Awaited` doesn't exist + var awaitedSymbol = getGlobalAwaitedSymbol(/*reportErrors*/ true); + if (awaitedSymbol) { + // Unwrap unions that may contain `Awaited`, otherwise its possible to manufacture an `Awaited | U>` where + // an `Awaited` would suffice. + return getTypeAliasInstantiation(awaitedSymbol, [unwrapAwaitedType(type)]); + } + return undefined; + } + function createAwaitedTypeIfNeeded(type) { + // We wrap type `T` in `Awaited` based on the following conditions: + // - `T` is not already an `Awaited`, and + // - `T` is generic, and + // - One of the following applies: + // - `T` has no base constraint, or + // - The base constraint of `T` is `any`, `unknown`, `object`, or `{}`, or + // - The base constraint of `T` is an object type with a callable `then` method. + if (isAwaitedTypeNeeded(type)) { + var awaitedType = tryCreateAwaitedType(type); + if (awaitedType) { + return awaitedType; + } + } + ts.Debug.assert(getPromisedTypeOfPromise(type) === undefined, "type provided should not be a non-generic 'promise'-like."); + return type; + } + /** + * Gets the "awaited type" of a type. + * + * The "awaited type" of an expression is its "promised type" if the expression is a + * Promise-like type; otherwise, it is the type of the expression. If the "promised + * type" is itself a Promise-like, the "promised type" is recursively unwrapped until a + * non-promise type is found. + * + * This is used to reflect the runtime behavior of the `await` keyword. + */ + function getAwaitedType(type, errorNode, diagnosticMessage, arg0) { + var awaitedType = getAwaitedTypeNoAlias(type, errorNode, diagnosticMessage, arg0); + return awaitedType && createAwaitedTypeIfNeeded(awaitedType); + } + /** + * Gets the "awaited type" of a type without introducing an `Awaited` wrapper. + * + * @see {@link getAwaitedType} + */ + function getAwaitedTypeNoAlias(type, errorNode, diagnosticMessage, arg0) { + if (isTypeAny(type)) { + return type; + } + // If this is already an `Awaited`, just return it. This avoids `Awaited>` in higher-order + if (isAwaitedTypeInstantiation(type)) { + return type; + } + // If we've already cached an awaited type, return a possible `Awaited` for it. + var typeAsAwaitable = type; + if (typeAsAwaitable.awaitedTypeOfType) { + return typeAsAwaitable.awaitedTypeOfType; + } + // For a union, get a union of the awaited types of each constituent. + if (type.flags & 1048576 /* TypeFlags.Union */) { + if (awaitedTypeStack.lastIndexOf(type.id) >= 0) { + if (errorNode) { + error(errorNode, ts.Diagnostics.Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method); + } + return undefined; + } + var mapper = errorNode ? function (constituentType) { return getAwaitedTypeNoAlias(constituentType, errorNode, diagnosticMessage, arg0); } : getAwaitedTypeNoAlias; + awaitedTypeStack.push(type.id); + var mapped = mapType(type, mapper); + awaitedTypeStack.pop(); + return typeAsAwaitable.awaitedTypeOfType = mapped; + } + // If `type` is generic and should be wrapped in `Awaited`, return it. + if (isAwaitedTypeNeeded(type)) { + return typeAsAwaitable.awaitedTypeOfType = type; + } + var thisTypeForErrorOut = { value: undefined }; + var promisedType = getPromisedTypeOfPromise(type, /*errorNode*/ undefined, thisTypeForErrorOut); + if (promisedType) { + if (type.id === promisedType.id || awaitedTypeStack.lastIndexOf(promisedType.id) >= 0) { + // Verify that we don't have a bad actor in the form of a promise whose + // promised type is the same as the promise type, or a mutually recursive + // promise. If so, we return undefined as we cannot guess the shape. If this + // were the actual case in the JavaScript, this Promise would never resolve. + // + // An example of a bad actor with a singly-recursive promise type might + // be: + // + // interface BadPromise { + // then( + // onfulfilled: (value: BadPromise) => any, + // onrejected: (error: any) => any): BadPromise; + // } + // + // The above interface will pass the PromiseLike check, and return a + // promised type of `BadPromise`. Since this is a self reference, we + // don't want to keep recursing ad infinitum. + // + // An example of a bad actor in the form of a mutually-recursive + // promise type might be: + // + // interface BadPromiseA { + // then( + // onfulfilled: (value: BadPromiseB) => any, + // onrejected: (error: any) => any): BadPromiseB; + // } + // + // interface BadPromiseB { + // then( + // onfulfilled: (value: BadPromiseA) => any, + // onrejected: (error: any) => any): BadPromiseA; + // } + // + if (errorNode) { + error(errorNode, ts.Diagnostics.Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method); + } + return undefined; + } + // Keep track of the type we're about to unwrap to avoid bad recursive promise types. + // See the comments above for more information. + awaitedTypeStack.push(type.id); + var awaitedType = getAwaitedTypeNoAlias(promisedType, errorNode, diagnosticMessage, arg0); + awaitedTypeStack.pop(); + if (!awaitedType) { + return undefined; + } + return typeAsAwaitable.awaitedTypeOfType = awaitedType; + } + // The type was not a promise, so it could not be unwrapped any further. + // As long as the type does not have a callable "then" property, it is + // safe to return the type; otherwise, an error is reported and we return + // undefined. + // + // An example of a non-promise "thenable" might be: + // + // await { then(): void {} } + // + // The "thenable" does not match the minimal definition for a promise. When + // a Promise/A+-compatible or ES6 promise tries to adopt this value, the promise + // will never settle. We treat this as an error to help flag an early indicator + // of a runtime problem. If the user wants to return this value from an async + // function, they would need to wrap it in some other value. If they want it to + // be treated as a promise, they can cast to . + if (isThenableType(type)) { + if (errorNode) { + ts.Debug.assertIsDefined(diagnosticMessage); + var chain = void 0; + if (thisTypeForErrorOut.value) { + chain = ts.chainDiagnosticMessages(chain, ts.Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1, typeToString(type), typeToString(thisTypeForErrorOut.value)); + } + chain = ts.chainDiagnosticMessages(chain, diagnosticMessage, arg0); + diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(errorNode, chain)); + } + return undefined; + } + return typeAsAwaitable.awaitedTypeOfType = type; + } + /** + * Checks the return type of an async function to ensure it is a compatible + * Promise implementation. + * + * This checks that an async function has a valid Promise-compatible return type. + * An async function has a valid Promise-compatible return type if the resolved value + * of the return type has a construct signature that takes in an `initializer` function + * that in turn supplies a `resolve` function as one of its arguments and results in an + * object with a callable `then` signature. + * + * @param node The signature to check + */ + function checkAsyncFunctionReturnType(node, returnTypeNode) { + // As part of our emit for an async function, we will need to emit the entity name of + // the return type annotation as an expression. To meet the necessary runtime semantics + // for __awaiter, we must also check that the type of the declaration (e.g. the static + // side or "constructor" of the promise type) is compatible `PromiseConstructorLike`. + // + // An example might be (from lib.es6.d.ts): + // + // interface Promise { ... } + // interface PromiseConstructor { + // new (...): Promise; + // } + // declare var Promise: PromiseConstructor; + // + // When an async function declares a return type annotation of `Promise`, we + // need to get the type of the `Promise` variable declaration above, which would + // be `PromiseConstructor`. + // + // The same case applies to a class: + // + // declare class Promise { + // constructor(...); + // then(...): Promise; + // } + // + var returnType = getTypeFromTypeNode(returnTypeNode); + if (languageVersion >= 2 /* ScriptTarget.ES2015 */) { + if (isErrorType(returnType)) { + return; + } + var globalPromiseType = getGlobalPromiseType(/*reportErrors*/ true); + if (globalPromiseType !== emptyGenericType && !isReferenceToType(returnType, globalPromiseType)) { + // The promise type was not a valid type reference to the global promise type, so we + // report an error and return the unknown type. + error(returnTypeNode, ts.Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0, typeToString(getAwaitedTypeNoAlias(returnType) || voidType)); + return; + } + } + else { + // Always mark the type node as referenced if it points to a value + markTypeNodeAsReferenced(returnTypeNode); + if (isErrorType(returnType)) { + return; + } + var promiseConstructorName = ts.getEntityNameFromTypeNode(returnTypeNode); + if (promiseConstructorName === undefined) { + error(returnTypeNode, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value, typeToString(returnType)); + return; + } + var promiseConstructorSymbol = resolveEntityName(promiseConstructorName, 111551 /* SymbolFlags.Value */, /*ignoreErrors*/ true); + var promiseConstructorType = promiseConstructorSymbol ? getTypeOfSymbol(promiseConstructorSymbol) : errorType; + if (isErrorType(promiseConstructorType)) { + if (promiseConstructorName.kind === 79 /* SyntaxKind.Identifier */ && promiseConstructorName.escapedText === "Promise" && getTargetType(returnType) === getGlobalPromiseType(/*reportErrors*/ false)) { + error(returnTypeNode, ts.Diagnostics.An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option); + } + else { + error(returnTypeNode, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value, ts.entityNameToString(promiseConstructorName)); + } + return; + } + var globalPromiseConstructorLikeType = getGlobalPromiseConstructorLikeType(/*reportErrors*/ true); + if (globalPromiseConstructorLikeType === emptyObjectType) { + // If we couldn't resolve the global PromiseConstructorLike type we cannot verify + // compatibility with __awaiter. + error(returnTypeNode, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value, ts.entityNameToString(promiseConstructorName)); + return; + } + if (!checkTypeAssignableTo(promiseConstructorType, globalPromiseConstructorLikeType, returnTypeNode, ts.Diagnostics.Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value)) { + return; + } + // Verify there is no local declaration that could collide with the promise constructor. + var rootName = promiseConstructorName && ts.getFirstIdentifier(promiseConstructorName); + var collidingSymbol = getSymbol(node.locals, rootName.escapedText, 111551 /* SymbolFlags.Value */); + if (collidingSymbol) { + error(collidingSymbol.valueDeclaration, ts.Diagnostics.Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions, ts.idText(rootName), ts.entityNameToString(promiseConstructorName)); + return; + } + } + checkAwaitedType(returnType, /*withAlias*/ false, node, ts.Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member); + } + /** Check a decorator */ + function checkDecorator(node) { + var signature = getResolvedSignature(node); + checkDeprecatedSignature(signature, node); + var returnType = getReturnTypeOfSignature(signature); + if (returnType.flags & 1 /* TypeFlags.Any */) { + return; + } + var headMessage; + var expectedReturnType; + switch (node.parent.kind) { + case 260 /* SyntaxKind.ClassDeclaration */: + headMessage = ts.Diagnostics.Decorator_function_return_type_0_is_not_assignable_to_type_1; + var classSymbol = getSymbolOfNode(node.parent); + var classConstructorType = getTypeOfSymbol(classSymbol); + expectedReturnType = getUnionType([classConstructorType, voidType]); + break; + case 169 /* SyntaxKind.PropertyDeclaration */: + case 166 /* SyntaxKind.Parameter */: + headMessage = ts.Diagnostics.Decorator_function_return_type_is_0_but_is_expected_to_be_void_or_any; + expectedReturnType = voidType; + break; + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + headMessage = ts.Diagnostics.Decorator_function_return_type_0_is_not_assignable_to_type_1; + var methodType = getTypeOfNode(node.parent); + var descriptorType = createTypedPropertyDescriptorType(methodType); + expectedReturnType = getUnionType([descriptorType, voidType]); + break; + default: + return ts.Debug.fail(); + } + checkTypeAssignableTo(returnType, expectedReturnType, node, headMessage); + } + /** + * If a TypeNode can be resolved to a value symbol imported from an external module, it is + * marked as referenced to prevent import elision. + */ + function markTypeNodeAsReferenced(node) { + markEntityNameOrEntityExpressionAsReference(node && ts.getEntityNameFromTypeNode(node), /*forDecoratorMetadata*/ false); + } + function markEntityNameOrEntityExpressionAsReference(typeName, forDecoratorMetadata) { + if (!typeName) + return; + var rootName = ts.getFirstIdentifier(typeName); + var meaning = (typeName.kind === 79 /* SyntaxKind.Identifier */ ? 788968 /* SymbolFlags.Type */ : 1920 /* SymbolFlags.Namespace */) | 2097152 /* SymbolFlags.Alias */; + var rootSymbol = resolveName(rootName, rootName.escapedText, meaning, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isReference*/ true); + if (rootSymbol && rootSymbol.flags & 2097152 /* SymbolFlags.Alias */) { + if (symbolIsValue(rootSymbol) + && !isConstEnumOrConstEnumOnlyModule(resolveAlias(rootSymbol)) + && !getTypeOnlyAliasDeclaration(rootSymbol)) { + markAliasSymbolAsReferenced(rootSymbol); + } + else if (forDecoratorMetadata + && compilerOptions.isolatedModules + && ts.getEmitModuleKind(compilerOptions) >= ts.ModuleKind.ES2015 + && !symbolIsValue(rootSymbol) + && !ts.some(rootSymbol.declarations, ts.isTypeOnlyImportOrExportDeclaration)) { + var diag = error(typeName, ts.Diagnostics.A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled); + var aliasDeclaration = ts.find(rootSymbol.declarations || ts.emptyArray, isAliasSymbolDeclaration); + if (aliasDeclaration) { + ts.addRelatedInfo(diag, ts.createDiagnosticForNode(aliasDeclaration, ts.Diagnostics._0_was_imported_here, ts.idText(rootName))); + } + } + } + } + /** + * This function marks the type used for metadata decorator as referenced if it is import + * from external module. + * This is different from markTypeNodeAsReferenced because it tries to simplify type nodes in + * union and intersection type + * @param node + */ + function markDecoratorMedataDataTypeNodeAsReferenced(node) { + var entityName = getEntityNameForDecoratorMetadata(node); + if (entityName && ts.isEntityName(entityName)) { + markEntityNameOrEntityExpressionAsReference(entityName, /*forDecoratorMetadata*/ true); + } + } + function getEntityNameForDecoratorMetadata(node) { + if (node) { + switch (node.kind) { + case 190 /* SyntaxKind.IntersectionType */: + case 189 /* SyntaxKind.UnionType */: + return getEntityNameForDecoratorMetadataFromTypeList(node.types); + case 191 /* SyntaxKind.ConditionalType */: + return getEntityNameForDecoratorMetadataFromTypeList([node.trueType, node.falseType]); + case 193 /* SyntaxKind.ParenthesizedType */: + case 199 /* SyntaxKind.NamedTupleMember */: + return getEntityNameForDecoratorMetadata(node.type); + case 180 /* SyntaxKind.TypeReference */: + return node.typeName; + } + } + } + function getEntityNameForDecoratorMetadataFromTypeList(types) { + var commonEntityName; + for (var _i = 0, types_21 = types; _i < types_21.length; _i++) { + var typeNode = types_21[_i]; + while (typeNode.kind === 193 /* SyntaxKind.ParenthesizedType */ || typeNode.kind === 199 /* SyntaxKind.NamedTupleMember */) { + typeNode = typeNode.type; // Skip parens if need be + } + if (typeNode.kind === 144 /* SyntaxKind.NeverKeyword */) { + continue; // Always elide `never` from the union/intersection if possible + } + if (!strictNullChecks && (typeNode.kind === 198 /* SyntaxKind.LiteralType */ && typeNode.literal.kind === 104 /* SyntaxKind.NullKeyword */ || typeNode.kind === 155 /* SyntaxKind.UndefinedKeyword */)) { + continue; // Elide null and undefined from unions for metadata, just like what we did prior to the implementation of strict null checks + } + var individualEntityName = getEntityNameForDecoratorMetadata(typeNode); + if (!individualEntityName) { + // Individual is something like string number + // So it would be serialized to either that type or object + // Safe to return here + return undefined; + } + if (commonEntityName) { + // Note this is in sync with the transformation that happens for type node. + // Keep this in sync with serializeUnionOrIntersectionType + // Verify if they refer to same entity and is identifier + // return undefined if they dont match because we would emit object + if (!ts.isIdentifier(commonEntityName) || + !ts.isIdentifier(individualEntityName) || + commonEntityName.escapedText !== individualEntityName.escapedText) { + return undefined; + } + } + else { + commonEntityName = individualEntityName; + } + } + return commonEntityName; + } + function getParameterTypeNodeForDecoratorCheck(node) { + var typeNode = ts.getEffectiveTypeAnnotationNode(node); + return ts.isRestParameter(node) ? ts.getRestParameterElementType(typeNode) : typeNode; + } + /** Check the decorators of a node */ + function checkDecorators(node) { + // skip this check for nodes that cannot have decorators. These should have already had an error reported by + // checkGrammarDecorators. + if (!ts.canHaveDecorators(node) || !ts.hasDecorators(node) || !node.modifiers || !ts.nodeCanBeDecorated(node, node.parent, node.parent.parent)) { + return; + } + if (!compilerOptions.experimentalDecorators) { + error(node, ts.Diagnostics.Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_the_experimentalDecorators_option_in_your_tsconfig_or_jsconfig_to_remove_this_warning); + } + var firstDecorator = ts.find(node.modifiers, ts.isDecorator); + if (!firstDecorator) { + return; + } + checkExternalEmitHelpers(firstDecorator, 8 /* ExternalEmitHelpers.Decorate */); + if (node.kind === 166 /* SyntaxKind.Parameter */) { + checkExternalEmitHelpers(firstDecorator, 32 /* ExternalEmitHelpers.Param */); + } + if (compilerOptions.emitDecoratorMetadata) { + checkExternalEmitHelpers(firstDecorator, 16 /* ExternalEmitHelpers.Metadata */); + // we only need to perform these checks if we are emitting serialized type metadata for the target of a decorator. + switch (node.kind) { + case 260 /* SyntaxKind.ClassDeclaration */: + var constructor = ts.getFirstConstructorWithBody(node); + if (constructor) { + for (var _i = 0, _a = constructor.parameters; _i < _a.length; _i++) { + var parameter = _a[_i]; + markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter)); + } + } + break; + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + var otherKind = node.kind === 174 /* SyntaxKind.GetAccessor */ ? 175 /* SyntaxKind.SetAccessor */ : 174 /* SyntaxKind.GetAccessor */; + var otherAccessor = ts.getDeclarationOfKind(getSymbolOfNode(node), otherKind); + markDecoratorMedataDataTypeNodeAsReferenced(getAnnotatedAccessorTypeNode(node) || otherAccessor && getAnnotatedAccessorTypeNode(otherAccessor)); + break; + case 171 /* SyntaxKind.MethodDeclaration */: + for (var _b = 0, _c = node.parameters; _b < _c.length; _b++) { + var parameter = _c[_b]; + markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter)); + } + markDecoratorMedataDataTypeNodeAsReferenced(ts.getEffectiveReturnTypeNode(node)); + break; + case 169 /* SyntaxKind.PropertyDeclaration */: + markDecoratorMedataDataTypeNodeAsReferenced(ts.getEffectiveTypeAnnotationNode(node)); + break; + case 166 /* SyntaxKind.Parameter */: + markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(node)); + var containingSignature = node.parent; + for (var _d = 0, _e = containingSignature.parameters; _d < _e.length; _d++) { + var parameter = _e[_d]; + markDecoratorMedataDataTypeNodeAsReferenced(getParameterTypeNodeForDecoratorCheck(parameter)); + } + break; + } + } + for (var _f = 0, _g = node.modifiers; _f < _g.length; _f++) { + var modifier = _g[_f]; + if (ts.isDecorator(modifier)) { + checkDecorator(modifier); + } + } + } + function checkFunctionDeclaration(node) { + addLazyDiagnostic(checkFunctionDeclarationDiagnostics); + function checkFunctionDeclarationDiagnostics() { + checkFunctionOrMethodDeclaration(node); + checkGrammarForGenerator(node); + checkCollisionsForDeclarationName(node, node.name); + } + } + function checkJSDocTypeAliasTag(node) { + if (!node.typeExpression) { + // If the node had `@property` tags, `typeExpression` would have been set to the first property tag. + error(node.name, ts.Diagnostics.JSDoc_typedef_tag_should_either_have_a_type_annotation_or_be_followed_by_property_or_member_tags); + } + if (node.name) { + checkTypeNameIsReserved(node.name, ts.Diagnostics.Type_alias_name_cannot_be_0); + } + checkSourceElement(node.typeExpression); + checkTypeParameters(ts.getEffectiveTypeParameterDeclarations(node)); + } + function checkJSDocTemplateTag(node) { + checkSourceElement(node.constraint); + for (var _i = 0, _a = node.typeParameters; _i < _a.length; _i++) { + var tp = _a[_i]; + checkSourceElement(tp); + } + } + function checkJSDocTypeTag(node) { + checkSourceElement(node.typeExpression); + } + function checkJSDocLinkLikeTag(node) { + if (node.name) { + resolveJSDocMemberName(node.name, /*ignoreErrors*/ true); + } + } + function checkJSDocParameterTag(node) { + checkSourceElement(node.typeExpression); + } + function checkJSDocPropertyTag(node) { + checkSourceElement(node.typeExpression); + } + function checkJSDocFunctionType(node) { + addLazyDiagnostic(checkJSDocFunctionTypeImplicitAny); + checkSignatureDeclaration(node); + function checkJSDocFunctionTypeImplicitAny() { + if (!node.type && !ts.isJSDocConstructSignature(node)) { + reportImplicitAny(node, anyType); + } + } + } + function checkJSDocImplementsTag(node) { + var classLike = ts.getEffectiveJSDocHost(node); + if (!classLike || !ts.isClassDeclaration(classLike) && !ts.isClassExpression(classLike)) { + error(classLike, ts.Diagnostics.JSDoc_0_is_not_attached_to_a_class, ts.idText(node.tagName)); + } + } + function checkJSDocAugmentsTag(node) { + var classLike = ts.getEffectiveJSDocHost(node); + if (!classLike || !ts.isClassDeclaration(classLike) && !ts.isClassExpression(classLike)) { + error(classLike, ts.Diagnostics.JSDoc_0_is_not_attached_to_a_class, ts.idText(node.tagName)); + return; + } + var augmentsTags = ts.getJSDocTags(classLike).filter(ts.isJSDocAugmentsTag); + ts.Debug.assert(augmentsTags.length > 0); + if (augmentsTags.length > 1) { + error(augmentsTags[1], ts.Diagnostics.Class_declarations_cannot_have_more_than_one_augments_or_extends_tag); + } + var name = getIdentifierFromEntityNameExpression(node.class.expression); + var extend = ts.getClassExtendsHeritageElement(classLike); + if (extend) { + var className = getIdentifierFromEntityNameExpression(extend.expression); + if (className && name.escapedText !== className.escapedText) { + error(name, ts.Diagnostics.JSDoc_0_1_does_not_match_the_extends_2_clause, ts.idText(node.tagName), ts.idText(name), ts.idText(className)); + } + } + } + function checkJSDocAccessibilityModifiers(node) { + var host = ts.getJSDocHost(node); + if (host && ts.isPrivateIdentifierClassElementDeclaration(host)) { + error(node, ts.Diagnostics.An_accessibility_modifier_cannot_be_used_with_a_private_identifier); + } + } + function getIdentifierFromEntityNameExpression(node) { + switch (node.kind) { + case 79 /* SyntaxKind.Identifier */: + return node; + case 208 /* SyntaxKind.PropertyAccessExpression */: + return node.name; + default: + return undefined; + } + } + function checkFunctionOrMethodDeclaration(node) { + var _a; + checkDecorators(node); + checkSignatureDeclaration(node); + var functionFlags = ts.getFunctionFlags(node); + // Do not use hasDynamicName here, because that returns false for well known symbols. + // We want to perform checkComputedPropertyName for all computed properties, including + // well known symbols. + if (node.name && node.name.kind === 164 /* SyntaxKind.ComputedPropertyName */) { + // This check will account for methods in class/interface declarations, + // as well as accessors in classes/object literals + checkComputedPropertyName(node.name); + } + if (hasBindableName(node)) { + // first we want to check the local symbol that contain this declaration + // - if node.localSymbol !== undefined - this is current declaration is exported and localSymbol points to the local symbol + // - if node.localSymbol === undefined - this node is non-exported so we can just pick the result of getSymbolOfNode + var symbol = getSymbolOfNode(node); + var localSymbol = node.localSymbol || symbol; + // Since the javascript won't do semantic analysis like typescript, + // if the javascript file comes before the typescript file and both contain same name functions, + // checkFunctionOrConstructorSymbol wouldn't be called if we didnt ignore javascript function. + var firstDeclaration = (_a = localSymbol.declarations) === null || _a === void 0 ? void 0 : _a.find( + // Get first non javascript function declaration + function (declaration) { return declaration.kind === node.kind && !(declaration.flags & 262144 /* NodeFlags.JavaScriptFile */); }); + // Only type check the symbol once + if (node === firstDeclaration) { + checkFunctionOrConstructorSymbol(localSymbol); + } + if (symbol.parent) { + // run check on export symbol to check that modifiers agree across all exported declarations + checkFunctionOrConstructorSymbol(symbol); + } + } + var body = node.kind === 170 /* SyntaxKind.MethodSignature */ ? undefined : node.body; + checkSourceElement(body); + checkAllCodePathsInNonVoidFunctionReturnOrThrow(node, getReturnTypeFromAnnotation(node)); + addLazyDiagnostic(checkFunctionOrMethodDeclarationDiagnostics); + // A js function declaration can have a @type tag instead of a return type node, but that type must have a call signature + if (ts.isInJSFile(node)) { + var typeTag = ts.getJSDocTypeTag(node); + if (typeTag && typeTag.typeExpression && !getContextualCallSignature(getTypeFromTypeNode(typeTag.typeExpression), node)) { + error(typeTag.typeExpression.type, ts.Diagnostics.The_type_of_a_function_declaration_must_match_the_function_s_signature); + } + } + function checkFunctionOrMethodDeclarationDiagnostics() { + if (!ts.getEffectiveReturnTypeNode(node)) { + // Report an implicit any error if there is no body, no explicit return type, and node is not a private method + // in an ambient context + if (ts.nodeIsMissing(body) && !isPrivateWithinAmbient(node)) { + reportImplicitAny(node, anyType); + } + if (functionFlags & 1 /* FunctionFlags.Generator */ && ts.nodeIsPresent(body)) { + // A generator with a body and no type annotation can still cause errors. It can error if the + // yielded values have no common supertype, or it can give an implicit any error if it has no + // yielded values. The only way to trigger these errors is to try checking its return type. + getReturnTypeOfSignature(getSignatureFromDeclaration(node)); + } + } + } + } + function registerForUnusedIdentifiersCheck(node) { + addLazyDiagnostic(registerForUnusedIdentifiersCheckDiagnostics); + function registerForUnusedIdentifiersCheckDiagnostics() { + // May be in a call such as getTypeOfNode that happened to call this. But potentiallyUnusedIdentifiers is only defined in the scope of `checkSourceFile`. + var sourceFile = ts.getSourceFileOfNode(node); + var potentiallyUnusedIdentifiers = allPotentiallyUnusedIdentifiers.get(sourceFile.path); + if (!potentiallyUnusedIdentifiers) { + potentiallyUnusedIdentifiers = []; + allPotentiallyUnusedIdentifiers.set(sourceFile.path, potentiallyUnusedIdentifiers); + } + // TODO: GH#22580 + // Debug.assert(addToSeen(seenPotentiallyUnusedIdentifiers, getNodeId(node)), "Adding potentially-unused identifier twice"); + potentiallyUnusedIdentifiers.push(node); + } + } + function checkUnusedIdentifiers(potentiallyUnusedIdentifiers, addDiagnostic) { + for (var _i = 0, potentiallyUnusedIdentifiers_1 = potentiallyUnusedIdentifiers; _i < potentiallyUnusedIdentifiers_1.length; _i++) { + var node = potentiallyUnusedIdentifiers_1[_i]; + switch (node.kind) { + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + checkUnusedClassMembers(node, addDiagnostic); + checkUnusedTypeParameters(node, addDiagnostic); + break; + case 308 /* SyntaxKind.SourceFile */: + case 264 /* SyntaxKind.ModuleDeclaration */: + case 238 /* SyntaxKind.Block */: + case 266 /* SyntaxKind.CaseBlock */: + case 245 /* SyntaxKind.ForStatement */: + case 246 /* SyntaxKind.ForInStatement */: + case 247 /* SyntaxKind.ForOfStatement */: + checkUnusedLocalsAndParameters(node, addDiagnostic); + break; + case 173 /* SyntaxKind.Constructor */: + case 215 /* SyntaxKind.FunctionExpression */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 216 /* SyntaxKind.ArrowFunction */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + if (node.body) { // Don't report unused parameters in overloads + checkUnusedLocalsAndParameters(node, addDiagnostic); + } + checkUnusedTypeParameters(node, addDiagnostic); + break; + case 170 /* SyntaxKind.MethodSignature */: + case 176 /* SyntaxKind.CallSignature */: + case 177 /* SyntaxKind.ConstructSignature */: + case 181 /* SyntaxKind.FunctionType */: + case 182 /* SyntaxKind.ConstructorType */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + checkUnusedTypeParameters(node, addDiagnostic); + break; + case 192 /* SyntaxKind.InferType */: + checkUnusedInferTypeParameter(node, addDiagnostic); + break; + default: + ts.Debug.assertNever(node, "Node should not have been registered for unused identifiers check"); + } + } + } + function errorUnusedLocal(declaration, name, addDiagnostic) { + var node = ts.getNameOfDeclaration(declaration) || declaration; + var message = ts.isTypeDeclaration(declaration) ? ts.Diagnostics._0_is_declared_but_never_used : ts.Diagnostics._0_is_declared_but_its_value_is_never_read; + addDiagnostic(declaration, 0 /* UnusedKind.Local */, ts.createDiagnosticForNode(node, message, name)); + } + function isIdentifierThatStartsWithUnderscore(node) { + return ts.isIdentifier(node) && ts.idText(node).charCodeAt(0) === 95 /* CharacterCodes._ */; + } + function checkUnusedClassMembers(node, addDiagnostic) { + for (var _i = 0, _a = node.members; _i < _a.length; _i++) { + var member = _a[_i]; + switch (member.kind) { + case 171 /* SyntaxKind.MethodDeclaration */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + if (member.kind === 175 /* SyntaxKind.SetAccessor */ && member.symbol.flags & 32768 /* SymbolFlags.GetAccessor */) { + // Already would have reported an error on the getter. + break; + } + var symbol = getSymbolOfNode(member); + if (!symbol.isReferenced + && (ts.hasEffectiveModifier(member, 8 /* ModifierFlags.Private */) || ts.isNamedDeclaration(member) && ts.isPrivateIdentifier(member.name)) + && !(member.flags & 16777216 /* NodeFlags.Ambient */)) { + addDiagnostic(member, 0 /* UnusedKind.Local */, ts.createDiagnosticForNode(member.name, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, symbolToString(symbol))); + } + break; + case 173 /* SyntaxKind.Constructor */: + for (var _b = 0, _c = member.parameters; _b < _c.length; _b++) { + var parameter = _c[_b]; + if (!parameter.symbol.isReferenced && ts.hasSyntacticModifier(parameter, 8 /* ModifierFlags.Private */)) { + addDiagnostic(parameter, 0 /* UnusedKind.Local */, ts.createDiagnosticForNode(parameter.name, ts.Diagnostics.Property_0_is_declared_but_its_value_is_never_read, ts.symbolName(parameter.symbol))); + } + } + break; + case 178 /* SyntaxKind.IndexSignature */: + case 237 /* SyntaxKind.SemicolonClassElement */: + case 172 /* SyntaxKind.ClassStaticBlockDeclaration */: + // Can't be private + break; + default: + ts.Debug.fail("Unexpected class member"); + } + } + } + function checkUnusedInferTypeParameter(node, addDiagnostic) { + var typeParameter = node.typeParameter; + if (isTypeParameterUnused(typeParameter)) { + addDiagnostic(node, 1 /* UnusedKind.Parameter */, ts.createDiagnosticForNode(node, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, ts.idText(typeParameter.name))); + } + } + function checkUnusedTypeParameters(node, addDiagnostic) { + // Only report errors on the last declaration for the type parameter container; + // this ensures that all uses have been accounted for. + var declarations = getSymbolOfNode(node).declarations; + if (!declarations || ts.last(declarations) !== node) + return; + var typeParameters = ts.getEffectiveTypeParameterDeclarations(node); + var seenParentsWithEveryUnused = new ts.Set(); + for (var _i = 0, typeParameters_4 = typeParameters; _i < typeParameters_4.length; _i++) { + var typeParameter = typeParameters_4[_i]; + if (!isTypeParameterUnused(typeParameter)) + continue; + var name = ts.idText(typeParameter.name); + var parent = typeParameter.parent; + if (parent.kind !== 192 /* SyntaxKind.InferType */ && parent.typeParameters.every(isTypeParameterUnused)) { + if (ts.tryAddToSet(seenParentsWithEveryUnused, parent)) { + var sourceFile = ts.getSourceFileOfNode(parent); + var range = ts.isJSDocTemplateTag(parent) + // Whole @template tag + ? ts.rangeOfNode(parent) + // Include the `<>` in the error message + : ts.rangeOfTypeParameters(sourceFile, parent.typeParameters); + var only = parent.typeParameters.length === 1; + //TODO: following line is possible reason for bug #41974, unusedTypeParameters_TemplateTag + var message = only ? ts.Diagnostics._0_is_declared_but_its_value_is_never_read : ts.Diagnostics.All_type_parameters_are_unused; + var arg0 = only ? name : undefined; + addDiagnostic(typeParameter, 1 /* UnusedKind.Parameter */, ts.createFileDiagnostic(sourceFile, range.pos, range.end - range.pos, message, arg0)); + } + } + else { + //TODO: following line is possible reason for bug #41974, unusedTypeParameters_TemplateTag + addDiagnostic(typeParameter, 1 /* UnusedKind.Parameter */, ts.createDiagnosticForNode(typeParameter, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, name)); + } + } + } + function isTypeParameterUnused(typeParameter) { + return !(getMergedSymbol(typeParameter.symbol).isReferenced & 262144 /* SymbolFlags.TypeParameter */) && !isIdentifierThatStartsWithUnderscore(typeParameter.name); + } + function addToGroup(map, key, value, getKey) { + var keyString = String(getKey(key)); + var group = map.get(keyString); + if (group) { + group[1].push(value); + } + else { + map.set(keyString, [key, [value]]); + } + } + function tryGetRootParameterDeclaration(node) { + return ts.tryCast(ts.getRootDeclaration(node), ts.isParameter); + } + function isValidUnusedLocalDeclaration(declaration) { + if (ts.isBindingElement(declaration)) { + if (ts.isObjectBindingPattern(declaration.parent)) { + /** + * ignore starts with underscore names _ + * const { a: _a } = { a: 1 } + */ + return !!(declaration.propertyName && isIdentifierThatStartsWithUnderscore(declaration.name)); + } + return isIdentifierThatStartsWithUnderscore(declaration.name); + } + return ts.isAmbientModule(declaration) || + (ts.isVariableDeclaration(declaration) && ts.isForInOrOfStatement(declaration.parent.parent) || isImportedDeclaration(declaration)) && isIdentifierThatStartsWithUnderscore(declaration.name); + } + function checkUnusedLocalsAndParameters(nodeWithLocals, addDiagnostic) { + // Ideally we could use the ImportClause directly as a key, but must wait until we have full ES6 maps. So must store key along with value. + var unusedImports = new ts.Map(); + var unusedDestructures = new ts.Map(); + var unusedVariables = new ts.Map(); + nodeWithLocals.locals.forEach(function (local) { + // If it's purely a type parameter, ignore, will be checked in `checkUnusedTypeParameters`. + // If it's a type parameter merged with a parameter, check if the parameter-side is used. + if (local.flags & 262144 /* SymbolFlags.TypeParameter */ ? !(local.flags & 3 /* SymbolFlags.Variable */ && !(local.isReferenced & 3 /* SymbolFlags.Variable */)) : local.isReferenced || local.exportSymbol) { + return; + } + if (local.declarations) { + for (var _i = 0, _a = local.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + if (isValidUnusedLocalDeclaration(declaration)) { + continue; + } + if (isImportedDeclaration(declaration)) { + addToGroup(unusedImports, importClauseFromImported(declaration), declaration, getNodeId); + } + else if (ts.isBindingElement(declaration) && ts.isObjectBindingPattern(declaration.parent)) { + // In `{ a, ...b }, `a` is considered used since it removes a property from `b`. `b` may still be unused though. + var lastElement = ts.last(declaration.parent.elements); + if (declaration === lastElement || !ts.last(declaration.parent.elements).dotDotDotToken) { + addToGroup(unusedDestructures, declaration.parent, declaration, getNodeId); + } + } + else if (ts.isVariableDeclaration(declaration)) { + addToGroup(unusedVariables, declaration.parent, declaration, getNodeId); + } + else { + var parameter = local.valueDeclaration && tryGetRootParameterDeclaration(local.valueDeclaration); + var name = local.valueDeclaration && ts.getNameOfDeclaration(local.valueDeclaration); + if (parameter && name) { + if (!ts.isParameterPropertyDeclaration(parameter, parameter.parent) && !ts.parameterIsThisKeyword(parameter) && !isIdentifierThatStartsWithUnderscore(name)) { + if (ts.isBindingElement(declaration) && ts.isArrayBindingPattern(declaration.parent)) { + addToGroup(unusedDestructures, declaration.parent, declaration, getNodeId); + } + else { + addDiagnostic(parameter, 1 /* UnusedKind.Parameter */, ts.createDiagnosticForNode(name, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, ts.symbolName(local))); + } + } + } + else { + errorUnusedLocal(declaration, ts.symbolName(local), addDiagnostic); + } + } + } + } + }); + unusedImports.forEach(function (_a) { + var importClause = _a[0], unuseds = _a[1]; + var importDecl = importClause.parent; + var nDeclarations = (importClause.name ? 1 : 0) + + (importClause.namedBindings ? + (importClause.namedBindings.kind === 271 /* SyntaxKind.NamespaceImport */ ? 1 : importClause.namedBindings.elements.length) + : 0); + if (nDeclarations === unuseds.length) { + addDiagnostic(importDecl, 0 /* UnusedKind.Local */, unuseds.length === 1 + ? ts.createDiagnosticForNode(importDecl, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, ts.idText(ts.first(unuseds).name)) + : ts.createDiagnosticForNode(importDecl, ts.Diagnostics.All_imports_in_import_declaration_are_unused)); + } + else { + for (var _i = 0, unuseds_1 = unuseds; _i < unuseds_1.length; _i++) { + var unused = unuseds_1[_i]; + errorUnusedLocal(unused, ts.idText(unused.name), addDiagnostic); + } + } + }); + unusedDestructures.forEach(function (_a) { + var bindingPattern = _a[0], bindingElements = _a[1]; + var kind = tryGetRootParameterDeclaration(bindingPattern.parent) ? 1 /* UnusedKind.Parameter */ : 0 /* UnusedKind.Local */; + if (bindingPattern.elements.length === bindingElements.length) { + if (bindingElements.length === 1 && bindingPattern.parent.kind === 257 /* SyntaxKind.VariableDeclaration */ && bindingPattern.parent.parent.kind === 258 /* SyntaxKind.VariableDeclarationList */) { + addToGroup(unusedVariables, bindingPattern.parent.parent, bindingPattern.parent, getNodeId); + } + else { + addDiagnostic(bindingPattern, kind, bindingElements.length === 1 + ? ts.createDiagnosticForNode(bindingPattern, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, bindingNameText(ts.first(bindingElements).name)) + : ts.createDiagnosticForNode(bindingPattern, ts.Diagnostics.All_destructured_elements_are_unused)); + } + } + else { + for (var _i = 0, bindingElements_1 = bindingElements; _i < bindingElements_1.length; _i++) { + var e = bindingElements_1[_i]; + addDiagnostic(e, kind, ts.createDiagnosticForNode(e, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, bindingNameText(e.name))); + } + } + }); + unusedVariables.forEach(function (_a) { + var declarationList = _a[0], declarations = _a[1]; + if (declarationList.declarations.length === declarations.length) { + addDiagnostic(declarationList, 0 /* UnusedKind.Local */, declarations.length === 1 + ? ts.createDiagnosticForNode(ts.first(declarations).name, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, bindingNameText(ts.first(declarations).name)) + : ts.createDiagnosticForNode(declarationList.parent.kind === 240 /* SyntaxKind.VariableStatement */ ? declarationList.parent : declarationList, ts.Diagnostics.All_variables_are_unused)); + } + else { + for (var _i = 0, declarations_6 = declarations; _i < declarations_6.length; _i++) { + var decl = declarations_6[_i]; + addDiagnostic(decl, 0 /* UnusedKind.Local */, ts.createDiagnosticForNode(decl, ts.Diagnostics._0_is_declared_but_its_value_is_never_read, bindingNameText(decl.name))); + } + } + }); + } + function checkPotentialUncheckedRenamedBindingElementsInTypes() { + var _a; + for (var _i = 0, potentialUnusedRenamedBindingElementsInTypes_1 = potentialUnusedRenamedBindingElementsInTypes; _i < potentialUnusedRenamedBindingElementsInTypes_1.length; _i++) { + var node = potentialUnusedRenamedBindingElementsInTypes_1[_i]; + if (!((_a = getSymbolOfNode(node)) === null || _a === void 0 ? void 0 : _a.isReferenced)) { + var wrappingDeclaration = ts.walkUpBindingElementsAndPatterns(node); + ts.Debug.assert(ts.isParameterDeclaration(wrappingDeclaration), "Only parameter declaration should be checked here"); + var diagnostic = ts.createDiagnosticForNode(node.name, ts.Diagnostics._0_is_an_unused_renaming_of_1_Did_you_intend_to_use_it_as_a_type_annotation, ts.declarationNameToString(node.name), ts.declarationNameToString(node.propertyName)); + if (!wrappingDeclaration.type) { + // entire parameter does not have type annotation, suggest adding an annotation + ts.addRelatedInfo(diagnostic, ts.createFileDiagnostic(ts.getSourceFileOfNode(wrappingDeclaration), wrappingDeclaration.end, 1, ts.Diagnostics.We_can_only_write_a_type_for_0_by_adding_a_type_for_the_entire_parameter_here, ts.declarationNameToString(node.propertyName))); + } + diagnostics.add(diagnostic); + } + } + } + function bindingNameText(name) { + switch (name.kind) { + case 79 /* SyntaxKind.Identifier */: + return ts.idText(name); + case 204 /* SyntaxKind.ArrayBindingPattern */: + case 203 /* SyntaxKind.ObjectBindingPattern */: + return bindingNameText(ts.cast(ts.first(name.elements), ts.isBindingElement).name); + default: + return ts.Debug.assertNever(name); + } + } + function isImportedDeclaration(node) { + return node.kind === 270 /* SyntaxKind.ImportClause */ || node.kind === 273 /* SyntaxKind.ImportSpecifier */ || node.kind === 271 /* SyntaxKind.NamespaceImport */; + } + function importClauseFromImported(decl) { + return decl.kind === 270 /* SyntaxKind.ImportClause */ ? decl : decl.kind === 271 /* SyntaxKind.NamespaceImport */ ? decl.parent : decl.parent.parent; + } + function checkBlock(node) { + // Grammar checking for SyntaxKind.Block + if (node.kind === 238 /* SyntaxKind.Block */) { + checkGrammarStatementInAmbientContext(node); + } + if (ts.isFunctionOrModuleBlock(node)) { + var saveFlowAnalysisDisabled = flowAnalysisDisabled; + ts.forEach(node.statements, checkSourceElement); + flowAnalysisDisabled = saveFlowAnalysisDisabled; + } + else { + ts.forEach(node.statements, checkSourceElement); + } + if (node.locals) { + registerForUnusedIdentifiersCheck(node); + } + } + function checkCollisionWithArgumentsInGeneratedCode(node) { + // no rest parameters \ declaration context \ overload - no codegen impact + if (languageVersion >= 2 /* ScriptTarget.ES2015 */ || !ts.hasRestParameter(node) || node.flags & 16777216 /* NodeFlags.Ambient */ || ts.nodeIsMissing(node.body)) { + return; + } + ts.forEach(node.parameters, function (p) { + if (p.name && !ts.isBindingPattern(p.name) && p.name.escapedText === argumentsSymbol.escapedName) { + errorSkippedOn("noEmit", p, ts.Diagnostics.Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters); + } + }); + } + /** + * Checks whether an {@link Identifier}, in the context of another {@link Node}, would collide with a runtime value + * of {@link name} in an outer scope. This is used to check for collisions for downlevel transformations that + * require names like `Object`, `Promise`, `Reflect`, `require`, `exports`, etc. + */ + function needCollisionCheckForIdentifier(node, identifier, name) { + if ((identifier === null || identifier === void 0 ? void 0 : identifier.escapedText) !== name) { + return false; + } + if (node.kind === 169 /* SyntaxKind.PropertyDeclaration */ || + node.kind === 168 /* SyntaxKind.PropertySignature */ || + node.kind === 171 /* SyntaxKind.MethodDeclaration */ || + node.kind === 170 /* SyntaxKind.MethodSignature */ || + node.kind === 174 /* SyntaxKind.GetAccessor */ || + node.kind === 175 /* SyntaxKind.SetAccessor */ || + node.kind === 299 /* SyntaxKind.PropertyAssignment */) { + // it is ok to have member named '_super', '_this', `Promise`, etc. - member access is always qualified + return false; + } + if (node.flags & 16777216 /* NodeFlags.Ambient */) { + // ambient context - no codegen impact + return false; + } + if (ts.isImportClause(node) || ts.isImportEqualsDeclaration(node) || ts.isImportSpecifier(node)) { + // type-only imports do not require collision checks against runtime values. + if (ts.isTypeOnlyImportOrExportDeclaration(node)) { + return false; + } + } + var root = ts.getRootDeclaration(node); + if (ts.isParameter(root) && ts.nodeIsMissing(root.parent.body)) { + // just an overload - no codegen impact + return false; + } + return true; + } + // this function will run after checking the source file so 'CaptureThis' is correct for all nodes + function checkIfThisIsCapturedInEnclosingScope(node) { + ts.findAncestor(node, function (current) { + if (getNodeCheckFlags(current) & 4 /* NodeCheckFlags.CaptureThis */) { + var isDeclaration_1 = node.kind !== 79 /* SyntaxKind.Identifier */; + if (isDeclaration_1) { + error(ts.getNameOfDeclaration(node), ts.Diagnostics.Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference); + } + else { + error(node, ts.Diagnostics.Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference); + } + return true; + } + return false; + }); + } + function checkIfNewTargetIsCapturedInEnclosingScope(node) { + ts.findAncestor(node, function (current) { + if (getNodeCheckFlags(current) & 8 /* NodeCheckFlags.CaptureNewTarget */) { + var isDeclaration_2 = node.kind !== 79 /* SyntaxKind.Identifier */; + if (isDeclaration_2) { + error(ts.getNameOfDeclaration(node), ts.Diagnostics.Duplicate_identifier_newTarget_Compiler_uses_variable_declaration_newTarget_to_capture_new_target_meta_property_reference); + } + else { + error(node, ts.Diagnostics.Expression_resolves_to_variable_declaration_newTarget_that_compiler_uses_to_capture_new_target_meta_property_reference); + } + return true; + } + return false; + }); + } + function checkCollisionWithRequireExportsInGeneratedCode(node, name) { + // No need to check for require or exports for ES6 modules and later + if (moduleKind >= ts.ModuleKind.ES2015 && !(moduleKind >= ts.ModuleKind.Node16 && ts.getSourceFileOfNode(node).impliedNodeFormat === ts.ModuleKind.CommonJS)) { + return; + } + if (!name || !needCollisionCheckForIdentifier(node, name, "require") && !needCollisionCheckForIdentifier(node, name, "exports")) { + return; + } + // Uninstantiated modules shouldnt do this check + if (ts.isModuleDeclaration(node) && ts.getModuleInstanceState(node) !== 1 /* ModuleInstanceState.Instantiated */) { + return; + } + // In case of variable declaration, node.parent is variable statement so look at the variable statement's parent + var parent = getDeclarationContainer(node); + if (parent.kind === 308 /* SyntaxKind.SourceFile */ && ts.isExternalOrCommonJsModule(parent)) { + // If the declaration happens to be in external module, report error that require and exports are reserved keywords + errorSkippedOn("noEmit", name, ts.Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module, ts.declarationNameToString(name), ts.declarationNameToString(name)); + } + } + function checkCollisionWithGlobalPromiseInGeneratedCode(node, name) { + if (!name || languageVersion >= 4 /* ScriptTarget.ES2017 */ || !needCollisionCheckForIdentifier(node, name, "Promise")) { + return; + } + // Uninstantiated modules shouldnt do this check + if (ts.isModuleDeclaration(node) && ts.getModuleInstanceState(node) !== 1 /* ModuleInstanceState.Instantiated */) { + return; + } + // In case of variable declaration, node.parent is variable statement so look at the variable statement's parent + var parent = getDeclarationContainer(node); + if (parent.kind === 308 /* SyntaxKind.SourceFile */ && ts.isExternalOrCommonJsModule(parent) && parent.flags & 2048 /* NodeFlags.HasAsyncFunctions */) { + // If the declaration happens to be in external module, report error that Promise is a reserved identifier. + errorSkippedOn("noEmit", name, ts.Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_functions, ts.declarationNameToString(name), ts.declarationNameToString(name)); + } + } + function recordPotentialCollisionWithWeakMapSetInGeneratedCode(node, name) { + if (languageVersion <= 8 /* ScriptTarget.ES2021 */ + && (needCollisionCheckForIdentifier(node, name, "WeakMap") || needCollisionCheckForIdentifier(node, name, "WeakSet"))) { + potentialWeakMapSetCollisions.push(node); + } + } + function checkWeakMapSetCollision(node) { + var enclosingBlockScope = ts.getEnclosingBlockScopeContainer(node); + if (getNodeCheckFlags(enclosingBlockScope) & 67108864 /* NodeCheckFlags.ContainsClassWithPrivateIdentifiers */) { + ts.Debug.assert(ts.isNamedDeclaration(node) && ts.isIdentifier(node.name) && typeof node.name.escapedText === "string", "The target of a WeakMap/WeakSet collision check should be an identifier"); + errorSkippedOn("noEmit", node, ts.Diagnostics.Compiler_reserves_name_0_when_emitting_private_identifier_downlevel, node.name.escapedText); + } + } + function recordPotentialCollisionWithReflectInGeneratedCode(node, name) { + if (name && languageVersion >= 2 /* ScriptTarget.ES2015 */ && languageVersion <= 8 /* ScriptTarget.ES2021 */ + && needCollisionCheckForIdentifier(node, name, "Reflect")) { + potentialReflectCollisions.push(node); + } + } + function checkReflectCollision(node) { + var hasCollision = false; + if (ts.isClassExpression(node)) { + // ClassExpression names don't contribute to their containers, but do matter for any of their block-scoped members. + for (var _i = 0, _a = node.members; _i < _a.length; _i++) { + var member = _a[_i]; + if (getNodeCheckFlags(member) & 134217728 /* NodeCheckFlags.ContainsSuperPropertyInStaticInitializer */) { + hasCollision = true; + break; + } + } + } + else if (ts.isFunctionExpression(node)) { + // FunctionExpression names don't contribute to their containers, but do matter for their contents + if (getNodeCheckFlags(node) & 134217728 /* NodeCheckFlags.ContainsSuperPropertyInStaticInitializer */) { + hasCollision = true; + } + } + else { + var container = ts.getEnclosingBlockScopeContainer(node); + if (container && getNodeCheckFlags(container) & 134217728 /* NodeCheckFlags.ContainsSuperPropertyInStaticInitializer */) { + hasCollision = true; + } + } + if (hasCollision) { + ts.Debug.assert(ts.isNamedDeclaration(node) && ts.isIdentifier(node.name), "The target of a Reflect collision check should be an identifier"); + errorSkippedOn("noEmit", node, ts.Diagnostics.Duplicate_identifier_0_Compiler_reserves_name_1_when_emitting_super_references_in_static_initializers, ts.declarationNameToString(node.name), "Reflect"); + } + } + function checkCollisionsForDeclarationName(node, name) { + if (!name) + return; + checkCollisionWithRequireExportsInGeneratedCode(node, name); + checkCollisionWithGlobalPromiseInGeneratedCode(node, name); + recordPotentialCollisionWithWeakMapSetInGeneratedCode(node, name); + recordPotentialCollisionWithReflectInGeneratedCode(node, name); + if (ts.isClassLike(node)) { + checkTypeNameIsReserved(name, ts.Diagnostics.Class_name_cannot_be_0); + if (!(node.flags & 16777216 /* NodeFlags.Ambient */)) { + checkClassNameCollisionWithObject(name); + } + } + else if (ts.isEnumDeclaration(node)) { + checkTypeNameIsReserved(name, ts.Diagnostics.Enum_name_cannot_be_0); + } + } + function checkVarDeclaredNamesNotShadowed(node) { + // - ScriptBody : StatementList + // It is a Syntax Error if any element of the LexicallyDeclaredNames of StatementList + // also occurs in the VarDeclaredNames of StatementList. + // - Block : { StatementList } + // It is a Syntax Error if any element of the LexicallyDeclaredNames of StatementList + // also occurs in the VarDeclaredNames of StatementList. + // Variable declarations are hoisted to the top of their function scope. They can shadow + // block scoped declarations, which bind tighter. this will not be flagged as duplicate definition + // by the binder as the declaration scope is different. + // A non-initialized declaration is a no-op as the block declaration will resolve before the var + // declaration. the problem is if the declaration has an initializer. this will act as a write to the + // block declared value. this is fine for let, but not const. + // Only consider declarations with initializers, uninitialized const declarations will not + // step on a let/const variable. + // Do not consider const and const declarations, as duplicate block-scoped declarations + // are handled by the binder. + // We are only looking for const declarations that step on let\const declarations from a + // different scope. e.g.: + // { + // const x = 0; // localDeclarationSymbol obtained after name resolution will correspond to this declaration + // const x = 0; // symbol for this declaration will be 'symbol' + // } + // skip block-scoped variables and parameters + if ((ts.getCombinedNodeFlags(node) & 3 /* NodeFlags.BlockScoped */) !== 0 || ts.isParameterDeclaration(node)) { + return; + } + // skip variable declarations that don't have initializers + // NOTE: in ES6 spec initializer is required in variable declarations where name is binding pattern + // so we'll always treat binding elements as initialized + if (node.kind === 257 /* SyntaxKind.VariableDeclaration */ && !node.initializer) { + return; + } + var symbol = getSymbolOfNode(node); + if (symbol.flags & 1 /* SymbolFlags.FunctionScopedVariable */) { + if (!ts.isIdentifier(node.name)) + return ts.Debug.fail(); + var localDeclarationSymbol = resolveName(node, node.name.escapedText, 3 /* SymbolFlags.Variable */, /*nodeNotFoundErrorMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false); + if (localDeclarationSymbol && + localDeclarationSymbol !== symbol && + localDeclarationSymbol.flags & 2 /* SymbolFlags.BlockScopedVariable */) { + if (getDeclarationNodeFlagsFromSymbol(localDeclarationSymbol) & 3 /* NodeFlags.BlockScoped */) { + var varDeclList = ts.getAncestor(localDeclarationSymbol.valueDeclaration, 258 /* SyntaxKind.VariableDeclarationList */); + var container = varDeclList.parent.kind === 240 /* SyntaxKind.VariableStatement */ && varDeclList.parent.parent + ? varDeclList.parent.parent + : undefined; + // names of block-scoped and function scoped variables can collide only + // if block scoped variable is defined in the function\module\source file scope (because of variable hoisting) + var namesShareScope = container && + (container.kind === 238 /* SyntaxKind.Block */ && ts.isFunctionLike(container.parent) || + container.kind === 265 /* SyntaxKind.ModuleBlock */ || + container.kind === 264 /* SyntaxKind.ModuleDeclaration */ || + container.kind === 308 /* SyntaxKind.SourceFile */); + // here we know that function scoped variable is shadowed by block scoped one + // if they are defined in the same scope - binder has already reported redeclaration error + // otherwise if variable has an initializer - show error that initialization will fail + // since LHS will be block scoped name instead of function scoped + if (!namesShareScope) { + var name = symbolToString(localDeclarationSymbol); + error(node, ts.Diagnostics.Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1, name, name); + } + } + } + } + } + function convertAutoToAny(type) { + return type === autoType ? anyType : type === autoArrayType ? anyArrayType : type; + } + // Check variable, parameter, or property declaration + function checkVariableLikeDeclaration(node) { + var _a; + checkDecorators(node); + if (!ts.isBindingElement(node)) { + checkSourceElement(node.type); + } + // JSDoc `function(string, string): string` syntax results in parameters with no name + if (!node.name) { + return; + } + // For a computed property, just check the initializer and exit + // Do not use hasDynamicName here, because that returns false for well known symbols. + // We want to perform checkComputedPropertyName for all computed properties, including + // well known symbols. + if (node.name.kind === 164 /* SyntaxKind.ComputedPropertyName */) { + checkComputedPropertyName(node.name); + if (ts.hasOnlyExpressionInitializer(node) && node.initializer) { + checkExpressionCached(node.initializer); + } + } + if (ts.isBindingElement(node)) { + if (node.propertyName && + ts.isIdentifier(node.name) && + ts.isParameterDeclaration(node) && + ts.nodeIsMissing(ts.getContainingFunction(node).body)) { + // type F = ({a: string}) => void; + // ^^^^^^ + // variable renaming in function type notation is confusing, + // so we forbid it even if noUnusedLocals is not enabled + potentialUnusedRenamedBindingElementsInTypes.push(node); + return; + } + if (ts.isObjectBindingPattern(node.parent) && node.dotDotDotToken && languageVersion < 5 /* ScriptTarget.ES2018 */) { + checkExternalEmitHelpers(node, 4 /* ExternalEmitHelpers.Rest */); + } + // check computed properties inside property names of binding elements + if (node.propertyName && node.propertyName.kind === 164 /* SyntaxKind.ComputedPropertyName */) { + checkComputedPropertyName(node.propertyName); + } + // check private/protected variable access + var parent = node.parent.parent; + var parentCheckMode = node.dotDotDotToken ? 64 /* CheckMode.RestBindingElement */ : 0 /* CheckMode.Normal */; + var parentType = getTypeForBindingElementParent(parent, parentCheckMode); + var name = node.propertyName || node.name; + if (parentType && !ts.isBindingPattern(name)) { + var exprType = getLiteralTypeFromPropertyName(name); + if (isTypeUsableAsPropertyName(exprType)) { + var nameText = getPropertyNameFromType(exprType); + var property = getPropertyOfType(parentType, nameText); + if (property) { + markPropertyAsReferenced(property, /*nodeForCheckWriteOnly*/ undefined, /*isSelfTypeAccess*/ false); // A destructuring is never a write-only reference. + checkPropertyAccessibility(node, !!parent.initializer && parent.initializer.kind === 106 /* SyntaxKind.SuperKeyword */, /*writing*/ false, parentType, property); + } + } + } + } + // For a binding pattern, check contained binding elements + if (ts.isBindingPattern(node.name)) { + if (node.name.kind === 204 /* SyntaxKind.ArrayBindingPattern */ && languageVersion < 2 /* ScriptTarget.ES2015 */ && compilerOptions.downlevelIteration) { + checkExternalEmitHelpers(node, 512 /* ExternalEmitHelpers.Read */); + } + ts.forEach(node.name.elements, checkSourceElement); + } + // For a parameter declaration with an initializer, error and exit if the containing function doesn't have a body + if (ts.isParameter(node) && node.initializer && ts.nodeIsMissing(ts.getContainingFunction(node).body)) { + error(node, ts.Diagnostics.A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation); + return; + } + // For a binding pattern, validate the initializer and exit + if (ts.isBindingPattern(node.name)) { + var needCheckInitializer = ts.hasOnlyExpressionInitializer(node) && node.initializer && node.parent.parent.kind !== 246 /* SyntaxKind.ForInStatement */; + var needCheckWidenedType = !ts.some(node.name.elements, ts.not(ts.isOmittedExpression)); + if (needCheckInitializer || needCheckWidenedType) { + // Don't validate for-in initializer as it is already an error + var widenedType = getWidenedTypeForVariableLikeDeclaration(node); + if (needCheckInitializer) { + var initializerType = checkExpressionCached(node.initializer); + if (strictNullChecks && needCheckWidenedType) { + checkNonNullNonVoidType(initializerType, node); + } + else { + checkTypeAssignableToAndOptionallyElaborate(initializerType, getWidenedTypeForVariableLikeDeclaration(node), node, node.initializer); + } + } + // check the binding pattern with empty elements + if (needCheckWidenedType) { + if (ts.isArrayBindingPattern(node.name)) { + checkIteratedTypeOrElementType(65 /* IterationUse.Destructuring */, widenedType, undefinedType, node); + } + else if (strictNullChecks) { + checkNonNullNonVoidType(widenedType, node); + } + } + } + return; + } + // For a commonjs `const x = require`, validate the alias and exit + var symbol = getSymbolOfNode(node); + if (symbol.flags & 2097152 /* SymbolFlags.Alias */ && ts.isVariableDeclarationInitializedToBareOrAccessedRequire(node.kind === 205 /* SyntaxKind.BindingElement */ ? node.parent.parent : node)) { + checkAliasSymbol(node); + return; + } + var type = convertAutoToAny(getTypeOfSymbol(symbol)); + if (node === symbol.valueDeclaration) { + // Node is the primary declaration of the symbol, just validate the initializer + // Don't validate for-in initializer as it is already an error + var initializer = ts.hasOnlyExpressionInitializer(node) && ts.getEffectiveInitializer(node); + if (initializer) { + var isJSObjectLiteralInitializer = ts.isInJSFile(node) && + ts.isObjectLiteralExpression(initializer) && + (initializer.properties.length === 0 || ts.isPrototypeAccess(node.name)) && + !!((_a = symbol.exports) === null || _a === void 0 ? void 0 : _a.size); + if (!isJSObjectLiteralInitializer && node.parent.parent.kind !== 246 /* SyntaxKind.ForInStatement */) { + checkTypeAssignableToAndOptionallyElaborate(checkExpressionCached(initializer), type, node, initializer, /*headMessage*/ undefined); + } + } + if (symbol.declarations && symbol.declarations.length > 1) { + if (ts.some(symbol.declarations, function (d) { return d !== node && ts.isVariableLike(d) && !areDeclarationFlagsIdentical(d, node); })) { + error(node.name, ts.Diagnostics.All_declarations_of_0_must_have_identical_modifiers, ts.declarationNameToString(node.name)); + } + } + } + else { + // Node is a secondary declaration, check that type is identical to primary declaration and check that + // initializer is consistent with type associated with the node + var declarationType = convertAutoToAny(getWidenedTypeForVariableLikeDeclaration(node)); + if (!isErrorType(type) && !isErrorType(declarationType) && + !isTypeIdenticalTo(type, declarationType) && + !(symbol.flags & 67108864 /* SymbolFlags.Assignment */)) { + errorNextVariableOrPropertyDeclarationMustHaveSameType(symbol.valueDeclaration, type, node, declarationType); + } + if (ts.hasOnlyExpressionInitializer(node) && node.initializer) { + checkTypeAssignableToAndOptionallyElaborate(checkExpressionCached(node.initializer), declarationType, node, node.initializer, /*headMessage*/ undefined); + } + if (symbol.valueDeclaration && !areDeclarationFlagsIdentical(node, symbol.valueDeclaration)) { + error(node.name, ts.Diagnostics.All_declarations_of_0_must_have_identical_modifiers, ts.declarationNameToString(node.name)); + } + } + if (node.kind !== 169 /* SyntaxKind.PropertyDeclaration */ && node.kind !== 168 /* SyntaxKind.PropertySignature */) { + // We know we don't have a binding pattern or computed name here + checkExportsOnMergedDeclarations(node); + if (node.kind === 257 /* SyntaxKind.VariableDeclaration */ || node.kind === 205 /* SyntaxKind.BindingElement */) { + checkVarDeclaredNamesNotShadowed(node); + } + checkCollisionsForDeclarationName(node, node.name); + } + } + function errorNextVariableOrPropertyDeclarationMustHaveSameType(firstDeclaration, firstType, nextDeclaration, nextType) { + var nextDeclarationName = ts.getNameOfDeclaration(nextDeclaration); + var message = nextDeclaration.kind === 169 /* SyntaxKind.PropertyDeclaration */ || nextDeclaration.kind === 168 /* SyntaxKind.PropertySignature */ + ? ts.Diagnostics.Subsequent_property_declarations_must_have_the_same_type_Property_0_must_be_of_type_1_but_here_has_type_2 + : ts.Diagnostics.Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2; + var declName = ts.declarationNameToString(nextDeclarationName); + var err = error(nextDeclarationName, message, declName, typeToString(firstType), typeToString(nextType)); + if (firstDeclaration) { + ts.addRelatedInfo(err, ts.createDiagnosticForNode(firstDeclaration, ts.Diagnostics._0_was_also_declared_here, declName)); + } + } + function areDeclarationFlagsIdentical(left, right) { + if ((left.kind === 166 /* SyntaxKind.Parameter */ && right.kind === 257 /* SyntaxKind.VariableDeclaration */) || + (left.kind === 257 /* SyntaxKind.VariableDeclaration */ && right.kind === 166 /* SyntaxKind.Parameter */)) { + // Differences in optionality between parameters and variables are allowed. + return true; + } + if (ts.hasQuestionToken(left) !== ts.hasQuestionToken(right)) { + return false; + } + var interestingFlags = 8 /* ModifierFlags.Private */ | + 16 /* ModifierFlags.Protected */ | + 512 /* ModifierFlags.Async */ | + 256 /* ModifierFlags.Abstract */ | + 64 /* ModifierFlags.Readonly */ | + 32 /* ModifierFlags.Static */; + return ts.getSelectedEffectiveModifierFlags(left, interestingFlags) === ts.getSelectedEffectiveModifierFlags(right, interestingFlags); + } + function checkVariableDeclaration(node) { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("check" /* tracing.Phase.Check */, "checkVariableDeclaration", { kind: node.kind, pos: node.pos, end: node.end, path: node.tracingPath }); + checkGrammarVariableDeclaration(node); + checkVariableLikeDeclaration(node); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + } + function checkBindingElement(node) { + checkGrammarBindingElement(node); + return checkVariableLikeDeclaration(node); + } + function checkVariableStatement(node) { + // Grammar checking + if (!checkGrammarDecoratorsAndModifiers(node) && !checkGrammarVariableDeclarationList(node.declarationList)) + checkGrammarForDisallowedLetOrConstStatement(node); + ts.forEach(node.declarationList.declarations, checkSourceElement); + } + function checkExpressionStatement(node) { + // Grammar checking + checkGrammarStatementInAmbientContext(node); + checkExpression(node.expression); + } + function checkIfStatement(node) { + // Grammar checking + checkGrammarStatementInAmbientContext(node); + var type = checkTruthinessExpression(node.expression); + checkTestingKnownTruthyCallableOrAwaitableType(node.expression, type, node.thenStatement); + checkSourceElement(node.thenStatement); + if (node.thenStatement.kind === 239 /* SyntaxKind.EmptyStatement */) { + error(node.thenStatement, ts.Diagnostics.The_body_of_an_if_statement_cannot_be_the_empty_statement); + } + checkSourceElement(node.elseStatement); + } + function checkTestingKnownTruthyCallableOrAwaitableType(condExpr, condType, body) { + if (!strictNullChecks) + return; + helper(condExpr, body); + while (ts.isBinaryExpression(condExpr) && condExpr.operatorToken.kind === 56 /* SyntaxKind.BarBarToken */) { + condExpr = condExpr.left; + helper(condExpr, body); + } + function helper(condExpr, body) { + var location = ts.isBinaryExpression(condExpr) && + (condExpr.operatorToken.kind === 56 /* SyntaxKind.BarBarToken */ || condExpr.operatorToken.kind === 55 /* SyntaxKind.AmpersandAmpersandToken */) + ? condExpr.right + : condExpr; + if (ts.isModuleExportsAccessExpression(location)) + return; + var type = location === condExpr ? condType : checkTruthinessExpression(location); + var isPropertyExpressionCast = ts.isPropertyAccessExpression(location) && isTypeAssertion(location.expression); + if (!(getTypeFacts(type) & 4194304 /* TypeFacts.Truthy */) || isPropertyExpressionCast) + return; + // While it technically should be invalid for any known-truthy value + // to be tested, we de-scope to functions and Promises unreferenced in + // the block as a heuristic to identify the most common bugs. There + // are too many false positives for values sourced from type + // definitions without strictNullChecks otherwise. + var callSignatures = getSignaturesOfType(type, 0 /* SignatureKind.Call */); + var isPromise = !!getAwaitedTypeOfPromise(type); + if (callSignatures.length === 0 && !isPromise) { + return; + } + var testedNode = ts.isIdentifier(location) ? location + : ts.isPropertyAccessExpression(location) ? location.name + : ts.isBinaryExpression(location) && ts.isIdentifier(location.right) ? location.right + : undefined; + var testedSymbol = testedNode && getSymbolAtLocation(testedNode); + if (!testedSymbol && !isPromise) { + return; + } + var isUsed = testedSymbol && ts.isBinaryExpression(condExpr.parent) && isSymbolUsedInBinaryExpressionChain(condExpr.parent, testedSymbol) + || testedSymbol && body && isSymbolUsedInConditionBody(condExpr, body, testedNode, testedSymbol); + if (!isUsed) { + if (isPromise) { + errorAndMaybeSuggestAwait(location, + /*maybeMissingAwait*/ true, ts.Diagnostics.This_condition_will_always_return_true_since_this_0_is_always_defined, getTypeNameForErrorDisplay(type)); + } + else { + error(location, ts.Diagnostics.This_condition_will_always_return_true_since_this_function_is_always_defined_Did_you_mean_to_call_it_instead); + } + } + } + } + function isSymbolUsedInConditionBody(expr, body, testedNode, testedSymbol) { + return !!ts.forEachChild(body, function check(childNode) { + if (ts.isIdentifier(childNode)) { + var childSymbol = getSymbolAtLocation(childNode); + if (childSymbol && childSymbol === testedSymbol) { + // If the test was a simple identifier, the above check is sufficient + if (ts.isIdentifier(expr) || ts.isIdentifier(testedNode) && ts.isBinaryExpression(testedNode.parent)) { + return true; + } + // Otherwise we need to ensure the symbol is called on the same target + var testedExpression = testedNode.parent; + var childExpression = childNode.parent; + while (testedExpression && childExpression) { + if (ts.isIdentifier(testedExpression) && ts.isIdentifier(childExpression) || + testedExpression.kind === 108 /* SyntaxKind.ThisKeyword */ && childExpression.kind === 108 /* SyntaxKind.ThisKeyword */) { + return getSymbolAtLocation(testedExpression) === getSymbolAtLocation(childExpression); + } + else if (ts.isPropertyAccessExpression(testedExpression) && ts.isPropertyAccessExpression(childExpression)) { + if (getSymbolAtLocation(testedExpression.name) !== getSymbolAtLocation(childExpression.name)) { + return false; + } + childExpression = childExpression.expression; + testedExpression = testedExpression.expression; + } + else if (ts.isCallExpression(testedExpression) && ts.isCallExpression(childExpression)) { + childExpression = childExpression.expression; + testedExpression = testedExpression.expression; + } + else { + return false; + } + } + } + } + return ts.forEachChild(childNode, check); + }); + } + function isSymbolUsedInBinaryExpressionChain(node, testedSymbol) { + while (ts.isBinaryExpression(node) && node.operatorToken.kind === 55 /* SyntaxKind.AmpersandAmpersandToken */) { + var isUsed = ts.forEachChild(node.right, function visit(child) { + if (ts.isIdentifier(child)) { + var symbol = getSymbolAtLocation(child); + if (symbol && symbol === testedSymbol) { + return true; + } + } + return ts.forEachChild(child, visit); + }); + if (isUsed) { + return true; + } + node = node.parent; + } + return false; + } + function checkDoStatement(node) { + // Grammar checking + checkGrammarStatementInAmbientContext(node); + checkSourceElement(node.statement); + checkTruthinessExpression(node.expression); + } + function checkWhileStatement(node) { + // Grammar checking + checkGrammarStatementInAmbientContext(node); + checkTruthinessExpression(node.expression); + checkSourceElement(node.statement); + } + function checkTruthinessOfType(type, node) { + if (type.flags & 16384 /* TypeFlags.Void */) { + error(node, ts.Diagnostics.An_expression_of_type_void_cannot_be_tested_for_truthiness); + } + return type; + } + function checkTruthinessExpression(node, checkMode) { + return checkTruthinessOfType(checkExpression(node, checkMode), node); + } + function checkForStatement(node) { + // Grammar checking + if (!checkGrammarStatementInAmbientContext(node)) { + if (node.initializer && node.initializer.kind === 258 /* SyntaxKind.VariableDeclarationList */) { + checkGrammarVariableDeclarationList(node.initializer); + } + } + if (node.initializer) { + if (node.initializer.kind === 258 /* SyntaxKind.VariableDeclarationList */) { + ts.forEach(node.initializer.declarations, checkVariableDeclaration); + } + else { + checkExpression(node.initializer); + } + } + if (node.condition) + checkTruthinessExpression(node.condition); + if (node.incrementor) + checkExpression(node.incrementor); + checkSourceElement(node.statement); + if (node.locals) { + registerForUnusedIdentifiersCheck(node); + } + } + function checkForOfStatement(node) { + checkGrammarForInOrForOfStatement(node); + var container = ts.getContainingFunctionOrClassStaticBlock(node); + if (node.awaitModifier) { + if (container && ts.isClassStaticBlockDeclaration(container)) { + grammarErrorOnNode(node.awaitModifier, ts.Diagnostics.For_await_loops_cannot_be_used_inside_a_class_static_block); + } + else { + var functionFlags = ts.getFunctionFlags(container); + if ((functionFlags & (4 /* FunctionFlags.Invalid */ | 2 /* FunctionFlags.Async */)) === 2 /* FunctionFlags.Async */ && languageVersion < 99 /* ScriptTarget.ESNext */) { + // for..await..of in an async function or async generator function prior to ESNext requires the __asyncValues helper + checkExternalEmitHelpers(node, 16384 /* ExternalEmitHelpers.ForAwaitOfIncludes */); + } + } + } + else if (compilerOptions.downlevelIteration && languageVersion < 2 /* ScriptTarget.ES2015 */) { + // for..of prior to ES2015 requires the __values helper when downlevelIteration is enabled + checkExternalEmitHelpers(node, 256 /* ExternalEmitHelpers.ForOfIncludes */); + } + // Check the LHS and RHS + // If the LHS is a declaration, just check it as a variable declaration, which will in turn check the RHS + // via checkRightHandSideOfForOf. + // If the LHS is an expression, check the LHS, as a destructuring assignment or as a reference. + // Then check that the RHS is assignable to it. + if (node.initializer.kind === 258 /* SyntaxKind.VariableDeclarationList */) { + checkForInOrForOfVariableDeclaration(node); + } + else { + var varExpr = node.initializer; + var iteratedType = checkRightHandSideOfForOf(node); + // There may be a destructuring assignment on the left side + if (varExpr.kind === 206 /* SyntaxKind.ArrayLiteralExpression */ || varExpr.kind === 207 /* SyntaxKind.ObjectLiteralExpression */) { + // iteratedType may be undefined. In this case, we still want to check the structure of + // varExpr, in particular making sure it's a valid LeftHandSideExpression. But we'd like + // to short circuit the type relation checking as much as possible, so we pass the unknownType. + checkDestructuringAssignment(varExpr, iteratedType || errorType); + } + else { + var leftType = checkExpression(varExpr); + checkReferenceExpression(varExpr, ts.Diagnostics.The_left_hand_side_of_a_for_of_statement_must_be_a_variable_or_a_property_access, ts.Diagnostics.The_left_hand_side_of_a_for_of_statement_may_not_be_an_optional_property_access); + // iteratedType will be undefined if the rightType was missing properties/signatures + // required to get its iteratedType (like [Symbol.iterator] or next). This may be + // because we accessed properties from anyType, or it may have led to an error inside + // getElementTypeOfIterable. + if (iteratedType) { + checkTypeAssignableToAndOptionallyElaborate(iteratedType, leftType, varExpr, node.expression); + } + } + } + checkSourceElement(node.statement); + if (node.locals) { + registerForUnusedIdentifiersCheck(node); + } + } + function checkForInStatement(node) { + // Grammar checking + checkGrammarForInOrForOfStatement(node); + var rightType = getNonNullableTypeIfNeeded(checkExpression(node.expression)); + // TypeScript 1.0 spec (April 2014): 5.4 + // In a 'for-in' statement of the form + // for (let VarDecl in Expr) Statement + // VarDecl must be a variable declaration without a type annotation that declares a variable of type Any, + // and Expr must be an expression of type Any, an object type, or a type parameter type. + if (node.initializer.kind === 258 /* SyntaxKind.VariableDeclarationList */) { + var variable = node.initializer.declarations[0]; + if (variable && ts.isBindingPattern(variable.name)) { + error(variable.name, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern); + } + checkForInOrForOfVariableDeclaration(node); + } + else { + // In a 'for-in' statement of the form + // for (Var in Expr) Statement + // Var must be an expression classified as a reference of type Any or the String primitive type, + // and Expr must be an expression of type Any, an object type, or a type parameter type. + var varExpr = node.initializer; + var leftType = checkExpression(varExpr); + if (varExpr.kind === 206 /* SyntaxKind.ArrayLiteralExpression */ || varExpr.kind === 207 /* SyntaxKind.ObjectLiteralExpression */) { + error(varExpr, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern); + } + else if (!isTypeAssignableTo(getIndexTypeOrString(rightType), leftType)) { + error(varExpr, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any); + } + else { + // run check only former check succeeded to avoid cascading errors + checkReferenceExpression(varExpr, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_must_be_a_variable_or_a_property_access, ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_may_not_be_an_optional_property_access); + } + } + // unknownType is returned i.e. if node.expression is identifier whose name cannot be resolved + // in this case error about missing name is already reported - do not report extra one + if (rightType === neverType || !isTypeAssignableToKind(rightType, 67108864 /* TypeFlags.NonPrimitive */ | 58982400 /* TypeFlags.InstantiableNonPrimitive */)) { + error(node.expression, ts.Diagnostics.The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter_but_here_has_type_0, typeToString(rightType)); + } + checkSourceElement(node.statement); + if (node.locals) { + registerForUnusedIdentifiersCheck(node); + } + } + function checkForInOrForOfVariableDeclaration(iterationStatement) { + var variableDeclarationList = iterationStatement.initializer; + // checkGrammarForInOrForOfStatement will check that there is exactly one declaration. + if (variableDeclarationList.declarations.length >= 1) { + var decl = variableDeclarationList.declarations[0]; + checkVariableDeclaration(decl); + } + } + function checkRightHandSideOfForOf(statement) { + var use = statement.awaitModifier ? 15 /* IterationUse.ForAwaitOf */ : 13 /* IterationUse.ForOf */; + return checkIteratedTypeOrElementType(use, checkNonNullExpression(statement.expression), undefinedType, statement.expression); + } + function checkIteratedTypeOrElementType(use, inputType, sentType, errorNode) { + if (isTypeAny(inputType)) { + return inputType; + } + return getIteratedTypeOrElementType(use, inputType, sentType, errorNode, /*checkAssignability*/ true) || anyType; + } + /** + * When consuming an iterable type in a for..of, spread, or iterator destructuring assignment + * we want to get the iterated type of an iterable for ES2015 or later, or the iterated type + * of a iterable (if defined globally) or element type of an array like for ES2015 or earlier. + */ + function getIteratedTypeOrElementType(use, inputType, sentType, errorNode, checkAssignability) { + var allowAsyncIterables = (use & 2 /* IterationUse.AllowsAsyncIterablesFlag */) !== 0; + if (inputType === neverType) { + reportTypeNotIterableError(errorNode, inputType, allowAsyncIterables); // TODO: GH#18217 + return undefined; + } + var uplevelIteration = languageVersion >= 2 /* ScriptTarget.ES2015 */; + var downlevelIteration = !uplevelIteration && compilerOptions.downlevelIteration; + var possibleOutOfBounds = compilerOptions.noUncheckedIndexedAccess && !!(use & 128 /* IterationUse.PossiblyOutOfBounds */); + // Get the iterated type of an `Iterable` or `IterableIterator` only in ES2015 + // or higher, when inside of an async generator or for-await-if, or when + // downlevelIteration is requested. + if (uplevelIteration || downlevelIteration || allowAsyncIterables) { + // We only report errors for an invalid iterable type in ES2015 or higher. + var iterationTypes = getIterationTypesOfIterable(inputType, use, uplevelIteration ? errorNode : undefined); + if (checkAssignability) { + if (iterationTypes) { + var diagnostic = use & 8 /* IterationUse.ForOfFlag */ ? ts.Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_for_of_will_always_send_0 : + use & 32 /* IterationUse.SpreadFlag */ ? ts.Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_spread_will_always_send_0 : + use & 64 /* IterationUse.DestructuringFlag */ ? ts.Diagnostics.Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_destructuring_will_always_send_0 : + use & 16 /* IterationUse.YieldStarFlag */ ? ts.Diagnostics.Cannot_delegate_iteration_to_value_because_the_next_method_of_its_iterator_expects_type_1_but_the_containing_generator_will_always_send_0 : + undefined; + if (diagnostic) { + checkTypeAssignableTo(sentType, iterationTypes.nextType, errorNode, diagnostic); + } + } + } + if (iterationTypes || uplevelIteration) { + return possibleOutOfBounds ? includeUndefinedInIndexSignature(iterationTypes && iterationTypes.yieldType) : (iterationTypes && iterationTypes.yieldType); + } + } + var arrayType = inputType; + var reportedError = false; + var hasStringConstituent = false; + // If strings are permitted, remove any string-like constituents from the array type. + // This allows us to find other non-string element types from an array unioned with + // a string. + if (use & 4 /* IterationUse.AllowsStringInputFlag */) { + if (arrayType.flags & 1048576 /* TypeFlags.Union */) { + // After we remove all types that are StringLike, we will know if there was a string constituent + // based on whether the result of filter is a new array. + var arrayTypes = inputType.types; + var filteredTypes = ts.filter(arrayTypes, function (t) { return !(t.flags & 402653316 /* TypeFlags.StringLike */); }); + if (filteredTypes !== arrayTypes) { + arrayType = getUnionType(filteredTypes, 2 /* UnionReduction.Subtype */); + } + } + else if (arrayType.flags & 402653316 /* TypeFlags.StringLike */) { + arrayType = neverType; + } + hasStringConstituent = arrayType !== inputType; + if (hasStringConstituent) { + if (languageVersion < 1 /* ScriptTarget.ES5 */) { + if (errorNode) { + error(errorNode, ts.Diagnostics.Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher); + reportedError = true; + } + } + // Now that we've removed all the StringLike types, if no constituents remain, then the entire + // arrayOrStringType was a string. + if (arrayType.flags & 131072 /* TypeFlags.Never */) { + return possibleOutOfBounds ? includeUndefinedInIndexSignature(stringType) : stringType; + } + } + } + if (!isArrayLikeType(arrayType)) { + if (errorNode && !reportedError) { + // Which error we report depends on whether we allow strings or if there was a + // string constituent. For example, if the input type is number | string, we + // want to say that number is not an array type. But if the input was just + // number and string input is allowed, we want to say that number is not an + // array type or a string type. + var allowsStrings = !!(use & 4 /* IterationUse.AllowsStringInputFlag */) && !hasStringConstituent; + var _a = getIterationDiagnosticDetails(allowsStrings, downlevelIteration), defaultDiagnostic = _a[0], maybeMissingAwait = _a[1]; + errorAndMaybeSuggestAwait(errorNode, maybeMissingAwait && !!getAwaitedTypeOfPromise(arrayType), defaultDiagnostic, typeToString(arrayType)); + } + return hasStringConstituent ? possibleOutOfBounds ? includeUndefinedInIndexSignature(stringType) : stringType : undefined; + } + var arrayElementType = getIndexTypeOfType(arrayType, numberType); + if (hasStringConstituent && arrayElementType) { + // This is just an optimization for the case where arrayOrStringType is string | string[] + if (arrayElementType.flags & 402653316 /* TypeFlags.StringLike */ && !compilerOptions.noUncheckedIndexedAccess) { + return stringType; + } + return getUnionType(possibleOutOfBounds ? [arrayElementType, stringType, undefinedType] : [arrayElementType, stringType], 2 /* UnionReduction.Subtype */); + } + return (use & 128 /* IterationUse.PossiblyOutOfBounds */) ? includeUndefinedInIndexSignature(arrayElementType) : arrayElementType; + function getIterationDiagnosticDetails(allowsStrings, downlevelIteration) { + var _a; + if (downlevelIteration) { + return allowsStrings + ? [ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator, true] + : [ts.Diagnostics.Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator, true]; + } + var yieldType = getIterationTypeOfIterable(use, 0 /* IterationTypeKind.Yield */, inputType, /*errorNode*/ undefined); + if (yieldType) { + return [ts.Diagnostics.Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher, false]; + } + if (isES2015OrLaterIterable((_a = inputType.symbol) === null || _a === void 0 ? void 0 : _a.escapedName)) { + return [ts.Diagnostics.Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher, true]; + } + return allowsStrings + ? [ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type, true] + : [ts.Diagnostics.Type_0_is_not_an_array_type, true]; + } + } + function isES2015OrLaterIterable(n) { + switch (n) { + case "Float32Array": + case "Float64Array": + case "Int16Array": + case "Int32Array": + case "Int8Array": + case "NodeList": + case "Uint16Array": + case "Uint32Array": + case "Uint8Array": + case "Uint8ClampedArray": + return true; + } + return false; + } + /** + * Gets the requested "iteration type" from an `Iterable`-like or `AsyncIterable`-like type. + */ + function getIterationTypeOfIterable(use, typeKind, inputType, errorNode) { + if (isTypeAny(inputType)) { + return undefined; + } + var iterationTypes = getIterationTypesOfIterable(inputType, use, errorNode); + return iterationTypes && iterationTypes[getIterationTypesKeyFromIterationTypeKind(typeKind)]; + } + function createIterationTypes(yieldType, returnType, nextType) { + // `yieldType` and `returnType` are defaulted to `neverType` they each will be combined + // via `getUnionType` when merging iteration types. `nextType` is defined as `unknownType` + // as it is combined via `getIntersectionType` when merging iteration types. + if (yieldType === void 0) { yieldType = neverType; } + if (returnType === void 0) { returnType = neverType; } + if (nextType === void 0) { nextType = unknownType; } + // Use the cache only for intrinsic types to keep it small as they are likely to be + // more frequently created (i.e. `Iterator`). Iteration types + // are also cached on the type they are requested for, so we shouldn't need to maintain + // the cache for less-frequently used types. + if (yieldType.flags & 67359327 /* TypeFlags.Intrinsic */ && + returnType.flags & (1 /* TypeFlags.Any */ | 131072 /* TypeFlags.Never */ | 2 /* TypeFlags.Unknown */ | 16384 /* TypeFlags.Void */ | 32768 /* TypeFlags.Undefined */) && + nextType.flags & (1 /* TypeFlags.Any */ | 131072 /* TypeFlags.Never */ | 2 /* TypeFlags.Unknown */ | 16384 /* TypeFlags.Void */ | 32768 /* TypeFlags.Undefined */)) { + var id = getTypeListId([yieldType, returnType, nextType]); + var iterationTypes = iterationTypesCache.get(id); + if (!iterationTypes) { + iterationTypes = { yieldType: yieldType, returnType: returnType, nextType: nextType }; + iterationTypesCache.set(id, iterationTypes); + } + return iterationTypes; + } + return { yieldType: yieldType, returnType: returnType, nextType: nextType }; + } + /** + * Combines multiple `IterationTypes` records. + * + * If `array` is empty or all elements are missing or are references to `noIterationTypes`, + * then `noIterationTypes` is returned. Otherwise, an `IterationTypes` record is returned + * for the combined iteration types. + */ + function combineIterationTypes(array) { + var yieldTypes; + var returnTypes; + var nextTypes; + for (var _i = 0, array_11 = array; _i < array_11.length; _i++) { + var iterationTypes = array_11[_i]; + if (iterationTypes === undefined || iterationTypes === noIterationTypes) { + continue; + } + if (iterationTypes === anyIterationTypes) { + return anyIterationTypes; + } + yieldTypes = ts.append(yieldTypes, iterationTypes.yieldType); + returnTypes = ts.append(returnTypes, iterationTypes.returnType); + nextTypes = ts.append(nextTypes, iterationTypes.nextType); + } + if (yieldTypes || returnTypes || nextTypes) { + return createIterationTypes(yieldTypes && getUnionType(yieldTypes), returnTypes && getUnionType(returnTypes), nextTypes && getIntersectionType(nextTypes)); + } + return noIterationTypes; + } + function getCachedIterationTypes(type, cacheKey) { + return type[cacheKey]; + } + function setCachedIterationTypes(type, cacheKey, cachedTypes) { + return type[cacheKey] = cachedTypes; + } + /** + * Gets the *yield*, *return*, and *next* types from an `Iterable`-like or `AsyncIterable`-like type. + * + * At every level that involves analyzing return types of signatures, we union the return types of all the signatures. + * + * Another thing to note is that at any step of this process, we could run into a dead end, + * meaning either the property is missing, or we run into the anyType. If either of these things + * happens, we return `undefined` to signal that we could not find the iteration type. If a property + * is missing, and the previous step did not result in `any`, then we also give an error if the + * caller requested it. Then the caller can decide what to do in the case where there is no iterated + * type. + * + * For a **for-of** statement, `yield*` (in a normal generator), spread, array + * destructuring, or normal generator we will only ever look for a `[Symbol.iterator]()` + * method. + * + * For an async generator we will only ever look at the `[Symbol.asyncIterator]()` method. + * + * For a **for-await-of** statement or a `yield*` in an async generator we will look for + * the `[Symbol.asyncIterator]()` method first, and then the `[Symbol.iterator]()` method. + */ + function getIterationTypesOfIterable(type, use, errorNode) { + var _a, _b; + if (isTypeAny(type)) { + return anyIterationTypes; + } + if (!(type.flags & 1048576 /* TypeFlags.Union */)) { + var errorOutputContainer = errorNode ? { errors: undefined } : undefined; + var iterationTypes_1 = getIterationTypesOfIterableWorker(type, use, errorNode, errorOutputContainer); + if (iterationTypes_1 === noIterationTypes) { + if (errorNode) { + var rootDiag = reportTypeNotIterableError(errorNode, type, !!(use & 2 /* IterationUse.AllowsAsyncIterablesFlag */)); + if (errorOutputContainer === null || errorOutputContainer === void 0 ? void 0 : errorOutputContainer.errors) { + ts.addRelatedInfo.apply(void 0, __spreadArray([rootDiag], errorOutputContainer.errors, false)); + } + } + return undefined; + } + else if ((_a = errorOutputContainer === null || errorOutputContainer === void 0 ? void 0 : errorOutputContainer.errors) === null || _a === void 0 ? void 0 : _a.length) { + for (var _i = 0, _c = errorOutputContainer.errors; _i < _c.length; _i++) { + var diag = _c[_i]; + diagnostics.add(diag); + } + } + return iterationTypes_1; + } + var cacheKey = use & 2 /* IterationUse.AllowsAsyncIterablesFlag */ ? "iterationTypesOfAsyncIterable" : "iterationTypesOfIterable"; + var cachedTypes = getCachedIterationTypes(type, cacheKey); + if (cachedTypes) + return cachedTypes === noIterationTypes ? undefined : cachedTypes; + var allIterationTypes; + for (var _d = 0, _e = type.types; _d < _e.length; _d++) { + var constituent = _e[_d]; + var errorOutputContainer = errorNode ? { errors: undefined } : undefined; + var iterationTypes_2 = getIterationTypesOfIterableWorker(constituent, use, errorNode, errorOutputContainer); + if (iterationTypes_2 === noIterationTypes) { + if (errorNode) { + var rootDiag = reportTypeNotIterableError(errorNode, type, !!(use & 2 /* IterationUse.AllowsAsyncIterablesFlag */)); + if (errorOutputContainer === null || errorOutputContainer === void 0 ? void 0 : errorOutputContainer.errors) { + ts.addRelatedInfo.apply(void 0, __spreadArray([rootDiag], errorOutputContainer.errors, false)); + } + } + setCachedIterationTypes(type, cacheKey, noIterationTypes); + return undefined; + } + else if ((_b = errorOutputContainer === null || errorOutputContainer === void 0 ? void 0 : errorOutputContainer.errors) === null || _b === void 0 ? void 0 : _b.length) { + for (var _f = 0, _g = errorOutputContainer.errors; _f < _g.length; _f++) { + var diag = _g[_f]; + diagnostics.add(diag); + } + } + allIterationTypes = ts.append(allIterationTypes, iterationTypes_2); + } + var iterationTypes = allIterationTypes ? combineIterationTypes(allIterationTypes) : noIterationTypes; + setCachedIterationTypes(type, cacheKey, iterationTypes); + return iterationTypes === noIterationTypes ? undefined : iterationTypes; + } + function getAsyncFromSyncIterationTypes(iterationTypes, errorNode) { + if (iterationTypes === noIterationTypes) + return noIterationTypes; + if (iterationTypes === anyIterationTypes) + return anyIterationTypes; + var yieldType = iterationTypes.yieldType, returnType = iterationTypes.returnType, nextType = iterationTypes.nextType; + // if we're requesting diagnostics, report errors for a missing `Awaited`. + if (errorNode) { + getGlobalAwaitedSymbol(/*reportErrors*/ true); + } + return createIterationTypes(getAwaitedType(yieldType, errorNode) || anyType, getAwaitedType(returnType, errorNode) || anyType, nextType); + } + /** + * Gets the *yield*, *return*, and *next* types from a non-union type. + * + * If we are unable to find the *yield*, *return*, and *next* types, `noIterationTypes` is + * returned to indicate to the caller that it should report an error. Otherwise, an + * `IterationTypes` record is returned. + * + * NOTE: You probably don't want to call this directly and should be calling + * `getIterationTypesOfIterable` instead. + */ + function getIterationTypesOfIterableWorker(type, use, errorNode, errorOutputContainer) { + if (isTypeAny(type)) { + return anyIterationTypes; + } + // If we are reporting errors and encounter a cached `noIterationTypes`, we should ignore the cached value and continue as if nothing was cached. + // In addition, we should not cache any new results for this call. + var noCache = false; + if (use & 2 /* IterationUse.AllowsAsyncIterablesFlag */) { + var iterationTypes = getIterationTypesOfIterableCached(type, asyncIterationTypesResolver) || + getIterationTypesOfIterableFast(type, asyncIterationTypesResolver); + if (iterationTypes) { + if (iterationTypes === noIterationTypes && errorNode) { + // ignore the cached value + noCache = true; + } + else { + return use & 8 /* IterationUse.ForOfFlag */ ? + getAsyncFromSyncIterationTypes(iterationTypes, errorNode) : + iterationTypes; + } + } + } + if (use & 1 /* IterationUse.AllowsSyncIterablesFlag */) { + var iterationTypes = getIterationTypesOfIterableCached(type, syncIterationTypesResolver) || + getIterationTypesOfIterableFast(type, syncIterationTypesResolver); + if (iterationTypes) { + if (iterationTypes === noIterationTypes && errorNode) { + // ignore the cached value + noCache = true; + } + else { + if (use & 2 /* IterationUse.AllowsAsyncIterablesFlag */) { + // for a sync iterable in an async context, only use the cached types if they are valid. + if (iterationTypes !== noIterationTypes) { + iterationTypes = getAsyncFromSyncIterationTypes(iterationTypes, errorNode); + return noCache ? iterationTypes : setCachedIterationTypes(type, "iterationTypesOfAsyncIterable", iterationTypes); + } + } + else { + return iterationTypes; + } + } + } + } + if (use & 2 /* IterationUse.AllowsAsyncIterablesFlag */) { + var iterationTypes = getIterationTypesOfIterableSlow(type, asyncIterationTypesResolver, errorNode, errorOutputContainer, noCache); + if (iterationTypes !== noIterationTypes) { + return iterationTypes; + } + } + if (use & 1 /* IterationUse.AllowsSyncIterablesFlag */) { + var iterationTypes = getIterationTypesOfIterableSlow(type, syncIterationTypesResolver, errorNode, errorOutputContainer, noCache); + if (iterationTypes !== noIterationTypes) { + if (use & 2 /* IterationUse.AllowsAsyncIterablesFlag */) { + iterationTypes = getAsyncFromSyncIterationTypes(iterationTypes, errorNode); + return noCache ? iterationTypes : setCachedIterationTypes(type, "iterationTypesOfAsyncIterable", iterationTypes); + } + else { + return iterationTypes; + } + } + } + return noIterationTypes; + } + /** + * Gets the *yield*, *return*, and *next* types of an `Iterable`-like or + * `AsyncIterable`-like type from the cache. + * + * NOTE: You probably don't want to call this directly and should be calling + * `getIterationTypesOfIterable` instead. + */ + function getIterationTypesOfIterableCached(type, resolver) { + return getCachedIterationTypes(type, resolver.iterableCacheKey); + } + function getIterationTypesOfGlobalIterableType(globalType, resolver) { + var globalIterationTypes = getIterationTypesOfIterableCached(globalType, resolver) || + getIterationTypesOfIterableSlow(globalType, resolver, /*errorNode*/ undefined, /*errorOutputContainer*/ undefined, /*noCache*/ false); + return globalIterationTypes === noIterationTypes ? defaultIterationTypes : globalIterationTypes; + } + /** + * Gets the *yield*, *return*, and *next* types of an `Iterable`-like or `AsyncIterable`-like + * type from from common heuristics. + * + * If we previously analyzed this type and found no iteration types, `noIterationTypes` is + * returned. If we found iteration types, an `IterationTypes` record is returned. + * Otherwise, we return `undefined` to indicate to the caller it should perform a more + * exhaustive analysis. + * + * NOTE: You probably don't want to call this directly and should be calling + * `getIterationTypesOfIterable` instead. + */ + function getIterationTypesOfIterableFast(type, resolver) { + // As an optimization, if the type is an instantiation of one of the following global types, then + // just grab its related type argument: + // - `Iterable` or `AsyncIterable` + // - `IterableIterator` or `AsyncIterableIterator` + var globalType; + if (isReferenceToType(type, globalType = resolver.getGlobalIterableType(/*reportErrors*/ false)) || + isReferenceToType(type, globalType = resolver.getGlobalIterableIteratorType(/*reportErrors*/ false))) { + var yieldType = getTypeArguments(type)[0]; + // The "return" and "next" types of `Iterable` and `IterableIterator` are defined by the + // iteration types of their `[Symbol.iterator]()` method. The same is true for their async cousins. + // While we define these as `any` and `undefined` in our libs by default, a custom lib *could* use + // different definitions. + var _a = getIterationTypesOfGlobalIterableType(globalType, resolver), returnType = _a.returnType, nextType = _a.nextType; + return setCachedIterationTypes(type, resolver.iterableCacheKey, createIterationTypes(resolver.resolveIterationType(yieldType, /*errorNode*/ undefined) || yieldType, resolver.resolveIterationType(returnType, /*errorNode*/ undefined) || returnType, nextType)); + } + // As an optimization, if the type is an instantiation of the following global type, then + // just grab its related type arguments: + // - `Generator` or `AsyncGenerator` + if (isReferenceToType(type, resolver.getGlobalGeneratorType(/*reportErrors*/ false))) { + var _b = getTypeArguments(type), yieldType = _b[0], returnType = _b[1], nextType = _b[2]; + return setCachedIterationTypes(type, resolver.iterableCacheKey, createIterationTypes(resolver.resolveIterationType(yieldType, /*errorNode*/ undefined) || yieldType, resolver.resolveIterationType(returnType, /*errorNode*/ undefined) || returnType, nextType)); + } + } + function getPropertyNameForKnownSymbolName(symbolName) { + var ctorType = getGlobalESSymbolConstructorSymbol(/*reportErrors*/ false); + var uniqueType = ctorType && getTypeOfPropertyOfType(getTypeOfSymbol(ctorType), ts.escapeLeadingUnderscores(symbolName)); + return uniqueType && isTypeUsableAsPropertyName(uniqueType) ? getPropertyNameFromType(uniqueType) : "__@".concat(symbolName); + } + /** + * Gets the *yield*, *return*, and *next* types of an `Iterable`-like or `AsyncIterable`-like + * type from its members. + * + * If we successfully found the *yield*, *return*, and *next* types, an `IterationTypes` + * record is returned. Otherwise, `noIterationTypes` is returned. + * + * NOTE: You probably don't want to call this directly and should be calling + * `getIterationTypesOfIterable` instead. + */ + function getIterationTypesOfIterableSlow(type, resolver, errorNode, errorOutputContainer, noCache) { + var _a; + var method = getPropertyOfType(type, getPropertyNameForKnownSymbolName(resolver.iteratorSymbolName)); + var methodType = method && !(method.flags & 16777216 /* SymbolFlags.Optional */) ? getTypeOfSymbol(method) : undefined; + if (isTypeAny(methodType)) { + return noCache ? anyIterationTypes : setCachedIterationTypes(type, resolver.iterableCacheKey, anyIterationTypes); + } + var signatures = methodType ? getSignaturesOfType(methodType, 0 /* SignatureKind.Call */) : undefined; + if (!ts.some(signatures)) { + return noCache ? noIterationTypes : setCachedIterationTypes(type, resolver.iterableCacheKey, noIterationTypes); + } + var iteratorType = getIntersectionType(ts.map(signatures, getReturnTypeOfSignature)); + var iterationTypes = (_a = getIterationTypesOfIteratorWorker(iteratorType, resolver, errorNode, errorOutputContainer, noCache)) !== null && _a !== void 0 ? _a : noIterationTypes; + return noCache ? iterationTypes : setCachedIterationTypes(type, resolver.iterableCacheKey, iterationTypes); + } + function reportTypeNotIterableError(errorNode, type, allowAsyncIterables) { + var message = allowAsyncIterables + ? ts.Diagnostics.Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator + : ts.Diagnostics.Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator; + var suggestAwait = + // for (const x of Promise<...>) or [...Promise<...>] + !!getAwaitedTypeOfPromise(type) + // for (const x of AsyncIterable<...>) + || (!allowAsyncIterables && + ts.isForOfStatement(errorNode.parent) && + errorNode.parent.expression === errorNode && + getGlobalAsyncIterableType(/** reportErrors */ false) !== emptyGenericType && + isTypeAssignableTo(type, getGlobalAsyncIterableType(/** reportErrors */ false))); + return errorAndMaybeSuggestAwait(errorNode, suggestAwait, message, typeToString(type)); + } + /** + * Gets the *yield*, *return*, and *next* types from an `Iterator`-like or `AsyncIterator`-like type. + * + * If we successfully found the *yield*, *return*, and *next* types, an `IterationTypes` + * record is returned. Otherwise, `undefined` is returned. + */ + function getIterationTypesOfIterator(type, resolver, errorNode, errorOutputContainer) { + return getIterationTypesOfIteratorWorker(type, resolver, errorNode, errorOutputContainer, /*noCache*/ false); + } + /** + * Gets the *yield*, *return*, and *next* types from an `Iterator`-like or `AsyncIterator`-like type. + * + * If we successfully found the *yield*, *return*, and *next* types, an `IterationTypes` + * record is returned. Otherwise, `undefined` is returned. + * + * NOTE: You probably don't want to call this directly and should be calling + * `getIterationTypesOfIterator` instead. + */ + function getIterationTypesOfIteratorWorker(type, resolver, errorNode, errorOutputContainer, noCache) { + if (isTypeAny(type)) { + return anyIterationTypes; + } + var iterationTypes = getIterationTypesOfIteratorCached(type, resolver) || + getIterationTypesOfIteratorFast(type, resolver); + if (iterationTypes === noIterationTypes && errorNode) { + iterationTypes = undefined; + noCache = true; + } + iterationTypes !== null && iterationTypes !== void 0 ? iterationTypes : (iterationTypes = getIterationTypesOfIteratorSlow(type, resolver, errorNode, errorOutputContainer, noCache)); + return iterationTypes === noIterationTypes ? undefined : iterationTypes; + } + /** + * Gets the iteration types of an `Iterator`-like or `AsyncIterator`-like type from the + * cache. + * + * NOTE: You probably don't want to call this directly and should be calling + * `getIterationTypesOfIterator` instead. + */ + function getIterationTypesOfIteratorCached(type, resolver) { + return getCachedIterationTypes(type, resolver.iteratorCacheKey); + } + /** + * Gets the iteration types of an `Iterator`-like or `AsyncIterator`-like type from the + * cache or from common heuristics. + * + * If we previously analyzed this type and found no iteration types, `noIterationTypes` is + * returned. If we found iteration types, an `IterationTypes` record is returned. + * Otherwise, we return `undefined` to indicate to the caller it should perform a more + * exhaustive analysis. + * + * NOTE: You probably don't want to call this directly and should be calling + * `getIterationTypesOfIterator` instead. + */ + function getIterationTypesOfIteratorFast(type, resolver) { + // As an optimization, if the type is an instantiation of one of the following global types, + // then just grab its related type argument: + // - `IterableIterator` or `AsyncIterableIterator` + // - `Iterator` or `AsyncIterator` + // - `Generator` or `AsyncGenerator` + var globalType = resolver.getGlobalIterableIteratorType(/*reportErrors*/ false); + if (isReferenceToType(type, globalType)) { + var yieldType = getTypeArguments(type)[0]; + // The "return" and "next" types of `IterableIterator` and `AsyncIterableIterator` are defined by the + // iteration types of their `next`, `return`, and `throw` methods. While we define these as `any` + // and `undefined` in our libs by default, a custom lib *could* use different definitions. + var globalIterationTypes = getIterationTypesOfIteratorCached(globalType, resolver) || + getIterationTypesOfIteratorSlow(globalType, resolver, /*errorNode*/ undefined, /*errorOutputContainer*/ undefined, /*noCache*/ false); + var _a = globalIterationTypes === noIterationTypes ? defaultIterationTypes : globalIterationTypes, returnType = _a.returnType, nextType = _a.nextType; + return setCachedIterationTypes(type, resolver.iteratorCacheKey, createIterationTypes(yieldType, returnType, nextType)); + } + if (isReferenceToType(type, resolver.getGlobalIteratorType(/*reportErrors*/ false)) || + isReferenceToType(type, resolver.getGlobalGeneratorType(/*reportErrors*/ false))) { + var _b = getTypeArguments(type), yieldType = _b[0], returnType = _b[1], nextType = _b[2]; + return setCachedIterationTypes(type, resolver.iteratorCacheKey, createIterationTypes(yieldType, returnType, nextType)); + } + } + function isIteratorResult(type, kind) { + // From https://tc39.github.io/ecma262/#sec-iteratorresult-interface: + // > [done] is the result status of an iterator `next` method call. If the end of the iterator was reached `done` is `true`. + // > If the end was not reached `done` is `false` and a value is available. + // > If a `done` property (either own or inherited) does not exist, it is consider to have the value `false`. + var doneType = getTypeOfPropertyOfType(type, "done") || falseType; + return isTypeAssignableTo(kind === 0 /* IterationTypeKind.Yield */ ? falseType : trueType, doneType); + } + function isYieldIteratorResult(type) { + return isIteratorResult(type, 0 /* IterationTypeKind.Yield */); + } + function isReturnIteratorResult(type) { + return isIteratorResult(type, 1 /* IterationTypeKind.Return */); + } + /** + * Gets the *yield* and *return* types of an `IteratorResult`-like type. + * + * If we are unable to determine a *yield* or a *return* type, `noIterationTypes` is + * returned to indicate to the caller that it should handle the error. Otherwise, an + * `IterationTypes` record is returned. + */ + function getIterationTypesOfIteratorResult(type) { + if (isTypeAny(type)) { + return anyIterationTypes; + } + var cachedTypes = getCachedIterationTypes(type, "iterationTypesOfIteratorResult"); + if (cachedTypes) { + return cachedTypes; + } + // As an optimization, if the type is an instantiation of one of the global `IteratorYieldResult` + // or `IteratorReturnResult` types, then just grab its type argument. + if (isReferenceToType(type, getGlobalIteratorYieldResultType(/*reportErrors*/ false))) { + var yieldType_1 = getTypeArguments(type)[0]; + return setCachedIterationTypes(type, "iterationTypesOfIteratorResult", createIterationTypes(yieldType_1, /*returnType*/ undefined, /*nextType*/ undefined)); + } + if (isReferenceToType(type, getGlobalIteratorReturnResultType(/*reportErrors*/ false))) { + var returnType_1 = getTypeArguments(type)[0]; + return setCachedIterationTypes(type, "iterationTypesOfIteratorResult", createIterationTypes(/*yieldType*/ undefined, returnType_1, /*nextType*/ undefined)); + } + // Choose any constituents that can produce the requested iteration type. + var yieldIteratorResult = filterType(type, isYieldIteratorResult); + var yieldType = yieldIteratorResult !== neverType ? getTypeOfPropertyOfType(yieldIteratorResult, "value") : undefined; + var returnIteratorResult = filterType(type, isReturnIteratorResult); + var returnType = returnIteratorResult !== neverType ? getTypeOfPropertyOfType(returnIteratorResult, "value") : undefined; + if (!yieldType && !returnType) { + return setCachedIterationTypes(type, "iterationTypesOfIteratorResult", noIterationTypes); + } + // From https://tc39.github.io/ecma262/#sec-iteratorresult-interface + // > ... If the iterator does not have a return value, `value` is `undefined`. In that case, the + // > `value` property may be absent from the conforming object if it does not inherit an explicit + // > `value` property. + return setCachedIterationTypes(type, "iterationTypesOfIteratorResult", createIterationTypes(yieldType, returnType || voidType, /*nextType*/ undefined)); + } + /** + * Gets the *yield*, *return*, and *next* types of a the `next()`, `return()`, or + * `throw()` method of an `Iterator`-like or `AsyncIterator`-like type. + * + * If we successfully found the *yield*, *return*, and *next* types, an `IterationTypes` + * record is returned. Otherwise, we return `undefined`. + */ + function getIterationTypesOfMethod(type, resolver, methodName, errorNode, errorOutputContainer) { + var _a, _b, _c, _d, _e, _f; + var method = getPropertyOfType(type, methodName); + // Ignore 'return' or 'throw' if they are missing. + if (!method && methodName !== "next") { + return undefined; + } + var methodType = method && !(methodName === "next" && (method.flags & 16777216 /* SymbolFlags.Optional */)) + ? methodName === "next" ? getTypeOfSymbol(method) : getTypeWithFacts(getTypeOfSymbol(method), 2097152 /* TypeFacts.NEUndefinedOrNull */) + : undefined; + if (isTypeAny(methodType)) { + // `return()` and `throw()` don't provide a *next* type. + return methodName === "next" ? anyIterationTypes : anyIterationTypesExceptNext; + } + // Both async and non-async iterators *must* have a `next` method. + var methodSignatures = methodType ? getSignaturesOfType(methodType, 0 /* SignatureKind.Call */) : ts.emptyArray; + if (methodSignatures.length === 0) { + if (errorNode) { + var diagnostic = methodName === "next" + ? resolver.mustHaveANextMethodDiagnostic + : resolver.mustBeAMethodDiagnostic; + if (errorOutputContainer) { + (_a = errorOutputContainer.errors) !== null && _a !== void 0 ? _a : (errorOutputContainer.errors = []); + errorOutputContainer.errors.push(ts.createDiagnosticForNode(errorNode, diagnostic, methodName)); + } + else { + error(errorNode, diagnostic, methodName); + } + } + return methodName === "next" ? noIterationTypes : undefined; + } + // If the method signature comes exclusively from the global iterator or generator type, + // create iteration types from its type arguments like `getIterationTypesOfIteratorFast` + // does (so as to remove `undefined` from the next and return types). We arrive here when + // a contextual type for a generator was not a direct reference to one of those global types, + // but looking up `methodType` referred to one of them (and nothing else). E.g., in + // `interface SpecialIterator extends Iterator {}`, `SpecialIterator` is not a + // reference to `Iterator`, but its `next` member derives exclusively from `Iterator`. + if ((methodType === null || methodType === void 0 ? void 0 : methodType.symbol) && methodSignatures.length === 1) { + var globalGeneratorType = resolver.getGlobalGeneratorType(/*reportErrors*/ false); + var globalIteratorType = resolver.getGlobalIteratorType(/*reportErrors*/ false); + var isGeneratorMethod = ((_c = (_b = globalGeneratorType.symbol) === null || _b === void 0 ? void 0 : _b.members) === null || _c === void 0 ? void 0 : _c.get(methodName)) === methodType.symbol; + var isIteratorMethod = !isGeneratorMethod && ((_e = (_d = globalIteratorType.symbol) === null || _d === void 0 ? void 0 : _d.members) === null || _e === void 0 ? void 0 : _e.get(methodName)) === methodType.symbol; + if (isGeneratorMethod || isIteratorMethod) { + var globalType = isGeneratorMethod ? globalGeneratorType : globalIteratorType; + var mapper = methodType.mapper; + return createIterationTypes(getMappedType(globalType.typeParameters[0], mapper), getMappedType(globalType.typeParameters[1], mapper), methodName === "next" ? getMappedType(globalType.typeParameters[2], mapper) : undefined); + } + } + // Extract the first parameter and return type of each signature. + var methodParameterTypes; + var methodReturnTypes; + for (var _i = 0, methodSignatures_1 = methodSignatures; _i < methodSignatures_1.length; _i++) { + var signature = methodSignatures_1[_i]; + if (methodName !== "throw" && ts.some(signature.parameters)) { + methodParameterTypes = ts.append(methodParameterTypes, getTypeAtPosition(signature, 0)); + } + methodReturnTypes = ts.append(methodReturnTypes, getReturnTypeOfSignature(signature)); + } + // Resolve the *next* or *return* type from the first parameter of a `next()` or + // `return()` method, respectively. + var returnTypes; + var nextType; + if (methodName !== "throw") { + var methodParameterType = methodParameterTypes ? getUnionType(methodParameterTypes) : unknownType; + if (methodName === "next") { + // The value of `next(value)` is *not* awaited by async generators + nextType = methodParameterType; + } + else if (methodName === "return") { + // The value of `return(value)` *is* awaited by async generators + var resolvedMethodParameterType = resolver.resolveIterationType(methodParameterType, errorNode) || anyType; + returnTypes = ts.append(returnTypes, resolvedMethodParameterType); + } + } + // Resolve the *yield* and *return* types from the return type of the method (i.e. `IteratorResult`) + var yieldType; + var methodReturnType = methodReturnTypes ? getIntersectionType(methodReturnTypes) : neverType; + var resolvedMethodReturnType = resolver.resolveIterationType(methodReturnType, errorNode) || anyType; + var iterationTypes = getIterationTypesOfIteratorResult(resolvedMethodReturnType); + if (iterationTypes === noIterationTypes) { + if (errorNode) { + if (errorOutputContainer) { + (_f = errorOutputContainer.errors) !== null && _f !== void 0 ? _f : (errorOutputContainer.errors = []); + errorOutputContainer.errors.push(ts.createDiagnosticForNode(errorNode, resolver.mustHaveAValueDiagnostic, methodName)); + } + else { + error(errorNode, resolver.mustHaveAValueDiagnostic, methodName); + } + } + yieldType = anyType; + returnTypes = ts.append(returnTypes, anyType); + } + else { + yieldType = iterationTypes.yieldType; + returnTypes = ts.append(returnTypes, iterationTypes.returnType); + } + return createIterationTypes(yieldType, getUnionType(returnTypes), nextType); + } + /** + * Gets the *yield*, *return*, and *next* types of an `Iterator`-like or `AsyncIterator`-like + * type from its members. + * + * If we successfully found the *yield*, *return*, and *next* types, an `IterationTypes` + * record is returned. Otherwise, `noIterationTypes` is returned. + * + * NOTE: You probably don't want to call this directly and should be calling + * `getIterationTypesOfIterator` instead. + */ + function getIterationTypesOfIteratorSlow(type, resolver, errorNode, errorOutputContainer, noCache) { + var iterationTypes = combineIterationTypes([ + getIterationTypesOfMethod(type, resolver, "next", errorNode, errorOutputContainer), + getIterationTypesOfMethod(type, resolver, "return", errorNode, errorOutputContainer), + getIterationTypesOfMethod(type, resolver, "throw", errorNode, errorOutputContainer), + ]); + return noCache ? iterationTypes : setCachedIterationTypes(type, resolver.iteratorCacheKey, iterationTypes); + } + /** + * Gets the requested "iteration type" from a type that is either `Iterable`-like, `Iterator`-like, + * `IterableIterator`-like, or `Generator`-like (for a non-async generator); or `AsyncIterable`-like, + * `AsyncIterator`-like, `AsyncIterableIterator`-like, or `AsyncGenerator`-like (for an async generator). + */ + function getIterationTypeOfGeneratorFunctionReturnType(kind, returnType, isAsyncGenerator) { + if (isTypeAny(returnType)) { + return undefined; + } + var iterationTypes = getIterationTypesOfGeneratorFunctionReturnType(returnType, isAsyncGenerator); + return iterationTypes && iterationTypes[getIterationTypesKeyFromIterationTypeKind(kind)]; + } + function getIterationTypesOfGeneratorFunctionReturnType(type, isAsyncGenerator) { + if (isTypeAny(type)) { + return anyIterationTypes; + } + var use = isAsyncGenerator ? 2 /* IterationUse.AsyncGeneratorReturnType */ : 1 /* IterationUse.GeneratorReturnType */; + var resolver = isAsyncGenerator ? asyncIterationTypesResolver : syncIterationTypesResolver; + return getIterationTypesOfIterable(type, use, /*errorNode*/ undefined) || + getIterationTypesOfIterator(type, resolver, /*errorNode*/ undefined, /*errorOutputContainer*/ undefined); + } + function checkBreakOrContinueStatement(node) { + // Grammar checking + if (!checkGrammarStatementInAmbientContext(node)) + checkGrammarBreakOrContinueStatement(node); + // TODO: Check that target label is valid + } + function unwrapReturnType(returnType, functionFlags) { + var isGenerator = !!(functionFlags & 1 /* FunctionFlags.Generator */); + var isAsync = !!(functionFlags & 2 /* FunctionFlags.Async */); + if (isGenerator) { + var returnIterationType = getIterationTypeOfGeneratorFunctionReturnType(1 /* IterationTypeKind.Return */, returnType, isAsync); + if (!returnIterationType) { + return errorType; + } + return isAsync ? getAwaitedTypeNoAlias(unwrapAwaitedType(returnIterationType)) : returnIterationType; + } + return isAsync ? getAwaitedTypeNoAlias(returnType) || errorType : returnType; + } + function isUnwrappedReturnTypeVoidOrAny(func, returnType) { + var unwrappedReturnType = unwrapReturnType(returnType, ts.getFunctionFlags(func)); + return !!unwrappedReturnType && maybeTypeOfKind(unwrappedReturnType, 16384 /* TypeFlags.Void */ | 3 /* TypeFlags.AnyOrUnknown */); + } + function checkReturnStatement(node) { + var _a; + // Grammar checking + if (checkGrammarStatementInAmbientContext(node)) { + return; + } + var container = ts.getContainingFunctionOrClassStaticBlock(node); + if (container && ts.isClassStaticBlockDeclaration(container)) { + grammarErrorOnFirstToken(node, ts.Diagnostics.A_return_statement_cannot_be_used_inside_a_class_static_block); + return; + } + if (!container) { + grammarErrorOnFirstToken(node, ts.Diagnostics.A_return_statement_can_only_be_used_within_a_function_body); + return; + } + var signature = getSignatureFromDeclaration(container); + var returnType = getReturnTypeOfSignature(signature); + var functionFlags = ts.getFunctionFlags(container); + if (strictNullChecks || node.expression || returnType.flags & 131072 /* TypeFlags.Never */) { + var exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType; + if (container.kind === 175 /* SyntaxKind.SetAccessor */) { + if (node.expression) { + error(node, ts.Diagnostics.Setters_cannot_return_a_value); + } + } + else if (container.kind === 173 /* SyntaxKind.Constructor */) { + if (node.expression && !checkTypeAssignableToAndOptionallyElaborate(exprType, returnType, node, node.expression)) { + error(node, ts.Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class); + } + } + else if (getReturnTypeFromAnnotation(container)) { + var unwrappedReturnType = (_a = unwrapReturnType(returnType, functionFlags)) !== null && _a !== void 0 ? _a : returnType; + var unwrappedExprType = functionFlags & 2 /* FunctionFlags.Async */ + ? checkAwaitedType(exprType, /*withAlias*/ false, node, ts.Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member) + : exprType; + if (unwrappedReturnType) { + // If the function has a return type, but promisedType is + // undefined, an error will be reported in checkAsyncFunctionReturnType + // so we don't need to report one here. + checkTypeAssignableToAndOptionallyElaborate(unwrappedExprType, unwrappedReturnType, node, node.expression); + } + } + } + else if (container.kind !== 173 /* SyntaxKind.Constructor */ && compilerOptions.noImplicitReturns && !isUnwrappedReturnTypeVoidOrAny(container, returnType)) { + // The function has a return type, but the return statement doesn't have an expression. + error(node, ts.Diagnostics.Not_all_code_paths_return_a_value); + } + } + function checkWithStatement(node) { + // Grammar checking for withStatement + if (!checkGrammarStatementInAmbientContext(node)) { + if (node.flags & 32768 /* NodeFlags.AwaitContext */) { + grammarErrorOnFirstToken(node, ts.Diagnostics.with_statements_are_not_allowed_in_an_async_function_block); + } + } + checkExpression(node.expression); + var sourceFile = ts.getSourceFileOfNode(node); + if (!hasParseDiagnostics(sourceFile)) { + var start = ts.getSpanOfTokenAtPosition(sourceFile, node.pos).start; + var end = node.statement.pos; + grammarErrorAtPos(sourceFile, start, end - start, ts.Diagnostics.The_with_statement_is_not_supported_All_symbols_in_a_with_block_will_have_type_any); + } + } + function checkSwitchStatement(node) { + // Grammar checking + checkGrammarStatementInAmbientContext(node); + var firstDefaultClause; + var hasDuplicateDefaultClause = false; + var expressionType = checkExpression(node.expression); + var expressionIsLiteral = isLiteralType(expressionType); + ts.forEach(node.caseBlock.clauses, function (clause) { + // Grammar check for duplicate default clauses, skip if we already report duplicate default clause + if (clause.kind === 293 /* SyntaxKind.DefaultClause */ && !hasDuplicateDefaultClause) { + if (firstDefaultClause === undefined) { + firstDefaultClause = clause; + } + else { + grammarErrorOnNode(clause, ts.Diagnostics.A_default_clause_cannot_appear_more_than_once_in_a_switch_statement); + hasDuplicateDefaultClause = true; + } + } + if (clause.kind === 292 /* SyntaxKind.CaseClause */) { + addLazyDiagnostic(createLazyCaseClauseDiagnostics(clause)); + } + ts.forEach(clause.statements, checkSourceElement); + if (compilerOptions.noFallthroughCasesInSwitch && clause.fallthroughFlowNode && isReachableFlowNode(clause.fallthroughFlowNode)) { + error(clause, ts.Diagnostics.Fallthrough_case_in_switch); + } + function createLazyCaseClauseDiagnostics(clause) { + return function () { + // TypeScript 1.0 spec (April 2014): 5.9 + // In a 'switch' statement, each 'case' expression must be of a type that is comparable + // to or from the type of the 'switch' expression. + var caseType = checkExpression(clause.expression); + var caseIsLiteral = isLiteralType(caseType); + var comparedExpressionType = expressionType; + if (!caseIsLiteral || !expressionIsLiteral) { + caseType = caseIsLiteral ? getBaseTypeOfLiteralType(caseType) : caseType; + comparedExpressionType = getBaseTypeOfLiteralType(expressionType); + } + if (!isTypeEqualityComparableTo(comparedExpressionType, caseType)) { + // expressionType is not comparable to caseType, try the reversed check and report errors if it fails + checkTypeComparableTo(caseType, comparedExpressionType, clause.expression, /*headMessage*/ undefined); + } + }; + } + }); + if (node.caseBlock.locals) { + registerForUnusedIdentifiersCheck(node.caseBlock); + } + } + function checkLabeledStatement(node) { + // Grammar checking + if (!checkGrammarStatementInAmbientContext(node)) { + ts.findAncestor(node.parent, function (current) { + if (ts.isFunctionLike(current)) { + return "quit"; + } + if (current.kind === 253 /* SyntaxKind.LabeledStatement */ && current.label.escapedText === node.label.escapedText) { + grammarErrorOnNode(node.label, ts.Diagnostics.Duplicate_label_0, ts.getTextOfNode(node.label)); + return true; + } + return false; + }); + } + // ensure that label is unique + checkSourceElement(node.statement); + } + function checkThrowStatement(node) { + // Grammar checking + if (!checkGrammarStatementInAmbientContext(node)) { + if (ts.isIdentifier(node.expression) && !node.expression.escapedText) { + grammarErrorAfterFirstToken(node, ts.Diagnostics.Line_break_not_permitted_here); + } + } + if (node.expression) { + checkExpression(node.expression); + } + } + function checkTryStatement(node) { + // Grammar checking + checkGrammarStatementInAmbientContext(node); + checkBlock(node.tryBlock); + var catchClause = node.catchClause; + if (catchClause) { + // Grammar checking + if (catchClause.variableDeclaration) { + var declaration = catchClause.variableDeclaration; + var typeNode = ts.getEffectiveTypeAnnotationNode(ts.getRootDeclaration(declaration)); + if (typeNode) { + var type = getTypeForVariableLikeDeclaration(declaration, /*includeOptionality*/ false, 0 /* CheckMode.Normal */); + if (type && !(type.flags & 3 /* TypeFlags.AnyOrUnknown */)) { + grammarErrorOnFirstToken(typeNode, ts.Diagnostics.Catch_clause_variable_type_annotation_must_be_any_or_unknown_if_specified); + } + } + else if (declaration.initializer) { + grammarErrorOnFirstToken(declaration.initializer, ts.Diagnostics.Catch_clause_variable_cannot_have_an_initializer); + } + else { + var blockLocals_1 = catchClause.block.locals; + if (blockLocals_1) { + ts.forEachKey(catchClause.locals, function (caughtName) { + var blockLocal = blockLocals_1.get(caughtName); + if ((blockLocal === null || blockLocal === void 0 ? void 0 : blockLocal.valueDeclaration) && (blockLocal.flags & 2 /* SymbolFlags.BlockScopedVariable */) !== 0) { + grammarErrorOnNode(blockLocal.valueDeclaration, ts.Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause, caughtName); + } + }); + } + } + } + checkBlock(catchClause.block); + } + if (node.finallyBlock) { + checkBlock(node.finallyBlock); + } + } + function checkIndexConstraints(type, symbol, isStaticIndex) { + var indexInfos = getIndexInfosOfType(type); + if (indexInfos.length === 0) { + return; + } + for (var _i = 0, _a = getPropertiesOfObjectType(type); _i < _a.length; _i++) { + var prop = _a[_i]; + if (!(isStaticIndex && prop.flags & 4194304 /* SymbolFlags.Prototype */)) { + checkIndexConstraintForProperty(type, prop, getLiteralTypeFromProperty(prop, 8576 /* TypeFlags.StringOrNumberLiteralOrUnique */, /*includeNonPublic*/ true), getNonMissingTypeOfSymbol(prop)); + } + } + var typeDeclaration = symbol.valueDeclaration; + if (typeDeclaration && ts.isClassLike(typeDeclaration)) { + for (var _b = 0, _c = typeDeclaration.members; _b < _c.length; _b++) { + var member = _c[_b]; + // Only process instance properties with computed names here. Static properties cannot be in conflict with indexers, + // and properties with literal names were already checked. + if (!ts.isStatic(member) && !hasBindableName(member)) { + var symbol_3 = getSymbolOfNode(member); + checkIndexConstraintForProperty(type, symbol_3, getTypeOfExpression(member.name.expression), getNonMissingTypeOfSymbol(symbol_3)); + } + } + } + if (indexInfos.length > 1) { + for (var _d = 0, indexInfos_8 = indexInfos; _d < indexInfos_8.length; _d++) { + var info = indexInfos_8[_d]; + checkIndexConstraintForIndexSignature(type, info); + } + } + } + function checkIndexConstraintForProperty(type, prop, propNameType, propType) { + var declaration = prop.valueDeclaration; + var name = ts.getNameOfDeclaration(declaration); + if (name && ts.isPrivateIdentifier(name)) { + return; + } + var indexInfos = getApplicableIndexInfos(type, propNameType); + var interfaceDeclaration = ts.getObjectFlags(type) & 2 /* ObjectFlags.Interface */ ? ts.getDeclarationOfKind(type.symbol, 261 /* SyntaxKind.InterfaceDeclaration */) : undefined; + var propDeclaration = declaration && declaration.kind === 223 /* SyntaxKind.BinaryExpression */ || + name && name.kind === 164 /* SyntaxKind.ComputedPropertyName */ ? declaration : undefined; + var localPropDeclaration = getParentOfSymbol(prop) === type.symbol ? declaration : undefined; + var _loop_30 = function (info) { + var localIndexDeclaration = info.declaration && getParentOfSymbol(getSymbolOfNode(info.declaration)) === type.symbol ? info.declaration : undefined; + // We check only when (a) the property is declared in the containing type, or (b) the applicable index signature is declared + // in the containing type, or (c) the containing type is an interface and no base interface contains both the property and + // the index signature (i.e. property and index signature are declared in separate inherited interfaces). + var errorNode = localPropDeclaration || localIndexDeclaration || + (interfaceDeclaration && !ts.some(getBaseTypes(type), function (base) { return !!getPropertyOfObjectType(base, prop.escapedName) && !!getIndexTypeOfType(base, info.keyType); }) ? interfaceDeclaration : undefined); + if (errorNode && !isTypeAssignableTo(propType, info.type)) { + var diagnostic = createError(errorNode, ts.Diagnostics.Property_0_of_type_1_is_not_assignable_to_2_index_type_3, symbolToString(prop), typeToString(propType), typeToString(info.keyType), typeToString(info.type)); + if (propDeclaration && errorNode !== propDeclaration) { + ts.addRelatedInfo(diagnostic, ts.createDiagnosticForNode(propDeclaration, ts.Diagnostics._0_is_declared_here, symbolToString(prop))); + } + diagnostics.add(diagnostic); + } + }; + for (var _i = 0, indexInfos_9 = indexInfos; _i < indexInfos_9.length; _i++) { + var info = indexInfos_9[_i]; + _loop_30(info); + } + } + function checkIndexConstraintForIndexSignature(type, checkInfo) { + var declaration = checkInfo.declaration; + var indexInfos = getApplicableIndexInfos(type, checkInfo.keyType); + var interfaceDeclaration = ts.getObjectFlags(type) & 2 /* ObjectFlags.Interface */ ? ts.getDeclarationOfKind(type.symbol, 261 /* SyntaxKind.InterfaceDeclaration */) : undefined; + var localCheckDeclaration = declaration && getParentOfSymbol(getSymbolOfNode(declaration)) === type.symbol ? declaration : undefined; + var _loop_31 = function (info) { + if (info === checkInfo) + return "continue"; + var localIndexDeclaration = info.declaration && getParentOfSymbol(getSymbolOfNode(info.declaration)) === type.symbol ? info.declaration : undefined; + // We check only when (a) the check index signature is declared in the containing type, or (b) the applicable index + // signature is declared in the containing type, or (c) the containing type is an interface and no base interface contains + // both index signatures (i.e. the index signatures are declared in separate inherited interfaces). + var errorNode = localCheckDeclaration || localIndexDeclaration || + (interfaceDeclaration && !ts.some(getBaseTypes(type), function (base) { return !!getIndexInfoOfType(base, checkInfo.keyType) && !!getIndexTypeOfType(base, info.keyType); }) ? interfaceDeclaration : undefined); + if (errorNode && !isTypeAssignableTo(checkInfo.type, info.type)) { + error(errorNode, ts.Diagnostics._0_index_type_1_is_not_assignable_to_2_index_type_3, typeToString(checkInfo.keyType), typeToString(checkInfo.type), typeToString(info.keyType), typeToString(info.type)); + } + }; + for (var _i = 0, indexInfos_10 = indexInfos; _i < indexInfos_10.length; _i++) { + var info = indexInfos_10[_i]; + _loop_31(info); + } + } + function checkTypeNameIsReserved(name, message) { + // TS 1.0 spec (April 2014): 3.6.1 + // The predefined type keywords are reserved and cannot be used as names of user defined types. + switch (name.escapedText) { + case "any": + case "unknown": + case "never": + case "number": + case "bigint": + case "boolean": + case "string": + case "symbol": + case "void": + case "object": + error(name, message, name.escapedText); + } + } + /** + * The name cannot be used as 'Object' of user defined types with special target. + */ + function checkClassNameCollisionWithObject(name) { + if (languageVersion >= 1 /* ScriptTarget.ES5 */ && name.escapedText === "Object" + && (moduleKind < ts.ModuleKind.ES2015 || ts.getSourceFileOfNode(name).impliedNodeFormat === ts.ModuleKind.CommonJS)) { + error(name, ts.Diagnostics.Class_name_cannot_be_Object_when_targeting_ES5_with_module_0, ts.ModuleKind[moduleKind]); // https://github.com/Microsoft/TypeScript/issues/17494 + } + } + function checkUnmatchedJSDocParameters(node) { + var jsdocParameters = ts.filter(ts.getJSDocTags(node), ts.isJSDocParameterTag); + if (!ts.length(jsdocParameters)) + return; + var isJs = ts.isInJSFile(node); + var parameters = new ts.Set(); + var excludedParameters = new ts.Set(); + ts.forEach(node.parameters, function (_a, index) { + var name = _a.name; + if (ts.isIdentifier(name)) { + parameters.add(name.escapedText); + } + if (ts.isBindingPattern(name)) { + excludedParameters.add(index); + } + }); + var containsArguments = containsArgumentsReference(node); + if (containsArguments) { + var lastJSDocParam = ts.lastOrUndefined(jsdocParameters); + if (isJs && lastJSDocParam && ts.isIdentifier(lastJSDocParam.name) && lastJSDocParam.typeExpression && + lastJSDocParam.typeExpression.type && !parameters.has(lastJSDocParam.name.escapedText) && !isArrayType(getTypeFromTypeNode(lastJSDocParam.typeExpression.type))) { + error(lastJSDocParam.name, ts.Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_had_an_array_type, ts.idText(lastJSDocParam.name)); + } + } + else { + ts.forEach(jsdocParameters, function (_a, index) { + var name = _a.name, isNameFirst = _a.isNameFirst; + if (excludedParameters.has(index) || ts.isIdentifier(name) && parameters.has(name.escapedText)) { + return; + } + if (ts.isQualifiedName(name)) { + if (isJs) { + error(name, ts.Diagnostics.Qualified_name_0_is_not_allowed_without_a_leading_param_object_1, ts.entityNameToString(name), ts.entityNameToString(name.left)); + } + } + else { + if (!isNameFirst) { + errorOrSuggestion(isJs, name, ts.Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name, ts.idText(name)); + } + } + }); + } + } + /** + * Check each type parameter and check that type parameters have no duplicate type parameter declarations + */ + function checkTypeParameters(typeParameterDeclarations) { + var seenDefault = false; + if (typeParameterDeclarations) { + for (var i = 0; i < typeParameterDeclarations.length; i++) { + var node = typeParameterDeclarations[i]; + checkTypeParameter(node); + addLazyDiagnostic(createCheckTypeParameterDiagnostic(node, i)); + } + } + function createCheckTypeParameterDiagnostic(node, i) { + return function () { + if (node.default) { + seenDefault = true; + checkTypeParametersNotReferenced(node.default, typeParameterDeclarations, i); + } + else if (seenDefault) { + error(node, ts.Diagnostics.Required_type_parameters_may_not_follow_optional_type_parameters); + } + for (var j = 0; j < i; j++) { + if (typeParameterDeclarations[j].symbol === node.symbol) { + error(node.name, ts.Diagnostics.Duplicate_identifier_0, ts.declarationNameToString(node.name)); + } + } + }; + } + } + /** Check that type parameter defaults only reference previously declared type parameters */ + function checkTypeParametersNotReferenced(root, typeParameters, index) { + visit(root); + function visit(node) { + if (node.kind === 180 /* SyntaxKind.TypeReference */) { + var type = getTypeFromTypeReference(node); + if (type.flags & 262144 /* TypeFlags.TypeParameter */) { + for (var i = index; i < typeParameters.length; i++) { + if (type.symbol === getSymbolOfNode(typeParameters[i])) { + error(node, ts.Diagnostics.Type_parameter_defaults_can_only_reference_previously_declared_type_parameters); + } + } + } + } + ts.forEachChild(node, visit); + } + } + /** Check that type parameter lists are identical across multiple declarations */ + function checkTypeParameterListsIdentical(symbol) { + if (symbol.declarations && symbol.declarations.length === 1) { + return; + } + var links = getSymbolLinks(symbol); + if (!links.typeParametersChecked) { + links.typeParametersChecked = true; + var declarations = getClassOrInterfaceDeclarationsOfSymbol(symbol); + if (!declarations || declarations.length <= 1) { + return; + } + var type = getDeclaredTypeOfSymbol(symbol); + if (!areTypeParametersIdentical(declarations, type.localTypeParameters, ts.getEffectiveTypeParameterDeclarations)) { + // Report an error on every conflicting declaration. + var name = symbolToString(symbol); + for (var _i = 0, declarations_7 = declarations; _i < declarations_7.length; _i++) { + var declaration = declarations_7[_i]; + error(declaration.name, ts.Diagnostics.All_declarations_of_0_must_have_identical_type_parameters, name); + } + } + } + } + function areTypeParametersIdentical(declarations, targetParameters, getTypeParameterDeclarations) { + var maxTypeArgumentCount = ts.length(targetParameters); + var minTypeArgumentCount = getMinTypeArgumentCount(targetParameters); + for (var _i = 0, declarations_8 = declarations; _i < declarations_8.length; _i++) { + var declaration = declarations_8[_i]; + // If this declaration has too few or too many type parameters, we report an error + var sourceParameters = getTypeParameterDeclarations(declaration); + var numTypeParameters = sourceParameters.length; + if (numTypeParameters < minTypeArgumentCount || numTypeParameters > maxTypeArgumentCount) { + return false; + } + for (var i = 0; i < numTypeParameters; i++) { + var source = sourceParameters[i]; + var target = targetParameters[i]; + // If the type parameter node does not have the same as the resolved type + // parameter at this position, we report an error. + if (source.name.escapedText !== target.symbol.escapedName) { + return false; + } + // If the type parameter node does not have an identical constraint as the resolved + // type parameter at this position, we report an error. + var constraint = ts.getEffectiveConstraintOfTypeParameter(source); + var sourceConstraint = constraint && getTypeFromTypeNode(constraint); + var targetConstraint = getConstraintOfTypeParameter(target); + // relax check if later interface augmentation has no constraint, it's more broad and is OK to merge with + // a more constrained interface (this could be generalized to a full hierarchy check, but that's maybe overkill) + if (sourceConstraint && targetConstraint && !isTypeIdenticalTo(sourceConstraint, targetConstraint)) { + return false; + } + // If the type parameter node has a default and it is not identical to the default + // for the type parameter at this position, we report an error. + var sourceDefault = source.default && getTypeFromTypeNode(source.default); + var targetDefault = getDefaultFromTypeParameter(target); + if (sourceDefault && targetDefault && !isTypeIdenticalTo(sourceDefault, targetDefault)) { + return false; + } + } + } + return true; + } + function checkClassExpression(node) { + checkClassLikeDeclaration(node); + checkNodeDeferred(node); + return getTypeOfSymbol(getSymbolOfNode(node)); + } + function checkClassExpressionDeferred(node) { + ts.forEach(node.members, checkSourceElement); + registerForUnusedIdentifiersCheck(node); + } + function checkClassDeclaration(node) { + var firstDecorator = ts.find(node.modifiers, ts.isDecorator); + if (firstDecorator && ts.some(node.members, function (p) { return ts.hasStaticModifier(p) && ts.isPrivateIdentifierClassElementDeclaration(p); })) { + grammarErrorOnNode(firstDecorator, ts.Diagnostics.Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_decorator); + } + if (!node.name && !ts.hasSyntacticModifier(node, 1024 /* ModifierFlags.Default */)) { + grammarErrorOnFirstToken(node, ts.Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name); + } + checkClassLikeDeclaration(node); + ts.forEach(node.members, checkSourceElement); + registerForUnusedIdentifiersCheck(node); + } + function checkClassLikeDeclaration(node) { + checkGrammarClassLikeDeclaration(node); + checkDecorators(node); + checkCollisionsForDeclarationName(node, node.name); + checkTypeParameters(ts.getEffectiveTypeParameterDeclarations(node)); + checkExportsOnMergedDeclarations(node); + var symbol = getSymbolOfNode(node); + var type = getDeclaredTypeOfSymbol(symbol); + var typeWithThis = getTypeWithThisArgument(type); + var staticType = getTypeOfSymbol(symbol); + checkTypeParameterListsIdentical(symbol); + checkFunctionOrConstructorSymbol(symbol); + checkClassForDuplicateDeclarations(node); + // Only check for reserved static identifiers on non-ambient context. + var nodeInAmbientContext = !!(node.flags & 16777216 /* NodeFlags.Ambient */); + if (!nodeInAmbientContext) { + checkClassForStaticPropertyNameConflicts(node); + } + var baseTypeNode = ts.getEffectiveBaseTypeNode(node); + if (baseTypeNode) { + ts.forEach(baseTypeNode.typeArguments, checkSourceElement); + if (languageVersion < 2 /* ScriptTarget.ES2015 */) { + checkExternalEmitHelpers(baseTypeNode.parent, 1 /* ExternalEmitHelpers.Extends */); + } + // check both @extends and extends if both are specified. + var extendsNode = ts.getClassExtendsHeritageElement(node); + if (extendsNode && extendsNode !== baseTypeNode) { + checkExpression(extendsNode.expression); + } + var baseTypes_2 = getBaseTypes(type); + if (baseTypes_2.length) { + addLazyDiagnostic(function () { + var baseType = baseTypes_2[0]; + var baseConstructorType = getBaseConstructorTypeOfClass(type); + var staticBaseType = getApparentType(baseConstructorType); + checkBaseTypeAccessibility(staticBaseType, baseTypeNode); + checkSourceElement(baseTypeNode.expression); + if (ts.some(baseTypeNode.typeArguments)) { + ts.forEach(baseTypeNode.typeArguments, checkSourceElement); + for (var _i = 0, _a = getConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments, baseTypeNode); _i < _a.length; _i++) { + var constructor = _a[_i]; + if (!checkTypeArgumentConstraints(baseTypeNode, constructor.typeParameters)) { + break; + } + } + } + var baseWithThis = getTypeWithThisArgument(baseType, type.thisType); + if (!checkTypeAssignableTo(typeWithThis, baseWithThis, /*errorNode*/ undefined)) { + issueMemberSpecificError(node, typeWithThis, baseWithThis, ts.Diagnostics.Class_0_incorrectly_extends_base_class_1); + } + else { + // Report static side error only when instance type is assignable + checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), node.name || node, ts.Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1); + } + if (baseConstructorType.flags & 8650752 /* TypeFlags.TypeVariable */) { + if (!isMixinConstructorType(staticType)) { + error(node.name || node, ts.Diagnostics.A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any); + } + else { + var constructSignatures = getSignaturesOfType(baseConstructorType, 1 /* SignatureKind.Construct */); + if (constructSignatures.some(function (signature) { return signature.flags & 4 /* SignatureFlags.Abstract */; }) && !ts.hasSyntacticModifier(node, 256 /* ModifierFlags.Abstract */)) { + error(node.name || node, ts.Diagnostics.A_mixin_class_that_extends_from_a_type_variable_containing_an_abstract_construct_signature_must_also_be_declared_abstract); + } + } + } + if (!(staticBaseType.symbol && staticBaseType.symbol.flags & 32 /* SymbolFlags.Class */) && !(baseConstructorType.flags & 8650752 /* TypeFlags.TypeVariable */)) { + // When the static base type is a "class-like" constructor function (but not actually a class), we verify + // that all instantiated base constructor signatures return the same type. + var constructors = getInstantiatedConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments, baseTypeNode); + if (ts.forEach(constructors, function (sig) { return !isJSConstructor(sig.declaration) && !isTypeIdenticalTo(getReturnTypeOfSignature(sig), baseType); })) { + error(baseTypeNode.expression, ts.Diagnostics.Base_constructors_must_all_have_the_same_return_type); + } + } + checkKindsOfPropertyMemberOverrides(type, baseType); + }); + } + } + checkMembersForOverrideModifier(node, type, typeWithThis, staticType); + var implementedTypeNodes = ts.getEffectiveImplementsTypeNodes(node); + if (implementedTypeNodes) { + for (var _i = 0, implementedTypeNodes_1 = implementedTypeNodes; _i < implementedTypeNodes_1.length; _i++) { + var typeRefNode = implementedTypeNodes_1[_i]; + if (!ts.isEntityNameExpression(typeRefNode.expression) || ts.isOptionalChain(typeRefNode.expression)) { + error(typeRefNode.expression, ts.Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments); + } + checkTypeReferenceNode(typeRefNode); + addLazyDiagnostic(createImplementsDiagnostics(typeRefNode)); + } + } + addLazyDiagnostic(function () { + checkIndexConstraints(type, symbol); + checkIndexConstraints(staticType, symbol, /*isStaticIndex*/ true); + checkTypeForDuplicateIndexSignatures(node); + checkPropertyInitialization(node); + }); + function createImplementsDiagnostics(typeRefNode) { + return function () { + var t = getReducedType(getTypeFromTypeNode(typeRefNode)); + if (!isErrorType(t)) { + if (isValidBaseType(t)) { + var genericDiag = t.symbol && t.symbol.flags & 32 /* SymbolFlags.Class */ ? + ts.Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass : + ts.Diagnostics.Class_0_incorrectly_implements_interface_1; + var baseWithThis = getTypeWithThisArgument(t, type.thisType); + if (!checkTypeAssignableTo(typeWithThis, baseWithThis, /*errorNode*/ undefined)) { + issueMemberSpecificError(node, typeWithThis, baseWithThis, genericDiag); + } + } + else { + error(typeRefNode, ts.Diagnostics.A_class_can_only_implement_an_object_type_or_intersection_of_object_types_with_statically_known_members); + } + } + }; + } + } + function checkMembersForOverrideModifier(node, type, typeWithThis, staticType) { + var baseTypeNode = ts.getEffectiveBaseTypeNode(node); + var baseTypes = baseTypeNode && getBaseTypes(type); + var baseWithThis = (baseTypes === null || baseTypes === void 0 ? void 0 : baseTypes.length) ? getTypeWithThisArgument(ts.first(baseTypes), type.thisType) : undefined; + var baseStaticType = getBaseConstructorTypeOfClass(type); + var _loop_32 = function (member) { + if (ts.hasAmbientModifier(member)) { + return "continue"; + } + if (ts.isConstructorDeclaration(member)) { + ts.forEach(member.parameters, function (param) { + if (ts.isParameterPropertyDeclaration(param, member)) { + checkExistingMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, param, + /* memberIsParameterProperty */ true); + } + }); + } + checkExistingMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, member, + /* memberIsParameterProperty */ false); + }; + for (var _i = 0, _a = node.members; _i < _a.length; _i++) { + var member = _a[_i]; + _loop_32(member); + } + } + /** + * @param member Existing member node to be checked. + * Note: `member` cannot be a synthetic node. + */ + function checkExistingMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, member, memberIsParameterProperty, reportErrors) { + if (reportErrors === void 0) { reportErrors = true; } + var declaredProp = member.name + && getSymbolAtLocation(member.name) + || getSymbolAtLocation(member); + if (!declaredProp) { + return 0 /* MemberOverrideStatus.Ok */; + } + return checkMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, ts.hasOverrideModifier(member), ts.hasAbstractModifier(member), ts.isStatic(member), memberIsParameterProperty, ts.symbolName(declaredProp), reportErrors ? member : undefined); + } + /** + * Checks a class member declaration for either a missing or an invalid `override` modifier. + * Note: this function can be used for speculative checking, + * i.e. checking a member that does not yet exist in the program. + * An example of that would be to call this function in a completions scenario, + * when offering a method declaration as completion. + * @param errorNode The node where we should report an error, or undefined if we should not report errors. + */ + function checkMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, memberHasOverrideModifier, memberHasAbstractModifier, memberIsStatic, memberIsParameterProperty, memberName, errorNode) { + var isJs = ts.isInJSFile(node); + var nodeInAmbientContext = !!(node.flags & 16777216 /* NodeFlags.Ambient */); + if (baseWithThis && (memberHasOverrideModifier || compilerOptions.noImplicitOverride)) { + var memberEscapedName = ts.escapeLeadingUnderscores(memberName); + var thisType = memberIsStatic ? staticType : typeWithThis; + var baseType = memberIsStatic ? baseStaticType : baseWithThis; + var prop = getPropertyOfType(thisType, memberEscapedName); + var baseProp = getPropertyOfType(baseType, memberEscapedName); + var baseClassName = typeToString(baseWithThis); + if (prop && !baseProp && memberHasOverrideModifier) { + if (errorNode) { + var suggestion = getSuggestedSymbolForNonexistentClassMember(memberName, baseType); // Again, using symbol name: note that's different from `symbol.escapedName` + suggestion ? + error(errorNode, isJs ? + ts.Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1 : + ts.Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1, baseClassName, symbolToString(suggestion)) : + error(errorNode, isJs ? + ts.Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0 : + ts.Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0, baseClassName); + } + return 2 /* MemberOverrideStatus.HasInvalidOverride */; + } + else if (prop && (baseProp === null || baseProp === void 0 ? void 0 : baseProp.declarations) && compilerOptions.noImplicitOverride && !nodeInAmbientContext) { + var baseHasAbstract = ts.some(baseProp.declarations, ts.hasAbstractModifier); + if (memberHasOverrideModifier) { + return 0 /* MemberOverrideStatus.Ok */; + } + if (!baseHasAbstract) { + if (errorNode) { + var diag = memberIsParameterProperty ? + isJs ? + ts.Diagnostics.This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0 : + ts.Diagnostics.This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0 : + isJs ? + ts.Diagnostics.This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0 : + ts.Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0; + error(errorNode, diag, baseClassName); + } + return 1 /* MemberOverrideStatus.NeedsOverride */; + } + else if (memberHasAbstractModifier && baseHasAbstract) { + if (errorNode) { + error(errorNode, ts.Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0, baseClassName); + } + return 1 /* MemberOverrideStatus.NeedsOverride */; + } + } + } + else if (memberHasOverrideModifier) { + if (errorNode) { + var className = typeToString(type); + error(errorNode, isJs ? + ts.Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class : + ts.Diagnostics.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class, className); + } + return 2 /* MemberOverrideStatus.HasInvalidOverride */; + } + return 0 /* MemberOverrideStatus.Ok */; + } + function issueMemberSpecificError(node, typeWithThis, baseWithThis, broadDiag) { + // iterate over all implemented properties and issue errors on each one which isn't compatible, rather than the class as a whole, if possible + var issuedMemberError = false; + var _loop_33 = function (member) { + if (ts.isStatic(member)) { + return "continue"; + } + var declaredProp = member.name && getSymbolAtLocation(member.name) || getSymbolAtLocation(member); + if (declaredProp) { + var prop = getPropertyOfType(typeWithThis, declaredProp.escapedName); + var baseProp = getPropertyOfType(baseWithThis, declaredProp.escapedName); + if (prop && baseProp) { + var rootChain = function () { return ts.chainDiagnosticMessages( + /*details*/ undefined, ts.Diagnostics.Property_0_in_type_1_is_not_assignable_to_the_same_property_in_base_type_2, symbolToString(declaredProp), typeToString(typeWithThis), typeToString(baseWithThis)); }; + if (!checkTypeAssignableTo(getTypeOfSymbol(prop), getTypeOfSymbol(baseProp), member.name || member, /*message*/ undefined, rootChain)) { + issuedMemberError = true; + } + } + } + }; + for (var _i = 0, _a = node.members; _i < _a.length; _i++) { + var member = _a[_i]; + _loop_33(member); + } + if (!issuedMemberError) { + // check again with diagnostics to generate a less-specific error + checkTypeAssignableTo(typeWithThis, baseWithThis, node.name || node, broadDiag); + } + } + function checkBaseTypeAccessibility(type, node) { + var signatures = getSignaturesOfType(type, 1 /* SignatureKind.Construct */); + if (signatures.length) { + var declaration = signatures[0].declaration; + if (declaration && ts.hasEffectiveModifier(declaration, 8 /* ModifierFlags.Private */)) { + var typeClassDeclaration = ts.getClassLikeDeclarationOfSymbol(type.symbol); + if (!isNodeWithinClass(node, typeClassDeclaration)) { + error(node, ts.Diagnostics.Cannot_extend_a_class_0_Class_constructor_is_marked_as_private, getFullyQualifiedName(type.symbol)); + } + } + } + } + /** + * Checks a member declaration node to see if has a missing or invalid `override` modifier. + * @param node Class-like node where the member is declared. + * @param member Member declaration node. + * Note: `member` can be a synthetic node without a parent. + */ + function getMemberOverrideModifierStatus(node, member) { + if (!member.name) { + return 0 /* MemberOverrideStatus.Ok */; + } + var symbol = getSymbolOfNode(node); + var type = getDeclaredTypeOfSymbol(symbol); + var typeWithThis = getTypeWithThisArgument(type); + var staticType = getTypeOfSymbol(symbol); + var baseTypeNode = ts.getEffectiveBaseTypeNode(node); + var baseTypes = baseTypeNode && getBaseTypes(type); + var baseWithThis = (baseTypes === null || baseTypes === void 0 ? void 0 : baseTypes.length) ? getTypeWithThisArgument(ts.first(baseTypes), type.thisType) : undefined; + var baseStaticType = getBaseConstructorTypeOfClass(type); + var memberHasOverrideModifier = member.parent + ? ts.hasOverrideModifier(member) + : ts.hasSyntacticModifier(member, 16384 /* ModifierFlags.Override */); + var memberName = ts.unescapeLeadingUnderscores(ts.getTextOfPropertyName(member.name)); + return checkMemberForOverrideModifier(node, staticType, baseStaticType, baseWithThis, type, typeWithThis, memberHasOverrideModifier, ts.hasAbstractModifier(member), ts.isStatic(member), + /* memberIsParameterProperty */ false, memberName); + } + function getTargetSymbol(s) { + // if symbol is instantiated its flags are not copied from the 'target' + // so we'll need to get back original 'target' symbol to work with correct set of flags + return ts.getCheckFlags(s) & 1 /* CheckFlags.Instantiated */ ? s.target : s; + } + function getClassOrInterfaceDeclarationsOfSymbol(symbol) { + return ts.filter(symbol.declarations, function (d) { + return d.kind === 260 /* SyntaxKind.ClassDeclaration */ || d.kind === 261 /* SyntaxKind.InterfaceDeclaration */; + }); + } + function checkKindsOfPropertyMemberOverrides(type, baseType) { + // TypeScript 1.0 spec (April 2014): 8.2.3 + // A derived class inherits all members from its base class it doesn't override. + // Inheritance means that a derived class implicitly contains all non - overridden members of the base class. + // Both public and private property members are inherited, but only public property members can be overridden. + // A property member in a derived class is said to override a property member in a base class + // when the derived class property member has the same name and kind(instance or static) + // as the base class property member. + // The type of an overriding property member must be assignable(section 3.8.4) + // to the type of the overridden property member, or otherwise a compile - time error occurs. + // Base class instance member functions can be overridden by derived class instance member functions, + // but not by other kinds of members. + // Base class instance member variables and accessors can be overridden by + // derived class instance member variables and accessors, but not by other kinds of members. + var _a, _b, _c, _d; + // NOTE: assignability is checked in checkClassDeclaration + var baseProperties = getPropertiesOfType(baseType); + var _loop_34 = function (baseProperty) { + var base = getTargetSymbol(baseProperty); + if (base.flags & 4194304 /* SymbolFlags.Prototype */) { + return "continue"; + } + var baseSymbol = getPropertyOfObjectType(type, base.escapedName); + if (!baseSymbol) { + return "continue"; + } + var derived = getTargetSymbol(baseSymbol); + var baseDeclarationFlags = ts.getDeclarationModifierFlagsFromSymbol(base); + ts.Debug.assert(!!derived, "derived should point to something, even if it is the base class' declaration."); + // In order to resolve whether the inherited method was overridden in the base class or not, + // we compare the Symbols obtained. Since getTargetSymbol returns the symbol on the *uninstantiated* + // type declaration, derived and base resolve to the same symbol even in the case of generic classes. + if (derived === base) { + // derived class inherits base without override/redeclaration + var derivedClassDecl = ts.getClassLikeDeclarationOfSymbol(type.symbol); + // It is an error to inherit an abstract member without implementing it or being declared abstract. + // If there is no declaration for the derived class (as in the case of class expressions), + // then the class cannot be declared abstract. + if (baseDeclarationFlags & 256 /* ModifierFlags.Abstract */ && (!derivedClassDecl || !ts.hasSyntacticModifier(derivedClassDecl, 256 /* ModifierFlags.Abstract */))) { + // Searches other base types for a declaration that would satisfy the inherited abstract member. + // (The class may have more than one base type via declaration merging with an interface with the + // same name.) + for (var _e = 0, _f = getBaseTypes(type); _e < _f.length; _e++) { + var otherBaseType = _f[_e]; + if (otherBaseType === baseType) + continue; + var baseSymbol_1 = getPropertyOfObjectType(otherBaseType, base.escapedName); + var derivedElsewhere = baseSymbol_1 && getTargetSymbol(baseSymbol_1); + if (derivedElsewhere && derivedElsewhere !== base) { + return "continue-basePropertyCheck"; + } + } + if (derivedClassDecl.kind === 228 /* SyntaxKind.ClassExpression */) { + error(derivedClassDecl, ts.Diagnostics.Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1, symbolToString(baseProperty), typeToString(baseType)); + } + else { + error(derivedClassDecl, ts.Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2, typeToString(type), symbolToString(baseProperty), typeToString(baseType)); + } + } + } + else { + // derived overrides base. + var derivedDeclarationFlags = ts.getDeclarationModifierFlagsFromSymbol(derived); + if (baseDeclarationFlags & 8 /* ModifierFlags.Private */ || derivedDeclarationFlags & 8 /* ModifierFlags.Private */) { + return "continue"; + } + var errorMessage = void 0; + var basePropertyFlags = base.flags & 98308 /* SymbolFlags.PropertyOrAccessor */; + var derivedPropertyFlags = derived.flags & 98308 /* SymbolFlags.PropertyOrAccessor */; + if (basePropertyFlags && derivedPropertyFlags) { + // property/accessor is overridden with property/accessor + if ((ts.getCheckFlags(base) & 6 /* CheckFlags.Synthetic */ + ? (_a = base.declarations) === null || _a === void 0 ? void 0 : _a.some(function (d) { return isPropertyAbstractOrInterface(d, baseDeclarationFlags); }) + : (_b = base.declarations) === null || _b === void 0 ? void 0 : _b.every(function (d) { return isPropertyAbstractOrInterface(d, baseDeclarationFlags); })) + || ts.getCheckFlags(base) & 262144 /* CheckFlags.Mapped */ + || derived.valueDeclaration && ts.isBinaryExpression(derived.valueDeclaration)) { + return "continue"; + } + var overriddenInstanceProperty = basePropertyFlags !== 4 /* SymbolFlags.Property */ && derivedPropertyFlags === 4 /* SymbolFlags.Property */; + var overriddenInstanceAccessor = basePropertyFlags === 4 /* SymbolFlags.Property */ && derivedPropertyFlags !== 4 /* SymbolFlags.Property */; + if (overriddenInstanceProperty || overriddenInstanceAccessor) { + var errorMessage_1 = overriddenInstanceProperty ? + ts.Diagnostics._0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property : + ts.Diagnostics._0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor; + error(ts.getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage_1, symbolToString(base), typeToString(baseType), typeToString(type)); + } + else if (useDefineForClassFields) { + var uninitialized = (_c = derived.declarations) === null || _c === void 0 ? void 0 : _c.find(function (d) { return d.kind === 169 /* SyntaxKind.PropertyDeclaration */ && !d.initializer; }); + if (uninitialized + && !(derived.flags & 33554432 /* SymbolFlags.Transient */) + && !(baseDeclarationFlags & 256 /* ModifierFlags.Abstract */) + && !(derivedDeclarationFlags & 256 /* ModifierFlags.Abstract */) + && !((_d = derived.declarations) === null || _d === void 0 ? void 0 : _d.some(function (d) { return !!(d.flags & 16777216 /* NodeFlags.Ambient */); }))) { + var constructor = findConstructorDeclaration(ts.getClassLikeDeclarationOfSymbol(type.symbol)); + var propName = uninitialized.name; + if (uninitialized.exclamationToken + || !constructor + || !ts.isIdentifier(propName) + || !strictNullChecks + || !isPropertyInitializedInConstructor(propName, type, constructor)) { + var errorMessage_2 = ts.Diagnostics.Property_0_will_overwrite_the_base_property_in_1_If_this_is_intentional_add_an_initializer_Otherwise_add_a_declare_modifier_or_remove_the_redundant_declaration; + error(ts.getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage_2, symbolToString(base), typeToString(baseType)); + } + } + } + return "continue"; + } + else if (isPrototypeProperty(base)) { + if (isPrototypeProperty(derived) || derived.flags & 4 /* SymbolFlags.Property */) { + return "continue"; + } + else { + ts.Debug.assert(!!(derived.flags & 98304 /* SymbolFlags.Accessor */)); + errorMessage = ts.Diagnostics.Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor; + } + } + else if (base.flags & 98304 /* SymbolFlags.Accessor */) { + errorMessage = ts.Diagnostics.Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function; + } + else { + errorMessage = ts.Diagnostics.Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function; + } + error(ts.getNameOfDeclaration(derived.valueDeclaration) || derived.valueDeclaration, errorMessage, typeToString(baseType), symbolToString(base), typeToString(type)); + } + }; + basePropertyCheck: for (var _i = 0, baseProperties_1 = baseProperties; _i < baseProperties_1.length; _i++) { + var baseProperty = baseProperties_1[_i]; + var state_10 = _loop_34(baseProperty); + switch (state_10) { + case "continue-basePropertyCheck": continue basePropertyCheck; + } + } + } + function isPropertyAbstractOrInterface(declaration, baseDeclarationFlags) { + return baseDeclarationFlags & 256 /* ModifierFlags.Abstract */ && (!ts.isPropertyDeclaration(declaration) || !declaration.initializer) + || ts.isInterfaceDeclaration(declaration.parent); + } + function getNonInheritedProperties(type, baseTypes, properties) { + if (!ts.length(baseTypes)) { + return properties; + } + var seen = new ts.Map(); + ts.forEach(properties, function (p) { + seen.set(p.escapedName, p); + }); + for (var _i = 0, baseTypes_3 = baseTypes; _i < baseTypes_3.length; _i++) { + var base = baseTypes_3[_i]; + var properties_5 = getPropertiesOfType(getTypeWithThisArgument(base, type.thisType)); + for (var _a = 0, properties_4 = properties_5; _a < properties_4.length; _a++) { + var prop = properties_4[_a]; + var existing = seen.get(prop.escapedName); + if (existing && prop.parent === existing.parent) { + seen.delete(prop.escapedName); + } + } + } + return ts.arrayFrom(seen.values()); + } + function checkInheritedPropertiesAreIdentical(type, typeNode) { + var baseTypes = getBaseTypes(type); + if (baseTypes.length < 2) { + return true; + } + var seen = new ts.Map(); + ts.forEach(resolveDeclaredMembers(type).declaredProperties, function (p) { + seen.set(p.escapedName, { prop: p, containingType: type }); + }); + var ok = true; + for (var _i = 0, baseTypes_4 = baseTypes; _i < baseTypes_4.length; _i++) { + var base = baseTypes_4[_i]; + var properties = getPropertiesOfType(getTypeWithThisArgument(base, type.thisType)); + for (var _a = 0, properties_6 = properties; _a < properties_6.length; _a++) { + var prop = properties_6[_a]; + var existing = seen.get(prop.escapedName); + if (!existing) { + seen.set(prop.escapedName, { prop: prop, containingType: base }); + } + else { + var isInheritedProperty = existing.containingType !== type; + if (isInheritedProperty && !isPropertyIdenticalTo(existing.prop, prop)) { + ok = false; + var typeName1 = typeToString(existing.containingType); + var typeName2 = typeToString(base); + var errorInfo = ts.chainDiagnosticMessages(/*details*/ undefined, ts.Diagnostics.Named_property_0_of_types_1_and_2_are_not_identical, symbolToString(prop), typeName1, typeName2); + errorInfo = ts.chainDiagnosticMessages(errorInfo, ts.Diagnostics.Interface_0_cannot_simultaneously_extend_types_1_and_2, typeToString(type), typeName1, typeName2); + diagnostics.add(ts.createDiagnosticForNodeFromMessageChain(typeNode, errorInfo)); + } + } + } + } + return ok; + } + function checkPropertyInitialization(node) { + if (!strictNullChecks || !strictPropertyInitialization || node.flags & 16777216 /* NodeFlags.Ambient */) { + return; + } + var constructor = findConstructorDeclaration(node); + for (var _i = 0, _a = node.members; _i < _a.length; _i++) { + var member = _a[_i]; + if (ts.getEffectiveModifierFlags(member) & 2 /* ModifierFlags.Ambient */) { + continue; + } + if (!ts.isStatic(member) && isPropertyWithoutInitializer(member)) { + var propName = member.name; + if (ts.isIdentifier(propName) || ts.isPrivateIdentifier(propName) || ts.isComputedPropertyName(propName)) { + var type = getTypeOfSymbol(getSymbolOfNode(member)); + if (!(type.flags & 3 /* TypeFlags.AnyOrUnknown */ || containsUndefinedType(type))) { + if (!constructor || !isPropertyInitializedInConstructor(propName, type, constructor)) { + error(member.name, ts.Diagnostics.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor, ts.declarationNameToString(propName)); + } + } + } + } + } + } + function isPropertyWithoutInitializer(node) { + return node.kind === 169 /* SyntaxKind.PropertyDeclaration */ && + !ts.hasAbstractModifier(node) && + !node.exclamationToken && + !node.initializer; + } + function isPropertyInitializedInStaticBlocks(propName, propType, staticBlocks, startPos, endPos) { + for (var _i = 0, staticBlocks_2 = staticBlocks; _i < staticBlocks_2.length; _i++) { + var staticBlock = staticBlocks_2[_i]; + // static block must be within the provided range as they are evaluated in document order (unlike constructors) + if (staticBlock.pos >= startPos && staticBlock.pos <= endPos) { + var reference = ts.factory.createPropertyAccessExpression(ts.factory.createThis(), propName); + ts.setParent(reference.expression, reference); + ts.setParent(reference, staticBlock); + reference.flowNode = staticBlock.returnFlowNode; + var flowType = getFlowTypeOfReference(reference, propType, getOptionalType(propType)); + if (!containsUndefinedType(flowType)) { + return true; + } + } + } + return false; + } + function isPropertyInitializedInConstructor(propName, propType, constructor) { + var reference = ts.isComputedPropertyName(propName) + ? ts.factory.createElementAccessExpression(ts.factory.createThis(), propName.expression) + : ts.factory.createPropertyAccessExpression(ts.factory.createThis(), propName); + ts.setParent(reference.expression, reference); + ts.setParent(reference, constructor); + reference.flowNode = constructor.returnFlowNode; + var flowType = getFlowTypeOfReference(reference, propType, getOptionalType(propType)); + return !containsUndefinedType(flowType); + } + function checkInterfaceDeclaration(node) { + // Grammar checking + if (!checkGrammarDecoratorsAndModifiers(node)) + checkGrammarInterfaceDeclaration(node); + checkTypeParameters(node.typeParameters); + addLazyDiagnostic(function () { + checkTypeNameIsReserved(node.name, ts.Diagnostics.Interface_name_cannot_be_0); + checkExportsOnMergedDeclarations(node); + var symbol = getSymbolOfNode(node); + checkTypeParameterListsIdentical(symbol); + // Only check this symbol once + var firstInterfaceDecl = ts.getDeclarationOfKind(symbol, 261 /* SyntaxKind.InterfaceDeclaration */); + if (node === firstInterfaceDecl) { + var type = getDeclaredTypeOfSymbol(symbol); + var typeWithThis = getTypeWithThisArgument(type); + // run subsequent checks only if first set succeeded + if (checkInheritedPropertiesAreIdentical(type, node.name)) { + for (var _i = 0, _a = getBaseTypes(type); _i < _a.length; _i++) { + var baseType = _a[_i]; + checkTypeAssignableTo(typeWithThis, getTypeWithThisArgument(baseType, type.thisType), node.name, ts.Diagnostics.Interface_0_incorrectly_extends_interface_1); + } + checkIndexConstraints(type, symbol); + } + } + checkObjectTypeForDuplicateDeclarations(node); + }); + ts.forEach(ts.getInterfaceBaseTypeNodes(node), function (heritageElement) { + if (!ts.isEntityNameExpression(heritageElement.expression) || ts.isOptionalChain(heritageElement.expression)) { + error(heritageElement.expression, ts.Diagnostics.An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments); + } + checkTypeReferenceNode(heritageElement); + }); + ts.forEach(node.members, checkSourceElement); + addLazyDiagnostic(function () { + checkTypeForDuplicateIndexSignatures(node); + registerForUnusedIdentifiersCheck(node); + }); + } + function checkTypeAliasDeclaration(node) { + // Grammar checking + checkGrammarDecoratorsAndModifiers(node); + checkTypeNameIsReserved(node.name, ts.Diagnostics.Type_alias_name_cannot_be_0); + checkExportsOnMergedDeclarations(node); + checkTypeParameters(node.typeParameters); + if (node.type.kind === 139 /* SyntaxKind.IntrinsicKeyword */) { + if (!intrinsicTypeKinds.has(node.name.escapedText) || ts.length(node.typeParameters) !== 1) { + error(node.type, ts.Diagnostics.The_intrinsic_keyword_can_only_be_used_to_declare_compiler_provided_intrinsic_types); + } + } + else { + checkSourceElement(node.type); + registerForUnusedIdentifiersCheck(node); + } + } + function computeEnumMemberValues(node) { + var nodeLinks = getNodeLinks(node); + if (!(nodeLinks.flags & 16384 /* NodeCheckFlags.EnumValuesComputed */)) { + nodeLinks.flags |= 16384 /* NodeCheckFlags.EnumValuesComputed */; + var autoValue = 0; + for (var _i = 0, _a = node.members; _i < _a.length; _i++) { + var member = _a[_i]; + var value = computeMemberValue(member, autoValue); + getNodeLinks(member).enumMemberValue = value; + autoValue = typeof value === "number" ? value + 1 : undefined; + } + } + } + function computeMemberValue(member, autoValue) { + if (ts.isComputedNonLiteralName(member.name)) { + error(member.name, ts.Diagnostics.Computed_property_names_are_not_allowed_in_enums); + } + else { + var text = ts.getTextOfPropertyName(member.name); + if (ts.isNumericLiteralName(text) && !ts.isInfinityOrNaNString(text)) { + error(member.name, ts.Diagnostics.An_enum_member_cannot_have_a_numeric_name); + } + } + if (member.initializer) { + return computeConstantValue(member); + } + // In ambient non-const numeric enum declarations, enum members without initializers are + // considered computed members (as opposed to having auto-incremented values). + if (member.parent.flags & 16777216 /* NodeFlags.Ambient */ && !ts.isEnumConst(member.parent) && getEnumKind(getSymbolOfNode(member.parent)) === 0 /* EnumKind.Numeric */) { + return undefined; + } + // If the member declaration specifies no value, the member is considered a constant enum member. + // If the member is the first member in the enum declaration, it is assigned the value zero. + // Otherwise, it is assigned the value of the immediately preceding member plus one, and an error + // occurs if the immediately preceding member is not a constant enum member. + if (autoValue !== undefined) { + return autoValue; + } + error(member.name, ts.Diagnostics.Enum_member_must_have_initializer); + return undefined; + } + function computeConstantValue(member) { + var enumKind = getEnumKind(getSymbolOfNode(member.parent)); + var isConstEnum = ts.isEnumConst(member.parent); + var initializer = member.initializer; + var value = enumKind === 1 /* EnumKind.Literal */ && !isLiteralEnumMember(member) ? undefined : evaluate(initializer); + if (value !== undefined) { + if (isConstEnum && typeof value === "number" && !isFinite(value)) { + error(initializer, isNaN(value) ? + ts.Diagnostics.const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN : + ts.Diagnostics.const_enum_member_initializer_was_evaluated_to_a_non_finite_value); + } + } + else if (enumKind === 1 /* EnumKind.Literal */) { + error(initializer, ts.Diagnostics.Computed_values_are_not_permitted_in_an_enum_with_string_valued_members); + return 0; + } + else if (isConstEnum) { + error(initializer, ts.Diagnostics.const_enum_member_initializers_can_only_contain_literal_values_and_other_computed_enum_values); + } + else if (member.parent.flags & 16777216 /* NodeFlags.Ambient */) { + error(initializer, ts.Diagnostics.In_ambient_enum_declarations_member_initializer_must_be_constant_expression); + } + else { + // Only here do we need to check that the initializer is assignable to the enum type. + var source = checkExpression(initializer); + if (!isTypeAssignableToKind(source, 296 /* TypeFlags.NumberLike */)) { + error(initializer, ts.Diagnostics.Only_numeric_enums_can_have_computed_members_but_this_expression_has_type_0_If_you_do_not_need_exhaustiveness_checks_consider_using_an_object_literal_instead, typeToString(source)); + } + else { + checkTypeAssignableTo(source, getDeclaredTypeOfSymbol(getSymbolOfNode(member.parent)), initializer, /*headMessage*/ undefined); + } + } + return value; + function evaluate(expr) { + switch (expr.kind) { + case 221 /* SyntaxKind.PrefixUnaryExpression */: + var value_2 = evaluate(expr.operand); + if (typeof value_2 === "number") { + switch (expr.operator) { + case 39 /* SyntaxKind.PlusToken */: return value_2; + case 40 /* SyntaxKind.MinusToken */: return -value_2; + case 54 /* SyntaxKind.TildeToken */: return ~value_2; + } + } + break; + case 223 /* SyntaxKind.BinaryExpression */: + var left = evaluate(expr.left); + var right = evaluate(expr.right); + if (typeof left === "number" && typeof right === "number") { + switch (expr.operatorToken.kind) { + case 51 /* SyntaxKind.BarToken */: return left | right; + case 50 /* SyntaxKind.AmpersandToken */: return left & right; + case 48 /* SyntaxKind.GreaterThanGreaterThanToken */: return left >> right; + case 49 /* SyntaxKind.GreaterThanGreaterThanGreaterThanToken */: return left >>> right; + case 47 /* SyntaxKind.LessThanLessThanToken */: return left << right; + case 52 /* SyntaxKind.CaretToken */: return left ^ right; + case 41 /* SyntaxKind.AsteriskToken */: return left * right; + case 43 /* SyntaxKind.SlashToken */: return left / right; + case 39 /* SyntaxKind.PlusToken */: return left + right; + case 40 /* SyntaxKind.MinusToken */: return left - right; + case 44 /* SyntaxKind.PercentToken */: return left % right; + case 42 /* SyntaxKind.AsteriskAsteriskToken */: return Math.pow(left, right); + } + } + else if (typeof left === "string" && typeof right === "string" && expr.operatorToken.kind === 39 /* SyntaxKind.PlusToken */) { + return left + right; + } + break; + case 10 /* SyntaxKind.StringLiteral */: + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + return expr.text; + case 8 /* SyntaxKind.NumericLiteral */: + checkGrammarNumericLiteral(expr); + return +expr.text; + case 214 /* SyntaxKind.ParenthesizedExpression */: + return evaluate(expr.expression); + case 79 /* SyntaxKind.Identifier */: + var identifier = expr; + if (ts.isInfinityOrNaNString(identifier.escapedText)) { + return +(identifier.escapedText); + } + return ts.nodeIsMissing(expr) ? 0 : evaluateEnumMember(expr, getSymbolOfNode(member.parent), identifier.escapedText); + case 209 /* SyntaxKind.ElementAccessExpression */: + case 208 /* SyntaxKind.PropertyAccessExpression */: + if (isConstantMemberAccess(expr)) { + var type = getTypeOfExpression(expr.expression); + if (type.symbol && type.symbol.flags & 384 /* SymbolFlags.Enum */) { + var name = void 0; + if (expr.kind === 208 /* SyntaxKind.PropertyAccessExpression */) { + name = expr.name.escapedText; + } + else { + name = ts.escapeLeadingUnderscores(ts.cast(expr.argumentExpression, ts.isLiteralExpression).text); + } + return evaluateEnumMember(expr, type.symbol, name); + } + } + break; + } + return undefined; + } + function evaluateEnumMember(expr, enumSymbol, name) { + var memberSymbol = enumSymbol.exports.get(name); + if (memberSymbol) { + var declaration = memberSymbol.valueDeclaration; + if (declaration !== member) { + if (declaration && isBlockScopedNameDeclaredBeforeUse(declaration, member) && ts.isEnumDeclaration(declaration.parent)) { + return getEnumMemberValue(declaration); + } + error(expr, ts.Diagnostics.A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums); + return 0; + } + else { + error(expr, ts.Diagnostics.Property_0_is_used_before_being_assigned, symbolToString(memberSymbol)); + } + } + return undefined; + } + } + function isConstantMemberAccess(node) { + var type = getTypeOfExpression(node); + if (type === errorType) { + return false; + } + return node.kind === 79 /* SyntaxKind.Identifier */ || + node.kind === 208 /* SyntaxKind.PropertyAccessExpression */ && isConstantMemberAccess(node.expression) || + node.kind === 209 /* SyntaxKind.ElementAccessExpression */ && isConstantMemberAccess(node.expression) && + ts.isStringLiteralLike(node.argumentExpression); + } + function checkEnumDeclaration(node) { + addLazyDiagnostic(function () { return checkEnumDeclarationWorker(node); }); + } + function checkEnumDeclarationWorker(node) { + // Grammar checking + checkGrammarDecoratorsAndModifiers(node); + checkCollisionsForDeclarationName(node, node.name); + checkExportsOnMergedDeclarations(node); + node.members.forEach(checkEnumMember); + computeEnumMemberValues(node); + // Spec 2014 - Section 9.3: + // It isn't possible for one enum declaration to continue the automatic numbering sequence of another, + // and when an enum type has multiple declarations, only one declaration is permitted to omit a value + // for the first member. + // + // Only perform this check once per symbol + var enumSymbol = getSymbolOfNode(node); + var firstDeclaration = ts.getDeclarationOfKind(enumSymbol, node.kind); + if (node === firstDeclaration) { + if (enumSymbol.declarations && enumSymbol.declarations.length > 1) { + var enumIsConst_1 = ts.isEnumConst(node); + // check that const is placed\omitted on all enum declarations + ts.forEach(enumSymbol.declarations, function (decl) { + if (ts.isEnumDeclaration(decl) && ts.isEnumConst(decl) !== enumIsConst_1) { + error(ts.getNameOfDeclaration(decl), ts.Diagnostics.Enum_declarations_must_all_be_const_or_non_const); + } + }); + } + var seenEnumMissingInitialInitializer_1 = false; + ts.forEach(enumSymbol.declarations, function (declaration) { + // return true if we hit a violation of the rule, false otherwise + if (declaration.kind !== 263 /* SyntaxKind.EnumDeclaration */) { + return false; + } + var enumDeclaration = declaration; + if (!enumDeclaration.members.length) { + return false; + } + var firstEnumMember = enumDeclaration.members[0]; + if (!firstEnumMember.initializer) { + if (seenEnumMissingInitialInitializer_1) { + error(firstEnumMember.name, ts.Diagnostics.In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enum_element); + } + else { + seenEnumMissingInitialInitializer_1 = true; + } + } + }); + } + } + function checkEnumMember(node) { + if (ts.isPrivateIdentifier(node.name)) { + error(node, ts.Diagnostics.An_enum_member_cannot_be_named_with_a_private_identifier); + } + } + function getFirstNonAmbientClassOrFunctionDeclaration(symbol) { + var declarations = symbol.declarations; + if (declarations) { + for (var _i = 0, declarations_9 = declarations; _i < declarations_9.length; _i++) { + var declaration = declarations_9[_i]; + if ((declaration.kind === 260 /* SyntaxKind.ClassDeclaration */ || + (declaration.kind === 259 /* SyntaxKind.FunctionDeclaration */ && ts.nodeIsPresent(declaration.body))) && + !(declaration.flags & 16777216 /* NodeFlags.Ambient */)) { + return declaration; + } + } + } + return undefined; + } + function inSameLexicalScope(node1, node2) { + var container1 = ts.getEnclosingBlockScopeContainer(node1); + var container2 = ts.getEnclosingBlockScopeContainer(node2); + if (isGlobalSourceFile(container1)) { + return isGlobalSourceFile(container2); + } + else if (isGlobalSourceFile(container2)) { + return false; + } + else { + return container1 === container2; + } + } + function checkModuleDeclaration(node) { + if (node.body) { + checkSourceElement(node.body); + if (!ts.isGlobalScopeAugmentation(node)) { + registerForUnusedIdentifiersCheck(node); + } + } + addLazyDiagnostic(checkModuleDeclarationDiagnostics); + function checkModuleDeclarationDiagnostics() { + // Grammar checking + var isGlobalAugmentation = ts.isGlobalScopeAugmentation(node); + var inAmbientContext = node.flags & 16777216 /* NodeFlags.Ambient */; + if (isGlobalAugmentation && !inAmbientContext) { + error(node.name, ts.Diagnostics.Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambient_context); + } + var isAmbientExternalModule = ts.isAmbientModule(node); + var contextErrorMessage = isAmbientExternalModule + ? ts.Diagnostics.An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file + : ts.Diagnostics.A_namespace_declaration_is_only_allowed_at_the_top_level_of_a_namespace_or_module; + if (checkGrammarModuleElementContext(node, contextErrorMessage)) { + // If we hit a module declaration in an illegal context, just bail out to avoid cascading errors. + return; + } + if (!checkGrammarDecoratorsAndModifiers(node)) { + if (!inAmbientContext && node.name.kind === 10 /* SyntaxKind.StringLiteral */) { + grammarErrorOnNode(node.name, ts.Diagnostics.Only_ambient_modules_can_use_quoted_names); + } + } + if (ts.isIdentifier(node.name)) { + checkCollisionsForDeclarationName(node, node.name); + } + checkExportsOnMergedDeclarations(node); + var symbol = getSymbolOfNode(node); + // The following checks only apply on a non-ambient instantiated module declaration. + if (symbol.flags & 512 /* SymbolFlags.ValueModule */ + && !inAmbientContext + && symbol.declarations + && symbol.declarations.length > 1 + && isInstantiatedModule(node, ts.shouldPreserveConstEnums(compilerOptions))) { + var firstNonAmbientClassOrFunc = getFirstNonAmbientClassOrFunctionDeclaration(symbol); + if (firstNonAmbientClassOrFunc) { + if (ts.getSourceFileOfNode(node) !== ts.getSourceFileOfNode(firstNonAmbientClassOrFunc)) { + error(node.name, ts.Diagnostics.A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merged); + } + else if (node.pos < firstNonAmbientClassOrFunc.pos) { + error(node.name, ts.Diagnostics.A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged); + } + } + // if the module merges with a class declaration in the same lexical scope, + // we need to track this to ensure the correct emit. + var mergedClass = ts.getDeclarationOfKind(symbol, 260 /* SyntaxKind.ClassDeclaration */); + if (mergedClass && + inSameLexicalScope(node, mergedClass)) { + getNodeLinks(node).flags |= 32768 /* NodeCheckFlags.LexicalModuleMergesWithClass */; + } + } + if (isAmbientExternalModule) { + if (ts.isExternalModuleAugmentation(node)) { + // body of the augmentation should be checked for consistency only if augmentation was applied to its target (either global scope or module) + // otherwise we'll be swamped in cascading errors. + // We can detect if augmentation was applied using following rules: + // - augmentation for a global scope is always applied + // - augmentation for some external module is applied if symbol for augmentation is merged (it was combined with target module). + var checkBody = isGlobalAugmentation || (getSymbolOfNode(node).flags & 33554432 /* SymbolFlags.Transient */); + if (checkBody && node.body) { + for (var _i = 0, _a = node.body.statements; _i < _a.length; _i++) { + var statement = _a[_i]; + checkModuleAugmentationElement(statement, isGlobalAugmentation); + } + } + } + else if (isGlobalSourceFile(node.parent)) { + if (isGlobalAugmentation) { + error(node.name, ts.Diagnostics.Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_declarations); + } + else if (ts.isExternalModuleNameRelative(ts.getTextOfIdentifierOrLiteral(node.name))) { + error(node.name, ts.Diagnostics.Ambient_module_declaration_cannot_specify_relative_module_name); + } + } + else { + if (isGlobalAugmentation) { + error(node.name, ts.Diagnostics.Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_declarations); + } + else { + // Node is not an augmentation and is not located on the script level. + // This means that this is declaration of ambient module that is located in other module or namespace which is prohibited. + error(node.name, ts.Diagnostics.Ambient_modules_cannot_be_nested_in_other_modules_or_namespaces); + } + } + } + } + } + function checkModuleAugmentationElement(node, isGlobalAugmentation) { + switch (node.kind) { + case 240 /* SyntaxKind.VariableStatement */: + // error each individual name in variable statement instead of marking the entire variable statement + for (var _i = 0, _a = node.declarationList.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + checkModuleAugmentationElement(decl, isGlobalAugmentation); + } + break; + case 274 /* SyntaxKind.ExportAssignment */: + case 275 /* SyntaxKind.ExportDeclaration */: + grammarErrorOnFirstToken(node, ts.Diagnostics.Exports_and_export_assignments_are_not_permitted_in_module_augmentations); + break; + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + case 269 /* SyntaxKind.ImportDeclaration */: + grammarErrorOnFirstToken(node, ts.Diagnostics.Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_module); + break; + case 205 /* SyntaxKind.BindingElement */: + case 257 /* SyntaxKind.VariableDeclaration */: + var name = node.name; + if (ts.isBindingPattern(name)) { + for (var _b = 0, _c = name.elements; _b < _c.length; _b++) { + var el = _c[_b]; + // mark individual names in binding pattern + checkModuleAugmentationElement(el, isGlobalAugmentation); + } + break; + } + // falls through + case 260 /* SyntaxKind.ClassDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 264 /* SyntaxKind.ModuleDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + if (isGlobalAugmentation) { + return; + } + break; + } + } + function getFirstNonModuleExportsIdentifier(node) { + switch (node.kind) { + case 79 /* SyntaxKind.Identifier */: + return node; + case 163 /* SyntaxKind.QualifiedName */: + do { + node = node.left; + } while (node.kind !== 79 /* SyntaxKind.Identifier */); + return node; + case 208 /* SyntaxKind.PropertyAccessExpression */: + do { + if (ts.isModuleExportsAccessExpression(node.expression) && !ts.isPrivateIdentifier(node.name)) { + return node.name; + } + node = node.expression; + } while (node.kind !== 79 /* SyntaxKind.Identifier */); + return node; + } + } + function checkExternalImportOrExportDeclaration(node) { + var moduleName = ts.getExternalModuleName(node); + if (!moduleName || ts.nodeIsMissing(moduleName)) { + // Should be a parse error. + return false; + } + if (!ts.isStringLiteral(moduleName)) { + error(moduleName, ts.Diagnostics.String_literal_expected); + return false; + } + var inAmbientExternalModule = node.parent.kind === 265 /* SyntaxKind.ModuleBlock */ && ts.isAmbientModule(node.parent.parent); + if (node.parent.kind !== 308 /* SyntaxKind.SourceFile */ && !inAmbientExternalModule) { + error(moduleName, node.kind === 275 /* SyntaxKind.ExportDeclaration */ ? + ts.Diagnostics.Export_declarations_are_not_permitted_in_a_namespace : + ts.Diagnostics.Import_declarations_in_a_namespace_cannot_reference_a_module); + return false; + } + if (inAmbientExternalModule && ts.isExternalModuleNameRelative(moduleName.text)) { + // we have already reported errors on top level imports/exports in external module augmentations in checkModuleDeclaration + // no need to do this again. + if (!isTopLevelInExternalModuleAugmentation(node)) { + // TypeScript 1.0 spec (April 2013): 12.1.6 + // An ExternalImportDeclaration in an AmbientExternalModuleDeclaration may reference + // other external modules only through top - level external module names. + // Relative external module names are not permitted. + error(node, ts.Diagnostics.Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relative_module_name); + return false; + } + } + if (!ts.isImportEqualsDeclaration(node) && node.assertClause) { + var hasError = false; + for (var _i = 0, _a = node.assertClause.elements; _i < _a.length; _i++) { + var clause = _a[_i]; + if (!ts.isStringLiteral(clause.value)) { + hasError = true; + error(clause.value, ts.Diagnostics.Import_assertion_values_must_be_string_literal_expressions); + } + } + return !hasError; + } + return true; + } + function checkAliasSymbol(node) { + var _a, _b, _c, _d, _e; + var symbol = getSymbolOfNode(node); + var target = resolveAlias(symbol); + if (target !== unknownSymbol) { + // For external modules, `symbol` represents the local symbol for an alias. + // This local symbol will merge any other local declarations (excluding other aliases) + // and symbol.flags will contains combined representation for all merged declaration. + // Based on symbol.flags we can compute a set of excluded meanings (meaning that resolved alias should not have, + // otherwise it will conflict with some local declaration). Note that in addition to normal flags we include matching SymbolFlags.Export* + // in order to prevent collisions with declarations that were exported from the current module (they still contribute to local names). + symbol = getMergedSymbol(symbol.exportSymbol || symbol); + // A type-only import/export will already have a grammar error in a JS file, so no need to issue more errors within + if (ts.isInJSFile(node) && !(target.flags & 111551 /* SymbolFlags.Value */) && !ts.isTypeOnlyImportOrExportDeclaration(node)) { + var errorNode = ts.isImportOrExportSpecifier(node) ? node.propertyName || node.name : + ts.isNamedDeclaration(node) ? node.name : + node; + ts.Debug.assert(node.kind !== 277 /* SyntaxKind.NamespaceExport */); + if (node.kind === 278 /* SyntaxKind.ExportSpecifier */) { + var diag = error(errorNode, ts.Diagnostics.Types_cannot_appear_in_export_declarations_in_JavaScript_files); + var alreadyExportedSymbol = (_b = (_a = ts.getSourceFileOfNode(node).symbol) === null || _a === void 0 ? void 0 : _a.exports) === null || _b === void 0 ? void 0 : _b.get((node.propertyName || node.name).escapedText); + if (alreadyExportedSymbol === target) { + var exportingDeclaration = (_c = alreadyExportedSymbol.declarations) === null || _c === void 0 ? void 0 : _c.find(ts.isJSDocNode); + if (exportingDeclaration) { + ts.addRelatedInfo(diag, ts.createDiagnosticForNode(exportingDeclaration, ts.Diagnostics._0_is_automatically_exported_here, ts.unescapeLeadingUnderscores(alreadyExportedSymbol.escapedName))); + } + } + } + else { + ts.Debug.assert(node.kind !== 257 /* SyntaxKind.VariableDeclaration */); + var importDeclaration = ts.findAncestor(node, ts.or(ts.isImportDeclaration, ts.isImportEqualsDeclaration)); + var moduleSpecifier = (_e = (importDeclaration && ((_d = ts.tryGetModuleSpecifierFromDeclaration(importDeclaration)) === null || _d === void 0 ? void 0 : _d.text))) !== null && _e !== void 0 ? _e : "..."; + var importedIdentifier = ts.unescapeLeadingUnderscores(ts.isIdentifier(errorNode) ? errorNode.escapedText : symbol.escapedName); + error(errorNode, ts.Diagnostics._0_is_a_type_and_cannot_be_imported_in_JavaScript_files_Use_1_in_a_JSDoc_type_annotation, importedIdentifier, "import(\"".concat(moduleSpecifier, "\").").concat(importedIdentifier)); + } + return; + } + var targetFlags = getAllSymbolFlags(target); + var excludedMeanings = (symbol.flags & (111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */) ? 111551 /* SymbolFlags.Value */ : 0) | + (symbol.flags & 788968 /* SymbolFlags.Type */ ? 788968 /* SymbolFlags.Type */ : 0) | + (symbol.flags & 1920 /* SymbolFlags.Namespace */ ? 1920 /* SymbolFlags.Namespace */ : 0); + if (targetFlags & excludedMeanings) { + var message = node.kind === 278 /* SyntaxKind.ExportSpecifier */ ? + ts.Diagnostics.Export_declaration_conflicts_with_exported_declaration_of_0 : + ts.Diagnostics.Import_declaration_conflicts_with_local_declaration_of_0; + error(node, message, symbolToString(symbol)); + } + if (compilerOptions.isolatedModules + && !ts.isTypeOnlyImportOrExportDeclaration(node) + && !(node.flags & 16777216 /* NodeFlags.Ambient */)) { + var typeOnlyAlias = getTypeOnlyAliasDeclaration(symbol); + var isType = !(targetFlags & 111551 /* SymbolFlags.Value */); + if (isType || typeOnlyAlias) { + switch (node.kind) { + case 270 /* SyntaxKind.ImportClause */: + case 273 /* SyntaxKind.ImportSpecifier */: + case 268 /* SyntaxKind.ImportEqualsDeclaration */: { + if (compilerOptions.preserveValueImports) { + ts.Debug.assertIsDefined(node.name, "An ImportClause with a symbol should have a name"); + var message = isType + ? ts.Diagnostics._0_is_a_type_and_must_be_imported_using_a_type_only_import_when_preserveValueImports_and_isolatedModules_are_both_enabled + : ts.Diagnostics._0_resolves_to_a_type_only_declaration_and_must_be_imported_using_a_type_only_import_when_preserveValueImports_and_isolatedModules_are_both_enabled; + var name = ts.idText(node.kind === 273 /* SyntaxKind.ImportSpecifier */ ? node.propertyName || node.name : node.name); + addTypeOnlyDeclarationRelatedInfo(error(node, message, name), isType ? undefined : typeOnlyAlias, name); + } + if (isType && node.kind === 268 /* SyntaxKind.ImportEqualsDeclaration */ && ts.hasEffectiveModifier(node, 1 /* ModifierFlags.Export */)) { + error(node, ts.Diagnostics.Cannot_use_export_import_on_a_type_or_type_only_namespace_when_the_isolatedModules_flag_is_provided); + } + break; + } + case 278 /* SyntaxKind.ExportSpecifier */: { + // Don't allow re-exporting an export that will be elided when `--isolatedModules` is set. + // The exception is that `import type { A } from './a'; export { A }` is allowed + // because single-file analysis can determine that the export should be dropped. + if (ts.getSourceFileOfNode(typeOnlyAlias) !== ts.getSourceFileOfNode(node)) { + var message = isType + ? ts.Diagnostics.Re_exporting_a_type_when_the_isolatedModules_flag_is_provided_requires_using_export_type + : ts.Diagnostics._0_resolves_to_a_type_only_declaration_and_must_be_re_exported_using_a_type_only_re_export_when_isolatedModules_is_enabled; + var name = ts.idText(node.propertyName || node.name); + addTypeOnlyDeclarationRelatedInfo(error(node, message, name), isType ? undefined : typeOnlyAlias, name); + return; + } + } + } + } + } + if (ts.isImportSpecifier(node)) { + var targetSymbol = checkDeprecatedAliasedSymbol(symbol, node); + if (isDeprecatedAliasedSymbol(targetSymbol) && targetSymbol.declarations) { + addDeprecatedSuggestion(node, targetSymbol.declarations, targetSymbol.escapedName); + } + } + } + } + function isDeprecatedAliasedSymbol(symbol) { + return !!symbol.declarations && ts.every(symbol.declarations, function (d) { return !!(ts.getCombinedNodeFlags(d) & 268435456 /* NodeFlags.Deprecated */); }); + } + function checkDeprecatedAliasedSymbol(symbol, location) { + if (!(symbol.flags & 2097152 /* SymbolFlags.Alias */)) + return symbol; + var targetSymbol = resolveAlias(symbol); + if (targetSymbol === unknownSymbol) + return targetSymbol; + while (symbol.flags & 2097152 /* SymbolFlags.Alias */) { + var target = getImmediateAliasedSymbol(symbol); + if (target) { + if (target === targetSymbol) + break; + if (target.declarations && ts.length(target.declarations)) { + if (isDeprecatedAliasedSymbol(target)) { + addDeprecatedSuggestion(location, target.declarations, target.escapedName); + break; + } + else { + if (symbol === targetSymbol) + break; + symbol = target; + } + } + } + else { + break; + } + } + return targetSymbol; + } + function checkImportBinding(node) { + checkCollisionsForDeclarationName(node, node.name); + checkAliasSymbol(node); + if (node.kind === 273 /* SyntaxKind.ImportSpecifier */ && + ts.idText(node.propertyName || node.name) === "default" && + ts.getESModuleInterop(compilerOptions) && + moduleKind !== ts.ModuleKind.System && (moduleKind < ts.ModuleKind.ES2015 || ts.getSourceFileOfNode(node).impliedNodeFormat === ts.ModuleKind.CommonJS)) { + checkExternalEmitHelpers(node, 131072 /* ExternalEmitHelpers.ImportDefault */); + } + } + function checkAssertClause(declaration) { + var _a; + if (declaration.assertClause) { + var validForTypeAssertions = ts.isExclusivelyTypeOnlyImportOrExport(declaration); + var override = ts.getResolutionModeOverrideForClause(declaration.assertClause, validForTypeAssertions ? grammarErrorOnNode : undefined); + if (validForTypeAssertions && override) { + if (!ts.isNightly()) { + grammarErrorOnNode(declaration.assertClause, ts.Diagnostics.resolution_mode_assertions_are_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next); + } + if (ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.Node16 && ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.NodeNext) { + return grammarErrorOnNode(declaration.assertClause, ts.Diagnostics.resolution_mode_assertions_are_only_supported_when_moduleResolution_is_node16_or_nodenext); + } + return; // Other grammar checks do not apply to type-only imports with resolution mode assertions + } + var mode = (moduleKind === ts.ModuleKind.NodeNext) && declaration.moduleSpecifier && getUsageModeForExpression(declaration.moduleSpecifier); + if (mode !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.ESNext) { + return grammarErrorOnNode(declaration.assertClause, moduleKind === ts.ModuleKind.NodeNext + ? ts.Diagnostics.Import_assertions_are_not_allowed_on_statements_that_transpile_to_commonjs_require_calls + : ts.Diagnostics.Import_assertions_are_only_supported_when_the_module_option_is_set_to_esnext_or_nodenext); + } + if (ts.isImportDeclaration(declaration) ? (_a = declaration.importClause) === null || _a === void 0 ? void 0 : _a.isTypeOnly : declaration.isTypeOnly) { + return grammarErrorOnNode(declaration.assertClause, ts.Diagnostics.Import_assertions_cannot_be_used_with_type_only_imports_or_exports); + } + if (override) { + return grammarErrorOnNode(declaration.assertClause, ts.Diagnostics.resolution_mode_can_only_be_set_for_type_only_imports); + } + } + } + function checkImportDeclaration(node) { + if (checkGrammarModuleElementContext(node, ts.isInJSFile(node) ? ts.Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module : ts.Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module)) { + // If we hit an import declaration in an illegal context, just bail out to avoid cascading errors. + return; + } + if (!checkGrammarDecoratorsAndModifiers(node) && ts.hasEffectiveModifiers(node)) { + grammarErrorOnFirstToken(node, ts.Diagnostics.An_import_declaration_cannot_have_modifiers); + } + if (checkExternalImportOrExportDeclaration(node)) { + var importClause = node.importClause; + if (importClause && !checkGrammarImportClause(importClause)) { + if (importClause.name) { + checkImportBinding(importClause); + } + if (importClause.namedBindings) { + if (importClause.namedBindings.kind === 271 /* SyntaxKind.NamespaceImport */) { + checkImportBinding(importClause.namedBindings); + if (moduleKind !== ts.ModuleKind.System && (moduleKind < ts.ModuleKind.ES2015 || ts.getSourceFileOfNode(node).impliedNodeFormat === ts.ModuleKind.CommonJS) && ts.getESModuleInterop(compilerOptions)) { + // import * as ns from "foo"; + checkExternalEmitHelpers(node, 65536 /* ExternalEmitHelpers.ImportStar */); + } + } + else { + var moduleExisted = resolveExternalModuleName(node, node.moduleSpecifier); + if (moduleExisted) { + ts.forEach(importClause.namedBindings.elements, checkImportBinding); + } + } + } + } + } + checkAssertClause(node); + } + function checkImportEqualsDeclaration(node) { + if (checkGrammarModuleElementContext(node, ts.isInJSFile(node) ? ts.Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module : ts.Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module)) { + // If we hit an import declaration in an illegal context, just bail out to avoid cascading errors. + return; + } + checkGrammarDecoratorsAndModifiers(node); + if (ts.isInternalModuleImportEqualsDeclaration(node) || checkExternalImportOrExportDeclaration(node)) { + checkImportBinding(node); + if (ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */)) { + markExportAsReferenced(node); + } + if (node.moduleReference.kind !== 280 /* SyntaxKind.ExternalModuleReference */) { + var target = resolveAlias(getSymbolOfNode(node)); + if (target !== unknownSymbol) { + var targetFlags = getAllSymbolFlags(target); + if (targetFlags & 111551 /* SymbolFlags.Value */) { + // Target is a value symbol, check that it is not hidden by a local declaration with the same name + var moduleName = ts.getFirstIdentifier(node.moduleReference); + if (!(resolveEntityName(moduleName, 111551 /* SymbolFlags.Value */ | 1920 /* SymbolFlags.Namespace */).flags & 1920 /* SymbolFlags.Namespace */)) { + error(moduleName, ts.Diagnostics.Module_0_is_hidden_by_a_local_declaration_with_the_same_name, ts.declarationNameToString(moduleName)); + } + } + if (targetFlags & 788968 /* SymbolFlags.Type */) { + checkTypeNameIsReserved(node.name, ts.Diagnostics.Import_name_cannot_be_0); + } + } + if (node.isTypeOnly) { + grammarErrorOnNode(node, ts.Diagnostics.An_import_alias_cannot_use_import_type); + } + } + else { + if (moduleKind >= ts.ModuleKind.ES2015 && ts.getSourceFileOfNode(node).impliedNodeFormat === undefined && !node.isTypeOnly && !(node.flags & 16777216 /* NodeFlags.Ambient */)) { + // Import equals declaration is deprecated in es6 or above + grammarErrorOnNode(node, ts.Diagnostics.Import_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_import_d_from_mod_or_another_module_format_instead); + } + } + } + } + function checkExportDeclaration(node) { + if (checkGrammarModuleElementContext(node, ts.isInJSFile(node) ? ts.Diagnostics.An_export_declaration_can_only_be_used_at_the_top_level_of_a_module : ts.Diagnostics.An_export_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module)) { + // If we hit an export in an illegal context, just bail out to avoid cascading errors. + return; + } + if (!checkGrammarDecoratorsAndModifiers(node) && ts.hasSyntacticModifiers(node)) { + grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_declaration_cannot_have_modifiers); + } + if (node.moduleSpecifier && node.exportClause && ts.isNamedExports(node.exportClause) && ts.length(node.exportClause.elements) && languageVersion === 0 /* ScriptTarget.ES3 */) { + checkExternalEmitHelpers(node, 4194304 /* ExternalEmitHelpers.CreateBinding */); + } + checkGrammarExportDeclaration(node); + if (!node.moduleSpecifier || checkExternalImportOrExportDeclaration(node)) { + if (node.exportClause && !ts.isNamespaceExport(node.exportClause)) { + // export { x, y } + // export { x, y } from "foo" + ts.forEach(node.exportClause.elements, checkExportSpecifier); + var inAmbientExternalModule = node.parent.kind === 265 /* SyntaxKind.ModuleBlock */ && ts.isAmbientModule(node.parent.parent); + var inAmbientNamespaceDeclaration = !inAmbientExternalModule && node.parent.kind === 265 /* SyntaxKind.ModuleBlock */ && + !node.moduleSpecifier && node.flags & 16777216 /* NodeFlags.Ambient */; + if (node.parent.kind !== 308 /* SyntaxKind.SourceFile */ && !inAmbientExternalModule && !inAmbientNamespaceDeclaration) { + error(node, ts.Diagnostics.Export_declarations_are_not_permitted_in_a_namespace); + } + } + else { + // export * from "foo" + // export * as ns from "foo"; + var moduleSymbol = resolveExternalModuleName(node, node.moduleSpecifier); + if (moduleSymbol && hasExportAssignmentSymbol(moduleSymbol)) { + error(node.moduleSpecifier, ts.Diagnostics.Module_0_uses_export_and_cannot_be_used_with_export_Asterisk, symbolToString(moduleSymbol)); + } + else if (node.exportClause) { + checkAliasSymbol(node.exportClause); + } + if (moduleKind !== ts.ModuleKind.System && (moduleKind < ts.ModuleKind.ES2015 || ts.getSourceFileOfNode(node).impliedNodeFormat === ts.ModuleKind.CommonJS)) { + if (node.exportClause) { + // export * as ns from "foo"; + // For ES2015 modules, we emit it as a pair of `import * as a_1 ...; export { a_1 as ns }` and don't need the helper. + // We only use the helper here when in esModuleInterop + if (ts.getESModuleInterop(compilerOptions)) { + checkExternalEmitHelpers(node, 65536 /* ExternalEmitHelpers.ImportStar */); + } + } + else { + // export * from "foo" + checkExternalEmitHelpers(node, 32768 /* ExternalEmitHelpers.ExportStar */); + } + } + } + } + checkAssertClause(node); + } + function checkGrammarExportDeclaration(node) { + var _a; + if (node.isTypeOnly) { + if (((_a = node.exportClause) === null || _a === void 0 ? void 0 : _a.kind) === 276 /* SyntaxKind.NamedExports */) { + return checkGrammarNamedImportsOrExports(node.exportClause); + } + else { + return grammarErrorOnNode(node, ts.Diagnostics.Only_named_exports_may_use_export_type); + } + } + return false; + } + function checkGrammarModuleElementContext(node, errorMessage) { + var isInAppropriateContext = node.parent.kind === 308 /* SyntaxKind.SourceFile */ || node.parent.kind === 265 /* SyntaxKind.ModuleBlock */ || node.parent.kind === 264 /* SyntaxKind.ModuleDeclaration */; + if (!isInAppropriateContext) { + grammarErrorOnFirstToken(node, errorMessage); + } + return !isInAppropriateContext; + } + function importClauseContainsReferencedImport(importClause) { + return ts.forEachImportClauseDeclaration(importClause, function (declaration) { + return !!getSymbolOfNode(declaration).isReferenced; + }); + } + function importClauseContainsConstEnumUsedAsValue(importClause) { + return ts.forEachImportClauseDeclaration(importClause, function (declaration) { + return !!getSymbolLinks(getSymbolOfNode(declaration)).constEnumReferenced; + }); + } + function canConvertImportDeclarationToTypeOnly(statement) { + return ts.isImportDeclaration(statement) && + statement.importClause && + !statement.importClause.isTypeOnly && + importClauseContainsReferencedImport(statement.importClause) && + !isReferencedAliasDeclaration(statement.importClause, /*checkChildren*/ true) && + !importClauseContainsConstEnumUsedAsValue(statement.importClause); + } + function canConvertImportEqualsDeclarationToTypeOnly(statement) { + return ts.isImportEqualsDeclaration(statement) && + ts.isExternalModuleReference(statement.moduleReference) && + !statement.isTypeOnly && + getSymbolOfNode(statement).isReferenced && + !isReferencedAliasDeclaration(statement, /*checkChildren*/ false) && + !getSymbolLinks(getSymbolOfNode(statement)).constEnumReferenced; + } + function checkImportsForTypeOnlyConversion(sourceFile) { + for (var _i = 0, _a = sourceFile.statements; _i < _a.length; _i++) { + var statement = _a[_i]; + if (canConvertImportDeclarationToTypeOnly(statement) || canConvertImportEqualsDeclarationToTypeOnly(statement)) { + error(statement, ts.Diagnostics.This_import_is_never_used_as_a_value_and_must_use_import_type_because_importsNotUsedAsValues_is_set_to_error); + } + } + } + function checkExportSpecifier(node) { + checkAliasSymbol(node); + if (ts.getEmitDeclarations(compilerOptions)) { + collectLinkedAliases(node.propertyName || node.name, /*setVisibility*/ true); + } + if (!node.parent.parent.moduleSpecifier) { + var exportedName = node.propertyName || node.name; + // find immediate value referenced by exported name (SymbolFlags.Alias is set so we don't chase down aliases) + var symbol = resolveName(exportedName, exportedName.escapedText, 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */ | 2097152 /* SymbolFlags.Alias */, + /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ true); + if (symbol && (symbol === undefinedSymbol || symbol === globalThisSymbol || symbol.declarations && isGlobalSourceFile(getDeclarationContainer(symbol.declarations[0])))) { + error(exportedName, ts.Diagnostics.Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module, ts.idText(exportedName)); + } + else { + if (!node.isTypeOnly && !node.parent.parent.isTypeOnly) { + markExportAsReferenced(node); + } + var target = symbol && (symbol.flags & 2097152 /* SymbolFlags.Alias */ ? resolveAlias(symbol) : symbol); + if (!target || getAllSymbolFlags(target) & 111551 /* SymbolFlags.Value */) { + checkExpressionCached(node.propertyName || node.name); + } + } + } + else { + if (ts.getESModuleInterop(compilerOptions) && + moduleKind !== ts.ModuleKind.System && + (moduleKind < ts.ModuleKind.ES2015 || ts.getSourceFileOfNode(node).impliedNodeFormat === ts.ModuleKind.CommonJS) && + ts.idText(node.propertyName || node.name) === "default") { + checkExternalEmitHelpers(node, 131072 /* ExternalEmitHelpers.ImportDefault */); + } + } + } + function checkExportAssignment(node) { + var illegalContextMessage = node.isExportEquals + ? ts.Diagnostics.An_export_assignment_must_be_at_the_top_level_of_a_file_or_module_declaration + : ts.Diagnostics.A_default_export_must_be_at_the_top_level_of_a_file_or_module_declaration; + if (checkGrammarModuleElementContext(node, illegalContextMessage)) { + // If we hit an export assignment in an illegal context, just bail out to avoid cascading errors. + return; + } + var container = node.parent.kind === 308 /* SyntaxKind.SourceFile */ ? node.parent : node.parent.parent; + if (container.kind === 264 /* SyntaxKind.ModuleDeclaration */ && !ts.isAmbientModule(container)) { + if (node.isExportEquals) { + error(node, ts.Diagnostics.An_export_assignment_cannot_be_used_in_a_namespace); + } + else { + error(node, ts.Diagnostics.A_default_export_can_only_be_used_in_an_ECMAScript_style_module); + } + return; + } + // Grammar checking + if (!checkGrammarDecoratorsAndModifiers(node) && ts.hasEffectiveModifiers(node)) { + grammarErrorOnFirstToken(node, ts.Diagnostics.An_export_assignment_cannot_have_modifiers); + } + var typeAnnotationNode = ts.getEffectiveTypeAnnotationNode(node); + if (typeAnnotationNode) { + checkTypeAssignableTo(checkExpressionCached(node.expression), getTypeFromTypeNode(typeAnnotationNode), node.expression); + } + if (node.expression.kind === 79 /* SyntaxKind.Identifier */) { + var id = node.expression; + var sym = resolveEntityName(id, 67108863 /* SymbolFlags.All */, /*ignoreErrors*/ true, /*dontResolveAlias*/ true, node); + if (sym) { + markAliasReferenced(sym, id); + // If not a value, we're interpreting the identifier as a type export, along the lines of (`export { Id as default }`) + var target = sym.flags & 2097152 /* SymbolFlags.Alias */ ? resolveAlias(sym) : sym; + if (getAllSymbolFlags(target) & 111551 /* SymbolFlags.Value */) { + // However if it is a value, we need to check it's being used correctly + checkExpressionCached(node.expression); + } + } + else { + checkExpressionCached(node.expression); // doesn't resolve, check as expression to mark as error + } + if (ts.getEmitDeclarations(compilerOptions)) { + collectLinkedAliases(node.expression, /*setVisibility*/ true); + } + } + else { + checkExpressionCached(node.expression); + } + checkExternalModuleExports(container); + if ((node.flags & 16777216 /* NodeFlags.Ambient */) && !ts.isEntityNameExpression(node.expression)) { + grammarErrorOnNode(node.expression, ts.Diagnostics.The_expression_of_an_export_assignment_must_be_an_identifier_or_qualified_name_in_an_ambient_context); + } + if (node.isExportEquals && !(node.flags & 16777216 /* NodeFlags.Ambient */)) { + if (moduleKind >= ts.ModuleKind.ES2015 && ts.getSourceFileOfNode(node).impliedNodeFormat !== ts.ModuleKind.CommonJS) { + // export assignment is not supported in es6 modules + grammarErrorOnNode(node, ts.Diagnostics.Export_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_export_default_or_another_module_format_instead); + } + else if (moduleKind === ts.ModuleKind.System) { + // system modules does not support export assignment + grammarErrorOnNode(node, ts.Diagnostics.Export_assignment_is_not_supported_when_module_flag_is_system); + } + } + } + function hasExportedMembers(moduleSymbol) { + return ts.forEachEntry(moduleSymbol.exports, function (_, id) { return id !== "export="; }); + } + function checkExternalModuleExports(node) { + var moduleSymbol = getSymbolOfNode(node); + var links = getSymbolLinks(moduleSymbol); + if (!links.exportsChecked) { + var exportEqualsSymbol = moduleSymbol.exports.get("export="); + if (exportEqualsSymbol && hasExportedMembers(moduleSymbol)) { + var declaration = getDeclarationOfAliasSymbol(exportEqualsSymbol) || exportEqualsSymbol.valueDeclaration; + if (declaration && !isTopLevelInExternalModuleAugmentation(declaration) && !ts.isInJSFile(declaration)) { + error(declaration, ts.Diagnostics.An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements); + } + } + // Checks for export * conflicts + var exports_3 = getExportsOfModule(moduleSymbol); + if (exports_3) { + exports_3.forEach(function (_a, id) { + var declarations = _a.declarations, flags = _a.flags; + if (id === "__export") { + return; + } + // ECMA262: 15.2.1.1 It is a Syntax Error if the ExportedNames of ModuleItemList contains any duplicate entries. + // (TS Exceptions: namespaces, function overloads, enums, and interfaces) + if (flags & (1920 /* SymbolFlags.Namespace */ | 384 /* SymbolFlags.Enum */)) { + return; + } + var exportedDeclarationsCount = ts.countWhere(declarations, ts.and(isNotOverloadAndNotAccessor, ts.not(ts.isInterfaceDeclaration))); + if (flags & 524288 /* SymbolFlags.TypeAlias */ && exportedDeclarationsCount <= 2) { + // it is legal to merge type alias with other values + // so count should be either 1 (just type alias) or 2 (type alias + merged value) + return; + } + if (exportedDeclarationsCount > 1) { + if (!isDuplicatedCommonJSExport(declarations)) { + for (var _i = 0, _b = declarations; _i < _b.length; _i++) { + var declaration = _b[_i]; + if (isNotOverload(declaration)) { + diagnostics.add(ts.createDiagnosticForNode(declaration, ts.Diagnostics.Cannot_redeclare_exported_variable_0, ts.unescapeLeadingUnderscores(id))); + } + } + } + } + }); + } + links.exportsChecked = true; + } + } + function isDuplicatedCommonJSExport(declarations) { + return declarations + && declarations.length > 1 + && declarations.every(function (d) { return ts.isInJSFile(d) && ts.isAccessExpression(d) && (ts.isExportsIdentifier(d.expression) || ts.isModuleExportsAccessExpression(d.expression)); }); + } + function checkSourceElement(node) { + if (node) { + var saveCurrentNode = currentNode; + currentNode = node; + instantiationCount = 0; + checkSourceElementWorker(node); + currentNode = saveCurrentNode; + } + } + function checkSourceElementWorker(node) { + ts.forEach(node.jsDoc, function (_a) { + var comment = _a.comment, tags = _a.tags; + checkJSDocCommentWorker(comment); + ts.forEach(tags, function (tag) { + checkJSDocCommentWorker(tag.comment); + if (ts.isInJSFile(node)) { + checkSourceElement(tag); + } + }); + }); + var kind = node.kind; + if (cancellationToken) { + // Only bother checking on a few construct kinds. We don't want to be excessively + // hitting the cancellation token on every node we check. + switch (kind) { + case 264 /* SyntaxKind.ModuleDeclaration */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 259 /* SyntaxKind.FunctionDeclaration */: + cancellationToken.throwIfCancellationRequested(); + } + } + if (kind >= 240 /* SyntaxKind.FirstStatement */ && kind <= 256 /* SyntaxKind.LastStatement */ && node.flowNode && !isReachableFlowNode(node.flowNode)) { + errorOrSuggestion(compilerOptions.allowUnreachableCode === false, node, ts.Diagnostics.Unreachable_code_detected); + } + switch (kind) { + case 165 /* SyntaxKind.TypeParameter */: + return checkTypeParameter(node); + case 166 /* SyntaxKind.Parameter */: + return checkParameter(node); + case 169 /* SyntaxKind.PropertyDeclaration */: + return checkPropertyDeclaration(node); + case 168 /* SyntaxKind.PropertySignature */: + return checkPropertySignature(node); + case 182 /* SyntaxKind.ConstructorType */: + case 181 /* SyntaxKind.FunctionType */: + case 176 /* SyntaxKind.CallSignature */: + case 177 /* SyntaxKind.ConstructSignature */: + case 178 /* SyntaxKind.IndexSignature */: + return checkSignatureDeclaration(node); + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + return checkMethodDeclaration(node); + case 172 /* SyntaxKind.ClassStaticBlockDeclaration */: + return checkClassStaticBlockDeclaration(node); + case 173 /* SyntaxKind.Constructor */: + return checkConstructorDeclaration(node); + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + return checkAccessorDeclaration(node); + case 180 /* SyntaxKind.TypeReference */: + return checkTypeReferenceNode(node); + case 179 /* SyntaxKind.TypePredicate */: + return checkTypePredicate(node); + case 183 /* SyntaxKind.TypeQuery */: + return checkTypeQuery(node); + case 184 /* SyntaxKind.TypeLiteral */: + return checkTypeLiteral(node); + case 185 /* SyntaxKind.ArrayType */: + return checkArrayType(node); + case 186 /* SyntaxKind.TupleType */: + return checkTupleType(node); + case 189 /* SyntaxKind.UnionType */: + case 190 /* SyntaxKind.IntersectionType */: + return checkUnionOrIntersectionType(node); + case 193 /* SyntaxKind.ParenthesizedType */: + case 187 /* SyntaxKind.OptionalType */: + case 188 /* SyntaxKind.RestType */: + return checkSourceElement(node.type); + case 194 /* SyntaxKind.ThisType */: + return checkThisType(node); + case 195 /* SyntaxKind.TypeOperator */: + return checkTypeOperator(node); + case 191 /* SyntaxKind.ConditionalType */: + return checkConditionalType(node); + case 192 /* SyntaxKind.InferType */: + return checkInferType(node); + case 200 /* SyntaxKind.TemplateLiteralType */: + return checkTemplateLiteralType(node); + case 202 /* SyntaxKind.ImportType */: + return checkImportType(node); + case 199 /* SyntaxKind.NamedTupleMember */: + return checkNamedTupleMember(node); + case 331 /* SyntaxKind.JSDocAugmentsTag */: + return checkJSDocAugmentsTag(node); + case 332 /* SyntaxKind.JSDocImplementsTag */: + return checkJSDocImplementsTag(node); + case 348 /* SyntaxKind.JSDocTypedefTag */: + case 341 /* SyntaxKind.JSDocCallbackTag */: + case 342 /* SyntaxKind.JSDocEnumTag */: + return checkJSDocTypeAliasTag(node); + case 347 /* SyntaxKind.JSDocTemplateTag */: + return checkJSDocTemplateTag(node); + case 346 /* SyntaxKind.JSDocTypeTag */: + return checkJSDocTypeTag(node); + case 327 /* SyntaxKind.JSDocLink */: + case 328 /* SyntaxKind.JSDocLinkCode */: + case 329 /* SyntaxKind.JSDocLinkPlain */: + return checkJSDocLinkLikeTag(node); + case 343 /* SyntaxKind.JSDocParameterTag */: + return checkJSDocParameterTag(node); + case 350 /* SyntaxKind.JSDocPropertyTag */: + return checkJSDocPropertyTag(node); + case 320 /* SyntaxKind.JSDocFunctionType */: + checkJSDocFunctionType(node); + // falls through + case 318 /* SyntaxKind.JSDocNonNullableType */: + case 317 /* SyntaxKind.JSDocNullableType */: + case 315 /* SyntaxKind.JSDocAllType */: + case 316 /* SyntaxKind.JSDocUnknownType */: + case 325 /* SyntaxKind.JSDocTypeLiteral */: + checkJSDocTypeIsInJsFile(node); + ts.forEachChild(node, checkSourceElement); + return; + case 321 /* SyntaxKind.JSDocVariadicType */: + checkJSDocVariadicType(node); + return; + case 312 /* SyntaxKind.JSDocTypeExpression */: + return checkSourceElement(node.type); + case 336 /* SyntaxKind.JSDocPublicTag */: + case 338 /* SyntaxKind.JSDocProtectedTag */: + case 337 /* SyntaxKind.JSDocPrivateTag */: + return checkJSDocAccessibilityModifiers(node); + case 196 /* SyntaxKind.IndexedAccessType */: + return checkIndexedAccessType(node); + case 197 /* SyntaxKind.MappedType */: + return checkMappedType(node); + case 259 /* SyntaxKind.FunctionDeclaration */: + return checkFunctionDeclaration(node); + case 238 /* SyntaxKind.Block */: + case 265 /* SyntaxKind.ModuleBlock */: + return checkBlock(node); + case 240 /* SyntaxKind.VariableStatement */: + return checkVariableStatement(node); + case 241 /* SyntaxKind.ExpressionStatement */: + return checkExpressionStatement(node); + case 242 /* SyntaxKind.IfStatement */: + return checkIfStatement(node); + case 243 /* SyntaxKind.DoStatement */: + return checkDoStatement(node); + case 244 /* SyntaxKind.WhileStatement */: + return checkWhileStatement(node); + case 245 /* SyntaxKind.ForStatement */: + return checkForStatement(node); + case 246 /* SyntaxKind.ForInStatement */: + return checkForInStatement(node); + case 247 /* SyntaxKind.ForOfStatement */: + return checkForOfStatement(node); + case 248 /* SyntaxKind.ContinueStatement */: + case 249 /* SyntaxKind.BreakStatement */: + return checkBreakOrContinueStatement(node); + case 250 /* SyntaxKind.ReturnStatement */: + return checkReturnStatement(node); + case 251 /* SyntaxKind.WithStatement */: + return checkWithStatement(node); + case 252 /* SyntaxKind.SwitchStatement */: + return checkSwitchStatement(node); + case 253 /* SyntaxKind.LabeledStatement */: + return checkLabeledStatement(node); + case 254 /* SyntaxKind.ThrowStatement */: + return checkThrowStatement(node); + case 255 /* SyntaxKind.TryStatement */: + return checkTryStatement(node); + case 257 /* SyntaxKind.VariableDeclaration */: + return checkVariableDeclaration(node); + case 205 /* SyntaxKind.BindingElement */: + return checkBindingElement(node); + case 260 /* SyntaxKind.ClassDeclaration */: + return checkClassDeclaration(node); + case 261 /* SyntaxKind.InterfaceDeclaration */: + return checkInterfaceDeclaration(node); + case 262 /* SyntaxKind.TypeAliasDeclaration */: + return checkTypeAliasDeclaration(node); + case 263 /* SyntaxKind.EnumDeclaration */: + return checkEnumDeclaration(node); + case 264 /* SyntaxKind.ModuleDeclaration */: + return checkModuleDeclaration(node); + case 269 /* SyntaxKind.ImportDeclaration */: + return checkImportDeclaration(node); + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return checkImportEqualsDeclaration(node); + case 275 /* SyntaxKind.ExportDeclaration */: + return checkExportDeclaration(node); + case 274 /* SyntaxKind.ExportAssignment */: + return checkExportAssignment(node); + case 239 /* SyntaxKind.EmptyStatement */: + case 256 /* SyntaxKind.DebuggerStatement */: + checkGrammarStatementInAmbientContext(node); + return; + case 279 /* SyntaxKind.MissingDeclaration */: + return checkMissingDeclaration(node); + } + } + function checkJSDocCommentWorker(node) { + if (ts.isArray(node)) { + ts.forEach(node, function (tag) { + if (ts.isJSDocLinkLike(tag)) { + checkSourceElement(tag); + } + }); + } + } + function checkJSDocTypeIsInJsFile(node) { + if (!ts.isInJSFile(node)) { + grammarErrorOnNode(node, ts.Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments); + } + } + function checkJSDocVariadicType(node) { + checkJSDocTypeIsInJsFile(node); + checkSourceElement(node.type); + // Only legal location is in the *last* parameter tag or last parameter of a JSDoc function. + var parent = node.parent; + if (ts.isParameter(parent) && ts.isJSDocFunctionType(parent.parent)) { + if (ts.last(parent.parent.parameters) !== parent) { + error(node, ts.Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list); + } + return; + } + if (!ts.isJSDocTypeExpression(parent)) { + error(node, ts.Diagnostics.JSDoc_may_only_appear_in_the_last_parameter_of_a_signature); + } + var paramTag = node.parent.parent; + if (!ts.isJSDocParameterTag(paramTag)) { + error(node, ts.Diagnostics.JSDoc_may_only_appear_in_the_last_parameter_of_a_signature); + return; + } + var param = ts.getParameterSymbolFromJSDoc(paramTag); + if (!param) { + // We will error in `checkJSDocParameterTag`. + return; + } + var host = ts.getHostSignatureFromJSDoc(paramTag); + if (!host || ts.last(host.parameters).symbol !== param) { + error(node, ts.Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list); + } + } + function getTypeFromJSDocVariadicType(node) { + var type = getTypeFromTypeNode(node.type); + var parent = node.parent; + var paramTag = node.parent.parent; + if (ts.isJSDocTypeExpression(node.parent) && ts.isJSDocParameterTag(paramTag)) { + // Else we will add a diagnostic, see `checkJSDocVariadicType`. + var host_1 = ts.getHostSignatureFromJSDoc(paramTag); + var isCallbackTag = ts.isJSDocCallbackTag(paramTag.parent.parent); + if (host_1 || isCallbackTag) { + /* + Only return an array type if the corresponding parameter is marked as a rest parameter, or if there are no parameters. + So in the following situation we will not create an array type: + /** @param {...number} a * / + function f(a) {} + Because `a` will just be of type `number | undefined`. A synthetic `...args` will also be added, which *will* get an array type. + */ + var lastParamDeclaration = isCallbackTag + ? ts.lastOrUndefined(paramTag.parent.parent.typeExpression.parameters) + : ts.lastOrUndefined(host_1.parameters); + var symbol = ts.getParameterSymbolFromJSDoc(paramTag); + if (!lastParamDeclaration || + symbol && lastParamDeclaration.symbol === symbol && ts.isRestParameter(lastParamDeclaration)) { + return createArrayType(type); + } + } + } + if (ts.isParameter(parent) && ts.isJSDocFunctionType(parent.parent)) { + return createArrayType(type); + } + return addOptionality(type); + } + // Function and class expression bodies are checked after all statements in the enclosing body. This is + // to ensure constructs like the following are permitted: + // const foo = function () { + // const s = foo(); + // return "hello"; + // } + // Here, performing a full type check of the body of the function expression whilst in the process of + // determining the type of foo would cause foo to be given type any because of the recursive reference. + // Delaying the type check of the body ensures foo has been assigned a type. + function checkNodeDeferred(node) { + var enclosingFile = ts.getSourceFileOfNode(node); + var links = getNodeLinks(enclosingFile); + if (!(links.flags & 1 /* NodeCheckFlags.TypeChecked */)) { + links.deferredNodes || (links.deferredNodes = new ts.Set()); + links.deferredNodes.add(node); + } + } + function checkDeferredNodes(context) { + var links = getNodeLinks(context); + if (links.deferredNodes) { + links.deferredNodes.forEach(checkDeferredNode); + } + } + function checkDeferredNode(node) { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("check" /* tracing.Phase.Check */, "checkDeferredNode", { kind: node.kind, pos: node.pos, end: node.end, path: node.tracingPath }); + var saveCurrentNode = currentNode; + currentNode = node; + instantiationCount = 0; + switch (node.kind) { + case 210 /* SyntaxKind.CallExpression */: + case 211 /* SyntaxKind.NewExpression */: + case 212 /* SyntaxKind.TaggedTemplateExpression */: + case 167 /* SyntaxKind.Decorator */: + case 283 /* SyntaxKind.JsxOpeningElement */: + // These node kinds are deferred checked when overload resolution fails + // To save on work, we ensure the arguments are checked just once, in + // a deferred way + resolveUntypedCall(node); + break; + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + checkFunctionExpressionOrObjectLiteralMethodDeferred(node); + break; + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + checkAccessorDeclaration(node); + break; + case 228 /* SyntaxKind.ClassExpression */: + checkClassExpressionDeferred(node); + break; + case 165 /* SyntaxKind.TypeParameter */: + checkTypeParameterDeferred(node); + break; + case 282 /* SyntaxKind.JsxSelfClosingElement */: + checkJsxSelfClosingElementDeferred(node); + break; + case 281 /* SyntaxKind.JsxElement */: + checkJsxElementDeferred(node); + break; + } + currentNode = saveCurrentNode; + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + } + function checkSourceFile(node) { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("check" /* tracing.Phase.Check */, "checkSourceFile", { path: node.path }, /*separateBeginAndEnd*/ true); + ts.performance.mark("beforeCheck"); + checkSourceFileWorker(node); + ts.performance.mark("afterCheck"); + ts.performance.measure("Check", "beforeCheck", "afterCheck"); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + } + function unusedIsError(kind, isAmbient) { + if (isAmbient) { + return false; + } + switch (kind) { + case 0 /* UnusedKind.Local */: + return !!compilerOptions.noUnusedLocals; + case 1 /* UnusedKind.Parameter */: + return !!compilerOptions.noUnusedParameters; + default: + return ts.Debug.assertNever(kind); + } + } + function getPotentiallyUnusedIdentifiers(sourceFile) { + return allPotentiallyUnusedIdentifiers.get(sourceFile.path) || ts.emptyArray; + } + // Fully type check a source file and collect the relevant diagnostics. + function checkSourceFileWorker(node) { + var links = getNodeLinks(node); + if (!(links.flags & 1 /* NodeCheckFlags.TypeChecked */)) { + if (ts.skipTypeChecking(node, compilerOptions, host)) { + return; + } + // Grammar checking + checkGrammarSourceFile(node); + ts.clear(potentialThisCollisions); + ts.clear(potentialNewTargetCollisions); + ts.clear(potentialWeakMapSetCollisions); + ts.clear(potentialReflectCollisions); + ts.clear(potentialUnusedRenamedBindingElementsInTypes); + ts.forEach(node.statements, checkSourceElement); + checkSourceElement(node.endOfFileToken); + checkDeferredNodes(node); + if (ts.isExternalOrCommonJsModule(node)) { + registerForUnusedIdentifiersCheck(node); + } + addLazyDiagnostic(function () { + // This relies on the results of other lazy diagnostics, so must be computed after them + if (!node.isDeclarationFile && (compilerOptions.noUnusedLocals || compilerOptions.noUnusedParameters)) { + checkUnusedIdentifiers(getPotentiallyUnusedIdentifiers(node), function (containingNode, kind, diag) { + if (!ts.containsParseError(containingNode) && unusedIsError(kind, !!(containingNode.flags & 16777216 /* NodeFlags.Ambient */))) { + diagnostics.add(diag); + } + }); + } + if (!node.isDeclarationFile) { + checkPotentialUncheckedRenamedBindingElementsInTypes(); + } + }); + if (compilerOptions.importsNotUsedAsValues === 2 /* ImportsNotUsedAsValues.Error */ && + !node.isDeclarationFile && + ts.isExternalModule(node)) { + checkImportsForTypeOnlyConversion(node); + } + if (ts.isExternalOrCommonJsModule(node)) { + checkExternalModuleExports(node); + } + if (potentialThisCollisions.length) { + ts.forEach(potentialThisCollisions, checkIfThisIsCapturedInEnclosingScope); + ts.clear(potentialThisCollisions); + } + if (potentialNewTargetCollisions.length) { + ts.forEach(potentialNewTargetCollisions, checkIfNewTargetIsCapturedInEnclosingScope); + ts.clear(potentialNewTargetCollisions); + } + if (potentialWeakMapSetCollisions.length) { + ts.forEach(potentialWeakMapSetCollisions, checkWeakMapSetCollision); + ts.clear(potentialWeakMapSetCollisions); + } + if (potentialReflectCollisions.length) { + ts.forEach(potentialReflectCollisions, checkReflectCollision); + ts.clear(potentialReflectCollisions); + } + links.flags |= 1 /* NodeCheckFlags.TypeChecked */; + } + } + function getDiagnostics(sourceFile, ct) { + try { + // Record the cancellation token so it can be checked later on during checkSourceElement. + // Do this in a finally block so we can ensure that it gets reset back to nothing after + // this call is done. + cancellationToken = ct; + return getDiagnosticsWorker(sourceFile); + } + finally { + cancellationToken = undefined; + } + } + function ensurePendingDiagnosticWorkComplete() { + // Invoke any existing lazy diagnostics to add them, clear the backlog of diagnostics + for (var _i = 0, deferredDiagnosticsCallbacks_1 = deferredDiagnosticsCallbacks; _i < deferredDiagnosticsCallbacks_1.length; _i++) { + var cb = deferredDiagnosticsCallbacks_1[_i]; + cb(); + } + deferredDiagnosticsCallbacks = []; + } + function checkSourceFileWithEagerDiagnostics(sourceFile) { + ensurePendingDiagnosticWorkComplete(); + // then setup diagnostics for immediate invocation (as we are about to collect them, and + // this avoids the overhead of longer-lived callbacks we don't need to allocate) + // This also serves to make the shift to possibly lazy diagnostics transparent to serial command-line scenarios + // (as in those cases, all the diagnostics will still be computed as the appropriate place in the tree, + // thus much more likely retaining the same union ordering as before we had lazy diagnostics) + var oldAddLazyDiagnostics = addLazyDiagnostic; + addLazyDiagnostic = function (cb) { return cb(); }; + checkSourceFile(sourceFile); + addLazyDiagnostic = oldAddLazyDiagnostics; + } + function getDiagnosticsWorker(sourceFile) { + if (sourceFile) { + ensurePendingDiagnosticWorkComplete(); + // Some global diagnostics are deferred until they are needed and + // may not be reported in the first call to getGlobalDiagnostics. + // We should catch these changes and report them. + var previousGlobalDiagnostics = diagnostics.getGlobalDiagnostics(); + var previousGlobalDiagnosticsSize = previousGlobalDiagnostics.length; + checkSourceFileWithEagerDiagnostics(sourceFile); + var semanticDiagnostics = diagnostics.getDiagnostics(sourceFile.fileName); + var currentGlobalDiagnostics = diagnostics.getGlobalDiagnostics(); + if (currentGlobalDiagnostics !== previousGlobalDiagnostics) { + // If the arrays are not the same reference, new diagnostics were added. + var deferredGlobalDiagnostics = ts.relativeComplement(previousGlobalDiagnostics, currentGlobalDiagnostics, ts.compareDiagnostics); + return ts.concatenate(deferredGlobalDiagnostics, semanticDiagnostics); + } + else if (previousGlobalDiagnosticsSize === 0 && currentGlobalDiagnostics.length > 0) { + // If the arrays are the same reference, but the length has changed, a single + // new diagnostic was added as DiagnosticCollection attempts to reuse the + // same array. + return ts.concatenate(currentGlobalDiagnostics, semanticDiagnostics); + } + return semanticDiagnostics; + } + // Global diagnostics are always added when a file is not provided to + // getDiagnostics + ts.forEach(host.getSourceFiles(), checkSourceFileWithEagerDiagnostics); + return diagnostics.getDiagnostics(); + } + function getGlobalDiagnostics() { + ensurePendingDiagnosticWorkComplete(); + return diagnostics.getGlobalDiagnostics(); + } + // Language service support + function getSymbolsInScope(location, meaning) { + if (location.flags & 33554432 /* NodeFlags.InWithStatement */) { + // We cannot answer semantic questions within a with block, do not proceed any further + return []; + } + var symbols = ts.createSymbolTable(); + var isStaticSymbol = false; + populateSymbols(); + symbols.delete("this" /* InternalSymbolName.This */); // Not a symbol, a keyword + return symbolsToArray(symbols); + function populateSymbols() { + while (location) { + if (location.locals && !isGlobalSourceFile(location)) { + copySymbols(location.locals, meaning); + } + switch (location.kind) { + case 308 /* SyntaxKind.SourceFile */: + if (!ts.isExternalModule(location)) + break; + // falls through + case 264 /* SyntaxKind.ModuleDeclaration */: + copyLocallyVisibleExportSymbols(getSymbolOfNode(location).exports, meaning & 2623475 /* SymbolFlags.ModuleMember */); + break; + case 263 /* SyntaxKind.EnumDeclaration */: + copySymbols(getSymbolOfNode(location).exports, meaning & 8 /* SymbolFlags.EnumMember */); + break; + case 228 /* SyntaxKind.ClassExpression */: + var className = location.name; + if (className) { + copySymbol(location.symbol, meaning); + } + // this fall-through is necessary because we would like to handle + // type parameter inside class expression similar to how we handle it in classDeclaration and interface Declaration. + // falls through + case 260 /* SyntaxKind.ClassDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + // If we didn't come from static member of class or interface, + // add the type parameters into the symbol table + // (type parameters of classDeclaration/classExpression and interface are in member property of the symbol. + // Note: that the memberFlags come from previous iteration. + if (!isStaticSymbol) { + copySymbols(getMembersOfSymbol(getSymbolOfNode(location)), meaning & 788968 /* SymbolFlags.Type */); + } + break; + case 215 /* SyntaxKind.FunctionExpression */: + var funcName = location.name; + if (funcName) { + copySymbol(location.symbol, meaning); + } + break; + } + if (ts.introducesArgumentsExoticObject(location)) { + copySymbol(argumentsSymbol, meaning); + } + isStaticSymbol = ts.isStatic(location); + location = location.parent; + } + copySymbols(globals, meaning); + } + /** + * Copy the given symbol into symbol tables if the symbol has the given meaning + * and it doesn't already existed in the symbol table + * @param key a key for storing in symbol table; if undefined, use symbol.name + * @param symbol the symbol to be added into symbol table + * @param meaning meaning of symbol to filter by before adding to symbol table + */ + function copySymbol(symbol, meaning) { + if (ts.getCombinedLocalAndExportSymbolFlags(symbol) & meaning) { + var id = symbol.escapedName; + // We will copy all symbol regardless of its reserved name because + // symbolsToArray will check whether the key is a reserved name and + // it will not copy symbol with reserved name to the array + if (!symbols.has(id)) { + symbols.set(id, symbol); + } + } + } + function copySymbols(source, meaning) { + if (meaning) { + source.forEach(function (symbol) { + copySymbol(symbol, meaning); + }); + } + } + function copyLocallyVisibleExportSymbols(source, meaning) { + if (meaning) { + source.forEach(function (symbol) { + // Similar condition as in `resolveNameHelper` + if (!ts.getDeclarationOfKind(symbol, 278 /* SyntaxKind.ExportSpecifier */) && !ts.getDeclarationOfKind(symbol, 277 /* SyntaxKind.NamespaceExport */)) { + copySymbol(symbol, meaning); + } + }); + } + } + } + function isTypeDeclarationName(name) { + return name.kind === 79 /* SyntaxKind.Identifier */ && + ts.isTypeDeclaration(name.parent) && + ts.getNameOfDeclaration(name.parent) === name; + } + // True if the given identifier is part of a type reference + function isTypeReferenceIdentifier(node) { + while (node.parent.kind === 163 /* SyntaxKind.QualifiedName */) { + node = node.parent; + } + return node.parent.kind === 180 /* SyntaxKind.TypeReference */; + } + function isHeritageClauseElementIdentifier(node) { + while (node.parent.kind === 208 /* SyntaxKind.PropertyAccessExpression */) { + node = node.parent; + } + return node.parent.kind === 230 /* SyntaxKind.ExpressionWithTypeArguments */; + } + function forEachEnclosingClass(node, callback) { + var result; + while (true) { + node = ts.getContainingClass(node); + if (!node) + break; + if (result = callback(node)) + break; + } + return result; + } + function isNodeUsedDuringClassInitialization(node) { + return !!ts.findAncestor(node, function (element) { + if (ts.isConstructorDeclaration(element) && ts.nodeIsPresent(element.body) || ts.isPropertyDeclaration(element)) { + return true; + } + else if (ts.isClassLike(element) || ts.isFunctionLikeDeclaration(element)) { + return "quit"; + } + return false; + }); + } + function isNodeWithinClass(node, classDeclaration) { + return !!forEachEnclosingClass(node, function (n) { return n === classDeclaration; }); + } + function getLeftSideOfImportEqualsOrExportAssignment(nodeOnRightSide) { + while (nodeOnRightSide.parent.kind === 163 /* SyntaxKind.QualifiedName */) { + nodeOnRightSide = nodeOnRightSide.parent; + } + if (nodeOnRightSide.parent.kind === 268 /* SyntaxKind.ImportEqualsDeclaration */) { + return nodeOnRightSide.parent.moduleReference === nodeOnRightSide ? nodeOnRightSide.parent : undefined; + } + if (nodeOnRightSide.parent.kind === 274 /* SyntaxKind.ExportAssignment */) { + return nodeOnRightSide.parent.expression === nodeOnRightSide ? nodeOnRightSide.parent : undefined; + } + return undefined; + } + function isInRightSideOfImportOrExportAssignment(node) { + return getLeftSideOfImportEqualsOrExportAssignment(node) !== undefined; + } + function getSpecialPropertyAssignmentSymbolFromEntityName(entityName) { + var specialPropertyAssignmentKind = ts.getAssignmentDeclarationKind(entityName.parent.parent); + switch (specialPropertyAssignmentKind) { + case 1 /* AssignmentDeclarationKind.ExportsProperty */: + case 3 /* AssignmentDeclarationKind.PrototypeProperty */: + return getSymbolOfNode(entityName.parent); + case 4 /* AssignmentDeclarationKind.ThisProperty */: + case 2 /* AssignmentDeclarationKind.ModuleExports */: + case 5 /* AssignmentDeclarationKind.Property */: + return getSymbolOfNode(entityName.parent.parent); + } + } + function isImportTypeQualifierPart(node) { + var parent = node.parent; + while (ts.isQualifiedName(parent)) { + node = parent; + parent = parent.parent; + } + if (parent && parent.kind === 202 /* SyntaxKind.ImportType */ && parent.qualifier === node) { + return parent; + } + return undefined; + } + function getSymbolOfNameOrPropertyAccessExpression(name) { + if (ts.isDeclarationName(name)) { + return getSymbolOfNode(name.parent); + } + if (ts.isInJSFile(name) && + name.parent.kind === 208 /* SyntaxKind.PropertyAccessExpression */ && + name.parent === name.parent.parent.left) { + // Check if this is a special property assignment + if (!ts.isPrivateIdentifier(name) && !ts.isJSDocMemberName(name)) { + var specialPropertyAssignmentSymbol = getSpecialPropertyAssignmentSymbolFromEntityName(name); + if (specialPropertyAssignmentSymbol) { + return specialPropertyAssignmentSymbol; + } + } + } + if (name.parent.kind === 274 /* SyntaxKind.ExportAssignment */ && ts.isEntityNameExpression(name)) { + // Even an entity name expression that doesn't resolve as an entityname may still typecheck as a property access expression + var success = resolveEntityName(name, + /*all meanings*/ 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */ | 2097152 /* SymbolFlags.Alias */, /*ignoreErrors*/ true); + if (success && success !== unknownSymbol) { + return success; + } + } + else if (ts.isEntityName(name) && isInRightSideOfImportOrExportAssignment(name)) { + // Since we already checked for ExportAssignment, this really could only be an Import + var importEqualsDeclaration = ts.getAncestor(name, 268 /* SyntaxKind.ImportEqualsDeclaration */); + ts.Debug.assert(importEqualsDeclaration !== undefined); + return getSymbolOfPartOfRightHandSideOfImportEquals(name, /*dontResolveAlias*/ true); + } + if (ts.isEntityName(name)) { + var possibleImportNode = isImportTypeQualifierPart(name); + if (possibleImportNode) { + getTypeFromTypeNode(possibleImportNode); + var sym = getNodeLinks(name).resolvedSymbol; + return sym === unknownSymbol ? undefined : sym; + } + } + while (ts.isRightSideOfQualifiedNameOrPropertyAccessOrJSDocMemberName(name)) { + name = name.parent; + } + if (isHeritageClauseElementIdentifier(name)) { + var meaning = 0 /* SymbolFlags.None */; + // In an interface or class, we're definitely interested in a type. + if (name.parent.kind === 230 /* SyntaxKind.ExpressionWithTypeArguments */) { + meaning = 788968 /* SymbolFlags.Type */; + // In a class 'extends' clause we are also looking for a value. + if (ts.isExpressionWithTypeArgumentsInClassExtendsClause(name.parent)) { + meaning |= 111551 /* SymbolFlags.Value */; + } + } + else { + meaning = 1920 /* SymbolFlags.Namespace */; + } + meaning |= 2097152 /* SymbolFlags.Alias */; + var entityNameSymbol = ts.isEntityNameExpression(name) ? resolveEntityName(name, meaning) : undefined; + if (entityNameSymbol) { + return entityNameSymbol; + } + } + if (name.parent.kind === 343 /* SyntaxKind.JSDocParameterTag */) { + return ts.getParameterSymbolFromJSDoc(name.parent); + } + if (name.parent.kind === 165 /* SyntaxKind.TypeParameter */ && name.parent.parent.kind === 347 /* SyntaxKind.JSDocTemplateTag */) { + ts.Debug.assert(!ts.isInJSFile(name)); // Otherwise `isDeclarationName` would have been true. + var typeParameter = ts.getTypeParameterFromJsDoc(name.parent); + return typeParameter && typeParameter.symbol; + } + if (ts.isExpressionNode(name)) { + if (ts.nodeIsMissing(name)) { + // Missing entity name. + return undefined; + } + var isJSDoc_1 = ts.findAncestor(name, ts.or(ts.isJSDocLinkLike, ts.isJSDocNameReference, ts.isJSDocMemberName)); + var meaning = isJSDoc_1 ? 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */ | 111551 /* SymbolFlags.Value */ : 111551 /* SymbolFlags.Value */; + if (name.kind === 79 /* SyntaxKind.Identifier */) { + if (ts.isJSXTagName(name) && isJsxIntrinsicIdentifier(name)) { + var symbol = getIntrinsicTagSymbol(name.parent); + return symbol === unknownSymbol ? undefined : symbol; + } + var result = resolveEntityName(name, meaning, /*ignoreErrors*/ false, /* dontResolveAlias */ true, ts.getHostSignatureFromJSDoc(name)); + if (!result && isJSDoc_1) { + var container = ts.findAncestor(name, ts.or(ts.isClassLike, ts.isInterfaceDeclaration)); + if (container) { + return resolveJSDocMemberName(name, /*ignoreErrors*/ false, getSymbolOfNode(container)); + } + } + if (result && isJSDoc_1) { + var container = ts.getJSDocHost(name); + if (container && ts.isEnumMember(container) && container === result.valueDeclaration) { + return resolveEntityName(name, meaning, /*ignoreErrors*/ true, /* dontResolveAlias */ true, ts.getSourceFileOfNode(container)) || result; + } + } + return result; + } + else if (ts.isPrivateIdentifier(name)) { + return getSymbolForPrivateIdentifierExpression(name); + } + else if (name.kind === 208 /* SyntaxKind.PropertyAccessExpression */ || name.kind === 163 /* SyntaxKind.QualifiedName */) { + var links = getNodeLinks(name); + if (links.resolvedSymbol) { + return links.resolvedSymbol; + } + if (name.kind === 208 /* SyntaxKind.PropertyAccessExpression */) { + checkPropertyAccessExpression(name, 0 /* CheckMode.Normal */); + if (!links.resolvedSymbol) { + var expressionType = checkExpressionCached(name.expression); + var infos = getApplicableIndexInfos(expressionType, getLiteralTypeFromPropertyName(name.name)); + if (infos.length && expressionType.members) { + var resolved = resolveStructuredTypeMembers(expressionType); + var symbol = resolved.members.get("__index" /* InternalSymbolName.Index */); + if (infos === getIndexInfosOfType(expressionType)) { + links.resolvedSymbol = symbol; + } + else if (symbol) { + var symbolLinks_1 = getSymbolLinks(symbol); + var declarationList = ts.mapDefined(infos, function (i) { return i.declaration; }); + var nodeListId = ts.map(declarationList, getNodeId).join(","); + if (!symbolLinks_1.filteredIndexSymbolCache) { + symbolLinks_1.filteredIndexSymbolCache = new ts.Map(); + } + if (symbolLinks_1.filteredIndexSymbolCache.has(nodeListId)) { + links.resolvedSymbol = symbolLinks_1.filteredIndexSymbolCache.get(nodeListId); + } + else { + var copy = createSymbol(131072 /* SymbolFlags.Signature */, "__index" /* InternalSymbolName.Index */); + copy.declarations = ts.mapDefined(infos, function (i) { return i.declaration; }); + copy.parent = expressionType.aliasSymbol ? expressionType.aliasSymbol : expressionType.symbol ? expressionType.symbol : getSymbolAtLocation(copy.declarations[0].parent); + symbolLinks_1.filteredIndexSymbolCache.set(nodeListId, copy); + links.resolvedSymbol = symbolLinks_1.filteredIndexSymbolCache.get(nodeListId); + } + } + } + } + } + else { + checkQualifiedName(name, 0 /* CheckMode.Normal */); + } + if (!links.resolvedSymbol && isJSDoc_1 && ts.isQualifiedName(name)) { + return resolveJSDocMemberName(name); + } + return links.resolvedSymbol; + } + else if (ts.isJSDocMemberName(name)) { + return resolveJSDocMemberName(name); + } + } + else if (isTypeReferenceIdentifier(name)) { + var meaning = name.parent.kind === 180 /* SyntaxKind.TypeReference */ ? 788968 /* SymbolFlags.Type */ : 1920 /* SymbolFlags.Namespace */; + var symbol = resolveEntityName(name, meaning, /*ignoreErrors*/ false, /*dontResolveAlias*/ true); + return symbol && symbol !== unknownSymbol ? symbol : getUnresolvedSymbolForEntityName(name); + } + if (name.parent.kind === 179 /* SyntaxKind.TypePredicate */) { + return resolveEntityName(name, /*meaning*/ 1 /* SymbolFlags.FunctionScopedVariable */); + } + return undefined; + } + /** + * Recursively resolve entity names and jsdoc instance references: + * 1. K#m as K.prototype.m for a class (or other value) K + * 2. K.m as K.prototype.m + * 3. I.m as I.m for a type I, or any other I.m that fails to resolve in (1) or (2) + * + * For unqualified names, a container K may be provided as a second argument. + */ + function resolveJSDocMemberName(name, ignoreErrors, container) { + if (ts.isEntityName(name)) { + // resolve static values first + var meaning = 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */ | 111551 /* SymbolFlags.Value */; + var symbol = resolveEntityName(name, meaning, ignoreErrors, /*dontResolveAlias*/ true, ts.getHostSignatureFromJSDoc(name)); + if (!symbol && ts.isIdentifier(name) && container) { + symbol = getMergedSymbol(getSymbol(getExportsOfSymbol(container), name.escapedText, meaning)); + } + if (symbol) { + return symbol; + } + } + var left = ts.isIdentifier(name) ? container : resolveJSDocMemberName(name.left, ignoreErrors, container); + var right = ts.isIdentifier(name) ? name.escapedText : name.right.escapedText; + if (left) { + var proto = left.flags & 111551 /* SymbolFlags.Value */ && getPropertyOfType(getTypeOfSymbol(left), "prototype"); + var t = proto ? getTypeOfSymbol(proto) : getDeclaredTypeOfSymbol(left); + return getPropertyOfType(t, right); + } + } + function getSymbolAtLocation(node, ignoreErrors) { + if (node.kind === 308 /* SyntaxKind.SourceFile */) { + return ts.isExternalModule(node) ? getMergedSymbol(node.symbol) : undefined; + } + var parent = node.parent; + var grandParent = parent.parent; + if (node.flags & 33554432 /* NodeFlags.InWithStatement */) { + // We cannot answer semantic questions within a with block, do not proceed any further + return undefined; + } + if (isDeclarationNameOrImportPropertyName(node)) { + // This is a declaration, call getSymbolOfNode + var parentSymbol = getSymbolOfNode(parent); + return ts.isImportOrExportSpecifier(node.parent) && node.parent.propertyName === node + ? getImmediateAliasedSymbol(parentSymbol) + : parentSymbol; + } + else if (ts.isLiteralComputedPropertyDeclarationName(node)) { + return getSymbolOfNode(parent.parent); + } + if (node.kind === 79 /* SyntaxKind.Identifier */) { + if (isInRightSideOfImportOrExportAssignment(node)) { + return getSymbolOfNameOrPropertyAccessExpression(node); + } + else if (parent.kind === 205 /* SyntaxKind.BindingElement */ && + grandParent.kind === 203 /* SyntaxKind.ObjectBindingPattern */ && + node === parent.propertyName) { + var typeOfPattern = getTypeOfNode(grandParent); + var propertyDeclaration = getPropertyOfType(typeOfPattern, node.escapedText); + if (propertyDeclaration) { + return propertyDeclaration; + } + } + else if (ts.isMetaProperty(parent) && parent.name === node) { + if (parent.keywordToken === 103 /* SyntaxKind.NewKeyword */ && ts.idText(node) === "target") { + // `target` in `new.target` + return checkNewTargetMetaProperty(parent).symbol; + } + // The `meta` in `import.meta` could be given `getTypeOfNode(parent).symbol` (the `ImportMeta` interface symbol), but + // we have a fake expression type made for other reasons already, whose transient `meta` + // member should more exactly be the kind of (declarationless) symbol we want. + // (See #44364 and #45031 for relevant implementation PRs) + if (parent.keywordToken === 100 /* SyntaxKind.ImportKeyword */ && ts.idText(node) === "meta") { + return getGlobalImportMetaExpressionType().members.get("meta"); + } + // no other meta properties are valid syntax, thus no others should have symbols + return undefined; + } + } + switch (node.kind) { + case 79 /* SyntaxKind.Identifier */: + case 80 /* SyntaxKind.PrivateIdentifier */: + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 163 /* SyntaxKind.QualifiedName */: + if (!ts.isThisInTypeQuery(node)) { + return getSymbolOfNameOrPropertyAccessExpression(node); + } + // falls through + case 108 /* SyntaxKind.ThisKeyword */: + var container = ts.getThisContainer(node, /*includeArrowFunctions*/ false); + if (ts.isFunctionLike(container)) { + var sig = getSignatureFromDeclaration(container); + if (sig.thisParameter) { + return sig.thisParameter; + } + } + if (ts.isInExpressionContext(node)) { + return checkExpression(node).symbol; + } + // falls through + case 194 /* SyntaxKind.ThisType */: + return getTypeFromThisTypeNode(node).symbol; + case 106 /* SyntaxKind.SuperKeyword */: + return checkExpression(node).symbol; + case 135 /* SyntaxKind.ConstructorKeyword */: + // constructor keyword for an overload, should take us to the definition if it exist + var constructorDeclaration = node.parent; + if (constructorDeclaration && constructorDeclaration.kind === 173 /* SyntaxKind.Constructor */) { + return constructorDeclaration.parent.symbol; + } + return undefined; + case 10 /* SyntaxKind.StringLiteral */: + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + // 1). import x = require("./mo/*gotToDefinitionHere*/d") + // 2). External module name in an import declaration + // 3). Dynamic import call or require in javascript + // 4). type A = import("./f/*gotToDefinitionHere*/oo") + if ((ts.isExternalModuleImportEqualsDeclaration(node.parent.parent) && ts.getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node) || + ((node.parent.kind === 269 /* SyntaxKind.ImportDeclaration */ || node.parent.kind === 275 /* SyntaxKind.ExportDeclaration */) && node.parent.moduleSpecifier === node) || + ((ts.isInJSFile(node) && ts.isRequireCall(node.parent, /*checkArgumentIsStringLiteralLike*/ false)) || ts.isImportCall(node.parent)) || + (ts.isLiteralTypeNode(node.parent) && ts.isLiteralImportTypeNode(node.parent.parent) && node.parent.parent.argument === node.parent)) { + return resolveExternalModuleName(node, node, ignoreErrors); + } + if (ts.isCallExpression(parent) && ts.isBindableObjectDefinePropertyCall(parent) && parent.arguments[1] === node) { + return getSymbolOfNode(parent); + } + // falls through + case 8 /* SyntaxKind.NumericLiteral */: + // index access + var objectType = ts.isElementAccessExpression(parent) + ? parent.argumentExpression === node ? getTypeOfExpression(parent.expression) : undefined + : ts.isLiteralTypeNode(parent) && ts.isIndexedAccessTypeNode(grandParent) + ? getTypeFromTypeNode(grandParent.objectType) + : undefined; + return objectType && getPropertyOfType(objectType, ts.escapeLeadingUnderscores(node.text)); + case 88 /* SyntaxKind.DefaultKeyword */: + case 98 /* SyntaxKind.FunctionKeyword */: + case 38 /* SyntaxKind.EqualsGreaterThanToken */: + case 84 /* SyntaxKind.ClassKeyword */: + return getSymbolOfNode(node.parent); + case 202 /* SyntaxKind.ImportType */: + return ts.isLiteralImportTypeNode(node) ? getSymbolAtLocation(node.argument.literal, ignoreErrors) : undefined; + case 93 /* SyntaxKind.ExportKeyword */: + return ts.isExportAssignment(node.parent) ? ts.Debug.checkDefined(node.parent.symbol) : undefined; + case 100 /* SyntaxKind.ImportKeyword */: + case 103 /* SyntaxKind.NewKeyword */: + return ts.isMetaProperty(node.parent) ? checkMetaPropertyKeyword(node.parent).symbol : undefined; + case 233 /* SyntaxKind.MetaProperty */: + return checkExpression(node).symbol; + default: + return undefined; + } + } + function getIndexInfosAtLocation(node) { + if (ts.isIdentifier(node) && ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) { + var keyType_1 = getLiteralTypeFromPropertyName(node); + var objectType = getTypeOfExpression(node.parent.expression); + var objectTypes = objectType.flags & 1048576 /* TypeFlags.Union */ ? objectType.types : [objectType]; + return ts.flatMap(objectTypes, function (t) { return ts.filter(getIndexInfosOfType(t), function (info) { return isApplicableIndexType(keyType_1, info.keyType); }); }); + } + return undefined; + } + function getShorthandAssignmentValueSymbol(location) { + if (location && location.kind === 300 /* SyntaxKind.ShorthandPropertyAssignment */) { + return resolveEntityName(location.name, 111551 /* SymbolFlags.Value */ | 2097152 /* SymbolFlags.Alias */); + } + return undefined; + } + /** Returns the target of an export specifier without following aliases */ + function getExportSpecifierLocalTargetSymbol(node) { + if (ts.isExportSpecifier(node)) { + return node.parent.parent.moduleSpecifier ? + getExternalModuleMember(node.parent.parent, node) : + resolveEntityName(node.propertyName || node.name, 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */ | 2097152 /* SymbolFlags.Alias */); + } + else { + return resolveEntityName(node, 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */ | 2097152 /* SymbolFlags.Alias */); + } + } + function getTypeOfNode(node) { + if (ts.isSourceFile(node) && !ts.isExternalModule(node)) { + return errorType; + } + if (node.flags & 33554432 /* NodeFlags.InWithStatement */) { + // We cannot answer semantic questions within a with block, do not proceed any further + return errorType; + } + var classDecl = ts.tryGetClassImplementingOrExtendingExpressionWithTypeArguments(node); + var classType = classDecl && getDeclaredTypeOfClassOrInterface(getSymbolOfNode(classDecl.class)); + if (ts.isPartOfTypeNode(node)) { + var typeFromTypeNode = getTypeFromTypeNode(node); + return classType ? getTypeWithThisArgument(typeFromTypeNode, classType.thisType) : typeFromTypeNode; + } + if (ts.isExpressionNode(node)) { + return getRegularTypeOfExpression(node); + } + if (classType && !classDecl.isImplements) { + // A SyntaxKind.ExpressionWithTypeArguments is considered a type node, except when it occurs in the + // extends clause of a class. We handle that case here. + var baseType = ts.firstOrUndefined(getBaseTypes(classType)); + return baseType ? getTypeWithThisArgument(baseType, classType.thisType) : errorType; + } + if (ts.isTypeDeclaration(node)) { + // In this case, we call getSymbolOfNode instead of getSymbolAtLocation because it is a declaration + var symbol = getSymbolOfNode(node); + return getDeclaredTypeOfSymbol(symbol); + } + if (isTypeDeclarationName(node)) { + var symbol = getSymbolAtLocation(node); + return symbol ? getDeclaredTypeOfSymbol(symbol) : errorType; + } + if (ts.isDeclaration(node)) { + // In this case, we call getSymbolOfNode instead of getSymbolAtLocation because it is a declaration + var symbol = getSymbolOfNode(node); + return symbol ? getTypeOfSymbol(symbol) : errorType; + } + if (isDeclarationNameOrImportPropertyName(node)) { + var symbol = getSymbolAtLocation(node); + if (symbol) { + return getTypeOfSymbol(symbol); + } + return errorType; + } + if (ts.isBindingPattern(node)) { + return getTypeForVariableLikeDeclaration(node.parent, /*includeOptionality*/ true, 0 /* CheckMode.Normal */) || errorType; + } + if (isInRightSideOfImportOrExportAssignment(node)) { + var symbol = getSymbolAtLocation(node); + if (symbol) { + var declaredType = getDeclaredTypeOfSymbol(symbol); + return !isErrorType(declaredType) ? declaredType : getTypeOfSymbol(symbol); + } + } + if (ts.isMetaProperty(node.parent) && node.parent.keywordToken === node.kind) { + return checkMetaPropertyKeyword(node.parent); + } + return errorType; + } + // Gets the type of object literal or array literal of destructuring assignment. + // { a } from + // for ( { a } of elems) { + // } + // [ a ] from + // [a] = [ some array ...] + function getTypeOfAssignmentPattern(expr) { + ts.Debug.assert(expr.kind === 207 /* SyntaxKind.ObjectLiteralExpression */ || expr.kind === 206 /* SyntaxKind.ArrayLiteralExpression */); + // If this is from "for of" + // for ( { a } of elems) { + // } + if (expr.parent.kind === 247 /* SyntaxKind.ForOfStatement */) { + var iteratedType = checkRightHandSideOfForOf(expr.parent); + return checkDestructuringAssignment(expr, iteratedType || errorType); + } + // If this is from "for" initializer + // for ({a } = elems[0];.....) { } + if (expr.parent.kind === 223 /* SyntaxKind.BinaryExpression */) { + var iteratedType = getTypeOfExpression(expr.parent.right); + return checkDestructuringAssignment(expr, iteratedType || errorType); + } + // If this is from nested object binding pattern + // for ({ skills: { primary, secondary } } = multiRobot, i = 0; i < 1; i++) { + if (expr.parent.kind === 299 /* SyntaxKind.PropertyAssignment */) { + var node_3 = ts.cast(expr.parent.parent, ts.isObjectLiteralExpression); + var typeOfParentObjectLiteral = getTypeOfAssignmentPattern(node_3) || errorType; + var propertyIndex = ts.indexOfNode(node_3.properties, expr.parent); + return checkObjectLiteralDestructuringPropertyAssignment(node_3, typeOfParentObjectLiteral, propertyIndex); + } + // Array literal assignment - array destructuring pattern + var node = ts.cast(expr.parent, ts.isArrayLiteralExpression); + // [{ property1: p1, property2 }] = elems; + var typeOfArrayLiteral = getTypeOfAssignmentPattern(node) || errorType; + var elementType = checkIteratedTypeOrElementType(65 /* IterationUse.Destructuring */, typeOfArrayLiteral, undefinedType, expr.parent) || errorType; + return checkArrayLiteralDestructuringElementAssignment(node, typeOfArrayLiteral, node.elements.indexOf(expr), elementType); + } + // Gets the property symbol corresponding to the property in destructuring assignment + // 'property1' from + // for ( { property1: a } of elems) { + // } + // 'property1' at location 'a' from: + // [a] = [ property1, property2 ] + function getPropertySymbolOfDestructuringAssignment(location) { + // Get the type of the object or array literal and then look for property of given name in the type + var typeOfObjectLiteral = getTypeOfAssignmentPattern(ts.cast(location.parent.parent, ts.isAssignmentPattern)); + return typeOfObjectLiteral && getPropertyOfType(typeOfObjectLiteral, location.escapedText); + } + function getRegularTypeOfExpression(expr) { + if (ts.isRightSideOfQualifiedNameOrPropertyAccess(expr)) { + expr = expr.parent; + } + return getRegularTypeOfLiteralType(getTypeOfExpression(expr)); + } + /** + * Gets either the static or instance type of a class element, based on + * whether the element is declared as "static". + */ + function getParentTypeOfClassElement(node) { + var classSymbol = getSymbolOfNode(node.parent); + return ts.isStatic(node) + ? getTypeOfSymbol(classSymbol) + : getDeclaredTypeOfSymbol(classSymbol); + } + function getClassElementPropertyKeyType(element) { + var name = element.name; + switch (name.kind) { + case 79 /* SyntaxKind.Identifier */: + return getStringLiteralType(ts.idText(name)); + case 8 /* SyntaxKind.NumericLiteral */: + case 10 /* SyntaxKind.StringLiteral */: + return getStringLiteralType(name.text); + case 164 /* SyntaxKind.ComputedPropertyName */: + var nameType = checkComputedPropertyName(name); + return isTypeAssignableToKind(nameType, 12288 /* TypeFlags.ESSymbolLike */) ? nameType : stringType; + default: + return ts.Debug.fail("Unsupported property name."); + } + } + // Return the list of properties of the given type, augmented with properties from Function + // if the type has call or construct signatures + function getAugmentedPropertiesOfType(type) { + type = getApparentType(type); + var propsByName = ts.createSymbolTable(getPropertiesOfType(type)); + var functionType = getSignaturesOfType(type, 0 /* SignatureKind.Call */).length ? globalCallableFunctionType : + getSignaturesOfType(type, 1 /* SignatureKind.Construct */).length ? globalNewableFunctionType : + undefined; + if (functionType) { + ts.forEach(getPropertiesOfType(functionType), function (p) { + if (!propsByName.has(p.escapedName)) { + propsByName.set(p.escapedName, p); + } + }); + } + return getNamedMembers(propsByName); + } + function typeHasCallOrConstructSignatures(type) { + return ts.typeHasCallOrConstructSignatures(type, checker); + } + function getRootSymbols(symbol) { + var roots = getImmediateRootSymbols(symbol); + return roots ? ts.flatMap(roots, getRootSymbols) : [symbol]; + } + function getImmediateRootSymbols(symbol) { + if (ts.getCheckFlags(symbol) & 6 /* CheckFlags.Synthetic */) { + return ts.mapDefined(getSymbolLinks(symbol).containingType.types, function (type) { return getPropertyOfType(type, symbol.escapedName); }); + } + else if (symbol.flags & 33554432 /* SymbolFlags.Transient */) { + var _a = symbol, leftSpread = _a.leftSpread, rightSpread = _a.rightSpread, syntheticOrigin = _a.syntheticOrigin; + return leftSpread ? [leftSpread, rightSpread] + : syntheticOrigin ? [syntheticOrigin] + : ts.singleElementArray(tryGetTarget(symbol)); + } + return undefined; + } + function tryGetTarget(symbol) { + var target; + var next = symbol; + while (next = getSymbolLinks(next).target) { + target = next; + } + return target; + } + // Emitter support + function isArgumentsLocalBinding(nodeIn) { + // Note: does not handle isShorthandPropertyAssignment (and probably a few more) + if (ts.isGeneratedIdentifier(nodeIn)) + return false; + var node = ts.getParseTreeNode(nodeIn, ts.isIdentifier); + if (!node) + return false; + var parent = node.parent; + if (!parent) + return false; + var isPropertyName = ((ts.isPropertyAccessExpression(parent) + || ts.isPropertyAssignment(parent)) + && parent.name === node); + return !isPropertyName && getReferencedValueSymbol(node) === argumentsSymbol; + } + function moduleExportsSomeValue(moduleReferenceExpression) { + var moduleSymbol = resolveExternalModuleName(moduleReferenceExpression.parent, moduleReferenceExpression); + if (!moduleSymbol || ts.isShorthandAmbientModuleSymbol(moduleSymbol)) { + // If the module is not found or is shorthand, assume that it may export a value. + return true; + } + var hasExportAssignment = hasExportAssignmentSymbol(moduleSymbol); + // if module has export assignment then 'resolveExternalModuleSymbol' will return resolved symbol for export assignment + // otherwise it will return moduleSymbol itself + moduleSymbol = resolveExternalModuleSymbol(moduleSymbol); + var symbolLinks = getSymbolLinks(moduleSymbol); + if (symbolLinks.exportsSomeValue === undefined) { + // for export assignments - check if resolved symbol for RHS is itself a value + // otherwise - check if at least one export is value + symbolLinks.exportsSomeValue = hasExportAssignment + ? !!(moduleSymbol.flags & 111551 /* SymbolFlags.Value */) + : ts.forEachEntry(getExportsOfModule(moduleSymbol), isValue); + } + return symbolLinks.exportsSomeValue; + function isValue(s) { + s = resolveSymbol(s); + return s && !!(getAllSymbolFlags(s) & 111551 /* SymbolFlags.Value */); + } + } + function isNameOfModuleOrEnumDeclaration(node) { + return ts.isModuleOrEnumDeclaration(node.parent) && node === node.parent.name; + } + // When resolved as an expression identifier, if the given node references an exported entity, return the declaration + // node of the exported entity's container. Otherwise, return undefined. + function getReferencedExportContainer(nodeIn, prefixLocals) { + var _a; + var node = ts.getParseTreeNode(nodeIn, ts.isIdentifier); + if (node) { + // When resolving the export container for the name of a module or enum + // declaration, we need to start resolution at the declaration's container. + // Otherwise, we could incorrectly resolve the export container as the + // declaration if it contains an exported member with the same name. + var symbol = getReferencedValueSymbol(node, /*startInDeclarationContainer*/ isNameOfModuleOrEnumDeclaration(node)); + if (symbol) { + if (symbol.flags & 1048576 /* SymbolFlags.ExportValue */) { + // If we reference an exported entity within the same module declaration, then whether + // we prefix depends on the kind of entity. SymbolFlags.ExportHasLocal encompasses all the + // kinds that we do NOT prefix. + var exportSymbol = getMergedSymbol(symbol.exportSymbol); + if (!prefixLocals && exportSymbol.flags & 944 /* SymbolFlags.ExportHasLocal */ && !(exportSymbol.flags & 3 /* SymbolFlags.Variable */)) { + return undefined; + } + symbol = exportSymbol; + } + var parentSymbol_1 = getParentOfSymbol(symbol); + if (parentSymbol_1) { + if (parentSymbol_1.flags & 512 /* SymbolFlags.ValueModule */ && ((_a = parentSymbol_1.valueDeclaration) === null || _a === void 0 ? void 0 : _a.kind) === 308 /* SyntaxKind.SourceFile */) { + var symbolFile = parentSymbol_1.valueDeclaration; + var referenceFile = ts.getSourceFileOfNode(node); + // If `node` accesses an export and that export isn't in the same file, then symbol is a namespace export, so return undefined. + var symbolIsUmdExport = symbolFile !== referenceFile; + return symbolIsUmdExport ? undefined : symbolFile; + } + return ts.findAncestor(node.parent, function (n) { return ts.isModuleOrEnumDeclaration(n) && getSymbolOfNode(n) === parentSymbol_1; }); + } + } + } + } + // When resolved as an expression identifier, if the given node references an import, return the declaration of + // that import. Otherwise, return undefined. + function getReferencedImportDeclaration(nodeIn) { + if (nodeIn.generatedImportReference) { + return nodeIn.generatedImportReference; + } + var node = ts.getParseTreeNode(nodeIn, ts.isIdentifier); + if (node) { + var symbol = getReferencedValueOrAliasSymbol(node); + // We should only get the declaration of an alias if there isn't a local value + // declaration for the symbol + if (isNonLocalAlias(symbol, /*excludes*/ 111551 /* SymbolFlags.Value */) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* SymbolFlags.Value */)) { + return getDeclarationOfAliasSymbol(symbol); + } + } + return undefined; + } + function isSymbolOfDestructuredElementOfCatchBinding(symbol) { + return symbol.valueDeclaration + && ts.isBindingElement(symbol.valueDeclaration) + && ts.walkUpBindingElementsAndPatterns(symbol.valueDeclaration).parent.kind === 295 /* SyntaxKind.CatchClause */; + } + function isSymbolOfDeclarationWithCollidingName(symbol) { + if (symbol.flags & 418 /* SymbolFlags.BlockScoped */ && symbol.valueDeclaration && !ts.isSourceFile(symbol.valueDeclaration)) { + var links = getSymbolLinks(symbol); + if (links.isDeclarationWithCollidingName === undefined) { + var container = ts.getEnclosingBlockScopeContainer(symbol.valueDeclaration); + if (ts.isStatementWithLocals(container) || isSymbolOfDestructuredElementOfCatchBinding(symbol)) { + var nodeLinks_1 = getNodeLinks(symbol.valueDeclaration); + if (resolveName(container.parent, symbol.escapedName, 111551 /* SymbolFlags.Value */, /*nameNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ false)) { + // redeclaration - always should be renamed + links.isDeclarationWithCollidingName = true; + } + else if (nodeLinks_1.flags & 262144 /* NodeCheckFlags.CapturedBlockScopedBinding */) { + // binding is captured in the function + // should be renamed if: + // - binding is not top level - top level bindings never collide with anything + // AND + // - binding is not declared in loop, should be renamed to avoid name reuse across siblings + // let a, b + // { let x = 1; a = () => x; } + // { let x = 100; b = () => x; } + // console.log(a()); // should print '1' + // console.log(b()); // should print '100' + // OR + // - binding is declared inside loop but not in inside initializer of iteration statement or directly inside loop body + // * variables from initializer are passed to rewritten loop body as parameters so they are not captured directly + // * variables that are declared immediately in loop body will become top level variable after loop is rewritten and thus + // they will not collide with anything + var isDeclaredInLoop = nodeLinks_1.flags & 524288 /* NodeCheckFlags.BlockScopedBindingInLoop */; + var inLoopInitializer = ts.isIterationStatement(container, /*lookInLabeledStatements*/ false); + var inLoopBodyBlock = container.kind === 238 /* SyntaxKind.Block */ && ts.isIterationStatement(container.parent, /*lookInLabeledStatements*/ false); + links.isDeclarationWithCollidingName = !ts.isBlockScopedContainerTopLevel(container) && (!isDeclaredInLoop || (!inLoopInitializer && !inLoopBodyBlock)); + } + else { + links.isDeclarationWithCollidingName = false; + } + } + } + return links.isDeclarationWithCollidingName; + } + return false; + } + // When resolved as an expression identifier, if the given node references a nested block scoped entity with + // a name that either hides an existing name or might hide it when compiled downlevel, + // return the declaration of that entity. Otherwise, return undefined. + function getReferencedDeclarationWithCollidingName(nodeIn) { + if (!ts.isGeneratedIdentifier(nodeIn)) { + var node = ts.getParseTreeNode(nodeIn, ts.isIdentifier); + if (node) { + var symbol = getReferencedValueSymbol(node); + if (symbol && isSymbolOfDeclarationWithCollidingName(symbol)) { + return symbol.valueDeclaration; + } + } + } + return undefined; + } + // Return true if the given node is a declaration of a nested block scoped entity with a name that either hides an + // existing name or might hide a name when compiled downlevel + function isDeclarationWithCollidingName(nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.isDeclaration); + if (node) { + var symbol = getSymbolOfNode(node); + if (symbol) { + return isSymbolOfDeclarationWithCollidingName(symbol); + } + } + return false; + } + function isValueAliasDeclaration(node) { + switch (node.kind) { + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return isAliasResolvedToValue(getSymbolOfNode(node)); + case 270 /* SyntaxKind.ImportClause */: + case 271 /* SyntaxKind.NamespaceImport */: + case 273 /* SyntaxKind.ImportSpecifier */: + case 278 /* SyntaxKind.ExportSpecifier */: + var symbol = getSymbolOfNode(node); + return !!symbol && isAliasResolvedToValue(symbol) && !getTypeOnlyAliasDeclaration(symbol, 111551 /* SymbolFlags.Value */); + case 275 /* SyntaxKind.ExportDeclaration */: + var exportClause = node.exportClause; + return !!exportClause && (ts.isNamespaceExport(exportClause) || + ts.some(exportClause.elements, isValueAliasDeclaration)); + case 274 /* SyntaxKind.ExportAssignment */: + return node.expression && node.expression.kind === 79 /* SyntaxKind.Identifier */ ? + isAliasResolvedToValue(getSymbolOfNode(node)) : + true; + } + return false; + } + function isTopLevelValueImportEqualsWithEntityName(nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.isImportEqualsDeclaration); + if (node === undefined || node.parent.kind !== 308 /* SyntaxKind.SourceFile */ || !ts.isInternalModuleImportEqualsDeclaration(node)) { + // parent is not source file or it is not reference to internal module + return false; + } + var isValue = isAliasResolvedToValue(getSymbolOfNode(node)); + return isValue && node.moduleReference && !ts.nodeIsMissing(node.moduleReference); + } + function isAliasResolvedToValue(symbol) { + var _a; + if (!symbol) { + return false; + } + var target = getExportSymbolOfValueSymbolIfExported(resolveAlias(symbol)); + if (target === unknownSymbol) { + return true; + } + // const enums and modules that contain only const enums are not considered values from the emit perspective + // unless 'preserveConstEnums' option is set to true + return !!(((_a = getAllSymbolFlags(target)) !== null && _a !== void 0 ? _a : -1) & 111551 /* SymbolFlags.Value */) && + (ts.shouldPreserveConstEnums(compilerOptions) || !isConstEnumOrConstEnumOnlyModule(target)); + } + function isConstEnumOrConstEnumOnlyModule(s) { + return isConstEnumSymbol(s) || !!s.constEnumOnlyModule; + } + function isReferencedAliasDeclaration(node, checkChildren) { + if (isAliasSymbolDeclaration(node)) { + var symbol = getSymbolOfNode(node); + var links = symbol && getSymbolLinks(symbol); + if (links === null || links === void 0 ? void 0 : links.referenced) { + return true; + } + var target = getSymbolLinks(symbol).aliasTarget; // TODO: GH#18217 + if (target && ts.getEffectiveModifierFlags(node) & 1 /* ModifierFlags.Export */ && + getAllSymbolFlags(target) & 111551 /* SymbolFlags.Value */ && + (ts.shouldPreserveConstEnums(compilerOptions) || !isConstEnumOrConstEnumOnlyModule(target))) { + // An `export import ... =` of a value symbol is always considered referenced + return true; + } + } + if (checkChildren) { + return !!ts.forEachChild(node, function (node) { return isReferencedAliasDeclaration(node, checkChildren); }); + } + return false; + } + function isImplementationOfOverload(node) { + if (ts.nodeIsPresent(node.body)) { + if (ts.isGetAccessor(node) || ts.isSetAccessor(node)) + return false; // Get or set accessors can never be overload implementations, but can have up to 2 signatures + var symbol = getSymbolOfNode(node); + var signaturesOfSymbol = getSignaturesOfSymbol(symbol); + // If this function body corresponds to function with multiple signature, it is implementation of overload + // e.g.: function foo(a: string): string; + // function foo(a: number): number; + // function foo(a: any) { // This is implementation of the overloads + // return a; + // } + return signaturesOfSymbol.length > 1 || + // If there is single signature for the symbol, it is overload if that signature isn't coming from the node + // e.g.: function foo(a: string): string; + // function foo(a: any) { // This is implementation of the overloads + // return a; + // } + (signaturesOfSymbol.length === 1 && signaturesOfSymbol[0].declaration !== node); + } + return false; + } + function isRequiredInitializedParameter(parameter) { + return !!strictNullChecks && + !isOptionalParameter(parameter) && + !ts.isJSDocParameterTag(parameter) && + !!parameter.initializer && + !ts.hasSyntacticModifier(parameter, 16476 /* ModifierFlags.ParameterPropertyModifier */); + } + function isOptionalUninitializedParameterProperty(parameter) { + return strictNullChecks && + isOptionalParameter(parameter) && + !parameter.initializer && + ts.hasSyntacticModifier(parameter, 16476 /* ModifierFlags.ParameterPropertyModifier */); + } + function isExpandoFunctionDeclaration(node) { + var declaration = ts.getParseTreeNode(node, ts.isFunctionDeclaration); + if (!declaration) { + return false; + } + var symbol = getSymbolOfNode(declaration); + if (!symbol || !(symbol.flags & 16 /* SymbolFlags.Function */)) { + return false; + } + return !!ts.forEachEntry(getExportsOfSymbol(symbol), function (p) { return p.flags & 111551 /* SymbolFlags.Value */ && p.valueDeclaration && ts.isPropertyAccessExpression(p.valueDeclaration); }); + } + function getPropertiesOfContainerFunction(node) { + var declaration = ts.getParseTreeNode(node, ts.isFunctionDeclaration); + if (!declaration) { + return ts.emptyArray; + } + var symbol = getSymbolOfNode(declaration); + return symbol && getPropertiesOfType(getTypeOfSymbol(symbol)) || ts.emptyArray; + } + function getNodeCheckFlags(node) { + var _a; + var nodeId = node.id || 0; + if (nodeId < 0 || nodeId >= nodeLinks.length) + return 0; + return ((_a = nodeLinks[nodeId]) === null || _a === void 0 ? void 0 : _a.flags) || 0; + } + function getEnumMemberValue(node) { + computeEnumMemberValues(node.parent); + return getNodeLinks(node).enumMemberValue; + } + function canHaveConstantValue(node) { + switch (node.kind) { + case 302 /* SyntaxKind.EnumMember */: + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 209 /* SyntaxKind.ElementAccessExpression */: + return true; + } + return false; + } + function getConstantValue(node) { + if (node.kind === 302 /* SyntaxKind.EnumMember */) { + return getEnumMemberValue(node); + } + var symbol = getNodeLinks(node).resolvedSymbol; + if (symbol && (symbol.flags & 8 /* SymbolFlags.EnumMember */)) { + // inline property\index accesses only for const enums + var member = symbol.valueDeclaration; + if (ts.isEnumConst(member.parent)) { + return getEnumMemberValue(member); + } + } + return undefined; + } + function isFunctionType(type) { + return !!(type.flags & 524288 /* TypeFlags.Object */) && getSignaturesOfType(type, 0 /* SignatureKind.Call */).length > 0; + } + function getTypeReferenceSerializationKind(typeNameIn, location) { + var _a, _b; + // ensure both `typeName` and `location` are parse tree nodes. + var typeName = ts.getParseTreeNode(typeNameIn, ts.isEntityName); + if (!typeName) + return ts.TypeReferenceSerializationKind.Unknown; + if (location) { + location = ts.getParseTreeNode(location); + if (!location) + return ts.TypeReferenceSerializationKind.Unknown; + } + // Resolve the symbol as a value to ensure the type can be reached at runtime during emit. + var isTypeOnly = false; + if (ts.isQualifiedName(typeName)) { + var rootValueSymbol = resolveEntityName(ts.getFirstIdentifier(typeName), 111551 /* SymbolFlags.Value */, /*ignoreErrors*/ true, /*dontResolveAlias*/ true, location); + isTypeOnly = !!((_a = rootValueSymbol === null || rootValueSymbol === void 0 ? void 0 : rootValueSymbol.declarations) === null || _a === void 0 ? void 0 : _a.every(ts.isTypeOnlyImportOrExportDeclaration)); + } + var valueSymbol = resolveEntityName(typeName, 111551 /* SymbolFlags.Value */, /*ignoreErrors*/ true, /*dontResolveAlias*/ true, location); + var resolvedSymbol = valueSymbol && valueSymbol.flags & 2097152 /* SymbolFlags.Alias */ ? resolveAlias(valueSymbol) : valueSymbol; + isTypeOnly || (isTypeOnly = !!((_b = valueSymbol === null || valueSymbol === void 0 ? void 0 : valueSymbol.declarations) === null || _b === void 0 ? void 0 : _b.every(ts.isTypeOnlyImportOrExportDeclaration))); + // Resolve the symbol as a type so that we can provide a more useful hint for the type serializer. + var typeSymbol = resolveEntityName(typeName, 788968 /* SymbolFlags.Type */, /*ignoreErrors*/ true, /*dontResolveAlias*/ false, location); + if (resolvedSymbol && resolvedSymbol === typeSymbol) { + var globalPromiseSymbol = getGlobalPromiseConstructorSymbol(/*reportErrors*/ false); + if (globalPromiseSymbol && resolvedSymbol === globalPromiseSymbol) { + return ts.TypeReferenceSerializationKind.Promise; + } + var constructorType = getTypeOfSymbol(resolvedSymbol); + if (constructorType && isConstructorType(constructorType)) { + return isTypeOnly ? ts.TypeReferenceSerializationKind.TypeWithCallSignature : ts.TypeReferenceSerializationKind.TypeWithConstructSignatureAndValue; + } + } + // We might not be able to resolve type symbol so use unknown type in that case (eg error case) + if (!typeSymbol) { + return isTypeOnly ? ts.TypeReferenceSerializationKind.ObjectType : ts.TypeReferenceSerializationKind.Unknown; + } + var type = getDeclaredTypeOfSymbol(typeSymbol); + if (isErrorType(type)) { + return isTypeOnly ? ts.TypeReferenceSerializationKind.ObjectType : ts.TypeReferenceSerializationKind.Unknown; + } + else if (type.flags & 3 /* TypeFlags.AnyOrUnknown */) { + return ts.TypeReferenceSerializationKind.ObjectType; + } + else if (isTypeAssignableToKind(type, 16384 /* TypeFlags.Void */ | 98304 /* TypeFlags.Nullable */ | 131072 /* TypeFlags.Never */)) { + return ts.TypeReferenceSerializationKind.VoidNullableOrNeverType; + } + else if (isTypeAssignableToKind(type, 528 /* TypeFlags.BooleanLike */)) { + return ts.TypeReferenceSerializationKind.BooleanType; + } + else if (isTypeAssignableToKind(type, 296 /* TypeFlags.NumberLike */)) { + return ts.TypeReferenceSerializationKind.NumberLikeType; + } + else if (isTypeAssignableToKind(type, 2112 /* TypeFlags.BigIntLike */)) { + return ts.TypeReferenceSerializationKind.BigIntLikeType; + } + else if (isTypeAssignableToKind(type, 402653316 /* TypeFlags.StringLike */)) { + return ts.TypeReferenceSerializationKind.StringLikeType; + } + else if (isTupleType(type)) { + return ts.TypeReferenceSerializationKind.ArrayLikeType; + } + else if (isTypeAssignableToKind(type, 12288 /* TypeFlags.ESSymbolLike */)) { + return ts.TypeReferenceSerializationKind.ESSymbolType; + } + else if (isFunctionType(type)) { + return ts.TypeReferenceSerializationKind.TypeWithCallSignature; + } + else if (isArrayType(type)) { + return ts.TypeReferenceSerializationKind.ArrayLikeType; + } + else { + return ts.TypeReferenceSerializationKind.ObjectType; + } + } + function createTypeOfDeclaration(declarationIn, enclosingDeclaration, flags, tracker, addUndefined) { + var declaration = ts.getParseTreeNode(declarationIn, ts.isVariableLikeOrAccessor); + if (!declaration) { + return ts.factory.createToken(131 /* SyntaxKind.AnyKeyword */); + } + // Get type of the symbol if this is the valid symbol otherwise get type at location + var symbol = getSymbolOfNode(declaration); + var type = symbol && !(symbol.flags & (2048 /* SymbolFlags.TypeLiteral */ | 131072 /* SymbolFlags.Signature */)) + ? getWidenedLiteralType(getTypeOfSymbol(symbol)) + : errorType; + if (type.flags & 8192 /* TypeFlags.UniqueESSymbol */ && + type.symbol === symbol) { + flags |= 1048576 /* NodeBuilderFlags.AllowUniqueESSymbolType */; + } + if (addUndefined) { + type = getOptionalType(type); + } + return nodeBuilder.typeToTypeNode(type, enclosingDeclaration, flags | 1024 /* NodeBuilderFlags.MultilineObjectLiterals */, tracker); + } + function createReturnTypeOfSignatureDeclaration(signatureDeclarationIn, enclosingDeclaration, flags, tracker) { + var signatureDeclaration = ts.getParseTreeNode(signatureDeclarationIn, ts.isFunctionLike); + if (!signatureDeclaration) { + return ts.factory.createToken(131 /* SyntaxKind.AnyKeyword */); + } + var signature = getSignatureFromDeclaration(signatureDeclaration); + return nodeBuilder.typeToTypeNode(getReturnTypeOfSignature(signature), enclosingDeclaration, flags | 1024 /* NodeBuilderFlags.MultilineObjectLiterals */, tracker); + } + function createTypeOfExpression(exprIn, enclosingDeclaration, flags, tracker) { + var expr = ts.getParseTreeNode(exprIn, ts.isExpression); + if (!expr) { + return ts.factory.createToken(131 /* SyntaxKind.AnyKeyword */); + } + var type = getWidenedType(getRegularTypeOfExpression(expr)); + return nodeBuilder.typeToTypeNode(type, enclosingDeclaration, flags | 1024 /* NodeBuilderFlags.MultilineObjectLiterals */, tracker); + } + function hasGlobalName(name) { + return globals.has(ts.escapeLeadingUnderscores(name)); + } + function getReferencedValueSymbol(reference, startInDeclarationContainer) { + var resolvedSymbol = getNodeLinks(reference).resolvedSymbol; + if (resolvedSymbol) { + return resolvedSymbol; + } + var location = reference; + if (startInDeclarationContainer) { + // When resolving the name of a declaration as a value, we need to start resolution + // at a point outside of the declaration. + var parent = reference.parent; + if (ts.isDeclaration(parent) && reference === parent.name) { + location = getDeclarationContainer(parent); + } + } + return resolveName(location, reference.escapedText, 111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */ | 2097152 /* SymbolFlags.Alias */, /*nodeNotFoundMessage*/ undefined, /*nameArg*/ undefined, /*isUse*/ true); + } + /** + * Get either a value-meaning symbol or an alias symbol. + * Unlike `getReferencedValueSymbol`, if the cached resolved symbol is the unknown symbol, + * we call `resolveName` to find a symbol. + * This is because when caching the resolved symbol, we only consider value symbols, but here + * we want to also get an alias symbol if one exists. + */ + function getReferencedValueOrAliasSymbol(reference) { + var resolvedSymbol = getNodeLinks(reference).resolvedSymbol; + if (resolvedSymbol && resolvedSymbol !== unknownSymbol) { + return resolvedSymbol; + } + return resolveName(reference, reference.escapedText, 111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */ | 2097152 /* SymbolFlags.Alias */, + /*nodeNotFoundMessage*/ undefined, + /*nameArg*/ undefined, + /*isUse*/ true, + /*excludeGlobals*/ undefined, + /*getSpellingSuggestions*/ undefined); + } + function getReferencedValueDeclaration(referenceIn) { + if (!ts.isGeneratedIdentifier(referenceIn)) { + var reference = ts.getParseTreeNode(referenceIn, ts.isIdentifier); + if (reference) { + var symbol = getReferencedValueSymbol(reference); + if (symbol) { + return getExportSymbolOfValueSymbolIfExported(symbol).valueDeclaration; + } + } + } + return undefined; + } + function isLiteralConstDeclaration(node) { + if (ts.isDeclarationReadonly(node) || ts.isVariableDeclaration(node) && ts.isVarConst(node)) { + return isFreshLiteralType(getTypeOfSymbol(getSymbolOfNode(node))); + } + return false; + } + function literalTypeToNode(type, enclosing, tracker) { + var enumResult = type.flags & 1024 /* TypeFlags.EnumLiteral */ ? nodeBuilder.symbolToExpression(type.symbol, 111551 /* SymbolFlags.Value */, enclosing, /*flags*/ undefined, tracker) + : type === trueType ? ts.factory.createTrue() : type === falseType && ts.factory.createFalse(); + if (enumResult) + return enumResult; + var literalValue = type.value; + return typeof literalValue === "object" ? ts.factory.createBigIntLiteral(literalValue) : + typeof literalValue === "number" ? ts.factory.createNumericLiteral(literalValue) : + ts.factory.createStringLiteral(literalValue); + } + function createLiteralConstValue(node, tracker) { + var type = getTypeOfSymbol(getSymbolOfNode(node)); + return literalTypeToNode(type, node, tracker); + } + function getJsxFactoryEntity(location) { + return location ? (getJsxNamespace(location), (ts.getSourceFileOfNode(location).localJsxFactory || _jsxFactoryEntity)) : _jsxFactoryEntity; + } + function getJsxFragmentFactoryEntity(location) { + if (location) { + var file = ts.getSourceFileOfNode(location); + if (file) { + if (file.localJsxFragmentFactory) { + return file.localJsxFragmentFactory; + } + var jsxFragPragmas = file.pragmas.get("jsxfrag"); + var jsxFragPragma = ts.isArray(jsxFragPragmas) ? jsxFragPragmas[0] : jsxFragPragmas; + if (jsxFragPragma) { + file.localJsxFragmentFactory = ts.parseIsolatedEntityName(jsxFragPragma.arguments.factory, languageVersion); + return file.localJsxFragmentFactory; + } + } + } + if (compilerOptions.jsxFragmentFactory) { + return ts.parseIsolatedEntityName(compilerOptions.jsxFragmentFactory, languageVersion); + } + } + function createResolver() { + // this variable and functions that use it are deliberately moved here from the outer scope + // to avoid scope pollution + var resolvedTypeReferenceDirectives = host.getResolvedTypeReferenceDirectives(); + var fileToDirective; + if (resolvedTypeReferenceDirectives) { + // populate reverse mapping: file path -> type reference directive that was resolved to this file + fileToDirective = new ts.Map(); + resolvedTypeReferenceDirectives.forEach(function (resolvedDirective, key, mode) { + if (!resolvedDirective || !resolvedDirective.resolvedFileName) { + return; + } + var file = host.getSourceFile(resolvedDirective.resolvedFileName); + if (file) { + // Add the transitive closure of path references loaded by this file (as long as they are not) + // part of an existing type reference. + addReferencedFilesToTypeDirective(file, key, mode); + } + }); + } + return { + getReferencedExportContainer: getReferencedExportContainer, + getReferencedImportDeclaration: getReferencedImportDeclaration, + getReferencedDeclarationWithCollidingName: getReferencedDeclarationWithCollidingName, + isDeclarationWithCollidingName: isDeclarationWithCollidingName, + isValueAliasDeclaration: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn); + // Synthesized nodes are always treated like values. + return node ? isValueAliasDeclaration(node) : true; + }, + hasGlobalName: hasGlobalName, + isReferencedAliasDeclaration: function (nodeIn, checkChildren) { + var node = ts.getParseTreeNode(nodeIn); + // Synthesized nodes are always treated as referenced. + return node ? isReferencedAliasDeclaration(node, checkChildren) : true; + }, + getNodeCheckFlags: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn); + return node ? getNodeCheckFlags(node) : 0; + }, + isTopLevelValueImportEqualsWithEntityName: isTopLevelValueImportEqualsWithEntityName, + isDeclarationVisible: isDeclarationVisible, + isImplementationOfOverload: isImplementationOfOverload, + isRequiredInitializedParameter: isRequiredInitializedParameter, + isOptionalUninitializedParameterProperty: isOptionalUninitializedParameterProperty, + isExpandoFunctionDeclaration: isExpandoFunctionDeclaration, + getPropertiesOfContainerFunction: getPropertiesOfContainerFunction, + createTypeOfDeclaration: createTypeOfDeclaration, + createReturnTypeOfSignatureDeclaration: createReturnTypeOfSignatureDeclaration, + createTypeOfExpression: createTypeOfExpression, + createLiteralConstValue: createLiteralConstValue, + isSymbolAccessible: isSymbolAccessible, + isEntityNameVisible: isEntityNameVisible, + getConstantValue: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn, canHaveConstantValue); + return node ? getConstantValue(node) : undefined; + }, + collectLinkedAliases: collectLinkedAliases, + getReferencedValueDeclaration: getReferencedValueDeclaration, + getTypeReferenceSerializationKind: getTypeReferenceSerializationKind, + isOptionalParameter: isOptionalParameter, + moduleExportsSomeValue: moduleExportsSomeValue, + isArgumentsLocalBinding: isArgumentsLocalBinding, + getExternalModuleFileFromDeclaration: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.hasPossibleExternalModuleReference); + return node && getExternalModuleFileFromDeclaration(node); + }, + getTypeReferenceDirectivesForEntityName: getTypeReferenceDirectivesForEntityName, + getTypeReferenceDirectivesForSymbol: getTypeReferenceDirectivesForSymbol, + isLiteralConstDeclaration: isLiteralConstDeclaration, + isLateBound: function (nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.isDeclaration); + var symbol = node && getSymbolOfNode(node); + return !!(symbol && ts.getCheckFlags(symbol) & 4096 /* CheckFlags.Late */); + }, + getJsxFactoryEntity: getJsxFactoryEntity, + getJsxFragmentFactoryEntity: getJsxFragmentFactoryEntity, + getAllAccessorDeclarations: function (accessor) { + accessor = ts.getParseTreeNode(accessor, ts.isGetOrSetAccessorDeclaration); // TODO: GH#18217 + var otherKind = accessor.kind === 175 /* SyntaxKind.SetAccessor */ ? 174 /* SyntaxKind.GetAccessor */ : 175 /* SyntaxKind.SetAccessor */; + var otherAccessor = ts.getDeclarationOfKind(getSymbolOfNode(accessor), otherKind); + var firstAccessor = otherAccessor && (otherAccessor.pos < accessor.pos) ? otherAccessor : accessor; + var secondAccessor = otherAccessor && (otherAccessor.pos < accessor.pos) ? accessor : otherAccessor; + var setAccessor = accessor.kind === 175 /* SyntaxKind.SetAccessor */ ? accessor : otherAccessor; + var getAccessor = accessor.kind === 174 /* SyntaxKind.GetAccessor */ ? accessor : otherAccessor; + return { + firstAccessor: firstAccessor, + secondAccessor: secondAccessor, + setAccessor: setAccessor, + getAccessor: getAccessor + }; + }, + getSymbolOfExternalModuleSpecifier: function (moduleName) { return resolveExternalModuleNameWorker(moduleName, moduleName, /*moduleNotFoundError*/ undefined); }, + isBindingCapturedByNode: function (node, decl) { + var parseNode = ts.getParseTreeNode(node); + var parseDecl = ts.getParseTreeNode(decl); + return !!parseNode && !!parseDecl && (ts.isVariableDeclaration(parseDecl) || ts.isBindingElement(parseDecl)) && isBindingCapturedByNode(parseNode, parseDecl); + }, + getDeclarationStatementsForSourceFile: function (node, flags, tracker, bundled) { + var n = ts.getParseTreeNode(node); + ts.Debug.assert(n && n.kind === 308 /* SyntaxKind.SourceFile */, "Non-sourcefile node passed into getDeclarationsForSourceFile"); + var sym = getSymbolOfNode(node); + if (!sym) { + return !node.locals ? [] : nodeBuilder.symbolTableToDeclarationStatements(node.locals, node, flags, tracker, bundled); + } + return !sym.exports ? [] : nodeBuilder.symbolTableToDeclarationStatements(sym.exports, node, flags, tracker, bundled); + }, + isImportRequiredByAugmentation: isImportRequiredByAugmentation, + }; + function isImportRequiredByAugmentation(node) { + var file = ts.getSourceFileOfNode(node); + if (!file.symbol) + return false; + var importTarget = getExternalModuleFileFromDeclaration(node); + if (!importTarget) + return false; + if (importTarget === file) + return false; + var exports = getExportsOfModule(file.symbol); + for (var _i = 0, _a = ts.arrayFrom(exports.values()); _i < _a.length; _i++) { + var s = _a[_i]; + if (s.mergeId) { + var merged = getMergedSymbol(s); + if (merged.declarations) { + for (var _b = 0, _c = merged.declarations; _b < _c.length; _b++) { + var d = _c[_b]; + var declFile = ts.getSourceFileOfNode(d); + if (declFile === importTarget) { + return true; + } + } + } + } + } + return false; + } + function isInHeritageClause(node) { + return node.parent && node.parent.kind === 230 /* SyntaxKind.ExpressionWithTypeArguments */ && node.parent.parent && node.parent.parent.kind === 294 /* SyntaxKind.HeritageClause */; + } + // defined here to avoid outer scope pollution + function getTypeReferenceDirectivesForEntityName(node) { + // program does not have any files with type reference directives - bail out + if (!fileToDirective) { + return undefined; + } + // computed property name should use node as value + // property access can only be used as values, or types when within an expression with type arguments inside a heritage clause + // qualified names can only be used as types\namespaces + // identifiers are treated as values only if they appear in type queries + var meaning; + if (node.parent.kind === 164 /* SyntaxKind.ComputedPropertyName */) { + meaning = 111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */; + } + else { + meaning = 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */; + if ((node.kind === 79 /* SyntaxKind.Identifier */ && isInTypeQuery(node)) || (node.kind === 208 /* SyntaxKind.PropertyAccessExpression */ && !isInHeritageClause(node))) { + meaning = 111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */; + } + } + var symbol = resolveEntityName(node, meaning, /*ignoreErrors*/ true); + return symbol && symbol !== unknownSymbol ? getTypeReferenceDirectivesForSymbol(symbol, meaning) : undefined; + } + // defined here to avoid outer scope pollution + function getTypeReferenceDirectivesForSymbol(symbol, meaning) { + // program does not have any files with type reference directives - bail out + if (!fileToDirective || !isSymbolFromTypeDeclarationFile(symbol)) { + return undefined; + } + // check what declarations in the symbol can contribute to the target meaning + var typeReferenceDirectives; + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + // check meaning of the local symbol to see if declaration needs to be analyzed further + if (decl.symbol && decl.symbol.flags & meaning) { + var file = ts.getSourceFileOfNode(decl); + var typeReferenceDirective = fileToDirective.get(file.path); + if (typeReferenceDirective) { + (typeReferenceDirectives || (typeReferenceDirectives = [])).push(typeReferenceDirective); + } + else { + // found at least one entry that does not originate from type reference directive + return undefined; + } + } + } + return typeReferenceDirectives; + } + function isSymbolFromTypeDeclarationFile(symbol) { + // bail out if symbol does not have associated declarations (i.e. this is transient symbol created for property in binding pattern) + if (!symbol.declarations) { + return false; + } + // walk the parent chain for symbols to make sure that top level parent symbol is in the global scope + // external modules cannot define or contribute to type declaration files + var current = symbol; + while (true) { + var parent = getParentOfSymbol(current); + if (parent) { + current = parent; + } + else { + break; + } + } + if (current.valueDeclaration && current.valueDeclaration.kind === 308 /* SyntaxKind.SourceFile */ && current.flags & 512 /* SymbolFlags.ValueModule */) { + return false; + } + // check that at least one declaration of top level symbol originates from type declaration file + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + var file = ts.getSourceFileOfNode(decl); + if (fileToDirective.has(file.path)) { + return true; + } + } + return false; + } + function addReferencedFilesToTypeDirective(file, key, mode) { + if (fileToDirective.has(file.path)) + return; + fileToDirective.set(file.path, [key, mode]); + for (var _i = 0, _a = file.referencedFiles; _i < _a.length; _i++) { + var _b = _a[_i], fileName = _b.fileName, resolutionMode = _b.resolutionMode; + var resolvedFile = ts.resolveTripleslashReference(fileName, file.fileName); + var referencedFile = host.getSourceFile(resolvedFile); + if (referencedFile) { + addReferencedFilesToTypeDirective(referencedFile, key, resolutionMode || file.impliedNodeFormat); + } + } + } + } + function getExternalModuleFileFromDeclaration(declaration) { + var specifier = declaration.kind === 264 /* SyntaxKind.ModuleDeclaration */ ? ts.tryCast(declaration.name, ts.isStringLiteral) : ts.getExternalModuleName(declaration); + var moduleSymbol = resolveExternalModuleNameWorker(specifier, specifier, /*moduleNotFoundError*/ undefined); // TODO: GH#18217 + if (!moduleSymbol) { + return undefined; + } + return ts.getDeclarationOfKind(moduleSymbol, 308 /* SyntaxKind.SourceFile */); + } + function initializeTypeChecker() { + // Bind all source files and propagate errors + for (var _i = 0, _a = host.getSourceFiles(); _i < _a.length; _i++) { + var file = _a[_i]; + ts.bindSourceFile(file, compilerOptions); + } + amalgamatedDuplicates = new ts.Map(); + // Initialize global symbol table + var augmentations; + for (var _b = 0, _c = host.getSourceFiles(); _b < _c.length; _b++) { + var file = _c[_b]; + if (file.redirectInfo) { + continue; + } + if (!ts.isExternalOrCommonJsModule(file)) { + // It is an error for a non-external-module (i.e. script) to declare its own `globalThis`. + // We can't use `builtinGlobals` for this due to synthetic expando-namespace generation in JS files. + var fileGlobalThisSymbol = file.locals.get("globalThis"); + if (fileGlobalThisSymbol === null || fileGlobalThisSymbol === void 0 ? void 0 : fileGlobalThisSymbol.declarations) { + for (var _d = 0, _e = fileGlobalThisSymbol.declarations; _d < _e.length; _d++) { + var declaration = _e[_d]; + diagnostics.add(ts.createDiagnosticForNode(declaration, ts.Diagnostics.Declaration_name_conflicts_with_built_in_global_identifier_0, "globalThis")); + } + } + mergeSymbolTable(globals, file.locals); + } + if (file.jsGlobalAugmentations) { + mergeSymbolTable(globals, file.jsGlobalAugmentations); + } + if (file.patternAmbientModules && file.patternAmbientModules.length) { + patternAmbientModules = ts.concatenate(patternAmbientModules, file.patternAmbientModules); + } + if (file.moduleAugmentations.length) { + (augmentations || (augmentations = [])).push(file.moduleAugmentations); + } + if (file.symbol && file.symbol.globalExports) { + // Merge in UMD exports with first-in-wins semantics (see #9771) + var source = file.symbol.globalExports; + source.forEach(function (sourceSymbol, id) { + if (!globals.has(id)) { + globals.set(id, sourceSymbol); + } + }); + } + } + // We do global augmentations separately from module augmentations (and before creating global types) because they + // 1. Affect global types. We won't have the correct global types until global augmentations are merged. Also, + // 2. Module augmentation instantiation requires creating the type of a module, which, in turn, can require + // checking for an export or property on the module (if export=) which, in turn, can fall back to the + // apparent type of the module - either globalObjectType or globalFunctionType - which wouldn't exist if we + // did module augmentations prior to finalizing the global types. + if (augmentations) { + // merge _global_ module augmentations. + // this needs to be done after global symbol table is initialized to make sure that all ambient modules are indexed + for (var _f = 0, augmentations_1 = augmentations; _f < augmentations_1.length; _f++) { + var list = augmentations_1[_f]; + for (var _g = 0, list_1 = list; _g < list_1.length; _g++) { + var augmentation = list_1[_g]; + if (!ts.isGlobalScopeAugmentation(augmentation.parent)) + continue; + mergeModuleAugmentation(augmentation); + } + } + } + // Setup global builtins + addToSymbolTable(globals, builtinGlobals, ts.Diagnostics.Declaration_name_conflicts_with_built_in_global_identifier_0); + getSymbolLinks(undefinedSymbol).type = undefinedWideningType; + getSymbolLinks(argumentsSymbol).type = getGlobalType("IArguments", /*arity*/ 0, /*reportErrors*/ true); + getSymbolLinks(unknownSymbol).type = errorType; + getSymbolLinks(globalThisSymbol).type = createObjectType(16 /* ObjectFlags.Anonymous */, globalThisSymbol); + // Initialize special types + globalArrayType = getGlobalType("Array", /*arity*/ 1, /*reportErrors*/ true); + globalObjectType = getGlobalType("Object", /*arity*/ 0, /*reportErrors*/ true); + globalFunctionType = getGlobalType("Function", /*arity*/ 0, /*reportErrors*/ true); + globalCallableFunctionType = strictBindCallApply && getGlobalType("CallableFunction", /*arity*/ 0, /*reportErrors*/ true) || globalFunctionType; + globalNewableFunctionType = strictBindCallApply && getGlobalType("NewableFunction", /*arity*/ 0, /*reportErrors*/ true) || globalFunctionType; + globalStringType = getGlobalType("String", /*arity*/ 0, /*reportErrors*/ true); + globalNumberType = getGlobalType("Number", /*arity*/ 0, /*reportErrors*/ true); + globalBooleanType = getGlobalType("Boolean", /*arity*/ 0, /*reportErrors*/ true); + globalRegExpType = getGlobalType("RegExp", /*arity*/ 0, /*reportErrors*/ true); + anyArrayType = createArrayType(anyType); + autoArrayType = createArrayType(autoType); + if (autoArrayType === emptyObjectType) { + // autoArrayType is used as a marker, so even if global Array type is not defined, it needs to be a unique type + autoArrayType = createAnonymousType(undefined, emptySymbols, ts.emptyArray, ts.emptyArray, ts.emptyArray); + } + globalReadonlyArrayType = getGlobalTypeOrUndefined("ReadonlyArray", /*arity*/ 1) || globalArrayType; + anyReadonlyArrayType = globalReadonlyArrayType ? createTypeFromGenericGlobalType(globalReadonlyArrayType, [anyType]) : anyArrayType; + globalThisType = getGlobalTypeOrUndefined("ThisType", /*arity*/ 1); + if (augmentations) { + // merge _nonglobal_ module augmentations. + // this needs to be done after global symbol table is initialized to make sure that all ambient modules are indexed + for (var _h = 0, augmentations_2 = augmentations; _h < augmentations_2.length; _h++) { + var list = augmentations_2[_h]; + for (var _j = 0, list_2 = list; _j < list_2.length; _j++) { + var augmentation = list_2[_j]; + if (ts.isGlobalScopeAugmentation(augmentation.parent)) + continue; + mergeModuleAugmentation(augmentation); + } + } + } + amalgamatedDuplicates.forEach(function (_a) { + var firstFile = _a.firstFile, secondFile = _a.secondFile, conflictingSymbols = _a.conflictingSymbols; + // If not many things conflict, issue individual errors + if (conflictingSymbols.size < 8) { + conflictingSymbols.forEach(function (_a, symbolName) { + var isBlockScoped = _a.isBlockScoped, firstFileLocations = _a.firstFileLocations, secondFileLocations = _a.secondFileLocations; + var message = isBlockScoped ? ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0 : ts.Diagnostics.Duplicate_identifier_0; + for (var _i = 0, firstFileLocations_1 = firstFileLocations; _i < firstFileLocations_1.length; _i++) { + var node = firstFileLocations_1[_i]; + addDuplicateDeclarationError(node, message, symbolName, secondFileLocations); + } + for (var _b = 0, secondFileLocations_1 = secondFileLocations; _b < secondFileLocations_1.length; _b++) { + var node = secondFileLocations_1[_b]; + addDuplicateDeclarationError(node, message, symbolName, firstFileLocations); + } + }); + } + else { + // Otherwise issue top-level error since the files appear very identical in terms of what they contain + var list = ts.arrayFrom(conflictingSymbols.keys()).join(", "); + diagnostics.add(ts.addRelatedInfo(ts.createDiagnosticForNode(firstFile, ts.Diagnostics.Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0, list), ts.createDiagnosticForNode(secondFile, ts.Diagnostics.Conflicts_are_in_this_file))); + diagnostics.add(ts.addRelatedInfo(ts.createDiagnosticForNode(secondFile, ts.Diagnostics.Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0, list), ts.createDiagnosticForNode(firstFile, ts.Diagnostics.Conflicts_are_in_this_file))); + } + }); + amalgamatedDuplicates = undefined; + } + function checkExternalEmitHelpers(location, helpers) { + if ((requestedExternalEmitHelpers & helpers) !== helpers && compilerOptions.importHelpers) { + var sourceFile = ts.getSourceFileOfNode(location); + if (ts.isEffectiveExternalModule(sourceFile, compilerOptions) && !(location.flags & 16777216 /* NodeFlags.Ambient */)) { + var helpersModule = resolveHelpersModule(sourceFile, location); + if (helpersModule !== unknownSymbol) { + var uncheckedHelpers = helpers & ~requestedExternalEmitHelpers; + for (var helper = 1 /* ExternalEmitHelpers.FirstEmitHelper */; helper <= 4194304 /* ExternalEmitHelpers.LastEmitHelper */; helper <<= 1) { + if (uncheckedHelpers & helper) { + var name = getHelperName(helper); + var symbol = getSymbol(helpersModule.exports, ts.escapeLeadingUnderscores(name), 111551 /* SymbolFlags.Value */); + if (!symbol) { + error(location, ts.Diagnostics.This_syntax_requires_an_imported_helper_named_1_which_does_not_exist_in_0_Consider_upgrading_your_version_of_0, ts.externalHelpersModuleNameText, name); + } + else if (helper & 524288 /* ExternalEmitHelpers.ClassPrivateFieldGet */) { + if (!ts.some(getSignaturesOfSymbol(symbol), function (signature) { return getParameterCount(signature) > 3; })) { + error(location, ts.Diagnostics.This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_one_in_0_Consider_upgrading_your_version_of_0, ts.externalHelpersModuleNameText, name, 4); + } + } + else if (helper & 1048576 /* ExternalEmitHelpers.ClassPrivateFieldSet */) { + if (!ts.some(getSignaturesOfSymbol(symbol), function (signature) { return getParameterCount(signature) > 4; })) { + error(location, ts.Diagnostics.This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_one_in_0_Consider_upgrading_your_version_of_0, ts.externalHelpersModuleNameText, name, 5); + } + } + else if (helper & 1024 /* ExternalEmitHelpers.SpreadArray */) { + if (!ts.some(getSignaturesOfSymbol(symbol), function (signature) { return getParameterCount(signature) > 2; })) { + error(location, ts.Diagnostics.This_syntax_requires_an_imported_helper_named_1_with_2_parameters_which_is_not_compatible_with_the_one_in_0_Consider_upgrading_your_version_of_0, ts.externalHelpersModuleNameText, name, 3); + } + } + } + } + } + requestedExternalEmitHelpers |= helpers; + } + } + } + function getHelperName(helper) { + switch (helper) { + case 1 /* ExternalEmitHelpers.Extends */: return "__extends"; + case 2 /* ExternalEmitHelpers.Assign */: return "__assign"; + case 4 /* ExternalEmitHelpers.Rest */: return "__rest"; + case 8 /* ExternalEmitHelpers.Decorate */: return "__decorate"; + case 16 /* ExternalEmitHelpers.Metadata */: return "__metadata"; + case 32 /* ExternalEmitHelpers.Param */: return "__param"; + case 64 /* ExternalEmitHelpers.Awaiter */: return "__awaiter"; + case 128 /* ExternalEmitHelpers.Generator */: return "__generator"; + case 256 /* ExternalEmitHelpers.Values */: return "__values"; + case 512 /* ExternalEmitHelpers.Read */: return "__read"; + case 1024 /* ExternalEmitHelpers.SpreadArray */: return "__spreadArray"; + case 2048 /* ExternalEmitHelpers.Await */: return "__await"; + case 4096 /* ExternalEmitHelpers.AsyncGenerator */: return "__asyncGenerator"; + case 8192 /* ExternalEmitHelpers.AsyncDelegator */: return "__asyncDelegator"; + case 16384 /* ExternalEmitHelpers.AsyncValues */: return "__asyncValues"; + case 32768 /* ExternalEmitHelpers.ExportStar */: return "__exportStar"; + case 65536 /* ExternalEmitHelpers.ImportStar */: return "__importStar"; + case 131072 /* ExternalEmitHelpers.ImportDefault */: return "__importDefault"; + case 262144 /* ExternalEmitHelpers.MakeTemplateObject */: return "__makeTemplateObject"; + case 524288 /* ExternalEmitHelpers.ClassPrivateFieldGet */: return "__classPrivateFieldGet"; + case 1048576 /* ExternalEmitHelpers.ClassPrivateFieldSet */: return "__classPrivateFieldSet"; + case 2097152 /* ExternalEmitHelpers.ClassPrivateFieldIn */: return "__classPrivateFieldIn"; + case 4194304 /* ExternalEmitHelpers.CreateBinding */: return "__createBinding"; + default: return ts.Debug.fail("Unrecognized helper"); + } + } + function resolveHelpersModule(node, errorNode) { + if (!externalHelpersModule) { + externalHelpersModule = resolveExternalModule(node, ts.externalHelpersModuleNameText, ts.Diagnostics.This_syntax_requires_an_imported_helper_but_module_0_cannot_be_found, errorNode) || unknownSymbol; + } + return externalHelpersModule; + } + // GRAMMAR CHECKING + function checkGrammarDecoratorsAndModifiers(node) { + return checkGrammarDecorators(node) || checkGrammarModifiers(node); + } + function checkGrammarDecorators(node) { + if (ts.canHaveIllegalDecorators(node) && ts.some(node.illegalDecorators)) { + return grammarErrorOnFirstToken(node, ts.Diagnostics.Decorators_are_not_valid_here); + } + if (!ts.canHaveDecorators(node) || !ts.hasDecorators(node)) { + return false; + } + if (!ts.nodeCanBeDecorated(node, node.parent, node.parent.parent)) { + if (node.kind === 171 /* SyntaxKind.MethodDeclaration */ && !ts.nodeIsPresent(node.body)) { + return grammarErrorOnFirstToken(node, ts.Diagnostics.A_decorator_can_only_decorate_a_method_implementation_not_an_overload); + } + else { + return grammarErrorOnFirstToken(node, ts.Diagnostics.Decorators_are_not_valid_here); + } + } + else if (node.kind === 174 /* SyntaxKind.GetAccessor */ || node.kind === 175 /* SyntaxKind.SetAccessor */) { + var accessors = ts.getAllAccessorDeclarations(node.parent.members, node); + if (ts.hasDecorators(accessors.firstAccessor) && node === accessors.secondAccessor) { + return grammarErrorOnFirstToken(node, ts.Diagnostics.Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name); + } + } + return false; + } + function checkGrammarModifiers(node) { + var quickResult = reportObviousModifierErrors(node); + if (quickResult !== undefined) { + return quickResult; + } + var lastStatic, lastDeclare, lastAsync, lastOverride; + var flags = 0 /* ModifierFlags.None */; + for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) { + var modifier = _a[_i]; + if (ts.isDecorator(modifier)) + continue; + if (modifier.kind !== 146 /* SyntaxKind.ReadonlyKeyword */) { + if (node.kind === 168 /* SyntaxKind.PropertySignature */ || node.kind === 170 /* SyntaxKind.MethodSignature */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_type_member, ts.tokenToString(modifier.kind)); + } + if (node.kind === 178 /* SyntaxKind.IndexSignature */ && (modifier.kind !== 124 /* SyntaxKind.StaticKeyword */ || !ts.isClassLike(node.parent))) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_an_index_signature, ts.tokenToString(modifier.kind)); + } + } + if (modifier.kind !== 101 /* SyntaxKind.InKeyword */ && modifier.kind !== 145 /* SyntaxKind.OutKeyword */) { + if (node.kind === 165 /* SyntaxKind.TypeParameter */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_type_parameter, ts.tokenToString(modifier.kind)); + } + } + switch (modifier.kind) { + case 85 /* SyntaxKind.ConstKeyword */: + if (node.kind !== 263 /* SyntaxKind.EnumDeclaration */) { + return grammarErrorOnNode(node, ts.Diagnostics.A_class_member_cannot_have_the_0_keyword, ts.tokenToString(85 /* SyntaxKind.ConstKeyword */)); + } + break; + case 161 /* SyntaxKind.OverrideKeyword */: + // If node.kind === SyntaxKind.Parameter, checkParameter reports an error if it's not a parameter property. + if (flags & 16384 /* ModifierFlags.Override */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "override"); + } + else if (flags & 2 /* ModifierFlags.Ambient */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "override", "declare"); + } + else if (flags & 64 /* ModifierFlags.Readonly */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "override", "readonly"); + } + else if (flags & 128 /* ModifierFlags.Accessor */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "override", "accessor"); + } + else if (flags & 512 /* ModifierFlags.Async */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "override", "async"); + } + flags |= 16384 /* ModifierFlags.Override */; + lastOverride = modifier; + break; + case 123 /* SyntaxKind.PublicKeyword */: + case 122 /* SyntaxKind.ProtectedKeyword */: + case 121 /* SyntaxKind.PrivateKeyword */: + var text = visibilityToString(ts.modifierToFlag(modifier.kind)); + if (flags & 28 /* ModifierFlags.AccessibilityModifier */) { + return grammarErrorOnNode(modifier, ts.Diagnostics.Accessibility_modifier_already_seen); + } + else if (flags & 16384 /* ModifierFlags.Override */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "override"); + } + else if (flags & 32 /* ModifierFlags.Static */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "static"); + } + else if (flags & 128 /* ModifierFlags.Accessor */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "accessor"); + } + else if (flags & 64 /* ModifierFlags.Readonly */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "readonly"); + } + else if (flags & 512 /* ModifierFlags.Async */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "async"); + } + else if (node.parent.kind === 265 /* SyntaxKind.ModuleBlock */ || node.parent.kind === 308 /* SyntaxKind.SourceFile */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_or_namespace_element, text); + } + else if (flags & 256 /* ModifierFlags.Abstract */) { + if (modifier.kind === 121 /* SyntaxKind.PrivateKeyword */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, text, "abstract"); + } + else { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, text, "abstract"); + } + } + else if (ts.isPrivateIdentifierClassElementDeclaration(node)) { + return grammarErrorOnNode(modifier, ts.Diagnostics.An_accessibility_modifier_cannot_be_used_with_a_private_identifier); + } + flags |= ts.modifierToFlag(modifier.kind); + break; + case 124 /* SyntaxKind.StaticKeyword */: + if (flags & 32 /* ModifierFlags.Static */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "static"); + } + else if (flags & 64 /* ModifierFlags.Readonly */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "static", "readonly"); + } + else if (flags & 512 /* ModifierFlags.Async */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "static", "async"); + } + else if (flags & 128 /* ModifierFlags.Accessor */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "static", "accessor"); + } + else if (node.parent.kind === 265 /* SyntaxKind.ModuleBlock */ || node.parent.kind === 308 /* SyntaxKind.SourceFile */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_module_or_namespace_element, "static"); + } + else if (node.kind === 166 /* SyntaxKind.Parameter */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "static"); + } + else if (flags & 256 /* ModifierFlags.Abstract */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract"); + } + else if (flags & 16384 /* ModifierFlags.Override */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "static", "override"); + } + flags |= 32 /* ModifierFlags.Static */; + lastStatic = modifier; + break; + case 127 /* SyntaxKind.AccessorKeyword */: + if (flags & 128 /* ModifierFlags.Accessor */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "accessor"); + } + else if (flags & 64 /* ModifierFlags.Readonly */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "accessor", "readonly"); + } + else if (flags & 2 /* ModifierFlags.Ambient */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "accessor", "declare"); + } + else if (node.kind !== 169 /* SyntaxKind.PropertyDeclaration */) { + return grammarErrorOnNode(modifier, ts.Diagnostics.accessor_modifier_can_only_appear_on_a_property_declaration); + } + flags |= 128 /* ModifierFlags.Accessor */; + break; + case 146 /* SyntaxKind.ReadonlyKeyword */: + if (flags & 64 /* ModifierFlags.Readonly */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "readonly"); + } + else if (node.kind !== 169 /* SyntaxKind.PropertyDeclaration */ && node.kind !== 168 /* SyntaxKind.PropertySignature */ && node.kind !== 178 /* SyntaxKind.IndexSignature */ && node.kind !== 166 /* SyntaxKind.Parameter */) { + // If node.kind === SyntaxKind.Parameter, checkParameter reports an error if it's not a parameter property. + return grammarErrorOnNode(modifier, ts.Diagnostics.readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature); + } + flags |= 64 /* ModifierFlags.Readonly */; + break; + case 93 /* SyntaxKind.ExportKeyword */: + if (flags & 1 /* ModifierFlags.Export */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "export"); + } + else if (flags & 2 /* ModifierFlags.Ambient */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "declare"); + } + else if (flags & 256 /* ModifierFlags.Abstract */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "abstract"); + } + else if (flags & 512 /* ModifierFlags.Async */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "async"); + } + else if (ts.isClassLike(node.parent)) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_class_elements_of_this_kind, "export"); + } + else if (node.kind === 166 /* SyntaxKind.Parameter */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "export"); + } + flags |= 1 /* ModifierFlags.Export */; + break; + case 88 /* SyntaxKind.DefaultKeyword */: + var container = node.parent.kind === 308 /* SyntaxKind.SourceFile */ ? node.parent : node.parent.parent; + if (container.kind === 264 /* SyntaxKind.ModuleDeclaration */ && !ts.isAmbientModule(container)) { + return grammarErrorOnNode(modifier, ts.Diagnostics.A_default_export_can_only_be_used_in_an_ECMAScript_style_module); + } + else if (!(flags & 1 /* ModifierFlags.Export */)) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "export", "default"); + } + flags |= 1024 /* ModifierFlags.Default */; + break; + case 136 /* SyntaxKind.DeclareKeyword */: + if (flags & 2 /* ModifierFlags.Ambient */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "declare"); + } + else if (flags & 512 /* ModifierFlags.Async */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async"); + } + else if (flags & 16384 /* ModifierFlags.Override */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "override"); + } + else if (ts.isClassLike(node.parent) && !ts.isPropertyDeclaration(node)) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_class_elements_of_this_kind, "declare"); + } + else if (node.kind === 166 /* SyntaxKind.Parameter */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "declare"); + } + else if ((node.parent.flags & 16777216 /* NodeFlags.Ambient */) && node.parent.kind === 265 /* SyntaxKind.ModuleBlock */) { + return grammarErrorOnNode(modifier, ts.Diagnostics.A_declare_modifier_cannot_be_used_in_an_already_ambient_context); + } + else if (ts.isPrivateIdentifierClassElementDeclaration(node)) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_a_private_identifier, "declare"); + } + flags |= 2 /* ModifierFlags.Ambient */; + lastDeclare = modifier; + break; + case 126 /* SyntaxKind.AbstractKeyword */: + if (flags & 256 /* ModifierFlags.Abstract */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "abstract"); + } + if (node.kind !== 260 /* SyntaxKind.ClassDeclaration */ && + node.kind !== 182 /* SyntaxKind.ConstructorType */) { + if (node.kind !== 171 /* SyntaxKind.MethodDeclaration */ && + node.kind !== 169 /* SyntaxKind.PropertyDeclaration */ && + node.kind !== 174 /* SyntaxKind.GetAccessor */ && + node.kind !== 175 /* SyntaxKind.SetAccessor */) { + return grammarErrorOnNode(modifier, ts.Diagnostics.abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration); + } + if (!(node.parent.kind === 260 /* SyntaxKind.ClassDeclaration */ && ts.hasSyntacticModifier(node.parent, 256 /* ModifierFlags.Abstract */))) { + return grammarErrorOnNode(modifier, ts.Diagnostics.Abstract_methods_can_only_appear_within_an_abstract_class); + } + if (flags & 32 /* ModifierFlags.Static */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract"); + } + if (flags & 8 /* ModifierFlags.Private */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "private", "abstract"); + } + if (flags & 512 /* ModifierFlags.Async */ && lastAsync) { + return grammarErrorOnNode(lastAsync, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "async", "abstract"); + } + if (flags & 16384 /* ModifierFlags.Override */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "abstract", "override"); + } + if (flags & 128 /* ModifierFlags.Accessor */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "abstract", "accessor"); + } + } + if (ts.isNamedDeclaration(node) && node.name.kind === 80 /* SyntaxKind.PrivateIdentifier */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_a_private_identifier, "abstract"); + } + flags |= 256 /* ModifierFlags.Abstract */; + break; + case 132 /* SyntaxKind.AsyncKeyword */: + if (flags & 512 /* ModifierFlags.Async */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, "async"); + } + else if (flags & 2 /* ModifierFlags.Ambient */ || node.parent.flags & 16777216 /* NodeFlags.Ambient */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_in_an_ambient_context, "async"); + } + else if (node.kind === 166 /* SyntaxKind.Parameter */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter, "async"); + } + if (flags & 256 /* ModifierFlags.Abstract */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "async", "abstract"); + } + flags |= 512 /* ModifierFlags.Async */; + lastAsync = modifier; + break; + case 101 /* SyntaxKind.InKeyword */: + case 145 /* SyntaxKind.OutKeyword */: + var inOutFlag = modifier.kind === 101 /* SyntaxKind.InKeyword */ ? 32768 /* ModifierFlags.In */ : 65536 /* ModifierFlags.Out */; + var inOutText = modifier.kind === 101 /* SyntaxKind.InKeyword */ ? "in" : "out"; + if (node.kind !== 165 /* SyntaxKind.TypeParameter */ || !(ts.isInterfaceDeclaration(node.parent) || ts.isClassLike(node.parent) || ts.isTypeAliasDeclaration(node.parent))) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_can_only_appear_on_a_type_parameter_of_a_class_interface_or_type_alias, inOutText); + } + if (flags & inOutFlag) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_already_seen, inOutText); + } + if (inOutFlag & 32768 /* ModifierFlags.In */ && flags & 65536 /* ModifierFlags.Out */) { + return grammarErrorOnNode(modifier, ts.Diagnostics._0_modifier_must_precede_1_modifier, "in", "out"); + } + flags |= inOutFlag; + break; + } + } + if (node.kind === 173 /* SyntaxKind.Constructor */) { + if (flags & 32 /* ModifierFlags.Static */) { + return grammarErrorOnNode(lastStatic, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "static"); + } + if (flags & 16384 /* ModifierFlags.Override */) { + return grammarErrorOnNode(lastOverride, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "override"); // TODO: GH#18217 + } + if (flags & 512 /* ModifierFlags.Async */) { + return grammarErrorOnNode(lastAsync, ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration, "async"); + } + return false; + } + else if ((node.kind === 269 /* SyntaxKind.ImportDeclaration */ || node.kind === 268 /* SyntaxKind.ImportEqualsDeclaration */) && flags & 2 /* ModifierFlags.Ambient */) { + return grammarErrorOnNode(lastDeclare, ts.Diagnostics.A_0_modifier_cannot_be_used_with_an_import_declaration, "declare"); + } + else if (node.kind === 166 /* SyntaxKind.Parameter */ && (flags & 16476 /* ModifierFlags.ParameterPropertyModifier */) && ts.isBindingPattern(node.name)) { + return grammarErrorOnNode(node, ts.Diagnostics.A_parameter_property_may_not_be_declared_using_a_binding_pattern); + } + else if (node.kind === 166 /* SyntaxKind.Parameter */ && (flags & 16476 /* ModifierFlags.ParameterPropertyModifier */) && node.dotDotDotToken) { + return grammarErrorOnNode(node, ts.Diagnostics.A_parameter_property_cannot_be_declared_using_a_rest_parameter); + } + if (flags & 512 /* ModifierFlags.Async */) { + return checkGrammarAsyncModifier(node, lastAsync); + } + return false; + } + /** + * true | false: Early return this value from checkGrammarModifiers. + * undefined: Need to do full checking on the modifiers. + */ + function reportObviousModifierErrors(node) { + return !node.modifiers + ? false + : shouldReportBadModifier(node) + ? grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_cannot_appear_here) + : undefined; + } + function shouldReportBadModifier(node) { + switch (node.kind) { + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 173 /* SyntaxKind.Constructor */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 168 /* SyntaxKind.PropertySignature */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + case 178 /* SyntaxKind.IndexSignature */: + case 264 /* SyntaxKind.ModuleDeclaration */: + case 269 /* SyntaxKind.ImportDeclaration */: + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + case 275 /* SyntaxKind.ExportDeclaration */: + case 274 /* SyntaxKind.ExportAssignment */: + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + case 166 /* SyntaxKind.Parameter */: + case 165 /* SyntaxKind.TypeParameter */: + return false; + case 172 /* SyntaxKind.ClassStaticBlockDeclaration */: + case 299 /* SyntaxKind.PropertyAssignment */: + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + case 267 /* SyntaxKind.NamespaceExportDeclaration */: + case 181 /* SyntaxKind.FunctionType */: + case 279 /* SyntaxKind.MissingDeclaration */: + return true; + default: + if (node.parent.kind === 265 /* SyntaxKind.ModuleBlock */ || node.parent.kind === 308 /* SyntaxKind.SourceFile */) { + return false; + } + switch (node.kind) { + case 259 /* SyntaxKind.FunctionDeclaration */: + return nodeHasAnyModifiersExcept(node, 132 /* SyntaxKind.AsyncKeyword */); + case 260 /* SyntaxKind.ClassDeclaration */: + case 182 /* SyntaxKind.ConstructorType */: + return nodeHasAnyModifiersExcept(node, 126 /* SyntaxKind.AbstractKeyword */); + case 228 /* SyntaxKind.ClassExpression */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 240 /* SyntaxKind.VariableStatement */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + return true; + case 263 /* SyntaxKind.EnumDeclaration */: + return nodeHasAnyModifiersExcept(node, 85 /* SyntaxKind.ConstKeyword */); + default: + ts.Debug.assertNever(node); + } + } + } + function nodeHasAnyModifiersExcept(node, allowedModifier) { + for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) { + var modifier = _a[_i]; + if (ts.isDecorator(modifier)) + continue; + return modifier.kind !== allowedModifier; + } + return false; + } + function checkGrammarAsyncModifier(node, asyncModifier) { + switch (node.kind) { + case 171 /* SyntaxKind.MethodDeclaration */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + return false; + } + return grammarErrorOnNode(asyncModifier, ts.Diagnostics._0_modifier_cannot_be_used_here, "async"); + } + function checkGrammarForDisallowedTrailingComma(list, diag) { + if (diag === void 0) { diag = ts.Diagnostics.Trailing_comma_not_allowed; } + if (list && list.hasTrailingComma) { + return grammarErrorAtPos(list[0], list.end - ",".length, ",".length, diag); + } + return false; + } + function checkGrammarTypeParameterList(typeParameters, file) { + if (typeParameters && typeParameters.length === 0) { + var start = typeParameters.pos - "<".length; + var end = ts.skipTrivia(file.text, typeParameters.end) + ">".length; + return grammarErrorAtPos(file, start, end - start, ts.Diagnostics.Type_parameter_list_cannot_be_empty); + } + return false; + } + function checkGrammarParameterList(parameters) { + var seenOptionalParameter = false; + var parameterCount = parameters.length; + for (var i = 0; i < parameterCount; i++) { + var parameter = parameters[i]; + if (parameter.dotDotDotToken) { + if (i !== (parameterCount - 1)) { + return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list); + } + if (!(parameter.flags & 16777216 /* NodeFlags.Ambient */)) { // Allow `...foo,` in ambient declarations; see GH#23070 + checkGrammarForDisallowedTrailingComma(parameters, ts.Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma); + } + if (parameter.questionToken) { + return grammarErrorOnNode(parameter.questionToken, ts.Diagnostics.A_rest_parameter_cannot_be_optional); + } + if (parameter.initializer) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.A_rest_parameter_cannot_have_an_initializer); + } + } + else if (isOptionalParameter(parameter)) { + seenOptionalParameter = true; + if (parameter.questionToken && parameter.initializer) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.Parameter_cannot_have_question_mark_and_initializer); + } + } + else if (seenOptionalParameter && !parameter.initializer) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.A_required_parameter_cannot_follow_an_optional_parameter); + } + } + } + function getNonSimpleParameters(parameters) { + return ts.filter(parameters, function (parameter) { return !!parameter.initializer || ts.isBindingPattern(parameter.name) || ts.isRestParameter(parameter); }); + } + function checkGrammarForUseStrictSimpleParameterList(node) { + if (languageVersion >= 3 /* ScriptTarget.ES2016 */) { + var useStrictDirective_1 = node.body && ts.isBlock(node.body) && ts.findUseStrictPrologue(node.body.statements); + if (useStrictDirective_1) { + var nonSimpleParameters = getNonSimpleParameters(node.parameters); + if (ts.length(nonSimpleParameters)) { + ts.forEach(nonSimpleParameters, function (parameter) { + ts.addRelatedInfo(error(parameter, ts.Diagnostics.This_parameter_is_not_allowed_with_use_strict_directive), ts.createDiagnosticForNode(useStrictDirective_1, ts.Diagnostics.use_strict_directive_used_here)); + }); + var diagnostics_2 = nonSimpleParameters.map(function (parameter, index) { return (index === 0 ? ts.createDiagnosticForNode(parameter, ts.Diagnostics.Non_simple_parameter_declared_here) : ts.createDiagnosticForNode(parameter, ts.Diagnostics.and_here)); }); + ts.addRelatedInfo.apply(void 0, __spreadArray([error(useStrictDirective_1, ts.Diagnostics.use_strict_directive_cannot_be_used_with_non_simple_parameter_list)], diagnostics_2, false)); + return true; + } + } + } + return false; + } + function checkGrammarFunctionLikeDeclaration(node) { + // Prevent cascading error by short-circuit + var file = ts.getSourceFileOfNode(node); + return checkGrammarDecoratorsAndModifiers(node) || + checkGrammarTypeParameterList(node.typeParameters, file) || + checkGrammarParameterList(node.parameters) || + checkGrammarArrowFunction(node, file) || + (ts.isFunctionLikeDeclaration(node) && checkGrammarForUseStrictSimpleParameterList(node)); + } + function checkGrammarClassLikeDeclaration(node) { + var file = ts.getSourceFileOfNode(node); + return checkGrammarClassDeclarationHeritageClauses(node) || + checkGrammarTypeParameterList(node.typeParameters, file); + } + function checkGrammarArrowFunction(node, file) { + if (!ts.isArrowFunction(node)) { + return false; + } + if (node.typeParameters && !(ts.length(node.typeParameters) > 1 || node.typeParameters.hasTrailingComma || node.typeParameters[0].constraint)) { + if (file && ts.fileExtensionIsOneOf(file.fileName, [".mts" /* Extension.Mts */, ".cts" /* Extension.Cts */])) { + grammarErrorOnNode(node.typeParameters[0], ts.Diagnostics.This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Add_a_trailing_comma_or_explicit_constraint); + } + } + var equalsGreaterThanToken = node.equalsGreaterThanToken; + var startLine = ts.getLineAndCharacterOfPosition(file, equalsGreaterThanToken.pos).line; + var endLine = ts.getLineAndCharacterOfPosition(file, equalsGreaterThanToken.end).line; + return startLine !== endLine && grammarErrorOnNode(equalsGreaterThanToken, ts.Diagnostics.Line_terminator_not_permitted_before_arrow); + } + function checkGrammarIndexSignatureParameters(node) { + var parameter = node.parameters[0]; + if (node.parameters.length !== 1) { + if (parameter) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_must_have_exactly_one_parameter); + } + else { + return grammarErrorOnNode(node, ts.Diagnostics.An_index_signature_must_have_exactly_one_parameter); + } + } + checkGrammarForDisallowedTrailingComma(node.parameters, ts.Diagnostics.An_index_signature_cannot_have_a_trailing_comma); + if (parameter.dotDotDotToken) { + return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.An_index_signature_cannot_have_a_rest_parameter); + } + if (ts.hasEffectiveModifiers(parameter)) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_cannot_have_an_accessibility_modifier); + } + if (parameter.questionToken) { + return grammarErrorOnNode(parameter.questionToken, ts.Diagnostics.An_index_signature_parameter_cannot_have_a_question_mark); + } + if (parameter.initializer) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_cannot_have_an_initializer); + } + if (!parameter.type) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_must_have_a_type_annotation); + } + var type = getTypeFromTypeNode(parameter.type); + if (someType(type, function (t) { return !!(t.flags & 8576 /* TypeFlags.StringOrNumberLiteralOrUnique */); }) || isGenericType(type)) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_object_type_instead); + } + if (!everyType(type, isValidIndexKeyType)) { + return grammarErrorOnNode(parameter.name, ts.Diagnostics.An_index_signature_parameter_type_must_be_string_number_symbol_or_a_template_literal_type); + } + if (!node.type) { + return grammarErrorOnNode(node, ts.Diagnostics.An_index_signature_must_have_a_type_annotation); + } + return false; + } + function checkGrammarIndexSignature(node) { + // Prevent cascading error by short-circuit + return checkGrammarDecoratorsAndModifiers(node) || checkGrammarIndexSignatureParameters(node); + } + function checkGrammarForAtLeastOneTypeArgument(node, typeArguments) { + if (typeArguments && typeArguments.length === 0) { + var sourceFile = ts.getSourceFileOfNode(node); + var start = typeArguments.pos - "<".length; + var end = ts.skipTrivia(sourceFile.text, typeArguments.end) + ">".length; + return grammarErrorAtPos(sourceFile, start, end - start, ts.Diagnostics.Type_argument_list_cannot_be_empty); + } + return false; + } + function checkGrammarTypeArguments(node, typeArguments) { + return checkGrammarForDisallowedTrailingComma(typeArguments) || + checkGrammarForAtLeastOneTypeArgument(node, typeArguments); + } + function checkGrammarTaggedTemplateChain(node) { + if (node.questionDotToken || node.flags & 32 /* NodeFlags.OptionalChain */) { + return grammarErrorOnNode(node.template, ts.Diagnostics.Tagged_template_expressions_are_not_permitted_in_an_optional_chain); + } + return false; + } + function checkGrammarHeritageClause(node) { + var types = node.types; + if (checkGrammarForDisallowedTrailingComma(types)) { + return true; + } + if (types && types.length === 0) { + var listType = ts.tokenToString(node.token); + return grammarErrorAtPos(node, types.pos, 0, ts.Diagnostics._0_list_cannot_be_empty, listType); + } + return ts.some(types, checkGrammarExpressionWithTypeArguments); + } + function checkGrammarExpressionWithTypeArguments(node) { + if (ts.isExpressionWithTypeArguments(node) && ts.isImportKeyword(node.expression) && node.typeArguments) { + return grammarErrorOnNode(node, ts.Diagnostics.This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments); + } + return checkGrammarTypeArguments(node, node.typeArguments); + } + function checkGrammarClassDeclarationHeritageClauses(node) { + var seenExtendsClause = false; + var seenImplementsClause = false; + if (!checkGrammarDecoratorsAndModifiers(node) && node.heritageClauses) { + for (var _i = 0, _a = node.heritageClauses; _i < _a.length; _i++) { + var heritageClause = _a[_i]; + if (heritageClause.token === 94 /* SyntaxKind.ExtendsKeyword */) { + if (seenExtendsClause) { + return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.extends_clause_already_seen); + } + if (seenImplementsClause) { + return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.extends_clause_must_precede_implements_clause); + } + if (heritageClause.types.length > 1) { + return grammarErrorOnFirstToken(heritageClause.types[1], ts.Diagnostics.Classes_can_only_extend_a_single_class); + } + seenExtendsClause = true; + } + else { + ts.Debug.assert(heritageClause.token === 117 /* SyntaxKind.ImplementsKeyword */); + if (seenImplementsClause) { + return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.implements_clause_already_seen); + } + seenImplementsClause = true; + } + // Grammar checking heritageClause inside class declaration + checkGrammarHeritageClause(heritageClause); + } + } + } + function checkGrammarInterfaceDeclaration(node) { + var seenExtendsClause = false; + if (node.heritageClauses) { + for (var _i = 0, _a = node.heritageClauses; _i < _a.length; _i++) { + var heritageClause = _a[_i]; + if (heritageClause.token === 94 /* SyntaxKind.ExtendsKeyword */) { + if (seenExtendsClause) { + return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.extends_clause_already_seen); + } + seenExtendsClause = true; + } + else { + ts.Debug.assert(heritageClause.token === 117 /* SyntaxKind.ImplementsKeyword */); + return grammarErrorOnFirstToken(heritageClause, ts.Diagnostics.Interface_declaration_cannot_have_implements_clause); + } + // Grammar checking heritageClause inside class declaration + checkGrammarHeritageClause(heritageClause); + } + } + return false; + } + function checkGrammarComputedPropertyName(node) { + // If node is not a computedPropertyName, just skip the grammar checking + if (node.kind !== 164 /* SyntaxKind.ComputedPropertyName */) { + return false; + } + var computedPropertyName = node; + if (computedPropertyName.expression.kind === 223 /* SyntaxKind.BinaryExpression */ && computedPropertyName.expression.operatorToken.kind === 27 /* SyntaxKind.CommaToken */) { + return grammarErrorOnNode(computedPropertyName.expression, ts.Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name); + } + return false; + } + function checkGrammarForGenerator(node) { + if (node.asteriskToken) { + ts.Debug.assert(node.kind === 259 /* SyntaxKind.FunctionDeclaration */ || + node.kind === 215 /* SyntaxKind.FunctionExpression */ || + node.kind === 171 /* SyntaxKind.MethodDeclaration */); + if (node.flags & 16777216 /* NodeFlags.Ambient */) { + return grammarErrorOnNode(node.asteriskToken, ts.Diagnostics.Generators_are_not_allowed_in_an_ambient_context); + } + if (!node.body) { + return grammarErrorOnNode(node.asteriskToken, ts.Diagnostics.An_overload_signature_cannot_be_declared_as_a_generator); + } + } + } + function checkGrammarForInvalidQuestionMark(questionToken, message) { + return !!questionToken && grammarErrorOnNode(questionToken, message); + } + function checkGrammarForInvalidExclamationToken(exclamationToken, message) { + return !!exclamationToken && grammarErrorOnNode(exclamationToken, message); + } + function checkGrammarObjectLiteralExpression(node, inDestructuring) { + var seen = new ts.Map(); + for (var _i = 0, _a = node.properties; _i < _a.length; _i++) { + var prop = _a[_i]; + if (prop.kind === 301 /* SyntaxKind.SpreadAssignment */) { + if (inDestructuring) { + // a rest property cannot be destructured any further + var expression = ts.skipParentheses(prop.expression); + if (ts.isArrayLiteralExpression(expression) || ts.isObjectLiteralExpression(expression)) { + return grammarErrorOnNode(prop.expression, ts.Diagnostics.A_rest_element_cannot_contain_a_binding_pattern); + } + } + continue; + } + var name = prop.name; + if (name.kind === 164 /* SyntaxKind.ComputedPropertyName */) { + // If the name is not a ComputedPropertyName, the grammar checking will skip it + checkGrammarComputedPropertyName(name); + } + if (prop.kind === 300 /* SyntaxKind.ShorthandPropertyAssignment */ && !inDestructuring && prop.objectAssignmentInitializer) { + // having objectAssignmentInitializer is only valid in ObjectAssignmentPattern + // outside of destructuring it is a syntax error + grammarErrorOnNode(prop.equalsToken, ts.Diagnostics.Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_part_of_a_destructuring_pattern); + } + if (name.kind === 80 /* SyntaxKind.PrivateIdentifier */) { + grammarErrorOnNode(name, ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies); + } + // Modifiers are never allowed on properties except for 'async' on a method declaration + if (ts.canHaveModifiers(prop) && prop.modifiers) { + for (var _b = 0, _c = prop.modifiers; _b < _c.length; _b++) { + var mod = _c[_b]; + if (ts.isModifier(mod) && (mod.kind !== 132 /* SyntaxKind.AsyncKeyword */ || prop.kind !== 171 /* SyntaxKind.MethodDeclaration */)) { + grammarErrorOnNode(mod, ts.Diagnostics._0_modifier_cannot_be_used_here, ts.getTextOfNode(mod)); + } + } + } + else if (ts.canHaveIllegalModifiers(prop) && prop.modifiers) { + for (var _d = 0, _e = prop.modifiers; _d < _e.length; _d++) { + var mod = _e[_d]; + grammarErrorOnNode(mod, ts.Diagnostics._0_modifier_cannot_be_used_here, ts.getTextOfNode(mod)); + } + } + // ECMA-262 11.1.5 Object Initializer + // If previous is not undefined then throw a SyntaxError exception if any of the following conditions are true + // a.This production is contained in strict code and IsDataDescriptor(previous) is true and + // IsDataDescriptor(propId.descriptor) is true. + // b.IsDataDescriptor(previous) is true and IsAccessorDescriptor(propId.descriptor) is true. + // c.IsAccessorDescriptor(previous) is true and IsDataDescriptor(propId.descriptor) is true. + // d.IsAccessorDescriptor(previous) is true and IsAccessorDescriptor(propId.descriptor) is true + // and either both previous and propId.descriptor have[[Get]] fields or both previous and propId.descriptor have[[Set]] fields + var currentKind = void 0; + switch (prop.kind) { + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + case 299 /* SyntaxKind.PropertyAssignment */: + // Grammar checking for computedPropertyName and shorthandPropertyAssignment + checkGrammarForInvalidExclamationToken(prop.exclamationToken, ts.Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context); + checkGrammarForInvalidQuestionMark(prop.questionToken, ts.Diagnostics.An_object_member_cannot_be_declared_optional); + if (name.kind === 8 /* SyntaxKind.NumericLiteral */) { + checkGrammarNumericLiteral(name); + } + currentKind = 4 /* DeclarationMeaning.PropertyAssignment */; + break; + case 171 /* SyntaxKind.MethodDeclaration */: + currentKind = 8 /* DeclarationMeaning.Method */; + break; + case 174 /* SyntaxKind.GetAccessor */: + currentKind = 1 /* DeclarationMeaning.GetAccessor */; + break; + case 175 /* SyntaxKind.SetAccessor */: + currentKind = 2 /* DeclarationMeaning.SetAccessor */; + break; + default: + throw ts.Debug.assertNever(prop, "Unexpected syntax kind:" + prop.kind); + } + if (!inDestructuring) { + var effectiveName = ts.getPropertyNameForPropertyNameNode(name); + if (effectiveName === undefined) { + continue; + } + var existingKind = seen.get(effectiveName); + if (!existingKind) { + seen.set(effectiveName, currentKind); + } + else { + if ((currentKind & 8 /* DeclarationMeaning.Method */) && (existingKind & 8 /* DeclarationMeaning.Method */)) { + grammarErrorOnNode(name, ts.Diagnostics.Duplicate_identifier_0, ts.getTextOfNode(name)); + } + else if ((currentKind & 4 /* DeclarationMeaning.PropertyAssignment */) && (existingKind & 4 /* DeclarationMeaning.PropertyAssignment */)) { + grammarErrorOnNode(name, ts.Diagnostics.An_object_literal_cannot_have_multiple_properties_with_the_same_name, ts.getTextOfNode(name)); + } + else if ((currentKind & 3 /* DeclarationMeaning.GetOrSetAccessor */) && (existingKind & 3 /* DeclarationMeaning.GetOrSetAccessor */)) { + if (existingKind !== 3 /* DeclarationMeaning.GetOrSetAccessor */ && currentKind !== existingKind) { + seen.set(effectiveName, currentKind | existingKind); + } + else { + return grammarErrorOnNode(name, ts.Diagnostics.An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name); + } + } + else { + return grammarErrorOnNode(name, ts.Diagnostics.An_object_literal_cannot_have_property_and_accessor_with_the_same_name); + } + } + } + } + } + function checkGrammarJsxElement(node) { + checkGrammarJsxName(node.tagName); + checkGrammarTypeArguments(node, node.typeArguments); + var seen = new ts.Map(); + for (var _i = 0, _a = node.attributes.properties; _i < _a.length; _i++) { + var attr = _a[_i]; + if (attr.kind === 290 /* SyntaxKind.JsxSpreadAttribute */) { + continue; + } + var name = attr.name, initializer = attr.initializer; + if (!seen.get(name.escapedText)) { + seen.set(name.escapedText, true); + } + else { + return grammarErrorOnNode(name, ts.Diagnostics.JSX_elements_cannot_have_multiple_attributes_with_the_same_name); + } + if (initializer && initializer.kind === 291 /* SyntaxKind.JsxExpression */ && !initializer.expression) { + return grammarErrorOnNode(initializer, ts.Diagnostics.JSX_attributes_must_only_be_assigned_a_non_empty_expression); + } + } + } + function checkGrammarJsxName(node) { + if (ts.isPropertyAccessExpression(node)) { + var propName = node; + do { + var check_1 = checkGrammarJsxNestedIdentifier(propName.name); + if (check_1) { + return check_1; + } + propName = propName.expression; + } while (ts.isPropertyAccessExpression(propName)); + var check = checkGrammarJsxNestedIdentifier(propName); + if (check) { + return check; + } + } + function checkGrammarJsxNestedIdentifier(name) { + if (ts.isIdentifier(name) && ts.idText(name).indexOf(":") !== -1) { + return grammarErrorOnNode(name, ts.Diagnostics.JSX_property_access_expressions_cannot_include_JSX_namespace_names); + } + } + } + function checkGrammarJsxExpression(node) { + if (node.expression && ts.isCommaSequence(node.expression)) { + return grammarErrorOnNode(node.expression, ts.Diagnostics.JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array); + } + } + function checkGrammarForInOrForOfStatement(forInOrOfStatement) { + if (checkGrammarStatementInAmbientContext(forInOrOfStatement)) { + return true; + } + if (forInOrOfStatement.kind === 247 /* SyntaxKind.ForOfStatement */ && forInOrOfStatement.awaitModifier) { + if (!(forInOrOfStatement.flags & 32768 /* NodeFlags.AwaitContext */)) { + var sourceFile = ts.getSourceFileOfNode(forInOrOfStatement); + if (ts.isInTopLevelContext(forInOrOfStatement)) { + if (!hasParseDiagnostics(sourceFile)) { + if (!ts.isEffectiveExternalModule(sourceFile, compilerOptions)) { + diagnostics.add(ts.createDiagnosticForNode(forInOrOfStatement.awaitModifier, ts.Diagnostics.for_await_loops_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module)); + } + switch (moduleKind) { + case ts.ModuleKind.Node16: + case ts.ModuleKind.NodeNext: + if (sourceFile.impliedNodeFormat === ts.ModuleKind.CommonJS) { + diagnostics.add(ts.createDiagnosticForNode(forInOrOfStatement.awaitModifier, ts.Diagnostics.The_current_file_is_a_CommonJS_module_and_cannot_use_await_at_the_top_level)); + break; + } + // fallthrough + case ts.ModuleKind.ES2022: + case ts.ModuleKind.ESNext: + case ts.ModuleKind.System: + if (languageVersion >= 4 /* ScriptTarget.ES2017 */) { + break; + } + // fallthrough + default: + diagnostics.add(ts.createDiagnosticForNode(forInOrOfStatement.awaitModifier, ts.Diagnostics.Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher)); + break; + } + } + } + else { + // use of 'for-await-of' in non-async function + if (!hasParseDiagnostics(sourceFile)) { + var diagnostic = ts.createDiagnosticForNode(forInOrOfStatement.awaitModifier, ts.Diagnostics.for_await_loops_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules); + var func = ts.getContainingFunction(forInOrOfStatement); + if (func && func.kind !== 173 /* SyntaxKind.Constructor */) { + ts.Debug.assert((ts.getFunctionFlags(func) & 2 /* FunctionFlags.Async */) === 0, "Enclosing function should never be an async function."); + var relatedInfo = ts.createDiagnosticForNode(func, ts.Diagnostics.Did_you_mean_to_mark_this_function_as_async); + ts.addRelatedInfo(diagnostic, relatedInfo); + } + diagnostics.add(diagnostic); + return true; + } + } + return false; + } + } + if (ts.isForOfStatement(forInOrOfStatement) && !(forInOrOfStatement.flags & 32768 /* NodeFlags.AwaitContext */) && + ts.isIdentifier(forInOrOfStatement.initializer) && forInOrOfStatement.initializer.escapedText === "async") { + grammarErrorOnNode(forInOrOfStatement.initializer, ts.Diagnostics.The_left_hand_side_of_a_for_of_statement_may_not_be_async); + return false; + } + if (forInOrOfStatement.initializer.kind === 258 /* SyntaxKind.VariableDeclarationList */) { + var variableList = forInOrOfStatement.initializer; + if (!checkGrammarVariableDeclarationList(variableList)) { + var declarations = variableList.declarations; + // declarations.length can be zero if there is an error in variable declaration in for-of or for-in + // See http://www.ecma-international.org/ecma-262/6.0/#sec-for-in-and-for-of-statements for details + // For example: + // var let = 10; + // for (let of [1,2,3]) {} // this is invalid ES6 syntax + // for (let in [1,2,3]) {} // this is invalid ES6 syntax + // We will then want to skip on grammar checking on variableList declaration + if (!declarations.length) { + return false; + } + if (declarations.length > 1) { + var diagnostic = forInOrOfStatement.kind === 246 /* SyntaxKind.ForInStatement */ + ? ts.Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement + : ts.Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement; + return grammarErrorOnFirstToken(variableList.declarations[1], diagnostic); + } + var firstDeclaration = declarations[0]; + if (firstDeclaration.initializer) { + var diagnostic = forInOrOfStatement.kind === 246 /* SyntaxKind.ForInStatement */ + ? ts.Diagnostics.The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer + : ts.Diagnostics.The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer; + return grammarErrorOnNode(firstDeclaration.name, diagnostic); + } + if (firstDeclaration.type) { + var diagnostic = forInOrOfStatement.kind === 246 /* SyntaxKind.ForInStatement */ + ? ts.Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation + : ts.Diagnostics.The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation; + return grammarErrorOnNode(firstDeclaration, diagnostic); + } + } + } + return false; + } + function checkGrammarAccessor(accessor) { + if (!(accessor.flags & 16777216 /* NodeFlags.Ambient */) && (accessor.parent.kind !== 184 /* SyntaxKind.TypeLiteral */) && (accessor.parent.kind !== 261 /* SyntaxKind.InterfaceDeclaration */)) { + if (languageVersion < 1 /* ScriptTarget.ES5 */) { + return grammarErrorOnNode(accessor.name, ts.Diagnostics.Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher); + } + if (languageVersion < 2 /* ScriptTarget.ES2015 */ && ts.isPrivateIdentifier(accessor.name)) { + return grammarErrorOnNode(accessor.name, ts.Diagnostics.Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher); + } + if (accessor.body === undefined && !ts.hasSyntacticModifier(accessor, 256 /* ModifierFlags.Abstract */)) { + return grammarErrorAtPos(accessor, accessor.end - 1, ";".length, ts.Diagnostics._0_expected, "{"); + } + } + if (accessor.body) { + if (ts.hasSyntacticModifier(accessor, 256 /* ModifierFlags.Abstract */)) { + return grammarErrorOnNode(accessor, ts.Diagnostics.An_abstract_accessor_cannot_have_an_implementation); + } + if (accessor.parent.kind === 184 /* SyntaxKind.TypeLiteral */ || accessor.parent.kind === 261 /* SyntaxKind.InterfaceDeclaration */) { + return grammarErrorOnNode(accessor.body, ts.Diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts); + } + } + if (accessor.typeParameters) { + return grammarErrorOnNode(accessor.name, ts.Diagnostics.An_accessor_cannot_have_type_parameters); + } + if (!doesAccessorHaveCorrectParameterCount(accessor)) { + return grammarErrorOnNode(accessor.name, accessor.kind === 174 /* SyntaxKind.GetAccessor */ ? + ts.Diagnostics.A_get_accessor_cannot_have_parameters : + ts.Diagnostics.A_set_accessor_must_have_exactly_one_parameter); + } + if (accessor.kind === 175 /* SyntaxKind.SetAccessor */) { + if (accessor.type) { + return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_set_accessor_cannot_have_a_return_type_annotation); + } + var parameter = ts.Debug.checkDefined(ts.getSetAccessorValueParameter(accessor), "Return value does not match parameter count assertion."); + if (parameter.dotDotDotToken) { + return grammarErrorOnNode(parameter.dotDotDotToken, ts.Diagnostics.A_set_accessor_cannot_have_rest_parameter); + } + if (parameter.questionToken) { + return grammarErrorOnNode(parameter.questionToken, ts.Diagnostics.A_set_accessor_cannot_have_an_optional_parameter); + } + if (parameter.initializer) { + return grammarErrorOnNode(accessor.name, ts.Diagnostics.A_set_accessor_parameter_cannot_have_an_initializer); + } + } + return false; + } + /** Does the accessor have the right number of parameters? + * A get accessor has no parameters or a single `this` parameter. + * A set accessor has one parameter or a `this` parameter and one more parameter. + */ + function doesAccessorHaveCorrectParameterCount(accessor) { + return getAccessorThisParameter(accessor) || accessor.parameters.length === (accessor.kind === 174 /* SyntaxKind.GetAccessor */ ? 0 : 1); + } + function getAccessorThisParameter(accessor) { + if (accessor.parameters.length === (accessor.kind === 174 /* SyntaxKind.GetAccessor */ ? 1 : 2)) { + return ts.getThisParameter(accessor); + } + } + function checkGrammarTypeOperatorNode(node) { + if (node.operator === 156 /* SyntaxKind.UniqueKeyword */) { + if (node.type.kind !== 153 /* SyntaxKind.SymbolKeyword */) { + return grammarErrorOnNode(node.type, ts.Diagnostics._0_expected, ts.tokenToString(153 /* SyntaxKind.SymbolKeyword */)); + } + var parent = ts.walkUpParenthesizedTypes(node.parent); + if (ts.isInJSFile(parent) && ts.isJSDocTypeExpression(parent)) { + var host_2 = ts.getJSDocHost(parent); + if (host_2) { + parent = ts.getSingleVariableOfVariableStatement(host_2) || host_2; + } + } + switch (parent.kind) { + case 257 /* SyntaxKind.VariableDeclaration */: + var decl = parent; + if (decl.name.kind !== 79 /* SyntaxKind.Identifier */) { + return grammarErrorOnNode(node, ts.Diagnostics.unique_symbol_types_may_not_be_used_on_a_variable_declaration_with_a_binding_name); + } + if (!ts.isVariableDeclarationInVariableStatement(decl)) { + return grammarErrorOnNode(node, ts.Diagnostics.unique_symbol_types_are_only_allowed_on_variables_in_a_variable_statement); + } + if (!(decl.parent.flags & 2 /* NodeFlags.Const */)) { + return grammarErrorOnNode(parent.name, ts.Diagnostics.A_variable_whose_type_is_a_unique_symbol_type_must_be_const); + } + break; + case 169 /* SyntaxKind.PropertyDeclaration */: + if (!ts.isStatic(parent) || + !ts.hasEffectiveReadonlyModifier(parent)) { + return grammarErrorOnNode(parent.name, ts.Diagnostics.A_property_of_a_class_whose_type_is_a_unique_symbol_type_must_be_both_static_and_readonly); + } + break; + case 168 /* SyntaxKind.PropertySignature */: + if (!ts.hasSyntacticModifier(parent, 64 /* ModifierFlags.Readonly */)) { + return grammarErrorOnNode(parent.name, ts.Diagnostics.A_property_of_an_interface_or_type_literal_whose_type_is_a_unique_symbol_type_must_be_readonly); + } + break; + default: + return grammarErrorOnNode(node, ts.Diagnostics.unique_symbol_types_are_not_allowed_here); + } + } + else if (node.operator === 146 /* SyntaxKind.ReadonlyKeyword */) { + if (node.type.kind !== 185 /* SyntaxKind.ArrayType */ && node.type.kind !== 186 /* SyntaxKind.TupleType */) { + return grammarErrorOnFirstToken(node, ts.Diagnostics.readonly_type_modifier_is_only_permitted_on_array_and_tuple_literal_types, ts.tokenToString(153 /* SyntaxKind.SymbolKeyword */)); + } + } + } + function checkGrammarForInvalidDynamicName(node, message) { + if (isNonBindableDynamicName(node)) { + return grammarErrorOnNode(node, message); + } + } + function checkGrammarMethod(node) { + if (checkGrammarFunctionLikeDeclaration(node)) { + return true; + } + if (node.kind === 171 /* SyntaxKind.MethodDeclaration */) { + if (node.parent.kind === 207 /* SyntaxKind.ObjectLiteralExpression */) { + // We only disallow modifier on a method declaration if it is a property of object-literal-expression + if (node.modifiers && !(node.modifiers.length === 1 && ts.first(node.modifiers).kind === 132 /* SyntaxKind.AsyncKeyword */)) { + return grammarErrorOnFirstToken(node, ts.Diagnostics.Modifiers_cannot_appear_here); + } + else if (checkGrammarForInvalidQuestionMark(node.questionToken, ts.Diagnostics.An_object_member_cannot_be_declared_optional)) { + return true; + } + else if (checkGrammarForInvalidExclamationToken(node.exclamationToken, ts.Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context)) { + return true; + } + else if (node.body === undefined) { + return grammarErrorAtPos(node, node.end - 1, ";".length, ts.Diagnostics._0_expected, "{"); + } + } + if (checkGrammarForGenerator(node)) { + return true; + } + } + if (ts.isClassLike(node.parent)) { + if (languageVersion < 2 /* ScriptTarget.ES2015 */ && ts.isPrivateIdentifier(node.name)) { + return grammarErrorOnNode(node.name, ts.Diagnostics.Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher); + } + // Technically, computed properties in ambient contexts is disallowed + // for property declarations and accessors too, not just methods. + // However, property declarations disallow computed names in general, + // and accessors are not allowed in ambient contexts in general, + // so this error only really matters for methods. + if (node.flags & 16777216 /* NodeFlags.Ambient */) { + return checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_an_ambient_context_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type); + } + else if (node.kind === 171 /* SyntaxKind.MethodDeclaration */ && !node.body) { + return checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_a_method_overload_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type); + } + } + else if (node.parent.kind === 261 /* SyntaxKind.InterfaceDeclaration */) { + return checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type); + } + else if (node.parent.kind === 184 /* SyntaxKind.TypeLiteral */) { + return checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type); + } + } + function checkGrammarBreakOrContinueStatement(node) { + var current = node; + while (current) { + if (ts.isFunctionLikeOrClassStaticBlockDeclaration(current)) { + return grammarErrorOnNode(node, ts.Diagnostics.Jump_target_cannot_cross_function_boundary); + } + switch (current.kind) { + case 253 /* SyntaxKind.LabeledStatement */: + if (node.label && current.label.escapedText === node.label.escapedText) { + // found matching label - verify that label usage is correct + // continue can only target labels that are on iteration statements + var isMisplacedContinueLabel = node.kind === 248 /* SyntaxKind.ContinueStatement */ + && !ts.isIterationStatement(current.statement, /*lookInLabeledStatement*/ true); + if (isMisplacedContinueLabel) { + return grammarErrorOnNode(node, ts.Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement); + } + return false; + } + break; + case 252 /* SyntaxKind.SwitchStatement */: + if (node.kind === 249 /* SyntaxKind.BreakStatement */ && !node.label) { + // unlabeled break within switch statement - ok + return false; + } + break; + default: + if (ts.isIterationStatement(current, /*lookInLabeledStatement*/ false) && !node.label) { + // unlabeled break or continue within iteration statement - ok + return false; + } + break; + } + current = current.parent; + } + if (node.label) { + var message = node.kind === 249 /* SyntaxKind.BreakStatement */ + ? ts.Diagnostics.A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement + : ts.Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement; + return grammarErrorOnNode(node, message); + } + else { + var message = node.kind === 249 /* SyntaxKind.BreakStatement */ + ? ts.Diagnostics.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement + : ts.Diagnostics.A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement; + return grammarErrorOnNode(node, message); + } + } + function checkGrammarBindingElement(node) { + if (node.dotDotDotToken) { + var elements = node.parent.elements; + if (node !== ts.last(elements)) { + return grammarErrorOnNode(node, ts.Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern); + } + checkGrammarForDisallowedTrailingComma(elements, ts.Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma); + if (node.propertyName) { + return grammarErrorOnNode(node.name, ts.Diagnostics.A_rest_element_cannot_have_a_property_name); + } + } + if (node.dotDotDotToken && node.initializer) { + // Error on equals token which immediately precedes the initializer + return grammarErrorAtPos(node, node.initializer.pos - 1, 1, ts.Diagnostics.A_rest_element_cannot_have_an_initializer); + } + } + function isStringOrNumberLiteralExpression(expr) { + return ts.isStringOrNumericLiteralLike(expr) || + expr.kind === 221 /* SyntaxKind.PrefixUnaryExpression */ && expr.operator === 40 /* SyntaxKind.MinusToken */ && + expr.operand.kind === 8 /* SyntaxKind.NumericLiteral */; + } + function isBigIntLiteralExpression(expr) { + return expr.kind === 9 /* SyntaxKind.BigIntLiteral */ || + expr.kind === 221 /* SyntaxKind.PrefixUnaryExpression */ && expr.operator === 40 /* SyntaxKind.MinusToken */ && + expr.operand.kind === 9 /* SyntaxKind.BigIntLiteral */; + } + function isSimpleLiteralEnumReference(expr) { + if ((ts.isPropertyAccessExpression(expr) || (ts.isElementAccessExpression(expr) && isStringOrNumberLiteralExpression(expr.argumentExpression))) && + ts.isEntityNameExpression(expr.expression)) { + return !!(checkExpressionCached(expr).flags & 1024 /* TypeFlags.EnumLiteral */); + } + } + function checkAmbientInitializer(node) { + var initializer = node.initializer; + if (initializer) { + var isInvalidInitializer = !(isStringOrNumberLiteralExpression(initializer) || + isSimpleLiteralEnumReference(initializer) || + initializer.kind === 110 /* SyntaxKind.TrueKeyword */ || initializer.kind === 95 /* SyntaxKind.FalseKeyword */ || + isBigIntLiteralExpression(initializer)); + var isConstOrReadonly = ts.isDeclarationReadonly(node) || ts.isVariableDeclaration(node) && ts.isVarConst(node); + if (isConstOrReadonly && !node.type) { + if (isInvalidInitializer) { + return grammarErrorOnNode(initializer, ts.Diagnostics.A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_reference); + } + } + else { + return grammarErrorOnNode(initializer, ts.Diagnostics.Initializers_are_not_allowed_in_ambient_contexts); + } + } + } + function checkGrammarVariableDeclaration(node) { + if (node.parent.parent.kind !== 246 /* SyntaxKind.ForInStatement */ && node.parent.parent.kind !== 247 /* SyntaxKind.ForOfStatement */) { + if (node.flags & 16777216 /* NodeFlags.Ambient */) { + checkAmbientInitializer(node); + } + else if (!node.initializer) { + if (ts.isBindingPattern(node.name) && !ts.isBindingPattern(node.parent)) { + return grammarErrorOnNode(node, ts.Diagnostics.A_destructuring_declaration_must_have_an_initializer); + } + if (ts.isVarConst(node)) { + return grammarErrorOnNode(node, ts.Diagnostics.const_declarations_must_be_initialized); + } + } + } + if (node.exclamationToken && (node.parent.parent.kind !== 240 /* SyntaxKind.VariableStatement */ || !node.type || node.initializer || node.flags & 16777216 /* NodeFlags.Ambient */)) { + var message = node.initializer + ? ts.Diagnostics.Declarations_with_initializers_cannot_also_have_definite_assignment_assertions + : !node.type + ? ts.Diagnostics.Declarations_with_definite_assignment_assertions_must_also_have_type_annotations + : ts.Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context; + return grammarErrorOnNode(node.exclamationToken, message); + } + if ((moduleKind < ts.ModuleKind.ES2015 || ts.getSourceFileOfNode(node).impliedNodeFormat === ts.ModuleKind.CommonJS) && moduleKind !== ts.ModuleKind.System && + !(node.parent.parent.flags & 16777216 /* NodeFlags.Ambient */) && ts.hasSyntacticModifier(node.parent.parent, 1 /* ModifierFlags.Export */)) { + checkESModuleMarker(node.name); + } + var checkLetConstNames = (ts.isLet(node) || ts.isVarConst(node)); + // 1. LexicalDeclaration : LetOrConst BindingList ; + // It is a Syntax Error if the BoundNames of BindingList contains "let". + // 2. ForDeclaration: ForDeclaration : LetOrConst ForBinding + // It is a Syntax Error if the BoundNames of ForDeclaration contains "let". + // It is a SyntaxError if a VariableDeclaration or VariableDeclarationNoIn occurs within strict code + // and its Identifier is eval or arguments + return checkLetConstNames && checkGrammarNameInLetOrConstDeclarations(node.name); + } + function checkESModuleMarker(name) { + if (name.kind === 79 /* SyntaxKind.Identifier */) { + if (ts.idText(name) === "__esModule") { + return grammarErrorOnNodeSkippedOn("noEmit", name, ts.Diagnostics.Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules); + } + } + else { + var elements = name.elements; + for (var _i = 0, elements_2 = elements; _i < elements_2.length; _i++) { + var element = elements_2[_i]; + if (!ts.isOmittedExpression(element)) { + return checkESModuleMarker(element.name); + } + } + } + return false; + } + function checkGrammarNameInLetOrConstDeclarations(name) { + if (name.kind === 79 /* SyntaxKind.Identifier */) { + if (name.originalKeywordKind === 119 /* SyntaxKind.LetKeyword */) { + return grammarErrorOnNode(name, ts.Diagnostics.let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations); + } + } + else { + var elements = name.elements; + for (var _i = 0, elements_3 = elements; _i < elements_3.length; _i++) { + var element = elements_3[_i]; + if (!ts.isOmittedExpression(element)) { + checkGrammarNameInLetOrConstDeclarations(element.name); + } + } + } + return false; + } + function checkGrammarVariableDeclarationList(declarationList) { + var declarations = declarationList.declarations; + if (checkGrammarForDisallowedTrailingComma(declarationList.declarations)) { + return true; + } + if (!declarationList.declarations.length) { + return grammarErrorAtPos(declarationList, declarations.pos, declarations.end - declarations.pos, ts.Diagnostics.Variable_declaration_list_cannot_be_empty); + } + return false; + } + function allowLetAndConstDeclarations(parent) { + switch (parent.kind) { + case 242 /* SyntaxKind.IfStatement */: + case 243 /* SyntaxKind.DoStatement */: + case 244 /* SyntaxKind.WhileStatement */: + case 251 /* SyntaxKind.WithStatement */: + case 245 /* SyntaxKind.ForStatement */: + case 246 /* SyntaxKind.ForInStatement */: + case 247 /* SyntaxKind.ForOfStatement */: + return false; + case 253 /* SyntaxKind.LabeledStatement */: + return allowLetAndConstDeclarations(parent.parent); + } + return true; + } + function checkGrammarForDisallowedLetOrConstStatement(node) { + if (!allowLetAndConstDeclarations(node.parent)) { + if (ts.isLet(node.declarationList)) { + return grammarErrorOnNode(node, ts.Diagnostics.let_declarations_can_only_be_declared_inside_a_block); + } + else if (ts.isVarConst(node.declarationList)) { + return grammarErrorOnNode(node, ts.Diagnostics.const_declarations_can_only_be_declared_inside_a_block); + } + } + } + function checkGrammarMetaProperty(node) { + var escapedText = node.name.escapedText; + switch (node.keywordToken) { + case 103 /* SyntaxKind.NewKeyword */: + if (escapedText !== "target") { + return grammarErrorOnNode(node.name, ts.Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2, node.name.escapedText, ts.tokenToString(node.keywordToken), "target"); + } + break; + case 100 /* SyntaxKind.ImportKeyword */: + if (escapedText !== "meta") { + return grammarErrorOnNode(node.name, ts.Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2, node.name.escapedText, ts.tokenToString(node.keywordToken), "meta"); + } + break; + } + } + function hasParseDiagnostics(sourceFile) { + return sourceFile.parseDiagnostics.length > 0; + } + function grammarErrorOnFirstToken(node, message, arg0, arg1, arg2) { + var sourceFile = ts.getSourceFileOfNode(node); + if (!hasParseDiagnostics(sourceFile)) { + var span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos); + diagnostics.add(ts.createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2)); + return true; + } + return false; + } + function grammarErrorAtPos(nodeForSourceFile, start, length, message, arg0, arg1, arg2) { + var sourceFile = ts.getSourceFileOfNode(nodeForSourceFile); + if (!hasParseDiagnostics(sourceFile)) { + diagnostics.add(ts.createFileDiagnostic(sourceFile, start, length, message, arg0, arg1, arg2)); + return true; + } + return false; + } + function grammarErrorOnNodeSkippedOn(key, node, message, arg0, arg1, arg2) { + var sourceFile = ts.getSourceFileOfNode(node); + if (!hasParseDiagnostics(sourceFile)) { + errorSkippedOn(key, node, message, arg0, arg1, arg2); + return true; + } + return false; + } + function grammarErrorOnNode(node, message, arg0, arg1, arg2) { + var sourceFile = ts.getSourceFileOfNode(node); + if (!hasParseDiagnostics(sourceFile)) { + diagnostics.add(ts.createDiagnosticForNode(node, message, arg0, arg1, arg2)); + return true; + } + return false; + } + function checkGrammarConstructorTypeParameters(node) { + var jsdocTypeParameters = ts.isInJSFile(node) ? ts.getJSDocTypeParameterDeclarations(node) : undefined; + var range = node.typeParameters || jsdocTypeParameters && ts.firstOrUndefined(jsdocTypeParameters); + if (range) { + var pos = range.pos === range.end ? range.pos : ts.skipTrivia(ts.getSourceFileOfNode(node).text, range.pos); + return grammarErrorAtPos(node, pos, range.end - pos, ts.Diagnostics.Type_parameters_cannot_appear_on_a_constructor_declaration); + } + } + function checkGrammarConstructorTypeAnnotation(node) { + var type = node.type || ts.getEffectiveReturnTypeNode(node); + if (type) { + return grammarErrorOnNode(type, ts.Diagnostics.Type_annotation_cannot_appear_on_a_constructor_declaration); + } + } + function checkGrammarProperty(node) { + if (ts.isComputedPropertyName(node.name) && ts.isBinaryExpression(node.name.expression) && node.name.expression.operatorToken.kind === 101 /* SyntaxKind.InKeyword */) { + return grammarErrorOnNode(node.parent.members[0], ts.Diagnostics.A_mapped_type_may_not_declare_properties_or_methods); + } + if (ts.isClassLike(node.parent)) { + if (ts.isStringLiteral(node.name) && node.name.text === "constructor") { + return grammarErrorOnNode(node.name, ts.Diagnostics.Classes_may_not_have_a_field_named_constructor); + } + if (checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_a_class_property_declaration_must_have_a_simple_literal_type_or_a_unique_symbol_type)) { + return true; + } + if (languageVersion < 2 /* ScriptTarget.ES2015 */ && ts.isPrivateIdentifier(node.name)) { + return grammarErrorOnNode(node.name, ts.Diagnostics.Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher); + } + if (languageVersion < 2 /* ScriptTarget.ES2015 */ && ts.isAutoAccessorPropertyDeclaration(node)) { + return grammarErrorOnNode(node.name, ts.Diagnostics.Properties_with_the_accessor_modifier_are_only_available_when_targeting_ECMAScript_2015_and_higher); + } + if (ts.isAutoAccessorPropertyDeclaration(node) && checkGrammarForInvalidQuestionMark(node.questionToken, ts.Diagnostics.An_accessor_property_cannot_be_declared_optional)) { + return true; + } + } + else if (node.parent.kind === 261 /* SyntaxKind.InterfaceDeclaration */) { + if (checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type)) { + return true; + } + // Interfaces cannot contain property declarations + ts.Debug.assertNode(node, ts.isPropertySignature); + if (node.initializer) { + return grammarErrorOnNode(node.initializer, ts.Diagnostics.An_interface_property_cannot_have_an_initializer); + } + } + else if (ts.isTypeLiteralNode(node.parent)) { + if (checkGrammarForInvalidDynamicName(node.name, ts.Diagnostics.A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type)) { + return true; + } + // Type literals cannot contain property declarations + ts.Debug.assertNode(node, ts.isPropertySignature); + if (node.initializer) { + return grammarErrorOnNode(node.initializer, ts.Diagnostics.A_type_literal_property_cannot_have_an_initializer); + } + } + if (node.flags & 16777216 /* NodeFlags.Ambient */) { + checkAmbientInitializer(node); + } + if (ts.isPropertyDeclaration(node) && node.exclamationToken && (!ts.isClassLike(node.parent) || !node.type || node.initializer || + node.flags & 16777216 /* NodeFlags.Ambient */ || ts.isStatic(node) || ts.hasAbstractModifier(node))) { + var message = node.initializer + ? ts.Diagnostics.Declarations_with_initializers_cannot_also_have_definite_assignment_assertions + : !node.type + ? ts.Diagnostics.Declarations_with_definite_assignment_assertions_must_also_have_type_annotations + : ts.Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context; + return grammarErrorOnNode(node.exclamationToken, message); + } + } + function checkGrammarTopLevelElementForRequiredDeclareModifier(node) { + // A declare modifier is required for any top level .d.ts declaration except export=, export default, export as namespace + // interfaces and imports categories: + // + // DeclarationElement: + // ExportAssignment + // export_opt InterfaceDeclaration + // export_opt TypeAliasDeclaration + // export_opt ImportDeclaration + // export_opt ExternalImportDeclaration + // export_opt AmbientDeclaration + // + // TODO: The spec needs to be amended to reflect this grammar. + if (node.kind === 261 /* SyntaxKind.InterfaceDeclaration */ || + node.kind === 262 /* SyntaxKind.TypeAliasDeclaration */ || + node.kind === 269 /* SyntaxKind.ImportDeclaration */ || + node.kind === 268 /* SyntaxKind.ImportEqualsDeclaration */ || + node.kind === 275 /* SyntaxKind.ExportDeclaration */ || + node.kind === 274 /* SyntaxKind.ExportAssignment */ || + node.kind === 267 /* SyntaxKind.NamespaceExportDeclaration */ || + ts.hasSyntacticModifier(node, 2 /* ModifierFlags.Ambient */ | 1 /* ModifierFlags.Export */ | 1024 /* ModifierFlags.Default */)) { + return false; + } + return grammarErrorOnFirstToken(node, ts.Diagnostics.Top_level_declarations_in_d_ts_files_must_start_with_either_a_declare_or_export_modifier); + } + function checkGrammarTopLevelElementsForRequiredDeclareModifier(file) { + for (var _i = 0, _a = file.statements; _i < _a.length; _i++) { + var decl = _a[_i]; + if (ts.isDeclaration(decl) || decl.kind === 240 /* SyntaxKind.VariableStatement */) { + if (checkGrammarTopLevelElementForRequiredDeclareModifier(decl)) { + return true; + } + } + } + return false; + } + function checkGrammarSourceFile(node) { + return !!(node.flags & 16777216 /* NodeFlags.Ambient */) && checkGrammarTopLevelElementsForRequiredDeclareModifier(node); + } + function checkGrammarStatementInAmbientContext(node) { + if (node.flags & 16777216 /* NodeFlags.Ambient */) { + // Find containing block which is either Block, ModuleBlock, SourceFile + var links = getNodeLinks(node); + if (!links.hasReportedStatementInAmbientContext && (ts.isFunctionLike(node.parent) || ts.isAccessor(node.parent))) { + return getNodeLinks(node).hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, ts.Diagnostics.An_implementation_cannot_be_declared_in_ambient_contexts); + } + // We are either parented by another statement, or some sort of block. + // If we're in a block, we only want to really report an error once + // to prevent noisiness. So use a bit on the block to indicate if + // this has already been reported, and don't report if it has. + // + if (node.parent.kind === 238 /* SyntaxKind.Block */ || node.parent.kind === 265 /* SyntaxKind.ModuleBlock */ || node.parent.kind === 308 /* SyntaxKind.SourceFile */) { + var links_2 = getNodeLinks(node.parent); + // Check if the containing block ever report this error + if (!links_2.hasReportedStatementInAmbientContext) { + return links_2.hasReportedStatementInAmbientContext = grammarErrorOnFirstToken(node, ts.Diagnostics.Statements_are_not_allowed_in_ambient_contexts); + } + } + else { + // We must be parented by a statement. If so, there's no need + // to report the error as our parent will have already done it. + // Debug.assert(isStatement(node.parent)); + } + } + return false; + } + function checkGrammarNumericLiteral(node) { + // Grammar checking + if (node.numericLiteralFlags & 32 /* TokenFlags.Octal */) { + var diagnosticMessage = void 0; + if (languageVersion >= 1 /* ScriptTarget.ES5 */) { + diagnosticMessage = ts.Diagnostics.Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_Use_the_syntax_0; + } + else if (ts.isChildOfNodeWithKind(node, 198 /* SyntaxKind.LiteralType */)) { + diagnosticMessage = ts.Diagnostics.Octal_literal_types_must_use_ES2015_syntax_Use_the_syntax_0; + } + else if (ts.isChildOfNodeWithKind(node, 302 /* SyntaxKind.EnumMember */)) { + diagnosticMessage = ts.Diagnostics.Octal_literals_are_not_allowed_in_enums_members_initializer_Use_the_syntax_0; + } + if (diagnosticMessage) { + var withMinus = ts.isPrefixUnaryExpression(node.parent) && node.parent.operator === 40 /* SyntaxKind.MinusToken */; + var literal = (withMinus ? "-" : "") + "0o" + node.text; + return grammarErrorOnNode(withMinus ? node.parent : node, diagnosticMessage, literal); + } + } + // Realism (size) checking + checkNumericLiteralValueSize(node); + return false; + } + function checkNumericLiteralValueSize(node) { + // We should test against `getTextOfNode(node)` rather than `node.text`, because `node.text` for large numeric literals can contain "." + // e.g. `node.text` for numeric literal `1100000000000000000000` is `1.1e21`. + var isFractional = ts.getTextOfNode(node).indexOf(".") !== -1; + var isScientific = node.numericLiteralFlags & 16 /* TokenFlags.Scientific */; + // Scientific notation (e.g. 2e54 and 1e00000000010) can't be converted to bigint + // Fractional numbers (e.g. 9000000000000000.001) are inherently imprecise anyway + if (isFractional || isScientific) { + return; + } + // Here `node` is guaranteed to be a numeric literal representing an integer. + // We need to judge whether the integer `node` represents is <= 2 ** 53 - 1, which can be accomplished by comparing to `value` defined below because: + // 1) when `node` represents an integer <= 2 ** 53 - 1, `node.text` is its exact string representation and thus `value` precisely represents the integer. + // 2) otherwise, although `node.text` may be imprecise string representation, its mathematical value and consequently `value` cannot be less than 2 ** 53, + // thus the result of the predicate won't be affected. + var value = +node.text; + if (value <= Math.pow(2, 53) - 1) { + return; + } + addErrorOrSuggestion(/*isError*/ false, ts.createDiagnosticForNode(node, ts.Diagnostics.Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers)); + } + function checkGrammarBigIntLiteral(node) { + var literalType = ts.isLiteralTypeNode(node.parent) || + ts.isPrefixUnaryExpression(node.parent) && ts.isLiteralTypeNode(node.parent.parent); + if (!literalType) { + if (languageVersion < 7 /* ScriptTarget.ES2020 */) { + if (grammarErrorOnNode(node, ts.Diagnostics.BigInt_literals_are_not_available_when_targeting_lower_than_ES2020)) { + return true; + } + } + } + return false; + } + function grammarErrorAfterFirstToken(node, message, arg0, arg1, arg2) { + var sourceFile = ts.getSourceFileOfNode(node); + if (!hasParseDiagnostics(sourceFile)) { + var span = ts.getSpanOfTokenAtPosition(sourceFile, node.pos); + diagnostics.add(ts.createFileDiagnostic(sourceFile, ts.textSpanEnd(span), /*length*/ 0, message, arg0, arg1, arg2)); + return true; + } + return false; + } + function getAmbientModules() { + if (!ambientModulesCache) { + ambientModulesCache = []; + globals.forEach(function (global, sym) { + // No need to `unescapeLeadingUnderscores`, an escaped symbol is never an ambient module. + if (ambientModuleSymbolRegex.test(sym)) { + ambientModulesCache.push(global); + } + }); + } + return ambientModulesCache; + } + function checkGrammarImportClause(node) { + var _a; + if (node.isTypeOnly && node.name && node.namedBindings) { + return grammarErrorOnNode(node, ts.Diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both); + } + if (node.isTypeOnly && ((_a = node.namedBindings) === null || _a === void 0 ? void 0 : _a.kind) === 272 /* SyntaxKind.NamedImports */) { + return checkGrammarNamedImportsOrExports(node.namedBindings); + } + return false; + } + function checkGrammarNamedImportsOrExports(namedBindings) { + return !!ts.forEach(namedBindings.elements, function (specifier) { + if (specifier.isTypeOnly) { + return grammarErrorOnFirstToken(specifier, specifier.kind === 273 /* SyntaxKind.ImportSpecifier */ + ? ts.Diagnostics.The_type_modifier_cannot_be_used_on_a_named_import_when_import_type_is_used_on_its_import_statement + : ts.Diagnostics.The_type_modifier_cannot_be_used_on_a_named_export_when_export_type_is_used_on_its_export_statement); + } + }); + } + function checkGrammarImportCallExpression(node) { + if (moduleKind === ts.ModuleKind.ES2015) { + return grammarErrorOnNode(node, ts.Diagnostics.Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_es2022_esnext_commonjs_amd_system_umd_node16_or_nodenext); + } + if (node.typeArguments) { + return grammarErrorOnNode(node, ts.Diagnostics.This_use_of_import_is_invalid_import_calls_can_be_written_but_they_must_have_parentheses_and_cannot_have_type_arguments); + } + var nodeArguments = node.arguments; + if (moduleKind !== ts.ModuleKind.ESNext && moduleKind !== ts.ModuleKind.NodeNext && moduleKind !== ts.ModuleKind.Node16) { + // We are allowed trailing comma after proposal-import-assertions. + checkGrammarForDisallowedTrailingComma(nodeArguments); + if (nodeArguments.length > 1) { + var assertionArgument = nodeArguments[1]; + return grammarErrorOnNode(assertionArgument, ts.Diagnostics.Dynamic_imports_only_support_a_second_argument_when_the_module_option_is_set_to_esnext_node16_or_nodenext); + } + } + if (nodeArguments.length === 0 || nodeArguments.length > 2) { + return grammarErrorOnNode(node, ts.Diagnostics.Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_assertion_as_arguments); + } + // see: parseArgumentOrArrayLiteralElement...we use this function which parse arguments of callExpression to parse specifier for dynamic import. + // parseArgumentOrArrayLiteralElement allows spread element to be in an argument list which is not allowed as specifier in dynamic import. + var spreadElement = ts.find(nodeArguments, ts.isSpreadElement); + if (spreadElement) { + return grammarErrorOnNode(spreadElement, ts.Diagnostics.Argument_of_dynamic_import_cannot_be_spread_element); + } + return false; + } + function findMatchingTypeReferenceOrTypeAliasReference(source, unionTarget) { + var sourceObjectFlags = ts.getObjectFlags(source); + if (sourceObjectFlags & (4 /* ObjectFlags.Reference */ | 16 /* ObjectFlags.Anonymous */) && unionTarget.flags & 1048576 /* TypeFlags.Union */) { + return ts.find(unionTarget.types, function (target) { + if (target.flags & 524288 /* TypeFlags.Object */) { + var overlapObjFlags = sourceObjectFlags & ts.getObjectFlags(target); + if (overlapObjFlags & 4 /* ObjectFlags.Reference */) { + return source.target === target.target; + } + if (overlapObjFlags & 16 /* ObjectFlags.Anonymous */) { + return !!source.aliasSymbol && source.aliasSymbol === target.aliasSymbol; + } + } + return false; + }); + } + } + function findBestTypeForObjectLiteral(source, unionTarget) { + if (ts.getObjectFlags(source) & 128 /* ObjectFlags.ObjectLiteral */ && someType(unionTarget, isArrayLikeType)) { + return ts.find(unionTarget.types, function (t) { return !isArrayLikeType(t); }); + } + } + function findBestTypeForInvokable(source, unionTarget) { + var signatureKind = 0 /* SignatureKind.Call */; + var hasSignatures = getSignaturesOfType(source, signatureKind).length > 0 || + (signatureKind = 1 /* SignatureKind.Construct */, getSignaturesOfType(source, signatureKind).length > 0); + if (hasSignatures) { + return ts.find(unionTarget.types, function (t) { return getSignaturesOfType(t, signatureKind).length > 0; }); + } + } + function findMostOverlappyType(source, unionTarget) { + var bestMatch; + if (!(source.flags & (131068 /* TypeFlags.Primitive */ | 406847488 /* TypeFlags.InstantiablePrimitive */))) { + var matchingCount = 0; + for (var _i = 0, _a = unionTarget.types; _i < _a.length; _i++) { + var target = _a[_i]; + if (!(target.flags & (131068 /* TypeFlags.Primitive */ | 406847488 /* TypeFlags.InstantiablePrimitive */))) { + var overlap = getIntersectionType([getIndexType(source), getIndexType(target)]); + if (overlap.flags & 4194304 /* TypeFlags.Index */) { + // perfect overlap of keys + return target; + } + else if (isUnitType(overlap) || overlap.flags & 1048576 /* TypeFlags.Union */) { + // We only want to account for literal types otherwise. + // If we have a union of index types, it seems likely that we + // needed to elaborate between two generic mapped types anyway. + var len = overlap.flags & 1048576 /* TypeFlags.Union */ ? ts.countWhere(overlap.types, isUnitType) : 1; + if (len >= matchingCount) { + bestMatch = target; + matchingCount = len; + } + } + } + } + } + return bestMatch; + } + function filterPrimitivesIfContainsNonPrimitive(type) { + if (maybeTypeOfKind(type, 67108864 /* TypeFlags.NonPrimitive */)) { + var result = filterType(type, function (t) { return !(t.flags & 131068 /* TypeFlags.Primitive */); }); + if (!(result.flags & 131072 /* TypeFlags.Never */)) { + return result; + } + } + return type; + } + // Keep this up-to-date with the same logic within `getApparentTypeOfContextualType`, since they should behave similarly + function findMatchingDiscriminantType(source, target, isRelatedTo, skipPartial) { + if (target.flags & 1048576 /* TypeFlags.Union */ && source.flags & (2097152 /* TypeFlags.Intersection */ | 524288 /* TypeFlags.Object */)) { + var match = getMatchingUnionConstituentForType(target, source); + if (match) { + return match; + } + var sourceProperties = getPropertiesOfType(source); + if (sourceProperties) { + var sourcePropertiesFiltered = findDiscriminantProperties(sourceProperties, target); + if (sourcePropertiesFiltered) { + return discriminateTypeByDiscriminableItems(target, ts.map(sourcePropertiesFiltered, function (p) { return [function () { return getTypeOfSymbol(p); }, p.escapedName]; }), isRelatedTo, /*defaultValue*/ undefined, skipPartial); + } + } + } + return undefined; + } + } + ts.createTypeChecker = createTypeChecker; + function isNotAccessor(declaration) { + // Accessors check for their own matching duplicates, and in contexts where they are valid, there are already duplicate identifier checks + return !ts.isAccessor(declaration); + } + function isNotOverload(declaration) { + return (declaration.kind !== 259 /* SyntaxKind.FunctionDeclaration */ && declaration.kind !== 171 /* SyntaxKind.MethodDeclaration */) || + !!declaration.body; + } + /** Like 'isDeclarationName', but returns true for LHS of `import { x as y }` or `export { x as y }`. */ + function isDeclarationNameOrImportPropertyName(name) { + switch (name.parent.kind) { + case 273 /* SyntaxKind.ImportSpecifier */: + case 278 /* SyntaxKind.ExportSpecifier */: + return ts.isIdentifier(name); + default: + return ts.isDeclarationName(name); + } + } + var JsxNames; + (function (JsxNames) { + JsxNames.JSX = "JSX"; + JsxNames.IntrinsicElements = "IntrinsicElements"; + JsxNames.ElementClass = "ElementClass"; + JsxNames.ElementAttributesPropertyNameContainer = "ElementAttributesProperty"; // TODO: Deprecate and remove support + JsxNames.ElementChildrenAttributeNameContainer = "ElementChildrenAttribute"; + JsxNames.Element = "Element"; + JsxNames.IntrinsicAttributes = "IntrinsicAttributes"; + JsxNames.IntrinsicClassAttributes = "IntrinsicClassAttributes"; + JsxNames.LibraryManagedAttributes = "LibraryManagedAttributes"; + })(JsxNames || (JsxNames = {})); + function getIterationTypesKeyFromIterationTypeKind(typeKind) { + switch (typeKind) { + case 0 /* IterationTypeKind.Yield */: return "yieldType"; + case 1 /* IterationTypeKind.Return */: return "returnType"; + case 2 /* IterationTypeKind.Next */: return "nextType"; + } + } + function signatureHasRestParameter(s) { + return !!(s.flags & 1 /* SignatureFlags.HasRestParameter */); + } + ts.signatureHasRestParameter = signatureHasRestParameter; + function signatureHasLiteralTypes(s) { + return !!(s.flags & 2 /* SignatureFlags.HasLiteralTypes */); + } + ts.signatureHasLiteralTypes = signatureHasLiteralTypes; +})(ts || (ts = {})); +var ts; +(function (ts) { + var _a; + function visitNode(node, visitor, test, lift) { + if (node === undefined || visitor === undefined) { + return node; + } + var visited = visitor(node); + if (visited === node) { + return node; + } + var visitedNode; + if (visited === undefined) { + return undefined; + } + else if (ts.isArray(visited)) { + visitedNode = (lift || extractSingleNode)(visited); + } + else { + visitedNode = visited; + } + ts.Debug.assertNode(visitedNode, test); + return visitedNode; + } + ts.visitNode = visitNode; + /** + * Visits a NodeArray using the supplied visitor, possibly returning a new NodeArray in its place. + * + * @param nodes The NodeArray to visit. + * @param visitor The callback used to visit a Node. + * @param test A node test to execute for each node. + * @param start An optional value indicating the starting offset at which to start visiting. + * @param count An optional value indicating the maximum number of nodes to visit. + */ + function visitNodes(nodes, visitor, test, start, count) { + if (nodes === undefined || visitor === undefined) { + return nodes; + } + // Ensure start and count have valid values + var length = nodes.length; + if (start === undefined || start < 0) { + start = 0; + } + if (count === undefined || count > length - start) { + count = length - start; + } + var hasTrailingComma; + var pos = -1; + var end = -1; + if (start > 0 || count < length) { + // Since this is a fragment of a node array, we do not copy over the previous location + // and will only copy over `hasTrailingComma` if we are including the last element. + hasTrailingComma = nodes.hasTrailingComma && start + count === length; + } + else { + pos = nodes.pos; + end = nodes.end; + hasTrailingComma = nodes.hasTrailingComma; + } + var updated = visitArrayWorker(nodes, visitor, test, start, count); + if (updated !== nodes) { + // TODO(rbuckton): Remove dependency on `ts.factory` in favor of a provided factory. + var updatedArray = ts.factory.createNodeArray(updated, hasTrailingComma); + ts.setTextRangePosEnd(updatedArray, pos, end); + return updatedArray; + } + return nodes; + } + ts.visitNodes = visitNodes; + function visitArray(nodes, visitor, test, start, count) { + if (nodes === undefined) { + return nodes; + } + // Ensure start and count have valid values + var length = nodes.length; + if (start === undefined || start < 0) { + start = 0; + } + if (count === undefined || count > length - start) { + count = length - start; + } + return visitArrayWorker(nodes, visitor, test, start, count); + } + ts.visitArray = visitArray; + /* @internal */ + function visitArrayWorker(nodes, visitor, test, start, count) { + var updated; + var length = nodes.length; + if (start > 0 || count < length) { + // If we are not visiting all of the original nodes, we must always create a new array. + updated = []; + } + // Visit each original node. + for (var i = 0; i < count; i++) { + var node = nodes[i + start]; + var visited = node !== undefined ? visitor(node) : undefined; + if (updated !== undefined || visited === undefined || visited !== node) { + if (updated === undefined) { + // Ensure we have a copy of `nodes`, up to the current index. + updated = nodes.slice(0, i); + } + if (visited) { + if (ts.isArray(visited)) { + for (var _i = 0, visited_1 = visited; _i < visited_1.length; _i++) { + var visitedNode = visited_1[_i]; + void ts.Debug.assertNode(visitedNode, test); + updated.push(visitedNode); + } + } + else { + void ts.Debug.assertNode(visited, test); + updated.push(visited); + } + } + } + } + return updated !== null && updated !== void 0 ? updated : nodes; + } + /** + * Starts a new lexical environment and visits a statement list, ending the lexical environment + * and merging hoisted declarations upon completion. + */ + function visitLexicalEnvironment(statements, visitor, context, start, ensureUseStrict, nodesVisitor) { + if (nodesVisitor === void 0) { nodesVisitor = visitNodes; } + context.startLexicalEnvironment(); + statements = nodesVisitor(statements, visitor, ts.isStatement, start); + if (ensureUseStrict) + statements = context.factory.ensureUseStrict(statements); + return ts.factory.mergeLexicalEnvironment(statements, context.endLexicalEnvironment()); + } + ts.visitLexicalEnvironment = visitLexicalEnvironment; + function visitParameterList(nodes, visitor, context, nodesVisitor) { + if (nodesVisitor === void 0) { nodesVisitor = visitNodes; } + var updated; + context.startLexicalEnvironment(); + if (nodes) { + context.setLexicalEnvironmentFlags(1 /* LexicalEnvironmentFlags.InParameters */, true); + updated = nodesVisitor(nodes, visitor, ts.isParameterDeclaration); + // As of ES2015, any runtime execution of that occurs in for a parameter (such as evaluating an + // initializer or a binding pattern), occurs in its own lexical scope. As a result, any expression + // that we might transform that introduces a temporary variable would fail as the temporary variable + // exists in a different lexical scope. To address this, we move any binding patterns and initializers + // in a parameter list to the body if we detect a variable being hoisted while visiting a parameter list + // when the emit target is greater than ES2015. + if (context.getLexicalEnvironmentFlags() & 2 /* LexicalEnvironmentFlags.VariablesHoistedInParameters */ && + ts.getEmitScriptTarget(context.getCompilerOptions()) >= 2 /* ScriptTarget.ES2015 */) { + updated = addDefaultValueAssignmentsIfNeeded(updated, context); + } + context.setLexicalEnvironmentFlags(1 /* LexicalEnvironmentFlags.InParameters */, false); + } + context.suspendLexicalEnvironment(); + return updated; + } + ts.visitParameterList = visitParameterList; + function addDefaultValueAssignmentsIfNeeded(parameters, context) { + var result; + for (var i = 0; i < parameters.length; i++) { + var parameter = parameters[i]; + var updated = addDefaultValueAssignmentIfNeeded(parameter, context); + if (result || updated !== parameter) { + if (!result) + result = parameters.slice(0, i); + result[i] = updated; + } + } + if (result) { + return ts.setTextRange(context.factory.createNodeArray(result, parameters.hasTrailingComma), parameters); + } + return parameters; + } + function addDefaultValueAssignmentIfNeeded(parameter, context) { + // A rest parameter cannot have a binding pattern or an initializer, + // so let's just ignore it. + return parameter.dotDotDotToken ? parameter : + ts.isBindingPattern(parameter.name) ? addDefaultValueAssignmentForBindingPattern(parameter, context) : + parameter.initializer ? addDefaultValueAssignmentForInitializer(parameter, parameter.name, parameter.initializer, context) : + parameter; + } + function addDefaultValueAssignmentForBindingPattern(parameter, context) { + var factory = context.factory; + context.addInitializationStatement(factory.createVariableStatement( + /*modifiers*/ undefined, factory.createVariableDeclarationList([ + factory.createVariableDeclaration(parameter.name, + /*exclamationToken*/ undefined, parameter.type, parameter.initializer ? + factory.createConditionalExpression(factory.createStrictEquality(factory.getGeneratedNameForNode(parameter), factory.createVoidZero()), + /*questionToken*/ undefined, parameter.initializer, + /*colonToken*/ undefined, factory.getGeneratedNameForNode(parameter)) : + factory.getGeneratedNameForNode(parameter)), + ]))); + return factory.updateParameterDeclaration(parameter, parameter.modifiers, parameter.dotDotDotToken, factory.getGeneratedNameForNode(parameter), parameter.questionToken, parameter.type, + /*initializer*/ undefined); + } + function addDefaultValueAssignmentForInitializer(parameter, name, initializer, context) { + var factory = context.factory; + context.addInitializationStatement(factory.createIfStatement(factory.createTypeCheck(factory.cloneNode(name), "undefined"), ts.setEmitFlags(ts.setTextRange(factory.createBlock([ + factory.createExpressionStatement(ts.setEmitFlags(ts.setTextRange(factory.createAssignment(ts.setEmitFlags(factory.cloneNode(name), 48 /* EmitFlags.NoSourceMap */), ts.setEmitFlags(initializer, 48 /* EmitFlags.NoSourceMap */ | ts.getEmitFlags(initializer) | 1536 /* EmitFlags.NoComments */)), parameter), 1536 /* EmitFlags.NoComments */)) + ]), parameter), 1 /* EmitFlags.SingleLine */ | 32 /* EmitFlags.NoTrailingSourceMap */ | 384 /* EmitFlags.NoTokenSourceMaps */ | 1536 /* EmitFlags.NoComments */))); + return factory.updateParameterDeclaration(parameter, parameter.modifiers, parameter.dotDotDotToken, parameter.name, parameter.questionToken, parameter.type, + /*initializer*/ undefined); + } + function visitFunctionBody(node, visitor, context, nodeVisitor) { + if (nodeVisitor === void 0) { nodeVisitor = visitNode; } + context.resumeLexicalEnvironment(); + var updated = nodeVisitor(node, visitor, ts.isConciseBody); + var declarations = context.endLexicalEnvironment(); + if (ts.some(declarations)) { + if (!updated) { + return context.factory.createBlock(declarations); + } + var block = context.factory.converters.convertToFunctionBlock(updated); + var statements = ts.factory.mergeLexicalEnvironment(block.statements, declarations); + return context.factory.updateBlock(block, statements); + } + return updated; + } + ts.visitFunctionBody = visitFunctionBody; + function visitIterationBody(body, visitor, context, nodeVisitor) { + if (nodeVisitor === void 0) { nodeVisitor = visitNode; } + context.startBlockScope(); + var updated = nodeVisitor(body, visitor, ts.isStatement, context.factory.liftToBlock); + var declarations = context.endBlockScope(); + if (ts.some(declarations)) { + if (ts.isBlock(updated)) { + declarations.push.apply(declarations, updated.statements); + return context.factory.updateBlock(updated, declarations); + } + declarations.push(updated); + return context.factory.createBlock(declarations); + } + return updated; + } + ts.visitIterationBody = visitIterationBody; + function visitEachChild(node, visitor, context, nodesVisitor, tokenVisitor, nodeVisitor) { + if (nodesVisitor === void 0) { nodesVisitor = visitNodes; } + if (nodeVisitor === void 0) { nodeVisitor = visitNode; } + if (node === undefined) { + return undefined; + } + var fn = visitEachChildTable[node.kind]; + return fn === undefined ? node : fn(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor); + } + ts.visitEachChild = visitEachChild; + // NOTE: Before you can add a new method to `visitEachChildTable`, you must first ensure the `Node` subtype you + // wish to add is defined in the `HasChildren` union in types.ts. + var visitEachChildTable = (_a = {}, + _a[79 /* SyntaxKind.Identifier */] = function visitEachChildOfIdentifier(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { + return context.factory.updateIdentifier(node, nodesVisitor(node.typeArguments, visitor, ts.isTypeNodeOrTypeParameterDeclaration)); + }, + _a[163 /* SyntaxKind.QualifiedName */] = function visitEachChildOfQualifiedName(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateQualifiedName(node, nodeVisitor(node.left, visitor, ts.isEntityName), nodeVisitor(node.right, visitor, ts.isIdentifier)); + }, + _a[164 /* SyntaxKind.ComputedPropertyName */] = function visitEachChildOfComputedPropertyName(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateComputedPropertyName(node, nodeVisitor(node.expression, visitor, ts.isExpression)); + }, + // Signature elements + _a[165 /* SyntaxKind.TypeParameter */] = function visitEachChildOfTypeParameterDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateTypeParameterDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.constraint, visitor, ts.isTypeNode), nodeVisitor(node.default, visitor, ts.isTypeNode)); + }, + _a[166 /* SyntaxKind.Parameter */] = function visitEachChildOfParameterDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) { + return context.factory.updateParameterDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), nodeVisitor(node.dotDotDotToken, tokenVisitor, ts.isDotDotDotToken), nodeVisitor(node.name, visitor, ts.isBindingName), nodeVisitor(node.questionToken, tokenVisitor, ts.isQuestionToken), nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.initializer, visitor, ts.isExpression)); + }, + _a[167 /* SyntaxKind.Decorator */] = function visitEachChildOfDecorator(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateDecorator(node, nodeVisitor(node.expression, visitor, ts.isExpression)); + }, + // Type elements + _a[168 /* SyntaxKind.PropertySignature */] = function visitEachChildOfPropertySignature(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) { + return context.factory.updatePropertySignature(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.questionToken, tokenVisitor, ts.isToken), nodeVisitor(node.type, visitor, ts.isTypeNode)); + }, + _a[169 /* SyntaxKind.PropertyDeclaration */] = function visitEachChildOfPropertyDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) { + var _a; + return context.factory.updatePropertyDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), nodeVisitor(node.name, visitor, ts.isPropertyName), + // QuestionToken and ExclamationToken are mutually exclusive in PropertyDeclaration + nodeVisitor((_a = node.questionToken) !== null && _a !== void 0 ? _a : node.exclamationToken, tokenVisitor, ts.isQuestionOrExclamationToken), nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.initializer, visitor, ts.isExpression)); + }, + _a[170 /* SyntaxKind.MethodSignature */] = function visitEachChildOfMethodSignature(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) { + return context.factory.updateMethodSignature(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.questionToken, tokenVisitor, ts.isQuestionToken), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode)); + }, + _a[171 /* SyntaxKind.MethodDeclaration */] = function visitEachChildOfMethodDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) { + return context.factory.updateMethodDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), nodeVisitor(node.asteriskToken, tokenVisitor, ts.isAsteriskToken), nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.questionToken, tokenVisitor, ts.isQuestionToken), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), nodeVisitor(node.type, visitor, ts.isTypeNode), visitFunctionBody(node.body, visitor, context, nodeVisitor)); + }, + _a[173 /* SyntaxKind.Constructor */] = function visitEachChildOfConstructorDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateConstructorDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), visitParameterList(node.parameters, visitor, context, nodesVisitor), visitFunctionBody(node.body, visitor, context, nodeVisitor)); + }, + _a[174 /* SyntaxKind.GetAccessor */] = function visitEachChildOfGetAccessorDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateGetAccessorDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), nodeVisitor(node.name, visitor, ts.isPropertyName), visitParameterList(node.parameters, visitor, context, nodesVisitor), nodeVisitor(node.type, visitor, ts.isTypeNode), visitFunctionBody(node.body, visitor, context, nodeVisitor)); + }, + _a[175 /* SyntaxKind.SetAccessor */] = function visitEachChildOfSetAccessorDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateSetAccessorDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), nodeVisitor(node.name, visitor, ts.isPropertyName), visitParameterList(node.parameters, visitor, context, nodesVisitor), visitFunctionBody(node.body, visitor, context, nodeVisitor)); + }, + _a[172 /* SyntaxKind.ClassStaticBlockDeclaration */] = function visitEachChildOfClassStaticBlockDeclaration(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + context.startLexicalEnvironment(); + context.suspendLexicalEnvironment(); + return context.factory.updateClassStaticBlockDeclaration(node, visitFunctionBody(node.body, visitor, context, nodeVisitor)); + }, + _a[176 /* SyntaxKind.CallSignature */] = function visitEachChildOfCallSignatureDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateCallSignature(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode)); + }, + _a[177 /* SyntaxKind.ConstructSignature */] = function visitEachChildOfConstructSignatureDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateConstructSignature(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode)); + }, + _a[178 /* SyntaxKind.IndexSignature */] = function visitEachChildOfIndexSignatureDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateIndexSignature(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode)); + }, + // Types + _a[179 /* SyntaxKind.TypePredicate */] = function visitEachChildOfTypePredicateNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateTypePredicateNode(node, nodeVisitor(node.assertsModifier, visitor, ts.isAssertsKeyword), nodeVisitor(node.parameterName, visitor, ts.isIdentifierOrThisTypeNode), nodeVisitor(node.type, visitor, ts.isTypeNode)); + }, + _a[180 /* SyntaxKind.TypeReference */] = function visitEachChildOfTypeReferenceNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateTypeReferenceNode(node, nodeVisitor(node.typeName, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode)); + }, + _a[181 /* SyntaxKind.FunctionType */] = function visitEachChildOfFunctionTypeNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateFunctionTypeNode(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode)); + }, + _a[182 /* SyntaxKind.ConstructorType */] = function visitEachChildOfConstructorTypeNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateConstructorTypeNode(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode)); + }, + _a[183 /* SyntaxKind.TypeQuery */] = function visitEachChildOfTypeQueryNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateTypeQueryNode(node, nodeVisitor(node.exprName, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode)); + }, + _a[184 /* SyntaxKind.TypeLiteral */] = function visitEachChildOfTypeLiteralNode(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { + return context.factory.updateTypeLiteralNode(node, nodesVisitor(node.members, visitor, ts.isTypeElement)); + }, + _a[185 /* SyntaxKind.ArrayType */] = function visitEachChildOfArrayTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateArrayTypeNode(node, nodeVisitor(node.elementType, visitor, ts.isTypeNode)); + }, + _a[186 /* SyntaxKind.TupleType */] = function visitEachChildOfTupleTypeNode(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { + return context.factory.updateTupleTypeNode(node, nodesVisitor(node.elements, visitor, ts.isTypeNode)); + }, + _a[187 /* SyntaxKind.OptionalType */] = function visitEachChildOfOptionalTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateOptionalTypeNode(node, nodeVisitor(node.type, visitor, ts.isTypeNode)); + }, + _a[188 /* SyntaxKind.RestType */] = function visitEachChildOfRestTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateRestTypeNode(node, nodeVisitor(node.type, visitor, ts.isTypeNode)); + }, + _a[189 /* SyntaxKind.UnionType */] = function visitEachChildOfUnionTypeNode(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { + return context.factory.updateUnionTypeNode(node, nodesVisitor(node.types, visitor, ts.isTypeNode)); + }, + _a[190 /* SyntaxKind.IntersectionType */] = function visitEachChildOfIntersectionTypeNode(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { + return context.factory.updateIntersectionTypeNode(node, nodesVisitor(node.types, visitor, ts.isTypeNode)); + }, + _a[191 /* SyntaxKind.ConditionalType */] = function visitEachChildOfConditionalTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateConditionalTypeNode(node, nodeVisitor(node.checkType, visitor, ts.isTypeNode), nodeVisitor(node.extendsType, visitor, ts.isTypeNode), nodeVisitor(node.trueType, visitor, ts.isTypeNode), nodeVisitor(node.falseType, visitor, ts.isTypeNode)); + }, + _a[192 /* SyntaxKind.InferType */] = function visitEachChildOfInferTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateInferTypeNode(node, nodeVisitor(node.typeParameter, visitor, ts.isTypeParameterDeclaration)); + }, + _a[202 /* SyntaxKind.ImportType */] = function visitEachChildOfImportTypeNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateImportTypeNode(node, nodeVisitor(node.argument, visitor, ts.isTypeNode), nodeVisitor(node.assertions, visitor, ts.isImportTypeAssertionContainer), nodeVisitor(node.qualifier, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf); + }, + _a[298 /* SyntaxKind.ImportTypeAssertionContainer */] = function visitEachChildOfImportTypeAssertionContainer(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateImportTypeAssertionContainer(node, nodeVisitor(node.assertClause, visitor, ts.isAssertClause), node.multiLine); + }, + _a[199 /* SyntaxKind.NamedTupleMember */] = function visitEachChildOfNamedTupleMember(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) { + return context.factory.updateNamedTupleMember(node, nodeVisitor(node.dotDotDotToken, tokenVisitor, ts.isDotDotDotToken), nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.questionToken, tokenVisitor, ts.isQuestionToken), nodeVisitor(node.type, visitor, ts.isTypeNode)); + }, + _a[193 /* SyntaxKind.ParenthesizedType */] = function visitEachChildOfParenthesizedType(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateParenthesizedType(node, nodeVisitor(node.type, visitor, ts.isTypeNode)); + }, + _a[195 /* SyntaxKind.TypeOperator */] = function visitEachChildOfTypeOperatorNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateTypeOperatorNode(node, nodeVisitor(node.type, visitor, ts.isTypeNode)); + }, + _a[196 /* SyntaxKind.IndexedAccessType */] = function visitEachChildOfIndexedAccessType(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateIndexedAccessTypeNode(node, nodeVisitor(node.objectType, visitor, ts.isTypeNode), nodeVisitor(node.indexType, visitor, ts.isTypeNode)); + }, + _a[197 /* SyntaxKind.MappedType */] = function visitEachChildOfMappedType(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) { + return context.factory.updateMappedTypeNode(node, nodeVisitor(node.readonlyToken, tokenVisitor, ts.isReadonlyKeywordOrPlusOrMinusToken), nodeVisitor(node.typeParameter, visitor, ts.isTypeParameterDeclaration), nodeVisitor(node.nameType, visitor, ts.isTypeNode), nodeVisitor(node.questionToken, tokenVisitor, ts.isQuestionOrPlusOrMinusToken), nodeVisitor(node.type, visitor, ts.isTypeNode), nodesVisitor(node.members, visitor, ts.isTypeElement)); + }, + _a[198 /* SyntaxKind.LiteralType */] = function visitEachChildOfLiteralTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateLiteralTypeNode(node, nodeVisitor(node.literal, visitor, ts.isExpression)); + }, + _a[200 /* SyntaxKind.TemplateLiteralType */] = function visitEachChildOfTemplateLiteralType(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateTemplateLiteralType(node, nodeVisitor(node.head, visitor, ts.isTemplateHead), nodesVisitor(node.templateSpans, visitor, ts.isTemplateLiteralTypeSpan)); + }, + _a[201 /* SyntaxKind.TemplateLiteralTypeSpan */] = function visitEachChildOfTemplateLiteralTypeSpan(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateTemplateLiteralTypeSpan(node, nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.literal, visitor, ts.isTemplateMiddleOrTemplateTail)); + }, + // Binding patterns + _a[203 /* SyntaxKind.ObjectBindingPattern */] = function visitEachChildOfObjectBindingPattern(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { + return context.factory.updateObjectBindingPattern(node, nodesVisitor(node.elements, visitor, ts.isBindingElement)); + }, + _a[204 /* SyntaxKind.ArrayBindingPattern */] = function visitEachChildOfArrayBindingPattern(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { + return context.factory.updateArrayBindingPattern(node, nodesVisitor(node.elements, visitor, ts.isArrayBindingElement)); + }, + _a[205 /* SyntaxKind.BindingElement */] = function visitEachChildOfBindingElement(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) { + return context.factory.updateBindingElement(node, nodeVisitor(node.dotDotDotToken, tokenVisitor, ts.isDotDotDotToken), nodeVisitor(node.propertyName, visitor, ts.isPropertyName), nodeVisitor(node.name, visitor, ts.isBindingName), nodeVisitor(node.initializer, visitor, ts.isExpression)); + }, + // Expression + _a[206 /* SyntaxKind.ArrayLiteralExpression */] = function visitEachChildOfArrayLiteralExpression(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { + return context.factory.updateArrayLiteralExpression(node, nodesVisitor(node.elements, visitor, ts.isExpression)); + }, + _a[207 /* SyntaxKind.ObjectLiteralExpression */] = function visitEachChildOfObjectLiteralExpression(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { + return context.factory.updateObjectLiteralExpression(node, nodesVisitor(node.properties, visitor, ts.isObjectLiteralElementLike)); + }, + _a[208 /* SyntaxKind.PropertyAccessExpression */] = function visitEachChildOfPropertyAccessExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) { + return ts.isPropertyAccessChain(node) ? + context.factory.updatePropertyAccessChain(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.questionDotToken, tokenVisitor, ts.isQuestionDotToken), nodeVisitor(node.name, visitor, ts.isMemberName)) : + context.factory.updatePropertyAccessExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.name, visitor, ts.isMemberName)); + }, + _a[209 /* SyntaxKind.ElementAccessExpression */] = function visitEachChildOfElementAccessExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) { + return ts.isElementAccessChain(node) ? + context.factory.updateElementAccessChain(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.questionDotToken, tokenVisitor, ts.isQuestionDotToken), nodeVisitor(node.argumentExpression, visitor, ts.isExpression)) : + context.factory.updateElementAccessExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.argumentExpression, visitor, ts.isExpression)); + }, + _a[210 /* SyntaxKind.CallExpression */] = function visitEachChildOfCallExpression(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) { + return ts.isCallChain(node) ? + context.factory.updateCallChain(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.questionDotToken, tokenVisitor, ts.isQuestionDotToken), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression)) : + context.factory.updateCallExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression)); + }, + _a[211 /* SyntaxKind.NewExpression */] = function visitEachChildOfNewExpression(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateNewExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression)); + }, + _a[212 /* SyntaxKind.TaggedTemplateExpression */] = function visitEachChildOfTaggedTemplateExpression(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateTaggedTemplateExpression(node, nodeVisitor(node.tag, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.template, visitor, ts.isTemplateLiteral)); + }, + _a[213 /* SyntaxKind.TypeAssertionExpression */] = function visitEachChildOfTypeAssertionExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateTypeAssertion(node, nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.expression, visitor, ts.isExpression)); + }, + _a[214 /* SyntaxKind.ParenthesizedExpression */] = function visitEachChildOfParenthesizedExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateParenthesizedExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression)); + }, + _a[215 /* SyntaxKind.FunctionExpression */] = function visitEachChildOfFunctionExpression(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) { + return context.factory.updateFunctionExpression(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.asteriskToken, tokenVisitor, ts.isAsteriskToken), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), nodeVisitor(node.type, visitor, ts.isTypeNode), visitFunctionBody(node.body, visitor, context, nodeVisitor)); + }, + _a[216 /* SyntaxKind.ArrowFunction */] = function visitEachChildOfArrowFunction(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) { + return context.factory.updateArrowFunction(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.equalsGreaterThanToken, tokenVisitor, ts.isEqualsGreaterThanToken), visitFunctionBody(node.body, visitor, context, nodeVisitor)); + }, + _a[217 /* SyntaxKind.DeleteExpression */] = function visitEachChildOfDeleteExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateDeleteExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression)); + }, + _a[218 /* SyntaxKind.TypeOfExpression */] = function visitEachChildOfTypeOfExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateTypeOfExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression)); + }, + _a[219 /* SyntaxKind.VoidExpression */] = function visitEachChildOfVoidExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateVoidExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression)); + }, + _a[220 /* SyntaxKind.AwaitExpression */] = function visitEachChildOfAwaitExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateAwaitExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression)); + }, + _a[221 /* SyntaxKind.PrefixUnaryExpression */] = function visitEachChildOfPrefixUnaryExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updatePrefixUnaryExpression(node, nodeVisitor(node.operand, visitor, ts.isExpression)); + }, + _a[222 /* SyntaxKind.PostfixUnaryExpression */] = function visitEachChildOfPostfixUnaryExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updatePostfixUnaryExpression(node, nodeVisitor(node.operand, visitor, ts.isExpression)); + }, + _a[223 /* SyntaxKind.BinaryExpression */] = function visitEachChildOfBinaryExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) { + return context.factory.updateBinaryExpression(node, nodeVisitor(node.left, visitor, ts.isExpression), nodeVisitor(node.operatorToken, tokenVisitor, ts.isBinaryOperatorToken), nodeVisitor(node.right, visitor, ts.isExpression)); + }, + _a[224 /* SyntaxKind.ConditionalExpression */] = function visitEachChildOfConditionalExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) { + return context.factory.updateConditionalExpression(node, nodeVisitor(node.condition, visitor, ts.isExpression), nodeVisitor(node.questionToken, tokenVisitor, ts.isQuestionToken), nodeVisitor(node.whenTrue, visitor, ts.isExpression), nodeVisitor(node.colonToken, tokenVisitor, ts.isColonToken), nodeVisitor(node.whenFalse, visitor, ts.isExpression)); + }, + _a[225 /* SyntaxKind.TemplateExpression */] = function visitEachChildOfTemplateExpression(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateTemplateExpression(node, nodeVisitor(node.head, visitor, ts.isTemplateHead), nodesVisitor(node.templateSpans, visitor, ts.isTemplateSpan)); + }, + _a[226 /* SyntaxKind.YieldExpression */] = function visitEachChildOfYieldExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) { + return context.factory.updateYieldExpression(node, nodeVisitor(node.asteriskToken, tokenVisitor, ts.isAsteriskToken), nodeVisitor(node.expression, visitor, ts.isExpression)); + }, + _a[227 /* SyntaxKind.SpreadElement */] = function visitEachChildOfSpreadElement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateSpreadElement(node, nodeVisitor(node.expression, visitor, ts.isExpression)); + }, + _a[228 /* SyntaxKind.ClassExpression */] = function visitEachChildOfClassExpression(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateClassExpression(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.heritageClauses, visitor, ts.isHeritageClause), nodesVisitor(node.members, visitor, ts.isClassElement)); + }, + _a[230 /* SyntaxKind.ExpressionWithTypeArguments */] = function visitEachChildOfExpressionWithTypeArguments(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateExpressionWithTypeArguments(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode)); + }, + _a[231 /* SyntaxKind.AsExpression */] = function visitEachChildOfAsExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateAsExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.type, visitor, ts.isTypeNode)); + }, + _a[235 /* SyntaxKind.SatisfiesExpression */] = function visitEachChildOfSatisfiesExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateSatisfiesExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.type, visitor, ts.isTypeNode)); + }, + _a[232 /* SyntaxKind.NonNullExpression */] = function visitEachChildOfNonNullExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return ts.isOptionalChain(node) ? + context.factory.updateNonNullChain(node, nodeVisitor(node.expression, visitor, ts.isExpression)) : + context.factory.updateNonNullExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression)); + }, + _a[233 /* SyntaxKind.MetaProperty */] = function visitEachChildOfMetaProperty(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateMetaProperty(node, nodeVisitor(node.name, visitor, ts.isIdentifier)); + }, + // Misc + _a[236 /* SyntaxKind.TemplateSpan */] = function visitEachChildOfTemplateSpan(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateTemplateSpan(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.literal, visitor, ts.isTemplateMiddleOrTemplateTail)); + }, + // Element + _a[238 /* SyntaxKind.Block */] = function visitEachChildOfBlock(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { + return context.factory.updateBlock(node, nodesVisitor(node.statements, visitor, ts.isStatement)); + }, + _a[240 /* SyntaxKind.VariableStatement */] = function visitEachChildOfVariableStatement(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateVariableStatement(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.declarationList, visitor, ts.isVariableDeclarationList)); + }, + _a[241 /* SyntaxKind.ExpressionStatement */] = function visitEachChildOfExpressionStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateExpressionStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression)); + }, + _a[242 /* SyntaxKind.IfStatement */] = function visitEachChildOfIfStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateIfStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.thenStatement, visitor, ts.isStatement, context.factory.liftToBlock), nodeVisitor(node.elseStatement, visitor, ts.isStatement, context.factory.liftToBlock)); + }, + _a[243 /* SyntaxKind.DoStatement */] = function visitEachChildOfDoStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateDoStatement(node, visitIterationBody(node.statement, visitor, context, nodeVisitor), nodeVisitor(node.expression, visitor, ts.isExpression)); + }, + _a[244 /* SyntaxKind.WhileStatement */] = function visitEachChildOfWhileStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateWhileStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression), visitIterationBody(node.statement, visitor, context, nodeVisitor)); + }, + _a[245 /* SyntaxKind.ForStatement */] = function visitEachChildOfForStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateForStatement(node, nodeVisitor(node.initializer, visitor, ts.isForInitializer), nodeVisitor(node.condition, visitor, ts.isExpression), nodeVisitor(node.incrementor, visitor, ts.isExpression), visitIterationBody(node.statement, visitor, context, nodeVisitor)); + }, + _a[246 /* SyntaxKind.ForInStatement */] = function visitEachChildOfForInStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateForInStatement(node, nodeVisitor(node.initializer, visitor, ts.isForInitializer), nodeVisitor(node.expression, visitor, ts.isExpression), visitIterationBody(node.statement, visitor, context, nodeVisitor)); + }, + _a[247 /* SyntaxKind.ForOfStatement */] = function visitEachChildOfForOfStatement(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) { + return context.factory.updateForOfStatement(node, nodeVisitor(node.awaitModifier, tokenVisitor, ts.isAwaitKeyword), nodeVisitor(node.initializer, visitor, ts.isForInitializer), nodeVisitor(node.expression, visitor, ts.isExpression), visitIterationBody(node.statement, visitor, context, nodeVisitor)); + }, + _a[248 /* SyntaxKind.ContinueStatement */] = function visitEachChildOfContinueStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateContinueStatement(node, nodeVisitor(node.label, visitor, ts.isIdentifier)); + }, + _a[249 /* SyntaxKind.BreakStatement */] = function visitEachChildOfBreakStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateBreakStatement(node, nodeVisitor(node.label, visitor, ts.isIdentifier)); + }, + _a[250 /* SyntaxKind.ReturnStatement */] = function visitEachChildOfReturnStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateReturnStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression)); + }, + _a[251 /* SyntaxKind.WithStatement */] = function visitEachChildOfWithStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateWithStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.statement, visitor, ts.isStatement, context.factory.liftToBlock)); + }, + _a[252 /* SyntaxKind.SwitchStatement */] = function visitEachChildOfSwitchStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateSwitchStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.caseBlock, visitor, ts.isCaseBlock)); + }, + _a[253 /* SyntaxKind.LabeledStatement */] = function visitEachChildOfLabeledStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateLabeledStatement(node, nodeVisitor(node.label, visitor, ts.isIdentifier), nodeVisitor(node.statement, visitor, ts.isStatement, context.factory.liftToBlock)); + }, + _a[254 /* SyntaxKind.ThrowStatement */] = function visitEachChildOfThrowStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateThrowStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression)); + }, + _a[255 /* SyntaxKind.TryStatement */] = function visitEachChildOfTryStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateTryStatement(node, nodeVisitor(node.tryBlock, visitor, ts.isBlock), nodeVisitor(node.catchClause, visitor, ts.isCatchClause), nodeVisitor(node.finallyBlock, visitor, ts.isBlock)); + }, + _a[257 /* SyntaxKind.VariableDeclaration */] = function visitEachChildOfVariableDeclaration(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) { + return context.factory.updateVariableDeclaration(node, nodeVisitor(node.name, visitor, ts.isBindingName), nodeVisitor(node.exclamationToken, tokenVisitor, ts.isExclamationToken), nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.initializer, visitor, ts.isExpression)); + }, + _a[258 /* SyntaxKind.VariableDeclarationList */] = function visitEachChildOfVariableDeclarationList(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { + return context.factory.updateVariableDeclarationList(node, nodesVisitor(node.declarations, visitor, ts.isVariableDeclaration)); + }, + _a[259 /* SyntaxKind.FunctionDeclaration */] = function visitEachChildOfFunctionDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) { + return context.factory.updateFunctionDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.asteriskToken, tokenVisitor, ts.isAsteriskToken), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), nodeVisitor(node.type, visitor, ts.isTypeNode), visitFunctionBody(node.body, visitor, context, nodeVisitor)); + }, + _a[260 /* SyntaxKind.ClassDeclaration */] = function visitEachChildOfClassDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateClassDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.heritageClauses, visitor, ts.isHeritageClause), nodesVisitor(node.members, visitor, ts.isClassElement)); + }, + _a[261 /* SyntaxKind.InterfaceDeclaration */] = function visitEachChildOfInterfaceDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateInterfaceDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.heritageClauses, visitor, ts.isHeritageClause), nodesVisitor(node.members, visitor, ts.isTypeElement)); + }, + _a[262 /* SyntaxKind.TypeAliasDeclaration */] = function visitEachChildOfTypeAliasDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateTypeAliasDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode)); + }, + _a[263 /* SyntaxKind.EnumDeclaration */] = function visitEachChildOfEnumDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateEnumDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.members, visitor, ts.isEnumMember)); + }, + _a[264 /* SyntaxKind.ModuleDeclaration */] = function visitEachChildOfModuleDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateModuleDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isModuleName), nodeVisitor(node.body, visitor, ts.isModuleBody)); + }, + _a[265 /* SyntaxKind.ModuleBlock */] = function visitEachChildOfModuleBlock(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { + return context.factory.updateModuleBlock(node, nodesVisitor(node.statements, visitor, ts.isStatement)); + }, + _a[266 /* SyntaxKind.CaseBlock */] = function visitEachChildOfCaseBlock(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { + return context.factory.updateCaseBlock(node, nodesVisitor(node.clauses, visitor, ts.isCaseOrDefaultClause)); + }, + _a[267 /* SyntaxKind.NamespaceExportDeclaration */] = function visitEachChildOfNamespaceExportDeclaration(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateNamespaceExportDeclaration(node, nodeVisitor(node.name, visitor, ts.isIdentifier)); + }, + _a[268 /* SyntaxKind.ImportEqualsDeclaration */] = function visitEachChildOfImportEqualsDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateImportEqualsDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), node.isTypeOnly, nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.moduleReference, visitor, ts.isModuleReference)); + }, + _a[269 /* SyntaxKind.ImportDeclaration */] = function visitEachChildOfImportDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateImportDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.importClause, visitor, ts.isImportClause), nodeVisitor(node.moduleSpecifier, visitor, ts.isExpression), nodeVisitor(node.assertClause, visitor, ts.isAssertClause)); + }, + _a[296 /* SyntaxKind.AssertClause */] = function visitEachChildOfAssertClause(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { + return context.factory.updateAssertClause(node, nodesVisitor(node.elements, visitor, ts.isAssertEntry), node.multiLine); + }, + _a[297 /* SyntaxKind.AssertEntry */] = function visitEachChildOfAssertEntry(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateAssertEntry(node, nodeVisitor(node.name, visitor, ts.isAssertionKey), nodeVisitor(node.value, visitor, ts.isExpression)); + }, + _a[270 /* SyntaxKind.ImportClause */] = function visitEachChildOfImportClause(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateImportClause(node, node.isTypeOnly, nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.namedBindings, visitor, ts.isNamedImportBindings)); + }, + _a[271 /* SyntaxKind.NamespaceImport */] = function visitEachChildOfNamespaceImport(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateNamespaceImport(node, nodeVisitor(node.name, visitor, ts.isIdentifier)); + }, + _a[277 /* SyntaxKind.NamespaceExport */] = function visitEachChildOfNamespaceExport(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateNamespaceExport(node, nodeVisitor(node.name, visitor, ts.isIdentifier)); + }, + _a[272 /* SyntaxKind.NamedImports */] = function visitEachChildOfNamedImports(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { + return context.factory.updateNamedImports(node, nodesVisitor(node.elements, visitor, ts.isImportSpecifier)); + }, + _a[273 /* SyntaxKind.ImportSpecifier */] = function visitEachChildOfImportSpecifier(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateImportSpecifier(node, node.isTypeOnly, nodeVisitor(node.propertyName, visitor, ts.isIdentifier), nodeVisitor(node.name, visitor, ts.isIdentifier)); + }, + _a[274 /* SyntaxKind.ExportAssignment */] = function visitEachChildOfExportAssignment(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateExportAssignment(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.expression, visitor, ts.isExpression)); + }, + _a[275 /* SyntaxKind.ExportDeclaration */] = function visitEachChildOfExportDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateExportDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), node.isTypeOnly, nodeVisitor(node.exportClause, visitor, ts.isNamedExportBindings), nodeVisitor(node.moduleSpecifier, visitor, ts.isExpression), nodeVisitor(node.assertClause, visitor, ts.isAssertClause)); + }, + _a[276 /* SyntaxKind.NamedExports */] = function visitEachChildOfNamedExports(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { + return context.factory.updateNamedExports(node, nodesVisitor(node.elements, visitor, ts.isExportSpecifier)); + }, + _a[278 /* SyntaxKind.ExportSpecifier */] = function visitEachChildOfExportSpecifier(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateExportSpecifier(node, node.isTypeOnly, nodeVisitor(node.propertyName, visitor, ts.isIdentifier), nodeVisitor(node.name, visitor, ts.isIdentifier)); + }, + // Module references + _a[280 /* SyntaxKind.ExternalModuleReference */] = function visitEachChildOfExternalModuleReference(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateExternalModuleReference(node, nodeVisitor(node.expression, visitor, ts.isExpression)); + }, + // JSX + _a[281 /* SyntaxKind.JsxElement */] = function visitEachChildOfJsxElement(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateJsxElement(node, nodeVisitor(node.openingElement, visitor, ts.isJsxOpeningElement), nodesVisitor(node.children, visitor, ts.isJsxChild), nodeVisitor(node.closingElement, visitor, ts.isJsxClosingElement)); + }, + _a[282 /* SyntaxKind.JsxSelfClosingElement */] = function visitEachChildOfJsxSelfClosingElement(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateJsxSelfClosingElement(node, nodeVisitor(node.tagName, visitor, ts.isJsxTagNameExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.attributes, visitor, ts.isJsxAttributes)); + }, + _a[283 /* SyntaxKind.JsxOpeningElement */] = function visitEachChildOfJsxOpeningElement(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateJsxOpeningElement(node, nodeVisitor(node.tagName, visitor, ts.isJsxTagNameExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.attributes, visitor, ts.isJsxAttributes)); + }, + _a[284 /* SyntaxKind.JsxClosingElement */] = function visitEachChildOfJsxClosingElement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateJsxClosingElement(node, nodeVisitor(node.tagName, visitor, ts.isJsxTagNameExpression)); + }, + _a[285 /* SyntaxKind.JsxFragment */] = function visitEachChildOfJsxFragment(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateJsxFragment(node, nodeVisitor(node.openingFragment, visitor, ts.isJsxOpeningFragment), nodesVisitor(node.children, visitor, ts.isJsxChild), nodeVisitor(node.closingFragment, visitor, ts.isJsxClosingFragment)); + }, + _a[288 /* SyntaxKind.JsxAttribute */] = function visitEachChildOfJsxAttribute(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateJsxAttribute(node, nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.initializer, visitor, ts.isStringLiteralOrJsxExpression)); + }, + _a[289 /* SyntaxKind.JsxAttributes */] = function visitEachChildOfJsxAttributes(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { + return context.factory.updateJsxAttributes(node, nodesVisitor(node.properties, visitor, ts.isJsxAttributeLike)); + }, + _a[290 /* SyntaxKind.JsxSpreadAttribute */] = function visitEachChildOfJsxSpreadAttribute(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateJsxSpreadAttribute(node, nodeVisitor(node.expression, visitor, ts.isExpression)); + }, + _a[291 /* SyntaxKind.JsxExpression */] = function visitEachChildOfJsxExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateJsxExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression)); + }, + // Clauses + _a[292 /* SyntaxKind.CaseClause */] = function visitEachChildOfCaseClause(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateCaseClause(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.statements, visitor, ts.isStatement)); + }, + _a[293 /* SyntaxKind.DefaultClause */] = function visitEachChildOfDefaultClause(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { + return context.factory.updateDefaultClause(node, nodesVisitor(node.statements, visitor, ts.isStatement)); + }, + _a[294 /* SyntaxKind.HeritageClause */] = function visitEachChildOfHeritageClause(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { + return context.factory.updateHeritageClause(node, nodesVisitor(node.types, visitor, ts.isExpressionWithTypeArguments)); + }, + _a[295 /* SyntaxKind.CatchClause */] = function visitEachChildOfCatchClause(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateCatchClause(node, nodeVisitor(node.variableDeclaration, visitor, ts.isVariableDeclaration), nodeVisitor(node.block, visitor, ts.isBlock)); + }, + // Property assignments + _a[299 /* SyntaxKind.PropertyAssignment */] = function visitEachChildOfPropertyAssignment(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updatePropertyAssignment(node, nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.initializer, visitor, ts.isExpression)); + }, + _a[300 /* SyntaxKind.ShorthandPropertyAssignment */] = function visitEachChildOfShorthandPropertyAssignment(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateShorthandPropertyAssignment(node, nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.objectAssignmentInitializer, visitor, ts.isExpression)); + }, + _a[301 /* SyntaxKind.SpreadAssignment */] = function visitEachChildOfSpreadAssignment(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateSpreadAssignment(node, nodeVisitor(node.expression, visitor, ts.isExpression)); + }, + // Enum + _a[302 /* SyntaxKind.EnumMember */] = function visitEachChildOfEnumMember(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updateEnumMember(node, nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.initializer, visitor, ts.isExpression)); + }, + // Top-level nodes + _a[308 /* SyntaxKind.SourceFile */] = function visitEachChildOfSourceFile(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { + return context.factory.updateSourceFile(node, visitLexicalEnvironment(node.statements, visitor, context, /*start*/ undefined, /*ensureUseStrict*/ undefined, nodesVisitor)); + }, + // Transformation nodes + _a[353 /* SyntaxKind.PartiallyEmittedExpression */] = function visitEachChildOfPartiallyEmittedExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) { + return context.factory.updatePartiallyEmittedExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression)); + }, + _a[354 /* SyntaxKind.CommaListExpression */] = function visitEachChildOfCommaListExpression(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) { + return context.factory.updateCommaListExpression(node, nodesVisitor(node.elements, visitor, ts.isExpression)); + }, + _a); + /** + * Extracts the single node from a NodeArray. + * + * @param nodes The NodeArray. + */ + function extractSingleNode(nodes) { + ts.Debug.assert(nodes.length <= 1, "Too many nodes written to output."); + return ts.singleOrUndefined(nodes); + } +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + function createSourceMapGenerator(host, file, sourceRoot, sourcesDirectoryPath, generatorOptions) { + var _a = generatorOptions.extendedDiagnostics + ? ts.performance.createTimer("Source Map", "beforeSourcemap", "afterSourcemap") + : ts.performance.nullTimer, enter = _a.enter, exit = _a.exit; + // Current source map file and its index in the sources list + var rawSources = []; + var sources = []; + var sourceToSourceIndexMap = new ts.Map(); + var sourcesContent; + var names = []; + var nameToNameIndexMap; + var mappingCharCodes = []; + var mappings = ""; + // Last recorded and encoded mappings + var lastGeneratedLine = 0; + var lastGeneratedCharacter = 0; + var lastSourceIndex = 0; + var lastSourceLine = 0; + var lastSourceCharacter = 0; + var lastNameIndex = 0; + var hasLast = false; + var pendingGeneratedLine = 0; + var pendingGeneratedCharacter = 0; + var pendingSourceIndex = 0; + var pendingSourceLine = 0; + var pendingSourceCharacter = 0; + var pendingNameIndex = 0; + var hasPending = false; + var hasPendingSource = false; + var hasPendingName = false; + return { + getSources: function () { return rawSources; }, + addSource: addSource, + setSourceContent: setSourceContent, + addName: addName, + addMapping: addMapping, + appendSourceMap: appendSourceMap, + toJSON: toJSON, + toString: function () { return JSON.stringify(toJSON()); } + }; + function addSource(fileName) { + enter(); + var source = ts.getRelativePathToDirectoryOrUrl(sourcesDirectoryPath, fileName, host.getCurrentDirectory(), host.getCanonicalFileName, + /*isAbsolutePathAnUrl*/ true); + var sourceIndex = sourceToSourceIndexMap.get(source); + if (sourceIndex === undefined) { + sourceIndex = sources.length; + sources.push(source); + rawSources.push(fileName); + sourceToSourceIndexMap.set(source, sourceIndex); + } + exit(); + return sourceIndex; + } + /* eslint-disable local/boolean-trivia, no-null/no-null */ + function setSourceContent(sourceIndex, content) { + enter(); + if (content !== null) { + if (!sourcesContent) + sourcesContent = []; + while (sourcesContent.length < sourceIndex) { + sourcesContent.push(null); + } + sourcesContent[sourceIndex] = content; + } + exit(); + } + /* eslint-enable local/boolean-trivia, no-null/no-null */ + function addName(name) { + enter(); + if (!nameToNameIndexMap) + nameToNameIndexMap = new ts.Map(); + var nameIndex = nameToNameIndexMap.get(name); + if (nameIndex === undefined) { + nameIndex = names.length; + names.push(name); + nameToNameIndexMap.set(name, nameIndex); + } + exit(); + return nameIndex; + } + function isNewGeneratedPosition(generatedLine, generatedCharacter) { + return !hasPending + || pendingGeneratedLine !== generatedLine + || pendingGeneratedCharacter !== generatedCharacter; + } + function isBacktrackingSourcePosition(sourceIndex, sourceLine, sourceCharacter) { + return sourceIndex !== undefined + && sourceLine !== undefined + && sourceCharacter !== undefined + && pendingSourceIndex === sourceIndex + && (pendingSourceLine > sourceLine + || pendingSourceLine === sourceLine && pendingSourceCharacter > sourceCharacter); + } + function addMapping(generatedLine, generatedCharacter, sourceIndex, sourceLine, sourceCharacter, nameIndex) { + ts.Debug.assert(generatedLine >= pendingGeneratedLine, "generatedLine cannot backtrack"); + ts.Debug.assert(generatedCharacter >= 0, "generatedCharacter cannot be negative"); + ts.Debug.assert(sourceIndex === undefined || sourceIndex >= 0, "sourceIndex cannot be negative"); + ts.Debug.assert(sourceLine === undefined || sourceLine >= 0, "sourceLine cannot be negative"); + ts.Debug.assert(sourceCharacter === undefined || sourceCharacter >= 0, "sourceCharacter cannot be negative"); + enter(); + // If this location wasn't recorded or the location in source is going backwards, record the mapping + if (isNewGeneratedPosition(generatedLine, generatedCharacter) || + isBacktrackingSourcePosition(sourceIndex, sourceLine, sourceCharacter)) { + commitPendingMapping(); + pendingGeneratedLine = generatedLine; + pendingGeneratedCharacter = generatedCharacter; + hasPendingSource = false; + hasPendingName = false; + hasPending = true; + } + if (sourceIndex !== undefined && sourceLine !== undefined && sourceCharacter !== undefined) { + pendingSourceIndex = sourceIndex; + pendingSourceLine = sourceLine; + pendingSourceCharacter = sourceCharacter; + hasPendingSource = true; + if (nameIndex !== undefined) { + pendingNameIndex = nameIndex; + hasPendingName = true; + } + } + exit(); + } + function appendSourceMap(generatedLine, generatedCharacter, map, sourceMapPath, start, end) { + ts.Debug.assert(generatedLine >= pendingGeneratedLine, "generatedLine cannot backtrack"); + ts.Debug.assert(generatedCharacter >= 0, "generatedCharacter cannot be negative"); + enter(); + // First, decode the old component sourcemap + var sourceIndexToNewSourceIndexMap = []; + var nameIndexToNewNameIndexMap; + var mappingIterator = decodeMappings(map.mappings); + for (var iterResult = mappingIterator.next(); !iterResult.done; iterResult = mappingIterator.next()) { + var raw = iterResult.value; + if (end && (raw.generatedLine > end.line || + (raw.generatedLine === end.line && raw.generatedCharacter > end.character))) { + break; + } + if (start && (raw.generatedLine < start.line || + (start.line === raw.generatedLine && raw.generatedCharacter < start.character))) { + continue; + } + // Then reencode all the updated mappings into the overall map + var newSourceIndex = void 0; + var newSourceLine = void 0; + var newSourceCharacter = void 0; + var newNameIndex = void 0; + if (raw.sourceIndex !== undefined) { + newSourceIndex = sourceIndexToNewSourceIndexMap[raw.sourceIndex]; + if (newSourceIndex === undefined) { + // Apply offsets to each position and fixup source entries + var rawPath = map.sources[raw.sourceIndex]; + var relativePath = map.sourceRoot ? ts.combinePaths(map.sourceRoot, rawPath) : rawPath; + var combinedPath = ts.combinePaths(ts.getDirectoryPath(sourceMapPath), relativePath); + sourceIndexToNewSourceIndexMap[raw.sourceIndex] = newSourceIndex = addSource(combinedPath); + if (map.sourcesContent && typeof map.sourcesContent[raw.sourceIndex] === "string") { + setSourceContent(newSourceIndex, map.sourcesContent[raw.sourceIndex]); + } + } + newSourceLine = raw.sourceLine; + newSourceCharacter = raw.sourceCharacter; + if (map.names && raw.nameIndex !== undefined) { + if (!nameIndexToNewNameIndexMap) + nameIndexToNewNameIndexMap = []; + newNameIndex = nameIndexToNewNameIndexMap[raw.nameIndex]; + if (newNameIndex === undefined) { + nameIndexToNewNameIndexMap[raw.nameIndex] = newNameIndex = addName(map.names[raw.nameIndex]); + } + } + } + var rawGeneratedLine = raw.generatedLine - (start ? start.line : 0); + var newGeneratedLine = rawGeneratedLine + generatedLine; + var rawGeneratedCharacter = start && start.line === raw.generatedLine ? raw.generatedCharacter - start.character : raw.generatedCharacter; + var newGeneratedCharacter = rawGeneratedLine === 0 ? rawGeneratedCharacter + generatedCharacter : rawGeneratedCharacter; + addMapping(newGeneratedLine, newGeneratedCharacter, newSourceIndex, newSourceLine, newSourceCharacter, newNameIndex); + } + exit(); + } + function shouldCommitMapping() { + return !hasLast + || lastGeneratedLine !== pendingGeneratedLine + || lastGeneratedCharacter !== pendingGeneratedCharacter + || lastSourceIndex !== pendingSourceIndex + || lastSourceLine !== pendingSourceLine + || lastSourceCharacter !== pendingSourceCharacter + || lastNameIndex !== pendingNameIndex; + } + function appendMappingCharCode(charCode) { + mappingCharCodes.push(charCode); + // String.fromCharCode accepts its arguments on the stack, so we have to chunk the input, + // otherwise we can get stack overflows for large source maps + if (mappingCharCodes.length >= 1024) { + flushMappingBuffer(); + } + } + function commitPendingMapping() { + if (!hasPending || !shouldCommitMapping()) { + return; + } + enter(); + // Line/Comma delimiters + if (lastGeneratedLine < pendingGeneratedLine) { + // Emit line delimiters + do { + appendMappingCharCode(59 /* CharacterCodes.semicolon */); + lastGeneratedLine++; + } while (lastGeneratedLine < pendingGeneratedLine); + // Only need to set this once + lastGeneratedCharacter = 0; + } + else { + ts.Debug.assertEqual(lastGeneratedLine, pendingGeneratedLine, "generatedLine cannot backtrack"); + // Emit comma to separate the entry + if (hasLast) { + appendMappingCharCode(44 /* CharacterCodes.comma */); + } + } + // 1. Relative generated character + appendBase64VLQ(pendingGeneratedCharacter - lastGeneratedCharacter); + lastGeneratedCharacter = pendingGeneratedCharacter; + if (hasPendingSource) { + // 2. Relative sourceIndex + appendBase64VLQ(pendingSourceIndex - lastSourceIndex); + lastSourceIndex = pendingSourceIndex; + // 3. Relative source line + appendBase64VLQ(pendingSourceLine - lastSourceLine); + lastSourceLine = pendingSourceLine; + // 4. Relative source character + appendBase64VLQ(pendingSourceCharacter - lastSourceCharacter); + lastSourceCharacter = pendingSourceCharacter; + if (hasPendingName) { + // 5. Relative nameIndex + appendBase64VLQ(pendingNameIndex - lastNameIndex); + lastNameIndex = pendingNameIndex; + } + } + hasLast = true; + exit(); + } + function flushMappingBuffer() { + if (mappingCharCodes.length > 0) { + mappings += String.fromCharCode.apply(undefined, mappingCharCodes); + mappingCharCodes.length = 0; + } + } + function toJSON() { + commitPendingMapping(); + flushMappingBuffer(); + return { + version: 3, + file: file, + sourceRoot: sourceRoot, + sources: sources, + names: names, + mappings: mappings, + sourcesContent: sourcesContent, + }; + } + function appendBase64VLQ(inValue) { + // Add a new least significant bit that has the sign of the value. + // if negative number the least significant bit that gets added to the number has value 1 + // else least significant bit value that gets added is 0 + // eg. -1 changes to binary : 01 [1] => 3 + // +1 changes to binary : 01 [0] => 2 + if (inValue < 0) { + inValue = ((-inValue) << 1) + 1; + } + else { + inValue = inValue << 1; + } + // Encode 5 bits at a time starting from least significant bits + do { + var currentDigit = inValue & 31; // 11111 + inValue = inValue >> 5; + if (inValue > 0) { + // There are still more digits to decode, set the msb (6th bit) + currentDigit = currentDigit | 32; + } + appendMappingCharCode(base64FormatEncode(currentDigit)); + } while (inValue > 0); + } + } + ts.createSourceMapGenerator = createSourceMapGenerator; + // Sometimes tools can see the following line as a source mapping url comment, so we mangle it a bit (the [M]) + var sourceMapCommentRegExp = /^\/\/[@#] source[M]appingURL=(.+)\r?\n?$/; + var whitespaceOrMapCommentRegExp = /^\s*(\/\/[@#] .*)?$/; + function getLineInfo(text, lineStarts) { + return { + getLineCount: function () { return lineStarts.length; }, + getLineText: function (line) { return text.substring(lineStarts[line], lineStarts[line + 1]); } + }; + } + ts.getLineInfo = getLineInfo; + /** + * Tries to find the sourceMappingURL comment at the end of a file. + */ + function tryGetSourceMappingURL(lineInfo) { + for (var index = lineInfo.getLineCount() - 1; index >= 0; index--) { + var line = lineInfo.getLineText(index); + var comment = sourceMapCommentRegExp.exec(line); + if (comment) { + return ts.trimStringEnd(comment[1]); + } + // If we see a non-whitespace/map comment-like line, break, to avoid scanning up the entire file + else if (!line.match(whitespaceOrMapCommentRegExp)) { + break; + } + } + } + ts.tryGetSourceMappingURL = tryGetSourceMappingURL; + /* eslint-disable no-null/no-null */ + function isStringOrNull(x) { + return typeof x === "string" || x === null; + } + function isRawSourceMap(x) { + return x !== null + && typeof x === "object" + && x.version === 3 + && typeof x.file === "string" + && typeof x.mappings === "string" + && ts.isArray(x.sources) && ts.every(x.sources, ts.isString) + && (x.sourceRoot === undefined || x.sourceRoot === null || typeof x.sourceRoot === "string") + && (x.sourcesContent === undefined || x.sourcesContent === null || ts.isArray(x.sourcesContent) && ts.every(x.sourcesContent, isStringOrNull)) + && (x.names === undefined || x.names === null || ts.isArray(x.names) && ts.every(x.names, ts.isString)); + } + ts.isRawSourceMap = isRawSourceMap; + /* eslint-enable no-null/no-null */ + function tryParseRawSourceMap(text) { + try { + var parsed = JSON.parse(text); + if (isRawSourceMap(parsed)) { + return parsed; + } + } + catch (_a) { + // empty + } + return undefined; + } + ts.tryParseRawSourceMap = tryParseRawSourceMap; + function decodeMappings(mappings) { + var done = false; + var pos = 0; + var generatedLine = 0; + var generatedCharacter = 0; + var sourceIndex = 0; + var sourceLine = 0; + var sourceCharacter = 0; + var nameIndex = 0; + var error; + return { + get pos() { return pos; }, + get error() { return error; }, + get state() { return captureMapping(/*hasSource*/ true, /*hasName*/ true); }, + next: function () { + while (!done && pos < mappings.length) { + var ch = mappings.charCodeAt(pos); + if (ch === 59 /* CharacterCodes.semicolon */) { + // new line + generatedLine++; + generatedCharacter = 0; + pos++; + continue; + } + if (ch === 44 /* CharacterCodes.comma */) { + // Next entry is on same line - no action needed + pos++; + continue; + } + var hasSource = false; + var hasName = false; + generatedCharacter += base64VLQFormatDecode(); + if (hasReportedError()) + return stopIterating(); + if (generatedCharacter < 0) + return setErrorAndStopIterating("Invalid generatedCharacter found"); + if (!isSourceMappingSegmentEnd()) { + hasSource = true; + sourceIndex += base64VLQFormatDecode(); + if (hasReportedError()) + return stopIterating(); + if (sourceIndex < 0) + return setErrorAndStopIterating("Invalid sourceIndex found"); + if (isSourceMappingSegmentEnd()) + return setErrorAndStopIterating("Unsupported Format: No entries after sourceIndex"); + sourceLine += base64VLQFormatDecode(); + if (hasReportedError()) + return stopIterating(); + if (sourceLine < 0) + return setErrorAndStopIterating("Invalid sourceLine found"); + if (isSourceMappingSegmentEnd()) + return setErrorAndStopIterating("Unsupported Format: No entries after sourceLine"); + sourceCharacter += base64VLQFormatDecode(); + if (hasReportedError()) + return stopIterating(); + if (sourceCharacter < 0) + return setErrorAndStopIterating("Invalid sourceCharacter found"); + if (!isSourceMappingSegmentEnd()) { + hasName = true; + nameIndex += base64VLQFormatDecode(); + if (hasReportedError()) + return stopIterating(); + if (nameIndex < 0) + return setErrorAndStopIterating("Invalid nameIndex found"); + if (!isSourceMappingSegmentEnd()) + return setErrorAndStopIterating("Unsupported Error Format: Entries after nameIndex"); + } + } + return { value: captureMapping(hasSource, hasName), done: done }; + } + return stopIterating(); + } + }; + function captureMapping(hasSource, hasName) { + return { + generatedLine: generatedLine, + generatedCharacter: generatedCharacter, + sourceIndex: hasSource ? sourceIndex : undefined, + sourceLine: hasSource ? sourceLine : undefined, + sourceCharacter: hasSource ? sourceCharacter : undefined, + nameIndex: hasName ? nameIndex : undefined + }; + } + function stopIterating() { + done = true; + return { value: undefined, done: true }; + } + function setError(message) { + if (error === undefined) { + error = message; + } + } + function setErrorAndStopIterating(message) { + setError(message); + return stopIterating(); + } + function hasReportedError() { + return error !== undefined; + } + function isSourceMappingSegmentEnd() { + return (pos === mappings.length || + mappings.charCodeAt(pos) === 44 /* CharacterCodes.comma */ || + mappings.charCodeAt(pos) === 59 /* CharacterCodes.semicolon */); + } + function base64VLQFormatDecode() { + var moreDigits = true; + var shiftCount = 0; + var value = 0; + for (; moreDigits; pos++) { + if (pos >= mappings.length) + return setError("Error in decoding base64VLQFormatDecode, past the mapping string"), -1; + // 6 digit number + var currentByte = base64FormatDecode(mappings.charCodeAt(pos)); + if (currentByte === -1) + return setError("Invalid character in VLQ"), -1; + // If msb is set, we still have more bits to continue + moreDigits = (currentByte & 32) !== 0; + // least significant 5 bits are the next msbs in the final value. + value = value | ((currentByte & 31) << shiftCount); + shiftCount += 5; + } + // Least significant bit if 1 represents negative and rest of the msb is actual absolute value + if ((value & 1) === 0) { + // + number + value = value >> 1; + } + else { + // - number + value = value >> 1; + value = -value; + } + return value; + } + } + ts.decodeMappings = decodeMappings; + function sameMapping(left, right) { + return left === right + || left.generatedLine === right.generatedLine + && left.generatedCharacter === right.generatedCharacter + && left.sourceIndex === right.sourceIndex + && left.sourceLine === right.sourceLine + && left.sourceCharacter === right.sourceCharacter + && left.nameIndex === right.nameIndex; + } + ts.sameMapping = sameMapping; + function isSourceMapping(mapping) { + return mapping.sourceIndex !== undefined + && mapping.sourceLine !== undefined + && mapping.sourceCharacter !== undefined; + } + ts.isSourceMapping = isSourceMapping; + function base64FormatEncode(value) { + return value >= 0 && value < 26 ? 65 /* CharacterCodes.A */ + value : + value >= 26 && value < 52 ? 97 /* CharacterCodes.a */ + value - 26 : + value >= 52 && value < 62 ? 48 /* CharacterCodes._0 */ + value - 52 : + value === 62 ? 43 /* CharacterCodes.plus */ : + value === 63 ? 47 /* CharacterCodes.slash */ : + ts.Debug.fail("".concat(value, ": not a base64 value")); + } + function base64FormatDecode(ch) { + return ch >= 65 /* CharacterCodes.A */ && ch <= 90 /* CharacterCodes.Z */ ? ch - 65 /* CharacterCodes.A */ : + ch >= 97 /* CharacterCodes.a */ && ch <= 122 /* CharacterCodes.z */ ? ch - 97 /* CharacterCodes.a */ + 26 : + ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */ ? ch - 48 /* CharacterCodes._0 */ + 52 : + ch === 43 /* CharacterCodes.plus */ ? 62 : + ch === 47 /* CharacterCodes.slash */ ? 63 : + -1; + } + function isSourceMappedPosition(value) { + return value.sourceIndex !== undefined + && value.sourcePosition !== undefined; + } + function sameMappedPosition(left, right) { + return left.generatedPosition === right.generatedPosition + && left.sourceIndex === right.sourceIndex + && left.sourcePosition === right.sourcePosition; + } + function compareSourcePositions(left, right) { + // Compares sourcePosition without comparing sourceIndex + // since the mappings are grouped by sourceIndex + ts.Debug.assert(left.sourceIndex === right.sourceIndex); + return ts.compareValues(left.sourcePosition, right.sourcePosition); + } + function compareGeneratedPositions(left, right) { + return ts.compareValues(left.generatedPosition, right.generatedPosition); + } + function getSourcePositionOfMapping(value) { + return value.sourcePosition; + } + function getGeneratedPositionOfMapping(value) { + return value.generatedPosition; + } + function createDocumentPositionMapper(host, map, mapPath) { + var mapDirectory = ts.getDirectoryPath(mapPath); + var sourceRoot = map.sourceRoot ? ts.getNormalizedAbsolutePath(map.sourceRoot, mapDirectory) : mapDirectory; + var generatedAbsoluteFilePath = ts.getNormalizedAbsolutePath(map.file, mapDirectory); + var generatedFile = host.getSourceFileLike(generatedAbsoluteFilePath); + var sourceFileAbsolutePaths = map.sources.map(function (source) { return ts.getNormalizedAbsolutePath(source, sourceRoot); }); + var sourceToSourceIndexMap = new ts.Map(sourceFileAbsolutePaths.map(function (source, i) { return [host.getCanonicalFileName(source), i]; })); + var decodedMappings; + var generatedMappings; + var sourceMappings; + return { + getSourcePosition: getSourcePosition, + getGeneratedPosition: getGeneratedPosition + }; + function processMapping(mapping) { + var generatedPosition = generatedFile !== undefined + ? ts.getPositionOfLineAndCharacter(generatedFile, mapping.generatedLine, mapping.generatedCharacter, /*allowEdits*/ true) + : -1; + var source; + var sourcePosition; + if (isSourceMapping(mapping)) { + var sourceFile = host.getSourceFileLike(sourceFileAbsolutePaths[mapping.sourceIndex]); + source = map.sources[mapping.sourceIndex]; + sourcePosition = sourceFile !== undefined + ? ts.getPositionOfLineAndCharacter(sourceFile, mapping.sourceLine, mapping.sourceCharacter, /*allowEdits*/ true) + : -1; + } + return { + generatedPosition: generatedPosition, + source: source, + sourceIndex: mapping.sourceIndex, + sourcePosition: sourcePosition, + nameIndex: mapping.nameIndex + }; + } + function getDecodedMappings() { + if (decodedMappings === undefined) { + var decoder = decodeMappings(map.mappings); + var mappings = ts.arrayFrom(decoder, processMapping); + if (decoder.error !== undefined) { + if (host.log) { + host.log("Encountered error while decoding sourcemap: ".concat(decoder.error)); + } + decodedMappings = ts.emptyArray; + } + else { + decodedMappings = mappings; + } + } + return decodedMappings; + } + function getSourceMappings(sourceIndex) { + if (sourceMappings === undefined) { + var lists = []; + for (var _i = 0, _a = getDecodedMappings(); _i < _a.length; _i++) { + var mapping = _a[_i]; + if (!isSourceMappedPosition(mapping)) + continue; + var list = lists[mapping.sourceIndex]; + if (!list) + lists[mapping.sourceIndex] = list = []; + list.push(mapping); + } + sourceMappings = lists.map(function (list) { return ts.sortAndDeduplicate(list, compareSourcePositions, sameMappedPosition); }); + } + return sourceMappings[sourceIndex]; + } + function getGeneratedMappings() { + if (generatedMappings === undefined) { + var list = []; + for (var _i = 0, _a = getDecodedMappings(); _i < _a.length; _i++) { + var mapping = _a[_i]; + list.push(mapping); + } + generatedMappings = ts.sortAndDeduplicate(list, compareGeneratedPositions, sameMappedPosition); + } + return generatedMappings; + } + function getGeneratedPosition(loc) { + var sourceIndex = sourceToSourceIndexMap.get(host.getCanonicalFileName(loc.fileName)); + if (sourceIndex === undefined) + return loc; + var sourceMappings = getSourceMappings(sourceIndex); + if (!ts.some(sourceMappings)) + return loc; + var targetIndex = ts.binarySearchKey(sourceMappings, loc.pos, getSourcePositionOfMapping, ts.compareValues); + if (targetIndex < 0) { + // if no exact match, closest is 2's complement of result + targetIndex = ~targetIndex; + } + var mapping = sourceMappings[targetIndex]; + if (mapping === undefined || mapping.sourceIndex !== sourceIndex) { + return loc; + } + return { fileName: generatedAbsoluteFilePath, pos: mapping.generatedPosition }; // Closest pos + } + function getSourcePosition(loc) { + var generatedMappings = getGeneratedMappings(); + if (!ts.some(generatedMappings)) + return loc; + var targetIndex = ts.binarySearchKey(generatedMappings, loc.pos, getGeneratedPositionOfMapping, ts.compareValues); + if (targetIndex < 0) { + // if no exact match, closest is 2's complement of result + targetIndex = ~targetIndex; + } + var mapping = generatedMappings[targetIndex]; + if (mapping === undefined || !isSourceMappedPosition(mapping)) { + return loc; + } + return { fileName: sourceFileAbsolutePaths[mapping.sourceIndex], pos: mapping.sourcePosition }; // Closest pos + } + } + ts.createDocumentPositionMapper = createDocumentPositionMapper; + ts.identitySourceMapConsumer = { + getSourcePosition: ts.identity, + getGeneratedPosition: ts.identity + }; +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + function getOriginalNodeId(node) { + node = ts.getOriginalNode(node); + return node ? ts.getNodeId(node) : 0; + } + ts.getOriginalNodeId = getOriginalNodeId; + function containsDefaultReference(node) { + if (!node) + return false; + if (!ts.isNamedImports(node)) + return false; + return ts.some(node.elements, isNamedDefaultReference); + } + function isNamedDefaultReference(e) { + return e.propertyName !== undefined && e.propertyName.escapedText === "default" /* InternalSymbolName.Default */; + } + function chainBundle(context, transformSourceFile) { + return transformSourceFileOrBundle; + function transformSourceFileOrBundle(node) { + return node.kind === 308 /* SyntaxKind.SourceFile */ ? transformSourceFile(node) : transformBundle(node); + } + function transformBundle(node) { + return context.factory.createBundle(ts.map(node.sourceFiles, transformSourceFile), node.prepends); + } + } + ts.chainBundle = chainBundle; + function getExportNeedsImportStarHelper(node) { + return !!ts.getNamespaceDeclarationNode(node); + } + ts.getExportNeedsImportStarHelper = getExportNeedsImportStarHelper; + function getImportNeedsImportStarHelper(node) { + if (!!ts.getNamespaceDeclarationNode(node)) { + return true; + } + var bindings = node.importClause && node.importClause.namedBindings; + if (!bindings) { + return false; + } + if (!ts.isNamedImports(bindings)) + return false; + var defaultRefCount = 0; + for (var _i = 0, _a = bindings.elements; _i < _a.length; _i++) { + var binding = _a[_i]; + if (isNamedDefaultReference(binding)) { + defaultRefCount++; + } + } + // Import star is required if there's default named refs mixed with non-default refs, or if theres non-default refs and it has a default import + return (defaultRefCount > 0 && defaultRefCount !== bindings.elements.length) || (!!(bindings.elements.length - defaultRefCount) && ts.isDefaultImport(node)); + } + ts.getImportNeedsImportStarHelper = getImportNeedsImportStarHelper; + function getImportNeedsImportDefaultHelper(node) { + // Import default is needed if there's a default import or a default ref and no other refs (meaning an import star helper wasn't requested) + return !getImportNeedsImportStarHelper(node) && (ts.isDefaultImport(node) || (!!node.importClause && ts.isNamedImports(node.importClause.namedBindings) && containsDefaultReference(node.importClause.namedBindings))); // TODO: GH#18217 + } + ts.getImportNeedsImportDefaultHelper = getImportNeedsImportDefaultHelper; + function collectExternalModuleInfo(context, sourceFile, resolver, compilerOptions) { + var externalImports = []; + var exportSpecifiers = ts.createMultiMap(); + var exportedBindings = []; + var uniqueExports = new ts.Map(); + var exportedNames; + var hasExportDefault = false; + var exportEquals; + var hasExportStarsToExportValues = false; + var hasImportStar = false; + var hasImportDefault = false; + for (var _i = 0, _a = sourceFile.statements; _i < _a.length; _i++) { + var node = _a[_i]; + switch (node.kind) { + case 269 /* SyntaxKind.ImportDeclaration */: + // import "mod" + // import x from "mod" + // import * as x from "mod" + // import { x, y } from "mod" + externalImports.push(node); + if (!hasImportStar && getImportNeedsImportStarHelper(node)) { + hasImportStar = true; + } + if (!hasImportDefault && getImportNeedsImportDefaultHelper(node)) { + hasImportDefault = true; + } + break; + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + if (node.moduleReference.kind === 280 /* SyntaxKind.ExternalModuleReference */) { + // import x = require("mod") + externalImports.push(node); + } + break; + case 275 /* SyntaxKind.ExportDeclaration */: + if (node.moduleSpecifier) { + if (!node.exportClause) { + // export * from "mod" + externalImports.push(node); + hasExportStarsToExportValues = true; + } + else { + // export * as ns from "mod" + // export { x, y } from "mod" + externalImports.push(node); + if (ts.isNamedExports(node.exportClause)) { + addExportedNamesForExportDeclaration(node); + } + else { + var name = node.exportClause.name; + if (!uniqueExports.get(ts.idText(name))) { + multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), name); + uniqueExports.set(ts.idText(name), true); + exportedNames = ts.append(exportedNames, name); + } + // we use the same helpers for `export * as ns` as we do for `import * as ns` + hasImportStar = true; + } + } + } + else { + // export { x, y } + addExportedNamesForExportDeclaration(node); + } + break; + case 274 /* SyntaxKind.ExportAssignment */: + if (node.isExportEquals && !exportEquals) { + // export = x + exportEquals = node; + } + break; + case 240 /* SyntaxKind.VariableStatement */: + if (ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */)) { + for (var _b = 0, _c = node.declarationList.declarations; _b < _c.length; _b++) { + var decl = _c[_b]; + exportedNames = collectExportedVariableInfo(decl, uniqueExports, exportedNames); + } + } + break; + case 259 /* SyntaxKind.FunctionDeclaration */: + if (ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */)) { + if (ts.hasSyntacticModifier(node, 1024 /* ModifierFlags.Default */)) { + // export default function() { } + if (!hasExportDefault) { + multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), context.factory.getDeclarationName(node)); + hasExportDefault = true; + } + } + else { + // export function x() { } + var name = node.name; + if (!uniqueExports.get(ts.idText(name))) { + multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), name); + uniqueExports.set(ts.idText(name), true); + exportedNames = ts.append(exportedNames, name); + } + } + } + break; + case 260 /* SyntaxKind.ClassDeclaration */: + if (ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */)) { + if (ts.hasSyntacticModifier(node, 1024 /* ModifierFlags.Default */)) { + // export default class { } + if (!hasExportDefault) { + multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), context.factory.getDeclarationName(node)); + hasExportDefault = true; + } + } + else { + // export class x { } + var name = node.name; + if (name && !uniqueExports.get(ts.idText(name))) { + multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(node), name); + uniqueExports.set(ts.idText(name), true); + exportedNames = ts.append(exportedNames, name); + } + } + } + break; + } + } + var externalHelpersImportDeclaration = ts.createExternalHelpersImportDeclarationIfNeeded(context.factory, context.getEmitHelperFactory(), sourceFile, compilerOptions, hasExportStarsToExportValues, hasImportStar, hasImportDefault); + if (externalHelpersImportDeclaration) { + externalImports.unshift(externalHelpersImportDeclaration); + } + return { externalImports: externalImports, exportSpecifiers: exportSpecifiers, exportEquals: exportEquals, hasExportStarsToExportValues: hasExportStarsToExportValues, exportedBindings: exportedBindings, exportedNames: exportedNames, externalHelpersImportDeclaration: externalHelpersImportDeclaration }; + function addExportedNamesForExportDeclaration(node) { + for (var _i = 0, _a = ts.cast(node.exportClause, ts.isNamedExports).elements; _i < _a.length; _i++) { + var specifier = _a[_i]; + if (!uniqueExports.get(ts.idText(specifier.name))) { + var name = specifier.propertyName || specifier.name; + if (!node.moduleSpecifier) { + exportSpecifiers.add(ts.idText(name), specifier); + } + var decl = resolver.getReferencedImportDeclaration(name) + || resolver.getReferencedValueDeclaration(name); + if (decl) { + multiMapSparseArrayAdd(exportedBindings, getOriginalNodeId(decl), specifier.name); + } + uniqueExports.set(ts.idText(specifier.name), true); + exportedNames = ts.append(exportedNames, specifier.name); + } + } + } + } + ts.collectExternalModuleInfo = collectExternalModuleInfo; + function collectExportedVariableInfo(decl, uniqueExports, exportedNames) { + if (ts.isBindingPattern(decl.name)) { + for (var _i = 0, _a = decl.name.elements; _i < _a.length; _i++) { + var element = _a[_i]; + if (!ts.isOmittedExpression(element)) { + exportedNames = collectExportedVariableInfo(element, uniqueExports, exportedNames); + } + } + } + else if (!ts.isGeneratedIdentifier(decl.name)) { + var text = ts.idText(decl.name); + if (!uniqueExports.get(text)) { + uniqueExports.set(text, true); + exportedNames = ts.append(exportedNames, decl.name); + } + } + return exportedNames; + } + /** Use a sparse array as a multi-map. */ + function multiMapSparseArrayAdd(map, key, value) { + var values = map[key]; + if (values) { + values.push(value); + } + else { + map[key] = values = [value]; + } + return values; + } + /** + * Used in the module transformer to check if an expression is reasonably without sideeffect, + * and thus better to copy into multiple places rather than to cache in a temporary variable + * - this is mostly subjective beyond the requirement that the expression not be sideeffecting + */ + function isSimpleCopiableExpression(expression) { + return ts.isStringLiteralLike(expression) || + expression.kind === 8 /* SyntaxKind.NumericLiteral */ || + ts.isKeyword(expression.kind) || + ts.isIdentifier(expression); + } + ts.isSimpleCopiableExpression = isSimpleCopiableExpression; + /** + * A simple inlinable expression is an expression which can be copied into multiple locations + * without risk of repeating any sideeffects and whose value could not possibly change between + * any such locations + */ + function isSimpleInlineableExpression(expression) { + return !ts.isIdentifier(expression) && isSimpleCopiableExpression(expression); + } + ts.isSimpleInlineableExpression = isSimpleInlineableExpression; + function isCompoundAssignment(kind) { + return kind >= 64 /* SyntaxKind.FirstCompoundAssignment */ + && kind <= 78 /* SyntaxKind.LastCompoundAssignment */; + } + ts.isCompoundAssignment = isCompoundAssignment; + function getNonAssignmentOperatorForCompoundAssignment(kind) { + switch (kind) { + case 64 /* SyntaxKind.PlusEqualsToken */: return 39 /* SyntaxKind.PlusToken */; + case 65 /* SyntaxKind.MinusEqualsToken */: return 40 /* SyntaxKind.MinusToken */; + case 66 /* SyntaxKind.AsteriskEqualsToken */: return 41 /* SyntaxKind.AsteriskToken */; + case 67 /* SyntaxKind.AsteriskAsteriskEqualsToken */: return 42 /* SyntaxKind.AsteriskAsteriskToken */; + case 68 /* SyntaxKind.SlashEqualsToken */: return 43 /* SyntaxKind.SlashToken */; + case 69 /* SyntaxKind.PercentEqualsToken */: return 44 /* SyntaxKind.PercentToken */; + case 70 /* SyntaxKind.LessThanLessThanEqualsToken */: return 47 /* SyntaxKind.LessThanLessThanToken */; + case 71 /* SyntaxKind.GreaterThanGreaterThanEqualsToken */: return 48 /* SyntaxKind.GreaterThanGreaterThanToken */; + case 72 /* SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken */: return 49 /* SyntaxKind.GreaterThanGreaterThanGreaterThanToken */; + case 73 /* SyntaxKind.AmpersandEqualsToken */: return 50 /* SyntaxKind.AmpersandToken */; + case 74 /* SyntaxKind.BarEqualsToken */: return 51 /* SyntaxKind.BarToken */; + case 78 /* SyntaxKind.CaretEqualsToken */: return 52 /* SyntaxKind.CaretToken */; + case 75 /* SyntaxKind.BarBarEqualsToken */: return 56 /* SyntaxKind.BarBarToken */; + case 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */: return 55 /* SyntaxKind.AmpersandAmpersandToken */; + case 77 /* SyntaxKind.QuestionQuestionEqualsToken */: return 60 /* SyntaxKind.QuestionQuestionToken */; + } + } + ts.getNonAssignmentOperatorForCompoundAssignment = getNonAssignmentOperatorForCompoundAssignment; + /** + * @returns Contained super() call from descending into the statement ignoring parentheses, if that call exists. + */ + function getSuperCallFromStatement(statement) { + if (!ts.isExpressionStatement(statement)) { + return undefined; + } + var expression = ts.skipParentheses(statement.expression); + return ts.isSuperCall(expression) + ? expression + : undefined; + } + ts.getSuperCallFromStatement = getSuperCallFromStatement; + /** + * @returns The index (after prologue statements) of a super call, or -1 if not found. + */ + function findSuperStatementIndex(statements, indexAfterLastPrologueStatement) { + for (var i = indexAfterLastPrologueStatement; i < statements.length; i += 1) { + var statement = statements[i]; + if (getSuperCallFromStatement(statement)) { + return i; + } + } + return -1; + } + ts.findSuperStatementIndex = findSuperStatementIndex; + function getProperties(node, requireInitializer, isStatic) { + return ts.filter(node.members, function (m) { return isInitializedOrStaticProperty(m, requireInitializer, isStatic); }); + } + ts.getProperties = getProperties; + function isStaticPropertyDeclarationOrClassStaticBlockDeclaration(element) { + return isStaticPropertyDeclaration(element) || ts.isClassStaticBlockDeclaration(element); + } + function getStaticPropertiesAndClassStaticBlock(node) { + return ts.filter(node.members, isStaticPropertyDeclarationOrClassStaticBlockDeclaration); + } + ts.getStaticPropertiesAndClassStaticBlock = getStaticPropertiesAndClassStaticBlock; + /** + * Is a class element either a static or an instance property declaration with an initializer? + * + * @param member The class element node. + * @param isStatic A value indicating whether the member should be a static or instance member. + */ + function isInitializedOrStaticProperty(member, requireInitializer, isStatic) { + return ts.isPropertyDeclaration(member) + && (!!member.initializer || !requireInitializer) + && ts.hasStaticModifier(member) === isStatic; + } + function isStaticPropertyDeclaration(member) { + return ts.isPropertyDeclaration(member) && ts.hasStaticModifier(member); + } + /** + * Gets a value indicating whether a class element is either a static or an instance property declaration with an initializer. + * + * @param member The class element node. + * @param isStatic A value indicating whether the member should be a static or instance member. + */ + function isInitializedProperty(member) { + return member.kind === 169 /* SyntaxKind.PropertyDeclaration */ + && member.initializer !== undefined; + } + ts.isInitializedProperty = isInitializedProperty; + /** + * Gets a value indicating whether a class element is a private instance method or accessor. + * + * @param member The class element node. + */ + function isNonStaticMethodOrAccessorWithPrivateName(member) { + return !ts.isStatic(member) && (ts.isMethodOrAccessor(member) || ts.isAutoAccessorPropertyDeclaration(member)) && ts.isPrivateIdentifier(member.name); + } + ts.isNonStaticMethodOrAccessorWithPrivateName = isNonStaticMethodOrAccessorWithPrivateName; + /** + * Gets an array of arrays of decorators for the parameters of a function-like node. + * The offset into the result array should correspond to the offset of the parameter. + * + * @param node The function-like node. + */ + function getDecoratorsOfParameters(node) { + var decorators; + if (node) { + var parameters = node.parameters; + var firstParameterIsThis = parameters.length > 0 && ts.parameterIsThisKeyword(parameters[0]); + var firstParameterOffset = firstParameterIsThis ? 1 : 0; + var numParameters = firstParameterIsThis ? parameters.length - 1 : parameters.length; + for (var i = 0; i < numParameters; i++) { + var parameter = parameters[i + firstParameterOffset]; + if (decorators || ts.hasDecorators(parameter)) { + if (!decorators) { + decorators = new Array(numParameters); + } + decorators[i] = ts.getDecorators(parameter); + } + } + } + return decorators; + } + /** + * Gets an AllDecorators object containing the decorators for the class and the decorators for the + * parameters of the constructor of the class. + * + * @param node The class node. + */ + function getAllDecoratorsOfClass(node) { + var decorators = ts.getDecorators(node); + var parameters = getDecoratorsOfParameters(ts.getFirstConstructorWithBody(node)); + if (!ts.some(decorators) && !ts.some(parameters)) { + return undefined; + } + return { + decorators: decorators, + parameters: parameters + }; + } + ts.getAllDecoratorsOfClass = getAllDecoratorsOfClass; + /** + * Gets an AllDecorators object containing the decorators for the member and its parameters. + * + * @param parent The class node that contains the member. + * @param member The class member. + */ + function getAllDecoratorsOfClassElement(member, parent) { + switch (member.kind) { + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + return getAllDecoratorsOfAccessors(member, parent); + case 171 /* SyntaxKind.MethodDeclaration */: + return getAllDecoratorsOfMethod(member); + case 169 /* SyntaxKind.PropertyDeclaration */: + return getAllDecoratorsOfProperty(member); + default: + return undefined; + } + } + ts.getAllDecoratorsOfClassElement = getAllDecoratorsOfClassElement; + /** + * Gets an AllDecorators object containing the decorators for the accessor and its parameters. + * + * @param parent The class node that contains the accessor. + * @param accessor The class accessor member. + */ + function getAllDecoratorsOfAccessors(accessor, parent) { + if (!accessor.body) { + return undefined; + } + var _a = ts.getAllAccessorDeclarations(parent.members, accessor), firstAccessor = _a.firstAccessor, secondAccessor = _a.secondAccessor, getAccessor = _a.getAccessor, setAccessor = _a.setAccessor; + var firstAccessorWithDecorators = ts.hasDecorators(firstAccessor) ? firstAccessor : + secondAccessor && ts.hasDecorators(secondAccessor) ? secondAccessor : + undefined; + if (!firstAccessorWithDecorators || accessor !== firstAccessorWithDecorators) { + return undefined; + } + var decorators = ts.getDecorators(firstAccessorWithDecorators); + var parameters = getDecoratorsOfParameters(setAccessor); + if (!ts.some(decorators) && !ts.some(parameters)) { + return undefined; + } + return { + decorators: decorators, + parameters: parameters, + getDecorators: getAccessor && ts.getDecorators(getAccessor), + setDecorators: setAccessor && ts.getDecorators(setAccessor) + }; + } + /** + * Gets an AllDecorators object containing the decorators for the method and its parameters. + * + * @param method The class method member. + */ + function getAllDecoratorsOfMethod(method) { + if (!method.body) { + return undefined; + } + var decorators = ts.getDecorators(method); + var parameters = getDecoratorsOfParameters(method); + if (!ts.some(decorators) && !ts.some(parameters)) { + return undefined; + } + return { decorators: decorators, parameters: parameters }; + } + /** + * Gets an AllDecorators object containing the decorators for the property. + * + * @param property The class property member. + */ + function getAllDecoratorsOfProperty(property) { + var decorators = ts.getDecorators(property); + if (!ts.some(decorators)) { + return undefined; + } + return { decorators: decorators }; + } +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + var FlattenLevel; + (function (FlattenLevel) { + FlattenLevel[FlattenLevel["All"] = 0] = "All"; + FlattenLevel[FlattenLevel["ObjectRest"] = 1] = "ObjectRest"; + })(FlattenLevel = ts.FlattenLevel || (ts.FlattenLevel = {})); + /** + * Flattens a DestructuringAssignment or a VariableDeclaration to an expression. + * + * @param node The node to flatten. + * @param visitor An optional visitor used to visit initializers. + * @param context The transformation context. + * @param level Indicates the extent to which flattening should occur. + * @param needsValue An optional value indicating whether the value from the right-hand-side of + * the destructuring assignment is needed as part of a larger expression. + * @param createAssignmentCallback An optional callback used to create the assignment expression. + */ + function flattenDestructuringAssignment(node, visitor, context, level, needsValue, createAssignmentCallback) { + var location = node; + var value; + if (ts.isDestructuringAssignment(node)) { + value = node.right; + while (ts.isEmptyArrayLiteral(node.left) || ts.isEmptyObjectLiteral(node.left)) { + if (ts.isDestructuringAssignment(value)) { + location = node = value; + value = node.right; + } + else { + return ts.visitNode(value, visitor, ts.isExpression); + } + } + } + var expressions; + var flattenContext = { + context: context, + level: level, + downlevelIteration: !!context.getCompilerOptions().downlevelIteration, + hoistTempVariables: true, + emitExpression: emitExpression, + emitBindingOrAssignment: emitBindingOrAssignment, + createArrayBindingOrAssignmentPattern: function (elements) { return makeArrayAssignmentPattern(context.factory, elements); }, + createObjectBindingOrAssignmentPattern: function (elements) { return makeObjectAssignmentPattern(context.factory, elements); }, + createArrayBindingOrAssignmentElement: makeAssignmentElement, + visitor: visitor + }; + if (value) { + value = ts.visitNode(value, visitor, ts.isExpression); + if (ts.isIdentifier(value) && bindingOrAssignmentElementAssignsToName(node, value.escapedText) || + bindingOrAssignmentElementContainsNonLiteralComputedName(node)) { + // If the right-hand value of the assignment is also an assignment target then + // we need to cache the right-hand value. + value = ensureIdentifier(flattenContext, value, /*reuseIdentifierExpressions*/ false, location); + } + else if (needsValue) { + // If the right-hand value of the destructuring assignment needs to be preserved (as + // is the case when the destructuring assignment is part of a larger expression), + // then we need to cache the right-hand value. + // + // The source map location for the assignment should point to the entire binary + // expression. + value = ensureIdentifier(flattenContext, value, /*reuseIdentifierExpressions*/ true, location); + } + else if (ts.nodeIsSynthesized(node)) { + // Generally, the source map location for a destructuring assignment is the root + // expression. + // + // However, if the root expression is synthesized (as in the case + // of the initializer when transforming a ForOfStatement), then the source map + // location should point to the right-hand value of the expression. + location = value; + } + } + flattenBindingOrAssignmentElement(flattenContext, node, value, location, /*skipInitializer*/ ts.isDestructuringAssignment(node)); + if (value && needsValue) { + if (!ts.some(expressions)) { + return value; + } + expressions.push(value); + } + return context.factory.inlineExpressions(expressions) || context.factory.createOmittedExpression(); + function emitExpression(expression) { + expressions = ts.append(expressions, expression); + } + function emitBindingOrAssignment(target, value, location, original) { + ts.Debug.assertNode(target, createAssignmentCallback ? ts.isIdentifier : ts.isExpression); + var expression = createAssignmentCallback + ? createAssignmentCallback(target, value, location) + : ts.setTextRange(context.factory.createAssignment(ts.visitNode(target, visitor, ts.isExpression), value), location); + expression.original = original; + emitExpression(expression); + } + } + ts.flattenDestructuringAssignment = flattenDestructuringAssignment; + function bindingOrAssignmentElementAssignsToName(element, escapedName) { + var target = ts.getTargetOfBindingOrAssignmentElement(element); // TODO: GH#18217 + if (ts.isBindingOrAssignmentPattern(target)) { + return bindingOrAssignmentPatternAssignsToName(target, escapedName); + } + else if (ts.isIdentifier(target)) { + return target.escapedText === escapedName; + } + return false; + } + function bindingOrAssignmentPatternAssignsToName(pattern, escapedName) { + var elements = ts.getElementsOfBindingOrAssignmentPattern(pattern); + for (var _i = 0, elements_4 = elements; _i < elements_4.length; _i++) { + var element = elements_4[_i]; + if (bindingOrAssignmentElementAssignsToName(element, escapedName)) { + return true; + } + } + return false; + } + function bindingOrAssignmentElementContainsNonLiteralComputedName(element) { + var propertyName = ts.tryGetPropertyNameOfBindingOrAssignmentElement(element); + if (propertyName && ts.isComputedPropertyName(propertyName) && !ts.isLiteralExpression(propertyName.expression)) { + return true; + } + var target = ts.getTargetOfBindingOrAssignmentElement(element); + return !!target && ts.isBindingOrAssignmentPattern(target) && bindingOrAssignmentPatternContainsNonLiteralComputedName(target); + } + function bindingOrAssignmentPatternContainsNonLiteralComputedName(pattern) { + return !!ts.forEach(ts.getElementsOfBindingOrAssignmentPattern(pattern), bindingOrAssignmentElementContainsNonLiteralComputedName); + } + /** + * Flattens a VariableDeclaration or ParameterDeclaration to one or more variable declarations. + * + * @param node The node to flatten. + * @param visitor An optional visitor used to visit initializers. + * @param context The transformation context. + * @param boundValue The value bound to the declaration. + * @param skipInitializer A value indicating whether to ignore the initializer of `node`. + * @param hoistTempVariables Indicates whether temporary variables should not be recorded in-line. + * @param level Indicates the extent to which flattening should occur. + */ + function flattenDestructuringBinding(node, visitor, context, level, rval, hoistTempVariables, skipInitializer) { + if (hoistTempVariables === void 0) { hoistTempVariables = false; } + var pendingExpressions; + var pendingDeclarations = []; + var declarations = []; + var flattenContext = { + context: context, + level: level, + downlevelIteration: !!context.getCompilerOptions().downlevelIteration, + hoistTempVariables: hoistTempVariables, + emitExpression: emitExpression, + emitBindingOrAssignment: emitBindingOrAssignment, + createArrayBindingOrAssignmentPattern: function (elements) { return makeArrayBindingPattern(context.factory, elements); }, + createObjectBindingOrAssignmentPattern: function (elements) { return makeObjectBindingPattern(context.factory, elements); }, + createArrayBindingOrAssignmentElement: function (name) { return makeBindingElement(context.factory, name); }, + visitor: visitor + }; + if (ts.isVariableDeclaration(node)) { + var initializer = ts.getInitializerOfBindingOrAssignmentElement(node); + if (initializer && (ts.isIdentifier(initializer) && bindingOrAssignmentElementAssignsToName(node, initializer.escapedText) || + bindingOrAssignmentElementContainsNonLiteralComputedName(node))) { + // If the right-hand value of the assignment is also an assignment target then + // we need to cache the right-hand value. + initializer = ensureIdentifier(flattenContext, ts.visitNode(initializer, flattenContext.visitor), /*reuseIdentifierExpressions*/ false, initializer); + node = context.factory.updateVariableDeclaration(node, node.name, /*exclamationToken*/ undefined, /*type*/ undefined, initializer); + } + } + flattenBindingOrAssignmentElement(flattenContext, node, rval, node, skipInitializer); + if (pendingExpressions) { + var temp = context.factory.createTempVariable(/*recordTempVariable*/ undefined); + if (hoistTempVariables) { + var value = context.factory.inlineExpressions(pendingExpressions); + pendingExpressions = undefined; + emitBindingOrAssignment(temp, value, /*location*/ undefined, /*original*/ undefined); + } + else { + context.hoistVariableDeclaration(temp); + var pendingDeclaration = ts.last(pendingDeclarations); + pendingDeclaration.pendingExpressions = ts.append(pendingDeclaration.pendingExpressions, context.factory.createAssignment(temp, pendingDeclaration.value)); + ts.addRange(pendingDeclaration.pendingExpressions, pendingExpressions); + pendingDeclaration.value = temp; + } + } + for (var _i = 0, pendingDeclarations_1 = pendingDeclarations; _i < pendingDeclarations_1.length; _i++) { + var _a = pendingDeclarations_1[_i], pendingExpressions_1 = _a.pendingExpressions, name = _a.name, value = _a.value, location = _a.location, original = _a.original; + var variable = context.factory.createVariableDeclaration(name, + /*exclamationToken*/ undefined, + /*type*/ undefined, pendingExpressions_1 ? context.factory.inlineExpressions(ts.append(pendingExpressions_1, value)) : value); + variable.original = original; + ts.setTextRange(variable, location); + declarations.push(variable); + } + return declarations; + function emitExpression(value) { + pendingExpressions = ts.append(pendingExpressions, value); + } + function emitBindingOrAssignment(target, value, location, original) { + ts.Debug.assertNode(target, ts.isBindingName); + if (pendingExpressions) { + value = context.factory.inlineExpressions(ts.append(pendingExpressions, value)); + pendingExpressions = undefined; + } + pendingDeclarations.push({ pendingExpressions: pendingExpressions, name: target, value: value, location: location, original: original }); + } + } + ts.flattenDestructuringBinding = flattenDestructuringBinding; + /** + * Flattens a BindingOrAssignmentElement into zero or more bindings or assignments. + * + * @param flattenContext Options used to control flattening. + * @param element The element to flatten. + * @param value The current RHS value to assign to the element. + * @param location The location to use for source maps and comments. + * @param skipInitializer An optional value indicating whether to include the initializer + * for the element. + */ + function flattenBindingOrAssignmentElement(flattenContext, element, value, location, skipInitializer) { + var bindingTarget = ts.getTargetOfBindingOrAssignmentElement(element); // TODO: GH#18217 + if (!skipInitializer) { + var initializer = ts.visitNode(ts.getInitializerOfBindingOrAssignmentElement(element), flattenContext.visitor, ts.isExpression); + if (initializer) { + // Combine value and initializer + if (value) { + value = createDefaultValueCheck(flattenContext, value, initializer, location); + // If 'value' is not a simple expression, it could contain side-effecting code that should evaluate before an object or array binding pattern. + if (!ts.isSimpleInlineableExpression(initializer) && ts.isBindingOrAssignmentPattern(bindingTarget)) { + value = ensureIdentifier(flattenContext, value, /*reuseIdentifierExpressions*/ true, location); + } + } + else { + value = initializer; + } + } + else if (!value) { + // Use 'void 0' in absence of value and initializer + value = flattenContext.context.factory.createVoidZero(); + } + } + if (ts.isObjectBindingOrAssignmentPattern(bindingTarget)) { + flattenObjectBindingOrAssignmentPattern(flattenContext, element, bindingTarget, value, location); + } + else if (ts.isArrayBindingOrAssignmentPattern(bindingTarget)) { + flattenArrayBindingOrAssignmentPattern(flattenContext, element, bindingTarget, value, location); + } + else { + flattenContext.emitBindingOrAssignment(bindingTarget, value, location, /*original*/ element); // TODO: GH#18217 + } + } + /** + * Flattens an ObjectBindingOrAssignmentPattern into zero or more bindings or assignments. + * + * @param flattenContext Options used to control flattening. + * @param parent The parent element of the pattern. + * @param pattern The ObjectBindingOrAssignmentPattern to flatten. + * @param value The current RHS value to assign to the element. + * @param location The location to use for source maps and comments. + */ + function flattenObjectBindingOrAssignmentPattern(flattenContext, parent, pattern, value, location) { + var elements = ts.getElementsOfBindingOrAssignmentPattern(pattern); + var numElements = elements.length; + if (numElements !== 1) { + // For anything other than a single-element destructuring we need to generate a temporary + // to ensure value is evaluated exactly once. Additionally, if we have zero elements + // we need to emit *something* to ensure that in case a 'var' keyword was already emitted, + // so in that case, we'll intentionally create that temporary. + var reuseIdentifierExpressions = !ts.isDeclarationBindingElement(parent) || numElements !== 0; + value = ensureIdentifier(flattenContext, value, reuseIdentifierExpressions, location); + } + var bindingElements; + var computedTempVariables; + for (var i = 0; i < numElements; i++) { + var element = elements[i]; + if (!ts.getRestIndicatorOfBindingOrAssignmentElement(element)) { + var propertyName = ts.getPropertyNameOfBindingOrAssignmentElement(element); + if (flattenContext.level >= 1 /* FlattenLevel.ObjectRest */ + && !(element.transformFlags & (32768 /* TransformFlags.ContainsRestOrSpread */ | 65536 /* TransformFlags.ContainsObjectRestOrSpread */)) + && !(ts.getTargetOfBindingOrAssignmentElement(element).transformFlags & (32768 /* TransformFlags.ContainsRestOrSpread */ | 65536 /* TransformFlags.ContainsObjectRestOrSpread */)) + && !ts.isComputedPropertyName(propertyName)) { + bindingElements = ts.append(bindingElements, ts.visitNode(element, flattenContext.visitor)); + } + else { + if (bindingElements) { + flattenContext.emitBindingOrAssignment(flattenContext.createObjectBindingOrAssignmentPattern(bindingElements), value, location, pattern); + bindingElements = undefined; + } + var rhsValue = createDestructuringPropertyAccess(flattenContext, value, propertyName); + if (ts.isComputedPropertyName(propertyName)) { + computedTempVariables = ts.append(computedTempVariables, rhsValue.argumentExpression); + } + flattenBindingOrAssignmentElement(flattenContext, element, rhsValue, /*location*/ element); + } + } + else if (i === numElements - 1) { + if (bindingElements) { + flattenContext.emitBindingOrAssignment(flattenContext.createObjectBindingOrAssignmentPattern(bindingElements), value, location, pattern); + bindingElements = undefined; + } + var rhsValue = flattenContext.context.getEmitHelperFactory().createRestHelper(value, elements, computedTempVariables, pattern); + flattenBindingOrAssignmentElement(flattenContext, element, rhsValue, element); + } + } + if (bindingElements) { + flattenContext.emitBindingOrAssignment(flattenContext.createObjectBindingOrAssignmentPattern(bindingElements), value, location, pattern); + } + } + /** + * Flattens an ArrayBindingOrAssignmentPattern into zero or more bindings or assignments. + * + * @param flattenContext Options used to control flattening. + * @param parent The parent element of the pattern. + * @param pattern The ArrayBindingOrAssignmentPattern to flatten. + * @param value The current RHS value to assign to the element. + * @param location The location to use for source maps and comments. + */ + function flattenArrayBindingOrAssignmentPattern(flattenContext, parent, pattern, value, location) { + var elements = ts.getElementsOfBindingOrAssignmentPattern(pattern); + var numElements = elements.length; + if (flattenContext.level < 1 /* FlattenLevel.ObjectRest */ && flattenContext.downlevelIteration) { + // Read the elements of the iterable into an array + value = ensureIdentifier(flattenContext, ts.setTextRange(flattenContext.context.getEmitHelperFactory().createReadHelper(value, numElements > 0 && ts.getRestIndicatorOfBindingOrAssignmentElement(elements[numElements - 1]) + ? undefined + : numElements), location), + /*reuseIdentifierExpressions*/ false, location); + } + else if (numElements !== 1 && (flattenContext.level < 1 /* FlattenLevel.ObjectRest */ || numElements === 0) + || ts.every(elements, ts.isOmittedExpression)) { + // For anything other than a single-element destructuring we need to generate a temporary + // to ensure value is evaluated exactly once. Additionally, if we have zero elements + // we need to emit *something* to ensure that in case a 'var' keyword was already emitted, + // so in that case, we'll intentionally create that temporary. + // Or all the elements of the binding pattern are omitted expression such as "var [,] = [1,2]", + // then we will create temporary variable. + var reuseIdentifierExpressions = !ts.isDeclarationBindingElement(parent) || numElements !== 0; + value = ensureIdentifier(flattenContext, value, reuseIdentifierExpressions, location); + } + var bindingElements; + var restContainingElements; + for (var i = 0; i < numElements; i++) { + var element = elements[i]; + if (flattenContext.level >= 1 /* FlattenLevel.ObjectRest */) { + // If an array pattern contains an ObjectRest, we must cache the result so that we + // can perform the ObjectRest destructuring in a different declaration + if (element.transformFlags & 65536 /* TransformFlags.ContainsObjectRestOrSpread */ || flattenContext.hasTransformedPriorElement && !isSimpleBindingOrAssignmentElement(element)) { + flattenContext.hasTransformedPriorElement = true; + var temp = flattenContext.context.factory.createTempVariable(/*recordTempVariable*/ undefined); + if (flattenContext.hoistTempVariables) { + flattenContext.context.hoistVariableDeclaration(temp); + } + restContainingElements = ts.append(restContainingElements, [temp, element]); + bindingElements = ts.append(bindingElements, flattenContext.createArrayBindingOrAssignmentElement(temp)); + } + else { + bindingElements = ts.append(bindingElements, element); + } + } + else if (ts.isOmittedExpression(element)) { + continue; + } + else if (!ts.getRestIndicatorOfBindingOrAssignmentElement(element)) { + var rhsValue = flattenContext.context.factory.createElementAccessExpression(value, i); + flattenBindingOrAssignmentElement(flattenContext, element, rhsValue, /*location*/ element); + } + else if (i === numElements - 1) { + var rhsValue = flattenContext.context.factory.createArraySliceCall(value, i); + flattenBindingOrAssignmentElement(flattenContext, element, rhsValue, /*location*/ element); + } + } + if (bindingElements) { + flattenContext.emitBindingOrAssignment(flattenContext.createArrayBindingOrAssignmentPattern(bindingElements), value, location, pattern); + } + if (restContainingElements) { + for (var _i = 0, restContainingElements_1 = restContainingElements; _i < restContainingElements_1.length; _i++) { + var _a = restContainingElements_1[_i], id = _a[0], element = _a[1]; + flattenBindingOrAssignmentElement(flattenContext, element, id, element); + } + } + } + function isSimpleBindingOrAssignmentElement(element) { + var target = ts.getTargetOfBindingOrAssignmentElement(element); + if (!target || ts.isOmittedExpression(target)) + return true; + var propertyName = ts.tryGetPropertyNameOfBindingOrAssignmentElement(element); + if (propertyName && !ts.isPropertyNameLiteral(propertyName)) + return false; + var initializer = ts.getInitializerOfBindingOrAssignmentElement(element); + if (initializer && !ts.isSimpleInlineableExpression(initializer)) + return false; + if (ts.isBindingOrAssignmentPattern(target)) + return ts.every(ts.getElementsOfBindingOrAssignmentPattern(target), isSimpleBindingOrAssignmentElement); + return ts.isIdentifier(target); + } + /** + * Creates an expression used to provide a default value if a value is `undefined` at runtime. + * + * @param flattenContext Options used to control flattening. + * @param value The RHS value to test. + * @param defaultValue The default value to use if `value` is `undefined` at runtime. + * @param location The location to use for source maps and comments. + */ + function createDefaultValueCheck(flattenContext, value, defaultValue, location) { + value = ensureIdentifier(flattenContext, value, /*reuseIdentifierExpressions*/ true, location); + return flattenContext.context.factory.createConditionalExpression(flattenContext.context.factory.createTypeCheck(value, "undefined"), /*questionToken*/ undefined, defaultValue, /*colonToken*/ undefined, value); + } + /** + * Creates either a PropertyAccessExpression or an ElementAccessExpression for the + * right-hand side of a transformed destructuring assignment. + * + * @link https://tc39.github.io/ecma262/#sec-runtime-semantics-keyeddestructuringassignmentevaluation + * + * @param flattenContext Options used to control flattening. + * @param value The RHS value that is the source of the property. + * @param propertyName The destructuring property name. + */ + function createDestructuringPropertyAccess(flattenContext, value, propertyName) { + if (ts.isComputedPropertyName(propertyName)) { + var argumentExpression = ensureIdentifier(flattenContext, ts.visitNode(propertyName.expression, flattenContext.visitor), /*reuseIdentifierExpressions*/ false, /*location*/ propertyName); + return flattenContext.context.factory.createElementAccessExpression(value, argumentExpression); + } + else if (ts.isStringOrNumericLiteralLike(propertyName)) { + var argumentExpression = ts.factory.cloneNode(propertyName); + return flattenContext.context.factory.createElementAccessExpression(value, argumentExpression); + } + else { + var name = flattenContext.context.factory.createIdentifier(ts.idText(propertyName)); + return flattenContext.context.factory.createPropertyAccessExpression(value, name); + } + } + /** + * Ensures that there exists a declared identifier whose value holds the given expression. + * This function is useful to ensure that the expression's value can be read from in subsequent expressions. + * Unless 'reuseIdentifierExpressions' is false, 'value' will be returned if it is just an identifier. + * + * @param flattenContext Options used to control flattening. + * @param value the expression whose value needs to be bound. + * @param reuseIdentifierExpressions true if identifier expressions can simply be returned; + * false if it is necessary to always emit an identifier. + * @param location The location to use for source maps and comments. + */ + function ensureIdentifier(flattenContext, value, reuseIdentifierExpressions, location) { + if (ts.isIdentifier(value) && reuseIdentifierExpressions) { + return value; + } + else { + var temp = flattenContext.context.factory.createTempVariable(/*recordTempVariable*/ undefined); + if (flattenContext.hoistTempVariables) { + flattenContext.context.hoistVariableDeclaration(temp); + flattenContext.emitExpression(ts.setTextRange(flattenContext.context.factory.createAssignment(temp, value), location)); + } + else { + flattenContext.emitBindingOrAssignment(temp, value, location, /*original*/ undefined); + } + return temp; + } + } + function makeArrayBindingPattern(factory, elements) { + ts.Debug.assertEachNode(elements, ts.isArrayBindingElement); + return factory.createArrayBindingPattern(elements); + } + function makeArrayAssignmentPattern(factory, elements) { + return factory.createArrayLiteralExpression(ts.map(elements, factory.converters.convertToArrayAssignmentElement)); + } + function makeObjectBindingPattern(factory, elements) { + ts.Debug.assertEachNode(elements, ts.isBindingElement); + return factory.createObjectBindingPattern(elements); + } + function makeObjectAssignmentPattern(factory, elements) { + return factory.createObjectLiteralExpression(ts.map(elements, factory.converters.convertToObjectAssignmentElement)); + } + function makeBindingElement(factory, name) { + return factory.createBindingElement(/*dotDotDotToken*/ undefined, /*propertyName*/ undefined, name); + } + function makeAssignmentElement(name) { + return name; + } +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + var ProcessLevel; + (function (ProcessLevel) { + ProcessLevel[ProcessLevel["LiftRestriction"] = 0] = "LiftRestriction"; + ProcessLevel[ProcessLevel["All"] = 1] = "All"; + })(ProcessLevel = ts.ProcessLevel || (ts.ProcessLevel = {})); + function processTaggedTemplateExpression(context, node, visitor, currentSourceFile, recordTaggedTemplateString, level) { + // Visit the tag expression + var tag = ts.visitNode(node.tag, visitor, ts.isExpression); + // Build up the template arguments and the raw and cooked strings for the template. + // We start out with 'undefined' for the first argument and revisit later + // to avoid walking over the template string twice and shifting all our arguments over after the fact. + var templateArguments = [undefined]; + var cookedStrings = []; + var rawStrings = []; + var template = node.template; + if (level === ProcessLevel.LiftRestriction && !ts.hasInvalidEscape(template)) { + return ts.visitEachChild(node, visitor, context); + } + if (ts.isNoSubstitutionTemplateLiteral(template)) { + cookedStrings.push(createTemplateCooked(template)); + rawStrings.push(getRawLiteral(template, currentSourceFile)); + } + else { + cookedStrings.push(createTemplateCooked(template.head)); + rawStrings.push(getRawLiteral(template.head, currentSourceFile)); + for (var _i = 0, _a = template.templateSpans; _i < _a.length; _i++) { + var templateSpan = _a[_i]; + cookedStrings.push(createTemplateCooked(templateSpan.literal)); + rawStrings.push(getRawLiteral(templateSpan.literal, currentSourceFile)); + templateArguments.push(ts.visitNode(templateSpan.expression, visitor, ts.isExpression)); + } + } + var helperCall = context.getEmitHelperFactory().createTemplateObjectHelper(ts.factory.createArrayLiteralExpression(cookedStrings), ts.factory.createArrayLiteralExpression(rawStrings)); + // Create a variable to cache the template object if we're in a module. + // Do not do this in the global scope, as any variable we currently generate could conflict with + // variables from outside of the current compilation. In the future, we can revisit this behavior. + if (ts.isExternalModule(currentSourceFile)) { + var tempVar = ts.factory.createUniqueName("templateObject"); + recordTaggedTemplateString(tempVar); + templateArguments[0] = ts.factory.createLogicalOr(tempVar, ts.factory.createAssignment(tempVar, helperCall)); + } + else { + templateArguments[0] = helperCall; + } + return ts.factory.createCallExpression(tag, /*typeArguments*/ undefined, templateArguments); + } + ts.processTaggedTemplateExpression = processTaggedTemplateExpression; + function createTemplateCooked(template) { + return template.templateFlags ? ts.factory.createVoidZero() : ts.factory.createStringLiteral(template.text); + } + /** + * Creates an ES5 compatible literal from an ES6 template literal. + * + * @param node The ES6 template literal. + */ + function getRawLiteral(node, currentSourceFile) { + // Find original source text, since we need to emit the raw strings of the tagged template. + // The raw strings contain the (escaped) strings of what the user wrote. + // Examples: `\n` is converted to "\\n", a template string with a newline to "\n". + var text = node.rawText; + if (text === undefined) { + ts.Debug.assertIsDefined(currentSourceFile, "Template literal node is missing 'rawText' and does not have a source file. Possibly bad transform."); + text = ts.getSourceTextOfNodeFromSourceFile(currentSourceFile, node); + // text contains the original source, it will also contain quotes ("`"), dolar signs and braces ("${" and "}"), + // thus we need to remove those characters. + // First template piece starts with "`", others with "}" + // Last template piece ends with "`", others with "${" + var isLast = node.kind === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */ || node.kind === 17 /* SyntaxKind.TemplateTail */; + text = text.substring(1, text.length - (isLast ? 1 : 2)); + } + // Newline normalization: + // ES6 Spec 11.8.6.1 - Static Semantics of TV's and TRV's + // and LineTerminatorSequences are normalized to for both TV and TRV. + text = text.replace(/\r\n?/g, "\n"); + return ts.setTextRange(ts.factory.createStringLiteral(text), node); + } +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + /** + * Indicates whether to emit type metadata in the new format. + */ + var USE_NEW_TYPE_METADATA_FORMAT = false; + var TypeScriptSubstitutionFlags; + (function (TypeScriptSubstitutionFlags) { + /** Enables substitutions for namespace exports. */ + TypeScriptSubstitutionFlags[TypeScriptSubstitutionFlags["NamespaceExports"] = 2] = "NamespaceExports"; + /* Enables substitutions for unqualified enum members */ + TypeScriptSubstitutionFlags[TypeScriptSubstitutionFlags["NonQualifiedEnumMembers"] = 8] = "NonQualifiedEnumMembers"; + })(TypeScriptSubstitutionFlags || (TypeScriptSubstitutionFlags = {})); + var ClassFacts; + (function (ClassFacts) { + ClassFacts[ClassFacts["None"] = 0] = "None"; + ClassFacts[ClassFacts["HasStaticInitializedProperties"] = 1] = "HasStaticInitializedProperties"; + ClassFacts[ClassFacts["HasConstructorDecorators"] = 2] = "HasConstructorDecorators"; + ClassFacts[ClassFacts["HasMemberDecorators"] = 4] = "HasMemberDecorators"; + ClassFacts[ClassFacts["IsExportOfNamespace"] = 8] = "IsExportOfNamespace"; + ClassFacts[ClassFacts["IsNamedExternalExport"] = 16] = "IsNamedExternalExport"; + ClassFacts[ClassFacts["IsDefaultExternalExport"] = 32] = "IsDefaultExternalExport"; + ClassFacts[ClassFacts["IsDerivedClass"] = 64] = "IsDerivedClass"; + ClassFacts[ClassFacts["UseImmediatelyInvokedFunctionExpression"] = 128] = "UseImmediatelyInvokedFunctionExpression"; + ClassFacts[ClassFacts["HasAnyDecorators"] = 6] = "HasAnyDecorators"; + ClassFacts[ClassFacts["NeedsName"] = 5] = "NeedsName"; + ClassFacts[ClassFacts["MayNeedImmediatelyInvokedFunctionExpression"] = 7] = "MayNeedImmediatelyInvokedFunctionExpression"; + ClassFacts[ClassFacts["IsExported"] = 56] = "IsExported"; + })(ClassFacts || (ClassFacts = {})); + function transformTypeScript(context) { + var factory = context.factory, emitHelpers = context.getEmitHelperFactory, startLexicalEnvironment = context.startLexicalEnvironment, resumeLexicalEnvironment = context.resumeLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistVariableDeclaration = context.hoistVariableDeclaration; + var resolver = context.getEmitResolver(); + var compilerOptions = context.getCompilerOptions(); + var languageVersion = ts.getEmitScriptTarget(compilerOptions); + var moduleKind = ts.getEmitModuleKind(compilerOptions); + var typeSerializer = compilerOptions.emitDecoratorMetadata ? ts.createRuntimeTypeSerializer(context) : undefined; + // Save the previous transformation hooks. + var previousOnEmitNode = context.onEmitNode; + var previousOnSubstituteNode = context.onSubstituteNode; + // Set new transformation hooks. + context.onEmitNode = onEmitNode; + context.onSubstituteNode = onSubstituteNode; + // Enable substitution for property/element access to emit const enum values. + context.enableSubstitution(208 /* SyntaxKind.PropertyAccessExpression */); + context.enableSubstitution(209 /* SyntaxKind.ElementAccessExpression */); + // These variables contain state that changes as we descend into the tree. + var currentSourceFile; + var currentNamespace; + var currentNamespaceContainerName; + var currentLexicalScope; + var currentScopeFirstDeclarationsOfName; + var currentClassHasParameterProperties; + /** + * Keeps track of whether expression substitution has been enabled for specific edge cases. + * They are persisted between each SourceFile transformation and should not be reset. + */ + var enabledSubstitutions; + /** + * Keeps track of whether we are within any containing namespaces when performing + * just-in-time substitution while printing an expression identifier. + */ + var applicableSubstitutions; + return transformSourceFileOrBundle; + function transformSourceFileOrBundle(node) { + if (node.kind === 309 /* SyntaxKind.Bundle */) { + return transformBundle(node); + } + return transformSourceFile(node); + } + function transformBundle(node) { + return factory.createBundle(node.sourceFiles.map(transformSourceFile), ts.mapDefined(node.prepends, function (prepend) { + if (prepend.kind === 311 /* SyntaxKind.InputFiles */) { + return ts.createUnparsedSourceFile(prepend, "js"); + } + return prepend; + })); + } + /** + * Transform TypeScript-specific syntax in a SourceFile. + * + * @param node A SourceFile node. + */ + function transformSourceFile(node) { + if (node.isDeclarationFile) { + return node; + } + currentSourceFile = node; + var visited = saveStateAndInvoke(node, visitSourceFile); + ts.addEmitHelpers(visited, context.readEmitHelpers()); + currentSourceFile = undefined; + return visited; + } + /** + * Visits a node, saving and restoring state variables on the stack. + * + * @param node The node to visit. + */ + function saveStateAndInvoke(node, f) { + // Save state + var savedCurrentScope = currentLexicalScope; + var savedCurrentScopeFirstDeclarationsOfName = currentScopeFirstDeclarationsOfName; + var savedCurrentClassHasParameterProperties = currentClassHasParameterProperties; + // Handle state changes before visiting a node. + onBeforeVisitNode(node); + var visited = f(node); + // Restore state + if (currentLexicalScope !== savedCurrentScope) { + currentScopeFirstDeclarationsOfName = savedCurrentScopeFirstDeclarationsOfName; + } + currentLexicalScope = savedCurrentScope; + currentClassHasParameterProperties = savedCurrentClassHasParameterProperties; + return visited; + } + /** + * Performs actions that should always occur immediately before visiting a node. + * + * @param node The node to visit. + */ + function onBeforeVisitNode(node) { + switch (node.kind) { + case 308 /* SyntaxKind.SourceFile */: + case 266 /* SyntaxKind.CaseBlock */: + case 265 /* SyntaxKind.ModuleBlock */: + case 238 /* SyntaxKind.Block */: + currentLexicalScope = node; + currentScopeFirstDeclarationsOfName = undefined; + break; + case 260 /* SyntaxKind.ClassDeclaration */: + case 259 /* SyntaxKind.FunctionDeclaration */: + if (ts.hasSyntacticModifier(node, 2 /* ModifierFlags.Ambient */)) { + break; + } + // Record these declarations provided that they have a name. + if (node.name) { + recordEmittedDeclarationInScope(node); + } + else { + // These nodes should always have names unless they are default-exports; + // however, class declaration parsing allows for undefined names, so syntactically invalid + // programs may also have an undefined name. + ts.Debug.assert(node.kind === 260 /* SyntaxKind.ClassDeclaration */ || ts.hasSyntacticModifier(node, 1024 /* ModifierFlags.Default */)); + } + break; + } + } + /** + * General-purpose node visitor. + * + * @param node The node to visit. + */ + function visitor(node) { + return saveStateAndInvoke(node, visitorWorker); + } + /** + * Visits and possibly transforms any node. + * + * @param node The node to visit. + */ + function visitorWorker(node) { + if (node.transformFlags & 1 /* TransformFlags.ContainsTypeScript */) { + return visitTypeScript(node); + } + return node; + } + /** + * Specialized visitor that visits the immediate children of a SourceFile. + * + * @param node The node to visit. + */ + function sourceElementVisitor(node) { + return saveStateAndInvoke(node, sourceElementVisitorWorker); + } + /** + * Specialized visitor that visits the immediate children of a SourceFile. + * + * @param node The node to visit. + */ + function sourceElementVisitorWorker(node) { + switch (node.kind) { + case 269 /* SyntaxKind.ImportDeclaration */: + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + case 274 /* SyntaxKind.ExportAssignment */: + case 275 /* SyntaxKind.ExportDeclaration */: + return visitElidableStatement(node); + default: + return visitorWorker(node); + } + } + function visitElidableStatement(node) { + var parsed = ts.getParseTreeNode(node); + if (parsed !== node) { + // If the node has been transformed by a `before` transformer, perform no ellision on it + // As the type information we would attempt to lookup to perform ellision is potentially unavailable for the synthesized nodes + // We do not reuse `visitorWorker`, as the ellidable statement syntax kinds are technically unrecognized by the switch-case in `visitTypeScript`, + // and will trigger debug failures when debug verbosity is turned up + if (node.transformFlags & 1 /* TransformFlags.ContainsTypeScript */) { + // This node contains TypeScript, so we should visit its children. + return ts.visitEachChild(node, visitor, context); + } + // Otherwise, we can just return the node + return node; + } + switch (node.kind) { + case 269 /* SyntaxKind.ImportDeclaration */: + return visitImportDeclaration(node); + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return visitImportEqualsDeclaration(node); + case 274 /* SyntaxKind.ExportAssignment */: + return visitExportAssignment(node); + case 275 /* SyntaxKind.ExportDeclaration */: + return visitExportDeclaration(node); + default: + ts.Debug.fail("Unhandled ellided statement"); + } + } + /** + * Specialized visitor that visits the immediate children of a namespace. + * + * @param node The node to visit. + */ + function namespaceElementVisitor(node) { + return saveStateAndInvoke(node, namespaceElementVisitorWorker); + } + /** + * Specialized visitor that visits the immediate children of a namespace. + * + * @param node The node to visit. + */ + function namespaceElementVisitorWorker(node) { + if (node.kind === 275 /* SyntaxKind.ExportDeclaration */ || + node.kind === 269 /* SyntaxKind.ImportDeclaration */ || + node.kind === 270 /* SyntaxKind.ImportClause */ || + (node.kind === 268 /* SyntaxKind.ImportEqualsDeclaration */ && + node.moduleReference.kind === 280 /* SyntaxKind.ExternalModuleReference */)) { + // do not emit ES6 imports and exports since they are illegal inside a namespace + return undefined; + } + else if (node.transformFlags & 1 /* TransformFlags.ContainsTypeScript */ || ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */)) { + return visitTypeScript(node); + } + return node; + } + /** + * Gets a specialized visitor that visits the immediate children of a class with TypeScript syntax. + * + * @param parent The class containing the elements to visit. + */ + function getClassElementVisitor(parent) { + return function (node) { return saveStateAndInvoke(node, function (n) { return classElementVisitorWorker(n, parent); }); }; + } + /** + * Specialized visitor that visits the immediate children of a class with TypeScript syntax. + * + * @param node The node to visit. + */ + function classElementVisitorWorker(node, parent) { + switch (node.kind) { + case 173 /* SyntaxKind.Constructor */: + return visitConstructor(node); + case 169 /* SyntaxKind.PropertyDeclaration */: + // Property declarations are not TypeScript syntax, but they must be visited + // for the decorator transformation. + return visitPropertyDeclaration(node, parent); + case 174 /* SyntaxKind.GetAccessor */: + // Get Accessors can have TypeScript modifiers, decorators, and type annotations. + return visitGetAccessor(node, parent); + case 175 /* SyntaxKind.SetAccessor */: + // Set Accessors can have TypeScript modifiers and type annotations. + return visitSetAccessor(node, parent); + case 171 /* SyntaxKind.MethodDeclaration */: + // TypeScript method declarations may have decorators, modifiers + // or type annotations. + return visitMethodDeclaration(node, parent); + case 172 /* SyntaxKind.ClassStaticBlockDeclaration */: + return ts.visitEachChild(node, visitor, context); + case 237 /* SyntaxKind.SemicolonClassElement */: + return node; + case 178 /* SyntaxKind.IndexSignature */: + // Index signatures are elided + return; + default: + return ts.Debug.failBadSyntaxKind(node); + } + } + function getObjectLiteralElementVisitor(parent) { + return function (node) { return saveStateAndInvoke(node, function (n) { return objectLiteralElementVisitorWorker(n, parent); }); }; + } + function objectLiteralElementVisitorWorker(node, parent) { + switch (node.kind) { + case 299 /* SyntaxKind.PropertyAssignment */: + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + case 301 /* SyntaxKind.SpreadAssignment */: + return visitor(node); + case 174 /* SyntaxKind.GetAccessor */: + // Get Accessors can have TypeScript modifiers, decorators, and type annotations. + return visitGetAccessor(node, parent); + case 175 /* SyntaxKind.SetAccessor */: + // Set Accessors can have TypeScript modifiers and type annotations. + return visitSetAccessor(node, parent); + case 171 /* SyntaxKind.MethodDeclaration */: + // TypeScript method declarations may have decorators, modifiers + // or type annotations. + return visitMethodDeclaration(node, parent); + default: + return ts.Debug.failBadSyntaxKind(node); + } + } + function modifierVisitor(node) { + if (ts.isDecorator(node)) + return undefined; + if (ts.modifierToFlag(node.kind) & 117086 /* ModifierFlags.TypeScriptModifier */) { + return undefined; + } + else if (currentNamespace && node.kind === 93 /* SyntaxKind.ExportKeyword */) { + return undefined; + } + return node; + } + /** + * Branching visitor, visits a TypeScript syntax node. + * + * @param node The node to visit. + */ + function visitTypeScript(node) { + if (ts.isStatement(node) && ts.hasSyntacticModifier(node, 2 /* ModifierFlags.Ambient */)) { + // TypeScript ambient declarations are elided, but some comments may be preserved. + // See the implementation of `getLeadingComments` in comments.ts for more details. + return factory.createNotEmittedStatement(node); + } + switch (node.kind) { + case 93 /* SyntaxKind.ExportKeyword */: + case 88 /* SyntaxKind.DefaultKeyword */: + // ES6 export and default modifiers are elided when inside a namespace. + return currentNamespace ? undefined : node; + case 123 /* SyntaxKind.PublicKeyword */: + case 121 /* SyntaxKind.PrivateKeyword */: + case 122 /* SyntaxKind.ProtectedKeyword */: + case 126 /* SyntaxKind.AbstractKeyword */: + case 161 /* SyntaxKind.OverrideKeyword */: + case 85 /* SyntaxKind.ConstKeyword */: + case 136 /* SyntaxKind.DeclareKeyword */: + case 146 /* SyntaxKind.ReadonlyKeyword */: + case 101 /* SyntaxKind.InKeyword */: + case 145 /* SyntaxKind.OutKeyword */: + // TypeScript accessibility and readonly modifiers are elided + // falls through + case 185 /* SyntaxKind.ArrayType */: + case 186 /* SyntaxKind.TupleType */: + case 187 /* SyntaxKind.OptionalType */: + case 188 /* SyntaxKind.RestType */: + case 184 /* SyntaxKind.TypeLiteral */: + case 179 /* SyntaxKind.TypePredicate */: + case 165 /* SyntaxKind.TypeParameter */: + case 131 /* SyntaxKind.AnyKeyword */: + case 157 /* SyntaxKind.UnknownKeyword */: + case 134 /* SyntaxKind.BooleanKeyword */: + case 152 /* SyntaxKind.StringKeyword */: + case 148 /* SyntaxKind.NumberKeyword */: + case 144 /* SyntaxKind.NeverKeyword */: + case 114 /* SyntaxKind.VoidKeyword */: + case 153 /* SyntaxKind.SymbolKeyword */: + case 182 /* SyntaxKind.ConstructorType */: + case 181 /* SyntaxKind.FunctionType */: + case 183 /* SyntaxKind.TypeQuery */: + case 180 /* SyntaxKind.TypeReference */: + case 189 /* SyntaxKind.UnionType */: + case 190 /* SyntaxKind.IntersectionType */: + case 191 /* SyntaxKind.ConditionalType */: + case 193 /* SyntaxKind.ParenthesizedType */: + case 194 /* SyntaxKind.ThisType */: + case 195 /* SyntaxKind.TypeOperator */: + case 196 /* SyntaxKind.IndexedAccessType */: + case 197 /* SyntaxKind.MappedType */: + case 198 /* SyntaxKind.LiteralType */: + // TypeScript type nodes are elided. + // falls through + case 178 /* SyntaxKind.IndexSignature */: + // TypeScript index signatures are elided. + return undefined; + case 262 /* SyntaxKind.TypeAliasDeclaration */: + // TypeScript type-only declarations are elided. + return factory.createNotEmittedStatement(node); + case 267 /* SyntaxKind.NamespaceExportDeclaration */: + // TypeScript namespace export declarations are elided. + return undefined; + case 261 /* SyntaxKind.InterfaceDeclaration */: + // TypeScript interfaces are elided, but some comments may be preserved. + // See the implementation of `getLeadingComments` in comments.ts for more details. + return factory.createNotEmittedStatement(node); + case 260 /* SyntaxKind.ClassDeclaration */: + // This may be a class declaration with TypeScript syntax extensions. + // + // TypeScript class syntax extensions include: + // - decorators + // - optional `implements` heritage clause + // - parameter property assignments in the constructor + // - index signatures + // - method overload signatures + return visitClassDeclaration(node); + case 228 /* SyntaxKind.ClassExpression */: + // This may be a class expression with TypeScript syntax extensions. + // + // TypeScript class syntax extensions include: + // - decorators + // - optional `implements` heritage clause + // - parameter property assignments in the constructor + // - index signatures + // - method overload signatures + return visitClassExpression(node); + case 294 /* SyntaxKind.HeritageClause */: + // This may be a heritage clause with TypeScript syntax extensions. + // + // TypeScript heritage clause extensions include: + // - `implements` clause + return visitHeritageClause(node); + case 230 /* SyntaxKind.ExpressionWithTypeArguments */: + // TypeScript supports type arguments on an expression in an `extends` heritage clause. + return visitExpressionWithTypeArguments(node); + case 207 /* SyntaxKind.ObjectLiteralExpression */: + return visitObjectLiteralExpression(node); + case 173 /* SyntaxKind.Constructor */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 172 /* SyntaxKind.ClassStaticBlockDeclaration */: + return ts.Debug.fail("Class and object literal elements must be visited with their respective visitors"); + case 259 /* SyntaxKind.FunctionDeclaration */: + // Typescript function declarations can have modifiers, decorators, and type annotations. + return visitFunctionDeclaration(node); + case 215 /* SyntaxKind.FunctionExpression */: + // TypeScript function expressions can have modifiers and type annotations. + return visitFunctionExpression(node); + case 216 /* SyntaxKind.ArrowFunction */: + // TypeScript arrow functions can have modifiers and type annotations. + return visitArrowFunction(node); + case 166 /* SyntaxKind.Parameter */: + // This may be a parameter declaration with TypeScript syntax extensions. + // + // TypeScript parameter declaration syntax extensions include: + // - decorators + // - accessibility modifiers + // - the question mark (?) token for optional parameters + // - type annotations + // - this parameters + return visitParameter(node); + case 214 /* SyntaxKind.ParenthesizedExpression */: + // ParenthesizedExpressions are TypeScript if their expression is a + // TypeAssertion or AsExpression + return visitParenthesizedExpression(node); + case 213 /* SyntaxKind.TypeAssertionExpression */: + case 231 /* SyntaxKind.AsExpression */: + // TypeScript type assertions are removed, but their subtrees are preserved. + return visitAssertionExpression(node); + case 235 /* SyntaxKind.SatisfiesExpression */: + return visitSatisfiesExpression(node); + case 210 /* SyntaxKind.CallExpression */: + return visitCallExpression(node); + case 211 /* SyntaxKind.NewExpression */: + return visitNewExpression(node); + case 212 /* SyntaxKind.TaggedTemplateExpression */: + return visitTaggedTemplateExpression(node); + case 232 /* SyntaxKind.NonNullExpression */: + // TypeScript non-null expressions are removed, but their subtrees are preserved. + return visitNonNullExpression(node); + case 263 /* SyntaxKind.EnumDeclaration */: + // TypeScript enum declarations do not exist in ES6 and must be rewritten. + return visitEnumDeclaration(node); + case 240 /* SyntaxKind.VariableStatement */: + // TypeScript namespace exports for variable statements must be transformed. + return visitVariableStatement(node); + case 257 /* SyntaxKind.VariableDeclaration */: + return visitVariableDeclaration(node); + case 264 /* SyntaxKind.ModuleDeclaration */: + // TypeScript namespace declarations must be transformed. + return visitModuleDeclaration(node); + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + // TypeScript namespace or external module import. + return visitImportEqualsDeclaration(node); + case 282 /* SyntaxKind.JsxSelfClosingElement */: + return visitJsxSelfClosingElement(node); + case 283 /* SyntaxKind.JsxOpeningElement */: + return visitJsxJsxOpeningElement(node); + default: + // node contains some other TypeScript syntax + return ts.visitEachChild(node, visitor, context); + } + } + function visitSourceFile(node) { + var alwaysStrict = ts.getStrictOptionValue(compilerOptions, "alwaysStrict") && + !(ts.isExternalModule(node) && moduleKind >= ts.ModuleKind.ES2015) && + !ts.isJsonSourceFile(node); + return factory.updateSourceFile(node, ts.visitLexicalEnvironment(node.statements, sourceElementVisitor, context, /*start*/ 0, alwaysStrict)); + } + function visitObjectLiteralExpression(node) { + return factory.updateObjectLiteralExpression(node, ts.visitNodes(node.properties, getObjectLiteralElementVisitor(node), ts.isObjectLiteralElement)); + } + function getClassFacts(node, staticProperties) { + var facts = 0 /* ClassFacts.None */; + if (ts.some(staticProperties)) + facts |= 1 /* ClassFacts.HasStaticInitializedProperties */; + var extendsClauseElement = ts.getEffectiveBaseTypeNode(node); + if (extendsClauseElement && ts.skipOuterExpressions(extendsClauseElement.expression).kind !== 104 /* SyntaxKind.NullKeyword */) + facts |= 64 /* ClassFacts.IsDerivedClass */; + if (ts.classOrConstructorParameterIsDecorated(node)) + facts |= 2 /* ClassFacts.HasConstructorDecorators */; + if (ts.childIsDecorated(node)) + facts |= 4 /* ClassFacts.HasMemberDecorators */; + if (isExportOfNamespace(node)) + facts |= 8 /* ClassFacts.IsExportOfNamespace */; + else if (isDefaultExternalModuleExport(node)) + facts |= 32 /* ClassFacts.IsDefaultExternalExport */; + else if (isNamedExternalModuleExport(node)) + facts |= 16 /* ClassFacts.IsNamedExternalExport */; + if (languageVersion <= 1 /* ScriptTarget.ES5 */ && (facts & 7 /* ClassFacts.MayNeedImmediatelyInvokedFunctionExpression */)) + facts |= 128 /* ClassFacts.UseImmediatelyInvokedFunctionExpression */; + return facts; + } + function hasTypeScriptClassSyntax(node) { + return !!(node.transformFlags & 8192 /* TransformFlags.ContainsTypeScriptClassSyntax */); + } + function isClassLikeDeclarationWithTypeScriptSyntax(node) { + return ts.hasDecorators(node) + || ts.some(node.typeParameters) + || ts.some(node.heritageClauses, hasTypeScriptClassSyntax) + || ts.some(node.members, hasTypeScriptClassSyntax); + } + function visitClassDeclaration(node) { + if (!isClassLikeDeclarationWithTypeScriptSyntax(node) && !(currentNamespace && ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */))) { + return factory.updateClassDeclaration(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), node.name, + /*typeParameters*/ undefined, ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause), ts.visitNodes(node.members, getClassElementVisitor(node), ts.isClassElement)); + } + var staticProperties = ts.getProperties(node, /*requireInitializer*/ true, /*isStatic*/ true); + var facts = getClassFacts(node, staticProperties); + if (facts & 128 /* ClassFacts.UseImmediatelyInvokedFunctionExpression */) { + context.startLexicalEnvironment(); + } + var name = node.name || (facts & 5 /* ClassFacts.NeedsName */ ? factory.getGeneratedNameForNode(node) : undefined); + var allDecorators = ts.getAllDecoratorsOfClass(node); + var decorators = transformAllDecoratorsOfDeclaration(node, node, allDecorators); + // we do not emit modifiers on the declaration if we are emitting an IIFE + var modifiers = !(facts & 128 /* ClassFacts.UseImmediatelyInvokedFunctionExpression */) + ? ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier) + : ts.elideNodes(factory, node.modifiers); // preserve positions, if available + // ${modifiers} class ${name} ${heritageClauses} { + // ${members} + // } + var classStatement = factory.updateClassDeclaration(node, ts.concatenate(decorators, modifiers), name, + /*typeParameters*/ undefined, ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause), transformClassMembers(node)); + // To better align with the old emitter, we should not emit a trailing source map + // entry if the class has static properties. + var emitFlags = ts.getEmitFlags(node); + if (facts & 1 /* ClassFacts.HasStaticInitializedProperties */) { + emitFlags |= 32 /* EmitFlags.NoTrailingSourceMap */; + } + ts.setEmitFlags(classStatement, emitFlags); + var statements = [classStatement]; + if (facts & 128 /* ClassFacts.UseImmediatelyInvokedFunctionExpression */) { + // When we emit a TypeScript class down to ES5, we must wrap it in an IIFE so that the + // 'es2015' transformer can properly nest static initializers and decorators. The result + // looks something like: + // + // var C = function () { + // class C { + // } + // C.static_prop = 1; + // return C; + // }(); + // + var closingBraceLocation = ts.createTokenRange(ts.skipTrivia(currentSourceFile.text, node.members.end), 19 /* SyntaxKind.CloseBraceToken */); + var localName = factory.getInternalName(node); + // The following partially-emitted expression exists purely to align our sourcemap + // emit with the original emitter. + var outer = factory.createPartiallyEmittedExpression(localName); + ts.setTextRangeEnd(outer, closingBraceLocation.end); + ts.setEmitFlags(outer, 1536 /* EmitFlags.NoComments */); + var statement = factory.createReturnStatement(outer); + ts.setTextRangePos(statement, closingBraceLocation.pos); + ts.setEmitFlags(statement, 1536 /* EmitFlags.NoComments */ | 384 /* EmitFlags.NoTokenSourceMaps */); + statements.push(statement); + ts.insertStatementsAfterStandardPrologue(statements, context.endLexicalEnvironment()); + var iife = factory.createImmediatelyInvokedArrowFunction(statements); + ts.setEmitFlags(iife, 33554432 /* EmitFlags.TypeScriptClassWrapper */); + var varStatement = factory.createVariableStatement( + /*modifiers*/ undefined, factory.createVariableDeclarationList([ + factory.createVariableDeclaration(factory.getLocalName(node, /*allowComments*/ false, /*allowSourceMaps*/ false), + /*exclamationToken*/ undefined, + /*type*/ undefined, iife) + ])); + ts.setOriginalNode(varStatement, node); + ts.setCommentRange(varStatement, node); + ts.setSourceMapRange(varStatement, ts.moveRangePastDecorators(node)); + ts.startOnNewLine(varStatement); + statements = [varStatement]; + } + // If the class is exported as part of a TypeScript namespace, emit the namespace export. + // Otherwise, if the class was exported at the top level and was decorated, emit an export + // declaration or export default for the class. + if (facts & 8 /* ClassFacts.IsExportOfNamespace */) { + addExportMemberAssignment(statements, node); + } + else if (facts & 128 /* ClassFacts.UseImmediatelyInvokedFunctionExpression */ || facts & 2 /* ClassFacts.HasConstructorDecorators */) { + if (facts & 32 /* ClassFacts.IsDefaultExternalExport */) { + statements.push(factory.createExportDefault(factory.getLocalName(node, /*allowComments*/ false, /*allowSourceMaps*/ true))); + } + else if (facts & 16 /* ClassFacts.IsNamedExternalExport */) { + statements.push(factory.createExternalModuleExport(factory.getLocalName(node, /*allowComments*/ false, /*allowSourceMaps*/ true))); + } + } + if (statements.length > 1) { + // Add a DeclarationMarker as a marker for the end of the declaration + statements.push(factory.createEndOfDeclarationMarker(node)); + ts.setEmitFlags(classStatement, ts.getEmitFlags(classStatement) | 4194304 /* EmitFlags.HasEndOfDeclarationMarker */); + } + return ts.singleOrMany(statements); + } + function visitClassExpression(node) { + var allDecorators = ts.getAllDecoratorsOfClass(node); + var decorators = transformAllDecoratorsOfDeclaration(node, node, allDecorators); + return factory.updateClassExpression(node, decorators, node.name, + /*typeParameters*/ undefined, ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause), isClassLikeDeclarationWithTypeScriptSyntax(node) ? + transformClassMembers(node) : + ts.visitNodes(node.members, getClassElementVisitor(node), ts.isClassElement)); + } + /** + * Transforms the members of a class. + * + * @param node The current class. + */ + function transformClassMembers(node) { + var members = []; + var constructor = ts.getFirstConstructorWithBody(node); + var parametersWithPropertyAssignments = constructor && + ts.filter(constructor.parameters, function (p) { return ts.isParameterPropertyDeclaration(p, constructor); }); + if (parametersWithPropertyAssignments) { + for (var _i = 0, parametersWithPropertyAssignments_1 = parametersWithPropertyAssignments; _i < parametersWithPropertyAssignments_1.length; _i++) { + var parameter = parametersWithPropertyAssignments_1[_i]; + if (ts.isIdentifier(parameter.name)) { + members.push(ts.setOriginalNode(factory.createPropertyDeclaration( + /*modifiers*/ undefined, parameter.name, + /*questionOrExclamationToken*/ undefined, + /*type*/ undefined, + /*initializer*/ undefined), parameter)); + } + } + } + ts.addRange(members, ts.visitNodes(node.members, getClassElementVisitor(node), ts.isClassElement)); + return ts.setTextRange(factory.createNodeArray(members), /*location*/ node.members); + } + /** + * Transforms all of the decorators for a declaration into an array of expressions. + * + * @param node The declaration node. + * @param allDecorators An object containing all of the decorators for the declaration. + */ + function transformAllDecoratorsOfDeclaration(node, container, allDecorators) { + var _a, _b, _c, _d; + if (!allDecorators) { + return undefined; + } + var decorators = ts.visitArray(allDecorators.decorators, visitor, ts.isDecorator); + var parameterDecorators = ts.flatMap(allDecorators.parameters, transformDecoratorsOfParameter); + var metadataDecorators = ts.some(decorators) || ts.some(parameterDecorators) ? getTypeMetadata(node, container) : undefined; + var result = factory.createNodeArray(ts.concatenate(ts.concatenate(decorators, parameterDecorators), metadataDecorators)); + var pos = (_b = (_a = ts.firstOrUndefined(allDecorators.decorators)) === null || _a === void 0 ? void 0 : _a.pos) !== null && _b !== void 0 ? _b : -1; + var end = (_d = (_c = ts.lastOrUndefined(allDecorators.decorators)) === null || _c === void 0 ? void 0 : _c.end) !== null && _d !== void 0 ? _d : -1; + ts.setTextRangePosEnd(result, pos, end); + return result; + } + /** + * Transforms the decorators of a parameter into decorators of the class/method. + * + * @param parameterDecorators The decorators for the parameter at the provided offset. + * @param parameterOffset The offset of the parameter. + */ + function transformDecoratorsOfParameter(parameterDecorators, parameterOffset) { + if (parameterDecorators) { + var decorators = []; + for (var _i = 0, parameterDecorators_1 = parameterDecorators; _i < parameterDecorators_1.length; _i++) { + var parameterDecorator = parameterDecorators_1[_i]; + var expression = ts.visitNode(parameterDecorator.expression, visitor, ts.isExpression); + var helper = emitHelpers().createParamHelper(expression, parameterOffset); + ts.setTextRange(helper, parameterDecorator.expression); + ts.setEmitFlags(helper, 1536 /* EmitFlags.NoComments */); + var decorator = factory.createDecorator(helper); + ts.setSourceMapRange(decorator, parameterDecorator.expression); + ts.setCommentRange(decorator, parameterDecorator.expression); + ts.setEmitFlags(decorator, 1536 /* EmitFlags.NoComments */); + decorators.push(decorator); + } + return decorators; + } + } + /** + * Gets optional type metadata for a declaration. + * + * @param node The declaration node. + */ + function getTypeMetadata(node, container) { + return USE_NEW_TYPE_METADATA_FORMAT ? + getNewTypeMetadata(node, container) : + getOldTypeMetadata(node, container); + } + function getOldTypeMetadata(node, container) { + if (typeSerializer) { + var decorators = void 0; + if (shouldAddTypeMetadata(node)) { + var typeMetadata = emitHelpers().createMetadataHelper("design:type", typeSerializer.serializeTypeOfNode({ currentLexicalScope: currentLexicalScope, currentNameScope: container }, node)); + decorators = ts.append(decorators, factory.createDecorator(typeMetadata)); + } + if (shouldAddParamTypesMetadata(node)) { + var paramTypesMetadata = emitHelpers().createMetadataHelper("design:paramtypes", typeSerializer.serializeParameterTypesOfNode({ currentLexicalScope: currentLexicalScope, currentNameScope: container }, node, container)); + decorators = ts.append(decorators, factory.createDecorator(paramTypesMetadata)); + } + if (shouldAddReturnTypeMetadata(node)) { + var returnTypeMetadata = emitHelpers().createMetadataHelper("design:returntype", typeSerializer.serializeReturnTypeOfNode({ currentLexicalScope: currentLexicalScope, currentNameScope: container }, node)); + decorators = ts.append(decorators, factory.createDecorator(returnTypeMetadata)); + } + return decorators; + } + } + function getNewTypeMetadata(node, container) { + if (typeSerializer) { + var properties = void 0; + if (shouldAddTypeMetadata(node)) { + var typeProperty = factory.createPropertyAssignment("type", factory.createArrowFunction(/*modifiers*/ undefined, /*typeParameters*/ undefined, [], /*type*/ undefined, factory.createToken(38 /* SyntaxKind.EqualsGreaterThanToken */), typeSerializer.serializeTypeOfNode({ currentLexicalScope: currentLexicalScope, currentNameScope: container }, node))); + properties = ts.append(properties, typeProperty); + } + if (shouldAddParamTypesMetadata(node)) { + var paramTypeProperty = factory.createPropertyAssignment("paramTypes", factory.createArrowFunction(/*modifiers*/ undefined, /*typeParameters*/ undefined, [], /*type*/ undefined, factory.createToken(38 /* SyntaxKind.EqualsGreaterThanToken */), typeSerializer.serializeParameterTypesOfNode({ currentLexicalScope: currentLexicalScope, currentNameScope: container }, node, container))); + properties = ts.append(properties, paramTypeProperty); + } + if (shouldAddReturnTypeMetadata(node)) { + var returnTypeProperty = factory.createPropertyAssignment("returnType", factory.createArrowFunction(/*modifiers*/ undefined, /*typeParameters*/ undefined, [], /*type*/ undefined, factory.createToken(38 /* SyntaxKind.EqualsGreaterThanToken */), typeSerializer.serializeReturnTypeOfNode({ currentLexicalScope: currentLexicalScope, currentNameScope: container }, node))); + properties = ts.append(properties, returnTypeProperty); + } + if (properties) { + var typeInfoMetadata = emitHelpers().createMetadataHelper("design:typeinfo", factory.createObjectLiteralExpression(properties, /*multiLine*/ true)); + return [factory.createDecorator(typeInfoMetadata)]; + } + } + } + /** + * Determines whether to emit the "design:type" metadata based on the node's kind. + * The caller should have already tested whether the node has decorators and whether the + * emitDecoratorMetadata compiler option is set. + * + * @param node The node to test. + */ + function shouldAddTypeMetadata(node) { + var kind = node.kind; + return kind === 171 /* SyntaxKind.MethodDeclaration */ + || kind === 174 /* SyntaxKind.GetAccessor */ + || kind === 175 /* SyntaxKind.SetAccessor */ + || kind === 169 /* SyntaxKind.PropertyDeclaration */; + } + /** + * Determines whether to emit the "design:returntype" metadata based on the node's kind. + * The caller should have already tested whether the node has decorators and whether the + * emitDecoratorMetadata compiler option is set. + * + * @param node The node to test. + */ + function shouldAddReturnTypeMetadata(node) { + return node.kind === 171 /* SyntaxKind.MethodDeclaration */; + } + /** + * Determines whether to emit the "design:paramtypes" metadata based on the node's kind. + * The caller should have already tested whether the node has decorators and whether the + * emitDecoratorMetadata compiler option is set. + * + * @param node The node to test. + */ + function shouldAddParamTypesMetadata(node) { + switch (node.kind) { + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + return ts.getFirstConstructorWithBody(node) !== undefined; + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + return true; + } + return false; + } + /** + * Gets an expression that represents a property name (for decorated properties or enums). + * For a computed property, a name is generated for the node. + * + * @param member The member whose name should be converted into an expression. + */ + function getExpressionForPropertyName(member, generateNameForComputedPropertyName) { + var name = member.name; + if (ts.isPrivateIdentifier(name)) { + return factory.createIdentifier(""); + } + else if (ts.isComputedPropertyName(name)) { + return generateNameForComputedPropertyName && !ts.isSimpleInlineableExpression(name.expression) + ? factory.getGeneratedNameForNode(name) + : name.expression; + } + else if (ts.isIdentifier(name)) { + return factory.createStringLiteral(ts.idText(name)); + } + else { + return factory.cloneNode(name); + } + } + /** + * Visits the property name of a class element, for use when emitting property + * initializers. For a computed property on a node with decorators, a temporary + * value is stored for later use. + * + * @param member The member whose name should be visited. + */ + function visitPropertyNameOfClassElement(member) { + var name = member.name; + // Computed property names need to be transformed into a hoisted variable when they are used more than once. + // The names are used more than once when: + // - the property is non-static and its initializer is moved to the constructor (when there are parameter property assignments). + // - the property has a decorator. + if (ts.isComputedPropertyName(name) && ((!ts.hasStaticModifier(member) && currentClassHasParameterProperties) || ts.hasDecorators(member))) { + var expression = ts.visitNode(name.expression, visitor, ts.isExpression); + var innerExpression = ts.skipPartiallyEmittedExpressions(expression); + if (!ts.isSimpleInlineableExpression(innerExpression)) { + var generatedName = factory.getGeneratedNameForNode(name); + hoistVariableDeclaration(generatedName); + return factory.updateComputedPropertyName(name, factory.createAssignment(generatedName, expression)); + } + } + return ts.visitNode(name, visitor, ts.isPropertyName); + } + /** + * Transforms a HeritageClause with TypeScript syntax. + * + * This function will only be called when one of the following conditions are met: + * - The node is a non-`extends` heritage clause that should be elided. + * - The node is an `extends` heritage clause that should be visited, but only allow a single type. + * + * @param node The HeritageClause to transform. + */ + function visitHeritageClause(node) { + if (node.token === 117 /* SyntaxKind.ImplementsKeyword */) { + // implements clauses are elided + return undefined; + } + return ts.visitEachChild(node, visitor, context); + } + /** + * Transforms an ExpressionWithTypeArguments with TypeScript syntax. + * + * This function will only be called when one of the following conditions are met: + * - The node contains type arguments that should be elided. + * + * @param node The ExpressionWithTypeArguments to transform. + */ + function visitExpressionWithTypeArguments(node) { + return factory.updateExpressionWithTypeArguments(node, ts.visitNode(node.expression, visitor, ts.isLeftHandSideExpression), + /*typeArguments*/ undefined); + } + /** + * Determines whether to emit a function-like declaration. We should not emit the + * declaration if it does not have a body. + * + * @param node The declaration node. + */ + function shouldEmitFunctionLikeDeclaration(node) { + return !ts.nodeIsMissing(node.body); + } + function visitPropertyDeclaration(node, parent) { + var isAmbient = node.flags & 16777216 /* NodeFlags.Ambient */ || ts.hasSyntacticModifier(node, 256 /* ModifierFlags.Abstract */); + if (isAmbient && !ts.hasDecorators(node)) { + return undefined; + } + var allDecorators = ts.getAllDecoratorsOfClassElement(node, parent); + var decorators = transformAllDecoratorsOfDeclaration(node, parent, allDecorators); + // Preserve a `declare x` property with decorators to be handled by the decorators transform + if (isAmbient) { + return factory.updatePropertyDeclaration(node, ts.concatenate(decorators, factory.createModifiersFromModifierFlags(2 /* ModifierFlags.Ambient */)), ts.visitNode(node.name, visitor, ts.isPropertyName), + /*questionOrExclamationToken*/ undefined, + /*type*/ undefined, + /*initializer*/ undefined); + } + return factory.updatePropertyDeclaration(node, ts.concatenate(decorators, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifierLike)), visitPropertyNameOfClassElement(node), + /*questionOrExclamationToken*/ undefined, + /*type*/ undefined, ts.visitNode(node.initializer, visitor)); + } + function visitConstructor(node) { + if (!shouldEmitFunctionLikeDeclaration(node)) { + return undefined; + } + return factory.updateConstructorDeclaration(node, + /*modifiers*/ undefined, ts.visitParameterList(node.parameters, visitor, context), transformConstructorBody(node.body, node)); + } + function transformConstructorBody(body, constructor) { + var parametersWithPropertyAssignments = constructor && + ts.filter(constructor.parameters, function (p) { return ts.isParameterPropertyDeclaration(p, constructor); }); + if (!ts.some(parametersWithPropertyAssignments)) { + return ts.visitFunctionBody(body, visitor, context); + } + var statements = []; + resumeLexicalEnvironment(); + var prologueStatementCount = factory.copyPrologue(body.statements, statements, /*ensureUseStrict*/ false, visitor); + var superStatementIndex = ts.findSuperStatementIndex(body.statements, prologueStatementCount); + // If there was a super call, visit existing statements up to and including it + if (superStatementIndex >= 0) { + ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, prologueStatementCount, superStatementIndex + 1 - prologueStatementCount)); + } + // Transform parameters into property assignments. Transforms this: + // + // constructor (public x, public y) { + // } + // + // Into this: + // + // constructor (x, y) { + // this.x = x; + // this.y = y; + // } + // + var parameterPropertyAssignments = ts.mapDefined(parametersWithPropertyAssignments, transformParameterWithPropertyAssignment); + // If there is a super() call, the parameter properties go immediately after it + if (superStatementIndex >= 0) { + ts.addRange(statements, parameterPropertyAssignments); + } + // Since there was no super() call, parameter properties are the first statements in the constructor after any prologue statements + else { + statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, prologueStatementCount), true), parameterPropertyAssignments, true), statements.slice(prologueStatementCount), true); + } + // Add remaining statements from the body, skipping the super() call if it was found and any (already added) prologue statements + var start = superStatementIndex >= 0 ? superStatementIndex + 1 : prologueStatementCount; + ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, start)); + // End the lexical environment. + statements = factory.mergeLexicalEnvironment(statements, endLexicalEnvironment()); + var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), body.statements), /*multiLine*/ true); + ts.setTextRange(block, /*location*/ body); + ts.setOriginalNode(block, body); + return block; + } + /** + * Transforms a parameter into a property assignment statement. + * + * @param node The parameter declaration. + */ + function transformParameterWithPropertyAssignment(node) { + var name = node.name; + if (!ts.isIdentifier(name)) { + return undefined; + } + // TODO(rbuckton): Does this need to be parented? + var propertyName = ts.setParent(ts.setTextRange(factory.cloneNode(name), name), name.parent); + ts.setEmitFlags(propertyName, 1536 /* EmitFlags.NoComments */ | 48 /* EmitFlags.NoSourceMap */); + // TODO(rbuckton): Does this need to be parented? + var localName = ts.setParent(ts.setTextRange(factory.cloneNode(name), name), name.parent); + ts.setEmitFlags(localName, 1536 /* EmitFlags.NoComments */); + return ts.startOnNewLine(ts.removeAllComments(ts.setTextRange(ts.setOriginalNode(factory.createExpressionStatement(factory.createAssignment(ts.setTextRange(factory.createPropertyAccessExpression(factory.createThis(), propertyName), node.name), localName)), node), ts.moveRangePos(node, -1)))); + } + function visitMethodDeclaration(node, parent) { + if (!(node.transformFlags & 1 /* TransformFlags.ContainsTypeScript */)) { + return node; + } + if (!shouldEmitFunctionLikeDeclaration(node)) { + return undefined; + } + var allDecorators = ts.isClassLike(parent) ? ts.getAllDecoratorsOfClassElement(node, parent) : undefined; + var decorators = ts.isClassLike(parent) ? transformAllDecoratorsOfDeclaration(node, parent, allDecorators) : undefined; + return factory.updateMethodDeclaration(node, ts.concatenate(decorators, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifierLike)), node.asteriskToken, visitPropertyNameOfClassElement(node), + /*questionToken*/ undefined, + /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, visitor, context), + /*type*/ undefined, ts.visitFunctionBody(node.body, visitor, context)); + } + /** + * Determines whether to emit an accessor declaration. We should not emit the + * declaration if it does not have a body and is abstract. + * + * @param node The declaration node. + */ + function shouldEmitAccessorDeclaration(node) { + return !(ts.nodeIsMissing(node.body) && ts.hasSyntacticModifier(node, 256 /* ModifierFlags.Abstract */)); + } + function visitGetAccessor(node, parent) { + if (!(node.transformFlags & 1 /* TransformFlags.ContainsTypeScript */)) { + return node; + } + if (!shouldEmitAccessorDeclaration(node)) { + return undefined; + } + var decorators = ts.isClassLike(parent) ? + transformAllDecoratorsOfDeclaration(node, parent, ts.getAllDecoratorsOfClassElement(node, parent)) : + undefined; + return factory.updateGetAccessorDeclaration(node, ts.concatenate(decorators, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifierLike)), visitPropertyNameOfClassElement(node), ts.visitParameterList(node.parameters, visitor, context), + /*type*/ undefined, ts.visitFunctionBody(node.body, visitor, context) || factory.createBlock([])); + } + function visitSetAccessor(node, parent) { + if (!(node.transformFlags & 1 /* TransformFlags.ContainsTypeScript */)) { + return node; + } + if (!shouldEmitAccessorDeclaration(node)) { + return undefined; + } + var decorators = ts.isClassLike(parent) ? + transformAllDecoratorsOfDeclaration(node, parent, ts.getAllDecoratorsOfClassElement(node, parent)) : + undefined; + return factory.updateSetAccessorDeclaration(node, ts.concatenate(decorators, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifierLike)), visitPropertyNameOfClassElement(node), ts.visitParameterList(node.parameters, visitor, context), ts.visitFunctionBody(node.body, visitor, context) || factory.createBlock([])); + } + function visitFunctionDeclaration(node) { + if (!shouldEmitFunctionLikeDeclaration(node)) { + return factory.createNotEmittedStatement(node); + } + var updated = factory.updateFunctionDeclaration(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), node.asteriskToken, node.name, + /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, visitor, context), + /*type*/ undefined, ts.visitFunctionBody(node.body, visitor, context) || factory.createBlock([])); + if (isExportOfNamespace(node)) { + var statements = [updated]; + addExportMemberAssignment(statements, node); + return statements; + } + return updated; + } + function visitFunctionExpression(node) { + if (!shouldEmitFunctionLikeDeclaration(node)) { + return factory.createOmittedExpression(); + } + var updated = factory.updateFunctionExpression(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), node.asteriskToken, node.name, + /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, visitor, context), + /*type*/ undefined, ts.visitFunctionBody(node.body, visitor, context) || factory.createBlock([])); + return updated; + } + function visitArrowFunction(node) { + var updated = factory.updateArrowFunction(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), + /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, visitor, context), + /*type*/ undefined, node.equalsGreaterThanToken, ts.visitFunctionBody(node.body, visitor, context)); + return updated; + } + function visitParameter(node) { + if (ts.parameterIsThisKeyword(node)) { + return undefined; + } + var updated = factory.updateParameterDeclaration(node, ts.elideNodes(factory, node.modifiers), // preserve positions, if available + node.dotDotDotToken, ts.visitNode(node.name, visitor, ts.isBindingName), + /*questionToken*/ undefined, + /*type*/ undefined, ts.visitNode(node.initializer, visitor, ts.isExpression)); + if (updated !== node) { + // While we emit the source map for the node after skipping decorators and modifiers, + // we need to emit the comments for the original range. + ts.setCommentRange(updated, node); + ts.setTextRange(updated, ts.moveRangePastModifiers(node)); + ts.setSourceMapRange(updated, ts.moveRangePastModifiers(node)); + ts.setEmitFlags(updated.name, 32 /* EmitFlags.NoTrailingSourceMap */); + } + return updated; + } + function visitVariableStatement(node) { + if (isExportOfNamespace(node)) { + var variables = ts.getInitializedVariables(node.declarationList); + if (variables.length === 0) { + // elide statement if there are no initialized variables. + return undefined; + } + return ts.setTextRange(factory.createExpressionStatement(factory.inlineExpressions(ts.map(variables, transformInitializedVariable))), node); + } + else { + return ts.visitEachChild(node, visitor, context); + } + } + function transformInitializedVariable(node) { + var name = node.name; + if (ts.isBindingPattern(name)) { + return ts.flattenDestructuringAssignment(node, visitor, context, 0 /* FlattenLevel.All */, + /*needsValue*/ false, createNamespaceExportExpression); + } + else { + return ts.setTextRange(factory.createAssignment(getNamespaceMemberNameWithSourceMapsAndWithoutComments(name), ts.visitNode(node.initializer, visitor, ts.isExpression)), + /*location*/ node); + } + } + function visitVariableDeclaration(node) { + var updated = factory.updateVariableDeclaration(node, ts.visitNode(node.name, visitor, ts.isBindingName), + /*exclamationToken*/ undefined, + /*type*/ undefined, ts.visitNode(node.initializer, visitor, ts.isExpression)); + if (node.type) { + ts.setTypeNode(updated.name, node.type); + } + return updated; + } + function visitParenthesizedExpression(node) { + var innerExpression = ts.skipOuterExpressions(node.expression, ~6 /* OuterExpressionKinds.Assertions */); + if (ts.isAssertionExpression(innerExpression)) { + // Make sure we consider all nested cast expressions, e.g.: + // (-A).x; + var expression = ts.visitNode(node.expression, visitor, ts.isExpression); + // We have an expression of the form: (SubExpr). Emitting this as (SubExpr) + // is really not desirable. We would like to emit the subexpression as-is. Omitting + // the parentheses, however, could cause change in the semantics of the generated + // code if the casted expression has a lower precedence than the rest of the + // expression. + // + // To preserve comments, we return a "PartiallyEmittedExpression" here which will + // preserve the position information of the original expression. + // + // Due to the auto-parenthesization rules used by the visitor and factory functions + // we can safely elide the parentheses here, as a new synthetic + // ParenthesizedExpression will be inserted if we remove parentheses too + // aggressively. + // + // If there are leading comments on the expression itself, the emitter will handle ASI + // for return, throw, and yield by re-introducing parenthesis during emit on an as-need + // basis. + return factory.createPartiallyEmittedExpression(expression, node); + } + return ts.visitEachChild(node, visitor, context); + } + function visitAssertionExpression(node) { + var expression = ts.visitNode(node.expression, visitor, ts.isExpression); + return factory.createPartiallyEmittedExpression(expression, node); + } + function visitNonNullExpression(node) { + var expression = ts.visitNode(node.expression, visitor, ts.isLeftHandSideExpression); + return factory.createPartiallyEmittedExpression(expression, node); + } + function visitSatisfiesExpression(node) { + var expression = ts.visitNode(node.expression, visitor, ts.isExpression); + return factory.createPartiallyEmittedExpression(expression, node); + } + function visitCallExpression(node) { + return factory.updateCallExpression(node, ts.visitNode(node.expression, visitor, ts.isExpression), + /*typeArguments*/ undefined, ts.visitNodes(node.arguments, visitor, ts.isExpression)); + } + function visitNewExpression(node) { + return factory.updateNewExpression(node, ts.visitNode(node.expression, visitor, ts.isExpression), + /*typeArguments*/ undefined, ts.visitNodes(node.arguments, visitor, ts.isExpression)); + } + function visitTaggedTemplateExpression(node) { + return factory.updateTaggedTemplateExpression(node, ts.visitNode(node.tag, visitor, ts.isExpression), + /*typeArguments*/ undefined, ts.visitNode(node.template, visitor, ts.isExpression)); + } + function visitJsxSelfClosingElement(node) { + return factory.updateJsxSelfClosingElement(node, ts.visitNode(node.tagName, visitor, ts.isJsxTagNameExpression), + /*typeArguments*/ undefined, ts.visitNode(node.attributes, visitor, ts.isJsxAttributes)); + } + function visitJsxJsxOpeningElement(node) { + return factory.updateJsxOpeningElement(node, ts.visitNode(node.tagName, visitor, ts.isJsxTagNameExpression), + /*typeArguments*/ undefined, ts.visitNode(node.attributes, visitor, ts.isJsxAttributes)); + } + /** + * Determines whether to emit an enum declaration. + * + * @param node The enum declaration node. + */ + function shouldEmitEnumDeclaration(node) { + return !ts.isEnumConst(node) + || ts.shouldPreserveConstEnums(compilerOptions); + } + /** + * Visits an enum declaration. + * + * This function will be called any time a TypeScript enum is encountered. + * + * @param node The enum declaration node. + */ + function visitEnumDeclaration(node) { + if (!shouldEmitEnumDeclaration(node)) { + return factory.createNotEmittedStatement(node); + } + var statements = []; + // We request to be advised when the printer is about to print this node. This allows + // us to set up the correct state for later substitutions. + var emitFlags = 2 /* EmitFlags.AdviseOnEmitNode */; + // If needed, we should emit a variable declaration for the enum. If we emit + // a leading variable declaration, we should not emit leading comments for the + // enum body. + var varAdded = addVarForEnumOrModuleDeclaration(statements, node); + if (varAdded) { + // We should still emit the comments if we are emitting a system module. + if (moduleKind !== ts.ModuleKind.System || currentLexicalScope !== currentSourceFile) { + emitFlags |= 512 /* EmitFlags.NoLeadingComments */; + } + } + // `parameterName` is the declaration name used inside of the enum. + var parameterName = getNamespaceParameterName(node); + // `containerName` is the expression used inside of the enum for assignments. + var containerName = getNamespaceContainerName(node); + // `exportName` is the expression used within this node's container for any exported references. + var exportName = ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */) + ? factory.getExternalModuleOrNamespaceExportName(currentNamespaceContainerName, node, /*allowComments*/ false, /*allowSourceMaps*/ true) + : factory.getLocalName(node, /*allowComments*/ false, /*allowSourceMaps*/ true); + // x || (x = {}) + // exports.x || (exports.x = {}) + var moduleArg = factory.createLogicalOr(exportName, factory.createAssignment(exportName, factory.createObjectLiteralExpression())); + if (hasNamespaceQualifiedExportName(node)) { + // `localName` is the expression used within this node's containing scope for any local references. + var localName = factory.getLocalName(node, /*allowComments*/ false, /*allowSourceMaps*/ true); + // x = (exports.x || (exports.x = {})) + moduleArg = factory.createAssignment(localName, moduleArg); + } + // (function (x) { + // x[x["y"] = 0] = "y"; + // ... + // })(x || (x = {})); + var enumStatement = factory.createExpressionStatement(factory.createCallExpression(factory.createFunctionExpression( + /*modifiers*/ undefined, + /*asteriskToken*/ undefined, + /*name*/ undefined, + /*typeParameters*/ undefined, [factory.createParameterDeclaration(/*modifiers*/ undefined, /*dotDotDotToken*/ undefined, parameterName)], + /*type*/ undefined, transformEnumBody(node, containerName)), + /*typeArguments*/ undefined, [moduleArg])); + ts.setOriginalNode(enumStatement, node); + if (varAdded) { + // If a variable was added, synthetic comments are emitted on it, not on the moduleStatement. + ts.setSyntheticLeadingComments(enumStatement, undefined); + ts.setSyntheticTrailingComments(enumStatement, undefined); + } + ts.setTextRange(enumStatement, node); + ts.addEmitFlags(enumStatement, emitFlags); + statements.push(enumStatement); + // Add a DeclarationMarker for the enum to preserve trailing comments and mark + // the end of the declaration. + statements.push(factory.createEndOfDeclarationMarker(node)); + return statements; + } + /** + * Transforms the body of an enum declaration. + * + * @param node The enum declaration node. + */ + function transformEnumBody(node, localName) { + var savedCurrentNamespaceLocalName = currentNamespaceContainerName; + currentNamespaceContainerName = localName; + var statements = []; + startLexicalEnvironment(); + var members = ts.map(node.members, transformEnumMember); + ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment()); + ts.addRange(statements, members); + currentNamespaceContainerName = savedCurrentNamespaceLocalName; + return factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), /*location*/ node.members), + /*multiLine*/ true); + } + /** + * Transforms an enum member into a statement. + * + * @param member The enum member node. + */ + function transformEnumMember(member) { + // enums don't support computed properties + // we pass false as 'generateNameForComputedPropertyName' for a backward compatibility purposes + // old emitter always generate 'expression' part of the name as-is. + var name = getExpressionForPropertyName(member, /*generateNameForComputedPropertyName*/ false); + var valueExpression = transformEnumMemberDeclarationValue(member); + var innerAssignment = factory.createAssignment(factory.createElementAccessExpression(currentNamespaceContainerName, name), valueExpression); + var outerAssignment = valueExpression.kind === 10 /* SyntaxKind.StringLiteral */ ? + innerAssignment : + factory.createAssignment(factory.createElementAccessExpression(currentNamespaceContainerName, innerAssignment), name); + return ts.setTextRange(factory.createExpressionStatement(ts.setTextRange(outerAssignment, member)), member); + } + /** + * Transforms the value of an enum member. + * + * @param member The enum member node. + */ + function transformEnumMemberDeclarationValue(member) { + var value = resolver.getConstantValue(member); + if (value !== undefined) { + return typeof value === "string" ? factory.createStringLiteral(value) : factory.createNumericLiteral(value); + } + else { + enableSubstitutionForNonQualifiedEnumMembers(); + if (member.initializer) { + return ts.visitNode(member.initializer, visitor, ts.isExpression); + } + else { + return factory.createVoidZero(); + } + } + } + /** + * Determines whether to elide a module declaration. + * + * @param node The module declaration node. + */ + function shouldEmitModuleDeclaration(nodeIn) { + var node = ts.getParseTreeNode(nodeIn, ts.isModuleDeclaration); + if (!node) { + // If we can't find a parse tree node, assume the node is instantiated. + return true; + } + return ts.isInstantiatedModule(node, ts.shouldPreserveConstEnums(compilerOptions)); + } + /** + * Determines whether an exported declaration will have a qualified export name (e.g. `f.x` + * or `exports.x`). + */ + function hasNamespaceQualifiedExportName(node) { + return isExportOfNamespace(node) + || (isExternalModuleExport(node) + && moduleKind !== ts.ModuleKind.ES2015 + && moduleKind !== ts.ModuleKind.ES2020 + && moduleKind !== ts.ModuleKind.ES2022 + && moduleKind !== ts.ModuleKind.ESNext + && moduleKind !== ts.ModuleKind.System); + } + /** + * Records that a declaration was emitted in the current scope, if it was the first + * declaration for the provided symbol. + */ + function recordEmittedDeclarationInScope(node) { + if (!currentScopeFirstDeclarationsOfName) { + currentScopeFirstDeclarationsOfName = new ts.Map(); + } + var name = declaredNameInScope(node); + if (!currentScopeFirstDeclarationsOfName.has(name)) { + currentScopeFirstDeclarationsOfName.set(name, node); + } + } + /** + * Determines whether a declaration is the first declaration with + * the same name emitted in the current scope. + */ + function isFirstEmittedDeclarationInScope(node) { + if (currentScopeFirstDeclarationsOfName) { + var name = declaredNameInScope(node); + return currentScopeFirstDeclarationsOfName.get(name) === node; + } + return true; + } + function declaredNameInScope(node) { + ts.Debug.assertNode(node.name, ts.isIdentifier); + return node.name.escapedText; + } + /** + * Adds a leading VariableStatement for a enum or module declaration. + */ + function addVarForEnumOrModuleDeclaration(statements, node) { + // Emit a variable statement for the module. We emit top-level enums as a `var` + // declaration to avoid static errors in global scripts scripts due to redeclaration. + // enums in any other scope are emitted as a `let` declaration. + var statement = factory.createVariableStatement(ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), factory.createVariableDeclarationList([ + factory.createVariableDeclaration(factory.getLocalName(node, /*allowComments*/ false, /*allowSourceMaps*/ true)) + ], currentLexicalScope.kind === 308 /* SyntaxKind.SourceFile */ ? 0 /* NodeFlags.None */ : 1 /* NodeFlags.Let */)); + ts.setOriginalNode(statement, node); + recordEmittedDeclarationInScope(node); + if (isFirstEmittedDeclarationInScope(node)) { + // Adjust the source map emit to match the old emitter. + if (node.kind === 263 /* SyntaxKind.EnumDeclaration */) { + ts.setSourceMapRange(statement.declarationList, node); + } + else { + ts.setSourceMapRange(statement, node); + } + // Trailing comments for module declaration should be emitted after the function closure + // instead of the variable statement: + // + // /** Module comment*/ + // module m1 { + // function foo4Export() { + // } + // } // trailing comment module + // + // Should emit: + // + // /** Module comment*/ + // var m1; + // (function (m1) { + // function foo4Export() { + // } + // })(m1 || (m1 = {})); // trailing comment module + // + ts.setCommentRange(statement, node); + ts.addEmitFlags(statement, 1024 /* EmitFlags.NoTrailingComments */ | 4194304 /* EmitFlags.HasEndOfDeclarationMarker */); + statements.push(statement); + return true; + } + else { + // For an EnumDeclaration or ModuleDeclaration that merges with a preceeding + // declaration we do not emit a leading variable declaration. To preserve the + // begin/end semantics of the declararation and to properly handle exports + // we wrap the leading variable declaration in a `MergeDeclarationMarker`. + var mergeMarker = factory.createMergeDeclarationMarker(statement); + ts.setEmitFlags(mergeMarker, 1536 /* EmitFlags.NoComments */ | 4194304 /* EmitFlags.HasEndOfDeclarationMarker */); + statements.push(mergeMarker); + return false; + } + } + /** + * Visits a module declaration node. + * + * This function will be called any time a TypeScript namespace (ModuleDeclaration) is encountered. + * + * @param node The module declaration node. + */ + function visitModuleDeclaration(node) { + if (!shouldEmitModuleDeclaration(node)) { + return factory.createNotEmittedStatement(node); + } + ts.Debug.assertNode(node.name, ts.isIdentifier, "A TypeScript namespace should have an Identifier name."); + enableSubstitutionForNamespaceExports(); + var statements = []; + // We request to be advised when the printer is about to print this node. This allows + // us to set up the correct state for later substitutions. + var emitFlags = 2 /* EmitFlags.AdviseOnEmitNode */; + // If needed, we should emit a variable declaration for the module. If we emit + // a leading variable declaration, we should not emit leading comments for the + // module body. + var varAdded = addVarForEnumOrModuleDeclaration(statements, node); + if (varAdded) { + // We should still emit the comments if we are emitting a system module. + if (moduleKind !== ts.ModuleKind.System || currentLexicalScope !== currentSourceFile) { + emitFlags |= 512 /* EmitFlags.NoLeadingComments */; + } + } + // `parameterName` is the declaration name used inside of the namespace. + var parameterName = getNamespaceParameterName(node); + // `containerName` is the expression used inside of the namespace for exports. + var containerName = getNamespaceContainerName(node); + // `exportName` is the expression used within this node's container for any exported references. + var exportName = ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */) + ? factory.getExternalModuleOrNamespaceExportName(currentNamespaceContainerName, node, /*allowComments*/ false, /*allowSourceMaps*/ true) + : factory.getLocalName(node, /*allowComments*/ false, /*allowSourceMaps*/ true); + // x || (x = {}) + // exports.x || (exports.x = {}) + var moduleArg = factory.createLogicalOr(exportName, factory.createAssignment(exportName, factory.createObjectLiteralExpression())); + if (hasNamespaceQualifiedExportName(node)) { + // `localName` is the expression used within this node's containing scope for any local references. + var localName = factory.getLocalName(node, /*allowComments*/ false, /*allowSourceMaps*/ true); + // x = (exports.x || (exports.x = {})) + moduleArg = factory.createAssignment(localName, moduleArg); + } + // (function (x_1) { + // x_1.y = ...; + // })(x || (x = {})); + var moduleStatement = factory.createExpressionStatement(factory.createCallExpression(factory.createFunctionExpression( + /*modifiers*/ undefined, + /*asteriskToken*/ undefined, + /*name*/ undefined, + /*typeParameters*/ undefined, [factory.createParameterDeclaration(/*modifiers*/ undefined, /*dotDotDotToken*/ undefined, parameterName)], + /*type*/ undefined, transformModuleBody(node, containerName)), + /*typeArguments*/ undefined, [moduleArg])); + ts.setOriginalNode(moduleStatement, node); + if (varAdded) { + // If a variable was added, synthetic comments are emitted on it, not on the moduleStatement. + ts.setSyntheticLeadingComments(moduleStatement, undefined); + ts.setSyntheticTrailingComments(moduleStatement, undefined); + } + ts.setTextRange(moduleStatement, node); + ts.addEmitFlags(moduleStatement, emitFlags); + statements.push(moduleStatement); + // Add a DeclarationMarker for the namespace to preserve trailing comments and mark + // the end of the declaration. + statements.push(factory.createEndOfDeclarationMarker(node)); + return statements; + } + /** + * Transforms the body of a module declaration. + * + * @param node The module declaration node. + */ + function transformModuleBody(node, namespaceLocalName) { + var savedCurrentNamespaceContainerName = currentNamespaceContainerName; + var savedCurrentNamespace = currentNamespace; + var savedCurrentScopeFirstDeclarationsOfName = currentScopeFirstDeclarationsOfName; + currentNamespaceContainerName = namespaceLocalName; + currentNamespace = node; + currentScopeFirstDeclarationsOfName = undefined; + var statements = []; + startLexicalEnvironment(); + var statementsLocation; + var blockLocation; + if (node.body) { + if (node.body.kind === 265 /* SyntaxKind.ModuleBlock */) { + saveStateAndInvoke(node.body, function (body) { return ts.addRange(statements, ts.visitNodes(body.statements, namespaceElementVisitor, ts.isStatement)); }); + statementsLocation = node.body.statements; + blockLocation = node.body; + } + else { + var result = visitModuleDeclaration(node.body); + if (result) { + if (ts.isArray(result)) { + ts.addRange(statements, result); + } + else { + statements.push(result); + } + } + var moduleBlock = getInnerMostModuleDeclarationFromDottedModule(node).body; + statementsLocation = ts.moveRangePos(moduleBlock.statements, -1); + } + } + ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment()); + currentNamespaceContainerName = savedCurrentNamespaceContainerName; + currentNamespace = savedCurrentNamespace; + currentScopeFirstDeclarationsOfName = savedCurrentScopeFirstDeclarationsOfName; + var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), + /*location*/ statementsLocation), + /*multiLine*/ true); + ts.setTextRange(block, blockLocation); + // namespace hello.hi.world { + // function foo() {} + // + // // TODO, blah + // } + // + // should be emitted as + // + // var hello; + // (function (hello) { + // var hi; + // (function (hi) { + // var world; + // (function (world) { + // function foo() { } + // // TODO, blah + // })(world = hi.world || (hi.world = {})); + // })(hi = hello.hi || (hello.hi = {})); + // })(hello || (hello = {})); + // We only want to emit comment on the namespace which contains block body itself, not the containing namespaces. + if (!node.body || node.body.kind !== 265 /* SyntaxKind.ModuleBlock */) { + ts.setEmitFlags(block, ts.getEmitFlags(block) | 1536 /* EmitFlags.NoComments */); + } + return block; + } + function getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration) { + if (moduleDeclaration.body.kind === 264 /* SyntaxKind.ModuleDeclaration */) { + var recursiveInnerModule = getInnerMostModuleDeclarationFromDottedModule(moduleDeclaration.body); + return recursiveInnerModule || moduleDeclaration.body; + } + } + /** + * Visits an import declaration, eliding it if it is type-only or if it has an import clause that may be elided. + * + * @param node The import declaration node. + */ + function visitImportDeclaration(node) { + if (!node.importClause) { + // Do not elide a side-effect only import declaration. + // import "foo"; + return node; + } + if (node.importClause.isTypeOnly) { + // Always elide type-only imports + return undefined; + } + // Elide the declaration if the import clause was elided. + var importClause = ts.visitNode(node.importClause, visitImportClause, ts.isImportClause); + return importClause || + compilerOptions.importsNotUsedAsValues === 1 /* ImportsNotUsedAsValues.Preserve */ || + compilerOptions.importsNotUsedAsValues === 2 /* ImportsNotUsedAsValues.Error */ + ? factory.updateImportDeclaration(node, + /*modifiers*/ undefined, importClause, node.moduleSpecifier, node.assertClause) + : undefined; + } + /** + * Visits an import clause, eliding it if its `name` and `namedBindings` may both be elided. + * + * @param node The import clause node. + */ + function visitImportClause(node) { + ts.Debug.assert(!node.isTypeOnly); + // Elide the import clause if we elide both its name and its named bindings. + var name = shouldEmitAliasDeclaration(node) ? node.name : undefined; + var namedBindings = ts.visitNode(node.namedBindings, visitNamedImportBindings, ts.isNamedImportBindings); + return (name || namedBindings) ? factory.updateImportClause(node, /*isTypeOnly*/ false, name, namedBindings) : undefined; + } + /** + * Visits named import bindings, eliding them if their targets, their references, and the compilation settings allow. + * + * @param node The named import bindings node. + */ + function visitNamedImportBindings(node) { + if (node.kind === 271 /* SyntaxKind.NamespaceImport */) { + // Elide a namespace import if it is not referenced. + return shouldEmitAliasDeclaration(node) ? node : undefined; + } + else { + // Elide named imports if all of its import specifiers are elided and settings allow. + var allowEmpty = compilerOptions.preserveValueImports && (compilerOptions.importsNotUsedAsValues === 1 /* ImportsNotUsedAsValues.Preserve */ || + compilerOptions.importsNotUsedAsValues === 2 /* ImportsNotUsedAsValues.Error */); + var elements = ts.visitNodes(node.elements, visitImportSpecifier, ts.isImportSpecifier); + return allowEmpty || ts.some(elements) ? factory.updateNamedImports(node, elements) : undefined; + } + } + /** + * Visits an import specifier, eliding it if its target, its references, and the compilation settings allow. + * + * @param node The import specifier node. + */ + function visitImportSpecifier(node) { + return !node.isTypeOnly && shouldEmitAliasDeclaration(node) ? node : undefined; + } + /** + * Visits an export assignment, eliding it if it does not contain a clause that resolves + * to a value. + * + * @param node The export assignment node. + */ + function visitExportAssignment(node) { + // Elide the export assignment if it does not reference a value. + return resolver.isValueAliasDeclaration(node) + ? ts.visitEachChild(node, visitor, context) + : undefined; + } + /** + * Visits an export declaration, eliding it if it does not contain a clause that resolves to a value. + * + * @param node The export declaration node. + */ + function visitExportDeclaration(node) { + if (node.isTypeOnly) { + return undefined; + } + if (!node.exportClause || ts.isNamespaceExport(node.exportClause)) { + // never elide `export from ` declarations - + // they should be kept for sideffects/untyped exports, even when the + // type checker doesn't know about any exports + return node; + } + // Elide the export declaration if all of its named exports are elided. + var allowEmpty = !!node.moduleSpecifier && (compilerOptions.importsNotUsedAsValues === 1 /* ImportsNotUsedAsValues.Preserve */ || + compilerOptions.importsNotUsedAsValues === 2 /* ImportsNotUsedAsValues.Error */); + var exportClause = ts.visitNode(node.exportClause, function (bindings) { return visitNamedExportBindings(bindings, allowEmpty); }, ts.isNamedExportBindings); + return exportClause + ? factory.updateExportDeclaration(node, + /*modifiers*/ undefined, node.isTypeOnly, exportClause, node.moduleSpecifier, node.assertClause) + : undefined; + } + /** + * Visits named exports, eliding it if it does not contain an export specifier that + * resolves to a value. + * + * @param node The named exports node. + */ + function visitNamedExports(node, allowEmpty) { + // Elide the named exports if all of its export specifiers were elided. + var elements = ts.visitNodes(node.elements, visitExportSpecifier, ts.isExportSpecifier); + return allowEmpty || ts.some(elements) ? factory.updateNamedExports(node, elements) : undefined; + } + function visitNamespaceExports(node) { + return factory.updateNamespaceExport(node, ts.visitNode(node.name, visitor, ts.isIdentifier)); + } + function visitNamedExportBindings(node, allowEmpty) { + return ts.isNamespaceExport(node) ? visitNamespaceExports(node) : visitNamedExports(node, allowEmpty); + } + /** + * Visits an export specifier, eliding it if it does not resolve to a value. + * + * @param node The export specifier node. + */ + function visitExportSpecifier(node) { + // Elide an export specifier if it does not reference a value. + return !node.isTypeOnly && resolver.isValueAliasDeclaration(node) ? node : undefined; + } + /** + * Determines whether to emit an import equals declaration. + * + * @param node The import equals declaration node. + */ + function shouldEmitImportEqualsDeclaration(node) { + // preserve old compiler's behavior: emit 'var' for import declaration (even if we do not consider them referenced) when + // - current file is not external module + // - import declaration is top level and target is value imported by entity name + return shouldEmitAliasDeclaration(node) + || (!ts.isExternalModule(currentSourceFile) + && resolver.isTopLevelValueImportEqualsWithEntityName(node)); + } + /** + * Visits an import equals declaration. + * + * @param node The import equals declaration node. + */ + function visitImportEqualsDeclaration(node) { + // Always elide type-only imports + if (node.isTypeOnly) { + return undefined; + } + if (ts.isExternalModuleImportEqualsDeclaration(node)) { + var isReferenced = shouldEmitAliasDeclaration(node); + // If the alias is unreferenced but we want to keep the import, replace with 'import "mod"'. + if (!isReferenced && compilerOptions.importsNotUsedAsValues === 1 /* ImportsNotUsedAsValues.Preserve */) { + return ts.setOriginalNode(ts.setTextRange(factory.createImportDeclaration( + /*modifiers*/ undefined, + /*importClause*/ undefined, node.moduleReference.expression, + /*assertClause*/ undefined), node), node); + } + return isReferenced ? ts.visitEachChild(node, visitor, context) : undefined; + } + if (!shouldEmitImportEqualsDeclaration(node)) { + return undefined; + } + var moduleReference = ts.createExpressionFromEntityName(factory, node.moduleReference); + ts.setEmitFlags(moduleReference, 1536 /* EmitFlags.NoComments */ | 2048 /* EmitFlags.NoNestedComments */); + if (isNamedExternalModuleExport(node) || !isExportOfNamespace(node)) { + // export var ${name} = ${moduleReference}; + // var ${name} = ${moduleReference}; + return ts.setOriginalNode(ts.setTextRange(factory.createVariableStatement(ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), factory.createVariableDeclarationList([ + ts.setOriginalNode(factory.createVariableDeclaration(node.name, + /*exclamationToken*/ undefined, + /*type*/ undefined, moduleReference), node) + ])), node), node); + } + else { + // exports.${name} = ${moduleReference}; + return ts.setOriginalNode(createNamespaceExport(node.name, moduleReference, node), node); + } + } + /** + * Gets a value indicating whether the node is exported from a namespace. + * + * @param node The node to test. + */ + function isExportOfNamespace(node) { + return currentNamespace !== undefined && ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */); + } + /** + * Gets a value indicating whether the node is exported from an external module. + * + * @param node The node to test. + */ + function isExternalModuleExport(node) { + return currentNamespace === undefined && ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */); + } + /** + * Gets a value indicating whether the node is a named export from an external module. + * + * @param node The node to test. + */ + function isNamedExternalModuleExport(node) { + return isExternalModuleExport(node) + && !ts.hasSyntacticModifier(node, 1024 /* ModifierFlags.Default */); + } + /** + * Gets a value indicating whether the node is the default export of an external module. + * + * @param node The node to test. + */ + function isDefaultExternalModuleExport(node) { + return isExternalModuleExport(node) + && ts.hasSyntacticModifier(node, 1024 /* ModifierFlags.Default */); + } + function addExportMemberAssignment(statements, node) { + var expression = factory.createAssignment(factory.getExternalModuleOrNamespaceExportName(currentNamespaceContainerName, node, /*allowComments*/ false, /*allowSourceMaps*/ true), factory.getLocalName(node)); + ts.setSourceMapRange(expression, ts.createRange(node.name ? node.name.pos : node.pos, node.end)); + var statement = factory.createExpressionStatement(expression); + ts.setSourceMapRange(statement, ts.createRange(-1, node.end)); + statements.push(statement); + } + function createNamespaceExport(exportName, exportValue, location) { + return ts.setTextRange(factory.createExpressionStatement(factory.createAssignment(factory.getNamespaceMemberName(currentNamespaceContainerName, exportName, /*allowComments*/ false, /*allowSourceMaps*/ true), exportValue)), location); + } + function createNamespaceExportExpression(exportName, exportValue, location) { + return ts.setTextRange(factory.createAssignment(getNamespaceMemberNameWithSourceMapsAndWithoutComments(exportName), exportValue), location); + } + function getNamespaceMemberNameWithSourceMapsAndWithoutComments(name) { + return factory.getNamespaceMemberName(currentNamespaceContainerName, name, /*allowComments*/ false, /*allowSourceMaps*/ true); + } + /** + * Gets the declaration name used inside of a namespace or enum. + */ + function getNamespaceParameterName(node) { + var name = factory.getGeneratedNameForNode(node); + ts.setSourceMapRange(name, node.name); + return name; + } + /** + * Gets the expression used to refer to a namespace or enum within the body + * of its declaration. + */ + function getNamespaceContainerName(node) { + return factory.getGeneratedNameForNode(node); + } + function enableSubstitutionForNonQualifiedEnumMembers() { + if ((enabledSubstitutions & 8 /* TypeScriptSubstitutionFlags.NonQualifiedEnumMembers */) === 0) { + enabledSubstitutions |= 8 /* TypeScriptSubstitutionFlags.NonQualifiedEnumMembers */; + context.enableSubstitution(79 /* SyntaxKind.Identifier */); + } + } + function enableSubstitutionForNamespaceExports() { + if ((enabledSubstitutions & 2 /* TypeScriptSubstitutionFlags.NamespaceExports */) === 0) { + enabledSubstitutions |= 2 /* TypeScriptSubstitutionFlags.NamespaceExports */; + // We need to enable substitutions for identifiers and shorthand property assignments. This allows us to + // substitute the names of exported members of a namespace. + context.enableSubstitution(79 /* SyntaxKind.Identifier */); + context.enableSubstitution(300 /* SyntaxKind.ShorthandPropertyAssignment */); + // We need to be notified when entering and exiting namespaces. + context.enableEmitNotification(264 /* SyntaxKind.ModuleDeclaration */); + } + } + function isTransformedModuleDeclaration(node) { + return ts.getOriginalNode(node).kind === 264 /* SyntaxKind.ModuleDeclaration */; + } + function isTransformedEnumDeclaration(node) { + return ts.getOriginalNode(node).kind === 263 /* SyntaxKind.EnumDeclaration */; + } + /** + * Hook for node emit. + * + * @param hint A hint as to the intended usage of the node. + * @param node The node to emit. + * @param emit A callback used to emit the node in the printer. + */ + function onEmitNode(hint, node, emitCallback) { + var savedApplicableSubstitutions = applicableSubstitutions; + var savedCurrentSourceFile = currentSourceFile; + if (ts.isSourceFile(node)) { + currentSourceFile = node; + } + if (enabledSubstitutions & 2 /* TypeScriptSubstitutionFlags.NamespaceExports */ && isTransformedModuleDeclaration(node)) { + applicableSubstitutions |= 2 /* TypeScriptSubstitutionFlags.NamespaceExports */; + } + if (enabledSubstitutions & 8 /* TypeScriptSubstitutionFlags.NonQualifiedEnumMembers */ && isTransformedEnumDeclaration(node)) { + applicableSubstitutions |= 8 /* TypeScriptSubstitutionFlags.NonQualifiedEnumMembers */; + } + previousOnEmitNode(hint, node, emitCallback); + applicableSubstitutions = savedApplicableSubstitutions; + currentSourceFile = savedCurrentSourceFile; + } + /** + * Hooks node substitutions. + * + * @param hint A hint as to the intended usage of the node. + * @param node The node to substitute. + */ + function onSubstituteNode(hint, node) { + node = previousOnSubstituteNode(hint, node); + if (hint === 1 /* EmitHint.Expression */) { + return substituteExpression(node); + } + else if (ts.isShorthandPropertyAssignment(node)) { + return substituteShorthandPropertyAssignment(node); + } + return node; + } + function substituteShorthandPropertyAssignment(node) { + if (enabledSubstitutions & 2 /* TypeScriptSubstitutionFlags.NamespaceExports */) { + var name = node.name; + var exportedName = trySubstituteNamespaceExportedName(name); + if (exportedName) { + // A shorthand property with an assignment initializer is probably part of a + // destructuring assignment + if (node.objectAssignmentInitializer) { + var initializer = factory.createAssignment(exportedName, node.objectAssignmentInitializer); + return ts.setTextRange(factory.createPropertyAssignment(name, initializer), node); + } + return ts.setTextRange(factory.createPropertyAssignment(name, exportedName), node); + } + } + return node; + } + function substituteExpression(node) { + switch (node.kind) { + case 79 /* SyntaxKind.Identifier */: + return substituteExpressionIdentifier(node); + case 208 /* SyntaxKind.PropertyAccessExpression */: + return substitutePropertyAccessExpression(node); + case 209 /* SyntaxKind.ElementAccessExpression */: + return substituteElementAccessExpression(node); + } + return node; + } + function substituteExpressionIdentifier(node) { + return trySubstituteNamespaceExportedName(node) + || node; + } + function trySubstituteNamespaceExportedName(node) { + // If this is explicitly a local name, do not substitute. + if (enabledSubstitutions & applicableSubstitutions && !ts.isGeneratedIdentifier(node) && !ts.isLocalName(node)) { + // If we are nested within a namespace declaration, we may need to qualifiy + // an identifier that is exported from a merged namespace. + var container = resolver.getReferencedExportContainer(node, /*prefixLocals*/ false); + if (container && container.kind !== 308 /* SyntaxKind.SourceFile */) { + var substitute = (applicableSubstitutions & 2 /* TypeScriptSubstitutionFlags.NamespaceExports */ && container.kind === 264 /* SyntaxKind.ModuleDeclaration */) || + (applicableSubstitutions & 8 /* TypeScriptSubstitutionFlags.NonQualifiedEnumMembers */ && container.kind === 263 /* SyntaxKind.EnumDeclaration */); + if (substitute) { + return ts.setTextRange(factory.createPropertyAccessExpression(factory.getGeneratedNameForNode(container), node), + /*location*/ node); + } + } + } + return undefined; + } + function substitutePropertyAccessExpression(node) { + return substituteConstantValue(node); + } + function substituteElementAccessExpression(node) { + return substituteConstantValue(node); + } + function safeMultiLineComment(value) { + return value.replace(/\*\//g, "*_/"); + } + function substituteConstantValue(node) { + var constantValue = tryGetConstEnumValue(node); + if (constantValue !== undefined) { + // track the constant value on the node for the printer in needsDotDotForPropertyAccess + ts.setConstantValue(node, constantValue); + var substitute = typeof constantValue === "string" ? factory.createStringLiteral(constantValue) : factory.createNumericLiteral(constantValue); + if (!compilerOptions.removeComments) { + var originalNode = ts.getOriginalNode(node, ts.isAccessExpression); + ts.addSyntheticTrailingComment(substitute, 3 /* SyntaxKind.MultiLineCommentTrivia */, " ".concat(safeMultiLineComment(ts.getTextOfNode(originalNode)), " ")); + } + return substitute; + } + return node; + } + function tryGetConstEnumValue(node) { + if (compilerOptions.isolatedModules) { + return undefined; + } + return ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node) ? resolver.getConstantValue(node) : undefined; + } + function shouldEmitAliasDeclaration(node) { + return ts.isInJSFile(node) || + (compilerOptions.preserveValueImports + ? resolver.isValueAliasDeclaration(node) + : resolver.isReferencedAliasDeclaration(node)); + } + } + ts.transformTypeScript = transformTypeScript; +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + var ClassPropertySubstitutionFlags; + (function (ClassPropertySubstitutionFlags) { + /** + * Enables substitutions for class expressions with static fields + * which have initializers that reference the class name. + */ + ClassPropertySubstitutionFlags[ClassPropertySubstitutionFlags["ClassAliases"] = 1] = "ClassAliases"; + /** + * Enables substitutions for class expressions with static fields + * which have initializers that reference the 'this' or 'super'. + */ + ClassPropertySubstitutionFlags[ClassPropertySubstitutionFlags["ClassStaticThisOrSuperReference"] = 2] = "ClassStaticThisOrSuperReference"; + })(ClassPropertySubstitutionFlags || (ClassPropertySubstitutionFlags = {})); + var PrivateIdentifierKind; + (function (PrivateIdentifierKind) { + PrivateIdentifierKind["Field"] = "f"; + PrivateIdentifierKind["Method"] = "m"; + PrivateIdentifierKind["Accessor"] = "a"; + })(PrivateIdentifierKind = ts.PrivateIdentifierKind || (ts.PrivateIdentifierKind = {})); + var ClassFacts; + (function (ClassFacts) { + ClassFacts[ClassFacts["None"] = 0] = "None"; + ClassFacts[ClassFacts["ClassWasDecorated"] = 1] = "ClassWasDecorated"; + ClassFacts[ClassFacts["NeedsClassConstructorReference"] = 2] = "NeedsClassConstructorReference"; + ClassFacts[ClassFacts["NeedsClassSuperReference"] = 4] = "NeedsClassSuperReference"; + ClassFacts[ClassFacts["NeedsSubstitutionForThisInClassStaticField"] = 8] = "NeedsSubstitutionForThisInClassStaticField"; + })(ClassFacts || (ClassFacts = {})); + /** + * Transforms ECMAScript Class Syntax. + * TypeScript parameter property syntax is transformed in the TypeScript transformer. + * For now, this transforms public field declarations using TypeScript class semantics, + * where declarations are elided and initializers are transformed as assignments in the constructor. + * When --useDefineForClassFields is on, this transforms to ECMAScript semantics, with Object.defineProperty. + */ + function transformClassFields(context) { + var factory = context.factory, hoistVariableDeclaration = context.hoistVariableDeclaration, endLexicalEnvironment = context.endLexicalEnvironment, startLexicalEnvironment = context.startLexicalEnvironment, resumeLexicalEnvironment = context.resumeLexicalEnvironment, addBlockScopedVariable = context.addBlockScopedVariable; + var resolver = context.getEmitResolver(); + var compilerOptions = context.getCompilerOptions(); + var languageVersion = ts.getEmitScriptTarget(compilerOptions); + var useDefineForClassFields = ts.getUseDefineForClassFields(compilerOptions); + // Always transform field initializers using Set semantics when `useDefineForClassFields: false`. + var shouldTransformInitializersUsingSet = !useDefineForClassFields; + // Transform field initializers using Define semantics when `useDefineForClassFields: true` and target < ES2022. + var shouldTransformInitializersUsingDefine = useDefineForClassFields && languageVersion < 9 /* ScriptTarget.ES2022 */; + var shouldTransformInitializers = shouldTransformInitializersUsingSet || shouldTransformInitializersUsingDefine; + // We need to transform private members and class static blocks when target < ES2022. + var shouldTransformPrivateElementsOrClassStaticBlocks = languageVersion < 9 /* ScriptTarget.ES2022 */; + // We need to transform `accessor` fields when target < ESNext + var shouldTransformAutoAccessors = languageVersion < 99 /* ScriptTarget.ESNext */; + // We need to transform `this` in a static initializer into a reference to the class + // when target < ES2022 since the assignment will be moved outside of the class body. + var shouldTransformThisInStaticInitializers = languageVersion < 9 /* ScriptTarget.ES2022 */; + // We don't need to transform `super` property access when target <= ES5 because + // the es2015 transformation handles those. + var shouldTransformSuperInStaticInitializers = shouldTransformThisInStaticInitializers && languageVersion >= 2 /* ScriptTarget.ES2015 */; + var shouldTransformAnything = shouldTransformInitializers || + shouldTransformPrivateElementsOrClassStaticBlocks || + shouldTransformAutoAccessors; + var previousOnSubstituteNode = context.onSubstituteNode; + context.onSubstituteNode = onSubstituteNode; + var previousOnEmitNode = context.onEmitNode; + context.onEmitNode = onEmitNode; + var enabledSubstitutions; + var classAliases; + /** + * Tracks what computed name expressions originating from elided names must be inlined + * at the next execution site, in document order + */ + var pendingExpressions; + /** + * Tracks what computed name expression statements and static property initializers must be + * emitted at the next execution site, in document order (for decorated classes). + */ + var pendingStatements; + var classLexicalEnvironmentStack = []; + var classLexicalEnvironmentMap = new ts.Map(); + var currentClassLexicalEnvironment; + var currentClassContainer; + var currentComputedPropertyNameClassLexicalEnvironment; + var currentStaticPropertyDeclarationOrStaticBlock; + return ts.chainBundle(context, transformSourceFile); + function transformSourceFile(node) { + if (node.isDeclarationFile || !shouldTransformAnything) { + return node; + } + var visited = ts.visitEachChild(node, visitor, context); + ts.addEmitHelpers(visited, context.readEmitHelpers()); + return visited; + } + function visitor(node) { + if (!(node.transformFlags & 16777216 /* TransformFlags.ContainsClassFields */) && + !(node.transformFlags & 134234112 /* TransformFlags.ContainsLexicalThisOrSuper */)) { + return node; + } + switch (node.kind) { + case 127 /* SyntaxKind.AccessorKeyword */: + return shouldTransformAutoAccessors ? undefined : node; + case 260 /* SyntaxKind.ClassDeclaration */: + return visitClassDeclaration(node); + case 228 /* SyntaxKind.ClassExpression */: + return visitClassExpression(node); + case 172 /* SyntaxKind.ClassStaticBlockDeclaration */: + return visitClassStaticBlockDeclaration(node); + case 169 /* SyntaxKind.PropertyDeclaration */: + return visitPropertyDeclaration(node); + case 240 /* SyntaxKind.VariableStatement */: + return visitVariableStatement(node); + case 80 /* SyntaxKind.PrivateIdentifier */: + return visitPrivateIdentifier(node); + case 208 /* SyntaxKind.PropertyAccessExpression */: + return visitPropertyAccessExpression(node); + case 209 /* SyntaxKind.ElementAccessExpression */: + return visitElementAccessExpression(node); + case 221 /* SyntaxKind.PrefixUnaryExpression */: + case 222 /* SyntaxKind.PostfixUnaryExpression */: + return visitPreOrPostfixUnaryExpression(node, /*valueIsDiscarded*/ false); + case 223 /* SyntaxKind.BinaryExpression */: + return visitBinaryExpression(node, /*valueIsDiscarded*/ false); + case 210 /* SyntaxKind.CallExpression */: + return visitCallExpression(node); + case 241 /* SyntaxKind.ExpressionStatement */: + return visitExpressionStatement(node); + case 212 /* SyntaxKind.TaggedTemplateExpression */: + return visitTaggedTemplateExpression(node); + case 245 /* SyntaxKind.ForStatement */: + return visitForStatement(node); + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 173 /* SyntaxKind.Constructor */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: { + // If we are descending into a new scope, clear the current static property or block + return setCurrentStaticPropertyDeclarationOrStaticBlockAnd( + /*current*/ undefined, fallbackVisitor, node); + } + default: + return fallbackVisitor(node); + } + } + function fallbackVisitor(node) { + return ts.visitEachChild(node, visitor, context); + } + /** + * Visits a node in an expression whose result is discarded. + */ + function discardedValueVisitor(node) { + switch (node.kind) { + case 221 /* SyntaxKind.PrefixUnaryExpression */: + case 222 /* SyntaxKind.PostfixUnaryExpression */: + return visitPreOrPostfixUnaryExpression(node, /*valueIsDiscarded*/ true); + case 223 /* SyntaxKind.BinaryExpression */: + return visitBinaryExpression(node, /*valueIsDiscarded*/ true); + default: + return visitor(node); + } + } + /** + * Visits a node in a {@link HeritageClause}. + */ + function heritageClauseVisitor(node) { + switch (node.kind) { + case 294 /* SyntaxKind.HeritageClause */: + return ts.visitEachChild(node, heritageClauseVisitor, context); + case 230 /* SyntaxKind.ExpressionWithTypeArguments */: + return visitExpressionWithTypeArgumentsInHeritageClause(node); + default: + return visitor(node); + } + } + /** + * Visits the assignment target of a destructuring assignment. + */ + function assignmentTargetVisitor(node) { + switch (node.kind) { + case 207 /* SyntaxKind.ObjectLiteralExpression */: + case 206 /* SyntaxKind.ArrayLiteralExpression */: + return visitAssignmentPattern(node); + default: + return visitor(node); + } + } + /** + * Visits a member of a class. + */ + function classElementVisitor(node) { + switch (node.kind) { + case 173 /* SyntaxKind.Constructor */: + return visitConstructorDeclaration(node); + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 171 /* SyntaxKind.MethodDeclaration */: + return setCurrentStaticPropertyDeclarationOrStaticBlockAnd( + /*current*/ undefined, visitMethodOrAccessorDeclaration, node); + case 169 /* SyntaxKind.PropertyDeclaration */: + return setCurrentStaticPropertyDeclarationOrStaticBlockAnd( + /*current*/ undefined, visitPropertyDeclaration, node); + case 164 /* SyntaxKind.ComputedPropertyName */: + return visitComputedPropertyName(node); + case 237 /* SyntaxKind.SemicolonClassElement */: + return node; + default: + return visitor(node); + } + } + /** + * Visits the results of an auto-accessor field transformation in a second pass. + */ + function accessorFieldResultVisitor(node) { + switch (node.kind) { + case 169 /* SyntaxKind.PropertyDeclaration */: + return transformFieldInitializer(node); + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + return classElementVisitor(node); + default: + ts.Debug.assertMissingNode(node, "Expected node to either be a PropertyDeclaration, GetAccessorDeclaration, or SetAccessorDeclaration"); + break; + } + } + /** + * If we visit a private name, this means it is an undeclared private name. + * Replace it with an empty identifier to indicate a problem with the code, + * unless we are in a statement position - otherwise this will not trigger + * a SyntaxError. + */ + function visitPrivateIdentifier(node) { + if (!shouldTransformPrivateElementsOrClassStaticBlocks) { + return node; + } + if (ts.isStatement(node.parent)) { + return node; + } + return ts.setOriginalNode(factory.createIdentifier(""), node); + } + function isPrivateIdentifierInExpression(node) { + return ts.isPrivateIdentifier(node.left) + && node.operatorToken.kind === 101 /* SyntaxKind.InKeyword */; + } + /** + * Visits `#id in expr` + */ + function transformPrivateIdentifierInInExpression(node) { + var info = accessPrivateIdentifier(node.left); + if (info) { + var receiver = ts.visitNode(node.right, visitor, ts.isExpression); + return ts.setOriginalNode(context.getEmitHelperFactory().createClassPrivateFieldInHelper(info.brandCheckIdentifier, receiver), node); + } + // Private name has not been declared. Subsequent transformers will handle this error + return ts.visitEachChild(node, visitor, context); + } + function visitVariableStatement(node) { + var savedPendingStatements = pendingStatements; + pendingStatements = []; + var visitedNode = ts.visitEachChild(node, visitor, context); + var statement = ts.some(pendingStatements) ? __spreadArray([visitedNode], pendingStatements, true) : + visitedNode; + pendingStatements = savedPendingStatements; + return statement; + } + function visitComputedPropertyName(node) { + var expression = ts.visitNode(node.expression, visitor, ts.isExpression); + if (ts.some(pendingExpressions)) { + if (ts.isParenthesizedExpression(expression)) { + expression = factory.updateParenthesizedExpression(expression, factory.inlineExpressions(__spreadArray(__spreadArray([], pendingExpressions, true), [expression.expression], false))); + } + else { + expression = factory.inlineExpressions(__spreadArray(__spreadArray([], pendingExpressions, true), [expression], false)); + } + pendingExpressions = undefined; + } + return factory.updateComputedPropertyName(node, expression); + } + function visitConstructorDeclaration(node) { + if (currentClassContainer) { + return transformConstructor(node, currentClassContainer); + } + return fallbackVisitor(node); + } + function visitMethodOrAccessorDeclaration(node) { + ts.Debug.assert(!ts.hasDecorators(node)); + if (!shouldTransformPrivateElementsOrClassStaticBlocks || !ts.isPrivateIdentifier(node.name)) { + return ts.visitEachChild(node, classElementVisitor, context); + } + // leave invalid code untransformed + var info = accessPrivateIdentifier(node.name); + ts.Debug.assert(info, "Undeclared private name for property declaration."); + if (!info.isValid) { + return node; + } + var functionName = getHoistedFunctionName(node); + if (functionName) { + getPendingExpressions().push(factory.createAssignment(functionName, factory.createFunctionExpression(ts.filter(node.modifiers, function (m) { return ts.isModifier(m) && !ts.isStaticModifier(m) && !ts.isAccessorModifier(m); }), node.asteriskToken, functionName, + /* typeParameters */ undefined, ts.visitParameterList(node.parameters, visitor, context), + /* type */ undefined, ts.visitFunctionBody(node.body, visitor, context)))); + } + // remove method declaration from class + return undefined; + } + function setCurrentStaticPropertyDeclarationOrStaticBlockAnd(current, visitor, arg) { + var savedCurrentStaticPropertyDeclarationOrStaticBlock = currentStaticPropertyDeclarationOrStaticBlock; + currentStaticPropertyDeclarationOrStaticBlock = current; + var result = visitor(arg); + currentStaticPropertyDeclarationOrStaticBlock = savedCurrentStaticPropertyDeclarationOrStaticBlock; + return result; + } + function getHoistedFunctionName(node) { + ts.Debug.assert(ts.isPrivateIdentifier(node.name)); + var info = accessPrivateIdentifier(node.name); + ts.Debug.assert(info, "Undeclared private name for property declaration."); + if (info.kind === "m" /* PrivateIdentifierKind.Method */) { + return info.methodName; + } + if (info.kind === "a" /* PrivateIdentifierKind.Accessor */) { + if (ts.isGetAccessor(node)) { + return info.getterName; + } + if (ts.isSetAccessor(node)) { + return info.setterName; + } + } + } + function transformAutoAccessor(node) { + // transforms: + // accessor x = 1; + // into: + // #x = 1; + // get x() { return this.#x; } + // set x(value) { this.#x = value; } + ts.Debug.assertEachNode(node.modifiers, ts.isModifier); + var commentRange = ts.getCommentRange(node); + var sourceMapRange = ts.getSourceMapRange(node); + // Since we're creating two declarations where there was previously one, cache + // the expression for any computed property names. + var name = node.name; + var getterName = name; + var setterName = name; + if (ts.isComputedPropertyName(name) && !ts.isSimpleInlineableExpression(name.expression)) { + var temp = factory.createTempVariable(hoistVariableDeclaration); + ts.setSourceMapRange(temp, name.expression); + var expression = ts.visitNode(name.expression, visitor, ts.isExpression); + var assignment = factory.createAssignment(temp, expression); + ts.setSourceMapRange(assignment, name.expression); + getterName = factory.updateComputedPropertyName(name, factory.inlineExpressions([assignment, temp])); + setterName = factory.updateComputedPropertyName(name, temp); + } + var backingField = ts.createAccessorPropertyBackingField(factory, node, node.modifiers, node.initializer); + ts.setOriginalNode(backingField, node); + ts.setEmitFlags(backingField, 1536 /* EmitFlags.NoComments */); + ts.setSourceMapRange(backingField, sourceMapRange); + var getter = ts.createAccessorPropertyGetRedirector(factory, node, node.modifiers, getterName); + ts.setOriginalNode(getter, node); + ts.setCommentRange(getter, commentRange); + ts.setSourceMapRange(getter, sourceMapRange); + var setter = ts.createAccessorPropertySetRedirector(factory, node, node.modifiers, setterName); + ts.setOriginalNode(setter, node); + ts.setEmitFlags(setter, 1536 /* EmitFlags.NoComments */); + ts.setSourceMapRange(setter, sourceMapRange); + return ts.visitArray([backingField, getter, setter], accessorFieldResultVisitor, ts.isClassElement); + } + function transformPrivateFieldInitializer(node) { + if (shouldTransformPrivateElementsOrClassStaticBlocks) { + // If we are transforming private elements into WeakMap/WeakSet, we should elide the node. + var info = accessPrivateIdentifier(node.name); + ts.Debug.assert(info, "Undeclared private name for property declaration."); + // Leave invalid code untransformed; otherwise, elide the node as it is transformed elsewhere. + return info.isValid ? undefined : node; + } + if (shouldTransformInitializersUsingSet && !ts.isStatic(node)) { + // If we are transforming initializers using Set semantics we will elide the initializer as it will + // be moved to the constructor to preserve evaluation order next to public instance fields. We don't + // need to do this transformation for private static fields since public static fields can be + // transformed into `static {}` blocks. + return factory.updatePropertyDeclaration(node, ts.visitNodes(node.modifiers, visitor, ts.isModifierLike), node.name, + /*questionOrExclamationToken*/ undefined, + /*type*/ undefined, + /*initializer*/ undefined); + } + return ts.visitEachChild(node, visitor, context); + } + function transformPublicFieldInitializer(node) { + if (shouldTransformInitializers) { + // Create a temporary variable to store a computed property name (if necessary). + // If it's not inlineable, then we emit an expression after the class which assigns + // the property name to the temporary variable. + var expr = getPropertyNameExpressionIfNeeded(node.name, /*shouldHoist*/ !!node.initializer || useDefineForClassFields); + if (expr) { + getPendingExpressions().push(expr); + } + if (ts.isStatic(node) && !shouldTransformPrivateElementsOrClassStaticBlocks) { + var initializerStatement = transformPropertyOrClassStaticBlock(node, factory.createThis()); + if (initializerStatement) { + var staticBlock = factory.createClassStaticBlockDeclaration(factory.createBlock([initializerStatement])); + ts.setOriginalNode(staticBlock, node); + ts.setCommentRange(staticBlock, node); + // Set the comment range for the statement to an empty synthetic range + // and drop synthetic comments from the statement to avoid printing them twice. + ts.setCommentRange(initializerStatement, { pos: -1, end: -1 }); + ts.setSyntheticLeadingComments(initializerStatement, undefined); + ts.setSyntheticTrailingComments(initializerStatement, undefined); + return staticBlock; + } + } + return undefined; + } + return ts.visitEachChild(node, classElementVisitor, context); + } + function transformFieldInitializer(node) { + ts.Debug.assert(!ts.hasDecorators(node), "Decorators should already have been transformed and elided."); + return ts.isPrivateIdentifierClassElementDeclaration(node) ? + transformPrivateFieldInitializer(node) : + transformPublicFieldInitializer(node); + } + function visitPropertyDeclaration(node) { + // If this is an auto-accessor, we defer to `transformAutoAccessor`. That function + // will in turn call `transformFieldInitializer` as needed. + if (shouldTransformAutoAccessors && ts.isAutoAccessorPropertyDeclaration(node)) { + return transformAutoAccessor(node); + } + return transformFieldInitializer(node); + } + function createPrivateIdentifierAccess(info, receiver) { + return createPrivateIdentifierAccessHelper(info, ts.visitNode(receiver, visitor, ts.isExpression)); + } + function createPrivateIdentifierAccessHelper(info, receiver) { + ts.setCommentRange(receiver, ts.moveRangePos(receiver, -1)); + switch (info.kind) { + case "a" /* PrivateIdentifierKind.Accessor */: + return context.getEmitHelperFactory().createClassPrivateFieldGetHelper(receiver, info.brandCheckIdentifier, info.kind, info.getterName); + case "m" /* PrivateIdentifierKind.Method */: + return context.getEmitHelperFactory().createClassPrivateFieldGetHelper(receiver, info.brandCheckIdentifier, info.kind, info.methodName); + case "f" /* PrivateIdentifierKind.Field */: + return context.getEmitHelperFactory().createClassPrivateFieldGetHelper(receiver, info.brandCheckIdentifier, info.kind, info.variableName); + default: + ts.Debug.assertNever(info, "Unknown private element type"); + } + } + function visitPropertyAccessExpression(node) { + if (shouldTransformPrivateElementsOrClassStaticBlocks && ts.isPrivateIdentifier(node.name)) { + var privateIdentifierInfo = accessPrivateIdentifier(node.name); + if (privateIdentifierInfo) { + return ts.setTextRange(ts.setOriginalNode(createPrivateIdentifierAccess(privateIdentifierInfo, node.expression), node), node); + } + } + if (shouldTransformSuperInStaticInitializers && + ts.isSuperProperty(node) && + ts.isIdentifier(node.name) && + currentStaticPropertyDeclarationOrStaticBlock && + currentClassLexicalEnvironment) { + var classConstructor = currentClassLexicalEnvironment.classConstructor, superClassReference = currentClassLexicalEnvironment.superClassReference, facts = currentClassLexicalEnvironment.facts; + if (facts & 1 /* ClassFacts.ClassWasDecorated */) { + return visitInvalidSuperProperty(node); + } + if (classConstructor && superClassReference) { + // converts `super.x` into `Reflect.get(_baseTemp, "x", _classTemp)` + var superProperty = factory.createReflectGetCall(superClassReference, factory.createStringLiteralFromNode(node.name), classConstructor); + ts.setOriginalNode(superProperty, node.expression); + ts.setTextRange(superProperty, node.expression); + return superProperty; + } + } + return ts.visitEachChild(node, visitor, context); + } + function visitElementAccessExpression(node) { + if (shouldTransformSuperInStaticInitializers && + ts.isSuperProperty(node) && + currentStaticPropertyDeclarationOrStaticBlock && + currentClassLexicalEnvironment) { + var classConstructor = currentClassLexicalEnvironment.classConstructor, superClassReference = currentClassLexicalEnvironment.superClassReference, facts = currentClassLexicalEnvironment.facts; + if (facts & 1 /* ClassFacts.ClassWasDecorated */) { + return visitInvalidSuperProperty(node); + } + if (classConstructor && superClassReference) { + // converts `super[x]` into `Reflect.get(_baseTemp, x, _classTemp)` + var superProperty = factory.createReflectGetCall(superClassReference, ts.visitNode(node.argumentExpression, visitor, ts.isExpression), classConstructor); + ts.setOriginalNode(superProperty, node.expression); + ts.setTextRange(superProperty, node.expression); + return superProperty; + } + } + return ts.visitEachChild(node, visitor, context); + } + function visitPreOrPostfixUnaryExpression(node, valueIsDiscarded) { + if (node.operator === 45 /* SyntaxKind.PlusPlusToken */ || + node.operator === 46 /* SyntaxKind.MinusMinusToken */) { + var operand = ts.skipParentheses(node.operand); + if (shouldTransformPrivateElementsOrClassStaticBlocks && + ts.isPrivateIdentifierPropertyAccessExpression(operand)) { + var info = void 0; + if (info = accessPrivateIdentifier(operand.name)) { + var receiver = ts.visitNode(operand.expression, visitor, ts.isExpression); + var _a = createCopiableReceiverExpr(receiver), readExpression = _a.readExpression, initializeExpression = _a.initializeExpression; + var expression = createPrivateIdentifierAccess(info, readExpression); + var temp = ts.isPrefixUnaryExpression(node) || valueIsDiscarded ? undefined : factory.createTempVariable(hoistVariableDeclaration); + expression = ts.expandPreOrPostfixIncrementOrDecrementExpression(factory, node, expression, hoistVariableDeclaration, temp); + expression = createPrivateIdentifierAssignment(info, initializeExpression || readExpression, expression, 63 /* SyntaxKind.EqualsToken */); + ts.setOriginalNode(expression, node); + ts.setTextRange(expression, node); + if (temp) { + expression = factory.createComma(expression, temp); + ts.setTextRange(expression, node); + } + return expression; + } + } + else if (shouldTransformSuperInStaticInitializers && + ts.isSuperProperty(operand) && + currentStaticPropertyDeclarationOrStaticBlock && + currentClassLexicalEnvironment) { + // converts `++super.a` into `(Reflect.set(_baseTemp, "a", (_a = Reflect.get(_baseTemp, "a", _classTemp), _b = ++_a), _classTemp), _b)` + // converts `++super[f()]` into `(Reflect.set(_baseTemp, _a = f(), (_b = Reflect.get(_baseTemp, _a, _classTemp), _c = ++_b), _classTemp), _c)` + // converts `--super.a` into `(Reflect.set(_baseTemp, "a", (_a = Reflect.get(_baseTemp, "a", _classTemp), _b = --_a), _classTemp), _b)` + // converts `--super[f()]` into `(Reflect.set(_baseTemp, _a = f(), (_b = Reflect.get(_baseTemp, _a, _classTemp), _c = --_b), _classTemp), _c)` + // converts `super.a++` into `(Reflect.set(_baseTemp, "a", (_a = Reflect.get(_baseTemp, "a", _classTemp), _b = _a++), _classTemp), _b)` + // converts `super[f()]++` into `(Reflect.set(_baseTemp, _a = f(), (_b = Reflect.get(_baseTemp, _a, _classTemp), _c = _b++), _classTemp), _c)` + // converts `super.a--` into `(Reflect.set(_baseTemp, "a", (_a = Reflect.get(_baseTemp, "a", _classTemp), _b = _a--), _classTemp), _b)` + // converts `super[f()]--` into `(Reflect.set(_baseTemp, _a = f(), (_b = Reflect.get(_baseTemp, _a, _classTemp), _c = _b--), _classTemp), _c)` + var classConstructor = currentClassLexicalEnvironment.classConstructor, superClassReference = currentClassLexicalEnvironment.superClassReference, facts = currentClassLexicalEnvironment.facts; + if (facts & 1 /* ClassFacts.ClassWasDecorated */) { + var expression = visitInvalidSuperProperty(operand); + return ts.isPrefixUnaryExpression(node) ? + factory.updatePrefixUnaryExpression(node, expression) : + factory.updatePostfixUnaryExpression(node, expression); + } + if (classConstructor && superClassReference) { + var setterName = void 0; + var getterName = void 0; + if (ts.isPropertyAccessExpression(operand)) { + if (ts.isIdentifier(operand.name)) { + getterName = setterName = factory.createStringLiteralFromNode(operand.name); + } + } + else { + if (ts.isSimpleInlineableExpression(operand.argumentExpression)) { + getterName = setterName = operand.argumentExpression; + } + else { + getterName = factory.createTempVariable(hoistVariableDeclaration); + setterName = factory.createAssignment(getterName, ts.visitNode(operand.argumentExpression, visitor, ts.isExpression)); + } + } + if (setterName && getterName) { + var expression = factory.createReflectGetCall(superClassReference, getterName, classConstructor); + ts.setTextRange(expression, operand); + var temp = valueIsDiscarded ? undefined : factory.createTempVariable(hoistVariableDeclaration); + expression = ts.expandPreOrPostfixIncrementOrDecrementExpression(factory, node, expression, hoistVariableDeclaration, temp); + expression = factory.createReflectSetCall(superClassReference, setterName, expression, classConstructor); + ts.setOriginalNode(expression, node); + ts.setTextRange(expression, node); + if (temp) { + expression = factory.createComma(expression, temp); + ts.setTextRange(expression, node); + } + return expression; + } + } + } + } + return ts.visitEachChild(node, visitor, context); + } + function visitForStatement(node) { + return factory.updateForStatement(node, ts.visitNode(node.initializer, discardedValueVisitor, ts.isForInitializer), ts.visitNode(node.condition, visitor, ts.isExpression), ts.visitNode(node.incrementor, discardedValueVisitor, ts.isExpression), ts.visitIterationBody(node.statement, visitor, context)); + } + function visitExpressionStatement(node) { + return factory.updateExpressionStatement(node, ts.visitNode(node.expression, discardedValueVisitor, ts.isExpression)); + } + function createCopiableReceiverExpr(receiver) { + var clone = ts.nodeIsSynthesized(receiver) ? receiver : factory.cloneNode(receiver); + if (ts.isSimpleInlineableExpression(receiver)) { + return { readExpression: clone, initializeExpression: undefined }; + } + var readExpression = factory.createTempVariable(hoistVariableDeclaration); + var initializeExpression = factory.createAssignment(readExpression, clone); + return { readExpression: readExpression, initializeExpression: initializeExpression }; + } + function visitCallExpression(node) { + if (shouldTransformPrivateElementsOrClassStaticBlocks && + ts.isPrivateIdentifierPropertyAccessExpression(node.expression)) { + // obj.#x() + // Transform call expressions of private names to properly bind the `this` parameter. + var _a = factory.createCallBinding(node.expression, hoistVariableDeclaration, languageVersion), thisArg = _a.thisArg, target = _a.target; + if (ts.isCallChain(node)) { + return factory.updateCallChain(node, factory.createPropertyAccessChain(ts.visitNode(target, visitor), node.questionDotToken, "call"), + /*questionDotToken*/ undefined, + /*typeArguments*/ undefined, __spreadArray([ts.visitNode(thisArg, visitor, ts.isExpression)], ts.visitNodes(node.arguments, visitor, ts.isExpression), true)); + } + return factory.updateCallExpression(node, factory.createPropertyAccessExpression(ts.visitNode(target, visitor), "call"), + /*typeArguments*/ undefined, __spreadArray([ts.visitNode(thisArg, visitor, ts.isExpression)], ts.visitNodes(node.arguments, visitor, ts.isExpression), true)); + } + if (shouldTransformSuperInStaticInitializers && + ts.isSuperProperty(node.expression) && + currentStaticPropertyDeclarationOrStaticBlock && + (currentClassLexicalEnvironment === null || currentClassLexicalEnvironment === void 0 ? void 0 : currentClassLexicalEnvironment.classConstructor)) { + // super.x() + // super[x]() + // converts `super.f(...)` into `Reflect.get(_baseTemp, "f", _classTemp).call(_classTemp, ...)` + var invocation = factory.createFunctionCallCall(ts.visitNode(node.expression, visitor, ts.isExpression), currentClassLexicalEnvironment.classConstructor, ts.visitNodes(node.arguments, visitor, ts.isExpression)); + ts.setOriginalNode(invocation, node); + ts.setTextRange(invocation, node); + return invocation; + } + return ts.visitEachChild(node, visitor, context); + } + function visitTaggedTemplateExpression(node) { + if (shouldTransformPrivateElementsOrClassStaticBlocks && + ts.isPrivateIdentifierPropertyAccessExpression(node.tag)) { + // Bind the `this` correctly for tagged template literals when the tag is a private identifier property access. + var _a = factory.createCallBinding(node.tag, hoistVariableDeclaration, languageVersion), thisArg = _a.thisArg, target = _a.target; + return factory.updateTaggedTemplateExpression(node, factory.createCallExpression(factory.createPropertyAccessExpression(ts.visitNode(target, visitor), "bind"), + /*typeArguments*/ undefined, [ts.visitNode(thisArg, visitor, ts.isExpression)]), + /*typeArguments*/ undefined, ts.visitNode(node.template, visitor, ts.isTemplateLiteral)); + } + if (shouldTransformSuperInStaticInitializers && + ts.isSuperProperty(node.tag) && + currentStaticPropertyDeclarationOrStaticBlock && + (currentClassLexicalEnvironment === null || currentClassLexicalEnvironment === void 0 ? void 0 : currentClassLexicalEnvironment.classConstructor)) { + // converts `` super.f`x` `` into `` Reflect.get(_baseTemp, "f", _classTemp).bind(_classTemp)`x` `` + var invocation = factory.createFunctionBindCall(ts.visitNode(node.tag, visitor, ts.isExpression), currentClassLexicalEnvironment.classConstructor, []); + ts.setOriginalNode(invocation, node); + ts.setTextRange(invocation, node); + return factory.updateTaggedTemplateExpression(node, invocation, + /*typeArguments*/ undefined, ts.visitNode(node.template, visitor, ts.isTemplateLiteral)); + } + return ts.visitEachChild(node, visitor, context); + } + function transformClassStaticBlockDeclaration(node) { + if (shouldTransformPrivateElementsOrClassStaticBlocks) { + if (currentClassLexicalEnvironment) { + classLexicalEnvironmentMap.set(ts.getOriginalNodeId(node), currentClassLexicalEnvironment); + } + startLexicalEnvironment(); + var statements = setCurrentStaticPropertyDeclarationOrStaticBlockAnd(node, function (statements) { return ts.visitNodes(statements, visitor, ts.isStatement); }, node.body.statements); + statements = factory.mergeLexicalEnvironment(statements, endLexicalEnvironment()); + var iife = factory.createImmediatelyInvokedArrowFunction(statements); + ts.setOriginalNode(iife, node); + ts.setTextRange(iife, node); + ts.addEmitFlags(iife, 2 /* EmitFlags.AdviseOnEmitNode */); + return iife; + } + } + function visitBinaryExpression(node, valueIsDiscarded) { + if (ts.isDestructuringAssignment(node)) { + // ({ x: obj.#x } = ...) + // ({ x: super.x } = ...) + // ({ x: super[x] } = ...) + var savedPendingExpressions = pendingExpressions; + pendingExpressions = undefined; + node = factory.updateBinaryExpression(node, ts.visitNode(node.left, assignmentTargetVisitor), node.operatorToken, ts.visitNode(node.right, visitor)); + var expr = ts.some(pendingExpressions) ? + factory.inlineExpressions(ts.compact(__spreadArray(__spreadArray([], pendingExpressions, true), [node], false))) : + node; + pendingExpressions = savedPendingExpressions; + return expr; + } + if (ts.isAssignmentExpression(node)) { + if (shouldTransformPrivateElementsOrClassStaticBlocks && + ts.isPrivateIdentifierPropertyAccessExpression(node.left)) { + // obj.#x = ... + var info = accessPrivateIdentifier(node.left.name); + if (info) { + return ts.setTextRange(ts.setOriginalNode(createPrivateIdentifierAssignment(info, node.left.expression, node.right, node.operatorToken.kind), node), node); + } + } + else if (shouldTransformSuperInStaticInitializers && + ts.isSuperProperty(node.left) && + currentStaticPropertyDeclarationOrStaticBlock && + currentClassLexicalEnvironment) { + // super.x = ... + // super[x] = ... + // super.x += ... + // super.x -= ... + var classConstructor = currentClassLexicalEnvironment.classConstructor, superClassReference = currentClassLexicalEnvironment.superClassReference, facts = currentClassLexicalEnvironment.facts; + if (facts & 1 /* ClassFacts.ClassWasDecorated */) { + return factory.updateBinaryExpression(node, visitInvalidSuperProperty(node.left), node.operatorToken, ts.visitNode(node.right, visitor, ts.isExpression)); + } + if (classConstructor && superClassReference) { + var setterName = ts.isElementAccessExpression(node.left) ? ts.visitNode(node.left.argumentExpression, visitor, ts.isExpression) : + ts.isIdentifier(node.left.name) ? factory.createStringLiteralFromNode(node.left.name) : + undefined; + if (setterName) { + // converts `super.x = 1` into `(Reflect.set(_baseTemp, "x", _a = 1, _classTemp), _a)` + // converts `super[f()] = 1` into `(Reflect.set(_baseTemp, f(), _a = 1, _classTemp), _a)` + // converts `super.x += 1` into `(Reflect.set(_baseTemp, "x", _a = Reflect.get(_baseTemp, "x", _classtemp) + 1, _classTemp), _a)` + // converts `super[f()] += 1` into `(Reflect.set(_baseTemp, _a = f(), _b = Reflect.get(_baseTemp, _a, _classtemp) + 1, _classTemp), _b)` + var expression = ts.visitNode(node.right, visitor, ts.isExpression); + if (ts.isCompoundAssignment(node.operatorToken.kind)) { + var getterName = setterName; + if (!ts.isSimpleInlineableExpression(setterName)) { + getterName = factory.createTempVariable(hoistVariableDeclaration); + setterName = factory.createAssignment(getterName, setterName); + } + var superPropertyGet = factory.createReflectGetCall(superClassReference, getterName, classConstructor); + ts.setOriginalNode(superPropertyGet, node.left); + ts.setTextRange(superPropertyGet, node.left); + expression = factory.createBinaryExpression(superPropertyGet, ts.getNonAssignmentOperatorForCompoundAssignment(node.operatorToken.kind), expression); + ts.setTextRange(expression, node); + } + var temp = valueIsDiscarded ? undefined : factory.createTempVariable(hoistVariableDeclaration); + if (temp) { + expression = factory.createAssignment(temp, expression); + ts.setTextRange(temp, node); + } + expression = factory.createReflectSetCall(superClassReference, setterName, expression, classConstructor); + ts.setOriginalNode(expression, node); + ts.setTextRange(expression, node); + if (temp) { + expression = factory.createComma(expression, temp); + ts.setTextRange(expression, node); + } + return expression; + } + } + } + } + if (shouldTransformPrivateElementsOrClassStaticBlocks && + isPrivateIdentifierInExpression(node)) { + // #x in obj + return transformPrivateIdentifierInInExpression(node); + } + return ts.visitEachChild(node, visitor, context); + } + function createPrivateIdentifierAssignment(info, receiver, right, operator) { + receiver = ts.visitNode(receiver, visitor, ts.isExpression); + right = ts.visitNode(right, visitor, ts.isExpression); + if (ts.isCompoundAssignment(operator)) { + var _a = createCopiableReceiverExpr(receiver), readExpression = _a.readExpression, initializeExpression = _a.initializeExpression; + receiver = initializeExpression || readExpression; + right = factory.createBinaryExpression(createPrivateIdentifierAccessHelper(info, readExpression), ts.getNonAssignmentOperatorForCompoundAssignment(operator), right); + } + ts.setCommentRange(receiver, ts.moveRangePos(receiver, -1)); + switch (info.kind) { + case "a" /* PrivateIdentifierKind.Accessor */: + return context.getEmitHelperFactory().createClassPrivateFieldSetHelper(receiver, info.brandCheckIdentifier, right, info.kind, info.setterName); + case "m" /* PrivateIdentifierKind.Method */: + return context.getEmitHelperFactory().createClassPrivateFieldSetHelper(receiver, info.brandCheckIdentifier, right, info.kind, + /* f */ undefined); + case "f" /* PrivateIdentifierKind.Field */: + return context.getEmitHelperFactory().createClassPrivateFieldSetHelper(receiver, info.brandCheckIdentifier, right, info.kind, info.variableName); + default: + ts.Debug.assertNever(info, "Unknown private element type"); + } + } + function getPrivateInstanceMethodsAndAccessors(node) { + return ts.filter(node.members, ts.isNonStaticMethodOrAccessorWithPrivateName); + } + function getClassFacts(node) { + var facts = 0 /* ClassFacts.None */; + var original = ts.getOriginalNode(node); + if (ts.isClassDeclaration(original) && ts.classOrConstructorParameterIsDecorated(original)) { + facts |= 1 /* ClassFacts.ClassWasDecorated */; + } + for (var _i = 0, _a = node.members; _i < _a.length; _i++) { + var member = _a[_i]; + if (!ts.isStatic(member)) + continue; + if (member.name && (ts.isPrivateIdentifier(member.name) || ts.isAutoAccessorPropertyDeclaration(member)) && shouldTransformPrivateElementsOrClassStaticBlocks) { + facts |= 2 /* ClassFacts.NeedsClassConstructorReference */; + } + if (ts.isPropertyDeclaration(member) || ts.isClassStaticBlockDeclaration(member)) { + if (shouldTransformThisInStaticInitializers && member.transformFlags & 16384 /* TransformFlags.ContainsLexicalThis */) { + facts |= 8 /* ClassFacts.NeedsSubstitutionForThisInClassStaticField */; + if (!(facts & 1 /* ClassFacts.ClassWasDecorated */)) { + facts |= 2 /* ClassFacts.NeedsClassConstructorReference */; + } + } + if (shouldTransformSuperInStaticInitializers && member.transformFlags & 134217728 /* TransformFlags.ContainsLexicalSuper */) { + if (!(facts & 1 /* ClassFacts.ClassWasDecorated */)) { + facts |= 2 /* ClassFacts.NeedsClassConstructorReference */ | 4 /* ClassFacts.NeedsClassSuperReference */; + } + } + } + } + return facts; + } + function visitExpressionWithTypeArgumentsInHeritageClause(node) { + var facts = (currentClassLexicalEnvironment === null || currentClassLexicalEnvironment === void 0 ? void 0 : currentClassLexicalEnvironment.facts) || 0 /* ClassFacts.None */; + if (facts & 4 /* ClassFacts.NeedsClassSuperReference */) { + var temp = factory.createTempVariable(hoistVariableDeclaration, /*reserveInNestedScopes*/ true); + getClassLexicalEnvironment().superClassReference = temp; + return factory.updateExpressionWithTypeArguments(node, factory.createAssignment(temp, ts.visitNode(node.expression, visitor, ts.isExpression)), + /*typeArguments*/ undefined); + } + return ts.visitEachChild(node, visitor, context); + } + function visitInNewClassLexicalEnvironment(node, visitor) { + var savedCurrentClassContainer = currentClassContainer; + var savedPendingExpressions = pendingExpressions; + currentClassContainer = node; + pendingExpressions = undefined; + startClassLexicalEnvironment(); + if (shouldTransformPrivateElementsOrClassStaticBlocks) { + var name = ts.getNameOfDeclaration(node); + if (name && ts.isIdentifier(name)) { + getPrivateIdentifierEnvironment().className = name; + } + var privateInstanceMethodsAndAccessors = getPrivateInstanceMethodsAndAccessors(node); + if (ts.some(privateInstanceMethodsAndAccessors)) { + getPrivateIdentifierEnvironment().weakSetName = createHoistedVariableForClass("instances", privateInstanceMethodsAndAccessors[0].name); + } + } + var facts = getClassFacts(node); + if (facts) { + getClassLexicalEnvironment().facts = facts; + } + if (facts & 8 /* ClassFacts.NeedsSubstitutionForThisInClassStaticField */) { + enableSubstitutionForClassStaticThisOrSuperReference(); + } + var result = visitor(node, facts); + endClassLexicalEnvironment(); + currentClassContainer = savedCurrentClassContainer; + pendingExpressions = savedPendingExpressions; + return result; + } + function visitClassDeclaration(node) { + return visitInNewClassLexicalEnvironment(node, visitClassDeclarationInNewClassLexicalEnvironment); + } + function visitClassDeclarationInNewClassLexicalEnvironment(node, facts) { + // If a class has private static fields, or a static field has a `this` or `super` reference, + // then we need to allocate a temp variable to hold on to that reference. + var pendingClassReferenceAssignment; + if (facts & 2 /* ClassFacts.NeedsClassConstructorReference */) { + var temp = factory.createTempVariable(hoistVariableDeclaration, /*reservedInNestedScopes*/ true); + getClassLexicalEnvironment().classConstructor = factory.cloneNode(temp); + pendingClassReferenceAssignment = factory.createAssignment(temp, factory.getInternalName(node)); + } + var modifiers = ts.visitNodes(node.modifiers, visitor, ts.isModifierLike); + var heritageClauses = ts.visitNodes(node.heritageClauses, heritageClauseVisitor, ts.isHeritageClause); + var _a = transformClassMembers(node), members = _a.members, prologue = _a.prologue; + var classDecl = factory.updateClassDeclaration(node, modifiers, node.name, + /*typeParameters*/ undefined, heritageClauses, members); + var statements = []; + if (prologue) { + statements.push(factory.createExpressionStatement(prologue)); + } + statements.push(classDecl); + if (pendingClassReferenceAssignment) { + getPendingExpressions().unshift(pendingClassReferenceAssignment); + } + // Write any pending expressions from elided or moved computed property names + if (ts.some(pendingExpressions)) { + statements.push(factory.createExpressionStatement(factory.inlineExpressions(pendingExpressions))); + } + if (shouldTransformInitializersUsingSet || shouldTransformPrivateElementsOrClassStaticBlocks) { + // Emit static property assignment. Because classDeclaration is lexically evaluated, + // it is safe to emit static property assignment after classDeclaration + // From ES6 specification: + // HasLexicalDeclaration (N) : Determines if the argument identifier has a binding in this environment record that was created using + // a lexical declaration such as a LexicalDeclaration or a ClassDeclaration. + var staticProperties = ts.getStaticPropertiesAndClassStaticBlock(node); + if (ts.some(staticProperties)) { + addPropertyOrClassStaticBlockStatements(statements, staticProperties, factory.getInternalName(node)); + } + } + return statements; + } + function visitClassExpression(node) { + return visitInNewClassLexicalEnvironment(node, visitClassExpressionInNewClassLexicalEnvironment); + } + function visitClassExpressionInNewClassLexicalEnvironment(node, facts) { + // If this class expression is a transformation of a decorated class declaration, + // then we want to output the pendingExpressions as statements, not as inlined + // expressions with the class statement. + // + // In this case, we use pendingStatements to produce the same output as the + // class declaration transformation. The VariableStatement visitor will insert + // these statements after the class expression variable statement. + var isDecoratedClassDeclaration = !!(facts & 1 /* ClassFacts.ClassWasDecorated */); + var staticPropertiesOrClassStaticBlocks = ts.getStaticPropertiesAndClassStaticBlock(node); + var isClassWithConstructorReference = resolver.getNodeCheckFlags(node) & 16777216 /* NodeCheckFlags.ClassWithConstructorReference */; + var temp; + function createClassTempVar() { + var classCheckFlags = resolver.getNodeCheckFlags(node); + var isClassWithConstructorReference = classCheckFlags & 16777216 /* NodeCheckFlags.ClassWithConstructorReference */; + var requiresBlockScopedVar = classCheckFlags & 524288 /* NodeCheckFlags.BlockScopedBindingInLoop */; + return factory.createTempVariable(requiresBlockScopedVar ? addBlockScopedVariable : hoistVariableDeclaration, !!isClassWithConstructorReference); + } + if (facts & 2 /* ClassFacts.NeedsClassConstructorReference */) { + temp = createClassTempVar(); + getClassLexicalEnvironment().classConstructor = factory.cloneNode(temp); + } + var modifiers = ts.visitNodes(node.modifiers, visitor, ts.isModifierLike); + var heritageClauses = ts.visitNodes(node.heritageClauses, heritageClauseVisitor, ts.isHeritageClause); + var _a = transformClassMembers(node), members = _a.members, prologue = _a.prologue; + var classExpression = factory.updateClassExpression(node, modifiers, node.name, + /*typeParameters*/ undefined, heritageClauses, members); + var expressions = []; + if (prologue) { + expressions.push(prologue); + } + // Static initializers are transformed to `static {}` blocks when `useDefineForClassFields: false` + // and not also transforming static blocks. + var hasTransformableStatics = shouldTransformPrivateElementsOrClassStaticBlocks && + ts.some(staticPropertiesOrClassStaticBlocks, function (node) { + return ts.isClassStaticBlockDeclaration(node) || + ts.isPrivateIdentifierClassElementDeclaration(node) || + shouldTransformInitializers && ts.isInitializedProperty(node); + }); + if (hasTransformableStatics || ts.some(pendingExpressions)) { + if (isDecoratedClassDeclaration) { + ts.Debug.assertIsDefined(pendingStatements, "Decorated classes transformed by TypeScript are expected to be within a variable declaration."); + // Write any pending expressions from elided or moved computed property names + if (pendingStatements && pendingExpressions && ts.some(pendingExpressions)) { + pendingStatements.push(factory.createExpressionStatement(factory.inlineExpressions(pendingExpressions))); + } + if (pendingStatements && ts.some(staticPropertiesOrClassStaticBlocks)) { + addPropertyOrClassStaticBlockStatements(pendingStatements, staticPropertiesOrClassStaticBlocks, factory.getInternalName(node)); + } + if (temp) { + expressions.push(ts.startOnNewLine(factory.createAssignment(temp, classExpression)), ts.startOnNewLine(temp)); + } + else { + expressions.push(classExpression); + if (prologue) { + ts.startOnNewLine(classExpression); + } + } + } + else { + temp || (temp = createClassTempVar()); + if (isClassWithConstructorReference) { + // record an alias as the class name is not in scope for statics. + enableSubstitutionForClassAliases(); + var alias = factory.cloneNode(temp); + alias.autoGenerateFlags &= ~8 /* GeneratedIdentifierFlags.ReservedInNestedScopes */; + classAliases[ts.getOriginalNodeId(node)] = alias; + } + // To preserve the behavior of the old emitter, we explicitly indent + // the body of a class with static initializers. + ts.setEmitFlags(classExpression, 65536 /* EmitFlags.Indented */ | ts.getEmitFlags(classExpression)); + expressions.push(ts.startOnNewLine(factory.createAssignment(temp, classExpression))); + // Add any pending expressions leftover from elided or relocated computed property names + ts.addRange(expressions, ts.map(pendingExpressions, ts.startOnNewLine)); + ts.addRange(expressions, generateInitializedPropertyExpressionsOrClassStaticBlock(staticPropertiesOrClassStaticBlocks, temp)); + expressions.push(ts.startOnNewLine(temp)); + } + } + else { + expressions.push(classExpression); + if (prologue) { + ts.startOnNewLine(classExpression); + } + } + return factory.inlineExpressions(expressions); + } + function visitClassStaticBlockDeclaration(node) { + if (!shouldTransformPrivateElementsOrClassStaticBlocks) { + return ts.visitEachChild(node, visitor, context); + } + // ClassStaticBlockDeclaration for classes are transformed in `visitClassDeclaration` or `visitClassExpression`. + return undefined; + } + function transformClassMembers(node) { + // Declare private names + if (shouldTransformPrivateElementsOrClassStaticBlocks) { + for (var _i = 0, _a = node.members; _i < _a.length; _i++) { + var member = _a[_i]; + if (ts.isPrivateIdentifierClassElementDeclaration(member)) { + addPrivateIdentifierToEnvironment(member, member.name, addPrivateIdentifierClassElementToEnvironment); + } + } + if (ts.some(getPrivateInstanceMethodsAndAccessors(node))) { + createBrandCheckWeakSetForPrivateMethods(); + } + if (shouldTransformAutoAccessors) { + for (var _b = 0, _c = node.members; _b < _c.length; _b++) { + var member = _c[_b]; + if (ts.isAutoAccessorPropertyDeclaration(member)) { + var storageName = factory.getGeneratedPrivateNameForNode(member.name, /*prefix*/ undefined, "_accessor_storage"); + addPrivateIdentifierToEnvironment(member, storageName, addPrivateIdentifierPropertyDeclarationToEnvironment); + } + } + } + } + var members = ts.visitNodes(node.members, classElementVisitor, ts.isClassElement); + // Create a synthetic constructor if necessary + var syntheticConstructor; + if (!ts.some(members, ts.isConstructorDeclaration)) { + syntheticConstructor = transformConstructor(/*constructor*/ undefined, node); + } + var prologue; + // If there are pending expressions create a class static block in which to evaluate them, but only if + // class static blocks are not also being transformed. This block will be injected at the top of the class + // to ensure that expressions from computed property names are evaluated before any other static + // initializers. + var syntheticStaticBlock; + if (!shouldTransformPrivateElementsOrClassStaticBlocks && ts.some(pendingExpressions)) { + var statement = factory.createExpressionStatement(factory.inlineExpressions(pendingExpressions)); + if (statement.transformFlags & 134234112 /* TransformFlags.ContainsLexicalThisOrSuper */) { + // If there are `this` or `super` references from computed property names, shift the expression + // into an arrow function to be evaluated in the outer scope so that `this` and `super` are + // properly captured. + var temp = factory.createTempVariable(hoistVariableDeclaration); + var arrow = factory.createArrowFunction( + /*modifiers*/ undefined, + /*typeParameters*/ undefined, + /*parameters*/ [], + /*type*/ undefined, + /*equalsGreaterThanToken*/ undefined, factory.createBlock([statement])); + prologue = factory.createAssignment(temp, arrow); + statement = factory.createExpressionStatement(factory.createCallExpression(temp, /*typeArguments*/ undefined, [])); + } + var block = factory.createBlock([statement]); + syntheticStaticBlock = factory.createClassStaticBlockDeclaration(block); + pendingExpressions = undefined; + } + // If we created a synthetic constructor or class static block, add them to the visited members + // and return a new array. + if (syntheticConstructor || syntheticStaticBlock) { + var membersArray = void 0; + membersArray = ts.append(membersArray, syntheticConstructor); + membersArray = ts.append(membersArray, syntheticStaticBlock); + membersArray = ts.addRange(membersArray, members); + members = ts.setTextRange(factory.createNodeArray(membersArray), /*location*/ node.members); + } + return { members: members, prologue: prologue }; + } + function createBrandCheckWeakSetForPrivateMethods() { + var weakSetName = getPrivateIdentifierEnvironment().weakSetName; + ts.Debug.assert(weakSetName, "weakSetName should be set in private identifier environment"); + getPendingExpressions().push(factory.createAssignment(weakSetName, factory.createNewExpression(factory.createIdentifier("WeakSet"), + /*typeArguments*/ undefined, []))); + } + function isClassElementThatRequiresConstructorStatement(member) { + if (ts.isStatic(member) || ts.hasAbstractModifier(ts.getOriginalNode(member))) { + return false; + } + return shouldTransformInitializersUsingDefine && ts.isPropertyDeclaration(member) || + shouldTransformInitializersUsingSet && ts.isInitializedProperty(member) || + shouldTransformPrivateElementsOrClassStaticBlocks && ts.isPrivateIdentifierClassElementDeclaration(member) || + shouldTransformPrivateElementsOrClassStaticBlocks && shouldTransformAutoAccessors && ts.isAutoAccessorPropertyDeclaration(member); + } + function transformConstructor(constructor, container) { + constructor = ts.visitNode(constructor, visitor, ts.isConstructorDeclaration); + if (!ts.some(container.members, isClassElementThatRequiresConstructorStatement)) { + return constructor; + } + var extendsClauseElement = ts.getEffectiveBaseTypeNode(container); + var isDerivedClass = !!(extendsClauseElement && ts.skipOuterExpressions(extendsClauseElement.expression).kind !== 104 /* SyntaxKind.NullKeyword */); + var parameters = ts.visitParameterList(constructor ? constructor.parameters : undefined, visitor, context); + var body = transformConstructorBody(container, constructor, isDerivedClass); + if (!body) { + return constructor; + } + if (constructor) { + ts.Debug.assert(parameters); + return factory.updateConstructorDeclaration(constructor, /*modifiers*/ undefined, parameters, body); + } + return ts.startOnNewLine(ts.setOriginalNode(ts.setTextRange(factory.createConstructorDeclaration( + /*modifiers*/ undefined, parameters !== null && parameters !== void 0 ? parameters : [], body), constructor || container), constructor)); + } + function transformConstructorBody(node, constructor, isDerivedClass) { + var _a, _b; + var properties = ts.getProperties(node, /*requireInitializer*/ false, /*isStatic*/ false); + if (!useDefineForClassFields) { + properties = ts.filter(properties, function (property) { return !!property.initializer || ts.isPrivateIdentifier(property.name) || ts.hasAccessorModifier(property); }); + } + var privateMethodsAndAccessors = getPrivateInstanceMethodsAndAccessors(node); + var needsConstructorBody = ts.some(properties) || ts.some(privateMethodsAndAccessors); + // Only generate synthetic constructor when there are property initializers to move. + if (!constructor && !needsConstructorBody) { + return ts.visitFunctionBody(/*node*/ undefined, visitor, context); + } + resumeLexicalEnvironment(); + var needsSyntheticConstructor = !constructor && isDerivedClass; + var indexOfFirstStatementAfterSuperAndPrologue = 0; + var prologueStatementCount = 0; + var superStatementIndex = -1; + var statements = []; + if ((_a = constructor === null || constructor === void 0 ? void 0 : constructor.body) === null || _a === void 0 ? void 0 : _a.statements) { + prologueStatementCount = factory.copyPrologue(constructor.body.statements, statements, /*ensureUseStrict*/ false, visitor); + superStatementIndex = ts.findSuperStatementIndex(constructor.body.statements, prologueStatementCount); + // If there was a super call, visit existing statements up to and including it + if (superStatementIndex >= 0) { + indexOfFirstStatementAfterSuperAndPrologue = superStatementIndex + 1; + statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, prologueStatementCount), true), ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, prologueStatementCount, indexOfFirstStatementAfterSuperAndPrologue - prologueStatementCount), true), statements.slice(prologueStatementCount), true); + } + else if (prologueStatementCount >= 0) { + indexOfFirstStatementAfterSuperAndPrologue = prologueStatementCount; + } + } + if (needsSyntheticConstructor) { + // Add a synthetic `super` call: + // + // super(...arguments); + // + statements.push(factory.createExpressionStatement(factory.createCallExpression(factory.createSuper(), + /*typeArguments*/ undefined, [factory.createSpreadElement(factory.createIdentifier("arguments"))]))); + } + // Add the property initializers. Transforms this: + // + // public x = 1; + // + // Into this: + // + // constructor() { + // this.x = 1; + // } + // + // If we do useDefineForClassFields, they'll be converted elsewhere. + // We instead *remove* them from the transformed output at this stage. + var parameterPropertyDeclarationCount = 0; + if (constructor === null || constructor === void 0 ? void 0 : constructor.body) { + if (useDefineForClassFields) { + statements = statements.filter(function (statement) { return !ts.isParameterPropertyDeclaration(ts.getOriginalNode(statement), constructor); }); + } + else { + for (var _i = 0, _c = constructor.body.statements; _i < _c.length; _i++) { + var statement = _c[_i]; + if (ts.isParameterPropertyDeclaration(ts.getOriginalNode(statement), constructor)) { + parameterPropertyDeclarationCount++; + } + } + if (parameterPropertyDeclarationCount > 0) { + var parameterProperties = ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, indexOfFirstStatementAfterSuperAndPrologue, parameterPropertyDeclarationCount); + // If there was a super() call found, add parameter properties immediately after it + if (superStatementIndex >= 0) { + ts.addRange(statements, parameterProperties); + } + else { + // Add add parameter properties to the top of the constructor after the prologue + var superAndPrologueStatementCount = prologueStatementCount; + // If a synthetic super() call was added, need to account for that + if (needsSyntheticConstructor) + superAndPrologueStatementCount++; + statements = __spreadArray(__spreadArray(__spreadArray([], statements.slice(0, superAndPrologueStatementCount), true), parameterProperties, true), statements.slice(superAndPrologueStatementCount), true); + } + indexOfFirstStatementAfterSuperAndPrologue += parameterPropertyDeclarationCount; + } + } + } + var receiver = factory.createThis(); + // private methods can be called in property initializers, they should execute first. + addMethodStatements(statements, privateMethodsAndAccessors, receiver); + addPropertyOrClassStaticBlockStatements(statements, properties, receiver); + // Add existing statements after the initial prologues and super call + if (constructor) { + ts.addRange(statements, ts.visitNodes(constructor.body.statements, visitBodyStatement, ts.isStatement, indexOfFirstStatementAfterSuperAndPrologue)); + } + statements = factory.mergeLexicalEnvironment(statements, endLexicalEnvironment()); + if (statements.length === 0 && !constructor) { + return undefined; + } + var multiLine = (constructor === null || constructor === void 0 ? void 0 : constructor.body) && constructor.body.statements.length >= statements.length ? + (_b = constructor.body.multiLine) !== null && _b !== void 0 ? _b : statements.length > 0 : + statements.length > 0; + return ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), + /*location*/ constructor ? constructor.body.statements : node.members), multiLine), + /*location*/ constructor ? constructor.body : undefined); + function visitBodyStatement(statement) { + if (useDefineForClassFields && ts.isParameterPropertyDeclaration(ts.getOriginalNode(statement), constructor)) { + return undefined; + } + return visitor(statement); + } + } + /** + * Generates assignment statements for property initializers. + * + * @param properties An array of property declarations to transform. + * @param receiver The receiver on which each property should be assigned. + */ + function addPropertyOrClassStaticBlockStatements(statements, properties, receiver) { + for (var _i = 0, properties_7 = properties; _i < properties_7.length; _i++) { + var property = properties_7[_i]; + if (ts.isStatic(property) && !shouldTransformPrivateElementsOrClassStaticBlocks && !useDefineForClassFields) { + continue; + } + var statement = transformPropertyOrClassStaticBlock(property, receiver); + if (!statement) { + continue; + } + statements.push(statement); + } + } + function transformPropertyOrClassStaticBlock(property, receiver) { + var expression = ts.isClassStaticBlockDeclaration(property) ? + transformClassStaticBlockDeclaration(property) : + transformProperty(property, receiver); + if (!expression) { + return undefined; + } + var statement = factory.createExpressionStatement(expression); + ts.setOriginalNode(statement, property); + ts.addEmitFlags(statement, ts.getEmitFlags(property) & 1536 /* EmitFlags.NoComments */); + ts.setSourceMapRange(statement, ts.moveRangePastModifiers(property)); + ts.setCommentRange(statement, property); + // `setOriginalNode` *copies* the `emitNode` from `property`, so now both + // `statement` and `expression` have a copy of the synthesized comments. + // Drop the comments from expression to avoid printing them twice. + ts.setSyntheticLeadingComments(expression, undefined); + ts.setSyntheticTrailingComments(expression, undefined); + return statement; + } + /** + * Generates assignment expressions for property initializers. + * + * @param propertiesOrClassStaticBlocks An array of property declarations to transform. + * @param receiver The receiver on which each property should be assigned. + */ + function generateInitializedPropertyExpressionsOrClassStaticBlock(propertiesOrClassStaticBlocks, receiver) { + var expressions = []; + for (var _i = 0, propertiesOrClassStaticBlocks_1 = propertiesOrClassStaticBlocks; _i < propertiesOrClassStaticBlocks_1.length; _i++) { + var property = propertiesOrClassStaticBlocks_1[_i]; + var expression = ts.isClassStaticBlockDeclaration(property) ? transformClassStaticBlockDeclaration(property) : transformProperty(property, receiver); + if (!expression) { + continue; + } + ts.startOnNewLine(expression); + ts.setOriginalNode(expression, property); + ts.addEmitFlags(expression, ts.getEmitFlags(property) & 1536 /* EmitFlags.NoComments */); + ts.setSourceMapRange(expression, ts.moveRangePastModifiers(property)); + ts.setCommentRange(expression, property); + expressions.push(expression); + } + return expressions; + } + /** + * Transforms a property initializer into an assignment statement. + * + * @param property The property declaration. + * @param receiver The object receiving the property assignment. + */ + function transformProperty(property, receiver) { + var savedCurrentStaticPropertyDeclarationOrStaticBlock = currentStaticPropertyDeclarationOrStaticBlock; + var transformed = transformPropertyWorker(property, receiver); + if (transformed && ts.hasStaticModifier(property) && (currentClassLexicalEnvironment === null || currentClassLexicalEnvironment === void 0 ? void 0 : currentClassLexicalEnvironment.facts)) { + // capture the lexical environment for the member + ts.setOriginalNode(transformed, property); + ts.addEmitFlags(transformed, 2 /* EmitFlags.AdviseOnEmitNode */); + classLexicalEnvironmentMap.set(ts.getOriginalNodeId(transformed), currentClassLexicalEnvironment); + } + currentStaticPropertyDeclarationOrStaticBlock = savedCurrentStaticPropertyDeclarationOrStaticBlock; + return transformed; + } + function transformPropertyWorker(property, receiver) { + var _a; + // We generate a name here in order to reuse the value cached by the relocated computed name expression (which uses the same generated name) + var emitAssignment = !useDefineForClassFields; + var propertyName = ts.hasAccessorModifier(property) ? + factory.getGeneratedPrivateNameForNode(property.name) : + ts.isComputedPropertyName(property.name) && !ts.isSimpleInlineableExpression(property.name.expression) ? + factory.updateComputedPropertyName(property.name, factory.getGeneratedNameForNode(property.name)) : + property.name; + if (ts.hasStaticModifier(property)) { + currentStaticPropertyDeclarationOrStaticBlock = property; + } + if (shouldTransformPrivateElementsOrClassStaticBlocks && ts.isPrivateIdentifier(propertyName)) { + var privateIdentifierInfo = accessPrivateIdentifier(propertyName); + if (privateIdentifierInfo) { + if (privateIdentifierInfo.kind === "f" /* PrivateIdentifierKind.Field */) { + if (!privateIdentifierInfo.isStatic) { + return createPrivateInstanceFieldInitializer(receiver, ts.visitNode(property.initializer, visitor, ts.isExpression), privateIdentifierInfo.brandCheckIdentifier); + } + else { + return createPrivateStaticFieldInitializer(privateIdentifierInfo.variableName, ts.visitNode(property.initializer, visitor, ts.isExpression)); + } + } + else { + return undefined; + } + } + else { + ts.Debug.fail("Undeclared private name for property declaration."); + } + } + if ((ts.isPrivateIdentifier(propertyName) || ts.hasStaticModifier(property)) && !property.initializer) { + return undefined; + } + var propertyOriginalNode = ts.getOriginalNode(property); + if (ts.hasSyntacticModifier(propertyOriginalNode, 256 /* ModifierFlags.Abstract */)) { + return undefined; + } + var initializer = property.initializer || emitAssignment ? (_a = ts.visitNode(property.initializer, visitor, ts.isExpression)) !== null && _a !== void 0 ? _a : factory.createVoidZero() + : ts.isParameterPropertyDeclaration(propertyOriginalNode, propertyOriginalNode.parent) && ts.isIdentifier(propertyName) ? propertyName + : factory.createVoidZero(); + if (emitAssignment || ts.isPrivateIdentifier(propertyName)) { + var memberAccess = ts.createMemberAccessForPropertyName(factory, receiver, propertyName, /*location*/ propertyName); + return factory.createAssignment(memberAccess, initializer); + } + else { + var name = ts.isComputedPropertyName(propertyName) ? propertyName.expression + : ts.isIdentifier(propertyName) ? factory.createStringLiteral(ts.unescapeLeadingUnderscores(propertyName.escapedText)) + : propertyName; + var descriptor = factory.createPropertyDescriptor({ value: initializer, configurable: true, writable: true, enumerable: true }); + return factory.createObjectDefinePropertyCall(receiver, name, descriptor); + } + } + function enableSubstitutionForClassAliases() { + if ((enabledSubstitutions & 1 /* ClassPropertySubstitutionFlags.ClassAliases */) === 0) { + enabledSubstitutions |= 1 /* ClassPropertySubstitutionFlags.ClassAliases */; + // We need to enable substitutions for identifiers. This allows us to + // substitute class names inside of a class declaration. + context.enableSubstitution(79 /* SyntaxKind.Identifier */); + // Keep track of class aliases. + classAliases = []; + } + } + function enableSubstitutionForClassStaticThisOrSuperReference() { + if ((enabledSubstitutions & 2 /* ClassPropertySubstitutionFlags.ClassStaticThisOrSuperReference */) === 0) { + enabledSubstitutions |= 2 /* ClassPropertySubstitutionFlags.ClassStaticThisOrSuperReference */; + // substitute `this` in a static field initializer + context.enableSubstitution(108 /* SyntaxKind.ThisKeyword */); + // these push a new lexical environment that is not the class lexical environment + context.enableEmitNotification(259 /* SyntaxKind.FunctionDeclaration */); + context.enableEmitNotification(215 /* SyntaxKind.FunctionExpression */); + context.enableEmitNotification(173 /* SyntaxKind.Constructor */); + // these push a new lexical environment that is not the class lexical environment, except + // when they have a computed property name + context.enableEmitNotification(174 /* SyntaxKind.GetAccessor */); + context.enableEmitNotification(175 /* SyntaxKind.SetAccessor */); + context.enableEmitNotification(171 /* SyntaxKind.MethodDeclaration */); + context.enableEmitNotification(169 /* SyntaxKind.PropertyDeclaration */); + // class lexical environments are restored when entering a computed property name + context.enableEmitNotification(164 /* SyntaxKind.ComputedPropertyName */); + } + } + /** + * Generates brand-check initializer for private methods. + * + * @param statements Statement list that should be used to append new statements. + * @param methods An array of method declarations. + * @param receiver The receiver on which each method should be assigned. + */ + function addMethodStatements(statements, methods, receiver) { + if (!shouldTransformPrivateElementsOrClassStaticBlocks || !ts.some(methods)) { + return; + } + var weakSetName = getPrivateIdentifierEnvironment().weakSetName; + ts.Debug.assert(weakSetName, "weakSetName should be set in private identifier environment"); + statements.push(factory.createExpressionStatement(createPrivateInstanceMethodInitializer(receiver, weakSetName))); + } + function visitInvalidSuperProperty(node) { + return ts.isPropertyAccessExpression(node) ? + factory.updatePropertyAccessExpression(node, factory.createVoidZero(), node.name) : + factory.updateElementAccessExpression(node, factory.createVoidZero(), ts.visitNode(node.argumentExpression, visitor, ts.isExpression)); + } + function onEmitNode(hint, node, emitCallback) { + var original = ts.getOriginalNode(node); + if (original.id) { + var classLexicalEnvironment = classLexicalEnvironmentMap.get(original.id); + if (classLexicalEnvironment) { + var savedClassLexicalEnvironment = currentClassLexicalEnvironment; + var savedCurrentComputedPropertyNameClassLexicalEnvironment = currentComputedPropertyNameClassLexicalEnvironment; + currentClassLexicalEnvironment = classLexicalEnvironment; + currentComputedPropertyNameClassLexicalEnvironment = classLexicalEnvironment; + previousOnEmitNode(hint, node, emitCallback); + currentClassLexicalEnvironment = savedClassLexicalEnvironment; + currentComputedPropertyNameClassLexicalEnvironment = savedCurrentComputedPropertyNameClassLexicalEnvironment; + return; + } + } + switch (node.kind) { + case 215 /* SyntaxKind.FunctionExpression */: + if (ts.isArrowFunction(original) || ts.getEmitFlags(node) & 262144 /* EmitFlags.AsyncFunctionBody */) { + break; + } + // falls through + case 259 /* SyntaxKind.FunctionDeclaration */: + case 173 /* SyntaxKind.Constructor */: { + var savedClassLexicalEnvironment = currentClassLexicalEnvironment; + var savedCurrentComputedPropertyNameClassLexicalEnvironment = currentComputedPropertyNameClassLexicalEnvironment; + currentClassLexicalEnvironment = undefined; + currentComputedPropertyNameClassLexicalEnvironment = undefined; + previousOnEmitNode(hint, node, emitCallback); + currentClassLexicalEnvironment = savedClassLexicalEnvironment; + currentComputedPropertyNameClassLexicalEnvironment = savedCurrentComputedPropertyNameClassLexicalEnvironment; + return; + } + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 169 /* SyntaxKind.PropertyDeclaration */: { + var savedClassLexicalEnvironment = currentClassLexicalEnvironment; + var savedCurrentComputedPropertyNameClassLexicalEnvironment = currentComputedPropertyNameClassLexicalEnvironment; + currentComputedPropertyNameClassLexicalEnvironment = currentClassLexicalEnvironment; + currentClassLexicalEnvironment = undefined; + previousOnEmitNode(hint, node, emitCallback); + currentClassLexicalEnvironment = savedClassLexicalEnvironment; + currentComputedPropertyNameClassLexicalEnvironment = savedCurrentComputedPropertyNameClassLexicalEnvironment; + return; + } + case 164 /* SyntaxKind.ComputedPropertyName */: { + var savedClassLexicalEnvironment = currentClassLexicalEnvironment; + var savedCurrentComputedPropertyNameClassLexicalEnvironment = currentComputedPropertyNameClassLexicalEnvironment; + currentClassLexicalEnvironment = currentComputedPropertyNameClassLexicalEnvironment; + currentComputedPropertyNameClassLexicalEnvironment = undefined; + previousOnEmitNode(hint, node, emitCallback); + currentClassLexicalEnvironment = savedClassLexicalEnvironment; + currentComputedPropertyNameClassLexicalEnvironment = savedCurrentComputedPropertyNameClassLexicalEnvironment; + return; + } + } + previousOnEmitNode(hint, node, emitCallback); + } + /** + * Hooks node substitutions. + * + * @param hint The context for the emitter. + * @param node The node to substitute. + */ + function onSubstituteNode(hint, node) { + node = previousOnSubstituteNode(hint, node); + if (hint === 1 /* EmitHint.Expression */) { + return substituteExpression(node); + } + return node; + } + function substituteExpression(node) { + switch (node.kind) { + case 79 /* SyntaxKind.Identifier */: + return substituteExpressionIdentifier(node); + case 108 /* SyntaxKind.ThisKeyword */: + return substituteThisExpression(node); + } + return node; + } + function substituteThisExpression(node) { + if (enabledSubstitutions & 2 /* ClassPropertySubstitutionFlags.ClassStaticThisOrSuperReference */ && currentClassLexicalEnvironment) { + var facts = currentClassLexicalEnvironment.facts, classConstructor = currentClassLexicalEnvironment.classConstructor; + if (facts & 1 /* ClassFacts.ClassWasDecorated */) { + return factory.createParenthesizedExpression(factory.createVoidZero()); + } + if (classConstructor) { + return ts.setTextRange(ts.setOriginalNode(factory.cloneNode(classConstructor), node), node); + } + } + return node; + } + function substituteExpressionIdentifier(node) { + return trySubstituteClassAlias(node) || node; + } + function trySubstituteClassAlias(node) { + if (enabledSubstitutions & 1 /* ClassPropertySubstitutionFlags.ClassAliases */) { + if (resolver.getNodeCheckFlags(node) & 33554432 /* NodeCheckFlags.ConstructorReferenceInClass */) { + // Due to the emit for class decorators, any reference to the class from inside of the class body + // must instead be rewritten to point to a temporary variable to avoid issues with the double-bind + // behavior of class names in ES6. + // Also, when emitting statics for class expressions, we must substitute a class alias for + // constructor references in static property initializers. + var declaration = resolver.getReferencedValueDeclaration(node); + if (declaration) { + var classAlias = classAliases[declaration.id]; // TODO: GH#18217 + if (classAlias) { + var clone_2 = factory.cloneNode(classAlias); + ts.setSourceMapRange(clone_2, node); + ts.setCommentRange(clone_2, node); + return clone_2; + } + } + } + } + return undefined; + } + /** + * If the name is a computed property, this function transforms it, then either returns an expression which caches the + * value of the result or the expression itself if the value is either unused or safe to inline into multiple locations + * @param shouldHoist Does the expression need to be reused? (ie, for an initializer or a decorator) + */ + function getPropertyNameExpressionIfNeeded(name, shouldHoist) { + if (ts.isComputedPropertyName(name)) { + var expression = ts.visitNode(name.expression, visitor, ts.isExpression); + var innerExpression = ts.skipPartiallyEmittedExpressions(expression); + var inlinable = ts.isSimpleInlineableExpression(innerExpression); + var alreadyTransformed = ts.isAssignmentExpression(innerExpression) && ts.isGeneratedIdentifier(innerExpression.left); + if (!alreadyTransformed && !inlinable && shouldHoist) { + var generatedName = factory.getGeneratedNameForNode(name); + if (resolver.getNodeCheckFlags(name) & 524288 /* NodeCheckFlags.BlockScopedBindingInLoop */) { + addBlockScopedVariable(generatedName); + } + else { + hoistVariableDeclaration(generatedName); + } + return factory.createAssignment(generatedName, expression); + } + return (inlinable || ts.isIdentifier(innerExpression)) ? undefined : expression; + } + } + function startClassLexicalEnvironment() { + classLexicalEnvironmentStack.push(currentClassLexicalEnvironment); + currentClassLexicalEnvironment = undefined; + } + function endClassLexicalEnvironment() { + currentClassLexicalEnvironment = classLexicalEnvironmentStack.pop(); + } + function getClassLexicalEnvironment() { + return currentClassLexicalEnvironment || (currentClassLexicalEnvironment = { + facts: 0 /* ClassFacts.None */, + classConstructor: undefined, + superClassReference: undefined, + privateIdentifierEnvironment: undefined, + }); + } + function getPrivateIdentifierEnvironment() { + var lex = getClassLexicalEnvironment(); + lex.privateIdentifierEnvironment || (lex.privateIdentifierEnvironment = { + className: undefined, + weakSetName: undefined, + identifiers: undefined, + generatedIdentifiers: undefined, + }); + return lex.privateIdentifierEnvironment; + } + function getPendingExpressions() { + return pendingExpressions !== null && pendingExpressions !== void 0 ? pendingExpressions : (pendingExpressions = []); + } + function addPrivateIdentifierClassElementToEnvironment(node, name, lex, privateEnv, isStatic, isValid, previousInfo) { + if (ts.isAutoAccessorPropertyDeclaration(node)) { + addPrivateIdentifierAutoAccessorPropertyDeclarationToEnvironment(node, name, lex, privateEnv, isStatic, isValid, previousInfo); + } + else if (ts.isPropertyDeclaration(node)) { + addPrivateIdentifierPropertyDeclarationToEnvironment(node, name, lex, privateEnv, isStatic, isValid, previousInfo); + } + else if (ts.isMethodDeclaration(node)) { + addPrivateIdentifierMethodDeclarationToEnvironment(node, name, lex, privateEnv, isStatic, isValid, previousInfo); + } + else if (ts.isGetAccessorDeclaration(node)) { + addPrivateIdentifierGetAccessorDeclarationToEnvironment(node, name, lex, privateEnv, isStatic, isValid, previousInfo); + } + else if (ts.isSetAccessorDeclaration(node)) { + addPrivateIdentifierSetAccessorDeclarationToEnvironment(node, name, lex, privateEnv, isStatic, isValid, previousInfo); + } + } + function addPrivateIdentifierPropertyDeclarationToEnvironment(_node, name, lex, privateEnv, isStatic, isValid, _previousInfo) { + if (isStatic) { + ts.Debug.assert(lex.classConstructor, "classConstructor should be set in private identifier environment"); + var variableName = createHoistedVariableForPrivateName(name); + setPrivateIdentifier(privateEnv, name, { + kind: "f" /* PrivateIdentifierKind.Field */, + brandCheckIdentifier: lex.classConstructor, + variableName: variableName, + isStatic: true, + isValid: isValid, + }); + } + else { + var weakMapName = createHoistedVariableForPrivateName(name); + setPrivateIdentifier(privateEnv, name, { + kind: "f" /* PrivateIdentifierKind.Field */, + brandCheckIdentifier: weakMapName, + variableName: undefined, + isStatic: false, + isValid: isValid, + }); + getPendingExpressions().push(factory.createAssignment(weakMapName, factory.createNewExpression(factory.createIdentifier("WeakMap"), + /*typeArguments*/ undefined, []))); + } + } + function addPrivateIdentifierMethodDeclarationToEnvironment(_node, name, lex, privateEnv, isStatic, isValid, _previousInfo) { + var methodName = createHoistedVariableForPrivateName(name); + var brandCheckIdentifier = isStatic ? + ts.Debug.checkDefined(lex.classConstructor, "classConstructor should be set in private identifier environment") : + ts.Debug.checkDefined(privateEnv.weakSetName, "weakSetName should be set in private identifier environment"); + setPrivateIdentifier(privateEnv, name, { + kind: "m" /* PrivateIdentifierKind.Method */, + methodName: methodName, + brandCheckIdentifier: brandCheckIdentifier, + isStatic: isStatic, + isValid: isValid, + }); + } + function addPrivateIdentifierGetAccessorDeclarationToEnvironment(_node, name, lex, privateEnv, isStatic, isValid, previousInfo) { + var getterName = createHoistedVariableForPrivateName(name, "_get"); + var brandCheckIdentifier = isStatic ? + ts.Debug.checkDefined(lex.classConstructor, "classConstructor should be set in private identifier environment") : + ts.Debug.checkDefined(privateEnv.weakSetName, "weakSetName should be set in private identifier environment"); + if ((previousInfo === null || previousInfo === void 0 ? void 0 : previousInfo.kind) === "a" /* PrivateIdentifierKind.Accessor */ && previousInfo.isStatic === isStatic && !previousInfo.getterName) { + previousInfo.getterName = getterName; + } + else { + setPrivateIdentifier(privateEnv, name, { + kind: "a" /* PrivateIdentifierKind.Accessor */, + getterName: getterName, + setterName: undefined, + brandCheckIdentifier: brandCheckIdentifier, + isStatic: isStatic, + isValid: isValid, + }); + } + } + function addPrivateIdentifierSetAccessorDeclarationToEnvironment(_node, name, lex, privateEnv, isStatic, isValid, previousInfo) { + var setterName = createHoistedVariableForPrivateName(name, "_set"); + var brandCheckIdentifier = isStatic ? + ts.Debug.checkDefined(lex.classConstructor, "classConstructor should be set in private identifier environment") : + ts.Debug.checkDefined(privateEnv.weakSetName, "weakSetName should be set in private identifier environment"); + if ((previousInfo === null || previousInfo === void 0 ? void 0 : previousInfo.kind) === "a" /* PrivateIdentifierKind.Accessor */ && previousInfo.isStatic === isStatic && !previousInfo.setterName) { + previousInfo.setterName = setterName; + } + else { + setPrivateIdentifier(privateEnv, name, { + kind: "a" /* PrivateIdentifierKind.Accessor */, + getterName: undefined, + setterName: setterName, + brandCheckIdentifier: brandCheckIdentifier, + isStatic: isStatic, + isValid: isValid, + }); + } + } + function addPrivateIdentifierAutoAccessorPropertyDeclarationToEnvironment(_node, name, lex, privateEnv, isStatic, isValid, _previousInfo) { + var getterName = createHoistedVariableForPrivateName(name, "_get"); + var setterName = createHoistedVariableForPrivateName(name, "_set"); + var brandCheckIdentifier = isStatic ? + ts.Debug.checkDefined(lex.classConstructor, "classConstructor should be set in private identifier environment") : + ts.Debug.checkDefined(privateEnv.weakSetName, "weakSetName should be set in private identifier environment"); + setPrivateIdentifier(privateEnv, name, { + kind: "a" /* PrivateIdentifierKind.Accessor */, + getterName: getterName, + setterName: setterName, + brandCheckIdentifier: brandCheckIdentifier, + isStatic: isStatic, + isValid: isValid, + }); + } + function addPrivateIdentifierToEnvironment(node, name, addDeclaration) { + var lex = getClassLexicalEnvironment(); + var privateEnv = getPrivateIdentifierEnvironment(); + var previousInfo = getPrivateIdentifier(privateEnv, name); + var isStatic = ts.hasStaticModifier(node); + var isValid = !isReservedPrivateName(name) && previousInfo === undefined; + addDeclaration(node, name, lex, privateEnv, isStatic, isValid, previousInfo); + } + function createHoistedVariableForClass(name, node, suffix) { + var className = getPrivateIdentifierEnvironment().className; + var prefix = className ? { prefix: "_", node: className, suffix: "_" } : "_"; + var identifier = typeof name === "object" ? factory.getGeneratedNameForNode(name, 16 /* GeneratedIdentifierFlags.Optimistic */ | 8 /* GeneratedIdentifierFlags.ReservedInNestedScopes */, prefix, suffix) : + typeof name === "string" ? factory.createUniqueName(name, 16 /* GeneratedIdentifierFlags.Optimistic */, prefix, suffix) : + factory.createTempVariable(/*recordTempVariable*/ undefined, /*reserveInNestedScopes*/ true, prefix, suffix); + if (resolver.getNodeCheckFlags(node) & 524288 /* NodeCheckFlags.BlockScopedBindingInLoop */) { + addBlockScopedVariable(identifier); + } + else { + hoistVariableDeclaration(identifier); + } + return identifier; + } + function createHoistedVariableForPrivateName(name, suffix) { + var _a; + var text = ts.tryGetTextOfPropertyName(name); + return createHoistedVariableForClass((_a = text === null || text === void 0 ? void 0 : text.substring(1)) !== null && _a !== void 0 ? _a : name, name, suffix); + } + /** + * Access an already defined {@link PrivateIdentifier} in the current {@link PrivateIdentifierEnvironment}. + * + * @seealso {@link addPrivateIdentifierToEnvironment} + */ + function accessPrivateIdentifier(name) { + if (ts.isGeneratedPrivateIdentifier(name)) { + return accessGeneratedPrivateIdentifier(name); + } + else { + return accessPrivateIdentifierByText(name.escapedText); + } + } + function accessPrivateIdentifierByText(text) { + return accessPrivateIdentifierWorker(getPrivateIdentifierInfo, text); + } + function accessGeneratedPrivateIdentifier(name) { + return accessPrivateIdentifierWorker(getGeneratedPrivateIdentifierInfo, ts.getNodeForGeneratedName(name)); + } + function accessPrivateIdentifierWorker(getPrivateIdentifierInfo, privateIdentifierKey) { + if (currentClassLexicalEnvironment === null || currentClassLexicalEnvironment === void 0 ? void 0 : currentClassLexicalEnvironment.privateIdentifierEnvironment) { + var info = getPrivateIdentifierInfo(currentClassLexicalEnvironment.privateIdentifierEnvironment, privateIdentifierKey); + if (info) { + return info; + } + } + for (var i = classLexicalEnvironmentStack.length - 1; i >= 0; --i) { + var env = classLexicalEnvironmentStack[i]; + if (!env) { + continue; + } + if (env.privateIdentifierEnvironment) { + var info = getPrivateIdentifierInfo(env.privateIdentifierEnvironment, privateIdentifierKey); + if (info) { + return info; + } + } + } + return undefined; + } + function wrapPrivateIdentifierForDestructuringTarget(node) { + var parameter = factory.getGeneratedNameForNode(node); + var info = accessPrivateIdentifier(node.name); + if (!info) { + return ts.visitEachChild(node, visitor, context); + } + var receiver = node.expression; + // We cannot copy `this` or `super` into the function because they will be bound + // differently inside the function. + if (ts.isThisProperty(node) || ts.isSuperProperty(node) || !ts.isSimpleCopiableExpression(node.expression)) { + receiver = factory.createTempVariable(hoistVariableDeclaration, /*reservedInNestedScopes*/ true); + getPendingExpressions().push(factory.createBinaryExpression(receiver, 63 /* SyntaxKind.EqualsToken */, ts.visitNode(node.expression, visitor, ts.isExpression))); + } + return factory.createAssignmentTargetWrapper(parameter, createPrivateIdentifierAssignment(info, receiver, parameter, 63 /* SyntaxKind.EqualsToken */)); + } + function visitArrayAssignmentTarget(node) { + var target = ts.getTargetOfBindingOrAssignmentElement(node); + if (target) { + var wrapped = void 0; + if (ts.isPrivateIdentifierPropertyAccessExpression(target)) { + wrapped = wrapPrivateIdentifierForDestructuringTarget(target); + } + else if (shouldTransformSuperInStaticInitializers && + ts.isSuperProperty(target) && + currentStaticPropertyDeclarationOrStaticBlock && + currentClassLexicalEnvironment) { + var classConstructor = currentClassLexicalEnvironment.classConstructor, superClassReference = currentClassLexicalEnvironment.superClassReference, facts = currentClassLexicalEnvironment.facts; + if (facts & 1 /* ClassFacts.ClassWasDecorated */) { + wrapped = visitInvalidSuperProperty(target); + } + else if (classConstructor && superClassReference) { + var name = ts.isElementAccessExpression(target) ? ts.visitNode(target.argumentExpression, visitor, ts.isExpression) : + ts.isIdentifier(target.name) ? factory.createStringLiteralFromNode(target.name) : + undefined; + if (name) { + var temp = factory.createTempVariable(/*recordTempVariable*/ undefined); + wrapped = factory.createAssignmentTargetWrapper(temp, factory.createReflectSetCall(superClassReference, name, temp, classConstructor)); + } + } + } + if (wrapped) { + if (ts.isAssignmentExpression(node)) { + return factory.updateBinaryExpression(node, wrapped, node.operatorToken, ts.visitNode(node.right, visitor, ts.isExpression)); + } + else if (ts.isSpreadElement(node)) { + return factory.updateSpreadElement(node, wrapped); + } + else { + return wrapped; + } + } + } + return ts.visitNode(node, assignmentTargetVisitor); + } + function visitObjectAssignmentTarget(node) { + if (ts.isObjectBindingOrAssignmentElement(node) && !ts.isShorthandPropertyAssignment(node)) { + var target = ts.getTargetOfBindingOrAssignmentElement(node); + var wrapped = void 0; + if (target) { + if (ts.isPrivateIdentifierPropertyAccessExpression(target)) { + wrapped = wrapPrivateIdentifierForDestructuringTarget(target); + } + else if (shouldTransformSuperInStaticInitializers && + ts.isSuperProperty(target) && + currentStaticPropertyDeclarationOrStaticBlock && + currentClassLexicalEnvironment) { + var classConstructor = currentClassLexicalEnvironment.classConstructor, superClassReference = currentClassLexicalEnvironment.superClassReference, facts = currentClassLexicalEnvironment.facts; + if (facts & 1 /* ClassFacts.ClassWasDecorated */) { + wrapped = visitInvalidSuperProperty(target); + } + else if (classConstructor && superClassReference) { + var name = ts.isElementAccessExpression(target) ? ts.visitNode(target.argumentExpression, visitor, ts.isExpression) : + ts.isIdentifier(target.name) ? factory.createStringLiteralFromNode(target.name) : + undefined; + if (name) { + var temp = factory.createTempVariable(/*recordTempVariable*/ undefined); + wrapped = factory.createAssignmentTargetWrapper(temp, factory.createReflectSetCall(superClassReference, name, temp, classConstructor)); + } + } + } + } + if (ts.isPropertyAssignment(node)) { + var initializer = ts.getInitializerOfBindingOrAssignmentElement(node); + return factory.updatePropertyAssignment(node, ts.visitNode(node.name, visitor, ts.isPropertyName), wrapped ? + initializer ? factory.createAssignment(wrapped, ts.visitNode(initializer, visitor)) : wrapped : + ts.visitNode(node.initializer, assignmentTargetVisitor, ts.isExpression)); + } + if (ts.isSpreadAssignment(node)) { + return factory.updateSpreadAssignment(node, wrapped || ts.visitNode(node.expression, assignmentTargetVisitor, ts.isExpression)); + } + ts.Debug.assert(wrapped === undefined, "Should not have generated a wrapped target"); + } + return ts.visitNode(node, visitor); + } + function visitAssignmentPattern(node) { + if (ts.isArrayLiteralExpression(node)) { + // Transforms private names in destructuring assignment array bindings. + // Transforms SuperProperty assignments in destructuring assignment array bindings in static initializers. + // + // Source: + // ([ this.#myProp ] = [ "hello" ]); + // + // Transformation: + // [ { set value(x) { this.#myProp = x; } }.value ] = [ "hello" ]; + return factory.updateArrayLiteralExpression(node, ts.visitNodes(node.elements, visitArrayAssignmentTarget, ts.isExpression)); + } + else { + // Transforms private names in destructuring assignment object bindings. + // Transforms SuperProperty assignments in destructuring assignment object bindings in static initializers. + // + // Source: + // ({ stringProperty: this.#myProp } = { stringProperty: "hello" }); + // + // Transformation: + // ({ stringProperty: { set value(x) { this.#myProp = x; } }.value }) = { stringProperty: "hello" }; + return factory.updateObjectLiteralExpression(node, ts.visitNodes(node.properties, visitObjectAssignmentTarget, ts.isObjectLiteralElementLike)); + } + } + } + ts.transformClassFields = transformClassFields; + function createPrivateStaticFieldInitializer(variableName, initializer) { + return ts.factory.createAssignment(variableName, ts.factory.createObjectLiteralExpression([ + ts.factory.createPropertyAssignment("value", initializer || ts.factory.createVoidZero()) + ])); + } + function createPrivateInstanceFieldInitializer(receiver, initializer, weakMapName) { + return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(weakMapName, "set"), + /*typeArguments*/ undefined, [receiver, initializer || ts.factory.createVoidZero()]); + } + function createPrivateInstanceMethodInitializer(receiver, weakSetName) { + return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(weakSetName, "add"), + /*typeArguments*/ undefined, [receiver]); + } + function isReservedPrivateName(node) { + return !ts.isGeneratedPrivateIdentifier(node) && node.escapedText === "#constructor"; + } + function getPrivateIdentifier(privateEnv, name) { + return ts.isGeneratedPrivateIdentifier(name) ? + getGeneratedPrivateIdentifierInfo(privateEnv, ts.getNodeForGeneratedName(name)) : + getPrivateIdentifierInfo(privateEnv, name.escapedText); + } + function setPrivateIdentifier(privateEnv, name, info) { + var _a, _b; + if (ts.isGeneratedPrivateIdentifier(name)) { + (_a = privateEnv.generatedIdentifiers) !== null && _a !== void 0 ? _a : (privateEnv.generatedIdentifiers = new ts.Map()); + privateEnv.generatedIdentifiers.set(ts.getNodeForGeneratedName(name), info); + } + else { + (_b = privateEnv.identifiers) !== null && _b !== void 0 ? _b : (privateEnv.identifiers = new ts.Map()); + privateEnv.identifiers.set(name.escapedText, info); + } + } + function getPrivateIdentifierInfo(privateEnv, key) { + var _a; + return (_a = privateEnv.identifiers) === null || _a === void 0 ? void 0 : _a.get(key); + } + function getGeneratedPrivateIdentifierInfo(privateEnv, key) { + var _a; + return (_a = privateEnv.generatedIdentifiers) === null || _a === void 0 ? void 0 : _a.get(key); + } +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + function createRuntimeTypeSerializer(context) { + var hoistVariableDeclaration = context.hoistVariableDeclaration; + var resolver = context.getEmitResolver(); + var compilerOptions = context.getCompilerOptions(); + var languageVersion = ts.getEmitScriptTarget(compilerOptions); + var strictNullChecks = ts.getStrictOptionValue(compilerOptions, "strictNullChecks"); + var currentLexicalScope; + var currentNameScope; + return { + serializeTypeNode: function (serializerContext, node) { return setSerializerContextAnd(serializerContext, serializeTypeNode, node); }, + serializeTypeOfNode: function (serializerContext, node) { return setSerializerContextAnd(serializerContext, serializeTypeOfNode, node); }, + serializeParameterTypesOfNode: function (serializerContext, node, container) { return setSerializerContextAnd(serializerContext, serializeParameterTypesOfNode, node, container); }, + serializeReturnTypeOfNode: function (serializerContext, node) { return setSerializerContextAnd(serializerContext, serializeReturnTypeOfNode, node); }, + }; + function setSerializerContextAnd(serializerContext, cb, node, arg) { + var savedCurrentLexicalScope = currentLexicalScope; + var savedCurrentNameScope = currentNameScope; + currentLexicalScope = serializerContext.currentLexicalScope; + currentNameScope = serializerContext.currentNameScope; + var result = arg === undefined ? cb(node) : cb(node, arg); + currentLexicalScope = savedCurrentLexicalScope; + currentNameScope = savedCurrentNameScope; + return result; + } + function getAccessorTypeNode(node) { + var accessors = resolver.getAllAccessorDeclarations(node); + return accessors.setAccessor && ts.getSetAccessorTypeAnnotationNode(accessors.setAccessor) + || accessors.getAccessor && ts.getEffectiveReturnTypeNode(accessors.getAccessor); + } + /** + * Serializes the type of a node for use with decorator type metadata. + * @param node The node that should have its type serialized. + */ + function serializeTypeOfNode(node) { + switch (node.kind) { + case 169 /* SyntaxKind.PropertyDeclaration */: + case 166 /* SyntaxKind.Parameter */: + return serializeTypeNode(node.type); + case 175 /* SyntaxKind.SetAccessor */: + case 174 /* SyntaxKind.GetAccessor */: + return serializeTypeNode(getAccessorTypeNode(node)); + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + case 171 /* SyntaxKind.MethodDeclaration */: + return ts.factory.createIdentifier("Function"); + default: + return ts.factory.createVoidZero(); + } + } + /** + * Serializes the type of a node for use with decorator type metadata. + * @param node The node that should have its type serialized. + */ + function serializeParameterTypesOfNode(node, container) { + var valueDeclaration = ts.isClassLike(node) + ? ts.getFirstConstructorWithBody(node) + : ts.isFunctionLike(node) && ts.nodeIsPresent(node.body) + ? node + : undefined; + var expressions = []; + if (valueDeclaration) { + var parameters = getParametersOfDecoratedDeclaration(valueDeclaration, container); + var numParameters = parameters.length; + for (var i = 0; i < numParameters; i++) { + var parameter = parameters[i]; + if (i === 0 && ts.isIdentifier(parameter.name) && parameter.name.escapedText === "this") { + continue; + } + if (parameter.dotDotDotToken) { + expressions.push(serializeTypeNode(ts.getRestParameterElementType(parameter.type))); + } + else { + expressions.push(serializeTypeOfNode(parameter)); + } + } + } + return ts.factory.createArrayLiteralExpression(expressions); + } + function getParametersOfDecoratedDeclaration(node, container) { + if (container && node.kind === 174 /* SyntaxKind.GetAccessor */) { + var setAccessor = ts.getAllAccessorDeclarations(container.members, node).setAccessor; + if (setAccessor) { + return setAccessor.parameters; + } + } + return node.parameters; + } + /** + * Serializes the return type of a node for use with decorator type metadata. + * @param node The node that should have its return type serialized. + */ + function serializeReturnTypeOfNode(node) { + if (ts.isFunctionLike(node) && node.type) { + return serializeTypeNode(node.type); + } + else if (ts.isAsyncFunction(node)) { + return ts.factory.createIdentifier("Promise"); + } + return ts.factory.createVoidZero(); + } + /** + * Serializes a type node for use with decorator type metadata. + * + * Types are serialized in the following fashion: + * - Void types point to "undefined" (e.g. "void 0") + * - Function and Constructor types point to the global "Function" constructor. + * - Interface types with a call or construct signature types point to the global + * "Function" constructor. + * - Array and Tuple types point to the global "Array" constructor. + * - Type predicates and booleans point to the global "Boolean" constructor. + * - String literal types and strings point to the global "String" constructor. + * - Enum and number types point to the global "Number" constructor. + * - Symbol types point to the global "Symbol" constructor. + * - Type references to classes (or class-like variables) point to the constructor for the class. + * - Anything else points to the global "Object" constructor. + * + * @param node The type node to serialize. + */ + function serializeTypeNode(node) { + if (node === undefined) { + return ts.factory.createIdentifier("Object"); + } + node = ts.skipTypeParentheses(node); + switch (node.kind) { + case 114 /* SyntaxKind.VoidKeyword */: + case 155 /* SyntaxKind.UndefinedKeyword */: + case 144 /* SyntaxKind.NeverKeyword */: + return ts.factory.createVoidZero(); + case 181 /* SyntaxKind.FunctionType */: + case 182 /* SyntaxKind.ConstructorType */: + return ts.factory.createIdentifier("Function"); + case 185 /* SyntaxKind.ArrayType */: + case 186 /* SyntaxKind.TupleType */: + return ts.factory.createIdentifier("Array"); + case 179 /* SyntaxKind.TypePredicate */: + return node.assertsModifier ? + ts.factory.createVoidZero() : + ts.factory.createIdentifier("Boolean"); + case 134 /* SyntaxKind.BooleanKeyword */: + return ts.factory.createIdentifier("Boolean"); + case 200 /* SyntaxKind.TemplateLiteralType */: + case 152 /* SyntaxKind.StringKeyword */: + return ts.factory.createIdentifier("String"); + case 149 /* SyntaxKind.ObjectKeyword */: + return ts.factory.createIdentifier("Object"); + case 198 /* SyntaxKind.LiteralType */: + return serializeLiteralOfLiteralTypeNode(node.literal); + case 148 /* SyntaxKind.NumberKeyword */: + return ts.factory.createIdentifier("Number"); + case 160 /* SyntaxKind.BigIntKeyword */: + return getGlobalConstructor("BigInt", 7 /* ScriptTarget.ES2020 */); + case 153 /* SyntaxKind.SymbolKeyword */: + return getGlobalConstructor("Symbol", 2 /* ScriptTarget.ES2015 */); + case 180 /* SyntaxKind.TypeReference */: + return serializeTypeReferenceNode(node); + case 190 /* SyntaxKind.IntersectionType */: + return serializeUnionOrIntersectionConstituents(node.types, /*isIntersection*/ true); + case 189 /* SyntaxKind.UnionType */: + return serializeUnionOrIntersectionConstituents(node.types, /*isIntersection*/ false); + case 191 /* SyntaxKind.ConditionalType */: + return serializeUnionOrIntersectionConstituents([node.trueType, node.falseType], /*isIntersection*/ false); + case 195 /* SyntaxKind.TypeOperator */: + if (node.operator === 146 /* SyntaxKind.ReadonlyKeyword */) { + return serializeTypeNode(node.type); + } + break; + case 183 /* SyntaxKind.TypeQuery */: + case 196 /* SyntaxKind.IndexedAccessType */: + case 197 /* SyntaxKind.MappedType */: + case 184 /* SyntaxKind.TypeLiteral */: + case 131 /* SyntaxKind.AnyKeyword */: + case 157 /* SyntaxKind.UnknownKeyword */: + case 194 /* SyntaxKind.ThisType */: + case 202 /* SyntaxKind.ImportType */: + break; + // handle JSDoc types from an invalid parse + case 315 /* SyntaxKind.JSDocAllType */: + case 316 /* SyntaxKind.JSDocUnknownType */: + case 320 /* SyntaxKind.JSDocFunctionType */: + case 321 /* SyntaxKind.JSDocVariadicType */: + case 322 /* SyntaxKind.JSDocNamepathType */: + break; + case 317 /* SyntaxKind.JSDocNullableType */: + case 318 /* SyntaxKind.JSDocNonNullableType */: + case 319 /* SyntaxKind.JSDocOptionalType */: + return serializeTypeNode(node.type); + default: + return ts.Debug.failBadSyntaxKind(node); + } + return ts.factory.createIdentifier("Object"); + } + function serializeLiteralOfLiteralTypeNode(node) { + switch (node.kind) { + case 10 /* SyntaxKind.StringLiteral */: + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + return ts.factory.createIdentifier("String"); + case 221 /* SyntaxKind.PrefixUnaryExpression */: { + var operand = node.operand; + switch (operand.kind) { + case 8 /* SyntaxKind.NumericLiteral */: + case 9 /* SyntaxKind.BigIntLiteral */: + return serializeLiteralOfLiteralTypeNode(operand); + default: + return ts.Debug.failBadSyntaxKind(operand); + } + } + case 8 /* SyntaxKind.NumericLiteral */: + return ts.factory.createIdentifier("Number"); + case 9 /* SyntaxKind.BigIntLiteral */: + return getGlobalConstructor("BigInt", 7 /* ScriptTarget.ES2020 */); + case 110 /* SyntaxKind.TrueKeyword */: + case 95 /* SyntaxKind.FalseKeyword */: + return ts.factory.createIdentifier("Boolean"); + case 104 /* SyntaxKind.NullKeyword */: + return ts.factory.createVoidZero(); + default: + return ts.Debug.failBadSyntaxKind(node); + } + } + function serializeUnionOrIntersectionConstituents(types, isIntersection) { + // Note when updating logic here also update `getEntityNameForDecoratorMetadata` in checker.ts so that aliases can be marked as referenced + var serializedType; + for (var _i = 0, types_22 = types; _i < types_22.length; _i++) { + var typeNode = types_22[_i]; + typeNode = ts.skipTypeParentheses(typeNode); + if (typeNode.kind === 144 /* SyntaxKind.NeverKeyword */) { + if (isIntersection) + return ts.factory.createVoidZero(); // Reduce to `never` in an intersection + continue; // Elide `never` in a union + } + if (typeNode.kind === 157 /* SyntaxKind.UnknownKeyword */) { + if (!isIntersection) + return ts.factory.createIdentifier("Object"); // Reduce to `unknown` in a union + continue; // Elide `unknown` in an intersection + } + if (typeNode.kind === 131 /* SyntaxKind.AnyKeyword */) { + return ts.factory.createIdentifier("Object"); // Reduce to `any` in a union or intersection + } + if (!strictNullChecks && ((ts.isLiteralTypeNode(typeNode) && typeNode.literal.kind === 104 /* SyntaxKind.NullKeyword */) || typeNode.kind === 155 /* SyntaxKind.UndefinedKeyword */)) { + continue; // Elide null and undefined from unions for metadata, just like what we did prior to the implementation of strict null checks + } + var serializedConstituent = serializeTypeNode(typeNode); + if (ts.isIdentifier(serializedConstituent) && serializedConstituent.escapedText === "Object") { + // One of the individual is global object, return immediately + return serializedConstituent; + } + // If there exists union that is not `void 0` expression, check if the the common type is identifier. + // anything more complex and we will just default to Object + if (serializedType) { + // Different types + if (!equateSerializedTypeNodes(serializedType, serializedConstituent)) { + return ts.factory.createIdentifier("Object"); + } + } + else { + // Initialize the union type + serializedType = serializedConstituent; + } + } + // If we were able to find common type, use it + return serializedType !== null && serializedType !== void 0 ? serializedType : (ts.factory.createVoidZero()); // Fallback is only hit if all union constituents are null/undefined/never + } + function equateSerializedTypeNodes(left, right) { + return ( + // temp vars used in fallback + ts.isGeneratedIdentifier(left) ? ts.isGeneratedIdentifier(right) : + // entity names + ts.isIdentifier(left) ? ts.isIdentifier(right) + && left.escapedText === right.escapedText : + ts.isPropertyAccessExpression(left) ? ts.isPropertyAccessExpression(right) + && equateSerializedTypeNodes(left.expression, right.expression) + && equateSerializedTypeNodes(left.name, right.name) : + // `void 0` + ts.isVoidExpression(left) ? ts.isVoidExpression(right) + && ts.isNumericLiteral(left.expression) && left.expression.text === "0" + && ts.isNumericLiteral(right.expression) && right.expression.text === "0" : + // `"undefined"` or `"function"` in `typeof` checks + ts.isStringLiteral(left) ? ts.isStringLiteral(right) + && left.text === right.text : + // used in `typeof` checks for fallback + ts.isTypeOfExpression(left) ? ts.isTypeOfExpression(right) + && equateSerializedTypeNodes(left.expression, right.expression) : + // parens in `typeof` checks with temps + ts.isParenthesizedExpression(left) ? ts.isParenthesizedExpression(right) + && equateSerializedTypeNodes(left.expression, right.expression) : + // conditionals used in fallback + ts.isConditionalExpression(left) ? ts.isConditionalExpression(right) + && equateSerializedTypeNodes(left.condition, right.condition) + && equateSerializedTypeNodes(left.whenTrue, right.whenTrue) + && equateSerializedTypeNodes(left.whenFalse, right.whenFalse) : + // logical binary and assignments used in fallback + ts.isBinaryExpression(left) ? ts.isBinaryExpression(right) + && left.operatorToken.kind === right.operatorToken.kind + && equateSerializedTypeNodes(left.left, right.left) + && equateSerializedTypeNodes(left.right, right.right) : + false); + } + /** + * Serializes a TypeReferenceNode to an appropriate JS constructor value for use with decorator type metadata. + * @param node The type reference node. + */ + function serializeTypeReferenceNode(node) { + var kind = resolver.getTypeReferenceSerializationKind(node.typeName, currentNameScope !== null && currentNameScope !== void 0 ? currentNameScope : currentLexicalScope); + switch (kind) { + case ts.TypeReferenceSerializationKind.Unknown: + // From conditional type type reference that cannot be resolved is Similar to any or unknown + if (ts.findAncestor(node, function (n) { return n.parent && ts.isConditionalTypeNode(n.parent) && (n.parent.trueType === n || n.parent.falseType === n); })) { + return ts.factory.createIdentifier("Object"); + } + var serialized = serializeEntityNameAsExpressionFallback(node.typeName); + var temp = ts.factory.createTempVariable(hoistVariableDeclaration); + return ts.factory.createConditionalExpression(ts.factory.createTypeCheck(ts.factory.createAssignment(temp, serialized), "function"), + /*questionToken*/ undefined, temp, + /*colonToken*/ undefined, ts.factory.createIdentifier("Object")); + case ts.TypeReferenceSerializationKind.TypeWithConstructSignatureAndValue: + return serializeEntityNameAsExpression(node.typeName); + case ts.TypeReferenceSerializationKind.VoidNullableOrNeverType: + return ts.factory.createVoidZero(); + case ts.TypeReferenceSerializationKind.BigIntLikeType: + return getGlobalConstructor("BigInt", 7 /* ScriptTarget.ES2020 */); + case ts.TypeReferenceSerializationKind.BooleanType: + return ts.factory.createIdentifier("Boolean"); + case ts.TypeReferenceSerializationKind.NumberLikeType: + return ts.factory.createIdentifier("Number"); + case ts.TypeReferenceSerializationKind.StringLikeType: + return ts.factory.createIdentifier("String"); + case ts.TypeReferenceSerializationKind.ArrayLikeType: + return ts.factory.createIdentifier("Array"); + case ts.TypeReferenceSerializationKind.ESSymbolType: + return getGlobalConstructor("Symbol", 2 /* ScriptTarget.ES2015 */); + case ts.TypeReferenceSerializationKind.TypeWithCallSignature: + return ts.factory.createIdentifier("Function"); + case ts.TypeReferenceSerializationKind.Promise: + return ts.factory.createIdentifier("Promise"); + case ts.TypeReferenceSerializationKind.ObjectType: + return ts.factory.createIdentifier("Object"); + default: + return ts.Debug.assertNever(kind); + } + } + /** + * Produces an expression that results in `right` if `left` is not undefined at runtime: + * + * ``` + * typeof left !== "undefined" && right + * ``` + * + * We use `typeof L !== "undefined"` (rather than `L !== undefined`) since `L` may not be declared. + * It's acceptable for this expression to result in `false` at runtime, as the result is intended to be + * further checked by any containing expression. + */ + function createCheckedValue(left, right) { + return ts.factory.createLogicalAnd(ts.factory.createStrictInequality(ts.factory.createTypeOfExpression(left), ts.factory.createStringLiteral("undefined")), right); + } + /** + * Serializes an entity name which may not exist at runtime, but whose access shouldn't throw + * @param node The entity name to serialize. + */ + function serializeEntityNameAsExpressionFallback(node) { + if (node.kind === 79 /* SyntaxKind.Identifier */) { + // A -> typeof A !== "undefined" && A + var copied = serializeEntityNameAsExpression(node); + return createCheckedValue(copied, copied); + } + if (node.left.kind === 79 /* SyntaxKind.Identifier */) { + // A.B -> typeof A !== "undefined" && A.B + return createCheckedValue(serializeEntityNameAsExpression(node.left), serializeEntityNameAsExpression(node)); + } + // A.B.C -> typeof A !== "undefined" && (_a = A.B) !== void 0 && _a.C + var left = serializeEntityNameAsExpressionFallback(node.left); + var temp = ts.factory.createTempVariable(hoistVariableDeclaration); + return ts.factory.createLogicalAnd(ts.factory.createLogicalAnd(left.left, ts.factory.createStrictInequality(ts.factory.createAssignment(temp, left.right), ts.factory.createVoidZero())), ts.factory.createPropertyAccessExpression(temp, node.right)); + } + /** + * Serializes an entity name as an expression for decorator type metadata. + * @param node The entity name to serialize. + */ + function serializeEntityNameAsExpression(node) { + switch (node.kind) { + case 79 /* SyntaxKind.Identifier */: + // Create a clone of the name with a new parent, and treat it as if it were + // a source tree node for the purposes of the checker. + var name = ts.setParent(ts.setTextRange(ts.parseNodeFactory.cloneNode(node), node), node.parent); + name.original = undefined; + ts.setParent(name, ts.getParseTreeNode(currentLexicalScope)); // ensure the parent is set to a parse tree node. + return name; + case 163 /* SyntaxKind.QualifiedName */: + return serializeQualifiedNameAsExpression(node); + } + } + /** + * Serializes an qualified name as an expression for decorator type metadata. + * @param node The qualified name to serialize. + */ + function serializeQualifiedNameAsExpression(node) { + return ts.factory.createPropertyAccessExpression(serializeEntityNameAsExpression(node.left), node.right); + } + function getGlobalConstructorWithFallback(name) { + return ts.factory.createConditionalExpression(ts.factory.createTypeCheck(ts.factory.createIdentifier(name), "function"), + /*questionToken*/ undefined, ts.factory.createIdentifier(name), + /*colonToken*/ undefined, ts.factory.createIdentifier("Object")); + } + function getGlobalConstructor(name, minLanguageVersion) { + return languageVersion < minLanguageVersion ? + getGlobalConstructorWithFallback(name) : + ts.factory.createIdentifier(name); + } + } + ts.createRuntimeTypeSerializer = createRuntimeTypeSerializer; +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + function transformLegacyDecorators(context) { + var factory = context.factory, emitHelpers = context.getEmitHelperFactory, hoistVariableDeclaration = context.hoistVariableDeclaration; + var resolver = context.getEmitResolver(); + var compilerOptions = context.getCompilerOptions(); + var languageVersion = ts.getEmitScriptTarget(compilerOptions); + // Save the previous transformation hooks. + var previousOnSubstituteNode = context.onSubstituteNode; + // Set new transformation hooks. + context.onSubstituteNode = onSubstituteNode; + /** + * A map that keeps track of aliases created for classes with decorators to avoid issues + * with the double-binding behavior of classes. + */ + var classAliases; + return ts.chainBundle(context, transformSourceFile); + function transformSourceFile(node) { + var visited = ts.visitEachChild(node, visitor, context); + ts.addEmitHelpers(visited, context.readEmitHelpers()); + return visited; + } + function modifierVisitor(node) { + return ts.isDecorator(node) ? undefined : node; + } + function visitor(node) { + if (!(node.transformFlags & 33554432 /* TransformFlags.ContainsDecorators */)) { + return node; + } + switch (node.kind) { + case 167 /* SyntaxKind.Decorator */: + // Decorators are elided. They will be emitted as part of `visitClassDeclaration`. + return undefined; + case 260 /* SyntaxKind.ClassDeclaration */: + return visitClassDeclaration(node); + case 228 /* SyntaxKind.ClassExpression */: + return visitClassExpression(node); + case 173 /* SyntaxKind.Constructor */: + return visitConstructorDeclaration(node); + case 171 /* SyntaxKind.MethodDeclaration */: + return visitMethodDeclaration(node); + case 175 /* SyntaxKind.SetAccessor */: + return visitSetAccessorDeclaration(node); + case 174 /* SyntaxKind.GetAccessor */: + return visitGetAccessorDeclaration(node); + case 169 /* SyntaxKind.PropertyDeclaration */: + return visitPropertyDeclaration(node); + case 166 /* SyntaxKind.Parameter */: + return visitParameterDeclaration(node); + default: + return ts.visitEachChild(node, visitor, context); + } + } + function visitClassDeclaration(node) { + if (!(ts.classOrConstructorParameterIsDecorated(node) || ts.childIsDecorated(node))) + return ts.visitEachChild(node, visitor, context); + var statements = ts.hasDecorators(node) ? + transformClassDeclarationWithClassDecorators(node, node.name) : + transformClassDeclarationWithoutClassDecorators(node, node.name); + if (statements.length > 1) { + // Add a DeclarationMarker as a marker for the end of the declaration + statements.push(factory.createEndOfDeclarationMarker(node)); + ts.setEmitFlags(statements[0], ts.getEmitFlags(statements[0]) | 4194304 /* EmitFlags.HasEndOfDeclarationMarker */); + } + return ts.singleOrMany(statements); + } + function decoratorContainsPrivateIdentifierInExpression(decorator) { + return !!(decorator.transformFlags & 536870912 /* TransformFlags.ContainsPrivateIdentifierInExpression */); + } + function parameterDecoratorsContainPrivateIdentifierInExpression(parameterDecorators) { + return ts.some(parameterDecorators, decoratorContainsPrivateIdentifierInExpression); + } + function hasClassElementWithDecoratorContainingPrivateIdentifierInExpression(node) { + for (var _i = 0, _a = node.members; _i < _a.length; _i++) { + var member = _a[_i]; + if (!ts.canHaveDecorators(member)) + continue; + var allDecorators = ts.getAllDecoratorsOfClassElement(member, node); + if (ts.some(allDecorators === null || allDecorators === void 0 ? void 0 : allDecorators.decorators, decoratorContainsPrivateIdentifierInExpression)) + return true; + if (ts.some(allDecorators === null || allDecorators === void 0 ? void 0 : allDecorators.parameters, parameterDecoratorsContainPrivateIdentifierInExpression)) + return true; + } + return false; + } + function transformDecoratorsOfClassElements(node, members) { + var decorationStatements = []; + addClassElementDecorationStatements(decorationStatements, node, /*isStatic*/ false); + addClassElementDecorationStatements(decorationStatements, node, /*isStatic*/ true); + if (hasClassElementWithDecoratorContainingPrivateIdentifierInExpression(node)) { + members = ts.setTextRange(factory.createNodeArray(__spreadArray(__spreadArray([], members, true), [ + factory.createClassStaticBlockDeclaration(factory.createBlock(decorationStatements, /*multiLine*/ true)) + ], false)), members); + decorationStatements = undefined; + } + return { decorationStatements: decorationStatements, members: members }; + } + /** + * Transforms a non-decorated class declaration. + * + * @param node A ClassDeclaration node. + * @param name The name of the class. + */ + function transformClassDeclarationWithoutClassDecorators(node, name) { + // ${modifiers} class ${name} ${heritageClauses} { + // ${members} + // } + var _a; + var modifiers = ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier); + var heritageClauses = ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause); + var members = ts.visitNodes(node.members, visitor, ts.isClassElement); + var decorationStatements = []; + (_a = transformDecoratorsOfClassElements(node, members), members = _a.members, decorationStatements = _a.decorationStatements); + var updated = factory.updateClassDeclaration(node, modifiers, name, + /*typeParameters*/ undefined, heritageClauses, members); + return ts.addRange([updated], decorationStatements); + } + /** + * Transforms a decorated class declaration and appends the resulting statements. If + * the class requires an alias to avoid issues with double-binding, the alias is returned. + */ + function transformClassDeclarationWithClassDecorators(node, name) { + // When we emit an ES6 class that has a class decorator, we must tailor the + // emit to certain specific cases. + // + // In the simplest case, we emit the class declaration as a let declaration, and + // evaluate decorators after the close of the class body: + // + // [Example 1] + // --------------------------------------------------------------------- + // TypeScript | Javascript + // --------------------------------------------------------------------- + // @dec | let C = class C { + // class C { | } + // } | C = __decorate([dec], C); + // --------------------------------------------------------------------- + // @dec | let C = class C { + // export class C { | } + // } | C = __decorate([dec], C); + // | export { C }; + // --------------------------------------------------------------------- + // + // If a class declaration contains a reference to itself *inside* of the class body, + // this introduces two bindings to the class: One outside of the class body, and one + // inside of the class body. If we apply decorators as in [Example 1] above, there + // is the possibility that the decorator `dec` will return a new value for the + // constructor, which would result in the binding inside of the class no longer + // pointing to the same reference as the binding outside of the class. + // + // As a result, we must instead rewrite all references to the class *inside* of the + // class body to instead point to a local temporary alias for the class: + // + // [Example 2] + // --------------------------------------------------------------------- + // TypeScript | Javascript + // --------------------------------------------------------------------- + // @dec | let C = C_1 = class C { + // class C { | static x() { return C_1.y; } + // static x() { return C.y; } | } + // static y = 1; | C.y = 1; + // } | C = C_1 = __decorate([dec], C); + // | var C_1; + // --------------------------------------------------------------------- + // @dec | let C = class C { + // export class C { | static x() { return C_1.y; } + // static x() { return C.y; } | } + // static y = 1; | C.y = 1; + // } | C = C_1 = __decorate([dec], C); + // | export { C }; + // | var C_1; + // --------------------------------------------------------------------- + // + // If a class declaration is the default export of a module, we instead emit + // the export after the decorated declaration: + // + // [Example 3] + // --------------------------------------------------------------------- + // TypeScript | Javascript + // --------------------------------------------------------------------- + // @dec | let default_1 = class { + // export default class { | } + // } | default_1 = __decorate([dec], default_1); + // | export default default_1; + // --------------------------------------------------------------------- + // @dec | let C = class C { + // export default class C { | } + // } | C = __decorate([dec], C); + // | export default C; + // --------------------------------------------------------------------- + // + // If the class declaration is the default export and a reference to itself + // inside of the class body, we must emit both an alias for the class *and* + // move the export after the declaration: + // + // [Example 4] + // --------------------------------------------------------------------- + // TypeScript | Javascript + // --------------------------------------------------------------------- + // @dec | let C = class C { + // export default class C { | static x() { return C_1.y; } + // static x() { return C.y; } | } + // static y = 1; | C.y = 1; + // } | C = C_1 = __decorate([dec], C); + // | export default C; + // | var C_1; + // --------------------------------------------------------------------- + // + var _a; + var location = ts.moveRangePastModifiers(node); + var classAlias = getClassAliasIfNeeded(node); + // When we transform to ES5/3 this will be moved inside an IIFE and should reference the name + // without any block-scoped variable collision handling + var declName = languageVersion <= 2 /* ScriptTarget.ES2015 */ ? + factory.getInternalName(node, /*allowComments*/ false, /*allowSourceMaps*/ true) : + factory.getLocalName(node, /*allowComments*/ false, /*allowSourceMaps*/ true); + // ... = class ${name} ${heritageClauses} { + // ${members} + // } + var heritageClauses = ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause); + var members = ts.visitNodes(node.members, visitor, ts.isClassElement); + var decorationStatements = []; + (_a = transformDecoratorsOfClassElements(node, members), members = _a.members, decorationStatements = _a.decorationStatements); + var classExpression = factory.createClassExpression( + /*modifiers*/ undefined, name, + /*typeParameters*/ undefined, heritageClauses, members); + ts.setOriginalNode(classExpression, node); + ts.setTextRange(classExpression, location); + // let ${name} = ${classExpression} where name is either declaredName if the class doesn't contain self-reference + // or decoratedClassAlias if the class contain self-reference. + var statement = factory.createVariableStatement( + /*modifiers*/ undefined, factory.createVariableDeclarationList([ + factory.createVariableDeclaration(declName, + /*exclamationToken*/ undefined, + /*type*/ undefined, classAlias ? factory.createAssignment(classAlias, classExpression) : classExpression) + ], 1 /* NodeFlags.Let */)); + ts.setOriginalNode(statement, node); + ts.setTextRange(statement, location); + ts.setCommentRange(statement, node); + var statements = [statement]; + ts.addRange(statements, decorationStatements); + addConstructorDecorationStatement(statements, node); + return statements; + } + function visitClassExpression(node) { + // Legacy decorators were not supported on class expressions + return factory.updateClassExpression(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), node.name, + /*typeParameters*/ undefined, ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause), ts.visitNodes(node.members, visitor, ts.isClassElement)); + } + function visitConstructorDeclaration(node) { + return factory.updateConstructorDeclaration(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), ts.visitNodes(node.parameters, visitor, ts.isParameterDeclaration), ts.visitNode(node.body, visitor, ts.isBlock)); + } + function finishClassElement(updated, original) { + if (updated !== original) { + // While we emit the source map for the node after skipping decorators and modifiers, + // we need to emit the comments for the original range. + ts.setCommentRange(updated, original); + ts.setSourceMapRange(updated, ts.moveRangePastModifiers(original)); + } + return updated; + } + function visitMethodDeclaration(node) { + return finishClassElement(factory.updateMethodDeclaration(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), node.asteriskToken, ts.visitNode(node.name, visitor, ts.isPropertyName), + /*questionToken*/ undefined, + /*typeParameters*/ undefined, ts.visitNodes(node.parameters, visitor, ts.isParameterDeclaration), + /*type*/ undefined, ts.visitNode(node.body, visitor, ts.isBlock)), node); + } + function visitGetAccessorDeclaration(node) { + return finishClassElement(factory.updateGetAccessorDeclaration(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitNodes(node.parameters, visitor, ts.isParameterDeclaration), + /*type*/ undefined, ts.visitNode(node.body, visitor, ts.isBlock)), node); + } + function visitSetAccessorDeclaration(node) { + return finishClassElement(factory.updateSetAccessorDeclaration(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitNodes(node.parameters, visitor, ts.isParameterDeclaration), ts.visitNode(node.body, visitor, ts.isBlock)), node); + } + function visitPropertyDeclaration(node) { + if (node.flags & 16777216 /* NodeFlags.Ambient */ || ts.hasSyntacticModifier(node, 2 /* ModifierFlags.Ambient */)) { + return undefined; + } + return finishClassElement(factory.updatePropertyDeclaration(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), ts.visitNode(node.name, visitor, ts.isPropertyName), + /*questionOrExclamationToken*/ undefined, + /*type*/ undefined, ts.visitNode(node.initializer, visitor, ts.isExpression)), node); + } + function visitParameterDeclaration(node) { + var updated = factory.updateParameterDeclaration(node, ts.elideNodes(factory, node.modifiers), node.dotDotDotToken, ts.visitNode(node.name, visitor, ts.isBindingName), + /*questionToken*/ undefined, + /*type*/ undefined, ts.visitNode(node.initializer, visitor, ts.isExpression)); + if (updated !== node) { + // While we emit the source map for the node after skipping decorators and modifiers, + // we need to emit the comments for the original range. + ts.setCommentRange(updated, node); + ts.setTextRange(updated, ts.moveRangePastModifiers(node)); + ts.setSourceMapRange(updated, ts.moveRangePastModifiers(node)); + ts.setEmitFlags(updated.name, 32 /* EmitFlags.NoTrailingSourceMap */); + } + return updated; + } + /** + * Transforms all of the decorators for a declaration into an array of expressions. + * + * @param allDecorators An object containing all of the decorators for the declaration. + */ + function transformAllDecoratorsOfDeclaration(allDecorators) { + if (!allDecorators) { + return undefined; + } + var decoratorExpressions = []; + ts.addRange(decoratorExpressions, ts.map(allDecorators.decorators, transformDecorator)); + ts.addRange(decoratorExpressions, ts.flatMap(allDecorators.parameters, transformDecoratorsOfParameter)); + return decoratorExpressions; + } + /** + * Generates statements used to apply decorators to either the static or instance members + * of a class. + * + * @param node The class node. + * @param isStatic A value indicating whether to generate statements for static or + * instance members. + */ + function addClassElementDecorationStatements(statements, node, isStatic) { + ts.addRange(statements, ts.map(generateClassElementDecorationExpressions(node, isStatic), function (expr) { return factory.createExpressionStatement(expr); })); + } + /** + * Determines whether a class member is either a static or an instance member of a class + * that is decorated, or has parameters that are decorated. + * + * @param member The class member. + */ + function isDecoratedClassElement(member, isStaticElement, parent) { + return ts.nodeOrChildIsDecorated(member, parent) + && isStaticElement === ts.isStatic(member); + } + /** + * Gets either the static or instance members of a class that are decorated, or have + * parameters that are decorated. + * + * @param node The class containing the member. + * @param isStatic A value indicating whether to retrieve static or instance members of + * the class. + */ + function getDecoratedClassElements(node, isStatic) { + return ts.filter(node.members, function (m) { return isDecoratedClassElement(m, isStatic, node); }); + } + /** + * Generates expressions used to apply decorators to either the static or instance members + * of a class. + * + * @param node The class node. + * @param isStatic A value indicating whether to generate expressions for static or + * instance members. + */ + function generateClassElementDecorationExpressions(node, isStatic) { + var members = getDecoratedClassElements(node, isStatic); + var expressions; + for (var _i = 0, members_8 = members; _i < members_8.length; _i++) { + var member = members_8[_i]; + expressions = ts.append(expressions, generateClassElementDecorationExpression(node, member)); + } + return expressions; + } + /** + * Generates an expression used to evaluate class element decorators at runtime. + * + * @param node The class node that contains the member. + * @param member The class member. + */ + function generateClassElementDecorationExpression(node, member) { + var allDecorators = ts.getAllDecoratorsOfClassElement(member, node); + var decoratorExpressions = transformAllDecoratorsOfDeclaration(allDecorators); + if (!decoratorExpressions) { + return undefined; + } + // Emit the call to __decorate. Given the following: + // + // class C { + // @dec method(@dec2 x) {} + // @dec get accessor() {} + // @dec prop; + // } + // + // The emit for a method is: + // + // __decorate([ + // dec, + // __param(0, dec2), + // __metadata("design:type", Function), + // __metadata("design:paramtypes", [Object]), + // __metadata("design:returntype", void 0) + // ], C.prototype, "method", null); + // + // The emit for an accessor is: + // + // __decorate([ + // dec + // ], C.prototype, "accessor", null); + // + // The emit for a property is: + // + // __decorate([ + // dec + // ], C.prototype, "prop"); + // + var prefix = getClassMemberPrefix(node, member); + var memberName = getExpressionForPropertyName(member, /*generateNameForComputedPropertyName*/ !ts.hasSyntacticModifier(member, 2 /* ModifierFlags.Ambient */)); + var descriptor = languageVersion > 0 /* ScriptTarget.ES3 */ + ? ts.isPropertyDeclaration(member) && !ts.hasAccessorModifier(member) + // We emit `void 0` here to indicate to `__decorate` that it can invoke `Object.defineProperty` directly, but that it + // should not invoke `Object.getOwnPropertyDescriptor`. + ? factory.createVoidZero() + // We emit `null` here to indicate to `__decorate` that it can invoke `Object.getOwnPropertyDescriptor` directly. + // We have this extra argument here so that we can inject an explicit property descriptor at a later date. + : factory.createNull() + : undefined; + var helper = emitHelpers().createDecorateHelper(decoratorExpressions, prefix, memberName, descriptor); + ts.setEmitFlags(helper, 1536 /* EmitFlags.NoComments */); + ts.setSourceMapRange(helper, ts.moveRangePastModifiers(member)); + return helper; + } + /** + * Generates a __decorate helper call for a class constructor. + * + * @param node The class node. + */ + function addConstructorDecorationStatement(statements, node) { + var expression = generateConstructorDecorationExpression(node); + if (expression) { + statements.push(ts.setOriginalNode(factory.createExpressionStatement(expression), node)); + } + } + /** + * Generates a __decorate helper call for a class constructor. + * + * @param node The class node. + */ + function generateConstructorDecorationExpression(node) { + var allDecorators = ts.getAllDecoratorsOfClass(node); + var decoratorExpressions = transformAllDecoratorsOfDeclaration(allDecorators); + if (!decoratorExpressions) { + return undefined; + } + var classAlias = classAliases && classAliases[ts.getOriginalNodeId(node)]; + // When we transform to ES5/3 this will be moved inside an IIFE and should reference the name + // without any block-scoped variable collision handling + var localName = languageVersion <= 2 /* ScriptTarget.ES2015 */ ? + factory.getInternalName(node, /*allowComments*/ false, /*allowSourceMaps*/ true) : + factory.getLocalName(node, /*allowComments*/ false, /*allowSourceMaps*/ true); + var decorate = emitHelpers().createDecorateHelper(decoratorExpressions, localName); + var expression = factory.createAssignment(localName, classAlias ? factory.createAssignment(classAlias, decorate) : decorate); + ts.setEmitFlags(expression, 1536 /* EmitFlags.NoComments */); + ts.setSourceMapRange(expression, ts.moveRangePastModifiers(node)); + return expression; + } + /** + * Transforms a decorator into an expression. + * + * @param decorator The decorator node. + */ + function transformDecorator(decorator) { + return ts.visitNode(decorator.expression, visitor, ts.isExpression); + } + /** + * Transforms the decorators of a parameter. + * + * @param decorators The decorators for the parameter at the provided offset. + * @param parameterOffset The offset of the parameter. + */ + function transformDecoratorsOfParameter(decorators, parameterOffset) { + var expressions; + if (decorators) { + expressions = []; + for (var _i = 0, decorators_1 = decorators; _i < decorators_1.length; _i++) { + var decorator = decorators_1[_i]; + var helper = emitHelpers().createParamHelper(transformDecorator(decorator), parameterOffset); + ts.setTextRange(helper, decorator.expression); + ts.setEmitFlags(helper, 1536 /* EmitFlags.NoComments */); + expressions.push(helper); + } + } + return expressions; + } + /** + * Gets an expression that represents a property name (for decorated properties or enums). + * For a computed property, a name is generated for the node. + * + * @param member The member whose name should be converted into an expression. + */ + function getExpressionForPropertyName(member, generateNameForComputedPropertyName) { + var name = member.name; + if (ts.isPrivateIdentifier(name)) { + return factory.createIdentifier(""); + } + else if (ts.isComputedPropertyName(name)) { + return generateNameForComputedPropertyName && !ts.isSimpleInlineableExpression(name.expression) + ? factory.getGeneratedNameForNode(name) + : name.expression; + } + else if (ts.isIdentifier(name)) { + return factory.createStringLiteral(ts.idText(name)); + } + else { + return factory.cloneNode(name); + } + } + function enableSubstitutionForClassAliases() { + if (!classAliases) { + // We need to enable substitutions for identifiers. This allows us to + // substitute class names inside of a class declaration. + context.enableSubstitution(79 /* SyntaxKind.Identifier */); + // Keep track of class aliases. + classAliases = []; + } + } + /** + * Gets a local alias for a class declaration if it is a decorated class with an internal + * reference to the static side of the class. This is necessary to avoid issues with + * double-binding semantics for the class name. + */ + function getClassAliasIfNeeded(node) { + if (resolver.getNodeCheckFlags(node) & 16777216 /* NodeCheckFlags.ClassWithConstructorReference */) { + enableSubstitutionForClassAliases(); + var classAlias = factory.createUniqueName(node.name && !ts.isGeneratedIdentifier(node.name) ? ts.idText(node.name) : "default"); + classAliases[ts.getOriginalNodeId(node)] = classAlias; + hoistVariableDeclaration(classAlias); + return classAlias; + } + } + function getClassPrototype(node) { + return factory.createPropertyAccessExpression(factory.getDeclarationName(node), "prototype"); + } + function getClassMemberPrefix(node, member) { + return ts.isStatic(member) + ? factory.getDeclarationName(node) + : getClassPrototype(node); + } + /** + * Hooks node substitutions. + * + * @param hint A hint as to the intended usage of the node. + * @param node The node to substitute. + */ + function onSubstituteNode(hint, node) { + node = previousOnSubstituteNode(hint, node); + if (hint === 1 /* EmitHint.Expression */) { + return substituteExpression(node); + } + return node; + } + function substituteExpression(node) { + switch (node.kind) { + case 79 /* SyntaxKind.Identifier */: + return substituteExpressionIdentifier(node); + } + return node; + } + function substituteExpressionIdentifier(node) { + var _a; + return (_a = trySubstituteClassAlias(node)) !== null && _a !== void 0 ? _a : node; + } + function trySubstituteClassAlias(node) { + if (classAliases) { + if (resolver.getNodeCheckFlags(node) & 33554432 /* NodeCheckFlags.ConstructorReferenceInClass */) { + // Due to the emit for class decorators, any reference to the class from inside of the class body + // must instead be rewritten to point to a temporary variable to avoid issues with the double-bind + // behavior of class names in ES6. + // Also, when emitting statics for class expressions, we must substitute a class alias for + // constructor references in static property initializers. + var declaration = resolver.getReferencedValueDeclaration(node); + if (declaration) { + var classAlias = classAliases[declaration.id]; // TODO: GH#18217 + if (classAlias) { + var clone_3 = factory.cloneNode(classAlias); + ts.setSourceMapRange(clone_3, node); + ts.setCommentRange(clone_3, node); + return clone_3; + } + } + } + } + return undefined; + } + } + ts.transformLegacyDecorators = transformLegacyDecorators; +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + var ES2017SubstitutionFlags; + (function (ES2017SubstitutionFlags) { + /** Enables substitutions for async methods with `super` calls. */ + ES2017SubstitutionFlags[ES2017SubstitutionFlags["AsyncMethodsWithSuper"] = 1] = "AsyncMethodsWithSuper"; + })(ES2017SubstitutionFlags || (ES2017SubstitutionFlags = {})); + var ContextFlags; + (function (ContextFlags) { + ContextFlags[ContextFlags["NonTopLevel"] = 1] = "NonTopLevel"; + ContextFlags[ContextFlags["HasLexicalThis"] = 2] = "HasLexicalThis"; + })(ContextFlags || (ContextFlags = {})); + function transformES2017(context) { + var factory = context.factory, emitHelpers = context.getEmitHelperFactory, resumeLexicalEnvironment = context.resumeLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistVariableDeclaration = context.hoistVariableDeclaration; + var resolver = context.getEmitResolver(); + var compilerOptions = context.getCompilerOptions(); + var languageVersion = ts.getEmitScriptTarget(compilerOptions); + /** + * Keeps track of whether expression substitution has been enabled for specific edge cases. + * They are persisted between each SourceFile transformation and should not be reset. + */ + var enabledSubstitutions; + /** + * This keeps track of containers where `super` is valid, for use with + * just-in-time substitution for `super` expressions inside of async methods. + */ + var enclosingSuperContainerFlags = 0; + var enclosingFunctionParameterNames; + /** + * Keeps track of property names accessed on super (`super.x`) within async functions. + */ + var capturedSuperProperties; + /** Whether the async function contains an element access on super (`super[x]`). */ + var hasSuperElementAccess; + /** A set of node IDs for generated super accessors (variable statements). */ + var substitutedSuperAccessors = []; + var contextFlags = 0; + // Save the previous transformation hooks. + var previousOnEmitNode = context.onEmitNode; + var previousOnSubstituteNode = context.onSubstituteNode; + // Set new transformation hooks. + context.onEmitNode = onEmitNode; + context.onSubstituteNode = onSubstituteNode; + return ts.chainBundle(context, transformSourceFile); + function transformSourceFile(node) { + if (node.isDeclarationFile) { + return node; + } + setContextFlag(1 /* ContextFlags.NonTopLevel */, false); + setContextFlag(2 /* ContextFlags.HasLexicalThis */, !ts.isEffectiveStrictModeSourceFile(node, compilerOptions)); + var visited = ts.visitEachChild(node, visitor, context); + ts.addEmitHelpers(visited, context.readEmitHelpers()); + return visited; + } + function setContextFlag(flag, val) { + contextFlags = val ? contextFlags | flag : contextFlags & ~flag; + } + function inContext(flags) { + return (contextFlags & flags) !== 0; + } + function inTopLevelContext() { + return !inContext(1 /* ContextFlags.NonTopLevel */); + } + function inHasLexicalThisContext() { + return inContext(2 /* ContextFlags.HasLexicalThis */); + } + function doWithContext(flags, cb, value) { + var contextFlagsToSet = flags & ~contextFlags; + if (contextFlagsToSet) { + setContextFlag(contextFlagsToSet, /*val*/ true); + var result = cb(value); + setContextFlag(contextFlagsToSet, /*val*/ false); + return result; + } + return cb(value); + } + function visitDefault(node) { + return ts.visitEachChild(node, visitor, context); + } + function visitor(node) { + if ((node.transformFlags & 256 /* TransformFlags.ContainsES2017 */) === 0) { + return node; + } + switch (node.kind) { + case 132 /* SyntaxKind.AsyncKeyword */: + // ES2017 async modifier should be elided for targets < ES2017 + return undefined; + case 220 /* SyntaxKind.AwaitExpression */: + return visitAwaitExpression(node); + case 171 /* SyntaxKind.MethodDeclaration */: + return doWithContext(1 /* ContextFlags.NonTopLevel */ | 2 /* ContextFlags.HasLexicalThis */, visitMethodDeclaration, node); + case 259 /* SyntaxKind.FunctionDeclaration */: + return doWithContext(1 /* ContextFlags.NonTopLevel */ | 2 /* ContextFlags.HasLexicalThis */, visitFunctionDeclaration, node); + case 215 /* SyntaxKind.FunctionExpression */: + return doWithContext(1 /* ContextFlags.NonTopLevel */ | 2 /* ContextFlags.HasLexicalThis */, visitFunctionExpression, node); + case 216 /* SyntaxKind.ArrowFunction */: + return doWithContext(1 /* ContextFlags.NonTopLevel */, visitArrowFunction, node); + case 208 /* SyntaxKind.PropertyAccessExpression */: + if (capturedSuperProperties && ts.isPropertyAccessExpression(node) && node.expression.kind === 106 /* SyntaxKind.SuperKeyword */) { + capturedSuperProperties.add(node.name.escapedText); + } + return ts.visitEachChild(node, visitor, context); + case 209 /* SyntaxKind.ElementAccessExpression */: + if (capturedSuperProperties && node.expression.kind === 106 /* SyntaxKind.SuperKeyword */) { + hasSuperElementAccess = true; + } + return ts.visitEachChild(node, visitor, context); + case 174 /* SyntaxKind.GetAccessor */: + return doWithContext(1 /* ContextFlags.NonTopLevel */ | 2 /* ContextFlags.HasLexicalThis */, visitGetAccessorDeclaration, node); + case 175 /* SyntaxKind.SetAccessor */: + return doWithContext(1 /* ContextFlags.NonTopLevel */ | 2 /* ContextFlags.HasLexicalThis */, visitSetAccessorDeclaration, node); + case 173 /* SyntaxKind.Constructor */: + return doWithContext(1 /* ContextFlags.NonTopLevel */ | 2 /* ContextFlags.HasLexicalThis */, visitConstructorDeclaration, node); + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + return doWithContext(1 /* ContextFlags.NonTopLevel */ | 2 /* ContextFlags.HasLexicalThis */, visitDefault, node); + default: + return ts.visitEachChild(node, visitor, context); + } + } + function asyncBodyVisitor(node) { + if (ts.isNodeWithPossibleHoistedDeclaration(node)) { + switch (node.kind) { + case 240 /* SyntaxKind.VariableStatement */: + return visitVariableStatementInAsyncBody(node); + case 245 /* SyntaxKind.ForStatement */: + return visitForStatementInAsyncBody(node); + case 246 /* SyntaxKind.ForInStatement */: + return visitForInStatementInAsyncBody(node); + case 247 /* SyntaxKind.ForOfStatement */: + return visitForOfStatementInAsyncBody(node); + case 295 /* SyntaxKind.CatchClause */: + return visitCatchClauseInAsyncBody(node); + case 238 /* SyntaxKind.Block */: + case 252 /* SyntaxKind.SwitchStatement */: + case 266 /* SyntaxKind.CaseBlock */: + case 292 /* SyntaxKind.CaseClause */: + case 293 /* SyntaxKind.DefaultClause */: + case 255 /* SyntaxKind.TryStatement */: + case 243 /* SyntaxKind.DoStatement */: + case 244 /* SyntaxKind.WhileStatement */: + case 242 /* SyntaxKind.IfStatement */: + case 251 /* SyntaxKind.WithStatement */: + case 253 /* SyntaxKind.LabeledStatement */: + return ts.visitEachChild(node, asyncBodyVisitor, context); + default: + return ts.Debug.assertNever(node, "Unhandled node."); + } + } + return visitor(node); + } + function visitCatchClauseInAsyncBody(node) { + var catchClauseNames = new ts.Set(); + recordDeclarationName(node.variableDeclaration, catchClauseNames); // TODO: GH#18217 + // names declared in a catch variable are block scoped + var catchClauseUnshadowedNames; + catchClauseNames.forEach(function (_, escapedName) { + if (enclosingFunctionParameterNames.has(escapedName)) { + if (!catchClauseUnshadowedNames) { + catchClauseUnshadowedNames = new ts.Set(enclosingFunctionParameterNames); + } + catchClauseUnshadowedNames.delete(escapedName); + } + }); + if (catchClauseUnshadowedNames) { + var savedEnclosingFunctionParameterNames = enclosingFunctionParameterNames; + enclosingFunctionParameterNames = catchClauseUnshadowedNames; + var result = ts.visitEachChild(node, asyncBodyVisitor, context); + enclosingFunctionParameterNames = savedEnclosingFunctionParameterNames; + return result; + } + else { + return ts.visitEachChild(node, asyncBodyVisitor, context); + } + } + function visitVariableStatementInAsyncBody(node) { + if (isVariableDeclarationListWithCollidingName(node.declarationList)) { + var expression = visitVariableDeclarationListWithCollidingNames(node.declarationList, /*hasReceiver*/ false); + return expression ? factory.createExpressionStatement(expression) : undefined; + } + return ts.visitEachChild(node, visitor, context); + } + function visitForInStatementInAsyncBody(node) { + return factory.updateForInStatement(node, isVariableDeclarationListWithCollidingName(node.initializer) + ? visitVariableDeclarationListWithCollidingNames(node.initializer, /*hasReceiver*/ true) + : ts.visitNode(node.initializer, visitor, ts.isForInitializer), ts.visitNode(node.expression, visitor, ts.isExpression), ts.visitIterationBody(node.statement, asyncBodyVisitor, context)); + } + function visitForOfStatementInAsyncBody(node) { + return factory.updateForOfStatement(node, ts.visitNode(node.awaitModifier, visitor, ts.isToken), isVariableDeclarationListWithCollidingName(node.initializer) + ? visitVariableDeclarationListWithCollidingNames(node.initializer, /*hasReceiver*/ true) + : ts.visitNode(node.initializer, visitor, ts.isForInitializer), ts.visitNode(node.expression, visitor, ts.isExpression), ts.visitIterationBody(node.statement, asyncBodyVisitor, context)); + } + function visitForStatementInAsyncBody(node) { + var initializer = node.initializer; // TODO: GH#18217 + return factory.updateForStatement(node, isVariableDeclarationListWithCollidingName(initializer) + ? visitVariableDeclarationListWithCollidingNames(initializer, /*hasReceiver*/ false) + : ts.visitNode(node.initializer, visitor, ts.isForInitializer), ts.visitNode(node.condition, visitor, ts.isExpression), ts.visitNode(node.incrementor, visitor, ts.isExpression), ts.visitIterationBody(node.statement, asyncBodyVisitor, context)); + } + /** + * Visits an AwaitExpression node. + * + * This function will be called any time a ES2017 await expression is encountered. + * + * @param node The node to visit. + */ + function visitAwaitExpression(node) { + // do not downlevel a top-level await as it is module syntax... + if (inTopLevelContext()) { + return ts.visitEachChild(node, visitor, context); + } + return ts.setOriginalNode(ts.setTextRange(factory.createYieldExpression( + /*asteriskToken*/ undefined, ts.visitNode(node.expression, visitor, ts.isExpression)), node), node); + } + function visitConstructorDeclaration(node) { + return factory.updateConstructorDeclaration(node, ts.visitNodes(node.modifiers, visitor, ts.isModifierLike), ts.visitParameterList(node.parameters, visitor, context), transformMethodBody(node)); + } + /** + * Visits a MethodDeclaration node. + * + * This function will be called when one of the following conditions are met: + * - The node is marked as async + * + * @param node The node to visit. + */ + function visitMethodDeclaration(node) { + return factory.updateMethodDeclaration(node, ts.visitNodes(node.modifiers, visitor, ts.isModifierLike), node.asteriskToken, node.name, + /*questionToken*/ undefined, + /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, visitor, context), + /*type*/ undefined, ts.getFunctionFlags(node) & 2 /* FunctionFlags.Async */ + ? transformAsyncFunctionBody(node) + : transformMethodBody(node)); + } + function visitGetAccessorDeclaration(node) { + return factory.updateGetAccessorDeclaration(node, ts.visitNodes(node.modifiers, visitor, ts.isModifierLike), node.name, ts.visitParameterList(node.parameters, visitor, context), + /*type*/ undefined, transformMethodBody(node)); + } + function visitSetAccessorDeclaration(node) { + return factory.updateSetAccessorDeclaration(node, ts.visitNodes(node.modifiers, visitor, ts.isModifierLike), node.name, ts.visitParameterList(node.parameters, visitor, context), transformMethodBody(node)); + } + /** + * Visits a FunctionDeclaration node. + * + * This function will be called when one of the following conditions are met: + * - The node is marked async + * + * @param node The node to visit. + */ + function visitFunctionDeclaration(node) { + return factory.updateFunctionDeclaration(node, ts.visitNodes(node.modifiers, visitor, ts.isModifierLike), node.asteriskToken, node.name, + /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, visitor, context), + /*type*/ undefined, ts.getFunctionFlags(node) & 2 /* FunctionFlags.Async */ + ? transformAsyncFunctionBody(node) + : ts.visitFunctionBody(node.body, visitor, context)); + } + /** + * Visits a FunctionExpression node. + * + * This function will be called when one of the following conditions are met: + * - The node is marked async + * + * @param node The node to visit. + */ + function visitFunctionExpression(node) { + return factory.updateFunctionExpression(node, ts.visitNodes(node.modifiers, visitor, ts.isModifierLike), node.asteriskToken, node.name, + /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, visitor, context), + /*type*/ undefined, ts.getFunctionFlags(node) & 2 /* FunctionFlags.Async */ + ? transformAsyncFunctionBody(node) + : ts.visitFunctionBody(node.body, visitor, context)); + } + /** + * Visits an ArrowFunction. + * + * This function will be called when one of the following conditions are met: + * - The node is marked async + * + * @param node The node to visit. + */ + function visitArrowFunction(node) { + return factory.updateArrowFunction(node, ts.visitNodes(node.modifiers, visitor, ts.isModifierLike), + /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, visitor, context), + /*type*/ undefined, node.equalsGreaterThanToken, ts.getFunctionFlags(node) & 2 /* FunctionFlags.Async */ + ? transformAsyncFunctionBody(node) + : ts.visitFunctionBody(node.body, visitor, context)); + } + function recordDeclarationName(_a, names) { + var name = _a.name; + if (ts.isIdentifier(name)) { + names.add(name.escapedText); + } + else { + for (var _i = 0, _b = name.elements; _i < _b.length; _i++) { + var element = _b[_i]; + if (!ts.isOmittedExpression(element)) { + recordDeclarationName(element, names); + } + } + } + } + function isVariableDeclarationListWithCollidingName(node) { + return !!node + && ts.isVariableDeclarationList(node) + && !(node.flags & 3 /* NodeFlags.BlockScoped */) + && node.declarations.some(collidesWithParameterName); + } + function visitVariableDeclarationListWithCollidingNames(node, hasReceiver) { + hoistVariableDeclarationList(node); + var variables = ts.getInitializedVariables(node); + if (variables.length === 0) { + if (hasReceiver) { + return ts.visitNode(factory.converters.convertToAssignmentElementTarget(node.declarations[0].name), visitor, ts.isExpression); + } + return undefined; + } + return factory.inlineExpressions(ts.map(variables, transformInitializedVariable)); + } + function hoistVariableDeclarationList(node) { + ts.forEach(node.declarations, hoistVariable); + } + function hoistVariable(_a) { + var name = _a.name; + if (ts.isIdentifier(name)) { + hoistVariableDeclaration(name); + } + else { + for (var _i = 0, _b = name.elements; _i < _b.length; _i++) { + var element = _b[_i]; + if (!ts.isOmittedExpression(element)) { + hoistVariable(element); + } + } + } + } + function transformInitializedVariable(node) { + var converted = ts.setSourceMapRange(factory.createAssignment(factory.converters.convertToAssignmentElementTarget(node.name), node.initializer), node); + return ts.visitNode(converted, visitor, ts.isExpression); + } + function collidesWithParameterName(_a) { + var name = _a.name; + if (ts.isIdentifier(name)) { + return enclosingFunctionParameterNames.has(name.escapedText); + } + else { + for (var _i = 0, _b = name.elements; _i < _b.length; _i++) { + var element = _b[_i]; + if (!ts.isOmittedExpression(element) && collidesWithParameterName(element)) { + return true; + } + } + } + return false; + } + function transformMethodBody(node) { + ts.Debug.assertIsDefined(node.body); + var savedCapturedSuperProperties = capturedSuperProperties; + var savedHasSuperElementAccess = hasSuperElementAccess; + capturedSuperProperties = new ts.Set(); + hasSuperElementAccess = false; + var updated = ts.visitFunctionBody(node.body, visitor, context); + // Minor optimization, emit `_super` helper to capture `super` access in an arrow. + // This step isn't needed if we eventually transform this to ES5. + var originalMethod = ts.getOriginalNode(node, ts.isFunctionLikeDeclaration); + var emitSuperHelpers = languageVersion >= 2 /* ScriptTarget.ES2015 */ && + resolver.getNodeCheckFlags(node) & (4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */ | 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */) && + (ts.getFunctionFlags(originalMethod) & 3 /* FunctionFlags.AsyncGenerator */) !== 3 /* FunctionFlags.AsyncGenerator */; + if (emitSuperHelpers) { + enableSubstitutionForAsyncMethodsWithSuper(); + if (capturedSuperProperties.size) { + var variableStatement = createSuperAccessVariableStatement(factory, resolver, node, capturedSuperProperties); + substitutedSuperAccessors[ts.getNodeId(variableStatement)] = true; + var statements = updated.statements.slice(); + ts.insertStatementsAfterStandardPrologue(statements, [variableStatement]); + updated = factory.updateBlock(updated, statements); + } + if (hasSuperElementAccess) { + // Emit helpers for super element access expressions (`super[x]`). + if (resolver.getNodeCheckFlags(node) & 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */) { + ts.addEmitHelper(updated, ts.advancedAsyncSuperHelper); + } + else if (resolver.getNodeCheckFlags(node) & 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */) { + ts.addEmitHelper(updated, ts.asyncSuperHelper); + } + } + } + capturedSuperProperties = savedCapturedSuperProperties; + hasSuperElementAccess = savedHasSuperElementAccess; + return updated; + } + function transformAsyncFunctionBody(node) { + resumeLexicalEnvironment(); + var original = ts.getOriginalNode(node, ts.isFunctionLike); + var nodeType = original.type; + var promiseConstructor = languageVersion < 2 /* ScriptTarget.ES2015 */ ? getPromiseConstructor(nodeType) : undefined; + var isArrowFunction = node.kind === 216 /* SyntaxKind.ArrowFunction */; + var hasLexicalArguments = (resolver.getNodeCheckFlags(node) & 8192 /* NodeCheckFlags.CaptureArguments */) !== 0; + // An async function is emit as an outer function that calls an inner + // generator function. To preserve lexical bindings, we pass the current + // `this` and `arguments` objects to `__awaiter`. The generator function + // passed to `__awaiter` is executed inside of the callback to the + // promise constructor. + var savedEnclosingFunctionParameterNames = enclosingFunctionParameterNames; + enclosingFunctionParameterNames = new ts.Set(); + for (var _i = 0, _a = node.parameters; _i < _a.length; _i++) { + var parameter = _a[_i]; + recordDeclarationName(parameter, enclosingFunctionParameterNames); + } + var savedCapturedSuperProperties = capturedSuperProperties; + var savedHasSuperElementAccess = hasSuperElementAccess; + if (!isArrowFunction) { + capturedSuperProperties = new ts.Set(); + hasSuperElementAccess = false; + } + var result; + if (!isArrowFunction) { + var statements = []; + var statementOffset = factory.copyPrologue(node.body.statements, statements, /*ensureUseStrict*/ false, visitor); + statements.push(factory.createReturnStatement(emitHelpers().createAwaiterHelper(inHasLexicalThisContext(), hasLexicalArguments, promiseConstructor, transformAsyncFunctionBodyWorker(node.body, statementOffset)))); + ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment()); + // Minor optimization, emit `_super` helper to capture `super` access in an arrow. + // This step isn't needed if we eventually transform this to ES5. + var emitSuperHelpers = languageVersion >= 2 /* ScriptTarget.ES2015 */ && resolver.getNodeCheckFlags(node) & (4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */ | 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */); + if (emitSuperHelpers) { + enableSubstitutionForAsyncMethodsWithSuper(); + if (capturedSuperProperties.size) { + var variableStatement = createSuperAccessVariableStatement(factory, resolver, node, capturedSuperProperties); + substitutedSuperAccessors[ts.getNodeId(variableStatement)] = true; + ts.insertStatementsAfterStandardPrologue(statements, [variableStatement]); + } + } + var block = factory.createBlock(statements, /*multiLine*/ true); + ts.setTextRange(block, node.body); + if (emitSuperHelpers && hasSuperElementAccess) { + // Emit helpers for super element access expressions (`super[x]`). + if (resolver.getNodeCheckFlags(node) & 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */) { + ts.addEmitHelper(block, ts.advancedAsyncSuperHelper); + } + else if (resolver.getNodeCheckFlags(node) & 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */) { + ts.addEmitHelper(block, ts.asyncSuperHelper); + } + } + result = block; + } + else { + var expression = emitHelpers().createAwaiterHelper(inHasLexicalThisContext(), hasLexicalArguments, promiseConstructor, transformAsyncFunctionBodyWorker(node.body)); + var declarations = endLexicalEnvironment(); + if (ts.some(declarations)) { + var block = factory.converters.convertToFunctionBlock(expression); + result = factory.updateBlock(block, ts.setTextRange(factory.createNodeArray(ts.concatenate(declarations, block.statements)), block.statements)); + } + else { + result = expression; + } + } + enclosingFunctionParameterNames = savedEnclosingFunctionParameterNames; + if (!isArrowFunction) { + capturedSuperProperties = savedCapturedSuperProperties; + hasSuperElementAccess = savedHasSuperElementAccess; + } + return result; + } + function transformAsyncFunctionBodyWorker(body, start) { + if (ts.isBlock(body)) { + return factory.updateBlock(body, ts.visitNodes(body.statements, asyncBodyVisitor, ts.isStatement, start)); + } + else { + return factory.converters.convertToFunctionBlock(ts.visitNode(body, asyncBodyVisitor, ts.isConciseBody)); + } + } + function getPromiseConstructor(type) { + var typeName = type && ts.getEntityNameFromTypeNode(type); + if (typeName && ts.isEntityName(typeName)) { + var serializationKind = resolver.getTypeReferenceSerializationKind(typeName); + if (serializationKind === ts.TypeReferenceSerializationKind.TypeWithConstructSignatureAndValue + || serializationKind === ts.TypeReferenceSerializationKind.Unknown) { + return typeName; + } + } + return undefined; + } + function enableSubstitutionForAsyncMethodsWithSuper() { + if ((enabledSubstitutions & 1 /* ES2017SubstitutionFlags.AsyncMethodsWithSuper */) === 0) { + enabledSubstitutions |= 1 /* ES2017SubstitutionFlags.AsyncMethodsWithSuper */; + // We need to enable substitutions for call, property access, and element access + // if we need to rewrite super calls. + context.enableSubstitution(210 /* SyntaxKind.CallExpression */); + context.enableSubstitution(208 /* SyntaxKind.PropertyAccessExpression */); + context.enableSubstitution(209 /* SyntaxKind.ElementAccessExpression */); + // We need to be notified when entering and exiting declarations that bind super. + context.enableEmitNotification(260 /* SyntaxKind.ClassDeclaration */); + context.enableEmitNotification(171 /* SyntaxKind.MethodDeclaration */); + context.enableEmitNotification(174 /* SyntaxKind.GetAccessor */); + context.enableEmitNotification(175 /* SyntaxKind.SetAccessor */); + context.enableEmitNotification(173 /* SyntaxKind.Constructor */); + // We need to be notified when entering the generated accessor arrow functions. + context.enableEmitNotification(240 /* SyntaxKind.VariableStatement */); + } + } + /** + * Hook for node emit. + * + * @param hint A hint as to the intended usage of the node. + * @param node The node to emit. + * @param emit A callback used to emit the node in the printer. + */ + function onEmitNode(hint, node, emitCallback) { + // If we need to support substitutions for `super` in an async method, + // we should track it here. + if (enabledSubstitutions & 1 /* ES2017SubstitutionFlags.AsyncMethodsWithSuper */ && isSuperContainer(node)) { + var superContainerFlags = resolver.getNodeCheckFlags(node) & (2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */ | 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */); + if (superContainerFlags !== enclosingSuperContainerFlags) { + var savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags; + enclosingSuperContainerFlags = superContainerFlags; + previousOnEmitNode(hint, node, emitCallback); + enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags; + return; + } + } + // Disable substitution in the generated super accessor itself. + else if (enabledSubstitutions && substitutedSuperAccessors[ts.getNodeId(node)]) { + var savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags; + enclosingSuperContainerFlags = 0; + previousOnEmitNode(hint, node, emitCallback); + enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags; + return; + } + previousOnEmitNode(hint, node, emitCallback); + } + /** + * Hooks node substitutions. + * + * @param hint A hint as to the intended usage of the node. + * @param node The node to substitute. + */ + function onSubstituteNode(hint, node) { + node = previousOnSubstituteNode(hint, node); + if (hint === 1 /* EmitHint.Expression */ && enclosingSuperContainerFlags) { + return substituteExpression(node); + } + return node; + } + function substituteExpression(node) { + switch (node.kind) { + case 208 /* SyntaxKind.PropertyAccessExpression */: + return substitutePropertyAccessExpression(node); + case 209 /* SyntaxKind.ElementAccessExpression */: + return substituteElementAccessExpression(node); + case 210 /* SyntaxKind.CallExpression */: + return substituteCallExpression(node); + } + return node; + } + function substitutePropertyAccessExpression(node) { + if (node.expression.kind === 106 /* SyntaxKind.SuperKeyword */) { + return ts.setTextRange(factory.createPropertyAccessExpression(factory.createUniqueName("_super", 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */), node.name), node); + } + return node; + } + function substituteElementAccessExpression(node) { + if (node.expression.kind === 106 /* SyntaxKind.SuperKeyword */) { + return createSuperElementAccessInAsyncMethod(node.argumentExpression, node); + } + return node; + } + function substituteCallExpression(node) { + var expression = node.expression; + if (ts.isSuperProperty(expression)) { + var argumentExpression = ts.isPropertyAccessExpression(expression) + ? substitutePropertyAccessExpression(expression) + : substituteElementAccessExpression(expression); + return factory.createCallExpression(factory.createPropertyAccessExpression(argumentExpression, "call"), + /*typeArguments*/ undefined, __spreadArray([ + factory.createThis() + ], node.arguments, true)); + } + return node; + } + function isSuperContainer(node) { + var kind = node.kind; + return kind === 260 /* SyntaxKind.ClassDeclaration */ + || kind === 173 /* SyntaxKind.Constructor */ + || kind === 171 /* SyntaxKind.MethodDeclaration */ + || kind === 174 /* SyntaxKind.GetAccessor */ + || kind === 175 /* SyntaxKind.SetAccessor */; + } + function createSuperElementAccessInAsyncMethod(argumentExpression, location) { + if (enclosingSuperContainerFlags & 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */) { + return ts.setTextRange(factory.createPropertyAccessExpression(factory.createCallExpression(factory.createUniqueName("_superIndex", 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */), + /*typeArguments*/ undefined, [argumentExpression]), "value"), location); + } + else { + return ts.setTextRange(factory.createCallExpression(factory.createUniqueName("_superIndex", 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */), + /*typeArguments*/ undefined, [argumentExpression]), location); + } + } + } + ts.transformES2017 = transformES2017; + /** Creates a variable named `_super` with accessor properties for the given property names. */ + function createSuperAccessVariableStatement(factory, resolver, node, names) { + // Create a variable declaration with a getter/setter (if binding) definition for each name: + // const _super = Object.create(null, { x: { get: () => super.x, set: (v) => super.x = v }, ... }); + var hasBinding = (resolver.getNodeCheckFlags(node) & 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */) !== 0; + var accessors = []; + names.forEach(function (_, key) { + var name = ts.unescapeLeadingUnderscores(key); + var getterAndSetter = []; + getterAndSetter.push(factory.createPropertyAssignment("get", factory.createArrowFunction( + /* modifiers */ undefined, + /* typeParameters */ undefined, + /* parameters */ [], + /* type */ undefined, + /* equalsGreaterThanToken */ undefined, ts.setEmitFlags(factory.createPropertyAccessExpression(ts.setEmitFlags(factory.createSuper(), 4 /* EmitFlags.NoSubstitution */), name), 4 /* EmitFlags.NoSubstitution */)))); + if (hasBinding) { + getterAndSetter.push(factory.createPropertyAssignment("set", factory.createArrowFunction( + /* modifiers */ undefined, + /* typeParameters */ undefined, + /* parameters */ [ + factory.createParameterDeclaration( + /* modifiers */ undefined, + /* dotDotDotToken */ undefined, "v", + /* questionToken */ undefined, + /* type */ undefined, + /* initializer */ undefined) + ], + /* type */ undefined, + /* equalsGreaterThanToken */ undefined, factory.createAssignment(ts.setEmitFlags(factory.createPropertyAccessExpression(ts.setEmitFlags(factory.createSuper(), 4 /* EmitFlags.NoSubstitution */), name), 4 /* EmitFlags.NoSubstitution */), factory.createIdentifier("v"))))); + } + accessors.push(factory.createPropertyAssignment(name, factory.createObjectLiteralExpression(getterAndSetter))); + }); + return factory.createVariableStatement( + /* modifiers */ undefined, factory.createVariableDeclarationList([ + factory.createVariableDeclaration(factory.createUniqueName("_super", 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */), + /*exclamationToken*/ undefined, + /* type */ undefined, factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Object"), "create"), + /* typeArguments */ undefined, [ + factory.createNull(), + factory.createObjectLiteralExpression(accessors, /* multiline */ true) + ])) + ], 2 /* NodeFlags.Const */)); + } + ts.createSuperAccessVariableStatement = createSuperAccessVariableStatement; +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + var ESNextSubstitutionFlags; + (function (ESNextSubstitutionFlags) { + /** Enables substitutions for async methods with `super` calls. */ + ESNextSubstitutionFlags[ESNextSubstitutionFlags["AsyncMethodsWithSuper"] = 1] = "AsyncMethodsWithSuper"; + })(ESNextSubstitutionFlags || (ESNextSubstitutionFlags = {})); + // Facts we track as we traverse the tree + var HierarchyFacts; + (function (HierarchyFacts) { + HierarchyFacts[HierarchyFacts["None"] = 0] = "None"; + // + // Ancestor facts + // + HierarchyFacts[HierarchyFacts["HasLexicalThis"] = 1] = "HasLexicalThis"; + HierarchyFacts[HierarchyFacts["IterationContainer"] = 2] = "IterationContainer"; + // NOTE: do not add more ancestor flags without also updating AncestorFactsMask below. + // + // Ancestor masks + // + HierarchyFacts[HierarchyFacts["AncestorFactsMask"] = 3] = "AncestorFactsMask"; + HierarchyFacts[HierarchyFacts["SourceFileIncludes"] = 1] = "SourceFileIncludes"; + HierarchyFacts[HierarchyFacts["SourceFileExcludes"] = 2] = "SourceFileExcludes"; + HierarchyFacts[HierarchyFacts["StrictModeSourceFileIncludes"] = 0] = "StrictModeSourceFileIncludes"; + HierarchyFacts[HierarchyFacts["ClassOrFunctionIncludes"] = 1] = "ClassOrFunctionIncludes"; + HierarchyFacts[HierarchyFacts["ClassOrFunctionExcludes"] = 2] = "ClassOrFunctionExcludes"; + HierarchyFacts[HierarchyFacts["ArrowFunctionIncludes"] = 0] = "ArrowFunctionIncludes"; + HierarchyFacts[HierarchyFacts["ArrowFunctionExcludes"] = 2] = "ArrowFunctionExcludes"; + HierarchyFacts[HierarchyFacts["IterationStatementIncludes"] = 2] = "IterationStatementIncludes"; + HierarchyFacts[HierarchyFacts["IterationStatementExcludes"] = 0] = "IterationStatementExcludes"; + })(HierarchyFacts || (HierarchyFacts = {})); + function transformES2018(context) { + var factory = context.factory, emitHelpers = context.getEmitHelperFactory, resumeLexicalEnvironment = context.resumeLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistVariableDeclaration = context.hoistVariableDeclaration; + var resolver = context.getEmitResolver(); + var compilerOptions = context.getCompilerOptions(); + var languageVersion = ts.getEmitScriptTarget(compilerOptions); + var previousOnEmitNode = context.onEmitNode; + context.onEmitNode = onEmitNode; + var previousOnSubstituteNode = context.onSubstituteNode; + context.onSubstituteNode = onSubstituteNode; + var exportedVariableStatement = false; + var enabledSubstitutions; + var enclosingFunctionFlags; + var parametersWithPrecedingObjectRestOrSpread; + var enclosingSuperContainerFlags = 0; + var hierarchyFacts = 0; + var currentSourceFile; + var taggedTemplateStringDeclarations; + /** Keeps track of property names accessed on super (`super.x`) within async functions. */ + var capturedSuperProperties; + /** Whether the async function contains an element access on super (`super[x]`). */ + var hasSuperElementAccess; + /** A set of node IDs for generated super accessors. */ + var substitutedSuperAccessors = []; + return ts.chainBundle(context, transformSourceFile); + function affectsSubtree(excludeFacts, includeFacts) { + return hierarchyFacts !== (hierarchyFacts & ~excludeFacts | includeFacts); + } + /** + * Sets the `HierarchyFacts` for this node prior to visiting this node's subtree, returning the facts set prior to modification. + * @param excludeFacts The existing `HierarchyFacts` to reset before visiting the subtree. + * @param includeFacts The new `HierarchyFacts` to set before visiting the subtree. + */ + function enterSubtree(excludeFacts, includeFacts) { + var ancestorFacts = hierarchyFacts; + hierarchyFacts = (hierarchyFacts & ~excludeFacts | includeFacts) & 3 /* HierarchyFacts.AncestorFactsMask */; + return ancestorFacts; + } + /** + * Restores the `HierarchyFacts` for this node's ancestor after visiting this node's + * subtree. + * @param ancestorFacts The `HierarchyFacts` of the ancestor to restore after visiting the subtree. + */ + function exitSubtree(ancestorFacts) { + hierarchyFacts = ancestorFacts; + } + function recordTaggedTemplateString(temp) { + taggedTemplateStringDeclarations = ts.append(taggedTemplateStringDeclarations, factory.createVariableDeclaration(temp)); + } + function transformSourceFile(node) { + if (node.isDeclarationFile) { + return node; + } + currentSourceFile = node; + var visited = visitSourceFile(node); + ts.addEmitHelpers(visited, context.readEmitHelpers()); + currentSourceFile = undefined; + taggedTemplateStringDeclarations = undefined; + return visited; + } + function visitor(node) { + return visitorWorker(node, /*expressionResultIsUnused*/ false); + } + function visitorWithUnusedExpressionResult(node) { + return visitorWorker(node, /*expressionResultIsUnused*/ true); + } + function visitorNoAsyncModifier(node) { + if (node.kind === 132 /* SyntaxKind.AsyncKeyword */) { + return undefined; + } + return node; + } + function doWithHierarchyFacts(cb, value, excludeFacts, includeFacts) { + if (affectsSubtree(excludeFacts, includeFacts)) { + var ancestorFacts = enterSubtree(excludeFacts, includeFacts); + var result = cb(value); + exitSubtree(ancestorFacts); + return result; + } + return cb(value); + } + function visitDefault(node) { + return ts.visitEachChild(node, visitor, context); + } + /** + * @param expressionResultIsUnused Indicates the result of an expression is unused by the parent node (i.e., the left side of a comma or the + * expression of an `ExpressionStatement`). + */ + function visitorWorker(node, expressionResultIsUnused) { + if ((node.transformFlags & 128 /* TransformFlags.ContainsES2018 */) === 0) { + return node; + } + switch (node.kind) { + case 220 /* SyntaxKind.AwaitExpression */: + return visitAwaitExpression(node); + case 226 /* SyntaxKind.YieldExpression */: + return visitYieldExpression(node); + case 250 /* SyntaxKind.ReturnStatement */: + return visitReturnStatement(node); + case 253 /* SyntaxKind.LabeledStatement */: + return visitLabeledStatement(node); + case 207 /* SyntaxKind.ObjectLiteralExpression */: + return visitObjectLiteralExpression(node); + case 223 /* SyntaxKind.BinaryExpression */: + return visitBinaryExpression(node, expressionResultIsUnused); + case 354 /* SyntaxKind.CommaListExpression */: + return visitCommaListExpression(node, expressionResultIsUnused); + case 295 /* SyntaxKind.CatchClause */: + return visitCatchClause(node); + case 240 /* SyntaxKind.VariableStatement */: + return visitVariableStatement(node); + case 257 /* SyntaxKind.VariableDeclaration */: + return visitVariableDeclaration(node); + case 243 /* SyntaxKind.DoStatement */: + case 244 /* SyntaxKind.WhileStatement */: + case 246 /* SyntaxKind.ForInStatement */: + return doWithHierarchyFacts(visitDefault, node, 0 /* HierarchyFacts.IterationStatementExcludes */, 2 /* HierarchyFacts.IterationStatementIncludes */); + case 247 /* SyntaxKind.ForOfStatement */: + return visitForOfStatement(node, /*outermostLabeledStatement*/ undefined); + case 245 /* SyntaxKind.ForStatement */: + return doWithHierarchyFacts(visitForStatement, node, 0 /* HierarchyFacts.IterationStatementExcludes */, 2 /* HierarchyFacts.IterationStatementIncludes */); + case 219 /* SyntaxKind.VoidExpression */: + return visitVoidExpression(node); + case 173 /* SyntaxKind.Constructor */: + return doWithHierarchyFacts(visitConstructorDeclaration, node, 2 /* HierarchyFacts.ClassOrFunctionExcludes */, 1 /* HierarchyFacts.ClassOrFunctionIncludes */); + case 171 /* SyntaxKind.MethodDeclaration */: + return doWithHierarchyFacts(visitMethodDeclaration, node, 2 /* HierarchyFacts.ClassOrFunctionExcludes */, 1 /* HierarchyFacts.ClassOrFunctionIncludes */); + case 174 /* SyntaxKind.GetAccessor */: + return doWithHierarchyFacts(visitGetAccessorDeclaration, node, 2 /* HierarchyFacts.ClassOrFunctionExcludes */, 1 /* HierarchyFacts.ClassOrFunctionIncludes */); + case 175 /* SyntaxKind.SetAccessor */: + return doWithHierarchyFacts(visitSetAccessorDeclaration, node, 2 /* HierarchyFacts.ClassOrFunctionExcludes */, 1 /* HierarchyFacts.ClassOrFunctionIncludes */); + case 259 /* SyntaxKind.FunctionDeclaration */: + return doWithHierarchyFacts(visitFunctionDeclaration, node, 2 /* HierarchyFacts.ClassOrFunctionExcludes */, 1 /* HierarchyFacts.ClassOrFunctionIncludes */); + case 215 /* SyntaxKind.FunctionExpression */: + return doWithHierarchyFacts(visitFunctionExpression, node, 2 /* HierarchyFacts.ClassOrFunctionExcludes */, 1 /* HierarchyFacts.ClassOrFunctionIncludes */); + case 216 /* SyntaxKind.ArrowFunction */: + return doWithHierarchyFacts(visitArrowFunction, node, 2 /* HierarchyFacts.ArrowFunctionExcludes */, 0 /* HierarchyFacts.ArrowFunctionIncludes */); + case 166 /* SyntaxKind.Parameter */: + return visitParameter(node); + case 241 /* SyntaxKind.ExpressionStatement */: + return visitExpressionStatement(node); + case 214 /* SyntaxKind.ParenthesizedExpression */: + return visitParenthesizedExpression(node, expressionResultIsUnused); + case 212 /* SyntaxKind.TaggedTemplateExpression */: + return visitTaggedTemplateExpression(node); + case 208 /* SyntaxKind.PropertyAccessExpression */: + if (capturedSuperProperties && ts.isPropertyAccessExpression(node) && node.expression.kind === 106 /* SyntaxKind.SuperKeyword */) { + capturedSuperProperties.add(node.name.escapedText); + } + return ts.visitEachChild(node, visitor, context); + case 209 /* SyntaxKind.ElementAccessExpression */: + if (capturedSuperProperties && node.expression.kind === 106 /* SyntaxKind.SuperKeyword */) { + hasSuperElementAccess = true; + } + return ts.visitEachChild(node, visitor, context); + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + return doWithHierarchyFacts(visitDefault, node, 2 /* HierarchyFacts.ClassOrFunctionExcludes */, 1 /* HierarchyFacts.ClassOrFunctionIncludes */); + default: + return ts.visitEachChild(node, visitor, context); + } + } + function visitAwaitExpression(node) { + if (enclosingFunctionFlags & 2 /* FunctionFlags.Async */ && enclosingFunctionFlags & 1 /* FunctionFlags.Generator */) { + return ts.setOriginalNode(ts.setTextRange(factory.createYieldExpression(/*asteriskToken*/ undefined, emitHelpers().createAwaitHelper(ts.visitNode(node.expression, visitor, ts.isExpression))), + /*location*/ node), node); + } + return ts.visitEachChild(node, visitor, context); + } + function visitYieldExpression(node) { + if (enclosingFunctionFlags & 2 /* FunctionFlags.Async */ && enclosingFunctionFlags & 1 /* FunctionFlags.Generator */) { + if (node.asteriskToken) { + var expression = ts.visitNode(ts.Debug.checkDefined(node.expression), visitor, ts.isExpression); + return ts.setOriginalNode(ts.setTextRange(factory.createYieldExpression( + /*asteriskToken*/ undefined, emitHelpers().createAwaitHelper(factory.updateYieldExpression(node, node.asteriskToken, ts.setTextRange(emitHelpers().createAsyncDelegatorHelper(ts.setTextRange(emitHelpers().createAsyncValuesHelper(expression), expression)), expression)))), node), node); + } + return ts.setOriginalNode(ts.setTextRange(factory.createYieldExpression( + /*asteriskToken*/ undefined, createDownlevelAwait(node.expression + ? ts.visitNode(node.expression, visitor, ts.isExpression) + : factory.createVoidZero())), node), node); + } + return ts.visitEachChild(node, visitor, context); + } + function visitReturnStatement(node) { + if (enclosingFunctionFlags & 2 /* FunctionFlags.Async */ && enclosingFunctionFlags & 1 /* FunctionFlags.Generator */) { + return factory.updateReturnStatement(node, createDownlevelAwait(node.expression ? ts.visitNode(node.expression, visitor, ts.isExpression) : factory.createVoidZero())); + } + return ts.visitEachChild(node, visitor, context); + } + function visitLabeledStatement(node) { + if (enclosingFunctionFlags & 2 /* FunctionFlags.Async */) { + var statement = ts.unwrapInnermostStatementOfLabel(node); + if (statement.kind === 247 /* SyntaxKind.ForOfStatement */ && statement.awaitModifier) { + return visitForOfStatement(statement, node); + } + return factory.restoreEnclosingLabel(ts.visitNode(statement, visitor, ts.isStatement, factory.liftToBlock), node); + } + return ts.visitEachChild(node, visitor, context); + } + function chunkObjectLiteralElements(elements) { + var chunkObject; + var objects = []; + for (var _i = 0, elements_5 = elements; _i < elements_5.length; _i++) { + var e = elements_5[_i]; + if (e.kind === 301 /* SyntaxKind.SpreadAssignment */) { + if (chunkObject) { + objects.push(factory.createObjectLiteralExpression(chunkObject)); + chunkObject = undefined; + } + var target = e.expression; + objects.push(ts.visitNode(target, visitor, ts.isExpression)); + } + else { + chunkObject = ts.append(chunkObject, e.kind === 299 /* SyntaxKind.PropertyAssignment */ + ? factory.createPropertyAssignment(e.name, ts.visitNode(e.initializer, visitor, ts.isExpression)) + : ts.visitNode(e, visitor, ts.isObjectLiteralElementLike)); + } + } + if (chunkObject) { + objects.push(factory.createObjectLiteralExpression(chunkObject)); + } + return objects; + } + function visitObjectLiteralExpression(node) { + if (node.transformFlags & 65536 /* TransformFlags.ContainsObjectRestOrSpread */) { + // spread elements emit like so: + // non-spread elements are chunked together into object literals, and then all are passed to __assign: + // { a, ...o, b } => __assign(__assign({a}, o), {b}); + // If the first element is a spread element, then the first argument to __assign is {}: + // { ...o, a, b, ...o2 } => __assign(__assign(__assign({}, o), {a, b}), o2) + // + // We cannot call __assign with more than two elements, since any element could cause side effects. For + // example: + // var k = { a: 1, b: 2 }; + // var o = { a: 3, ...k, b: k.a++ }; + // // expected: { a: 1, b: 1 } + // If we translate the above to `__assign({ a: 3 }, k, { b: k.a++ })`, the `k.a++` will evaluate before + // `k` is spread and we end up with `{ a: 2, b: 1 }`. + // + // This also occurs for spread elements, not just property assignments: + // var k = { a: 1, get b() { l = { z: 9 }; return 2; } }; + // var l = { c: 3 }; + // var o = { ...k, ...l }; + // // expected: { a: 1, b: 2, z: 9 } + // If we translate the above to `__assign({}, k, l)`, the `l` will evaluate before `k` is spread and we + // end up with `{ a: 1, b: 2, c: 3 }` + var objects = chunkObjectLiteralElements(node.properties); + if (objects.length && objects[0].kind !== 207 /* SyntaxKind.ObjectLiteralExpression */) { + objects.unshift(factory.createObjectLiteralExpression()); + } + var expression = objects[0]; + if (objects.length > 1) { + for (var i = 1; i < objects.length; i++) { + expression = emitHelpers().createAssignHelper([expression, objects[i]]); + } + return expression; + } + else { + return emitHelpers().createAssignHelper(objects); + } + } + return ts.visitEachChild(node, visitor, context); + } + function visitExpressionStatement(node) { + return ts.visitEachChild(node, visitorWithUnusedExpressionResult, context); + } + /** + * @param expressionResultIsUnused Indicates the result of an expression is unused by the parent node (i.e., the left side of a comma or the + * expression of an `ExpressionStatement`). + */ + function visitParenthesizedExpression(node, expressionResultIsUnused) { + return ts.visitEachChild(node, expressionResultIsUnused ? visitorWithUnusedExpressionResult : visitor, context); + } + function visitSourceFile(node) { + var ancestorFacts = enterSubtree(2 /* HierarchyFacts.SourceFileExcludes */, ts.isEffectiveStrictModeSourceFile(node, compilerOptions) ? + 0 /* HierarchyFacts.StrictModeSourceFileIncludes */ : + 1 /* HierarchyFacts.SourceFileIncludes */); + exportedVariableStatement = false; + var visited = ts.visitEachChild(node, visitor, context); + var statement = ts.concatenate(visited.statements, taggedTemplateStringDeclarations && [ + factory.createVariableStatement(/*modifiers*/ undefined, factory.createVariableDeclarationList(taggedTemplateStringDeclarations)) + ]); + var result = factory.updateSourceFile(visited, ts.setTextRange(factory.createNodeArray(statement), node.statements)); + exitSubtree(ancestorFacts); + return result; + } + function visitTaggedTemplateExpression(node) { + return ts.processTaggedTemplateExpression(context, node, visitor, currentSourceFile, recordTaggedTemplateString, ts.ProcessLevel.LiftRestriction); + } + /** + * Visits a BinaryExpression that contains a destructuring assignment. + * + * @param node A BinaryExpression node. + * @param expressionResultIsUnused Indicates the result of an expression is unused by the parent node (i.e., the left side of a comma or the + * expression of an `ExpressionStatement`). + */ + function visitBinaryExpression(node, expressionResultIsUnused) { + if (ts.isDestructuringAssignment(node) && node.left.transformFlags & 65536 /* TransformFlags.ContainsObjectRestOrSpread */) { + return ts.flattenDestructuringAssignment(node, visitor, context, 1 /* FlattenLevel.ObjectRest */, !expressionResultIsUnused); + } + if (node.operatorToken.kind === 27 /* SyntaxKind.CommaToken */) { + return factory.updateBinaryExpression(node, ts.visitNode(node.left, visitorWithUnusedExpressionResult, ts.isExpression), node.operatorToken, ts.visitNode(node.right, expressionResultIsUnused ? visitorWithUnusedExpressionResult : visitor, ts.isExpression)); + } + return ts.visitEachChild(node, visitor, context); + } + /** + * @param expressionResultIsUnused Indicates the result of an expression is unused by the parent node (i.e., the left side of a comma or the + * expression of an `ExpressionStatement`). + */ + function visitCommaListExpression(node, expressionResultIsUnused) { + if (expressionResultIsUnused) { + return ts.visitEachChild(node, visitorWithUnusedExpressionResult, context); + } + var result; + for (var i = 0; i < node.elements.length; i++) { + var element = node.elements[i]; + var visited = ts.visitNode(element, i < node.elements.length - 1 ? visitorWithUnusedExpressionResult : visitor, ts.isExpression); + if (result || visited !== element) { + result || (result = node.elements.slice(0, i)); + result.push(visited); + } + } + var elements = result ? ts.setTextRange(factory.createNodeArray(result), node.elements) : node.elements; + return factory.updateCommaListExpression(node, elements); + } + function visitCatchClause(node) { + if (node.variableDeclaration && + ts.isBindingPattern(node.variableDeclaration.name) && + node.variableDeclaration.name.transformFlags & 65536 /* TransformFlags.ContainsObjectRestOrSpread */) { + var name = factory.getGeneratedNameForNode(node.variableDeclaration.name); + var updatedDecl = factory.updateVariableDeclaration(node.variableDeclaration, node.variableDeclaration.name, /*exclamationToken*/ undefined, /*type*/ undefined, name); + var visitedBindings = ts.flattenDestructuringBinding(updatedDecl, visitor, context, 1 /* FlattenLevel.ObjectRest */); + var block = ts.visitNode(node.block, visitor, ts.isBlock); + if (ts.some(visitedBindings)) { + block = factory.updateBlock(block, __spreadArray([ + factory.createVariableStatement(/*modifiers*/ undefined, visitedBindings) + ], block.statements, true)); + } + return factory.updateCatchClause(node, factory.updateVariableDeclaration(node.variableDeclaration, name, /*exclamationToken*/ undefined, /*type*/ undefined, /*initializer*/ undefined), block); + } + return ts.visitEachChild(node, visitor, context); + } + function visitVariableStatement(node) { + if (ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */)) { + var savedExportedVariableStatement = exportedVariableStatement; + exportedVariableStatement = true; + var visited = ts.visitEachChild(node, visitor, context); + exportedVariableStatement = savedExportedVariableStatement; + return visited; + } + return ts.visitEachChild(node, visitor, context); + } + /** + * Visits a VariableDeclaration node with a binding pattern. + * + * @param node A VariableDeclaration node. + */ + function visitVariableDeclaration(node) { + if (exportedVariableStatement) { + var savedExportedVariableStatement = exportedVariableStatement; + exportedVariableStatement = false; + var visited = visitVariableDeclarationWorker(node, /*exportedVariableStatement*/ true); + exportedVariableStatement = savedExportedVariableStatement; + return visited; + } + return visitVariableDeclarationWorker(node, /*exportedVariableStatement*/ false); + } + function visitVariableDeclarationWorker(node, exportedVariableStatement) { + // If we are here it is because the name contains a binding pattern with a rest somewhere in it. + if (ts.isBindingPattern(node.name) && node.name.transformFlags & 65536 /* TransformFlags.ContainsObjectRestOrSpread */) { + return ts.flattenDestructuringBinding(node, visitor, context, 1 /* FlattenLevel.ObjectRest */, + /*rval*/ undefined, exportedVariableStatement); + } + return ts.visitEachChild(node, visitor, context); + } + function visitForStatement(node) { + return factory.updateForStatement(node, ts.visitNode(node.initializer, visitorWithUnusedExpressionResult, ts.isForInitializer), ts.visitNode(node.condition, visitor, ts.isExpression), ts.visitNode(node.incrementor, visitorWithUnusedExpressionResult, ts.isExpression), ts.visitIterationBody(node.statement, visitor, context)); + } + function visitVoidExpression(node) { + return ts.visitEachChild(node, visitorWithUnusedExpressionResult, context); + } + /** + * Visits a ForOfStatement and converts it into a ES2015-compatible ForOfStatement. + * + * @param node A ForOfStatement. + */ + function visitForOfStatement(node, outermostLabeledStatement) { + var ancestorFacts = enterSubtree(0 /* HierarchyFacts.IterationStatementExcludes */, 2 /* HierarchyFacts.IterationStatementIncludes */); + if (node.initializer.transformFlags & 65536 /* TransformFlags.ContainsObjectRestOrSpread */) { + node = transformForOfStatementWithObjectRest(node); + } + var result = node.awaitModifier ? + transformForAwaitOfStatement(node, outermostLabeledStatement, ancestorFacts) : + factory.restoreEnclosingLabel(ts.visitEachChild(node, visitor, context), outermostLabeledStatement); + exitSubtree(ancestorFacts); + return result; + } + function transformForOfStatementWithObjectRest(node) { + var initializerWithoutParens = ts.skipParentheses(node.initializer); + if (ts.isVariableDeclarationList(initializerWithoutParens) || ts.isAssignmentPattern(initializerWithoutParens)) { + var bodyLocation = void 0; + var statementsLocation = void 0; + var temp = factory.createTempVariable(/*recordTempVariable*/ undefined); + var statements = [ts.createForOfBindingStatement(factory, initializerWithoutParens, temp)]; + if (ts.isBlock(node.statement)) { + ts.addRange(statements, node.statement.statements); + bodyLocation = node.statement; + statementsLocation = node.statement.statements; + } + else if (node.statement) { + ts.append(statements, node.statement); + bodyLocation = node.statement; + statementsLocation = node.statement; + } + return factory.updateForOfStatement(node, node.awaitModifier, ts.setTextRange(factory.createVariableDeclarationList([ + ts.setTextRange(factory.createVariableDeclaration(temp), node.initializer) + ], 1 /* NodeFlags.Let */), node.initializer), node.expression, ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), statementsLocation), + /*multiLine*/ true), bodyLocation)); + } + return node; + } + function convertForOfStatementHead(node, boundValue, nonUserCode) { + var value = factory.createTempVariable(hoistVariableDeclaration); + var iteratorValueExpression = factory.createAssignment(value, boundValue); + var iteratorValueStatement = factory.createExpressionStatement(iteratorValueExpression); + ts.setSourceMapRange(iteratorValueStatement, node.expression); + var exitNonUserCodeExpression = factory.createAssignment(nonUserCode, factory.createFalse()); + var exitNonUserCodeStatement = factory.createExpressionStatement(exitNonUserCodeExpression); + ts.setSourceMapRange(exitNonUserCodeStatement, node.expression); + var enterNonUserCodeExpression = factory.createAssignment(nonUserCode, factory.createTrue()); + var enterNonUserCodeStatement = factory.createExpressionStatement(enterNonUserCodeExpression); + ts.setSourceMapRange(exitNonUserCodeStatement, node.expression); + var statements = []; + var binding = ts.createForOfBindingStatement(factory, node.initializer, value); + statements.push(ts.visitNode(binding, visitor, ts.isStatement)); + var bodyLocation; + var statementsLocation; + var statement = ts.visitIterationBody(node.statement, visitor, context); + if (ts.isBlock(statement)) { + ts.addRange(statements, statement.statements); + bodyLocation = statement; + statementsLocation = statement.statements; + } + else { + statements.push(statement); + } + var body = ts.setEmitFlags(ts.setTextRange(factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), statementsLocation), + /*multiLine*/ true), bodyLocation), 48 /* EmitFlags.NoSourceMap */ | 384 /* EmitFlags.NoTokenSourceMaps */); + return factory.createBlock([ + iteratorValueStatement, + exitNonUserCodeStatement, + factory.createTryStatement(body, + /*catchClause*/ undefined, factory.createBlock([ + enterNonUserCodeStatement + ])) + ]); + } + function createDownlevelAwait(expression) { + return enclosingFunctionFlags & 1 /* FunctionFlags.Generator */ + ? factory.createYieldExpression(/*asteriskToken*/ undefined, emitHelpers().createAwaitHelper(expression)) + : factory.createAwaitExpression(expression); + } + function transformForAwaitOfStatement(node, outermostLabeledStatement, ancestorFacts) { + var expression = ts.visitNode(node.expression, visitor, ts.isExpression); + var iterator = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(expression) : factory.createTempVariable(/*recordTempVariable*/ undefined); + var result = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(iterator) : factory.createTempVariable(/*recordTempVariable*/ undefined); + var nonUserCode = factory.createTempVariable(/*recordTempVariable*/ undefined); + var done = factory.createTempVariable(hoistVariableDeclaration); + var errorRecord = factory.createUniqueName("e"); + var catchVariable = factory.getGeneratedNameForNode(errorRecord); + var returnMethod = factory.createTempVariable(/*recordTempVariable*/ undefined); + var callValues = ts.setTextRange(emitHelpers().createAsyncValuesHelper(expression), node.expression); + var callNext = factory.createCallExpression(factory.createPropertyAccessExpression(iterator, "next"), /*typeArguments*/ undefined, []); + var getDone = factory.createPropertyAccessExpression(result, "done"); + var getValue = factory.createPropertyAccessExpression(result, "value"); + var callReturn = factory.createFunctionCallCall(returnMethod, iterator, []); + hoistVariableDeclaration(errorRecord); + hoistVariableDeclaration(returnMethod); + // if we are enclosed in an outer loop ensure we reset 'errorRecord' per each iteration + var initializer = ancestorFacts & 2 /* HierarchyFacts.IterationContainer */ ? + factory.inlineExpressions([factory.createAssignment(errorRecord, factory.createVoidZero()), callValues]) : + callValues; + var forStatement = ts.setEmitFlags(ts.setTextRange(factory.createForStatement( + /*initializer*/ ts.setEmitFlags(ts.setTextRange(factory.createVariableDeclarationList([ + factory.createVariableDeclaration(nonUserCode, /*exclamationToken*/ undefined, /*type*/ undefined, factory.createTrue()), + ts.setTextRange(factory.createVariableDeclaration(iterator, /*exclamationToken*/ undefined, /*type*/ undefined, initializer), node.expression), + factory.createVariableDeclaration(result) + ]), node.expression), 2097152 /* EmitFlags.NoHoisting */), + /*condition*/ factory.inlineExpressions([ + factory.createAssignment(result, createDownlevelAwait(callNext)), + factory.createAssignment(done, getDone), + factory.createLogicalNot(done) + ]), + /*incrementor*/ undefined, + /*statement*/ convertForOfStatementHead(node, getValue, nonUserCode)), + /*location*/ node), 256 /* EmitFlags.NoTokenTrailingSourceMaps */); + ts.setOriginalNode(forStatement, node); + return factory.createTryStatement(factory.createBlock([ + factory.restoreEnclosingLabel(forStatement, outermostLabeledStatement) + ]), factory.createCatchClause(factory.createVariableDeclaration(catchVariable), ts.setEmitFlags(factory.createBlock([ + factory.createExpressionStatement(factory.createAssignment(errorRecord, factory.createObjectLiteralExpression([ + factory.createPropertyAssignment("error", catchVariable) + ]))) + ]), 1 /* EmitFlags.SingleLine */)), factory.createBlock([ + factory.createTryStatement( + /*tryBlock*/ factory.createBlock([ + ts.setEmitFlags(factory.createIfStatement(factory.createLogicalAnd(factory.createLogicalAnd(factory.createLogicalNot(nonUserCode), factory.createLogicalNot(done)), factory.createAssignment(returnMethod, factory.createPropertyAccessExpression(iterator, "return"))), factory.createExpressionStatement(createDownlevelAwait(callReturn))), 1 /* EmitFlags.SingleLine */) + ]), + /*catchClause*/ undefined, + /*finallyBlock*/ ts.setEmitFlags(factory.createBlock([ + ts.setEmitFlags(factory.createIfStatement(errorRecord, factory.createThrowStatement(factory.createPropertyAccessExpression(errorRecord, "error"))), 1 /* EmitFlags.SingleLine */) + ]), 1 /* EmitFlags.SingleLine */)) + ])); + } + function parameterVisitor(node) { + ts.Debug.assertNode(node, ts.isParameter); + return visitParameter(node); + } + function visitParameter(node) { + if (parametersWithPrecedingObjectRestOrSpread === null || parametersWithPrecedingObjectRestOrSpread === void 0 ? void 0 : parametersWithPrecedingObjectRestOrSpread.has(node)) { + return factory.updateParameterDeclaration(node, + /*modifiers*/ undefined, node.dotDotDotToken, ts.isBindingPattern(node.name) ? factory.getGeneratedNameForNode(node) : node.name, + /*questionToken*/ undefined, + /*type*/ undefined, + /*initializer*/ undefined); + } + if (node.transformFlags & 65536 /* TransformFlags.ContainsObjectRestOrSpread */) { + // Binding patterns are converted into a generated name and are + // evaluated inside the function body. + return factory.updateParameterDeclaration(node, + /*modifiers*/ undefined, node.dotDotDotToken, factory.getGeneratedNameForNode(node), + /*questionToken*/ undefined, + /*type*/ undefined, ts.visitNode(node.initializer, visitor, ts.isExpression)); + } + return ts.visitEachChild(node, visitor, context); + } + function collectParametersWithPrecedingObjectRestOrSpread(node) { + var parameters; + for (var _i = 0, _a = node.parameters; _i < _a.length; _i++) { + var parameter = _a[_i]; + if (parameters) { + parameters.add(parameter); + } + else if (parameter.transformFlags & 65536 /* TransformFlags.ContainsObjectRestOrSpread */) { + parameters = new ts.Set(); + } + } + return parameters; + } + function visitConstructorDeclaration(node) { + var savedEnclosingFunctionFlags = enclosingFunctionFlags; + var savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread; + enclosingFunctionFlags = ts.getFunctionFlags(node); + parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node); + var updated = factory.updateConstructorDeclaration(node, node.modifiers, ts.visitParameterList(node.parameters, parameterVisitor, context), transformFunctionBody(node)); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread; + return updated; + } + function visitGetAccessorDeclaration(node) { + var savedEnclosingFunctionFlags = enclosingFunctionFlags; + var savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread; + enclosingFunctionFlags = ts.getFunctionFlags(node); + parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node); + var updated = factory.updateGetAccessorDeclaration(node, node.modifiers, ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitParameterList(node.parameters, parameterVisitor, context), + /*type*/ undefined, transformFunctionBody(node)); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread; + return updated; + } + function visitSetAccessorDeclaration(node) { + var savedEnclosingFunctionFlags = enclosingFunctionFlags; + var savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread; + enclosingFunctionFlags = ts.getFunctionFlags(node); + parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node); + var updated = factory.updateSetAccessorDeclaration(node, node.modifiers, ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitParameterList(node.parameters, parameterVisitor, context), transformFunctionBody(node)); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread; + return updated; + } + function visitMethodDeclaration(node) { + var savedEnclosingFunctionFlags = enclosingFunctionFlags; + var savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread; + enclosingFunctionFlags = ts.getFunctionFlags(node); + parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node); + var updated = factory.updateMethodDeclaration(node, enclosingFunctionFlags & 1 /* FunctionFlags.Generator */ + ? ts.visitNodes(node.modifiers, visitorNoAsyncModifier, ts.isModifierLike) + : node.modifiers, enclosingFunctionFlags & 2 /* FunctionFlags.Async */ + ? undefined + : node.asteriskToken, ts.visitNode(node.name, visitor, ts.isPropertyName), ts.visitNode(/*questionToken*/ undefined, visitor, ts.isToken), + /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, parameterVisitor, context), + /*type*/ undefined, enclosingFunctionFlags & 2 /* FunctionFlags.Async */ && enclosingFunctionFlags & 1 /* FunctionFlags.Generator */ + ? transformAsyncGeneratorFunctionBody(node) + : transformFunctionBody(node)); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread; + return updated; + } + function visitFunctionDeclaration(node) { + var savedEnclosingFunctionFlags = enclosingFunctionFlags; + var savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread; + enclosingFunctionFlags = ts.getFunctionFlags(node); + parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node); + var updated = factory.updateFunctionDeclaration(node, enclosingFunctionFlags & 1 /* FunctionFlags.Generator */ + ? ts.visitNodes(node.modifiers, visitorNoAsyncModifier, ts.isModifier) + : node.modifiers, enclosingFunctionFlags & 2 /* FunctionFlags.Async */ + ? undefined + : node.asteriskToken, node.name, + /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, parameterVisitor, context), + /*type*/ undefined, enclosingFunctionFlags & 2 /* FunctionFlags.Async */ && enclosingFunctionFlags & 1 /* FunctionFlags.Generator */ + ? transformAsyncGeneratorFunctionBody(node) + : transformFunctionBody(node)); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread; + return updated; + } + function visitArrowFunction(node) { + var savedEnclosingFunctionFlags = enclosingFunctionFlags; + var savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread; + enclosingFunctionFlags = ts.getFunctionFlags(node); + parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node); + var updated = factory.updateArrowFunction(node, node.modifiers, + /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, parameterVisitor, context), + /*type*/ undefined, node.equalsGreaterThanToken, transformFunctionBody(node)); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread; + return updated; + } + function visitFunctionExpression(node) { + var savedEnclosingFunctionFlags = enclosingFunctionFlags; + var savedParametersWithPrecedingObjectRestOrSpread = parametersWithPrecedingObjectRestOrSpread; + enclosingFunctionFlags = ts.getFunctionFlags(node); + parametersWithPrecedingObjectRestOrSpread = collectParametersWithPrecedingObjectRestOrSpread(node); + var updated = factory.updateFunctionExpression(node, enclosingFunctionFlags & 1 /* FunctionFlags.Generator */ + ? ts.visitNodes(node.modifiers, visitorNoAsyncModifier, ts.isModifier) + : node.modifiers, enclosingFunctionFlags & 2 /* FunctionFlags.Async */ + ? undefined + : node.asteriskToken, node.name, + /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, parameterVisitor, context), + /*type*/ undefined, enclosingFunctionFlags & 2 /* FunctionFlags.Async */ && enclosingFunctionFlags & 1 /* FunctionFlags.Generator */ + ? transformAsyncGeneratorFunctionBody(node) + : transformFunctionBody(node)); + enclosingFunctionFlags = savedEnclosingFunctionFlags; + parametersWithPrecedingObjectRestOrSpread = savedParametersWithPrecedingObjectRestOrSpread; + return updated; + } + function transformAsyncGeneratorFunctionBody(node) { + resumeLexicalEnvironment(); + var statements = []; + var statementOffset = factory.copyPrologue(node.body.statements, statements, /*ensureUseStrict*/ false, visitor); + appendObjectRestAssignmentsIfNeeded(statements, node); + var savedCapturedSuperProperties = capturedSuperProperties; + var savedHasSuperElementAccess = hasSuperElementAccess; + capturedSuperProperties = new ts.Set(); + hasSuperElementAccess = false; + var returnStatement = factory.createReturnStatement(emitHelpers().createAsyncGeneratorHelper(factory.createFunctionExpression( + /*modifiers*/ undefined, factory.createToken(41 /* SyntaxKind.AsteriskToken */), node.name && factory.getGeneratedNameForNode(node.name), + /*typeParameters*/ undefined, + /*parameters*/ [], + /*type*/ undefined, factory.updateBlock(node.body, ts.visitLexicalEnvironment(node.body.statements, visitor, context, statementOffset))), !!(hierarchyFacts & 1 /* HierarchyFacts.HasLexicalThis */))); + // Minor optimization, emit `_super` helper to capture `super` access in an arrow. + // This step isn't needed if we eventually transform this to ES5. + var emitSuperHelpers = languageVersion >= 2 /* ScriptTarget.ES2015 */ && resolver.getNodeCheckFlags(node) & (4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */ | 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */); + if (emitSuperHelpers) { + enableSubstitutionForAsyncMethodsWithSuper(); + var variableStatement = ts.createSuperAccessVariableStatement(factory, resolver, node, capturedSuperProperties); + substitutedSuperAccessors[ts.getNodeId(variableStatement)] = true; + ts.insertStatementsAfterStandardPrologue(statements, [variableStatement]); + } + statements.push(returnStatement); + ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment()); + var block = factory.updateBlock(node.body, statements); + if (emitSuperHelpers && hasSuperElementAccess) { + if (resolver.getNodeCheckFlags(node) & 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */) { + ts.addEmitHelper(block, ts.advancedAsyncSuperHelper); + } + else if (resolver.getNodeCheckFlags(node) & 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */) { + ts.addEmitHelper(block, ts.asyncSuperHelper); + } + } + capturedSuperProperties = savedCapturedSuperProperties; + hasSuperElementAccess = savedHasSuperElementAccess; + return block; + } + function transformFunctionBody(node) { + var _a; + resumeLexicalEnvironment(); + var statementOffset = 0; + var statements = []; + var body = (_a = ts.visitNode(node.body, visitor, ts.isConciseBody)) !== null && _a !== void 0 ? _a : factory.createBlock([]); + if (ts.isBlock(body)) { + statementOffset = factory.copyPrologue(body.statements, statements, /*ensureUseStrict*/ false, visitor); + } + ts.addRange(statements, appendObjectRestAssignmentsIfNeeded(/*statements*/ undefined, node)); + var leadingStatements = endLexicalEnvironment(); + if (statementOffset > 0 || ts.some(statements) || ts.some(leadingStatements)) { + var block = factory.converters.convertToFunctionBlock(body, /*multiLine*/ true); + ts.insertStatementsAfterStandardPrologue(statements, leadingStatements); + ts.addRange(statements, block.statements.slice(statementOffset)); + return factory.updateBlock(block, ts.setTextRange(factory.createNodeArray(statements), block.statements)); + } + return body; + } + function appendObjectRestAssignmentsIfNeeded(statements, node) { + var containsPrecedingObjectRestOrSpread = false; + for (var _i = 0, _a = node.parameters; _i < _a.length; _i++) { + var parameter = _a[_i]; + if (containsPrecedingObjectRestOrSpread) { + if (ts.isBindingPattern(parameter.name)) { + // In cases where a binding pattern is simply '[]' or '{}', + // we usually don't want to emit a var declaration; however, in the presence + // of an initializer, we must emit that expression to preserve side effects. + // + // NOTE: see `insertDefaultValueAssignmentForBindingPattern` in es2015.ts + if (parameter.name.elements.length > 0) { + var declarations = ts.flattenDestructuringBinding(parameter, visitor, context, 0 /* FlattenLevel.All */, factory.getGeneratedNameForNode(parameter)); + if (ts.some(declarations)) { + var declarationList = factory.createVariableDeclarationList(declarations); + var statement = factory.createVariableStatement(/*modifiers*/ undefined, declarationList); + ts.setEmitFlags(statement, 1048576 /* EmitFlags.CustomPrologue */); + statements = ts.append(statements, statement); + } + } + else if (parameter.initializer) { + var name = factory.getGeneratedNameForNode(parameter); + var initializer = ts.visitNode(parameter.initializer, visitor, ts.isExpression); + var assignment = factory.createAssignment(name, initializer); + var statement = factory.createExpressionStatement(assignment); + ts.setEmitFlags(statement, 1048576 /* EmitFlags.CustomPrologue */); + statements = ts.append(statements, statement); + } + } + else if (parameter.initializer) { + // Converts a parameter initializer into a function body statement, i.e.: + // + // function f(x = 1) { } + // + // becomes + // + // function f(x) { + // if (typeof x === "undefined") { x = 1; } + // } + var name = factory.cloneNode(parameter.name); + ts.setTextRange(name, parameter.name); + ts.setEmitFlags(name, 48 /* EmitFlags.NoSourceMap */); + var initializer = ts.visitNode(parameter.initializer, visitor, ts.isExpression); + ts.addEmitFlags(initializer, 48 /* EmitFlags.NoSourceMap */ | 1536 /* EmitFlags.NoComments */); + var assignment = factory.createAssignment(name, initializer); + ts.setTextRange(assignment, parameter); + ts.setEmitFlags(assignment, 1536 /* EmitFlags.NoComments */); + var block = factory.createBlock([factory.createExpressionStatement(assignment)]); + ts.setTextRange(block, parameter); + ts.setEmitFlags(block, 1 /* EmitFlags.SingleLine */ | 32 /* EmitFlags.NoTrailingSourceMap */ | 384 /* EmitFlags.NoTokenSourceMaps */ | 1536 /* EmitFlags.NoComments */); + var typeCheck = factory.createTypeCheck(factory.cloneNode(parameter.name), "undefined"); + var statement = factory.createIfStatement(typeCheck, block); + ts.startOnNewLine(statement); + ts.setTextRange(statement, parameter); + ts.setEmitFlags(statement, 384 /* EmitFlags.NoTokenSourceMaps */ | 32 /* EmitFlags.NoTrailingSourceMap */ | 1048576 /* EmitFlags.CustomPrologue */ | 1536 /* EmitFlags.NoComments */); + statements = ts.append(statements, statement); + } + } + else if (parameter.transformFlags & 65536 /* TransformFlags.ContainsObjectRestOrSpread */) { + containsPrecedingObjectRestOrSpread = true; + var declarations = ts.flattenDestructuringBinding(parameter, visitor, context, 1 /* FlattenLevel.ObjectRest */, factory.getGeneratedNameForNode(parameter), + /*doNotRecordTempVariablesInLine*/ false, + /*skipInitializer*/ true); + if (ts.some(declarations)) { + var declarationList = factory.createVariableDeclarationList(declarations); + var statement = factory.createVariableStatement(/*modifiers*/ undefined, declarationList); + ts.setEmitFlags(statement, 1048576 /* EmitFlags.CustomPrologue */); + statements = ts.append(statements, statement); + } + } + } + return statements; + } + function enableSubstitutionForAsyncMethodsWithSuper() { + if ((enabledSubstitutions & 1 /* ESNextSubstitutionFlags.AsyncMethodsWithSuper */) === 0) { + enabledSubstitutions |= 1 /* ESNextSubstitutionFlags.AsyncMethodsWithSuper */; + // We need to enable substitutions for call, property access, and element access + // if we need to rewrite super calls. + context.enableSubstitution(210 /* SyntaxKind.CallExpression */); + context.enableSubstitution(208 /* SyntaxKind.PropertyAccessExpression */); + context.enableSubstitution(209 /* SyntaxKind.ElementAccessExpression */); + // We need to be notified when entering and exiting declarations that bind super. + context.enableEmitNotification(260 /* SyntaxKind.ClassDeclaration */); + context.enableEmitNotification(171 /* SyntaxKind.MethodDeclaration */); + context.enableEmitNotification(174 /* SyntaxKind.GetAccessor */); + context.enableEmitNotification(175 /* SyntaxKind.SetAccessor */); + context.enableEmitNotification(173 /* SyntaxKind.Constructor */); + // We need to be notified when entering the generated accessor arrow functions. + context.enableEmitNotification(240 /* SyntaxKind.VariableStatement */); + } + } + /** + * Called by the printer just before a node is printed. + * + * @param hint A hint as to the intended usage of the node. + * @param node The node to be printed. + * @param emitCallback The callback used to emit the node. + */ + function onEmitNode(hint, node, emitCallback) { + // If we need to support substitutions for `super` in an async method, + // we should track it here. + if (enabledSubstitutions & 1 /* ESNextSubstitutionFlags.AsyncMethodsWithSuper */ && isSuperContainer(node)) { + var superContainerFlags = resolver.getNodeCheckFlags(node) & (2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */ | 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */); + if (superContainerFlags !== enclosingSuperContainerFlags) { + var savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags; + enclosingSuperContainerFlags = superContainerFlags; + previousOnEmitNode(hint, node, emitCallback); + enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags; + return; + } + } + // Disable substitution in the generated super accessor itself. + else if (enabledSubstitutions && substitutedSuperAccessors[ts.getNodeId(node)]) { + var savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags; + enclosingSuperContainerFlags = 0; + previousOnEmitNode(hint, node, emitCallback); + enclosingSuperContainerFlags = savedEnclosingSuperContainerFlags; + return; + } + previousOnEmitNode(hint, node, emitCallback); + } + /** + * Hooks node substitutions. + * + * @param hint The context for the emitter. + * @param node The node to substitute. + */ + function onSubstituteNode(hint, node) { + node = previousOnSubstituteNode(hint, node); + if (hint === 1 /* EmitHint.Expression */ && enclosingSuperContainerFlags) { + return substituteExpression(node); + } + return node; + } + function substituteExpression(node) { + switch (node.kind) { + case 208 /* SyntaxKind.PropertyAccessExpression */: + return substitutePropertyAccessExpression(node); + case 209 /* SyntaxKind.ElementAccessExpression */: + return substituteElementAccessExpression(node); + case 210 /* SyntaxKind.CallExpression */: + return substituteCallExpression(node); + } + return node; + } + function substitutePropertyAccessExpression(node) { + if (node.expression.kind === 106 /* SyntaxKind.SuperKeyword */) { + return ts.setTextRange(factory.createPropertyAccessExpression(factory.createUniqueName("_super", 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */), node.name), node); + } + return node; + } + function substituteElementAccessExpression(node) { + if (node.expression.kind === 106 /* SyntaxKind.SuperKeyword */) { + return createSuperElementAccessInAsyncMethod(node.argumentExpression, node); + } + return node; + } + function substituteCallExpression(node) { + var expression = node.expression; + if (ts.isSuperProperty(expression)) { + var argumentExpression = ts.isPropertyAccessExpression(expression) + ? substitutePropertyAccessExpression(expression) + : substituteElementAccessExpression(expression); + return factory.createCallExpression(factory.createPropertyAccessExpression(argumentExpression, "call"), + /*typeArguments*/ undefined, __spreadArray([ + factory.createThis() + ], node.arguments, true)); + } + return node; + } + function isSuperContainer(node) { + var kind = node.kind; + return kind === 260 /* SyntaxKind.ClassDeclaration */ + || kind === 173 /* SyntaxKind.Constructor */ + || kind === 171 /* SyntaxKind.MethodDeclaration */ + || kind === 174 /* SyntaxKind.GetAccessor */ + || kind === 175 /* SyntaxKind.SetAccessor */; + } + function createSuperElementAccessInAsyncMethod(argumentExpression, location) { + if (enclosingSuperContainerFlags & 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */) { + return ts.setTextRange(factory.createPropertyAccessExpression(factory.createCallExpression(factory.createIdentifier("_superIndex"), + /*typeArguments*/ undefined, [argumentExpression]), "value"), location); + } + else { + return ts.setTextRange(factory.createCallExpression(factory.createIdentifier("_superIndex"), + /*typeArguments*/ undefined, [argumentExpression]), location); + } + } + } + ts.transformES2018 = transformES2018; +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + function transformES2019(context) { + var factory = context.factory; + return ts.chainBundle(context, transformSourceFile); + function transformSourceFile(node) { + if (node.isDeclarationFile) { + return node; + } + return ts.visitEachChild(node, visitor, context); + } + function visitor(node) { + if ((node.transformFlags & 64 /* TransformFlags.ContainsES2019 */) === 0) { + return node; + } + switch (node.kind) { + case 295 /* SyntaxKind.CatchClause */: + return visitCatchClause(node); + default: + return ts.visitEachChild(node, visitor, context); + } + } + function visitCatchClause(node) { + if (!node.variableDeclaration) { + return factory.updateCatchClause(node, factory.createVariableDeclaration(factory.createTempVariable(/*recordTempVariable*/ undefined)), ts.visitNode(node.block, visitor, ts.isBlock)); + } + return ts.visitEachChild(node, visitor, context); + } + } + ts.transformES2019 = transformES2019; +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + function transformES2020(context) { + var factory = context.factory, hoistVariableDeclaration = context.hoistVariableDeclaration; + return ts.chainBundle(context, transformSourceFile); + function transformSourceFile(node) { + if (node.isDeclarationFile) { + return node; + } + return ts.visitEachChild(node, visitor, context); + } + function visitor(node) { + if ((node.transformFlags & 32 /* TransformFlags.ContainsES2020 */) === 0) { + return node; + } + switch (node.kind) { + case 210 /* SyntaxKind.CallExpression */: { + var updated = visitNonOptionalCallExpression(node, /*captureThisArg*/ false); + ts.Debug.assertNotNode(updated, ts.isSyntheticReference); + return updated; + } + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 209 /* SyntaxKind.ElementAccessExpression */: + if (ts.isOptionalChain(node)) { + var updated = visitOptionalExpression(node, /*captureThisArg*/ false, /*isDelete*/ false); + ts.Debug.assertNotNode(updated, ts.isSyntheticReference); + return updated; + } + return ts.visitEachChild(node, visitor, context); + case 223 /* SyntaxKind.BinaryExpression */: + if (node.operatorToken.kind === 60 /* SyntaxKind.QuestionQuestionToken */) { + return transformNullishCoalescingExpression(node); + } + return ts.visitEachChild(node, visitor, context); + case 217 /* SyntaxKind.DeleteExpression */: + return visitDeleteExpression(node); + default: + return ts.visitEachChild(node, visitor, context); + } + } + function flattenChain(chain) { + ts.Debug.assertNotNode(chain, ts.isNonNullChain); + var links = [chain]; + while (!chain.questionDotToken && !ts.isTaggedTemplateExpression(chain)) { + chain = ts.cast(ts.skipPartiallyEmittedExpressions(chain.expression), ts.isOptionalChain); + ts.Debug.assertNotNode(chain, ts.isNonNullChain); + links.unshift(chain); + } + return { expression: chain.expression, chain: links }; + } + function visitNonOptionalParenthesizedExpression(node, captureThisArg, isDelete) { + var expression = visitNonOptionalExpression(node.expression, captureThisArg, isDelete); + if (ts.isSyntheticReference(expression)) { + // `(a.b)` -> { expression `((_a = a).b)`, thisArg: `_a` } + // `(a[b])` -> { expression `((_a = a)[b])`, thisArg: `_a` } + return factory.createSyntheticReferenceExpression(factory.updateParenthesizedExpression(node, expression.expression), expression.thisArg); + } + return factory.updateParenthesizedExpression(node, expression); + } + function visitNonOptionalPropertyOrElementAccessExpression(node, captureThisArg, isDelete) { + if (ts.isOptionalChain(node)) { + // If `node` is an optional chain, then it is the outermost chain of an optional expression. + return visitOptionalExpression(node, captureThisArg, isDelete); + } + var expression = ts.visitNode(node.expression, visitor, ts.isExpression); + ts.Debug.assertNotNode(expression, ts.isSyntheticReference); + var thisArg; + if (captureThisArg) { + if (!ts.isSimpleCopiableExpression(expression)) { + thisArg = factory.createTempVariable(hoistVariableDeclaration); + expression = factory.createAssignment(thisArg, expression); + } + else { + thisArg = expression; + } + } + expression = node.kind === 208 /* SyntaxKind.PropertyAccessExpression */ + ? factory.updatePropertyAccessExpression(node, expression, ts.visitNode(node.name, visitor, ts.isIdentifier)) + : factory.updateElementAccessExpression(node, expression, ts.visitNode(node.argumentExpression, visitor, ts.isExpression)); + return thisArg ? factory.createSyntheticReferenceExpression(expression, thisArg) : expression; + } + function visitNonOptionalCallExpression(node, captureThisArg) { + if (ts.isOptionalChain(node)) { + // If `node` is an optional chain, then it is the outermost chain of an optional expression. + return visitOptionalExpression(node, captureThisArg, /*isDelete*/ false); + } + if (ts.isParenthesizedExpression(node.expression) && ts.isOptionalChain(ts.skipParentheses(node.expression))) { + // capture thisArg for calls of parenthesized optional chains like `(foo?.bar)()` + var expression = visitNonOptionalParenthesizedExpression(node.expression, /*captureThisArg*/ true, /*isDelete*/ false); + var args = ts.visitNodes(node.arguments, visitor, ts.isExpression); + if (ts.isSyntheticReference(expression)) { + return ts.setTextRange(factory.createFunctionCallCall(expression.expression, expression.thisArg, args), node); + } + return factory.updateCallExpression(node, expression, /*typeArguments*/ undefined, args); + } + return ts.visitEachChild(node, visitor, context); + } + function visitNonOptionalExpression(node, captureThisArg, isDelete) { + switch (node.kind) { + case 214 /* SyntaxKind.ParenthesizedExpression */: return visitNonOptionalParenthesizedExpression(node, captureThisArg, isDelete); + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 209 /* SyntaxKind.ElementAccessExpression */: return visitNonOptionalPropertyOrElementAccessExpression(node, captureThisArg, isDelete); + case 210 /* SyntaxKind.CallExpression */: return visitNonOptionalCallExpression(node, captureThisArg); + default: return ts.visitNode(node, visitor, ts.isExpression); + } + } + function visitOptionalExpression(node, captureThisArg, isDelete) { + var _a = flattenChain(node), expression = _a.expression, chain = _a.chain; + var left = visitNonOptionalExpression(ts.skipPartiallyEmittedExpressions(expression), ts.isCallChain(chain[0]), /*isDelete*/ false); + var leftThisArg = ts.isSyntheticReference(left) ? left.thisArg : undefined; + var capturedLeft = ts.isSyntheticReference(left) ? left.expression : left; + var leftExpression = factory.restoreOuterExpressions(expression, capturedLeft, 8 /* OuterExpressionKinds.PartiallyEmittedExpressions */); + if (!ts.isSimpleCopiableExpression(capturedLeft)) { + capturedLeft = factory.createTempVariable(hoistVariableDeclaration); + leftExpression = factory.createAssignment(capturedLeft, leftExpression); + } + var rightExpression = capturedLeft; + var thisArg; + for (var i = 0; i < chain.length; i++) { + var segment = chain[i]; + switch (segment.kind) { + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 209 /* SyntaxKind.ElementAccessExpression */: + if (i === chain.length - 1 && captureThisArg) { + if (!ts.isSimpleCopiableExpression(rightExpression)) { + thisArg = factory.createTempVariable(hoistVariableDeclaration); + rightExpression = factory.createAssignment(thisArg, rightExpression); + } + else { + thisArg = rightExpression; + } + } + rightExpression = segment.kind === 208 /* SyntaxKind.PropertyAccessExpression */ + ? factory.createPropertyAccessExpression(rightExpression, ts.visitNode(segment.name, visitor, ts.isIdentifier)) + : factory.createElementAccessExpression(rightExpression, ts.visitNode(segment.argumentExpression, visitor, ts.isExpression)); + break; + case 210 /* SyntaxKind.CallExpression */: + if (i === 0 && leftThisArg) { + if (!ts.isGeneratedIdentifier(leftThisArg)) { + leftThisArg = factory.cloneNode(leftThisArg); + ts.addEmitFlags(leftThisArg, 1536 /* EmitFlags.NoComments */); + } + rightExpression = factory.createFunctionCallCall(rightExpression, leftThisArg.kind === 106 /* SyntaxKind.SuperKeyword */ ? factory.createThis() : leftThisArg, ts.visitNodes(segment.arguments, visitor, ts.isExpression)); + } + else { + rightExpression = factory.createCallExpression(rightExpression, + /*typeArguments*/ undefined, ts.visitNodes(segment.arguments, visitor, ts.isExpression)); + } + break; + } + ts.setOriginalNode(rightExpression, segment); + } + var target = isDelete + ? factory.createConditionalExpression(createNotNullCondition(leftExpression, capturedLeft, /*invert*/ true), /*questionToken*/ undefined, factory.createTrue(), /*colonToken*/ undefined, factory.createDeleteExpression(rightExpression)) + : factory.createConditionalExpression(createNotNullCondition(leftExpression, capturedLeft, /*invert*/ true), /*questionToken*/ undefined, factory.createVoidZero(), /*colonToken*/ undefined, rightExpression); + ts.setTextRange(target, node); + return thisArg ? factory.createSyntheticReferenceExpression(target, thisArg) : target; + } + function createNotNullCondition(left, right, invert) { + return factory.createBinaryExpression(factory.createBinaryExpression(left, factory.createToken(invert ? 36 /* SyntaxKind.EqualsEqualsEqualsToken */ : 37 /* SyntaxKind.ExclamationEqualsEqualsToken */), factory.createNull()), factory.createToken(invert ? 56 /* SyntaxKind.BarBarToken */ : 55 /* SyntaxKind.AmpersandAmpersandToken */), factory.createBinaryExpression(right, factory.createToken(invert ? 36 /* SyntaxKind.EqualsEqualsEqualsToken */ : 37 /* SyntaxKind.ExclamationEqualsEqualsToken */), factory.createVoidZero())); + } + function transformNullishCoalescingExpression(node) { + var left = ts.visitNode(node.left, visitor, ts.isExpression); + var right = left; + if (!ts.isSimpleCopiableExpression(left)) { + right = factory.createTempVariable(hoistVariableDeclaration); + left = factory.createAssignment(right, left); + } + return ts.setTextRange(factory.createConditionalExpression(createNotNullCondition(left, right), + /*questionToken*/ undefined, right, + /*colonToken*/ undefined, ts.visitNode(node.right, visitor, ts.isExpression)), node); + } + function visitDeleteExpression(node) { + return ts.isOptionalChain(ts.skipParentheses(node.expression)) + ? ts.setOriginalNode(visitNonOptionalExpression(node.expression, /*captureThisArg*/ false, /*isDelete*/ true), node) + : factory.updateDeleteExpression(node, ts.visitNode(node.expression, visitor, ts.isExpression)); + } + } + ts.transformES2020 = transformES2020; +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + function transformES2021(context) { + var hoistVariableDeclaration = context.hoistVariableDeclaration, factory = context.factory; + return ts.chainBundle(context, transformSourceFile); + function transformSourceFile(node) { + if (node.isDeclarationFile) { + return node; + } + return ts.visitEachChild(node, visitor, context); + } + function visitor(node) { + if ((node.transformFlags & 16 /* TransformFlags.ContainsES2021 */) === 0) { + return node; + } + switch (node.kind) { + case 223 /* SyntaxKind.BinaryExpression */: + var binaryExpression = node; + if (ts.isLogicalOrCoalescingAssignmentExpression(binaryExpression)) { + return transformLogicalAssignment(binaryExpression); + } + // falls through + default: + return ts.visitEachChild(node, visitor, context); + } + } + function transformLogicalAssignment(binaryExpression) { + var operator = binaryExpression.operatorToken; + var nonAssignmentOperator = ts.getNonAssignmentOperatorForCompoundAssignment(operator.kind); + var left = ts.skipParentheses(ts.visitNode(binaryExpression.left, visitor, ts.isLeftHandSideExpression)); + var assignmentTarget = left; + var right = ts.skipParentheses(ts.visitNode(binaryExpression.right, visitor, ts.isExpression)); + if (ts.isAccessExpression(left)) { + var propertyAccessTargetSimpleCopiable = ts.isSimpleCopiableExpression(left.expression); + var propertyAccessTarget = propertyAccessTargetSimpleCopiable ? left.expression : + factory.createTempVariable(hoistVariableDeclaration); + var propertyAccessTargetAssignment = propertyAccessTargetSimpleCopiable ? left.expression : factory.createAssignment(propertyAccessTarget, left.expression); + if (ts.isPropertyAccessExpression(left)) { + assignmentTarget = factory.createPropertyAccessExpression(propertyAccessTarget, left.name); + left = factory.createPropertyAccessExpression(propertyAccessTargetAssignment, left.name); + } + else { + var elementAccessArgumentSimpleCopiable = ts.isSimpleCopiableExpression(left.argumentExpression); + var elementAccessArgument = elementAccessArgumentSimpleCopiable ? left.argumentExpression : + factory.createTempVariable(hoistVariableDeclaration); + assignmentTarget = factory.createElementAccessExpression(propertyAccessTarget, elementAccessArgument); + left = factory.createElementAccessExpression(propertyAccessTargetAssignment, elementAccessArgumentSimpleCopiable ? left.argumentExpression : factory.createAssignment(elementAccessArgument, left.argumentExpression)); + } + } + return factory.createBinaryExpression(left, nonAssignmentOperator, factory.createParenthesizedExpression(factory.createAssignment(assignmentTarget, right))); + } + } + ts.transformES2021 = transformES2021; +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + function transformESNext(context) { + return ts.chainBundle(context, transformSourceFile); + function transformSourceFile(node) { + if (node.isDeclarationFile) { + return node; + } + return ts.visitEachChild(node, visitor, context); + } + function visitor(node) { + if ((node.transformFlags & 4 /* TransformFlags.ContainsESNext */) === 0) { + return node; + } + switch (node.kind) { + default: + return ts.visitEachChild(node, visitor, context); + } + } + } + ts.transformESNext = transformESNext; +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + function transformJsx(context) { + var factory = context.factory, emitHelpers = context.getEmitHelperFactory; + var compilerOptions = context.getCompilerOptions(); + var currentSourceFile; + var currentFileState; + return ts.chainBundle(context, transformSourceFile); + function getCurrentFileNameExpression() { + if (currentFileState.filenameDeclaration) { + return currentFileState.filenameDeclaration.name; + } + var declaration = factory.createVariableDeclaration(factory.createUniqueName("_jsxFileName", 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */), /*exclaimationToken*/ undefined, /*type*/ undefined, factory.createStringLiteral(currentSourceFile.fileName)); + currentFileState.filenameDeclaration = declaration; + return currentFileState.filenameDeclaration.name; + } + function getJsxFactoryCalleePrimitive(isStaticChildren) { + return compilerOptions.jsx === 5 /* JsxEmit.ReactJSXDev */ ? "jsxDEV" : isStaticChildren ? "jsxs" : "jsx"; + } + function getJsxFactoryCallee(isStaticChildren) { + var type = getJsxFactoryCalleePrimitive(isStaticChildren); + return getImplicitImportForName(type); + } + function getImplicitJsxFragmentReference() { + return getImplicitImportForName("Fragment"); + } + function getImplicitImportForName(name) { + var _a, _b; + var importSource = name === "createElement" + ? currentFileState.importSpecifier + : ts.getJSXRuntimeImport(currentFileState.importSpecifier, compilerOptions); + var existing = (_b = (_a = currentFileState.utilizedImplicitRuntimeImports) === null || _a === void 0 ? void 0 : _a.get(importSource)) === null || _b === void 0 ? void 0 : _b.get(name); + if (existing) { + return existing.name; + } + if (!currentFileState.utilizedImplicitRuntimeImports) { + currentFileState.utilizedImplicitRuntimeImports = new ts.Map(); + } + var specifierSourceImports = currentFileState.utilizedImplicitRuntimeImports.get(importSource); + if (!specifierSourceImports) { + specifierSourceImports = new ts.Map(); + currentFileState.utilizedImplicitRuntimeImports.set(importSource, specifierSourceImports); + } + var generatedName = factory.createUniqueName("_".concat(name), 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */ | 64 /* GeneratedIdentifierFlags.AllowNameSubstitution */); + var specifier = factory.createImportSpecifier(/*isTypeOnly*/ false, factory.createIdentifier(name), generatedName); + generatedName.generatedImportReference = specifier; + specifierSourceImports.set(name, specifier); + return generatedName; + } + /** + * Transform JSX-specific syntax in a SourceFile. + * + * @param node A SourceFile node. + */ + function transformSourceFile(node) { + if (node.isDeclarationFile) { + return node; + } + currentSourceFile = node; + currentFileState = {}; + currentFileState.importSpecifier = ts.getJSXImplicitImportBase(compilerOptions, node); + var visited = ts.visitEachChild(node, visitor, context); + ts.addEmitHelpers(visited, context.readEmitHelpers()); + var statements = visited.statements; + if (currentFileState.filenameDeclaration) { + statements = ts.insertStatementAfterCustomPrologue(statements.slice(), factory.createVariableStatement(/*modifiers*/ undefined, factory.createVariableDeclarationList([currentFileState.filenameDeclaration], 2 /* NodeFlags.Const */))); + } + if (currentFileState.utilizedImplicitRuntimeImports) { + for (var _i = 0, _a = ts.arrayFrom(currentFileState.utilizedImplicitRuntimeImports.entries()); _i < _a.length; _i++) { + var _b = _a[_i], importSource = _b[0], importSpecifiersMap = _b[1]; + if (ts.isExternalModule(node)) { + // Add `import` statement + var importStatement = factory.createImportDeclaration(/*modifiers*/ undefined, factory.createImportClause(/*typeOnly*/ false, /*name*/ undefined, factory.createNamedImports(ts.arrayFrom(importSpecifiersMap.values()))), factory.createStringLiteral(importSource), /*assertClause*/ undefined); + ts.setParentRecursive(importStatement, /*incremental*/ false); + statements = ts.insertStatementAfterCustomPrologue(statements.slice(), importStatement); + } + else if (ts.isExternalOrCommonJsModule(node)) { + // Add `require` statement + var requireStatement = factory.createVariableStatement(/*modifiers*/ undefined, factory.createVariableDeclarationList([ + factory.createVariableDeclaration(factory.createObjectBindingPattern(ts.map(ts.arrayFrom(importSpecifiersMap.values()), function (s) { return factory.createBindingElement(/*dotdotdot*/ undefined, s.propertyName, s.name); })), + /*exclaimationToken*/ undefined, + /*type*/ undefined, factory.createCallExpression(factory.createIdentifier("require"), /*typeArguments*/ undefined, [factory.createStringLiteral(importSource)])) + ], 2 /* NodeFlags.Const */)); + ts.setParentRecursive(requireStatement, /*incremental*/ false); + statements = ts.insertStatementAfterCustomPrologue(statements.slice(), requireStatement); + } + else { + // Do nothing (script file) - consider an error in the checker? + } + } + } + if (statements !== visited.statements) { + visited = factory.updateSourceFile(visited, statements); + } + currentFileState = undefined; + return visited; + } + function visitor(node) { + if (node.transformFlags & 2 /* TransformFlags.ContainsJsx */) { + return visitorWorker(node); + } + else { + return node; + } + } + function visitorWorker(node) { + switch (node.kind) { + case 281 /* SyntaxKind.JsxElement */: + return visitJsxElement(node, /*isChild*/ false); + case 282 /* SyntaxKind.JsxSelfClosingElement */: + return visitJsxSelfClosingElement(node, /*isChild*/ false); + case 285 /* SyntaxKind.JsxFragment */: + return visitJsxFragment(node, /*isChild*/ false); + case 291 /* SyntaxKind.JsxExpression */: + return visitJsxExpression(node); + default: + return ts.visitEachChild(node, visitor, context); + } + } + function transformJsxChildToExpression(node) { + switch (node.kind) { + case 11 /* SyntaxKind.JsxText */: + return visitJsxText(node); + case 291 /* SyntaxKind.JsxExpression */: + return visitJsxExpression(node); + case 281 /* SyntaxKind.JsxElement */: + return visitJsxElement(node, /*isChild*/ true); + case 282 /* SyntaxKind.JsxSelfClosingElement */: + return visitJsxSelfClosingElement(node, /*isChild*/ true); + case 285 /* SyntaxKind.JsxFragment */: + return visitJsxFragment(node, /*isChild*/ true); + default: + return ts.Debug.failBadSyntaxKind(node); + } + } + /** + * The react jsx/jsxs transform falls back to `createElement` when an explicit `key` argument comes after a spread + */ + function hasKeyAfterPropsSpread(node) { + var spread = false; + for (var _i = 0, _a = node.attributes.properties; _i < _a.length; _i++) { + var elem = _a[_i]; + if (ts.isJsxSpreadAttribute(elem)) { + spread = true; + } + else if (spread && ts.isJsxAttribute(elem) && elem.name.escapedText === "key") { + return true; + } + } + return false; + } + function shouldUseCreateElement(node) { + return currentFileState.importSpecifier === undefined || hasKeyAfterPropsSpread(node); + } + function visitJsxElement(node, isChild) { + var tagTransform = shouldUseCreateElement(node.openingElement) ? visitJsxOpeningLikeElementCreateElement : visitJsxOpeningLikeElementJSX; + return tagTransform(node.openingElement, node.children, isChild, /*location*/ node); + } + function visitJsxSelfClosingElement(node, isChild) { + var tagTransform = shouldUseCreateElement(node) ? visitJsxOpeningLikeElementCreateElement : visitJsxOpeningLikeElementJSX; + return tagTransform(node, /*children*/ undefined, isChild, /*location*/ node); + } + function visitJsxFragment(node, isChild) { + var tagTransform = currentFileState.importSpecifier === undefined ? visitJsxOpeningFragmentCreateElement : visitJsxOpeningFragmentJSX; + return tagTransform(node.openingFragment, node.children, isChild, /*location*/ node); + } + function convertJsxChildrenToChildrenPropObject(children) { + var prop = convertJsxChildrenToChildrenPropAssignment(children); + return prop && factory.createObjectLiteralExpression([prop]); + } + function convertJsxChildrenToChildrenPropAssignment(children) { + var nonWhitespaceChildren = ts.getSemanticJsxChildren(children); + if (ts.length(nonWhitespaceChildren) === 1 && !nonWhitespaceChildren[0].dotDotDotToken) { + var result_13 = transformJsxChildToExpression(nonWhitespaceChildren[0]); + return result_13 && factory.createPropertyAssignment("children", result_13); + } + var result = ts.mapDefined(children, transformJsxChildToExpression); + return ts.length(result) ? factory.createPropertyAssignment("children", factory.createArrayLiteralExpression(result)) : undefined; + } + function visitJsxOpeningLikeElementJSX(node, children, isChild, location) { + var tagName = getTagName(node); + var childrenProp = children && children.length ? convertJsxChildrenToChildrenPropAssignment(children) : undefined; + var keyAttr = ts.find(node.attributes.properties, function (p) { return !!p.name && ts.isIdentifier(p.name) && p.name.escapedText === "key"; }); + var attrs = keyAttr ? ts.filter(node.attributes.properties, function (p) { return p !== keyAttr; }) : node.attributes.properties; + var objectProperties = ts.length(attrs) ? transformJsxAttributesToObjectProps(attrs, childrenProp) : + factory.createObjectLiteralExpression(childrenProp ? [childrenProp] : ts.emptyArray); // When there are no attributes, React wants {} + return visitJsxOpeningLikeElementOrFragmentJSX(tagName, objectProperties, keyAttr, children || ts.emptyArray, isChild, location); + } + function visitJsxOpeningLikeElementOrFragmentJSX(tagName, objectProperties, keyAttr, children, isChild, location) { + var _a; + var nonWhitespaceChildren = ts.getSemanticJsxChildren(children); + var isStaticChildren = ts.length(nonWhitespaceChildren) > 1 || !!((_a = nonWhitespaceChildren[0]) === null || _a === void 0 ? void 0 : _a.dotDotDotToken); + var args = [tagName, objectProperties]; + // function jsx(type, config, maybeKey) {} + // "maybeKey" is optional. It is acceptable to use "_jsx" without a third argument + if (keyAttr) { + args.push(transformJsxAttributeInitializer(keyAttr.initializer)); + } + if (compilerOptions.jsx === 5 /* JsxEmit.ReactJSXDev */) { + var originalFile = ts.getOriginalNode(currentSourceFile); + if (originalFile && ts.isSourceFile(originalFile)) { + // "maybeKey" has to be replaced with "void 0" to not break the jsxDEV signature + if (keyAttr === undefined) { + args.push(factory.createVoidZero()); + } + // isStaticChildren development flag + args.push(isStaticChildren ? factory.createTrue() : factory.createFalse()); + // __source development flag + var lineCol = ts.getLineAndCharacterOfPosition(originalFile, location.pos); + args.push(factory.createObjectLiteralExpression([ + factory.createPropertyAssignment("fileName", getCurrentFileNameExpression()), + factory.createPropertyAssignment("lineNumber", factory.createNumericLiteral(lineCol.line + 1)), + factory.createPropertyAssignment("columnNumber", factory.createNumericLiteral(lineCol.character + 1)) + ])); + // __self development flag + args.push(factory.createThis()); + } + } + var element = ts.setTextRange(factory.createCallExpression(getJsxFactoryCallee(isStaticChildren), /*typeArguments*/ undefined, args), location); + if (isChild) { + ts.startOnNewLine(element); + } + return element; + } + function visitJsxOpeningLikeElementCreateElement(node, children, isChild, location) { + var tagName = getTagName(node); + var attrs = node.attributes.properties; + var objectProperties = ts.length(attrs) ? transformJsxAttributesToObjectProps(attrs) : + factory.createNull(); // When there are no attributes, React wants "null" + var callee = currentFileState.importSpecifier === undefined + ? ts.createJsxFactoryExpression(factory, context.getEmitResolver().getJsxFactoryEntity(currentSourceFile), compilerOptions.reactNamespace, // TODO: GH#18217 + node) + : getImplicitImportForName("createElement"); + var element = ts.createExpressionForJsxElement(factory, callee, tagName, objectProperties, ts.mapDefined(children, transformJsxChildToExpression), location); + if (isChild) { + ts.startOnNewLine(element); + } + return element; + } + function visitJsxOpeningFragmentJSX(_node, children, isChild, location) { + var childrenProps; + if (children && children.length) { + var result = convertJsxChildrenToChildrenPropObject(children); + if (result) { + childrenProps = result; + } + } + return visitJsxOpeningLikeElementOrFragmentJSX(getImplicitJsxFragmentReference(), childrenProps || factory.createObjectLiteralExpression([]), + /*keyAttr*/ undefined, children, isChild, location); + } + function visitJsxOpeningFragmentCreateElement(node, children, isChild, location) { + var element = ts.createExpressionForJsxFragment(factory, context.getEmitResolver().getJsxFactoryEntity(currentSourceFile), context.getEmitResolver().getJsxFragmentFactoryEntity(currentSourceFile), compilerOptions.reactNamespace, // TODO: GH#18217 + ts.mapDefined(children, transformJsxChildToExpression), node, location); + if (isChild) { + ts.startOnNewLine(element); + } + return element; + } + function transformJsxSpreadAttributeToSpreadAssignment(node) { + return factory.createSpreadAssignment(ts.visitNode(node.expression, visitor, ts.isExpression)); + } + function transformJsxAttributesToObjectProps(attrs, children) { + var target = ts.getEmitScriptTarget(compilerOptions); + return target && target >= 5 /* ScriptTarget.ES2018 */ ? factory.createObjectLiteralExpression(transformJsxAttributesToProps(attrs, children)) : + transformJsxAttributesToExpression(attrs, children); + } + function transformJsxAttributesToProps(attrs, children) { + var props = ts.flatten(ts.spanMap(attrs, ts.isJsxSpreadAttribute, function (attrs, isSpread) { + return ts.map(attrs, function (attr) { return isSpread ? transformJsxSpreadAttributeToSpreadAssignment(attr) : transformJsxAttributeToObjectLiteralElement(attr); }); + })); + if (children) { + props.push(children); + } + return props; + } + function transformJsxAttributesToExpression(attrs, children) { + // Map spans of JsxAttribute nodes into object literals and spans + // of JsxSpreadAttribute nodes into expressions. + var expressions = ts.flatten(ts.spanMap(attrs, ts.isJsxSpreadAttribute, function (attrs, isSpread) { return isSpread + ? ts.map(attrs, transformJsxSpreadAttributeToExpression) + : factory.createObjectLiteralExpression(ts.map(attrs, transformJsxAttributeToObjectLiteralElement)); })); + if (ts.isJsxSpreadAttribute(attrs[0])) { + // We must always emit at least one object literal before a spread + // argument.factory.createObjectLiteral + expressions.unshift(factory.createObjectLiteralExpression()); + } + if (children) { + expressions.push(factory.createObjectLiteralExpression([children])); + } + return ts.singleOrUndefined(expressions) || emitHelpers().createAssignHelper(expressions); + } + function transformJsxSpreadAttributeToExpression(node) { + return ts.visitNode(node.expression, visitor, ts.isExpression); + } + function transformJsxAttributeToObjectLiteralElement(node) { + var name = getAttributeName(node); + var expression = transformJsxAttributeInitializer(node.initializer); + return factory.createPropertyAssignment(name, expression); + } + function transformJsxAttributeInitializer(node) { + if (node === undefined) { + return factory.createTrue(); + } + if (node.kind === 10 /* SyntaxKind.StringLiteral */) { + // Always recreate the literal to escape any escape sequences or newlines which may be in the original jsx string and which + // Need to be escaped to be handled correctly in a normal string + var singleQuote = node.singleQuote !== undefined ? node.singleQuote : !ts.isStringDoubleQuoted(node, currentSourceFile); + var literal = factory.createStringLiteral(tryDecodeEntities(node.text) || node.text, singleQuote); + return ts.setTextRange(literal, node); + } + if (node.kind === 291 /* SyntaxKind.JsxExpression */) { + if (node.expression === undefined) { + return factory.createTrue(); + } + return ts.visitNode(node.expression, visitor, ts.isExpression); + } + if (ts.isJsxElement(node)) { + return visitJsxElement(node, /*isChild*/ false); + } + if (ts.isJsxSelfClosingElement(node)) { + return visitJsxSelfClosingElement(node, /*isChild*/ false); + } + if (ts.isJsxFragment(node)) { + return visitJsxFragment(node, /*isChild*/ false); + } + return ts.Debug.failBadSyntaxKind(node); + } + function visitJsxText(node) { + var fixed = fixupWhitespaceAndDecodeEntities(node.text); + return fixed === undefined ? undefined : factory.createStringLiteral(fixed); + } + /** + * JSX trims whitespace at the end and beginning of lines, except that the + * start/end of a tag is considered a start/end of a line only if that line is + * on the same line as the closing tag. See examples in + * tests/cases/conformance/jsx/tsxReactEmitWhitespace.tsx + * See also https://www.w3.org/TR/html4/struct/text.html#h-9.1 and https://www.w3.org/TR/CSS2/text.html#white-space-model + * + * An equivalent algorithm would be: + * - If there is only one line, return it. + * - If there is only whitespace (but multiple lines), return `undefined`. + * - Split the text into lines. + * - 'trimRight' the first line, 'trimLeft' the last line, 'trim' middle lines. + * - Decode entities on each line (individually). + * - Remove empty lines and join the rest with " ". + */ + function fixupWhitespaceAndDecodeEntities(text) { + var acc; + // First non-whitespace character on this line. + var firstNonWhitespace = 0; + // Last non-whitespace character on this line. + var lastNonWhitespace = -1; + // These initial values are special because the first line is: + // firstNonWhitespace = 0 to indicate that we want leading whitsepace, + // but lastNonWhitespace = -1 as a special flag to indicate that we *don't* include the line if it's all whitespace. + for (var i = 0; i < text.length; i++) { + var c = text.charCodeAt(i); + if (ts.isLineBreak(c)) { + // If we've seen any non-whitespace characters on this line, add the 'trim' of the line. + // (lastNonWhitespace === -1 is a special flag to detect whether the first line is all whitespace.) + if (firstNonWhitespace !== -1 && lastNonWhitespace !== -1) { + acc = addLineOfJsxText(acc, text.substr(firstNonWhitespace, lastNonWhitespace - firstNonWhitespace + 1)); + } + // Reset firstNonWhitespace for the next line. + // Don't bother to reset lastNonWhitespace because we ignore it if firstNonWhitespace = -1. + firstNonWhitespace = -1; + } + else if (!ts.isWhiteSpaceSingleLine(c)) { + lastNonWhitespace = i; + if (firstNonWhitespace === -1) { + firstNonWhitespace = i; + } + } + } + return firstNonWhitespace !== -1 + // Last line had a non-whitespace character. Emit the 'trimLeft', meaning keep trailing whitespace. + ? addLineOfJsxText(acc, text.substr(firstNonWhitespace)) + // Last line was all whitespace, so ignore it + : acc; + } + function addLineOfJsxText(acc, trimmedLine) { + // We do not escape the string here as that is handled by the printer + // when it emits the literal. We do, however, need to decode JSX entities. + var decoded = decodeEntities(trimmedLine); + return acc === undefined ? decoded : acc + " " + decoded; + } + /** + * Replace entities like " ", "{", and "�" with the characters they encode. + * See https://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references + */ + function decodeEntities(text) { + return text.replace(/&((#((\d+)|x([\da-fA-F]+)))|(\w+));/g, function (match, _all, _number, _digits, decimal, hex, word) { + if (decimal) { + return ts.utf16EncodeAsString(parseInt(decimal, 10)); + } + else if (hex) { + return ts.utf16EncodeAsString(parseInt(hex, 16)); + } + else { + var ch = entities.get(word); + // If this is not a valid entity, then just use `match` (replace it with itself, i.e. don't replace) + return ch ? ts.utf16EncodeAsString(ch) : match; + } + }); + } + /** Like `decodeEntities` but returns `undefined` if there were no entities to decode. */ + function tryDecodeEntities(text) { + var decoded = decodeEntities(text); + return decoded === text ? undefined : decoded; + } + function getTagName(node) { + if (node.kind === 281 /* SyntaxKind.JsxElement */) { + return getTagName(node.openingElement); + } + else { + var name = node.tagName; + if (ts.isIdentifier(name) && ts.isIntrinsicJsxName(name.escapedText)) { + return factory.createStringLiteral(ts.idText(name)); + } + else { + return ts.createExpressionFromEntityName(factory, name); + } + } + } + /** + * Emit an attribute name, which is quoted if it needs to be quoted. Because + * these emit into an object literal property name, we don't need to be worried + * about keywords, just non-identifier characters + */ + function getAttributeName(node) { + var name = node.name; + var text = ts.idText(name); + if (/^[A-Za-z_]\w*$/.test(text)) { + return name; + } + else { + return factory.createStringLiteral(text); + } + } + function visitJsxExpression(node) { + var expression = ts.visitNode(node.expression, visitor, ts.isExpression); + return node.dotDotDotToken ? factory.createSpreadElement(expression) : expression; + } + } + ts.transformJsx = transformJsx; + var entities = new ts.Map(ts.getEntries({ + quot: 0x0022, + amp: 0x0026, + apos: 0x0027, + lt: 0x003C, + gt: 0x003E, + nbsp: 0x00A0, + iexcl: 0x00A1, + cent: 0x00A2, + pound: 0x00A3, + curren: 0x00A4, + yen: 0x00A5, + brvbar: 0x00A6, + sect: 0x00A7, + uml: 0x00A8, + copy: 0x00A9, + ordf: 0x00AA, + laquo: 0x00AB, + not: 0x00AC, + shy: 0x00AD, + reg: 0x00AE, + macr: 0x00AF, + deg: 0x00B0, + plusmn: 0x00B1, + sup2: 0x00B2, + sup3: 0x00B3, + acute: 0x00B4, + micro: 0x00B5, + para: 0x00B6, + middot: 0x00B7, + cedil: 0x00B8, + sup1: 0x00B9, + ordm: 0x00BA, + raquo: 0x00BB, + frac14: 0x00BC, + frac12: 0x00BD, + frac34: 0x00BE, + iquest: 0x00BF, + Agrave: 0x00C0, + Aacute: 0x00C1, + Acirc: 0x00C2, + Atilde: 0x00C3, + Auml: 0x00C4, + Aring: 0x00C5, + AElig: 0x00C6, + Ccedil: 0x00C7, + Egrave: 0x00C8, + Eacute: 0x00C9, + Ecirc: 0x00CA, + Euml: 0x00CB, + Igrave: 0x00CC, + Iacute: 0x00CD, + Icirc: 0x00CE, + Iuml: 0x00CF, + ETH: 0x00D0, + Ntilde: 0x00D1, + Ograve: 0x00D2, + Oacute: 0x00D3, + Ocirc: 0x00D4, + Otilde: 0x00D5, + Ouml: 0x00D6, + times: 0x00D7, + Oslash: 0x00D8, + Ugrave: 0x00D9, + Uacute: 0x00DA, + Ucirc: 0x00DB, + Uuml: 0x00DC, + Yacute: 0x00DD, + THORN: 0x00DE, + szlig: 0x00DF, + agrave: 0x00E0, + aacute: 0x00E1, + acirc: 0x00E2, + atilde: 0x00E3, + auml: 0x00E4, + aring: 0x00E5, + aelig: 0x00E6, + ccedil: 0x00E7, + egrave: 0x00E8, + eacute: 0x00E9, + ecirc: 0x00EA, + euml: 0x00EB, + igrave: 0x00EC, + iacute: 0x00ED, + icirc: 0x00EE, + iuml: 0x00EF, + eth: 0x00F0, + ntilde: 0x00F1, + ograve: 0x00F2, + oacute: 0x00F3, + ocirc: 0x00F4, + otilde: 0x00F5, + ouml: 0x00F6, + divide: 0x00F7, + oslash: 0x00F8, + ugrave: 0x00F9, + uacute: 0x00FA, + ucirc: 0x00FB, + uuml: 0x00FC, + yacute: 0x00FD, + thorn: 0x00FE, + yuml: 0x00FF, + OElig: 0x0152, + oelig: 0x0153, + Scaron: 0x0160, + scaron: 0x0161, + Yuml: 0x0178, + fnof: 0x0192, + circ: 0x02C6, + tilde: 0x02DC, + Alpha: 0x0391, + Beta: 0x0392, + Gamma: 0x0393, + Delta: 0x0394, + Epsilon: 0x0395, + Zeta: 0x0396, + Eta: 0x0397, + Theta: 0x0398, + Iota: 0x0399, + Kappa: 0x039A, + Lambda: 0x039B, + Mu: 0x039C, + Nu: 0x039D, + Xi: 0x039E, + Omicron: 0x039F, + Pi: 0x03A0, + Rho: 0x03A1, + Sigma: 0x03A3, + Tau: 0x03A4, + Upsilon: 0x03A5, + Phi: 0x03A6, + Chi: 0x03A7, + Psi: 0x03A8, + Omega: 0x03A9, + alpha: 0x03B1, + beta: 0x03B2, + gamma: 0x03B3, + delta: 0x03B4, + epsilon: 0x03B5, + zeta: 0x03B6, + eta: 0x03B7, + theta: 0x03B8, + iota: 0x03B9, + kappa: 0x03BA, + lambda: 0x03BB, + mu: 0x03BC, + nu: 0x03BD, + xi: 0x03BE, + omicron: 0x03BF, + pi: 0x03C0, + rho: 0x03C1, + sigmaf: 0x03C2, + sigma: 0x03C3, + tau: 0x03C4, + upsilon: 0x03C5, + phi: 0x03C6, + chi: 0x03C7, + psi: 0x03C8, + omega: 0x03C9, + thetasym: 0x03D1, + upsih: 0x03D2, + piv: 0x03D6, + ensp: 0x2002, + emsp: 0x2003, + thinsp: 0x2009, + zwnj: 0x200C, + zwj: 0x200D, + lrm: 0x200E, + rlm: 0x200F, + ndash: 0x2013, + mdash: 0x2014, + lsquo: 0x2018, + rsquo: 0x2019, + sbquo: 0x201A, + ldquo: 0x201C, + rdquo: 0x201D, + bdquo: 0x201E, + dagger: 0x2020, + Dagger: 0x2021, + bull: 0x2022, + hellip: 0x2026, + permil: 0x2030, + prime: 0x2032, + Prime: 0x2033, + lsaquo: 0x2039, + rsaquo: 0x203A, + oline: 0x203E, + frasl: 0x2044, + euro: 0x20AC, + image: 0x2111, + weierp: 0x2118, + real: 0x211C, + trade: 0x2122, + alefsym: 0x2135, + larr: 0x2190, + uarr: 0x2191, + rarr: 0x2192, + darr: 0x2193, + harr: 0x2194, + crarr: 0x21B5, + lArr: 0x21D0, + uArr: 0x21D1, + rArr: 0x21D2, + dArr: 0x21D3, + hArr: 0x21D4, + forall: 0x2200, + part: 0x2202, + exist: 0x2203, + empty: 0x2205, + nabla: 0x2207, + isin: 0x2208, + notin: 0x2209, + ni: 0x220B, + prod: 0x220F, + sum: 0x2211, + minus: 0x2212, + lowast: 0x2217, + radic: 0x221A, + prop: 0x221D, + infin: 0x221E, + ang: 0x2220, + and: 0x2227, + or: 0x2228, + cap: 0x2229, + cup: 0x222A, + int: 0x222B, + there4: 0x2234, + sim: 0x223C, + cong: 0x2245, + asymp: 0x2248, + ne: 0x2260, + equiv: 0x2261, + le: 0x2264, + ge: 0x2265, + sub: 0x2282, + sup: 0x2283, + nsub: 0x2284, + sube: 0x2286, + supe: 0x2287, + oplus: 0x2295, + otimes: 0x2297, + perp: 0x22A5, + sdot: 0x22C5, + lceil: 0x2308, + rceil: 0x2309, + lfloor: 0x230A, + rfloor: 0x230B, + lang: 0x2329, + rang: 0x232A, + loz: 0x25CA, + spades: 0x2660, + clubs: 0x2663, + hearts: 0x2665, + diams: 0x2666 + })); +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + function transformES2016(context) { + var factory = context.factory, hoistVariableDeclaration = context.hoistVariableDeclaration; + return ts.chainBundle(context, transformSourceFile); + function transformSourceFile(node) { + if (node.isDeclarationFile) { + return node; + } + return ts.visitEachChild(node, visitor, context); + } + function visitor(node) { + if ((node.transformFlags & 512 /* TransformFlags.ContainsES2016 */) === 0) { + return node; + } + switch (node.kind) { + case 223 /* SyntaxKind.BinaryExpression */: + return visitBinaryExpression(node); + default: + return ts.visitEachChild(node, visitor, context); + } + } + function visitBinaryExpression(node) { + switch (node.operatorToken.kind) { + case 67 /* SyntaxKind.AsteriskAsteriskEqualsToken */: + return visitExponentiationAssignmentExpression(node); + case 42 /* SyntaxKind.AsteriskAsteriskToken */: + return visitExponentiationExpression(node); + default: + return ts.visitEachChild(node, visitor, context); + } + } + function visitExponentiationAssignmentExpression(node) { + var target; + var value; + var left = ts.visitNode(node.left, visitor, ts.isExpression); + var right = ts.visitNode(node.right, visitor, ts.isExpression); + if (ts.isElementAccessExpression(left)) { + // Transforms `a[x] **= b` into `(_a = a)[_x = x] = Math.pow(_a[_x], b)` + var expressionTemp = factory.createTempVariable(hoistVariableDeclaration); + var argumentExpressionTemp = factory.createTempVariable(hoistVariableDeclaration); + target = ts.setTextRange(factory.createElementAccessExpression(ts.setTextRange(factory.createAssignment(expressionTemp, left.expression), left.expression), ts.setTextRange(factory.createAssignment(argumentExpressionTemp, left.argumentExpression), left.argumentExpression)), left); + value = ts.setTextRange(factory.createElementAccessExpression(expressionTemp, argumentExpressionTemp), left); + } + else if (ts.isPropertyAccessExpression(left)) { + // Transforms `a.x **= b` into `(_a = a).x = Math.pow(_a.x, b)` + var expressionTemp = factory.createTempVariable(hoistVariableDeclaration); + target = ts.setTextRange(factory.createPropertyAccessExpression(ts.setTextRange(factory.createAssignment(expressionTemp, left.expression), left.expression), left.name), left); + value = ts.setTextRange(factory.createPropertyAccessExpression(expressionTemp, left.name), left); + } + else { + // Transforms `a **= b` into `a = Math.pow(a, b)` + target = left; + value = left; + } + return ts.setTextRange(factory.createAssignment(target, ts.setTextRange(factory.createGlobalMethodCall("Math", "pow", [value, right]), node)), node); + } + function visitExponentiationExpression(node) { + // Transforms `a ** b` into `Math.pow(a, b)` + var left = ts.visitNode(node.left, visitor, ts.isExpression); + var right = ts.visitNode(node.right, visitor, ts.isExpression); + return ts.setTextRange(factory.createGlobalMethodCall("Math", "pow", [left, right]), node); + } + } + ts.transformES2016 = transformES2016; +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + var ES2015SubstitutionFlags; + (function (ES2015SubstitutionFlags) { + /** Enables substitutions for captured `this` */ + ES2015SubstitutionFlags[ES2015SubstitutionFlags["CapturedThis"] = 1] = "CapturedThis"; + /** Enables substitutions for block-scoped bindings. */ + ES2015SubstitutionFlags[ES2015SubstitutionFlags["BlockScopedBindings"] = 2] = "BlockScopedBindings"; + })(ES2015SubstitutionFlags || (ES2015SubstitutionFlags = {})); + var LoopOutParameterFlags; + (function (LoopOutParameterFlags) { + LoopOutParameterFlags[LoopOutParameterFlags["Body"] = 1] = "Body"; + LoopOutParameterFlags[LoopOutParameterFlags["Initializer"] = 2] = "Initializer"; + })(LoopOutParameterFlags || (LoopOutParameterFlags = {})); + var CopyDirection; + (function (CopyDirection) { + CopyDirection[CopyDirection["ToOriginal"] = 0] = "ToOriginal"; + CopyDirection[CopyDirection["ToOutParameter"] = 1] = "ToOutParameter"; + })(CopyDirection || (CopyDirection = {})); + var Jump; + (function (Jump) { + Jump[Jump["Break"] = 2] = "Break"; + Jump[Jump["Continue"] = 4] = "Continue"; + Jump[Jump["Return"] = 8] = "Return"; + })(Jump || (Jump = {})); + // Facts we track as we traverse the tree + var HierarchyFacts; + (function (HierarchyFacts) { + HierarchyFacts[HierarchyFacts["None"] = 0] = "None"; + // + // Ancestor facts + // + HierarchyFacts[HierarchyFacts["Function"] = 1] = "Function"; + HierarchyFacts[HierarchyFacts["ArrowFunction"] = 2] = "ArrowFunction"; + HierarchyFacts[HierarchyFacts["AsyncFunctionBody"] = 4] = "AsyncFunctionBody"; + HierarchyFacts[HierarchyFacts["NonStaticClassElement"] = 8] = "NonStaticClassElement"; + HierarchyFacts[HierarchyFacts["CapturesThis"] = 16] = "CapturesThis"; + HierarchyFacts[HierarchyFacts["ExportedVariableStatement"] = 32] = "ExportedVariableStatement"; + HierarchyFacts[HierarchyFacts["TopLevel"] = 64] = "TopLevel"; + HierarchyFacts[HierarchyFacts["Block"] = 128] = "Block"; + HierarchyFacts[HierarchyFacts["IterationStatement"] = 256] = "IterationStatement"; + HierarchyFacts[HierarchyFacts["IterationStatementBlock"] = 512] = "IterationStatementBlock"; + HierarchyFacts[HierarchyFacts["IterationContainer"] = 1024] = "IterationContainer"; + HierarchyFacts[HierarchyFacts["ForStatement"] = 2048] = "ForStatement"; + HierarchyFacts[HierarchyFacts["ForInOrForOfStatement"] = 4096] = "ForInOrForOfStatement"; + HierarchyFacts[HierarchyFacts["ConstructorWithCapturedSuper"] = 8192] = "ConstructorWithCapturedSuper"; + HierarchyFacts[HierarchyFacts["StaticInitializer"] = 16384] = "StaticInitializer"; + // NOTE: do not add more ancestor flags without also updating AncestorFactsMask below. + // NOTE: when adding a new ancestor flag, be sure to update the subtree flags below. + // + // Ancestor masks + // + HierarchyFacts[HierarchyFacts["AncestorFactsMask"] = 32767] = "AncestorFactsMask"; + // We are always in *some* kind of block scope, but only specific block-scope containers are + // top-level or Blocks. + HierarchyFacts[HierarchyFacts["BlockScopeIncludes"] = 0] = "BlockScopeIncludes"; + HierarchyFacts[HierarchyFacts["BlockScopeExcludes"] = 7104] = "BlockScopeExcludes"; + // A source file is a top-level block scope. + HierarchyFacts[HierarchyFacts["SourceFileIncludes"] = 64] = "SourceFileIncludes"; + HierarchyFacts[HierarchyFacts["SourceFileExcludes"] = 8064] = "SourceFileExcludes"; + // Functions, methods, and accessors are both new lexical scopes and new block scopes. + HierarchyFacts[HierarchyFacts["FunctionIncludes"] = 65] = "FunctionIncludes"; + HierarchyFacts[HierarchyFacts["FunctionExcludes"] = 32670] = "FunctionExcludes"; + HierarchyFacts[HierarchyFacts["AsyncFunctionBodyIncludes"] = 69] = "AsyncFunctionBodyIncludes"; + HierarchyFacts[HierarchyFacts["AsyncFunctionBodyExcludes"] = 32662] = "AsyncFunctionBodyExcludes"; + // Arrow functions are lexically scoped to their container, but are new block scopes. + HierarchyFacts[HierarchyFacts["ArrowFunctionIncludes"] = 66] = "ArrowFunctionIncludes"; + HierarchyFacts[HierarchyFacts["ArrowFunctionExcludes"] = 15232] = "ArrowFunctionExcludes"; + // Constructors are both new lexical scopes and new block scopes. Constructors are also + // always considered non-static members of a class. + HierarchyFacts[HierarchyFacts["ConstructorIncludes"] = 73] = "ConstructorIncludes"; + HierarchyFacts[HierarchyFacts["ConstructorExcludes"] = 32662] = "ConstructorExcludes"; + // 'do' and 'while' statements are not block scopes. We track that the subtree is contained + // within an IterationStatement to indicate whether the embedded statement is an + // IterationStatementBlock. + HierarchyFacts[HierarchyFacts["DoOrWhileStatementIncludes"] = 1280] = "DoOrWhileStatementIncludes"; + HierarchyFacts[HierarchyFacts["DoOrWhileStatementExcludes"] = 0] = "DoOrWhileStatementExcludes"; + // 'for' statements are new block scopes and have special handling for 'let' declarations. + HierarchyFacts[HierarchyFacts["ForStatementIncludes"] = 3328] = "ForStatementIncludes"; + HierarchyFacts[HierarchyFacts["ForStatementExcludes"] = 5056] = "ForStatementExcludes"; + // 'for-in' and 'for-of' statements are new block scopes and have special handling for + // 'let' declarations. + HierarchyFacts[HierarchyFacts["ForInOrForOfStatementIncludes"] = 5376] = "ForInOrForOfStatementIncludes"; + HierarchyFacts[HierarchyFacts["ForInOrForOfStatementExcludes"] = 3008] = "ForInOrForOfStatementExcludes"; + // Blocks (other than function bodies) are new block scopes. + HierarchyFacts[HierarchyFacts["BlockIncludes"] = 128] = "BlockIncludes"; + HierarchyFacts[HierarchyFacts["BlockExcludes"] = 6976] = "BlockExcludes"; + HierarchyFacts[HierarchyFacts["IterationStatementBlockIncludes"] = 512] = "IterationStatementBlockIncludes"; + HierarchyFacts[HierarchyFacts["IterationStatementBlockExcludes"] = 7104] = "IterationStatementBlockExcludes"; + HierarchyFacts[HierarchyFacts["StaticInitializerIncludes"] = 16449] = "StaticInitializerIncludes"; + HierarchyFacts[HierarchyFacts["StaticInitializerExcludes"] = 32670] = "StaticInitializerExcludes"; + // + // Subtree facts + // + HierarchyFacts[HierarchyFacts["NewTarget"] = 32768] = "NewTarget"; + HierarchyFacts[HierarchyFacts["CapturedLexicalThis"] = 65536] = "CapturedLexicalThis"; + // + // Subtree masks + // + HierarchyFacts[HierarchyFacts["SubtreeFactsMask"] = -32768] = "SubtreeFactsMask"; + HierarchyFacts[HierarchyFacts["ArrowFunctionSubtreeExcludes"] = 0] = "ArrowFunctionSubtreeExcludes"; + HierarchyFacts[HierarchyFacts["FunctionSubtreeExcludes"] = 98304] = "FunctionSubtreeExcludes"; + })(HierarchyFacts || (HierarchyFacts = {})); + var SpreadSegmentKind; + (function (SpreadSegmentKind) { + SpreadSegmentKind[SpreadSegmentKind["None"] = 0] = "None"; + SpreadSegmentKind[SpreadSegmentKind["UnpackedSpread"] = 1] = "UnpackedSpread"; + SpreadSegmentKind[SpreadSegmentKind["PackedSpread"] = 2] = "PackedSpread"; + })(SpreadSegmentKind || (SpreadSegmentKind = {})); + function createSpreadSegment(kind, expression) { + return { kind: kind, expression: expression }; + } + function transformES2015(context) { + var factory = context.factory, emitHelpers = context.getEmitHelperFactory, startLexicalEnvironment = context.startLexicalEnvironment, resumeLexicalEnvironment = context.resumeLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistVariableDeclaration = context.hoistVariableDeclaration; + var compilerOptions = context.getCompilerOptions(); + var resolver = context.getEmitResolver(); + var previousOnSubstituteNode = context.onSubstituteNode; + var previousOnEmitNode = context.onEmitNode; + context.onEmitNode = onEmitNode; + context.onSubstituteNode = onSubstituteNode; + var currentSourceFile; + var currentText; + var hierarchyFacts; + var taggedTemplateStringDeclarations; + function recordTaggedTemplateString(temp) { + taggedTemplateStringDeclarations = ts.append(taggedTemplateStringDeclarations, factory.createVariableDeclaration(temp)); + } + /** + * Used to track if we are emitting body of the converted loop + */ + var convertedLoopState; + /** + * Keeps track of whether substitutions have been enabled for specific cases. + * They are persisted between each SourceFile transformation and should not + * be reset. + */ + var enabledSubstitutions; + return ts.chainBundle(context, transformSourceFile); + function transformSourceFile(node) { + if (node.isDeclarationFile) { + return node; + } + currentSourceFile = node; + currentText = node.text; + var visited = visitSourceFile(node); + ts.addEmitHelpers(visited, context.readEmitHelpers()); + currentSourceFile = undefined; + currentText = undefined; + taggedTemplateStringDeclarations = undefined; + hierarchyFacts = 0 /* HierarchyFacts.None */; + return visited; + } + /** + * Sets the `HierarchyFacts` for this node prior to visiting this node's subtree, returning the facts set prior to modification. + * @param excludeFacts The existing `HierarchyFacts` to reset before visiting the subtree. + * @param includeFacts The new `HierarchyFacts` to set before visiting the subtree. + */ + function enterSubtree(excludeFacts, includeFacts) { + var ancestorFacts = hierarchyFacts; + hierarchyFacts = (hierarchyFacts & ~excludeFacts | includeFacts) & 32767 /* HierarchyFacts.AncestorFactsMask */; + return ancestorFacts; + } + /** + * Restores the `HierarchyFacts` for this node's ancestor after visiting this node's + * subtree, propagating specific facts from the subtree. + * @param ancestorFacts The `HierarchyFacts` of the ancestor to restore after visiting the subtree. + * @param excludeFacts The existing `HierarchyFacts` of the subtree that should not be propagated. + * @param includeFacts The new `HierarchyFacts` of the subtree that should be propagated. + */ + function exitSubtree(ancestorFacts, excludeFacts, includeFacts) { + hierarchyFacts = (hierarchyFacts & ~excludeFacts | includeFacts) & -32768 /* HierarchyFacts.SubtreeFactsMask */ | ancestorFacts; + } + function isReturnVoidStatementInConstructorWithCapturedSuper(node) { + return (hierarchyFacts & 8192 /* HierarchyFacts.ConstructorWithCapturedSuper */) !== 0 + && node.kind === 250 /* SyntaxKind.ReturnStatement */ + && !node.expression; + } + function isOrMayContainReturnCompletion(node) { + return node.transformFlags & 4194304 /* TransformFlags.ContainsHoistedDeclarationOrCompletion */ + && (ts.isReturnStatement(node) + || ts.isIfStatement(node) + || ts.isWithStatement(node) + || ts.isSwitchStatement(node) + || ts.isCaseBlock(node) + || ts.isCaseClause(node) + || ts.isDefaultClause(node) + || ts.isTryStatement(node) + || ts.isCatchClause(node) + || ts.isLabeledStatement(node) + || ts.isIterationStatement(node, /*lookInLabeledStatements*/ false) + || ts.isBlock(node)); + } + function shouldVisitNode(node) { + return (node.transformFlags & 1024 /* TransformFlags.ContainsES2015 */) !== 0 + || convertedLoopState !== undefined + || (hierarchyFacts & 8192 /* HierarchyFacts.ConstructorWithCapturedSuper */ && isOrMayContainReturnCompletion(node)) + || (ts.isIterationStatement(node, /*lookInLabeledStatements*/ false) && shouldConvertIterationStatement(node)) + || (ts.getEmitFlags(node) & 33554432 /* EmitFlags.TypeScriptClassWrapper */) !== 0; + } + function visitor(node) { + return shouldVisitNode(node) ? visitorWorker(node, /*expressionResultIsUnused*/ false) : node; + } + function visitorWithUnusedExpressionResult(node) { + return shouldVisitNode(node) ? visitorWorker(node, /*expressionResultIsUnused*/ true) : node; + } + function classWrapperStatementVisitor(node) { + if (shouldVisitNode(node)) { + var original = ts.getOriginalNode(node); + if (ts.isPropertyDeclaration(original) && ts.hasStaticModifier(original)) { + var ancestorFacts = enterSubtree(32670 /* HierarchyFacts.StaticInitializerExcludes */, 16449 /* HierarchyFacts.StaticInitializerIncludes */); + var result = visitorWorker(node, /*expressionResultIsUnused*/ false); + exitSubtree(ancestorFacts, 98304 /* HierarchyFacts.FunctionSubtreeExcludes */, 0 /* HierarchyFacts.None */); + return result; + } + return visitorWorker(node, /*expressionResultIsUnused*/ false); + } + return node; + } + function callExpressionVisitor(node) { + if (node.kind === 106 /* SyntaxKind.SuperKeyword */) { + return visitSuperKeyword(/*isExpressionOfCall*/ true); + } + return visitor(node); + } + function visitorWorker(node, expressionResultIsUnused) { + switch (node.kind) { + case 124 /* SyntaxKind.StaticKeyword */: + return undefined; // elide static keyword + case 260 /* SyntaxKind.ClassDeclaration */: + return visitClassDeclaration(node); + case 228 /* SyntaxKind.ClassExpression */: + return visitClassExpression(node); + case 166 /* SyntaxKind.Parameter */: + return visitParameter(node); + case 259 /* SyntaxKind.FunctionDeclaration */: + return visitFunctionDeclaration(node); + case 216 /* SyntaxKind.ArrowFunction */: + return visitArrowFunction(node); + case 215 /* SyntaxKind.FunctionExpression */: + return visitFunctionExpression(node); + case 257 /* SyntaxKind.VariableDeclaration */: + return visitVariableDeclaration(node); + case 79 /* SyntaxKind.Identifier */: + return visitIdentifier(node); + case 258 /* SyntaxKind.VariableDeclarationList */: + return visitVariableDeclarationList(node); + case 252 /* SyntaxKind.SwitchStatement */: + return visitSwitchStatement(node); + case 266 /* SyntaxKind.CaseBlock */: + return visitCaseBlock(node); + case 238 /* SyntaxKind.Block */: + return visitBlock(node, /*isFunctionBody*/ false); + case 249 /* SyntaxKind.BreakStatement */: + case 248 /* SyntaxKind.ContinueStatement */: + return visitBreakOrContinueStatement(node); + case 253 /* SyntaxKind.LabeledStatement */: + return visitLabeledStatement(node); + case 243 /* SyntaxKind.DoStatement */: + case 244 /* SyntaxKind.WhileStatement */: + return visitDoOrWhileStatement(node, /*outermostLabeledStatement*/ undefined); + case 245 /* SyntaxKind.ForStatement */: + return visitForStatement(node, /*outermostLabeledStatement*/ undefined); + case 246 /* SyntaxKind.ForInStatement */: + return visitForInStatement(node, /*outermostLabeledStatement*/ undefined); + case 247 /* SyntaxKind.ForOfStatement */: + return visitForOfStatement(node, /*outermostLabeledStatement*/ undefined); + case 241 /* SyntaxKind.ExpressionStatement */: + return visitExpressionStatement(node); + case 207 /* SyntaxKind.ObjectLiteralExpression */: + return visitObjectLiteralExpression(node); + case 295 /* SyntaxKind.CatchClause */: + return visitCatchClause(node); + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + return visitShorthandPropertyAssignment(node); + case 164 /* SyntaxKind.ComputedPropertyName */: + return visitComputedPropertyName(node); + case 206 /* SyntaxKind.ArrayLiteralExpression */: + return visitArrayLiteralExpression(node); + case 210 /* SyntaxKind.CallExpression */: + return visitCallExpression(node); + case 211 /* SyntaxKind.NewExpression */: + return visitNewExpression(node); + case 214 /* SyntaxKind.ParenthesizedExpression */: + return visitParenthesizedExpression(node, expressionResultIsUnused); + case 223 /* SyntaxKind.BinaryExpression */: + return visitBinaryExpression(node, expressionResultIsUnused); + case 354 /* SyntaxKind.CommaListExpression */: + return visitCommaListExpression(node, expressionResultIsUnused); + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + case 15 /* SyntaxKind.TemplateHead */: + case 16 /* SyntaxKind.TemplateMiddle */: + case 17 /* SyntaxKind.TemplateTail */: + return visitTemplateLiteral(node); + case 10 /* SyntaxKind.StringLiteral */: + return visitStringLiteral(node); + case 8 /* SyntaxKind.NumericLiteral */: + return visitNumericLiteral(node); + case 212 /* SyntaxKind.TaggedTemplateExpression */: + return visitTaggedTemplateExpression(node); + case 225 /* SyntaxKind.TemplateExpression */: + return visitTemplateExpression(node); + case 226 /* SyntaxKind.YieldExpression */: + return visitYieldExpression(node); + case 227 /* SyntaxKind.SpreadElement */: + return visitSpreadElement(node); + case 106 /* SyntaxKind.SuperKeyword */: + return visitSuperKeyword(/*isExpressionOfCall*/ false); + case 108 /* SyntaxKind.ThisKeyword */: + return visitThisKeyword(node); + case 233 /* SyntaxKind.MetaProperty */: + return visitMetaProperty(node); + case 171 /* SyntaxKind.MethodDeclaration */: + return visitMethodDeclaration(node); + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + return visitAccessorDeclaration(node); + case 240 /* SyntaxKind.VariableStatement */: + return visitVariableStatement(node); + case 250 /* SyntaxKind.ReturnStatement */: + return visitReturnStatement(node); + case 219 /* SyntaxKind.VoidExpression */: + return visitVoidExpression(node); + default: + return ts.visitEachChild(node, visitor, context); + } + } + function visitSourceFile(node) { + var ancestorFacts = enterSubtree(8064 /* HierarchyFacts.SourceFileExcludes */, 64 /* HierarchyFacts.SourceFileIncludes */); + var prologue = []; + var statements = []; + startLexicalEnvironment(); + var statementOffset = factory.copyPrologue(node.statements, prologue, /*ensureUseStrict*/ false, visitor); + ts.addRange(statements, ts.visitNodes(node.statements, visitor, ts.isStatement, statementOffset)); + if (taggedTemplateStringDeclarations) { + statements.push(factory.createVariableStatement(/*modifiers*/ undefined, factory.createVariableDeclarationList(taggedTemplateStringDeclarations))); + } + factory.mergeLexicalEnvironment(prologue, endLexicalEnvironment()); + insertCaptureThisForNodeIfNeeded(prologue, node); + exitSubtree(ancestorFacts, 0 /* HierarchyFacts.None */, 0 /* HierarchyFacts.None */); + return factory.updateSourceFile(node, ts.setTextRange(factory.createNodeArray(ts.concatenate(prologue, statements)), node.statements)); + } + function visitSwitchStatement(node) { + if (convertedLoopState !== undefined) { + var savedAllowedNonLabeledJumps = convertedLoopState.allowedNonLabeledJumps; + // for switch statement allow only non-labeled break + convertedLoopState.allowedNonLabeledJumps |= 2 /* Jump.Break */; + var result = ts.visitEachChild(node, visitor, context); + convertedLoopState.allowedNonLabeledJumps = savedAllowedNonLabeledJumps; + return result; + } + return ts.visitEachChild(node, visitor, context); + } + function visitCaseBlock(node) { + var ancestorFacts = enterSubtree(7104 /* HierarchyFacts.BlockScopeExcludes */, 0 /* HierarchyFacts.BlockScopeIncludes */); + var updated = ts.visitEachChild(node, visitor, context); + exitSubtree(ancestorFacts, 0 /* HierarchyFacts.None */, 0 /* HierarchyFacts.None */); + return updated; + } + function returnCapturedThis(node) { + return ts.setOriginalNode(factory.createReturnStatement(factory.createUniqueName("_this", 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */)), node); + } + function visitReturnStatement(node) { + if (convertedLoopState) { + convertedLoopState.nonLocalJumps |= 8 /* Jump.Return */; + if (isReturnVoidStatementInConstructorWithCapturedSuper(node)) { + node = returnCapturedThis(node); + } + return factory.createReturnStatement(factory.createObjectLiteralExpression([ + factory.createPropertyAssignment(factory.createIdentifier("value"), node.expression + ? ts.visitNode(node.expression, visitor, ts.isExpression) + : factory.createVoidZero()) + ])); + } + else if (isReturnVoidStatementInConstructorWithCapturedSuper(node)) { + return returnCapturedThis(node); + } + return ts.visitEachChild(node, visitor, context); + } + function visitThisKeyword(node) { + if (hierarchyFacts & 2 /* HierarchyFacts.ArrowFunction */ && !(hierarchyFacts & 16384 /* HierarchyFacts.StaticInitializer */)) { + hierarchyFacts |= 65536 /* HierarchyFacts.CapturedLexicalThis */; + } + if (convertedLoopState) { + if (hierarchyFacts & 2 /* HierarchyFacts.ArrowFunction */) { + // if the enclosing function is an ArrowFunction then we use the captured 'this' keyword. + convertedLoopState.containsLexicalThis = true; + return node; + } + return convertedLoopState.thisName || (convertedLoopState.thisName = factory.createUniqueName("this")); + } + return node; + } + function visitVoidExpression(node) { + return ts.visitEachChild(node, visitorWithUnusedExpressionResult, context); + } + function visitIdentifier(node) { + if (convertedLoopState) { + if (resolver.isArgumentsLocalBinding(node)) { + return convertedLoopState.argumentsName || (convertedLoopState.argumentsName = factory.createUniqueName("arguments")); + } + } + if (node.hasExtendedUnicodeEscape) { + return ts.setOriginalNode(ts.setTextRange(factory.createIdentifier(ts.unescapeLeadingUnderscores(node.escapedText)), node), node); + } + return node; + } + function visitBreakOrContinueStatement(node) { + if (convertedLoopState) { + // check if we can emit break/continue as is + // it is possible if either + // - break/continue is labeled and label is located inside the converted loop + // - break/continue is non-labeled and located in non-converted loop/switch statement + var jump = node.kind === 249 /* SyntaxKind.BreakStatement */ ? 2 /* Jump.Break */ : 4 /* Jump.Continue */; + var canUseBreakOrContinue = (node.label && convertedLoopState.labels && convertedLoopState.labels.get(ts.idText(node.label))) || + (!node.label && (convertedLoopState.allowedNonLabeledJumps & jump)); + if (!canUseBreakOrContinue) { + var labelMarker = void 0; + var label = node.label; + if (!label) { + if (node.kind === 249 /* SyntaxKind.BreakStatement */) { + convertedLoopState.nonLocalJumps |= 2 /* Jump.Break */; + labelMarker = "break"; + } + else { + convertedLoopState.nonLocalJumps |= 4 /* Jump.Continue */; + // note: return value is emitted only to simplify debugging, call to converted loop body does not do any dispatching on it. + labelMarker = "continue"; + } + } + else { + if (node.kind === 249 /* SyntaxKind.BreakStatement */) { + labelMarker = "break-".concat(label.escapedText); + setLabeledJump(convertedLoopState, /*isBreak*/ true, ts.idText(label), labelMarker); + } + else { + labelMarker = "continue-".concat(label.escapedText); + setLabeledJump(convertedLoopState, /*isBreak*/ false, ts.idText(label), labelMarker); + } + } + var returnExpression = factory.createStringLiteral(labelMarker); + if (convertedLoopState.loopOutParameters.length) { + var outParams = convertedLoopState.loopOutParameters; + var expr = void 0; + for (var i = 0; i < outParams.length; i++) { + var copyExpr = copyOutParameter(outParams[i], 1 /* CopyDirection.ToOutParameter */); + if (i === 0) { + expr = copyExpr; + } + else { + expr = factory.createBinaryExpression(expr, 27 /* SyntaxKind.CommaToken */, copyExpr); + } + } + returnExpression = factory.createBinaryExpression(expr, 27 /* SyntaxKind.CommaToken */, returnExpression); + } + return factory.createReturnStatement(returnExpression); + } + } + return ts.visitEachChild(node, visitor, context); + } + /** + * Visits a ClassDeclaration and transforms it into a variable statement. + * + * @param node A ClassDeclaration node. + */ + function visitClassDeclaration(node) { + // [source] + // class C { } + // + // [output] + // var C = (function () { + // function C() { + // } + // return C; + // }()); + var variable = factory.createVariableDeclaration(factory.getLocalName(node, /*allowComments*/ true), + /*exclamationToken*/ undefined, + /*type*/ undefined, transformClassLikeDeclarationToExpression(node)); + ts.setOriginalNode(variable, node); + var statements = []; + var statement = factory.createVariableStatement(/*modifiers*/ undefined, factory.createVariableDeclarationList([variable])); + ts.setOriginalNode(statement, node); + ts.setTextRange(statement, node); + ts.startOnNewLine(statement); + statements.push(statement); + // Add an `export default` statement for default exports (for `--target es5 --module es6`) + if (ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */)) { + var exportStatement = ts.hasSyntacticModifier(node, 1024 /* ModifierFlags.Default */) + ? factory.createExportDefault(factory.getLocalName(node)) + : factory.createExternalModuleExport(factory.getLocalName(node)); + ts.setOriginalNode(exportStatement, statement); + statements.push(exportStatement); + } + var emitFlags = ts.getEmitFlags(node); + if ((emitFlags & 4194304 /* EmitFlags.HasEndOfDeclarationMarker */) === 0) { + // Add a DeclarationMarker as a marker for the end of the declaration + statements.push(factory.createEndOfDeclarationMarker(node)); + ts.setEmitFlags(statement, emitFlags | 4194304 /* EmitFlags.HasEndOfDeclarationMarker */); + } + return ts.singleOrMany(statements); + } + /** + * Visits a ClassExpression and transforms it into an expression. + * + * @param node A ClassExpression node. + */ + function visitClassExpression(node) { + // [source] + // C = class { } + // + // [output] + // C = (function () { + // function class_1() { + // } + // return class_1; + // }()) + return transformClassLikeDeclarationToExpression(node); + } + /** + * Transforms a ClassExpression or ClassDeclaration into an expression. + * + * @param node A ClassExpression or ClassDeclaration node. + */ + function transformClassLikeDeclarationToExpression(node) { + // [source] + // class C extends D { + // constructor() {} + // method() {} + // get prop() {} + // set prop(v) {} + // } + // + // [output] + // (function (_super) { + // __extends(C, _super); + // function C() { + // } + // C.prototype.method = function () {} + // Object.defineProperty(C.prototype, "prop", { + // get: function() {}, + // set: function() {}, + // enumerable: true, + // configurable: true + // }); + // return C; + // }(D)) + if (node.name) { + enableSubstitutionsForBlockScopedBindings(); + } + var extendsClauseElement = ts.getClassExtendsHeritageElement(node); + var classFunction = factory.createFunctionExpression( + /*modifiers*/ undefined, + /*asteriskToken*/ undefined, + /*name*/ undefined, + /*typeParameters*/ undefined, extendsClauseElement ? [factory.createParameterDeclaration(/*modifiers*/ undefined, /*dotDotDotToken*/ undefined, factory.createUniqueName("_super", 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */))] : [], + /*type*/ undefined, transformClassBody(node, extendsClauseElement)); + // To preserve the behavior of the old emitter, we explicitly indent + // the body of the function here if it was requested in an earlier + // transformation. + ts.setEmitFlags(classFunction, (ts.getEmitFlags(node) & 65536 /* EmitFlags.Indented */) | 524288 /* EmitFlags.ReuseTempVariableScope */); + // "inner" and "outer" below are added purely to preserve source map locations from + // the old emitter + var inner = factory.createPartiallyEmittedExpression(classFunction); + ts.setTextRangeEnd(inner, node.end); + ts.setEmitFlags(inner, 1536 /* EmitFlags.NoComments */); + var outer = factory.createPartiallyEmittedExpression(inner); + ts.setTextRangeEnd(outer, ts.skipTrivia(currentText, node.pos)); + ts.setEmitFlags(outer, 1536 /* EmitFlags.NoComments */); + var result = factory.createParenthesizedExpression(factory.createCallExpression(outer, + /*typeArguments*/ undefined, extendsClauseElement + ? [ts.visitNode(extendsClauseElement.expression, visitor, ts.isExpression)] + : [])); + ts.addSyntheticLeadingComment(result, 3 /* SyntaxKind.MultiLineCommentTrivia */, "* @class "); + return result; + } + /** + * Transforms a ClassExpression or ClassDeclaration into a function body. + * + * @param node A ClassExpression or ClassDeclaration node. + * @param extendsClauseElement The expression for the class `extends` clause. + */ + function transformClassBody(node, extendsClauseElement) { + var statements = []; + var name = factory.getInternalName(node); + var constructorLikeName = ts.isIdentifierANonContextualKeyword(name) ? factory.getGeneratedNameForNode(name) : name; + startLexicalEnvironment(); + addExtendsHelperIfNeeded(statements, node, extendsClauseElement); + addConstructor(statements, node, constructorLikeName, extendsClauseElement); + addClassMembers(statements, node); + // Create a synthetic text range for the return statement. + var closingBraceLocation = ts.createTokenRange(ts.skipTrivia(currentText, node.members.end), 19 /* SyntaxKind.CloseBraceToken */); + // The following partially-emitted expression exists purely to align our sourcemap + // emit with the original emitter. + var outer = factory.createPartiallyEmittedExpression(constructorLikeName); + ts.setTextRangeEnd(outer, closingBraceLocation.end); + ts.setEmitFlags(outer, 1536 /* EmitFlags.NoComments */); + var statement = factory.createReturnStatement(outer); + ts.setTextRangePos(statement, closingBraceLocation.pos); + ts.setEmitFlags(statement, 1536 /* EmitFlags.NoComments */ | 384 /* EmitFlags.NoTokenSourceMaps */); + statements.push(statement); + ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment()); + var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), /*location*/ node.members), /*multiLine*/ true); + ts.setEmitFlags(block, 1536 /* EmitFlags.NoComments */); + return block; + } + /** + * Adds a call to the `__extends` helper if needed for a class. + * + * @param statements The statements of the class body function. + * @param node The ClassExpression or ClassDeclaration node. + * @param extendsClauseElement The expression for the class `extends` clause. + */ + function addExtendsHelperIfNeeded(statements, node, extendsClauseElement) { + if (extendsClauseElement) { + statements.push(ts.setTextRange(factory.createExpressionStatement(emitHelpers().createExtendsHelper(factory.getInternalName(node))), + /*location*/ extendsClauseElement)); + } + } + /** + * Adds the constructor of the class to a class body function. + * + * @param statements The statements of the class body function. + * @param node The ClassExpression or ClassDeclaration node. + * @param extendsClauseElement The expression for the class `extends` clause. + */ + function addConstructor(statements, node, name, extendsClauseElement) { + var savedConvertedLoopState = convertedLoopState; + convertedLoopState = undefined; + var ancestorFacts = enterSubtree(32662 /* HierarchyFacts.ConstructorExcludes */, 73 /* HierarchyFacts.ConstructorIncludes */); + var constructor = ts.getFirstConstructorWithBody(node); + var hasSynthesizedSuper = hasSynthesizedDefaultSuperCall(constructor, extendsClauseElement !== undefined); + var constructorFunction = factory.createFunctionDeclaration( + /*modifiers*/ undefined, + /*asteriskToken*/ undefined, name, + /*typeParameters*/ undefined, transformConstructorParameters(constructor, hasSynthesizedSuper), + /*type*/ undefined, transformConstructorBody(constructor, node, extendsClauseElement, hasSynthesizedSuper)); + ts.setTextRange(constructorFunction, constructor || node); + if (extendsClauseElement) { + ts.setEmitFlags(constructorFunction, 8 /* EmitFlags.CapturesThis */); + } + statements.push(constructorFunction); + exitSubtree(ancestorFacts, 98304 /* HierarchyFacts.FunctionSubtreeExcludes */, 0 /* HierarchyFacts.None */); + convertedLoopState = savedConvertedLoopState; + } + /** + * Transforms the parameters of the constructor declaration of a class. + * + * @param constructor The constructor for the class. + * @param hasSynthesizedSuper A value indicating whether the constructor starts with a + * synthesized `super` call. + */ + function transformConstructorParameters(constructor, hasSynthesizedSuper) { + // If the TypeScript transformer needed to synthesize a constructor for property + // initializers, it would have also added a synthetic `...args` parameter and + // `super` call. + // If this is the case, we do not include the synthetic `...args` parameter and + // will instead use the `arguments` object in ES5/3. + return ts.visitParameterList(constructor && !hasSynthesizedSuper ? constructor.parameters : undefined, visitor, context) + || []; + } + function createDefaultConstructorBody(node, isDerivedClass) { + // We must be here because the user didn't write a constructor + // but we needed to call 'super(...args)' anyway as per 14.5.14 of the ES2016 spec. + // If that's the case we can just immediately return the result of a 'super()' call. + var statements = []; + resumeLexicalEnvironment(); + factory.mergeLexicalEnvironment(statements, endLexicalEnvironment()); + if (isDerivedClass) { + // return _super !== null && _super.apply(this, arguments) || this; + statements.push(factory.createReturnStatement(createDefaultSuperCallOrThis())); + } + var statementsArray = factory.createNodeArray(statements); + ts.setTextRange(statementsArray, node.members); + var block = factory.createBlock(statementsArray, /*multiLine*/ true); + ts.setTextRange(block, node); + ts.setEmitFlags(block, 1536 /* EmitFlags.NoComments */); + return block; + } + /** + * Transforms the body of a constructor declaration of a class. + * + * @param constructor The constructor for the class. + * @param node The node which contains the constructor. + * @param extendsClauseElement The expression for the class `extends` clause. + * @param hasSynthesizedSuper A value indicating whether the constructor starts with a + * synthesized `super` call. + */ + function transformConstructorBody(constructor, node, extendsClauseElement, hasSynthesizedSuper) { + // determine whether the class is known syntactically to be a derived class (e.g. a + // class that extends a value that is not syntactically known to be `null`). + var isDerivedClass = !!extendsClauseElement && ts.skipOuterExpressions(extendsClauseElement.expression).kind !== 104 /* SyntaxKind.NullKeyword */; + // When the subclass does not have a constructor, we synthesize a *default* constructor using the following + // representation: + // + // ``` + // // es2015 (source) + // class C extends Base { } + // + // // es5 (transformed) + // var C = (function (_super) { + // function C() { + // return _super.apply(this, arguments) || this; + // } + // return C; + // })(Base); + // ``` + if (!constructor) + return createDefaultConstructorBody(node, isDerivedClass); + // The prologue will contain all leading standard and custom prologue statements added by this transform + var prologue = []; + var statements = []; + resumeLexicalEnvironment(); + // In derived classes, there may be code before the necessary super() call + // We'll remove pre-super statements to be tacked on after the rest of the body + var existingPrologue = ts.takeWhile(constructor.body.statements, ts.isPrologueDirective); + var _a = findSuperCallAndStatementIndex(constructor.body.statements, existingPrologue), superCall = _a.superCall, superStatementIndex = _a.superStatementIndex; + var postSuperStatementsStart = superStatementIndex === -1 ? existingPrologue.length : superStatementIndex + 1; + // If a super call has already been synthesized, + // we're going to assume that we should just transform everything after that. + // The assumption is that no prior step in the pipeline has added any prologue directives. + var statementOffset = postSuperStatementsStart; + if (!hasSynthesizedSuper) + statementOffset = factory.copyStandardPrologue(constructor.body.statements, prologue, statementOffset, /*ensureUseStrict*/ false); + if (!hasSynthesizedSuper) + statementOffset = factory.copyCustomPrologue(constructor.body.statements, statements, statementOffset, visitor, /*filter*/ undefined); + // If there already exists a call to `super()`, visit the statement directly + var superCallExpression; + if (hasSynthesizedSuper) { + superCallExpression = createDefaultSuperCallOrThis(); + } + else if (superCall) { + superCallExpression = visitSuperCallInBody(superCall); + } + if (superCallExpression) { + hierarchyFacts |= 8192 /* HierarchyFacts.ConstructorWithCapturedSuper */; + } + // Add parameter defaults at the beginning of the output, with prologue statements + addDefaultValueAssignmentsIfNeeded(prologue, constructor); + addRestParameterIfNeeded(prologue, constructor, hasSynthesizedSuper); + // visit the remaining statements + ts.addRange(statements, ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, /*start*/ statementOffset)); + factory.mergeLexicalEnvironment(prologue, endLexicalEnvironment()); + insertCaptureNewTargetIfNeeded(prologue, constructor, /*copyOnWrite*/ false); + if (isDerivedClass || superCallExpression) { + if (superCallExpression && postSuperStatementsStart === constructor.body.statements.length && !(constructor.body.transformFlags & 16384 /* TransformFlags.ContainsLexicalThis */)) { + // If the subclass constructor does *not* contain `this` and *ends* with a `super()` call, we will use the + // following representation: + // + // ``` + // // es2015 (source) + // class C extends Base { + // constructor() { + // super("foo"); + // } + // } + // + // // es5 (transformed) + // var C = (function (_super) { + // function C() { + // return _super.call(this, "foo") || this; + // } + // return C; + // })(Base); + // ``` + var superCall_1 = ts.cast(ts.cast(superCallExpression, ts.isBinaryExpression).left, ts.isCallExpression); + var returnStatement = factory.createReturnStatement(superCallExpression); + ts.setCommentRange(returnStatement, ts.getCommentRange(superCall_1)); + ts.setEmitFlags(superCall_1, 1536 /* EmitFlags.NoComments */); + statements.push(returnStatement); + } + else { + // Otherwise, we will use the following transformed representation for calls to `super()` in a constructor: + // + // ``` + // // es2015 (source) + // class C extends Base { + // constructor() { + // super("foo"); + // this.x = 1; + // } + // } + // + // // es5 (transformed) + // var C = (function (_super) { + // function C() { + // var _this = _super.call(this, "foo") || this; + // _this.x = 1; + // return _this; + // } + // return C; + // })(Base); + // ``` + // If the super() call is the first statement, we can directly create and assign its result to `_this` + if (superStatementIndex <= existingPrologue.length) { + insertCaptureThisForNode(statements, constructor, superCallExpression || createActualThis()); + } + // Since the `super()` call isn't the first statement, it's split across 1-2 statements: + // * A prologue `var _this = this;`, in case the constructor accesses this before super() + // * If it exists, a reassignment to that `_this` of the super() call + else { + insertCaptureThisForNode(prologue, constructor, createActualThis()); + if (superCallExpression) { + insertSuperThisCaptureThisForNode(statements, superCallExpression); + } + } + if (!isSufficientlyCoveredByReturnStatements(constructor.body)) { + statements.push(factory.createReturnStatement(factory.createUniqueName("_this", 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */))); + } + } + } + else { + // If a class is not derived from a base class or does not have a call to `super()`, `this` is only + // captured when necessitated by an arrow function capturing the lexical `this`: + // + // ``` + // // es2015 + // class C {} + // + // // es5 + // var C = (function () { + // function C() { + // } + // return C; + // })(); + // ``` + insertCaptureThisForNodeIfNeeded(prologue, constructor); + } + var body = factory.createBlock(ts.setTextRange(factory.createNodeArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], existingPrologue, true), prologue, true), (superStatementIndex <= existingPrologue.length ? ts.emptyArray : ts.visitNodes(constructor.body.statements, visitor, ts.isStatement, existingPrologue.length, superStatementIndex - existingPrologue.length)), true), statements, true)), + /*location*/ constructor.body.statements), + /*multiLine*/ true); + ts.setTextRange(body, constructor.body); + return body; + } + function findSuperCallAndStatementIndex(originalBodyStatements, existingPrologue) { + for (var i = existingPrologue.length; i < originalBodyStatements.length; i += 1) { + var superCall = ts.getSuperCallFromStatement(originalBodyStatements[i]); + if (superCall) { + // With a super() call, split the statements into pre-super() and 'body' (post-super()) + return { + superCall: superCall, + superStatementIndex: i, + }; + } + } + // Since there was no super() call found, consider all statements to be in the main 'body' (post-super()) + return { + superStatementIndex: -1, + }; + } + /** + * We want to try to avoid emitting a return statement in certain cases if a user already returned something. + * It would generate obviously dead code, so we'll try to make things a little bit prettier + * by doing a minimal check on whether some common patterns always explicitly return. + */ + function isSufficientlyCoveredByReturnStatements(statement) { + // A return statement is considered covered. + if (statement.kind === 250 /* SyntaxKind.ReturnStatement */) { + return true; + } + // An if-statement with two covered branches is covered. + else if (statement.kind === 242 /* SyntaxKind.IfStatement */) { + var ifStatement = statement; + if (ifStatement.elseStatement) { + return isSufficientlyCoveredByReturnStatements(ifStatement.thenStatement) && + isSufficientlyCoveredByReturnStatements(ifStatement.elseStatement); + } + } + // A block is covered if it has a last statement which is covered. + else if (statement.kind === 238 /* SyntaxKind.Block */) { + var lastStatement = ts.lastOrUndefined(statement.statements); + if (lastStatement && isSufficientlyCoveredByReturnStatements(lastStatement)) { + return true; + } + } + return false; + } + function createActualThis() { + return ts.setEmitFlags(factory.createThis(), 4 /* EmitFlags.NoSubstitution */); + } + function createDefaultSuperCallOrThis() { + return factory.createLogicalOr(factory.createLogicalAnd(factory.createStrictInequality(factory.createUniqueName("_super", 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */), factory.createNull()), factory.createFunctionApplyCall(factory.createUniqueName("_super", 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */), createActualThis(), factory.createIdentifier("arguments"))), createActualThis()); + } + /** + * Visits a parameter declaration. + * + * @param node A ParameterDeclaration node. + */ + function visitParameter(node) { + if (node.dotDotDotToken) { + // rest parameters are elided + return undefined; + } + else if (ts.isBindingPattern(node.name)) { + // Binding patterns are converted into a generated name and are + // evaluated inside the function body. + return ts.setOriginalNode(ts.setTextRange(factory.createParameterDeclaration( + /*modifiers*/ undefined, + /*dotDotDotToken*/ undefined, factory.getGeneratedNameForNode(node), + /*questionToken*/ undefined, + /*type*/ undefined, + /*initializer*/ undefined), + /*location*/ node), + /*original*/ node); + } + else if (node.initializer) { + // Initializers are elided + return ts.setOriginalNode(ts.setTextRange(factory.createParameterDeclaration( + /*modifiers*/ undefined, + /*dotDotDotToken*/ undefined, node.name, + /*questionToken*/ undefined, + /*type*/ undefined, + /*initializer*/ undefined), + /*location*/ node), + /*original*/ node); + } + else { + return node; + } + } + function hasDefaultValueOrBindingPattern(node) { + return node.initializer !== undefined + || ts.isBindingPattern(node.name); + } + /** + * Adds statements to the body of a function-like node if it contains parameters with + * binding patterns or initializers. + * + * @param statements The statements for the new function body. + * @param node A function-like node. + */ + function addDefaultValueAssignmentsIfNeeded(statements, node) { + if (!ts.some(node.parameters, hasDefaultValueOrBindingPattern)) { + return false; + } + var added = false; + for (var _i = 0, _a = node.parameters; _i < _a.length; _i++) { + var parameter = _a[_i]; + var name = parameter.name, initializer = parameter.initializer, dotDotDotToken = parameter.dotDotDotToken; + // A rest parameter cannot have a binding pattern or an initializer, + // so let's just ignore it. + if (dotDotDotToken) { + continue; + } + if (ts.isBindingPattern(name)) { + added = insertDefaultValueAssignmentForBindingPattern(statements, parameter, name, initializer) || added; + } + else if (initializer) { + insertDefaultValueAssignmentForInitializer(statements, parameter, name, initializer); + added = true; + } + } + return added; + } + /** + * Adds statements to the body of a function-like node for parameters with binding patterns + * + * @param statements The statements for the new function body. + * @param parameter The parameter for the function. + * @param name The name of the parameter. + * @param initializer The initializer for the parameter. + */ + function insertDefaultValueAssignmentForBindingPattern(statements, parameter, name, initializer) { + // In cases where a binding pattern is simply '[]' or '{}', + // we usually don't want to emit a var declaration; however, in the presence + // of an initializer, we must emit that expression to preserve side effects. + if (name.elements.length > 0) { + ts.insertStatementAfterCustomPrologue(statements, ts.setEmitFlags(factory.createVariableStatement( + /*modifiers*/ undefined, factory.createVariableDeclarationList(ts.flattenDestructuringBinding(parameter, visitor, context, 0 /* FlattenLevel.All */, factory.getGeneratedNameForNode(parameter)))), 1048576 /* EmitFlags.CustomPrologue */)); + return true; + } + else if (initializer) { + ts.insertStatementAfterCustomPrologue(statements, ts.setEmitFlags(factory.createExpressionStatement(factory.createAssignment(factory.getGeneratedNameForNode(parameter), ts.visitNode(initializer, visitor, ts.isExpression))), 1048576 /* EmitFlags.CustomPrologue */)); + return true; + } + return false; + } + /** + * Adds statements to the body of a function-like node for parameters with initializers. + * + * @param statements The statements for the new function body. + * @param parameter The parameter for the function. + * @param name The name of the parameter. + * @param initializer The initializer for the parameter. + */ + function insertDefaultValueAssignmentForInitializer(statements, parameter, name, initializer) { + initializer = ts.visitNode(initializer, visitor, ts.isExpression); + var statement = factory.createIfStatement(factory.createTypeCheck(factory.cloneNode(name), "undefined"), ts.setEmitFlags(ts.setTextRange(factory.createBlock([ + factory.createExpressionStatement(ts.setEmitFlags(ts.setTextRange(factory.createAssignment( + // TODO(rbuckton): Does this need to be parented? + ts.setEmitFlags(ts.setParent(ts.setTextRange(factory.cloneNode(name), name), name.parent), 48 /* EmitFlags.NoSourceMap */), ts.setEmitFlags(initializer, 48 /* EmitFlags.NoSourceMap */ | ts.getEmitFlags(initializer) | 1536 /* EmitFlags.NoComments */)), parameter), 1536 /* EmitFlags.NoComments */)) + ]), parameter), 1 /* EmitFlags.SingleLine */ | 32 /* EmitFlags.NoTrailingSourceMap */ | 384 /* EmitFlags.NoTokenSourceMaps */ | 1536 /* EmitFlags.NoComments */)); + ts.startOnNewLine(statement); + ts.setTextRange(statement, parameter); + ts.setEmitFlags(statement, 384 /* EmitFlags.NoTokenSourceMaps */ | 32 /* EmitFlags.NoTrailingSourceMap */ | 1048576 /* EmitFlags.CustomPrologue */ | 1536 /* EmitFlags.NoComments */); + ts.insertStatementAfterCustomPrologue(statements, statement); + } + /** + * Gets a value indicating whether we need to add statements to handle a rest parameter. + * + * @param node A ParameterDeclaration node. + * @param inConstructorWithSynthesizedSuper A value indicating whether the parameter is + * part of a constructor declaration with a + * synthesized call to `super` + */ + function shouldAddRestParameter(node, inConstructorWithSynthesizedSuper) { + return !!(node && node.dotDotDotToken && !inConstructorWithSynthesizedSuper); + } + /** + * Adds statements to the body of a function-like node if it contains a rest parameter. + * + * @param statements The statements for the new function body. + * @param node A function-like node. + * @param inConstructorWithSynthesizedSuper A value indicating whether the parameter is + * part of a constructor declaration with a + * synthesized call to `super` + */ + function addRestParameterIfNeeded(statements, node, inConstructorWithSynthesizedSuper) { + var prologueStatements = []; + var parameter = ts.lastOrUndefined(node.parameters); + if (!shouldAddRestParameter(parameter, inConstructorWithSynthesizedSuper)) { + return false; + } + // `declarationName` is the name of the local declaration for the parameter. + // TODO(rbuckton): Does this need to be parented? + var declarationName = parameter.name.kind === 79 /* SyntaxKind.Identifier */ ? ts.setParent(ts.setTextRange(factory.cloneNode(parameter.name), parameter.name), parameter.name.parent) : factory.createTempVariable(/*recordTempVariable*/ undefined); + ts.setEmitFlags(declarationName, 48 /* EmitFlags.NoSourceMap */); + // `expressionName` is the name of the parameter used in expressions. + var expressionName = parameter.name.kind === 79 /* SyntaxKind.Identifier */ ? factory.cloneNode(parameter.name) : declarationName; + var restIndex = node.parameters.length - 1; + var temp = factory.createLoopVariable(); + // var param = []; + prologueStatements.push(ts.setEmitFlags(ts.setTextRange(factory.createVariableStatement( + /*modifiers*/ undefined, factory.createVariableDeclarationList([ + factory.createVariableDeclaration(declarationName, + /*exclamationToken*/ undefined, + /*type*/ undefined, factory.createArrayLiteralExpression([])) + ])), + /*location*/ parameter), 1048576 /* EmitFlags.CustomPrologue */)); + // for (var _i = restIndex; _i < arguments.length; _i++) { + // param[_i - restIndex] = arguments[_i]; + // } + var forStatement = factory.createForStatement(ts.setTextRange(factory.createVariableDeclarationList([ + factory.createVariableDeclaration(temp, /*exclamationToken*/ undefined, /*type*/ undefined, factory.createNumericLiteral(restIndex)) + ]), parameter), ts.setTextRange(factory.createLessThan(temp, factory.createPropertyAccessExpression(factory.createIdentifier("arguments"), "length")), parameter), ts.setTextRange(factory.createPostfixIncrement(temp), parameter), factory.createBlock([ + ts.startOnNewLine(ts.setTextRange(factory.createExpressionStatement(factory.createAssignment(factory.createElementAccessExpression(expressionName, restIndex === 0 + ? temp + : factory.createSubtract(temp, factory.createNumericLiteral(restIndex))), factory.createElementAccessExpression(factory.createIdentifier("arguments"), temp))), + /*location*/ parameter)) + ])); + ts.setEmitFlags(forStatement, 1048576 /* EmitFlags.CustomPrologue */); + ts.startOnNewLine(forStatement); + prologueStatements.push(forStatement); + if (parameter.name.kind !== 79 /* SyntaxKind.Identifier */) { + // do the actual destructuring of the rest parameter if necessary + prologueStatements.push(ts.setEmitFlags(ts.setTextRange(factory.createVariableStatement( + /*modifiers*/ undefined, factory.createVariableDeclarationList(ts.flattenDestructuringBinding(parameter, visitor, context, 0 /* FlattenLevel.All */, expressionName))), parameter), 1048576 /* EmitFlags.CustomPrologue */)); + } + ts.insertStatementsAfterCustomPrologue(statements, prologueStatements); + return true; + } + /** + * Adds a statement to capture the `this` of a function declaration if it is needed. + * NOTE: This must be executed *after* the subtree has been visited. + * + * @param statements The statements for the new function body. + * @param node A node. + */ + function insertCaptureThisForNodeIfNeeded(statements, node) { + if (hierarchyFacts & 65536 /* HierarchyFacts.CapturedLexicalThis */ && node.kind !== 216 /* SyntaxKind.ArrowFunction */) { + insertCaptureThisForNode(statements, node, factory.createThis()); + return true; + } + return false; + } + /** + * Assigns the `this` in a constructor to the result of its `super()` call. + * + * @param statements Statements in the constructor body. + * @param superExpression Existing `super()` call for the constructor. + */ + function insertSuperThisCaptureThisForNode(statements, superExpression) { + enableSubstitutionsForCapturedThis(); + var assignSuperExpression = factory.createExpressionStatement(factory.createBinaryExpression(factory.createThis(), 63 /* SyntaxKind.EqualsToken */, superExpression)); + ts.insertStatementAfterCustomPrologue(statements, assignSuperExpression); + ts.setCommentRange(assignSuperExpression, ts.getOriginalNode(superExpression).parent); + } + function insertCaptureThisForNode(statements, node, initializer) { + enableSubstitutionsForCapturedThis(); + var captureThisStatement = factory.createVariableStatement( + /*modifiers*/ undefined, factory.createVariableDeclarationList([ + factory.createVariableDeclaration(factory.createUniqueName("_this", 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */), + /*exclamationToken*/ undefined, + /*type*/ undefined, initializer) + ])); + ts.setEmitFlags(captureThisStatement, 1536 /* EmitFlags.NoComments */ | 1048576 /* EmitFlags.CustomPrologue */); + ts.setSourceMapRange(captureThisStatement, node); + ts.insertStatementAfterCustomPrologue(statements, captureThisStatement); + } + function insertCaptureNewTargetIfNeeded(statements, node, copyOnWrite) { + if (hierarchyFacts & 32768 /* HierarchyFacts.NewTarget */) { + var newTarget = void 0; + switch (node.kind) { + case 216 /* SyntaxKind.ArrowFunction */: + return statements; + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + // Methods and accessors cannot be constructors, so 'new.target' will + // always return 'undefined'. + newTarget = factory.createVoidZero(); + break; + case 173 /* SyntaxKind.Constructor */: + // Class constructors can only be called with `new`, so `this.constructor` + // should be relatively safe to use. + newTarget = factory.createPropertyAccessExpression(ts.setEmitFlags(factory.createThis(), 4 /* EmitFlags.NoSubstitution */), "constructor"); + break; + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + // Functions can be called or constructed, and may have a `this` due to + // being a member or when calling an imported function via `other_1.f()`. + newTarget = factory.createConditionalExpression(factory.createLogicalAnd(ts.setEmitFlags(factory.createThis(), 4 /* EmitFlags.NoSubstitution */), factory.createBinaryExpression(ts.setEmitFlags(factory.createThis(), 4 /* EmitFlags.NoSubstitution */), 102 /* SyntaxKind.InstanceOfKeyword */, factory.getLocalName(node))), + /*questionToken*/ undefined, factory.createPropertyAccessExpression(ts.setEmitFlags(factory.createThis(), 4 /* EmitFlags.NoSubstitution */), "constructor"), + /*colonToken*/ undefined, factory.createVoidZero()); + break; + default: + return ts.Debug.failBadSyntaxKind(node); + } + var captureNewTargetStatement = factory.createVariableStatement( + /*modifiers*/ undefined, factory.createVariableDeclarationList([ + factory.createVariableDeclaration(factory.createUniqueName("_newTarget", 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */), + /*exclamationToken*/ undefined, + /*type*/ undefined, newTarget) + ])); + ts.setEmitFlags(captureNewTargetStatement, 1536 /* EmitFlags.NoComments */ | 1048576 /* EmitFlags.CustomPrologue */); + if (copyOnWrite) { + statements = statements.slice(); + } + ts.insertStatementAfterCustomPrologue(statements, captureNewTargetStatement); + } + return statements; + } + /** + * Adds statements to the class body function for a class to define the members of the + * class. + * + * @param statements The statements for the class body function. + * @param node The ClassExpression or ClassDeclaration node. + */ + function addClassMembers(statements, node) { + for (var _i = 0, _a = node.members; _i < _a.length; _i++) { + var member = _a[_i]; + switch (member.kind) { + case 237 /* SyntaxKind.SemicolonClassElement */: + statements.push(transformSemicolonClassElementToStatement(member)); + break; + case 171 /* SyntaxKind.MethodDeclaration */: + statements.push(transformClassMethodDeclarationToStatement(getClassMemberPrefix(node, member), member, node)); + break; + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + var accessors = ts.getAllAccessorDeclarations(node.members, member); + if (member === accessors.firstAccessor) { + statements.push(transformAccessorsToStatement(getClassMemberPrefix(node, member), accessors, node)); + } + break; + case 173 /* SyntaxKind.Constructor */: + case 172 /* SyntaxKind.ClassStaticBlockDeclaration */: + // Constructors are handled in visitClassExpression/visitClassDeclaration + break; + default: + ts.Debug.failBadSyntaxKind(member, currentSourceFile && currentSourceFile.fileName); + break; + } + } + } + /** + * Transforms a SemicolonClassElement into a statement for a class body function. + * + * @param member The SemicolonClassElement node. + */ + function transformSemicolonClassElementToStatement(member) { + return ts.setTextRange(factory.createEmptyStatement(), member); + } + /** + * Transforms a MethodDeclaration into a statement for a class body function. + * + * @param receiver The receiver for the member. + * @param member The MethodDeclaration node. + */ + function transformClassMethodDeclarationToStatement(receiver, member, container) { + var commentRange = ts.getCommentRange(member); + var sourceMapRange = ts.getSourceMapRange(member); + var memberFunction = transformFunctionLikeToExpression(member, /*location*/ member, /*name*/ undefined, container); + var propertyName = ts.visitNode(member.name, visitor, ts.isPropertyName); + var e; + if (!ts.isPrivateIdentifier(propertyName) && ts.getUseDefineForClassFields(context.getCompilerOptions())) { + var name = ts.isComputedPropertyName(propertyName) ? propertyName.expression + : ts.isIdentifier(propertyName) ? factory.createStringLiteral(ts.unescapeLeadingUnderscores(propertyName.escapedText)) + : propertyName; + e = factory.createObjectDefinePropertyCall(receiver, name, factory.createPropertyDescriptor({ value: memberFunction, enumerable: false, writable: true, configurable: true })); + } + else { + var memberName = ts.createMemberAccessForPropertyName(factory, receiver, propertyName, /*location*/ member.name); + e = factory.createAssignment(memberName, memberFunction); + } + ts.setEmitFlags(memberFunction, 1536 /* EmitFlags.NoComments */); + ts.setSourceMapRange(memberFunction, sourceMapRange); + var statement = ts.setTextRange(factory.createExpressionStatement(e), /*location*/ member); + ts.setOriginalNode(statement, member); + ts.setCommentRange(statement, commentRange); + // The location for the statement is used to emit comments only. + // No source map should be emitted for this statement to align with the + // old emitter. + ts.setEmitFlags(statement, 48 /* EmitFlags.NoSourceMap */); + return statement; + } + /** + * Transforms a set of related of get/set accessors into a statement for a class body function. + * + * @param receiver The receiver for the member. + * @param accessors The set of related get/set accessors. + */ + function transformAccessorsToStatement(receiver, accessors, container) { + var statement = factory.createExpressionStatement(transformAccessorsToExpression(receiver, accessors, container, /*startsOnNewLine*/ false)); + // The location for the statement is used to emit source maps only. + // No comments should be emitted for this statement to align with the + // old emitter. + ts.setEmitFlags(statement, 1536 /* EmitFlags.NoComments */); + ts.setSourceMapRange(statement, ts.getSourceMapRange(accessors.firstAccessor)); + return statement; + } + /** + * Transforms a set of related get/set accessors into an expression for either a class + * body function or an ObjectLiteralExpression with computed properties. + * + * @param receiver The receiver for the member. + */ + function transformAccessorsToExpression(receiver, _a, container, startsOnNewLine) { + var firstAccessor = _a.firstAccessor, getAccessor = _a.getAccessor, setAccessor = _a.setAccessor; + // To align with source maps in the old emitter, the receiver and property name + // arguments are both mapped contiguously to the accessor name. + // TODO(rbuckton): Does this need to be parented? + var target = ts.setParent(ts.setTextRange(factory.cloneNode(receiver), receiver), receiver.parent); + ts.setEmitFlags(target, 1536 /* EmitFlags.NoComments */ | 32 /* EmitFlags.NoTrailingSourceMap */); + ts.setSourceMapRange(target, firstAccessor.name); + var visitedAccessorName = ts.visitNode(firstAccessor.name, visitor, ts.isPropertyName); + if (ts.isPrivateIdentifier(visitedAccessorName)) { + return ts.Debug.failBadSyntaxKind(visitedAccessorName, "Encountered unhandled private identifier while transforming ES2015."); + } + var propertyName = ts.createExpressionForPropertyName(factory, visitedAccessorName); + ts.setEmitFlags(propertyName, 1536 /* EmitFlags.NoComments */ | 16 /* EmitFlags.NoLeadingSourceMap */); + ts.setSourceMapRange(propertyName, firstAccessor.name); + var properties = []; + if (getAccessor) { + var getterFunction = transformFunctionLikeToExpression(getAccessor, /*location*/ undefined, /*name*/ undefined, container); + ts.setSourceMapRange(getterFunction, ts.getSourceMapRange(getAccessor)); + ts.setEmitFlags(getterFunction, 512 /* EmitFlags.NoLeadingComments */); + var getter = factory.createPropertyAssignment("get", getterFunction); + ts.setCommentRange(getter, ts.getCommentRange(getAccessor)); + properties.push(getter); + } + if (setAccessor) { + var setterFunction = transformFunctionLikeToExpression(setAccessor, /*location*/ undefined, /*name*/ undefined, container); + ts.setSourceMapRange(setterFunction, ts.getSourceMapRange(setAccessor)); + ts.setEmitFlags(setterFunction, 512 /* EmitFlags.NoLeadingComments */); + var setter = factory.createPropertyAssignment("set", setterFunction); + ts.setCommentRange(setter, ts.getCommentRange(setAccessor)); + properties.push(setter); + } + properties.push(factory.createPropertyAssignment("enumerable", getAccessor || setAccessor ? factory.createFalse() : factory.createTrue()), factory.createPropertyAssignment("configurable", factory.createTrue())); + var call = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Object"), "defineProperty"), + /*typeArguments*/ undefined, [ + target, + propertyName, + factory.createObjectLiteralExpression(properties, /*multiLine*/ true) + ]); + if (startsOnNewLine) { + ts.startOnNewLine(call); + } + return call; + } + /** + * Visits an ArrowFunction and transforms it into a FunctionExpression. + * + * @param node An ArrowFunction node. + */ + function visitArrowFunction(node) { + if (node.transformFlags & 16384 /* TransformFlags.ContainsLexicalThis */ && !(hierarchyFacts & 16384 /* HierarchyFacts.StaticInitializer */)) { + hierarchyFacts |= 65536 /* HierarchyFacts.CapturedLexicalThis */; + } + var savedConvertedLoopState = convertedLoopState; + convertedLoopState = undefined; + var ancestorFacts = enterSubtree(15232 /* HierarchyFacts.ArrowFunctionExcludes */, 66 /* HierarchyFacts.ArrowFunctionIncludes */); + var func = factory.createFunctionExpression( + /*modifiers*/ undefined, + /*asteriskToken*/ undefined, + /*name*/ undefined, + /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, visitor, context), + /*type*/ undefined, transformFunctionBody(node)); + ts.setTextRange(func, node); + ts.setOriginalNode(func, node); + ts.setEmitFlags(func, 8 /* EmitFlags.CapturesThis */); + // If an arrow function contains + exitSubtree(ancestorFacts, 0 /* HierarchyFacts.ArrowFunctionSubtreeExcludes */, 0 /* HierarchyFacts.None */); + convertedLoopState = savedConvertedLoopState; + return func; + } + /** + * Visits a FunctionExpression node. + * + * @param node a FunctionExpression node. + */ + function visitFunctionExpression(node) { + var ancestorFacts = ts.getEmitFlags(node) & 262144 /* EmitFlags.AsyncFunctionBody */ + ? enterSubtree(32662 /* HierarchyFacts.AsyncFunctionBodyExcludes */, 69 /* HierarchyFacts.AsyncFunctionBodyIncludes */) + : enterSubtree(32670 /* HierarchyFacts.FunctionExcludes */, 65 /* HierarchyFacts.FunctionIncludes */); + var savedConvertedLoopState = convertedLoopState; + convertedLoopState = undefined; + var parameters = ts.visitParameterList(node.parameters, visitor, context); + var body = transformFunctionBody(node); + var name = hierarchyFacts & 32768 /* HierarchyFacts.NewTarget */ + ? factory.getLocalName(node) + : node.name; + exitSubtree(ancestorFacts, 98304 /* HierarchyFacts.FunctionSubtreeExcludes */, 0 /* HierarchyFacts.None */); + convertedLoopState = savedConvertedLoopState; + return factory.updateFunctionExpression(node, + /*modifiers*/ undefined, node.asteriskToken, name, + /*typeParameters*/ undefined, parameters, + /*type*/ undefined, body); + } + /** + * Visits a FunctionDeclaration node. + * + * @param node a FunctionDeclaration node. + */ + function visitFunctionDeclaration(node) { + var savedConvertedLoopState = convertedLoopState; + convertedLoopState = undefined; + var ancestorFacts = enterSubtree(32670 /* HierarchyFacts.FunctionExcludes */, 65 /* HierarchyFacts.FunctionIncludes */); + var parameters = ts.visitParameterList(node.parameters, visitor, context); + var body = transformFunctionBody(node); + var name = hierarchyFacts & 32768 /* HierarchyFacts.NewTarget */ + ? factory.getLocalName(node) + : node.name; + exitSubtree(ancestorFacts, 98304 /* HierarchyFacts.FunctionSubtreeExcludes */, 0 /* HierarchyFacts.None */); + convertedLoopState = savedConvertedLoopState; + return factory.updateFunctionDeclaration(node, ts.visitNodes(node.modifiers, visitor, ts.isModifier), node.asteriskToken, name, + /*typeParameters*/ undefined, parameters, + /*type*/ undefined, body); + } + /** + * Transforms a function-like node into a FunctionExpression. + * + * @param node The function-like node to transform. + * @param location The source-map location for the new FunctionExpression. + * @param name The name of the new FunctionExpression. + */ + function transformFunctionLikeToExpression(node, location, name, container) { + var savedConvertedLoopState = convertedLoopState; + convertedLoopState = undefined; + var ancestorFacts = container && ts.isClassLike(container) && !ts.isStatic(node) + ? enterSubtree(32670 /* HierarchyFacts.FunctionExcludes */, 65 /* HierarchyFacts.FunctionIncludes */ | 8 /* HierarchyFacts.NonStaticClassElement */) + : enterSubtree(32670 /* HierarchyFacts.FunctionExcludes */, 65 /* HierarchyFacts.FunctionIncludes */); + var parameters = ts.visitParameterList(node.parameters, visitor, context); + var body = transformFunctionBody(node); + if (hierarchyFacts & 32768 /* HierarchyFacts.NewTarget */ && !name && (node.kind === 259 /* SyntaxKind.FunctionDeclaration */ || node.kind === 215 /* SyntaxKind.FunctionExpression */)) { + name = factory.getGeneratedNameForNode(node); + } + exitSubtree(ancestorFacts, 98304 /* HierarchyFacts.FunctionSubtreeExcludes */, 0 /* HierarchyFacts.None */); + convertedLoopState = savedConvertedLoopState; + return ts.setOriginalNode(ts.setTextRange(factory.createFunctionExpression( + /*modifiers*/ undefined, node.asteriskToken, name, + /*typeParameters*/ undefined, parameters, + /*type*/ undefined, body), location), + /*original*/ node); + } + /** + * Transforms the body of a function-like node. + * + * @param node A function-like node. + */ + function transformFunctionBody(node) { + var multiLine = false; // indicates whether the block *must* be emitted as multiple lines + var singleLine = false; // indicates whether the block *may* be emitted as a single line + var statementsLocation; + var closeBraceLocation; + var prologue = []; + var statements = []; + var body = node.body; + var statementOffset; + resumeLexicalEnvironment(); + if (ts.isBlock(body)) { + // ensureUseStrict is false because no new prologue-directive should be added. + // addStandardPrologue will put already-existing directives at the beginning of the target statement-array + statementOffset = factory.copyStandardPrologue(body.statements, prologue, 0, /*ensureUseStrict*/ false); + statementOffset = factory.copyCustomPrologue(body.statements, statements, statementOffset, visitor, ts.isHoistedFunction); + statementOffset = factory.copyCustomPrologue(body.statements, statements, statementOffset, visitor, ts.isHoistedVariableStatement); + } + multiLine = addDefaultValueAssignmentsIfNeeded(statements, node) || multiLine; + multiLine = addRestParameterIfNeeded(statements, node, /*inConstructorWithSynthesizedSuper*/ false) || multiLine; + if (ts.isBlock(body)) { + // addCustomPrologue puts already-existing directives at the beginning of the target statement-array + statementOffset = factory.copyCustomPrologue(body.statements, statements, statementOffset, visitor); + statementsLocation = body.statements; + ts.addRange(statements, ts.visitNodes(body.statements, visitor, ts.isStatement, statementOffset)); + // If the original body was a multi-line block, this must be a multi-line block. + if (!multiLine && body.multiLine) { + multiLine = true; + } + } + else { + ts.Debug.assert(node.kind === 216 /* SyntaxKind.ArrowFunction */); + // To align with the old emitter, we use a synthetic end position on the location + // for the statement list we synthesize when we down-level an arrow function with + // an expression function body. This prevents both comments and source maps from + // being emitted for the end position only. + statementsLocation = ts.moveRangeEnd(body, -1); + var equalsGreaterThanToken = node.equalsGreaterThanToken; + if (!ts.nodeIsSynthesized(equalsGreaterThanToken) && !ts.nodeIsSynthesized(body)) { + if (ts.rangeEndIsOnSameLineAsRangeStart(equalsGreaterThanToken, body, currentSourceFile)) { + singleLine = true; + } + else { + multiLine = true; + } + } + var expression = ts.visitNode(body, visitor, ts.isExpression); + var returnStatement = factory.createReturnStatement(expression); + ts.setTextRange(returnStatement, body); + ts.moveSyntheticComments(returnStatement, body); + ts.setEmitFlags(returnStatement, 384 /* EmitFlags.NoTokenSourceMaps */ | 32 /* EmitFlags.NoTrailingSourceMap */ | 1024 /* EmitFlags.NoTrailingComments */); + statements.push(returnStatement); + // To align with the source map emit for the old emitter, we set a custom + // source map location for the close brace. + closeBraceLocation = body; + } + factory.mergeLexicalEnvironment(prologue, endLexicalEnvironment()); + insertCaptureNewTargetIfNeeded(prologue, node, /*copyOnWrite*/ false); + insertCaptureThisForNodeIfNeeded(prologue, node); + // If we added any final generated statements, this must be a multi-line block + if (ts.some(prologue)) { + multiLine = true; + } + statements.unshift.apply(statements, prologue); + if (ts.isBlock(body) && ts.arrayIsEqualTo(statements, body.statements)) { + // no changes were made, preserve the tree + return body; + } + var block = factory.createBlock(ts.setTextRange(factory.createNodeArray(statements), statementsLocation), multiLine); + ts.setTextRange(block, node.body); + if (!multiLine && singleLine) { + ts.setEmitFlags(block, 1 /* EmitFlags.SingleLine */); + } + if (closeBraceLocation) { + ts.setTokenSourceMapRange(block, 19 /* SyntaxKind.CloseBraceToken */, closeBraceLocation); + } + ts.setOriginalNode(block, node.body); + return block; + } + function visitBlock(node, isFunctionBody) { + if (isFunctionBody) { + // A function body is not a block scope. + return ts.visitEachChild(node, visitor, context); + } + var ancestorFacts = hierarchyFacts & 256 /* HierarchyFacts.IterationStatement */ + ? enterSubtree(7104 /* HierarchyFacts.IterationStatementBlockExcludes */, 512 /* HierarchyFacts.IterationStatementBlockIncludes */) + : enterSubtree(6976 /* HierarchyFacts.BlockExcludes */, 128 /* HierarchyFacts.BlockIncludes */); + var updated = ts.visitEachChild(node, visitor, context); + exitSubtree(ancestorFacts, 0 /* HierarchyFacts.None */, 0 /* HierarchyFacts.None */); + return updated; + } + /** + * Visits an ExpressionStatement that contains a destructuring assignment. + * + * @param node An ExpressionStatement node. + */ + function visitExpressionStatement(node) { + return ts.visitEachChild(node, visitorWithUnusedExpressionResult, context); + } + /** + * Visits a ParenthesizedExpression that may contain a destructuring assignment. + * + * @param node A ParenthesizedExpression node. + * @param expressionResultIsUnused Indicates the result of an expression is unused by the parent node (i.e., the left side of a comma or the + * expression of an `ExpressionStatement`). + */ + function visitParenthesizedExpression(node, expressionResultIsUnused) { + return ts.visitEachChild(node, expressionResultIsUnused ? visitorWithUnusedExpressionResult : visitor, context); + } + /** + * Visits a BinaryExpression that contains a destructuring assignment. + * + * @param node A BinaryExpression node. + * @param expressionResultIsUnused Indicates the result of an expression is unused by the parent node (i.e., the left side of a comma or the + * expression of an `ExpressionStatement`). + */ + function visitBinaryExpression(node, expressionResultIsUnused) { + // If we are here it is because this is a destructuring assignment. + if (ts.isDestructuringAssignment(node)) { + return ts.flattenDestructuringAssignment(node, visitor, context, 0 /* FlattenLevel.All */, !expressionResultIsUnused); + } + if (node.operatorToken.kind === 27 /* SyntaxKind.CommaToken */) { + return factory.updateBinaryExpression(node, ts.visitNode(node.left, visitorWithUnusedExpressionResult, ts.isExpression), node.operatorToken, ts.visitNode(node.right, expressionResultIsUnused ? visitorWithUnusedExpressionResult : visitor, ts.isExpression)); + } + return ts.visitEachChild(node, visitor, context); + } + /** + * @param expressionResultIsUnused Indicates the result of an expression is unused by the parent node (i.e., the left side of a comma or the + * expression of an `ExpressionStatement`). + */ + function visitCommaListExpression(node, expressionResultIsUnused) { + if (expressionResultIsUnused) { + return ts.visitEachChild(node, visitorWithUnusedExpressionResult, context); + } + var result; + for (var i = 0; i < node.elements.length; i++) { + var element = node.elements[i]; + var visited = ts.visitNode(element, i < node.elements.length - 1 ? visitorWithUnusedExpressionResult : visitor, ts.isExpression); + if (result || visited !== element) { + result || (result = node.elements.slice(0, i)); + result.push(visited); + } + } + var elements = result ? ts.setTextRange(factory.createNodeArray(result), node.elements) : node.elements; + return factory.updateCommaListExpression(node, elements); + } + function isVariableStatementOfTypeScriptClassWrapper(node) { + return node.declarationList.declarations.length === 1 + && !!node.declarationList.declarations[0].initializer + && !!(ts.getEmitFlags(node.declarationList.declarations[0].initializer) & 33554432 /* EmitFlags.TypeScriptClassWrapper */); + } + function visitVariableStatement(node) { + var ancestorFacts = enterSubtree(0 /* HierarchyFacts.None */, ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */) ? 32 /* HierarchyFacts.ExportedVariableStatement */ : 0 /* HierarchyFacts.None */); + var updated; + if (convertedLoopState && (node.declarationList.flags & 3 /* NodeFlags.BlockScoped */) === 0 && !isVariableStatementOfTypeScriptClassWrapper(node)) { + // we are inside a converted loop - hoist variable declarations + var assignments = void 0; + for (var _i = 0, _a = node.declarationList.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + hoistVariableDeclarationDeclaredInConvertedLoop(convertedLoopState, decl); + if (decl.initializer) { + var assignment = void 0; + if (ts.isBindingPattern(decl.name)) { + assignment = ts.flattenDestructuringAssignment(decl, visitor, context, 0 /* FlattenLevel.All */); + } + else { + assignment = factory.createBinaryExpression(decl.name, 63 /* SyntaxKind.EqualsToken */, ts.visitNode(decl.initializer, visitor, ts.isExpression)); + ts.setTextRange(assignment, decl); + } + assignments = ts.append(assignments, assignment); + } + } + if (assignments) { + updated = ts.setTextRange(factory.createExpressionStatement(factory.inlineExpressions(assignments)), node); + } + else { + // none of declarations has initializer - the entire variable statement can be deleted + updated = undefined; + } + } + else { + updated = ts.visitEachChild(node, visitor, context); + } + exitSubtree(ancestorFacts, 0 /* HierarchyFacts.None */, 0 /* HierarchyFacts.None */); + return updated; + } + /** + * Visits a VariableDeclarationList that is block scoped (e.g. `let` or `const`). + * + * @param node A VariableDeclarationList node. + */ + function visitVariableDeclarationList(node) { + if (node.flags & 3 /* NodeFlags.BlockScoped */ || node.transformFlags & 524288 /* TransformFlags.ContainsBindingPattern */) { + if (node.flags & 3 /* NodeFlags.BlockScoped */) { + enableSubstitutionsForBlockScopedBindings(); + } + var declarations = ts.flatMap(node.declarations, node.flags & 1 /* NodeFlags.Let */ + ? visitVariableDeclarationInLetDeclarationList + : visitVariableDeclaration); + var declarationList = factory.createVariableDeclarationList(declarations); + ts.setOriginalNode(declarationList, node); + ts.setTextRange(declarationList, node); + ts.setCommentRange(declarationList, node); + // If the first or last declaration is a binding pattern, we need to modify + // the source map range for the declaration list. + if (node.transformFlags & 524288 /* TransformFlags.ContainsBindingPattern */ + && (ts.isBindingPattern(node.declarations[0].name) || ts.isBindingPattern(ts.last(node.declarations).name))) { + ts.setSourceMapRange(declarationList, getRangeUnion(declarations)); + } + return declarationList; + } + return ts.visitEachChild(node, visitor, context); + } + function getRangeUnion(declarations) { + // declarations may not be sorted by position. + // pos should be the minimum* position over all nodes (that's not -1), end should be the maximum end over all nodes. + var pos = -1, end = -1; + for (var _i = 0, declarations_10 = declarations; _i < declarations_10.length; _i++) { + var node = declarations_10[_i]; + pos = pos === -1 ? node.pos : node.pos === -1 ? pos : Math.min(pos, node.pos); + end = Math.max(end, node.end); + } + return ts.createRange(pos, end); + } + /** + * Gets a value indicating whether we should emit an explicit initializer for a variable + * declaration in a `let` declaration list. + * + * @param node A VariableDeclaration node. + */ + function shouldEmitExplicitInitializerForLetDeclaration(node) { + // Nested let bindings might need to be initialized explicitly to preserve + // ES6 semantic: + // + // { let x = 1; } + // { let x; } // x here should be undefined. not 1 + // + // Top level bindings never collide with anything and thus don't require + // explicit initialization. As for nested let bindings there are two cases: + // + // - Nested let bindings that were not renamed definitely should be + // initialized explicitly: + // + // { let x = 1; } + // { let x; if (some-condition) { x = 1}; if (x) { /*1*/ } } + // + // Without explicit initialization code in /*1*/ can be executed even if + // some-condition is evaluated to false. + // + // - Renaming introduces fresh name that should not collide with any + // existing names, however renamed bindings sometimes also should be + // explicitly initialized. One particular case: non-captured binding + // declared inside loop body (but not in loop initializer): + // + // let x; + // for (;;) { + // let x; + // } + // + // In downlevel codegen inner 'x' will be renamed so it won't collide + // with outer 'x' however it will should be reset on every iteration as + // if it was declared anew. + // + // * Why non-captured binding? + // - Because if loop contains block scoped binding captured in some + // function then loop body will be rewritten to have a fresh scope + // on every iteration so everything will just work. + // + // * Why loop initializer is excluded? + // - Since we've introduced a fresh name it already will be undefined. + var flags = resolver.getNodeCheckFlags(node); + var isCapturedInFunction = flags & 262144 /* NodeCheckFlags.CapturedBlockScopedBinding */; + var isDeclaredInLoop = flags & 524288 /* NodeCheckFlags.BlockScopedBindingInLoop */; + var emittedAsTopLevel = (hierarchyFacts & 64 /* HierarchyFacts.TopLevel */) !== 0 + || (isCapturedInFunction + && isDeclaredInLoop + && (hierarchyFacts & 512 /* HierarchyFacts.IterationStatementBlock */) !== 0); + var emitExplicitInitializer = !emittedAsTopLevel + && (hierarchyFacts & 4096 /* HierarchyFacts.ForInOrForOfStatement */) === 0 + && (!resolver.isDeclarationWithCollidingName(node) + || (isDeclaredInLoop + && !isCapturedInFunction + && (hierarchyFacts & (2048 /* HierarchyFacts.ForStatement */ | 4096 /* HierarchyFacts.ForInOrForOfStatement */)) === 0)); + return emitExplicitInitializer; + } + /** + * Visits a VariableDeclaration in a `let` declaration list. + * + * @param node A VariableDeclaration node. + */ + function visitVariableDeclarationInLetDeclarationList(node) { + // For binding pattern names that lack initializers there is no point to emit + // explicit initializer since downlevel codegen for destructuring will fail + // in the absence of initializer so all binding elements will say uninitialized + var name = node.name; + if (ts.isBindingPattern(name)) { + return visitVariableDeclaration(node); + } + if (!node.initializer && shouldEmitExplicitInitializerForLetDeclaration(node)) { + return factory.updateVariableDeclaration(node, node.name, /*exclamationToken*/ undefined, /*type*/ undefined, factory.createVoidZero()); + } + return ts.visitEachChild(node, visitor, context); + } + /** + * Visits a VariableDeclaration node with a binding pattern. + * + * @param node A VariableDeclaration node. + */ + function visitVariableDeclaration(node) { + var ancestorFacts = enterSubtree(32 /* HierarchyFacts.ExportedVariableStatement */, 0 /* HierarchyFacts.None */); + var updated; + if (ts.isBindingPattern(node.name)) { + updated = ts.flattenDestructuringBinding(node, visitor, context, 0 /* FlattenLevel.All */, + /*value*/ undefined, (ancestorFacts & 32 /* HierarchyFacts.ExportedVariableStatement */) !== 0); + } + else { + updated = ts.visitEachChild(node, visitor, context); + } + exitSubtree(ancestorFacts, 0 /* HierarchyFacts.None */, 0 /* HierarchyFacts.None */); + return updated; + } + function recordLabel(node) { + convertedLoopState.labels.set(ts.idText(node.label), true); + } + function resetLabel(node) { + convertedLoopState.labels.set(ts.idText(node.label), false); + } + function visitLabeledStatement(node) { + if (convertedLoopState && !convertedLoopState.labels) { + convertedLoopState.labels = new ts.Map(); + } + var statement = ts.unwrapInnermostStatementOfLabel(node, convertedLoopState && recordLabel); + return ts.isIterationStatement(statement, /*lookInLabeledStatements*/ false) + ? visitIterationStatement(statement, /*outermostLabeledStatement*/ node) + : factory.restoreEnclosingLabel(ts.visitNode(statement, visitor, ts.isStatement, factory.liftToBlock), node, convertedLoopState && resetLabel); + } + function visitIterationStatement(node, outermostLabeledStatement) { + switch (node.kind) { + case 243 /* SyntaxKind.DoStatement */: + case 244 /* SyntaxKind.WhileStatement */: + return visitDoOrWhileStatement(node, outermostLabeledStatement); + case 245 /* SyntaxKind.ForStatement */: + return visitForStatement(node, outermostLabeledStatement); + case 246 /* SyntaxKind.ForInStatement */: + return visitForInStatement(node, outermostLabeledStatement); + case 247 /* SyntaxKind.ForOfStatement */: + return visitForOfStatement(node, outermostLabeledStatement); + } + } + function visitIterationStatementWithFacts(excludeFacts, includeFacts, node, outermostLabeledStatement, convert) { + var ancestorFacts = enterSubtree(excludeFacts, includeFacts); + var updated = convertIterationStatementBodyIfNecessary(node, outermostLabeledStatement, ancestorFacts, convert); + exitSubtree(ancestorFacts, 0 /* HierarchyFacts.None */, 0 /* HierarchyFacts.None */); + return updated; + } + function visitDoOrWhileStatement(node, outermostLabeledStatement) { + return visitIterationStatementWithFacts(0 /* HierarchyFacts.DoOrWhileStatementExcludes */, 1280 /* HierarchyFacts.DoOrWhileStatementIncludes */, node, outermostLabeledStatement); + } + function visitForStatement(node, outermostLabeledStatement) { + return visitIterationStatementWithFacts(5056 /* HierarchyFacts.ForStatementExcludes */, 3328 /* HierarchyFacts.ForStatementIncludes */, node, outermostLabeledStatement); + } + function visitEachChildOfForStatement(node) { + return factory.updateForStatement(node, ts.visitNode(node.initializer, visitorWithUnusedExpressionResult, ts.isForInitializer), ts.visitNode(node.condition, visitor, ts.isExpression), ts.visitNode(node.incrementor, visitorWithUnusedExpressionResult, ts.isExpression), ts.visitNode(node.statement, visitor, ts.isStatement, factory.liftToBlock)); + } + function visitForInStatement(node, outermostLabeledStatement) { + return visitIterationStatementWithFacts(3008 /* HierarchyFacts.ForInOrForOfStatementExcludes */, 5376 /* HierarchyFacts.ForInOrForOfStatementIncludes */, node, outermostLabeledStatement); + } + function visitForOfStatement(node, outermostLabeledStatement) { + return visitIterationStatementWithFacts(3008 /* HierarchyFacts.ForInOrForOfStatementExcludes */, 5376 /* HierarchyFacts.ForInOrForOfStatementIncludes */, node, outermostLabeledStatement, compilerOptions.downlevelIteration ? convertForOfStatementForIterable : convertForOfStatementForArray); + } + function convertForOfStatementHead(node, boundValue, convertedLoopBodyStatements) { + var statements = []; + var initializer = node.initializer; + if (ts.isVariableDeclarationList(initializer)) { + if (node.initializer.flags & 3 /* NodeFlags.BlockScoped */) { + enableSubstitutionsForBlockScopedBindings(); + } + var firstOriginalDeclaration = ts.firstOrUndefined(initializer.declarations); + if (firstOriginalDeclaration && ts.isBindingPattern(firstOriginalDeclaration.name)) { + // This works whether the declaration is a var, let, or const. + // It will use rhsIterationValue _a[_i] as the initializer. + var declarations = ts.flattenDestructuringBinding(firstOriginalDeclaration, visitor, context, 0 /* FlattenLevel.All */, boundValue); + var declarationList = ts.setTextRange(factory.createVariableDeclarationList(declarations), node.initializer); + ts.setOriginalNode(declarationList, node.initializer); + // Adjust the source map range for the first declaration to align with the old + // emitter. + ts.setSourceMapRange(declarationList, ts.createRange(declarations[0].pos, ts.last(declarations).end)); + statements.push(factory.createVariableStatement( + /*modifiers*/ undefined, declarationList)); + } + else { + // The following call does not include the initializer, so we have + // to emit it separately. + statements.push(ts.setTextRange(factory.createVariableStatement( + /*modifiers*/ undefined, ts.setOriginalNode(ts.setTextRange(factory.createVariableDeclarationList([ + factory.createVariableDeclaration(firstOriginalDeclaration ? firstOriginalDeclaration.name : factory.createTempVariable(/*recordTempVariable*/ undefined), + /*exclamationToken*/ undefined, + /*type*/ undefined, boundValue) + ]), ts.moveRangePos(initializer, -1)), initializer)), ts.moveRangeEnd(initializer, -1))); + } + } + else { + // Initializer is an expression. Emit the expression in the body, so that it's + // evaluated on every iteration. + var assignment = factory.createAssignment(initializer, boundValue); + if (ts.isDestructuringAssignment(assignment)) { + statements.push(factory.createExpressionStatement(visitBinaryExpression(assignment, /*expressionResultIsUnused*/ true))); + } + else { + ts.setTextRangeEnd(assignment, initializer.end); + statements.push(ts.setTextRange(factory.createExpressionStatement(ts.visitNode(assignment, visitor, ts.isExpression)), ts.moveRangeEnd(initializer, -1))); + } + } + if (convertedLoopBodyStatements) { + return createSyntheticBlockForConvertedStatements(ts.addRange(statements, convertedLoopBodyStatements)); + } + else { + var statement = ts.visitNode(node.statement, visitor, ts.isStatement, factory.liftToBlock); + if (ts.isBlock(statement)) { + return factory.updateBlock(statement, ts.setTextRange(factory.createNodeArray(ts.concatenate(statements, statement.statements)), statement.statements)); + } + else { + statements.push(statement); + return createSyntheticBlockForConvertedStatements(statements); + } + } + } + function createSyntheticBlockForConvertedStatements(statements) { + return ts.setEmitFlags(factory.createBlock(factory.createNodeArray(statements), + /*multiLine*/ true), 48 /* EmitFlags.NoSourceMap */ | 384 /* EmitFlags.NoTokenSourceMaps */); + } + function convertForOfStatementForArray(node, outermostLabeledStatement, convertedLoopBodyStatements) { + // The following ES6 code: + // + // for (let v of expr) { } + // + // should be emitted as + // + // for (var _i = 0, _a = expr; _i < _a.length; _i++) { + // var v = _a[_i]; + // } + // + // where _a and _i are temps emitted to capture the RHS and the counter, + // respectively. + // When the left hand side is an expression instead of a let declaration, + // the "let v" is not emitted. + // When the left hand side is a let/const, the v is renamed if there is + // another v in scope. + // Note that all assignments to the LHS are emitted in the body, including + // all destructuring. + // Note also that because an extra statement is needed to assign to the LHS, + // for-of bodies are always emitted as blocks. + var expression = ts.visitNode(node.expression, visitor, ts.isExpression); + // In the case where the user wrote an identifier as the RHS, like this: + // + // for (let v of arr) { } + // + // we don't want to emit a temporary variable for the RHS, just use it directly. + var counter = factory.createLoopVariable(); + var rhsReference = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(expression) : factory.createTempVariable(/*recordTempVariable*/ undefined); + // The old emitter does not emit source maps for the expression + ts.setEmitFlags(expression, 48 /* EmitFlags.NoSourceMap */ | ts.getEmitFlags(expression)); + var forStatement = ts.setTextRange(factory.createForStatement( + /*initializer*/ ts.setEmitFlags(ts.setTextRange(factory.createVariableDeclarationList([ + ts.setTextRange(factory.createVariableDeclaration(counter, /*exclamationToken*/ undefined, /*type*/ undefined, factory.createNumericLiteral(0)), ts.moveRangePos(node.expression, -1)), + ts.setTextRange(factory.createVariableDeclaration(rhsReference, /*exclamationToken*/ undefined, /*type*/ undefined, expression), node.expression) + ]), node.expression), 2097152 /* EmitFlags.NoHoisting */), + /*condition*/ ts.setTextRange(factory.createLessThan(counter, factory.createPropertyAccessExpression(rhsReference, "length")), node.expression), + /*incrementor*/ ts.setTextRange(factory.createPostfixIncrement(counter), node.expression), + /*statement*/ convertForOfStatementHead(node, factory.createElementAccessExpression(rhsReference, counter), convertedLoopBodyStatements)), + /*location*/ node); + // Disable trailing source maps for the OpenParenToken to align source map emit with the old emitter. + ts.setEmitFlags(forStatement, 256 /* EmitFlags.NoTokenTrailingSourceMaps */); + ts.setTextRange(forStatement, node); + return factory.restoreEnclosingLabel(forStatement, outermostLabeledStatement, convertedLoopState && resetLabel); + } + function convertForOfStatementForIterable(node, outermostLabeledStatement, convertedLoopBodyStatements, ancestorFacts) { + var expression = ts.visitNode(node.expression, visitor, ts.isExpression); + var iterator = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(expression) : factory.createTempVariable(/*recordTempVariable*/ undefined); + var result = ts.isIdentifier(expression) ? factory.getGeneratedNameForNode(iterator) : factory.createTempVariable(/*recordTempVariable*/ undefined); + var errorRecord = factory.createUniqueName("e"); + var catchVariable = factory.getGeneratedNameForNode(errorRecord); + var returnMethod = factory.createTempVariable(/*recordTempVariable*/ undefined); + var values = ts.setTextRange(emitHelpers().createValuesHelper(expression), node.expression); + var next = factory.createCallExpression(factory.createPropertyAccessExpression(iterator, "next"), /*typeArguments*/ undefined, []); + hoistVariableDeclaration(errorRecord); + hoistVariableDeclaration(returnMethod); + // if we are enclosed in an outer loop ensure we reset 'errorRecord' per each iteration + var initializer = ancestorFacts & 1024 /* HierarchyFacts.IterationContainer */ + ? factory.inlineExpressions([factory.createAssignment(errorRecord, factory.createVoidZero()), values]) + : values; + var forStatement = ts.setEmitFlags(ts.setTextRange(factory.createForStatement( + /*initializer*/ ts.setEmitFlags(ts.setTextRange(factory.createVariableDeclarationList([ + ts.setTextRange(factory.createVariableDeclaration(iterator, /*exclamationToken*/ undefined, /*type*/ undefined, initializer), node.expression), + factory.createVariableDeclaration(result, /*exclamationToken*/ undefined, /*type*/ undefined, next) + ]), node.expression), 2097152 /* EmitFlags.NoHoisting */), + /*condition*/ factory.createLogicalNot(factory.createPropertyAccessExpression(result, "done")), + /*incrementor*/ factory.createAssignment(result, next), + /*statement*/ convertForOfStatementHead(node, factory.createPropertyAccessExpression(result, "value"), convertedLoopBodyStatements)), + /*location*/ node), 256 /* EmitFlags.NoTokenTrailingSourceMaps */); + return factory.createTryStatement(factory.createBlock([ + factory.restoreEnclosingLabel(forStatement, outermostLabeledStatement, convertedLoopState && resetLabel) + ]), factory.createCatchClause(factory.createVariableDeclaration(catchVariable), ts.setEmitFlags(factory.createBlock([ + factory.createExpressionStatement(factory.createAssignment(errorRecord, factory.createObjectLiteralExpression([ + factory.createPropertyAssignment("error", catchVariable) + ]))) + ]), 1 /* EmitFlags.SingleLine */)), factory.createBlock([ + factory.createTryStatement( + /*tryBlock*/ factory.createBlock([ + ts.setEmitFlags(factory.createIfStatement(factory.createLogicalAnd(factory.createLogicalAnd(result, factory.createLogicalNot(factory.createPropertyAccessExpression(result, "done"))), factory.createAssignment(returnMethod, factory.createPropertyAccessExpression(iterator, "return"))), factory.createExpressionStatement(factory.createFunctionCallCall(returnMethod, iterator, []))), 1 /* EmitFlags.SingleLine */), + ]), + /*catchClause*/ undefined, + /*finallyBlock*/ ts.setEmitFlags(factory.createBlock([ + ts.setEmitFlags(factory.createIfStatement(errorRecord, factory.createThrowStatement(factory.createPropertyAccessExpression(errorRecord, "error"))), 1 /* EmitFlags.SingleLine */) + ]), 1 /* EmitFlags.SingleLine */)) + ])); + } + /** + * Visits an ObjectLiteralExpression with computed property names. + * + * @param node An ObjectLiteralExpression node. + */ + function visitObjectLiteralExpression(node) { + var properties = node.properties; + // Find the first computed property. + // Everything until that point can be emitted as part of the initial object literal. + var numInitialProperties = -1, hasComputed = false; + for (var i = 0; i < properties.length; i++) { + var property = properties[i]; + if ((property.transformFlags & 1048576 /* TransformFlags.ContainsYield */ && + hierarchyFacts & 4 /* HierarchyFacts.AsyncFunctionBody */) + || (hasComputed = ts.Debug.checkDefined(property.name).kind === 164 /* SyntaxKind.ComputedPropertyName */)) { + numInitialProperties = i; + break; + } + } + if (numInitialProperties < 0) { + return ts.visitEachChild(node, visitor, context); + } + // For computed properties, we need to create a unique handle to the object + // literal so we can modify it without risking internal assignments tainting the object. + var temp = factory.createTempVariable(hoistVariableDeclaration); + // Write out the first non-computed properties, then emit the rest through indexing on the temp variable. + var expressions = []; + var assignment = factory.createAssignment(temp, ts.setEmitFlags(factory.createObjectLiteralExpression(ts.visitNodes(properties, visitor, ts.isObjectLiteralElementLike, 0, numInitialProperties), node.multiLine), hasComputed ? 65536 /* EmitFlags.Indented */ : 0)); + if (node.multiLine) { + ts.startOnNewLine(assignment); + } + expressions.push(assignment); + addObjectLiteralMembers(expressions, node, temp, numInitialProperties); + // We need to clone the temporary identifier so that we can write it on a + // new line + expressions.push(node.multiLine ? ts.startOnNewLine(ts.setParent(ts.setTextRange(factory.cloneNode(temp), temp), temp.parent)) : temp); + return factory.inlineExpressions(expressions); + } + function shouldConvertPartOfIterationStatement(node) { + return (resolver.getNodeCheckFlags(node) & 131072 /* NodeCheckFlags.ContainsCapturedBlockScopeBinding */) !== 0; + } + function shouldConvertInitializerOfForStatement(node) { + return ts.isForStatement(node) && !!node.initializer && shouldConvertPartOfIterationStatement(node.initializer); + } + function shouldConvertConditionOfForStatement(node) { + return ts.isForStatement(node) && !!node.condition && shouldConvertPartOfIterationStatement(node.condition); + } + function shouldConvertIncrementorOfForStatement(node) { + return ts.isForStatement(node) && !!node.incrementor && shouldConvertPartOfIterationStatement(node.incrementor); + } + function shouldConvertIterationStatement(node) { + return shouldConvertBodyOfIterationStatement(node) + || shouldConvertInitializerOfForStatement(node); + } + function shouldConvertBodyOfIterationStatement(node) { + return (resolver.getNodeCheckFlags(node) & 65536 /* NodeCheckFlags.LoopWithCapturedBlockScopedBinding */) !== 0; + } + /** + * Records constituents of name for the given variable to be hoisted in the outer scope. + */ + function hoistVariableDeclarationDeclaredInConvertedLoop(state, node) { + if (!state.hoistedLocalVariables) { + state.hoistedLocalVariables = []; + } + visit(node.name); + function visit(node) { + if (node.kind === 79 /* SyntaxKind.Identifier */) { + state.hoistedLocalVariables.push(node); + } + else { + for (var _i = 0, _a = node.elements; _i < _a.length; _i++) { + var element = _a[_i]; + if (!ts.isOmittedExpression(element)) { + visit(element.name); + } + } + } + } + } + function convertIterationStatementBodyIfNecessary(node, outermostLabeledStatement, ancestorFacts, convert) { + if (!shouldConvertIterationStatement(node)) { + var saveAllowedNonLabeledJumps = void 0; + if (convertedLoopState) { + // we get here if we are trying to emit normal loop loop inside converted loop + // set allowedNonLabeledJumps to Break | Continue to mark that break\continue inside the loop should be emitted as is + saveAllowedNonLabeledJumps = convertedLoopState.allowedNonLabeledJumps; + convertedLoopState.allowedNonLabeledJumps = 2 /* Jump.Break */ | 4 /* Jump.Continue */; + } + var result = convert + ? convert(node, outermostLabeledStatement, /*convertedLoopBodyStatements*/ undefined, ancestorFacts) + : factory.restoreEnclosingLabel(ts.isForStatement(node) ? visitEachChildOfForStatement(node) : ts.visitEachChild(node, visitor, context), outermostLabeledStatement, convertedLoopState && resetLabel); + if (convertedLoopState) { + convertedLoopState.allowedNonLabeledJumps = saveAllowedNonLabeledJumps; + } + return result; + } + var currentState = createConvertedLoopState(node); + var statements = []; + var outerConvertedLoopState = convertedLoopState; + convertedLoopState = currentState; + var initializerFunction = shouldConvertInitializerOfForStatement(node) ? createFunctionForInitializerOfForStatement(node, currentState) : undefined; + var bodyFunction = shouldConvertBodyOfIterationStatement(node) ? createFunctionForBodyOfIterationStatement(node, currentState, outerConvertedLoopState) : undefined; + convertedLoopState = outerConvertedLoopState; + if (initializerFunction) + statements.push(initializerFunction.functionDeclaration); + if (bodyFunction) + statements.push(bodyFunction.functionDeclaration); + addExtraDeclarationsForConvertedLoop(statements, currentState, outerConvertedLoopState); + if (initializerFunction) { + statements.push(generateCallToConvertedLoopInitializer(initializerFunction.functionName, initializerFunction.containsYield)); + } + var loop; + if (bodyFunction) { + if (convert) { + loop = convert(node, outermostLabeledStatement, bodyFunction.part, ancestorFacts); + } + else { + var clone_4 = convertIterationStatementCore(node, initializerFunction, factory.createBlock(bodyFunction.part, /*multiLine*/ true)); + loop = factory.restoreEnclosingLabel(clone_4, outermostLabeledStatement, convertedLoopState && resetLabel); + } + } + else { + var clone_5 = convertIterationStatementCore(node, initializerFunction, ts.visitNode(node.statement, visitor, ts.isStatement, factory.liftToBlock)); + loop = factory.restoreEnclosingLabel(clone_5, outermostLabeledStatement, convertedLoopState && resetLabel); + } + statements.push(loop); + return statements; + } + function convertIterationStatementCore(node, initializerFunction, convertedLoopBody) { + switch (node.kind) { + case 245 /* SyntaxKind.ForStatement */: return convertForStatement(node, initializerFunction, convertedLoopBody); + case 246 /* SyntaxKind.ForInStatement */: return convertForInStatement(node, convertedLoopBody); + case 247 /* SyntaxKind.ForOfStatement */: return convertForOfStatement(node, convertedLoopBody); + case 243 /* SyntaxKind.DoStatement */: return convertDoStatement(node, convertedLoopBody); + case 244 /* SyntaxKind.WhileStatement */: return convertWhileStatement(node, convertedLoopBody); + default: return ts.Debug.failBadSyntaxKind(node, "IterationStatement expected"); + } + } + function convertForStatement(node, initializerFunction, convertedLoopBody) { + var shouldConvertCondition = node.condition && shouldConvertPartOfIterationStatement(node.condition); + var shouldConvertIncrementor = shouldConvertCondition || node.incrementor && shouldConvertPartOfIterationStatement(node.incrementor); + return factory.updateForStatement(node, ts.visitNode(initializerFunction ? initializerFunction.part : node.initializer, visitorWithUnusedExpressionResult, ts.isForInitializer), ts.visitNode(shouldConvertCondition ? undefined : node.condition, visitor, ts.isExpression), ts.visitNode(shouldConvertIncrementor ? undefined : node.incrementor, visitorWithUnusedExpressionResult, ts.isExpression), convertedLoopBody); + } + function convertForOfStatement(node, convertedLoopBody) { + return factory.updateForOfStatement(node, + /*awaitModifier*/ undefined, ts.visitNode(node.initializer, visitor, ts.isForInitializer), ts.visitNode(node.expression, visitor, ts.isExpression), convertedLoopBody); + } + function convertForInStatement(node, convertedLoopBody) { + return factory.updateForInStatement(node, ts.visitNode(node.initializer, visitor, ts.isForInitializer), ts.visitNode(node.expression, visitor, ts.isExpression), convertedLoopBody); + } + function convertDoStatement(node, convertedLoopBody) { + return factory.updateDoStatement(node, convertedLoopBody, ts.visitNode(node.expression, visitor, ts.isExpression)); + } + function convertWhileStatement(node, convertedLoopBody) { + return factory.updateWhileStatement(node, ts.visitNode(node.expression, visitor, ts.isExpression), convertedLoopBody); + } + function createConvertedLoopState(node) { + var loopInitializer; + switch (node.kind) { + case 245 /* SyntaxKind.ForStatement */: + case 246 /* SyntaxKind.ForInStatement */: + case 247 /* SyntaxKind.ForOfStatement */: + var initializer = node.initializer; + if (initializer && initializer.kind === 258 /* SyntaxKind.VariableDeclarationList */) { + loopInitializer = initializer; + } + break; + } + // variables that will be passed to the loop as parameters + var loopParameters = []; + // variables declared in the loop initializer that will be changed inside the loop + var loopOutParameters = []; + if (loopInitializer && (ts.getCombinedNodeFlags(loopInitializer) & 3 /* NodeFlags.BlockScoped */)) { + var hasCapturedBindingsInForHead = shouldConvertInitializerOfForStatement(node) || + shouldConvertConditionOfForStatement(node) || + shouldConvertIncrementorOfForStatement(node); + for (var _i = 0, _a = loopInitializer.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + processLoopVariableDeclaration(node, decl, loopParameters, loopOutParameters, hasCapturedBindingsInForHead); + } + } + var currentState = { loopParameters: loopParameters, loopOutParameters: loopOutParameters }; + if (convertedLoopState) { + // convertedOuterLoopState !== undefined means that this converted loop is nested in another converted loop. + // if outer converted loop has already accumulated some state - pass it through + if (convertedLoopState.argumentsName) { + // outer loop has already used 'arguments' so we've already have some name to alias it + // use the same name in all nested loops + currentState.argumentsName = convertedLoopState.argumentsName; + } + if (convertedLoopState.thisName) { + // outer loop has already used 'this' so we've already have some name to alias it + // use the same name in all nested loops + currentState.thisName = convertedLoopState.thisName; + } + if (convertedLoopState.hoistedLocalVariables) { + // we've already collected some non-block scoped variable declarations in enclosing loop + // use the same storage in nested loop + currentState.hoistedLocalVariables = convertedLoopState.hoistedLocalVariables; + } + } + return currentState; + } + function addExtraDeclarationsForConvertedLoop(statements, state, outerState) { + var extraVariableDeclarations; + // propagate state from the inner loop to the outer loop if necessary + if (state.argumentsName) { + // if alias for arguments is set + if (outerState) { + // pass it to outer converted loop + outerState.argumentsName = state.argumentsName; + } + else { + // this is top level converted loop and we need to create an alias for 'arguments' object + (extraVariableDeclarations || (extraVariableDeclarations = [])).push(factory.createVariableDeclaration(state.argumentsName, + /*exclamationToken*/ undefined, + /*type*/ undefined, factory.createIdentifier("arguments"))); + } + } + if (state.thisName) { + // if alias for this is set + if (outerState) { + // pass it to outer converted loop + outerState.thisName = state.thisName; + } + else { + // this is top level converted loop so we need to create an alias for 'this' here + // NOTE: + // if converted loops were all nested in arrow function then we'll always emit '_this' so convertedLoopState.thisName will not be set. + // If it is set this means that all nested loops are not nested in arrow function and it is safe to capture 'this'. + (extraVariableDeclarations || (extraVariableDeclarations = [])).push(factory.createVariableDeclaration(state.thisName, + /*exclamationToken*/ undefined, + /*type*/ undefined, factory.createIdentifier("this"))); + } + } + if (state.hoistedLocalVariables) { + // if hoistedLocalVariables !== undefined this means that we've possibly collected some variable declarations to be hoisted later + if (outerState) { + // pass them to outer converted loop + outerState.hoistedLocalVariables = state.hoistedLocalVariables; + } + else { + if (!extraVariableDeclarations) { + extraVariableDeclarations = []; + } + // hoist collected variable declarations + for (var _i = 0, _a = state.hoistedLocalVariables; _i < _a.length; _i++) { + var identifier = _a[_i]; + extraVariableDeclarations.push(factory.createVariableDeclaration(identifier)); + } + } + } + // add extra variables to hold out parameters if necessary + if (state.loopOutParameters.length) { + if (!extraVariableDeclarations) { + extraVariableDeclarations = []; + } + for (var _b = 0, _c = state.loopOutParameters; _b < _c.length; _b++) { + var outParam = _c[_b]; + extraVariableDeclarations.push(factory.createVariableDeclaration(outParam.outParamName)); + } + } + if (state.conditionVariable) { + if (!extraVariableDeclarations) { + extraVariableDeclarations = []; + } + extraVariableDeclarations.push(factory.createVariableDeclaration(state.conditionVariable, /*exclamationToken*/ undefined, /*type*/ undefined, factory.createFalse())); + } + // create variable statement to hold all introduced variable declarations + if (extraVariableDeclarations) { + statements.push(factory.createVariableStatement( + /*modifiers*/ undefined, factory.createVariableDeclarationList(extraVariableDeclarations))); + } + } + function createOutVariable(p) { + return factory.createVariableDeclaration(p.originalName, /*exclamationToken*/ undefined, /*type*/ undefined, p.outParamName); + } + /** + * Creates a `_loop_init` function for a `ForStatement` with a block-scoped initializer + * that is captured in a closure inside of the initializer. The `_loop_init` function is + * used to preserve the per-iteration environment semantics of + * [13.7.4.8 RS: ForBodyEvaluation](https://tc39.github.io/ecma262/#sec-forbodyevaluation). + */ + function createFunctionForInitializerOfForStatement(node, currentState) { + var functionName = factory.createUniqueName("_loop_init"); + var containsYield = (node.initializer.transformFlags & 1048576 /* TransformFlags.ContainsYield */) !== 0; + var emitFlags = 0 /* EmitFlags.None */; + if (currentState.containsLexicalThis) + emitFlags |= 8 /* EmitFlags.CapturesThis */; + if (containsYield && hierarchyFacts & 4 /* HierarchyFacts.AsyncFunctionBody */) + emitFlags |= 262144 /* EmitFlags.AsyncFunctionBody */; + var statements = []; + statements.push(factory.createVariableStatement(/*modifiers*/ undefined, node.initializer)); + copyOutParameters(currentState.loopOutParameters, 2 /* LoopOutParameterFlags.Initializer */, 1 /* CopyDirection.ToOutParameter */, statements); + // This transforms the following ES2015 syntax: + // + // for (let i = (setImmediate(() => console.log(i)), 0); i < 2; i++) { + // // loop body + // } + // + // Into the following ES5 syntax: + // + // var _loop_init_1 = function () { + // var i = (setImmediate(() => console.log(i)), 0); + // out_i_1 = i; + // }; + // var out_i_1; + // _loop_init_1(); + // for (var i = out_i_1; i < 2; i++) { + // // loop body + // } + // + // Which prevents mutations to `i` in the per-iteration environment of the body + // from affecting the initial value for `i` outside of the per-iteration environment. + var functionDeclaration = factory.createVariableStatement( + /*modifiers*/ undefined, ts.setEmitFlags(factory.createVariableDeclarationList([ + factory.createVariableDeclaration(functionName, + /*exclamationToken*/ undefined, + /*type*/ undefined, ts.setEmitFlags(factory.createFunctionExpression( + /*modifiers*/ undefined, containsYield ? factory.createToken(41 /* SyntaxKind.AsteriskToken */) : undefined, + /*name*/ undefined, + /*typeParameters*/ undefined, + /*parameters*/ undefined, + /*type*/ undefined, ts.visitNode(factory.createBlock(statements, /*multiLine*/ true), visitor, ts.isBlock)), emitFlags)) + ]), 2097152 /* EmitFlags.NoHoisting */)); + var part = factory.createVariableDeclarationList(ts.map(currentState.loopOutParameters, createOutVariable)); + return { functionName: functionName, containsYield: containsYield, functionDeclaration: functionDeclaration, part: part }; + } + /** + * Creates a `_loop` function for an `IterationStatement` with a block-scoped initializer + * that is captured in a closure inside of the loop body. The `_loop` function is used to + * preserve the per-iteration environment semantics of + * [13.7.4.8 RS: ForBodyEvaluation](https://tc39.github.io/ecma262/#sec-forbodyevaluation). + */ + function createFunctionForBodyOfIterationStatement(node, currentState, outerState) { + var functionName = factory.createUniqueName("_loop"); + startLexicalEnvironment(); + var statement = ts.visitNode(node.statement, visitor, ts.isStatement, factory.liftToBlock); + var lexicalEnvironment = endLexicalEnvironment(); + var statements = []; + if (shouldConvertConditionOfForStatement(node) || shouldConvertIncrementorOfForStatement(node)) { + // If a block-scoped variable declared in the initializer of `node` is captured in + // the condition or incrementor, we must move the condition and incrementor into + // the body of the for loop. + // + // This transforms the following ES2015 syntax: + // + // for (let i = 0; setImmediate(() => console.log(i)), i < 2; setImmediate(() => console.log(i)), i++) { + // // loop body + // } + // + // Into the following ES5 syntax: + // + // var _loop_1 = function (i) { + // if (inc_1) + // setImmediate(() => console.log(i)), i++; + // else + // inc_1 = true; + // if (!(setImmediate(() => console.log(i)), i < 2)) + // return out_i_1 = i, "break"; + // // loop body + // out_i_1 = i; + // } + // var out_i_1, inc_1 = false; + // for (var i = 0;;) { + // var state_1 = _loop_1(i); + // i = out_i_1; + // if (state_1 === "break") + // break; + // } + // + // Which prevents mutations to `i` in the per-iteration environment of the body + // from affecting the value of `i` in the previous per-iteration environment. + // + // Note that the incrementor of a `for` loop is evaluated in a *new* per-iteration + // environment that is carried over to the next iteration of the loop. As a result, + // we must indicate whether this is the first evaluation of the loop body so that + // we only evaluate the incrementor on subsequent evaluations. + currentState.conditionVariable = factory.createUniqueName("inc"); + if (node.incrementor) { + statements.push(factory.createIfStatement(currentState.conditionVariable, factory.createExpressionStatement(ts.visitNode(node.incrementor, visitor, ts.isExpression)), factory.createExpressionStatement(factory.createAssignment(currentState.conditionVariable, factory.createTrue())))); + } + else { + statements.push(factory.createIfStatement(factory.createLogicalNot(currentState.conditionVariable), factory.createExpressionStatement(factory.createAssignment(currentState.conditionVariable, factory.createTrue())))); + } + if (shouldConvertConditionOfForStatement(node)) { + statements.push(factory.createIfStatement(factory.createPrefixUnaryExpression(53 /* SyntaxKind.ExclamationToken */, ts.visitNode(node.condition, visitor, ts.isExpression)), ts.visitNode(factory.createBreakStatement(), visitor, ts.isStatement))); + } + } + if (ts.isBlock(statement)) { + ts.addRange(statements, statement.statements); + } + else { + statements.push(statement); + } + copyOutParameters(currentState.loopOutParameters, 1 /* LoopOutParameterFlags.Body */, 1 /* CopyDirection.ToOutParameter */, statements); + ts.insertStatementsAfterStandardPrologue(statements, lexicalEnvironment); + var loopBody = factory.createBlock(statements, /*multiLine*/ true); + if (ts.isBlock(statement)) + ts.setOriginalNode(loopBody, statement); + var containsYield = (node.statement.transformFlags & 1048576 /* TransformFlags.ContainsYield */) !== 0; + var emitFlags = 524288 /* EmitFlags.ReuseTempVariableScope */; + if (currentState.containsLexicalThis) + emitFlags |= 8 /* EmitFlags.CapturesThis */; + if (containsYield && (hierarchyFacts & 4 /* HierarchyFacts.AsyncFunctionBody */) !== 0) + emitFlags |= 262144 /* EmitFlags.AsyncFunctionBody */; + // This transforms the following ES2015 syntax (in addition to other variations): + // + // for (let i = 0; i < 2; i++) { + // setImmediate(() => console.log(i)); + // } + // + // Into the following ES5 syntax: + // + // var _loop_1 = function (i) { + // setImmediate(() => console.log(i)); + // }; + // for (var i = 0; i < 2; i++) { + // _loop_1(i); + // } + var functionDeclaration = factory.createVariableStatement( + /*modifiers*/ undefined, ts.setEmitFlags(factory.createVariableDeclarationList([ + factory.createVariableDeclaration(functionName, + /*exclamationToken*/ undefined, + /*type*/ undefined, ts.setEmitFlags(factory.createFunctionExpression( + /*modifiers*/ undefined, containsYield ? factory.createToken(41 /* SyntaxKind.AsteriskToken */) : undefined, + /*name*/ undefined, + /*typeParameters*/ undefined, currentState.loopParameters, + /*type*/ undefined, loopBody), emitFlags)) + ]), 2097152 /* EmitFlags.NoHoisting */)); + var part = generateCallToConvertedLoop(functionName, currentState, outerState, containsYield); + return { functionName: functionName, containsYield: containsYield, functionDeclaration: functionDeclaration, part: part }; + } + function copyOutParameter(outParam, copyDirection) { + var source = copyDirection === 0 /* CopyDirection.ToOriginal */ ? outParam.outParamName : outParam.originalName; + var target = copyDirection === 0 /* CopyDirection.ToOriginal */ ? outParam.originalName : outParam.outParamName; + return factory.createBinaryExpression(target, 63 /* SyntaxKind.EqualsToken */, source); + } + function copyOutParameters(outParams, partFlags, copyDirection, statements) { + for (var _i = 0, outParams_1 = outParams; _i < outParams_1.length; _i++) { + var outParam = outParams_1[_i]; + if (outParam.flags & partFlags) { + statements.push(factory.createExpressionStatement(copyOutParameter(outParam, copyDirection))); + } + } + } + function generateCallToConvertedLoopInitializer(initFunctionExpressionName, containsYield) { + var call = factory.createCallExpression(initFunctionExpressionName, /*typeArguments*/ undefined, []); + var callResult = containsYield + ? factory.createYieldExpression(factory.createToken(41 /* SyntaxKind.AsteriskToken */), ts.setEmitFlags(call, 8388608 /* EmitFlags.Iterator */)) + : call; + return factory.createExpressionStatement(callResult); + } + function generateCallToConvertedLoop(loopFunctionExpressionName, state, outerState, containsYield) { + var statements = []; + // loop is considered simple if it does not have any return statements or break\continue that transfer control outside of the loop + // simple loops are emitted as just 'loop()'; + // NOTE: if loop uses only 'continue' it still will be emitted as simple loop + var isSimpleLoop = !(state.nonLocalJumps & ~4 /* Jump.Continue */) && + !state.labeledNonLocalBreaks && + !state.labeledNonLocalContinues; + var call = factory.createCallExpression(loopFunctionExpressionName, /*typeArguments*/ undefined, ts.map(state.loopParameters, function (p) { return p.name; })); + var callResult = containsYield + ? factory.createYieldExpression(factory.createToken(41 /* SyntaxKind.AsteriskToken */), ts.setEmitFlags(call, 8388608 /* EmitFlags.Iterator */)) + : call; + if (isSimpleLoop) { + statements.push(factory.createExpressionStatement(callResult)); + copyOutParameters(state.loopOutParameters, 1 /* LoopOutParameterFlags.Body */, 0 /* CopyDirection.ToOriginal */, statements); + } + else { + var loopResultName = factory.createUniqueName("state"); + var stateVariable = factory.createVariableStatement( + /*modifiers*/ undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(loopResultName, /*exclamationToken*/ undefined, /*type*/ undefined, callResult)])); + statements.push(stateVariable); + copyOutParameters(state.loopOutParameters, 1 /* LoopOutParameterFlags.Body */, 0 /* CopyDirection.ToOriginal */, statements); + if (state.nonLocalJumps & 8 /* Jump.Return */) { + var returnStatement = void 0; + if (outerState) { + outerState.nonLocalJumps |= 8 /* Jump.Return */; + returnStatement = factory.createReturnStatement(loopResultName); + } + else { + returnStatement = factory.createReturnStatement(factory.createPropertyAccessExpression(loopResultName, "value")); + } + statements.push(factory.createIfStatement(factory.createTypeCheck(loopResultName, "object"), returnStatement)); + } + if (state.nonLocalJumps & 2 /* Jump.Break */) { + statements.push(factory.createIfStatement(factory.createStrictEquality(loopResultName, factory.createStringLiteral("break")), factory.createBreakStatement())); + } + if (state.labeledNonLocalBreaks || state.labeledNonLocalContinues) { + var caseClauses = []; + processLabeledJumps(state.labeledNonLocalBreaks, /*isBreak*/ true, loopResultName, outerState, caseClauses); + processLabeledJumps(state.labeledNonLocalContinues, /*isBreak*/ false, loopResultName, outerState, caseClauses); + statements.push(factory.createSwitchStatement(loopResultName, factory.createCaseBlock(caseClauses))); + } + } + return statements; + } + function setLabeledJump(state, isBreak, labelText, labelMarker) { + if (isBreak) { + if (!state.labeledNonLocalBreaks) { + state.labeledNonLocalBreaks = new ts.Map(); + } + state.labeledNonLocalBreaks.set(labelText, labelMarker); + } + else { + if (!state.labeledNonLocalContinues) { + state.labeledNonLocalContinues = new ts.Map(); + } + state.labeledNonLocalContinues.set(labelText, labelMarker); + } + } + function processLabeledJumps(table, isBreak, loopResultName, outerLoop, caseClauses) { + if (!table) { + return; + } + table.forEach(function (labelMarker, labelText) { + var statements = []; + // if there are no outer converted loop or outer label in question is located inside outer converted loop + // then emit labeled break\continue + // otherwise propagate pair 'label -> marker' to outer converted loop and emit 'return labelMarker' so outer loop can later decide what to do + if (!outerLoop || (outerLoop.labels && outerLoop.labels.get(labelText))) { + var label = factory.createIdentifier(labelText); + statements.push(isBreak ? factory.createBreakStatement(label) : factory.createContinueStatement(label)); + } + else { + setLabeledJump(outerLoop, isBreak, labelText, labelMarker); + statements.push(factory.createReturnStatement(loopResultName)); + } + caseClauses.push(factory.createCaseClause(factory.createStringLiteral(labelMarker), statements)); + }); + } + function processLoopVariableDeclaration(container, decl, loopParameters, loopOutParameters, hasCapturedBindingsInForHead) { + var name = decl.name; + if (ts.isBindingPattern(name)) { + for (var _i = 0, _a = name.elements; _i < _a.length; _i++) { + var element = _a[_i]; + if (!ts.isOmittedExpression(element)) { + processLoopVariableDeclaration(container, element, loopParameters, loopOutParameters, hasCapturedBindingsInForHead); + } + } + } + else { + loopParameters.push(factory.createParameterDeclaration(/*modifiers*/ undefined, /*dotDotDotToken*/ undefined, name)); + var checkFlags = resolver.getNodeCheckFlags(decl); + if (checkFlags & 4194304 /* NodeCheckFlags.NeedsLoopOutParameter */ || hasCapturedBindingsInForHead) { + var outParamName = factory.createUniqueName("out_" + ts.idText(name)); + var flags = 0; + if (checkFlags & 4194304 /* NodeCheckFlags.NeedsLoopOutParameter */) { + flags |= 1 /* LoopOutParameterFlags.Body */; + } + if (ts.isForStatement(container)) { + if (container.initializer && resolver.isBindingCapturedByNode(container.initializer, decl)) { + flags |= 2 /* LoopOutParameterFlags.Initializer */; + } + if (container.condition && resolver.isBindingCapturedByNode(container.condition, decl) || + container.incrementor && resolver.isBindingCapturedByNode(container.incrementor, decl)) { + flags |= 1 /* LoopOutParameterFlags.Body */; + } + } + loopOutParameters.push({ flags: flags, originalName: name, outParamName: outParamName }); + } + } + } + /** + * Adds the members of an object literal to an array of expressions. + * + * @param expressions An array of expressions. + * @param node An ObjectLiteralExpression node. + * @param receiver The receiver for members of the ObjectLiteralExpression. + * @param numInitialNonComputedProperties The number of initial properties without + * computed property names. + */ + function addObjectLiteralMembers(expressions, node, receiver, start) { + var properties = node.properties; + var numProperties = properties.length; + for (var i = start; i < numProperties; i++) { + var property = properties[i]; + switch (property.kind) { + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + var accessors = ts.getAllAccessorDeclarations(node.properties, property); + if (property === accessors.firstAccessor) { + expressions.push(transformAccessorsToExpression(receiver, accessors, node, !!node.multiLine)); + } + break; + case 171 /* SyntaxKind.MethodDeclaration */: + expressions.push(transformObjectLiteralMethodDeclarationToExpression(property, receiver, node, node.multiLine)); + break; + case 299 /* SyntaxKind.PropertyAssignment */: + expressions.push(transformPropertyAssignmentToExpression(property, receiver, node.multiLine)); + break; + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + expressions.push(transformShorthandPropertyAssignmentToExpression(property, receiver, node.multiLine)); + break; + default: + ts.Debug.failBadSyntaxKind(node); + break; + } + } + } + /** + * Transforms a PropertyAssignment node into an expression. + * + * @param node The ObjectLiteralExpression that contains the PropertyAssignment. + * @param property The PropertyAssignment node. + * @param receiver The receiver for the assignment. + */ + function transformPropertyAssignmentToExpression(property, receiver, startsOnNewLine) { + var expression = factory.createAssignment(ts.createMemberAccessForPropertyName(factory, receiver, ts.visitNode(property.name, visitor, ts.isPropertyName)), ts.visitNode(property.initializer, visitor, ts.isExpression)); + ts.setTextRange(expression, property); + if (startsOnNewLine) { + ts.startOnNewLine(expression); + } + return expression; + } + /** + * Transforms a ShorthandPropertyAssignment node into an expression. + * + * @param node The ObjectLiteralExpression that contains the ShorthandPropertyAssignment. + * @param property The ShorthandPropertyAssignment node. + * @param receiver The receiver for the assignment. + */ + function transformShorthandPropertyAssignmentToExpression(property, receiver, startsOnNewLine) { + var expression = factory.createAssignment(ts.createMemberAccessForPropertyName(factory, receiver, ts.visitNode(property.name, visitor, ts.isPropertyName)), factory.cloneNode(property.name)); + ts.setTextRange(expression, property); + if (startsOnNewLine) { + ts.startOnNewLine(expression); + } + return expression; + } + /** + * Transforms a MethodDeclaration of an ObjectLiteralExpression into an expression. + * + * @param node The ObjectLiteralExpression that contains the MethodDeclaration. + * @param method The MethodDeclaration node. + * @param receiver The receiver for the assignment. + */ + function transformObjectLiteralMethodDeclarationToExpression(method, receiver, container, startsOnNewLine) { + var expression = factory.createAssignment(ts.createMemberAccessForPropertyName(factory, receiver, ts.visitNode(method.name, visitor, ts.isPropertyName)), transformFunctionLikeToExpression(method, /*location*/ method, /*name*/ undefined, container)); + ts.setTextRange(expression, method); + if (startsOnNewLine) { + ts.startOnNewLine(expression); + } + return expression; + } + function visitCatchClause(node) { + var ancestorFacts = enterSubtree(7104 /* HierarchyFacts.BlockScopeExcludes */, 0 /* HierarchyFacts.BlockScopeIncludes */); + var updated; + ts.Debug.assert(!!node.variableDeclaration, "Catch clause variable should always be present when downleveling ES2015."); + if (ts.isBindingPattern(node.variableDeclaration.name)) { + var temp = factory.createTempVariable(/*recordTempVariable*/ undefined); + var newVariableDeclaration = factory.createVariableDeclaration(temp); + ts.setTextRange(newVariableDeclaration, node.variableDeclaration); + var vars = ts.flattenDestructuringBinding(node.variableDeclaration, visitor, context, 0 /* FlattenLevel.All */, temp); + var list = factory.createVariableDeclarationList(vars); + ts.setTextRange(list, node.variableDeclaration); + var destructure = factory.createVariableStatement(/*modifiers*/ undefined, list); + updated = factory.updateCatchClause(node, newVariableDeclaration, addStatementToStartOfBlock(node.block, destructure)); + } + else { + updated = ts.visitEachChild(node, visitor, context); + } + exitSubtree(ancestorFacts, 0 /* HierarchyFacts.None */, 0 /* HierarchyFacts.None */); + return updated; + } + function addStatementToStartOfBlock(block, statement) { + var transformedStatements = ts.visitNodes(block.statements, visitor, ts.isStatement); + return factory.updateBlock(block, __spreadArray([statement], transformedStatements, true)); + } + /** + * Visits a MethodDeclaration of an ObjectLiteralExpression and transforms it into a + * PropertyAssignment. + * + * @param node A MethodDeclaration node. + */ + function visitMethodDeclaration(node) { + // We should only get here for methods on an object literal with regular identifier names. + // Methods on classes are handled in visitClassDeclaration/visitClassExpression. + // Methods with computed property names are handled in visitObjectLiteralExpression. + ts.Debug.assert(!ts.isComputedPropertyName(node.name)); + var functionExpression = transformFunctionLikeToExpression(node, /*location*/ ts.moveRangePos(node, -1), /*name*/ undefined, /*container*/ undefined); + ts.setEmitFlags(functionExpression, 512 /* EmitFlags.NoLeadingComments */ | ts.getEmitFlags(functionExpression)); + return ts.setTextRange(factory.createPropertyAssignment(node.name, functionExpression), + /*location*/ node); + } + /** + * Visits an AccessorDeclaration of an ObjectLiteralExpression. + * + * @param node An AccessorDeclaration node. + */ + function visitAccessorDeclaration(node) { + ts.Debug.assert(!ts.isComputedPropertyName(node.name)); + var savedConvertedLoopState = convertedLoopState; + convertedLoopState = undefined; + var ancestorFacts = enterSubtree(32670 /* HierarchyFacts.FunctionExcludes */, 65 /* HierarchyFacts.FunctionIncludes */); + var updated; + var parameters = ts.visitParameterList(node.parameters, visitor, context); + var body = transformFunctionBody(node); + if (node.kind === 174 /* SyntaxKind.GetAccessor */) { + updated = factory.updateGetAccessorDeclaration(node, node.modifiers, node.name, parameters, node.type, body); + } + else { + updated = factory.updateSetAccessorDeclaration(node, node.modifiers, node.name, parameters, body); + } + exitSubtree(ancestorFacts, 98304 /* HierarchyFacts.FunctionSubtreeExcludes */, 0 /* HierarchyFacts.None */); + convertedLoopState = savedConvertedLoopState; + return updated; + } + /** + * Visits a ShorthandPropertyAssignment and transforms it into a PropertyAssignment. + * + * @param node A ShorthandPropertyAssignment node. + */ + function visitShorthandPropertyAssignment(node) { + return ts.setTextRange(factory.createPropertyAssignment(node.name, visitIdentifier(factory.cloneNode(node.name))), + /*location*/ node); + } + function visitComputedPropertyName(node) { + return ts.visitEachChild(node, visitor, context); + } + /** + * Visits a YieldExpression node. + * + * @param node A YieldExpression node. + */ + function visitYieldExpression(node) { + // `yield` expressions are transformed using the generators transformer. + return ts.visitEachChild(node, visitor, context); + } + /** + * Visits an ArrayLiteralExpression that contains a spread element. + * + * @param node An ArrayLiteralExpression node. + */ + function visitArrayLiteralExpression(node) { + if (ts.some(node.elements, ts.isSpreadElement)) { + // We are here because we contain a SpreadElementExpression. + return transformAndSpreadElements(node.elements, /*isArgumentList*/ false, !!node.multiLine, /*hasTrailingComma*/ !!node.elements.hasTrailingComma); + } + return ts.visitEachChild(node, visitor, context); + } + /** + * Visits a CallExpression that contains either a spread element or `super`. + * + * @param node a CallExpression. + */ + function visitCallExpression(node) { + if (ts.getEmitFlags(node) & 33554432 /* EmitFlags.TypeScriptClassWrapper */) { + return visitTypeScriptClassWrapper(node); + } + var expression = ts.skipOuterExpressions(node.expression); + if (expression.kind === 106 /* SyntaxKind.SuperKeyword */ || + ts.isSuperProperty(expression) || + ts.some(node.arguments, ts.isSpreadElement)) { + return visitCallExpressionWithPotentialCapturedThisAssignment(node, /*assignToCapturedThis*/ true); + } + return factory.updateCallExpression(node, ts.visitNode(node.expression, callExpressionVisitor, ts.isExpression), + /*typeArguments*/ undefined, ts.visitNodes(node.arguments, visitor, ts.isExpression)); + } + function visitTypeScriptClassWrapper(node) { + // This is a call to a class wrapper function (an IIFE) created by the 'ts' transformer. + // The wrapper has a form similar to: + // + // (function() { + // class C { // 1 + // } + // C.x = 1; // 2 + // return C; + // }()) + // + // When we transform the class, we end up with something like this: + // + // (function () { + // var C = (function () { // 3 + // function C() { + // } + // return C; // 4 + // }()); + // C.x = 1; + // return C; + // }()) + // + // We want to simplify the two nested IIFEs to end up with something like this: + // + // (function () { + // function C() { + // } + // C.x = 1; + // return C; + // }()) + // We skip any outer expressions in a number of places to get to the innermost + // expression, but we will restore them later to preserve comments and source maps. + var body = ts.cast(ts.cast(ts.skipOuterExpressions(node.expression), ts.isArrowFunction).body, ts.isBlock); + // The class statements are the statements generated by visiting the first statement with initializer of the + // body (1), while all other statements are added to remainingStatements (2) + var isVariableStatementWithInitializer = function (stmt) { return ts.isVariableStatement(stmt) && !!ts.first(stmt.declarationList.declarations).initializer; }; + // visit the class body statements outside of any converted loop body. + var savedConvertedLoopState = convertedLoopState; + convertedLoopState = undefined; + var bodyStatements = ts.visitNodes(body.statements, classWrapperStatementVisitor, ts.isStatement); + convertedLoopState = savedConvertedLoopState; + var classStatements = ts.filter(bodyStatements, isVariableStatementWithInitializer); + var remainingStatements = ts.filter(bodyStatements, function (stmt) { return !isVariableStatementWithInitializer(stmt); }); + var varStatement = ts.cast(ts.first(classStatements), ts.isVariableStatement); + // We know there is only one variable declaration here as we verified this in an + // earlier call to isTypeScriptClassWrapper + var variable = varStatement.declarationList.declarations[0]; + var initializer = ts.skipOuterExpressions(variable.initializer); + // Under certain conditions, the 'ts' transformer may introduce a class alias, which + // we see as an assignment, for example: + // + // (function () { + // var C_1; + // var C = C_1 = (function () { + // function C() { + // } + // C.x = function () { return C_1; } + // return C; + // }()); + // C = C_1 = __decorate([dec], C); + // return C; + // }()) + // + var aliasAssignment = ts.tryCast(initializer, ts.isAssignmentExpression); + if (!aliasAssignment && ts.isBinaryExpression(initializer) && initializer.operatorToken.kind === 27 /* SyntaxKind.CommaToken */) { + aliasAssignment = ts.tryCast(initializer.left, ts.isAssignmentExpression); + } + // The underlying call (3) is another IIFE that may contain a '_super' argument. + var call = ts.cast(aliasAssignment ? ts.skipOuterExpressions(aliasAssignment.right) : initializer, ts.isCallExpression); + var func = ts.cast(ts.skipOuterExpressions(call.expression), ts.isFunctionExpression); + var funcStatements = func.body.statements; + var classBodyStart = 0; + var classBodyEnd = -1; + var statements = []; + if (aliasAssignment) { + // If we have a class alias assignment, we need to move it to the down-level constructor + // function we generated for the class. + var extendsCall = ts.tryCast(funcStatements[classBodyStart], ts.isExpressionStatement); + if (extendsCall) { + statements.push(extendsCall); + classBodyStart++; + } + // The next statement is the function declaration. + statements.push(funcStatements[classBodyStart]); + classBodyStart++; + // Add the class alias following the declaration. + statements.push(factory.createExpressionStatement(factory.createAssignment(aliasAssignment.left, ts.cast(variable.name, ts.isIdentifier)))); + } + // Find the trailing 'return' statement (4) + while (!ts.isReturnStatement(ts.elementAt(funcStatements, classBodyEnd))) { + classBodyEnd--; + } + // When we extract the statements of the inner IIFE, we exclude the 'return' statement (4) + // as we already have one that has been introduced by the 'ts' transformer. + ts.addRange(statements, funcStatements, classBodyStart, classBodyEnd); + if (classBodyEnd < -1) { + // If there were any hoisted declarations following the return statement, we should + // append them. + ts.addRange(statements, funcStatements, classBodyEnd + 1); + } + // Add the remaining statements of the outer wrapper. + ts.addRange(statements, remainingStatements); + // The 'es2015' class transform may add an end-of-declaration marker. If so we will add it + // after the remaining statements from the 'ts' transformer. + ts.addRange(statements, classStatements, /*start*/ 1); + // Recreate any outer parentheses or partially-emitted expressions to preserve source map + // and comment locations. + return factory.restoreOuterExpressions(node.expression, factory.restoreOuterExpressions(variable.initializer, factory.restoreOuterExpressions(aliasAssignment && aliasAssignment.right, factory.updateCallExpression(call, factory.restoreOuterExpressions(call.expression, factory.updateFunctionExpression(func, + /*modifiers*/ undefined, + /*asteriskToken*/ undefined, + /*name*/ undefined, + /*typeParameters*/ undefined, func.parameters, + /*type*/ undefined, factory.updateBlock(func.body, statements))), + /*typeArguments*/ undefined, call.arguments)))); + } + function visitSuperCallInBody(node) { + return visitCallExpressionWithPotentialCapturedThisAssignment(node, /*assignToCapturedThis*/ false); + } + function visitCallExpressionWithPotentialCapturedThisAssignment(node, assignToCapturedThis) { + // We are here either because SuperKeyword was used somewhere in the expression, or + // because we contain a SpreadElementExpression. + if (node.transformFlags & 32768 /* TransformFlags.ContainsRestOrSpread */ || + node.expression.kind === 106 /* SyntaxKind.SuperKeyword */ || + ts.isSuperProperty(ts.skipOuterExpressions(node.expression))) { + var _a = factory.createCallBinding(node.expression, hoistVariableDeclaration), target = _a.target, thisArg = _a.thisArg; + if (node.expression.kind === 106 /* SyntaxKind.SuperKeyword */) { + ts.setEmitFlags(thisArg, 4 /* EmitFlags.NoSubstitution */); + } + var resultingCall = void 0; + if (node.transformFlags & 32768 /* TransformFlags.ContainsRestOrSpread */) { + // [source] + // f(...a, b) + // x.m(...a, b) + // super(...a, b) + // super.m(...a, b) // in static + // super.m(...a, b) // in instance + // + // [output] + // f.apply(void 0, a.concat([b])) + // (_a = x).m.apply(_a, a.concat([b])) + // _super.apply(this, a.concat([b])) + // _super.m.apply(this, a.concat([b])) + // _super.prototype.m.apply(this, a.concat([b])) + resultingCall = factory.createFunctionApplyCall(ts.visitNode(target, callExpressionVisitor, ts.isExpression), node.expression.kind === 106 /* SyntaxKind.SuperKeyword */ ? thisArg : ts.visitNode(thisArg, visitor, ts.isExpression), transformAndSpreadElements(node.arguments, /*isArgumentList*/ true, /*multiLine*/ false, /*hasTrailingComma*/ false)); + } + else { + // [source] + // super(a) + // super.m(a) // in static + // super.m(a) // in instance + // + // [output] + // _super.call(this, a) + // _super.m.call(this, a) + // _super.prototype.m.call(this, a) + resultingCall = ts.setTextRange(factory.createFunctionCallCall(ts.visitNode(target, callExpressionVisitor, ts.isExpression), node.expression.kind === 106 /* SyntaxKind.SuperKeyword */ ? thisArg : ts.visitNode(thisArg, visitor, ts.isExpression), ts.visitNodes(node.arguments, visitor, ts.isExpression)), node); + } + if (node.expression.kind === 106 /* SyntaxKind.SuperKeyword */) { + var initializer = factory.createLogicalOr(resultingCall, createActualThis()); + resultingCall = assignToCapturedThis + ? factory.createAssignment(factory.createUniqueName("_this", 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */), initializer) + : initializer; + } + return ts.setOriginalNode(resultingCall, node); + } + return ts.visitEachChild(node, visitor, context); + } + /** + * Visits a NewExpression that contains a spread element. + * + * @param node A NewExpression node. + */ + function visitNewExpression(node) { + if (ts.some(node.arguments, ts.isSpreadElement)) { + // We are here because we contain a SpreadElementExpression. + // [source] + // new C(...a) + // + // [output] + // new ((_a = C).bind.apply(_a, [void 0].concat(a)))() + var _a = factory.createCallBinding(factory.createPropertyAccessExpression(node.expression, "bind"), hoistVariableDeclaration), target = _a.target, thisArg = _a.thisArg; + return factory.createNewExpression(factory.createFunctionApplyCall(ts.visitNode(target, visitor, ts.isExpression), thisArg, transformAndSpreadElements(factory.createNodeArray(__spreadArray([factory.createVoidZero()], node.arguments, true)), /*isArgumentList*/ true, /*multiLine*/ false, /*hasTrailingComma*/ false)), + /*typeArguments*/ undefined, []); + } + return ts.visitEachChild(node, visitor, context); + } + /** + * Transforms an array of Expression nodes that contains a SpreadExpression. + * + * @param elements The array of Expression nodes. + * @param isArgumentList A value indicating whether to ensure that the result is a fresh array. + * This should be `false` when spreading into an `ArrayLiteral`, and `true` when spreading into an + * argument list. + * @param multiLine A value indicating whether the result should be emitted on multiple lines. + */ + function transformAndSpreadElements(elements, isArgumentList, multiLine, hasTrailingComma) { + // When there is no leading SpreadElement: + // + // [source] + // [a, ...b, c] + // + // [output (downlevelIteration)] + // __spreadArray(__spreadArray([a], __read(b)), [c]) + // + // [output] + // __spreadArray(__spreadArray([a], b), [c]) + // + // When there *is* a leading SpreadElement: + // + // [source] + // [...a, b] + // + // [output (downlevelIteration)] + // __spreadArray(__spreadArray([], __read(a)), [b]) + // + // [output] + // __spreadArray(__spreadArray([], a), [b]) + // + // NOTE: We use `isPackedArrayLiteral` below rather than just `isArrayLiteral` + // because ES2015 spread will replace _missing_ array elements with `undefined`, + // so we cannot just use an array as is. For example: + // + // `[1, ...[2, , 3]]` becomes `[1, 2, undefined, 3]` + // + // However, for packed array literals (i.e., an array literal with no OmittedExpression + // elements), we can use the array as-is. + // Map spans of spread expressions into their expressions and spans of other + // expressions into an array literal. + var numElements = elements.length; + var segments = ts.flatten( + // As we visit each element, we return one of two functions to use as the "key": + // - `visitSpanOfSpreads` for one or more contiguous `...` spread expressions, i.e. `...a, ...b` in `[1, 2, ...a, ...b]` + // - `visitSpanOfNonSpreads` for one or more contiguous non-spread elements, i.e. `1, 2`, in `[1, 2, ...a, ...b]` + ts.spanMap(elements, partitionSpread, function (partition, visitPartition, _start, end) { + return visitPartition(partition, multiLine, hasTrailingComma && end === numElements); + })); + if (segments.length === 1) { + var firstSegment = segments[0]; + // If we don't need a unique copy, then we are spreading into an argument list for + // a CallExpression or NewExpression. When using `--downlevelIteration`, we need + // to coerce this into an array for use with `apply`, so we will use the code path + // that follows instead. + if (isArgumentList && !compilerOptions.downlevelIteration + || ts.isPackedArrayLiteral(firstSegment.expression) // see NOTE (above) + || ts.isCallToHelper(firstSegment.expression, "___spreadArray")) { + return firstSegment.expression; + } + } + var helpers = emitHelpers(); + var startsWithSpread = segments[0].kind !== 0 /* SpreadSegmentKind.None */; + var expression = startsWithSpread ? factory.createArrayLiteralExpression() : + segments[0].expression; + for (var i = startsWithSpread ? 0 : 1; i < segments.length; i++) { + var segment = segments[i]; + // If this is for an argument list, it doesn't matter if the array is packed or sparse + expression = helpers.createSpreadArrayHelper(expression, segment.expression, segment.kind === 1 /* SpreadSegmentKind.UnpackedSpread */ && !isArgumentList); + } + return expression; + } + function partitionSpread(node) { + return ts.isSpreadElement(node) + ? visitSpanOfSpreads + : visitSpanOfNonSpreads; + } + function visitSpanOfSpreads(chunk) { + return ts.map(chunk, visitExpressionOfSpread); + } + function visitExpressionOfSpread(node) { + var expression = ts.visitNode(node.expression, visitor, ts.isExpression); + // We don't need to pack already packed array literals, or existing calls to the `__read` helper. + var isCallToReadHelper = ts.isCallToHelper(expression, "___read"); + var kind = isCallToReadHelper || ts.isPackedArrayLiteral(expression) ? 2 /* SpreadSegmentKind.PackedSpread */ : 1 /* SpreadSegmentKind.UnpackedSpread */; + // We don't need the `__read` helper for array literals. Array packing will be performed by `__spreadArray`. + if (compilerOptions.downlevelIteration && kind === 1 /* SpreadSegmentKind.UnpackedSpread */ && !ts.isArrayLiteralExpression(expression) && !isCallToReadHelper) { + expression = emitHelpers().createReadHelper(expression, /*count*/ undefined); + // the `__read` helper returns a packed array, so we don't need to ensure a packed array + kind = 2 /* SpreadSegmentKind.PackedSpread */; + } + return createSpreadSegment(kind, expression); + } + function visitSpanOfNonSpreads(chunk, multiLine, hasTrailingComma) { + var expression = factory.createArrayLiteralExpression(ts.visitNodes(factory.createNodeArray(chunk, hasTrailingComma), visitor, ts.isExpression), multiLine); + // We do not pack non-spread segments, this is so that `[1, , ...[2, , 3], , 4]` is properly downleveled to + // `[1, , 2, undefined, 3, , 4]`. See the NOTE in `transformAndSpreadElements` + return createSpreadSegment(0 /* SpreadSegmentKind.None */, expression); + } + function visitSpreadElement(node) { + return ts.visitNode(node.expression, visitor, ts.isExpression); + } + /** + * Visits a template literal. + * + * @param node A template literal. + */ + function visitTemplateLiteral(node) { + return ts.setTextRange(factory.createStringLiteral(node.text), node); + } + /** + * Visits a string literal with an extended unicode escape. + * + * @param node A string literal. + */ + function visitStringLiteral(node) { + if (node.hasExtendedUnicodeEscape) { + return ts.setTextRange(factory.createStringLiteral(node.text), node); + } + return node; + } + /** + * Visits a binary or octal (ES6) numeric literal. + * + * @param node A string literal. + */ + function visitNumericLiteral(node) { + if (node.numericLiteralFlags & 384 /* TokenFlags.BinaryOrOctalSpecifier */) { + return ts.setTextRange(factory.createNumericLiteral(node.text), node); + } + return node; + } + /** + * Visits a TaggedTemplateExpression node. + * + * @param node A TaggedTemplateExpression node. + */ + function visitTaggedTemplateExpression(node) { + return ts.processTaggedTemplateExpression(context, node, visitor, currentSourceFile, recordTaggedTemplateString, ts.ProcessLevel.All); + } + /** + * Visits a TemplateExpression node. + * + * @param node A TemplateExpression node. + */ + function visitTemplateExpression(node) { + var expression = factory.createStringLiteral(node.head.text); + for (var _i = 0, _a = node.templateSpans; _i < _a.length; _i++) { + var span = _a[_i]; + var args = [ts.visitNode(span.expression, visitor, ts.isExpression)]; + if (span.literal.text.length > 0) { + args.push(factory.createStringLiteral(span.literal.text)); + } + expression = factory.createCallExpression(factory.createPropertyAccessExpression(expression, "concat"), + /*typeArguments*/ undefined, args); + } + return ts.setTextRange(expression, node); + } + /** + * Visits the `super` keyword + */ + function visitSuperKeyword(isExpressionOfCall) { + return hierarchyFacts & 8 /* HierarchyFacts.NonStaticClassElement */ + && !isExpressionOfCall + ? factory.createPropertyAccessExpression(factory.createUniqueName("_super", 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */), "prototype") + : factory.createUniqueName("_super", 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */); + } + function visitMetaProperty(node) { + if (node.keywordToken === 103 /* SyntaxKind.NewKeyword */ && node.name.escapedText === "target") { + hierarchyFacts |= 32768 /* HierarchyFacts.NewTarget */; + return factory.createUniqueName("_newTarget", 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */); + } + return node; + } + /** + * Called by the printer just before a node is printed. + * + * @param hint A hint as to the intended usage of the node. + * @param node The node to be printed. + * @param emitCallback The callback used to emit the node. + */ + function onEmitNode(hint, node, emitCallback) { + if (enabledSubstitutions & 1 /* ES2015SubstitutionFlags.CapturedThis */ && ts.isFunctionLike(node)) { + // If we are tracking a captured `this`, keep track of the enclosing function. + var ancestorFacts = enterSubtree(32670 /* HierarchyFacts.FunctionExcludes */, ts.getEmitFlags(node) & 8 /* EmitFlags.CapturesThis */ + ? 65 /* HierarchyFacts.FunctionIncludes */ | 16 /* HierarchyFacts.CapturesThis */ + : 65 /* HierarchyFacts.FunctionIncludes */); + previousOnEmitNode(hint, node, emitCallback); + exitSubtree(ancestorFacts, 0 /* HierarchyFacts.None */, 0 /* HierarchyFacts.None */); + return; + } + previousOnEmitNode(hint, node, emitCallback); + } + /** + * Enables a more costly code path for substitutions when we determine a source file + * contains block-scoped bindings (e.g. `let` or `const`). + */ + function enableSubstitutionsForBlockScopedBindings() { + if ((enabledSubstitutions & 2 /* ES2015SubstitutionFlags.BlockScopedBindings */) === 0) { + enabledSubstitutions |= 2 /* ES2015SubstitutionFlags.BlockScopedBindings */; + context.enableSubstitution(79 /* SyntaxKind.Identifier */); + } + } + /** + * Enables a more costly code path for substitutions when we determine a source file + * contains a captured `this`. + */ + function enableSubstitutionsForCapturedThis() { + if ((enabledSubstitutions & 1 /* ES2015SubstitutionFlags.CapturedThis */) === 0) { + enabledSubstitutions |= 1 /* ES2015SubstitutionFlags.CapturedThis */; + context.enableSubstitution(108 /* SyntaxKind.ThisKeyword */); + context.enableEmitNotification(173 /* SyntaxKind.Constructor */); + context.enableEmitNotification(171 /* SyntaxKind.MethodDeclaration */); + context.enableEmitNotification(174 /* SyntaxKind.GetAccessor */); + context.enableEmitNotification(175 /* SyntaxKind.SetAccessor */); + context.enableEmitNotification(216 /* SyntaxKind.ArrowFunction */); + context.enableEmitNotification(215 /* SyntaxKind.FunctionExpression */); + context.enableEmitNotification(259 /* SyntaxKind.FunctionDeclaration */); + } + } + /** + * Hooks node substitutions. + * + * @param hint The context for the emitter. + * @param node The node to substitute. + */ + function onSubstituteNode(hint, node) { + node = previousOnSubstituteNode(hint, node); + if (hint === 1 /* EmitHint.Expression */) { + return substituteExpression(node); + } + if (ts.isIdentifier(node)) { + return substituteIdentifier(node); + } + return node; + } + /** + * Hooks substitutions for non-expression identifiers. + */ + function substituteIdentifier(node) { + // Only substitute the identifier if we have enabled substitutions for block-scoped + // bindings. + if (enabledSubstitutions & 2 /* ES2015SubstitutionFlags.BlockScopedBindings */ && !ts.isInternalName(node)) { + var original = ts.getParseTreeNode(node, ts.isIdentifier); + if (original && isNameOfDeclarationWithCollidingName(original)) { + return ts.setTextRange(factory.getGeneratedNameForNode(original), node); + } + } + return node; + } + /** + * Determines whether a name is the name of a declaration with a colliding name. + * NOTE: This function expects to be called with an original source tree node. + * + * @param node An original source tree node. + */ + function isNameOfDeclarationWithCollidingName(node) { + switch (node.parent.kind) { + case 205 /* SyntaxKind.BindingElement */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 257 /* SyntaxKind.VariableDeclaration */: + return node.parent.name === node + && resolver.isDeclarationWithCollidingName(node.parent); + } + return false; + } + /** + * Substitutes an expression. + * + * @param node An Expression node. + */ + function substituteExpression(node) { + switch (node.kind) { + case 79 /* SyntaxKind.Identifier */: + return substituteExpressionIdentifier(node); + case 108 /* SyntaxKind.ThisKeyword */: + return substituteThisKeyword(node); + } + return node; + } + /** + * Substitutes an expression identifier. + * + * @param node An Identifier node. + */ + function substituteExpressionIdentifier(node) { + if (enabledSubstitutions & 2 /* ES2015SubstitutionFlags.BlockScopedBindings */ && !ts.isInternalName(node)) { + var declaration = resolver.getReferencedDeclarationWithCollidingName(node); + if (declaration && !(ts.isClassLike(declaration) && isPartOfClassBody(declaration, node))) { + return ts.setTextRange(factory.getGeneratedNameForNode(ts.getNameOfDeclaration(declaration)), node); + } + } + return node; + } + function isPartOfClassBody(declaration, node) { + var currentNode = ts.getParseTreeNode(node); + if (!currentNode || currentNode === declaration || currentNode.end <= declaration.pos || currentNode.pos >= declaration.end) { + // if the node has no correlation to a parse tree node, its definitely not + // part of the body. + // if the node is outside of the document range of the declaration, its + // definitely not part of the body. + return false; + } + var blockScope = ts.getEnclosingBlockScopeContainer(declaration); + while (currentNode) { + if (currentNode === blockScope || currentNode === declaration) { + // if we are in the enclosing block scope of the declaration, we are definitely + // not inside the class body. + return false; + } + if (ts.isClassElement(currentNode) && currentNode.parent === declaration) { + return true; + } + currentNode = currentNode.parent; + } + return false; + } + /** + * Substitutes `this` when contained within an arrow function. + * + * @param node The ThisKeyword node. + */ + function substituteThisKeyword(node) { + if (enabledSubstitutions & 1 /* ES2015SubstitutionFlags.CapturedThis */ + && hierarchyFacts & 16 /* HierarchyFacts.CapturesThis */) { + return ts.setTextRange(factory.createUniqueName("_this", 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */), node); + } + return node; + } + function getClassMemberPrefix(node, member) { + return ts.isStatic(member) + ? factory.getInternalName(node) + : factory.createPropertyAccessExpression(factory.getInternalName(node), "prototype"); + } + function hasSynthesizedDefaultSuperCall(constructor, hasExtendsClause) { + if (!constructor || !hasExtendsClause) { + return false; + } + if (ts.some(constructor.parameters)) { + return false; + } + var statement = ts.firstOrUndefined(constructor.body.statements); + if (!statement || !ts.nodeIsSynthesized(statement) || statement.kind !== 241 /* SyntaxKind.ExpressionStatement */) { + return false; + } + var statementExpression = statement.expression; + if (!ts.nodeIsSynthesized(statementExpression) || statementExpression.kind !== 210 /* SyntaxKind.CallExpression */) { + return false; + } + var callTarget = statementExpression.expression; + if (!ts.nodeIsSynthesized(callTarget) || callTarget.kind !== 106 /* SyntaxKind.SuperKeyword */) { + return false; + } + var callArgument = ts.singleOrUndefined(statementExpression.arguments); + if (!callArgument || !ts.nodeIsSynthesized(callArgument) || callArgument.kind !== 227 /* SyntaxKind.SpreadElement */) { + return false; + } + var expression = callArgument.expression; + return ts.isIdentifier(expression) && expression.escapedText === "arguments"; + } + } + ts.transformES2015 = transformES2015; +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + /** + * Transforms ES5 syntax into ES3 syntax. + * + * @param context Context and state information for the transformation. + */ + function transformES5(context) { + var factory = context.factory; + var compilerOptions = context.getCompilerOptions(); + // enable emit notification only if using --jsx preserve or react-native + var previousOnEmitNode; + var noSubstitution; + if (compilerOptions.jsx === 1 /* JsxEmit.Preserve */ || compilerOptions.jsx === 3 /* JsxEmit.ReactNative */) { + previousOnEmitNode = context.onEmitNode; + context.onEmitNode = onEmitNode; + context.enableEmitNotification(283 /* SyntaxKind.JsxOpeningElement */); + context.enableEmitNotification(284 /* SyntaxKind.JsxClosingElement */); + context.enableEmitNotification(282 /* SyntaxKind.JsxSelfClosingElement */); + noSubstitution = []; + } + var previousOnSubstituteNode = context.onSubstituteNode; + context.onSubstituteNode = onSubstituteNode; + context.enableSubstitution(208 /* SyntaxKind.PropertyAccessExpression */); + context.enableSubstitution(299 /* SyntaxKind.PropertyAssignment */); + return ts.chainBundle(context, transformSourceFile); + /** + * Transforms an ES5 source file to ES3. + * + * @param node A SourceFile + */ + function transformSourceFile(node) { + return node; + } + /** + * Called by the printer just before a node is printed. + * + * @param hint A hint as to the intended usage of the node. + * @param node The node to emit. + * @param emitCallback A callback used to emit the node. + */ + function onEmitNode(hint, node, emitCallback) { + switch (node.kind) { + case 283 /* SyntaxKind.JsxOpeningElement */: + case 284 /* SyntaxKind.JsxClosingElement */: + case 282 /* SyntaxKind.JsxSelfClosingElement */: + var tagName = node.tagName; + noSubstitution[ts.getOriginalNodeId(tagName)] = true; + break; + } + previousOnEmitNode(hint, node, emitCallback); + } + /** + * Hooks node substitutions. + * + * @param hint A hint as to the intended usage of the node. + * @param node The node to substitute. + */ + function onSubstituteNode(hint, node) { + if (node.id && noSubstitution && noSubstitution[node.id]) { + return previousOnSubstituteNode(hint, node); + } + node = previousOnSubstituteNode(hint, node); + if (ts.isPropertyAccessExpression(node)) { + return substitutePropertyAccessExpression(node); + } + else if (ts.isPropertyAssignment(node)) { + return substitutePropertyAssignment(node); + } + return node; + } + /** + * Substitutes a PropertyAccessExpression whose name is a reserved word. + * + * @param node A PropertyAccessExpression + */ + function substitutePropertyAccessExpression(node) { + if (ts.isPrivateIdentifier(node.name)) { + return node; + } + var literalName = trySubstituteReservedName(node.name); + if (literalName) { + return ts.setTextRange(factory.createElementAccessExpression(node.expression, literalName), node); + } + return node; + } + /** + * Substitutes a PropertyAssignment whose name is a reserved word. + * + * @param node A PropertyAssignment + */ + function substitutePropertyAssignment(node) { + var literalName = ts.isIdentifier(node.name) && trySubstituteReservedName(node.name); + if (literalName) { + return factory.updatePropertyAssignment(node, literalName, node.initializer); + } + return node; + } + /** + * If an identifier name is a reserved word, returns a string literal for the name. + * + * @param name An Identifier + */ + function trySubstituteReservedName(name) { + var token = name.originalKeywordKind || (ts.nodeIsSynthesized(name) ? ts.stringToToken(ts.idText(name)) : undefined); + if (token !== undefined && token >= 81 /* SyntaxKind.FirstReservedWord */ && token <= 116 /* SyntaxKind.LastReservedWord */) { + return ts.setTextRange(factory.createStringLiteralFromNode(name), name); + } + return undefined; + } + } + ts.transformES5 = transformES5; +})(ts || (ts = {})); +// Transforms generator functions into a compatible ES5 representation with similar runtime +// semantics. This is accomplished by first transforming the body of each generator +// function into an intermediate representation that is the compiled into a JavaScript +// switch statement. +// +// Many functions in this transformer will contain comments indicating the expected +// intermediate representation. For illustrative purposes, the following intermediate +// language is used to define this intermediate representation: +// +// .nop - Performs no operation. +// .local NAME, ... - Define local variable declarations. +// .mark LABEL - Mark the location of a label. +// .br LABEL - Jump to a label. If jumping out of a protected +// region, all .finally blocks are executed. +// .brtrue LABEL, (x) - Jump to a label IIF the expression `x` is truthy. +// If jumping out of a protected region, all .finally +// blocks are executed. +// .brfalse LABEL, (x) - Jump to a label IIF the expression `x` is falsey. +// If jumping out of a protected region, all .finally +// blocks are executed. +// .yield (x) - Yield the value of the optional expression `x`. +// Resume at the next label. +// .yieldstar (x) - Delegate yield to the value of the optional +// expression `x`. Resume at the next label. +// NOTE: `x` must be an Iterator, not an Iterable. +// .loop CONTINUE, BREAK - Marks the beginning of a loop. Any "continue" or +// "break" abrupt completions jump to the CONTINUE or +// BREAK labels, respectively. +// .endloop - Marks the end of a loop. +// .with (x) - Marks the beginning of a WithStatement block, using +// the supplied expression. +// .endwith - Marks the end of a WithStatement. +// .switch - Marks the beginning of a SwitchStatement. +// .endswitch - Marks the end of a SwitchStatement. +// .labeled NAME - Marks the beginning of a LabeledStatement with the +// supplied name. +// .endlabeled - Marks the end of a LabeledStatement. +// .try TRY, CATCH, FINALLY, END - Marks the beginning of a protected region, and the +// labels for each block. +// .catch (x) - Marks the beginning of a catch block. +// .finally - Marks the beginning of a finally block. +// .endfinally - Marks the end of a finally block. +// .endtry - Marks the end of a protected region. +// .throw (x) - Throws the value of the expression `x`. +// .return (x) - Returns the value of the expression `x`. +// +// In addition, the illustrative intermediate representation introduces some special +// variables: +// +// %sent% - Either returns the next value sent to the generator, +// returns the result of a delegated yield, or throws +// the exception sent to the generator. +// %error% - Returns the value of the current exception in a +// catch block. +// +// This intermediate representation is then compiled into JavaScript syntax. The resulting +// compilation output looks something like the following: +// +// function f() { +// var /*locals*/; +// /*functions*/ +// return __generator(function (state) { +// switch (state.label) { +// /*cases per label*/ +// } +// }); +// } +// +// Each of the above instructions corresponds to JavaScript emit similar to the following: +// +// .local NAME | var NAME; +// -------------------------------|---------------------------------------------- +// .mark LABEL | case LABEL: +// -------------------------------|---------------------------------------------- +// .br LABEL | return [3 /*break*/, LABEL]; +// -------------------------------|---------------------------------------------- +// .brtrue LABEL, (x) | if (x) return [3 /*break*/, LABEL]; +// -------------------------------|---------------------------------------------- +// .brfalse LABEL, (x) | if (!(x)) return [3, /*break*/, LABEL]; +// -------------------------------|---------------------------------------------- +// .yield (x) | return [4 /*yield*/, x]; +// .mark RESUME | case RESUME: +// a = %sent%; | a = state.sent(); +// -------------------------------|---------------------------------------------- +// .yieldstar (x) | return [5 /*yield**/, x]; +// .mark RESUME | case RESUME: +// a = %sent%; | a = state.sent(); +// -------------------------------|---------------------------------------------- +// .with (_a) | with (_a) { +// a(); | a(); +// | } +// | state.label = LABEL; +// .mark LABEL | case LABEL: +// | with (_a) { +// b(); | b(); +// | } +// .endwith | +// -------------------------------|---------------------------------------------- +// | case 0: +// | state.trys = []; +// | ... +// .try TRY, CATCH, FINALLY, END | +// .mark TRY | case TRY: +// | state.trys.push([TRY, CATCH, FINALLY, END]); +// .nop | +// a(); | a(); +// .br END | return [3 /*break*/, END]; +// .catch (e) | +// .mark CATCH | case CATCH: +// | e = state.sent(); +// b(); | b(); +// .br END | return [3 /*break*/, END]; +// .finally | +// .mark FINALLY | case FINALLY: +// c(); | c(); +// .endfinally | return [7 /*endfinally*/]; +// .endtry | +// .mark END | case END: +/*@internal*/ +var ts; +(function (ts) { + var OpCode; + (function (OpCode) { + OpCode[OpCode["Nop"] = 0] = "Nop"; + OpCode[OpCode["Statement"] = 1] = "Statement"; + OpCode[OpCode["Assign"] = 2] = "Assign"; + OpCode[OpCode["Break"] = 3] = "Break"; + OpCode[OpCode["BreakWhenTrue"] = 4] = "BreakWhenTrue"; + OpCode[OpCode["BreakWhenFalse"] = 5] = "BreakWhenFalse"; + OpCode[OpCode["Yield"] = 6] = "Yield"; + OpCode[OpCode["YieldStar"] = 7] = "YieldStar"; + OpCode[OpCode["Return"] = 8] = "Return"; + OpCode[OpCode["Throw"] = 9] = "Throw"; + OpCode[OpCode["Endfinally"] = 10] = "Endfinally"; // Marks the end of a `finally` block + })(OpCode || (OpCode = {})); + // whether a generated code block is opening or closing at the current operation for a FunctionBuilder + var BlockAction; + (function (BlockAction) { + BlockAction[BlockAction["Open"] = 0] = "Open"; + BlockAction[BlockAction["Close"] = 1] = "Close"; + })(BlockAction || (BlockAction = {})); + // the kind for a generated code block in a FunctionBuilder + var CodeBlockKind; + (function (CodeBlockKind) { + CodeBlockKind[CodeBlockKind["Exception"] = 0] = "Exception"; + CodeBlockKind[CodeBlockKind["With"] = 1] = "With"; + CodeBlockKind[CodeBlockKind["Switch"] = 2] = "Switch"; + CodeBlockKind[CodeBlockKind["Loop"] = 3] = "Loop"; + CodeBlockKind[CodeBlockKind["Labeled"] = 4] = "Labeled"; + })(CodeBlockKind || (CodeBlockKind = {})); + // the state for a generated code exception block + var ExceptionBlockState; + (function (ExceptionBlockState) { + ExceptionBlockState[ExceptionBlockState["Try"] = 0] = "Try"; + ExceptionBlockState[ExceptionBlockState["Catch"] = 1] = "Catch"; + ExceptionBlockState[ExceptionBlockState["Finally"] = 2] = "Finally"; + ExceptionBlockState[ExceptionBlockState["Done"] = 3] = "Done"; + })(ExceptionBlockState || (ExceptionBlockState = {})); + // NOTE: changes to this enum should be reflected in the __generator helper. + var Instruction; + (function (Instruction) { + Instruction[Instruction["Next"] = 0] = "Next"; + Instruction[Instruction["Throw"] = 1] = "Throw"; + Instruction[Instruction["Return"] = 2] = "Return"; + Instruction[Instruction["Break"] = 3] = "Break"; + Instruction[Instruction["Yield"] = 4] = "Yield"; + Instruction[Instruction["YieldStar"] = 5] = "YieldStar"; + Instruction[Instruction["Catch"] = 6] = "Catch"; + Instruction[Instruction["Endfinally"] = 7] = "Endfinally"; + })(Instruction || (Instruction = {})); + function getInstructionName(instruction) { + switch (instruction) { + case 2 /* Instruction.Return */: return "return"; + case 3 /* Instruction.Break */: return "break"; + case 4 /* Instruction.Yield */: return "yield"; + case 5 /* Instruction.YieldStar */: return "yield*"; + case 7 /* Instruction.Endfinally */: return "endfinally"; + default: return undefined; // TODO: GH#18217 + } + } + function transformGenerators(context) { + var factory = context.factory, emitHelpers = context.getEmitHelperFactory, resumeLexicalEnvironment = context.resumeLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistFunctionDeclaration = context.hoistFunctionDeclaration, hoistVariableDeclaration = context.hoistVariableDeclaration; + var compilerOptions = context.getCompilerOptions(); + var languageVersion = ts.getEmitScriptTarget(compilerOptions); + var resolver = context.getEmitResolver(); + var previousOnSubstituteNode = context.onSubstituteNode; + context.onSubstituteNode = onSubstituteNode; + var renamedCatchVariables; + var renamedCatchVariableDeclarations; + var inGeneratorFunctionBody; + var inStatementContainingYield; + // The following three arrays store information about generated code blocks. + // All three arrays are correlated by their index. This approach is used over allocating + // objects to store the same information to avoid GC overhead. + // + var blocks; // Information about the code block + var blockOffsets; // The operation offset at which a code block begins or ends + var blockActions; // Whether the code block is opened or closed + var blockStack; // A stack of currently open code blocks + // Labels are used to mark locations in the code that can be the target of a Break (jump) + // operation. These are translated into case clauses in a switch statement. + // The following two arrays are correlated by their index. This approach is used over + // allocating objects to store the same information to avoid GC overhead. + // + var labelOffsets; // The operation offset at which the label is defined. + var labelExpressions; // The NumericLiteral nodes bound to each label. + var nextLabelId = 1; // The next label id to use. + // Operations store information about generated code for the function body. This + // Includes things like statements, assignments, breaks (jumps), and yields. + // The following three arrays are correlated by their index. This approach is used over + // allocating objects to store the same information to avoid GC overhead. + // + var operations; // The operation to perform. + var operationArguments; // The arguments to the operation. + var operationLocations; // The source map location for the operation. + var state; // The name of the state object used by the generator at runtime. + // The following variables store information used by the `build` function: + // + var blockIndex = 0; // The index of the current block. + var labelNumber = 0; // The current label number. + var labelNumbers; + var lastOperationWasAbrupt; // Indicates whether the last operation was abrupt (break/continue). + var lastOperationWasCompletion; // Indicates whether the last operation was a completion (return/throw). + var clauses; // The case clauses generated for labels. + var statements; // The statements for the current label. + var exceptionBlockStack; // A stack of containing exception blocks. + var currentExceptionBlock; // The current exception block. + var withBlockStack; // A stack containing `with` blocks. + return ts.chainBundle(context, transformSourceFile); + function transformSourceFile(node) { + if (node.isDeclarationFile || (node.transformFlags & 2048 /* TransformFlags.ContainsGenerator */) === 0) { + return node; + } + var visited = ts.visitEachChild(node, visitor, context); + ts.addEmitHelpers(visited, context.readEmitHelpers()); + return visited; + } + /** + * Visits a node. + * + * @param node The node to visit. + */ + function visitor(node) { + var transformFlags = node.transformFlags; + if (inStatementContainingYield) { + return visitJavaScriptInStatementContainingYield(node); + } + else if (inGeneratorFunctionBody) { + return visitJavaScriptInGeneratorFunctionBody(node); + } + else if (ts.isFunctionLikeDeclaration(node) && node.asteriskToken) { + return visitGenerator(node); + } + else if (transformFlags & 2048 /* TransformFlags.ContainsGenerator */) { + return ts.visitEachChild(node, visitor, context); + } + else { + return node; + } + } + /** + * Visits a node that is contained within a statement that contains yield. + * + * @param node The node to visit. + */ + function visitJavaScriptInStatementContainingYield(node) { + switch (node.kind) { + case 243 /* SyntaxKind.DoStatement */: + return visitDoStatement(node); + case 244 /* SyntaxKind.WhileStatement */: + return visitWhileStatement(node); + case 252 /* SyntaxKind.SwitchStatement */: + return visitSwitchStatement(node); + case 253 /* SyntaxKind.LabeledStatement */: + return visitLabeledStatement(node); + default: + return visitJavaScriptInGeneratorFunctionBody(node); + } + } + /** + * Visits a node that is contained within a generator function. + * + * @param node The node to visit. + */ + function visitJavaScriptInGeneratorFunctionBody(node) { + switch (node.kind) { + case 259 /* SyntaxKind.FunctionDeclaration */: + return visitFunctionDeclaration(node); + case 215 /* SyntaxKind.FunctionExpression */: + return visitFunctionExpression(node); + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + return visitAccessorDeclaration(node); + case 240 /* SyntaxKind.VariableStatement */: + return visitVariableStatement(node); + case 245 /* SyntaxKind.ForStatement */: + return visitForStatement(node); + case 246 /* SyntaxKind.ForInStatement */: + return visitForInStatement(node); + case 249 /* SyntaxKind.BreakStatement */: + return visitBreakStatement(node); + case 248 /* SyntaxKind.ContinueStatement */: + return visitContinueStatement(node); + case 250 /* SyntaxKind.ReturnStatement */: + return visitReturnStatement(node); + default: + if (node.transformFlags & 1048576 /* TransformFlags.ContainsYield */) { + return visitJavaScriptContainingYield(node); + } + else if (node.transformFlags & (2048 /* TransformFlags.ContainsGenerator */ | 4194304 /* TransformFlags.ContainsHoistedDeclarationOrCompletion */)) { + return ts.visitEachChild(node, visitor, context); + } + else { + return node; + } + } + } + /** + * Visits a node that contains a YieldExpression. + * + * @param node The node to visit. + */ + function visitJavaScriptContainingYield(node) { + switch (node.kind) { + case 223 /* SyntaxKind.BinaryExpression */: + return visitBinaryExpression(node); + case 354 /* SyntaxKind.CommaListExpression */: + return visitCommaListExpression(node); + case 224 /* SyntaxKind.ConditionalExpression */: + return visitConditionalExpression(node); + case 226 /* SyntaxKind.YieldExpression */: + return visitYieldExpression(node); + case 206 /* SyntaxKind.ArrayLiteralExpression */: + return visitArrayLiteralExpression(node); + case 207 /* SyntaxKind.ObjectLiteralExpression */: + return visitObjectLiteralExpression(node); + case 209 /* SyntaxKind.ElementAccessExpression */: + return visitElementAccessExpression(node); + case 210 /* SyntaxKind.CallExpression */: + return visitCallExpression(node); + case 211 /* SyntaxKind.NewExpression */: + return visitNewExpression(node); + default: + return ts.visitEachChild(node, visitor, context); + } + } + /** + * Visits a generator function. + * + * @param node The node to visit. + */ + function visitGenerator(node) { + switch (node.kind) { + case 259 /* SyntaxKind.FunctionDeclaration */: + return visitFunctionDeclaration(node); + case 215 /* SyntaxKind.FunctionExpression */: + return visitFunctionExpression(node); + default: + return ts.Debug.failBadSyntaxKind(node); + } + } + /** + * Visits a function declaration. + * + * This will be called when one of the following conditions are met: + * - The function declaration is a generator function. + * - The function declaration is contained within the body of a generator function. + * + * @param node The node to visit. + */ + function visitFunctionDeclaration(node) { + // Currently, we only support generators that were originally async functions. + if (node.asteriskToken) { + node = ts.setOriginalNode(ts.setTextRange(factory.createFunctionDeclaration(node.modifiers, + /*asteriskToken*/ undefined, node.name, + /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, visitor, context), + /*type*/ undefined, transformGeneratorFunctionBody(node.body)), + /*location*/ node), node); + } + else { + var savedInGeneratorFunctionBody = inGeneratorFunctionBody; + var savedInStatementContainingYield = inStatementContainingYield; + inGeneratorFunctionBody = false; + inStatementContainingYield = false; + node = ts.visitEachChild(node, visitor, context); + inGeneratorFunctionBody = savedInGeneratorFunctionBody; + inStatementContainingYield = savedInStatementContainingYield; + } + if (inGeneratorFunctionBody) { + // Function declarations in a generator function body are hoisted + // to the top of the lexical scope and elided from the current statement. + hoistFunctionDeclaration(node); + return undefined; + } + else { + return node; + } + } + /** + * Visits a function expression. + * + * This will be called when one of the following conditions are met: + * - The function expression is a generator function. + * - The function expression is contained within the body of a generator function. + * + * @param node The node to visit. + */ + function visitFunctionExpression(node) { + // Currently, we only support generators that were originally async functions. + if (node.asteriskToken) { + node = ts.setOriginalNode(ts.setTextRange(factory.createFunctionExpression( + /*modifiers*/ undefined, + /*asteriskToken*/ undefined, node.name, + /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, visitor, context), + /*type*/ undefined, transformGeneratorFunctionBody(node.body)), + /*location*/ node), node); + } + else { + var savedInGeneratorFunctionBody = inGeneratorFunctionBody; + var savedInStatementContainingYield = inStatementContainingYield; + inGeneratorFunctionBody = false; + inStatementContainingYield = false; + node = ts.visitEachChild(node, visitor, context); + inGeneratorFunctionBody = savedInGeneratorFunctionBody; + inStatementContainingYield = savedInStatementContainingYield; + } + return node; + } + /** + * Visits a get or set accessor declaration. + * + * This will be called when one of the following conditions are met: + * - The accessor is contained within the body of a generator function. + * + * @param node The node to visit. + */ + function visitAccessorDeclaration(node) { + var savedInGeneratorFunctionBody = inGeneratorFunctionBody; + var savedInStatementContainingYield = inStatementContainingYield; + inGeneratorFunctionBody = false; + inStatementContainingYield = false; + node = ts.visitEachChild(node, visitor, context); + inGeneratorFunctionBody = savedInGeneratorFunctionBody; + inStatementContainingYield = savedInStatementContainingYield; + return node; + } + /** + * Transforms the body of a generator function declaration. + * + * @param node The function body to transform. + */ + function transformGeneratorFunctionBody(body) { + // Save existing generator state + var statements = []; + var savedInGeneratorFunctionBody = inGeneratorFunctionBody; + var savedInStatementContainingYield = inStatementContainingYield; + var savedBlocks = blocks; + var savedBlockOffsets = blockOffsets; + var savedBlockActions = blockActions; + var savedBlockStack = blockStack; + var savedLabelOffsets = labelOffsets; + var savedLabelExpressions = labelExpressions; + var savedNextLabelId = nextLabelId; + var savedOperations = operations; + var savedOperationArguments = operationArguments; + var savedOperationLocations = operationLocations; + var savedState = state; + // Initialize generator state + inGeneratorFunctionBody = true; + inStatementContainingYield = false; + blocks = undefined; + blockOffsets = undefined; + blockActions = undefined; + blockStack = undefined; + labelOffsets = undefined; + labelExpressions = undefined; + nextLabelId = 1; + operations = undefined; + operationArguments = undefined; + operationLocations = undefined; + state = factory.createTempVariable(/*recordTempVariable*/ undefined); + // Build the generator + resumeLexicalEnvironment(); + var statementOffset = factory.copyPrologue(body.statements, statements, /*ensureUseStrict*/ false, visitor); + transformAndEmitStatements(body.statements, statementOffset); + var buildResult = build(); + ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment()); + statements.push(factory.createReturnStatement(buildResult)); + // Restore previous generator state + inGeneratorFunctionBody = savedInGeneratorFunctionBody; + inStatementContainingYield = savedInStatementContainingYield; + blocks = savedBlocks; + blockOffsets = savedBlockOffsets; + blockActions = savedBlockActions; + blockStack = savedBlockStack; + labelOffsets = savedLabelOffsets; + labelExpressions = savedLabelExpressions; + nextLabelId = savedNextLabelId; + operations = savedOperations; + operationArguments = savedOperationArguments; + operationLocations = savedOperationLocations; + state = savedState; + return ts.setTextRange(factory.createBlock(statements, body.multiLine), body); + } + /** + * Visits a variable statement. + * + * This will be called when one of the following conditions are met: + * - The variable statement is contained within the body of a generator function. + * + * @param node The node to visit. + */ + function visitVariableStatement(node) { + if (node.transformFlags & 1048576 /* TransformFlags.ContainsYield */) { + transformAndEmitVariableDeclarationList(node.declarationList); + return undefined; + } + else { + // Do not hoist custom prologues. + if (ts.getEmitFlags(node) & 1048576 /* EmitFlags.CustomPrologue */) { + return node; + } + for (var _i = 0, _a = node.declarationList.declarations; _i < _a.length; _i++) { + var variable = _a[_i]; + hoistVariableDeclaration(variable.name); + } + var variables = ts.getInitializedVariables(node.declarationList); + if (variables.length === 0) { + return undefined; + } + return ts.setSourceMapRange(factory.createExpressionStatement(factory.inlineExpressions(ts.map(variables, transformInitializedVariable))), node); + } + } + /** + * Visits a binary expression. + * + * This will be called when one of the following conditions are met: + * - The node contains a YieldExpression. + * + * @param node The node to visit. + */ + function visitBinaryExpression(node) { + var assoc = ts.getExpressionAssociativity(node); + switch (assoc) { + case 0 /* Associativity.Left */: + return visitLeftAssociativeBinaryExpression(node); + case 1 /* Associativity.Right */: + return visitRightAssociativeBinaryExpression(node); + default: + return ts.Debug.assertNever(assoc); + } + } + /** + * Visits a right-associative binary expression containing `yield`. + * + * @param node The node to visit. + */ + function visitRightAssociativeBinaryExpression(node) { + var left = node.left, right = node.right; + if (containsYield(right)) { + var target = void 0; + switch (left.kind) { + case 208 /* SyntaxKind.PropertyAccessExpression */: + // [source] + // a.b = yield; + // + // [intermediate] + // .local _a + // _a = a; + // .yield resumeLabel + // .mark resumeLabel + // _a.b = %sent%; + target = factory.updatePropertyAccessExpression(left, cacheExpression(ts.visitNode(left.expression, visitor, ts.isLeftHandSideExpression)), left.name); + break; + case 209 /* SyntaxKind.ElementAccessExpression */: + // [source] + // a[b] = yield; + // + // [intermediate] + // .local _a, _b + // _a = a; + // _b = b; + // .yield resumeLabel + // .mark resumeLabel + // _a[_b] = %sent%; + target = factory.updateElementAccessExpression(left, cacheExpression(ts.visitNode(left.expression, visitor, ts.isLeftHandSideExpression)), cacheExpression(ts.visitNode(left.argumentExpression, visitor, ts.isExpression))); + break; + default: + target = ts.visitNode(left, visitor, ts.isExpression); + break; + } + var operator = node.operatorToken.kind; + if (ts.isCompoundAssignment(operator)) { + return ts.setTextRange(factory.createAssignment(target, ts.setTextRange(factory.createBinaryExpression(cacheExpression(target), ts.getNonAssignmentOperatorForCompoundAssignment(operator), ts.visitNode(right, visitor, ts.isExpression)), node)), node); + } + else { + return factory.updateBinaryExpression(node, target, node.operatorToken, ts.visitNode(right, visitor, ts.isExpression)); + } + } + return ts.visitEachChild(node, visitor, context); + } + function visitLeftAssociativeBinaryExpression(node) { + if (containsYield(node.right)) { + if (ts.isLogicalOperator(node.operatorToken.kind)) { + return visitLogicalBinaryExpression(node); + } + else if (node.operatorToken.kind === 27 /* SyntaxKind.CommaToken */) { + return visitCommaExpression(node); + } + // [source] + // a() + (yield) + c() + // + // [intermediate] + // .local _a + // _a = a(); + // .yield resumeLabel + // _a + %sent% + c() + return factory.updateBinaryExpression(node, cacheExpression(ts.visitNode(node.left, visitor, ts.isExpression)), node.operatorToken, ts.visitNode(node.right, visitor, ts.isExpression)); + } + return ts.visitEachChild(node, visitor, context); + } + /** + * Visits a comma expression containing `yield`. + * + * @param node The node to visit. + */ + function visitCommaExpression(node) { + // [source] + // x = a(), yield, b(); + // + // [intermediate] + // a(); + // .yield resumeLabel + // .mark resumeLabel + // x = %sent%, b(); + var pendingExpressions = []; + visit(node.left); + visit(node.right); + return factory.inlineExpressions(pendingExpressions); + function visit(node) { + if (ts.isBinaryExpression(node) && node.operatorToken.kind === 27 /* SyntaxKind.CommaToken */) { + visit(node.left); + visit(node.right); + } + else { + if (containsYield(node) && pendingExpressions.length > 0) { + emitWorker(1 /* OpCode.Statement */, [factory.createExpressionStatement(factory.inlineExpressions(pendingExpressions))]); + pendingExpressions = []; + } + pendingExpressions.push(ts.visitNode(node, visitor, ts.isExpression)); + } + } + } + /** + * Visits a comma-list expression. + * + * @param node The node to visit. + */ + function visitCommaListExpression(node) { + // flattened version of `visitCommaExpression` + var pendingExpressions = []; + for (var _i = 0, _a = node.elements; _i < _a.length; _i++) { + var elem = _a[_i]; + if (ts.isBinaryExpression(elem) && elem.operatorToken.kind === 27 /* SyntaxKind.CommaToken */) { + pendingExpressions.push(visitCommaExpression(elem)); + } + else { + if (containsYield(elem) && pendingExpressions.length > 0) { + emitWorker(1 /* OpCode.Statement */, [factory.createExpressionStatement(factory.inlineExpressions(pendingExpressions))]); + pendingExpressions = []; + } + pendingExpressions.push(ts.visitNode(elem, visitor, ts.isExpression)); + } + } + return factory.inlineExpressions(pendingExpressions); + } + /** + * Visits a logical binary expression containing `yield`. + * + * @param node A node to visit. + */ + function visitLogicalBinaryExpression(node) { + // Logical binary expressions (`&&` and `||`) are shortcutting expressions and need + // to be transformed as such: + // + // [source] + // x = a() && yield; + // + // [intermediate] + // .local _a + // _a = a(); + // .brfalse resultLabel, (_a) + // .yield resumeLabel + // .mark resumeLabel + // _a = %sent%; + // .mark resultLabel + // x = _a; + // + // [source] + // x = a() || yield; + // + // [intermediate] + // .local _a + // _a = a(); + // .brtrue resultLabel, (_a) + // .yield resumeLabel + // .mark resumeLabel + // _a = %sent%; + // .mark resultLabel + // x = _a; + var resultLabel = defineLabel(); + var resultLocal = declareLocal(); + emitAssignment(resultLocal, ts.visitNode(node.left, visitor, ts.isExpression), /*location*/ node.left); + if (node.operatorToken.kind === 55 /* SyntaxKind.AmpersandAmpersandToken */) { + // Logical `&&` shortcuts when the left-hand operand is falsey. + emitBreakWhenFalse(resultLabel, resultLocal, /*location*/ node.left); + } + else { + // Logical `||` shortcuts when the left-hand operand is truthy. + emitBreakWhenTrue(resultLabel, resultLocal, /*location*/ node.left); + } + emitAssignment(resultLocal, ts.visitNode(node.right, visitor, ts.isExpression), /*location*/ node.right); + markLabel(resultLabel); + return resultLocal; + } + /** + * Visits a conditional expression containing `yield`. + * + * @param node The node to visit. + */ + function visitConditionalExpression(node) { + // [source] + // x = a() ? yield : b(); + // + // [intermediate] + // .local _a + // .brfalse whenFalseLabel, (a()) + // .yield resumeLabel + // .mark resumeLabel + // _a = %sent%; + // .br resultLabel + // .mark whenFalseLabel + // _a = b(); + // .mark resultLabel + // x = _a; + // We only need to perform a specific transformation if a `yield` expression exists + // in either the `whenTrue` or `whenFalse` branches. + // A `yield` in the condition will be handled by the normal visitor. + if (containsYield(node.whenTrue) || containsYield(node.whenFalse)) { + var whenFalseLabel = defineLabel(); + var resultLabel = defineLabel(); + var resultLocal = declareLocal(); + emitBreakWhenFalse(whenFalseLabel, ts.visitNode(node.condition, visitor, ts.isExpression), /*location*/ node.condition); + emitAssignment(resultLocal, ts.visitNode(node.whenTrue, visitor, ts.isExpression), /*location*/ node.whenTrue); + emitBreak(resultLabel); + markLabel(whenFalseLabel); + emitAssignment(resultLocal, ts.visitNode(node.whenFalse, visitor, ts.isExpression), /*location*/ node.whenFalse); + markLabel(resultLabel); + return resultLocal; + } + return ts.visitEachChild(node, visitor, context); + } + /** + * Visits a `yield` expression. + * + * @param node The node to visit. + */ + function visitYieldExpression(node) { + // [source] + // x = yield a(); + // + // [intermediate] + // .yield resumeLabel, (a()) + // .mark resumeLabel + // x = %sent%; + var resumeLabel = defineLabel(); + var expression = ts.visitNode(node.expression, visitor, ts.isExpression); + if (node.asteriskToken) { + // NOTE: `expression` must be defined for `yield*`. + var iterator = (ts.getEmitFlags(node.expression) & 8388608 /* EmitFlags.Iterator */) === 0 + ? ts.setTextRange(emitHelpers().createValuesHelper(expression), node) + : expression; + emitYieldStar(iterator, /*location*/ node); + } + else { + emitYield(expression, /*location*/ node); + } + markLabel(resumeLabel); + return createGeneratorResume(/*location*/ node); + } + /** + * Visits an ArrayLiteralExpression that contains a YieldExpression. + * + * @param node The node to visit. + */ + function visitArrayLiteralExpression(node) { + return visitElements(node.elements, /*leadingElement*/ undefined, /*location*/ undefined, node.multiLine); + } + /** + * Visits an array of expressions containing one or more YieldExpression nodes + * and returns an expression for the resulting value. + * + * @param elements The elements to visit. + * @param multiLine Whether array literals created should be emitted on multiple lines. + */ + function visitElements(elements, leadingElement, location, multiLine) { + // [source] + // ar = [1, yield, 2]; + // + // [intermediate] + // .local _a + // _a = [1]; + // .yield resumeLabel + // .mark resumeLabel + // ar = _a.concat([%sent%, 2]); + var numInitialElements = countInitialNodesWithoutYield(elements); + var temp; + if (numInitialElements > 0) { + temp = declareLocal(); + var initialElements = ts.visitNodes(elements, visitor, ts.isExpression, 0, numInitialElements); + emitAssignment(temp, factory.createArrayLiteralExpression(leadingElement + ? __spreadArray([leadingElement], initialElements, true) : initialElements)); + leadingElement = undefined; + } + var expressions = ts.reduceLeft(elements, reduceElement, [], numInitialElements); + return temp + ? factory.createArrayConcatCall(temp, [factory.createArrayLiteralExpression(expressions, multiLine)]) + : ts.setTextRange(factory.createArrayLiteralExpression(leadingElement ? __spreadArray([leadingElement], expressions, true) : expressions, multiLine), location); + function reduceElement(expressions, element) { + if (containsYield(element) && expressions.length > 0) { + var hasAssignedTemp = temp !== undefined; + if (!temp) { + temp = declareLocal(); + } + emitAssignment(temp, hasAssignedTemp + ? factory.createArrayConcatCall(temp, [factory.createArrayLiteralExpression(expressions, multiLine)]) + : factory.createArrayLiteralExpression(leadingElement ? __spreadArray([leadingElement], expressions, true) : expressions, multiLine)); + leadingElement = undefined; + expressions = []; + } + expressions.push(ts.visitNode(element, visitor, ts.isExpression)); + return expressions; + } + } + function visitObjectLiteralExpression(node) { + // [source] + // o = { + // a: 1, + // b: yield, + // c: 2 + // }; + // + // [intermediate] + // .local _a + // _a = { + // a: 1 + // }; + // .yield resumeLabel + // .mark resumeLabel + // o = (_a.b = %sent%, + // _a.c = 2, + // _a); + var properties = node.properties; + var multiLine = node.multiLine; + var numInitialProperties = countInitialNodesWithoutYield(properties); + var temp = declareLocal(); + emitAssignment(temp, factory.createObjectLiteralExpression(ts.visitNodes(properties, visitor, ts.isObjectLiteralElementLike, 0, numInitialProperties), multiLine)); + var expressions = ts.reduceLeft(properties, reduceProperty, [], numInitialProperties); + // TODO(rbuckton): Does this need to be parented? + expressions.push(multiLine ? ts.startOnNewLine(ts.setParent(ts.setTextRange(factory.cloneNode(temp), temp), temp.parent)) : temp); + return factory.inlineExpressions(expressions); + function reduceProperty(expressions, property) { + if (containsYield(property) && expressions.length > 0) { + emitStatement(factory.createExpressionStatement(factory.inlineExpressions(expressions))); + expressions = []; + } + var expression = ts.createExpressionForObjectLiteralElementLike(factory, node, property, temp); + var visited = ts.visitNode(expression, visitor, ts.isExpression); + if (visited) { + if (multiLine) { + ts.startOnNewLine(visited); + } + expressions.push(visited); + } + return expressions; + } + } + /** + * Visits an ElementAccessExpression that contains a YieldExpression. + * + * @param node The node to visit. + */ + function visitElementAccessExpression(node) { + if (containsYield(node.argumentExpression)) { + // [source] + // a = x[yield]; + // + // [intermediate] + // .local _a + // _a = x; + // .yield resumeLabel + // .mark resumeLabel + // a = _a[%sent%] + return factory.updateElementAccessExpression(node, cacheExpression(ts.visitNode(node.expression, visitor, ts.isLeftHandSideExpression)), ts.visitNode(node.argumentExpression, visitor, ts.isExpression)); + } + return ts.visitEachChild(node, visitor, context); + } + function visitCallExpression(node) { + if (!ts.isImportCall(node) && ts.forEach(node.arguments, containsYield)) { + // [source] + // a.b(1, yield, 2); + // + // [intermediate] + // .local _a, _b, _c + // _b = (_a = a).b; + // _c = [1]; + // .yield resumeLabel + // .mark resumeLabel + // _b.apply(_a, _c.concat([%sent%, 2])); + var _a = factory.createCallBinding(node.expression, hoistVariableDeclaration, languageVersion, /*cacheIdentifiers*/ true), target = _a.target, thisArg = _a.thisArg; + return ts.setOriginalNode(ts.setTextRange(factory.createFunctionApplyCall(cacheExpression(ts.visitNode(target, visitor, ts.isLeftHandSideExpression)), thisArg, visitElements(node.arguments)), node), node); + } + return ts.visitEachChild(node, visitor, context); + } + function visitNewExpression(node) { + if (ts.forEach(node.arguments, containsYield)) { + // [source] + // new a.b(1, yield, 2); + // + // [intermediate] + // .local _a, _b, _c + // _b = (_a = a.b).bind; + // _c = [1]; + // .yield resumeLabel + // .mark resumeLabel + // new (_b.apply(_a, _c.concat([%sent%, 2]))); + var _a = factory.createCallBinding(factory.createPropertyAccessExpression(node.expression, "bind"), hoistVariableDeclaration), target = _a.target, thisArg = _a.thisArg; + return ts.setOriginalNode(ts.setTextRange(factory.createNewExpression(factory.createFunctionApplyCall(cacheExpression(ts.visitNode(target, visitor, ts.isExpression)), thisArg, visitElements(node.arguments, + /*leadingElement*/ factory.createVoidZero())), + /*typeArguments*/ undefined, []), node), node); + } + return ts.visitEachChild(node, visitor, context); + } + function transformAndEmitStatements(statements, start) { + if (start === void 0) { start = 0; } + var numStatements = statements.length; + for (var i = start; i < numStatements; i++) { + transformAndEmitStatement(statements[i]); + } + } + function transformAndEmitEmbeddedStatement(node) { + if (ts.isBlock(node)) { + transformAndEmitStatements(node.statements); + } + else { + transformAndEmitStatement(node); + } + } + function transformAndEmitStatement(node) { + var savedInStatementContainingYield = inStatementContainingYield; + if (!inStatementContainingYield) { + inStatementContainingYield = containsYield(node); + } + transformAndEmitStatementWorker(node); + inStatementContainingYield = savedInStatementContainingYield; + } + function transformAndEmitStatementWorker(node) { + switch (node.kind) { + case 238 /* SyntaxKind.Block */: + return transformAndEmitBlock(node); + case 241 /* SyntaxKind.ExpressionStatement */: + return transformAndEmitExpressionStatement(node); + case 242 /* SyntaxKind.IfStatement */: + return transformAndEmitIfStatement(node); + case 243 /* SyntaxKind.DoStatement */: + return transformAndEmitDoStatement(node); + case 244 /* SyntaxKind.WhileStatement */: + return transformAndEmitWhileStatement(node); + case 245 /* SyntaxKind.ForStatement */: + return transformAndEmitForStatement(node); + case 246 /* SyntaxKind.ForInStatement */: + return transformAndEmitForInStatement(node); + case 248 /* SyntaxKind.ContinueStatement */: + return transformAndEmitContinueStatement(node); + case 249 /* SyntaxKind.BreakStatement */: + return transformAndEmitBreakStatement(node); + case 250 /* SyntaxKind.ReturnStatement */: + return transformAndEmitReturnStatement(node); + case 251 /* SyntaxKind.WithStatement */: + return transformAndEmitWithStatement(node); + case 252 /* SyntaxKind.SwitchStatement */: + return transformAndEmitSwitchStatement(node); + case 253 /* SyntaxKind.LabeledStatement */: + return transformAndEmitLabeledStatement(node); + case 254 /* SyntaxKind.ThrowStatement */: + return transformAndEmitThrowStatement(node); + case 255 /* SyntaxKind.TryStatement */: + return transformAndEmitTryStatement(node); + default: + return emitStatement(ts.visitNode(node, visitor, ts.isStatement)); + } + } + function transformAndEmitBlock(node) { + if (containsYield(node)) { + transformAndEmitStatements(node.statements); + } + else { + emitStatement(ts.visitNode(node, visitor, ts.isStatement)); + } + } + function transformAndEmitExpressionStatement(node) { + emitStatement(ts.visitNode(node, visitor, ts.isStatement)); + } + function transformAndEmitVariableDeclarationList(node) { + for (var _i = 0, _a = node.declarations; _i < _a.length; _i++) { + var variable = _a[_i]; + var name = factory.cloneNode(variable.name); + ts.setCommentRange(name, variable.name); + hoistVariableDeclaration(name); + } + var variables = ts.getInitializedVariables(node); + var numVariables = variables.length; + var variablesWritten = 0; + var pendingExpressions = []; + while (variablesWritten < numVariables) { + for (var i = variablesWritten; i < numVariables; i++) { + var variable = variables[i]; + if (containsYield(variable.initializer) && pendingExpressions.length > 0) { + break; + } + pendingExpressions.push(transformInitializedVariable(variable)); + } + if (pendingExpressions.length) { + emitStatement(factory.createExpressionStatement(factory.inlineExpressions(pendingExpressions))); + variablesWritten += pendingExpressions.length; + pendingExpressions = []; + } + } + return undefined; + } + function transformInitializedVariable(node) { + return ts.setSourceMapRange(factory.createAssignment(ts.setSourceMapRange(factory.cloneNode(node.name), node.name), ts.visitNode(node.initializer, visitor, ts.isExpression)), node); + } + function transformAndEmitIfStatement(node) { + if (containsYield(node)) { + // [source] + // if (x) + // /*thenStatement*/ + // else + // /*elseStatement*/ + // + // [intermediate] + // .brfalse elseLabel, (x) + // /*thenStatement*/ + // .br endLabel + // .mark elseLabel + // /*elseStatement*/ + // .mark endLabel + if (containsYield(node.thenStatement) || containsYield(node.elseStatement)) { + var endLabel = defineLabel(); + var elseLabel = node.elseStatement ? defineLabel() : undefined; + emitBreakWhenFalse(node.elseStatement ? elseLabel : endLabel, ts.visitNode(node.expression, visitor, ts.isExpression), /*location*/ node.expression); + transformAndEmitEmbeddedStatement(node.thenStatement); + if (node.elseStatement) { + emitBreak(endLabel); + markLabel(elseLabel); + transformAndEmitEmbeddedStatement(node.elseStatement); + } + markLabel(endLabel); + } + else { + emitStatement(ts.visitNode(node, visitor, ts.isStatement)); + } + } + else { + emitStatement(ts.visitNode(node, visitor, ts.isStatement)); + } + } + function transformAndEmitDoStatement(node) { + if (containsYield(node)) { + // [source] + // do { + // /*body*/ + // } + // while (i < 10); + // + // [intermediate] + // .loop conditionLabel, endLabel + // .mark loopLabel + // /*body*/ + // .mark conditionLabel + // .brtrue loopLabel, (i < 10) + // .endloop + // .mark endLabel + var conditionLabel = defineLabel(); + var loopLabel = defineLabel(); + beginLoopBlock(/*continueLabel*/ conditionLabel); + markLabel(loopLabel); + transformAndEmitEmbeddedStatement(node.statement); + markLabel(conditionLabel); + emitBreakWhenTrue(loopLabel, ts.visitNode(node.expression, visitor, ts.isExpression)); + endLoopBlock(); + } + else { + emitStatement(ts.visitNode(node, visitor, ts.isStatement)); + } + } + function visitDoStatement(node) { + if (inStatementContainingYield) { + beginScriptLoopBlock(); + node = ts.visitEachChild(node, visitor, context); + endLoopBlock(); + return node; + } + else { + return ts.visitEachChild(node, visitor, context); + } + } + function transformAndEmitWhileStatement(node) { + if (containsYield(node)) { + // [source] + // while (i < 10) { + // /*body*/ + // } + // + // [intermediate] + // .loop loopLabel, endLabel + // .mark loopLabel + // .brfalse endLabel, (i < 10) + // /*body*/ + // .br loopLabel + // .endloop + // .mark endLabel + var loopLabel = defineLabel(); + var endLabel = beginLoopBlock(loopLabel); + markLabel(loopLabel); + emitBreakWhenFalse(endLabel, ts.visitNode(node.expression, visitor, ts.isExpression)); + transformAndEmitEmbeddedStatement(node.statement); + emitBreak(loopLabel); + endLoopBlock(); + } + else { + emitStatement(ts.visitNode(node, visitor, ts.isStatement)); + } + } + function visitWhileStatement(node) { + if (inStatementContainingYield) { + beginScriptLoopBlock(); + node = ts.visitEachChild(node, visitor, context); + endLoopBlock(); + return node; + } + else { + return ts.visitEachChild(node, visitor, context); + } + } + function transformAndEmitForStatement(node) { + if (containsYield(node)) { + // [source] + // for (var i = 0; i < 10; i++) { + // /*body*/ + // } + // + // [intermediate] + // .local i + // i = 0; + // .loop incrementLabel, endLoopLabel + // .mark conditionLabel + // .brfalse endLoopLabel, (i < 10) + // /*body*/ + // .mark incrementLabel + // i++; + // .br conditionLabel + // .endloop + // .mark endLoopLabel + var conditionLabel = defineLabel(); + var incrementLabel = defineLabel(); + var endLabel = beginLoopBlock(incrementLabel); + if (node.initializer) { + var initializer = node.initializer; + if (ts.isVariableDeclarationList(initializer)) { + transformAndEmitVariableDeclarationList(initializer); + } + else { + emitStatement(ts.setTextRange(factory.createExpressionStatement(ts.visitNode(initializer, visitor, ts.isExpression)), initializer)); + } + } + markLabel(conditionLabel); + if (node.condition) { + emitBreakWhenFalse(endLabel, ts.visitNode(node.condition, visitor, ts.isExpression)); + } + transformAndEmitEmbeddedStatement(node.statement); + markLabel(incrementLabel); + if (node.incrementor) { + emitStatement(ts.setTextRange(factory.createExpressionStatement(ts.visitNode(node.incrementor, visitor, ts.isExpression)), node.incrementor)); + } + emitBreak(conditionLabel); + endLoopBlock(); + } + else { + emitStatement(ts.visitNode(node, visitor, ts.isStatement)); + } + } + function visitForStatement(node) { + if (inStatementContainingYield) { + beginScriptLoopBlock(); + } + var initializer = node.initializer; + if (initializer && ts.isVariableDeclarationList(initializer)) { + for (var _i = 0, _a = initializer.declarations; _i < _a.length; _i++) { + var variable = _a[_i]; + hoistVariableDeclaration(variable.name); + } + var variables = ts.getInitializedVariables(initializer); + node = factory.updateForStatement(node, variables.length > 0 + ? factory.inlineExpressions(ts.map(variables, transformInitializedVariable)) + : undefined, ts.visitNode(node.condition, visitor, ts.isExpression), ts.visitNode(node.incrementor, visitor, ts.isExpression), ts.visitIterationBody(node.statement, visitor, context)); + } + else { + node = ts.visitEachChild(node, visitor, context); + } + if (inStatementContainingYield) { + endLoopBlock(); + } + return node; + } + function transformAndEmitForInStatement(node) { + if (containsYield(node)) { + // [source] + // for (var p in o) { + // /*body*/ + // } + // + // [intermediate] + // .local _b, _a, _c, _i + // _b = []; + // _a = o; + // for (_c in _a) _b.push(_c); + // _i = 0; + // .loop incrementLabel, endLoopLabel + // .mark conditionLabel + // .brfalse endLoopLabel, (_i < _b.length) + // _c = _b[_i]; + // .brfalse incrementLabel, (_c in _a) + // p = _c; + // /*body*/ + // .mark incrementLabel + // _c++; + // .br conditionLabel + // .endloop + // .mark endLoopLabel + var obj = declareLocal(); // _a + var keysArray = declareLocal(); // _b + var key = declareLocal(); // _c + var keysIndex = factory.createLoopVariable(); // _i + var initializer = node.initializer; + hoistVariableDeclaration(keysIndex); + emitAssignment(obj, ts.visitNode(node.expression, visitor, ts.isExpression)); + emitAssignment(keysArray, factory.createArrayLiteralExpression()); + emitStatement(factory.createForInStatement(key, obj, factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(keysArray, "push"), + /*typeArguments*/ undefined, [key])))); + emitAssignment(keysIndex, factory.createNumericLiteral(0)); + var conditionLabel = defineLabel(); + var incrementLabel = defineLabel(); + var endLoopLabel = beginLoopBlock(incrementLabel); + markLabel(conditionLabel); + emitBreakWhenFalse(endLoopLabel, factory.createLessThan(keysIndex, factory.createPropertyAccessExpression(keysArray, "length"))); + emitAssignment(key, factory.createElementAccessExpression(keysArray, keysIndex)); + emitBreakWhenFalse(incrementLabel, factory.createBinaryExpression(key, 101 /* SyntaxKind.InKeyword */, obj)); + var variable = void 0; + if (ts.isVariableDeclarationList(initializer)) { + for (var _i = 0, _a = initializer.declarations; _i < _a.length; _i++) { + var variable_1 = _a[_i]; + hoistVariableDeclaration(variable_1.name); + } + variable = factory.cloneNode(initializer.declarations[0].name); + } + else { + variable = ts.visitNode(initializer, visitor, ts.isExpression); + ts.Debug.assert(ts.isLeftHandSideExpression(variable)); + } + emitAssignment(variable, key); + transformAndEmitEmbeddedStatement(node.statement); + markLabel(incrementLabel); + emitStatement(factory.createExpressionStatement(factory.createPostfixIncrement(keysIndex))); + emitBreak(conditionLabel); + endLoopBlock(); + } + else { + emitStatement(ts.visitNode(node, visitor, ts.isStatement)); + } + } + function visitForInStatement(node) { + // [source] + // for (var x in a) { + // /*body*/ + // } + // + // [intermediate] + // .local x + // .loop + // for (x in a) { + // /*body*/ + // } + // .endloop + if (inStatementContainingYield) { + beginScriptLoopBlock(); + } + var initializer = node.initializer; + if (ts.isVariableDeclarationList(initializer)) { + for (var _i = 0, _a = initializer.declarations; _i < _a.length; _i++) { + var variable = _a[_i]; + hoistVariableDeclaration(variable.name); + } + node = factory.updateForInStatement(node, initializer.declarations[0].name, ts.visitNode(node.expression, visitor, ts.isExpression), ts.visitNode(node.statement, visitor, ts.isStatement, factory.liftToBlock)); + } + else { + node = ts.visitEachChild(node, visitor, context); + } + if (inStatementContainingYield) { + endLoopBlock(); + } + return node; + } + function transformAndEmitContinueStatement(node) { + var label = findContinueTarget(node.label ? ts.idText(node.label) : undefined); + if (label > 0) { + emitBreak(label, /*location*/ node); + } + else { + // invalid continue without a containing loop. Leave the node as is, per #17875. + emitStatement(node); + } + } + function visitContinueStatement(node) { + if (inStatementContainingYield) { + var label = findContinueTarget(node.label && ts.idText(node.label)); + if (label > 0) { + return createInlineBreak(label, /*location*/ node); + } + } + return ts.visitEachChild(node, visitor, context); + } + function transformAndEmitBreakStatement(node) { + var label = findBreakTarget(node.label ? ts.idText(node.label) : undefined); + if (label > 0) { + emitBreak(label, /*location*/ node); + } + else { + // invalid break without a containing loop, switch, or labeled statement. Leave the node as is, per #17875. + emitStatement(node); + } + } + function visitBreakStatement(node) { + if (inStatementContainingYield) { + var label = findBreakTarget(node.label && ts.idText(node.label)); + if (label > 0) { + return createInlineBreak(label, /*location*/ node); + } + } + return ts.visitEachChild(node, visitor, context); + } + function transformAndEmitReturnStatement(node) { + emitReturn(ts.visitNode(node.expression, visitor, ts.isExpression), + /*location*/ node); + } + function visitReturnStatement(node) { + return createInlineReturn(ts.visitNode(node.expression, visitor, ts.isExpression), + /*location*/ node); + } + function transformAndEmitWithStatement(node) { + if (containsYield(node)) { + // [source] + // with (x) { + // /*body*/ + // } + // + // [intermediate] + // .with (x) + // /*body*/ + // .endwith + beginWithBlock(cacheExpression(ts.visitNode(node.expression, visitor, ts.isExpression))); + transformAndEmitEmbeddedStatement(node.statement); + endWithBlock(); + } + else { + emitStatement(ts.visitNode(node, visitor, ts.isStatement)); + } + } + function transformAndEmitSwitchStatement(node) { + if (containsYield(node.caseBlock)) { + // [source] + // switch (x) { + // case a: + // /*caseStatements*/ + // case b: + // /*caseStatements*/ + // default: + // /*defaultStatements*/ + // } + // + // [intermediate] + // .local _a + // .switch endLabel + // _a = x; + // switch (_a) { + // case a: + // .br clauseLabels[0] + // } + // switch (_a) { + // case b: + // .br clauseLabels[1] + // } + // .br clauseLabels[2] + // .mark clauseLabels[0] + // /*caseStatements*/ + // .mark clauseLabels[1] + // /*caseStatements*/ + // .mark clauseLabels[2] + // /*caseStatements*/ + // .endswitch + // .mark endLabel + var caseBlock = node.caseBlock; + var numClauses = caseBlock.clauses.length; + var endLabel = beginSwitchBlock(); + var expression = cacheExpression(ts.visitNode(node.expression, visitor, ts.isExpression)); + // Create labels for each clause and find the index of the first default clause. + var clauseLabels = []; + var defaultClauseIndex = -1; + for (var i = 0; i < numClauses; i++) { + var clause = caseBlock.clauses[i]; + clauseLabels.push(defineLabel()); + if (clause.kind === 293 /* SyntaxKind.DefaultClause */ && defaultClauseIndex === -1) { + defaultClauseIndex = i; + } + } + // Emit switch statements for each run of case clauses either from the first case + // clause or the next case clause with a `yield` in its expression, up to the next + // case clause with a `yield` in its expression. + var clausesWritten = 0; + var pendingClauses = []; + while (clausesWritten < numClauses) { + var defaultClausesSkipped = 0; + for (var i = clausesWritten; i < numClauses; i++) { + var clause = caseBlock.clauses[i]; + if (clause.kind === 292 /* SyntaxKind.CaseClause */) { + if (containsYield(clause.expression) && pendingClauses.length > 0) { + break; + } + pendingClauses.push(factory.createCaseClause(ts.visitNode(clause.expression, visitor, ts.isExpression), [ + createInlineBreak(clauseLabels[i], /*location*/ clause.expression) + ])); + } + else { + defaultClausesSkipped++; + } + } + if (pendingClauses.length) { + emitStatement(factory.createSwitchStatement(expression, factory.createCaseBlock(pendingClauses))); + clausesWritten += pendingClauses.length; + pendingClauses = []; + } + if (defaultClausesSkipped > 0) { + clausesWritten += defaultClausesSkipped; + defaultClausesSkipped = 0; + } + } + if (defaultClauseIndex >= 0) { + emitBreak(clauseLabels[defaultClauseIndex]); + } + else { + emitBreak(endLabel); + } + for (var i = 0; i < numClauses; i++) { + markLabel(clauseLabels[i]); + transformAndEmitStatements(caseBlock.clauses[i].statements); + } + endSwitchBlock(); + } + else { + emitStatement(ts.visitNode(node, visitor, ts.isStatement)); + } + } + function visitSwitchStatement(node) { + if (inStatementContainingYield) { + beginScriptSwitchBlock(); + } + node = ts.visitEachChild(node, visitor, context); + if (inStatementContainingYield) { + endSwitchBlock(); + } + return node; + } + function transformAndEmitLabeledStatement(node) { + if (containsYield(node)) { + // [source] + // x: { + // /*body*/ + // } + // + // [intermediate] + // .labeled "x", endLabel + // /*body*/ + // .endlabeled + // .mark endLabel + beginLabeledBlock(ts.idText(node.label)); + transformAndEmitEmbeddedStatement(node.statement); + endLabeledBlock(); + } + else { + emitStatement(ts.visitNode(node, visitor, ts.isStatement)); + } + } + function visitLabeledStatement(node) { + if (inStatementContainingYield) { + beginScriptLabeledBlock(ts.idText(node.label)); + } + node = ts.visitEachChild(node, visitor, context); + if (inStatementContainingYield) { + endLabeledBlock(); + } + return node; + } + function transformAndEmitThrowStatement(node) { + var _a; + // TODO(rbuckton): `expression` should be required on `throw`. + emitThrow(ts.visitNode((_a = node.expression) !== null && _a !== void 0 ? _a : factory.createVoidZero(), visitor, ts.isExpression), + /*location*/ node); + } + function transformAndEmitTryStatement(node) { + if (containsYield(node)) { + // [source] + // try { + // /*tryBlock*/ + // } + // catch (e) { + // /*catchBlock*/ + // } + // finally { + // /*finallyBlock*/ + // } + // + // [intermediate] + // .local _a + // .try tryLabel, catchLabel, finallyLabel, endLabel + // .mark tryLabel + // .nop + // /*tryBlock*/ + // .br endLabel + // .catch + // .mark catchLabel + // _a = %error%; + // /*catchBlock*/ + // .br endLabel + // .finally + // .mark finallyLabel + // /*finallyBlock*/ + // .endfinally + // .endtry + // .mark endLabel + beginExceptionBlock(); + transformAndEmitEmbeddedStatement(node.tryBlock); + if (node.catchClause) { + beginCatchBlock(node.catchClause.variableDeclaration); // TODO: GH#18217 + transformAndEmitEmbeddedStatement(node.catchClause.block); + } + if (node.finallyBlock) { + beginFinallyBlock(); + transformAndEmitEmbeddedStatement(node.finallyBlock); + } + endExceptionBlock(); + } + else { + emitStatement(ts.visitEachChild(node, visitor, context)); + } + } + function containsYield(node) { + return !!node && (node.transformFlags & 1048576 /* TransformFlags.ContainsYield */) !== 0; + } + function countInitialNodesWithoutYield(nodes) { + var numNodes = nodes.length; + for (var i = 0; i < numNodes; i++) { + if (containsYield(nodes[i])) { + return i; + } + } + return -1; + } + function onSubstituteNode(hint, node) { + node = previousOnSubstituteNode(hint, node); + if (hint === 1 /* EmitHint.Expression */) { + return substituteExpression(node); + } + return node; + } + function substituteExpression(node) { + if (ts.isIdentifier(node)) { + return substituteExpressionIdentifier(node); + } + return node; + } + function substituteExpressionIdentifier(node) { + if (!ts.isGeneratedIdentifier(node) && renamedCatchVariables && renamedCatchVariables.has(ts.idText(node))) { + var original = ts.getOriginalNode(node); + if (ts.isIdentifier(original) && original.parent) { + var declaration = resolver.getReferencedValueDeclaration(original); + if (declaration) { + var name = renamedCatchVariableDeclarations[ts.getOriginalNodeId(declaration)]; + if (name) { + // TODO(rbuckton): Does this need to be parented? + var clone_6 = ts.setParent(ts.setTextRange(factory.cloneNode(name), name), name.parent); + ts.setSourceMapRange(clone_6, node); + ts.setCommentRange(clone_6, node); + return clone_6; + } + } + } + } + return node; + } + function cacheExpression(node) { + if (ts.isGeneratedIdentifier(node) || ts.getEmitFlags(node) & 4096 /* EmitFlags.HelperName */) { + return node; + } + var temp = factory.createTempVariable(hoistVariableDeclaration); + emitAssignment(temp, node, /*location*/ node); + return temp; + } + function declareLocal(name) { + var temp = name + ? factory.createUniqueName(name) + : factory.createTempVariable(/*recordTempVariable*/ undefined); + hoistVariableDeclaration(temp); + return temp; + } + /** + * Defines a label, uses as the target of a Break operation. + */ + function defineLabel() { + if (!labelOffsets) { + labelOffsets = []; + } + var label = nextLabelId; + nextLabelId++; + labelOffsets[label] = -1; + return label; + } + /** + * Marks the current operation with the specified label. + */ + function markLabel(label) { + ts.Debug.assert(labelOffsets !== undefined, "No labels were defined."); + labelOffsets[label] = operations ? operations.length : 0; + } + /** + * Begins a block operation (With, Break/Continue, Try/Catch/Finally) + * + * @param block Information about the block. + */ + function beginBlock(block) { + if (!blocks) { + blocks = []; + blockActions = []; + blockOffsets = []; + blockStack = []; + } + var index = blockActions.length; + blockActions[index] = 0 /* BlockAction.Open */; + blockOffsets[index] = operations ? operations.length : 0; + blocks[index] = block; + blockStack.push(block); + return index; + } + /** + * Ends the current block operation. + */ + function endBlock() { + var block = peekBlock(); + if (block === undefined) + return ts.Debug.fail("beginBlock was never called."); + var index = blockActions.length; + blockActions[index] = 1 /* BlockAction.Close */; + blockOffsets[index] = operations ? operations.length : 0; + blocks[index] = block; + blockStack.pop(); + return block; + } + /** + * Gets the current open block. + */ + function peekBlock() { + return ts.lastOrUndefined(blockStack); + } + /** + * Gets the kind of the current open block. + */ + function peekBlockKind() { + var block = peekBlock(); + return block && block.kind; + } + /** + * Begins a code block for a generated `with` statement. + * + * @param expression An identifier representing expression for the `with` block. + */ + function beginWithBlock(expression) { + var startLabel = defineLabel(); + var endLabel = defineLabel(); + markLabel(startLabel); + beginBlock({ + kind: 1 /* CodeBlockKind.With */, + expression: expression, + startLabel: startLabel, + endLabel: endLabel + }); + } + /** + * Ends a code block for a generated `with` statement. + */ + function endWithBlock() { + ts.Debug.assert(peekBlockKind() === 1 /* CodeBlockKind.With */); + var block = endBlock(); + markLabel(block.endLabel); + } + /** + * Begins a code block for a generated `try` statement. + */ + function beginExceptionBlock() { + var startLabel = defineLabel(); + var endLabel = defineLabel(); + markLabel(startLabel); + beginBlock({ + kind: 0 /* CodeBlockKind.Exception */, + state: 0 /* ExceptionBlockState.Try */, + startLabel: startLabel, + endLabel: endLabel + }); + emitNop(); + return endLabel; + } + /** + * Enters the `catch` clause of a generated `try` statement. + * + * @param variable The catch variable. + */ + function beginCatchBlock(variable) { + ts.Debug.assert(peekBlockKind() === 0 /* CodeBlockKind.Exception */); + // generated identifiers should already be unique within a file + var name; + if (ts.isGeneratedIdentifier(variable.name)) { + name = variable.name; + hoistVariableDeclaration(variable.name); + } + else { + var text = ts.idText(variable.name); + name = declareLocal(text); + if (!renamedCatchVariables) { + renamedCatchVariables = new ts.Map(); + renamedCatchVariableDeclarations = []; + context.enableSubstitution(79 /* SyntaxKind.Identifier */); + } + renamedCatchVariables.set(text, true); + renamedCatchVariableDeclarations[ts.getOriginalNodeId(variable)] = name; + } + var exception = peekBlock(); + ts.Debug.assert(exception.state < 1 /* ExceptionBlockState.Catch */); + var endLabel = exception.endLabel; + emitBreak(endLabel); + var catchLabel = defineLabel(); + markLabel(catchLabel); + exception.state = 1 /* ExceptionBlockState.Catch */; + exception.catchVariable = name; + exception.catchLabel = catchLabel; + emitAssignment(name, factory.createCallExpression(factory.createPropertyAccessExpression(state, "sent"), /*typeArguments*/ undefined, [])); + emitNop(); + } + /** + * Enters the `finally` block of a generated `try` statement. + */ + function beginFinallyBlock() { + ts.Debug.assert(peekBlockKind() === 0 /* CodeBlockKind.Exception */); + var exception = peekBlock(); + ts.Debug.assert(exception.state < 2 /* ExceptionBlockState.Finally */); + var endLabel = exception.endLabel; + emitBreak(endLabel); + var finallyLabel = defineLabel(); + markLabel(finallyLabel); + exception.state = 2 /* ExceptionBlockState.Finally */; + exception.finallyLabel = finallyLabel; + } + /** + * Ends the code block for a generated `try` statement. + */ + function endExceptionBlock() { + ts.Debug.assert(peekBlockKind() === 0 /* CodeBlockKind.Exception */); + var exception = endBlock(); + var state = exception.state; + if (state < 2 /* ExceptionBlockState.Finally */) { + emitBreak(exception.endLabel); + } + else { + emitEndfinally(); + } + markLabel(exception.endLabel); + emitNop(); + exception.state = 3 /* ExceptionBlockState.Done */; + } + /** + * Begins a code block that supports `break` or `continue` statements that are defined in + * the source tree and not from generated code. + * + * @param labelText Names from containing labeled statements. + */ + function beginScriptLoopBlock() { + beginBlock({ + kind: 3 /* CodeBlockKind.Loop */, + isScript: true, + breakLabel: -1, + continueLabel: -1 + }); + } + /** + * Begins a code block that supports `break` or `continue` statements that are defined in + * generated code. Returns a label used to mark the operation to which to jump when a + * `break` statement targets this block. + * + * @param continueLabel A Label used to mark the operation to which to jump when a + * `continue` statement targets this block. + */ + function beginLoopBlock(continueLabel) { + var breakLabel = defineLabel(); + beginBlock({ + kind: 3 /* CodeBlockKind.Loop */, + isScript: false, + breakLabel: breakLabel, + continueLabel: continueLabel, + }); + return breakLabel; + } + /** + * Ends a code block that supports `break` or `continue` statements that are defined in + * generated code or in the source tree. + */ + function endLoopBlock() { + ts.Debug.assert(peekBlockKind() === 3 /* CodeBlockKind.Loop */); + var block = endBlock(); + var breakLabel = block.breakLabel; + if (!block.isScript) { + markLabel(breakLabel); + } + } + /** + * Begins a code block that supports `break` statements that are defined in the source + * tree and not from generated code. + * + */ + function beginScriptSwitchBlock() { + beginBlock({ + kind: 2 /* CodeBlockKind.Switch */, + isScript: true, + breakLabel: -1 + }); + } + /** + * Begins a code block that supports `break` statements that are defined in generated code. + * Returns a label used to mark the operation to which to jump when a `break` statement + * targets this block. + */ + function beginSwitchBlock() { + var breakLabel = defineLabel(); + beginBlock({ + kind: 2 /* CodeBlockKind.Switch */, + isScript: false, + breakLabel: breakLabel, + }); + return breakLabel; + } + /** + * Ends a code block that supports `break` statements that are defined in generated code. + */ + function endSwitchBlock() { + ts.Debug.assert(peekBlockKind() === 2 /* CodeBlockKind.Switch */); + var block = endBlock(); + var breakLabel = block.breakLabel; + if (!block.isScript) { + markLabel(breakLabel); + } + } + function beginScriptLabeledBlock(labelText) { + beginBlock({ + kind: 4 /* CodeBlockKind.Labeled */, + isScript: true, + labelText: labelText, + breakLabel: -1 + }); + } + function beginLabeledBlock(labelText) { + var breakLabel = defineLabel(); + beginBlock({ + kind: 4 /* CodeBlockKind.Labeled */, + isScript: false, + labelText: labelText, + breakLabel: breakLabel + }); + } + function endLabeledBlock() { + ts.Debug.assert(peekBlockKind() === 4 /* CodeBlockKind.Labeled */); + var block = endBlock(); + if (!block.isScript) { + markLabel(block.breakLabel); + } + } + /** + * Indicates whether the provided block supports `break` statements. + * + * @param block A code block. + */ + function supportsUnlabeledBreak(block) { + return block.kind === 2 /* CodeBlockKind.Switch */ + || block.kind === 3 /* CodeBlockKind.Loop */; + } + /** + * Indicates whether the provided block supports `break` statements with labels. + * + * @param block A code block. + */ + function supportsLabeledBreakOrContinue(block) { + return block.kind === 4 /* CodeBlockKind.Labeled */; + } + /** + * Indicates whether the provided block supports `continue` statements. + * + * @param block A code block. + */ + function supportsUnlabeledContinue(block) { + return block.kind === 3 /* CodeBlockKind.Loop */; + } + function hasImmediateContainingLabeledBlock(labelText, start) { + for (var j = start; j >= 0; j--) { + var containingBlock = blockStack[j]; + if (supportsLabeledBreakOrContinue(containingBlock)) { + if (containingBlock.labelText === labelText) { + return true; + } + } + else { + break; + } + } + return false; + } + /** + * Finds the label that is the target for a `break` statement. + * + * @param labelText An optional name of a containing labeled statement. + */ + function findBreakTarget(labelText) { + if (blockStack) { + if (labelText) { + for (var i = blockStack.length - 1; i >= 0; i--) { + var block = blockStack[i]; + if (supportsLabeledBreakOrContinue(block) && block.labelText === labelText) { + return block.breakLabel; + } + else if (supportsUnlabeledBreak(block) && hasImmediateContainingLabeledBlock(labelText, i - 1)) { + return block.breakLabel; + } + } + } + else { + for (var i = blockStack.length - 1; i >= 0; i--) { + var block = blockStack[i]; + if (supportsUnlabeledBreak(block)) { + return block.breakLabel; + } + } + } + } + return 0; + } + /** + * Finds the label that is the target for a `continue` statement. + * + * @param labelText An optional name of a containing labeled statement. + */ + function findContinueTarget(labelText) { + if (blockStack) { + if (labelText) { + for (var i = blockStack.length - 1; i >= 0; i--) { + var block = blockStack[i]; + if (supportsUnlabeledContinue(block) && hasImmediateContainingLabeledBlock(labelText, i - 1)) { + return block.continueLabel; + } + } + } + else { + for (var i = blockStack.length - 1; i >= 0; i--) { + var block = blockStack[i]; + if (supportsUnlabeledContinue(block)) { + return block.continueLabel; + } + } + } + } + return 0; + } + /** + * Creates an expression that can be used to indicate the value for a label. + * + * @param label A label. + */ + function createLabel(label) { + if (label !== undefined && label > 0) { + if (labelExpressions === undefined) { + labelExpressions = []; + } + var expression = factory.createNumericLiteral(-1); + if (labelExpressions[label] === undefined) { + labelExpressions[label] = [expression]; + } + else { + labelExpressions[label].push(expression); + } + return expression; + } + return factory.createOmittedExpression(); + } + /** + * Creates a numeric literal for the provided instruction. + */ + function createInstruction(instruction) { + var literal = factory.createNumericLiteral(instruction); + ts.addSyntheticTrailingComment(literal, 3 /* SyntaxKind.MultiLineCommentTrivia */, getInstructionName(instruction)); + return literal; + } + /** + * Creates a statement that can be used indicate a Break operation to the provided label. + * + * @param label A label. + * @param location An optional source map location for the statement. + */ + function createInlineBreak(label, location) { + ts.Debug.assertLessThan(0, label, "Invalid label"); + return ts.setTextRange(factory.createReturnStatement(factory.createArrayLiteralExpression([ + createInstruction(3 /* Instruction.Break */), + createLabel(label) + ])), location); + } + /** + * Creates a statement that can be used indicate a Return operation. + * + * @param expression The expression for the return statement. + * @param location An optional source map location for the statement. + */ + function createInlineReturn(expression, location) { + return ts.setTextRange(factory.createReturnStatement(factory.createArrayLiteralExpression(expression + ? [createInstruction(2 /* Instruction.Return */), expression] + : [createInstruction(2 /* Instruction.Return */)])), location); + } + /** + * Creates an expression that can be used to resume from a Yield operation. + */ + function createGeneratorResume(location) { + return ts.setTextRange(factory.createCallExpression(factory.createPropertyAccessExpression(state, "sent"), + /*typeArguments*/ undefined, []), location); + } + /** + * Emits an empty instruction. + */ + function emitNop() { + emitWorker(0 /* OpCode.Nop */); + } + /** + * Emits a Statement. + * + * @param node A statement. + */ + function emitStatement(node) { + if (node) { + emitWorker(1 /* OpCode.Statement */, [node]); + } + else { + emitNop(); + } + } + /** + * Emits an Assignment operation. + * + * @param left The left-hand side of the assignment. + * @param right The right-hand side of the assignment. + * @param location An optional source map location for the assignment. + */ + function emitAssignment(left, right, location) { + emitWorker(2 /* OpCode.Assign */, [left, right], location); + } + /** + * Emits a Break operation to the specified label. + * + * @param label A label. + * @param location An optional source map location for the assignment. + */ + function emitBreak(label, location) { + emitWorker(3 /* OpCode.Break */, [label], location); + } + /** + * Emits a Break operation to the specified label when a condition evaluates to a truthy + * value at runtime. + * + * @param label A label. + * @param condition The condition. + * @param location An optional source map location for the assignment. + */ + function emitBreakWhenTrue(label, condition, location) { + emitWorker(4 /* OpCode.BreakWhenTrue */, [label, condition], location); + } + /** + * Emits a Break to the specified label when a condition evaluates to a falsey value at + * runtime. + * + * @param label A label. + * @param condition The condition. + * @param location An optional source map location for the assignment. + */ + function emitBreakWhenFalse(label, condition, location) { + emitWorker(5 /* OpCode.BreakWhenFalse */, [label, condition], location); + } + /** + * Emits a YieldStar operation for the provided expression. + * + * @param expression An optional value for the yield operation. + * @param location An optional source map location for the assignment. + */ + function emitYieldStar(expression, location) { + emitWorker(7 /* OpCode.YieldStar */, [expression], location); + } + /** + * Emits a Yield operation for the provided expression. + * + * @param expression An optional value for the yield operation. + * @param location An optional source map location for the assignment. + */ + function emitYield(expression, location) { + emitWorker(6 /* OpCode.Yield */, [expression], location); + } + /** + * Emits a Return operation for the provided expression. + * + * @param expression An optional value for the operation. + * @param location An optional source map location for the assignment. + */ + function emitReturn(expression, location) { + emitWorker(8 /* OpCode.Return */, [expression], location); + } + /** + * Emits a Throw operation for the provided expression. + * + * @param expression A value for the operation. + * @param location An optional source map location for the assignment. + */ + function emitThrow(expression, location) { + emitWorker(9 /* OpCode.Throw */, [expression], location); + } + /** + * Emits an Endfinally operation. This is used to handle `finally` block semantics. + */ + function emitEndfinally() { + emitWorker(10 /* OpCode.Endfinally */); + } + /** + * Emits an operation. + * + * @param code The OpCode for the operation. + * @param args The optional arguments for the operation. + */ + function emitWorker(code, args, location) { + if (operations === undefined) { + operations = []; + operationArguments = []; + operationLocations = []; + } + if (labelOffsets === undefined) { + // mark entry point + markLabel(defineLabel()); + } + var operationIndex = operations.length; + operations[operationIndex] = code; + operationArguments[operationIndex] = args; + operationLocations[operationIndex] = location; + } + /** + * Builds the generator function body. + */ + function build() { + blockIndex = 0; + labelNumber = 0; + labelNumbers = undefined; + lastOperationWasAbrupt = false; + lastOperationWasCompletion = false; + clauses = undefined; + statements = undefined; + exceptionBlockStack = undefined; + currentExceptionBlock = undefined; + withBlockStack = undefined; + var buildResult = buildStatements(); + return emitHelpers().createGeneratorHelper(ts.setEmitFlags(factory.createFunctionExpression( + /*modifiers*/ undefined, + /*asteriskToken*/ undefined, + /*name*/ undefined, + /*typeParameters*/ undefined, [factory.createParameterDeclaration(/*modifiers*/ undefined, /*dotDotDotToken*/ undefined, state)], + /*type*/ undefined, factory.createBlock(buildResult, + /*multiLine*/ buildResult.length > 0)), 524288 /* EmitFlags.ReuseTempVariableScope */)); + } + /** + * Builds the statements for the generator function body. + */ + function buildStatements() { + if (operations) { + for (var operationIndex = 0; operationIndex < operations.length; operationIndex++) { + writeOperation(operationIndex); + } + flushFinalLabel(operations.length); + } + else { + flushFinalLabel(0); + } + if (clauses) { + var labelExpression = factory.createPropertyAccessExpression(state, "label"); + var switchStatement = factory.createSwitchStatement(labelExpression, factory.createCaseBlock(clauses)); + return [ts.startOnNewLine(switchStatement)]; + } + if (statements) { + return statements; + } + return []; + } + /** + * Flush the current label and advance to a new label. + */ + function flushLabel() { + if (!statements) { + return; + } + appendLabel(/*markLabelEnd*/ !lastOperationWasAbrupt); + lastOperationWasAbrupt = false; + lastOperationWasCompletion = false; + labelNumber++; + } + /** + * Flush the final label of the generator function body. + */ + function flushFinalLabel(operationIndex) { + if (isFinalLabelReachable(operationIndex)) { + tryEnterLabel(operationIndex); + withBlockStack = undefined; + writeReturn(/*expression*/ undefined, /*operationLocation*/ undefined); + } + if (statements && clauses) { + appendLabel(/*markLabelEnd*/ false); + } + updateLabelExpressions(); + } + /** + * Tests whether the final label of the generator function body + * is reachable by user code. + */ + function isFinalLabelReachable(operationIndex) { + // if the last operation was *not* a completion (return/throw) then + // the final label is reachable. + if (!lastOperationWasCompletion) { + return true; + } + // if there are no labels defined or referenced, then the final label is + // not reachable. + if (!labelOffsets || !labelExpressions) { + return false; + } + // if the label for this offset is referenced, then the final label + // is reachable. + for (var label = 0; label < labelOffsets.length; label++) { + if (labelOffsets[label] === operationIndex && labelExpressions[label]) { + return true; + } + } + return false; + } + /** + * Appends a case clause for the last label and sets the new label. + * + * @param markLabelEnd Indicates that the transition between labels was a fall-through + * from a previous case clause and the change in labels should be + * reflected on the `state` object. + */ + function appendLabel(markLabelEnd) { + if (!clauses) { + clauses = []; + } + if (statements) { + if (withBlockStack) { + // The previous label was nested inside one or more `with` blocks, so we + // surround the statements in generated `with` blocks to create the same environment. + for (var i = withBlockStack.length - 1; i >= 0; i--) { + var withBlock = withBlockStack[i]; + statements = [factory.createWithStatement(withBlock.expression, factory.createBlock(statements))]; + } + } + if (currentExceptionBlock) { + // The previous label was nested inside of an exception block, so we must + // indicate entry into a protected region by pushing the label numbers + // for each block in the protected region. + var startLabel = currentExceptionBlock.startLabel, catchLabel = currentExceptionBlock.catchLabel, finallyLabel = currentExceptionBlock.finallyLabel, endLabel = currentExceptionBlock.endLabel; + statements.unshift(factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(state, "trys"), "push"), + /*typeArguments*/ undefined, [ + factory.createArrayLiteralExpression([ + createLabel(startLabel), + createLabel(catchLabel), + createLabel(finallyLabel), + createLabel(endLabel) + ]) + ]))); + currentExceptionBlock = undefined; + } + if (markLabelEnd) { + // The case clause for the last label falls through to this label, so we + // add an assignment statement to reflect the change in labels. + statements.push(factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression(state, "label"), factory.createNumericLiteral(labelNumber + 1)))); + } + } + clauses.push(factory.createCaseClause(factory.createNumericLiteral(labelNumber), statements || [])); + statements = undefined; + } + /** + * Tries to enter into a new label at the current operation index. + */ + function tryEnterLabel(operationIndex) { + if (!labelOffsets) { + return; + } + for (var label = 0; label < labelOffsets.length; label++) { + if (labelOffsets[label] === operationIndex) { + flushLabel(); + if (labelNumbers === undefined) { + labelNumbers = []; + } + if (labelNumbers[labelNumber] === undefined) { + labelNumbers[labelNumber] = [label]; + } + else { + labelNumbers[labelNumber].push(label); + } + } + } + } + /** + * Updates literal expressions for labels with actual label numbers. + */ + function updateLabelExpressions() { + if (labelExpressions !== undefined && labelNumbers !== undefined) { + for (var labelNumber_1 = 0; labelNumber_1 < labelNumbers.length; labelNumber_1++) { + var labels = labelNumbers[labelNumber_1]; + if (labels !== undefined) { + for (var _i = 0, labels_1 = labels; _i < labels_1.length; _i++) { + var label = labels_1[_i]; + var expressions = labelExpressions[label]; + if (expressions !== undefined) { + for (var _a = 0, expressions_1 = expressions; _a < expressions_1.length; _a++) { + var expression = expressions_1[_a]; + expression.text = String(labelNumber_1); + } + } + } + } + } + } + } + /** + * Tries to enter or leave a code block. + */ + function tryEnterOrLeaveBlock(operationIndex) { + if (blocks) { + for (; blockIndex < blockActions.length && blockOffsets[blockIndex] <= operationIndex; blockIndex++) { + var block = blocks[blockIndex]; + var blockAction = blockActions[blockIndex]; + switch (block.kind) { + case 0 /* CodeBlockKind.Exception */: + if (blockAction === 0 /* BlockAction.Open */) { + if (!exceptionBlockStack) { + exceptionBlockStack = []; + } + if (!statements) { + statements = []; + } + exceptionBlockStack.push(currentExceptionBlock); + currentExceptionBlock = block; + } + else if (blockAction === 1 /* BlockAction.Close */) { + currentExceptionBlock = exceptionBlockStack.pop(); + } + break; + case 1 /* CodeBlockKind.With */: + if (blockAction === 0 /* BlockAction.Open */) { + if (!withBlockStack) { + withBlockStack = []; + } + withBlockStack.push(block); + } + else if (blockAction === 1 /* BlockAction.Close */) { + withBlockStack.pop(); + } + break; + // default: do nothing + } + } + } + } + /** + * Writes an operation as a statement to the current label's statement list. + * + * @param operation The OpCode of the operation + */ + function writeOperation(operationIndex) { + tryEnterLabel(operationIndex); + tryEnterOrLeaveBlock(operationIndex); + // early termination, nothing else to process in this label + if (lastOperationWasAbrupt) { + return; + } + lastOperationWasAbrupt = false; + lastOperationWasCompletion = false; + var opcode = operations[operationIndex]; + if (opcode === 0 /* OpCode.Nop */) { + return; + } + else if (opcode === 10 /* OpCode.Endfinally */) { + return writeEndfinally(); + } + var args = operationArguments[operationIndex]; + if (opcode === 1 /* OpCode.Statement */) { + return writeStatement(args[0]); + } + var location = operationLocations[operationIndex]; + switch (opcode) { + case 2 /* OpCode.Assign */: + return writeAssign(args[0], args[1], location); + case 3 /* OpCode.Break */: + return writeBreak(args[0], location); + case 4 /* OpCode.BreakWhenTrue */: + return writeBreakWhenTrue(args[0], args[1], location); + case 5 /* OpCode.BreakWhenFalse */: + return writeBreakWhenFalse(args[0], args[1], location); + case 6 /* OpCode.Yield */: + return writeYield(args[0], location); + case 7 /* OpCode.YieldStar */: + return writeYieldStar(args[0], location); + case 8 /* OpCode.Return */: + return writeReturn(args[0], location); + case 9 /* OpCode.Throw */: + return writeThrow(args[0], location); + } + } + /** + * Writes a statement to the current label's statement list. + * + * @param statement A statement to write. + */ + function writeStatement(statement) { + if (statement) { + if (!statements) { + statements = [statement]; + } + else { + statements.push(statement); + } + } + } + /** + * Writes an Assign operation to the current label's statement list. + * + * @param left The left-hand side of the assignment. + * @param right The right-hand side of the assignment. + * @param operationLocation The source map location for the operation. + */ + function writeAssign(left, right, operationLocation) { + writeStatement(ts.setTextRange(factory.createExpressionStatement(factory.createAssignment(left, right)), operationLocation)); + } + /** + * Writes a Throw operation to the current label's statement list. + * + * @param expression The value to throw. + * @param operationLocation The source map location for the operation. + */ + function writeThrow(expression, operationLocation) { + lastOperationWasAbrupt = true; + lastOperationWasCompletion = true; + writeStatement(ts.setTextRange(factory.createThrowStatement(expression), operationLocation)); + } + /** + * Writes a Return operation to the current label's statement list. + * + * @param expression The value to return. + * @param operationLocation The source map location for the operation. + */ + function writeReturn(expression, operationLocation) { + lastOperationWasAbrupt = true; + lastOperationWasCompletion = true; + writeStatement(ts.setEmitFlags(ts.setTextRange(factory.createReturnStatement(factory.createArrayLiteralExpression(expression + ? [createInstruction(2 /* Instruction.Return */), expression] + : [createInstruction(2 /* Instruction.Return */)])), operationLocation), 384 /* EmitFlags.NoTokenSourceMaps */)); + } + /** + * Writes a Break operation to the current label's statement list. + * + * @param label The label for the Break. + * @param operationLocation The source map location for the operation. + */ + function writeBreak(label, operationLocation) { + lastOperationWasAbrupt = true; + writeStatement(ts.setEmitFlags(ts.setTextRange(factory.createReturnStatement(factory.createArrayLiteralExpression([ + createInstruction(3 /* Instruction.Break */), + createLabel(label) + ])), operationLocation), 384 /* EmitFlags.NoTokenSourceMaps */)); + } + /** + * Writes a BreakWhenTrue operation to the current label's statement list. + * + * @param label The label for the Break. + * @param condition The condition for the Break. + * @param operationLocation The source map location for the operation. + */ + function writeBreakWhenTrue(label, condition, operationLocation) { + writeStatement(ts.setEmitFlags(factory.createIfStatement(condition, ts.setEmitFlags(ts.setTextRange(factory.createReturnStatement(factory.createArrayLiteralExpression([ + createInstruction(3 /* Instruction.Break */), + createLabel(label) + ])), operationLocation), 384 /* EmitFlags.NoTokenSourceMaps */)), 1 /* EmitFlags.SingleLine */)); + } + /** + * Writes a BreakWhenFalse operation to the current label's statement list. + * + * @param label The label for the Break. + * @param condition The condition for the Break. + * @param operationLocation The source map location for the operation. + */ + function writeBreakWhenFalse(label, condition, operationLocation) { + writeStatement(ts.setEmitFlags(factory.createIfStatement(factory.createLogicalNot(condition), ts.setEmitFlags(ts.setTextRange(factory.createReturnStatement(factory.createArrayLiteralExpression([ + createInstruction(3 /* Instruction.Break */), + createLabel(label) + ])), operationLocation), 384 /* EmitFlags.NoTokenSourceMaps */)), 1 /* EmitFlags.SingleLine */)); + } + /** + * Writes a Yield operation to the current label's statement list. + * + * @param expression The expression to yield. + * @param operationLocation The source map location for the operation. + */ + function writeYield(expression, operationLocation) { + lastOperationWasAbrupt = true; + writeStatement(ts.setEmitFlags(ts.setTextRange(factory.createReturnStatement(factory.createArrayLiteralExpression(expression + ? [createInstruction(4 /* Instruction.Yield */), expression] + : [createInstruction(4 /* Instruction.Yield */)])), operationLocation), 384 /* EmitFlags.NoTokenSourceMaps */)); + } + /** + * Writes a YieldStar instruction to the current label's statement list. + * + * @param expression The expression to yield. + * @param operationLocation The source map location for the operation. + */ + function writeYieldStar(expression, operationLocation) { + lastOperationWasAbrupt = true; + writeStatement(ts.setEmitFlags(ts.setTextRange(factory.createReturnStatement(factory.createArrayLiteralExpression([ + createInstruction(5 /* Instruction.YieldStar */), + expression + ])), operationLocation), 384 /* EmitFlags.NoTokenSourceMaps */)); + } + /** + * Writes an Endfinally instruction to the current label's statement list. + */ + function writeEndfinally() { + lastOperationWasAbrupt = true; + writeStatement(factory.createReturnStatement(factory.createArrayLiteralExpression([ + createInstruction(7 /* Instruction.Endfinally */) + ]))); + } + } + ts.transformGenerators = transformGenerators; +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + function transformModule(context) { + function getTransformModuleDelegate(moduleKind) { + switch (moduleKind) { + case ts.ModuleKind.AMD: return transformAMDModule; + case ts.ModuleKind.UMD: return transformUMDModule; + default: return transformCommonJSModule; + } + } + var factory = context.factory, emitHelpers = context.getEmitHelperFactory, startLexicalEnvironment = context.startLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistVariableDeclaration = context.hoistVariableDeclaration; + var compilerOptions = context.getCompilerOptions(); + var resolver = context.getEmitResolver(); + var host = context.getEmitHost(); + var languageVersion = ts.getEmitScriptTarget(compilerOptions); + var moduleKind = ts.getEmitModuleKind(compilerOptions); + var previousOnSubstituteNode = context.onSubstituteNode; + var previousOnEmitNode = context.onEmitNode; + context.onSubstituteNode = onSubstituteNode; + context.onEmitNode = onEmitNode; + context.enableSubstitution(210 /* SyntaxKind.CallExpression */); // Substitute calls to imported/exported symbols to avoid incorrect `this`. + context.enableSubstitution(212 /* SyntaxKind.TaggedTemplateExpression */); // Substitute calls to imported/exported symbols to avoid incorrect `this`. + context.enableSubstitution(79 /* SyntaxKind.Identifier */); // Substitutes expression identifiers with imported/exported symbols. + context.enableSubstitution(223 /* SyntaxKind.BinaryExpression */); // Substitutes assignments to exported symbols. + context.enableSubstitution(300 /* SyntaxKind.ShorthandPropertyAssignment */); // Substitutes shorthand property assignments for imported/exported symbols. + context.enableEmitNotification(308 /* SyntaxKind.SourceFile */); // Restore state when substituting nodes in a file. + var moduleInfoMap = []; // The ExternalModuleInfo for each file. + var deferredExports = []; // Exports to defer until an EndOfDeclarationMarker is found. + var currentSourceFile; // The current file. + var currentModuleInfo; // The ExternalModuleInfo for the current file. + var noSubstitution = []; // Set of nodes for which substitution rules should be ignored. + var needUMDDynamicImportHelper; + return ts.chainBundle(context, transformSourceFile); + /** + * Transforms the module aspects of a SourceFile. + * + * @param node The SourceFile node. + */ + function transformSourceFile(node) { + if (node.isDeclarationFile || + !(ts.isEffectiveExternalModule(node, compilerOptions) || + node.transformFlags & 8388608 /* TransformFlags.ContainsDynamicImport */ || + (ts.isJsonSourceFile(node) && ts.hasJsonModuleEmitEnabled(compilerOptions) && ts.outFile(compilerOptions)))) { + return node; + } + currentSourceFile = node; + currentModuleInfo = ts.collectExternalModuleInfo(context, node, resolver, compilerOptions); + moduleInfoMap[ts.getOriginalNodeId(node)] = currentModuleInfo; + // Perform the transformation. + var transformModule = getTransformModuleDelegate(moduleKind); + var updated = transformModule(node); + currentSourceFile = undefined; + currentModuleInfo = undefined; + needUMDDynamicImportHelper = false; + return updated; + } + function shouldEmitUnderscoreUnderscoreESModule() { + if (!currentModuleInfo.exportEquals && ts.isExternalModule(currentSourceFile)) { + return true; + } + return false; + } + /** + * Transforms a SourceFile into a CommonJS module. + * + * @param node The SourceFile node. + */ + function transformCommonJSModule(node) { + startLexicalEnvironment(); + var statements = []; + var ensureUseStrict = ts.getStrictOptionValue(compilerOptions, "alwaysStrict") || (!compilerOptions.noImplicitUseStrict && ts.isExternalModule(currentSourceFile)); + var statementOffset = factory.copyPrologue(node.statements, statements, ensureUseStrict && !ts.isJsonSourceFile(node), topLevelVisitor); + if (shouldEmitUnderscoreUnderscoreESModule()) { + ts.append(statements, createUnderscoreUnderscoreESModule()); + } + if (ts.length(currentModuleInfo.exportedNames)) { + var chunkSize = 50; + for (var i = 0; i < currentModuleInfo.exportedNames.length; i += chunkSize) { + ts.append(statements, factory.createExpressionStatement(ts.reduceLeft(currentModuleInfo.exportedNames.slice(i, i + chunkSize), function (prev, nextId) { return factory.createAssignment(factory.createPropertyAccessExpression(factory.createIdentifier("exports"), factory.createIdentifier(ts.idText(nextId))), prev); }, factory.createVoidZero()))); + } + } + ts.append(statements, ts.visitNode(currentModuleInfo.externalHelpersImportDeclaration, topLevelVisitor, ts.isStatement)); + ts.addRange(statements, ts.visitNodes(node.statements, topLevelVisitor, ts.isStatement, statementOffset)); + addExportEqualsIfNeeded(statements, /*emitAsReturn*/ false); + ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment()); + var updated = factory.updateSourceFile(node, ts.setTextRange(factory.createNodeArray(statements), node.statements)); + ts.addEmitHelpers(updated, context.readEmitHelpers()); + return updated; + } + /** + * Transforms a SourceFile into an AMD module. + * + * @param node The SourceFile node. + */ + function transformAMDModule(node) { + var define = factory.createIdentifier("define"); + var moduleName = ts.tryGetModuleNameFromFile(factory, node, host, compilerOptions); + var jsonSourceFile = ts.isJsonSourceFile(node) && node; + // An AMD define function has the following shape: + // + // define(id?, dependencies?, factory); + // + // This has the shape of the following: + // + // define(name, ["module1", "module2"], function (module1Alias) { ... } + // + // The location of the alias in the parameter list in the factory function needs to + // match the position of the module name in the dependency list. + // + // To ensure this is true in cases of modules with no aliases, e.g.: + // + // import "module" + // + // or + // + // /// + // + // we need to add modules without alias names to the end of the dependencies list + var _a = collectAsynchronousDependencies(node, /*includeNonAmdDependencies*/ true), aliasedModuleNames = _a.aliasedModuleNames, unaliasedModuleNames = _a.unaliasedModuleNames, importAliasNames = _a.importAliasNames; + // Create an updated SourceFile: + // + // define(mofactory.updateSourceFile", "module2"], function ... + var updated = factory.updateSourceFile(node, ts.setTextRange(factory.createNodeArray([ + factory.createExpressionStatement(factory.createCallExpression(define, + /*typeArguments*/ undefined, __spreadArray(__spreadArray([], (moduleName ? [moduleName] : []), true), [ + // Add the dependency array argument: + // + // ["require", "exports", module1", "module2", ...] + factory.createArrayLiteralExpression(jsonSourceFile ? ts.emptyArray : __spreadArray(__spreadArray([ + factory.createStringLiteral("require"), + factory.createStringLiteral("exports") + ], aliasedModuleNames, true), unaliasedModuleNames, true)), + // Add the module body function argument: + // + // function (require, exports, module1, module2) ... + jsonSourceFile ? + jsonSourceFile.statements.length ? jsonSourceFile.statements[0].expression : factory.createObjectLiteralExpression() : + factory.createFunctionExpression( + /*modifiers*/ undefined, + /*asteriskToken*/ undefined, + /*name*/ undefined, + /*typeParameters*/ undefined, __spreadArray([ + factory.createParameterDeclaration(/*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "require"), + factory.createParameterDeclaration(/*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "exports") + ], importAliasNames, true), + /*type*/ undefined, transformAsynchronousModuleBody(node)) + ], false))) + ]), + /*location*/ node.statements)); + ts.addEmitHelpers(updated, context.readEmitHelpers()); + return updated; + } + /** + * Transforms a SourceFile into a UMD module. + * + * @param node The SourceFile node. + */ + function transformUMDModule(node) { + var _a = collectAsynchronousDependencies(node, /*includeNonAmdDependencies*/ false), aliasedModuleNames = _a.aliasedModuleNames, unaliasedModuleNames = _a.unaliasedModuleNames, importAliasNames = _a.importAliasNames; + var moduleName = ts.tryGetModuleNameFromFile(factory, node, host, compilerOptions); + var umdHeader = factory.createFunctionExpression( + /*modifiers*/ undefined, + /*asteriskToken*/ undefined, + /*name*/ undefined, + /*typeParameters*/ undefined, [factory.createParameterDeclaration(/*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "factory")], + /*type*/ undefined, ts.setTextRange(factory.createBlock([ + factory.createIfStatement(factory.createLogicalAnd(factory.createTypeCheck(factory.createIdentifier("module"), "object"), factory.createTypeCheck(factory.createPropertyAccessExpression(factory.createIdentifier("module"), "exports"), "object")), factory.createBlock([ + factory.createVariableStatement( + /*modifiers*/ undefined, [ + factory.createVariableDeclaration("v", + /*exclamationToken*/ undefined, + /*type*/ undefined, factory.createCallExpression(factory.createIdentifier("factory"), + /*typeArguments*/ undefined, [ + factory.createIdentifier("require"), + factory.createIdentifier("exports") + ])) + ]), + ts.setEmitFlags(factory.createIfStatement(factory.createStrictInequality(factory.createIdentifier("v"), factory.createIdentifier("undefined")), factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression(factory.createIdentifier("module"), "exports"), factory.createIdentifier("v")))), 1 /* EmitFlags.SingleLine */) + ]), factory.createIfStatement(factory.createLogicalAnd(factory.createTypeCheck(factory.createIdentifier("define"), "function"), factory.createPropertyAccessExpression(factory.createIdentifier("define"), "amd")), factory.createBlock([ + factory.createExpressionStatement(factory.createCallExpression(factory.createIdentifier("define"), + /*typeArguments*/ undefined, __spreadArray(__spreadArray([], (moduleName ? [moduleName] : []), true), [ + factory.createArrayLiteralExpression(__spreadArray(__spreadArray([ + factory.createStringLiteral("require"), + factory.createStringLiteral("exports") + ], aliasedModuleNames, true), unaliasedModuleNames, true)), + factory.createIdentifier("factory") + ], false))) + ]))) + ], + /*multiLine*/ true), + /*location*/ undefined)); + // Create an updated SourceFile: + // + // (function (factory) { + // if (typeof module === "object" && typeof module.exports === "object") { + // var v = factory(require, exports); + // if (v !== undefined) module.exports = v; + // } + // else if (typeof define === 'function' && define.amd) { + // define(["require", "exports"], factory); + // } + // })(function ...) + var updated = factory.updateSourceFile(node, ts.setTextRange(factory.createNodeArray([ + factory.createExpressionStatement(factory.createCallExpression(umdHeader, + /*typeArguments*/ undefined, [ + // Add the module body function argument: + // + // function (require, exports) ... + factory.createFunctionExpression( + /*modifiers*/ undefined, + /*asteriskToken*/ undefined, + /*name*/ undefined, + /*typeParameters*/ undefined, __spreadArray([ + factory.createParameterDeclaration(/*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "require"), + factory.createParameterDeclaration(/*modifiers*/ undefined, /*dotDotDotToken*/ undefined, "exports") + ], importAliasNames, true), + /*type*/ undefined, transformAsynchronousModuleBody(node)) + ])) + ]), + /*location*/ node.statements)); + ts.addEmitHelpers(updated, context.readEmitHelpers()); + return updated; + } + /** + * Collect the additional asynchronous dependencies for the module. + * + * @param node The source file. + * @param includeNonAmdDependencies A value indicating whether to include non-AMD dependencies. + */ + function collectAsynchronousDependencies(node, includeNonAmdDependencies) { + // names of modules with corresponding parameter in the factory function + var aliasedModuleNames = []; + // names of modules with no corresponding parameters in factory function + var unaliasedModuleNames = []; + // names of the parameters in the factory function; these + // parameters need to match the indexes of the corresponding + // module names in aliasedModuleNames. + var importAliasNames = []; + // Fill in amd-dependency tags + for (var _i = 0, _a = node.amdDependencies; _i < _a.length; _i++) { + var amdDependency = _a[_i]; + if (amdDependency.name) { + aliasedModuleNames.push(factory.createStringLiteral(amdDependency.path)); + importAliasNames.push(factory.createParameterDeclaration(/*modifiers*/ undefined, /*dotDotDotToken*/ undefined, amdDependency.name)); + } + else { + unaliasedModuleNames.push(factory.createStringLiteral(amdDependency.path)); + } + } + for (var _b = 0, _c = currentModuleInfo.externalImports; _b < _c.length; _b++) { + var importNode = _c[_b]; + // Find the name of the external module + var externalModuleName = ts.getExternalModuleNameLiteral(factory, importNode, currentSourceFile, host, resolver, compilerOptions); + // Find the name of the module alias, if there is one + var importAliasName = ts.getLocalNameForExternalImport(factory, importNode, currentSourceFile); + // It is possible that externalModuleName is undefined if it is not string literal. + // This can happen in the invalid import syntax. + // E.g : "import * from alias from 'someLib';" + if (externalModuleName) { + if (includeNonAmdDependencies && importAliasName) { + // Set emitFlags on the name of the classDeclaration + // This is so that when printer will not substitute the identifier + ts.setEmitFlags(importAliasName, 4 /* EmitFlags.NoSubstitution */); + aliasedModuleNames.push(externalModuleName); + importAliasNames.push(factory.createParameterDeclaration(/*modifiers*/ undefined, /*dotDotDotToken*/ undefined, importAliasName)); + } + else { + unaliasedModuleNames.push(externalModuleName); + } + } + } + return { aliasedModuleNames: aliasedModuleNames, unaliasedModuleNames: unaliasedModuleNames, importAliasNames: importAliasNames }; + } + function getAMDImportExpressionForImport(node) { + if (ts.isImportEqualsDeclaration(node) || ts.isExportDeclaration(node) || !ts.getExternalModuleNameLiteral(factory, node, currentSourceFile, host, resolver, compilerOptions)) { + return undefined; + } + var name = ts.getLocalNameForExternalImport(factory, node, currentSourceFile); // TODO: GH#18217 + var expr = getHelperExpressionForImport(node, name); + if (expr === name) { + return undefined; + } + return factory.createExpressionStatement(factory.createAssignment(name, expr)); + } + /** + * Transforms a SourceFile into an AMD or UMD module body. + * + * @param node The SourceFile node. + */ + function transformAsynchronousModuleBody(node) { + startLexicalEnvironment(); + var statements = []; + var statementOffset = factory.copyPrologue(node.statements, statements, /*ensureUseStrict*/ !compilerOptions.noImplicitUseStrict, topLevelVisitor); + if (shouldEmitUnderscoreUnderscoreESModule()) { + ts.append(statements, createUnderscoreUnderscoreESModule()); + } + if (ts.length(currentModuleInfo.exportedNames)) { + ts.append(statements, factory.createExpressionStatement(ts.reduceLeft(currentModuleInfo.exportedNames, function (prev, nextId) { return factory.createAssignment(factory.createPropertyAccessExpression(factory.createIdentifier("exports"), factory.createIdentifier(ts.idText(nextId))), prev); }, factory.createVoidZero()))); + } + // Visit each statement of the module body. + ts.append(statements, ts.visitNode(currentModuleInfo.externalHelpersImportDeclaration, topLevelVisitor, ts.isStatement)); + if (moduleKind === ts.ModuleKind.AMD) { + ts.addRange(statements, ts.mapDefined(currentModuleInfo.externalImports, getAMDImportExpressionForImport)); + } + ts.addRange(statements, ts.visitNodes(node.statements, topLevelVisitor, ts.isStatement, statementOffset)); + // Append the 'export =' statement if provided. + addExportEqualsIfNeeded(statements, /*emitAsReturn*/ true); + // End the lexical environment for the module body + // and merge any new lexical declarations. + ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment()); + var body = factory.createBlock(statements, /*multiLine*/ true); + if (needUMDDynamicImportHelper) { + ts.addEmitHelper(body, dynamicImportUMDHelper); + } + return body; + } + /** + * Adds the down-level representation of `export=` to the statement list if one exists + * in the source file. + * + * @param statements The Statement list to modify. + * @param emitAsReturn A value indicating whether to emit the `export=` statement as a + * return statement. + */ + function addExportEqualsIfNeeded(statements, emitAsReturn) { + if (currentModuleInfo.exportEquals) { + var expressionResult = ts.visitNode(currentModuleInfo.exportEquals.expression, visitor); + if (expressionResult) { + if (emitAsReturn) { + var statement = factory.createReturnStatement(expressionResult); + ts.setTextRange(statement, currentModuleInfo.exportEquals); + ts.setEmitFlags(statement, 384 /* EmitFlags.NoTokenSourceMaps */ | 1536 /* EmitFlags.NoComments */); + statements.push(statement); + } + else { + var statement = factory.createExpressionStatement(factory.createAssignment(factory.createPropertyAccessExpression(factory.createIdentifier("module"), "exports"), expressionResult)); + ts.setTextRange(statement, currentModuleInfo.exportEquals); + ts.setEmitFlags(statement, 1536 /* EmitFlags.NoComments */); + statements.push(statement); + } + } + } + } + // + // Top-Level Source Element Visitors + // + /** + * Visits a node at the top level of the source file. + * + * @param node The node to visit. + */ + function topLevelVisitor(node) { + switch (node.kind) { + case 269 /* SyntaxKind.ImportDeclaration */: + return visitImportDeclaration(node); + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return visitImportEqualsDeclaration(node); + case 275 /* SyntaxKind.ExportDeclaration */: + return visitExportDeclaration(node); + case 274 /* SyntaxKind.ExportAssignment */: + return visitExportAssignment(node); + case 240 /* SyntaxKind.VariableStatement */: + return visitVariableStatement(node); + case 259 /* SyntaxKind.FunctionDeclaration */: + return visitFunctionDeclaration(node); + case 260 /* SyntaxKind.ClassDeclaration */: + return visitClassDeclaration(node); + case 355 /* SyntaxKind.MergeDeclarationMarker */: + return visitMergeDeclarationMarker(node); + case 356 /* SyntaxKind.EndOfDeclarationMarker */: + return visitEndOfDeclarationMarker(node); + default: + return visitor(node); + } + } + function visitorWorker(node, valueIsDiscarded) { + // This visitor does not need to descend into the tree if there is no dynamic import, destructuring assignment, or update expression + // as export/import statements are only transformed at the top level of a file. + if (!(node.transformFlags & (8388608 /* TransformFlags.ContainsDynamicImport */ | 4096 /* TransformFlags.ContainsDestructuringAssignment */ | 268435456 /* TransformFlags.ContainsUpdateExpressionForIdentifier */))) { + return node; + } + switch (node.kind) { + case 245 /* SyntaxKind.ForStatement */: + return visitForStatement(node); + case 241 /* SyntaxKind.ExpressionStatement */: + return visitExpressionStatement(node); + case 214 /* SyntaxKind.ParenthesizedExpression */: + return visitParenthesizedExpression(node, valueIsDiscarded); + case 353 /* SyntaxKind.PartiallyEmittedExpression */: + return visitPartiallyEmittedExpression(node, valueIsDiscarded); + case 210 /* SyntaxKind.CallExpression */: + if (ts.isImportCall(node) && currentSourceFile.impliedNodeFormat === undefined) { + return visitImportCallExpression(node); + } + break; + case 223 /* SyntaxKind.BinaryExpression */: + if (ts.isDestructuringAssignment(node)) { + return visitDestructuringAssignment(node, valueIsDiscarded); + } + break; + case 221 /* SyntaxKind.PrefixUnaryExpression */: + case 222 /* SyntaxKind.PostfixUnaryExpression */: + return visitPreOrPostfixUnaryExpression(node, valueIsDiscarded); + } + return ts.visitEachChild(node, visitor, context); + } + function visitor(node) { + return visitorWorker(node, /*valueIsDiscarded*/ false); + } + function discardedValueVisitor(node) { + return visitorWorker(node, /*valueIsDiscarded*/ true); + } + function destructuringNeedsFlattening(node) { + if (ts.isObjectLiteralExpression(node)) { + for (var _i = 0, _a = node.properties; _i < _a.length; _i++) { + var elem = _a[_i]; + switch (elem.kind) { + case 299 /* SyntaxKind.PropertyAssignment */: + if (destructuringNeedsFlattening(elem.initializer)) { + return true; + } + break; + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + if (destructuringNeedsFlattening(elem.name)) { + return true; + } + break; + case 301 /* SyntaxKind.SpreadAssignment */: + if (destructuringNeedsFlattening(elem.expression)) { + return true; + } + break; + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + return false; + default: ts.Debug.assertNever(elem, "Unhandled object member kind"); + } + } + } + else if (ts.isArrayLiteralExpression(node)) { + for (var _b = 0, _c = node.elements; _b < _c.length; _b++) { + var elem = _c[_b]; + if (ts.isSpreadElement(elem)) { + if (destructuringNeedsFlattening(elem.expression)) { + return true; + } + } + else if (destructuringNeedsFlattening(elem)) { + return true; + } + } + } + else if (ts.isIdentifier(node)) { + return ts.length(getExports(node)) > (ts.isExportName(node) ? 1 : 0); + } + return false; + } + function visitDestructuringAssignment(node, valueIsDiscarded) { + if (destructuringNeedsFlattening(node.left)) { + return ts.flattenDestructuringAssignment(node, visitor, context, 0 /* FlattenLevel.All */, !valueIsDiscarded, createAllExportExpressions); + } + return ts.visitEachChild(node, visitor, context); + } + function visitForStatement(node) { + return factory.updateForStatement(node, ts.visitNode(node.initializer, discardedValueVisitor, ts.isForInitializer), ts.visitNode(node.condition, visitor, ts.isExpression), ts.visitNode(node.incrementor, discardedValueVisitor, ts.isExpression), ts.visitIterationBody(node.statement, visitor, context)); + } + function visitExpressionStatement(node) { + return factory.updateExpressionStatement(node, ts.visitNode(node.expression, discardedValueVisitor, ts.isExpression)); + } + function visitParenthesizedExpression(node, valueIsDiscarded) { + return factory.updateParenthesizedExpression(node, ts.visitNode(node.expression, valueIsDiscarded ? discardedValueVisitor : visitor, ts.isExpression)); + } + function visitPartiallyEmittedExpression(node, valueIsDiscarded) { + return factory.updatePartiallyEmittedExpression(node, ts.visitNode(node.expression, valueIsDiscarded ? discardedValueVisitor : visitor, ts.isExpression)); + } + function visitPreOrPostfixUnaryExpression(node, valueIsDiscarded) { + // When we see a prefix or postfix increment expression whose operand is an exported + // symbol, we should ensure all exports of that symbol are updated with the correct + // value. + // + // - We do not transform generated identifiers for any reason. + // - We do not transform identifiers tagged with the LocalName flag. + // - We do not transform identifiers that were originally the name of an enum or + // namespace due to how they are transformed in TypeScript. + // - We only transform identifiers that are exported at the top level. + if ((node.operator === 45 /* SyntaxKind.PlusPlusToken */ || node.operator === 46 /* SyntaxKind.MinusMinusToken */) + && ts.isIdentifier(node.operand) + && !ts.isGeneratedIdentifier(node.operand) + && !ts.isLocalName(node.operand) + && !ts.isDeclarationNameOfEnumOrNamespace(node.operand)) { + var exportedNames = getExports(node.operand); + if (exportedNames) { + var temp = void 0; + var expression = ts.visitNode(node.operand, visitor, ts.isExpression); + if (ts.isPrefixUnaryExpression(node)) { + expression = factory.updatePrefixUnaryExpression(node, expression); + } + else { + expression = factory.updatePostfixUnaryExpression(node, expression); + if (!valueIsDiscarded) { + temp = factory.createTempVariable(hoistVariableDeclaration); + expression = factory.createAssignment(temp, expression); + ts.setTextRange(expression, node); + } + expression = factory.createComma(expression, factory.cloneNode(node.operand)); + ts.setTextRange(expression, node); + } + for (var _i = 0, exportedNames_1 = exportedNames; _i < exportedNames_1.length; _i++) { + var exportName = exportedNames_1[_i]; + noSubstitution[ts.getNodeId(expression)] = true; + expression = createExportExpression(exportName, expression); + ts.setTextRange(expression, node); + } + if (temp) { + noSubstitution[ts.getNodeId(expression)] = true; + expression = factory.createComma(expression, temp); + ts.setTextRange(expression, node); + } + return expression; + } + } + return ts.visitEachChild(node, visitor, context); + } + function visitImportCallExpression(node) { + var externalModuleName = ts.getExternalModuleNameLiteral(factory, node, currentSourceFile, host, resolver, compilerOptions); + var firstArgument = ts.visitNode(ts.firstOrUndefined(node.arguments), visitor); + // Only use the external module name if it differs from the first argument. This allows us to preserve the quote style of the argument on output. + var argument = externalModuleName && (!firstArgument || !ts.isStringLiteral(firstArgument) || firstArgument.text !== externalModuleName.text) ? externalModuleName : firstArgument; + var containsLexicalThis = !!(node.transformFlags & 16384 /* TransformFlags.ContainsLexicalThis */); + switch (compilerOptions.module) { + case ts.ModuleKind.AMD: + return createImportCallExpressionAMD(argument, containsLexicalThis); + case ts.ModuleKind.UMD: + return createImportCallExpressionUMD(argument !== null && argument !== void 0 ? argument : factory.createVoidZero(), containsLexicalThis); + case ts.ModuleKind.CommonJS: + default: + return createImportCallExpressionCommonJS(argument); + } + } + function createImportCallExpressionUMD(arg, containsLexicalThis) { + // (function (factory) { + // ... (regular UMD) + // } + // })(function (require, exports, useSyncRequire) { + // "use strict"; + // Object.defineProperty(exports, "__esModule", { value: true }); + // var __syncRequire = typeof module === "object" && typeof module.exports === "object"; + // var __resolved = new Promise(function (resolve) { resolve(); }); + // ..... + // __syncRequire + // ? __resolved.then(function () { return require(x); }) /*CommonJs Require*/ + // : new Promise(function (_a, _b) { require([x], _a, _b); }); /*Amd Require*/ + // }); + needUMDDynamicImportHelper = true; + if (ts.isSimpleCopiableExpression(arg)) { + var argClone = ts.isGeneratedIdentifier(arg) ? arg : ts.isStringLiteral(arg) ? factory.createStringLiteralFromNode(arg) : ts.setEmitFlags(ts.setTextRange(factory.cloneNode(arg), arg), 1536 /* EmitFlags.NoComments */); + return factory.createConditionalExpression( + /*condition*/ factory.createIdentifier("__syncRequire"), + /*questionToken*/ undefined, + /*whenTrue*/ createImportCallExpressionCommonJS(arg), + /*colonToken*/ undefined, + /*whenFalse*/ createImportCallExpressionAMD(argClone, containsLexicalThis)); + } + else { + var temp = factory.createTempVariable(hoistVariableDeclaration); + return factory.createComma(factory.createAssignment(temp, arg), factory.createConditionalExpression( + /*condition*/ factory.createIdentifier("__syncRequire"), + /*questionToken*/ undefined, + /*whenTrue*/ createImportCallExpressionCommonJS(temp, /* isInlineable */ true), + /*colonToken*/ undefined, + /*whenFalse*/ createImportCallExpressionAMD(temp, containsLexicalThis))); + } + } + function createImportCallExpressionAMD(arg, containsLexicalThis) { + // improt("./blah") + // emit as + // define(["require", "exports", "blah"], function (require, exports) { + // ... + // new Promise(function (_a, _b) { require([x], _a, _b); }); /*Amd Require*/ + // }); + var resolve = factory.createUniqueName("resolve"); + var reject = factory.createUniqueName("reject"); + var parameters = [ + factory.createParameterDeclaration(/*modifiers*/ undefined, /*dotDotDotToken*/ undefined, /*name*/ resolve), + factory.createParameterDeclaration(/*modifiers*/ undefined, /*dotDotDotToken*/ undefined, /*name*/ reject) + ]; + var body = factory.createBlock([ + factory.createExpressionStatement(factory.createCallExpression(factory.createIdentifier("require"), + /*typeArguments*/ undefined, [factory.createArrayLiteralExpression([arg || factory.createOmittedExpression()]), resolve, reject])) + ]); + var func; + if (languageVersion >= 2 /* ScriptTarget.ES2015 */) { + func = factory.createArrowFunction( + /*modifiers*/ undefined, + /*typeParameters*/ undefined, parameters, + /*type*/ undefined, + /*equalsGreaterThanToken*/ undefined, body); + } + else { + func = factory.createFunctionExpression( + /*modifiers*/ undefined, + /*asteriskToken*/ undefined, + /*name*/ undefined, + /*typeParameters*/ undefined, parameters, + /*type*/ undefined, body); + // if there is a lexical 'this' in the import call arguments, ensure we indicate + // that this new function expression indicates it captures 'this' so that the + // es2015 transformer will properly substitute 'this' with '_this'. + if (containsLexicalThis) { + ts.setEmitFlags(func, 8 /* EmitFlags.CapturesThis */); + } + } + var promise = factory.createNewExpression(factory.createIdentifier("Promise"), /*typeArguments*/ undefined, [func]); + if (ts.getESModuleInterop(compilerOptions)) { + return factory.createCallExpression(factory.createPropertyAccessExpression(promise, factory.createIdentifier("then")), /*typeArguments*/ undefined, [emitHelpers().createImportStarCallbackHelper()]); + } + return promise; + } + function createImportCallExpressionCommonJS(arg, isInlineable) { + // import(x) + // emit as + // var _a; + // (_a = x, Promise.resolve().then(() => require(_a)) /*CommonJs Require*/ + // We have to wrap require in then callback so that require is done in asynchronously + // if we simply do require in resolve callback in Promise constructor. We will execute the loading immediately + // If the arg is not inlineable, we have to evaluate it in the current scope with a temp var + var temp = arg && !ts.isSimpleInlineableExpression(arg) && !isInlineable ? factory.createTempVariable(hoistVariableDeclaration) : undefined; + var promiseResolveCall = factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Promise"), "resolve"), + /*typeArguments*/ undefined, + /*argumentsArray*/ []); + var requireCall = factory.createCallExpression(factory.createIdentifier("require"), + /*typeArguments*/ undefined, temp ? [temp] : arg ? [arg] : []); + if (ts.getESModuleInterop(compilerOptions)) { + requireCall = emitHelpers().createImportStarHelper(requireCall); + } + var func; + if (languageVersion >= 2 /* ScriptTarget.ES2015 */) { + func = factory.createArrowFunction( + /*modifiers*/ undefined, + /*typeParameters*/ undefined, + /*parameters*/ [], + /*type*/ undefined, + /*equalsGreaterThanToken*/ undefined, requireCall); + } + else { + func = factory.createFunctionExpression( + /*modifiers*/ undefined, + /*asteriskToken*/ undefined, + /*name*/ undefined, + /*typeParameters*/ undefined, + /*parameters*/ [], + /*type*/ undefined, factory.createBlock([factory.createReturnStatement(requireCall)])); + } + var downleveledImport = factory.createCallExpression(factory.createPropertyAccessExpression(promiseResolveCall, "then"), /*typeArguments*/ undefined, [func]); + return temp === undefined ? downleveledImport : factory.createCommaListExpression([factory.createAssignment(temp, arg), downleveledImport]); + } + function getHelperExpressionForExport(node, innerExpr) { + if (!ts.getESModuleInterop(compilerOptions) || ts.getEmitFlags(node) & 67108864 /* EmitFlags.NeverApplyImportHelper */) { + return innerExpr; + } + if (ts.getExportNeedsImportStarHelper(node)) { + return emitHelpers().createImportStarHelper(innerExpr); + } + return innerExpr; + } + function getHelperExpressionForImport(node, innerExpr) { + if (!ts.getESModuleInterop(compilerOptions) || ts.getEmitFlags(node) & 67108864 /* EmitFlags.NeverApplyImportHelper */) { + return innerExpr; + } + if (ts.getImportNeedsImportStarHelper(node)) { + return emitHelpers().createImportStarHelper(innerExpr); + } + if (ts.getImportNeedsImportDefaultHelper(node)) { + return emitHelpers().createImportDefaultHelper(innerExpr); + } + return innerExpr; + } + /** + * Visits an ImportDeclaration node. + * + * @param node The node to visit. + */ + function visitImportDeclaration(node) { + var statements; + var namespaceDeclaration = ts.getNamespaceDeclarationNode(node); + if (moduleKind !== ts.ModuleKind.AMD) { + if (!node.importClause) { + // import "mod"; + return ts.setOriginalNode(ts.setTextRange(factory.createExpressionStatement(createRequireCall(node)), node), node); + } + else { + var variables = []; + if (namespaceDeclaration && !ts.isDefaultImport(node)) { + // import * as n from "mod"; + variables.push(factory.createVariableDeclaration(factory.cloneNode(namespaceDeclaration.name), + /*exclamationToken*/ undefined, + /*type*/ undefined, getHelperExpressionForImport(node, createRequireCall(node)))); + } + else { + // import d from "mod"; + // import { x, y } from "mod"; + // import d, { x, y } from "mod"; + // import d, * as n from "mod"; + variables.push(factory.createVariableDeclaration(factory.getGeneratedNameForNode(node), + /*exclamationToken*/ undefined, + /*type*/ undefined, getHelperExpressionForImport(node, createRequireCall(node)))); + if (namespaceDeclaration && ts.isDefaultImport(node)) { + variables.push(factory.createVariableDeclaration(factory.cloneNode(namespaceDeclaration.name), + /*exclamationToken*/ undefined, + /*type*/ undefined, factory.getGeneratedNameForNode(node))); + } + } + statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(factory.createVariableStatement( + /*modifiers*/ undefined, factory.createVariableDeclarationList(variables, languageVersion >= 2 /* ScriptTarget.ES2015 */ ? 2 /* NodeFlags.Const */ : 0 /* NodeFlags.None */)), + /*location*/ node), + /*original*/ node)); + } + } + else if (namespaceDeclaration && ts.isDefaultImport(node)) { + // import d, * as n from "mod"; + statements = ts.append(statements, factory.createVariableStatement( + /*modifiers*/ undefined, factory.createVariableDeclarationList([ + ts.setOriginalNode(ts.setTextRange(factory.createVariableDeclaration(factory.cloneNode(namespaceDeclaration.name), + /*exclamationToken*/ undefined, + /*type*/ undefined, factory.getGeneratedNameForNode(node)), + /*location*/ node), + /*original*/ node) + ], languageVersion >= 2 /* ScriptTarget.ES2015 */ ? 2 /* NodeFlags.Const */ : 0 /* NodeFlags.None */))); + } + if (hasAssociatedEndOfDeclarationMarker(node)) { + // Defer exports until we encounter an EndOfDeclarationMarker node + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportsOfImportDeclaration(deferredExports[id], node); + } + else { + statements = appendExportsOfImportDeclaration(statements, node); + } + return ts.singleOrMany(statements); + } + /** + * Creates a `require()` call to import an external module. + * + * @param importNode The declararation to import. + */ + function createRequireCall(importNode) { + var moduleName = ts.getExternalModuleNameLiteral(factory, importNode, currentSourceFile, host, resolver, compilerOptions); + var args = []; + if (moduleName) { + args.push(moduleName); + } + return factory.createCallExpression(factory.createIdentifier("require"), /*typeArguments*/ undefined, args); + } + /** + * Visits an ImportEqualsDeclaration node. + * + * @param node The node to visit. + */ + function visitImportEqualsDeclaration(node) { + ts.Debug.assert(ts.isExternalModuleImportEqualsDeclaration(node), "import= for internal module references should be handled in an earlier transformer."); + var statements; + if (moduleKind !== ts.ModuleKind.AMD) { + if (ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */)) { + statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(factory.createExpressionStatement(createExportExpression(node.name, createRequireCall(node))), node), node)); + } + else { + statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(factory.createVariableStatement( + /*modifiers*/ undefined, factory.createVariableDeclarationList([ + factory.createVariableDeclaration(factory.cloneNode(node.name), + /*exclamationToken*/ undefined, + /*type*/ undefined, createRequireCall(node)) + ], + /*flags*/ languageVersion >= 2 /* ScriptTarget.ES2015 */ ? 2 /* NodeFlags.Const */ : 0 /* NodeFlags.None */)), node), node)); + } + } + else { + if (ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */)) { + statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(factory.createExpressionStatement(createExportExpression(factory.getExportName(node), factory.getLocalName(node))), node), node)); + } + } + if (hasAssociatedEndOfDeclarationMarker(node)) { + // Defer exports until we encounter an EndOfDeclarationMarker node + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportsOfImportEqualsDeclaration(deferredExports[id], node); + } + else { + statements = appendExportsOfImportEqualsDeclaration(statements, node); + } + return ts.singleOrMany(statements); + } + /** + * Visits an ExportDeclaration node. + * + * @param The node to visit. + */ + function visitExportDeclaration(node) { + if (!node.moduleSpecifier) { + // Elide export declarations with no module specifier as they are handled + // elsewhere. + return undefined; + } + var generatedName = factory.getGeneratedNameForNode(node); + if (node.exportClause && ts.isNamedExports(node.exportClause)) { + var statements = []; + // export { x, y } from "mod"; + if (moduleKind !== ts.ModuleKind.AMD) { + statements.push(ts.setOriginalNode(ts.setTextRange(factory.createVariableStatement( + /*modifiers*/ undefined, factory.createVariableDeclarationList([ + factory.createVariableDeclaration(generatedName, + /*exclamationToken*/ undefined, + /*type*/ undefined, createRequireCall(node)) + ])), + /*location*/ node), + /* original */ node)); + } + for (var _i = 0, _a = node.exportClause.elements; _i < _a.length; _i++) { + var specifier = _a[_i]; + if (languageVersion === 0 /* ScriptTarget.ES3 */) { + statements.push(ts.setOriginalNode(ts.setTextRange(factory.createExpressionStatement(emitHelpers().createCreateBindingHelper(generatedName, factory.createStringLiteralFromNode(specifier.propertyName || specifier.name), specifier.propertyName ? factory.createStringLiteralFromNode(specifier.name) : undefined)), specifier), specifier)); + } + else { + var exportNeedsImportDefault = !!ts.getESModuleInterop(compilerOptions) && + !(ts.getEmitFlags(node) & 67108864 /* EmitFlags.NeverApplyImportHelper */) && + ts.idText(specifier.propertyName || specifier.name) === "default"; + var exportedValue = factory.createPropertyAccessExpression(exportNeedsImportDefault ? emitHelpers().createImportDefaultHelper(generatedName) : generatedName, specifier.propertyName || specifier.name); + statements.push(ts.setOriginalNode(ts.setTextRange(factory.createExpressionStatement(createExportExpression(factory.getExportName(specifier), exportedValue, /* location */ undefined, /* liveBinding */ true)), specifier), specifier)); + } + } + return ts.singleOrMany(statements); + } + else if (node.exportClause) { + var statements = []; + // export * as ns from "mod"; + // export * as default from "mod"; + statements.push(ts.setOriginalNode(ts.setTextRange(factory.createExpressionStatement(createExportExpression(factory.cloneNode(node.exportClause.name), getHelperExpressionForExport(node, moduleKind !== ts.ModuleKind.AMD ? + createRequireCall(node) : + ts.isExportNamespaceAsDefaultDeclaration(node) ? generatedName : + factory.createIdentifier(ts.idText(node.exportClause.name))))), node), node)); + return ts.singleOrMany(statements); + } + else { + // export * from "mod"; + return ts.setOriginalNode(ts.setTextRange(factory.createExpressionStatement(emitHelpers().createExportStarHelper(moduleKind !== ts.ModuleKind.AMD ? createRequireCall(node) : generatedName)), node), node); + } + } + /** + * Visits an ExportAssignment node. + * + * @param node The node to visit. + */ + function visitExportAssignment(node) { + if (node.isExportEquals) { + return undefined; + } + var statements; + var original = node.original; + if (original && hasAssociatedEndOfDeclarationMarker(original)) { + // Defer exports until we encounter an EndOfDeclarationMarker node + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportStatement(deferredExports[id], factory.createIdentifier("default"), ts.visitNode(node.expression, visitor), /*location*/ node, /*allowComments*/ true); + } + else { + statements = appendExportStatement(statements, factory.createIdentifier("default"), ts.visitNode(node.expression, visitor), /*location*/ node, /*allowComments*/ true); + } + return ts.singleOrMany(statements); + } + /** + * Visits a FunctionDeclaration node. + * + * @param node The node to visit. + */ + function visitFunctionDeclaration(node) { + var statements; + if (ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */)) { + statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(factory.createFunctionDeclaration(ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier), node.asteriskToken, factory.getDeclarationName(node, /*allowComments*/ true, /*allowSourceMaps*/ true), + /*typeParameters*/ undefined, ts.visitNodes(node.parameters, visitor), + /*type*/ undefined, ts.visitEachChild(node.body, visitor, context)), + /*location*/ node), + /*original*/ node)); + } + else { + statements = ts.append(statements, ts.visitEachChild(node, visitor, context)); + } + if (hasAssociatedEndOfDeclarationMarker(node)) { + // Defer exports until we encounter an EndOfDeclarationMarker node + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node); + } + else { + statements = appendExportsOfHoistedDeclaration(statements, node); + } + return ts.singleOrMany(statements); + } + /** + * Visits a ClassDeclaration node. + * + * @param node The node to visit. + */ + function visitClassDeclaration(node) { + var statements; + if (ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */)) { + statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(factory.createClassDeclaration(ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifierLike), factory.getDeclarationName(node, /*allowComments*/ true, /*allowSourceMaps*/ true), + /*typeParameters*/ undefined, ts.visitNodes(node.heritageClauses, visitor), ts.visitNodes(node.members, visitor)), node), node)); + } + else { + statements = ts.append(statements, ts.visitEachChild(node, visitor, context)); + } + if (hasAssociatedEndOfDeclarationMarker(node)) { + // Defer exports until we encounter an EndOfDeclarationMarker node + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node); + } + else { + statements = appendExportsOfHoistedDeclaration(statements, node); + } + return ts.singleOrMany(statements); + } + /** + * Visits a VariableStatement node. + * + * @param node The node to visit. + */ + function visitVariableStatement(node) { + var statements; + var variables; + var expressions; + if (ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */)) { + var modifiers = void 0; + var removeCommentsOnExpressions = false; + // If we're exporting these variables, then these just become assignments to 'exports.x'. + for (var _i = 0, _a = node.declarationList.declarations; _i < _a.length; _i++) { + var variable = _a[_i]; + if (ts.isIdentifier(variable.name) && ts.isLocalName(variable.name)) { + if (!modifiers) { + modifiers = ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifier); + } + variables = ts.append(variables, variable); + } + else if (variable.initializer) { + if (!ts.isBindingPattern(variable.name) && (ts.isArrowFunction(variable.initializer) || ts.isFunctionExpression(variable.initializer) || ts.isClassExpression(variable.initializer))) { + var expression = factory.createAssignment(ts.setTextRange(factory.createPropertyAccessExpression(factory.createIdentifier("exports"), variable.name), + /*location*/ variable.name), factory.createIdentifier(ts.getTextOfIdentifierOrLiteral(variable.name))); + var updatedVariable = factory.createVariableDeclaration(variable.name, variable.exclamationToken, variable.type, ts.visitNode(variable.initializer, visitor)); + variables = ts.append(variables, updatedVariable); + expressions = ts.append(expressions, expression); + removeCommentsOnExpressions = true; + } + else { + expressions = ts.append(expressions, transformInitializedVariable(variable)); + } + } + } + if (variables) { + statements = ts.append(statements, factory.updateVariableStatement(node, modifiers, factory.updateVariableDeclarationList(node.declarationList, variables))); + } + if (expressions) { + var statement = ts.setOriginalNode(ts.setTextRange(factory.createExpressionStatement(factory.inlineExpressions(expressions)), node), node); + if (removeCommentsOnExpressions) { + ts.removeAllComments(statement); + } + statements = ts.append(statements, statement); + } + } + else { + statements = ts.append(statements, ts.visitEachChild(node, visitor, context)); + } + if (hasAssociatedEndOfDeclarationMarker(node)) { + // Defer exports until we encounter an EndOfDeclarationMarker node + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], node); + } + else { + statements = appendExportsOfVariableStatement(statements, node); + } + return ts.singleOrMany(statements); + } + function createAllExportExpressions(name, value, location) { + var exportedNames = getExports(name); + if (exportedNames) { + // For each additional export of the declaration, apply an export assignment. + var expression = ts.isExportName(name) ? value : factory.createAssignment(name, value); + for (var _i = 0, exportedNames_2 = exportedNames; _i < exportedNames_2.length; _i++) { + var exportName = exportedNames_2[_i]; + // Mark the node to prevent triggering substitution. + ts.setEmitFlags(expression, 4 /* EmitFlags.NoSubstitution */); + expression = createExportExpression(exportName, expression, /*location*/ location); + } + return expression; + } + return factory.createAssignment(name, value); + } + /** + * Transforms an exported variable with an initializer into an expression. + * + * @param node The node to transform. + */ + function transformInitializedVariable(node) { + if (ts.isBindingPattern(node.name)) { + return ts.flattenDestructuringAssignment(ts.visitNode(node, visitor), + /*visitor*/ undefined, context, 0 /* FlattenLevel.All */, + /*needsValue*/ false, createAllExportExpressions); + } + else { + return factory.createAssignment(ts.setTextRange(factory.createPropertyAccessExpression(factory.createIdentifier("exports"), node.name), + /*location*/ node.name), node.initializer ? ts.visitNode(node.initializer, visitor) : factory.createVoidZero()); + } + } + /** + * Visits a MergeDeclarationMarker used as a placeholder for the beginning of a merged + * and transformed declaration. + * + * @param node The node to visit. + */ + function visitMergeDeclarationMarker(node) { + // For an EnumDeclaration or ModuleDeclaration that merges with a preceeding + // declaration we do not emit a leading variable declaration. To preserve the + // begin/end semantics of the declararation and to properly handle exports + // we wrapped the leading variable declaration in a `MergeDeclarationMarker`. + // + // To balance the declaration, add the exports of the elided variable + // statement. + if (hasAssociatedEndOfDeclarationMarker(node) && node.original.kind === 240 /* SyntaxKind.VariableStatement */) { + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], node.original); + } + return node; + } + /** + * Determines whether a node has an associated EndOfDeclarationMarker. + * + * @param node The node to test. + */ + function hasAssociatedEndOfDeclarationMarker(node) { + return (ts.getEmitFlags(node) & 4194304 /* EmitFlags.HasEndOfDeclarationMarker */) !== 0; + } + /** + * Visits a DeclarationMarker used as a placeholder for the end of a transformed + * declaration. + * + * @param node The node to visit. + */ + function visitEndOfDeclarationMarker(node) { + // For some transformations we emit an `EndOfDeclarationMarker` to mark the actual + // end of the transformed declaration. We use this marker to emit any deferred exports + // of the declaration. + var id = ts.getOriginalNodeId(node); + var statements = deferredExports[id]; + if (statements) { + delete deferredExports[id]; + return ts.append(statements, node); + } + return node; + } + /** + * Appends the exports of an ImportDeclaration to a statement list, returning the + * statement list. + * + * @param statements A statement list to which the down-level export statements are to be + * appended. If `statements` is `undefined`, a new array is allocated if statements are + * appended. + * @param decl The declaration whose exports are to be recorded. + */ + function appendExportsOfImportDeclaration(statements, decl) { + if (currentModuleInfo.exportEquals) { + return statements; + } + var importClause = decl.importClause; + if (!importClause) { + return statements; + } + if (importClause.name) { + statements = appendExportsOfDeclaration(statements, importClause); + } + var namedBindings = importClause.namedBindings; + if (namedBindings) { + switch (namedBindings.kind) { + case 271 /* SyntaxKind.NamespaceImport */: + statements = appendExportsOfDeclaration(statements, namedBindings); + break; + case 272 /* SyntaxKind.NamedImports */: + for (var _i = 0, _a = namedBindings.elements; _i < _a.length; _i++) { + var importBinding = _a[_i]; + statements = appendExportsOfDeclaration(statements, importBinding, /* liveBinding */ true); + } + break; + } + } + return statements; + } + /** + * Appends the exports of an ImportEqualsDeclaration to a statement list, returning the + * statement list. + * + * @param statements A statement list to which the down-level export statements are to be + * appended. If `statements` is `undefined`, a new array is allocated if statements are + * appended. + * @param decl The declaration whose exports are to be recorded. + */ + function appendExportsOfImportEqualsDeclaration(statements, decl) { + if (currentModuleInfo.exportEquals) { + return statements; + } + return appendExportsOfDeclaration(statements, decl); + } + /** + * Appends the exports of a VariableStatement to a statement list, returning the statement + * list. + * + * @param statements A statement list to which the down-level export statements are to be + * appended. If `statements` is `undefined`, a new array is allocated if statements are + * appended. + * @param node The VariableStatement whose exports are to be recorded. + */ + function appendExportsOfVariableStatement(statements, node) { + if (currentModuleInfo.exportEquals) { + return statements; + } + for (var _i = 0, _a = node.declarationList.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + statements = appendExportsOfBindingElement(statements, decl); + } + return statements; + } + /** + * Appends the exports of a VariableDeclaration or BindingElement to a statement list, + * returning the statement list. + * + * @param statements A statement list to which the down-level export statements are to be + * appended. If `statements` is `undefined`, a new array is allocated if statements are + * appended. + * @param decl The declaration whose exports are to be recorded. + */ + function appendExportsOfBindingElement(statements, decl) { + if (currentModuleInfo.exportEquals) { + return statements; + } + if (ts.isBindingPattern(decl.name)) { + for (var _i = 0, _a = decl.name.elements; _i < _a.length; _i++) { + var element = _a[_i]; + if (!ts.isOmittedExpression(element)) { + statements = appendExportsOfBindingElement(statements, element); + } + } + } + else if (!ts.isGeneratedIdentifier(decl.name)) { + statements = appendExportsOfDeclaration(statements, decl); + } + return statements; + } + /** + * Appends the exports of a ClassDeclaration or FunctionDeclaration to a statement list, + * returning the statement list. + * + * @param statements A statement list to which the down-level export statements are to be + * appended. If `statements` is `undefined`, a new array is allocated if statements are + * appended. + * @param decl The declaration whose exports are to be recorded. + */ + function appendExportsOfHoistedDeclaration(statements, decl) { + if (currentModuleInfo.exportEquals) { + return statements; + } + if (ts.hasSyntacticModifier(decl, 1 /* ModifierFlags.Export */)) { + var exportName = ts.hasSyntacticModifier(decl, 1024 /* ModifierFlags.Default */) ? factory.createIdentifier("default") : factory.getDeclarationName(decl); + statements = appendExportStatement(statements, exportName, factory.getLocalName(decl), /*location*/ decl); + } + if (decl.name) { + statements = appendExportsOfDeclaration(statements, decl); + } + return statements; + } + /** + * Appends the exports of a declaration to a statement list, returning the statement list. + * + * @param statements A statement list to which the down-level export statements are to be + * appended. If `statements` is `undefined`, a new array is allocated if statements are + * appended. + * @param decl The declaration to export. + */ + function appendExportsOfDeclaration(statements, decl, liveBinding) { + var name = factory.getDeclarationName(decl); + var exportSpecifiers = currentModuleInfo.exportSpecifiers.get(ts.idText(name)); + if (exportSpecifiers) { + for (var _i = 0, exportSpecifiers_1 = exportSpecifiers; _i < exportSpecifiers_1.length; _i++) { + var exportSpecifier = exportSpecifiers_1[_i]; + statements = appendExportStatement(statements, exportSpecifier.name, name, /*location*/ exportSpecifier.name, /* allowComments */ undefined, liveBinding); + } + } + return statements; + } + /** + * Appends the down-level representation of an export to a statement list, returning the + * statement list. + * + * @param statements A statement list to which the down-level export statements are to be + * appended. If `statements` is `undefined`, a new array is allocated if statements are + * appended. + * @param exportName The name of the export. + * @param expression The expression to export. + * @param location The location to use for source maps and comments for the export. + * @param allowComments Whether to allow comments on the export. + */ + function appendExportStatement(statements, exportName, expression, location, allowComments, liveBinding) { + statements = ts.append(statements, createExportStatement(exportName, expression, location, allowComments, liveBinding)); + return statements; + } + function createUnderscoreUnderscoreESModule() { + var statement; + if (languageVersion === 0 /* ScriptTarget.ES3 */) { + statement = factory.createExpressionStatement(createExportExpression(factory.createIdentifier("__esModule"), factory.createTrue())); + } + else { + statement = factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Object"), "defineProperty"), + /*typeArguments*/ undefined, [ + factory.createIdentifier("exports"), + factory.createStringLiteral("__esModule"), + factory.createObjectLiteralExpression([ + factory.createPropertyAssignment("value", factory.createTrue()) + ]) + ])); + } + ts.setEmitFlags(statement, 1048576 /* EmitFlags.CustomPrologue */); + return statement; + } + /** + * Creates a call to the current file's export function to export a value. + * + * @param name The bound name of the export. + * @param value The exported value. + * @param location The location to use for source maps and comments for the export. + * @param allowComments An optional value indicating whether to emit comments for the statement. + */ + function createExportStatement(name, value, location, allowComments, liveBinding) { + var statement = ts.setTextRange(factory.createExpressionStatement(createExportExpression(name, value, /* location */ undefined, liveBinding)), location); + ts.startOnNewLine(statement); + if (!allowComments) { + ts.setEmitFlags(statement, 1536 /* EmitFlags.NoComments */); + } + return statement; + } + /** + * Creates a call to the current file's export function to export a value. + * + * @param name The bound name of the export. + * @param value The exported value. + * @param location The location to use for source maps and comments for the export. + */ + function createExportExpression(name, value, location, liveBinding) { + return ts.setTextRange(liveBinding && languageVersion !== 0 /* ScriptTarget.ES3 */ ? factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("Object"), "defineProperty"), + /*typeArguments*/ undefined, [ + factory.createIdentifier("exports"), + factory.createStringLiteralFromNode(name), + factory.createObjectLiteralExpression([ + factory.createPropertyAssignment("enumerable", factory.createTrue()), + factory.createPropertyAssignment("get", factory.createFunctionExpression( + /*modifiers*/ undefined, + /*asteriskToken*/ undefined, + /*name*/ undefined, + /*typeParameters*/ undefined, + /*parameters*/ [], + /*type*/ undefined, factory.createBlock([factory.createReturnStatement(value)]))) + ]) + ]) : factory.createAssignment(factory.createPropertyAccessExpression(factory.createIdentifier("exports"), factory.cloneNode(name)), value), location); + } + // + // Modifier Visitors + // + /** + * Visit nodes to elide module-specific modifiers. + * + * @param node The node to visit. + */ + function modifierVisitor(node) { + // Elide module-specific modifiers. + switch (node.kind) { + case 93 /* SyntaxKind.ExportKeyword */: + case 88 /* SyntaxKind.DefaultKeyword */: + return undefined; + } + return node; + } + // + // Emit Notification + // + /** + * Hook for node emit notifications. + * + * @param hint A hint as to the intended usage of the node. + * @param node The node to emit. + * @param emit A callback used to emit the node in the printer. + */ + function onEmitNode(hint, node, emitCallback) { + if (node.kind === 308 /* SyntaxKind.SourceFile */) { + currentSourceFile = node; + currentModuleInfo = moduleInfoMap[ts.getOriginalNodeId(currentSourceFile)]; + previousOnEmitNode(hint, node, emitCallback); + currentSourceFile = undefined; + currentModuleInfo = undefined; + } + else { + previousOnEmitNode(hint, node, emitCallback); + } + } + // + // Substitutions + // + /** + * Hooks node substitutions. + * + * @param hint A hint as to the intended usage of the node. + * @param node The node to substitute. + */ + function onSubstituteNode(hint, node) { + node = previousOnSubstituteNode(hint, node); + if (node.id && noSubstitution[node.id]) { + return node; + } + if (hint === 1 /* EmitHint.Expression */) { + return substituteExpression(node); + } + else if (ts.isShorthandPropertyAssignment(node)) { + return substituteShorthandPropertyAssignment(node); + } + return node; + } + /** + * Substitution for a ShorthandPropertyAssignment whose declaration name is an imported + * or exported symbol. + * + * @param node The node to substitute. + */ + function substituteShorthandPropertyAssignment(node) { + var name = node.name; + var exportedOrImportedName = substituteExpressionIdentifier(name); + if (exportedOrImportedName !== name) { + // A shorthand property with an assignment initializer is probably part of a + // destructuring assignment + if (node.objectAssignmentInitializer) { + var initializer = factory.createAssignment(exportedOrImportedName, node.objectAssignmentInitializer); + return ts.setTextRange(factory.createPropertyAssignment(name, initializer), node); + } + return ts.setTextRange(factory.createPropertyAssignment(name, exportedOrImportedName), node); + } + return node; + } + /** + * Substitution for an Expression that may contain an imported or exported symbol. + * + * @param node The node to substitute. + */ + function substituteExpression(node) { + switch (node.kind) { + case 79 /* SyntaxKind.Identifier */: + return substituteExpressionIdentifier(node); + case 210 /* SyntaxKind.CallExpression */: + return substituteCallExpression(node); + case 212 /* SyntaxKind.TaggedTemplateExpression */: + return substituteTaggedTemplateExpression(node); + case 223 /* SyntaxKind.BinaryExpression */: + return substituteBinaryExpression(node); + } + return node; + } + function substituteCallExpression(node) { + if (ts.isIdentifier(node.expression)) { + var expression = substituteExpressionIdentifier(node.expression); + noSubstitution[ts.getNodeId(expression)] = true; + if (!ts.isIdentifier(expression) && !(ts.getEmitFlags(node.expression) & 4096 /* EmitFlags.HelperName */)) { + return ts.addEmitFlags(factory.updateCallExpression(node, expression, + /*typeArguments*/ undefined, node.arguments), 536870912 /* EmitFlags.IndirectCall */); + } + } + return node; + } + function substituteTaggedTemplateExpression(node) { + if (ts.isIdentifier(node.tag)) { + var tag = substituteExpressionIdentifier(node.tag); + noSubstitution[ts.getNodeId(tag)] = true; + if (!ts.isIdentifier(tag) && !(ts.getEmitFlags(node.tag) & 4096 /* EmitFlags.HelperName */)) { + return ts.addEmitFlags(factory.updateTaggedTemplateExpression(node, tag, + /*typeArguments*/ undefined, node.template), 536870912 /* EmitFlags.IndirectCall */); + } + } + return node; + } + /** + * Substitution for an Identifier expression that may contain an imported or exported + * symbol. + * + * @param node The node to substitute. + */ + function substituteExpressionIdentifier(node) { + var _a, _b; + if (ts.getEmitFlags(node) & 4096 /* EmitFlags.HelperName */) { + var externalHelpersModuleName = ts.getExternalHelpersModuleName(currentSourceFile); + if (externalHelpersModuleName) { + return factory.createPropertyAccessExpression(externalHelpersModuleName, node); + } + return node; + } + else if (!(ts.isGeneratedIdentifier(node) && !(node.autoGenerateFlags & 64 /* GeneratedIdentifierFlags.AllowNameSubstitution */)) && !ts.isLocalName(node)) { + var exportContainer = resolver.getReferencedExportContainer(node, ts.isExportName(node)); + if (exportContainer && exportContainer.kind === 308 /* SyntaxKind.SourceFile */) { + return ts.setTextRange(factory.createPropertyAccessExpression(factory.createIdentifier("exports"), factory.cloneNode(node)), + /*location*/ node); + } + var importDeclaration = resolver.getReferencedImportDeclaration(node); + if (importDeclaration) { + if (ts.isImportClause(importDeclaration)) { + return ts.setTextRange(factory.createPropertyAccessExpression(factory.getGeneratedNameForNode(importDeclaration.parent), factory.createIdentifier("default")), + /*location*/ node); + } + else if (ts.isImportSpecifier(importDeclaration)) { + var name = importDeclaration.propertyName || importDeclaration.name; + return ts.setTextRange(factory.createPropertyAccessExpression(factory.getGeneratedNameForNode(((_b = (_a = importDeclaration.parent) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.parent) || importDeclaration), factory.cloneNode(name)), + /*location*/ node); + } + } + } + return node; + } + /** + * Substitution for a BinaryExpression that may contain an imported or exported symbol. + * + * @param node The node to substitute. + */ + function substituteBinaryExpression(node) { + // When we see an assignment expression whose left-hand side is an exported symbol, + // we should ensure all exports of that symbol are updated with the correct value. + // + // - We do not substitute generated identifiers for any reason. + // - We do not substitute identifiers tagged with the LocalName flag. + // - We do not substitute identifiers that were originally the name of an enum or + // namespace due to how they are transformed in TypeScript. + // - We only substitute identifiers that are exported at the top level. + if (ts.isAssignmentOperator(node.operatorToken.kind) + && ts.isIdentifier(node.left) + && !ts.isGeneratedIdentifier(node.left) + && !ts.isLocalName(node.left) + && !ts.isDeclarationNameOfEnumOrNamespace(node.left)) { + var exportedNames = getExports(node.left); + if (exportedNames) { + // For each additional export of the declaration, apply an export assignment. + var expression = node; + for (var _i = 0, exportedNames_3 = exportedNames; _i < exportedNames_3.length; _i++) { + var exportName = exportedNames_3[_i]; + // Mark the node to prevent triggering this rule again. + noSubstitution[ts.getNodeId(expression)] = true; + expression = createExportExpression(exportName, expression, /*location*/ node); + } + return expression; + } + } + return node; + } + /** + * Gets the additional exports of a name. + * + * @param name The name. + */ + function getExports(name) { + if (!ts.isGeneratedIdentifier(name)) { + var valueDeclaration = resolver.getReferencedImportDeclaration(name) + || resolver.getReferencedValueDeclaration(name); + if (valueDeclaration) { + return currentModuleInfo + && currentModuleInfo.exportedBindings[ts.getOriginalNodeId(valueDeclaration)]; + } + } + } + } + ts.transformModule = transformModule; + // emit helper for dynamic import + var dynamicImportUMDHelper = { + name: "typescript:dynamicimport-sync-require", + scoped: true, + text: "\n var __syncRequire = typeof module === \"object\" && typeof module.exports === \"object\";" + }; +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + function transformSystemModule(context) { + var factory = context.factory, startLexicalEnvironment = context.startLexicalEnvironment, endLexicalEnvironment = context.endLexicalEnvironment, hoistVariableDeclaration = context.hoistVariableDeclaration; + var compilerOptions = context.getCompilerOptions(); + var resolver = context.getEmitResolver(); + var host = context.getEmitHost(); + var previousOnSubstituteNode = context.onSubstituteNode; + var previousOnEmitNode = context.onEmitNode; + context.onSubstituteNode = onSubstituteNode; + context.onEmitNode = onEmitNode; + context.enableSubstitution(79 /* SyntaxKind.Identifier */); // Substitutes expression identifiers for imported symbols. + context.enableSubstitution(300 /* SyntaxKind.ShorthandPropertyAssignment */); // Substitutes expression identifiers for imported symbols + context.enableSubstitution(223 /* SyntaxKind.BinaryExpression */); // Substitutes assignments to exported symbols. + context.enableSubstitution(233 /* SyntaxKind.MetaProperty */); // Substitutes 'import.meta' + context.enableEmitNotification(308 /* SyntaxKind.SourceFile */); // Restore state when substituting nodes in a file. + var moduleInfoMap = []; // The ExternalModuleInfo for each file. + var deferredExports = []; // Exports to defer until an EndOfDeclarationMarker is found. + var exportFunctionsMap = []; // The export function associated with a source file. + var noSubstitutionMap = []; // Set of nodes for which substitution rules should be ignored for each file. + var contextObjectMap = []; // The context object associated with a source file. + var currentSourceFile; // The current file. + var moduleInfo; // ExternalModuleInfo for the current file. + var exportFunction; // The export function for the current file. + var contextObject; // The context object for the current file. + var hoistedStatements; + var enclosingBlockScopedContainer; + var noSubstitution; // Set of nodes for which substitution rules should be ignored. + return ts.chainBundle(context, transformSourceFile); + /** + * Transforms the module aspects of a SourceFile. + * + * @param node The SourceFile node. + */ + function transformSourceFile(node) { + if (node.isDeclarationFile || !(ts.isEffectiveExternalModule(node, compilerOptions) || node.transformFlags & 8388608 /* TransformFlags.ContainsDynamicImport */)) { + return node; + } + var id = ts.getOriginalNodeId(node); + currentSourceFile = node; + enclosingBlockScopedContainer = node; + // System modules have the following shape: + // + // System.register(['dep-1', ... 'dep-n'], function(exports) {/* module body function */}) + // + // The parameter 'exports' here is a callback '(name: string, value: T) => T' that + // is used to publish exported values. 'exports' returns its 'value' argument so in + // most cases expressions that mutate exported values can be rewritten as: + // + // expr -> exports('name', expr) + // + // The only exception in this rule is postfix unary operators, + // see comment to 'substitutePostfixUnaryExpression' for more details + // Collect information about the external module and dependency groups. + moduleInfo = moduleInfoMap[id] = ts.collectExternalModuleInfo(context, node, resolver, compilerOptions); + // Make sure that the name of the 'exports' function does not conflict with + // existing identifiers. + exportFunction = factory.createUniqueName("exports"); + exportFunctionsMap[id] = exportFunction; + contextObject = contextObjectMap[id] = factory.createUniqueName("context"); + // Add the body of the module. + var dependencyGroups = collectDependencyGroups(moduleInfo.externalImports); + var moduleBodyBlock = createSystemModuleBody(node, dependencyGroups); + var moduleBodyFunction = factory.createFunctionExpression( + /*modifiers*/ undefined, + /*asteriskToken*/ undefined, + /*name*/ undefined, + /*typeParameters*/ undefined, [ + factory.createParameterDeclaration(/*modifiers*/ undefined, /*dotDotDotToken*/ undefined, exportFunction), + factory.createParameterDeclaration(/*modifiers*/ undefined, /*dotDotDotToken*/ undefined, contextObject) + ], + /*type*/ undefined, moduleBodyBlock); + // Write the call to `System.register` + // Clear the emit-helpers flag for later passes since we'll have already used it in the module body + // So the helper will be emit at the correct position instead of at the top of the source-file + var moduleName = ts.tryGetModuleNameFromFile(factory, node, host, compilerOptions); + var dependencies = factory.createArrayLiteralExpression(ts.map(dependencyGroups, function (dependencyGroup) { return dependencyGroup.name; })); + var updated = ts.setEmitFlags(factory.updateSourceFile(node, ts.setTextRange(factory.createNodeArray([ + factory.createExpressionStatement(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("System"), "register"), + /*typeArguments*/ undefined, moduleName + ? [moduleName, dependencies, moduleBodyFunction] + : [dependencies, moduleBodyFunction])) + ]), node.statements)), 1024 /* EmitFlags.NoTrailingComments */); + if (!ts.outFile(compilerOptions)) { + ts.moveEmitHelpers(updated, moduleBodyBlock, function (helper) { return !helper.scoped; }); + } + if (noSubstitution) { + noSubstitutionMap[id] = noSubstitution; + noSubstitution = undefined; + } + currentSourceFile = undefined; + moduleInfo = undefined; + exportFunction = undefined; + contextObject = undefined; + hoistedStatements = undefined; + enclosingBlockScopedContainer = undefined; + return updated; + } + /** + * Collects the dependency groups for this files imports. + * + * @param externalImports The imports for the file. + */ + function collectDependencyGroups(externalImports) { + var groupIndices = new ts.Map(); + var dependencyGroups = []; + for (var _i = 0, externalImports_1 = externalImports; _i < externalImports_1.length; _i++) { + var externalImport = externalImports_1[_i]; + var externalModuleName = ts.getExternalModuleNameLiteral(factory, externalImport, currentSourceFile, host, resolver, compilerOptions); + if (externalModuleName) { + var text = externalModuleName.text; + var groupIndex = groupIndices.get(text); + if (groupIndex !== undefined) { + // deduplicate/group entries in dependency list by the dependency name + dependencyGroups[groupIndex].externalImports.push(externalImport); + } + else { + groupIndices.set(text, dependencyGroups.length); + dependencyGroups.push({ + name: externalModuleName, + externalImports: [externalImport] + }); + } + } + } + return dependencyGroups; + } + /** + * Adds the statements for the module body function for the source file. + * + * @param node The source file for the module. + * @param dependencyGroups The grouped dependencies of the module. + */ + function createSystemModuleBody(node, dependencyGroups) { + // Shape of the body in system modules: + // + // function (exports) { + // + // + // + // return { + // setters: [ + // + // ], + // execute: function() { + // + // } + // } + // + // } + // + // i.e: + // + // import {x} from 'file1' + // var y = 1; + // export function foo() { return y + x(); } + // console.log(y); + // + // Will be transformed to: + // + // function(exports) { + // function foo() { return y + file_1.x(); } + // exports("foo", foo); + // var file_1, y; + // return { + // setters: [ + // function(v) { file_1 = v } + // ], + // execute(): function() { + // y = 1; + // console.log(y); + // } + // }; + // } + var statements = []; + // We start a new lexical environment in this function body, but *not* in the + // body of the execute function. This allows us to emit temporary declarations + // only in the outer module body and not in the inner one. + startLexicalEnvironment(); + // Add any prologue directives. + var ensureUseStrict = ts.getStrictOptionValue(compilerOptions, "alwaysStrict") || (!compilerOptions.noImplicitUseStrict && ts.isExternalModule(currentSourceFile)); + var statementOffset = factory.copyPrologue(node.statements, statements, ensureUseStrict, topLevelVisitor); + // var __moduleName = context_1 && context_1.id; + statements.push(factory.createVariableStatement( + /*modifiers*/ undefined, factory.createVariableDeclarationList([ + factory.createVariableDeclaration("__moduleName", + /*exclamationToken*/ undefined, + /*type*/ undefined, factory.createLogicalAnd(contextObject, factory.createPropertyAccessExpression(contextObject, "id"))) + ]))); + // Visit the synthetic external helpers import declaration if present + ts.visitNode(moduleInfo.externalHelpersImportDeclaration, topLevelVisitor, ts.isStatement); + // Visit the statements of the source file, emitting any transformations into + // the `executeStatements` array. We do this *before* we fill the `setters` array + // as we both emit transformations as well as aggregate some data used when creating + // setters. This allows us to reduce the number of times we need to loop through the + // statements of the source file. + var executeStatements = ts.visitNodes(node.statements, topLevelVisitor, ts.isStatement, statementOffset); + // Emit early exports for function declarations. + ts.addRange(statements, hoistedStatements); + // We emit hoisted variables early to align roughly with our previous emit output. + // Two key differences in this approach are: + // - Temporary variables will appear at the top rather than at the bottom of the file + ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment()); + var exportStarFunction = addExportStarIfNeeded(statements); // TODO: GH#18217 + var modifiers = node.transformFlags & 2097152 /* TransformFlags.ContainsAwait */ ? + factory.createModifiersFromModifierFlags(512 /* ModifierFlags.Async */) : + undefined; + var moduleObject = factory.createObjectLiteralExpression([ + factory.createPropertyAssignment("setters", createSettersArray(exportStarFunction, dependencyGroups)), + factory.createPropertyAssignment("execute", factory.createFunctionExpression(modifiers, + /*asteriskToken*/ undefined, + /*name*/ undefined, + /*typeParameters*/ undefined, + /*parameters*/ [], + /*type*/ undefined, factory.createBlock(executeStatements, /*multiLine*/ true))) + ], /*multiLine*/ true); + statements.push(factory.createReturnStatement(moduleObject)); + return factory.createBlock(statements, /*multiLine*/ true); + } + /** + * Adds an exportStar function to a statement list if it is needed for the file. + * + * @param statements A statement list. + */ + function addExportStarIfNeeded(statements) { + if (!moduleInfo.hasExportStarsToExportValues) { + return; + } + // when resolving exports local exported entries/indirect exported entries in the module + // should always win over entries with similar names that were added via star exports + // to support this we store names of local/indirect exported entries in a set. + // this set is used to filter names brought by star expors. + // local names set should only be added if we have anything exported + if (!moduleInfo.exportedNames && moduleInfo.exportSpecifiers.size === 0) { + // no exported declarations (export var ...) or export specifiers (export {x}) + // check if we have any non star export declarations. + var hasExportDeclarationWithExportClause = false; + for (var _i = 0, _a = moduleInfo.externalImports; _i < _a.length; _i++) { + var externalImport = _a[_i]; + if (externalImport.kind === 275 /* SyntaxKind.ExportDeclaration */ && externalImport.exportClause) { + hasExportDeclarationWithExportClause = true; + break; + } + } + if (!hasExportDeclarationWithExportClause) { + // we still need to emit exportStar helper + var exportStarFunction_1 = createExportStarFunction(/*localNames*/ undefined); + statements.push(exportStarFunction_1); + return exportStarFunction_1.name; + } + } + var exportedNames = []; + if (moduleInfo.exportedNames) { + for (var _b = 0, _c = moduleInfo.exportedNames; _b < _c.length; _b++) { + var exportedLocalName = _c[_b]; + if (exportedLocalName.escapedText === "default") { + continue; + } + // write name of exported declaration, i.e 'export var x...' + exportedNames.push(factory.createPropertyAssignment(factory.createStringLiteralFromNode(exportedLocalName), factory.createTrue())); + } + } + var exportedNamesStorageRef = factory.createUniqueName("exportedNames"); + statements.push(factory.createVariableStatement( + /*modifiers*/ undefined, factory.createVariableDeclarationList([ + factory.createVariableDeclaration(exportedNamesStorageRef, + /*exclamationToken*/ undefined, + /*type*/ undefined, factory.createObjectLiteralExpression(exportedNames, /*multiline*/ true)) + ]))); + var exportStarFunction = createExportStarFunction(exportedNamesStorageRef); + statements.push(exportStarFunction); + return exportStarFunction.name; + } + /** + * Creates an exportStar function for the file, with an optional set of excluded local + * names. + * + * @param localNames An optional reference to an object containing a set of excluded local + * names. + */ + function createExportStarFunction(localNames) { + var exportStarFunction = factory.createUniqueName("exportStar"); + var m = factory.createIdentifier("m"); + var n = factory.createIdentifier("n"); + var exports = factory.createIdentifier("exports"); + var condition = factory.createStrictInequality(n, factory.createStringLiteral("default")); + if (localNames) { + condition = factory.createLogicalAnd(condition, factory.createLogicalNot(factory.createCallExpression(factory.createPropertyAccessExpression(localNames, "hasOwnProperty"), + /*typeArguments*/ undefined, [n]))); + } + return factory.createFunctionDeclaration( + /*modifiers*/ undefined, + /*asteriskToken*/ undefined, exportStarFunction, + /*typeParameters*/ undefined, [factory.createParameterDeclaration(/*modifiers*/ undefined, /*dotDotDotToken*/ undefined, m)], + /*type*/ undefined, factory.createBlock([ + factory.createVariableStatement( + /*modifiers*/ undefined, factory.createVariableDeclarationList([ + factory.createVariableDeclaration(exports, + /*exclamationToken*/ undefined, + /*type*/ undefined, factory.createObjectLiteralExpression([])) + ])), + factory.createForInStatement(factory.createVariableDeclarationList([ + factory.createVariableDeclaration(n) + ]), m, factory.createBlock([ + ts.setEmitFlags(factory.createIfStatement(condition, factory.createExpressionStatement(factory.createAssignment(factory.createElementAccessExpression(exports, n), factory.createElementAccessExpression(m, n)))), 1 /* EmitFlags.SingleLine */) + ])), + factory.createExpressionStatement(factory.createCallExpression(exportFunction, + /*typeArguments*/ undefined, [exports])) + ], /*multiline*/ true)); + } + /** + * Creates an array setter callbacks for each dependency group. + * + * @param exportStarFunction A reference to an exportStarFunction for the file. + * @param dependencyGroups An array of grouped dependencies. + */ + function createSettersArray(exportStarFunction, dependencyGroups) { + var setters = []; + for (var _i = 0, dependencyGroups_1 = dependencyGroups; _i < dependencyGroups_1.length; _i++) { + var group_2 = dependencyGroups_1[_i]; + // derive a unique name for parameter from the first named entry in the group + var localName = ts.forEach(group_2.externalImports, function (i) { return ts.getLocalNameForExternalImport(factory, i, currentSourceFile); }); + var parameterName = localName ? factory.getGeneratedNameForNode(localName) : factory.createUniqueName(""); + var statements = []; + for (var _a = 0, _b = group_2.externalImports; _a < _b.length; _a++) { + var entry = _b[_a]; + var importVariableName = ts.getLocalNameForExternalImport(factory, entry, currentSourceFile); // TODO: GH#18217 + switch (entry.kind) { + case 269 /* SyntaxKind.ImportDeclaration */: + if (!entry.importClause) { + // 'import "..."' case + // module is imported only for side-effects, no emit required + break; + } + // falls through + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + ts.Debug.assert(importVariableName !== undefined); + // save import into the local + statements.push(factory.createExpressionStatement(factory.createAssignment(importVariableName, parameterName))); + if (ts.hasSyntacticModifier(entry, 1 /* ModifierFlags.Export */)) { + statements.push(factory.createExpressionStatement(factory.createCallExpression(exportFunction, + /*typeArguments*/ undefined, [ + factory.createStringLiteral(ts.idText(importVariableName)), + parameterName, + ]))); + } + break; + case 275 /* SyntaxKind.ExportDeclaration */: + ts.Debug.assert(importVariableName !== undefined); + if (entry.exportClause) { + if (ts.isNamedExports(entry.exportClause)) { + // export {a, b as c} from 'foo' + // + // emit as: + // + // exports_({ + // "a": _["a"], + // "c": _["b"] + // }); + var properties = []; + for (var _c = 0, _d = entry.exportClause.elements; _c < _d.length; _c++) { + var e = _d[_c]; + properties.push(factory.createPropertyAssignment(factory.createStringLiteral(ts.idText(e.name)), factory.createElementAccessExpression(parameterName, factory.createStringLiteral(ts.idText(e.propertyName || e.name))))); + } + statements.push(factory.createExpressionStatement(factory.createCallExpression(exportFunction, + /*typeArguments*/ undefined, [factory.createObjectLiteralExpression(properties, /*multiline*/ true)]))); + } + else { + statements.push(factory.createExpressionStatement(factory.createCallExpression(exportFunction, + /*typeArguments*/ undefined, [ + factory.createStringLiteral(ts.idText(entry.exportClause.name)), + parameterName + ]))); + } + } + else { + // export * from 'foo' + // + // emit as: + // + // exportStar(foo_1_1); + statements.push(factory.createExpressionStatement(factory.createCallExpression(exportStarFunction, + /*typeArguments*/ undefined, [parameterName]))); + } + break; + } + } + setters.push(factory.createFunctionExpression( + /*modifiers*/ undefined, + /*asteriskToken*/ undefined, + /*name*/ undefined, + /*typeParameters*/ undefined, [factory.createParameterDeclaration(/*modifiers*/ undefined, /*dotDotDotToken*/ undefined, parameterName)], + /*type*/ undefined, factory.createBlock(statements, /*multiLine*/ true))); + } + return factory.createArrayLiteralExpression(setters, /*multiLine*/ true); + } + // + // Top-level Source Element Visitors + // + /** + * Visit source elements at the top-level of a module. + * + * @param node The node to visit. + */ + function topLevelVisitor(node) { + switch (node.kind) { + case 269 /* SyntaxKind.ImportDeclaration */: + return visitImportDeclaration(node); + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return visitImportEqualsDeclaration(node); + case 275 /* SyntaxKind.ExportDeclaration */: + return visitExportDeclaration(node); + case 274 /* SyntaxKind.ExportAssignment */: + return visitExportAssignment(node); + default: + return topLevelNestedVisitor(node); + } + } + /** + * Visits an ImportDeclaration node. + * + * @param node The node to visit. + */ + function visitImportDeclaration(node) { + var statements; + if (node.importClause) { + hoistVariableDeclaration(ts.getLocalNameForExternalImport(factory, node, currentSourceFile)); // TODO: GH#18217 + } + if (hasAssociatedEndOfDeclarationMarker(node)) { + // Defer exports until we encounter an EndOfDeclarationMarker node + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportsOfImportDeclaration(deferredExports[id], node); + } + else { + statements = appendExportsOfImportDeclaration(statements, node); + } + return ts.singleOrMany(statements); + } + function visitExportDeclaration(node) { + ts.Debug.assertIsDefined(node); + return undefined; + } + /** + * Visits an ImportEqualsDeclaration node. + * + * @param node The node to visit. + */ + function visitImportEqualsDeclaration(node) { + ts.Debug.assert(ts.isExternalModuleImportEqualsDeclaration(node), "import= for internal module references should be handled in an earlier transformer."); + var statements; + hoistVariableDeclaration(ts.getLocalNameForExternalImport(factory, node, currentSourceFile)); // TODO: GH#18217 + if (hasAssociatedEndOfDeclarationMarker(node)) { + // Defer exports until we encounter an EndOfDeclarationMarker node + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportsOfImportEqualsDeclaration(deferredExports[id], node); + } + else { + statements = appendExportsOfImportEqualsDeclaration(statements, node); + } + return ts.singleOrMany(statements); + } + /** + * Visits an ExportAssignment node. + * + * @param node The node to visit. + */ + function visitExportAssignment(node) { + if (node.isExportEquals) { + // Elide `export=` as it is illegal in a SystemJS module. + return undefined; + } + var expression = ts.visitNode(node.expression, visitor, ts.isExpression); + var original = node.original; + if (original && hasAssociatedEndOfDeclarationMarker(original)) { + // Defer exports until we encounter an EndOfDeclarationMarker node + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportStatement(deferredExports[id], factory.createIdentifier("default"), expression, /*allowComments*/ true); + } + else { + return createExportStatement(factory.createIdentifier("default"), expression, /*allowComments*/ true); + } + } + /** + * Visits a FunctionDeclaration, hoisting it to the outer module body function. + * + * @param node The node to visit. + */ + function visitFunctionDeclaration(node) { + if (ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */)) { + hoistedStatements = ts.append(hoistedStatements, factory.updateFunctionDeclaration(node, ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifierLike), node.asteriskToken, factory.getDeclarationName(node, /*allowComments*/ true, /*allowSourceMaps*/ true), + /*typeParameters*/ undefined, ts.visitNodes(node.parameters, visitor, ts.isParameterDeclaration), + /*type*/ undefined, ts.visitNode(node.body, visitor, ts.isBlock))); + } + else { + hoistedStatements = ts.append(hoistedStatements, ts.visitEachChild(node, visitor, context)); + } + if (hasAssociatedEndOfDeclarationMarker(node)) { + // Defer exports until we encounter an EndOfDeclarationMarker node + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node); + } + else { + hoistedStatements = appendExportsOfHoistedDeclaration(hoistedStatements, node); + } + return undefined; + } + /** + * Visits a ClassDeclaration, hoisting its name to the outer module body function. + * + * @param node The node to visit. + */ + function visitClassDeclaration(node) { + var statements; + // Hoist the name of the class declaration to the outer module body function. + var name = factory.getLocalName(node); + hoistVariableDeclaration(name); + // Rewrite the class declaration into an assignment of a class expression. + statements = ts.append(statements, ts.setTextRange(factory.createExpressionStatement(factory.createAssignment(name, ts.setTextRange(factory.createClassExpression(ts.visitNodes(node.modifiers, modifierVisitor, ts.isModifierLike), node.name, + /*typeParameters*/ undefined, ts.visitNodes(node.heritageClauses, visitor, ts.isHeritageClause), ts.visitNodes(node.members, visitor, ts.isClassElement)), node))), node)); + if (hasAssociatedEndOfDeclarationMarker(node)) { + // Defer exports until we encounter an EndOfDeclarationMarker node + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportsOfHoistedDeclaration(deferredExports[id], node); + } + else { + statements = appendExportsOfHoistedDeclaration(statements, node); + } + return ts.singleOrMany(statements); + } + /** + * Visits a variable statement, hoisting declared names to the top-level module body. + * Each declaration is rewritten into an assignment expression. + * + * @param node The node to visit. + */ + function visitVariableStatement(node) { + if (!shouldHoistVariableDeclarationList(node.declarationList)) { + return ts.visitNode(node, visitor, ts.isStatement); + } + var expressions; + var isExportedDeclaration = ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */); + var isMarkedDeclaration = hasAssociatedEndOfDeclarationMarker(node); + for (var _i = 0, _a = node.declarationList.declarations; _i < _a.length; _i++) { + var variable = _a[_i]; + if (variable.initializer) { + expressions = ts.append(expressions, transformInitializedVariable(variable, isExportedDeclaration && !isMarkedDeclaration)); + } + else { + hoistBindingElement(variable); + } + } + var statements; + if (expressions) { + statements = ts.append(statements, ts.setTextRange(factory.createExpressionStatement(factory.inlineExpressions(expressions)), node)); + } + if (isMarkedDeclaration) { + // Defer exports until we encounter an EndOfDeclarationMarker node + var id = ts.getOriginalNodeId(node); + deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], node, isExportedDeclaration); + } + else { + statements = appendExportsOfVariableStatement(statements, node, /*exportSelf*/ false); + } + return ts.singleOrMany(statements); + } + /** + * Hoists the declared names of a VariableDeclaration or BindingElement. + * + * @param node The declaration to hoist. + */ + function hoistBindingElement(node) { + if (ts.isBindingPattern(node.name)) { + for (var _i = 0, _a = node.name.elements; _i < _a.length; _i++) { + var element = _a[_i]; + if (!ts.isOmittedExpression(element)) { + hoistBindingElement(element); + } + } + } + else { + hoistVariableDeclaration(factory.cloneNode(node.name)); + } + } + /** + * Determines whether a VariableDeclarationList should be hoisted. + * + * @param node The node to test. + */ + function shouldHoistVariableDeclarationList(node) { + // hoist only non-block scoped declarations or block scoped declarations parented by source file + return (ts.getEmitFlags(node) & 2097152 /* EmitFlags.NoHoisting */) === 0 + && (enclosingBlockScopedContainer.kind === 308 /* SyntaxKind.SourceFile */ + || (ts.getOriginalNode(node).flags & 3 /* NodeFlags.BlockScoped */) === 0); + } + /** + * Transform an initialized variable declaration into an expression. + * + * @param node The node to transform. + * @param isExportedDeclaration A value indicating whether the variable is exported. + */ + function transformInitializedVariable(node, isExportedDeclaration) { + var createAssignment = isExportedDeclaration ? createExportedVariableAssignment : createNonExportedVariableAssignment; + return ts.isBindingPattern(node.name) + ? ts.flattenDestructuringAssignment(node, visitor, context, 0 /* FlattenLevel.All */, + /*needsValue*/ false, createAssignment) + : node.initializer ? createAssignment(node.name, ts.visitNode(node.initializer, visitor, ts.isExpression)) : node.name; + } + /** + * Creates an assignment expression for an exported variable declaration. + * + * @param name The name of the variable. + * @param value The value of the variable's initializer. + * @param location The source map location for the assignment. + */ + function createExportedVariableAssignment(name, value, location) { + return createVariableAssignment(name, value, location, /*isExportedDeclaration*/ true); + } + /** + * Creates an assignment expression for a non-exported variable declaration. + * + * @param name The name of the variable. + * @param value The value of the variable's initializer. + * @param location The source map location for the assignment. + */ + function createNonExportedVariableAssignment(name, value, location) { + return createVariableAssignment(name, value, location, /*isExportedDeclaration*/ false); + } + /** + * Creates an assignment expression for a variable declaration. + * + * @param name The name of the variable. + * @param value The value of the variable's initializer. + * @param location The source map location for the assignment. + * @param isExportedDeclaration A value indicating whether the variable is exported. + */ + function createVariableAssignment(name, value, location, isExportedDeclaration) { + hoistVariableDeclaration(factory.cloneNode(name)); + return isExportedDeclaration + ? createExportExpression(name, preventSubstitution(ts.setTextRange(factory.createAssignment(name, value), location))) + : preventSubstitution(ts.setTextRange(factory.createAssignment(name, value), location)); + } + /** + * Visits a MergeDeclarationMarker used as a placeholder for the beginning of a merged + * and transformed declaration. + * + * @param node The node to visit. + */ + function visitMergeDeclarationMarker(node) { + // For an EnumDeclaration or ModuleDeclaration that merges with a preceeding + // declaration we do not emit a leading variable declaration. To preserve the + // begin/end semantics of the declararation and to properly handle exports + // we wrapped the leading variable declaration in a `MergeDeclarationMarker`. + // + // To balance the declaration, we defer the exports of the elided variable + // statement until we visit this declaration's `EndOfDeclarationMarker`. + if (hasAssociatedEndOfDeclarationMarker(node) && node.original.kind === 240 /* SyntaxKind.VariableStatement */) { + var id = ts.getOriginalNodeId(node); + var isExportedDeclaration = ts.hasSyntacticModifier(node.original, 1 /* ModifierFlags.Export */); + deferredExports[id] = appendExportsOfVariableStatement(deferredExports[id], node.original, isExportedDeclaration); + } + return node; + } + /** + * Determines whether a node has an associated EndOfDeclarationMarker. + * + * @param node The node to test. + */ + function hasAssociatedEndOfDeclarationMarker(node) { + return (ts.getEmitFlags(node) & 4194304 /* EmitFlags.HasEndOfDeclarationMarker */) !== 0; + } + /** + * Visits a DeclarationMarker used as a placeholder for the end of a transformed + * declaration. + * + * @param node The node to visit. + */ + function visitEndOfDeclarationMarker(node) { + // For some transformations we emit an `EndOfDeclarationMarker` to mark the actual + // end of the transformed declaration. We use this marker to emit any deferred exports + // of the declaration. + var id = ts.getOriginalNodeId(node); + var statements = deferredExports[id]; + if (statements) { + delete deferredExports[id]; + return ts.append(statements, node); + } + else { + var original = ts.getOriginalNode(node); + if (ts.isModuleOrEnumDeclaration(original)) { + return ts.append(appendExportsOfDeclaration(statements, original), node); + } + } + return node; + } + /** + * Appends the exports of an ImportDeclaration to a statement list, returning the + * statement list. + * + * @param statements A statement list to which the down-level export statements are to be + * appended. If `statements` is `undefined`, a new array is allocated if statements are + * appended. + * @param decl The declaration whose exports are to be recorded. + */ + function appendExportsOfImportDeclaration(statements, decl) { + if (moduleInfo.exportEquals) { + return statements; + } + var importClause = decl.importClause; + if (!importClause) { + return statements; + } + if (importClause.name) { + statements = appendExportsOfDeclaration(statements, importClause); + } + var namedBindings = importClause.namedBindings; + if (namedBindings) { + switch (namedBindings.kind) { + case 271 /* SyntaxKind.NamespaceImport */: + statements = appendExportsOfDeclaration(statements, namedBindings); + break; + case 272 /* SyntaxKind.NamedImports */: + for (var _i = 0, _a = namedBindings.elements; _i < _a.length; _i++) { + var importBinding = _a[_i]; + statements = appendExportsOfDeclaration(statements, importBinding); + } + break; + } + } + return statements; + } + /** + * Appends the export of an ImportEqualsDeclaration to a statement list, returning the + * statement list. + * + * @param statements A statement list to which the down-level export statements are to be + * appended. If `statements` is `undefined`, a new array is allocated if statements are + * appended. + * @param decl The declaration whose exports are to be recorded. + */ + function appendExportsOfImportEqualsDeclaration(statements, decl) { + if (moduleInfo.exportEquals) { + return statements; + } + return appendExportsOfDeclaration(statements, decl); + } + /** + * Appends the exports of a VariableStatement to a statement list, returning the statement + * list. + * + * @param statements A statement list to which the down-level export statements are to be + * appended. If `statements` is `undefined`, a new array is allocated if statements are + * appended. + * @param node The VariableStatement whose exports are to be recorded. + * @param exportSelf A value indicating whether to also export each VariableDeclaration of + * `nodes` declaration list. + */ + function appendExportsOfVariableStatement(statements, node, exportSelf) { + if (moduleInfo.exportEquals) { + return statements; + } + for (var _i = 0, _a = node.declarationList.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + if (decl.initializer || exportSelf) { + statements = appendExportsOfBindingElement(statements, decl, exportSelf); + } + } + return statements; + } + /** + * Appends the exports of a VariableDeclaration or BindingElement to a statement list, + * returning the statement list. + * + * @param statements A statement list to which the down-level export statements are to be + * appended. If `statements` is `undefined`, a new array is allocated if statements are + * appended. + * @param decl The declaration whose exports are to be recorded. + * @param exportSelf A value indicating whether to also export the declaration itself. + */ + function appendExportsOfBindingElement(statements, decl, exportSelf) { + if (moduleInfo.exportEquals) { + return statements; + } + if (ts.isBindingPattern(decl.name)) { + for (var _i = 0, _a = decl.name.elements; _i < _a.length; _i++) { + var element = _a[_i]; + if (!ts.isOmittedExpression(element)) { + statements = appendExportsOfBindingElement(statements, element, exportSelf); + } + } + } + else if (!ts.isGeneratedIdentifier(decl.name)) { + var excludeName = void 0; + if (exportSelf) { + statements = appendExportStatement(statements, decl.name, factory.getLocalName(decl)); + excludeName = ts.idText(decl.name); + } + statements = appendExportsOfDeclaration(statements, decl, excludeName); + } + return statements; + } + /** + * Appends the exports of a ClassDeclaration or FunctionDeclaration to a statement list, + * returning the statement list. + * + * @param statements A statement list to which the down-level export statements are to be + * appended. If `statements` is `undefined`, a new array is allocated if statements are + * appended. + * @param decl The declaration whose exports are to be recorded. + */ + function appendExportsOfHoistedDeclaration(statements, decl) { + if (moduleInfo.exportEquals) { + return statements; + } + var excludeName; + if (ts.hasSyntacticModifier(decl, 1 /* ModifierFlags.Export */)) { + var exportName = ts.hasSyntacticModifier(decl, 1024 /* ModifierFlags.Default */) ? factory.createStringLiteral("default") : decl.name; + statements = appendExportStatement(statements, exportName, factory.getLocalName(decl)); + excludeName = ts.getTextOfIdentifierOrLiteral(exportName); + } + if (decl.name) { + statements = appendExportsOfDeclaration(statements, decl, excludeName); + } + return statements; + } + /** + * Appends the exports of a declaration to a statement list, returning the statement list. + * + * @param statements A statement list to which the down-level export statements are to be + * appended. If `statements` is `undefined`, a new array is allocated if statements are + * appended. + * @param decl The declaration to export. + * @param excludeName An optional name to exclude from exports. + */ + function appendExportsOfDeclaration(statements, decl, excludeName) { + if (moduleInfo.exportEquals) { + return statements; + } + var name = factory.getDeclarationName(decl); + var exportSpecifiers = moduleInfo.exportSpecifiers.get(ts.idText(name)); + if (exportSpecifiers) { + for (var _i = 0, exportSpecifiers_2 = exportSpecifiers; _i < exportSpecifiers_2.length; _i++) { + var exportSpecifier = exportSpecifiers_2[_i]; + if (exportSpecifier.name.escapedText !== excludeName) { + statements = appendExportStatement(statements, exportSpecifier.name, name); + } + } + } + return statements; + } + /** + * Appends the down-level representation of an export to a statement list, returning the + * statement list. + * + * @param statements A statement list to which the down-level export statements are to be + * appended. If `statements` is `undefined`, a new array is allocated if statements are + * appended. + * @param exportName The name of the export. + * @param expression The expression to export. + * @param allowComments Whether to allow comments on the export. + */ + function appendExportStatement(statements, exportName, expression, allowComments) { + statements = ts.append(statements, createExportStatement(exportName, expression, allowComments)); + return statements; + } + /** + * Creates a call to the current file's export function to export a value. + * + * @param name The bound name of the export. + * @param value The exported value. + * @param allowComments An optional value indicating whether to emit comments for the statement. + */ + function createExportStatement(name, value, allowComments) { + var statement = factory.createExpressionStatement(createExportExpression(name, value)); + ts.startOnNewLine(statement); + if (!allowComments) { + ts.setEmitFlags(statement, 1536 /* EmitFlags.NoComments */); + } + return statement; + } + /** + * Creates a call to the current file's export function to export a value. + * + * @param name The bound name of the export. + * @param value The exported value. + */ + function createExportExpression(name, value) { + var exportName = ts.isIdentifier(name) ? factory.createStringLiteralFromNode(name) : name; + ts.setEmitFlags(value, ts.getEmitFlags(value) | 1536 /* EmitFlags.NoComments */); + return ts.setCommentRange(factory.createCallExpression(exportFunction, /*typeArguments*/ undefined, [exportName, value]), value); + } + // + // Top-Level or Nested Source Element Visitors + // + /** + * Visit nested elements at the top-level of a module. + * + * @param node The node to visit. + */ + function topLevelNestedVisitor(node) { + switch (node.kind) { + case 240 /* SyntaxKind.VariableStatement */: + return visitVariableStatement(node); + case 259 /* SyntaxKind.FunctionDeclaration */: + return visitFunctionDeclaration(node); + case 260 /* SyntaxKind.ClassDeclaration */: + return visitClassDeclaration(node); + case 245 /* SyntaxKind.ForStatement */: + return visitForStatement(node, /*isTopLevel*/ true); + case 246 /* SyntaxKind.ForInStatement */: + return visitForInStatement(node); + case 247 /* SyntaxKind.ForOfStatement */: + return visitForOfStatement(node); + case 243 /* SyntaxKind.DoStatement */: + return visitDoStatement(node); + case 244 /* SyntaxKind.WhileStatement */: + return visitWhileStatement(node); + case 253 /* SyntaxKind.LabeledStatement */: + return visitLabeledStatement(node); + case 251 /* SyntaxKind.WithStatement */: + return visitWithStatement(node); + case 252 /* SyntaxKind.SwitchStatement */: + return visitSwitchStatement(node); + case 266 /* SyntaxKind.CaseBlock */: + return visitCaseBlock(node); + case 292 /* SyntaxKind.CaseClause */: + return visitCaseClause(node); + case 293 /* SyntaxKind.DefaultClause */: + return visitDefaultClause(node); + case 255 /* SyntaxKind.TryStatement */: + return visitTryStatement(node); + case 295 /* SyntaxKind.CatchClause */: + return visitCatchClause(node); + case 238 /* SyntaxKind.Block */: + return visitBlock(node); + case 355 /* SyntaxKind.MergeDeclarationMarker */: + return visitMergeDeclarationMarker(node); + case 356 /* SyntaxKind.EndOfDeclarationMarker */: + return visitEndOfDeclarationMarker(node); + default: + return visitor(node); + } + } + /** + * Visits the body of a ForStatement to hoist declarations. + * + * @param node The node to visit. + */ + function visitForStatement(node, isTopLevel) { + var savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer; + enclosingBlockScopedContainer = node; + node = factory.updateForStatement(node, ts.visitNode(node.initializer, isTopLevel ? visitForInitializer : discardedValueVisitor, ts.isForInitializer), ts.visitNode(node.condition, visitor, ts.isExpression), ts.visitNode(node.incrementor, discardedValueVisitor, ts.isExpression), ts.visitIterationBody(node.statement, isTopLevel ? topLevelNestedVisitor : visitor, context)); + enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer; + return node; + } + /** + * Visits the body of a ForInStatement to hoist declarations. + * + * @param node The node to visit. + */ + function visitForInStatement(node) { + var savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer; + enclosingBlockScopedContainer = node; + node = factory.updateForInStatement(node, visitForInitializer(node.initializer), ts.visitNode(node.expression, visitor, ts.isExpression), ts.visitIterationBody(node.statement, topLevelNestedVisitor, context)); + enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer; + return node; + } + /** + * Visits the body of a ForOfStatement to hoist declarations. + * + * @param node The node to visit. + */ + function visitForOfStatement(node) { + var savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer; + enclosingBlockScopedContainer = node; + node = factory.updateForOfStatement(node, node.awaitModifier, visitForInitializer(node.initializer), ts.visitNode(node.expression, visitor, ts.isExpression), ts.visitIterationBody(node.statement, topLevelNestedVisitor, context)); + enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer; + return node; + } + /** + * Determines whether to hoist the initializer of a ForStatement, ForInStatement, or + * ForOfStatement. + * + * @param node The node to test. + */ + function shouldHoistForInitializer(node) { + return ts.isVariableDeclarationList(node) + && shouldHoistVariableDeclarationList(node); + } + /** + * Visits the initializer of a ForStatement, ForInStatement, or ForOfStatement + * + * @param node The node to visit. + */ + function visitForInitializer(node) { + if (shouldHoistForInitializer(node)) { + var expressions = void 0; + for (var _i = 0, _a = node.declarations; _i < _a.length; _i++) { + var variable = _a[_i]; + expressions = ts.append(expressions, transformInitializedVariable(variable, /*isExportedDeclaration*/ false)); + if (!variable.initializer) { + hoistBindingElement(variable); + } + } + return expressions ? factory.inlineExpressions(expressions) : factory.createOmittedExpression(); + } + else { + return ts.visitNode(node, discardedValueVisitor, ts.isExpression); + } + } + /** + * Visits the body of a DoStatement to hoist declarations. + * + * @param node The node to visit. + */ + function visitDoStatement(node) { + return factory.updateDoStatement(node, ts.visitIterationBody(node.statement, topLevelNestedVisitor, context), ts.visitNode(node.expression, visitor, ts.isExpression)); + } + /** + * Visits the body of a WhileStatement to hoist declarations. + * + * @param node The node to visit. + */ + function visitWhileStatement(node) { + return factory.updateWhileStatement(node, ts.visitNode(node.expression, visitor, ts.isExpression), ts.visitIterationBody(node.statement, topLevelNestedVisitor, context)); + } + /** + * Visits the body of a LabeledStatement to hoist declarations. + * + * @param node The node to visit. + */ + function visitLabeledStatement(node) { + return factory.updateLabeledStatement(node, node.label, ts.visitNode(node.statement, topLevelNestedVisitor, ts.isStatement, factory.liftToBlock)); + } + /** + * Visits the body of a WithStatement to hoist declarations. + * + * @param node The node to visit. + */ + function visitWithStatement(node) { + return factory.updateWithStatement(node, ts.visitNode(node.expression, visitor, ts.isExpression), ts.visitNode(node.statement, topLevelNestedVisitor, ts.isStatement, factory.liftToBlock)); + } + /** + * Visits the body of a SwitchStatement to hoist declarations. + * + * @param node The node to visit. + */ + function visitSwitchStatement(node) { + return factory.updateSwitchStatement(node, ts.visitNode(node.expression, visitor, ts.isExpression), ts.visitNode(node.caseBlock, topLevelNestedVisitor, ts.isCaseBlock)); + } + /** + * Visits the body of a CaseBlock to hoist declarations. + * + * @param node The node to visit. + */ + function visitCaseBlock(node) { + var savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer; + enclosingBlockScopedContainer = node; + node = factory.updateCaseBlock(node, ts.visitNodes(node.clauses, topLevelNestedVisitor, ts.isCaseOrDefaultClause)); + enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer; + return node; + } + /** + * Visits the body of a CaseClause to hoist declarations. + * + * @param node The node to visit. + */ + function visitCaseClause(node) { + return factory.updateCaseClause(node, ts.visitNode(node.expression, visitor, ts.isExpression), ts.visitNodes(node.statements, topLevelNestedVisitor, ts.isStatement)); + } + /** + * Visits the body of a DefaultClause to hoist declarations. + * + * @param node The node to visit. + */ + function visitDefaultClause(node) { + return ts.visitEachChild(node, topLevelNestedVisitor, context); + } + /** + * Visits the body of a TryStatement to hoist declarations. + * + * @param node The node to visit. + */ + function visitTryStatement(node) { + return ts.visitEachChild(node, topLevelNestedVisitor, context); + } + /** + * Visits the body of a CatchClause to hoist declarations. + * + * @param node The node to visit. + */ + function visitCatchClause(node) { + var savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer; + enclosingBlockScopedContainer = node; + node = factory.updateCatchClause(node, node.variableDeclaration, ts.visitNode(node.block, topLevelNestedVisitor, ts.isBlock)); + enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer; + return node; + } + /** + * Visits the body of a Block to hoist declarations. + * + * @param node The node to visit. + */ + function visitBlock(node) { + var savedEnclosingBlockScopedContainer = enclosingBlockScopedContainer; + enclosingBlockScopedContainer = node; + node = ts.visitEachChild(node, topLevelNestedVisitor, context); + enclosingBlockScopedContainer = savedEnclosingBlockScopedContainer; + return node; + } + // + // Destructuring Assignment Visitors + // + /** + * Visit nodes to flatten destructuring assignments to exported symbols. + * + * @param node The node to visit. + */ + function visitorWorker(node, valueIsDiscarded) { + if (!(node.transformFlags & (4096 /* TransformFlags.ContainsDestructuringAssignment */ | 8388608 /* TransformFlags.ContainsDynamicImport */ | 268435456 /* TransformFlags.ContainsUpdateExpressionForIdentifier */))) { + return node; + } + switch (node.kind) { + case 245 /* SyntaxKind.ForStatement */: + return visitForStatement(node, /*isTopLevel*/ false); + case 241 /* SyntaxKind.ExpressionStatement */: + return visitExpressionStatement(node); + case 214 /* SyntaxKind.ParenthesizedExpression */: + return visitParenthesizedExpression(node, valueIsDiscarded); + case 353 /* SyntaxKind.PartiallyEmittedExpression */: + return visitPartiallyEmittedExpression(node, valueIsDiscarded); + case 223 /* SyntaxKind.BinaryExpression */: + if (ts.isDestructuringAssignment(node)) { + return visitDestructuringAssignment(node, valueIsDiscarded); + } + break; + case 210 /* SyntaxKind.CallExpression */: + if (ts.isImportCall(node)) { + return visitImportCallExpression(node); + } + break; + case 221 /* SyntaxKind.PrefixUnaryExpression */: + case 222 /* SyntaxKind.PostfixUnaryExpression */: + return visitPrefixOrPostfixUnaryExpression(node, valueIsDiscarded); + } + return ts.visitEachChild(node, visitor, context); + } + /** + * Visit nodes to flatten destructuring assignments to exported symbols. + * + * @param node The node to visit. + */ + function visitor(node) { + return visitorWorker(node, /*valueIsDiscarded*/ false); + } + function discardedValueVisitor(node) { + return visitorWorker(node, /*valueIsDiscarded*/ true); + } + function visitExpressionStatement(node) { + return factory.updateExpressionStatement(node, ts.visitNode(node.expression, discardedValueVisitor, ts.isExpression)); + } + function visitParenthesizedExpression(node, valueIsDiscarded) { + return factory.updateParenthesizedExpression(node, ts.visitNode(node.expression, valueIsDiscarded ? discardedValueVisitor : visitor, ts.isExpression)); + } + function visitPartiallyEmittedExpression(node, valueIsDiscarded) { + return factory.updatePartiallyEmittedExpression(node, ts.visitNode(node.expression, valueIsDiscarded ? discardedValueVisitor : visitor, ts.isExpression)); + } + function visitImportCallExpression(node) { + // import("./blah") + // emit as + // System.register([], function (_export, _context) { + // return { + // setters: [], + // execute: () => { + // _context.import('./blah'); + // } + // }; + // }); + var externalModuleName = ts.getExternalModuleNameLiteral(factory, node, currentSourceFile, host, resolver, compilerOptions); + var firstArgument = ts.visitNode(ts.firstOrUndefined(node.arguments), visitor); + // Only use the external module name if it differs from the first argument. This allows us to preserve the quote style of the argument on output. + var argument = externalModuleName && (!firstArgument || !ts.isStringLiteral(firstArgument) || firstArgument.text !== externalModuleName.text) ? externalModuleName : firstArgument; + return factory.createCallExpression(factory.createPropertyAccessExpression(contextObject, factory.createIdentifier("import")), + /*typeArguments*/ undefined, argument ? [argument] : []); + } + /** + * Visits a DestructuringAssignment to flatten destructuring to exported symbols. + * + * @param node The node to visit. + */ + function visitDestructuringAssignment(node, valueIsDiscarded) { + if (hasExportedReferenceInDestructuringTarget(node.left)) { + return ts.flattenDestructuringAssignment(node, visitor, context, 0 /* FlattenLevel.All */, !valueIsDiscarded); + } + return ts.visitEachChild(node, visitor, context); + } + /** + * Determines whether the target of a destructuring assignment refers to an exported symbol. + * + * @param node The destructuring target. + */ + function hasExportedReferenceInDestructuringTarget(node) { + if (ts.isAssignmentExpression(node, /*excludeCompoundAssignment*/ true)) { + return hasExportedReferenceInDestructuringTarget(node.left); + } + else if (ts.isSpreadElement(node)) { + return hasExportedReferenceInDestructuringTarget(node.expression); + } + else if (ts.isObjectLiteralExpression(node)) { + return ts.some(node.properties, hasExportedReferenceInDestructuringTarget); + } + else if (ts.isArrayLiteralExpression(node)) { + return ts.some(node.elements, hasExportedReferenceInDestructuringTarget); + } + else if (ts.isShorthandPropertyAssignment(node)) { + return hasExportedReferenceInDestructuringTarget(node.name); + } + else if (ts.isPropertyAssignment(node)) { + return hasExportedReferenceInDestructuringTarget(node.initializer); + } + else if (ts.isIdentifier(node)) { + var container = resolver.getReferencedExportContainer(node); + return container !== undefined && container.kind === 308 /* SyntaxKind.SourceFile */; + } + else { + return false; + } + } + function visitPrefixOrPostfixUnaryExpression(node, valueIsDiscarded) { + // When we see a prefix or postfix increment expression whose operand is an exported + // symbol, we should ensure all exports of that symbol are updated with the correct + // value. + // + // - We do not transform generated identifiers for any reason. + // - We do not transform identifiers tagged with the LocalName flag. + // - We do not transform identifiers that were originally the name of an enum or + // namespace due to how they are transformed in TypeScript. + // - We only transform identifiers that are exported at the top level. + if ((node.operator === 45 /* SyntaxKind.PlusPlusToken */ || node.operator === 46 /* SyntaxKind.MinusMinusToken */) + && ts.isIdentifier(node.operand) + && !ts.isGeneratedIdentifier(node.operand) + && !ts.isLocalName(node.operand) + && !ts.isDeclarationNameOfEnumOrNamespace(node.operand)) { + var exportedNames = getExports(node.operand); + if (exportedNames) { + var temp = void 0; + var expression = ts.visitNode(node.operand, visitor, ts.isExpression); + if (ts.isPrefixUnaryExpression(node)) { + expression = factory.updatePrefixUnaryExpression(node, expression); + } + else { + expression = factory.updatePostfixUnaryExpression(node, expression); + if (!valueIsDiscarded) { + temp = factory.createTempVariable(hoistVariableDeclaration); + expression = factory.createAssignment(temp, expression); + ts.setTextRange(expression, node); + } + expression = factory.createComma(expression, factory.cloneNode(node.operand)); + ts.setTextRange(expression, node); + } + for (var _i = 0, exportedNames_4 = exportedNames; _i < exportedNames_4.length; _i++) { + var exportName = exportedNames_4[_i]; + expression = createExportExpression(exportName, preventSubstitution(expression)); + } + if (temp) { + expression = factory.createComma(expression, temp); + ts.setTextRange(expression, node); + } + return expression; + } + } + return ts.visitEachChild(node, visitor, context); + } + // + // Modifier Visitors + // + /** + * Visit nodes to elide module-specific modifiers. + * + * @param node The node to visit. + */ + function modifierVisitor(node) { + switch (node.kind) { + case 93 /* SyntaxKind.ExportKeyword */: + case 88 /* SyntaxKind.DefaultKeyword */: + return undefined; + } + return node; + } + // + // Emit Notification + // + /** + * Hook for node emit notifications. + * + * @param hint A hint as to the intended usage of the node. + * @param node The node to emit. + * @param emitCallback A callback used to emit the node in the printer. + */ + function onEmitNode(hint, node, emitCallback) { + if (node.kind === 308 /* SyntaxKind.SourceFile */) { + var id = ts.getOriginalNodeId(node); + currentSourceFile = node; + moduleInfo = moduleInfoMap[id]; + exportFunction = exportFunctionsMap[id]; + noSubstitution = noSubstitutionMap[id]; + contextObject = contextObjectMap[id]; + if (noSubstitution) { + delete noSubstitutionMap[id]; + } + previousOnEmitNode(hint, node, emitCallback); + currentSourceFile = undefined; + moduleInfo = undefined; + exportFunction = undefined; + contextObject = undefined; + noSubstitution = undefined; + } + else { + previousOnEmitNode(hint, node, emitCallback); + } + } + // + // Substitutions + // + /** + * Hooks node substitutions. + * + * @param hint A hint as to the intended usage of the node. + * @param node The node to substitute. + */ + function onSubstituteNode(hint, node) { + node = previousOnSubstituteNode(hint, node); + if (isSubstitutionPrevented(node)) { + return node; + } + if (hint === 1 /* EmitHint.Expression */) { + return substituteExpression(node); + } + else if (hint === 4 /* EmitHint.Unspecified */) { + return substituteUnspecified(node); + } + return node; + } + /** + * Substitute the node, if necessary. + * + * @param node The node to substitute. + */ + function substituteUnspecified(node) { + switch (node.kind) { + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + return substituteShorthandPropertyAssignment(node); + } + return node; + } + /** + * Substitution for a ShorthandPropertyAssignment whose name that may contain an imported or exported symbol. + * + * @param node The node to substitute. + */ + function substituteShorthandPropertyAssignment(node) { + var _a, _b; + var name = node.name; + if (!ts.isGeneratedIdentifier(name) && !ts.isLocalName(name)) { + var importDeclaration = resolver.getReferencedImportDeclaration(name); + if (importDeclaration) { + if (ts.isImportClause(importDeclaration)) { + return ts.setTextRange(factory.createPropertyAssignment(factory.cloneNode(name), factory.createPropertyAccessExpression(factory.getGeneratedNameForNode(importDeclaration.parent), factory.createIdentifier("default"))), + /*location*/ node); + } + else if (ts.isImportSpecifier(importDeclaration)) { + return ts.setTextRange(factory.createPropertyAssignment(factory.cloneNode(name), factory.createPropertyAccessExpression(factory.getGeneratedNameForNode(((_b = (_a = importDeclaration.parent) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.parent) || importDeclaration), factory.cloneNode(importDeclaration.propertyName || importDeclaration.name))), + /*location*/ node); + } + } + } + return node; + } + /** + * Substitute the expression, if necessary. + * + * @param node The node to substitute. + */ + function substituteExpression(node) { + switch (node.kind) { + case 79 /* SyntaxKind.Identifier */: + return substituteExpressionIdentifier(node); + case 223 /* SyntaxKind.BinaryExpression */: + return substituteBinaryExpression(node); + case 233 /* SyntaxKind.MetaProperty */: + return substituteMetaProperty(node); + } + return node; + } + /** + * Substitution for an Identifier expression that may contain an imported or exported symbol. + * + * @param node The node to substitute. + */ + function substituteExpressionIdentifier(node) { + var _a, _b; + if (ts.getEmitFlags(node) & 4096 /* EmitFlags.HelperName */) { + var externalHelpersModuleName = ts.getExternalHelpersModuleName(currentSourceFile); + if (externalHelpersModuleName) { + return factory.createPropertyAccessExpression(externalHelpersModuleName, node); + } + return node; + } + // When we see an identifier in an expression position that + // points to an imported symbol, we should substitute a qualified + // reference to the imported symbol if one is needed. + // + // - We do not substitute generated identifiers for any reason. + // - We do not substitute identifiers tagged with the LocalName flag. + if (!ts.isGeneratedIdentifier(node) && !ts.isLocalName(node)) { + var importDeclaration = resolver.getReferencedImportDeclaration(node); + if (importDeclaration) { + if (ts.isImportClause(importDeclaration)) { + return ts.setTextRange(factory.createPropertyAccessExpression(factory.getGeneratedNameForNode(importDeclaration.parent), factory.createIdentifier("default")), + /*location*/ node); + } + else if (ts.isImportSpecifier(importDeclaration)) { + return ts.setTextRange(factory.createPropertyAccessExpression(factory.getGeneratedNameForNode(((_b = (_a = importDeclaration.parent) === null || _a === void 0 ? void 0 : _a.parent) === null || _b === void 0 ? void 0 : _b.parent) || importDeclaration), factory.cloneNode(importDeclaration.propertyName || importDeclaration.name)), + /*location*/ node); + } + } + } + return node; + } + /** + * Substitution for a BinaryExpression that may contain an imported or exported symbol. + * + * @param node The node to substitute. + */ + function substituteBinaryExpression(node) { + // When we see an assignment expression whose left-hand side is an exported symbol, + // we should ensure all exports of that symbol are updated with the correct value. + // + // - We do not substitute generated identifiers for any reason. + // - We do not substitute identifiers tagged with the LocalName flag. + // - We do not substitute identifiers that were originally the name of an enum or + // namespace due to how they are transformed in TypeScript. + // - We only substitute identifiers that are exported at the top level. + if (ts.isAssignmentOperator(node.operatorToken.kind) + && ts.isIdentifier(node.left) + && !ts.isGeneratedIdentifier(node.left) + && !ts.isLocalName(node.left) + && !ts.isDeclarationNameOfEnumOrNamespace(node.left)) { + var exportedNames = getExports(node.left); + if (exportedNames) { + // For each additional export of the declaration, apply an export assignment. + var expression = node; + for (var _i = 0, exportedNames_5 = exportedNames; _i < exportedNames_5.length; _i++) { + var exportName = exportedNames_5[_i]; + expression = createExportExpression(exportName, preventSubstitution(expression)); + } + return expression; + } + } + return node; + } + function substituteMetaProperty(node) { + if (ts.isImportMeta(node)) { + return factory.createPropertyAccessExpression(contextObject, factory.createIdentifier("meta")); + } + return node; + } + /** + * Gets the exports of a name. + * + * @param name The name. + */ + function getExports(name) { + var exportedNames; + if (!ts.isGeneratedIdentifier(name)) { + var valueDeclaration = resolver.getReferencedImportDeclaration(name) + || resolver.getReferencedValueDeclaration(name); + if (valueDeclaration) { + var exportContainer = resolver.getReferencedExportContainer(name, /*prefixLocals*/ false); + if (exportContainer && exportContainer.kind === 308 /* SyntaxKind.SourceFile */) { + exportedNames = ts.append(exportedNames, factory.getDeclarationName(valueDeclaration)); + } + exportedNames = ts.addRange(exportedNames, moduleInfo && moduleInfo.exportedBindings[ts.getOriginalNodeId(valueDeclaration)]); + } + } + return exportedNames; + } + /** + * Prevent substitution of a node for this transformer. + * + * @param node The node which should not be substituted. + */ + function preventSubstitution(node) { + if (noSubstitution === undefined) + noSubstitution = []; + noSubstitution[ts.getNodeId(node)] = true; + return node; + } + /** + * Determines whether a node should not be substituted. + * + * @param node The node to test. + */ + function isSubstitutionPrevented(node) { + return noSubstitution && node.id && noSubstitution[node.id]; + } + } + ts.transformSystemModule = transformSystemModule; +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + function transformECMAScriptModule(context) { + var factory = context.factory, emitHelpers = context.getEmitHelperFactory; + var host = context.getEmitHost(); + var resolver = context.getEmitResolver(); + var compilerOptions = context.getCompilerOptions(); + var languageVersion = ts.getEmitScriptTarget(compilerOptions); + var previousOnEmitNode = context.onEmitNode; + var previousOnSubstituteNode = context.onSubstituteNode; + context.onEmitNode = onEmitNode; + context.onSubstituteNode = onSubstituteNode; + context.enableEmitNotification(308 /* SyntaxKind.SourceFile */); + context.enableSubstitution(79 /* SyntaxKind.Identifier */); + var helperNameSubstitutions; + var currentSourceFile; + var importRequireStatements; + return ts.chainBundle(context, transformSourceFile); + function transformSourceFile(node) { + if (node.isDeclarationFile) { + return node; + } + if (ts.isExternalModule(node) || compilerOptions.isolatedModules) { + currentSourceFile = node; + importRequireStatements = undefined; + var result = updateExternalModule(node); + currentSourceFile = undefined; + if (importRequireStatements) { + result = factory.updateSourceFile(result, ts.setTextRange(factory.createNodeArray(ts.insertStatementsAfterCustomPrologue(result.statements.slice(), importRequireStatements)), result.statements)); + } + if (!ts.isExternalModule(node) || ts.some(result.statements, ts.isExternalModuleIndicator)) { + return result; + } + return factory.updateSourceFile(result, ts.setTextRange(factory.createNodeArray(__spreadArray(__spreadArray([], result.statements, true), [ts.createEmptyExports(factory)], false)), result.statements)); + } + return node; + } + function updateExternalModule(node) { + var externalHelpersImportDeclaration = ts.createExternalHelpersImportDeclarationIfNeeded(factory, emitHelpers(), node, compilerOptions); + if (externalHelpersImportDeclaration) { + var statements = []; + var statementOffset = factory.copyPrologue(node.statements, statements); + ts.append(statements, externalHelpersImportDeclaration); + ts.addRange(statements, ts.visitNodes(node.statements, visitor, ts.isStatement, statementOffset)); + return factory.updateSourceFile(node, ts.setTextRange(factory.createNodeArray(statements), node.statements)); + } + else { + return ts.visitEachChild(node, visitor, context); + } + } + function visitor(node) { + switch (node.kind) { + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + // Though an error in es2020 modules, in node-flavor es2020 modules, we can helpfully transform this to a synthetic `require` call + // To give easy access to a synchronous `require` in node-flavor esm. We do the transform even in scenarios where we error, but `import.meta.url` + // is available, just because the output is reasonable for a node-like runtime. + return ts.getEmitModuleKind(compilerOptions) >= ts.ModuleKind.Node16 ? visitImportEqualsDeclaration(node) : undefined; + case 274 /* SyntaxKind.ExportAssignment */: + return visitExportAssignment(node); + case 275 /* SyntaxKind.ExportDeclaration */: + var exportDecl = node; + return visitExportDeclaration(exportDecl); + } + return node; + } + /** + * Creates a `require()` call to import an external module. + * + * @param importNode The declaration to import. + */ + function createRequireCall(importNode) { + var moduleName = ts.getExternalModuleNameLiteral(factory, importNode, ts.Debug.checkDefined(currentSourceFile), host, resolver, compilerOptions); + var args = []; + if (moduleName) { + args.push(moduleName); + } + if (!importRequireStatements) { + var createRequireName = factory.createUniqueName("_createRequire", 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */); + var importStatement = factory.createImportDeclaration( + /*modifiers*/ undefined, factory.createImportClause( + /*isTypeOnly*/ false, + /*name*/ undefined, factory.createNamedImports([ + factory.createImportSpecifier(/*isTypeOnly*/ false, factory.createIdentifier("createRequire"), createRequireName) + ])), factory.createStringLiteral("module")); + var requireHelperName = factory.createUniqueName("__require", 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */); + var requireStatement = factory.createVariableStatement( + /*modifiers*/ undefined, factory.createVariableDeclarationList([ + factory.createVariableDeclaration(requireHelperName, + /*exclamationToken*/ undefined, + /*type*/ undefined, factory.createCallExpression(factory.cloneNode(createRequireName), /*typeArguments*/ undefined, [ + factory.createPropertyAccessExpression(factory.createMetaProperty(100 /* SyntaxKind.ImportKeyword */, factory.createIdentifier("meta")), factory.createIdentifier("url")) + ])) + ], + /*flags*/ languageVersion >= 2 /* ScriptTarget.ES2015 */ ? 2 /* NodeFlags.Const */ : 0 /* NodeFlags.None */)); + importRequireStatements = [importStatement, requireStatement]; + } + var name = importRequireStatements[1].declarationList.declarations[0].name; + ts.Debug.assertNode(name, ts.isIdentifier); + return factory.createCallExpression(factory.cloneNode(name), /*typeArguments*/ undefined, args); + } + /** + * Visits an ImportEqualsDeclaration node. + * + * @param node The node to visit. + */ + function visitImportEqualsDeclaration(node) { + ts.Debug.assert(ts.isExternalModuleImportEqualsDeclaration(node), "import= for internal module references should be handled in an earlier transformer."); + var statements; + statements = ts.append(statements, ts.setOriginalNode(ts.setTextRange(factory.createVariableStatement( + /*modifiers*/ undefined, factory.createVariableDeclarationList([ + factory.createVariableDeclaration(factory.cloneNode(node.name), + /*exclamationToken*/ undefined, + /*type*/ undefined, createRequireCall(node)) + ], + /*flags*/ languageVersion >= 2 /* ScriptTarget.ES2015 */ ? 2 /* NodeFlags.Const */ : 0 /* NodeFlags.None */)), node), node)); + statements = appendExportsOfImportEqualsDeclaration(statements, node); + return ts.singleOrMany(statements); + } + function appendExportsOfImportEqualsDeclaration(statements, node) { + if (ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */)) { + statements = ts.append(statements, factory.createExportDeclaration( + /*modifiers*/ undefined, node.isTypeOnly, factory.createNamedExports([factory.createExportSpecifier(/*isTypeOnly*/ false, /*propertyName*/ undefined, ts.idText(node.name))]))); + } + return statements; + } + function visitExportAssignment(node) { + // Elide `export=` as it is not legal with --module ES6 + return node.isExportEquals ? undefined : node; + } + function visitExportDeclaration(node) { + // `export * as ns` only needs to be transformed in ES2015 + if (compilerOptions.module !== undefined && compilerOptions.module > ts.ModuleKind.ES2015) { + return node; + } + // Either ill-formed or don't need to be tranformed. + if (!node.exportClause || !ts.isNamespaceExport(node.exportClause) || !node.moduleSpecifier) { + return node; + } + var oldIdentifier = node.exportClause.name; + var synthName = factory.getGeneratedNameForNode(oldIdentifier); + var importDecl = factory.createImportDeclaration( + /*modifiers*/ undefined, factory.createImportClause( + /*isTypeOnly*/ false, + /*name*/ undefined, factory.createNamespaceImport(synthName)), node.moduleSpecifier, node.assertClause); + ts.setOriginalNode(importDecl, node.exportClause); + var exportDecl = ts.isExportNamespaceAsDefaultDeclaration(node) ? factory.createExportDefault(synthName) : factory.createExportDeclaration( + /*modifiers*/ undefined, + /*isTypeOnly*/ false, factory.createNamedExports([factory.createExportSpecifier(/*isTypeOnly*/ false, synthName, oldIdentifier)])); + ts.setOriginalNode(exportDecl, node); + return [importDecl, exportDecl]; + } + // + // Emit Notification + // + /** + * Hook for node emit. + * + * @param hint A hint as to the intended usage of the node. + * @param node The node to emit. + * @param emit A callback used to emit the node in the printer. + */ + function onEmitNode(hint, node, emitCallback) { + if (ts.isSourceFile(node)) { + if ((ts.isExternalModule(node) || compilerOptions.isolatedModules) && compilerOptions.importHelpers) { + helperNameSubstitutions = new ts.Map(); + } + previousOnEmitNode(hint, node, emitCallback); + helperNameSubstitutions = undefined; + } + else { + previousOnEmitNode(hint, node, emitCallback); + } + } + // + // Substitutions + // + /** + * Hooks node substitutions. + * + * @param hint A hint as to the intended usage of the node. + * @param node The node to substitute. + */ + function onSubstituteNode(hint, node) { + node = previousOnSubstituteNode(hint, node); + if (helperNameSubstitutions && ts.isIdentifier(node) && ts.getEmitFlags(node) & 4096 /* EmitFlags.HelperName */) { + return substituteHelperName(node); + } + return node; + } + function substituteHelperName(node) { + var name = ts.idText(node); + var substitution = helperNameSubstitutions.get(name); + if (!substitution) { + helperNameSubstitutions.set(name, substitution = factory.createUniqueName(name, 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */)); + } + return substitution; + } + } + ts.transformECMAScriptModule = transformECMAScriptModule; +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + function transformNodeModule(context) { + var previousOnSubstituteNode = context.onSubstituteNode; + var previousOnEmitNode = context.onEmitNode; + var esmTransform = ts.transformECMAScriptModule(context); + var esmOnSubstituteNode = context.onSubstituteNode; + var esmOnEmitNode = context.onEmitNode; + context.onSubstituteNode = previousOnSubstituteNode; + context.onEmitNode = previousOnEmitNode; + var cjsTransform = ts.transformModule(context); + var cjsOnSubstituteNode = context.onSubstituteNode; + var cjsOnEmitNode = context.onEmitNode; + context.onSubstituteNode = onSubstituteNode; + context.onEmitNode = onEmitNode; + context.enableSubstitution(308 /* SyntaxKind.SourceFile */); + context.enableEmitNotification(308 /* SyntaxKind.SourceFile */); + var currentSourceFile; + return transformSourceFileOrBundle; + function onSubstituteNode(hint, node) { + if (ts.isSourceFile(node)) { + currentSourceFile = node; + // Neither component transform wants substitution notifications for `SourceFile`s, and, in fact, relies on + // the source file emit notification to setup scope variables for substitutions (so we _cannot_ call their substitute + // functions on source files safely, as that context only gets setup in a later pipeline phase!) + return previousOnSubstituteNode(hint, node); + } + else { + if (!currentSourceFile) { + return previousOnSubstituteNode(hint, node); + } + if (currentSourceFile.impliedNodeFormat === ts.ModuleKind.ESNext) { + return esmOnSubstituteNode(hint, node); + } + return cjsOnSubstituteNode(hint, node); + } + } + function onEmitNode(hint, node, emitCallback) { + if (ts.isSourceFile(node)) { + currentSourceFile = node; + } + if (!currentSourceFile) { + return previousOnEmitNode(hint, node, emitCallback); + } + if (currentSourceFile.impliedNodeFormat === ts.ModuleKind.ESNext) { + return esmOnEmitNode(hint, node, emitCallback); + } + return cjsOnEmitNode(hint, node, emitCallback); + } + function getModuleTransformForFile(file) { + return file.impliedNodeFormat === ts.ModuleKind.ESNext ? esmTransform : cjsTransform; + } + function transformSourceFile(node) { + if (node.isDeclarationFile) { + return node; + } + currentSourceFile = node; + var result = getModuleTransformForFile(node)(node); + currentSourceFile = undefined; + ts.Debug.assert(ts.isSourceFile(result)); + return result; + } + function transformSourceFileOrBundle(node) { + return node.kind === 308 /* SyntaxKind.SourceFile */ ? transformSourceFile(node) : transformBundle(node); + } + function transformBundle(node) { + return context.factory.createBundle(ts.map(node.sourceFiles, transformSourceFile), node.prepends); + } + } + ts.transformNodeModule = transformNodeModule; +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + function canProduceDiagnostics(node) { + return ts.isVariableDeclaration(node) || + ts.isPropertyDeclaration(node) || + ts.isPropertySignature(node) || + ts.isBindingElement(node) || + ts.isSetAccessor(node) || + ts.isGetAccessor(node) || + ts.isConstructSignatureDeclaration(node) || + ts.isCallSignatureDeclaration(node) || + ts.isMethodDeclaration(node) || + ts.isMethodSignature(node) || + ts.isFunctionDeclaration(node) || + ts.isParameter(node) || + ts.isTypeParameterDeclaration(node) || + ts.isExpressionWithTypeArguments(node) || + ts.isImportEqualsDeclaration(node) || + ts.isTypeAliasDeclaration(node) || + ts.isConstructorDeclaration(node) || + ts.isIndexSignatureDeclaration(node) || + ts.isPropertyAccessExpression(node) || + ts.isJSDocTypeAlias(node); + } + ts.canProduceDiagnostics = canProduceDiagnostics; + function createGetSymbolAccessibilityDiagnosticForNodeName(node) { + if (ts.isSetAccessor(node) || ts.isGetAccessor(node)) { + return getAccessorNameVisibilityError; + } + else if (ts.isMethodSignature(node) || ts.isMethodDeclaration(node)) { + return getMethodNameVisibilityError; + } + else { + return createGetSymbolAccessibilityDiagnosticForNode(node); + } + function getAccessorNameVisibilityError(symbolAccessibilityResult) { + var diagnosticMessage = getAccessorNameVisibilityDiagnosticMessage(symbolAccessibilityResult); + return diagnosticMessage !== undefined ? { + diagnosticMessage: diagnosticMessage, + errorNode: node, + typeName: node.name + } : undefined; + } + function getAccessorNameVisibilityDiagnosticMessage(symbolAccessibilityResult) { + if (ts.isStatic(node)) { + return symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 /* SymbolAccessibility.CannotBeNamed */ ? + ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_private_name_1; + } + else if (node.parent.kind === 260 /* SyntaxKind.ClassDeclaration */) { + return symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 /* SymbolAccessibility.CannotBeNamed */ ? + ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_private_name_1; + } + else { + return symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Property_0_of_exported_interface_has_or_is_using_private_name_1; + } + } + function getMethodNameVisibilityError(symbolAccessibilityResult) { + var diagnosticMessage = getMethodNameVisibilityDiagnosticMessage(symbolAccessibilityResult); + return diagnosticMessage !== undefined ? { + diagnosticMessage: diagnosticMessage, + errorNode: node, + typeName: node.name + } : undefined; + } + function getMethodNameVisibilityDiagnosticMessage(symbolAccessibilityResult) { + if (ts.isStatic(node)) { + return symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 /* SymbolAccessibility.CannotBeNamed */ ? + ts.Diagnostics.Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Public_static_method_0_of_exported_class_has_or_is_using_private_name_1; + } + else if (node.parent.kind === 260 /* SyntaxKind.ClassDeclaration */) { + return symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 /* SymbolAccessibility.CannotBeNamed */ ? + ts.Diagnostics.Public_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Public_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Public_method_0_of_exported_class_has_or_is_using_private_name_1; + } + else { + return symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Method_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Method_0_of_exported_interface_has_or_is_using_private_name_1; + } + } + } + ts.createGetSymbolAccessibilityDiagnosticForNodeName = createGetSymbolAccessibilityDiagnosticForNodeName; + function createGetSymbolAccessibilityDiagnosticForNode(node) { + if (ts.isVariableDeclaration(node) || ts.isPropertyDeclaration(node) || ts.isPropertySignature(node) || ts.isPropertyAccessExpression(node) || ts.isBindingElement(node) || ts.isConstructorDeclaration(node)) { + return getVariableDeclarationTypeVisibilityError; + } + else if (ts.isSetAccessor(node) || ts.isGetAccessor(node)) { + return getAccessorDeclarationTypeVisibilityError; + } + else if (ts.isConstructSignatureDeclaration(node) || ts.isCallSignatureDeclaration(node) || ts.isMethodDeclaration(node) || ts.isMethodSignature(node) || ts.isFunctionDeclaration(node) || ts.isIndexSignatureDeclaration(node)) { + return getReturnTypeVisibilityError; + } + else if (ts.isParameter(node)) { + if (ts.isParameterPropertyDeclaration(node, node.parent) && ts.hasSyntacticModifier(node.parent, 8 /* ModifierFlags.Private */)) { + return getVariableDeclarationTypeVisibilityError; + } + return getParameterDeclarationTypeVisibilityError; + } + else if (ts.isTypeParameterDeclaration(node)) { + return getTypeParameterConstraintVisibilityError; + } + else if (ts.isExpressionWithTypeArguments(node)) { + return getHeritageClauseVisibilityError; + } + else if (ts.isImportEqualsDeclaration(node)) { + return getImportEntityNameVisibilityError; + } + else if (ts.isTypeAliasDeclaration(node) || ts.isJSDocTypeAlias(node)) { + return getTypeAliasDeclarationVisibilityError; + } + else { + return ts.Debug.assertNever(node, "Attempted to set a declaration diagnostic context for unhandled node kind: ".concat(ts.Debug.formatSyntaxKind(node.kind))); + } + function getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult) { + if (node.kind === 257 /* SyntaxKind.VariableDeclaration */ || node.kind === 205 /* SyntaxKind.BindingElement */) { + return symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 /* SymbolAccessibility.CannotBeNamed */ ? + ts.Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Exported_variable_0_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Exported_variable_0_has_or_is_using_private_name_1; + } + // This check is to ensure we don't report error on constructor parameter property as that error would be reported during parameter emit + // The only exception here is if the constructor was marked as private. we are not emitting the constructor parameters at all. + else if (node.kind === 169 /* SyntaxKind.PropertyDeclaration */ || node.kind === 208 /* SyntaxKind.PropertyAccessExpression */ || node.kind === 168 /* SyntaxKind.PropertySignature */ || + (node.kind === 166 /* SyntaxKind.Parameter */ && ts.hasSyntacticModifier(node.parent, 8 /* ModifierFlags.Private */))) { + // TODO(jfreeman): Deal with computed properties in error reporting. + if (ts.isStatic(node)) { + return symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 /* SymbolAccessibility.CannotBeNamed */ ? + ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Public_static_property_0_of_exported_class_has_or_is_using_private_name_1; + } + else if (node.parent.kind === 260 /* SyntaxKind.ClassDeclaration */ || node.kind === 166 /* SyntaxKind.Parameter */) { + return symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 /* SymbolAccessibility.CannotBeNamed */ ? + ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Public_property_0_of_exported_class_has_or_is_using_private_name_1; + } + else { + // Interfaces cannot have types that cannot be named + return symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Property_0_of_exported_interface_has_or_is_using_private_name_1; + } + } + } + function getVariableDeclarationTypeVisibilityError(symbolAccessibilityResult) { + var diagnosticMessage = getVariableDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult); + return diagnosticMessage !== undefined ? { + diagnosticMessage: diagnosticMessage, + errorNode: node, + typeName: node.name + } : undefined; + } + function getAccessorDeclarationTypeVisibilityError(symbolAccessibilityResult) { + var diagnosticMessage; + if (node.kind === 175 /* SyntaxKind.SetAccessor */) { + // Getters can infer the return type from the returned expression, but setters cannot, so the + // "_from_external_module_1_but_cannot_be_named" case cannot occur. + if (ts.isStatic(node)) { + diagnosticMessage = symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_private_name_1; + } + else { + diagnosticMessage = symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_private_name_1; + } + } + else { + if (ts.isStatic(node)) { + diagnosticMessage = symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 /* SymbolAccessibility.CannotBeNamed */ ? + ts.Diagnostics.Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_private_name_1; + } + else { + diagnosticMessage = symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 /* SymbolAccessibility.CannotBeNamed */ ? + ts.Diagnostics.Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Return_type_of_public_getter_0_from_exported_class_has_or_is_using_private_name_1; + } + } + return { + diagnosticMessage: diagnosticMessage, + errorNode: node.name, + typeName: node.name + }; + } + function getReturnTypeVisibilityError(symbolAccessibilityResult) { + var diagnosticMessage; + switch (node.kind) { + case 177 /* SyntaxKind.ConstructSignature */: + // Interfaces cannot have return types that cannot be named + diagnosticMessage = symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : + ts.Diagnostics.Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0; + break; + case 176 /* SyntaxKind.CallSignature */: + // Interfaces cannot have return types that cannot be named + diagnosticMessage = symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : + ts.Diagnostics.Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0; + break; + case 178 /* SyntaxKind.IndexSignature */: + // Interfaces cannot have return types that cannot be named + diagnosticMessage = symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : + ts.Diagnostics.Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0; + break; + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + if (ts.isStatic(node)) { + diagnosticMessage = symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 /* SymbolAccessibility.CannotBeNamed */ ? + ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : + ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1 : + ts.Diagnostics.Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0; + } + else if (node.parent.kind === 260 /* SyntaxKind.ClassDeclaration */) { + diagnosticMessage = symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 /* SymbolAccessibility.CannotBeNamed */ ? + ts.Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : + ts.Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1 : + ts.Diagnostics.Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0; + } + else { + // Interfaces cannot have return types that cannot be named + diagnosticMessage = symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1 : + ts.Diagnostics.Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0; + } + break; + case 259 /* SyntaxKind.FunctionDeclaration */: + diagnosticMessage = symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 /* SymbolAccessibility.CannotBeNamed */ ? + ts.Diagnostics.Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named : + ts.Diagnostics.Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1 : + ts.Diagnostics.Return_type_of_exported_function_has_or_is_using_private_name_0; + break; + default: + return ts.Debug.fail("This is unknown kind for signature: " + node.kind); + } + return { + diagnosticMessage: diagnosticMessage, + errorNode: node.name || node + }; + } + function getParameterDeclarationTypeVisibilityError(symbolAccessibilityResult) { + var diagnosticMessage = getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult); + return diagnosticMessage !== undefined ? { + diagnosticMessage: diagnosticMessage, + errorNode: node, + typeName: node.name + } : undefined; + } + function getParameterDeclarationTypeVisibilityDiagnosticMessage(symbolAccessibilityResult) { + switch (node.parent.kind) { + case 173 /* SyntaxKind.Constructor */: + return symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 /* SymbolAccessibility.CannotBeNamed */ ? + ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1; + case 177 /* SyntaxKind.ConstructSignature */: + case 182 /* SyntaxKind.ConstructorType */: + // Interfaces cannot have parameter types that cannot be named + return symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1; + case 176 /* SyntaxKind.CallSignature */: + // Interfaces cannot have parameter types that cannot be named + return symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1; + case 178 /* SyntaxKind.IndexSignature */: + // Interfaces cannot have parameter types that cannot be named + return symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_private_name_1; + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + if (ts.isStatic(node.parent)) { + return symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 /* SymbolAccessibility.CannotBeNamed */ ? + ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1; + } + else if (node.parent.parent.kind === 260 /* SyntaxKind.ClassDeclaration */) { + return symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 /* SymbolAccessibility.CannotBeNamed */ ? + ts.Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1; + } + else { + // Interfaces cannot have parameter types that cannot be named + return symbolAccessibilityResult.errorModuleName ? + ts.Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1; + } + case 259 /* SyntaxKind.FunctionDeclaration */: + case 181 /* SyntaxKind.FunctionType */: + return symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 /* SymbolAccessibility.CannotBeNamed */ ? + ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Parameter_0_of_exported_function_has_or_is_using_private_name_1; + case 175 /* SyntaxKind.SetAccessor */: + case 174 /* SyntaxKind.GetAccessor */: + return symbolAccessibilityResult.errorModuleName ? + symbolAccessibilityResult.accessibility === 2 /* SymbolAccessibility.CannotBeNamed */ ? + ts.Diagnostics.Parameter_0_of_accessor_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named : + ts.Diagnostics.Parameter_0_of_accessor_has_or_is_using_name_1_from_private_module_2 : + ts.Diagnostics.Parameter_0_of_accessor_has_or_is_using_private_name_1; + default: + return ts.Debug.fail("Unknown parent for parameter: ".concat(ts.Debug.formatSyntaxKind(node.parent.kind))); + } + } + function getTypeParameterConstraintVisibilityError() { + // Type parameter constraints are named by user so we should always be able to name it + var diagnosticMessage; + switch (node.parent.kind) { + case 260 /* SyntaxKind.ClassDeclaration */: + diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_class_has_or_is_using_private_name_1; + break; + case 261 /* SyntaxKind.InterfaceDeclaration */: + diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1; + break; + case 197 /* SyntaxKind.MappedType */: + diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_mapped_object_type_is_using_private_name_1; + break; + case 182 /* SyntaxKind.ConstructorType */: + case 177 /* SyntaxKind.ConstructSignature */: + diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1; + break; + case 176 /* SyntaxKind.CallSignature */: + diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1; + break; + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + if (ts.isStatic(node.parent)) { + diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1; + } + else if (node.parent.parent.kind === 260 /* SyntaxKind.ClassDeclaration */) { + diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1; + } + else { + diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1; + } + break; + case 181 /* SyntaxKind.FunctionType */: + case 259 /* SyntaxKind.FunctionDeclaration */: + diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_function_has_or_is_using_private_name_1; + break; + case 262 /* SyntaxKind.TypeAliasDeclaration */: + diagnosticMessage = ts.Diagnostics.Type_parameter_0_of_exported_type_alias_has_or_is_using_private_name_1; + break; + default: + return ts.Debug.fail("This is unknown parent for type parameter: " + node.parent.kind); + } + return { + diagnosticMessage: diagnosticMessage, + errorNode: node, + typeName: node.name + }; + } + function getHeritageClauseVisibilityError() { + var diagnosticMessage; + // Heritage clause is written by user so it can always be named + if (ts.isClassDeclaration(node.parent.parent)) { + // Class or Interface implemented/extended is inaccessible + diagnosticMessage = ts.isHeritageClause(node.parent) && node.parent.token === 117 /* SyntaxKind.ImplementsKeyword */ ? + ts.Diagnostics.Implements_clause_of_exported_class_0_has_or_is_using_private_name_1 : + node.parent.parent.name ? ts.Diagnostics.extends_clause_of_exported_class_0_has_or_is_using_private_name_1 : + ts.Diagnostics.extends_clause_of_exported_class_has_or_is_using_private_name_0; + } + else { + // interface is inaccessible + diagnosticMessage = ts.Diagnostics.extends_clause_of_exported_interface_0_has_or_is_using_private_name_1; + } + return { + diagnosticMessage: diagnosticMessage, + errorNode: node, + typeName: ts.getNameOfDeclaration(node.parent.parent) + }; + } + function getImportEntityNameVisibilityError() { + return { + diagnosticMessage: ts.Diagnostics.Import_declaration_0_is_using_private_name_1, + errorNode: node, + typeName: node.name + }; + } + function getTypeAliasDeclarationVisibilityError(symbolAccessibilityResult) { + return { + diagnosticMessage: symbolAccessibilityResult.errorModuleName + ? ts.Diagnostics.Exported_type_alias_0_has_or_is_using_private_name_1_from_module_2 + : ts.Diagnostics.Exported_type_alias_0_has_or_is_using_private_name_1, + errorNode: ts.isJSDocTypeAlias(node) ? ts.Debug.checkDefined(node.typeExpression) : node.type, + typeName: ts.isJSDocTypeAlias(node) ? ts.getNameOfDeclaration(node) : node.name, + }; + } + } + ts.createGetSymbolAccessibilityDiagnosticForNode = createGetSymbolAccessibilityDiagnosticForNode; +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + function getDeclarationDiagnostics(host, resolver, file) { + var compilerOptions = host.getCompilerOptions(); + var result = ts.transformNodes(resolver, host, ts.factory, compilerOptions, file ? [file] : ts.filter(host.getSourceFiles(), ts.isSourceFileNotJson), [transformDeclarations], /*allowDtsFiles*/ false); + return result.diagnostics; + } + ts.getDeclarationDiagnostics = getDeclarationDiagnostics; + function hasInternalAnnotation(range, currentSourceFile) { + var comment = currentSourceFile.text.substring(range.pos, range.end); + return ts.stringContains(comment, "@internal"); + } + function isInternalDeclaration(node, currentSourceFile) { + var parseTreeNode = ts.getParseTreeNode(node); + if (parseTreeNode && parseTreeNode.kind === 166 /* SyntaxKind.Parameter */) { + var paramIdx = parseTreeNode.parent.parameters.indexOf(parseTreeNode); + var previousSibling = paramIdx > 0 ? parseTreeNode.parent.parameters[paramIdx - 1] : undefined; + var text = currentSourceFile.text; + var commentRanges = previousSibling + ? ts.concatenate( + // to handle + // ... parameters, /* @internal */ + // public param: string + ts.getTrailingCommentRanges(text, ts.skipTrivia(text, previousSibling.end + 1, /* stopAfterLineBreak */ false, /* stopAtComments */ true)), ts.getLeadingCommentRanges(text, node.pos)) + : ts.getTrailingCommentRanges(text, ts.skipTrivia(text, node.pos, /* stopAfterLineBreak */ false, /* stopAtComments */ true)); + return commentRanges && commentRanges.length && hasInternalAnnotation(ts.last(commentRanges), currentSourceFile); + } + var leadingCommentRanges = parseTreeNode && ts.getLeadingCommentRangesOfNode(parseTreeNode, currentSourceFile); + return !!ts.forEach(leadingCommentRanges, function (range) { + return hasInternalAnnotation(range, currentSourceFile); + }); + } + ts.isInternalDeclaration = isInternalDeclaration; + var declarationEmitNodeBuilderFlags = 1024 /* NodeBuilderFlags.MultilineObjectLiterals */ | + 2048 /* NodeBuilderFlags.WriteClassExpressionAsTypeLiteral */ | + 4096 /* NodeBuilderFlags.UseTypeOfFunction */ | + 8 /* NodeBuilderFlags.UseStructuralFallback */ | + 524288 /* NodeBuilderFlags.AllowEmptyTuple */ | + 4 /* NodeBuilderFlags.GenerateNamesForShadowedTypeParams */ | + 1 /* NodeBuilderFlags.NoTruncation */; + /** + * Transforms a ts file into a .d.ts file + * This process requires type information, which is retrieved through the emit resolver. Because of this, + * in many places this transformer assumes it will be operating on parse tree nodes directly. + * This means that _no transforms should be allowed to occur before this one_. + */ + function transformDeclarations(context) { + var throwDiagnostic = function () { return ts.Debug.fail("Diagnostic emitted without context"); }; + var getSymbolAccessibilityDiagnostic = throwDiagnostic; + var needsDeclare = true; + var isBundledEmit = false; + var resultHasExternalModuleIndicator = false; + var needsScopeFixMarker = false; + var resultHasScopeMarker = false; + var enclosingDeclaration; + var necessaryTypeReferences; + var lateMarkedStatements; + var lateStatementReplacementMap; + var suppressNewDiagnosticContexts; + var exportedModulesFromDeclarationEmit; + var factory = context.factory; + var host = context.getEmitHost(); + var symbolTracker = { + trackSymbol: trackSymbol, + reportInaccessibleThisError: reportInaccessibleThisError, + reportInaccessibleUniqueSymbolError: reportInaccessibleUniqueSymbolError, + reportCyclicStructureError: reportCyclicStructureError, + reportPrivateInBaseOfClassExpression: reportPrivateInBaseOfClassExpression, + reportLikelyUnsafeImportRequiredError: reportLikelyUnsafeImportRequiredError, + reportTruncationError: reportTruncationError, + moduleResolverHost: host, + trackReferencedAmbientModule: trackReferencedAmbientModule, + trackExternalModuleSymbolOfImportTypeNode: trackExternalModuleSymbolOfImportTypeNode, + reportNonlocalAugmentation: reportNonlocalAugmentation, + reportNonSerializableProperty: reportNonSerializableProperty, + reportImportTypeNodeResolutionModeOverride: reportImportTypeNodeResolutionModeOverride, + }; + var errorNameNode; + var errorFallbackNode; + var currentSourceFile; + var refs; + var libs; + var emittedImports; // must be declared in container so it can be `undefined` while transformer's first pass + var resolver = context.getEmitResolver(); + var options = context.getCompilerOptions(); + var noResolve = options.noResolve, stripInternal = options.stripInternal; + return transformRoot; + function recordTypeReferenceDirectivesIfNecessary(typeReferenceDirectives) { + if (!typeReferenceDirectives) { + return; + } + necessaryTypeReferences = necessaryTypeReferences || new ts.Set(); + for (var _i = 0, typeReferenceDirectives_2 = typeReferenceDirectives; _i < typeReferenceDirectives_2.length; _i++) { + var ref = typeReferenceDirectives_2[_i]; + necessaryTypeReferences.add(ref); + } + } + function trackReferencedAmbientModule(node, symbol) { + // If it is visible via `// `, then we should just use that + var directives = resolver.getTypeReferenceDirectivesForSymbol(symbol, 67108863 /* SymbolFlags.All */); + if (ts.length(directives)) { + return recordTypeReferenceDirectivesIfNecessary(directives); + } + // Otherwise we should emit a path-based reference + var container = ts.getSourceFileOfNode(node); + refs.set(ts.getOriginalNodeId(container), container); + } + function handleSymbolAccessibilityError(symbolAccessibilityResult) { + if (symbolAccessibilityResult.accessibility === 0 /* SymbolAccessibility.Accessible */) { + // Add aliases back onto the possible imports list if they're not there so we can try them again with updated visibility info + if (symbolAccessibilityResult && symbolAccessibilityResult.aliasesToMakeVisible) { + if (!lateMarkedStatements) { + lateMarkedStatements = symbolAccessibilityResult.aliasesToMakeVisible; + } + else { + for (var _i = 0, _a = symbolAccessibilityResult.aliasesToMakeVisible; _i < _a.length; _i++) { + var ref = _a[_i]; + ts.pushIfUnique(lateMarkedStatements, ref); + } + } + } + // TODO: Do all these accessibility checks inside/after the first pass in the checker when declarations are enabled, if possible + } + else { + // Report error + var errorInfo = getSymbolAccessibilityDiagnostic(symbolAccessibilityResult); + if (errorInfo) { + if (errorInfo.typeName) { + context.addDiagnostic(ts.createDiagnosticForNode(symbolAccessibilityResult.errorNode || errorInfo.errorNode, errorInfo.diagnosticMessage, ts.getTextOfNode(errorInfo.typeName), symbolAccessibilityResult.errorSymbolName, symbolAccessibilityResult.errorModuleName)); + } + else { + context.addDiagnostic(ts.createDiagnosticForNode(symbolAccessibilityResult.errorNode || errorInfo.errorNode, errorInfo.diagnosticMessage, symbolAccessibilityResult.errorSymbolName, symbolAccessibilityResult.errorModuleName)); + } + return true; + } + } + return false; + } + function trackExternalModuleSymbolOfImportTypeNode(symbol) { + if (!isBundledEmit) { + (exportedModulesFromDeclarationEmit || (exportedModulesFromDeclarationEmit = [])).push(symbol); + } + } + function trackSymbol(symbol, enclosingDeclaration, meaning) { + if (symbol.flags & 262144 /* SymbolFlags.TypeParameter */) + return false; + var issuedDiagnostic = handleSymbolAccessibilityError(resolver.isSymbolAccessible(symbol, enclosingDeclaration, meaning, /*shouldComputeAliasesToMakeVisible*/ true)); + recordTypeReferenceDirectivesIfNecessary(resolver.getTypeReferenceDirectivesForSymbol(symbol, meaning)); + return issuedDiagnostic; + } + function reportPrivateInBaseOfClassExpression(propertyName) { + if (errorNameNode || errorFallbackNode) { + context.addDiagnostic(ts.createDiagnosticForNode((errorNameNode || errorFallbackNode), ts.Diagnostics.Property_0_of_exported_class_expression_may_not_be_private_or_protected, propertyName)); + } + } + function errorDeclarationNameWithFallback() { + return errorNameNode ? ts.declarationNameToString(errorNameNode) : + errorFallbackNode && ts.getNameOfDeclaration(errorFallbackNode) ? ts.declarationNameToString(ts.getNameOfDeclaration(errorFallbackNode)) : + errorFallbackNode && ts.isExportAssignment(errorFallbackNode) ? errorFallbackNode.isExportEquals ? "export=" : "default" : + "(Missing)"; // same fallback declarationNameToString uses when node is zero-width (ie, nameless) + } + function reportInaccessibleUniqueSymbolError() { + if (errorNameNode || errorFallbackNode) { + context.addDiagnostic(ts.createDiagnosticForNode((errorNameNode || errorFallbackNode), ts.Diagnostics.The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary, errorDeclarationNameWithFallback(), "unique symbol")); + } + } + function reportCyclicStructureError() { + if (errorNameNode || errorFallbackNode) { + context.addDiagnostic(ts.createDiagnosticForNode((errorNameNode || errorFallbackNode), ts.Diagnostics.The_inferred_type_of_0_references_a_type_with_a_cyclic_structure_which_cannot_be_trivially_serialized_A_type_annotation_is_necessary, errorDeclarationNameWithFallback())); + } + } + function reportInaccessibleThisError() { + if (errorNameNode || errorFallbackNode) { + context.addDiagnostic(ts.createDiagnosticForNode((errorNameNode || errorFallbackNode), ts.Diagnostics.The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary, errorDeclarationNameWithFallback(), "this")); + } + } + function reportLikelyUnsafeImportRequiredError(specifier) { + if (errorNameNode || errorFallbackNode) { + context.addDiagnostic(ts.createDiagnosticForNode((errorNameNode || errorFallbackNode), ts.Diagnostics.The_inferred_type_of_0_cannot_be_named_without_a_reference_to_1_This_is_likely_not_portable_A_type_annotation_is_necessary, errorDeclarationNameWithFallback(), specifier)); + } + } + function reportTruncationError() { + if (errorNameNode || errorFallbackNode) { + context.addDiagnostic(ts.createDiagnosticForNode((errorNameNode || errorFallbackNode), ts.Diagnostics.The_inferred_type_of_this_node_exceeds_the_maximum_length_the_compiler_will_serialize_An_explicit_type_annotation_is_needed)); + } + } + function reportNonlocalAugmentation(containingFile, parentSymbol, symbol) { + var _a; + var primaryDeclaration = (_a = parentSymbol.declarations) === null || _a === void 0 ? void 0 : _a.find(function (d) { return ts.getSourceFileOfNode(d) === containingFile; }); + var augmentingDeclarations = ts.filter(symbol.declarations, function (d) { return ts.getSourceFileOfNode(d) !== containingFile; }); + if (primaryDeclaration && augmentingDeclarations) { + for (var _i = 0, augmentingDeclarations_1 = augmentingDeclarations; _i < augmentingDeclarations_1.length; _i++) { + var augmentations = augmentingDeclarations_1[_i]; + context.addDiagnostic(ts.addRelatedInfo(ts.createDiagnosticForNode(augmentations, ts.Diagnostics.Declaration_augments_declaration_in_another_file_This_cannot_be_serialized), ts.createDiagnosticForNode(primaryDeclaration, ts.Diagnostics.This_is_the_declaration_being_augmented_Consider_moving_the_augmenting_declaration_into_the_same_file))); + } + } + } + function reportNonSerializableProperty(propertyName) { + if (errorNameNode || errorFallbackNode) { + context.addDiagnostic(ts.createDiagnosticForNode((errorNameNode || errorFallbackNode), ts.Diagnostics.The_type_of_this_node_cannot_be_serialized_because_its_property_0_cannot_be_serialized, propertyName)); + } + } + function reportImportTypeNodeResolutionModeOverride() { + if (!ts.isNightly() && (errorNameNode || errorFallbackNode)) { + context.addDiagnostic(ts.createDiagnosticForNode((errorNameNode || errorFallbackNode), ts.Diagnostics.The_type_of_this_expression_cannot_be_named_without_a_resolution_mode_assertion_which_is_an_unstable_feature_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next)); + } + } + function transformDeclarationsForJS(sourceFile, bundled) { + var oldDiag = getSymbolAccessibilityDiagnostic; + getSymbolAccessibilityDiagnostic = function (s) { return (s.errorNode && ts.canProduceDiagnostics(s.errorNode) ? ts.createGetSymbolAccessibilityDiagnosticForNode(s.errorNode)(s) : ({ + diagnosticMessage: s.errorModuleName + ? ts.Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotation_may_unblock_declaration_emit + : ts.Diagnostics.Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_declaration_emit, + errorNode: s.errorNode || sourceFile + })); }; + var result = resolver.getDeclarationStatementsForSourceFile(sourceFile, declarationEmitNodeBuilderFlags, symbolTracker, bundled); + getSymbolAccessibilityDiagnostic = oldDiag; + return result; + } + function transformRoot(node) { + if (node.kind === 308 /* SyntaxKind.SourceFile */ && node.isDeclarationFile) { + return node; + } + if (node.kind === 309 /* SyntaxKind.Bundle */) { + isBundledEmit = true; + refs = new ts.Map(); + libs = new ts.Map(); + var hasNoDefaultLib_1 = false; + var bundle = factory.createBundle(ts.map(node.sourceFiles, function (sourceFile) { + if (sourceFile.isDeclarationFile) + return undefined; // Omit declaration files from bundle results, too // TODO: GH#18217 + hasNoDefaultLib_1 = hasNoDefaultLib_1 || sourceFile.hasNoDefaultLib; + currentSourceFile = sourceFile; + enclosingDeclaration = sourceFile; + lateMarkedStatements = undefined; + suppressNewDiagnosticContexts = false; + lateStatementReplacementMap = new ts.Map(); + getSymbolAccessibilityDiagnostic = throwDiagnostic; + needsScopeFixMarker = false; + resultHasScopeMarker = false; + collectReferences(sourceFile, refs); + collectLibs(sourceFile, libs); + if (ts.isExternalOrCommonJsModule(sourceFile) || ts.isJsonSourceFile(sourceFile)) { + resultHasExternalModuleIndicator = false; // unused in external module bundle emit (all external modules are within module blocks, therefore are known to be modules) + needsDeclare = false; + var statements = ts.isSourceFileJS(sourceFile) ? factory.createNodeArray(transformDeclarationsForJS(sourceFile, /*bundled*/ true)) : ts.visitNodes(sourceFile.statements, visitDeclarationStatements); + var newFile = factory.updateSourceFile(sourceFile, [factory.createModuleDeclaration([factory.createModifier(136 /* SyntaxKind.DeclareKeyword */)], factory.createStringLiteral(ts.getResolvedExternalModuleName(context.getEmitHost(), sourceFile)), factory.createModuleBlock(ts.setTextRange(factory.createNodeArray(transformAndReplaceLatePaintedStatements(statements)), sourceFile.statements)))], /*isDeclarationFile*/ true, /*referencedFiles*/ [], /*typeReferences*/ [], /*hasNoDefaultLib*/ false, /*libReferences*/ []); + return newFile; + } + needsDeclare = true; + var updated = ts.isSourceFileJS(sourceFile) ? factory.createNodeArray(transformDeclarationsForJS(sourceFile)) : ts.visitNodes(sourceFile.statements, visitDeclarationStatements); + return factory.updateSourceFile(sourceFile, transformAndReplaceLatePaintedStatements(updated), /*isDeclarationFile*/ true, /*referencedFiles*/ [], /*typeReferences*/ [], /*hasNoDefaultLib*/ false, /*libReferences*/ []); + }), ts.mapDefined(node.prepends, function (prepend) { + if (prepend.kind === 311 /* SyntaxKind.InputFiles */) { + var sourceFile = ts.createUnparsedSourceFile(prepend, "dts", stripInternal); + hasNoDefaultLib_1 = hasNoDefaultLib_1 || !!sourceFile.hasNoDefaultLib; + collectReferences(sourceFile, refs); + recordTypeReferenceDirectivesIfNecessary(ts.map(sourceFile.typeReferenceDirectives, function (ref) { return [ref.fileName, ref.resolutionMode]; })); + collectLibs(sourceFile, libs); + return sourceFile; + } + return prepend; + })); + bundle.syntheticFileReferences = []; + bundle.syntheticTypeReferences = getFileReferencesForUsedTypeReferences(); + bundle.syntheticLibReferences = getLibReferences(); + bundle.hasNoDefaultLib = hasNoDefaultLib_1; + var outputFilePath_1 = ts.getDirectoryPath(ts.normalizeSlashes(ts.getOutputPathsFor(node, host, /*forceDtsPaths*/ true).declarationFilePath)); + var referenceVisitor_1 = mapReferencesIntoArray(bundle.syntheticFileReferences, outputFilePath_1); + refs.forEach(referenceVisitor_1); + return bundle; + } + // Single source file + needsDeclare = true; + needsScopeFixMarker = false; + resultHasScopeMarker = false; + enclosingDeclaration = node; + currentSourceFile = node; + getSymbolAccessibilityDiagnostic = throwDiagnostic; + isBundledEmit = false; + resultHasExternalModuleIndicator = false; + suppressNewDiagnosticContexts = false; + lateMarkedStatements = undefined; + lateStatementReplacementMap = new ts.Map(); + necessaryTypeReferences = undefined; + refs = collectReferences(currentSourceFile, new ts.Map()); + libs = collectLibs(currentSourceFile, new ts.Map()); + var references = []; + var outputFilePath = ts.getDirectoryPath(ts.normalizeSlashes(ts.getOutputPathsFor(node, host, /*forceDtsPaths*/ true).declarationFilePath)); + var referenceVisitor = mapReferencesIntoArray(references, outputFilePath); + var combinedStatements; + if (ts.isSourceFileJS(currentSourceFile)) { + combinedStatements = factory.createNodeArray(transformDeclarationsForJS(node)); + refs.forEach(referenceVisitor); + emittedImports = ts.filter(combinedStatements, ts.isAnyImportSyntax); + } + else { + var statements = ts.visitNodes(node.statements, visitDeclarationStatements); + combinedStatements = ts.setTextRange(factory.createNodeArray(transformAndReplaceLatePaintedStatements(statements)), node.statements); + refs.forEach(referenceVisitor); + emittedImports = ts.filter(combinedStatements, ts.isAnyImportSyntax); + if (ts.isExternalModule(node) && (!resultHasExternalModuleIndicator || (needsScopeFixMarker && !resultHasScopeMarker))) { + combinedStatements = ts.setTextRange(factory.createNodeArray(__spreadArray(__spreadArray([], combinedStatements, true), [ts.createEmptyExports(factory)], false)), combinedStatements); + } + } + var updated = factory.updateSourceFile(node, combinedStatements, /*isDeclarationFile*/ true, references, getFileReferencesForUsedTypeReferences(), node.hasNoDefaultLib, getLibReferences()); + updated.exportedModulesFromDeclarationEmit = exportedModulesFromDeclarationEmit; + return updated; + function getLibReferences() { + return ts.map(ts.arrayFrom(libs.keys()), function (lib) { return ({ fileName: lib, pos: -1, end: -1 }); }); + } + function getFileReferencesForUsedTypeReferences() { + return necessaryTypeReferences ? ts.mapDefined(ts.arrayFrom(necessaryTypeReferences.keys()), getFileReferenceForSpecifierModeTuple) : []; + } + function getFileReferenceForSpecifierModeTuple(_a) { + var typeName = _a[0], mode = _a[1]; + // Elide type references for which we have imports + if (emittedImports) { + for (var _i = 0, emittedImports_1 = emittedImports; _i < emittedImports_1.length; _i++) { + var importStatement = emittedImports_1[_i]; + if (ts.isImportEqualsDeclaration(importStatement) && ts.isExternalModuleReference(importStatement.moduleReference)) { + var expr = importStatement.moduleReference.expression; + if (ts.isStringLiteralLike(expr) && expr.text === typeName) { + return undefined; + } + } + else if (ts.isImportDeclaration(importStatement) && ts.isStringLiteral(importStatement.moduleSpecifier) && importStatement.moduleSpecifier.text === typeName) { + return undefined; + } + } + } + return __assign({ fileName: typeName, pos: -1, end: -1 }, (mode ? { resolutionMode: mode } : undefined)); + } + function mapReferencesIntoArray(references, outputFilePath) { + return function (file) { + var declFileName; + if (file.isDeclarationFile) { // Neither decl files or js should have their refs changed + declFileName = file.fileName; + } + else { + if (isBundledEmit && ts.contains(node.sourceFiles, file)) + return; // Omit references to files which are being merged + var paths = ts.getOutputPathsFor(file, host, /*forceDtsPaths*/ true); + declFileName = paths.declarationFilePath || paths.jsFilePath || file.fileName; + } + if (declFileName) { + var specifier = ts.moduleSpecifiers.getModuleSpecifier(options, currentSourceFile, ts.toPath(outputFilePath, host.getCurrentDirectory(), host.getCanonicalFileName), ts.toPath(declFileName, host.getCurrentDirectory(), host.getCanonicalFileName), host); + if (!ts.pathIsRelative(specifier)) { + // If some compiler option/symlink/whatever allows access to the file containing the ambient module declaration + // via a non-relative name, emit a type reference directive to that non-relative name, rather than + // a relative path to the declaration file + recordTypeReferenceDirectivesIfNecessary([[specifier, /*mode*/ undefined]]); + return; + } + var fileName = ts.getRelativePathToDirectoryOrUrl(outputFilePath, declFileName, host.getCurrentDirectory(), host.getCanonicalFileName, + /*isAbsolutePathAnUrl*/ false); + if (ts.startsWith(fileName, "./") && ts.hasExtension(fileName)) { + fileName = fileName.substring(2); + } + // omit references to files from node_modules (npm may disambiguate module + // references when installing this package, making the path is unreliable). + if (ts.startsWith(fileName, "node_modules/") || ts.pathContainsNodeModules(fileName)) { + return; + } + references.push({ pos: -1, end: -1, fileName: fileName }); + } + }; + } + } + function collectReferences(sourceFile, ret) { + if (noResolve || (!ts.isUnparsedSource(sourceFile) && ts.isSourceFileJS(sourceFile))) + return ret; + ts.forEach(sourceFile.referencedFiles, function (f) { + var elem = host.getSourceFileFromReference(sourceFile, f); + if (elem) { + ret.set(ts.getOriginalNodeId(elem), elem); + } + }); + return ret; + } + function collectLibs(sourceFile, ret) { + ts.forEach(sourceFile.libReferenceDirectives, function (ref) { + var lib = host.getLibFileFromReference(ref); + if (lib) { + ret.set(ts.toFileNameLowerCase(ref.fileName), true); + } + }); + return ret; + } + function filterBindingPatternInitializersAndRenamings(name) { + if (name.kind === 79 /* SyntaxKind.Identifier */) { + return name; + } + else { + if (name.kind === 204 /* SyntaxKind.ArrayBindingPattern */) { + return factory.updateArrayBindingPattern(name, ts.visitNodes(name.elements, visitBindingElement)); + } + else { + return factory.updateObjectBindingPattern(name, ts.visitNodes(name.elements, visitBindingElement)); + } + } + function visitBindingElement(elem) { + if (elem.kind === 229 /* SyntaxKind.OmittedExpression */) { + return elem; + } + if (elem.propertyName && ts.isIdentifier(elem.propertyName) && ts.isIdentifier(elem.name) && !elem.symbol.isReferenced) { + // Unnecessary property renaming is forbidden in types, so remove renaming + return factory.updateBindingElement(elem, elem.dotDotDotToken, + /* propertyName */ undefined, elem.propertyName, shouldPrintWithInitializer(elem) ? elem.initializer : undefined); + } + return factory.updateBindingElement(elem, elem.dotDotDotToken, elem.propertyName, filterBindingPatternInitializersAndRenamings(elem.name), shouldPrintWithInitializer(elem) ? elem.initializer : undefined); + } + } + function ensureParameter(p, modifierMask, type) { + var oldDiag; + if (!suppressNewDiagnosticContexts) { + oldDiag = getSymbolAccessibilityDiagnostic; + getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(p); + } + var newParam = factory.updateParameterDeclaration(p, maskModifiers(p, modifierMask), p.dotDotDotToken, filterBindingPatternInitializersAndRenamings(p.name), resolver.isOptionalParameter(p) ? (p.questionToken || factory.createToken(57 /* SyntaxKind.QuestionToken */)) : undefined, ensureType(p, type || p.type, /*ignorePrivate*/ true), // Ignore private param props, since this type is going straight back into a param + ensureNoInitializer(p)); + if (!suppressNewDiagnosticContexts) { + getSymbolAccessibilityDiagnostic = oldDiag; + } + return newParam; + } + function shouldPrintWithInitializer(node) { + return canHaveLiteralInitializer(node) && resolver.isLiteralConstDeclaration(ts.getParseTreeNode(node)); // TODO: Make safe + } + function ensureNoInitializer(node) { + if (shouldPrintWithInitializer(node)) { + return resolver.createLiteralConstValue(ts.getParseTreeNode(node), symbolTracker); // TODO: Make safe + } + return undefined; + } + function ensureType(node, type, ignorePrivate) { + if (!ignorePrivate && ts.hasEffectiveModifier(node, 8 /* ModifierFlags.Private */)) { + // Private nodes emit no types (except private parameter properties, whose parameter types are actually visible) + return; + } + if (shouldPrintWithInitializer(node)) { + // Literal const declarations will have an initializer ensured rather than a type + return; + } + var shouldUseResolverType = node.kind === 166 /* SyntaxKind.Parameter */ && + (resolver.isRequiredInitializedParameter(node) || + resolver.isOptionalUninitializedParameterProperty(node)); + if (type && !shouldUseResolverType) { + return ts.visitNode(type, visitDeclarationSubtree); + } + if (!ts.getParseTreeNode(node)) { + return type ? ts.visitNode(type, visitDeclarationSubtree) : factory.createKeywordTypeNode(131 /* SyntaxKind.AnyKeyword */); + } + if (node.kind === 175 /* SyntaxKind.SetAccessor */) { + // Set accessors with no associated type node (from it's param or get accessor return) are `any` since they are never contextually typed right now + // (The inferred type here will be void, but the old declaration emitter printed `any`, so this replicates that) + return factory.createKeywordTypeNode(131 /* SyntaxKind.AnyKeyword */); + } + errorNameNode = node.name; + var oldDiag; + if (!suppressNewDiagnosticContexts) { + oldDiag = getSymbolAccessibilityDiagnostic; + getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(node); + } + if (node.kind === 257 /* SyntaxKind.VariableDeclaration */ || node.kind === 205 /* SyntaxKind.BindingElement */) { + return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker)); + } + if (node.kind === 166 /* SyntaxKind.Parameter */ + || node.kind === 169 /* SyntaxKind.PropertyDeclaration */ + || node.kind === 168 /* SyntaxKind.PropertySignature */) { + if (ts.isPropertySignature(node) || !node.initializer) + return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldUseResolverType)); + return cleanup(resolver.createTypeOfDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker, shouldUseResolverType) || resolver.createTypeOfExpression(node.initializer, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker)); + } + return cleanup(resolver.createReturnTypeOfSignatureDeclaration(node, enclosingDeclaration, declarationEmitNodeBuilderFlags, symbolTracker)); + function cleanup(returnValue) { + errorNameNode = undefined; + if (!suppressNewDiagnosticContexts) { + getSymbolAccessibilityDiagnostic = oldDiag; + } + return returnValue || factory.createKeywordTypeNode(131 /* SyntaxKind.AnyKeyword */); + } + } + function isDeclarationAndNotVisible(node) { + node = ts.getParseTreeNode(node); + switch (node.kind) { + case 259 /* SyntaxKind.FunctionDeclaration */: + case 264 /* SyntaxKind.ModuleDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + return !resolver.isDeclarationVisible(node); + // The following should be doing their own visibility checks based on filtering their members + case 257 /* SyntaxKind.VariableDeclaration */: + return !getBindingNameVisible(node); + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + case 269 /* SyntaxKind.ImportDeclaration */: + case 275 /* SyntaxKind.ExportDeclaration */: + case 274 /* SyntaxKind.ExportAssignment */: + return false; + case 172 /* SyntaxKind.ClassStaticBlockDeclaration */: + return true; + } + return false; + } + // If the ExpandoFunctionDeclaration have multiple overloads, then we only need to emit properties for the last one. + function shouldEmitFunctionProperties(input) { + var _a; + if (input.body) { + return true; + } + var overloadSignatures = (_a = input.symbol.declarations) === null || _a === void 0 ? void 0 : _a.filter(function (decl) { return ts.isFunctionDeclaration(decl) && !decl.body; }); + return !overloadSignatures || overloadSignatures.indexOf(input) === overloadSignatures.length - 1; + } + function getBindingNameVisible(elem) { + if (ts.isOmittedExpression(elem)) { + return false; + } + if (ts.isBindingPattern(elem.name)) { + // If any child binding pattern element has been marked visible (usually by collect linked aliases), then this is visible + return ts.some(elem.name.elements, getBindingNameVisible); + } + else { + return resolver.isDeclarationVisible(elem); + } + } + function updateParamsList(node, params, modifierMask) { + if (ts.hasEffectiveModifier(node, 8 /* ModifierFlags.Private */)) { + return undefined; // TODO: GH#18217 + } + var newParams = ts.map(params, function (p) { return ensureParameter(p, modifierMask); }); + if (!newParams) { + return undefined; // TODO: GH#18217 + } + return factory.createNodeArray(newParams, params.hasTrailingComma); + } + function updateAccessorParamsList(input, isPrivate) { + var newParams; + if (!isPrivate) { + var thisParameter = ts.getThisParameter(input); + if (thisParameter) { + newParams = [ensureParameter(thisParameter)]; + } + } + if (ts.isSetAccessorDeclaration(input)) { + var newValueParameter = void 0; + if (!isPrivate) { + var valueParameter = ts.getSetAccessorValueParameter(input); + if (valueParameter) { + var accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input)); + newValueParameter = ensureParameter(valueParameter, /*modifierMask*/ undefined, accessorType); + } + } + if (!newValueParameter) { + newValueParameter = factory.createParameterDeclaration( + /*modifiers*/ undefined, + /*dotDotDotToken*/ undefined, "value"); + } + newParams = ts.append(newParams, newValueParameter); + } + return factory.createNodeArray(newParams || ts.emptyArray); + } + function ensureTypeParams(node, params) { + return ts.hasEffectiveModifier(node, 8 /* ModifierFlags.Private */) ? undefined : ts.visitNodes(params, visitDeclarationSubtree); + } + function isEnclosingDeclaration(node) { + return ts.isSourceFile(node) + || ts.isTypeAliasDeclaration(node) + || ts.isModuleDeclaration(node) + || ts.isClassDeclaration(node) + || ts.isInterfaceDeclaration(node) + || ts.isFunctionLike(node) + || ts.isIndexSignatureDeclaration(node) + || ts.isMappedTypeNode(node); + } + function checkEntityNameVisibility(entityName, enclosingDeclaration) { + var visibilityResult = resolver.isEntityNameVisible(entityName, enclosingDeclaration); + handleSymbolAccessibilityError(visibilityResult); + recordTypeReferenceDirectivesIfNecessary(resolver.getTypeReferenceDirectivesForEntityName(entityName)); + } + function preserveJsDoc(updated, original) { + if (ts.hasJSDocNodes(updated) && ts.hasJSDocNodes(original)) { + updated.jsDoc = original.jsDoc; + } + return ts.setCommentRange(updated, ts.getCommentRange(original)); + } + function rewriteModuleSpecifier(parent, input) { + if (!input) + return undefined; // TODO: GH#18217 + resultHasExternalModuleIndicator = resultHasExternalModuleIndicator || (parent.kind !== 264 /* SyntaxKind.ModuleDeclaration */ && parent.kind !== 202 /* SyntaxKind.ImportType */); + if (ts.isStringLiteralLike(input)) { + if (isBundledEmit) { + var newName = ts.getExternalModuleNameFromDeclaration(context.getEmitHost(), resolver, parent); + if (newName) { + return factory.createStringLiteral(newName); + } + } + else { + var symbol = resolver.getSymbolOfExternalModuleSpecifier(input); + if (symbol) { + (exportedModulesFromDeclarationEmit || (exportedModulesFromDeclarationEmit = [])).push(symbol); + } + } + } + return input; + } + function transformImportEqualsDeclaration(decl) { + if (!resolver.isDeclarationVisible(decl)) + return; + if (decl.moduleReference.kind === 280 /* SyntaxKind.ExternalModuleReference */) { + // Rewrite external module names if necessary + var specifier = ts.getExternalModuleImportEqualsDeclarationExpression(decl); + return factory.updateImportEqualsDeclaration(decl, decl.modifiers, decl.isTypeOnly, decl.name, factory.updateExternalModuleReference(decl.moduleReference, rewriteModuleSpecifier(decl, specifier))); + } + else { + var oldDiag = getSymbolAccessibilityDiagnostic; + getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(decl); + checkEntityNameVisibility(decl.moduleReference, enclosingDeclaration); + getSymbolAccessibilityDiagnostic = oldDiag; + return decl; + } + } + function transformImportDeclaration(decl) { + if (!decl.importClause) { + // import "mod" - possibly needed for side effects? (global interface patches, module augmentations, etc) + return factory.updateImportDeclaration(decl, decl.modifiers, decl.importClause, rewriteModuleSpecifier(decl, decl.moduleSpecifier), getResolutionModeOverrideForClauseInNightly(decl.assertClause)); + } + // The `importClause` visibility corresponds to the default's visibility. + var visibleDefaultBinding = decl.importClause && decl.importClause.name && resolver.isDeclarationVisible(decl.importClause) ? decl.importClause.name : undefined; + if (!decl.importClause.namedBindings) { + // No named bindings (either namespace or list), meaning the import is just default or should be elided + return visibleDefaultBinding && factory.updateImportDeclaration(decl, decl.modifiers, factory.updateImportClause(decl.importClause, decl.importClause.isTypeOnly, visibleDefaultBinding, + /*namedBindings*/ undefined), rewriteModuleSpecifier(decl, decl.moduleSpecifier), getResolutionModeOverrideForClauseInNightly(decl.assertClause)); + } + if (decl.importClause.namedBindings.kind === 271 /* SyntaxKind.NamespaceImport */) { + // Namespace import (optionally with visible default) + var namedBindings = resolver.isDeclarationVisible(decl.importClause.namedBindings) ? decl.importClause.namedBindings : /*namedBindings*/ undefined; + return visibleDefaultBinding || namedBindings ? factory.updateImportDeclaration(decl, decl.modifiers, factory.updateImportClause(decl.importClause, decl.importClause.isTypeOnly, visibleDefaultBinding, namedBindings), rewriteModuleSpecifier(decl, decl.moduleSpecifier), getResolutionModeOverrideForClauseInNightly(decl.assertClause)) : undefined; + } + // Named imports (optionally with visible default) + var bindingList = ts.mapDefined(decl.importClause.namedBindings.elements, function (b) { return resolver.isDeclarationVisible(b) ? b : undefined; }); + if ((bindingList && bindingList.length) || visibleDefaultBinding) { + return factory.updateImportDeclaration(decl, decl.modifiers, factory.updateImportClause(decl.importClause, decl.importClause.isTypeOnly, visibleDefaultBinding, bindingList && bindingList.length ? factory.updateNamedImports(decl.importClause.namedBindings, bindingList) : undefined), rewriteModuleSpecifier(decl, decl.moduleSpecifier), getResolutionModeOverrideForClauseInNightly(decl.assertClause)); + } + // Augmentation of export depends on import + if (resolver.isImportRequiredByAugmentation(decl)) { + return factory.updateImportDeclaration(decl, decl.modifiers, + /*importClause*/ undefined, rewriteModuleSpecifier(decl, decl.moduleSpecifier), getResolutionModeOverrideForClauseInNightly(decl.assertClause)); + } + // Nothing visible + } + function getResolutionModeOverrideForClauseInNightly(assertClause) { + var mode = ts.getResolutionModeOverrideForClause(assertClause); + if (mode !== undefined) { + if (!ts.isNightly()) { + context.addDiagnostic(ts.createDiagnosticForNode(assertClause, ts.Diagnostics.resolution_mode_assertions_are_unstable_Use_nightly_TypeScript_to_silence_this_error_Try_updating_with_npm_install_D_typescript_next)); + } + return assertClause; + } + return undefined; + } + function transformAndReplaceLatePaintedStatements(statements) { + // This is a `while` loop because `handleSymbolAccessibilityError` can see additional import aliases marked as visible during + // error handling which must now be included in the output and themselves checked for errors. + // For example: + // ``` + // module A { + // export module Q {} + // import B = Q; + // import C = B; + // export import D = C; + // } + // ``` + // In such a scenario, only Q and D are initially visible, but we don't consider imports as private names - instead we say they if they are referenced they must + // be recorded. So while checking D's visibility we mark C as visible, then we must check C which in turn marks B, completing the chain of + // dependent imports and allowing a valid declaration file output. Today, this dependent alias marking only happens for internal import aliases. + while (ts.length(lateMarkedStatements)) { + var i = lateMarkedStatements.shift(); + if (!ts.isLateVisibilityPaintedStatement(i)) { + return ts.Debug.fail("Late replaced statement was found which is not handled by the declaration transformer!: ".concat(ts.Debug.formatSyntaxKind(i.kind))); + } + var priorNeedsDeclare = needsDeclare; + needsDeclare = i.parent && ts.isSourceFile(i.parent) && !(ts.isExternalModule(i.parent) && isBundledEmit); + var result = transformTopLevelDeclaration(i); + needsDeclare = priorNeedsDeclare; + lateStatementReplacementMap.set(ts.getOriginalNodeId(i), result); + } + // And lastly, we need to get the final form of all those indetermine import declarations from before and add them to the output list + // (and remove them from the set to examine for outter declarations) + return ts.visitNodes(statements, visitLateVisibilityMarkedStatements); + function visitLateVisibilityMarkedStatements(statement) { + if (ts.isLateVisibilityPaintedStatement(statement)) { + var key = ts.getOriginalNodeId(statement); + if (lateStatementReplacementMap.has(key)) { + var result = lateStatementReplacementMap.get(key); + lateStatementReplacementMap.delete(key); + if (result) { + if (ts.isArray(result) ? ts.some(result, ts.needsScopeMarker) : ts.needsScopeMarker(result)) { + // Top-level declarations in .d.ts files are always considered exported even without a modifier unless there's an export assignment or specifier + needsScopeFixMarker = true; + } + if (ts.isSourceFile(statement.parent) && (ts.isArray(result) ? ts.some(result, ts.isExternalModuleIndicator) : ts.isExternalModuleIndicator(result))) { + resultHasExternalModuleIndicator = true; + } + } + return result; + } + } + return statement; + } + } + function visitDeclarationSubtree(input) { + if (shouldStripInternal(input)) + return; + if (ts.isDeclaration(input)) { + if (isDeclarationAndNotVisible(input)) + return; + if (ts.hasDynamicName(input) && !resolver.isLateBound(ts.getParseTreeNode(input))) { + return; + } + } + // Elide implementation signatures from overload sets + if (ts.isFunctionLike(input) && resolver.isImplementationOfOverload(input)) + return; + // Elide semicolon class statements + if (ts.isSemicolonClassElement(input)) + return; + var previousEnclosingDeclaration; + if (isEnclosingDeclaration(input)) { + previousEnclosingDeclaration = enclosingDeclaration; + enclosingDeclaration = input; + } + var oldDiag = getSymbolAccessibilityDiagnostic; + // Setup diagnostic-related flags before first potential `cleanup` call, otherwise + // We'd see a TDZ violation at runtime + var canProduceDiagnostic = ts.canProduceDiagnostics(input); + var oldWithinObjectLiteralType = suppressNewDiagnosticContexts; + var shouldEnterSuppressNewDiagnosticsContextContext = ((input.kind === 184 /* SyntaxKind.TypeLiteral */ || input.kind === 197 /* SyntaxKind.MappedType */) && input.parent.kind !== 262 /* SyntaxKind.TypeAliasDeclaration */); + // Emit methods which are private as properties with no type information + if (ts.isMethodDeclaration(input) || ts.isMethodSignature(input)) { + if (ts.hasEffectiveModifier(input, 8 /* ModifierFlags.Private */)) { + if (input.symbol && input.symbol.declarations && input.symbol.declarations[0] !== input) + return; // Elide all but the first overload + return cleanup(factory.createPropertyDeclaration(ensureModifiers(input), input.name, /*questionToken*/ undefined, /*type*/ undefined, /*initializer*/ undefined)); + } + } + if (canProduceDiagnostic && !suppressNewDiagnosticContexts) { + getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(input); + } + if (ts.isTypeQueryNode(input)) { + checkEntityNameVisibility(input.exprName, enclosingDeclaration); + } + if (shouldEnterSuppressNewDiagnosticsContextContext) { + // We stop making new diagnostic contexts within object literal types. Unless it's an object type on the RHS of a type alias declaration. Then we do. + suppressNewDiagnosticContexts = true; + } + if (isProcessedComponent(input)) { + switch (input.kind) { + case 230 /* SyntaxKind.ExpressionWithTypeArguments */: { + if ((ts.isEntityName(input.expression) || ts.isEntityNameExpression(input.expression))) { + checkEntityNameVisibility(input.expression, enclosingDeclaration); + } + var node = ts.visitEachChild(input, visitDeclarationSubtree, context); + return cleanup(factory.updateExpressionWithTypeArguments(node, node.expression, node.typeArguments)); + } + case 180 /* SyntaxKind.TypeReference */: { + checkEntityNameVisibility(input.typeName, enclosingDeclaration); + var node = ts.visitEachChild(input, visitDeclarationSubtree, context); + return cleanup(factory.updateTypeReferenceNode(node, node.typeName, node.typeArguments)); + } + case 177 /* SyntaxKind.ConstructSignature */: + return cleanup(factory.updateConstructSignature(input, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), ensureType(input, input.type))); + case 173 /* SyntaxKind.Constructor */: { + // A constructor declaration may not have a type annotation + var ctor = factory.createConstructorDeclaration( + /*modifiers*/ ensureModifiers(input), updateParamsList(input, input.parameters, 0 /* ModifierFlags.None */), + /*body*/ undefined); + return cleanup(ctor); + } + case 171 /* SyntaxKind.MethodDeclaration */: { + if (ts.isPrivateIdentifier(input.name)) { + return cleanup(/*returnValue*/ undefined); + } + var sig = factory.createMethodDeclaration(ensureModifiers(input), + /*asteriskToken*/ undefined, input.name, input.questionToken, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), ensureType(input, input.type), + /*body*/ undefined); + return cleanup(sig); + } + case 174 /* SyntaxKind.GetAccessor */: { + if (ts.isPrivateIdentifier(input.name)) { + return cleanup(/*returnValue*/ undefined); + } + var accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input)); + return cleanup(factory.updateGetAccessorDeclaration(input, ensureModifiers(input), input.name, updateAccessorParamsList(input, ts.hasEffectiveModifier(input, 8 /* ModifierFlags.Private */)), ensureType(input, accessorType), + /*body*/ undefined)); + } + case 175 /* SyntaxKind.SetAccessor */: { + if (ts.isPrivateIdentifier(input.name)) { + return cleanup(/*returnValue*/ undefined); + } + return cleanup(factory.updateSetAccessorDeclaration(input, ensureModifiers(input), input.name, updateAccessorParamsList(input, ts.hasEffectiveModifier(input, 8 /* ModifierFlags.Private */)), + /*body*/ undefined)); + } + case 169 /* SyntaxKind.PropertyDeclaration */: + if (ts.isPrivateIdentifier(input.name)) { + return cleanup(/*returnValue*/ undefined); + } + return cleanup(factory.updatePropertyDeclaration(input, ensureModifiers(input), input.name, input.questionToken, ensureType(input, input.type), ensureNoInitializer(input))); + case 168 /* SyntaxKind.PropertySignature */: + if (ts.isPrivateIdentifier(input.name)) { + return cleanup(/*returnValue*/ undefined); + } + return cleanup(factory.updatePropertySignature(input, ensureModifiers(input), input.name, input.questionToken, ensureType(input, input.type))); + case 170 /* SyntaxKind.MethodSignature */: { + if (ts.isPrivateIdentifier(input.name)) { + return cleanup(/*returnValue*/ undefined); + } + return cleanup(factory.updateMethodSignature(input, ensureModifiers(input), input.name, input.questionToken, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), ensureType(input, input.type))); + } + case 176 /* SyntaxKind.CallSignature */: { + return cleanup(factory.updateCallSignature(input, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), ensureType(input, input.type))); + } + case 178 /* SyntaxKind.IndexSignature */: { + return cleanup(factory.updateIndexSignature(input, ensureModifiers(input), updateParamsList(input, input.parameters), ts.visitNode(input.type, visitDeclarationSubtree) || factory.createKeywordTypeNode(131 /* SyntaxKind.AnyKeyword */))); + } + case 257 /* SyntaxKind.VariableDeclaration */: { + if (ts.isBindingPattern(input.name)) { + return recreateBindingPattern(input.name); + } + shouldEnterSuppressNewDiagnosticsContextContext = true; + suppressNewDiagnosticContexts = true; // Variable declaration types also suppress new diagnostic contexts, provided the contexts wouldn't be made for binding pattern types + return cleanup(factory.updateVariableDeclaration(input, input.name, /*exclamationToken*/ undefined, ensureType(input, input.type), ensureNoInitializer(input))); + } + case 165 /* SyntaxKind.TypeParameter */: { + if (isPrivateMethodTypeParameter(input) && (input.default || input.constraint)) { + return cleanup(factory.updateTypeParameterDeclaration(input, input.modifiers, input.name, /*constraint*/ undefined, /*defaultType*/ undefined)); + } + return cleanup(ts.visitEachChild(input, visitDeclarationSubtree, context)); + } + case 191 /* SyntaxKind.ConditionalType */: { + // We have to process conditional types in a special way because for visibility purposes we need to push a new enclosingDeclaration + // just for the `infer` types in the true branch. It's an implicit declaration scope that only applies to _part_ of the type. + var checkType = ts.visitNode(input.checkType, visitDeclarationSubtree); + var extendsType = ts.visitNode(input.extendsType, visitDeclarationSubtree); + var oldEnclosingDecl = enclosingDeclaration; + enclosingDeclaration = input.trueType; + var trueType = ts.visitNode(input.trueType, visitDeclarationSubtree); + enclosingDeclaration = oldEnclosingDecl; + var falseType = ts.visitNode(input.falseType, visitDeclarationSubtree); + return cleanup(factory.updateConditionalTypeNode(input, checkType, extendsType, trueType, falseType)); + } + case 181 /* SyntaxKind.FunctionType */: { + return cleanup(factory.updateFunctionTypeNode(input, ts.visitNodes(input.typeParameters, visitDeclarationSubtree), updateParamsList(input, input.parameters), ts.visitNode(input.type, visitDeclarationSubtree))); + } + case 182 /* SyntaxKind.ConstructorType */: { + return cleanup(factory.updateConstructorTypeNode(input, ensureModifiers(input), ts.visitNodes(input.typeParameters, visitDeclarationSubtree), updateParamsList(input, input.parameters), ts.visitNode(input.type, visitDeclarationSubtree))); + } + case 202 /* SyntaxKind.ImportType */: { + if (!ts.isLiteralImportTypeNode(input)) + return cleanup(input); + return cleanup(factory.updateImportTypeNode(input, factory.updateLiteralTypeNode(input.argument, rewriteModuleSpecifier(input, input.argument.literal)), input.assertions, input.qualifier, ts.visitNodes(input.typeArguments, visitDeclarationSubtree, ts.isTypeNode), input.isTypeOf)); + } + default: ts.Debug.assertNever(input, "Attempted to process unhandled node kind: ".concat(ts.Debug.formatSyntaxKind(input.kind))); + } + } + if (ts.isTupleTypeNode(input) && (ts.getLineAndCharacterOfPosition(currentSourceFile, input.pos).line === ts.getLineAndCharacterOfPosition(currentSourceFile, input.end).line)) { + ts.setEmitFlags(input, 1 /* EmitFlags.SingleLine */); + } + return cleanup(ts.visitEachChild(input, visitDeclarationSubtree, context)); + function cleanup(returnValue) { + if (returnValue && canProduceDiagnostic && ts.hasDynamicName(input)) { + checkName(input); + } + if (isEnclosingDeclaration(input)) { + enclosingDeclaration = previousEnclosingDeclaration; + } + if (canProduceDiagnostic && !suppressNewDiagnosticContexts) { + getSymbolAccessibilityDiagnostic = oldDiag; + } + if (shouldEnterSuppressNewDiagnosticsContextContext) { + suppressNewDiagnosticContexts = oldWithinObjectLiteralType; + } + if (returnValue === input) { + return returnValue; + } + return returnValue && ts.setOriginalNode(preserveJsDoc(returnValue, input), input); + } + } + function isPrivateMethodTypeParameter(node) { + return node.parent.kind === 171 /* SyntaxKind.MethodDeclaration */ && ts.hasEffectiveModifier(node.parent, 8 /* ModifierFlags.Private */); + } + function visitDeclarationStatements(input) { + if (!isPreservedDeclarationStatement(input)) { + // return undefined for unmatched kinds to omit them from the tree + return; + } + if (shouldStripInternal(input)) + return; + switch (input.kind) { + case 275 /* SyntaxKind.ExportDeclaration */: { + if (ts.isSourceFile(input.parent)) { + resultHasExternalModuleIndicator = true; + } + resultHasScopeMarker = true; + // Always visible if the parent node isn't dropped for being not visible + // Rewrite external module names if necessary + return factory.updateExportDeclaration(input, input.modifiers, input.isTypeOnly, input.exportClause, rewriteModuleSpecifier(input, input.moduleSpecifier), ts.getResolutionModeOverrideForClause(input.assertClause) ? input.assertClause : undefined); + } + case 274 /* SyntaxKind.ExportAssignment */: { + // Always visible if the parent node isn't dropped for being not visible + if (ts.isSourceFile(input.parent)) { + resultHasExternalModuleIndicator = true; + } + resultHasScopeMarker = true; + if (input.expression.kind === 79 /* SyntaxKind.Identifier */) { + return input; + } + else { + var newId = factory.createUniqueName("_default", 16 /* GeneratedIdentifierFlags.Optimistic */); + getSymbolAccessibilityDiagnostic = function () { return ({ + diagnosticMessage: ts.Diagnostics.Default_export_of_the_module_has_or_is_using_private_name_0, + errorNode: input + }); }; + errorFallbackNode = input; + var varDecl = factory.createVariableDeclaration(newId, /*exclamationToken*/ undefined, resolver.createTypeOfExpression(input.expression, input, declarationEmitNodeBuilderFlags, symbolTracker), /*initializer*/ undefined); + errorFallbackNode = undefined; + var statement = factory.createVariableStatement(needsDeclare ? [factory.createModifier(136 /* SyntaxKind.DeclareKeyword */)] : [], factory.createVariableDeclarationList([varDecl], 2 /* NodeFlags.Const */)); + preserveJsDoc(statement, input); + ts.removeAllComments(input); + return [statement, factory.updateExportAssignment(input, input.modifiers, newId)]; + } + } + } + var result = transformTopLevelDeclaration(input); + // Don't actually transform yet; just leave as original node - will be elided/swapped by late pass + lateStatementReplacementMap.set(ts.getOriginalNodeId(input), result); + return input; + } + function stripExportModifiers(statement) { + if (ts.isImportEqualsDeclaration(statement) || ts.hasEffectiveModifier(statement, 1024 /* ModifierFlags.Default */) || !ts.canHaveModifiers(statement)) { + // `export import` statements should remain as-is, as imports are _not_ implicitly exported in an ambient namespace + // Likewise, `export default` classes and the like and just be `default`, so we preserve their `export` modifiers, too + return statement; + } + var modifiers = factory.createModifiersFromModifierFlags(ts.getEffectiveModifierFlags(statement) & (258047 /* ModifierFlags.All */ ^ 1 /* ModifierFlags.Export */)); + return factory.updateModifiers(statement, modifiers); + } + function transformTopLevelDeclaration(input) { + if (lateMarkedStatements) { + while (ts.orderedRemoveItem(lateMarkedStatements, input)) + ; + } + if (shouldStripInternal(input)) + return; + switch (input.kind) { + case 268 /* SyntaxKind.ImportEqualsDeclaration */: { + return transformImportEqualsDeclaration(input); + } + case 269 /* SyntaxKind.ImportDeclaration */: { + return transformImportDeclaration(input); + } + } + if (ts.isDeclaration(input) && isDeclarationAndNotVisible(input)) + return; + // Elide implementation signatures from overload sets + if (ts.isFunctionLike(input) && resolver.isImplementationOfOverload(input)) + return; + var previousEnclosingDeclaration; + if (isEnclosingDeclaration(input)) { + previousEnclosingDeclaration = enclosingDeclaration; + enclosingDeclaration = input; + } + var canProdiceDiagnostic = ts.canProduceDiagnostics(input); + var oldDiag = getSymbolAccessibilityDiagnostic; + if (canProdiceDiagnostic) { + getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(input); + } + var previousNeedsDeclare = needsDeclare; + switch (input.kind) { + case 262 /* SyntaxKind.TypeAliasDeclaration */: { + needsDeclare = false; + var clean = cleanup(factory.updateTypeAliasDeclaration(input, ensureModifiers(input), input.name, ts.visitNodes(input.typeParameters, visitDeclarationSubtree, ts.isTypeParameterDeclaration), ts.visitNode(input.type, visitDeclarationSubtree, ts.isTypeNode))); + needsDeclare = previousNeedsDeclare; + return clean; + } + case 261 /* SyntaxKind.InterfaceDeclaration */: { + return cleanup(factory.updateInterfaceDeclaration(input, ensureModifiers(input), input.name, ensureTypeParams(input, input.typeParameters), transformHeritageClauses(input.heritageClauses), ts.visitNodes(input.members, visitDeclarationSubtree))); + } + case 259 /* SyntaxKind.FunctionDeclaration */: { + // Generators lose their generator-ness, excepting their return type + var clean = cleanup(factory.updateFunctionDeclaration(input, ensureModifiers(input), + /*asteriskToken*/ undefined, input.name, ensureTypeParams(input, input.typeParameters), updateParamsList(input, input.parameters), ensureType(input, input.type), + /*body*/ undefined)); + if (clean && resolver.isExpandoFunctionDeclaration(input) && shouldEmitFunctionProperties(input)) { + var props = resolver.getPropertiesOfContainerFunction(input); + // Use parseNodeFactory so it is usable as an enclosing declaration + var fakespace_1 = ts.parseNodeFactory.createModuleDeclaration(/*modifiers*/ undefined, clean.name || factory.createIdentifier("_default"), factory.createModuleBlock([]), 16 /* NodeFlags.Namespace */); + ts.setParent(fakespace_1, enclosingDeclaration); + fakespace_1.locals = ts.createSymbolTable(props); + fakespace_1.symbol = props[0].parent; + var exportMappings_1 = []; + var declarations = ts.mapDefined(props, function (p) { + if (!p.valueDeclaration || !ts.isPropertyAccessExpression(p.valueDeclaration)) { + return undefined; // TODO GH#33569: Handle element access expressions that created late bound names (rather than silently omitting them) + } + getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(p.valueDeclaration); + var type = resolver.createTypeOfDeclaration(p.valueDeclaration, fakespace_1, declarationEmitNodeBuilderFlags, symbolTracker); + getSymbolAccessibilityDiagnostic = oldDiag; + var nameStr = ts.unescapeLeadingUnderscores(p.escapedName); + var isNonContextualKeywordName = ts.isStringANonContextualKeyword(nameStr); + var name = isNonContextualKeywordName ? factory.getGeneratedNameForNode(p.valueDeclaration) : factory.createIdentifier(nameStr); + if (isNonContextualKeywordName) { + exportMappings_1.push([name, nameStr]); + } + var varDecl = factory.createVariableDeclaration(name, /*exclamationToken*/ undefined, type, /*initializer*/ undefined); + return factory.createVariableStatement(isNonContextualKeywordName ? undefined : [factory.createToken(93 /* SyntaxKind.ExportKeyword */)], factory.createVariableDeclarationList([varDecl])); + }); + if (!exportMappings_1.length) { + declarations = ts.mapDefined(declarations, function (declaration) { return factory.updateModifiers(declaration, 0 /* ModifierFlags.None */); }); + } + else { + declarations.push(factory.createExportDeclaration( + /*modifiers*/ undefined, + /*isTypeOnly*/ false, factory.createNamedExports(ts.map(exportMappings_1, function (_a) { + var gen = _a[0], exp = _a[1]; + return factory.createExportSpecifier(/*isTypeOnly*/ false, gen, exp); + })))); + } + var namespaceDecl = factory.createModuleDeclaration(ensureModifiers(input), input.name, factory.createModuleBlock(declarations), 16 /* NodeFlags.Namespace */); + if (!ts.hasEffectiveModifier(clean, 1024 /* ModifierFlags.Default */)) { + return [clean, namespaceDecl]; + } + var modifiers = factory.createModifiersFromModifierFlags((ts.getEffectiveModifierFlags(clean) & ~1025 /* ModifierFlags.ExportDefault */) | 2 /* ModifierFlags.Ambient */); + var cleanDeclaration = factory.updateFunctionDeclaration(clean, modifiers, + /*asteriskToken*/ undefined, clean.name, clean.typeParameters, clean.parameters, clean.type, + /*body*/ undefined); + var namespaceDeclaration = factory.updateModuleDeclaration(namespaceDecl, modifiers, namespaceDecl.name, namespaceDecl.body); + var exportDefaultDeclaration = factory.createExportAssignment( + /*modifiers*/ undefined, + /*isExportEquals*/ false, namespaceDecl.name); + if (ts.isSourceFile(input.parent)) { + resultHasExternalModuleIndicator = true; + } + resultHasScopeMarker = true; + return [cleanDeclaration, namespaceDeclaration, exportDefaultDeclaration]; + } + else { + return clean; + } + } + case 264 /* SyntaxKind.ModuleDeclaration */: { + needsDeclare = false; + var inner = input.body; + if (inner && inner.kind === 265 /* SyntaxKind.ModuleBlock */) { + var oldNeedsScopeFix = needsScopeFixMarker; + var oldHasScopeFix = resultHasScopeMarker; + resultHasScopeMarker = false; + needsScopeFixMarker = false; + var statements = ts.visitNodes(inner.statements, visitDeclarationStatements); + var lateStatements = transformAndReplaceLatePaintedStatements(statements); + if (input.flags & 16777216 /* NodeFlags.Ambient */) { + needsScopeFixMarker = false; // If it was `declare`'d everything is implicitly exported already, ignore late printed "privates" + } + // With the final list of statements, there are 3 possibilities: + // 1. There's an export assignment or export declaration in the namespace - do nothing + // 2. Everything is exported and there are no export assignments or export declarations - strip all export modifiers + // 3. Some things are exported, some are not, and there's no marker - add an empty marker + if (!ts.isGlobalScopeAugmentation(input) && !hasScopeMarker(lateStatements) && !resultHasScopeMarker) { + if (needsScopeFixMarker) { + lateStatements = factory.createNodeArray(__spreadArray(__spreadArray([], lateStatements, true), [ts.createEmptyExports(factory)], false)); + } + else { + lateStatements = ts.visitNodes(lateStatements, stripExportModifiers); + } + } + var body = factory.updateModuleBlock(inner, lateStatements); + needsDeclare = previousNeedsDeclare; + needsScopeFixMarker = oldNeedsScopeFix; + resultHasScopeMarker = oldHasScopeFix; + var mods = ensureModifiers(input); + return cleanup(factory.updateModuleDeclaration(input, mods, ts.isExternalModuleAugmentation(input) ? rewriteModuleSpecifier(input, input.name) : input.name, body)); + } + else { + needsDeclare = previousNeedsDeclare; + var mods = ensureModifiers(input); + needsDeclare = false; + ts.visitNode(inner, visitDeclarationStatements); + // eagerly transform nested namespaces (the nesting doesn't need any elision or painting done) + var id = ts.getOriginalNodeId(inner); // TODO: GH#18217 + var body = lateStatementReplacementMap.get(id); + lateStatementReplacementMap.delete(id); + return cleanup(factory.updateModuleDeclaration(input, mods, input.name, body)); + } + } + case 260 /* SyntaxKind.ClassDeclaration */: { + errorNameNode = input.name; + errorFallbackNode = input; + var modifiers = factory.createNodeArray(ensureModifiers(input)); + var typeParameters = ensureTypeParams(input, input.typeParameters); + var ctor = ts.getFirstConstructorWithBody(input); + var parameterProperties = void 0; + if (ctor) { + var oldDiag_1 = getSymbolAccessibilityDiagnostic; + parameterProperties = ts.compact(ts.flatMap(ctor.parameters, function (param) { + if (!ts.hasSyntacticModifier(param, 16476 /* ModifierFlags.ParameterPropertyModifier */) || shouldStripInternal(param)) + return; + getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(param); + if (param.name.kind === 79 /* SyntaxKind.Identifier */) { + return preserveJsDoc(factory.createPropertyDeclaration(ensureModifiers(param), param.name, param.questionToken, ensureType(param, param.type), ensureNoInitializer(param)), param); + } + else { + // Pattern - this is currently an error, but we emit declarations for it somewhat correctly + return walkBindingPattern(param.name); + } + function walkBindingPattern(pattern) { + var elems; + for (var _i = 0, _a = pattern.elements; _i < _a.length; _i++) { + var elem = _a[_i]; + if (ts.isOmittedExpression(elem)) + continue; + if (ts.isBindingPattern(elem.name)) { + elems = ts.concatenate(elems, walkBindingPattern(elem.name)); + } + elems = elems || []; + elems.push(factory.createPropertyDeclaration(ensureModifiers(param), elem.name, + /*questionToken*/ undefined, ensureType(elem, /*type*/ undefined), + /*initializer*/ undefined)); + } + return elems; + } + })); + getSymbolAccessibilityDiagnostic = oldDiag_1; + } + var hasPrivateIdentifier = ts.some(input.members, function (member) { return !!member.name && ts.isPrivateIdentifier(member.name); }); + // When the class has at least one private identifier, create a unique constant identifier to retain the nominal typing behavior + // Prevents other classes with the same public members from being used in place of the current class + var privateIdentifier = hasPrivateIdentifier ? [ + factory.createPropertyDeclaration( + /*modifiers*/ undefined, factory.createPrivateIdentifier("#private"), + /*questionToken*/ undefined, + /*type*/ undefined, + /*initializer*/ undefined) + ] : undefined; + var memberNodes = ts.concatenate(ts.concatenate(privateIdentifier, parameterProperties), ts.visitNodes(input.members, visitDeclarationSubtree)); + var members = factory.createNodeArray(memberNodes); + var extendsClause_1 = ts.getEffectiveBaseTypeNode(input); + if (extendsClause_1 && !ts.isEntityNameExpression(extendsClause_1.expression) && extendsClause_1.expression.kind !== 104 /* SyntaxKind.NullKeyword */) { + // We must add a temporary declaration for the extends clause expression + var oldId = input.name ? ts.unescapeLeadingUnderscores(input.name.escapedText) : "default"; + var newId_1 = factory.createUniqueName("".concat(oldId, "_base"), 16 /* GeneratedIdentifierFlags.Optimistic */); + getSymbolAccessibilityDiagnostic = function () { return ({ + diagnosticMessage: ts.Diagnostics.extends_clause_of_exported_class_0_has_or_is_using_private_name_1, + errorNode: extendsClause_1, + typeName: input.name + }); }; + var varDecl = factory.createVariableDeclaration(newId_1, /*exclamationToken*/ undefined, resolver.createTypeOfExpression(extendsClause_1.expression, input, declarationEmitNodeBuilderFlags, symbolTracker), /*initializer*/ undefined); + var statement = factory.createVariableStatement(needsDeclare ? [factory.createModifier(136 /* SyntaxKind.DeclareKeyword */)] : [], factory.createVariableDeclarationList([varDecl], 2 /* NodeFlags.Const */)); + var heritageClauses = factory.createNodeArray(ts.map(input.heritageClauses, function (clause) { + if (clause.token === 94 /* SyntaxKind.ExtendsKeyword */) { + var oldDiag_2 = getSymbolAccessibilityDiagnostic; + getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(clause.types[0]); + var newClause = factory.updateHeritageClause(clause, ts.map(clause.types, function (t) { return factory.updateExpressionWithTypeArguments(t, newId_1, ts.visitNodes(t.typeArguments, visitDeclarationSubtree)); })); + getSymbolAccessibilityDiagnostic = oldDiag_2; + return newClause; + } + return factory.updateHeritageClause(clause, ts.visitNodes(factory.createNodeArray(ts.filter(clause.types, function (t) { return ts.isEntityNameExpression(t.expression) || t.expression.kind === 104 /* SyntaxKind.NullKeyword */; })), visitDeclarationSubtree)); + })); + return [statement, cleanup(factory.updateClassDeclaration(input, modifiers, input.name, typeParameters, heritageClauses, members))]; // TODO: GH#18217 + } + else { + var heritageClauses = transformHeritageClauses(input.heritageClauses); + return cleanup(factory.updateClassDeclaration(input, modifiers, input.name, typeParameters, heritageClauses, members)); + } + } + case 240 /* SyntaxKind.VariableStatement */: { + return cleanup(transformVariableStatement(input)); + } + case 263 /* SyntaxKind.EnumDeclaration */: { + return cleanup(factory.updateEnumDeclaration(input, factory.createNodeArray(ensureModifiers(input)), input.name, factory.createNodeArray(ts.mapDefined(input.members, function (m) { + if (shouldStripInternal(m)) + return; + // Rewrite enum values to their constants, if available + var constValue = resolver.getConstantValue(m); + return preserveJsDoc(factory.updateEnumMember(m, m.name, constValue !== undefined ? typeof constValue === "string" ? factory.createStringLiteral(constValue) : factory.createNumericLiteral(constValue) : undefined), m); + })))); + } + } + // Anything left unhandled is an error, so this should be unreachable + return ts.Debug.assertNever(input, "Unhandled top-level node in declaration emit: ".concat(ts.Debug.formatSyntaxKind(input.kind))); + function cleanup(node) { + if (isEnclosingDeclaration(input)) { + enclosingDeclaration = previousEnclosingDeclaration; + } + if (canProdiceDiagnostic) { + getSymbolAccessibilityDiagnostic = oldDiag; + } + if (input.kind === 264 /* SyntaxKind.ModuleDeclaration */) { + needsDeclare = previousNeedsDeclare; + } + if (node === input) { + return node; + } + errorFallbackNode = undefined; + errorNameNode = undefined; + return node && ts.setOriginalNode(preserveJsDoc(node, input), input); + } + } + function transformVariableStatement(input) { + if (!ts.forEach(input.declarationList.declarations, getBindingNameVisible)) + return; + var nodes = ts.visitNodes(input.declarationList.declarations, visitDeclarationSubtree); + if (!ts.length(nodes)) + return; + return factory.updateVariableStatement(input, factory.createNodeArray(ensureModifiers(input)), factory.updateVariableDeclarationList(input.declarationList, nodes)); + } + function recreateBindingPattern(d) { + return ts.flatten(ts.mapDefined(d.elements, function (e) { return recreateBindingElement(e); })); + } + function recreateBindingElement(e) { + if (e.kind === 229 /* SyntaxKind.OmittedExpression */) { + return; + } + if (e.name) { + if (!getBindingNameVisible(e)) + return; + if (ts.isBindingPattern(e.name)) { + return recreateBindingPattern(e.name); + } + else { + return factory.createVariableDeclaration(e.name, /*exclamationToken*/ undefined, ensureType(e, /*type*/ undefined), /*initializer*/ undefined); + } + } + } + function checkName(node) { + var oldDiag; + if (!suppressNewDiagnosticContexts) { + oldDiag = getSymbolAccessibilityDiagnostic; + getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNodeName(node); + } + errorNameNode = node.name; + ts.Debug.assert(resolver.isLateBound(ts.getParseTreeNode(node))); // Should only be called with dynamic names + var decl = node; + var entityName = decl.name.expression; + checkEntityNameVisibility(entityName, enclosingDeclaration); + if (!suppressNewDiagnosticContexts) { + getSymbolAccessibilityDiagnostic = oldDiag; + } + errorNameNode = undefined; + } + function shouldStripInternal(node) { + return !!stripInternal && !!node && isInternalDeclaration(node, currentSourceFile); + } + function isScopeMarker(node) { + return ts.isExportAssignment(node) || ts.isExportDeclaration(node); + } + function hasScopeMarker(statements) { + return ts.some(statements, isScopeMarker); + } + function ensureModifiers(node) { + var currentFlags = ts.getEffectiveModifierFlags(node); + var newFlags = ensureModifierFlags(node); + if (currentFlags === newFlags) { + return ts.visitArray(node.modifiers, function (n) { return ts.tryCast(n, ts.isModifier); }, ts.isModifier); + } + return factory.createModifiersFromModifierFlags(newFlags); + } + function ensureModifierFlags(node) { + var mask = 258047 /* ModifierFlags.All */ ^ (4 /* ModifierFlags.Public */ | 512 /* ModifierFlags.Async */ | 16384 /* ModifierFlags.Override */); // No async and override modifiers in declaration files + var additions = (needsDeclare && !isAlwaysType(node)) ? 2 /* ModifierFlags.Ambient */ : 0 /* ModifierFlags.None */; + var parentIsFile = node.parent.kind === 308 /* SyntaxKind.SourceFile */; + if (!parentIsFile || (isBundledEmit && parentIsFile && ts.isExternalModule(node.parent))) { + mask ^= 2 /* ModifierFlags.Ambient */; + additions = 0 /* ModifierFlags.None */; + } + return maskModifierFlags(node, mask, additions); + } + function getTypeAnnotationFromAllAccessorDeclarations(node, accessors) { + var accessorType = getTypeAnnotationFromAccessor(node); + if (!accessorType && node !== accessors.firstAccessor) { + accessorType = getTypeAnnotationFromAccessor(accessors.firstAccessor); + // If we end up pulling the type from the second accessor, we also need to change the diagnostic context to get the expected error message + getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(accessors.firstAccessor); + } + if (!accessorType && accessors.secondAccessor && node !== accessors.secondAccessor) { + accessorType = getTypeAnnotationFromAccessor(accessors.secondAccessor); + // If we end up pulling the type from the second accessor, we also need to change the diagnostic context to get the expected error message + getSymbolAccessibilityDiagnostic = ts.createGetSymbolAccessibilityDiagnosticForNode(accessors.secondAccessor); + } + return accessorType; + } + function transformHeritageClauses(nodes) { + return factory.createNodeArray(ts.filter(ts.map(nodes, function (clause) { return factory.updateHeritageClause(clause, ts.visitNodes(factory.createNodeArray(ts.filter(clause.types, function (t) { + return ts.isEntityNameExpression(t.expression) || (clause.token === 94 /* SyntaxKind.ExtendsKeyword */ && t.expression.kind === 104 /* SyntaxKind.NullKeyword */); + })), visitDeclarationSubtree)); }), function (clause) { return clause.types && !!clause.types.length; })); + } + } + ts.transformDeclarations = transformDeclarations; + function isAlwaysType(node) { + if (node.kind === 261 /* SyntaxKind.InterfaceDeclaration */) { + return true; + } + return false; + } + // Elide "public" modifier, as it is the default + function maskModifiers(node, modifierMask, modifierAdditions) { + return ts.factory.createModifiersFromModifierFlags(maskModifierFlags(node, modifierMask, modifierAdditions)); + } + function maskModifierFlags(node, modifierMask, modifierAdditions) { + if (modifierMask === void 0) { modifierMask = 258047 /* ModifierFlags.All */ ^ 4 /* ModifierFlags.Public */; } + if (modifierAdditions === void 0) { modifierAdditions = 0 /* ModifierFlags.None */; } + var flags = (ts.getEffectiveModifierFlags(node) & modifierMask) | modifierAdditions; + if (flags & 1024 /* ModifierFlags.Default */ && !(flags & 1 /* ModifierFlags.Export */)) { + // A non-exported default is a nonsequitor - we usually try to remove all export modifiers + // from statements in ambient declarations; but a default export must retain its export modifier to be syntactically valid + flags ^= 1 /* ModifierFlags.Export */; + } + if (flags & 1024 /* ModifierFlags.Default */ && flags & 2 /* ModifierFlags.Ambient */) { + flags ^= 2 /* ModifierFlags.Ambient */; // `declare` is never required alongside `default` (and would be an error if printed) + } + return flags; + } + function getTypeAnnotationFromAccessor(accessor) { + if (accessor) { + return accessor.kind === 174 /* SyntaxKind.GetAccessor */ + ? accessor.type // Getter - return type + : accessor.parameters.length > 0 + ? accessor.parameters[0].type // Setter parameter type + : undefined; + } + } + function canHaveLiteralInitializer(node) { + switch (node.kind) { + case 169 /* SyntaxKind.PropertyDeclaration */: + case 168 /* SyntaxKind.PropertySignature */: + return !ts.hasEffectiveModifier(node, 8 /* ModifierFlags.Private */); + case 166 /* SyntaxKind.Parameter */: + case 257 /* SyntaxKind.VariableDeclaration */: + return true; + } + return false; + } + function isPreservedDeclarationStatement(node) { + switch (node.kind) { + case 259 /* SyntaxKind.FunctionDeclaration */: + case 264 /* SyntaxKind.ModuleDeclaration */: + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 240 /* SyntaxKind.VariableStatement */: + case 269 /* SyntaxKind.ImportDeclaration */: + case 275 /* SyntaxKind.ExportDeclaration */: + case 274 /* SyntaxKind.ExportAssignment */: + return true; + } + return false; + } + function isProcessedComponent(node) { + switch (node.kind) { + case 177 /* SyntaxKind.ConstructSignature */: + case 173 /* SyntaxKind.Constructor */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 168 /* SyntaxKind.PropertySignature */: + case 170 /* SyntaxKind.MethodSignature */: + case 176 /* SyntaxKind.CallSignature */: + case 178 /* SyntaxKind.IndexSignature */: + case 257 /* SyntaxKind.VariableDeclaration */: + case 165 /* SyntaxKind.TypeParameter */: + case 230 /* SyntaxKind.ExpressionWithTypeArguments */: + case 180 /* SyntaxKind.TypeReference */: + case 191 /* SyntaxKind.ConditionalType */: + case 181 /* SyntaxKind.FunctionType */: + case 182 /* SyntaxKind.ConstructorType */: + case 202 /* SyntaxKind.ImportType */: + return true; + } + return false; + } +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + function getModuleTransformer(moduleKind) { + switch (moduleKind) { + case ts.ModuleKind.ESNext: + case ts.ModuleKind.ES2022: + case ts.ModuleKind.ES2020: + case ts.ModuleKind.ES2015: + return ts.transformECMAScriptModule; + case ts.ModuleKind.System: + return ts.transformSystemModule; + case ts.ModuleKind.Node16: + case ts.ModuleKind.NodeNext: + return ts.transformNodeModule; + default: + return ts.transformModule; + } + } + var TransformationState; + (function (TransformationState) { + TransformationState[TransformationState["Uninitialized"] = 0] = "Uninitialized"; + TransformationState[TransformationState["Initialized"] = 1] = "Initialized"; + TransformationState[TransformationState["Completed"] = 2] = "Completed"; + TransformationState[TransformationState["Disposed"] = 3] = "Disposed"; + })(TransformationState || (TransformationState = {})); + var SyntaxKindFeatureFlags; + (function (SyntaxKindFeatureFlags) { + SyntaxKindFeatureFlags[SyntaxKindFeatureFlags["Substitution"] = 1] = "Substitution"; + SyntaxKindFeatureFlags[SyntaxKindFeatureFlags["EmitNotifications"] = 2] = "EmitNotifications"; + })(SyntaxKindFeatureFlags || (SyntaxKindFeatureFlags = {})); + ts.noTransformers = { scriptTransformers: ts.emptyArray, declarationTransformers: ts.emptyArray }; + function getTransformers(compilerOptions, customTransformers, emitOnlyDtsFiles) { + return { + scriptTransformers: getScriptTransformers(compilerOptions, customTransformers, emitOnlyDtsFiles), + declarationTransformers: getDeclarationTransformers(customTransformers), + }; + } + ts.getTransformers = getTransformers; + function getScriptTransformers(compilerOptions, customTransformers, emitOnlyDtsFiles) { + if (emitOnlyDtsFiles) + return ts.emptyArray; + var languageVersion = ts.getEmitScriptTarget(compilerOptions); + var moduleKind = ts.getEmitModuleKind(compilerOptions); + var transformers = []; + ts.addRange(transformers, customTransformers && ts.map(customTransformers.before, wrapScriptTransformerFactory)); + transformers.push(ts.transformTypeScript); + transformers.push(ts.transformLegacyDecorators); + transformers.push(ts.transformClassFields); + if (ts.getJSXTransformEnabled(compilerOptions)) { + transformers.push(ts.transformJsx); + } + if (languageVersion < 99 /* ScriptTarget.ESNext */) { + transformers.push(ts.transformESNext); + } + if (languageVersion < 8 /* ScriptTarget.ES2021 */) { + transformers.push(ts.transformES2021); + } + if (languageVersion < 7 /* ScriptTarget.ES2020 */) { + transformers.push(ts.transformES2020); + } + if (languageVersion < 6 /* ScriptTarget.ES2019 */) { + transformers.push(ts.transformES2019); + } + if (languageVersion < 5 /* ScriptTarget.ES2018 */) { + transformers.push(ts.transformES2018); + } + if (languageVersion < 4 /* ScriptTarget.ES2017 */) { + transformers.push(ts.transformES2017); + } + if (languageVersion < 3 /* ScriptTarget.ES2016 */) { + transformers.push(ts.transformES2016); + } + if (languageVersion < 2 /* ScriptTarget.ES2015 */) { + transformers.push(ts.transformES2015); + transformers.push(ts.transformGenerators); + } + transformers.push(getModuleTransformer(moduleKind)); + // The ES5 transformer is last so that it can substitute expressions like `exports.default` + // for ES3. + if (languageVersion < 1 /* ScriptTarget.ES5 */) { + transformers.push(ts.transformES5); + } + ts.addRange(transformers, customTransformers && ts.map(customTransformers.after, wrapScriptTransformerFactory)); + return transformers; + } + function getDeclarationTransformers(customTransformers) { + var transformers = []; + transformers.push(ts.transformDeclarations); + ts.addRange(transformers, customTransformers && ts.map(customTransformers.afterDeclarations, wrapDeclarationTransformerFactory)); + return transformers; + } + /** + * Wrap a custom script or declaration transformer object in a `Transformer` callback with fallback support for transforming bundles. + */ + function wrapCustomTransformer(transformer) { + return function (node) { return ts.isBundle(node) ? transformer.transformBundle(node) : transformer.transformSourceFile(node); }; + } + /** + * Wrap a transformer factory that may return a custom script or declaration transformer object. + */ + function wrapCustomTransformerFactory(transformer, handleDefault) { + return function (context) { + var customTransformer = transformer(context); + return typeof customTransformer === "function" + ? handleDefault(context, customTransformer) + : wrapCustomTransformer(customTransformer); + }; + } + function wrapScriptTransformerFactory(transformer) { + return wrapCustomTransformerFactory(transformer, ts.chainBundle); + } + function wrapDeclarationTransformerFactory(transformer) { + return wrapCustomTransformerFactory(transformer, function (_, node) { return node; }); + } + function noEmitSubstitution(_hint, node) { + return node; + } + ts.noEmitSubstitution = noEmitSubstitution; + function noEmitNotification(hint, node, callback) { + callback(hint, node); + } + ts.noEmitNotification = noEmitNotification; + /** + * Transforms an array of SourceFiles by passing them through each transformer. + * + * @param resolver The emit resolver provided by the checker. + * @param host The emit host object used to interact with the file system. + * @param options Compiler options to surface in the `TransformationContext`. + * @param nodes An array of nodes to transform. + * @param transforms An array of `TransformerFactory` callbacks. + * @param allowDtsFiles A value indicating whether to allow the transformation of .d.ts files. + */ + function transformNodes(resolver, host, factory, options, nodes, transformers, allowDtsFiles) { + var enabledSyntaxKindFeatures = new Array(358 /* SyntaxKind.Count */); + var lexicalEnvironmentVariableDeclarations; + var lexicalEnvironmentFunctionDeclarations; + var lexicalEnvironmentStatements; + var lexicalEnvironmentFlags = 0 /* LexicalEnvironmentFlags.None */; + var lexicalEnvironmentVariableDeclarationsStack = []; + var lexicalEnvironmentFunctionDeclarationsStack = []; + var lexicalEnvironmentStatementsStack = []; + var lexicalEnvironmentFlagsStack = []; + var lexicalEnvironmentStackOffset = 0; + var lexicalEnvironmentSuspended = false; + var blockScopedVariableDeclarationsStack = []; + var blockScopeStackOffset = 0; + var blockScopedVariableDeclarations; + var emitHelpers; + var onSubstituteNode = noEmitSubstitution; + var onEmitNode = noEmitNotification; + var state = 0 /* TransformationState.Uninitialized */; + var diagnostics = []; + // The transformation context is provided to each transformer as part of transformer + // initialization. + var context = { + factory: factory, + getCompilerOptions: function () { return options; }, + getEmitResolver: function () { return resolver; }, + getEmitHost: function () { return host; }, + getEmitHelperFactory: ts.memoize(function () { return ts.createEmitHelperFactory(context); }), + startLexicalEnvironment: startLexicalEnvironment, + suspendLexicalEnvironment: suspendLexicalEnvironment, + resumeLexicalEnvironment: resumeLexicalEnvironment, + endLexicalEnvironment: endLexicalEnvironment, + setLexicalEnvironmentFlags: setLexicalEnvironmentFlags, + getLexicalEnvironmentFlags: getLexicalEnvironmentFlags, + hoistVariableDeclaration: hoistVariableDeclaration, + hoistFunctionDeclaration: hoistFunctionDeclaration, + addInitializationStatement: addInitializationStatement, + startBlockScope: startBlockScope, + endBlockScope: endBlockScope, + addBlockScopedVariable: addBlockScopedVariable, + requestEmitHelper: requestEmitHelper, + readEmitHelpers: readEmitHelpers, + enableSubstitution: enableSubstitution, + enableEmitNotification: enableEmitNotification, + isSubstitutionEnabled: isSubstitutionEnabled, + isEmitNotificationEnabled: isEmitNotificationEnabled, + get onSubstituteNode() { return onSubstituteNode; }, + set onSubstituteNode(value) { + ts.Debug.assert(state < 1 /* TransformationState.Initialized */, "Cannot modify transformation hooks after initialization has completed."); + ts.Debug.assert(value !== undefined, "Value must not be 'undefined'"); + onSubstituteNode = value; + }, + get onEmitNode() { return onEmitNode; }, + set onEmitNode(value) { + ts.Debug.assert(state < 1 /* TransformationState.Initialized */, "Cannot modify transformation hooks after initialization has completed."); + ts.Debug.assert(value !== undefined, "Value must not be 'undefined'"); + onEmitNode = value; + }, + addDiagnostic: function (diag) { + diagnostics.push(diag); + } + }; + // Ensure the parse tree is clean before applying transformations + for (var _i = 0, nodes_2 = nodes; _i < nodes_2.length; _i++) { + var node = nodes_2[_i]; + ts.disposeEmitNodes(ts.getSourceFileOfNode(ts.getParseTreeNode(node))); + } + ts.performance.mark("beforeTransform"); + // Chain together and initialize each transformer. + var transformersWithContext = transformers.map(function (t) { return t(context); }); + var transformation = function (node) { + for (var _i = 0, transformersWithContext_1 = transformersWithContext; _i < transformersWithContext_1.length; _i++) { + var transform = transformersWithContext_1[_i]; + node = transform(node); + } + return node; + }; + // prevent modification of transformation hooks. + state = 1 /* TransformationState.Initialized */; + // Transform each node. + var transformed = []; + for (var _a = 0, nodes_3 = nodes; _a < nodes_3.length; _a++) { + var node = nodes_3[_a]; + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("emit" /* tracing.Phase.Emit */, "transformNodes", node.kind === 308 /* SyntaxKind.SourceFile */ ? { path: node.path } : { kind: node.kind, pos: node.pos, end: node.end }); + transformed.push((allowDtsFiles ? transformation : transformRoot)(node)); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + } + // prevent modification of the lexical environment. + state = 2 /* TransformationState.Completed */; + ts.performance.mark("afterTransform"); + ts.performance.measure("transformTime", "beforeTransform", "afterTransform"); + return { + transformed: transformed, + substituteNode: substituteNode, + emitNodeWithNotification: emitNodeWithNotification, + isEmitNotificationEnabled: isEmitNotificationEnabled, + dispose: dispose, + diagnostics: diagnostics + }; + function transformRoot(node) { + return node && (!ts.isSourceFile(node) || !node.isDeclarationFile) ? transformation(node) : node; + } + /** + * Enables expression substitutions in the pretty printer for the provided SyntaxKind. + */ + function enableSubstitution(kind) { + ts.Debug.assert(state < 2 /* TransformationState.Completed */, "Cannot modify the transformation context after transformation has completed."); + enabledSyntaxKindFeatures[kind] |= 1 /* SyntaxKindFeatureFlags.Substitution */; + } + /** + * Determines whether expression substitutions are enabled for the provided node. + */ + function isSubstitutionEnabled(node) { + return (enabledSyntaxKindFeatures[node.kind] & 1 /* SyntaxKindFeatureFlags.Substitution */) !== 0 + && (ts.getEmitFlags(node) & 4 /* EmitFlags.NoSubstitution */) === 0; + } + /** + * Emits a node with possible substitution. + * + * @param hint A hint as to the intended usage of the node. + * @param node The node to emit. + * @param emitCallback The callback used to emit the node or its substitute. + */ + function substituteNode(hint, node) { + ts.Debug.assert(state < 3 /* TransformationState.Disposed */, "Cannot substitute a node after the result is disposed."); + return node && isSubstitutionEnabled(node) && onSubstituteNode(hint, node) || node; + } + /** + * Enables before/after emit notifications in the pretty printer for the provided SyntaxKind. + */ + function enableEmitNotification(kind) { + ts.Debug.assert(state < 2 /* TransformationState.Completed */, "Cannot modify the transformation context after transformation has completed."); + enabledSyntaxKindFeatures[kind] |= 2 /* SyntaxKindFeatureFlags.EmitNotifications */; + } + /** + * Determines whether before/after emit notifications should be raised in the pretty + * printer when it emits a node. + */ + function isEmitNotificationEnabled(node) { + return (enabledSyntaxKindFeatures[node.kind] & 2 /* SyntaxKindFeatureFlags.EmitNotifications */) !== 0 + || (ts.getEmitFlags(node) & 2 /* EmitFlags.AdviseOnEmitNode */) !== 0; + } + /** + * Emits a node with possible emit notification. + * + * @param hint A hint as to the intended usage of the node. + * @param node The node to emit. + * @param emitCallback The callback used to emit the node. + */ + function emitNodeWithNotification(hint, node, emitCallback) { + ts.Debug.assert(state < 3 /* TransformationState.Disposed */, "Cannot invoke TransformationResult callbacks after the result is disposed."); + if (node) { + // TODO: Remove check and unconditionally use onEmitNode when API is breakingly changed + // (see https://github.com/microsoft/TypeScript/pull/36248/files/5062623f39120171b98870c71344b3242eb03d23#r369766739) + if (isEmitNotificationEnabled(node)) { + onEmitNode(hint, node, emitCallback); + } + else { + emitCallback(hint, node); + } + } + } + /** + * Records a hoisted variable declaration for the provided name within a lexical environment. + */ + function hoistVariableDeclaration(name) { + ts.Debug.assert(state > 0 /* TransformationState.Uninitialized */, "Cannot modify the lexical environment during initialization."); + ts.Debug.assert(state < 2 /* TransformationState.Completed */, "Cannot modify the lexical environment after transformation has completed."); + var decl = ts.setEmitFlags(factory.createVariableDeclaration(name), 64 /* EmitFlags.NoNestedSourceMaps */); + if (!lexicalEnvironmentVariableDeclarations) { + lexicalEnvironmentVariableDeclarations = [decl]; + } + else { + lexicalEnvironmentVariableDeclarations.push(decl); + } + if (lexicalEnvironmentFlags & 1 /* LexicalEnvironmentFlags.InParameters */) { + lexicalEnvironmentFlags |= 2 /* LexicalEnvironmentFlags.VariablesHoistedInParameters */; + } + } + /** + * Records a hoisted function declaration within a lexical environment. + */ + function hoistFunctionDeclaration(func) { + ts.Debug.assert(state > 0 /* TransformationState.Uninitialized */, "Cannot modify the lexical environment during initialization."); + ts.Debug.assert(state < 2 /* TransformationState.Completed */, "Cannot modify the lexical environment after transformation has completed."); + ts.setEmitFlags(func, 1048576 /* EmitFlags.CustomPrologue */); + if (!lexicalEnvironmentFunctionDeclarations) { + lexicalEnvironmentFunctionDeclarations = [func]; + } + else { + lexicalEnvironmentFunctionDeclarations.push(func); + } + } + /** + * Adds an initialization statement to the top of the lexical environment. + */ + function addInitializationStatement(node) { + ts.Debug.assert(state > 0 /* TransformationState.Uninitialized */, "Cannot modify the lexical environment during initialization."); + ts.Debug.assert(state < 2 /* TransformationState.Completed */, "Cannot modify the lexical environment after transformation has completed."); + ts.setEmitFlags(node, 1048576 /* EmitFlags.CustomPrologue */); + if (!lexicalEnvironmentStatements) { + lexicalEnvironmentStatements = [node]; + } + else { + lexicalEnvironmentStatements.push(node); + } + } + /** + * Starts a new lexical environment. Any existing hoisted variable or function declarations + * are pushed onto a stack, and the related storage variables are reset. + */ + function startLexicalEnvironment() { + ts.Debug.assert(state > 0 /* TransformationState.Uninitialized */, "Cannot modify the lexical environment during initialization."); + ts.Debug.assert(state < 2 /* TransformationState.Completed */, "Cannot modify the lexical environment after transformation has completed."); + ts.Debug.assert(!lexicalEnvironmentSuspended, "Lexical environment is suspended."); + // Save the current lexical environment. Rather than resizing the array we adjust the + // stack size variable. This allows us to reuse existing array slots we've + // already allocated between transformations to avoid allocation and GC overhead during + // transformation. + lexicalEnvironmentVariableDeclarationsStack[lexicalEnvironmentStackOffset] = lexicalEnvironmentVariableDeclarations; + lexicalEnvironmentFunctionDeclarationsStack[lexicalEnvironmentStackOffset] = lexicalEnvironmentFunctionDeclarations; + lexicalEnvironmentStatementsStack[lexicalEnvironmentStackOffset] = lexicalEnvironmentStatements; + lexicalEnvironmentFlagsStack[lexicalEnvironmentStackOffset] = lexicalEnvironmentFlags; + lexicalEnvironmentStackOffset++; + lexicalEnvironmentVariableDeclarations = undefined; + lexicalEnvironmentFunctionDeclarations = undefined; + lexicalEnvironmentStatements = undefined; + lexicalEnvironmentFlags = 0 /* LexicalEnvironmentFlags.None */; + } + /** Suspends the current lexical environment, usually after visiting a parameter list. */ + function suspendLexicalEnvironment() { + ts.Debug.assert(state > 0 /* TransformationState.Uninitialized */, "Cannot modify the lexical environment during initialization."); + ts.Debug.assert(state < 2 /* TransformationState.Completed */, "Cannot modify the lexical environment after transformation has completed."); + ts.Debug.assert(!lexicalEnvironmentSuspended, "Lexical environment is already suspended."); + lexicalEnvironmentSuspended = true; + } + /** Resumes a suspended lexical environment, usually before visiting a function body. */ + function resumeLexicalEnvironment() { + ts.Debug.assert(state > 0 /* TransformationState.Uninitialized */, "Cannot modify the lexical environment during initialization."); + ts.Debug.assert(state < 2 /* TransformationState.Completed */, "Cannot modify the lexical environment after transformation has completed."); + ts.Debug.assert(lexicalEnvironmentSuspended, "Lexical environment is not suspended."); + lexicalEnvironmentSuspended = false; + } + /** + * Ends a lexical environment. The previous set of hoisted declarations are restored and + * any hoisted declarations added in this environment are returned. + */ + function endLexicalEnvironment() { + ts.Debug.assert(state > 0 /* TransformationState.Uninitialized */, "Cannot modify the lexical environment during initialization."); + ts.Debug.assert(state < 2 /* TransformationState.Completed */, "Cannot modify the lexical environment after transformation has completed."); + ts.Debug.assert(!lexicalEnvironmentSuspended, "Lexical environment is suspended."); + var statements; + if (lexicalEnvironmentVariableDeclarations || + lexicalEnvironmentFunctionDeclarations || + lexicalEnvironmentStatements) { + if (lexicalEnvironmentFunctionDeclarations) { + statements = __spreadArray([], lexicalEnvironmentFunctionDeclarations, true); + } + if (lexicalEnvironmentVariableDeclarations) { + var statement = factory.createVariableStatement( + /*modifiers*/ undefined, factory.createVariableDeclarationList(lexicalEnvironmentVariableDeclarations)); + ts.setEmitFlags(statement, 1048576 /* EmitFlags.CustomPrologue */); + if (!statements) { + statements = [statement]; + } + else { + statements.push(statement); + } + } + if (lexicalEnvironmentStatements) { + if (!statements) { + statements = __spreadArray([], lexicalEnvironmentStatements, true); + } + else { + statements = __spreadArray(__spreadArray([], statements, true), lexicalEnvironmentStatements, true); + } + } + } + // Restore the previous lexical environment. + lexicalEnvironmentStackOffset--; + lexicalEnvironmentVariableDeclarations = lexicalEnvironmentVariableDeclarationsStack[lexicalEnvironmentStackOffset]; + lexicalEnvironmentFunctionDeclarations = lexicalEnvironmentFunctionDeclarationsStack[lexicalEnvironmentStackOffset]; + lexicalEnvironmentStatements = lexicalEnvironmentStatementsStack[lexicalEnvironmentStackOffset]; + lexicalEnvironmentFlags = lexicalEnvironmentFlagsStack[lexicalEnvironmentStackOffset]; + if (lexicalEnvironmentStackOffset === 0) { + lexicalEnvironmentVariableDeclarationsStack = []; + lexicalEnvironmentFunctionDeclarationsStack = []; + lexicalEnvironmentStatementsStack = []; + lexicalEnvironmentFlagsStack = []; + } + return statements; + } + function setLexicalEnvironmentFlags(flags, value) { + lexicalEnvironmentFlags = value ? + lexicalEnvironmentFlags | flags : + lexicalEnvironmentFlags & ~flags; + } + function getLexicalEnvironmentFlags() { + return lexicalEnvironmentFlags; + } + /** + * Starts a block scope. Any existing block hoisted variables are pushed onto the stack and the related storage variables are reset. + */ + function startBlockScope() { + ts.Debug.assert(state > 0 /* TransformationState.Uninitialized */, "Cannot start a block scope during initialization."); + ts.Debug.assert(state < 2 /* TransformationState.Completed */, "Cannot start a block scope after transformation has completed."); + blockScopedVariableDeclarationsStack[blockScopeStackOffset] = blockScopedVariableDeclarations; + blockScopeStackOffset++; + blockScopedVariableDeclarations = undefined; + } + /** + * Ends a block scope. The previous set of block hoisted variables are restored. Any hoisted declarations are returned. + */ + function endBlockScope() { + ts.Debug.assert(state > 0 /* TransformationState.Uninitialized */, "Cannot end a block scope during initialization."); + ts.Debug.assert(state < 2 /* TransformationState.Completed */, "Cannot end a block scope after transformation has completed."); + var statements = ts.some(blockScopedVariableDeclarations) ? + [ + factory.createVariableStatement( + /*modifiers*/ undefined, factory.createVariableDeclarationList(blockScopedVariableDeclarations.map(function (identifier) { return factory.createVariableDeclaration(identifier); }), 1 /* NodeFlags.Let */)) + ] : undefined; + blockScopeStackOffset--; + blockScopedVariableDeclarations = blockScopedVariableDeclarationsStack[blockScopeStackOffset]; + if (blockScopeStackOffset === 0) { + blockScopedVariableDeclarationsStack = []; + } + return statements; + } + function addBlockScopedVariable(name) { + ts.Debug.assert(blockScopeStackOffset > 0, "Cannot add a block scoped variable outside of an iteration body."); + (blockScopedVariableDeclarations || (blockScopedVariableDeclarations = [])).push(name); + } + function requestEmitHelper(helper) { + ts.Debug.assert(state > 0 /* TransformationState.Uninitialized */, "Cannot modify the transformation context during initialization."); + ts.Debug.assert(state < 2 /* TransformationState.Completed */, "Cannot modify the transformation context after transformation has completed."); + ts.Debug.assert(!helper.scoped, "Cannot request a scoped emit helper."); + if (helper.dependencies) { + for (var _i = 0, _a = helper.dependencies; _i < _a.length; _i++) { + var h = _a[_i]; + requestEmitHelper(h); + } + } + emitHelpers = ts.append(emitHelpers, helper); + } + function readEmitHelpers() { + ts.Debug.assert(state > 0 /* TransformationState.Uninitialized */, "Cannot modify the transformation context during initialization."); + ts.Debug.assert(state < 2 /* TransformationState.Completed */, "Cannot modify the transformation context after transformation has completed."); + var helpers = emitHelpers; + emitHelpers = undefined; + return helpers; + } + function dispose() { + if (state < 3 /* TransformationState.Disposed */) { + // Clean up emit nodes on parse tree + for (var _i = 0, nodes_4 = nodes; _i < nodes_4.length; _i++) { + var node = nodes_4[_i]; + ts.disposeEmitNodes(ts.getSourceFileOfNode(ts.getParseTreeNode(node))); + } + // Release references to external entries for GC purposes. + lexicalEnvironmentVariableDeclarations = undefined; + lexicalEnvironmentVariableDeclarationsStack = undefined; + lexicalEnvironmentFunctionDeclarations = undefined; + lexicalEnvironmentFunctionDeclarationsStack = undefined; + onSubstituteNode = undefined; + onEmitNode = undefined; + emitHelpers = undefined; + // Prevent further use of the transformation result. + state = 3 /* TransformationState.Disposed */; + } + } + } + ts.transformNodes = transformNodes; + ts.nullTransformationContext = { + factory: ts.factory, + getCompilerOptions: function () { return ({}); }, + getEmitResolver: ts.notImplemented, + getEmitHost: ts.notImplemented, + getEmitHelperFactory: ts.notImplemented, + startLexicalEnvironment: ts.noop, + resumeLexicalEnvironment: ts.noop, + suspendLexicalEnvironment: ts.noop, + endLexicalEnvironment: ts.returnUndefined, + setLexicalEnvironmentFlags: ts.noop, + getLexicalEnvironmentFlags: function () { return 0; }, + hoistVariableDeclaration: ts.noop, + hoistFunctionDeclaration: ts.noop, + addInitializationStatement: ts.noop, + startBlockScope: ts.noop, + endBlockScope: ts.returnUndefined, + addBlockScopedVariable: ts.noop, + requestEmitHelper: ts.noop, + readEmitHelpers: ts.notImplemented, + enableSubstitution: ts.noop, + enableEmitNotification: ts.noop, + isSubstitutionEnabled: ts.notImplemented, + isEmitNotificationEnabled: ts.notImplemented, + onSubstituteNode: noEmitSubstitution, + onEmitNode: noEmitNotification, + addDiagnostic: ts.noop, + }; +})(ts || (ts = {})); +var ts; +(function (ts) { + var brackets = createBracketsMap(); + /*@internal*/ + function isBuildInfoFile(file) { + return ts.fileExtensionIs(file, ".tsbuildinfo" /* Extension.TsBuildInfo */); + } + ts.isBuildInfoFile = isBuildInfoFile; + /*@internal*/ + /** + * Iterates over the source files that are expected to have an emit output. + * + * @param host An EmitHost. + * @param action The action to execute. + * @param sourceFilesOrTargetSourceFile + * If an array, the full list of source files to emit. + * Else, calls `getSourceFilesToEmit` with the (optional) target source file to determine the list of source files to emit. + */ + function forEachEmittedFile(host, action, sourceFilesOrTargetSourceFile, forceDtsEmit, onlyBuildInfo, includeBuildInfo) { + if (forceDtsEmit === void 0) { forceDtsEmit = false; } + var sourceFiles = ts.isArray(sourceFilesOrTargetSourceFile) ? sourceFilesOrTargetSourceFile : ts.getSourceFilesToEmit(host, sourceFilesOrTargetSourceFile, forceDtsEmit); + var options = host.getCompilerOptions(); + if (ts.outFile(options)) { + var prepends = host.getPrependNodes(); + if (sourceFiles.length || prepends.length) { + var bundle = ts.factory.createBundle(sourceFiles, prepends); + var result = action(getOutputPathsFor(bundle, host, forceDtsEmit), bundle); + if (result) { + return result; + } + } + } + else { + if (!onlyBuildInfo) { + for (var _a = 0, sourceFiles_1 = sourceFiles; _a < sourceFiles_1.length; _a++) { + var sourceFile = sourceFiles_1[_a]; + var result = action(getOutputPathsFor(sourceFile, host, forceDtsEmit), sourceFile); + if (result) { + return result; + } + } + } + if (includeBuildInfo) { + var buildInfoPath = getTsBuildInfoEmitOutputFilePath(options); + if (buildInfoPath) + return action({ buildInfoPath: buildInfoPath }, /*sourceFileOrBundle*/ undefined); + } + } + } + ts.forEachEmittedFile = forEachEmittedFile; + function getTsBuildInfoEmitOutputFilePath(options) { + var configFile = options.configFilePath; + if (!ts.isIncrementalCompilation(options)) + return undefined; + if (options.tsBuildInfoFile) + return options.tsBuildInfoFile; + var outPath = ts.outFile(options); + var buildInfoExtensionLess; + if (outPath) { + buildInfoExtensionLess = ts.removeFileExtension(outPath); + } + else { + if (!configFile) + return undefined; + var configFileExtensionLess = ts.removeFileExtension(configFile); + buildInfoExtensionLess = options.outDir ? + options.rootDir ? + ts.resolvePath(options.outDir, ts.getRelativePathFromDirectory(options.rootDir, configFileExtensionLess, /*ignoreCase*/ true)) : + ts.combinePaths(options.outDir, ts.getBaseFileName(configFileExtensionLess)) : + configFileExtensionLess; + } + return buildInfoExtensionLess + ".tsbuildinfo" /* Extension.TsBuildInfo */; + } + ts.getTsBuildInfoEmitOutputFilePath = getTsBuildInfoEmitOutputFilePath; + /*@internal*/ + function getOutputPathsForBundle(options, forceDtsPaths) { + var outPath = ts.outFile(options); + var jsFilePath = options.emitDeclarationOnly ? undefined : outPath; + var sourceMapFilePath = jsFilePath && getSourceMapFilePath(jsFilePath, options); + var declarationFilePath = (forceDtsPaths || ts.getEmitDeclarations(options)) ? ts.removeFileExtension(outPath) + ".d.ts" /* Extension.Dts */ : undefined; + var declarationMapPath = declarationFilePath && ts.getAreDeclarationMapsEnabled(options) ? declarationFilePath + ".map" : undefined; + var buildInfoPath = getTsBuildInfoEmitOutputFilePath(options); + return { jsFilePath: jsFilePath, sourceMapFilePath: sourceMapFilePath, declarationFilePath: declarationFilePath, declarationMapPath: declarationMapPath, buildInfoPath: buildInfoPath }; + } + ts.getOutputPathsForBundle = getOutputPathsForBundle; + /*@internal*/ + function getOutputPathsFor(sourceFile, host, forceDtsPaths) { + var options = host.getCompilerOptions(); + if (sourceFile.kind === 309 /* SyntaxKind.Bundle */) { + return getOutputPathsForBundle(options, forceDtsPaths); + } + else { + var ownOutputFilePath = ts.getOwnEmitOutputFilePath(sourceFile.fileName, host, getOutputExtension(sourceFile.fileName, options)); + var isJsonFile = ts.isJsonSourceFile(sourceFile); + // If json file emits to the same location skip writing it, if emitDeclarationOnly skip writing it + var isJsonEmittedToSameLocation = isJsonFile && + ts.comparePaths(sourceFile.fileName, ownOutputFilePath, host.getCurrentDirectory(), !host.useCaseSensitiveFileNames()) === 0 /* Comparison.EqualTo */; + var jsFilePath = options.emitDeclarationOnly || isJsonEmittedToSameLocation ? undefined : ownOutputFilePath; + var sourceMapFilePath = !jsFilePath || ts.isJsonSourceFile(sourceFile) ? undefined : getSourceMapFilePath(jsFilePath, options); + var declarationFilePath = (forceDtsPaths || (ts.getEmitDeclarations(options) && !isJsonFile)) ? ts.getDeclarationEmitOutputFilePath(sourceFile.fileName, host) : undefined; + var declarationMapPath = declarationFilePath && ts.getAreDeclarationMapsEnabled(options) ? declarationFilePath + ".map" : undefined; + return { jsFilePath: jsFilePath, sourceMapFilePath: sourceMapFilePath, declarationFilePath: declarationFilePath, declarationMapPath: declarationMapPath, buildInfoPath: undefined }; + } + } + ts.getOutputPathsFor = getOutputPathsFor; + function getSourceMapFilePath(jsFilePath, options) { + return (options.sourceMap && !options.inlineSourceMap) ? jsFilePath + ".map" : undefined; + } + /* @internal */ + function getOutputExtension(fileName, options) { + return ts.fileExtensionIs(fileName, ".json" /* Extension.Json */) ? ".json" /* Extension.Json */ : + options.jsx === 1 /* JsxEmit.Preserve */ && ts.fileExtensionIsOneOf(fileName, [".jsx" /* Extension.Jsx */, ".tsx" /* Extension.Tsx */]) ? ".jsx" /* Extension.Jsx */ : + ts.fileExtensionIsOneOf(fileName, [".mts" /* Extension.Mts */, ".mjs" /* Extension.Mjs */]) ? ".mjs" /* Extension.Mjs */ : + ts.fileExtensionIsOneOf(fileName, [".cts" /* Extension.Cts */, ".cjs" /* Extension.Cjs */]) ? ".cjs" /* Extension.Cjs */ : + ".js" /* Extension.Js */; + } + ts.getOutputExtension = getOutputExtension; + function getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, outputDir, getCommonSourceDirectory) { + return outputDir ? + ts.resolvePath(outputDir, ts.getRelativePathFromDirectory(getCommonSourceDirectory ? getCommonSourceDirectory() : getCommonSourceDirectoryOfConfig(configFile, ignoreCase), inputFileName, ignoreCase)) : + inputFileName; + } + /* @internal */ + function getOutputDeclarationFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory) { + return ts.changeExtension(getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, configFile.options.declarationDir || configFile.options.outDir, getCommonSourceDirectory), ts.getDeclarationEmitExtensionForPath(inputFileName)); + } + ts.getOutputDeclarationFileName = getOutputDeclarationFileName; + function getOutputJSFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory) { + if (configFile.options.emitDeclarationOnly) + return undefined; + var isJsonFile = ts.fileExtensionIs(inputFileName, ".json" /* Extension.Json */); + var outputFileName = ts.changeExtension(getOutputPathWithoutChangingExt(inputFileName, configFile, ignoreCase, configFile.options.outDir, getCommonSourceDirectory), getOutputExtension(inputFileName, configFile.options)); + return !isJsonFile || ts.comparePaths(inputFileName, outputFileName, ts.Debug.checkDefined(configFile.options.configFilePath), ignoreCase) !== 0 /* Comparison.EqualTo */ ? + outputFileName : + undefined; + } + function createAddOutput() { + var outputs; + return { addOutput: addOutput, getOutputs: getOutputs }; + function addOutput(path) { + if (path) { + (outputs || (outputs = [])).push(path); + } + } + function getOutputs() { + return outputs || ts.emptyArray; + } + } + function getSingleOutputFileNames(configFile, addOutput) { + var _a = getOutputPathsForBundle(configFile.options, /*forceDtsPaths*/ false), jsFilePath = _a.jsFilePath, sourceMapFilePath = _a.sourceMapFilePath, declarationFilePath = _a.declarationFilePath, declarationMapPath = _a.declarationMapPath, buildInfoPath = _a.buildInfoPath; + addOutput(jsFilePath); + addOutput(sourceMapFilePath); + addOutput(declarationFilePath); + addOutput(declarationMapPath); + addOutput(buildInfoPath); + } + function getOwnOutputFileNames(configFile, inputFileName, ignoreCase, addOutput, getCommonSourceDirectory) { + if (ts.isDeclarationFileName(inputFileName)) + return; + var js = getOutputJSFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory); + addOutput(js); + if (ts.fileExtensionIs(inputFileName, ".json" /* Extension.Json */)) + return; + if (js && configFile.options.sourceMap) { + addOutput("".concat(js, ".map")); + } + if (ts.getEmitDeclarations(configFile.options)) { + var dts = getOutputDeclarationFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory); + addOutput(dts); + if (configFile.options.declarationMap) { + addOutput("".concat(dts, ".map")); + } + } + } + /*@internal*/ + function getCommonSourceDirectory(options, emittedFiles, currentDirectory, getCanonicalFileName, checkSourceFilesBelongToPath) { + var commonSourceDirectory; + if (options.rootDir) { + // If a rootDir is specified use it as the commonSourceDirectory + commonSourceDirectory = ts.getNormalizedAbsolutePath(options.rootDir, currentDirectory); + checkSourceFilesBelongToPath === null || checkSourceFilesBelongToPath === void 0 ? void 0 : checkSourceFilesBelongToPath(options.rootDir); + } + else if (options.composite && options.configFilePath) { + // Project compilations never infer their root from the input source paths + commonSourceDirectory = ts.getDirectoryPath(ts.normalizeSlashes(options.configFilePath)); + checkSourceFilesBelongToPath === null || checkSourceFilesBelongToPath === void 0 ? void 0 : checkSourceFilesBelongToPath(commonSourceDirectory); + } + else { + commonSourceDirectory = ts.computeCommonSourceDirectoryOfFilenames(emittedFiles(), currentDirectory, getCanonicalFileName); + } + if (commonSourceDirectory && commonSourceDirectory[commonSourceDirectory.length - 1] !== ts.directorySeparator) { + // Make sure directory path ends with directory separator so this string can directly + // used to replace with "" to get the relative path of the source file and the relative path doesn't + // start with / making it rooted path + commonSourceDirectory += ts.directorySeparator; + } + return commonSourceDirectory; + } + ts.getCommonSourceDirectory = getCommonSourceDirectory; + /*@internal*/ + function getCommonSourceDirectoryOfConfig(_a, ignoreCase) { + var options = _a.options, fileNames = _a.fileNames; + return getCommonSourceDirectory(options, function () { return ts.filter(fileNames, function (file) { return !(options.noEmitForJsFiles && ts.fileExtensionIsOneOf(file, ts.supportedJSExtensionsFlat)) && !ts.isDeclarationFileName(file); }); }, ts.getDirectoryPath(ts.normalizeSlashes(ts.Debug.checkDefined(options.configFilePath))), ts.createGetCanonicalFileName(!ignoreCase)); + } + ts.getCommonSourceDirectoryOfConfig = getCommonSourceDirectoryOfConfig; + /*@internal*/ + function getAllProjectOutputs(configFile, ignoreCase) { + var _a = createAddOutput(), addOutput = _a.addOutput, getOutputs = _a.getOutputs; + if (ts.outFile(configFile.options)) { + getSingleOutputFileNames(configFile, addOutput); + } + else { + var getCommonSourceDirectory_1 = ts.memoize(function () { return getCommonSourceDirectoryOfConfig(configFile, ignoreCase); }); + for (var _b = 0, _c = configFile.fileNames; _b < _c.length; _b++) { + var inputFileName = _c[_b]; + getOwnOutputFileNames(configFile, inputFileName, ignoreCase, addOutput, getCommonSourceDirectory_1); + } + addOutput(getTsBuildInfoEmitOutputFilePath(configFile.options)); + } + return getOutputs(); + } + ts.getAllProjectOutputs = getAllProjectOutputs; + function getOutputFileNames(commandLine, inputFileName, ignoreCase) { + inputFileName = ts.normalizePath(inputFileName); + ts.Debug.assert(ts.contains(commandLine.fileNames, inputFileName), "Expected fileName to be present in command line"); + var _a = createAddOutput(), addOutput = _a.addOutput, getOutputs = _a.getOutputs; + if (ts.outFile(commandLine.options)) { + getSingleOutputFileNames(commandLine, addOutput); + } + else { + getOwnOutputFileNames(commandLine, inputFileName, ignoreCase, addOutput); + } + return getOutputs(); + } + ts.getOutputFileNames = getOutputFileNames; + /*@internal*/ + function getFirstProjectOutput(configFile, ignoreCase) { + if (ts.outFile(configFile.options)) { + var jsFilePath = getOutputPathsForBundle(configFile.options, /*forceDtsPaths*/ false).jsFilePath; + return ts.Debug.checkDefined(jsFilePath, "project ".concat(configFile.options.configFilePath, " expected to have at least one output")); + } + var getCommonSourceDirectory = ts.memoize(function () { return getCommonSourceDirectoryOfConfig(configFile, ignoreCase); }); + for (var _a = 0, _b = configFile.fileNames; _a < _b.length; _a++) { + var inputFileName = _b[_a]; + if (ts.isDeclarationFileName(inputFileName)) + continue; + var jsFilePath = getOutputJSFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory); + if (jsFilePath) + return jsFilePath; + if (ts.fileExtensionIs(inputFileName, ".json" /* Extension.Json */)) + continue; + if (ts.getEmitDeclarations(configFile.options)) { + return getOutputDeclarationFileName(inputFileName, configFile, ignoreCase, getCommonSourceDirectory); + } + } + var buildInfoPath = getTsBuildInfoEmitOutputFilePath(configFile.options); + if (buildInfoPath) + return buildInfoPath; + return ts.Debug.fail("project ".concat(configFile.options.configFilePath, " expected to have at least one output")); + } + ts.getFirstProjectOutput = getFirstProjectOutput; + /*@internal*/ + // targetSourceFile is when users only want one file in entire project to be emitted. This is used in compileOnSave feature + function emitFiles(resolver, host, targetSourceFile, _a, emitOnlyDtsFiles, onlyBuildInfo, forceDtsEmit) { + var scriptTransformers = _a.scriptTransformers, declarationTransformers = _a.declarationTransformers; + var compilerOptions = host.getCompilerOptions(); + var sourceMapDataList = (compilerOptions.sourceMap || compilerOptions.inlineSourceMap || ts.getAreDeclarationMapsEnabled(compilerOptions)) ? [] : undefined; + var emittedFilesList = compilerOptions.listEmittedFiles ? [] : undefined; + var emitterDiagnostics = ts.createDiagnosticCollection(); + var newLine = ts.getNewLineCharacter(compilerOptions, function () { return host.getNewLine(); }); + var writer = ts.createTextWriter(newLine); + var _b = ts.performance.createTimer("printTime", "beforePrint", "afterPrint"), enter = _b.enter, exit = _b.exit; + var bundleBuildInfo; + var emitSkipped = false; + // Emit each output file + enter(); + forEachEmittedFile(host, emitSourceFileOrBundle, ts.getSourceFilesToEmit(host, targetSourceFile, forceDtsEmit), forceDtsEmit, onlyBuildInfo, !targetSourceFile); + exit(); + return { + emitSkipped: emitSkipped, + diagnostics: emitterDiagnostics.getDiagnostics(), + emittedFiles: emittedFilesList, + sourceMaps: sourceMapDataList, + }; + function emitSourceFileOrBundle(_a, sourceFileOrBundle) { + var jsFilePath = _a.jsFilePath, sourceMapFilePath = _a.sourceMapFilePath, declarationFilePath = _a.declarationFilePath, declarationMapPath = _a.declarationMapPath, buildInfoPath = _a.buildInfoPath; + var buildInfoDirectory; + if (buildInfoPath && sourceFileOrBundle && ts.isBundle(sourceFileOrBundle)) { + buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory())); + bundleBuildInfo = { + commonSourceDirectory: relativeToBuildInfo(host.getCommonSourceDirectory()), + sourceFiles: sourceFileOrBundle.sourceFiles.map(function (file) { return relativeToBuildInfo(ts.getNormalizedAbsolutePath(file.fileName, host.getCurrentDirectory())); }) + }; + } + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("emit" /* tracing.Phase.Emit */, "emitJsFileOrBundle", { jsFilePath: jsFilePath }); + emitJsFileOrBundle(sourceFileOrBundle, jsFilePath, sourceMapFilePath, relativeToBuildInfo); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("emit" /* tracing.Phase.Emit */, "emitDeclarationFileOrBundle", { declarationFilePath: declarationFilePath }); + emitDeclarationFileOrBundle(sourceFileOrBundle, declarationFilePath, declarationMapPath, relativeToBuildInfo); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("emit" /* tracing.Phase.Emit */, "emitBuildInfo", { buildInfoPath: buildInfoPath }); + emitBuildInfo(bundleBuildInfo, buildInfoPath); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + if (!emitSkipped && emittedFilesList) { + if (!emitOnlyDtsFiles) { + if (jsFilePath) { + emittedFilesList.push(jsFilePath); + } + if (sourceMapFilePath) { + emittedFilesList.push(sourceMapFilePath); + } + if (buildInfoPath) { + emittedFilesList.push(buildInfoPath); + } + } + if (declarationFilePath) { + emittedFilesList.push(declarationFilePath); + } + if (declarationMapPath) { + emittedFilesList.push(declarationMapPath); + } + } + function relativeToBuildInfo(path) { + return ts.ensurePathIsNonModuleName(ts.getRelativePathFromDirectory(buildInfoDirectory, path, host.getCanonicalFileName)); + } + } + function emitBuildInfo(bundle, buildInfoPath) { + // Write build information if applicable + if (!buildInfoPath || targetSourceFile || emitSkipped) + return; + var program = host.getProgramBuildInfo(); + if (host.isEmitBlocked(buildInfoPath)) { + emitSkipped = true; + return; + } + var version = ts.version; // Extracted into a const so the form is stable between namespace and module + var buildInfo = { bundle: bundle, program: program, version: version }; + // Pass buildinfo as additional data to avoid having to reparse + ts.writeFile(host, emitterDiagnostics, buildInfoPath, getBuildInfoText(buildInfo), /*writeByteOrderMark*/ false, /*sourceFiles*/ undefined, { buildInfo: buildInfo }); + } + function emitJsFileOrBundle(sourceFileOrBundle, jsFilePath, sourceMapFilePath, relativeToBuildInfo) { + if (!sourceFileOrBundle || emitOnlyDtsFiles || !jsFilePath) { + return; + } + // Make sure not to write js file and source map file if any of them cannot be written + if (host.isEmitBlocked(jsFilePath) || compilerOptions.noEmit) { + emitSkipped = true; + return; + } + // Transform the source files + var transform = ts.transformNodes(resolver, host, ts.factory, compilerOptions, [sourceFileOrBundle], scriptTransformers, /*allowDtsFiles*/ false); + var printerOptions = { + removeComments: compilerOptions.removeComments, + newLine: compilerOptions.newLine, + noEmitHelpers: compilerOptions.noEmitHelpers, + module: compilerOptions.module, + target: compilerOptions.target, + sourceMap: compilerOptions.sourceMap, + inlineSourceMap: compilerOptions.inlineSourceMap, + inlineSources: compilerOptions.inlineSources, + extendedDiagnostics: compilerOptions.extendedDiagnostics, + writeBundleFileInfo: !!bundleBuildInfo, + relativeToBuildInfo: relativeToBuildInfo + }; + // Create a printer to print the nodes + var printer = createPrinter(printerOptions, { + // resolver hooks + hasGlobalName: resolver.hasGlobalName, + // transform hooks + onEmitNode: transform.emitNodeWithNotification, + isEmitNotificationEnabled: transform.isEmitNotificationEnabled, + substituteNode: transform.substituteNode, + }); + ts.Debug.assert(transform.transformed.length === 1, "Should only see one output from the transform"); + printSourceFileOrBundle(jsFilePath, sourceMapFilePath, transform, printer, compilerOptions); + // Clean up emit nodes on parse tree + transform.dispose(); + if (bundleBuildInfo) + bundleBuildInfo.js = printer.bundleFileInfo; + } + function emitDeclarationFileOrBundle(sourceFileOrBundle, declarationFilePath, declarationMapPath, relativeToBuildInfo) { + if (!sourceFileOrBundle) + return; + if (!declarationFilePath) { + if (emitOnlyDtsFiles || compilerOptions.emitDeclarationOnly) + emitSkipped = true; + return; + } + var sourceFiles = ts.isSourceFile(sourceFileOrBundle) ? [sourceFileOrBundle] : sourceFileOrBundle.sourceFiles; + var filesForEmit = forceDtsEmit ? sourceFiles : ts.filter(sourceFiles, ts.isSourceFileNotJson); + // Setup and perform the transformation to retrieve declarations from the input files + var inputListOrBundle = ts.outFile(compilerOptions) ? [ts.factory.createBundle(filesForEmit, !ts.isSourceFile(sourceFileOrBundle) ? sourceFileOrBundle.prepends : undefined)] : filesForEmit; + if (emitOnlyDtsFiles && !ts.getEmitDeclarations(compilerOptions)) { + // Checker wont collect the linked aliases since thats only done when declaration is enabled. + // Do that here when emitting only dts files + filesForEmit.forEach(collectLinkedAliases); + } + var declarationTransform = ts.transformNodes(resolver, host, ts.factory, compilerOptions, inputListOrBundle, declarationTransformers, /*allowDtsFiles*/ false); + if (ts.length(declarationTransform.diagnostics)) { + for (var _a = 0, _b = declarationTransform.diagnostics; _a < _b.length; _a++) { + var diagnostic = _b[_a]; + emitterDiagnostics.add(diagnostic); + } + } + var printerOptions = { + removeComments: compilerOptions.removeComments, + newLine: compilerOptions.newLine, + noEmitHelpers: true, + module: compilerOptions.module, + target: compilerOptions.target, + sourceMap: !forceDtsEmit && compilerOptions.declarationMap, + inlineSourceMap: compilerOptions.inlineSourceMap, + extendedDiagnostics: compilerOptions.extendedDiagnostics, + onlyPrintJsDocStyle: true, + writeBundleFileInfo: !!bundleBuildInfo, + recordInternalSection: !!bundleBuildInfo, + relativeToBuildInfo: relativeToBuildInfo + }; + var declarationPrinter = createPrinter(printerOptions, { + // resolver hooks + hasGlobalName: resolver.hasGlobalName, + // transform hooks + onEmitNode: declarationTransform.emitNodeWithNotification, + isEmitNotificationEnabled: declarationTransform.isEmitNotificationEnabled, + substituteNode: declarationTransform.substituteNode, + }); + var declBlocked = (!!declarationTransform.diagnostics && !!declarationTransform.diagnostics.length) || !!host.isEmitBlocked(declarationFilePath) || !!compilerOptions.noEmit; + emitSkipped = emitSkipped || declBlocked; + if (!declBlocked || forceDtsEmit) { + ts.Debug.assert(declarationTransform.transformed.length === 1, "Should only see one output from the decl transform"); + printSourceFileOrBundle(declarationFilePath, declarationMapPath, declarationTransform, declarationPrinter, { + sourceMap: printerOptions.sourceMap, + sourceRoot: compilerOptions.sourceRoot, + mapRoot: compilerOptions.mapRoot, + extendedDiagnostics: compilerOptions.extendedDiagnostics, + // Explicitly do not passthru either `inline` option + }); + } + declarationTransform.dispose(); + if (bundleBuildInfo) + bundleBuildInfo.dts = declarationPrinter.bundleFileInfo; + } + function collectLinkedAliases(node) { + if (ts.isExportAssignment(node)) { + if (node.expression.kind === 79 /* SyntaxKind.Identifier */) { + resolver.collectLinkedAliases(node.expression, /*setVisibility*/ true); + } + return; + } + else if (ts.isExportSpecifier(node)) { + resolver.collectLinkedAliases(node.propertyName || node.name, /*setVisibility*/ true); + return; + } + ts.forEachChild(node, collectLinkedAliases); + } + function printSourceFileOrBundle(jsFilePath, sourceMapFilePath, transform, printer, mapOptions) { + var sourceFileOrBundle = transform.transformed[0]; + var bundle = sourceFileOrBundle.kind === 309 /* SyntaxKind.Bundle */ ? sourceFileOrBundle : undefined; + var sourceFile = sourceFileOrBundle.kind === 308 /* SyntaxKind.SourceFile */ ? sourceFileOrBundle : undefined; + var sourceFiles = bundle ? bundle.sourceFiles : [sourceFile]; + var sourceMapGenerator; + if (shouldEmitSourceMaps(mapOptions, sourceFileOrBundle)) { + sourceMapGenerator = ts.createSourceMapGenerator(host, ts.getBaseFileName(ts.normalizeSlashes(jsFilePath)), getSourceRoot(mapOptions), getSourceMapDirectory(mapOptions, jsFilePath, sourceFile), mapOptions); + } + if (bundle) { + printer.writeBundle(bundle, writer, sourceMapGenerator); + } + else { + printer.writeFile(sourceFile, writer, sourceMapGenerator); + } + var sourceMapUrlPos; + if (sourceMapGenerator) { + if (sourceMapDataList) { + sourceMapDataList.push({ + inputSourceFileNames: sourceMapGenerator.getSources(), + sourceMap: sourceMapGenerator.toJSON() + }); + } + var sourceMappingURL = getSourceMappingURL(mapOptions, sourceMapGenerator, jsFilePath, sourceMapFilePath, sourceFile); + if (sourceMappingURL) { + if (!writer.isAtStartOfLine()) + writer.rawWrite(newLine); + sourceMapUrlPos = writer.getTextPos(); + writer.writeComment("//# ".concat("sourceMappingURL", "=").concat(sourceMappingURL)); // Tools can sometimes see this line as a source mapping url comment + } + // Write the source map + if (sourceMapFilePath) { + var sourceMap = sourceMapGenerator.toString(); + ts.writeFile(host, emitterDiagnostics, sourceMapFilePath, sourceMap, /*writeByteOrderMark*/ false, sourceFiles); + if (printer.bundleFileInfo) + printer.bundleFileInfo.mapHash = ts.computeSignature(sourceMap, ts.maybeBind(host, host.createHash)); + } + } + else { + writer.writeLine(); + } + // Write the output file + var text = writer.getText(); + ts.writeFile(host, emitterDiagnostics, jsFilePath, text, !!compilerOptions.emitBOM, sourceFiles, { sourceMapUrlPos: sourceMapUrlPos, diagnostics: transform.diagnostics }); + // We store the hash of the text written in the buildinfo to ensure that text of the referenced d.ts file is same as whats in the buildinfo + // This is needed because incremental can be toggled between two runs and we might use stale file text to do text manipulation in prepend mode + if (printer.bundleFileInfo) + printer.bundleFileInfo.hash = ts.computeSignature(text, ts.maybeBind(host, host.createHash)); + // Reset state + writer.clear(); + } + function shouldEmitSourceMaps(mapOptions, sourceFileOrBundle) { + return (mapOptions.sourceMap || mapOptions.inlineSourceMap) + && (sourceFileOrBundle.kind !== 308 /* SyntaxKind.SourceFile */ || !ts.fileExtensionIs(sourceFileOrBundle.fileName, ".json" /* Extension.Json */)); + } + function getSourceRoot(mapOptions) { + // Normalize source root and make sure it has trailing "/" so that it can be used to combine paths with the + // relative paths of the sources list in the sourcemap + var sourceRoot = ts.normalizeSlashes(mapOptions.sourceRoot || ""); + return sourceRoot ? ts.ensureTrailingDirectorySeparator(sourceRoot) : sourceRoot; + } + function getSourceMapDirectory(mapOptions, filePath, sourceFile) { + if (mapOptions.sourceRoot) + return host.getCommonSourceDirectory(); + if (mapOptions.mapRoot) { + var sourceMapDir = ts.normalizeSlashes(mapOptions.mapRoot); + if (sourceFile) { + // For modules or multiple emit files the mapRoot will have directory structure like the sources + // So if src\a.ts and src\lib\b.ts are compiled together user would be moving the maps into mapRoot\a.js.map and mapRoot\lib\b.js.map + sourceMapDir = ts.getDirectoryPath(ts.getSourceFilePathInNewDir(sourceFile.fileName, host, sourceMapDir)); + } + if (ts.getRootLength(sourceMapDir) === 0) { + // The relative paths are relative to the common directory + sourceMapDir = ts.combinePaths(host.getCommonSourceDirectory(), sourceMapDir); + } + return sourceMapDir; + } + return ts.getDirectoryPath(ts.normalizePath(filePath)); + } + function getSourceMappingURL(mapOptions, sourceMapGenerator, filePath, sourceMapFilePath, sourceFile) { + if (mapOptions.inlineSourceMap) { + // Encode the sourceMap into the sourceMap url + var sourceMapText = sourceMapGenerator.toString(); + var base64SourceMapText = ts.base64encode(ts.sys, sourceMapText); + return "data:application/json;base64,".concat(base64SourceMapText); + } + var sourceMapFile = ts.getBaseFileName(ts.normalizeSlashes(ts.Debug.checkDefined(sourceMapFilePath))); + if (mapOptions.mapRoot) { + var sourceMapDir = ts.normalizeSlashes(mapOptions.mapRoot); + if (sourceFile) { + // For modules or multiple emit files the mapRoot will have directory structure like the sources + // So if src\a.ts and src\lib\b.ts are compiled together user would be moving the maps into mapRoot\a.js.map and mapRoot\lib\b.js.map + sourceMapDir = ts.getDirectoryPath(ts.getSourceFilePathInNewDir(sourceFile.fileName, host, sourceMapDir)); + } + if (ts.getRootLength(sourceMapDir) === 0) { + // The relative paths are relative to the common directory + sourceMapDir = ts.combinePaths(host.getCommonSourceDirectory(), sourceMapDir); + return encodeURI(ts.getRelativePathToDirectoryOrUrl(ts.getDirectoryPath(ts.normalizePath(filePath)), // get the relative sourceMapDir path based on jsFilePath + ts.combinePaths(sourceMapDir, sourceMapFile), // this is where user expects to see sourceMap + host.getCurrentDirectory(), host.getCanonicalFileName, + /*isAbsolutePathAnUrl*/ true)); + } + else { + return encodeURI(ts.combinePaths(sourceMapDir, sourceMapFile)); + } + } + return encodeURI(sourceMapFile); + } + } + ts.emitFiles = emitFiles; + /*@internal*/ + function getBuildInfoText(buildInfo) { + return JSON.stringify(buildInfo); + } + ts.getBuildInfoText = getBuildInfoText; + /*@internal*/ + function getBuildInfo(buildInfoFile, buildInfoText) { + return ts.readJsonOrUndefined(buildInfoFile, buildInfoText); + } + ts.getBuildInfo = getBuildInfo; + /*@internal*/ + ts.notImplementedResolver = { + hasGlobalName: ts.notImplemented, + getReferencedExportContainer: ts.notImplemented, + getReferencedImportDeclaration: ts.notImplemented, + getReferencedDeclarationWithCollidingName: ts.notImplemented, + isDeclarationWithCollidingName: ts.notImplemented, + isValueAliasDeclaration: ts.notImplemented, + isReferencedAliasDeclaration: ts.notImplemented, + isTopLevelValueImportEqualsWithEntityName: ts.notImplemented, + getNodeCheckFlags: ts.notImplemented, + isDeclarationVisible: ts.notImplemented, + isLateBound: function (_node) { return false; }, + collectLinkedAliases: ts.notImplemented, + isImplementationOfOverload: ts.notImplemented, + isRequiredInitializedParameter: ts.notImplemented, + isOptionalUninitializedParameterProperty: ts.notImplemented, + isExpandoFunctionDeclaration: ts.notImplemented, + getPropertiesOfContainerFunction: ts.notImplemented, + createTypeOfDeclaration: ts.notImplemented, + createReturnTypeOfSignatureDeclaration: ts.notImplemented, + createTypeOfExpression: ts.notImplemented, + createLiteralConstValue: ts.notImplemented, + isSymbolAccessible: ts.notImplemented, + isEntityNameVisible: ts.notImplemented, + // Returns the constant value this property access resolves to: notImplemented, or 'undefined' for a non-constant + getConstantValue: ts.notImplemented, + getReferencedValueDeclaration: ts.notImplemented, + getTypeReferenceSerializationKind: ts.notImplemented, + isOptionalParameter: ts.notImplemented, + moduleExportsSomeValue: ts.notImplemented, + isArgumentsLocalBinding: ts.notImplemented, + getExternalModuleFileFromDeclaration: ts.notImplemented, + getTypeReferenceDirectivesForEntityName: ts.notImplemented, + getTypeReferenceDirectivesForSymbol: ts.notImplemented, + isLiteralConstDeclaration: ts.notImplemented, + getJsxFactoryEntity: ts.notImplemented, + getJsxFragmentFactoryEntity: ts.notImplemented, + getAllAccessorDeclarations: ts.notImplemented, + getSymbolOfExternalModuleSpecifier: ts.notImplemented, + isBindingCapturedByNode: ts.notImplemented, + getDeclarationStatementsForSourceFile: ts.notImplemented, + isImportRequiredByAugmentation: ts.notImplemented, + }; + function createSourceFilesFromBundleBuildInfo(bundle, buildInfoDirectory, host) { + var _a; + var jsBundle = ts.Debug.checkDefined(bundle.js); + var prologueMap = ((_a = jsBundle.sources) === null || _a === void 0 ? void 0 : _a.prologues) && ts.arrayToMap(jsBundle.sources.prologues, function (prologueInfo) { return prologueInfo.file; }); + return bundle.sourceFiles.map(function (fileName, index) { + var _a, _b; + var prologueInfo = prologueMap === null || prologueMap === void 0 ? void 0 : prologueMap.get(index); + var statements = prologueInfo === null || prologueInfo === void 0 ? void 0 : prologueInfo.directives.map(function (directive) { + var literal = ts.setTextRange(ts.factory.createStringLiteral(directive.expression.text), directive.expression); + var statement = ts.setTextRange(ts.factory.createExpressionStatement(literal), directive); + ts.setParent(literal, statement); + return statement; + }); + var eofToken = ts.factory.createToken(1 /* SyntaxKind.EndOfFileToken */); + var sourceFile = ts.factory.createSourceFile(statements !== null && statements !== void 0 ? statements : [], eofToken, 0 /* NodeFlags.None */); + sourceFile.fileName = ts.getRelativePathFromDirectory(host.getCurrentDirectory(), ts.getNormalizedAbsolutePath(fileName, buildInfoDirectory), !host.useCaseSensitiveFileNames()); + sourceFile.text = (_a = prologueInfo === null || prologueInfo === void 0 ? void 0 : prologueInfo.text) !== null && _a !== void 0 ? _a : ""; + ts.setTextRangePosWidth(sourceFile, 0, (_b = prologueInfo === null || prologueInfo === void 0 ? void 0 : prologueInfo.text.length) !== null && _b !== void 0 ? _b : 0); + ts.setEachParent(sourceFile.statements, sourceFile); + ts.setTextRangePosWidth(eofToken, sourceFile.end, 0); + ts.setParent(eofToken, sourceFile); + return sourceFile; + }); + } + /*@internal*/ + function emitUsingBuildInfo(config, host, getCommandLine, customTransformers) { + var createHash = ts.maybeBind(host, host.createHash); + var _a = getOutputPathsForBundle(config.options, /*forceDtsPaths*/ false), buildInfoPath = _a.buildInfoPath, jsFilePath = _a.jsFilePath, sourceMapFilePath = _a.sourceMapFilePath, declarationFilePath = _a.declarationFilePath, declarationMapPath = _a.declarationMapPath; + var buildInfo; + if (host.getBuildInfo) { + // If host directly provides buildinfo we can get it directly. This allows host to cache the buildinfo + buildInfo = host.getBuildInfo(buildInfoPath, config.options.configFilePath); + } + else { + var buildInfoText = host.readFile(buildInfoPath); + if (!buildInfoText) + return buildInfoPath; + buildInfo = getBuildInfo(buildInfoPath, buildInfoText); + } + if (!buildInfo) + return buildInfoPath; + if (!buildInfo.bundle || !buildInfo.bundle.js || (declarationFilePath && !buildInfo.bundle.dts)) + return buildInfoPath; + var jsFileText = host.readFile(ts.Debug.checkDefined(jsFilePath)); + if (!jsFileText) + return jsFilePath; + // If the jsFileText is not same has what it was created with, tsbuildinfo is stale so dont use it + if (ts.computeSignature(jsFileText, createHash) !== buildInfo.bundle.js.hash) + return jsFilePath; + var sourceMapText = sourceMapFilePath && host.readFile(sourceMapFilePath); + // error if no source map or for now if inline sourcemap + if ((sourceMapFilePath && !sourceMapText) || config.options.inlineSourceMap) + return sourceMapFilePath || "inline sourcemap decoding"; + if (sourceMapFilePath && ts.computeSignature(sourceMapText, createHash) !== buildInfo.bundle.js.mapHash) + return sourceMapFilePath; + // read declaration text + var declarationText = declarationFilePath && host.readFile(declarationFilePath); + if (declarationFilePath && !declarationText) + return declarationFilePath; + if (declarationFilePath && ts.computeSignature(declarationText, createHash) !== buildInfo.bundle.dts.hash) + return declarationFilePath; + var declarationMapText = declarationMapPath && host.readFile(declarationMapPath); + // error if no source map or for now if inline sourcemap + if ((declarationMapPath && !declarationMapText) || config.options.inlineSourceMap) + return declarationMapPath || "inline sourcemap decoding"; + if (declarationMapPath && ts.computeSignature(declarationMapText, createHash) !== buildInfo.bundle.dts.mapHash) + return declarationMapPath; + var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory())); + var ownPrependInput = ts.createInputFiles(jsFileText, declarationText, sourceMapFilePath, sourceMapText, declarationMapPath, declarationMapText, jsFilePath, declarationFilePath, buildInfoPath, buildInfo, + /*onlyOwnText*/ true); + var outputFiles = []; + var prependNodes = ts.createPrependNodes(config.projectReferences, getCommandLine, function (f) { return host.readFile(f); }); + var sourceFilesForJsEmit = createSourceFilesFromBundleBuildInfo(buildInfo.bundle, buildInfoDirectory, host); + var changedDtsText; + var changedDtsData; + var emitHost = { + getPrependNodes: ts.memoize(function () { return __spreadArray(__spreadArray([], prependNodes, true), [ownPrependInput], false); }), + getCanonicalFileName: host.getCanonicalFileName, + getCommonSourceDirectory: function () { return ts.getNormalizedAbsolutePath(buildInfo.bundle.commonSourceDirectory, buildInfoDirectory); }, + getCompilerOptions: function () { return config.options; }, + getCurrentDirectory: function () { return host.getCurrentDirectory(); }, + getNewLine: function () { return host.getNewLine(); }, + getSourceFile: ts.returnUndefined, + getSourceFileByPath: ts.returnUndefined, + getSourceFiles: function () { return sourceFilesForJsEmit; }, + getLibFileFromReference: ts.notImplemented, + isSourceFileFromExternalLibrary: ts.returnFalse, + getResolvedProjectReferenceToRedirect: ts.returnUndefined, + getProjectReferenceRedirect: ts.returnUndefined, + isSourceOfProjectReferenceRedirect: ts.returnFalse, + writeFile: function (name, text, writeByteOrderMark, _onError, _sourceFiles, data) { + switch (name) { + case jsFilePath: + if (jsFileText === text) + return; + break; + case sourceMapFilePath: + if (sourceMapText === text) + return; + break; + case buildInfoPath: + var newBuildInfo = data.buildInfo; + newBuildInfo.program = buildInfo.program; + if (newBuildInfo.program && changedDtsText !== undefined && config.options.composite) { + // Update the output signature + newBuildInfo.program.outSignature = ts.computeSignature(changedDtsText, createHash, changedDtsData); + } + // Update sourceFileInfo + var _a = buildInfo.bundle, js = _a.js, dts = _a.dts, sourceFiles = _a.sourceFiles; + newBuildInfo.bundle.js.sources = js.sources; + if (dts) { + newBuildInfo.bundle.dts.sources = dts.sources; + } + newBuildInfo.bundle.sourceFiles = sourceFiles; + outputFiles.push({ name: name, text: getBuildInfoText(newBuildInfo), writeByteOrderMark: writeByteOrderMark, buildInfo: newBuildInfo }); + return; + case declarationFilePath: + if (declarationText === text) + return; + changedDtsText = text; + changedDtsData = data; + break; + case declarationMapPath: + if (declarationMapText === text) + return; + break; + default: + ts.Debug.fail("Unexpected path: ".concat(name)); + } + outputFiles.push({ name: name, text: text, writeByteOrderMark: writeByteOrderMark }); + }, + isEmitBlocked: ts.returnFalse, + readFile: function (f) { return host.readFile(f); }, + fileExists: function (f) { return host.fileExists(f); }, + useCaseSensitiveFileNames: function () { return host.useCaseSensitiveFileNames(); }, + getProgramBuildInfo: ts.returnUndefined, + getSourceFileFromReference: ts.returnUndefined, + redirectTargetsMap: ts.createMultiMap(), + getFileIncludeReasons: ts.notImplemented, + createHash: createHash, + }; + emitFiles(ts.notImplementedResolver, emitHost, + /*targetSourceFile*/ undefined, ts.getTransformers(config.options, customTransformers)); + return outputFiles; + } + ts.emitUsingBuildInfo = emitUsingBuildInfo; + var PipelinePhase; + (function (PipelinePhase) { + PipelinePhase[PipelinePhase["Notification"] = 0] = "Notification"; + PipelinePhase[PipelinePhase["Substitution"] = 1] = "Substitution"; + PipelinePhase[PipelinePhase["Comments"] = 2] = "Comments"; + PipelinePhase[PipelinePhase["SourceMaps"] = 3] = "SourceMaps"; + PipelinePhase[PipelinePhase["Emit"] = 4] = "Emit"; + })(PipelinePhase || (PipelinePhase = {})); + function createPrinter(printerOptions, handlers) { + if (printerOptions === void 0) { printerOptions = {}; } + if (handlers === void 0) { handlers = {}; } + var hasGlobalName = handlers.hasGlobalName, _a = handlers.onEmitNode, onEmitNode = _a === void 0 ? ts.noEmitNotification : _a, isEmitNotificationEnabled = handlers.isEmitNotificationEnabled, _b = handlers.substituteNode, substituteNode = _b === void 0 ? ts.noEmitSubstitution : _b, onBeforeEmitNode = handlers.onBeforeEmitNode, onAfterEmitNode = handlers.onAfterEmitNode, onBeforeEmitNodeArray = handlers.onBeforeEmitNodeArray, onAfterEmitNodeArray = handlers.onAfterEmitNodeArray, onBeforeEmitToken = handlers.onBeforeEmitToken, onAfterEmitToken = handlers.onAfterEmitToken; + var extendedDiagnostics = !!printerOptions.extendedDiagnostics; + var newLine = ts.getNewLineCharacter(printerOptions); + var moduleKind = ts.getEmitModuleKind(printerOptions); + var bundledHelpers = new ts.Map(); + var currentSourceFile; + var nodeIdToGeneratedName; // Map of generated names for specific nodes. + var autoGeneratedIdToGeneratedName; // Map of generated names for temp and loop variables. + var generatedNames; // Set of names generated by the NameGenerator. + var formattedNameTempFlagsStack; + var formattedNameTempFlags; + var privateNameTempFlagsStack; // Stack of enclosing name generation scopes. + var privateNameTempFlags; // TempFlags for the current name generation scope. + var tempFlagsStack; // Stack of enclosing name generation scopes. + var tempFlags; // TempFlags for the current name generation scope. + var reservedNamesStack; // Stack of TempFlags reserved in enclosing name generation scopes. + var reservedNames; // TempFlags to reserve in nested name generation scopes. + var preserveSourceNewlines = printerOptions.preserveSourceNewlines; // Can be overridden inside nodes with the `IgnoreSourceNewlines` emit flag. + var nextListElementPos; // See comment in `getLeadingLineTerminatorCount`. + var writer; + var ownWriter; // Reusable `EmitTextWriter` for basic printing. + var write = writeBase; + var isOwnFileEmit; + var bundleFileInfo = printerOptions.writeBundleFileInfo ? { sections: [] } : undefined; + var relativeToBuildInfo = bundleFileInfo ? ts.Debug.checkDefined(printerOptions.relativeToBuildInfo) : undefined; + var recordInternalSection = printerOptions.recordInternalSection; + var sourceFileTextPos = 0; + var sourceFileTextKind = "text" /* BundleFileSectionKind.Text */; + // Source Maps + var sourceMapsDisabled = true; + var sourceMapGenerator; + var sourceMapSource; + var sourceMapSourceIndex = -1; + var mostRecentlyAddedSourceMapSource; + var mostRecentlyAddedSourceMapSourceIndex = -1; + // Comments + var containerPos = -1; + var containerEnd = -1; + var declarationListContainerEnd = -1; + var currentLineMap; + var detachedCommentsInfo; + var hasWrittenComment = false; + var commentsDisabled = !!printerOptions.removeComments; + var lastSubstitution; + var currentParenthesizerRule; + var _c = ts.performance.createTimerIf(extendedDiagnostics, "commentTime", "beforeComment", "afterComment"), enterComment = _c.enter, exitComment = _c.exit; + var parenthesizer = ts.factory.parenthesizer; + var typeArgumentParenthesizerRuleSelector = { + select: function (index) { return index === 0 ? parenthesizer.parenthesizeLeadingTypeArgument : undefined; } + }; + var emitBinaryExpression = createEmitBinaryExpression(); + reset(); + return { + // public API + printNode: printNode, + printList: printList, + printFile: printFile, + printBundle: printBundle, + // internal API + writeNode: writeNode, + writeList: writeList, + writeFile: writeFile, + writeBundle: writeBundle, + bundleFileInfo: bundleFileInfo + }; + function printNode(hint, node, sourceFile) { + switch (hint) { + case 0 /* EmitHint.SourceFile */: + ts.Debug.assert(ts.isSourceFile(node), "Expected a SourceFile node."); + break; + case 2 /* EmitHint.IdentifierName */: + ts.Debug.assert(ts.isIdentifier(node), "Expected an Identifier node."); + break; + case 1 /* EmitHint.Expression */: + ts.Debug.assert(ts.isExpression(node), "Expected an Expression node."); + break; + } + switch (node.kind) { + case 308 /* SyntaxKind.SourceFile */: return printFile(node); + case 309 /* SyntaxKind.Bundle */: return printBundle(node); + case 310 /* SyntaxKind.UnparsedSource */: return printUnparsedSource(node); + } + writeNode(hint, node, sourceFile, beginPrint()); + return endPrint(); + } + function printList(format, nodes, sourceFile) { + writeList(format, nodes, sourceFile, beginPrint()); + return endPrint(); + } + function printBundle(bundle) { + writeBundle(bundle, beginPrint(), /*sourceMapEmitter*/ undefined); + return endPrint(); + } + function printFile(sourceFile) { + writeFile(sourceFile, beginPrint(), /*sourceMapEmitter*/ undefined); + return endPrint(); + } + function printUnparsedSource(unparsed) { + writeUnparsedSource(unparsed, beginPrint()); + return endPrint(); + } + function writeNode(hint, node, sourceFile, output) { + var previousWriter = writer; + setWriter(output, /*_sourceMapGenerator*/ undefined); + print(hint, node, sourceFile); + reset(); + writer = previousWriter; + } + function writeList(format, nodes, sourceFile, output) { + var previousWriter = writer; + setWriter(output, /*_sourceMapGenerator*/ undefined); + if (sourceFile) { + setSourceFile(sourceFile); + } + emitList(/*parentNode*/ undefined, nodes, format); + reset(); + writer = previousWriter; + } + function getTextPosWithWriteLine() { + return writer.getTextPosWithWriteLine ? writer.getTextPosWithWriteLine() : writer.getTextPos(); + } + function updateOrPushBundleFileTextLike(pos, end, kind) { + var last = ts.lastOrUndefined(bundleFileInfo.sections); + if (last && last.kind === kind) { + last.end = end; + } + else { + bundleFileInfo.sections.push({ pos: pos, end: end, kind: kind }); + } + } + function recordBundleFileInternalSectionStart(node) { + if (recordInternalSection && + bundleFileInfo && + currentSourceFile && + (ts.isDeclaration(node) || ts.isVariableStatement(node)) && + ts.isInternalDeclaration(node, currentSourceFile) && + sourceFileTextKind !== "internal" /* BundleFileSectionKind.Internal */) { + var prevSourceFileTextKind = sourceFileTextKind; + recordBundleFileTextLikeSection(writer.getTextPos()); + sourceFileTextPos = getTextPosWithWriteLine(); + sourceFileTextKind = "internal" /* BundleFileSectionKind.Internal */; + return prevSourceFileTextKind; + } + return undefined; + } + function recordBundleFileInternalSectionEnd(prevSourceFileTextKind) { + if (prevSourceFileTextKind) { + recordBundleFileTextLikeSection(writer.getTextPos()); + sourceFileTextPos = getTextPosWithWriteLine(); + sourceFileTextKind = prevSourceFileTextKind; + } + } + function recordBundleFileTextLikeSection(end) { + if (sourceFileTextPos < end) { + updateOrPushBundleFileTextLike(sourceFileTextPos, end, sourceFileTextKind); + return true; + } + return false; + } + function writeBundle(bundle, output, sourceMapGenerator) { + var _a; + isOwnFileEmit = false; + var previousWriter = writer; + setWriter(output, sourceMapGenerator); + emitShebangIfNeeded(bundle); + emitPrologueDirectivesIfNeeded(bundle); + emitHelpers(bundle); + emitSyntheticTripleSlashReferencesIfNeeded(bundle); + for (var _b = 0, _c = bundle.prepends; _b < _c.length; _b++) { + var prepend = _c[_b]; + writeLine(); + var pos = writer.getTextPos(); + var savedSections = bundleFileInfo && bundleFileInfo.sections; + if (savedSections) + bundleFileInfo.sections = []; + print(4 /* EmitHint.Unspecified */, prepend, /*sourceFile*/ undefined); + if (bundleFileInfo) { + var newSections = bundleFileInfo.sections; + bundleFileInfo.sections = savedSections; + if (prepend.oldFileOfCurrentEmit) + (_a = bundleFileInfo.sections).push.apply(_a, newSections); + else { + newSections.forEach(function (section) { return ts.Debug.assert(ts.isBundleFileTextLike(section)); }); + bundleFileInfo.sections.push({ + pos: pos, + end: writer.getTextPos(), + kind: "prepend" /* BundleFileSectionKind.Prepend */, + data: relativeToBuildInfo(prepend.fileName), + texts: newSections + }); + } + } + } + sourceFileTextPos = getTextPosWithWriteLine(); + for (var _d = 0, _e = bundle.sourceFiles; _d < _e.length; _d++) { + var sourceFile = _e[_d]; + print(0 /* EmitHint.SourceFile */, sourceFile, sourceFile); + } + if (bundleFileInfo && bundle.sourceFiles.length) { + var end = writer.getTextPos(); + if (recordBundleFileTextLikeSection(end)) { + // Store prologues + var prologues = getPrologueDirectivesFromBundledSourceFiles(bundle); + if (prologues) { + if (!bundleFileInfo.sources) + bundleFileInfo.sources = {}; + bundleFileInfo.sources.prologues = prologues; + } + // Store helpes + var helpers = getHelpersFromBundledSourceFiles(bundle); + if (helpers) { + if (!bundleFileInfo.sources) + bundleFileInfo.sources = {}; + bundleFileInfo.sources.helpers = helpers; + } + } + } + reset(); + writer = previousWriter; + } + function writeUnparsedSource(unparsed, output) { + var previousWriter = writer; + setWriter(output, /*_sourceMapGenerator*/ undefined); + print(4 /* EmitHint.Unspecified */, unparsed, /*sourceFile*/ undefined); + reset(); + writer = previousWriter; + } + function writeFile(sourceFile, output, sourceMapGenerator) { + isOwnFileEmit = true; + var previousWriter = writer; + setWriter(output, sourceMapGenerator); + emitShebangIfNeeded(sourceFile); + emitPrologueDirectivesIfNeeded(sourceFile); + print(0 /* EmitHint.SourceFile */, sourceFile, sourceFile); + reset(); + writer = previousWriter; + } + function beginPrint() { + return ownWriter || (ownWriter = ts.createTextWriter(newLine)); + } + function endPrint() { + var text = ownWriter.getText(); + ownWriter.clear(); + return text; + } + function print(hint, node, sourceFile) { + if (sourceFile) { + setSourceFile(sourceFile); + } + pipelineEmit(hint, node, /*parenthesizerRule*/ undefined); + } + function setSourceFile(sourceFile) { + currentSourceFile = sourceFile; + currentLineMap = undefined; + detachedCommentsInfo = undefined; + if (sourceFile) { + setSourceMapSource(sourceFile); + } + } + function setWriter(_writer, _sourceMapGenerator) { + if (_writer && printerOptions.omitTrailingSemicolon) { + _writer = ts.getTrailingSemicolonDeferringWriter(_writer); + } + writer = _writer; // TODO: GH#18217 + sourceMapGenerator = _sourceMapGenerator; + sourceMapsDisabled = !writer || !sourceMapGenerator; + } + function reset() { + nodeIdToGeneratedName = []; + autoGeneratedIdToGeneratedName = []; + generatedNames = new ts.Set(); + formattedNameTempFlagsStack = []; + formattedNameTempFlags = new ts.Map(); + privateNameTempFlagsStack = []; + privateNameTempFlags = 0 /* TempFlags.Auto */; + tempFlagsStack = []; + tempFlags = 0 /* TempFlags.Auto */; + reservedNamesStack = []; + currentSourceFile = undefined; + currentLineMap = undefined; + detachedCommentsInfo = undefined; + setWriter(/*output*/ undefined, /*_sourceMapGenerator*/ undefined); + } + function getCurrentLineMap() { + return currentLineMap || (currentLineMap = ts.getLineStarts(ts.Debug.checkDefined(currentSourceFile))); + } + function emit(node, parenthesizerRule) { + if (node === undefined) + return; + var prevSourceFileTextKind = recordBundleFileInternalSectionStart(node); + pipelineEmit(4 /* EmitHint.Unspecified */, node, parenthesizerRule); + recordBundleFileInternalSectionEnd(prevSourceFileTextKind); + } + function emitIdentifierName(node) { + if (node === undefined) + return; + pipelineEmit(2 /* EmitHint.IdentifierName */, node, /*parenthesizerRule*/ undefined); + } + function emitExpression(node, parenthesizerRule) { + if (node === undefined) + return; + pipelineEmit(1 /* EmitHint.Expression */, node, parenthesizerRule); + } + function emitJsxAttributeValue(node) { + pipelineEmit(ts.isStringLiteral(node) ? 6 /* EmitHint.JsxAttributeValue */ : 4 /* EmitHint.Unspecified */, node); + } + function beforeEmitNode(node) { + if (preserveSourceNewlines && (ts.getEmitFlags(node) & 134217728 /* EmitFlags.IgnoreSourceNewlines */)) { + preserveSourceNewlines = false; + } + } + function afterEmitNode(savedPreserveSourceNewlines) { + preserveSourceNewlines = savedPreserveSourceNewlines; + } + function pipelineEmit(emitHint, node, parenthesizerRule) { + currentParenthesizerRule = parenthesizerRule; + var pipelinePhase = getPipelinePhase(0 /* PipelinePhase.Notification */, emitHint, node); + pipelinePhase(emitHint, node); + currentParenthesizerRule = undefined; + } + function shouldEmitComments(node) { + return !commentsDisabled && !ts.isSourceFile(node); + } + function shouldEmitSourceMaps(node) { + return !sourceMapsDisabled && + !ts.isSourceFile(node) && + !ts.isInJsonFile(node) && + !ts.isUnparsedSource(node) && + !ts.isUnparsedPrepend(node); + } + function getPipelinePhase(phase, emitHint, node) { + switch (phase) { + case 0 /* PipelinePhase.Notification */: + if (onEmitNode !== ts.noEmitNotification && (!isEmitNotificationEnabled || isEmitNotificationEnabled(node))) { + return pipelineEmitWithNotification; + } + // falls through + case 1 /* PipelinePhase.Substitution */: + if (substituteNode !== ts.noEmitSubstitution && (lastSubstitution = substituteNode(emitHint, node) || node) !== node) { + if (currentParenthesizerRule) { + lastSubstitution = currentParenthesizerRule(lastSubstitution); + } + return pipelineEmitWithSubstitution; + } + // falls through + case 2 /* PipelinePhase.Comments */: + if (shouldEmitComments(node)) { + return pipelineEmitWithComments; + } + // falls through + case 3 /* PipelinePhase.SourceMaps */: + if (shouldEmitSourceMaps(node)) { + return pipelineEmitWithSourceMaps; + } + // falls through + case 4 /* PipelinePhase.Emit */: + return pipelineEmitWithHint; + default: + return ts.Debug.assertNever(phase); + } + } + function getNextPipelinePhase(currentPhase, emitHint, node) { + return getPipelinePhase(currentPhase + 1, emitHint, node); + } + function pipelineEmitWithNotification(hint, node) { + var pipelinePhase = getNextPipelinePhase(0 /* PipelinePhase.Notification */, hint, node); + onEmitNode(hint, node, pipelinePhase); + } + function pipelineEmitWithHint(hint, node) { + onBeforeEmitNode === null || onBeforeEmitNode === void 0 ? void 0 : onBeforeEmitNode(node); + if (preserveSourceNewlines) { + var savedPreserveSourceNewlines = preserveSourceNewlines; + beforeEmitNode(node); + pipelineEmitWithHintWorker(hint, node); + afterEmitNode(savedPreserveSourceNewlines); + } + else { + pipelineEmitWithHintWorker(hint, node); + } + onAfterEmitNode === null || onAfterEmitNode === void 0 ? void 0 : onAfterEmitNode(node); + // clear the parenthesizer rule as we ascend + currentParenthesizerRule = undefined; + } + function pipelineEmitWithHintWorker(hint, node, allowSnippets) { + if (allowSnippets === void 0) { allowSnippets = true; } + if (allowSnippets) { + var snippet = ts.getSnippetElement(node); + if (snippet) { + return emitSnippetNode(hint, node, snippet); + } + } + if (hint === 0 /* EmitHint.SourceFile */) + return emitSourceFile(ts.cast(node, ts.isSourceFile)); + if (hint === 2 /* EmitHint.IdentifierName */) + return emitIdentifier(ts.cast(node, ts.isIdentifier)); + if (hint === 6 /* EmitHint.JsxAttributeValue */) + return emitLiteral(ts.cast(node, ts.isStringLiteral), /*jsxAttributeEscape*/ true); + if (hint === 3 /* EmitHint.MappedTypeParameter */) + return emitMappedTypeParameter(ts.cast(node, ts.isTypeParameterDeclaration)); + if (hint === 5 /* EmitHint.EmbeddedStatement */) { + ts.Debug.assertNode(node, ts.isEmptyStatement); + return emitEmptyStatement(/*isEmbeddedStatement*/ true); + } + if (hint === 4 /* EmitHint.Unspecified */) { + switch (node.kind) { + // Pseudo-literals + case 15 /* SyntaxKind.TemplateHead */: + case 16 /* SyntaxKind.TemplateMiddle */: + case 17 /* SyntaxKind.TemplateTail */: + return emitLiteral(node, /*jsxAttributeEscape*/ false); + // Identifiers + case 79 /* SyntaxKind.Identifier */: + return emitIdentifier(node); + // PrivateIdentifiers + case 80 /* SyntaxKind.PrivateIdentifier */: + return emitPrivateIdentifier(node); + // Parse tree nodes + // Names + case 163 /* SyntaxKind.QualifiedName */: + return emitQualifiedName(node); + case 164 /* SyntaxKind.ComputedPropertyName */: + return emitComputedPropertyName(node); + // Signature elements + case 165 /* SyntaxKind.TypeParameter */: + return emitTypeParameter(node); + case 166 /* SyntaxKind.Parameter */: + return emitParameter(node); + case 167 /* SyntaxKind.Decorator */: + return emitDecorator(node); + // Type members + case 168 /* SyntaxKind.PropertySignature */: + return emitPropertySignature(node); + case 169 /* SyntaxKind.PropertyDeclaration */: + return emitPropertyDeclaration(node); + case 170 /* SyntaxKind.MethodSignature */: + return emitMethodSignature(node); + case 171 /* SyntaxKind.MethodDeclaration */: + return emitMethodDeclaration(node); + case 172 /* SyntaxKind.ClassStaticBlockDeclaration */: + return emitClassStaticBlockDeclaration(node); + case 173 /* SyntaxKind.Constructor */: + return emitConstructor(node); + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + return emitAccessorDeclaration(node); + case 176 /* SyntaxKind.CallSignature */: + return emitCallSignature(node); + case 177 /* SyntaxKind.ConstructSignature */: + return emitConstructSignature(node); + case 178 /* SyntaxKind.IndexSignature */: + return emitIndexSignature(node); + // Types + case 179 /* SyntaxKind.TypePredicate */: + return emitTypePredicate(node); + case 180 /* SyntaxKind.TypeReference */: + return emitTypeReference(node); + case 181 /* SyntaxKind.FunctionType */: + return emitFunctionType(node); + case 182 /* SyntaxKind.ConstructorType */: + return emitConstructorType(node); + case 183 /* SyntaxKind.TypeQuery */: + return emitTypeQuery(node); + case 184 /* SyntaxKind.TypeLiteral */: + return emitTypeLiteral(node); + case 185 /* SyntaxKind.ArrayType */: + return emitArrayType(node); + case 186 /* SyntaxKind.TupleType */: + return emitTupleType(node); + case 187 /* SyntaxKind.OptionalType */: + return emitOptionalType(node); + // SyntaxKind.RestType is handled below + case 189 /* SyntaxKind.UnionType */: + return emitUnionType(node); + case 190 /* SyntaxKind.IntersectionType */: + return emitIntersectionType(node); + case 191 /* SyntaxKind.ConditionalType */: + return emitConditionalType(node); + case 192 /* SyntaxKind.InferType */: + return emitInferType(node); + case 193 /* SyntaxKind.ParenthesizedType */: + return emitParenthesizedType(node); + case 230 /* SyntaxKind.ExpressionWithTypeArguments */: + return emitExpressionWithTypeArguments(node); + case 194 /* SyntaxKind.ThisType */: + return emitThisType(); + case 195 /* SyntaxKind.TypeOperator */: + return emitTypeOperator(node); + case 196 /* SyntaxKind.IndexedAccessType */: + return emitIndexedAccessType(node); + case 197 /* SyntaxKind.MappedType */: + return emitMappedType(node); + case 198 /* SyntaxKind.LiteralType */: + return emitLiteralType(node); + case 199 /* SyntaxKind.NamedTupleMember */: + return emitNamedTupleMember(node); + case 200 /* SyntaxKind.TemplateLiteralType */: + return emitTemplateType(node); + case 201 /* SyntaxKind.TemplateLiteralTypeSpan */: + return emitTemplateTypeSpan(node); + case 202 /* SyntaxKind.ImportType */: + return emitImportTypeNode(node); + // Binding patterns + case 203 /* SyntaxKind.ObjectBindingPattern */: + return emitObjectBindingPattern(node); + case 204 /* SyntaxKind.ArrayBindingPattern */: + return emitArrayBindingPattern(node); + case 205 /* SyntaxKind.BindingElement */: + return emitBindingElement(node); + // Misc + case 236 /* SyntaxKind.TemplateSpan */: + return emitTemplateSpan(node); + case 237 /* SyntaxKind.SemicolonClassElement */: + return emitSemicolonClassElement(); + // Statements + case 238 /* SyntaxKind.Block */: + return emitBlock(node); + case 240 /* SyntaxKind.VariableStatement */: + return emitVariableStatement(node); + case 239 /* SyntaxKind.EmptyStatement */: + return emitEmptyStatement(/*isEmbeddedStatement*/ false); + case 241 /* SyntaxKind.ExpressionStatement */: + return emitExpressionStatement(node); + case 242 /* SyntaxKind.IfStatement */: + return emitIfStatement(node); + case 243 /* SyntaxKind.DoStatement */: + return emitDoStatement(node); + case 244 /* SyntaxKind.WhileStatement */: + return emitWhileStatement(node); + case 245 /* SyntaxKind.ForStatement */: + return emitForStatement(node); + case 246 /* SyntaxKind.ForInStatement */: + return emitForInStatement(node); + case 247 /* SyntaxKind.ForOfStatement */: + return emitForOfStatement(node); + case 248 /* SyntaxKind.ContinueStatement */: + return emitContinueStatement(node); + case 249 /* SyntaxKind.BreakStatement */: + return emitBreakStatement(node); + case 250 /* SyntaxKind.ReturnStatement */: + return emitReturnStatement(node); + case 251 /* SyntaxKind.WithStatement */: + return emitWithStatement(node); + case 252 /* SyntaxKind.SwitchStatement */: + return emitSwitchStatement(node); + case 253 /* SyntaxKind.LabeledStatement */: + return emitLabeledStatement(node); + case 254 /* SyntaxKind.ThrowStatement */: + return emitThrowStatement(node); + case 255 /* SyntaxKind.TryStatement */: + return emitTryStatement(node); + case 256 /* SyntaxKind.DebuggerStatement */: + return emitDebuggerStatement(node); + // Declarations + case 257 /* SyntaxKind.VariableDeclaration */: + return emitVariableDeclaration(node); + case 258 /* SyntaxKind.VariableDeclarationList */: + return emitVariableDeclarationList(node); + case 259 /* SyntaxKind.FunctionDeclaration */: + return emitFunctionDeclaration(node); + case 260 /* SyntaxKind.ClassDeclaration */: + return emitClassDeclaration(node); + case 261 /* SyntaxKind.InterfaceDeclaration */: + return emitInterfaceDeclaration(node); + case 262 /* SyntaxKind.TypeAliasDeclaration */: + return emitTypeAliasDeclaration(node); + case 263 /* SyntaxKind.EnumDeclaration */: + return emitEnumDeclaration(node); + case 264 /* SyntaxKind.ModuleDeclaration */: + return emitModuleDeclaration(node); + case 265 /* SyntaxKind.ModuleBlock */: + return emitModuleBlock(node); + case 266 /* SyntaxKind.CaseBlock */: + return emitCaseBlock(node); + case 267 /* SyntaxKind.NamespaceExportDeclaration */: + return emitNamespaceExportDeclaration(node); + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return emitImportEqualsDeclaration(node); + case 269 /* SyntaxKind.ImportDeclaration */: + return emitImportDeclaration(node); + case 270 /* SyntaxKind.ImportClause */: + return emitImportClause(node); + case 271 /* SyntaxKind.NamespaceImport */: + return emitNamespaceImport(node); + case 277 /* SyntaxKind.NamespaceExport */: + return emitNamespaceExport(node); + case 272 /* SyntaxKind.NamedImports */: + return emitNamedImports(node); + case 273 /* SyntaxKind.ImportSpecifier */: + return emitImportSpecifier(node); + case 274 /* SyntaxKind.ExportAssignment */: + return emitExportAssignment(node); + case 275 /* SyntaxKind.ExportDeclaration */: + return emitExportDeclaration(node); + case 276 /* SyntaxKind.NamedExports */: + return emitNamedExports(node); + case 278 /* SyntaxKind.ExportSpecifier */: + return emitExportSpecifier(node); + case 296 /* SyntaxKind.AssertClause */: + return emitAssertClause(node); + case 297 /* SyntaxKind.AssertEntry */: + return emitAssertEntry(node); + case 279 /* SyntaxKind.MissingDeclaration */: + return; + // Module references + case 280 /* SyntaxKind.ExternalModuleReference */: + return emitExternalModuleReference(node); + // JSX (non-expression) + case 11 /* SyntaxKind.JsxText */: + return emitJsxText(node); + case 283 /* SyntaxKind.JsxOpeningElement */: + case 286 /* SyntaxKind.JsxOpeningFragment */: + return emitJsxOpeningElementOrFragment(node); + case 284 /* SyntaxKind.JsxClosingElement */: + case 287 /* SyntaxKind.JsxClosingFragment */: + return emitJsxClosingElementOrFragment(node); + case 288 /* SyntaxKind.JsxAttribute */: + return emitJsxAttribute(node); + case 289 /* SyntaxKind.JsxAttributes */: + return emitJsxAttributes(node); + case 290 /* SyntaxKind.JsxSpreadAttribute */: + return emitJsxSpreadAttribute(node); + case 291 /* SyntaxKind.JsxExpression */: + return emitJsxExpression(node); + // Clauses + case 292 /* SyntaxKind.CaseClause */: + return emitCaseClause(node); + case 293 /* SyntaxKind.DefaultClause */: + return emitDefaultClause(node); + case 294 /* SyntaxKind.HeritageClause */: + return emitHeritageClause(node); + case 295 /* SyntaxKind.CatchClause */: + return emitCatchClause(node); + // Property assignments + case 299 /* SyntaxKind.PropertyAssignment */: + return emitPropertyAssignment(node); + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + return emitShorthandPropertyAssignment(node); + case 301 /* SyntaxKind.SpreadAssignment */: + return emitSpreadAssignment(node); + // Enum + case 302 /* SyntaxKind.EnumMember */: + return emitEnumMember(node); + // Unparsed + case 303 /* SyntaxKind.UnparsedPrologue */: + return writeUnparsedNode(node); + case 310 /* SyntaxKind.UnparsedSource */: + case 304 /* SyntaxKind.UnparsedPrepend */: + return emitUnparsedSourceOrPrepend(node); + case 305 /* SyntaxKind.UnparsedText */: + case 306 /* SyntaxKind.UnparsedInternalText */: + return emitUnparsedTextLike(node); + case 307 /* SyntaxKind.UnparsedSyntheticReference */: + return emitUnparsedSyntheticReference(node); + // Top-level nodes + case 308 /* SyntaxKind.SourceFile */: + return emitSourceFile(node); + case 309 /* SyntaxKind.Bundle */: + return ts.Debug.fail("Bundles should be printed using printBundle"); + // SyntaxKind.UnparsedSource (handled above) + case 311 /* SyntaxKind.InputFiles */: + return ts.Debug.fail("InputFiles should not be printed"); + // JSDoc nodes (only used in codefixes currently) + case 312 /* SyntaxKind.JSDocTypeExpression */: + return emitJSDocTypeExpression(node); + case 313 /* SyntaxKind.JSDocNameReference */: + return emitJSDocNameReference(node); + case 315 /* SyntaxKind.JSDocAllType */: + return writePunctuation("*"); + case 316 /* SyntaxKind.JSDocUnknownType */: + return writePunctuation("?"); + case 317 /* SyntaxKind.JSDocNullableType */: + return emitJSDocNullableType(node); + case 318 /* SyntaxKind.JSDocNonNullableType */: + return emitJSDocNonNullableType(node); + case 319 /* SyntaxKind.JSDocOptionalType */: + return emitJSDocOptionalType(node); + case 320 /* SyntaxKind.JSDocFunctionType */: + return emitJSDocFunctionType(node); + case 188 /* SyntaxKind.RestType */: + case 321 /* SyntaxKind.JSDocVariadicType */: + return emitRestOrJSDocVariadicType(node); + case 322 /* SyntaxKind.JSDocNamepathType */: + return; + case 323 /* SyntaxKind.JSDoc */: + return emitJSDoc(node); + case 325 /* SyntaxKind.JSDocTypeLiteral */: + return emitJSDocTypeLiteral(node); + case 326 /* SyntaxKind.JSDocSignature */: + return emitJSDocSignature(node); + case 330 /* SyntaxKind.JSDocTag */: + case 335 /* SyntaxKind.JSDocClassTag */: + case 340 /* SyntaxKind.JSDocOverrideTag */: + return emitJSDocSimpleTag(node); + case 331 /* SyntaxKind.JSDocAugmentsTag */: + case 332 /* SyntaxKind.JSDocImplementsTag */: + return emitJSDocHeritageTag(node); + case 333 /* SyntaxKind.JSDocAuthorTag */: + case 334 /* SyntaxKind.JSDocDeprecatedTag */: + return; + // SyntaxKind.JSDocClassTag (see JSDocTag, above) + case 336 /* SyntaxKind.JSDocPublicTag */: + case 337 /* SyntaxKind.JSDocPrivateTag */: + case 338 /* SyntaxKind.JSDocProtectedTag */: + case 339 /* SyntaxKind.JSDocReadonlyTag */: + return; + case 341 /* SyntaxKind.JSDocCallbackTag */: + return emitJSDocCallbackTag(node); + // SyntaxKind.JSDocEnumTag (see below) + case 343 /* SyntaxKind.JSDocParameterTag */: + case 350 /* SyntaxKind.JSDocPropertyTag */: + return emitJSDocPropertyLikeTag(node); + case 342 /* SyntaxKind.JSDocEnumTag */: + case 344 /* SyntaxKind.JSDocReturnTag */: + case 345 /* SyntaxKind.JSDocThisTag */: + case 346 /* SyntaxKind.JSDocTypeTag */: + return emitJSDocSimpleTypedTag(node); + case 347 /* SyntaxKind.JSDocTemplateTag */: + return emitJSDocTemplateTag(node); + case 348 /* SyntaxKind.JSDocTypedefTag */: + return emitJSDocTypedefTag(node); + case 349 /* SyntaxKind.JSDocSeeTag */: + return emitJSDocSeeTag(node); + // SyntaxKind.JSDocPropertyTag (see JSDocParameterTag, above) + // Transformation nodes + case 352 /* SyntaxKind.NotEmittedStatement */: + case 356 /* SyntaxKind.EndOfDeclarationMarker */: + case 355 /* SyntaxKind.MergeDeclarationMarker */: + return; + } + if (ts.isExpression(node)) { + hint = 1 /* EmitHint.Expression */; + if (substituteNode !== ts.noEmitSubstitution) { + var substitute = substituteNode(hint, node) || node; + if (substitute !== node) { + node = substitute; + if (currentParenthesizerRule) { + node = currentParenthesizerRule(node); + } + } + } + } + } + if (hint === 1 /* EmitHint.Expression */) { + switch (node.kind) { + // Literals + case 8 /* SyntaxKind.NumericLiteral */: + case 9 /* SyntaxKind.BigIntLiteral */: + return emitNumericOrBigIntLiteral(node); + case 10 /* SyntaxKind.StringLiteral */: + case 13 /* SyntaxKind.RegularExpressionLiteral */: + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + return emitLiteral(node, /*jsxAttributeEscape*/ false); + // Identifiers + case 79 /* SyntaxKind.Identifier */: + return emitIdentifier(node); + case 80 /* SyntaxKind.PrivateIdentifier */: + return emitPrivateIdentifier(node); + // Expressions + case 206 /* SyntaxKind.ArrayLiteralExpression */: + return emitArrayLiteralExpression(node); + case 207 /* SyntaxKind.ObjectLiteralExpression */: + return emitObjectLiteralExpression(node); + case 208 /* SyntaxKind.PropertyAccessExpression */: + return emitPropertyAccessExpression(node); + case 209 /* SyntaxKind.ElementAccessExpression */: + return emitElementAccessExpression(node); + case 210 /* SyntaxKind.CallExpression */: + return emitCallExpression(node); + case 211 /* SyntaxKind.NewExpression */: + return emitNewExpression(node); + case 212 /* SyntaxKind.TaggedTemplateExpression */: + return emitTaggedTemplateExpression(node); + case 213 /* SyntaxKind.TypeAssertionExpression */: + return emitTypeAssertionExpression(node); + case 214 /* SyntaxKind.ParenthesizedExpression */: + return emitParenthesizedExpression(node); + case 215 /* SyntaxKind.FunctionExpression */: + return emitFunctionExpression(node); + case 216 /* SyntaxKind.ArrowFunction */: + return emitArrowFunction(node); + case 217 /* SyntaxKind.DeleteExpression */: + return emitDeleteExpression(node); + case 218 /* SyntaxKind.TypeOfExpression */: + return emitTypeOfExpression(node); + case 219 /* SyntaxKind.VoidExpression */: + return emitVoidExpression(node); + case 220 /* SyntaxKind.AwaitExpression */: + return emitAwaitExpression(node); + case 221 /* SyntaxKind.PrefixUnaryExpression */: + return emitPrefixUnaryExpression(node); + case 222 /* SyntaxKind.PostfixUnaryExpression */: + return emitPostfixUnaryExpression(node); + case 223 /* SyntaxKind.BinaryExpression */: + return emitBinaryExpression(node); + case 224 /* SyntaxKind.ConditionalExpression */: + return emitConditionalExpression(node); + case 225 /* SyntaxKind.TemplateExpression */: + return emitTemplateExpression(node); + case 226 /* SyntaxKind.YieldExpression */: + return emitYieldExpression(node); + case 227 /* SyntaxKind.SpreadElement */: + return emitSpreadElement(node); + case 228 /* SyntaxKind.ClassExpression */: + return emitClassExpression(node); + case 229 /* SyntaxKind.OmittedExpression */: + return; + case 231 /* SyntaxKind.AsExpression */: + return emitAsExpression(node); + case 232 /* SyntaxKind.NonNullExpression */: + return emitNonNullExpression(node); + case 230 /* SyntaxKind.ExpressionWithTypeArguments */: + return emitExpressionWithTypeArguments(node); + case 235 /* SyntaxKind.SatisfiesExpression */: + return emitSatisfiesExpression(node); + case 233 /* SyntaxKind.MetaProperty */: + return emitMetaProperty(node); + case 234 /* SyntaxKind.SyntheticExpression */: + return ts.Debug.fail("SyntheticExpression should never be printed."); + // JSX + case 281 /* SyntaxKind.JsxElement */: + return emitJsxElement(node); + case 282 /* SyntaxKind.JsxSelfClosingElement */: + return emitJsxSelfClosingElement(node); + case 285 /* SyntaxKind.JsxFragment */: + return emitJsxFragment(node); + // Synthesized list + case 351 /* SyntaxKind.SyntaxList */: + return ts.Debug.fail("SyntaxList should not be printed"); + // Transformation nodes + case 352 /* SyntaxKind.NotEmittedStatement */: + return; + case 353 /* SyntaxKind.PartiallyEmittedExpression */: + return emitPartiallyEmittedExpression(node); + case 354 /* SyntaxKind.CommaListExpression */: + return emitCommaList(node); + case 355 /* SyntaxKind.MergeDeclarationMarker */: + case 356 /* SyntaxKind.EndOfDeclarationMarker */: + return; + case 357 /* SyntaxKind.SyntheticReferenceExpression */: + return ts.Debug.fail("SyntheticReferenceExpression should not be printed"); + } + } + if (ts.isKeyword(node.kind)) + return writeTokenNode(node, writeKeyword); + if (ts.isTokenKind(node.kind)) + return writeTokenNode(node, writePunctuation); + ts.Debug.fail("Unhandled SyntaxKind: ".concat(ts.Debug.formatSyntaxKind(node.kind), ".")); + } + function emitMappedTypeParameter(node) { + emit(node.name); + writeSpace(); + writeKeyword("in"); + writeSpace(); + emit(node.constraint); + } + function pipelineEmitWithSubstitution(hint, node) { + var pipelinePhase = getNextPipelinePhase(1 /* PipelinePhase.Substitution */, hint, node); + ts.Debug.assertIsDefined(lastSubstitution); + node = lastSubstitution; + lastSubstitution = undefined; + pipelinePhase(hint, node); + } + function getHelpersFromBundledSourceFiles(bundle) { + var result; + if (moduleKind === ts.ModuleKind.None || printerOptions.noEmitHelpers) { + return undefined; + } + var bundledHelpers = new ts.Map(); + for (var _a = 0, _b = bundle.sourceFiles; _a < _b.length; _a++) { + var sourceFile = _b[_a]; + var shouldSkip = ts.getExternalHelpersModuleName(sourceFile) !== undefined; + var helpers = getSortedEmitHelpers(sourceFile); + if (!helpers) + continue; + for (var _c = 0, helpers_5 = helpers; _c < helpers_5.length; _c++) { + var helper = helpers_5[_c]; + if (!helper.scoped && !shouldSkip && !bundledHelpers.get(helper.name)) { + bundledHelpers.set(helper.name, true); + (result || (result = [])).push(helper.name); + } + } + } + return result; + } + function emitHelpers(node) { + var helpersEmitted = false; + var bundle = node.kind === 309 /* SyntaxKind.Bundle */ ? node : undefined; + if (bundle && moduleKind === ts.ModuleKind.None) { + return; + } + var numPrepends = bundle ? bundle.prepends.length : 0; + var numNodes = bundle ? bundle.sourceFiles.length + numPrepends : 1; + for (var i = 0; i < numNodes; i++) { + var currentNode = bundle ? i < numPrepends ? bundle.prepends[i] : bundle.sourceFiles[i - numPrepends] : node; + var sourceFile = ts.isSourceFile(currentNode) ? currentNode : ts.isUnparsedSource(currentNode) ? undefined : currentSourceFile; + var shouldSkip = printerOptions.noEmitHelpers || (!!sourceFile && ts.hasRecordedExternalHelpers(sourceFile)); + var shouldBundle = (ts.isSourceFile(currentNode) || ts.isUnparsedSource(currentNode)) && !isOwnFileEmit; + var helpers = ts.isUnparsedSource(currentNode) ? currentNode.helpers : getSortedEmitHelpers(currentNode); + if (helpers) { + for (var _a = 0, helpers_6 = helpers; _a < helpers_6.length; _a++) { + var helper = helpers_6[_a]; + if (!helper.scoped) { + // Skip the helper if it can be skipped and the noEmitHelpers compiler + // option is set, or if it can be imported and the importHelpers compiler + // option is set. + if (shouldSkip) + continue; + // Skip the helper if it can be bundled but hasn't already been emitted and we + // are emitting a bundled module. + if (shouldBundle) { + if (bundledHelpers.get(helper.name)) { + continue; + } + bundledHelpers.set(helper.name, true); + } + } + else if (bundle) { + // Skip the helper if it is scoped and we are emitting bundled helpers + continue; + } + var pos = getTextPosWithWriteLine(); + if (typeof helper.text === "string") { + writeLines(helper.text); + } + else { + writeLines(helper.text(makeFileLevelOptimisticUniqueName)); + } + if (bundleFileInfo) + bundleFileInfo.sections.push({ pos: pos, end: writer.getTextPos(), kind: "emitHelpers" /* BundleFileSectionKind.EmitHelpers */, data: helper.name }); + helpersEmitted = true; + } + } + } + return helpersEmitted; + } + function getSortedEmitHelpers(node) { + var helpers = ts.getEmitHelpers(node); + return helpers && ts.stableSort(helpers, ts.compareEmitHelpers); + } + // + // Literals/Pseudo-literals + // + // SyntaxKind.NumericLiteral + // SyntaxKind.BigIntLiteral + function emitNumericOrBigIntLiteral(node) { + emitLiteral(node, /*jsxAttributeEscape*/ false); + } + // SyntaxKind.StringLiteral + // SyntaxKind.RegularExpressionLiteral + // SyntaxKind.NoSubstitutionTemplateLiteral + // SyntaxKind.TemplateHead + // SyntaxKind.TemplateMiddle + // SyntaxKind.TemplateTail + function emitLiteral(node, jsxAttributeEscape) { + var text = getLiteralTextOfNode(node, printerOptions.neverAsciiEscape, jsxAttributeEscape); + if ((printerOptions.sourceMap || printerOptions.inlineSourceMap) + && (node.kind === 10 /* SyntaxKind.StringLiteral */ || ts.isTemplateLiteralKind(node.kind))) { + writeLiteral(text); + } + else { + // Quick info expects all literals to be called with writeStringLiteral, as there's no specific type for numberLiterals + writeStringLiteral(text); + } + } + // SyntaxKind.UnparsedSource + // SyntaxKind.UnparsedPrepend + function emitUnparsedSourceOrPrepend(unparsed) { + for (var _a = 0, _b = unparsed.texts; _a < _b.length; _a++) { + var text = _b[_a]; + writeLine(); + emit(text); + } + } + // SyntaxKind.UnparsedPrologue + // SyntaxKind.UnparsedText + // SyntaxKind.UnparsedInternal + // SyntaxKind.UnparsedSyntheticReference + function writeUnparsedNode(unparsed) { + writer.rawWrite(unparsed.parent.text.substring(unparsed.pos, unparsed.end)); + } + // SyntaxKind.UnparsedText + // SyntaxKind.UnparsedInternal + function emitUnparsedTextLike(unparsed) { + var pos = getTextPosWithWriteLine(); + writeUnparsedNode(unparsed); + if (bundleFileInfo) { + updateOrPushBundleFileTextLike(pos, writer.getTextPos(), unparsed.kind === 305 /* SyntaxKind.UnparsedText */ ? + "text" /* BundleFileSectionKind.Text */ : + "internal" /* BundleFileSectionKind.Internal */); + } + } + // SyntaxKind.UnparsedSyntheticReference + function emitUnparsedSyntheticReference(unparsed) { + var pos = getTextPosWithWriteLine(); + writeUnparsedNode(unparsed); + if (bundleFileInfo) { + var section = ts.clone(unparsed.section); + section.pos = pos; + section.end = writer.getTextPos(); + bundleFileInfo.sections.push(section); + } + } + // + // Snippet Elements + // + function emitSnippetNode(hint, node, snippet) { + switch (snippet.kind) { + case 1 /* SnippetKind.Placeholder */: + emitPlaceholder(hint, node, snippet); + break; + case 0 /* SnippetKind.TabStop */: + emitTabStop(hint, node, snippet); + break; + } + } + function emitPlaceholder(hint, node, snippet) { + nonEscapingWrite("${".concat(snippet.order, ":")); // `${2:` + pipelineEmitWithHintWorker(hint, node, /*allowSnippets*/ false); // `...` + nonEscapingWrite("}"); // `}` + // `${2:...}` + } + function emitTabStop(hint, node, snippet) { + // A tab stop should only be attached to an empty node, i.e. a node that doesn't emit any text. + ts.Debug.assert(node.kind === 239 /* SyntaxKind.EmptyStatement */, "A tab stop cannot be attached to a node of kind ".concat(ts.Debug.formatSyntaxKind(node.kind), ".")); + ts.Debug.assert(hint !== 5 /* EmitHint.EmbeddedStatement */, "A tab stop cannot be attached to an embedded statement."); + nonEscapingWrite("$".concat(snippet.order)); + } + // + // Identifiers + // + function emitIdentifier(node) { + var writeText = node.symbol ? writeSymbol : write; + writeText(getTextOfNode(node, /*includeTrivia*/ false), node.symbol); + emitList(node, node.typeArguments, 53776 /* ListFormat.TypeParameters */); // Call emitList directly since it could be an array of TypeParameterDeclarations _or_ type arguments + } + // + // Names + // + function emitPrivateIdentifier(node) { + var writeText = node.symbol ? writeSymbol : write; + writeText(getTextOfNode(node, /*includeTrivia*/ false), node.symbol); + } + function emitQualifiedName(node) { + emitEntityName(node.left); + writePunctuation("."); + emit(node.right); + } + function emitEntityName(node) { + if (node.kind === 79 /* SyntaxKind.Identifier */) { + emitExpression(node); + } + else { + emit(node); + } + } + function emitComputedPropertyName(node) { + writePunctuation("["); + emitExpression(node.expression, parenthesizer.parenthesizeExpressionOfComputedPropertyName); + writePunctuation("]"); + } + // + // Signature elements + // + function emitTypeParameter(node) { + emitModifiers(node, node.modifiers); + emit(node.name); + if (node.constraint) { + writeSpace(); + writeKeyword("extends"); + writeSpace(); + emit(node.constraint); + } + if (node.default) { + writeSpace(); + writeOperator("="); + writeSpace(); + emit(node.default); + } + } + function emitParameter(node) { + emitDecoratorsAndModifiers(node, node.modifiers); + emit(node.dotDotDotToken); + emitNodeWithWriter(node.name, writeParameter); + emit(node.questionToken); + if (node.parent && node.parent.kind === 320 /* SyntaxKind.JSDocFunctionType */ && !node.name) { + emit(node.type); + } + else { + emitTypeAnnotation(node.type); + } + // The comment position has to fallback to any present node within the parameterdeclaration because as it turns out, the parser can make parameter declarations with _just_ an initializer. + emitInitializer(node.initializer, node.type ? node.type.end : node.questionToken ? node.questionToken.end : node.name ? node.name.end : node.modifiers ? node.modifiers.end : node.pos, node, parenthesizer.parenthesizeExpressionForDisallowedComma); + } + function emitDecorator(decorator) { + writePunctuation("@"); + emitExpression(decorator.expression, parenthesizer.parenthesizeLeftSideOfAccess); + } + // + // Type members + // + function emitPropertySignature(node) { + emitModifiers(node, node.modifiers); + emitNodeWithWriter(node.name, writeProperty); + emit(node.questionToken); + emitTypeAnnotation(node.type); + writeTrailingSemicolon(); + } + function emitPropertyDeclaration(node) { + emitDecoratorsAndModifiers(node, node.modifiers); + emit(node.name); + emit(node.questionToken); + emit(node.exclamationToken); + emitTypeAnnotation(node.type); + emitInitializer(node.initializer, node.type ? node.type.end : node.questionToken ? node.questionToken.end : node.name.end, node); + writeTrailingSemicolon(); + } + function emitMethodSignature(node) { + pushNameGenerationScope(node); + emitModifiers(node, node.modifiers); + emit(node.name); + emit(node.questionToken); + emitTypeParameters(node, node.typeParameters); + emitParameters(node, node.parameters); + emitTypeAnnotation(node.type); + writeTrailingSemicolon(); + popNameGenerationScope(node); + } + function emitMethodDeclaration(node) { + emitDecoratorsAndModifiers(node, node.modifiers); + emit(node.asteriskToken); + emit(node.name); + emit(node.questionToken); + emitSignatureAndBody(node, emitSignatureHead); + } + function emitClassStaticBlockDeclaration(node) { + writeKeyword("static"); + emitBlockFunctionBody(node.body); + } + function emitConstructor(node) { + emitModifiers(node, node.modifiers); + writeKeyword("constructor"); + emitSignatureAndBody(node, emitSignatureHead); + } + function emitAccessorDeclaration(node) { + emitDecoratorsAndModifiers(node, node.modifiers); + writeKeyword(node.kind === 174 /* SyntaxKind.GetAccessor */ ? "get" : "set"); + writeSpace(); + emit(node.name); + emitSignatureAndBody(node, emitSignatureHead); + } + function emitCallSignature(node) { + pushNameGenerationScope(node); + emitTypeParameters(node, node.typeParameters); + emitParameters(node, node.parameters); + emitTypeAnnotation(node.type); + writeTrailingSemicolon(); + popNameGenerationScope(node); + } + function emitConstructSignature(node) { + pushNameGenerationScope(node); + writeKeyword("new"); + writeSpace(); + emitTypeParameters(node, node.typeParameters); + emitParameters(node, node.parameters); + emitTypeAnnotation(node.type); + writeTrailingSemicolon(); + popNameGenerationScope(node); + } + function emitIndexSignature(node) { + emitModifiers(node, node.modifiers); + emitParametersForIndexSignature(node, node.parameters); + emitTypeAnnotation(node.type); + writeTrailingSemicolon(); + } + function emitTemplateTypeSpan(node) { + emit(node.type); + emit(node.literal); + } + function emitSemicolonClassElement() { + writeTrailingSemicolon(); + } + // + // Types + // + function emitTypePredicate(node) { + if (node.assertsModifier) { + emit(node.assertsModifier); + writeSpace(); + } + emit(node.parameterName); + if (node.type) { + writeSpace(); + writeKeyword("is"); + writeSpace(); + emit(node.type); + } + } + function emitTypeReference(node) { + emit(node.typeName); + emitTypeArguments(node, node.typeArguments); + } + function emitFunctionType(node) { + pushNameGenerationScope(node); + emitTypeParameters(node, node.typeParameters); + emitParametersForArrow(node, node.parameters); + writeSpace(); + writePunctuation("=>"); + writeSpace(); + emit(node.type); + popNameGenerationScope(node); + } + function emitJSDocFunctionType(node) { + writeKeyword("function"); + emitParameters(node, node.parameters); + writePunctuation(":"); + emit(node.type); + } + function emitJSDocNullableType(node) { + writePunctuation("?"); + emit(node.type); + } + function emitJSDocNonNullableType(node) { + writePunctuation("!"); + emit(node.type); + } + function emitJSDocOptionalType(node) { + emit(node.type); + writePunctuation("="); + } + function emitConstructorType(node) { + pushNameGenerationScope(node); + emitModifiers(node, node.modifiers); + writeKeyword("new"); + writeSpace(); + emitTypeParameters(node, node.typeParameters); + emitParameters(node, node.parameters); + writeSpace(); + writePunctuation("=>"); + writeSpace(); + emit(node.type); + popNameGenerationScope(node); + } + function emitTypeQuery(node) { + writeKeyword("typeof"); + writeSpace(); + emit(node.exprName); + emitTypeArguments(node, node.typeArguments); + } + function emitTypeLiteral(node) { + writePunctuation("{"); + var flags = ts.getEmitFlags(node) & 1 /* EmitFlags.SingleLine */ ? 768 /* ListFormat.SingleLineTypeLiteralMembers */ : 32897 /* ListFormat.MultiLineTypeLiteralMembers */; + emitList(node, node.members, flags | 524288 /* ListFormat.NoSpaceIfEmpty */); + writePunctuation("}"); + } + function emitArrayType(node) { + emit(node.elementType, parenthesizer.parenthesizeNonArrayTypeOfPostfixType); + writePunctuation("["); + writePunctuation("]"); + } + function emitRestOrJSDocVariadicType(node) { + writePunctuation("..."); + emit(node.type); + } + function emitTupleType(node) { + emitTokenWithComment(22 /* SyntaxKind.OpenBracketToken */, node.pos, writePunctuation, node); + var flags = ts.getEmitFlags(node) & 1 /* EmitFlags.SingleLine */ ? 528 /* ListFormat.SingleLineTupleTypeElements */ : 657 /* ListFormat.MultiLineTupleTypeElements */; + emitList(node, node.elements, flags | 524288 /* ListFormat.NoSpaceIfEmpty */, parenthesizer.parenthesizeElementTypeOfTupleType); + emitTokenWithComment(23 /* SyntaxKind.CloseBracketToken */, node.elements.end, writePunctuation, node); + } + function emitNamedTupleMember(node) { + emit(node.dotDotDotToken); + emit(node.name); + emit(node.questionToken); + emitTokenWithComment(58 /* SyntaxKind.ColonToken */, node.name.end, writePunctuation, node); + writeSpace(); + emit(node.type); + } + function emitOptionalType(node) { + emit(node.type, parenthesizer.parenthesizeTypeOfOptionalType); + writePunctuation("?"); + } + function emitUnionType(node) { + emitList(node, node.types, 516 /* ListFormat.UnionTypeConstituents */, parenthesizer.parenthesizeConstituentTypeOfUnionType); + } + function emitIntersectionType(node) { + emitList(node, node.types, 520 /* ListFormat.IntersectionTypeConstituents */, parenthesizer.parenthesizeConstituentTypeOfIntersectionType); + } + function emitConditionalType(node) { + emit(node.checkType, parenthesizer.parenthesizeCheckTypeOfConditionalType); + writeSpace(); + writeKeyword("extends"); + writeSpace(); + emit(node.extendsType, parenthesizer.parenthesizeExtendsTypeOfConditionalType); + writeSpace(); + writePunctuation("?"); + writeSpace(); + emit(node.trueType); + writeSpace(); + writePunctuation(":"); + writeSpace(); + emit(node.falseType); + } + function emitInferType(node) { + writeKeyword("infer"); + writeSpace(); + emit(node.typeParameter); + } + function emitParenthesizedType(node) { + writePunctuation("("); + emit(node.type); + writePunctuation(")"); + } + function emitThisType() { + writeKeyword("this"); + } + function emitTypeOperator(node) { + writeTokenText(node.operator, writeKeyword); + writeSpace(); + var parenthesizerRule = node.operator === 146 /* SyntaxKind.ReadonlyKeyword */ ? + parenthesizer.parenthesizeOperandOfReadonlyTypeOperator : + parenthesizer.parenthesizeOperandOfTypeOperator; + emit(node.type, parenthesizerRule); + } + function emitIndexedAccessType(node) { + emit(node.objectType, parenthesizer.parenthesizeNonArrayTypeOfPostfixType); + writePunctuation("["); + emit(node.indexType); + writePunctuation("]"); + } + function emitMappedType(node) { + var emitFlags = ts.getEmitFlags(node); + writePunctuation("{"); + if (emitFlags & 1 /* EmitFlags.SingleLine */) { + writeSpace(); + } + else { + writeLine(); + increaseIndent(); + } + if (node.readonlyToken) { + emit(node.readonlyToken); + if (node.readonlyToken.kind !== 146 /* SyntaxKind.ReadonlyKeyword */) { + writeKeyword("readonly"); + } + writeSpace(); + } + writePunctuation("["); + pipelineEmit(3 /* EmitHint.MappedTypeParameter */, node.typeParameter); + if (node.nameType) { + writeSpace(); + writeKeyword("as"); + writeSpace(); + emit(node.nameType); + } + writePunctuation("]"); + if (node.questionToken) { + emit(node.questionToken); + if (node.questionToken.kind !== 57 /* SyntaxKind.QuestionToken */) { + writePunctuation("?"); + } + } + writePunctuation(":"); + writeSpace(); + emit(node.type); + writeTrailingSemicolon(); + if (emitFlags & 1 /* EmitFlags.SingleLine */) { + writeSpace(); + } + else { + writeLine(); + decreaseIndent(); + } + emitList(node, node.members, 2 /* ListFormat.PreserveLines */); + writePunctuation("}"); + } + function emitLiteralType(node) { + emitExpression(node.literal); + } + function emitTemplateType(node) { + emit(node.head); + emitList(node, node.templateSpans, 262144 /* ListFormat.TemplateExpressionSpans */); + } + function emitImportTypeNode(node) { + if (node.isTypeOf) { + writeKeyword("typeof"); + writeSpace(); + } + writeKeyword("import"); + writePunctuation("("); + emit(node.argument); + if (node.assertions) { + writePunctuation(","); + writeSpace(); + writePunctuation("{"); + writeSpace(); + writeKeyword("assert"); + writePunctuation(":"); + writeSpace(); + var elements = node.assertions.assertClause.elements; + emitList(node.assertions.assertClause, elements, 526226 /* ListFormat.ImportClauseEntries */); + writeSpace(); + writePunctuation("}"); + } + writePunctuation(")"); + if (node.qualifier) { + writePunctuation("."); + emit(node.qualifier); + } + emitTypeArguments(node, node.typeArguments); + } + // + // Binding patterns + // + function emitObjectBindingPattern(node) { + writePunctuation("{"); + emitList(node, node.elements, 525136 /* ListFormat.ObjectBindingPatternElements */); + writePunctuation("}"); + } + function emitArrayBindingPattern(node) { + writePunctuation("["); + emitList(node, node.elements, 524880 /* ListFormat.ArrayBindingPatternElements */); + writePunctuation("]"); + } + function emitBindingElement(node) { + emit(node.dotDotDotToken); + if (node.propertyName) { + emit(node.propertyName); + writePunctuation(":"); + writeSpace(); + } + emit(node.name); + emitInitializer(node.initializer, node.name.end, node, parenthesizer.parenthesizeExpressionForDisallowedComma); + } + // + // Expressions + // + function emitArrayLiteralExpression(node) { + var elements = node.elements; + var preferNewLine = node.multiLine ? 65536 /* ListFormat.PreferNewLine */ : 0 /* ListFormat.None */; + emitExpressionList(node, elements, 8914 /* ListFormat.ArrayLiteralExpressionElements */ | preferNewLine, parenthesizer.parenthesizeExpressionForDisallowedComma); + } + function emitObjectLiteralExpression(node) { + ts.forEach(node.properties, generateMemberNames); + var indentedFlag = ts.getEmitFlags(node) & 65536 /* EmitFlags.Indented */; + if (indentedFlag) { + increaseIndent(); + } + var preferNewLine = node.multiLine ? 65536 /* ListFormat.PreferNewLine */ : 0 /* ListFormat.None */; + var allowTrailingComma = currentSourceFile && currentSourceFile.languageVersion >= 1 /* ScriptTarget.ES5 */ && !ts.isJsonSourceFile(currentSourceFile) ? 64 /* ListFormat.AllowTrailingComma */ : 0 /* ListFormat.None */; + emitList(node, node.properties, 526226 /* ListFormat.ObjectLiteralExpressionProperties */ | allowTrailingComma | preferNewLine); + if (indentedFlag) { + decreaseIndent(); + } + } + function emitPropertyAccessExpression(node) { + emitExpression(node.expression, parenthesizer.parenthesizeLeftSideOfAccess); + var token = node.questionDotToken || ts.setTextRangePosEnd(ts.factory.createToken(24 /* SyntaxKind.DotToken */), node.expression.end, node.name.pos); + var linesBeforeDot = getLinesBetweenNodes(node, node.expression, token); + var linesAfterDot = getLinesBetweenNodes(node, token, node.name); + writeLinesAndIndent(linesBeforeDot, /*writeSpaceIfNotIndenting*/ false); + var shouldEmitDotDot = token.kind !== 28 /* SyntaxKind.QuestionDotToken */ && + mayNeedDotDotForPropertyAccess(node.expression) && + !writer.hasTrailingComment() && + !writer.hasTrailingWhitespace(); + if (shouldEmitDotDot) { + writePunctuation("."); + } + if (node.questionDotToken) { + emit(token); + } + else { + emitTokenWithComment(token.kind, node.expression.end, writePunctuation, node); + } + writeLinesAndIndent(linesAfterDot, /*writeSpaceIfNotIndenting*/ false); + emit(node.name); + decreaseIndentIf(linesBeforeDot, linesAfterDot); + } + // 1..toString is a valid property access, emit a dot after the literal + // Also emit a dot if expression is a integer const enum value - it will appear in generated code as numeric literal + function mayNeedDotDotForPropertyAccess(expression) { + expression = ts.skipPartiallyEmittedExpressions(expression); + if (ts.isNumericLiteral(expression)) { + // check if numeric literal is a decimal literal that was originally written with a dot + var text = getLiteralTextOfNode(expression, /*neverAsciiEscape*/ true, /*jsxAttributeEscape*/ false); + // If he number will be printed verbatim and it doesn't already contain a dot, add one + // if the expression doesn't have any comments that will be emitted. + return !expression.numericLiteralFlags && !ts.stringContains(text, ts.tokenToString(24 /* SyntaxKind.DotToken */)); + } + else if (ts.isAccessExpression(expression)) { + // check if constant enum value is integer + var constantValue = ts.getConstantValue(expression); + // isFinite handles cases when constantValue is undefined + return typeof constantValue === "number" && isFinite(constantValue) + && Math.floor(constantValue) === constantValue; + } + } + function emitElementAccessExpression(node) { + emitExpression(node.expression, parenthesizer.parenthesizeLeftSideOfAccess); + emit(node.questionDotToken); + emitTokenWithComment(22 /* SyntaxKind.OpenBracketToken */, node.expression.end, writePunctuation, node); + emitExpression(node.argumentExpression); + emitTokenWithComment(23 /* SyntaxKind.CloseBracketToken */, node.argumentExpression.end, writePunctuation, node); + } + function emitCallExpression(node) { + var indirectCall = ts.getEmitFlags(node) & 536870912 /* EmitFlags.IndirectCall */; + if (indirectCall) { + writePunctuation("("); + writeLiteral("0"); + writePunctuation(","); + writeSpace(); + } + emitExpression(node.expression, parenthesizer.parenthesizeLeftSideOfAccess); + if (indirectCall) { + writePunctuation(")"); + } + emit(node.questionDotToken); + emitTypeArguments(node, node.typeArguments); + emitExpressionList(node, node.arguments, 2576 /* ListFormat.CallExpressionArguments */, parenthesizer.parenthesizeExpressionForDisallowedComma); + } + function emitNewExpression(node) { + emitTokenWithComment(103 /* SyntaxKind.NewKeyword */, node.pos, writeKeyword, node); + writeSpace(); + emitExpression(node.expression, parenthesizer.parenthesizeExpressionOfNew); + emitTypeArguments(node, node.typeArguments); + emitExpressionList(node, node.arguments, 18960 /* ListFormat.NewExpressionArguments */, parenthesizer.parenthesizeExpressionForDisallowedComma); + } + function emitTaggedTemplateExpression(node) { + var indirectCall = ts.getEmitFlags(node) & 536870912 /* EmitFlags.IndirectCall */; + if (indirectCall) { + writePunctuation("("); + writeLiteral("0"); + writePunctuation(","); + writeSpace(); + } + emitExpression(node.tag, parenthesizer.parenthesizeLeftSideOfAccess); + if (indirectCall) { + writePunctuation(")"); + } + emitTypeArguments(node, node.typeArguments); + writeSpace(); + emitExpression(node.template); + } + function emitTypeAssertionExpression(node) { + writePunctuation("<"); + emit(node.type); + writePunctuation(">"); + emitExpression(node.expression, parenthesizer.parenthesizeOperandOfPrefixUnary); + } + function emitParenthesizedExpression(node) { + var openParenPos = emitTokenWithComment(20 /* SyntaxKind.OpenParenToken */, node.pos, writePunctuation, node); + var indented = writeLineSeparatorsAndIndentBefore(node.expression, node); + emitExpression(node.expression, /*parenthesizerRules*/ undefined); + writeLineSeparatorsAfter(node.expression, node); + decreaseIndentIf(indented); + emitTokenWithComment(21 /* SyntaxKind.CloseParenToken */, node.expression ? node.expression.end : openParenPos, writePunctuation, node); + } + function emitFunctionExpression(node) { + generateNameIfNeeded(node.name); + emitFunctionDeclarationOrExpression(node); + } + function emitArrowFunction(node) { + emitModifiers(node, node.modifiers); + emitSignatureAndBody(node, emitArrowFunctionHead); + } + function emitArrowFunctionHead(node) { + emitTypeParameters(node, node.typeParameters); + emitParametersForArrow(node, node.parameters); + emitTypeAnnotation(node.type); + writeSpace(); + emit(node.equalsGreaterThanToken); + } + function emitDeleteExpression(node) { + emitTokenWithComment(89 /* SyntaxKind.DeleteKeyword */, node.pos, writeKeyword, node); + writeSpace(); + emitExpression(node.expression, parenthesizer.parenthesizeOperandOfPrefixUnary); + } + function emitTypeOfExpression(node) { + emitTokenWithComment(112 /* SyntaxKind.TypeOfKeyword */, node.pos, writeKeyword, node); + writeSpace(); + emitExpression(node.expression, parenthesizer.parenthesizeOperandOfPrefixUnary); + } + function emitVoidExpression(node) { + emitTokenWithComment(114 /* SyntaxKind.VoidKeyword */, node.pos, writeKeyword, node); + writeSpace(); + emitExpression(node.expression, parenthesizer.parenthesizeOperandOfPrefixUnary); + } + function emitAwaitExpression(node) { + emitTokenWithComment(133 /* SyntaxKind.AwaitKeyword */, node.pos, writeKeyword, node); + writeSpace(); + emitExpression(node.expression, parenthesizer.parenthesizeOperandOfPrefixUnary); + } + function emitPrefixUnaryExpression(node) { + writeTokenText(node.operator, writeOperator); + if (shouldEmitWhitespaceBeforeOperand(node)) { + writeSpace(); + } + emitExpression(node.operand, parenthesizer.parenthesizeOperandOfPrefixUnary); + } + function shouldEmitWhitespaceBeforeOperand(node) { + // In some cases, we need to emit a space between the operator and the operand. One obvious case + // is when the operator is an identifier, like delete or typeof. We also need to do this for plus + // and minus expressions in certain cases. Specifically, consider the following two cases (parens + // are just for clarity of exposition, and not part of the source code): + // + // (+(+1)) + // (+(++1)) + // + // We need to emit a space in both cases. In the first case, the absence of a space will make + // the resulting expression a prefix increment operation. And in the second, it will make the resulting + // expression a prefix increment whose operand is a plus expression - (++(+x)) + // The same is true of minus of course. + var operand = node.operand; + return operand.kind === 221 /* SyntaxKind.PrefixUnaryExpression */ + && ((node.operator === 39 /* SyntaxKind.PlusToken */ && (operand.operator === 39 /* SyntaxKind.PlusToken */ || operand.operator === 45 /* SyntaxKind.PlusPlusToken */)) + || (node.operator === 40 /* SyntaxKind.MinusToken */ && (operand.operator === 40 /* SyntaxKind.MinusToken */ || operand.operator === 46 /* SyntaxKind.MinusMinusToken */))); + } + function emitPostfixUnaryExpression(node) { + emitExpression(node.operand, parenthesizer.parenthesizeOperandOfPostfixUnary); + writeTokenText(node.operator, writeOperator); + } + function createEmitBinaryExpression() { + return ts.createBinaryExpressionTrampoline(onEnter, onLeft, onOperator, onRight, onExit, /*foldState*/ undefined); + function onEnter(node, state) { + if (state) { + state.stackIndex++; + state.preserveSourceNewlinesStack[state.stackIndex] = preserveSourceNewlines; + state.containerPosStack[state.stackIndex] = containerPos; + state.containerEndStack[state.stackIndex] = containerEnd; + state.declarationListContainerEndStack[state.stackIndex] = declarationListContainerEnd; + var emitComments_1 = state.shouldEmitCommentsStack[state.stackIndex] = shouldEmitComments(node); + var emitSourceMaps = state.shouldEmitSourceMapsStack[state.stackIndex] = shouldEmitSourceMaps(node); + onBeforeEmitNode === null || onBeforeEmitNode === void 0 ? void 0 : onBeforeEmitNode(node); + if (emitComments_1) + emitCommentsBeforeNode(node); + if (emitSourceMaps) + emitSourceMapsBeforeNode(node); + beforeEmitNode(node); + } + else { + state = { + stackIndex: 0, + preserveSourceNewlinesStack: [undefined], + containerPosStack: [-1], + containerEndStack: [-1], + declarationListContainerEndStack: [-1], + shouldEmitCommentsStack: [false], + shouldEmitSourceMapsStack: [false], + }; + } + return state; + } + function onLeft(next, _workArea, parent) { + return maybeEmitExpression(next, parent, "left"); + } + function onOperator(operatorToken, _state, node) { + var isCommaOperator = operatorToken.kind !== 27 /* SyntaxKind.CommaToken */; + var linesBeforeOperator = getLinesBetweenNodes(node, node.left, operatorToken); + var linesAfterOperator = getLinesBetweenNodes(node, operatorToken, node.right); + writeLinesAndIndent(linesBeforeOperator, isCommaOperator); + emitLeadingCommentsOfPosition(operatorToken.pos); + writeTokenNode(operatorToken, operatorToken.kind === 101 /* SyntaxKind.InKeyword */ ? writeKeyword : writeOperator); + emitTrailingCommentsOfPosition(operatorToken.end, /*prefixSpace*/ true); // Binary operators should have a space before the comment starts + writeLinesAndIndent(linesAfterOperator, /*writeSpaceIfNotIndenting*/ true); + } + function onRight(next, _workArea, parent) { + return maybeEmitExpression(next, parent, "right"); + } + function onExit(node, state) { + var linesBeforeOperator = getLinesBetweenNodes(node, node.left, node.operatorToken); + var linesAfterOperator = getLinesBetweenNodes(node, node.operatorToken, node.right); + decreaseIndentIf(linesBeforeOperator, linesAfterOperator); + if (state.stackIndex > 0) { + var savedPreserveSourceNewlines = state.preserveSourceNewlinesStack[state.stackIndex]; + var savedContainerPos = state.containerPosStack[state.stackIndex]; + var savedContainerEnd = state.containerEndStack[state.stackIndex]; + var savedDeclarationListContainerEnd = state.declarationListContainerEndStack[state.stackIndex]; + var shouldEmitComments_1 = state.shouldEmitCommentsStack[state.stackIndex]; + var shouldEmitSourceMaps_1 = state.shouldEmitSourceMapsStack[state.stackIndex]; + afterEmitNode(savedPreserveSourceNewlines); + if (shouldEmitSourceMaps_1) + emitSourceMapsAfterNode(node); + if (shouldEmitComments_1) + emitCommentsAfterNode(node, savedContainerPos, savedContainerEnd, savedDeclarationListContainerEnd); + onAfterEmitNode === null || onAfterEmitNode === void 0 ? void 0 : onAfterEmitNode(node); + state.stackIndex--; + } + } + function maybeEmitExpression(next, parent, side) { + var parenthesizerRule = side === "left" ? + parenthesizer.getParenthesizeLeftSideOfBinaryForOperator(parent.operatorToken.kind) : + parenthesizer.getParenthesizeRightSideOfBinaryForOperator(parent.operatorToken.kind); + var pipelinePhase = getPipelinePhase(0 /* PipelinePhase.Notification */, 1 /* EmitHint.Expression */, next); + if (pipelinePhase === pipelineEmitWithSubstitution) { + ts.Debug.assertIsDefined(lastSubstitution); + next = parenthesizerRule(ts.cast(lastSubstitution, ts.isExpression)); + pipelinePhase = getNextPipelinePhase(1 /* PipelinePhase.Substitution */, 1 /* EmitHint.Expression */, next); + lastSubstitution = undefined; + } + if (pipelinePhase === pipelineEmitWithComments || + pipelinePhase === pipelineEmitWithSourceMaps || + pipelinePhase === pipelineEmitWithHint) { + if (ts.isBinaryExpression(next)) { + return next; + } + } + currentParenthesizerRule = parenthesizerRule; + pipelinePhase(1 /* EmitHint.Expression */, next); + } + } + function emitConditionalExpression(node) { + var linesBeforeQuestion = getLinesBetweenNodes(node, node.condition, node.questionToken); + var linesAfterQuestion = getLinesBetweenNodes(node, node.questionToken, node.whenTrue); + var linesBeforeColon = getLinesBetweenNodes(node, node.whenTrue, node.colonToken); + var linesAfterColon = getLinesBetweenNodes(node, node.colonToken, node.whenFalse); + emitExpression(node.condition, parenthesizer.parenthesizeConditionOfConditionalExpression); + writeLinesAndIndent(linesBeforeQuestion, /*writeSpaceIfNotIndenting*/ true); + emit(node.questionToken); + writeLinesAndIndent(linesAfterQuestion, /*writeSpaceIfNotIndenting*/ true); + emitExpression(node.whenTrue, parenthesizer.parenthesizeBranchOfConditionalExpression); + decreaseIndentIf(linesBeforeQuestion, linesAfterQuestion); + writeLinesAndIndent(linesBeforeColon, /*writeSpaceIfNotIndenting*/ true); + emit(node.colonToken); + writeLinesAndIndent(linesAfterColon, /*writeSpaceIfNotIndenting*/ true); + emitExpression(node.whenFalse, parenthesizer.parenthesizeBranchOfConditionalExpression); + decreaseIndentIf(linesBeforeColon, linesAfterColon); + } + function emitTemplateExpression(node) { + emit(node.head); + emitList(node, node.templateSpans, 262144 /* ListFormat.TemplateExpressionSpans */); + } + function emitYieldExpression(node) { + emitTokenWithComment(125 /* SyntaxKind.YieldKeyword */, node.pos, writeKeyword, node); + emit(node.asteriskToken); + emitExpressionWithLeadingSpace(node.expression && parenthesizeExpressionForNoAsi(node.expression), parenthesizeExpressionForNoAsiAndDisallowedComma); + } + function emitSpreadElement(node) { + emitTokenWithComment(25 /* SyntaxKind.DotDotDotToken */, node.pos, writePunctuation, node); + emitExpression(node.expression, parenthesizer.parenthesizeExpressionForDisallowedComma); + } + function emitClassExpression(node) { + generateNameIfNeeded(node.name); + emitClassDeclarationOrExpression(node); + } + function emitExpressionWithTypeArguments(node) { + emitExpression(node.expression, parenthesizer.parenthesizeLeftSideOfAccess); + emitTypeArguments(node, node.typeArguments); + } + function emitAsExpression(node) { + emitExpression(node.expression, /*parenthesizerRules*/ undefined); + if (node.type) { + writeSpace(); + writeKeyword("as"); + writeSpace(); + emit(node.type); + } + } + function emitNonNullExpression(node) { + emitExpression(node.expression, parenthesizer.parenthesizeLeftSideOfAccess); + writeOperator("!"); + } + function emitSatisfiesExpression(node) { + emitExpression(node.expression, /*parenthesizerRules*/ undefined); + if (node.type) { + writeSpace(); + writeKeyword("satisfies"); + writeSpace(); + emit(node.type); + } + } + function emitMetaProperty(node) { + writeToken(node.keywordToken, node.pos, writePunctuation); + writePunctuation("."); + emit(node.name); + } + // + // Misc + // + function emitTemplateSpan(node) { + emitExpression(node.expression); + emit(node.literal); + } + // + // Statements + // + function emitBlock(node) { + emitBlockStatements(node, /*forceSingleLine*/ !node.multiLine && isEmptyBlock(node)); + } + function emitBlockStatements(node, forceSingleLine) { + emitTokenWithComment(18 /* SyntaxKind.OpenBraceToken */, node.pos, writePunctuation, /*contextNode*/ node); + var format = forceSingleLine || ts.getEmitFlags(node) & 1 /* EmitFlags.SingleLine */ ? 768 /* ListFormat.SingleLineBlockStatements */ : 129 /* ListFormat.MultiLineBlockStatements */; + emitList(node, node.statements, format); + emitTokenWithComment(19 /* SyntaxKind.CloseBraceToken */, node.statements.end, writePunctuation, /*contextNode*/ node, /*indentLeading*/ !!(format & 1 /* ListFormat.MultiLine */)); + } + function emitVariableStatement(node) { + emitModifiers(node, node.modifiers); + emit(node.declarationList); + writeTrailingSemicolon(); + } + function emitEmptyStatement(isEmbeddedStatement) { + // While most trailing semicolons are possibly insignificant, an embedded "empty" + // statement is significant and cannot be elided by a trailing-semicolon-omitting writer. + if (isEmbeddedStatement) { + writePunctuation(";"); + } + else { + writeTrailingSemicolon(); + } + } + function emitExpressionStatement(node) { + emitExpression(node.expression, parenthesizer.parenthesizeExpressionOfExpressionStatement); + // Emit semicolon in non json files + // or if json file that created synthesized expression(eg.define expression statement when --out and amd code generation) + if (!currentSourceFile || !ts.isJsonSourceFile(currentSourceFile) || ts.nodeIsSynthesized(node.expression)) { + writeTrailingSemicolon(); + } + } + function emitIfStatement(node) { + var openParenPos = emitTokenWithComment(99 /* SyntaxKind.IfKeyword */, node.pos, writeKeyword, node); + writeSpace(); + emitTokenWithComment(20 /* SyntaxKind.OpenParenToken */, openParenPos, writePunctuation, node); + emitExpression(node.expression); + emitTokenWithComment(21 /* SyntaxKind.CloseParenToken */, node.expression.end, writePunctuation, node); + emitEmbeddedStatement(node, node.thenStatement); + if (node.elseStatement) { + writeLineOrSpace(node, node.thenStatement, node.elseStatement); + emitTokenWithComment(91 /* SyntaxKind.ElseKeyword */, node.thenStatement.end, writeKeyword, node); + if (node.elseStatement.kind === 242 /* SyntaxKind.IfStatement */) { + writeSpace(); + emit(node.elseStatement); + } + else { + emitEmbeddedStatement(node, node.elseStatement); + } + } + } + function emitWhileClause(node, startPos) { + var openParenPos = emitTokenWithComment(115 /* SyntaxKind.WhileKeyword */, startPos, writeKeyword, node); + writeSpace(); + emitTokenWithComment(20 /* SyntaxKind.OpenParenToken */, openParenPos, writePunctuation, node); + emitExpression(node.expression); + emitTokenWithComment(21 /* SyntaxKind.CloseParenToken */, node.expression.end, writePunctuation, node); + } + function emitDoStatement(node) { + emitTokenWithComment(90 /* SyntaxKind.DoKeyword */, node.pos, writeKeyword, node); + emitEmbeddedStatement(node, node.statement); + if (ts.isBlock(node.statement) && !preserveSourceNewlines) { + writeSpace(); + } + else { + writeLineOrSpace(node, node.statement, node.expression); + } + emitWhileClause(node, node.statement.end); + writeTrailingSemicolon(); + } + function emitWhileStatement(node) { + emitWhileClause(node, node.pos); + emitEmbeddedStatement(node, node.statement); + } + function emitForStatement(node) { + var openParenPos = emitTokenWithComment(97 /* SyntaxKind.ForKeyword */, node.pos, writeKeyword, node); + writeSpace(); + var pos = emitTokenWithComment(20 /* SyntaxKind.OpenParenToken */, openParenPos, writePunctuation, /*contextNode*/ node); + emitForBinding(node.initializer); + pos = emitTokenWithComment(26 /* SyntaxKind.SemicolonToken */, node.initializer ? node.initializer.end : pos, writePunctuation, node); + emitExpressionWithLeadingSpace(node.condition); + pos = emitTokenWithComment(26 /* SyntaxKind.SemicolonToken */, node.condition ? node.condition.end : pos, writePunctuation, node); + emitExpressionWithLeadingSpace(node.incrementor); + emitTokenWithComment(21 /* SyntaxKind.CloseParenToken */, node.incrementor ? node.incrementor.end : pos, writePunctuation, node); + emitEmbeddedStatement(node, node.statement); + } + function emitForInStatement(node) { + var openParenPos = emitTokenWithComment(97 /* SyntaxKind.ForKeyword */, node.pos, writeKeyword, node); + writeSpace(); + emitTokenWithComment(20 /* SyntaxKind.OpenParenToken */, openParenPos, writePunctuation, node); + emitForBinding(node.initializer); + writeSpace(); + emitTokenWithComment(101 /* SyntaxKind.InKeyword */, node.initializer.end, writeKeyword, node); + writeSpace(); + emitExpression(node.expression); + emitTokenWithComment(21 /* SyntaxKind.CloseParenToken */, node.expression.end, writePunctuation, node); + emitEmbeddedStatement(node, node.statement); + } + function emitForOfStatement(node) { + var openParenPos = emitTokenWithComment(97 /* SyntaxKind.ForKeyword */, node.pos, writeKeyword, node); + writeSpace(); + emitWithTrailingSpace(node.awaitModifier); + emitTokenWithComment(20 /* SyntaxKind.OpenParenToken */, openParenPos, writePunctuation, node); + emitForBinding(node.initializer); + writeSpace(); + emitTokenWithComment(162 /* SyntaxKind.OfKeyword */, node.initializer.end, writeKeyword, node); + writeSpace(); + emitExpression(node.expression); + emitTokenWithComment(21 /* SyntaxKind.CloseParenToken */, node.expression.end, writePunctuation, node); + emitEmbeddedStatement(node, node.statement); + } + function emitForBinding(node) { + if (node !== undefined) { + if (node.kind === 258 /* SyntaxKind.VariableDeclarationList */) { + emit(node); + } + else { + emitExpression(node); + } + } + } + function emitContinueStatement(node) { + emitTokenWithComment(86 /* SyntaxKind.ContinueKeyword */, node.pos, writeKeyword, node); + emitWithLeadingSpace(node.label); + writeTrailingSemicolon(); + } + function emitBreakStatement(node) { + emitTokenWithComment(81 /* SyntaxKind.BreakKeyword */, node.pos, writeKeyword, node); + emitWithLeadingSpace(node.label); + writeTrailingSemicolon(); + } + function emitTokenWithComment(token, pos, writer, contextNode, indentLeading) { + var node = ts.getParseTreeNode(contextNode); + var isSimilarNode = node && node.kind === contextNode.kind; + var startPos = pos; + if (isSimilarNode && currentSourceFile) { + pos = ts.skipTrivia(currentSourceFile.text, pos); + } + if (isSimilarNode && contextNode.pos !== startPos) { + var needsIndent = indentLeading && currentSourceFile && !ts.positionsAreOnSameLine(startPos, pos, currentSourceFile); + if (needsIndent) { + increaseIndent(); + } + emitLeadingCommentsOfPosition(startPos); + if (needsIndent) { + decreaseIndent(); + } + } + pos = writeTokenText(token, writer, pos); + if (isSimilarNode && contextNode.end !== pos) { + var isJsxExprContext = contextNode.kind === 291 /* SyntaxKind.JsxExpression */; + emitTrailingCommentsOfPosition(pos, /*prefixSpace*/ !isJsxExprContext, /*forceNoNewline*/ isJsxExprContext); + } + return pos; + } + function commentWillEmitNewLine(node) { + return node.kind === 2 /* SyntaxKind.SingleLineCommentTrivia */ || !!node.hasTrailingNewLine; + } + function willEmitLeadingNewLine(node) { + if (!currentSourceFile) + return false; + if (ts.some(ts.getLeadingCommentRanges(currentSourceFile.text, node.pos), commentWillEmitNewLine)) + return true; + if (ts.some(ts.getSyntheticLeadingComments(node), commentWillEmitNewLine)) + return true; + if (ts.isPartiallyEmittedExpression(node)) { + if (node.pos !== node.expression.pos) { + if (ts.some(ts.getTrailingCommentRanges(currentSourceFile.text, node.expression.pos), commentWillEmitNewLine)) + return true; + } + return willEmitLeadingNewLine(node.expression); + } + return false; + } + /** + * Wraps an expression in parens if we would emit a leading comment that would introduce a line separator + * between the node and its parent. + */ + function parenthesizeExpressionForNoAsi(node) { + if (!commentsDisabled && ts.isPartiallyEmittedExpression(node) && willEmitLeadingNewLine(node)) { + var parseNode = ts.getParseTreeNode(node); + if (parseNode && ts.isParenthesizedExpression(parseNode)) { + // If the original node was a parenthesized expression, restore it to preserve comment and source map emit + var parens = ts.factory.createParenthesizedExpression(node.expression); + ts.setOriginalNode(parens, node); + ts.setTextRange(parens, parseNode); + return parens; + } + return ts.factory.createParenthesizedExpression(node); + } + return node; + } + function parenthesizeExpressionForNoAsiAndDisallowedComma(node) { + return parenthesizeExpressionForNoAsi(parenthesizer.parenthesizeExpressionForDisallowedComma(node)); + } + function emitReturnStatement(node) { + emitTokenWithComment(105 /* SyntaxKind.ReturnKeyword */, node.pos, writeKeyword, /*contextNode*/ node); + emitExpressionWithLeadingSpace(node.expression && parenthesizeExpressionForNoAsi(node.expression), parenthesizeExpressionForNoAsi); + writeTrailingSemicolon(); + } + function emitWithStatement(node) { + var openParenPos = emitTokenWithComment(116 /* SyntaxKind.WithKeyword */, node.pos, writeKeyword, node); + writeSpace(); + emitTokenWithComment(20 /* SyntaxKind.OpenParenToken */, openParenPos, writePunctuation, node); + emitExpression(node.expression); + emitTokenWithComment(21 /* SyntaxKind.CloseParenToken */, node.expression.end, writePunctuation, node); + emitEmbeddedStatement(node, node.statement); + } + function emitSwitchStatement(node) { + var openParenPos = emitTokenWithComment(107 /* SyntaxKind.SwitchKeyword */, node.pos, writeKeyword, node); + writeSpace(); + emitTokenWithComment(20 /* SyntaxKind.OpenParenToken */, openParenPos, writePunctuation, node); + emitExpression(node.expression); + emitTokenWithComment(21 /* SyntaxKind.CloseParenToken */, node.expression.end, writePunctuation, node); + writeSpace(); + emit(node.caseBlock); + } + function emitLabeledStatement(node) { + emit(node.label); + emitTokenWithComment(58 /* SyntaxKind.ColonToken */, node.label.end, writePunctuation, node); + writeSpace(); + emit(node.statement); + } + function emitThrowStatement(node) { + emitTokenWithComment(109 /* SyntaxKind.ThrowKeyword */, node.pos, writeKeyword, node); + emitExpressionWithLeadingSpace(parenthesizeExpressionForNoAsi(node.expression), parenthesizeExpressionForNoAsi); + writeTrailingSemicolon(); + } + function emitTryStatement(node) { + emitTokenWithComment(111 /* SyntaxKind.TryKeyword */, node.pos, writeKeyword, node); + writeSpace(); + emit(node.tryBlock); + if (node.catchClause) { + writeLineOrSpace(node, node.tryBlock, node.catchClause); + emit(node.catchClause); + } + if (node.finallyBlock) { + writeLineOrSpace(node, node.catchClause || node.tryBlock, node.finallyBlock); + emitTokenWithComment(96 /* SyntaxKind.FinallyKeyword */, (node.catchClause || node.tryBlock).end, writeKeyword, node); + writeSpace(); + emit(node.finallyBlock); + } + } + function emitDebuggerStatement(node) { + writeToken(87 /* SyntaxKind.DebuggerKeyword */, node.pos, writeKeyword); + writeTrailingSemicolon(); + } + // + // Declarations + // + function emitVariableDeclaration(node) { + var _a, _b, _c, _d, _e; + emit(node.name); + emit(node.exclamationToken); + emitTypeAnnotation(node.type); + emitInitializer(node.initializer, (_e = (_b = (_a = node.type) === null || _a === void 0 ? void 0 : _a.end) !== null && _b !== void 0 ? _b : (_d = (_c = node.name.emitNode) === null || _c === void 0 ? void 0 : _c.typeNode) === null || _d === void 0 ? void 0 : _d.end) !== null && _e !== void 0 ? _e : node.name.end, node, parenthesizer.parenthesizeExpressionForDisallowedComma); + } + function emitVariableDeclarationList(node) { + writeKeyword(ts.isLet(node) ? "let" : ts.isVarConst(node) ? "const" : "var"); + writeSpace(); + emitList(node, node.declarations, 528 /* ListFormat.VariableDeclarationList */); + } + function emitFunctionDeclaration(node) { + emitFunctionDeclarationOrExpression(node); + } + function emitFunctionDeclarationOrExpression(node) { + emitModifiers(node, node.modifiers); + writeKeyword("function"); + emit(node.asteriskToken); + writeSpace(); + emitIdentifierName(node.name); + emitSignatureAndBody(node, emitSignatureHead); + } + function emitSignatureAndBody(node, emitSignatureHead) { + var body = node.body; + if (body) { + if (ts.isBlock(body)) { + var indentedFlag = ts.getEmitFlags(node) & 65536 /* EmitFlags.Indented */; + if (indentedFlag) { + increaseIndent(); + } + pushNameGenerationScope(node); + ts.forEach(node.parameters, generateNames); + generateNames(node.body); + emitSignatureHead(node); + emitBlockFunctionBody(body); + popNameGenerationScope(node); + if (indentedFlag) { + decreaseIndent(); + } + } + else { + emitSignatureHead(node); + writeSpace(); + emitExpression(body, parenthesizer.parenthesizeConciseBodyOfArrowFunction); + } + } + else { + emitSignatureHead(node); + writeTrailingSemicolon(); + } + } + function emitSignatureHead(node) { + emitTypeParameters(node, node.typeParameters); + emitParameters(node, node.parameters); + emitTypeAnnotation(node.type); + } + function shouldEmitBlockFunctionBodyOnSingleLine(body) { + // We must emit a function body as a single-line body in the following case: + // * The body has NodeEmitFlags.SingleLine specified. + // We must emit a function body as a multi-line body in the following cases: + // * The body is explicitly marked as multi-line. + // * A non-synthesized body's start and end position are on different lines. + // * Any statement in the body starts on a new line. + if (ts.getEmitFlags(body) & 1 /* EmitFlags.SingleLine */) { + return true; + } + if (body.multiLine) { + return false; + } + if (!ts.nodeIsSynthesized(body) && currentSourceFile && !ts.rangeIsOnSingleLine(body, currentSourceFile)) { + return false; + } + if (getLeadingLineTerminatorCount(body, ts.firstOrUndefined(body.statements), 2 /* ListFormat.PreserveLines */) + || getClosingLineTerminatorCount(body, ts.lastOrUndefined(body.statements), 2 /* ListFormat.PreserveLines */, body.statements)) { + return false; + } + var previousStatement; + for (var _a = 0, _b = body.statements; _a < _b.length; _a++) { + var statement = _b[_a]; + if (getSeparatingLineTerminatorCount(previousStatement, statement, 2 /* ListFormat.PreserveLines */) > 0) { + return false; + } + previousStatement = statement; + } + return true; + } + function emitBlockFunctionBody(body) { + onBeforeEmitNode === null || onBeforeEmitNode === void 0 ? void 0 : onBeforeEmitNode(body); + writeSpace(); + writePunctuation("{"); + increaseIndent(); + var emitBlockFunctionBody = shouldEmitBlockFunctionBodyOnSingleLine(body) + ? emitBlockFunctionBodyOnSingleLine + : emitBlockFunctionBodyWorker; + emitBodyWithDetachedComments(body, body.statements, emitBlockFunctionBody); + decreaseIndent(); + writeToken(19 /* SyntaxKind.CloseBraceToken */, body.statements.end, writePunctuation, body); + onAfterEmitNode === null || onAfterEmitNode === void 0 ? void 0 : onAfterEmitNode(body); + } + function emitBlockFunctionBodyOnSingleLine(body) { + emitBlockFunctionBodyWorker(body, /*emitBlockFunctionBodyOnSingleLine*/ true); + } + function emitBlockFunctionBodyWorker(body, emitBlockFunctionBodyOnSingleLine) { + // Emit all the prologue directives (like "use strict"). + var statementOffset = emitPrologueDirectives(body.statements); + var pos = writer.getTextPos(); + emitHelpers(body); + if (statementOffset === 0 && pos === writer.getTextPos() && emitBlockFunctionBodyOnSingleLine) { + decreaseIndent(); + emitList(body, body.statements, 768 /* ListFormat.SingleLineFunctionBodyStatements */); + increaseIndent(); + } + else { + emitList(body, body.statements, 1 /* ListFormat.MultiLineFunctionBodyStatements */, /*parenthesizerRule*/ undefined, statementOffset); + } + } + function emitClassDeclaration(node) { + emitClassDeclarationOrExpression(node); + } + function emitClassDeclarationOrExpression(node) { + ts.forEach(node.members, generateMemberNames); + emitDecoratorsAndModifiers(node, node.modifiers); + writeKeyword("class"); + if (node.name) { + writeSpace(); + emitIdentifierName(node.name); + } + var indentedFlag = ts.getEmitFlags(node) & 65536 /* EmitFlags.Indented */; + if (indentedFlag) { + increaseIndent(); + } + emitTypeParameters(node, node.typeParameters); + emitList(node, node.heritageClauses, 0 /* ListFormat.ClassHeritageClauses */); + writeSpace(); + writePunctuation("{"); + emitList(node, node.members, 129 /* ListFormat.ClassMembers */); + writePunctuation("}"); + if (indentedFlag) { + decreaseIndent(); + } + } + function emitInterfaceDeclaration(node) { + emitModifiers(node, node.modifiers); + writeKeyword("interface"); + writeSpace(); + emit(node.name); + emitTypeParameters(node, node.typeParameters); + emitList(node, node.heritageClauses, 512 /* ListFormat.HeritageClauses */); + writeSpace(); + writePunctuation("{"); + emitList(node, node.members, 129 /* ListFormat.InterfaceMembers */); + writePunctuation("}"); + } + function emitTypeAliasDeclaration(node) { + emitModifiers(node, node.modifiers); + writeKeyword("type"); + writeSpace(); + emit(node.name); + emitTypeParameters(node, node.typeParameters); + writeSpace(); + writePunctuation("="); + writeSpace(); + emit(node.type); + writeTrailingSemicolon(); + } + function emitEnumDeclaration(node) { + emitModifiers(node, node.modifiers); + writeKeyword("enum"); + writeSpace(); + emit(node.name); + writeSpace(); + writePunctuation("{"); + emitList(node, node.members, 145 /* ListFormat.EnumMembers */); + writePunctuation("}"); + } + function emitModuleDeclaration(node) { + emitModifiers(node, node.modifiers); + if (~node.flags & 1024 /* NodeFlags.GlobalAugmentation */) { + writeKeyword(node.flags & 16 /* NodeFlags.Namespace */ ? "namespace" : "module"); + writeSpace(); + } + emit(node.name); + var body = node.body; + if (!body) + return writeTrailingSemicolon(); + while (body && ts.isModuleDeclaration(body)) { + writePunctuation("."); + emit(body.name); + body = body.body; + } + writeSpace(); + emit(body); + } + function emitModuleBlock(node) { + pushNameGenerationScope(node); + ts.forEach(node.statements, generateNames); + emitBlockStatements(node, /*forceSingleLine*/ isEmptyBlock(node)); + popNameGenerationScope(node); + } + function emitCaseBlock(node) { + emitTokenWithComment(18 /* SyntaxKind.OpenBraceToken */, node.pos, writePunctuation, node); + emitList(node, node.clauses, 129 /* ListFormat.CaseBlockClauses */); + emitTokenWithComment(19 /* SyntaxKind.CloseBraceToken */, node.clauses.end, writePunctuation, node, /*indentLeading*/ true); + } + function emitImportEqualsDeclaration(node) { + emitModifiers(node, node.modifiers); + emitTokenWithComment(100 /* SyntaxKind.ImportKeyword */, node.modifiers ? node.modifiers.end : node.pos, writeKeyword, node); + writeSpace(); + if (node.isTypeOnly) { + emitTokenWithComment(154 /* SyntaxKind.TypeKeyword */, node.pos, writeKeyword, node); + writeSpace(); + } + emit(node.name); + writeSpace(); + emitTokenWithComment(63 /* SyntaxKind.EqualsToken */, node.name.end, writePunctuation, node); + writeSpace(); + emitModuleReference(node.moduleReference); + writeTrailingSemicolon(); + } + function emitModuleReference(node) { + if (node.kind === 79 /* SyntaxKind.Identifier */) { + emitExpression(node); + } + else { + emit(node); + } + } + function emitImportDeclaration(node) { + emitModifiers(node, node.modifiers); + emitTokenWithComment(100 /* SyntaxKind.ImportKeyword */, node.modifiers ? node.modifiers.end : node.pos, writeKeyword, node); + writeSpace(); + if (node.importClause) { + emit(node.importClause); + writeSpace(); + emitTokenWithComment(158 /* SyntaxKind.FromKeyword */, node.importClause.end, writeKeyword, node); + writeSpace(); + } + emitExpression(node.moduleSpecifier); + if (node.assertClause) { + emitWithLeadingSpace(node.assertClause); + } + writeTrailingSemicolon(); + } + function emitImportClause(node) { + if (node.isTypeOnly) { + emitTokenWithComment(154 /* SyntaxKind.TypeKeyword */, node.pos, writeKeyword, node); + writeSpace(); + } + emit(node.name); + if (node.name && node.namedBindings) { + emitTokenWithComment(27 /* SyntaxKind.CommaToken */, node.name.end, writePunctuation, node); + writeSpace(); + } + emit(node.namedBindings); + } + function emitNamespaceImport(node) { + var asPos = emitTokenWithComment(41 /* SyntaxKind.AsteriskToken */, node.pos, writePunctuation, node); + writeSpace(); + emitTokenWithComment(128 /* SyntaxKind.AsKeyword */, asPos, writeKeyword, node); + writeSpace(); + emit(node.name); + } + function emitNamedImports(node) { + emitNamedImportsOrExports(node); + } + function emitImportSpecifier(node) { + emitImportOrExportSpecifier(node); + } + function emitExportAssignment(node) { + var nextPos = emitTokenWithComment(93 /* SyntaxKind.ExportKeyword */, node.pos, writeKeyword, node); + writeSpace(); + if (node.isExportEquals) { + emitTokenWithComment(63 /* SyntaxKind.EqualsToken */, nextPos, writeOperator, node); + } + else { + emitTokenWithComment(88 /* SyntaxKind.DefaultKeyword */, nextPos, writeKeyword, node); + } + writeSpace(); + emitExpression(node.expression, node.isExportEquals ? + parenthesizer.getParenthesizeRightSideOfBinaryForOperator(63 /* SyntaxKind.EqualsToken */) : + parenthesizer.parenthesizeExpressionOfExportDefault); + writeTrailingSemicolon(); + } + function emitExportDeclaration(node) { + emitModifiers(node, node.modifiers); + var nextPos = emitTokenWithComment(93 /* SyntaxKind.ExportKeyword */, node.pos, writeKeyword, node); + writeSpace(); + if (node.isTypeOnly) { + nextPos = emitTokenWithComment(154 /* SyntaxKind.TypeKeyword */, nextPos, writeKeyword, node); + writeSpace(); + } + if (node.exportClause) { + emit(node.exportClause); + } + else { + nextPos = emitTokenWithComment(41 /* SyntaxKind.AsteriskToken */, nextPos, writePunctuation, node); + } + if (node.moduleSpecifier) { + writeSpace(); + var fromPos = node.exportClause ? node.exportClause.end : nextPos; + emitTokenWithComment(158 /* SyntaxKind.FromKeyword */, fromPos, writeKeyword, node); + writeSpace(); + emitExpression(node.moduleSpecifier); + } + if (node.assertClause) { + emitWithLeadingSpace(node.assertClause); + } + writeTrailingSemicolon(); + } + function emitAssertClause(node) { + emitTokenWithComment(130 /* SyntaxKind.AssertKeyword */, node.pos, writeKeyword, node); + writeSpace(); + var elements = node.elements; + emitList(node, elements, 526226 /* ListFormat.ImportClauseEntries */); + } + function emitAssertEntry(node) { + emit(node.name); + writePunctuation(":"); + writeSpace(); + var value = node.value; + /** @see {emitPropertyAssignment} */ + if ((ts.getEmitFlags(value) & 512 /* EmitFlags.NoLeadingComments */) === 0) { + var commentRange = ts.getCommentRange(value); + emitTrailingCommentsOfPosition(commentRange.pos); + } + emit(value); + } + function emitNamespaceExportDeclaration(node) { + var nextPos = emitTokenWithComment(93 /* SyntaxKind.ExportKeyword */, node.pos, writeKeyword, node); + writeSpace(); + nextPos = emitTokenWithComment(128 /* SyntaxKind.AsKeyword */, nextPos, writeKeyword, node); + writeSpace(); + nextPos = emitTokenWithComment(143 /* SyntaxKind.NamespaceKeyword */, nextPos, writeKeyword, node); + writeSpace(); + emit(node.name); + writeTrailingSemicolon(); + } + function emitNamespaceExport(node) { + var asPos = emitTokenWithComment(41 /* SyntaxKind.AsteriskToken */, node.pos, writePunctuation, node); + writeSpace(); + emitTokenWithComment(128 /* SyntaxKind.AsKeyword */, asPos, writeKeyword, node); + writeSpace(); + emit(node.name); + } + function emitNamedExports(node) { + emitNamedImportsOrExports(node); + } + function emitExportSpecifier(node) { + emitImportOrExportSpecifier(node); + } + function emitNamedImportsOrExports(node) { + writePunctuation("{"); + emitList(node, node.elements, 525136 /* ListFormat.NamedImportsOrExportsElements */); + writePunctuation("}"); + } + function emitImportOrExportSpecifier(node) { + if (node.isTypeOnly) { + writeKeyword("type"); + writeSpace(); + } + if (node.propertyName) { + emit(node.propertyName); + writeSpace(); + emitTokenWithComment(128 /* SyntaxKind.AsKeyword */, node.propertyName.end, writeKeyword, node); + writeSpace(); + } + emit(node.name); + } + // + // Module references + // + function emitExternalModuleReference(node) { + writeKeyword("require"); + writePunctuation("("); + emitExpression(node.expression); + writePunctuation(")"); + } + // + // JSX + // + function emitJsxElement(node) { + emit(node.openingElement); + emitList(node, node.children, 262144 /* ListFormat.JsxElementOrFragmentChildren */); + emit(node.closingElement); + } + function emitJsxSelfClosingElement(node) { + writePunctuation("<"); + emitJsxTagName(node.tagName); + emitTypeArguments(node, node.typeArguments); + writeSpace(); + emit(node.attributes); + writePunctuation("/>"); + } + function emitJsxFragment(node) { + emit(node.openingFragment); + emitList(node, node.children, 262144 /* ListFormat.JsxElementOrFragmentChildren */); + emit(node.closingFragment); + } + function emitJsxOpeningElementOrFragment(node) { + writePunctuation("<"); + if (ts.isJsxOpeningElement(node)) { + var indented = writeLineSeparatorsAndIndentBefore(node.tagName, node); + emitJsxTagName(node.tagName); + emitTypeArguments(node, node.typeArguments); + if (node.attributes.properties && node.attributes.properties.length > 0) { + writeSpace(); + } + emit(node.attributes); + writeLineSeparatorsAfter(node.attributes, node); + decreaseIndentIf(indented); + } + writePunctuation(">"); + } + function emitJsxText(node) { + writer.writeLiteral(node.text); + } + function emitJsxClosingElementOrFragment(node) { + writePunctuation(""); + } + function emitJsxAttributes(node) { + emitList(node, node.properties, 262656 /* ListFormat.JsxElementAttributes */); + } + function emitJsxAttribute(node) { + emit(node.name); + emitNodeWithPrefix("=", writePunctuation, node.initializer, emitJsxAttributeValue); + } + function emitJsxSpreadAttribute(node) { + writePunctuation("{..."); + emitExpression(node.expression); + writePunctuation("}"); + } + function hasTrailingCommentsAtPosition(pos) { + var result = false; + ts.forEachTrailingCommentRange((currentSourceFile === null || currentSourceFile === void 0 ? void 0 : currentSourceFile.text) || "", pos + 1, function () { return result = true; }); + return result; + } + function hasLeadingCommentsAtPosition(pos) { + var result = false; + ts.forEachLeadingCommentRange((currentSourceFile === null || currentSourceFile === void 0 ? void 0 : currentSourceFile.text) || "", pos + 1, function () { return result = true; }); + return result; + } + function hasCommentsAtPosition(pos) { + return hasTrailingCommentsAtPosition(pos) || hasLeadingCommentsAtPosition(pos); + } + function emitJsxExpression(node) { + var _a; + if (node.expression || (!commentsDisabled && !ts.nodeIsSynthesized(node) && hasCommentsAtPosition(node.pos))) { // preserve empty expressions if they contain comments! + var isMultiline = currentSourceFile && !ts.nodeIsSynthesized(node) && ts.getLineAndCharacterOfPosition(currentSourceFile, node.pos).line !== ts.getLineAndCharacterOfPosition(currentSourceFile, node.end).line; + if (isMultiline) { + writer.increaseIndent(); + } + var end = emitTokenWithComment(18 /* SyntaxKind.OpenBraceToken */, node.pos, writePunctuation, node); + emit(node.dotDotDotToken); + emitExpression(node.expression); + emitTokenWithComment(19 /* SyntaxKind.CloseBraceToken */, ((_a = node.expression) === null || _a === void 0 ? void 0 : _a.end) || end, writePunctuation, node); + if (isMultiline) { + writer.decreaseIndent(); + } + } + } + function emitJsxTagName(node) { + if (node.kind === 79 /* SyntaxKind.Identifier */) { + emitExpression(node); + } + else { + emit(node); + } + } + // + // Clauses + // + function emitCaseClause(node) { + emitTokenWithComment(82 /* SyntaxKind.CaseKeyword */, node.pos, writeKeyword, node); + writeSpace(); + emitExpression(node.expression, parenthesizer.parenthesizeExpressionForDisallowedComma); + emitCaseOrDefaultClauseRest(node, node.statements, node.expression.end); + } + function emitDefaultClause(node) { + var pos = emitTokenWithComment(88 /* SyntaxKind.DefaultKeyword */, node.pos, writeKeyword, node); + emitCaseOrDefaultClauseRest(node, node.statements, pos); + } + function emitCaseOrDefaultClauseRest(parentNode, statements, colonPos) { + var emitAsSingleStatement = statements.length === 1 && + ( + // treat synthesized nodes as located on the same line for emit purposes + !currentSourceFile || + ts.nodeIsSynthesized(parentNode) || + ts.nodeIsSynthesized(statements[0]) || + ts.rangeStartPositionsAreOnSameLine(parentNode, statements[0], currentSourceFile)); + var format = 163969 /* ListFormat.CaseOrDefaultClauseStatements */; + if (emitAsSingleStatement) { + writeToken(58 /* SyntaxKind.ColonToken */, colonPos, writePunctuation, parentNode); + writeSpace(); + format &= ~(1 /* ListFormat.MultiLine */ | 128 /* ListFormat.Indented */); + } + else { + emitTokenWithComment(58 /* SyntaxKind.ColonToken */, colonPos, writePunctuation, parentNode); + } + emitList(parentNode, statements, format); + } + function emitHeritageClause(node) { + writeSpace(); + writeTokenText(node.token, writeKeyword); + writeSpace(); + emitList(node, node.types, 528 /* ListFormat.HeritageClauseTypes */); + } + function emitCatchClause(node) { + var openParenPos = emitTokenWithComment(83 /* SyntaxKind.CatchKeyword */, node.pos, writeKeyword, node); + writeSpace(); + if (node.variableDeclaration) { + emitTokenWithComment(20 /* SyntaxKind.OpenParenToken */, openParenPos, writePunctuation, node); + emit(node.variableDeclaration); + emitTokenWithComment(21 /* SyntaxKind.CloseParenToken */, node.variableDeclaration.end, writePunctuation, node); + writeSpace(); + } + emit(node.block); + } + // + // Property assignments + // + function emitPropertyAssignment(node) { + emit(node.name); + writePunctuation(":"); + writeSpace(); + // This is to ensure that we emit comment in the following case: + // For example: + // obj = { + // id: /*comment1*/ ()=>void + // } + // "comment1" is not considered to be leading comment for node.initializer + // but rather a trailing comment on the previous node. + var initializer = node.initializer; + if ((ts.getEmitFlags(initializer) & 512 /* EmitFlags.NoLeadingComments */) === 0) { + var commentRange = ts.getCommentRange(initializer); + emitTrailingCommentsOfPosition(commentRange.pos); + } + emitExpression(initializer, parenthesizer.parenthesizeExpressionForDisallowedComma); + } + function emitShorthandPropertyAssignment(node) { + emit(node.name); + if (node.objectAssignmentInitializer) { + writeSpace(); + writePunctuation("="); + writeSpace(); + emitExpression(node.objectAssignmentInitializer, parenthesizer.parenthesizeExpressionForDisallowedComma); + } + } + function emitSpreadAssignment(node) { + if (node.expression) { + emitTokenWithComment(25 /* SyntaxKind.DotDotDotToken */, node.pos, writePunctuation, node); + emitExpression(node.expression, parenthesizer.parenthesizeExpressionForDisallowedComma); + } + } + // + // Enum + // + function emitEnumMember(node) { + emit(node.name); + emitInitializer(node.initializer, node.name.end, node, parenthesizer.parenthesizeExpressionForDisallowedComma); + } + // + // JSDoc + // + function emitJSDoc(node) { + write("/**"); + if (node.comment) { + var text = ts.getTextOfJSDocComment(node.comment); + if (text) { + var lines = text.split(/\r\n?|\n/g); + for (var _a = 0, lines_2 = lines; _a < lines_2.length; _a++) { + var line = lines_2[_a]; + writeLine(); + writeSpace(); + writePunctuation("*"); + writeSpace(); + write(line); + } + } + } + if (node.tags) { + if (node.tags.length === 1 && node.tags[0].kind === 346 /* SyntaxKind.JSDocTypeTag */ && !node.comment) { + writeSpace(); + emit(node.tags[0]); + } + else { + emitList(node, node.tags, 33 /* ListFormat.JSDocComment */); + } + } + writeSpace(); + write("*/"); + } + function emitJSDocSimpleTypedTag(tag) { + emitJSDocTagName(tag.tagName); + emitJSDocTypeExpression(tag.typeExpression); + emitJSDocComment(tag.comment); + } + function emitJSDocSeeTag(tag) { + emitJSDocTagName(tag.tagName); + emit(tag.name); + emitJSDocComment(tag.comment); + } + function emitJSDocNameReference(node) { + writeSpace(); + writePunctuation("{"); + emit(node.name); + writePunctuation("}"); + } + function emitJSDocHeritageTag(tag) { + emitJSDocTagName(tag.tagName); + writeSpace(); + writePunctuation("{"); + emit(tag.class); + writePunctuation("}"); + emitJSDocComment(tag.comment); + } + function emitJSDocTemplateTag(tag) { + emitJSDocTagName(tag.tagName); + emitJSDocTypeExpression(tag.constraint); + writeSpace(); + emitList(tag, tag.typeParameters, 528 /* ListFormat.CommaListElements */); + emitJSDocComment(tag.comment); + } + function emitJSDocTypedefTag(tag) { + emitJSDocTagName(tag.tagName); + if (tag.typeExpression) { + if (tag.typeExpression.kind === 312 /* SyntaxKind.JSDocTypeExpression */) { + emitJSDocTypeExpression(tag.typeExpression); + } + else { + writeSpace(); + writePunctuation("{"); + write("Object"); + if (tag.typeExpression.isArrayType) { + writePunctuation("["); + writePunctuation("]"); + } + writePunctuation("}"); + } + } + if (tag.fullName) { + writeSpace(); + emit(tag.fullName); + } + emitJSDocComment(tag.comment); + if (tag.typeExpression && tag.typeExpression.kind === 325 /* SyntaxKind.JSDocTypeLiteral */) { + emitJSDocTypeLiteral(tag.typeExpression); + } + } + function emitJSDocCallbackTag(tag) { + emitJSDocTagName(tag.tagName); + if (tag.name) { + writeSpace(); + emit(tag.name); + } + emitJSDocComment(tag.comment); + emitJSDocSignature(tag.typeExpression); + } + function emitJSDocSimpleTag(tag) { + emitJSDocTagName(tag.tagName); + emitJSDocComment(tag.comment); + } + function emitJSDocTypeLiteral(lit) { + emitList(lit, ts.factory.createNodeArray(lit.jsDocPropertyTags), 33 /* ListFormat.JSDocComment */); + } + function emitJSDocSignature(sig) { + if (sig.typeParameters) { + emitList(sig, ts.factory.createNodeArray(sig.typeParameters), 33 /* ListFormat.JSDocComment */); + } + if (sig.parameters) { + emitList(sig, ts.factory.createNodeArray(sig.parameters), 33 /* ListFormat.JSDocComment */); + } + if (sig.type) { + writeLine(); + writeSpace(); + writePunctuation("*"); + writeSpace(); + emit(sig.type); + } + } + function emitJSDocPropertyLikeTag(param) { + emitJSDocTagName(param.tagName); + emitJSDocTypeExpression(param.typeExpression); + writeSpace(); + if (param.isBracketed) { + writePunctuation("["); + } + emit(param.name); + if (param.isBracketed) { + writePunctuation("]"); + } + emitJSDocComment(param.comment); + } + function emitJSDocTagName(tagName) { + writePunctuation("@"); + emit(tagName); + } + function emitJSDocComment(comment) { + var text = ts.getTextOfJSDocComment(comment); + if (text) { + writeSpace(); + write(text); + } + } + function emitJSDocTypeExpression(typeExpression) { + if (typeExpression) { + writeSpace(); + writePunctuation("{"); + emit(typeExpression.type); + writePunctuation("}"); + } + } + // + // Top-level nodes + // + function emitSourceFile(node) { + writeLine(); + var statements = node.statements; + // Emit detached comment if there are no prologue directives or if the first node is synthesized. + // The synthesized node will have no leading comment so some comments may be missed. + var shouldEmitDetachedComment = statements.length === 0 || + !ts.isPrologueDirective(statements[0]) || + ts.nodeIsSynthesized(statements[0]); + if (shouldEmitDetachedComment) { + emitBodyWithDetachedComments(node, statements, emitSourceFileWorker); + return; + } + emitSourceFileWorker(node); + } + function emitSyntheticTripleSlashReferencesIfNeeded(node) { + emitTripleSlashDirectives(!!node.hasNoDefaultLib, node.syntheticFileReferences || [], node.syntheticTypeReferences || [], node.syntheticLibReferences || []); + for (var _a = 0, _b = node.prepends; _a < _b.length; _a++) { + var prepend = _b[_a]; + if (ts.isUnparsedSource(prepend) && prepend.syntheticReferences) { + for (var _c = 0, _d = prepend.syntheticReferences; _c < _d.length; _c++) { + var ref = _d[_c]; + emit(ref); + writeLine(); + } + } + } + } + function emitTripleSlashDirectivesIfNeeded(node) { + if (node.isDeclarationFile) + emitTripleSlashDirectives(node.hasNoDefaultLib, node.referencedFiles, node.typeReferenceDirectives, node.libReferenceDirectives); + } + function emitTripleSlashDirectives(hasNoDefaultLib, files, types, libs) { + if (hasNoDefaultLib) { + var pos = writer.getTextPos(); + writeComment("/// "); + if (bundleFileInfo) + bundleFileInfo.sections.push({ pos: pos, end: writer.getTextPos(), kind: "no-default-lib" /* BundleFileSectionKind.NoDefaultLib */ }); + writeLine(); + } + if (currentSourceFile && currentSourceFile.moduleName) { + writeComment("/// ")); + writeLine(); + } + if (currentSourceFile && currentSourceFile.amdDependencies) { + for (var _a = 0, _b = currentSourceFile.amdDependencies; _a < _b.length; _a++) { + var dep = _b[_a]; + if (dep.name) { + writeComment("/// ")); + } + else { + writeComment("/// ")); + } + writeLine(); + } + } + for (var _c = 0, files_2 = files; _c < files_2.length; _c++) { + var directive = files_2[_c]; + var pos = writer.getTextPos(); + writeComment("/// ")); + if (bundleFileInfo) + bundleFileInfo.sections.push({ pos: pos, end: writer.getTextPos(), kind: "reference" /* BundleFileSectionKind.Reference */, data: directive.fileName }); + writeLine(); + } + for (var _d = 0, types_23 = types; _d < types_23.length; _d++) { + var directive = types_23[_d]; + var pos = writer.getTextPos(); + var resolutionMode = directive.resolutionMode && directive.resolutionMode !== (currentSourceFile === null || currentSourceFile === void 0 ? void 0 : currentSourceFile.impliedNodeFormat) + ? "resolution-mode=\"".concat(directive.resolutionMode === ts.ModuleKind.ESNext ? "import" : "require", "\"") + : ""; + writeComment("/// ")); + if (bundleFileInfo) + bundleFileInfo.sections.push({ pos: pos, end: writer.getTextPos(), kind: !directive.resolutionMode ? "type" /* BundleFileSectionKind.Type */ : directive.resolutionMode === ts.ModuleKind.ESNext ? "type-import" /* BundleFileSectionKind.TypeResolutionModeImport */ : "type-require" /* BundleFileSectionKind.TypeResolutionModeRequire */, data: directive.fileName }); + writeLine(); + } + for (var _e = 0, libs_1 = libs; _e < libs_1.length; _e++) { + var directive = libs_1[_e]; + var pos = writer.getTextPos(); + writeComment("/// ")); + if (bundleFileInfo) + bundleFileInfo.sections.push({ pos: pos, end: writer.getTextPos(), kind: "lib" /* BundleFileSectionKind.Lib */, data: directive.fileName }); + writeLine(); + } + } + function emitSourceFileWorker(node) { + var statements = node.statements; + pushNameGenerationScope(node); + ts.forEach(node.statements, generateNames); + emitHelpers(node); + var index = ts.findIndex(statements, function (statement) { return !ts.isPrologueDirective(statement); }); + emitTripleSlashDirectivesIfNeeded(node); + emitList(node, statements, 1 /* ListFormat.MultiLine */, /*parenthesizerRule*/ undefined, index === -1 ? statements.length : index); + popNameGenerationScope(node); + } + // Transformation nodes + function emitPartiallyEmittedExpression(node) { + var emitFlags = ts.getEmitFlags(node); + if (!(emitFlags & 512 /* EmitFlags.NoLeadingComments */) && node.pos !== node.expression.pos) { + emitTrailingCommentsOfPosition(node.expression.pos); + } + emitExpression(node.expression); + if (!(emitFlags & 1024 /* EmitFlags.NoTrailingComments */) && node.end !== node.expression.end) { + emitLeadingCommentsOfPosition(node.expression.end); + } + } + function emitCommaList(node) { + emitExpressionList(node, node.elements, 528 /* ListFormat.CommaListElements */, /*parenthesizerRule*/ undefined); + } + /** + * Emits any prologue directives at the start of a Statement list, returning the + * number of prologue directives written to the output. + */ + function emitPrologueDirectives(statements, sourceFile, seenPrologueDirectives, recordBundleFileSection) { + var needsToSetSourceFile = !!sourceFile; + for (var i = 0; i < statements.length; i++) { + var statement = statements[i]; + if (ts.isPrologueDirective(statement)) { + var shouldEmitPrologueDirective = seenPrologueDirectives ? !seenPrologueDirectives.has(statement.expression.text) : true; + if (shouldEmitPrologueDirective) { + if (needsToSetSourceFile) { + needsToSetSourceFile = false; + setSourceFile(sourceFile); + } + writeLine(); + var pos = writer.getTextPos(); + emit(statement); + if (recordBundleFileSection && bundleFileInfo) + bundleFileInfo.sections.push({ pos: pos, end: writer.getTextPos(), kind: "prologue" /* BundleFileSectionKind.Prologue */, data: statement.expression.text }); + if (seenPrologueDirectives) { + seenPrologueDirectives.add(statement.expression.text); + } + } + } + else { + // return index of the first non prologue directive + return i; + } + } + return statements.length; + } + function emitUnparsedPrologues(prologues, seenPrologueDirectives) { + for (var _a = 0, prologues_1 = prologues; _a < prologues_1.length; _a++) { + var prologue = prologues_1[_a]; + if (!seenPrologueDirectives.has(prologue.data)) { + writeLine(); + var pos = writer.getTextPos(); + emit(prologue); + if (bundleFileInfo) + bundleFileInfo.sections.push({ pos: pos, end: writer.getTextPos(), kind: "prologue" /* BundleFileSectionKind.Prologue */, data: prologue.data }); + if (seenPrologueDirectives) { + seenPrologueDirectives.add(prologue.data); + } + } + } + } + function emitPrologueDirectivesIfNeeded(sourceFileOrBundle) { + if (ts.isSourceFile(sourceFileOrBundle)) { + emitPrologueDirectives(sourceFileOrBundle.statements, sourceFileOrBundle); + } + else { + var seenPrologueDirectives = new ts.Set(); + for (var _a = 0, _b = sourceFileOrBundle.prepends; _a < _b.length; _a++) { + var prepend = _b[_a]; + emitUnparsedPrologues(prepend.prologues, seenPrologueDirectives); + } + for (var _c = 0, _d = sourceFileOrBundle.sourceFiles; _c < _d.length; _c++) { + var sourceFile = _d[_c]; + emitPrologueDirectives(sourceFile.statements, sourceFile, seenPrologueDirectives, /*recordBundleFileSection*/ true); + } + setSourceFile(undefined); + } + } + function getPrologueDirectivesFromBundledSourceFiles(bundle) { + var seenPrologueDirectives = new ts.Set(); + var prologues; + for (var index = 0; index < bundle.sourceFiles.length; index++) { + var sourceFile = bundle.sourceFiles[index]; + var directives = void 0; + var end = 0; + for (var _a = 0, _b = sourceFile.statements; _a < _b.length; _a++) { + var statement = _b[_a]; + if (!ts.isPrologueDirective(statement)) + break; + if (seenPrologueDirectives.has(statement.expression.text)) + continue; + seenPrologueDirectives.add(statement.expression.text); + (directives || (directives = [])).push({ + pos: statement.pos, + end: statement.end, + expression: { + pos: statement.expression.pos, + end: statement.expression.end, + text: statement.expression.text + } + }); + end = end < statement.end ? statement.end : end; + } + if (directives) + (prologues || (prologues = [])).push({ file: index, text: sourceFile.text.substring(0, end), directives: directives }); + } + return prologues; + } + function emitShebangIfNeeded(sourceFileOrBundle) { + if (ts.isSourceFile(sourceFileOrBundle) || ts.isUnparsedSource(sourceFileOrBundle)) { + var shebang = ts.getShebang(sourceFileOrBundle.text); + if (shebang) { + writeComment(shebang); + writeLine(); + return true; + } + } + else { + for (var _a = 0, _b = sourceFileOrBundle.prepends; _a < _b.length; _a++) { + var prepend = _b[_a]; + ts.Debug.assertNode(prepend, ts.isUnparsedSource); + if (emitShebangIfNeeded(prepend)) { + return true; + } + } + for (var _c = 0, _d = sourceFileOrBundle.sourceFiles; _c < _d.length; _c++) { + var sourceFile = _d[_c]; + // Emit only the first encountered shebang + if (emitShebangIfNeeded(sourceFile)) { + return true; + } + } + } + } + // + // Helpers + // + function emitNodeWithWriter(node, writer) { + if (!node) + return; + var savedWrite = write; + write = writer; + emit(node); + write = savedWrite; + } + function emitDecoratorsAndModifiers(node, modifiers) { + if (modifiers === null || modifiers === void 0 ? void 0 : modifiers.length) { + if (ts.every(modifiers, ts.isModifier)) { + // if all modifier-likes are `Modifier`, simply emit the array as modifiers. + return emitModifiers(node, modifiers); + } + if (ts.every(modifiers, ts.isDecorator)) { + // if all modifier-likes are `Decorator`, simply emit the array as decorators. + return emitDecorators(node, modifiers); + } + onBeforeEmitNodeArray === null || onBeforeEmitNodeArray === void 0 ? void 0 : onBeforeEmitNodeArray(modifiers); + // partition modifiers into contiguous chunks of `Modifier` or `Decorator` + var lastMode = void 0; + var mode = void 0; + var start = 0; + var pos = 0; + while (start < modifiers.length) { + while (pos < modifiers.length) { + var modifier = modifiers[pos]; + mode = ts.isDecorator(modifier) ? "decorators" : "modifiers"; + if (lastMode === undefined) { + lastMode = mode; + } + else if (mode !== lastMode) { + break; + } + pos++; + } + var textRange = { pos: -1, end: -1 }; + if (start === 0) + textRange.pos = modifiers.pos; + if (pos === modifiers.length - 1) + textRange.end = modifiers.end; + emitNodeListItems(emit, node, modifiers, lastMode === "modifiers" ? 2359808 /* ListFormat.Modifiers */ : 2146305 /* ListFormat.Decorators */, + /*parenthesizerRule*/ undefined, start, pos - start, + /*hasTrailingComma*/ false, textRange); + start = pos; + lastMode = mode; + pos++; + } + onAfterEmitNodeArray === null || onAfterEmitNodeArray === void 0 ? void 0 : onAfterEmitNodeArray(modifiers); + } + } + function emitModifiers(node, modifiers) { + emitList(node, modifiers, 2359808 /* ListFormat.Modifiers */); + } + function emitTypeAnnotation(node) { + if (node) { + writePunctuation(":"); + writeSpace(); + emit(node); + } + } + function emitInitializer(node, equalCommentStartPos, container, parenthesizerRule) { + if (node) { + writeSpace(); + emitTokenWithComment(63 /* SyntaxKind.EqualsToken */, equalCommentStartPos, writeOperator, container); + writeSpace(); + emitExpression(node, parenthesizerRule); + } + } + function emitNodeWithPrefix(prefix, prefixWriter, node, emit) { + if (node) { + prefixWriter(prefix); + emit(node); + } + } + function emitWithLeadingSpace(node) { + if (node) { + writeSpace(); + emit(node); + } + } + function emitExpressionWithLeadingSpace(node, parenthesizerRule) { + if (node) { + writeSpace(); + emitExpression(node, parenthesizerRule); + } + } + function emitWithTrailingSpace(node) { + if (node) { + emit(node); + writeSpace(); + } + } + function emitEmbeddedStatement(parent, node) { + if (ts.isBlock(node) || ts.getEmitFlags(parent) & 1 /* EmitFlags.SingleLine */) { + writeSpace(); + emit(node); + } + else { + writeLine(); + increaseIndent(); + if (ts.isEmptyStatement(node)) { + pipelineEmit(5 /* EmitHint.EmbeddedStatement */, node); + } + else { + emit(node); + } + decreaseIndent(); + } + } + function emitDecorators(parentNode, decorators) { + emitList(parentNode, decorators, 2146305 /* ListFormat.Decorators */); + } + function emitTypeArguments(parentNode, typeArguments) { + emitList(parentNode, typeArguments, 53776 /* ListFormat.TypeArguments */, typeArgumentParenthesizerRuleSelector); + } + function emitTypeParameters(parentNode, typeParameters) { + if (ts.isFunctionLike(parentNode) && parentNode.typeArguments) { // Quick info uses type arguments in place of type parameters on instantiated signatures + return emitTypeArguments(parentNode, parentNode.typeArguments); + } + emitList(parentNode, typeParameters, 53776 /* ListFormat.TypeParameters */); + } + function emitParameters(parentNode, parameters) { + emitList(parentNode, parameters, 2576 /* ListFormat.Parameters */); + } + function canEmitSimpleArrowHead(parentNode, parameters) { + var parameter = ts.singleOrUndefined(parameters); + return parameter + && parameter.pos === parentNode.pos // may not have parsed tokens between parent and parameter + && ts.isArrowFunction(parentNode) // only arrow functions may have simple arrow head + && !parentNode.type // arrow function may not have return type annotation + && !ts.some(parentNode.modifiers) // parent may not have decorators or modifiers + && !ts.some(parentNode.typeParameters) // parent may not have type parameters + && !ts.some(parameter.modifiers) // parameter may not have decorators or modifiers + && !parameter.dotDotDotToken // parameter may not be rest + && !parameter.questionToken // parameter may not be optional + && !parameter.type // parameter may not have a type annotation + && !parameter.initializer // parameter may not have an initializer + && ts.isIdentifier(parameter.name); // parameter name must be identifier + } + function emitParametersForArrow(parentNode, parameters) { + if (canEmitSimpleArrowHead(parentNode, parameters)) { + emitList(parentNode, parameters, 2576 /* ListFormat.Parameters */ & ~2048 /* ListFormat.Parenthesis */); + } + else { + emitParameters(parentNode, parameters); + } + } + function emitParametersForIndexSignature(parentNode, parameters) { + emitList(parentNode, parameters, 8848 /* ListFormat.IndexSignatureParameters */); + } + function writeDelimiter(format) { + switch (format & 60 /* ListFormat.DelimitersMask */) { + case 0 /* ListFormat.None */: + break; + case 16 /* ListFormat.CommaDelimited */: + writePunctuation(","); + break; + case 4 /* ListFormat.BarDelimited */: + writeSpace(); + writePunctuation("|"); + break; + case 32 /* ListFormat.AsteriskDelimited */: + writeSpace(); + writePunctuation("*"); + writeSpace(); + break; + case 8 /* ListFormat.AmpersandDelimited */: + writeSpace(); + writePunctuation("&"); + break; + } + } + function emitList(parentNode, children, format, parenthesizerRule, start, count) { + emitNodeList(emit, parentNode, children, format, parenthesizerRule, start, count); + } + function emitExpressionList(parentNode, children, format, parenthesizerRule, start, count) { + emitNodeList(emitExpression, parentNode, children, format, parenthesizerRule, start, count); + } + function emitNodeList(emit, parentNode, children, format, parenthesizerRule, start, count) { + if (start === void 0) { start = 0; } + if (count === void 0) { count = children ? children.length - start : 0; } + var isUndefined = children === undefined; + if (isUndefined && format & 16384 /* ListFormat.OptionalIfUndefined */) { + return; + } + var isEmpty = children === undefined || start >= children.length || count === 0; + if (isEmpty && format & 32768 /* ListFormat.OptionalIfEmpty */) { + onBeforeEmitNodeArray === null || onBeforeEmitNodeArray === void 0 ? void 0 : onBeforeEmitNodeArray(children); + onAfterEmitNodeArray === null || onAfterEmitNodeArray === void 0 ? void 0 : onAfterEmitNodeArray(children); + return; + } + if (format & 15360 /* ListFormat.BracketsMask */) { + writePunctuation(getOpeningBracket(format)); + if (isEmpty && children) { + emitTrailingCommentsOfPosition(children.pos, /*prefixSpace*/ true); // Emit comments within empty bracketed lists + } + } + onBeforeEmitNodeArray === null || onBeforeEmitNodeArray === void 0 ? void 0 : onBeforeEmitNodeArray(children); + if (isEmpty) { + // Write a line terminator if the parent node was multi-line + if (format & 1 /* ListFormat.MultiLine */ && !(preserveSourceNewlines && (!parentNode || currentSourceFile && ts.rangeIsOnSingleLine(parentNode, currentSourceFile)))) { + writeLine(); + } + else if (format & 256 /* ListFormat.SpaceBetweenBraces */ && !(format & 524288 /* ListFormat.NoSpaceIfEmpty */)) { + writeSpace(); + } + } + else { + emitNodeListItems(emit, parentNode, children, format, parenthesizerRule, start, count, children.hasTrailingComma, children); + } + onAfterEmitNodeArray === null || onAfterEmitNodeArray === void 0 ? void 0 : onAfterEmitNodeArray(children); + if (format & 15360 /* ListFormat.BracketsMask */) { + if (isEmpty && children) { + emitLeadingCommentsOfPosition(children.end); // Emit leading comments within empty lists + } + writePunctuation(getClosingBracket(format)); + } + } + /** + * Emits a list without brackets or raising events. + * + * NOTE: You probably don't want to call this directly and should be using `emitList` or `emitExpressionList` instead. + */ + function emitNodeListItems(emit, parentNode, children, format, parenthesizerRule, start, count, hasTrailingComma, childrenTextRange) { + // Write the opening line terminator or leading whitespace. + var mayEmitInterveningComments = (format & 262144 /* ListFormat.NoInterveningComments */) === 0; + var shouldEmitInterveningComments = mayEmitInterveningComments; + var leadingLineTerminatorCount = getLeadingLineTerminatorCount(parentNode, children[start], format); + if (leadingLineTerminatorCount) { + writeLine(leadingLineTerminatorCount); + shouldEmitInterveningComments = false; + } + else if (format & 256 /* ListFormat.SpaceBetweenBraces */) { + writeSpace(); + } + // Increase the indent, if requested. + if (format & 128 /* ListFormat.Indented */) { + increaseIndent(); + } + var emitListItem = getEmitListItem(emit, parenthesizerRule); + // Emit each child. + var previousSibling; + var previousSourceFileTextKind; + var shouldDecreaseIndentAfterEmit = false; + for (var i = 0; i < count; i++) { + var child = children[start + i]; + // Write the delimiter if this is not the first node. + if (format & 32 /* ListFormat.AsteriskDelimited */) { + // always write JSDoc in the format "\n *" + writeLine(); + writeDelimiter(format); + } + else if (previousSibling) { + // i.e + // function commentedParameters( + // /* Parameter a */ + // a + // /* End of parameter a */ -> this comment isn't considered to be trailing comment of parameter "a" due to newline + // , + if (format & 60 /* ListFormat.DelimitersMask */ && previousSibling.end !== (parentNode ? parentNode.end : -1)) { + emitLeadingCommentsOfPosition(previousSibling.end); + } + writeDelimiter(format); + recordBundleFileInternalSectionEnd(previousSourceFileTextKind); + // Write either a line terminator or whitespace to separate the elements. + var separatingLineTerminatorCount = getSeparatingLineTerminatorCount(previousSibling, child, format); + if (separatingLineTerminatorCount > 0) { + // If a synthesized node in a single-line list starts on a new + // line, we should increase the indent. + if ((format & (3 /* ListFormat.LinesMask */ | 128 /* ListFormat.Indented */)) === 0 /* ListFormat.SingleLine */) { + increaseIndent(); + shouldDecreaseIndentAfterEmit = true; + } + writeLine(separatingLineTerminatorCount); + shouldEmitInterveningComments = false; + } + else if (previousSibling && format & 512 /* ListFormat.SpaceBetweenSiblings */) { + writeSpace(); + } + } + // Emit this child. + previousSourceFileTextKind = recordBundleFileInternalSectionStart(child); + if (shouldEmitInterveningComments) { + var commentRange = ts.getCommentRange(child); + emitTrailingCommentsOfPosition(commentRange.pos); + } + else { + shouldEmitInterveningComments = mayEmitInterveningComments; + } + nextListElementPos = child.pos; + emitListItem(child, emit, parenthesizerRule, i); + if (shouldDecreaseIndentAfterEmit) { + decreaseIndent(); + shouldDecreaseIndentAfterEmit = false; + } + previousSibling = child; + } + // Write a trailing comma, if requested. + var emitFlags = previousSibling ? ts.getEmitFlags(previousSibling) : 0; + var skipTrailingComments = commentsDisabled || !!(emitFlags & 1024 /* EmitFlags.NoTrailingComments */); + var emitTrailingComma = hasTrailingComma && (format & 64 /* ListFormat.AllowTrailingComma */) && (format & 16 /* ListFormat.CommaDelimited */); + if (emitTrailingComma) { + if (previousSibling && !skipTrailingComments) { + emitTokenWithComment(27 /* SyntaxKind.CommaToken */, previousSibling.end, writePunctuation, previousSibling); + } + else { + writePunctuation(","); + } + } + // Emit any trailing comment of the last element in the list + // i.e + // var array = [... + // 2 + // /* end of element 2 */ + // ]; + if (previousSibling && (parentNode ? parentNode.end : -1) !== previousSibling.end && (format & 60 /* ListFormat.DelimitersMask */) && !skipTrailingComments) { + emitLeadingCommentsOfPosition(emitTrailingComma && (childrenTextRange === null || childrenTextRange === void 0 ? void 0 : childrenTextRange.end) ? childrenTextRange.end : previousSibling.end); + } + // Decrease the indent, if requested. + if (format & 128 /* ListFormat.Indented */) { + decreaseIndent(); + } + recordBundleFileInternalSectionEnd(previousSourceFileTextKind); + // Write the closing line terminator or closing whitespace. + var closingLineTerminatorCount = getClosingLineTerminatorCount(parentNode, children[start + count - 1], format, childrenTextRange); + if (closingLineTerminatorCount) { + writeLine(closingLineTerminatorCount); + } + else if (format & (2097152 /* ListFormat.SpaceAfterList */ | 256 /* ListFormat.SpaceBetweenBraces */)) { + writeSpace(); + } + } + // Writers + function writeLiteral(s) { + writer.writeLiteral(s); + } + function writeStringLiteral(s) { + writer.writeStringLiteral(s); + } + function writeBase(s) { + writer.write(s); + } + function writeSymbol(s, sym) { + writer.writeSymbol(s, sym); + } + function writePunctuation(s) { + writer.writePunctuation(s); + } + function writeTrailingSemicolon() { + writer.writeTrailingSemicolon(";"); + } + function writeKeyword(s) { + writer.writeKeyword(s); + } + function writeOperator(s) { + writer.writeOperator(s); + } + function writeParameter(s) { + writer.writeParameter(s); + } + function writeComment(s) { + writer.writeComment(s); + } + function writeSpace() { + writer.writeSpace(" "); + } + function writeProperty(s) { + writer.writeProperty(s); + } + function nonEscapingWrite(s) { + // This should be defined in a snippet-escaping text writer. + if (writer.nonEscapingWrite) { + writer.nonEscapingWrite(s); + } + else { + writer.write(s); + } + } + function writeLine(count) { + if (count === void 0) { count = 1; } + for (var i = 0; i < count; i++) { + writer.writeLine(i > 0); + } + } + function increaseIndent() { + writer.increaseIndent(); + } + function decreaseIndent() { + writer.decreaseIndent(); + } + function writeToken(token, pos, writer, contextNode) { + return !sourceMapsDisabled + ? emitTokenWithSourceMap(contextNode, token, writer, pos, writeTokenText) + : writeTokenText(token, writer, pos); + } + function writeTokenNode(node, writer) { + if (onBeforeEmitToken) { + onBeforeEmitToken(node); + } + writer(ts.tokenToString(node.kind)); + if (onAfterEmitToken) { + onAfterEmitToken(node); + } + } + function writeTokenText(token, writer, pos) { + var tokenString = ts.tokenToString(token); + writer(tokenString); + return pos < 0 ? pos : pos + tokenString.length; + } + function writeLineOrSpace(parentNode, prevChildNode, nextChildNode) { + if (ts.getEmitFlags(parentNode) & 1 /* EmitFlags.SingleLine */) { + writeSpace(); + } + else if (preserveSourceNewlines) { + var lines = getLinesBetweenNodes(parentNode, prevChildNode, nextChildNode); + if (lines) { + writeLine(lines); + } + else { + writeSpace(); + } + } + else { + writeLine(); + } + } + function writeLines(text) { + var lines = text.split(/\r\n?|\n/g); + var indentation = ts.guessIndentation(lines); + for (var _a = 0, lines_3 = lines; _a < lines_3.length; _a++) { + var lineText = lines_3[_a]; + var line = indentation ? lineText.slice(indentation) : lineText; + if (line.length) { + writeLine(); + write(line); + } + } + } + function writeLinesAndIndent(lineCount, writeSpaceIfNotIndenting) { + if (lineCount) { + increaseIndent(); + writeLine(lineCount); + } + else if (writeSpaceIfNotIndenting) { + writeSpace(); + } + } + // Helper function to decrease the indent if we previously indented. Allows multiple + // previous indent values to be considered at a time. This also allows caller to just + // call this once, passing in all their appropriate indent values, instead of needing + // to call this helper function multiple times. + function decreaseIndentIf(value1, value2) { + if (value1) { + decreaseIndent(); + } + if (value2) { + decreaseIndent(); + } + } + function getLeadingLineTerminatorCount(parentNode, firstChild, format) { + if (format & 2 /* ListFormat.PreserveLines */ || preserveSourceNewlines) { + if (format & 65536 /* ListFormat.PreferNewLine */) { + return 1; + } + if (firstChild === undefined) { + return !parentNode || currentSourceFile && ts.rangeIsOnSingleLine(parentNode, currentSourceFile) ? 0 : 1; + } + if (firstChild.pos === nextListElementPos) { + // If this child starts at the beginning of a list item in a parent list, its leading + // line terminators have already been written as the separating line terminators of the + // parent list. Example: + // + // class Foo { + // constructor() {} + // public foo() {} + // } + // + // The outer list is the list of class members, with one line terminator between the + // constructor and the method. The constructor is written, the separating line terminator + // is written, and then we start emitting the method. Its modifiers ([public]) constitute an inner + // list, so we look for its leading line terminators. If we didn't know that we had already + // written a newline as part of the parent list, it would appear that we need to write a + // leading newline to start the modifiers. + return 0; + } + if (firstChild.kind === 11 /* SyntaxKind.JsxText */) { + // JsxText will be written with its leading whitespace, so don't add more manually. + return 0; + } + if (currentSourceFile && parentNode && + !ts.positionIsSynthesized(parentNode.pos) && + !ts.nodeIsSynthesized(firstChild) && + (!firstChild.parent || ts.getOriginalNode(firstChild.parent) === ts.getOriginalNode(parentNode))) { + if (preserveSourceNewlines) { + return getEffectiveLines(function (includeComments) { return ts.getLinesBetweenPositionAndPrecedingNonWhitespaceCharacter(firstChild.pos, parentNode.pos, currentSourceFile, includeComments); }); + } + return ts.rangeStartPositionsAreOnSameLine(parentNode, firstChild, currentSourceFile) ? 0 : 1; + } + if (synthesizedNodeStartsOnNewLine(firstChild, format)) { + return 1; + } + } + return format & 1 /* ListFormat.MultiLine */ ? 1 : 0; + } + function getSeparatingLineTerminatorCount(previousNode, nextNode, format) { + if (format & 2 /* ListFormat.PreserveLines */ || preserveSourceNewlines) { + if (previousNode === undefined || nextNode === undefined) { + return 0; + } + if (nextNode.kind === 11 /* SyntaxKind.JsxText */) { + // JsxText will be written with its leading whitespace, so don't add more manually. + return 0; + } + else if (currentSourceFile && !ts.nodeIsSynthesized(previousNode) && !ts.nodeIsSynthesized(nextNode)) { + if (preserveSourceNewlines && siblingNodePositionsAreComparable(previousNode, nextNode)) { + return getEffectiveLines(function (includeComments) { return ts.getLinesBetweenRangeEndAndRangeStart(previousNode, nextNode, currentSourceFile, includeComments); }); + } + // If `preserveSourceNewlines` is `false` we do not intend to preserve the effective lines between the + // previous and next node. Instead we naively check whether nodes are on separate lines within the + // same node parent. If so, we intend to preserve a single line terminator. This is less precise and + // expensive than checking with `preserveSourceNewlines` as above, but the goal is not to preserve the + // effective source lines between two sibling nodes. + else if (!preserveSourceNewlines && originalNodesHaveSameParent(previousNode, nextNode)) { + return ts.rangeEndIsOnSameLineAsRangeStart(previousNode, nextNode, currentSourceFile) ? 0 : 1; + } + // If the two nodes are not comparable, add a line terminator based on the format that can indicate + // whether new lines are preferred or not. + return format & 65536 /* ListFormat.PreferNewLine */ ? 1 : 0; + } + else if (synthesizedNodeStartsOnNewLine(previousNode, format) || synthesizedNodeStartsOnNewLine(nextNode, format)) { + return 1; + } + } + else if (ts.getStartsOnNewLine(nextNode)) { + return 1; + } + return format & 1 /* ListFormat.MultiLine */ ? 1 : 0; + } + function getClosingLineTerminatorCount(parentNode, lastChild, format, childrenTextRange) { + if (format & 2 /* ListFormat.PreserveLines */ || preserveSourceNewlines) { + if (format & 65536 /* ListFormat.PreferNewLine */) { + return 1; + } + if (lastChild === undefined) { + return !parentNode || currentSourceFile && ts.rangeIsOnSingleLine(parentNode, currentSourceFile) ? 0 : 1; + } + if (currentSourceFile && parentNode && !ts.positionIsSynthesized(parentNode.pos) && !ts.nodeIsSynthesized(lastChild) && (!lastChild.parent || lastChild.parent === parentNode)) { + if (preserveSourceNewlines) { + var end_1 = childrenTextRange && !ts.positionIsSynthesized(childrenTextRange.end) ? childrenTextRange.end : lastChild.end; + return getEffectiveLines(function (includeComments) { return ts.getLinesBetweenPositionAndNextNonWhitespaceCharacter(end_1, parentNode.end, currentSourceFile, includeComments); }); + } + return ts.rangeEndPositionsAreOnSameLine(parentNode, lastChild, currentSourceFile) ? 0 : 1; + } + if (synthesizedNodeStartsOnNewLine(lastChild, format)) { + return 1; + } + } + if (format & 1 /* ListFormat.MultiLine */ && !(format & 131072 /* ListFormat.NoTrailingNewLine */)) { + return 1; + } + return 0; + } + function getEffectiveLines(getLineDifference) { + // If 'preserveSourceNewlines' is disabled, we should never call this function + // because it could be more expensive than alternative approximations. + ts.Debug.assert(!!preserveSourceNewlines); + // We start by measuring the line difference from a position to its adjacent comments, + // so that this is counted as a one-line difference, not two: + // + // node1; + // // NODE2 COMMENT + // node2; + var lines = getLineDifference(/*includeComments*/ true); + if (lines === 0) { + // However, if the line difference considering comments was 0, we might have this: + // + // node1; // NODE2 COMMENT + // node2; + // + // in which case we should be ignoring node2's comment, so this too is counted as + // a one-line difference, not zero. + return getLineDifference(/*includeComments*/ false); + } + return lines; + } + function writeLineSeparatorsAndIndentBefore(node, parent) { + var leadingNewlines = preserveSourceNewlines && getLeadingLineTerminatorCount(parent, node, 0 /* ListFormat.None */); + if (leadingNewlines) { + writeLinesAndIndent(leadingNewlines, /*writeSpaceIfNotIndenting*/ false); + } + return !!leadingNewlines; + } + function writeLineSeparatorsAfter(node, parent) { + var trailingNewlines = preserveSourceNewlines && getClosingLineTerminatorCount(parent, node, 0 /* ListFormat.None */, /*childrenTextRange*/ undefined); + if (trailingNewlines) { + writeLine(trailingNewlines); + } + } + function synthesizedNodeStartsOnNewLine(node, format) { + if (ts.nodeIsSynthesized(node)) { + var startsOnNewLine = ts.getStartsOnNewLine(node); + if (startsOnNewLine === undefined) { + return (format & 65536 /* ListFormat.PreferNewLine */) !== 0; + } + return startsOnNewLine; + } + return (format & 65536 /* ListFormat.PreferNewLine */) !== 0; + } + function getLinesBetweenNodes(parent, node1, node2) { + if (ts.getEmitFlags(parent) & 131072 /* EmitFlags.NoIndentation */) { + return 0; + } + parent = skipSynthesizedParentheses(parent); + node1 = skipSynthesizedParentheses(node1); + node2 = skipSynthesizedParentheses(node2); + // Always use a newline for synthesized code if the synthesizer desires it. + if (ts.getStartsOnNewLine(node2)) { + return 1; + } + if (currentSourceFile && !ts.nodeIsSynthesized(parent) && !ts.nodeIsSynthesized(node1) && !ts.nodeIsSynthesized(node2)) { + if (preserveSourceNewlines) { + return getEffectiveLines(function (includeComments) { return ts.getLinesBetweenRangeEndAndRangeStart(node1, node2, currentSourceFile, includeComments); }); + } + return ts.rangeEndIsOnSameLineAsRangeStart(node1, node2, currentSourceFile) ? 0 : 1; + } + return 0; + } + function isEmptyBlock(block) { + return block.statements.length === 0 + && (!currentSourceFile || ts.rangeEndIsOnSameLineAsRangeStart(block, block, currentSourceFile)); + } + function skipSynthesizedParentheses(node) { + while (node.kind === 214 /* SyntaxKind.ParenthesizedExpression */ && ts.nodeIsSynthesized(node)) { + node = node.expression; + } + return node; + } + function getTextOfNode(node, includeTrivia) { + if (ts.isGeneratedIdentifier(node) || ts.isGeneratedPrivateIdentifier(node)) { + return generateName(node); + } + if (ts.isStringLiteral(node) && node.textSourceNode) { + return getTextOfNode(node.textSourceNode, includeTrivia); + } + var sourceFile = currentSourceFile; // const needed for control flow + var canUseSourceFile = !!sourceFile && !!node.parent && !ts.nodeIsSynthesized(node); + if (ts.isMemberName(node)) { + if (!canUseSourceFile || ts.getSourceFileOfNode(node) !== ts.getOriginalNode(sourceFile)) { + return ts.idText(node); + } + } + else { + ts.Debug.assertNode(node, ts.isLiteralExpression); // not strictly necessary + if (!canUseSourceFile) { + return node.text; + } + } + return ts.getSourceTextOfNodeFromSourceFile(sourceFile, node, includeTrivia); + } + function getLiteralTextOfNode(node, neverAsciiEscape, jsxAttributeEscape) { + if (node.kind === 10 /* SyntaxKind.StringLiteral */ && node.textSourceNode) { + var textSourceNode = node.textSourceNode; + if (ts.isIdentifier(textSourceNode) || ts.isPrivateIdentifier(textSourceNode) || ts.isNumericLiteral(textSourceNode)) { + var text = ts.isNumericLiteral(textSourceNode) ? textSourceNode.text : getTextOfNode(textSourceNode); + return jsxAttributeEscape ? "\"".concat(ts.escapeJsxAttributeString(text), "\"") : + neverAsciiEscape || (ts.getEmitFlags(node) & 16777216 /* EmitFlags.NoAsciiEscaping */) ? "\"".concat(ts.escapeString(text), "\"") : + "\"".concat(ts.escapeNonAsciiString(text), "\""); + } + else { + return getLiteralTextOfNode(textSourceNode, neverAsciiEscape, jsxAttributeEscape); + } + } + var flags = (neverAsciiEscape ? 1 /* GetLiteralTextFlags.NeverAsciiEscape */ : 0) + | (jsxAttributeEscape ? 2 /* GetLiteralTextFlags.JsxAttributeEscape */ : 0) + | (printerOptions.terminateUnterminatedLiterals ? 4 /* GetLiteralTextFlags.TerminateUnterminatedLiterals */ : 0) + | (printerOptions.target && printerOptions.target === 99 /* ScriptTarget.ESNext */ ? 8 /* GetLiteralTextFlags.AllowNumericSeparator */ : 0); + return ts.getLiteralText(node, currentSourceFile, flags); + } + /** + * Push a new name generation scope. + */ + function pushNameGenerationScope(node) { + if (node && ts.getEmitFlags(node) & 524288 /* EmitFlags.ReuseTempVariableScope */) { + return; + } + tempFlagsStack.push(tempFlags); + tempFlags = 0 /* TempFlags.Auto */; + privateNameTempFlagsStack.push(privateNameTempFlags); + privateNameTempFlags = 0 /* TempFlags.Auto */; + formattedNameTempFlagsStack.push(formattedNameTempFlags); + formattedNameTempFlags = undefined; + reservedNamesStack.push(reservedNames); + } + /** + * Pop the current name generation scope. + */ + function popNameGenerationScope(node) { + if (node && ts.getEmitFlags(node) & 524288 /* EmitFlags.ReuseTempVariableScope */) { + return; + } + tempFlags = tempFlagsStack.pop(); + privateNameTempFlags = privateNameTempFlagsStack.pop(); + formattedNameTempFlags = formattedNameTempFlagsStack.pop(); + reservedNames = reservedNamesStack.pop(); + } + function reserveNameInNestedScopes(name) { + if (!reservedNames || reservedNames === ts.lastOrUndefined(reservedNamesStack)) { + reservedNames = new ts.Set(); + } + reservedNames.add(name); + } + function generateNames(node) { + if (!node) + return; + switch (node.kind) { + case 238 /* SyntaxKind.Block */: + ts.forEach(node.statements, generateNames); + break; + case 253 /* SyntaxKind.LabeledStatement */: + case 251 /* SyntaxKind.WithStatement */: + case 243 /* SyntaxKind.DoStatement */: + case 244 /* SyntaxKind.WhileStatement */: + generateNames(node.statement); + break; + case 242 /* SyntaxKind.IfStatement */: + generateNames(node.thenStatement); + generateNames(node.elseStatement); + break; + case 245 /* SyntaxKind.ForStatement */: + case 247 /* SyntaxKind.ForOfStatement */: + case 246 /* SyntaxKind.ForInStatement */: + generateNames(node.initializer); + generateNames(node.statement); + break; + case 252 /* SyntaxKind.SwitchStatement */: + generateNames(node.caseBlock); + break; + case 266 /* SyntaxKind.CaseBlock */: + ts.forEach(node.clauses, generateNames); + break; + case 292 /* SyntaxKind.CaseClause */: + case 293 /* SyntaxKind.DefaultClause */: + ts.forEach(node.statements, generateNames); + break; + case 255 /* SyntaxKind.TryStatement */: + generateNames(node.tryBlock); + generateNames(node.catchClause); + generateNames(node.finallyBlock); + break; + case 295 /* SyntaxKind.CatchClause */: + generateNames(node.variableDeclaration); + generateNames(node.block); + break; + case 240 /* SyntaxKind.VariableStatement */: + generateNames(node.declarationList); + break; + case 258 /* SyntaxKind.VariableDeclarationList */: + ts.forEach(node.declarations, generateNames); + break; + case 257 /* SyntaxKind.VariableDeclaration */: + case 166 /* SyntaxKind.Parameter */: + case 205 /* SyntaxKind.BindingElement */: + case 260 /* SyntaxKind.ClassDeclaration */: + generateNameIfNeeded(node.name); + break; + case 259 /* SyntaxKind.FunctionDeclaration */: + generateNameIfNeeded(node.name); + if (ts.getEmitFlags(node) & 524288 /* EmitFlags.ReuseTempVariableScope */) { + ts.forEach(node.parameters, generateNames); + generateNames(node.body); + } + break; + case 203 /* SyntaxKind.ObjectBindingPattern */: + case 204 /* SyntaxKind.ArrayBindingPattern */: + ts.forEach(node.elements, generateNames); + break; + case 269 /* SyntaxKind.ImportDeclaration */: + generateNames(node.importClause); + break; + case 270 /* SyntaxKind.ImportClause */: + generateNameIfNeeded(node.name); + generateNames(node.namedBindings); + break; + case 271 /* SyntaxKind.NamespaceImport */: + generateNameIfNeeded(node.name); + break; + case 277 /* SyntaxKind.NamespaceExport */: + generateNameIfNeeded(node.name); + break; + case 272 /* SyntaxKind.NamedImports */: + ts.forEach(node.elements, generateNames); + break; + case 273 /* SyntaxKind.ImportSpecifier */: + generateNameIfNeeded(node.propertyName || node.name); + break; + } + } + function generateMemberNames(node) { + if (!node) + return; + switch (node.kind) { + case 299 /* SyntaxKind.PropertyAssignment */: + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + generateNameIfNeeded(node.name); + break; + } + } + function generateNameIfNeeded(name) { + if (name) { + if (ts.isGeneratedIdentifier(name) || ts.isGeneratedPrivateIdentifier(name)) { + generateName(name); + } + else if (ts.isBindingPattern(name)) { + generateNames(name); + } + } + } + /** + * Generate the text for a generated identifier. + */ + function generateName(name) { + if ((name.autoGenerateFlags & 7 /* GeneratedIdentifierFlags.KindMask */) === 4 /* GeneratedIdentifierFlags.Node */) { + // Node names generate unique names based on their original node + // and are cached based on that node's id. + return generateNameCached(ts.getNodeForGeneratedName(name), ts.isPrivateIdentifier(name), name.autoGenerateFlags, name.autoGeneratePrefix, name.autoGenerateSuffix); + } + else { + // Auto, Loop, and Unique names are cached based on their unique + // autoGenerateId. + var autoGenerateId = name.autoGenerateId; + return autoGeneratedIdToGeneratedName[autoGenerateId] || (autoGeneratedIdToGeneratedName[autoGenerateId] = makeName(name)); + } + } + function generateNameCached(node, privateName, flags, prefix, suffix) { + var nodeId = ts.getNodeId(node); + return nodeIdToGeneratedName[nodeId] || (nodeIdToGeneratedName[nodeId] = generateNameForNode(node, privateName, flags !== null && flags !== void 0 ? flags : 0 /* GeneratedIdentifierFlags.None */, ts.formatGeneratedNamePart(prefix, generateName), ts.formatGeneratedNamePart(suffix))); + } + /** + * Returns a value indicating whether a name is unique globally, within the current file, + * or within the NameGenerator. + */ + function isUniqueName(name) { + return isFileLevelUniqueName(name) + && !generatedNames.has(name) + && !(reservedNames && reservedNames.has(name)); + } + /** + * Returns a value indicating whether a name is unique globally or within the current file. + */ + function isFileLevelUniqueName(name) { + return currentSourceFile ? ts.isFileLevelUniqueName(currentSourceFile, name, hasGlobalName) : true; + } + /** + * Returns a value indicating whether a name is unique within a container. + */ + function isUniqueLocalName(name, container) { + for (var node = container; ts.isNodeDescendantOf(node, container); node = node.nextContainer) { + if (node.locals) { + var local = node.locals.get(ts.escapeLeadingUnderscores(name)); + // We conservatively include alias symbols to cover cases where they're emitted as locals + if (local && local.flags & (111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */ | 2097152 /* SymbolFlags.Alias */)) { + return false; + } + } + } + return true; + } + function getTempFlags(formattedNameKey) { + var _a; + switch (formattedNameKey) { + case "": + return tempFlags; + case "#": + return privateNameTempFlags; + default: + return (_a = formattedNameTempFlags === null || formattedNameTempFlags === void 0 ? void 0 : formattedNameTempFlags.get(formattedNameKey)) !== null && _a !== void 0 ? _a : 0 /* TempFlags.Auto */; + } + } + function setTempFlags(formattedNameKey, flags) { + switch (formattedNameKey) { + case "": + tempFlags = flags; + break; + case "#": + privateNameTempFlags = flags; + break; + default: + formattedNameTempFlags !== null && formattedNameTempFlags !== void 0 ? formattedNameTempFlags : (formattedNameTempFlags = new ts.Map()); + formattedNameTempFlags.set(formattedNameKey, flags); + break; + } + } + /** + * Return the next available name in the pattern _a ... _z, _0, _1, ... + * TempFlags._i or TempFlags._n may be used to express a preference for that dedicated name. + * Note that names generated by makeTempVariableName and makeUniqueName will never conflict. + */ + function makeTempVariableName(flags, reservedInNestedScopes, privateName, prefix, suffix) { + if (prefix.length > 0 && prefix.charCodeAt(0) === 35 /* CharacterCodes.hash */) { + prefix = prefix.slice(1); + } + // Generate a key to use to acquire a TempFlags counter based on the fixed portions of the generated name. + var key = ts.formatGeneratedName(privateName, prefix, "", suffix); + var tempFlags = getTempFlags(key); + if (flags && !(tempFlags & flags)) { + var name = flags === 268435456 /* TempFlags._i */ ? "_i" : "_n"; + var fullName = ts.formatGeneratedName(privateName, prefix, name, suffix); + if (isUniqueName(fullName)) { + tempFlags |= flags; + if (reservedInNestedScopes) { + reserveNameInNestedScopes(fullName); + } + setTempFlags(key, tempFlags); + return fullName; + } + } + while (true) { + var count = tempFlags & 268435455 /* TempFlags.CountMask */; + tempFlags++; + // Skip over 'i' and 'n' + if (count !== 8 && count !== 13) { + var name = count < 26 + ? "_" + String.fromCharCode(97 /* CharacterCodes.a */ + count) + : "_" + (count - 26); + var fullName = ts.formatGeneratedName(privateName, prefix, name, suffix); + if (isUniqueName(fullName)) { + if (reservedInNestedScopes) { + reserveNameInNestedScopes(fullName); + } + setTempFlags(key, tempFlags); + return fullName; + } + } + } + } + /** + * Generate a name that is unique within the current file and doesn't conflict with any names + * in global scope. The name is formed by adding an '_n' suffix to the specified base name, + * where n is a positive integer. Note that names generated by makeTempVariableName and + * makeUniqueName are guaranteed to never conflict. + * If `optimistic` is set, the first instance will use 'baseName' verbatim instead of 'baseName_1' + */ + function makeUniqueName(baseName, checkFn, optimistic, scoped, privateName, prefix, suffix) { + if (checkFn === void 0) { checkFn = isUniqueName; } + if (baseName.length > 0 && baseName.charCodeAt(0) === 35 /* CharacterCodes.hash */) { + baseName = baseName.slice(1); + } + if (prefix.length > 0 && prefix.charCodeAt(0) === 35 /* CharacterCodes.hash */) { + prefix = prefix.slice(1); + } + if (optimistic) { + var fullName = ts.formatGeneratedName(privateName, prefix, baseName, suffix); + if (checkFn(fullName)) { + if (scoped) { + reserveNameInNestedScopes(fullName); + } + else { + generatedNames.add(fullName); + } + return fullName; + } + } + // Find the first unique 'name_n', where n is a positive number + if (baseName.charCodeAt(baseName.length - 1) !== 95 /* CharacterCodes._ */) { + baseName += "_"; + } + var i = 1; + while (true) { + var fullName = ts.formatGeneratedName(privateName, prefix, baseName + i, suffix); + if (checkFn(fullName)) { + if (scoped) { + reserveNameInNestedScopes(fullName); + } + else { + generatedNames.add(fullName); + } + return fullName; + } + i++; + } + } + function makeFileLevelOptimisticUniqueName(name) { + return makeUniqueName(name, isFileLevelUniqueName, /*optimistic*/ true, /*scoped*/ false, /*privateName*/ false, /*prefix*/ "", /*suffix*/ ""); + } + /** + * Generates a unique name for a ModuleDeclaration or EnumDeclaration. + */ + function generateNameForModuleOrEnum(node) { + var name = getTextOfNode(node.name); + // Use module/enum name itself if it is unique, otherwise make a unique variation + return isUniqueLocalName(name, node) ? name : makeUniqueName(name, isUniqueName, /*optimistic*/ false, /*scoped*/ false, /*privateName*/ false, /*prefix*/ "", /*suffix*/ ""); + } + /** + * Generates a unique name for an ImportDeclaration or ExportDeclaration. + */ + function generateNameForImportOrExportDeclaration(node) { + var expr = ts.getExternalModuleName(node); // TODO: GH#18217 + var baseName = ts.isStringLiteral(expr) ? + ts.makeIdentifierFromModuleName(expr.text) : "module"; + return makeUniqueName(baseName, isUniqueName, /*optimistic*/ false, /*scoped*/ false, /*privateName*/ false, /*prefix*/ "", /*suffix*/ ""); + } + /** + * Generates a unique name for a default export. + */ + function generateNameForExportDefault() { + return makeUniqueName("default", isUniqueName, /*optimistic*/ false, /*scoped*/ false, /*privateName*/ false, /*prefix*/ "", /*suffix*/ ""); + } + /** + * Generates a unique name for a class expression. + */ + function generateNameForClassExpression() { + return makeUniqueName("class", isUniqueName, /*optimistic*/ false, /*scoped*/ false, /*privateName*/ false, /*prefix*/ "", /*suffix*/ ""); + } + function generateNameForMethodOrAccessor(node, privateName, prefix, suffix) { + if (ts.isIdentifier(node.name)) { + return generateNameCached(node.name, privateName); + } + return makeTempVariableName(0 /* TempFlags.Auto */, /*reservedInNestedScopes*/ false, privateName, prefix, suffix); + } + /** + * Generates a unique name from a node. + */ + function generateNameForNode(node, privateName, flags, prefix, suffix) { + switch (node.kind) { + case 79 /* SyntaxKind.Identifier */: + case 80 /* SyntaxKind.PrivateIdentifier */: + return makeUniqueName(getTextOfNode(node), isUniqueName, !!(flags & 16 /* GeneratedIdentifierFlags.Optimistic */), !!(flags & 8 /* GeneratedIdentifierFlags.ReservedInNestedScopes */), privateName, prefix, suffix); + case 264 /* SyntaxKind.ModuleDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + ts.Debug.assert(!prefix && !suffix && !privateName); + return generateNameForModuleOrEnum(node); + case 269 /* SyntaxKind.ImportDeclaration */: + case 275 /* SyntaxKind.ExportDeclaration */: + ts.Debug.assert(!prefix && !suffix && !privateName); + return generateNameForImportOrExportDeclaration(node); + case 259 /* SyntaxKind.FunctionDeclaration */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 274 /* SyntaxKind.ExportAssignment */: + ts.Debug.assert(!prefix && !suffix && !privateName); + return generateNameForExportDefault(); + case 228 /* SyntaxKind.ClassExpression */: + ts.Debug.assert(!prefix && !suffix && !privateName); + return generateNameForClassExpression(); + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + return generateNameForMethodOrAccessor(node, privateName, prefix, suffix); + case 164 /* SyntaxKind.ComputedPropertyName */: + return makeTempVariableName(0 /* TempFlags.Auto */, /*reserveInNestedScopes*/ true, privateName, prefix, suffix); + default: + return makeTempVariableName(0 /* TempFlags.Auto */, /*reserveInNestedScopes*/ false, privateName, prefix, suffix); + } + } + /** + * Generates a unique identifier for a node. + */ + function makeName(name) { + var prefix = ts.formatGeneratedNamePart(name.autoGeneratePrefix, generateName); + var suffix = ts.formatGeneratedNamePart(name.autoGenerateSuffix); + switch (name.autoGenerateFlags & 7 /* GeneratedIdentifierFlags.KindMask */) { + case 1 /* GeneratedIdentifierFlags.Auto */: + return makeTempVariableName(0 /* TempFlags.Auto */, !!(name.autoGenerateFlags & 8 /* GeneratedIdentifierFlags.ReservedInNestedScopes */), ts.isPrivateIdentifier(name), prefix, suffix); + case 2 /* GeneratedIdentifierFlags.Loop */: + ts.Debug.assertNode(name, ts.isIdentifier); + return makeTempVariableName(268435456 /* TempFlags._i */, !!(name.autoGenerateFlags & 8 /* GeneratedIdentifierFlags.ReservedInNestedScopes */), /*privateName*/ false, prefix, suffix); + case 3 /* GeneratedIdentifierFlags.Unique */: + return makeUniqueName(ts.idText(name), (name.autoGenerateFlags & 32 /* GeneratedIdentifierFlags.FileLevel */) ? isFileLevelUniqueName : isUniqueName, !!(name.autoGenerateFlags & 16 /* GeneratedIdentifierFlags.Optimistic */), !!(name.autoGenerateFlags & 8 /* GeneratedIdentifierFlags.ReservedInNestedScopes */), ts.isPrivateIdentifier(name), prefix, suffix); + } + return ts.Debug.fail("Unsupported GeneratedIdentifierKind: ".concat(ts.Debug.formatEnum(name.autoGenerateFlags & 7 /* GeneratedIdentifierFlags.KindMask */, ts.GeneratedIdentifierFlags, /*isFlags*/ true), ".")); + } + // Comments + function pipelineEmitWithComments(hint, node) { + var pipelinePhase = getNextPipelinePhase(2 /* PipelinePhase.Comments */, hint, node); + var savedContainerPos = containerPos; + var savedContainerEnd = containerEnd; + var savedDeclarationListContainerEnd = declarationListContainerEnd; + emitCommentsBeforeNode(node); + pipelinePhase(hint, node); + emitCommentsAfterNode(node, savedContainerPos, savedContainerEnd, savedDeclarationListContainerEnd); + } + function emitCommentsBeforeNode(node) { + var emitFlags = ts.getEmitFlags(node); + var commentRange = ts.getCommentRange(node); + // Emit leading comments + emitLeadingCommentsOfNode(node, emitFlags, commentRange.pos, commentRange.end); + if (emitFlags & 2048 /* EmitFlags.NoNestedComments */) { + commentsDisabled = true; + } + } + function emitCommentsAfterNode(node, savedContainerPos, savedContainerEnd, savedDeclarationListContainerEnd) { + var emitFlags = ts.getEmitFlags(node); + var commentRange = ts.getCommentRange(node); + // Emit trailing comments + if (emitFlags & 2048 /* EmitFlags.NoNestedComments */) { + commentsDisabled = false; + } + emitTrailingCommentsOfNode(node, emitFlags, commentRange.pos, commentRange.end, savedContainerPos, savedContainerEnd, savedDeclarationListContainerEnd); + var typeNode = ts.getTypeNode(node); + if (typeNode) { + emitTrailingCommentsOfNode(node, emitFlags, typeNode.pos, typeNode.end, savedContainerPos, savedContainerEnd, savedDeclarationListContainerEnd); + } + } + function emitLeadingCommentsOfNode(node, emitFlags, pos, end) { + enterComment(); + hasWrittenComment = false; + // We have to explicitly check that the node is JsxText because if the compilerOptions.jsx is "preserve" we will not do any transformation. + // It is expensive to walk entire tree just to set one kind of node to have no comments. + var skipLeadingComments = pos < 0 || (emitFlags & 512 /* EmitFlags.NoLeadingComments */) !== 0 || node.kind === 11 /* SyntaxKind.JsxText */; + var skipTrailingComments = end < 0 || (emitFlags & 1024 /* EmitFlags.NoTrailingComments */) !== 0 || node.kind === 11 /* SyntaxKind.JsxText */; + // Save current container state on the stack. + if ((pos > 0 || end > 0) && pos !== end) { + // Emit leading comments if the position is not synthesized and the node + // has not opted out from emitting leading comments. + if (!skipLeadingComments) { + emitLeadingComments(pos, /*isEmittedNode*/ node.kind !== 352 /* SyntaxKind.NotEmittedStatement */); + } + if (!skipLeadingComments || (pos >= 0 && (emitFlags & 512 /* EmitFlags.NoLeadingComments */) !== 0)) { + // Advance the container position if comments get emitted or if they've been disabled explicitly using NoLeadingComments. + containerPos = pos; + } + if (!skipTrailingComments || (end >= 0 && (emitFlags & 1024 /* EmitFlags.NoTrailingComments */) !== 0)) { + // As above. + containerEnd = end; + // To avoid invalid comment emit in a down-level binding pattern, we + // keep track of the last declaration list container's end + if (node.kind === 258 /* SyntaxKind.VariableDeclarationList */) { + declarationListContainerEnd = end; + } + } + } + ts.forEach(ts.getSyntheticLeadingComments(node), emitLeadingSynthesizedComment); + exitComment(); + } + function emitTrailingCommentsOfNode(node, emitFlags, pos, end, savedContainerPos, savedContainerEnd, savedDeclarationListContainerEnd) { + enterComment(); + var skipTrailingComments = end < 0 || (emitFlags & 1024 /* EmitFlags.NoTrailingComments */) !== 0 || node.kind === 11 /* SyntaxKind.JsxText */; + ts.forEach(ts.getSyntheticTrailingComments(node), emitTrailingSynthesizedComment); + if ((pos > 0 || end > 0) && pos !== end) { + // Restore previous container state. + containerPos = savedContainerPos; + containerEnd = savedContainerEnd; + declarationListContainerEnd = savedDeclarationListContainerEnd; + // Emit trailing comments if the position is not synthesized and the node + // has not opted out from emitting leading comments and is an emitted node. + if (!skipTrailingComments && node.kind !== 352 /* SyntaxKind.NotEmittedStatement */) { + emitTrailingComments(end); + } + } + exitComment(); + } + function emitLeadingSynthesizedComment(comment) { + if (comment.hasLeadingNewline || comment.kind === 2 /* SyntaxKind.SingleLineCommentTrivia */) { + writer.writeLine(); + } + writeSynthesizedComment(comment); + if (comment.hasTrailingNewLine || comment.kind === 2 /* SyntaxKind.SingleLineCommentTrivia */) { + writer.writeLine(); + } + else { + writer.writeSpace(" "); + } + } + function emitTrailingSynthesizedComment(comment) { + if (!writer.isAtStartOfLine()) { + writer.writeSpace(" "); + } + writeSynthesizedComment(comment); + if (comment.hasTrailingNewLine) { + writer.writeLine(); + } + } + function writeSynthesizedComment(comment) { + var text = formatSynthesizedComment(comment); + var lineMap = comment.kind === 3 /* SyntaxKind.MultiLineCommentTrivia */ ? ts.computeLineStarts(text) : undefined; + ts.writeCommentRange(text, lineMap, writer, 0, text.length, newLine); + } + function formatSynthesizedComment(comment) { + return comment.kind === 3 /* SyntaxKind.MultiLineCommentTrivia */ + ? "/*".concat(comment.text, "*/") + : "//".concat(comment.text); + } + function emitBodyWithDetachedComments(node, detachedRange, emitCallback) { + enterComment(); + var pos = detachedRange.pos, end = detachedRange.end; + var emitFlags = ts.getEmitFlags(node); + var skipLeadingComments = pos < 0 || (emitFlags & 512 /* EmitFlags.NoLeadingComments */) !== 0; + var skipTrailingComments = commentsDisabled || end < 0 || (emitFlags & 1024 /* EmitFlags.NoTrailingComments */) !== 0; + if (!skipLeadingComments) { + emitDetachedCommentsAndUpdateCommentsInfo(detachedRange); + } + exitComment(); + if (emitFlags & 2048 /* EmitFlags.NoNestedComments */ && !commentsDisabled) { + commentsDisabled = true; + emitCallback(node); + commentsDisabled = false; + } + else { + emitCallback(node); + } + enterComment(); + if (!skipTrailingComments) { + emitLeadingComments(detachedRange.end, /*isEmittedNode*/ true); + if (hasWrittenComment && !writer.isAtStartOfLine()) { + writer.writeLine(); + } + } + exitComment(); + } + function originalNodesHaveSameParent(nodeA, nodeB) { + nodeA = ts.getOriginalNode(nodeA); + // For performance, do not call `getOriginalNode` for `nodeB` if `nodeA` doesn't even + // have a parent node. + return nodeA.parent && nodeA.parent === ts.getOriginalNode(nodeB).parent; + } + function siblingNodePositionsAreComparable(previousNode, nextNode) { + if (nextNode.pos < previousNode.end) { + return false; + } + previousNode = ts.getOriginalNode(previousNode); + nextNode = ts.getOriginalNode(nextNode); + var parent = previousNode.parent; + if (!parent || parent !== nextNode.parent) { + return false; + } + var parentNodeArray = ts.getContainingNodeArray(previousNode); + var prevNodeIndex = parentNodeArray === null || parentNodeArray === void 0 ? void 0 : parentNodeArray.indexOf(previousNode); + return prevNodeIndex !== undefined && prevNodeIndex > -1 && parentNodeArray.indexOf(nextNode) === prevNodeIndex + 1; + } + function emitLeadingComments(pos, isEmittedNode) { + hasWrittenComment = false; + if (isEmittedNode) { + if (pos === 0 && (currentSourceFile === null || currentSourceFile === void 0 ? void 0 : currentSourceFile.isDeclarationFile)) { + forEachLeadingCommentToEmit(pos, emitNonTripleSlashLeadingComment); + } + else { + forEachLeadingCommentToEmit(pos, emitLeadingComment); + } + } + else if (pos === 0) { + // If the node will not be emitted in JS, remove all the comments(normal, pinned and ///) associated with the node, + // unless it is a triple slash comment at the top of the file. + // For Example: + // /// + // declare var x; + // /// + // interface F {} + // The first /// will NOT be removed while the second one will be removed even though both node will not be emitted + forEachLeadingCommentToEmit(pos, emitTripleSlashLeadingComment); + } + } + function emitTripleSlashLeadingComment(commentPos, commentEnd, kind, hasTrailingNewLine, rangePos) { + if (isTripleSlashComment(commentPos, commentEnd)) { + emitLeadingComment(commentPos, commentEnd, kind, hasTrailingNewLine, rangePos); + } + } + function emitNonTripleSlashLeadingComment(commentPos, commentEnd, kind, hasTrailingNewLine, rangePos) { + if (!isTripleSlashComment(commentPos, commentEnd)) { + emitLeadingComment(commentPos, commentEnd, kind, hasTrailingNewLine, rangePos); + } + } + function shouldWriteComment(text, pos) { + if (printerOptions.onlyPrintJsDocStyle) { + return (ts.isJSDocLikeText(text, pos) || ts.isPinnedComment(text, pos)); + } + return true; + } + function emitLeadingComment(commentPos, commentEnd, kind, hasTrailingNewLine, rangePos) { + if (!currentSourceFile || !shouldWriteComment(currentSourceFile.text, commentPos)) + return; + if (!hasWrittenComment) { + ts.emitNewLineBeforeLeadingCommentOfPosition(getCurrentLineMap(), writer, rangePos, commentPos); + hasWrittenComment = true; + } + // Leading comments are emitted at /*leading comment1 */space/*leading comment*/space + emitPos(commentPos); + ts.writeCommentRange(currentSourceFile.text, getCurrentLineMap(), writer, commentPos, commentEnd, newLine); + emitPos(commentEnd); + if (hasTrailingNewLine) { + writer.writeLine(); + } + else if (kind === 3 /* SyntaxKind.MultiLineCommentTrivia */) { + writer.writeSpace(" "); + } + } + function emitLeadingCommentsOfPosition(pos) { + if (commentsDisabled || pos === -1) { + return; + } + emitLeadingComments(pos, /*isEmittedNode*/ true); + } + function emitTrailingComments(pos) { + forEachTrailingCommentToEmit(pos, emitTrailingComment); + } + function emitTrailingComment(commentPos, commentEnd, _kind, hasTrailingNewLine) { + if (!currentSourceFile || !shouldWriteComment(currentSourceFile.text, commentPos)) + return; + // trailing comments are emitted at space/*trailing comment1 */space/*trailing comment2*/ + if (!writer.isAtStartOfLine()) { + writer.writeSpace(" "); + } + emitPos(commentPos); + ts.writeCommentRange(currentSourceFile.text, getCurrentLineMap(), writer, commentPos, commentEnd, newLine); + emitPos(commentEnd); + if (hasTrailingNewLine) { + writer.writeLine(); + } + } + function emitTrailingCommentsOfPosition(pos, prefixSpace, forceNoNewline) { + if (commentsDisabled) { + return; + } + enterComment(); + forEachTrailingCommentToEmit(pos, prefixSpace ? emitTrailingComment : forceNoNewline ? emitTrailingCommentOfPositionNoNewline : emitTrailingCommentOfPosition); + exitComment(); + } + function emitTrailingCommentOfPositionNoNewline(commentPos, commentEnd, kind) { + if (!currentSourceFile) + return; + // trailing comments of a position are emitted at /*trailing comment1 */space/*trailing comment*/space + emitPos(commentPos); + ts.writeCommentRange(currentSourceFile.text, getCurrentLineMap(), writer, commentPos, commentEnd, newLine); + emitPos(commentEnd); + if (kind === 2 /* SyntaxKind.SingleLineCommentTrivia */) { + writer.writeLine(); // still write a newline for single-line comments, so closing tokens aren't written on the same line + } + } + function emitTrailingCommentOfPosition(commentPos, commentEnd, _kind, hasTrailingNewLine) { + if (!currentSourceFile) + return; + // trailing comments of a position are emitted at /*trailing comment1 */space/*trailing comment*/space + emitPos(commentPos); + ts.writeCommentRange(currentSourceFile.text, getCurrentLineMap(), writer, commentPos, commentEnd, newLine); + emitPos(commentEnd); + if (hasTrailingNewLine) { + writer.writeLine(); + } + else { + writer.writeSpace(" "); + } + } + function forEachLeadingCommentToEmit(pos, cb) { + // Emit the leading comments only if the container's pos doesn't match because the container should take care of emitting these comments + if (currentSourceFile && (containerPos === -1 || pos !== containerPos)) { + if (hasDetachedComments(pos)) { + forEachLeadingCommentWithoutDetachedComments(cb); + } + else { + ts.forEachLeadingCommentRange(currentSourceFile.text, pos, cb, /*state*/ pos); + } + } + } + function forEachTrailingCommentToEmit(end, cb) { + // Emit the trailing comments only if the container's end doesn't match because the container should take care of emitting these comments + if (currentSourceFile && (containerEnd === -1 || (end !== containerEnd && end !== declarationListContainerEnd))) { + ts.forEachTrailingCommentRange(currentSourceFile.text, end, cb); + } + } + function hasDetachedComments(pos) { + return detachedCommentsInfo !== undefined && ts.last(detachedCommentsInfo).nodePos === pos; + } + function forEachLeadingCommentWithoutDetachedComments(cb) { + if (!currentSourceFile) + return; + // get the leading comments from detachedPos + var pos = ts.last(detachedCommentsInfo).detachedCommentEndPos; + if (detachedCommentsInfo.length - 1) { + detachedCommentsInfo.pop(); + } + else { + detachedCommentsInfo = undefined; + } + ts.forEachLeadingCommentRange(currentSourceFile.text, pos, cb, /*state*/ pos); + } + function emitDetachedCommentsAndUpdateCommentsInfo(range) { + var currentDetachedCommentInfo = currentSourceFile && ts.emitDetachedComments(currentSourceFile.text, getCurrentLineMap(), writer, emitComment, range, newLine, commentsDisabled); + if (currentDetachedCommentInfo) { + if (detachedCommentsInfo) { + detachedCommentsInfo.push(currentDetachedCommentInfo); + } + else { + detachedCommentsInfo = [currentDetachedCommentInfo]; + } + } + } + function emitComment(text, lineMap, writer, commentPos, commentEnd, newLine) { + if (!currentSourceFile || !shouldWriteComment(currentSourceFile.text, commentPos)) + return; + emitPos(commentPos); + ts.writeCommentRange(text, lineMap, writer, commentPos, commentEnd, newLine); + emitPos(commentEnd); + } + /** + * Determine if the given comment is a triple-slash + * + * @return true if the comment is a triple-slash comment else false + */ + function isTripleSlashComment(commentPos, commentEnd) { + return !!currentSourceFile && ts.isRecognizedTripleSlashComment(currentSourceFile.text, commentPos, commentEnd); + } + // Source Maps + function getParsedSourceMap(node) { + if (node.parsedSourceMap === undefined && node.sourceMapText !== undefined) { + node.parsedSourceMap = ts.tryParseRawSourceMap(node.sourceMapText) || false; + } + return node.parsedSourceMap || undefined; + } + function pipelineEmitWithSourceMaps(hint, node) { + var pipelinePhase = getNextPipelinePhase(3 /* PipelinePhase.SourceMaps */, hint, node); + emitSourceMapsBeforeNode(node); + pipelinePhase(hint, node); + emitSourceMapsAfterNode(node); + } + function emitSourceMapsBeforeNode(node) { + var emitFlags = ts.getEmitFlags(node); + var sourceMapRange = ts.getSourceMapRange(node); + // Emit leading sourcemap + if (ts.isUnparsedNode(node)) { + ts.Debug.assertIsDefined(node.parent, "UnparsedNodes must have parent pointers"); + var parsed = getParsedSourceMap(node.parent); + if (parsed && sourceMapGenerator) { + sourceMapGenerator.appendSourceMap(writer.getLine(), writer.getColumn(), parsed, node.parent.sourceMapPath, node.parent.getLineAndCharacterOfPosition(node.pos), node.parent.getLineAndCharacterOfPosition(node.end)); + } + } + else { + var source = sourceMapRange.source || sourceMapSource; + if (node.kind !== 352 /* SyntaxKind.NotEmittedStatement */ + && (emitFlags & 16 /* EmitFlags.NoLeadingSourceMap */) === 0 + && sourceMapRange.pos >= 0) { + emitSourcePos(sourceMapRange.source || sourceMapSource, skipSourceTrivia(source, sourceMapRange.pos)); + } + if (emitFlags & 64 /* EmitFlags.NoNestedSourceMaps */) { + sourceMapsDisabled = true; + } + } + } + function emitSourceMapsAfterNode(node) { + var emitFlags = ts.getEmitFlags(node); + var sourceMapRange = ts.getSourceMapRange(node); + // Emit trailing sourcemap + if (!ts.isUnparsedNode(node)) { + if (emitFlags & 64 /* EmitFlags.NoNestedSourceMaps */) { + sourceMapsDisabled = false; + } + if (node.kind !== 352 /* SyntaxKind.NotEmittedStatement */ + && (emitFlags & 32 /* EmitFlags.NoTrailingSourceMap */) === 0 + && sourceMapRange.end >= 0) { + emitSourcePos(sourceMapRange.source || sourceMapSource, sourceMapRange.end); + } + } + } + /** + * Skips trivia such as comments and white-space that can be optionally overridden by the source-map source + */ + function skipSourceTrivia(source, pos) { + return source.skipTrivia ? source.skipTrivia(pos) : ts.skipTrivia(source.text, pos); + } + /** + * Emits a mapping. + * + * If the position is synthetic (undefined or a negative value), no mapping will be + * created. + * + * @param pos The position. + */ + function emitPos(pos) { + if (sourceMapsDisabled || ts.positionIsSynthesized(pos) || isJsonSourceMapSource(sourceMapSource)) { + return; + } + var _a = ts.getLineAndCharacterOfPosition(sourceMapSource, pos), sourceLine = _a.line, sourceCharacter = _a.character; + sourceMapGenerator.addMapping(writer.getLine(), writer.getColumn(), sourceMapSourceIndex, sourceLine, sourceCharacter, + /*nameIndex*/ undefined); + } + function emitSourcePos(source, pos) { + if (source !== sourceMapSource) { + var savedSourceMapSource = sourceMapSource; + var savedSourceMapSourceIndex = sourceMapSourceIndex; + setSourceMapSource(source); + emitPos(pos); + resetSourceMapSource(savedSourceMapSource, savedSourceMapSourceIndex); + } + else { + emitPos(pos); + } + } + /** + * Emits a token of a node with possible leading and trailing source maps. + * + * @param node The node containing the token. + * @param token The token to emit. + * @param tokenStartPos The start pos of the token. + * @param emitCallback The callback used to emit the token. + */ + function emitTokenWithSourceMap(node, token, writer, tokenPos, emitCallback) { + if (sourceMapsDisabled || node && ts.isInJsonFile(node)) { + return emitCallback(token, writer, tokenPos); + } + var emitNode = node && node.emitNode; + var emitFlags = emitNode && emitNode.flags || 0 /* EmitFlags.None */; + var range = emitNode && emitNode.tokenSourceMapRanges && emitNode.tokenSourceMapRanges[token]; + var source = range && range.source || sourceMapSource; + tokenPos = skipSourceTrivia(source, range ? range.pos : tokenPos); + if ((emitFlags & 128 /* EmitFlags.NoTokenLeadingSourceMaps */) === 0 && tokenPos >= 0) { + emitSourcePos(source, tokenPos); + } + tokenPos = emitCallback(token, writer, tokenPos); + if (range) + tokenPos = range.end; + if ((emitFlags & 256 /* EmitFlags.NoTokenTrailingSourceMaps */) === 0 && tokenPos >= 0) { + emitSourcePos(source, tokenPos); + } + return tokenPos; + } + function setSourceMapSource(source) { + if (sourceMapsDisabled) { + return; + } + sourceMapSource = source; + if (source === mostRecentlyAddedSourceMapSource) { + // Fast path for when the new source map is the most recently added, in which case + // we use its captured index without going through the source map generator. + sourceMapSourceIndex = mostRecentlyAddedSourceMapSourceIndex; + return; + } + if (isJsonSourceMapSource(source)) { + return; + } + sourceMapSourceIndex = sourceMapGenerator.addSource(source.fileName); + if (printerOptions.inlineSources) { + sourceMapGenerator.setSourceContent(sourceMapSourceIndex, source.text); + } + mostRecentlyAddedSourceMapSource = source; + mostRecentlyAddedSourceMapSourceIndex = sourceMapSourceIndex; + } + function resetSourceMapSource(source, sourceIndex) { + sourceMapSource = source; + sourceMapSourceIndex = sourceIndex; + } + function isJsonSourceMapSource(sourceFile) { + return ts.fileExtensionIs(sourceFile.fileName, ".json" /* Extension.Json */); + } + } + ts.createPrinter = createPrinter; + function createBracketsMap() { + var brackets = []; + brackets[1024 /* ListFormat.Braces */] = ["{", "}"]; + brackets[2048 /* ListFormat.Parenthesis */] = ["(", ")"]; + brackets[4096 /* ListFormat.AngleBrackets */] = ["<", ">"]; + brackets[8192 /* ListFormat.SquareBrackets */] = ["[", "]"]; + return brackets; + } + function getOpeningBracket(format) { + return brackets[format & 15360 /* ListFormat.BracketsMask */][0]; + } + function getClosingBracket(format) { + return brackets[format & 15360 /* ListFormat.BracketsMask */][1]; + } + // Flags enum to track count of temp variables and a few dedicated names + var TempFlags; + (function (TempFlags) { + TempFlags[TempFlags["Auto"] = 0] = "Auto"; + TempFlags[TempFlags["CountMask"] = 268435455] = "CountMask"; + TempFlags[TempFlags["_i"] = 268435456] = "_i"; + })(TempFlags || (TempFlags = {})); + function emitListItemNoParenthesizer(node, emit, _parenthesizerRule, _index) { + emit(node); + } + function emitListItemWithParenthesizerRuleSelector(node, emit, parenthesizerRuleSelector, index) { + emit(node, parenthesizerRuleSelector.select(index)); + } + function emitListItemWithParenthesizerRule(node, emit, parenthesizerRule, _index) { + emit(node, parenthesizerRule); + } + function getEmitListItem(emit, parenthesizerRule) { + return emit.length === 1 ? emitListItemNoParenthesizer : + typeof parenthesizerRule === "object" ? emitListItemWithParenthesizerRuleSelector : + emitListItemWithParenthesizerRule; + } +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + function createCachedDirectoryStructureHost(host, currentDirectory, useCaseSensitiveFileNames) { + if (!host.getDirectories || !host.readDirectory) { + return undefined; + } + var cachedReadDirectoryResult = new ts.Map(); + var getCanonicalFileName = ts.createGetCanonicalFileName(useCaseSensitiveFileNames); + return { + useCaseSensitiveFileNames: useCaseSensitiveFileNames, + fileExists: fileExists, + readFile: function (path, encoding) { return host.readFile(path, encoding); }, + directoryExists: host.directoryExists && directoryExists, + getDirectories: getDirectories, + readDirectory: readDirectory, + createDirectory: host.createDirectory && createDirectory, + writeFile: host.writeFile && writeFile, + addOrDeleteFileOrDirectory: addOrDeleteFileOrDirectory, + addOrDeleteFile: addOrDeleteFile, + clearCache: clearCache, + realpath: host.realpath && realpath + }; + function toPath(fileName) { + return ts.toPath(fileName, currentDirectory, getCanonicalFileName); + } + function getCachedFileSystemEntries(rootDirPath) { + return cachedReadDirectoryResult.get(ts.ensureTrailingDirectorySeparator(rootDirPath)); + } + function getCachedFileSystemEntriesForBaseDir(path) { + var entries = getCachedFileSystemEntries(ts.getDirectoryPath(path)); + if (!entries) { + return entries; + } + // If we're looking for the base directory, we're definitely going to search the entries + if (!entries.sortedAndCanonicalizedFiles) { + entries.sortedAndCanonicalizedFiles = entries.files.map(getCanonicalFileName).sort(); + entries.sortedAndCanonicalizedDirectories = entries.directories.map(getCanonicalFileName).sort(); + } + return entries; + } + function getBaseNameOfFileName(fileName) { + return ts.getBaseFileName(ts.normalizePath(fileName)); + } + function createCachedFileSystemEntries(rootDir, rootDirPath) { + var _a; + if (!host.realpath || ts.ensureTrailingDirectorySeparator(toPath(host.realpath(rootDir))) === rootDirPath) { + var resultFromHost = { + files: ts.map(host.readDirectory(rootDir, /*extensions*/ undefined, /*exclude*/ undefined, /*include*/ ["*.*"]), getBaseNameOfFileName) || [], + directories: host.getDirectories(rootDir) || [] + }; + cachedReadDirectoryResult.set(ts.ensureTrailingDirectorySeparator(rootDirPath), resultFromHost); + return resultFromHost; + } + // If the directory is symlink do not cache the result + if ((_a = host.directoryExists) === null || _a === void 0 ? void 0 : _a.call(host, rootDir)) { + cachedReadDirectoryResult.set(rootDirPath, false); + return false; + } + // Non existing directory + return undefined; + } + /** + * If the readDirectory result was already cached, it returns that + * Otherwise gets result from host and caches it. + * The host request is done under try catch block to avoid caching incorrect result + */ + function tryReadDirectory(rootDir, rootDirPath) { + rootDirPath = ts.ensureTrailingDirectorySeparator(rootDirPath); + var cachedResult = getCachedFileSystemEntries(rootDirPath); + if (cachedResult) { + return cachedResult; + } + try { + return createCachedFileSystemEntries(rootDir, rootDirPath); + } + catch (_e) { + // If there is exception to read directories, dont cache the result and direct the calls to host + ts.Debug.assert(!cachedReadDirectoryResult.has(ts.ensureTrailingDirectorySeparator(rootDirPath))); + return undefined; + } + } + function hasEntry(entries, name) { + // Case-sensitive comparison since already canonicalized + var index = ts.binarySearch(entries, name, ts.identity, ts.compareStringsCaseSensitive); + return index >= 0; + } + function writeFile(fileName, data, writeByteOrderMark) { + var path = toPath(fileName); + var result = getCachedFileSystemEntriesForBaseDir(path); + if (result) { + updateFilesOfFileSystemEntry(result, getBaseNameOfFileName(fileName), /*fileExists*/ true); + } + return host.writeFile(fileName, data, writeByteOrderMark); + } + function fileExists(fileName) { + var path = toPath(fileName); + var result = getCachedFileSystemEntriesForBaseDir(path); + return result && hasEntry(result.sortedAndCanonicalizedFiles, getCanonicalFileName(getBaseNameOfFileName(fileName))) || + host.fileExists(fileName); + } + function directoryExists(dirPath) { + var path = toPath(dirPath); + return cachedReadDirectoryResult.has(ts.ensureTrailingDirectorySeparator(path)) || host.directoryExists(dirPath); + } + function createDirectory(dirPath) { + var path = toPath(dirPath); + var result = getCachedFileSystemEntriesForBaseDir(path); + if (result) { + var baseName = getBaseNameOfFileName(dirPath); + var canonicalizedBaseName = getCanonicalFileName(baseName); + var canonicalizedDirectories = result.sortedAndCanonicalizedDirectories; + // Case-sensitive comparison since already canonicalized + if (ts.insertSorted(canonicalizedDirectories, canonicalizedBaseName, ts.compareStringsCaseSensitive)) { + result.directories.push(baseName); + } + } + host.createDirectory(dirPath); + } + function getDirectories(rootDir) { + var rootDirPath = toPath(rootDir); + var result = tryReadDirectory(rootDir, rootDirPath); + if (result) { + return result.directories.slice(); + } + return host.getDirectories(rootDir); + } + function readDirectory(rootDir, extensions, excludes, includes, depth) { + var rootDirPath = toPath(rootDir); + var rootResult = tryReadDirectory(rootDir, rootDirPath); + var rootSymLinkResult; + if (rootResult !== undefined) { + return ts.matchFiles(rootDir, extensions, excludes, includes, useCaseSensitiveFileNames, currentDirectory, depth, getFileSystemEntries, realpath); + } + return host.readDirectory(rootDir, extensions, excludes, includes, depth); + function getFileSystemEntries(dir) { + var path = toPath(dir); + if (path === rootDirPath) { + return rootResult || getFileSystemEntriesFromHost(dir, path); + } + var result = tryReadDirectory(dir, path); + return result !== undefined ? + result || getFileSystemEntriesFromHost(dir, path) : + ts.emptyFileSystemEntries; + } + function getFileSystemEntriesFromHost(dir, path) { + if (rootSymLinkResult && path === rootDirPath) + return rootSymLinkResult; + var result = { + files: ts.map(host.readDirectory(dir, /*extensions*/ undefined, /*exclude*/ undefined, /*include*/ ["*.*"]), getBaseNameOfFileName) || ts.emptyArray, + directories: host.getDirectories(dir) || ts.emptyArray + }; + if (path === rootDirPath) + rootSymLinkResult = result; + return result; + } + } + function realpath(s) { + return host.realpath ? host.realpath(s) : s; + } + function addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath) { + var existingResult = getCachedFileSystemEntries(fileOrDirectoryPath); + if (existingResult !== undefined) { + // Just clear the cache for now + // For now just clear the cache, since this could mean that multiple level entries might need to be re-evaluated + clearCache(); + return undefined; + } + var parentResult = getCachedFileSystemEntriesForBaseDir(fileOrDirectoryPath); + if (!parentResult) { + return undefined; + } + // This was earlier a file (hence not in cached directory contents) + // or we never cached the directory containing it + if (!host.directoryExists) { + // Since host doesnt support directory exists, clear the cache as otherwise it might not be same + clearCache(); + return undefined; + } + var baseName = getBaseNameOfFileName(fileOrDirectory); + var fsQueryResult = { + fileExists: host.fileExists(fileOrDirectoryPath), + directoryExists: host.directoryExists(fileOrDirectoryPath) + }; + if (fsQueryResult.directoryExists || hasEntry(parentResult.sortedAndCanonicalizedDirectories, getCanonicalFileName(baseName))) { + // Folder added or removed, clear the cache instead of updating the folder and its structure + clearCache(); + } + else { + // No need to update the directory structure, just files + updateFilesOfFileSystemEntry(parentResult, baseName, fsQueryResult.fileExists); + } + return fsQueryResult; + } + function addOrDeleteFile(fileName, filePath, eventKind) { + if (eventKind === ts.FileWatcherEventKind.Changed) { + return; + } + var parentResult = getCachedFileSystemEntriesForBaseDir(filePath); + if (parentResult) { + updateFilesOfFileSystemEntry(parentResult, getBaseNameOfFileName(fileName), eventKind === ts.FileWatcherEventKind.Created); + } + } + function updateFilesOfFileSystemEntry(parentResult, baseName, fileExists) { + var canonicalizedFiles = parentResult.sortedAndCanonicalizedFiles; + var canonicalizedBaseName = getCanonicalFileName(baseName); + if (fileExists) { + // Case-sensitive comparison since already canonicalized + if (ts.insertSorted(canonicalizedFiles, canonicalizedBaseName, ts.compareStringsCaseSensitive)) { + parentResult.files.push(baseName); + } + } + else { + // Case-sensitive comparison since already canonicalized + var sortedIndex = ts.binarySearch(canonicalizedFiles, canonicalizedBaseName, ts.identity, ts.compareStringsCaseSensitive); + if (sortedIndex >= 0) { + canonicalizedFiles.splice(sortedIndex, 1); + var unsortedIndex = parentResult.files.findIndex(function (entry) { return getCanonicalFileName(entry) === canonicalizedBaseName; }); + parentResult.files.splice(unsortedIndex, 1); + } + } + } + function clearCache() { + cachedReadDirectoryResult.clear(); + } + } + ts.createCachedDirectoryStructureHost = createCachedDirectoryStructureHost; + var ConfigFileProgramReloadLevel; + (function (ConfigFileProgramReloadLevel) { + ConfigFileProgramReloadLevel[ConfigFileProgramReloadLevel["None"] = 0] = "None"; + /** Update the file name list from the disk */ + ConfigFileProgramReloadLevel[ConfigFileProgramReloadLevel["Partial"] = 1] = "Partial"; + /** Reload completely by re-reading contents of config file from disk and updating program */ + ConfigFileProgramReloadLevel[ConfigFileProgramReloadLevel["Full"] = 2] = "Full"; + })(ConfigFileProgramReloadLevel = ts.ConfigFileProgramReloadLevel || (ts.ConfigFileProgramReloadLevel = {})); + /** + * Updates the map of shared extended config file watches with a new set of extended config files from a base config file of the project + */ + function updateSharedExtendedConfigFileWatcher(projectPath, options, extendedConfigFilesMap, createExtendedConfigFileWatch, toPath) { + var _a; + var extendedConfigs = ts.arrayToMap(((_a = options === null || options === void 0 ? void 0 : options.configFile) === null || _a === void 0 ? void 0 : _a.extendedSourceFiles) || ts.emptyArray, toPath); + // remove project from all unrelated watchers + extendedConfigFilesMap.forEach(function (watcher, extendedConfigFilePath) { + if (!extendedConfigs.has(extendedConfigFilePath)) { + watcher.projects.delete(projectPath); + watcher.close(); + } + }); + // Update the extended config files watcher + extendedConfigs.forEach(function (extendedConfigFileName, extendedConfigFilePath) { + var existing = extendedConfigFilesMap.get(extendedConfigFilePath); + if (existing) { + existing.projects.add(projectPath); + } + else { + // start watching previously unseen extended config + extendedConfigFilesMap.set(extendedConfigFilePath, { + projects: new ts.Set([projectPath]), + watcher: createExtendedConfigFileWatch(extendedConfigFileName, extendedConfigFilePath), + close: function () { + var existing = extendedConfigFilesMap.get(extendedConfigFilePath); + if (!existing || existing.projects.size !== 0) + return; + existing.watcher.close(); + extendedConfigFilesMap.delete(extendedConfigFilePath); + }, + }); + } + }); + } + ts.updateSharedExtendedConfigFileWatcher = updateSharedExtendedConfigFileWatcher; + /** + * Remove the project from the extended config file watchers and close not needed watches + */ + function clearSharedExtendedConfigFileWatcher(projectPath, extendedConfigFilesMap) { + extendedConfigFilesMap.forEach(function (watcher) { + if (watcher.projects.delete(projectPath)) + watcher.close(); + }); + } + ts.clearSharedExtendedConfigFileWatcher = clearSharedExtendedConfigFileWatcher; + /** + * Clean the extendsConfigCache when extended config file has changed + */ + function cleanExtendedConfigCache(extendedConfigCache, extendedConfigFilePath, toPath) { + if (!extendedConfigCache.delete(extendedConfigFilePath)) + return; + extendedConfigCache.forEach(function (_a, key) { + var _b; + var extendedResult = _a.extendedResult; + if ((_b = extendedResult.extendedSourceFiles) === null || _b === void 0 ? void 0 : _b.some(function (extendedFile) { return toPath(extendedFile) === extendedConfigFilePath; })) { + cleanExtendedConfigCache(extendedConfigCache, key, toPath); + } + }); + } + ts.cleanExtendedConfigCache = cleanExtendedConfigCache; + /** + * Updates watchers based on the package json files used in module resolution + */ + function updatePackageJsonWatch(lookups, packageJsonWatches, createPackageJsonWatch) { + var newMap = new ts.Map(lookups); + ts.mutateMap(packageJsonWatches, newMap, { + createNewValue: createPackageJsonWatch, + onDeleteValue: ts.closeFileWatcher + }); + } + ts.updatePackageJsonWatch = updatePackageJsonWatch; + /** + * Updates the existing missing file watches with the new set of missing files after new program is created + */ + function updateMissingFilePathsWatch(program, missingFileWatches, createMissingFileWatch) { + var missingFilePaths = program.getMissingFilePaths(); + // TODO(rbuckton): Should be a `Set` but that requires changing the below code that uses `mutateMap` + var newMissingFilePathMap = ts.arrayToMap(missingFilePaths, ts.identity, ts.returnTrue); + // Update the missing file paths watcher + ts.mutateMap(missingFileWatches, newMissingFilePathMap, { + // Watch the missing files + createNewValue: createMissingFileWatch, + // Files that are no longer missing (e.g. because they are no longer required) + // should no longer be watched. + onDeleteValue: ts.closeFileWatcher + }); + } + ts.updateMissingFilePathsWatch = updateMissingFilePathsWatch; + /** + * Updates the existing wild card directory watches with the new set of wild card directories from the config file + * after new program is created because the config file was reloaded or program was created first time from the config file + * Note that there is no need to call this function when the program is updated with additional files without reloading config files, + * as wildcard directories wont change unless reloading config file + */ + function updateWatchingWildcardDirectories(existingWatchedForWildcards, wildcardDirectories, watchDirectory) { + ts.mutateMap(existingWatchedForWildcards, wildcardDirectories, { + // Create new watch and recursive info + createNewValue: createWildcardDirectoryWatcher, + // Close existing watch thats not needed any more + onDeleteValue: closeFileWatcherOf, + // Close existing watch that doesnt match in the flags + onExistingValue: updateWildcardDirectoryWatcher + }); + function createWildcardDirectoryWatcher(directory, flags) { + // Create new watch and recursive info + return { + watcher: watchDirectory(directory, flags), + flags: flags + }; + } + function updateWildcardDirectoryWatcher(existingWatcher, flags, directory) { + // Watcher needs to be updated if the recursive flags dont match + if (existingWatcher.flags === flags) { + return; + } + existingWatcher.watcher.close(); + existingWatchedForWildcards.set(directory, createWildcardDirectoryWatcher(directory, flags)); + } + } + ts.updateWatchingWildcardDirectories = updateWatchingWildcardDirectories; + /* @internal */ + function isIgnoredFileFromWildCardWatching(_a) { + var watchedDirPath = _a.watchedDirPath, fileOrDirectory = _a.fileOrDirectory, fileOrDirectoryPath = _a.fileOrDirectoryPath, configFileName = _a.configFileName, options = _a.options, program = _a.program, extraFileExtensions = _a.extraFileExtensions, currentDirectory = _a.currentDirectory, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, writeLog = _a.writeLog, toPath = _a.toPath; + var newPath = ts.removeIgnoredPath(fileOrDirectoryPath); + if (!newPath) { + writeLog("Project: ".concat(configFileName, " Detected ignored path: ").concat(fileOrDirectory)); + return true; + } + fileOrDirectoryPath = newPath; + if (fileOrDirectoryPath === watchedDirPath) + return false; + // If the the added or created file or directory is not supported file name, ignore the file + // But when watched directory is added/removed, we need to reload the file list + if (ts.hasExtension(fileOrDirectoryPath) && !ts.isSupportedSourceFileName(fileOrDirectory, options, extraFileExtensions)) { + writeLog("Project: ".concat(configFileName, " Detected file add/remove of non supported extension: ").concat(fileOrDirectory)); + return true; + } + if (ts.isExcludedFile(fileOrDirectory, options.configFile.configFileSpecs, ts.getNormalizedAbsolutePath(ts.getDirectoryPath(configFileName), currentDirectory), useCaseSensitiveFileNames, currentDirectory)) { + writeLog("Project: ".concat(configFileName, " Detected excluded file: ").concat(fileOrDirectory)); + return true; + } + if (!program) + return false; + // We want to ignore emit file check if file is not going to be emitted next to source file + // In that case we follow config file inclusion rules + if (ts.outFile(options) || options.outDir) + return false; + // File if emitted next to input needs to be ignored + if (ts.isDeclarationFileName(fileOrDirectoryPath)) { + // If its declaration directory: its not ignored if not excluded by config + if (options.declarationDir) + return false; + } + else if (!ts.fileExtensionIsOneOf(fileOrDirectoryPath, ts.supportedJSExtensionsFlat)) { + return false; + } + // just check if sourceFile with the name exists + var filePathWithoutExtension = ts.removeFileExtension(fileOrDirectoryPath); + var realProgram = ts.isArray(program) ? undefined : isBuilderProgram(program) ? program.getProgramOrUndefined() : program; + var builderProgram = !realProgram && !ts.isArray(program) ? program : undefined; + if (hasSourceFile((filePathWithoutExtension + ".ts" /* Extension.Ts */)) || + hasSourceFile((filePathWithoutExtension + ".tsx" /* Extension.Tsx */))) { + writeLog("Project: ".concat(configFileName, " Detected output file: ").concat(fileOrDirectory)); + return true; + } + return false; + function hasSourceFile(file) { + return realProgram ? + !!realProgram.getSourceFileByPath(file) : + builderProgram ? + builderProgram.getState().fileInfos.has(file) : + !!ts.find(program, function (rootFile) { return toPath(rootFile) === file; }); + } + } + ts.isIgnoredFileFromWildCardWatching = isIgnoredFileFromWildCardWatching; + function isBuilderProgram(program) { + return !!program.getState; + } + function isEmittedFileOfProgram(program, file) { + if (!program) { + return false; + } + return program.isEmittedFile(file); + } + ts.isEmittedFileOfProgram = isEmittedFileOfProgram; + var WatchLogLevel; + (function (WatchLogLevel) { + WatchLogLevel[WatchLogLevel["None"] = 0] = "None"; + WatchLogLevel[WatchLogLevel["TriggerOnly"] = 1] = "TriggerOnly"; + WatchLogLevel[WatchLogLevel["Verbose"] = 2] = "Verbose"; + })(WatchLogLevel = ts.WatchLogLevel || (ts.WatchLogLevel = {})); + function getWatchFactory(host, watchLogLevel, log, getDetailWatchInfo) { + ts.setSysLog(watchLogLevel === WatchLogLevel.Verbose ? log : ts.noop); + var plainInvokeFactory = { + watchFile: function (file, callback, pollingInterval, options) { return host.watchFile(file, callback, pollingInterval, options); }, + watchDirectory: function (directory, callback, flags, options) { return host.watchDirectory(directory, callback, (flags & 1 /* WatchDirectoryFlags.Recursive */) !== 0, options); }, + }; + var triggerInvokingFactory = watchLogLevel !== WatchLogLevel.None ? + { + watchFile: createTriggerLoggingAddWatch("watchFile"), + watchDirectory: createTriggerLoggingAddWatch("watchDirectory") + } : + undefined; + var factory = watchLogLevel === WatchLogLevel.Verbose ? + { + watchFile: createFileWatcherWithLogging, + watchDirectory: createDirectoryWatcherWithLogging + } : + triggerInvokingFactory || plainInvokeFactory; + var excludeWatcherFactory = watchLogLevel === WatchLogLevel.Verbose ? + createExcludeWatcherWithLogging : + ts.returnNoopFileWatcher; + return { + watchFile: createExcludeHandlingAddWatch("watchFile"), + watchDirectory: createExcludeHandlingAddWatch("watchDirectory") + }; + function createExcludeHandlingAddWatch(key) { + return function (file, cb, flags, options, detailInfo1, detailInfo2) { + var _a; + return !ts.matchesExclude(file, key === "watchFile" ? options === null || options === void 0 ? void 0 : options.excludeFiles : options === null || options === void 0 ? void 0 : options.excludeDirectories, useCaseSensitiveFileNames(), ((_a = host.getCurrentDirectory) === null || _a === void 0 ? void 0 : _a.call(host)) || "") ? + factory[key].call(/*thisArgs*/ undefined, file, cb, flags, options, detailInfo1, detailInfo2) : + excludeWatcherFactory(file, flags, options, detailInfo1, detailInfo2); + }; + } + function useCaseSensitiveFileNames() { + return typeof host.useCaseSensitiveFileNames === "boolean" ? + host.useCaseSensitiveFileNames : + host.useCaseSensitiveFileNames(); + } + function createExcludeWatcherWithLogging(file, flags, options, detailInfo1, detailInfo2) { + log("ExcludeWatcher:: Added:: ".concat(getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo))); + return { + close: function () { return log("ExcludeWatcher:: Close:: ".concat(getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo))); } + }; + } + function createFileWatcherWithLogging(file, cb, flags, options, detailInfo1, detailInfo2) { + log("FileWatcher:: Added:: ".concat(getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo))); + var watcher = triggerInvokingFactory.watchFile(file, cb, flags, options, detailInfo1, detailInfo2); + return { + close: function () { + log("FileWatcher:: Close:: ".concat(getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo))); + watcher.close(); + } + }; + } + function createDirectoryWatcherWithLogging(file, cb, flags, options, detailInfo1, detailInfo2) { + var watchInfo = "DirectoryWatcher:: Added:: ".concat(getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)); + log(watchInfo); + var start = ts.timestamp(); + var watcher = triggerInvokingFactory.watchDirectory(file, cb, flags, options, detailInfo1, detailInfo2); + var elapsed = ts.timestamp() - start; + log("Elapsed:: ".concat(elapsed, "ms ").concat(watchInfo)); + return { + close: function () { + var watchInfo = "DirectoryWatcher:: Close:: ".concat(getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)); + log(watchInfo); + var start = ts.timestamp(); + watcher.close(); + var elapsed = ts.timestamp() - start; + log("Elapsed:: ".concat(elapsed, "ms ").concat(watchInfo)); + } + }; + } + function createTriggerLoggingAddWatch(key) { + return function (file, cb, flags, options, detailInfo1, detailInfo2) { return plainInvokeFactory[key].call(/*thisArgs*/ undefined, file, function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + var triggerredInfo = "".concat(key === "watchFile" ? "FileWatcher" : "DirectoryWatcher", ":: Triggered with ").concat(args[0], " ").concat(args[1] !== undefined ? args[1] : "", ":: ").concat(getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo)); + log(triggerredInfo); + var start = ts.timestamp(); + cb.call.apply(cb, __spreadArray([/*thisArg*/ undefined], args, false)); + var elapsed = ts.timestamp() - start; + log("Elapsed:: ".concat(elapsed, "ms ").concat(triggerredInfo)); + }, flags, options, detailInfo1, detailInfo2); }; + } + function getWatchInfo(file, flags, options, detailInfo1, detailInfo2, getDetailWatchInfo) { + return "WatchInfo: ".concat(file, " ").concat(flags, " ").concat(JSON.stringify(options), " ").concat(getDetailWatchInfo ? getDetailWatchInfo(detailInfo1, detailInfo2) : detailInfo2 === undefined ? detailInfo1 : "".concat(detailInfo1, " ").concat(detailInfo2)); + } + } + ts.getWatchFactory = getWatchFactory; + function getFallbackOptions(options) { + var fallbackPolling = options === null || options === void 0 ? void 0 : options.fallbackPolling; + return { + watchFile: fallbackPolling !== undefined ? + fallbackPolling : + ts.WatchFileKind.PriorityPollingInterval + }; + } + ts.getFallbackOptions = getFallbackOptions; + function closeFileWatcherOf(objWithWatcher) { + objWithWatcher.watcher.close(); + } + ts.closeFileWatcherOf = closeFileWatcherOf; +})(ts || (ts = {})); +var ts; +(function (ts) { + function findConfigFile(searchPath, fileExists, configName) { + if (configName === void 0) { configName = "tsconfig.json"; } + return ts.forEachAncestorDirectory(searchPath, function (ancestor) { + var fileName = ts.combinePaths(ancestor, configName); + return fileExists(fileName) ? fileName : undefined; + }); + } + ts.findConfigFile = findConfigFile; + function resolveTripleslashReference(moduleName, containingFile) { + var basePath = ts.getDirectoryPath(containingFile); + var referencedFileName = ts.isRootedDiskPath(moduleName) ? moduleName : ts.combinePaths(basePath, moduleName); + return ts.normalizePath(referencedFileName); + } + ts.resolveTripleslashReference = resolveTripleslashReference; + /* @internal */ + function computeCommonSourceDirectoryOfFilenames(fileNames, currentDirectory, getCanonicalFileName) { + var commonPathComponents; + var failed = ts.forEach(fileNames, function (sourceFile) { + // Each file contributes into common source file path + var sourcePathComponents = ts.getNormalizedPathComponents(sourceFile, currentDirectory); + sourcePathComponents.pop(); // The base file name is not part of the common directory path + if (!commonPathComponents) { + // first file + commonPathComponents = sourcePathComponents; + return; + } + var n = Math.min(commonPathComponents.length, sourcePathComponents.length); + for (var i = 0; i < n; i++) { + if (getCanonicalFileName(commonPathComponents[i]) !== getCanonicalFileName(sourcePathComponents[i])) { + if (i === 0) { + // Failed to find any common path component + return true; + } + // New common path found that is 0 -> i-1 + commonPathComponents.length = i; + break; + } + } + // If the sourcePathComponents was shorter than the commonPathComponents, truncate to the sourcePathComponents + if (sourcePathComponents.length < commonPathComponents.length) { + commonPathComponents.length = sourcePathComponents.length; + } + }); + // A common path can not be found when paths span multiple drives on windows, for example + if (failed) { + return ""; + } + if (!commonPathComponents) { // Can happen when all input files are .d.ts files + return currentDirectory; + } + return ts.getPathFromPathComponents(commonPathComponents); + } + ts.computeCommonSourceDirectoryOfFilenames = computeCommonSourceDirectoryOfFilenames; + function createCompilerHost(options, setParentNodes) { + return createCompilerHostWorker(options, setParentNodes); + } + ts.createCompilerHost = createCompilerHost; + /*@internal*/ + function createCompilerHostWorker(options, setParentNodes, system) { + if (system === void 0) { system = ts.sys; } + var existingDirectories = new ts.Map(); + var getCanonicalFileName = ts.createGetCanonicalFileName(system.useCaseSensitiveFileNames); + function getSourceFile(fileName, languageVersionOrOptions, onError) { + var text; + try { + ts.performance.mark("beforeIORead"); + text = compilerHost.readFile(fileName); + ts.performance.mark("afterIORead"); + ts.performance.measure("I/O Read", "beforeIORead", "afterIORead"); + } + catch (e) { + if (onError) { + onError(e.message); + } + text = ""; + } + return text !== undefined ? ts.createSourceFile(fileName, text, languageVersionOrOptions, setParentNodes) : undefined; + } + function directoryExists(directoryPath) { + if (existingDirectories.has(directoryPath)) { + return true; + } + if ((compilerHost.directoryExists || system.directoryExists)(directoryPath)) { + existingDirectories.set(directoryPath, true); + return true; + } + return false; + } + function writeFile(fileName, data, writeByteOrderMark, onError) { + try { + ts.performance.mark("beforeIOWrite"); + // NOTE: If patchWriteFileEnsuringDirectory has been called, + // the system.writeFile will do its own directory creation and + // the ensureDirectoriesExist call will always be redundant. + ts.writeFileEnsuringDirectories(fileName, data, writeByteOrderMark, function (path, data, writeByteOrderMark) { return system.writeFile(path, data, writeByteOrderMark); }, function (path) { return (compilerHost.createDirectory || system.createDirectory)(path); }, function (path) { return directoryExists(path); }); + ts.performance.mark("afterIOWrite"); + ts.performance.measure("I/O Write", "beforeIOWrite", "afterIOWrite"); + } + catch (e) { + if (onError) { + onError(e.message); + } + } + } + function getDefaultLibLocation() { + return ts.getDirectoryPath(ts.normalizePath(system.getExecutingFilePath())); + } + var newLine = ts.getNewLineCharacter(options, function () { return system.newLine; }); + var realpath = system.realpath && (function (path) { return system.realpath(path); }); + var compilerHost = { + getSourceFile: getSourceFile, + getDefaultLibLocation: getDefaultLibLocation, + getDefaultLibFileName: function (options) { return ts.combinePaths(getDefaultLibLocation(), ts.getDefaultLibFileName(options)); }, + writeFile: writeFile, + getCurrentDirectory: ts.memoize(function () { return system.getCurrentDirectory(); }), + useCaseSensitiveFileNames: function () { return system.useCaseSensitiveFileNames; }, + getCanonicalFileName: getCanonicalFileName, + getNewLine: function () { return newLine; }, + fileExists: function (fileName) { return system.fileExists(fileName); }, + readFile: function (fileName) { return system.readFile(fileName); }, + trace: function (s) { return system.write(s + newLine); }, + directoryExists: function (directoryName) { return system.directoryExists(directoryName); }, + getEnvironmentVariable: function (name) { return system.getEnvironmentVariable ? system.getEnvironmentVariable(name) : ""; }, + getDirectories: function (path) { return system.getDirectories(path); }, + realpath: realpath, + readDirectory: function (path, extensions, include, exclude, depth) { return system.readDirectory(path, extensions, include, exclude, depth); }, + createDirectory: function (d) { return system.createDirectory(d); }, + createHash: ts.maybeBind(system, system.createHash) + }; + return compilerHost; + } + ts.createCompilerHostWorker = createCompilerHostWorker; + /*@internal*/ + function changeCompilerHostLikeToUseCache(host, toPath, getSourceFile) { + var originalReadFile = host.readFile; + var originalFileExists = host.fileExists; + var originalDirectoryExists = host.directoryExists; + var originalCreateDirectory = host.createDirectory; + var originalWriteFile = host.writeFile; + var readFileCache = new ts.Map(); + var fileExistsCache = new ts.Map(); + var directoryExistsCache = new ts.Map(); + var sourceFileCache = new ts.Map(); + var readFileWithCache = function (fileName) { + var key = toPath(fileName); + var value = readFileCache.get(key); + if (value !== undefined) + return value !== false ? value : undefined; + return setReadFileCache(key, fileName); + }; + var setReadFileCache = function (key, fileName) { + var newValue = originalReadFile.call(host, fileName); + readFileCache.set(key, newValue !== undefined ? newValue : false); + return newValue; + }; + host.readFile = function (fileName) { + var key = toPath(fileName); + var value = readFileCache.get(key); + if (value !== undefined) + return value !== false ? value : undefined; // could be .d.ts from output + // Cache json or buildInfo + if (!ts.fileExtensionIs(fileName, ".json" /* Extension.Json */) && !ts.isBuildInfoFile(fileName)) { + return originalReadFile.call(host, fileName); + } + return setReadFileCache(key, fileName); + }; + var getSourceFileWithCache = getSourceFile ? function (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) { + var key = toPath(fileName); + var impliedNodeFormat = typeof languageVersionOrOptions === "object" ? languageVersionOrOptions.impliedNodeFormat : undefined; + var forImpliedNodeFormat = sourceFileCache.get(impliedNodeFormat); + var value = forImpliedNodeFormat === null || forImpliedNodeFormat === void 0 ? void 0 : forImpliedNodeFormat.get(key); + if (value) + return value; + var sourceFile = getSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile); + if (sourceFile && (ts.isDeclarationFileName(fileName) || ts.fileExtensionIs(fileName, ".json" /* Extension.Json */))) { + sourceFileCache.set(impliedNodeFormat, (forImpliedNodeFormat || new ts.Map()).set(key, sourceFile)); + } + return sourceFile; + } : undefined; + // fileExists for any kind of extension + host.fileExists = function (fileName) { + var key = toPath(fileName); + var value = fileExistsCache.get(key); + if (value !== undefined) + return value; + var newValue = originalFileExists.call(host, fileName); + fileExistsCache.set(key, !!newValue); + return newValue; + }; + if (originalWriteFile) { + host.writeFile = function (fileName, data) { + var rest = []; + for (var _i = 2; _i < arguments.length; _i++) { + rest[_i - 2] = arguments[_i]; + } + var key = toPath(fileName); + fileExistsCache.delete(key); + var value = readFileCache.get(key); + if (value !== undefined && value !== data) { + readFileCache.delete(key); + sourceFileCache.forEach(function (map) { return map.delete(key); }); + } + else if (getSourceFileWithCache) { + sourceFileCache.forEach(function (map) { + var sourceFile = map.get(key); + if (sourceFile && sourceFile.text !== data) { + map.delete(key); + } + }); + } + originalWriteFile.call.apply(originalWriteFile, __spreadArray([host, fileName, data], rest, false)); + }; + } + // directoryExists + if (originalDirectoryExists) { + host.directoryExists = function (directory) { + var key = toPath(directory); + var value = directoryExistsCache.get(key); + if (value !== undefined) + return value; + var newValue = originalDirectoryExists.call(host, directory); + directoryExistsCache.set(key, !!newValue); + return newValue; + }; + if (originalCreateDirectory) { + host.createDirectory = function (directory) { + var key = toPath(directory); + directoryExistsCache.delete(key); + originalCreateDirectory.call(host, directory); + }; + } + } + return { + originalReadFile: originalReadFile, + originalFileExists: originalFileExists, + originalDirectoryExists: originalDirectoryExists, + originalCreateDirectory: originalCreateDirectory, + originalWriteFile: originalWriteFile, + getSourceFileWithCache: getSourceFileWithCache, + readFileWithCache: readFileWithCache + }; + } + ts.changeCompilerHostLikeToUseCache = changeCompilerHostLikeToUseCache; + function getPreEmitDiagnostics(program, sourceFile, cancellationToken) { + var diagnostics; + diagnostics = ts.addRange(diagnostics, program.getConfigFileParsingDiagnostics()); + diagnostics = ts.addRange(diagnostics, program.getOptionsDiagnostics(cancellationToken)); + diagnostics = ts.addRange(diagnostics, program.getSyntacticDiagnostics(sourceFile, cancellationToken)); + diagnostics = ts.addRange(diagnostics, program.getGlobalDiagnostics(cancellationToken)); + diagnostics = ts.addRange(diagnostics, program.getSemanticDiagnostics(sourceFile, cancellationToken)); + if (ts.getEmitDeclarations(program.getCompilerOptions())) { + diagnostics = ts.addRange(diagnostics, program.getDeclarationDiagnostics(sourceFile, cancellationToken)); + } + return ts.sortAndDeduplicateDiagnostics(diagnostics || ts.emptyArray); + } + ts.getPreEmitDiagnostics = getPreEmitDiagnostics; + function formatDiagnostics(diagnostics, host) { + var output = ""; + for (var _i = 0, diagnostics_3 = diagnostics; _i < diagnostics_3.length; _i++) { + var diagnostic = diagnostics_3[_i]; + output += formatDiagnostic(diagnostic, host); + } + return output; + } + ts.formatDiagnostics = formatDiagnostics; + function formatDiagnostic(diagnostic, host) { + var errorMessage = "".concat(ts.diagnosticCategoryName(diagnostic), " TS").concat(diagnostic.code, ": ").concat(flattenDiagnosticMessageText(diagnostic.messageText, host.getNewLine())).concat(host.getNewLine()); + if (diagnostic.file) { + var _a = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start), line = _a.line, character = _a.character; // TODO: GH#18217 + var fileName = diagnostic.file.fileName; + var relativeFileName = ts.convertToRelativePath(fileName, host.getCurrentDirectory(), function (fileName) { return host.getCanonicalFileName(fileName); }); + return "".concat(relativeFileName, "(").concat(line + 1, ",").concat(character + 1, "): ") + errorMessage; + } + return errorMessage; + } + ts.formatDiagnostic = formatDiagnostic; + /** @internal */ + var ForegroundColorEscapeSequences; + (function (ForegroundColorEscapeSequences) { + ForegroundColorEscapeSequences["Grey"] = "\u001B[90m"; + ForegroundColorEscapeSequences["Red"] = "\u001B[91m"; + ForegroundColorEscapeSequences["Yellow"] = "\u001B[93m"; + ForegroundColorEscapeSequences["Blue"] = "\u001B[94m"; + ForegroundColorEscapeSequences["Cyan"] = "\u001B[96m"; + })(ForegroundColorEscapeSequences = ts.ForegroundColorEscapeSequences || (ts.ForegroundColorEscapeSequences = {})); + var gutterStyleSequence = "\u001b[7m"; + var gutterSeparator = " "; + var resetEscapeSequence = "\u001b[0m"; + var ellipsis = "..."; + var halfIndent = " "; + var indent = " "; + function getCategoryFormat(category) { + switch (category) { + case ts.DiagnosticCategory.Error: return ForegroundColorEscapeSequences.Red; + case ts.DiagnosticCategory.Warning: return ForegroundColorEscapeSequences.Yellow; + case ts.DiagnosticCategory.Suggestion: return ts.Debug.fail("Should never get an Info diagnostic on the command line."); + case ts.DiagnosticCategory.Message: return ForegroundColorEscapeSequences.Blue; + } + } + /** @internal */ + function formatColorAndReset(text, formatStyle) { + return formatStyle + text + resetEscapeSequence; + } + ts.formatColorAndReset = formatColorAndReset; + function formatCodeSpan(file, start, length, indent, squiggleColor, host) { + var _a = ts.getLineAndCharacterOfPosition(file, start), firstLine = _a.line, firstLineChar = _a.character; + var _b = ts.getLineAndCharacterOfPosition(file, start + length), lastLine = _b.line, lastLineChar = _b.character; + var lastLineInFile = ts.getLineAndCharacterOfPosition(file, file.text.length).line; + var hasMoreThanFiveLines = (lastLine - firstLine) >= 4; + var gutterWidth = (lastLine + 1 + "").length; + if (hasMoreThanFiveLines) { + gutterWidth = Math.max(ellipsis.length, gutterWidth); + } + var context = ""; + for (var i = firstLine; i <= lastLine; i++) { + context += host.getNewLine(); + // If the error spans over 5 lines, we'll only show the first 2 and last 2 lines, + // so we'll skip ahead to the second-to-last line. + if (hasMoreThanFiveLines && firstLine + 1 < i && i < lastLine - 1) { + context += indent + formatColorAndReset(ts.padLeft(ellipsis, gutterWidth), gutterStyleSequence) + gutterSeparator + host.getNewLine(); + i = lastLine - 1; + } + var lineStart = ts.getPositionOfLineAndCharacter(file, i, 0); + var lineEnd = i < lastLineInFile ? ts.getPositionOfLineAndCharacter(file, i + 1, 0) : file.text.length; + var lineContent = file.text.slice(lineStart, lineEnd); + lineContent = ts.trimStringEnd(lineContent); // trim from end + lineContent = lineContent.replace(/\t/g, " "); // convert tabs to single spaces + // Output the gutter and the actual contents of the line. + context += indent + formatColorAndReset(ts.padLeft(i + 1 + "", gutterWidth), gutterStyleSequence) + gutterSeparator; + context += lineContent + host.getNewLine(); + // Output the gutter and the error span for the line using tildes. + context += indent + formatColorAndReset(ts.padLeft("", gutterWidth), gutterStyleSequence) + gutterSeparator; + context += squiggleColor; + if (i === firstLine) { + // If we're on the last line, then limit it to the last character of the last line. + // Otherwise, we'll just squiggle the rest of the line, giving 'slice' no end position. + var lastCharForLine = i === lastLine ? lastLineChar : undefined; + context += lineContent.slice(0, firstLineChar).replace(/\S/g, " "); + context += lineContent.slice(firstLineChar, lastCharForLine).replace(/./g, "~"); + } + else if (i === lastLine) { + context += lineContent.slice(0, lastLineChar).replace(/./g, "~"); + } + else { + // Squiggle the entire line. + context += lineContent.replace(/./g, "~"); + } + context += resetEscapeSequence; + } + return context; + } + /* @internal */ + function formatLocation(file, start, host, color) { + if (color === void 0) { color = formatColorAndReset; } + var _a = ts.getLineAndCharacterOfPosition(file, start), firstLine = _a.line, firstLineChar = _a.character; // TODO: GH#18217 + var relativeFileName = host ? ts.convertToRelativePath(file.fileName, host.getCurrentDirectory(), function (fileName) { return host.getCanonicalFileName(fileName); }) : file.fileName; + var output = ""; + output += color(relativeFileName, ForegroundColorEscapeSequences.Cyan); + output += ":"; + output += color("".concat(firstLine + 1), ForegroundColorEscapeSequences.Yellow); + output += ":"; + output += color("".concat(firstLineChar + 1), ForegroundColorEscapeSequences.Yellow); + return output; + } + ts.formatLocation = formatLocation; + function formatDiagnosticsWithColorAndContext(diagnostics, host) { + var output = ""; + for (var _i = 0, diagnostics_4 = diagnostics; _i < diagnostics_4.length; _i++) { + var diagnostic = diagnostics_4[_i]; + if (diagnostic.file) { + var file = diagnostic.file, start = diagnostic.start; + output += formatLocation(file, start, host); // TODO: GH#18217 + output += " - "; + } + output += formatColorAndReset(ts.diagnosticCategoryName(diagnostic), getCategoryFormat(diagnostic.category)); + output += formatColorAndReset(" TS".concat(diagnostic.code, ": "), ForegroundColorEscapeSequences.Grey); + output += flattenDiagnosticMessageText(diagnostic.messageText, host.getNewLine()); + if (diagnostic.file) { + output += host.getNewLine(); + output += formatCodeSpan(diagnostic.file, diagnostic.start, diagnostic.length, "", getCategoryFormat(diagnostic.category), host); // TODO: GH#18217 + } + if (diagnostic.relatedInformation) { + output += host.getNewLine(); + for (var _a = 0, _b = diagnostic.relatedInformation; _a < _b.length; _a++) { + var _c = _b[_a], file = _c.file, start = _c.start, length_9 = _c.length, messageText = _c.messageText; + if (file) { + output += host.getNewLine(); + output += halfIndent + formatLocation(file, start, host); // TODO: GH#18217 + output += formatCodeSpan(file, start, length_9, indent, ForegroundColorEscapeSequences.Cyan, host); // TODO: GH#18217 + } + output += host.getNewLine(); + output += indent + flattenDiagnosticMessageText(messageText, host.getNewLine()); + } + } + output += host.getNewLine(); + } + return output; + } + ts.formatDiagnosticsWithColorAndContext = formatDiagnosticsWithColorAndContext; + function flattenDiagnosticMessageText(diag, newLine, indent) { + if (indent === void 0) { indent = 0; } + if (ts.isString(diag)) { + return diag; + } + else if (diag === undefined) { + return ""; + } + var result = ""; + if (indent) { + result += newLine; + for (var i = 0; i < indent; i++) { + result += " "; + } + } + result += diag.messageText; + indent++; + if (diag.next) { + for (var _i = 0, _a = diag.next; _i < _a.length; _i++) { + var kid = _a[_i]; + result += flattenDiagnosticMessageText(kid, newLine, indent); + } + } + return result; + } + ts.flattenDiagnosticMessageText = flattenDiagnosticMessageText; + /* @internal */ + function loadWithTypeDirectiveCache(names, containingFile, redirectedReference, containingFileMode, loader) { + if (names.length === 0) { + return []; + } + var resolutions = []; + var cache = new ts.Map(); + for (var _i = 0, names_2 = names; _i < names_2.length; _i++) { + var name = names_2[_i]; + var result = void 0; + var mode = getModeForFileReference(name, containingFileMode); + // We lower-case all type references because npm automatically lowercases all packages. See GH#9824. + var strName = ts.isString(name) ? name : name.fileName.toLowerCase(); + var cacheKey = mode !== undefined ? "".concat(mode, "|").concat(strName) : strName; + if (cache.has(cacheKey)) { + result = cache.get(cacheKey); + } + else { + cache.set(cacheKey, result = loader(strName, containingFile, redirectedReference, mode)); + } + resolutions.push(result); + } + return resolutions; + } + ts.loadWithTypeDirectiveCache = loadWithTypeDirectiveCache; + /** + * Calculates the resulting resolution mode for some reference in some file - this is generally the explicitly + * provided resolution mode in the reference, unless one is not present, in which case it is the mode of the containing file. + */ + function getModeForFileReference(ref, containingFileMode) { + return (ts.isString(ref) ? containingFileMode : ref.resolutionMode) || containingFileMode; + } + ts.getModeForFileReference = getModeForFileReference; + function getModeForResolutionAtIndex(file, index) { + if (file.impliedNodeFormat === undefined) + return undefined; + // we ensure all elements of file.imports and file.moduleAugmentations have the relevant parent pointers set during program setup, + // so it's safe to use them even pre-bind + return getModeForUsageLocation(file, getModuleNameStringLiteralAt(file, index)); + } + ts.getModeForResolutionAtIndex = getModeForResolutionAtIndex; + /* @internal */ + function isExclusivelyTypeOnlyImportOrExport(decl) { + var _a; + if (ts.isExportDeclaration(decl)) { + return decl.isTypeOnly; + } + if ((_a = decl.importClause) === null || _a === void 0 ? void 0 : _a.isTypeOnly) { + return true; + } + return false; + } + ts.isExclusivelyTypeOnlyImportOrExport = isExclusivelyTypeOnlyImportOrExport; + /** + * Calculates the final resolution mode for a given module reference node. This is generally the explicitly provided resolution mode, if + * one exists, or the mode of the containing source file. (Excepting import=require, which is always commonjs, and dynamic import, which is always esm). + * Notably, this function always returns `undefined` if the containing file has an `undefined` `impliedNodeFormat` - this field is only set when + * `moduleResolution` is `node16`+. + * @param file The file the import or import-like reference is contained within + * @param usage The module reference string + * @returns The final resolution mode of the import + */ + function getModeForUsageLocation(file, usage) { + var _a, _b; + if (file.impliedNodeFormat === undefined) + return undefined; + if ((ts.isImportDeclaration(usage.parent) || ts.isExportDeclaration(usage.parent))) { + var isTypeOnly = isExclusivelyTypeOnlyImportOrExport(usage.parent); + if (isTypeOnly) { + var override = getResolutionModeOverrideForClause(usage.parent.assertClause); + if (override) { + return override; + } + } + } + if (usage.parent.parent && ts.isImportTypeNode(usage.parent.parent)) { + var override = getResolutionModeOverrideForClause((_a = usage.parent.parent.assertions) === null || _a === void 0 ? void 0 : _a.assertClause); + if (override) { + return override; + } + } + if (file.impliedNodeFormat !== ts.ModuleKind.ESNext) { + // in cjs files, import call expressions are esm format, otherwise everything is cjs + return ts.isImportCall(ts.walkUpParenthesizedExpressions(usage.parent)) ? ts.ModuleKind.ESNext : ts.ModuleKind.CommonJS; + } + // in esm files, import=require statements are cjs format, otherwise everything is esm + // imports are only parent'd up to their containing declaration/expression, so access farther parents with care + var exprParentParent = (_b = ts.walkUpParenthesizedExpressions(usage.parent)) === null || _b === void 0 ? void 0 : _b.parent; + return exprParentParent && ts.isImportEqualsDeclaration(exprParentParent) ? ts.ModuleKind.CommonJS : ts.ModuleKind.ESNext; + } + ts.getModeForUsageLocation = getModeForUsageLocation; + /* @internal */ + function getResolutionModeOverrideForClause(clause, grammarErrorOnNode) { + if (!clause) + return undefined; + if (ts.length(clause.elements) !== 1) { + grammarErrorOnNode === null || grammarErrorOnNode === void 0 ? void 0 : grammarErrorOnNode(clause, ts.Diagnostics.Type_import_assertions_should_have_exactly_one_key_resolution_mode_with_value_import_or_require); + return undefined; + } + var elem = clause.elements[0]; + if (!ts.isStringLiteralLike(elem.name)) + return undefined; + if (elem.name.text !== "resolution-mode") { + grammarErrorOnNode === null || grammarErrorOnNode === void 0 ? void 0 : grammarErrorOnNode(elem.name, ts.Diagnostics.resolution_mode_is_the_only_valid_key_for_type_import_assertions); + return undefined; + } + if (!ts.isStringLiteralLike(elem.value)) + return undefined; + if (elem.value.text !== "import" && elem.value.text !== "require") { + grammarErrorOnNode === null || grammarErrorOnNode === void 0 ? void 0 : grammarErrorOnNode(elem.value, ts.Diagnostics.resolution_mode_should_be_either_require_or_import); + return undefined; + } + return elem.value.text === "import" ? ts.ModuleKind.ESNext : ts.ModuleKind.CommonJS; + } + ts.getResolutionModeOverrideForClause = getResolutionModeOverrideForClause; + /* @internal */ + function loadWithModeAwareCache(names, containingFile, containingFileName, redirectedReference, loader) { + if (names.length === 0) { + return []; + } + var resolutions = []; + var cache = new ts.Map(); + var i = 0; + for (var _i = 0, names_3 = names; _i < names_3.length; _i++) { + var name = names_3[_i]; + var result = void 0; + var mode = getModeForResolutionAtIndex(containingFile, i); + i++; + var cacheKey = mode !== undefined ? "".concat(mode, "|").concat(name) : name; + if (cache.has(cacheKey)) { + result = cache.get(cacheKey); + } + else { + cache.set(cacheKey, result = loader(name, mode, containingFileName, redirectedReference)); + } + resolutions.push(result); + } + return resolutions; + } + ts.loadWithModeAwareCache = loadWithModeAwareCache; + /* @internal */ + function forEachResolvedProjectReference(resolvedProjectReferences, cb) { + return forEachProjectReference(/*projectReferences*/ undefined, resolvedProjectReferences, function (resolvedRef, parent) { return resolvedRef && cb(resolvedRef, parent); }); + } + ts.forEachResolvedProjectReference = forEachResolvedProjectReference; + function forEachProjectReference(projectReferences, resolvedProjectReferences, cbResolvedRef, cbRef) { + var seenResolvedRefs; + return worker(projectReferences, resolvedProjectReferences, /*parent*/ undefined); + function worker(projectReferences, resolvedProjectReferences, parent) { + // Visit project references first + if (cbRef) { + var result = cbRef(projectReferences, parent); + if (result) + return result; + } + return ts.forEach(resolvedProjectReferences, function (resolvedRef, index) { + if (resolvedRef && (seenResolvedRefs === null || seenResolvedRefs === void 0 ? void 0 : seenResolvedRefs.has(resolvedRef.sourceFile.path))) { + // ignore recursives + return undefined; + } + var result = cbResolvedRef(resolvedRef, parent, index); + if (result || !resolvedRef) + return result; + (seenResolvedRefs || (seenResolvedRefs = new ts.Set())).add(resolvedRef.sourceFile.path); + return worker(resolvedRef.commandLine.projectReferences, resolvedRef.references, resolvedRef); + }); + } + } + /* @internal */ + ts.inferredTypesContainingFile = "__inferred type names__.ts"; + /*@internal*/ + function isReferencedFile(reason) { + switch (reason === null || reason === void 0 ? void 0 : reason.kind) { + case ts.FileIncludeKind.Import: + case ts.FileIncludeKind.ReferenceFile: + case ts.FileIncludeKind.TypeReferenceDirective: + case ts.FileIncludeKind.LibReferenceDirective: + return true; + default: + return false; + } + } + ts.isReferencedFile = isReferencedFile; + /*@internal*/ + function isReferenceFileLocation(location) { + return location.pos !== undefined; + } + ts.isReferenceFileLocation = isReferenceFileLocation; + /*@internal*/ + function getReferencedFileLocation(getSourceFileByPath, ref) { + var _a, _b, _c; + var _d, _e, _f, _g; + var file = ts.Debug.checkDefined(getSourceFileByPath(ref.file)); + var kind = ref.kind, index = ref.index; + var pos, end, packageId, resolutionMode; + switch (kind) { + case ts.FileIncludeKind.Import: + var importLiteral = getModuleNameStringLiteralAt(file, index); + packageId = (_e = (_d = file.resolvedModules) === null || _d === void 0 ? void 0 : _d.get(importLiteral.text, getModeForResolutionAtIndex(file, index))) === null || _e === void 0 ? void 0 : _e.packageId; + if (importLiteral.pos === -1) + return { file: file, packageId: packageId, text: importLiteral.text }; + pos = ts.skipTrivia(file.text, importLiteral.pos); + end = importLiteral.end; + break; + case ts.FileIncludeKind.ReferenceFile: + (_a = file.referencedFiles[index], pos = _a.pos, end = _a.end); + break; + case ts.FileIncludeKind.TypeReferenceDirective: + (_b = file.typeReferenceDirectives[index], pos = _b.pos, end = _b.end, resolutionMode = _b.resolutionMode); + packageId = (_g = (_f = file.resolvedTypeReferenceDirectiveNames) === null || _f === void 0 ? void 0 : _f.get(ts.toFileNameLowerCase(file.typeReferenceDirectives[index].fileName), resolutionMode || file.impliedNodeFormat)) === null || _g === void 0 ? void 0 : _g.packageId; + break; + case ts.FileIncludeKind.LibReferenceDirective: + (_c = file.libReferenceDirectives[index], pos = _c.pos, end = _c.end); + break; + default: + return ts.Debug.assertNever(kind); + } + return { file: file, pos: pos, end: end, packageId: packageId }; + } + ts.getReferencedFileLocation = getReferencedFileLocation; + /** + * Determines if program structure is upto date or needs to be recreated + */ + /* @internal */ + function isProgramUptoDate(program, rootFileNames, newOptions, getSourceVersion, fileExists, hasInvalidatedResolutions, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences) { + // If we haven't created a program yet or have changed automatic type directives, then it is not up-to-date + if (!program || (hasChangedAutomaticTypeDirectiveNames === null || hasChangedAutomaticTypeDirectiveNames === void 0 ? void 0 : hasChangedAutomaticTypeDirectiveNames())) + return false; + // If root file names don't match + if (!ts.arrayIsEqualTo(program.getRootFileNames(), rootFileNames)) + return false; + var seenResolvedRefs; + // If project references don't match + if (!ts.arrayIsEqualTo(program.getProjectReferences(), projectReferences, projectReferenceUptoDate)) + return false; + // If any file is not up-to-date, then the whole program is not up-to-date + if (program.getSourceFiles().some(sourceFileNotUptoDate)) + return false; + // If any of the missing file paths are now created + if (program.getMissingFilePaths().some(fileExists)) + return false; + var currentOptions = program.getCompilerOptions(); + // If the compilation settings do no match, then the program is not up-to-date + if (!ts.compareDataObjects(currentOptions, newOptions)) + return false; + // If everything matches but the text of config file is changed, + // error locations can change for program options, so update the program + if (currentOptions.configFile && newOptions.configFile) + return currentOptions.configFile.text === newOptions.configFile.text; + return true; + function sourceFileNotUptoDate(sourceFile) { + return !sourceFileVersionUptoDate(sourceFile) || + hasInvalidatedResolutions(sourceFile.path); + } + function sourceFileVersionUptoDate(sourceFile) { + return sourceFile.version === getSourceVersion(sourceFile.resolvedPath, sourceFile.fileName); + } + function projectReferenceUptoDate(oldRef, newRef, index) { + return ts.projectReferenceIsEqualTo(oldRef, newRef) && + resolvedProjectReferenceUptoDate(program.getResolvedProjectReferences()[index], oldRef); + } + function resolvedProjectReferenceUptoDate(oldResolvedRef, oldRef) { + if (oldResolvedRef) { + // Assume true + if (ts.contains(seenResolvedRefs, oldResolvedRef)) + return true; + var refPath_1 = resolveProjectReferencePath(oldRef); + var newParsedCommandLine = getParsedCommandLine(refPath_1); + // Check if config file exists + if (!newParsedCommandLine) + return false; + // If change in source file + if (oldResolvedRef.commandLine.options.configFile !== newParsedCommandLine.options.configFile) + return false; + // check file names + if (!ts.arrayIsEqualTo(oldResolvedRef.commandLine.fileNames, newParsedCommandLine.fileNames)) + return false; + // Add to seen before checking the referenced paths of this config file + (seenResolvedRefs || (seenResolvedRefs = [])).push(oldResolvedRef); + // If child project references are upto date, this project reference is uptodate + return !ts.forEach(oldResolvedRef.references, function (childResolvedRef, index) { + return !resolvedProjectReferenceUptoDate(childResolvedRef, oldResolvedRef.commandLine.projectReferences[index]); + }); + } + // In old program, not able to resolve project reference path, + // so if config file doesnt exist, it is uptodate. + var refPath = resolveProjectReferencePath(oldRef); + return !getParsedCommandLine(refPath); + } + } + ts.isProgramUptoDate = isProgramUptoDate; + function getConfigFileParsingDiagnostics(configFileParseResult) { + return configFileParseResult.options.configFile ? __spreadArray(__spreadArray([], configFileParseResult.options.configFile.parseDiagnostics, true), configFileParseResult.errors, true) : + configFileParseResult.errors; + } + ts.getConfigFileParsingDiagnostics = getConfigFileParsingDiagnostics; + /** + * A function for determining if a given file is esm or cjs format, assuming modern node module resolution rules, as configured by the + * `options` parameter. + * + * @param fileName The normalized absolute path to check the format of (it need not exist on disk) + * @param [packageJsonInfoCache] A cache for package file lookups - it's best to have a cache when this function is called often + * @param host The ModuleResolutionHost which can perform the filesystem lookups for package json data + * @param options The compiler options to perform the analysis under - relevant options are `moduleResolution` and `traceResolution` + * @returns `undefined` if the path has no relevant implied format, `ModuleKind.ESNext` for esm format, and `ModuleKind.CommonJS` for cjs format + */ + function getImpliedNodeFormatForFile(fileName, packageJsonInfoCache, host, options) { + var result = getImpliedNodeFormatForFileWorker(fileName, packageJsonInfoCache, host, options); + return typeof result === "object" ? result.impliedNodeFormat : result; + } + ts.getImpliedNodeFormatForFile = getImpliedNodeFormatForFile; + /*@internal*/ + function getImpliedNodeFormatForFileWorker(fileName, packageJsonInfoCache, host, options) { + switch (ts.getEmitModuleResolutionKind(options)) { + case ts.ModuleResolutionKind.Node16: + case ts.ModuleResolutionKind.NodeNext: + return ts.fileExtensionIsOneOf(fileName, [".d.mts" /* Extension.Dmts */, ".mts" /* Extension.Mts */, ".mjs" /* Extension.Mjs */]) ? ts.ModuleKind.ESNext : + ts.fileExtensionIsOneOf(fileName, [".d.cts" /* Extension.Dcts */, ".cts" /* Extension.Cts */, ".cjs" /* Extension.Cjs */]) ? ts.ModuleKind.CommonJS : + ts.fileExtensionIsOneOf(fileName, [".d.ts" /* Extension.Dts */, ".ts" /* Extension.Ts */, ".tsx" /* Extension.Tsx */, ".js" /* Extension.Js */, ".jsx" /* Extension.Jsx */]) ? lookupFromPackageJson() : + undefined; // other extensions, like `json` or `tsbuildinfo`, are set as `undefined` here but they should never be fed through the transformer pipeline + default: + return undefined; + } + function lookupFromPackageJson() { + var state = ts.getTemporaryModuleResolutionState(packageJsonInfoCache, host, options); + var packageJsonLocations = []; + state.failedLookupLocations = packageJsonLocations; + state.affectingLocations = packageJsonLocations; + var packageJsonScope = ts.getPackageScopeForPath(fileName, state); + var impliedNodeFormat = (packageJsonScope === null || packageJsonScope === void 0 ? void 0 : packageJsonScope.contents.packageJsonContent.type) === "module" ? ts.ModuleKind.ESNext : ts.ModuleKind.CommonJS; + return { impliedNodeFormat: impliedNodeFormat, packageJsonLocations: packageJsonLocations, packageJsonScope: packageJsonScope }; + } + } + ts.getImpliedNodeFormatForFileWorker = getImpliedNodeFormatForFileWorker; + /** @internal */ + ts.plainJSErrors = new ts.Set([ + // binder errors + ts.Diagnostics.Cannot_redeclare_block_scoped_variable_0.code, + ts.Diagnostics.A_module_cannot_have_multiple_default_exports.code, + ts.Diagnostics.Another_export_default_is_here.code, + ts.Diagnostics.The_first_export_default_is_here.code, + ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_at_the_top_level_of_a_module.code, + ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode.code, + ts.Diagnostics.Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here.code, + ts.Diagnostics.constructor_is_a_reserved_word.code, + ts.Diagnostics.delete_cannot_be_called_on_an_identifier_in_strict_mode.code, + ts.Diagnostics.Code_contained_in_a_class_is_evaluated_in_JavaScript_s_strict_mode_which_does_not_allow_this_use_of_0_For_more_information_see_https_Colon_Slash_Slashdeveloper_mozilla_org_Slashen_US_Slashdocs_SlashWeb_SlashJavaScript_SlashReference_SlashStrict_mode.code, + ts.Diagnostics.Invalid_use_of_0_Modules_are_automatically_in_strict_mode.code, + ts.Diagnostics.Invalid_use_of_0_in_strict_mode.code, + ts.Diagnostics.A_label_is_not_allowed_here.code, + ts.Diagnostics.Octal_literals_are_not_allowed_in_strict_mode.code, + ts.Diagnostics.with_statements_are_not_allowed_in_strict_mode.code, + // grammar errors + ts.Diagnostics.A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement.code, + ts.Diagnostics.A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement.code, + ts.Diagnostics.A_class_declaration_without_the_default_modifier_must_have_a_name.code, + ts.Diagnostics.A_class_member_cannot_have_the_0_keyword.code, + ts.Diagnostics.A_comma_expression_is_not_allowed_in_a_computed_property_name.code, + ts.Diagnostics.A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement.code, + ts.Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement.code, + ts.Diagnostics.A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement.code, + ts.Diagnostics.A_default_clause_cannot_appear_more_than_once_in_a_switch_statement.code, + ts.Diagnostics.A_default_export_must_be_at_the_top_level_of_a_file_or_module_declaration.code, + ts.Diagnostics.A_definite_assignment_assertion_is_not_permitted_in_this_context.code, + ts.Diagnostics.A_destructuring_declaration_must_have_an_initializer.code, + ts.Diagnostics.A_get_accessor_cannot_have_parameters.code, + ts.Diagnostics.A_rest_element_cannot_contain_a_binding_pattern.code, + ts.Diagnostics.A_rest_element_cannot_have_a_property_name.code, + ts.Diagnostics.A_rest_element_cannot_have_an_initializer.code, + ts.Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern.code, + ts.Diagnostics.A_rest_parameter_cannot_have_an_initializer.code, + ts.Diagnostics.A_rest_parameter_must_be_last_in_a_parameter_list.code, + ts.Diagnostics.A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma.code, + ts.Diagnostics.A_return_statement_cannot_be_used_inside_a_class_static_block.code, + ts.Diagnostics.A_set_accessor_cannot_have_rest_parameter.code, + ts.Diagnostics.A_set_accessor_must_have_exactly_one_parameter.code, + ts.Diagnostics.An_export_declaration_can_only_be_used_at_the_top_level_of_a_module.code, + ts.Diagnostics.An_export_declaration_cannot_have_modifiers.code, + ts.Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module.code, + ts.Diagnostics.An_import_declaration_cannot_have_modifiers.code, + ts.Diagnostics.An_object_member_cannot_be_declared_optional.code, + ts.Diagnostics.Argument_of_dynamic_import_cannot_be_spread_element.code, + ts.Diagnostics.Cannot_assign_to_private_method_0_Private_methods_are_not_writable.code, + ts.Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause.code, + ts.Diagnostics.Catch_clause_variable_cannot_have_an_initializer.code, + ts.Diagnostics.Class_decorators_can_t_be_used_with_static_private_identifier_Consider_removing_the_experimental_decorator.code, + ts.Diagnostics.Classes_can_only_extend_a_single_class.code, + ts.Diagnostics.Classes_may_not_have_a_field_named_constructor.code, + ts.Diagnostics.Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_part_of_a_destructuring_pattern.code, + ts.Diagnostics.Duplicate_label_0.code, + ts.Diagnostics.Dynamic_imports_can_only_accept_a_module_specifier_and_an_optional_assertion_as_arguments.code, + ts.Diagnostics.For_await_loops_cannot_be_used_inside_a_class_static_block.code, + ts.Diagnostics.JSX_attributes_must_only_be_assigned_a_non_empty_expression.code, + ts.Diagnostics.JSX_elements_cannot_have_multiple_attributes_with_the_same_name.code, + ts.Diagnostics.JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array.code, + ts.Diagnostics.JSX_property_access_expressions_cannot_include_JSX_namespace_names.code, + ts.Diagnostics.Jump_target_cannot_cross_function_boundary.code, + ts.Diagnostics.Line_terminator_not_permitted_before_arrow.code, + ts.Diagnostics.Modifiers_cannot_appear_here.code, + ts.Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement.code, + ts.Diagnostics.Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement.code, + ts.Diagnostics.Private_identifiers_are_not_allowed_outside_class_bodies.code, + ts.Diagnostics.Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member_declaration_property_access_or_on_the_left_hand_side_of_an_in_expression.code, + ts.Diagnostics.Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_identifier.code, + ts.Diagnostics.Tagged_template_expressions_are_not_permitted_in_an_optional_chain.code, + ts.Diagnostics.The_left_hand_side_of_a_for_of_statement_may_not_be_async.code, + ts.Diagnostics.The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer.code, + ts.Diagnostics.The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer.code, + ts.Diagnostics.Trailing_comma_not_allowed.code, + ts.Diagnostics.Variable_declaration_list_cannot_be_empty.code, + ts.Diagnostics._0_and_1_operations_cannot_be_mixed_without_parentheses.code, + ts.Diagnostics._0_expected.code, + ts.Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2.code, + ts.Diagnostics._0_list_cannot_be_empty.code, + ts.Diagnostics._0_modifier_already_seen.code, + ts.Diagnostics._0_modifier_cannot_appear_on_a_constructor_declaration.code, + ts.Diagnostics._0_modifier_cannot_appear_on_a_module_or_namespace_element.code, + ts.Diagnostics._0_modifier_cannot_appear_on_a_parameter.code, + ts.Diagnostics._0_modifier_cannot_appear_on_class_elements_of_this_kind.code, + ts.Diagnostics._0_modifier_cannot_be_used_here.code, + ts.Diagnostics._0_modifier_must_precede_1_modifier.code, + ts.Diagnostics.const_declarations_can_only_be_declared_inside_a_block.code, + ts.Diagnostics.const_declarations_must_be_initialized.code, + ts.Diagnostics.extends_clause_already_seen.code, + ts.Diagnostics.let_declarations_can_only_be_declared_inside_a_block.code, + ts.Diagnostics.let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations.code, + ts.Diagnostics.Class_constructor_may_not_be_a_generator.code, + ts.Diagnostics.Class_constructor_may_not_be_an_accessor.code, + ts.Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code, + ]); + /** + * Determine if source file needs to be re-created even if its text hasn't changed + */ + function shouldProgramCreateNewSourceFiles(program, newOptions) { + if (!program) + return false; + // If any compiler options change, we can't reuse old source file even if version match + // The change in options like these could result in change in syntax tree or `sourceFile.bindDiagnostics`. + return ts.optionsHaveChanges(program.getCompilerOptions(), newOptions, ts.sourceFileAffectingCompilerOptions); + } + function createCreateProgramOptions(rootNames, options, host, oldProgram, configFileParsingDiagnostics) { + return { + rootNames: rootNames, + options: options, + host: host, + oldProgram: oldProgram, + configFileParsingDiagnostics: configFileParsingDiagnostics + }; + } + function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) { + var _a, _b, _c, _d; + var createProgramOptions = ts.isArray(rootNamesOrOptions) ? createCreateProgramOptions(rootNamesOrOptions, _options, _host, _oldProgram, _configFileParsingDiagnostics) : rootNamesOrOptions; // TODO: GH#18217 + var rootNames = createProgramOptions.rootNames, options = createProgramOptions.options, configFileParsingDiagnostics = createProgramOptions.configFileParsingDiagnostics, projectReferences = createProgramOptions.projectReferences; + var oldProgram = createProgramOptions.oldProgram; + var processingDefaultLibFiles; + var processingOtherFiles; + var files; + var symlinks; + var commonSourceDirectory; + var typeChecker; + var classifiableNames; + var ambientModuleNameToUnmodifiedFileName = new ts.Map(); + var fileReasons = ts.createMultiMap(); + var cachedBindAndCheckDiagnosticsForFile = {}; + var cachedDeclarationDiagnosticsForFile = {}; + var resolvedTypeReferenceDirectives = ts.createModeAwareCache(); + var fileProcessingDiagnostics; + // The below settings are to track if a .js file should be add to the program if loaded via searching under node_modules. + // This works as imported modules are discovered recursively in a depth first manner, specifically: + // - For each root file, findSourceFile is called. + // - This calls processImportedModules for each module imported in the source file. + // - This calls resolveModuleNames, and then calls findSourceFile for each resolved module. + // As all these operations happen - and are nested - within the createProgram call, they close over the below variables. + // The current resolution depth is tracked by incrementing/decrementing as the depth first search progresses. + var maxNodeModuleJsDepth = typeof options.maxNodeModuleJsDepth === "number" ? options.maxNodeModuleJsDepth : 0; + var currentNodeModulesDepth = 0; + // If a module has some of its imports skipped due to being at the depth limit under node_modules, then track + // this, as it may be imported at a shallower depth later, and then it will need its skipped imports processed. + var modulesWithElidedImports = new ts.Map(); + // Track source files that are source files found by searching under node_modules, as these shouldn't be compiled. + var sourceFilesFoundSearchingNodeModules = new ts.Map(); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* tracing.Phase.Program */, "createProgram", { configFilePath: options.configFilePath, rootDir: options.rootDir }, /*separateBeginAndEnd*/ true); + ts.performance.mark("beforeProgram"); + var host = createProgramOptions.host || createCompilerHost(options); + var configParsingHost = parseConfigHostFromCompilerHostLike(host); + var skipDefaultLib = options.noLib; + var getDefaultLibraryFileName = ts.memoize(function () { return host.getDefaultLibFileName(options); }); + var defaultLibraryPath = host.getDefaultLibLocation ? host.getDefaultLibLocation() : ts.getDirectoryPath(getDefaultLibraryFileName()); + var programDiagnostics = ts.createDiagnosticCollection(); + var currentDirectory = host.getCurrentDirectory(); + var supportedExtensions = ts.getSupportedExtensions(options); + var supportedExtensionsWithJsonIfResolveJsonModule = ts.getSupportedExtensionsWithJsonIfResolveJsonModule(options, supportedExtensions); + // Map storing if there is emit blocking diagnostics for given input + var hasEmitBlockingDiagnostics = new ts.Map(); + var _compilerOptionsObjectLiteralSyntax; + var moduleResolutionCache; + var typeReferenceDirectiveResolutionCache; + var actualResolveModuleNamesWorker; + var hasInvalidatedResolutions = host.hasInvalidatedResolutions || ts.returnFalse; + if (host.resolveModuleNames) { + actualResolveModuleNamesWorker = function (moduleNames, containingFile, containingFileName, reusedNames, redirectedReference) { return host.resolveModuleNames(ts.Debug.checkEachDefined(moduleNames), containingFileName, reusedNames, redirectedReference, options, containingFile).map(function (resolved) { + // An older host may have omitted extension, in which case we should infer it from the file extension of resolvedFileName. + if (!resolved || resolved.extension !== undefined) { + return resolved; + } + var withExtension = ts.clone(resolved); + withExtension.extension = ts.extensionFromPath(resolved.resolvedFileName); + return withExtension; + }); }; + moduleResolutionCache = (_a = host.getModuleResolutionCache) === null || _a === void 0 ? void 0 : _a.call(host); + } + else { + moduleResolutionCache = ts.createModuleResolutionCache(currentDirectory, getCanonicalFileName, options); + var loader_1 = function (moduleName, resolverMode, containingFileName, redirectedReference) { return ts.resolveModuleName(moduleName, containingFileName, options, host, moduleResolutionCache, redirectedReference, resolverMode).resolvedModule; }; // TODO: GH#18217 + actualResolveModuleNamesWorker = function (moduleNames, containingFile, containingFileName, _reusedNames, redirectedReference) { return loadWithModeAwareCache(ts.Debug.checkEachDefined(moduleNames), containingFile, containingFileName, redirectedReference, loader_1); }; + } + var actualResolveTypeReferenceDirectiveNamesWorker; + if (host.resolveTypeReferenceDirectives) { + actualResolveTypeReferenceDirectiveNamesWorker = function (typeDirectiveNames, containingFile, redirectedReference, containingFileMode) { return host.resolveTypeReferenceDirectives(ts.Debug.checkEachDefined(typeDirectiveNames), containingFile, redirectedReference, options, containingFileMode); }; + } + else { + typeReferenceDirectiveResolutionCache = ts.createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, /*options*/ undefined, moduleResolutionCache === null || moduleResolutionCache === void 0 ? void 0 : moduleResolutionCache.getPackageJsonInfoCache()); + var loader_2 = function (typesRef, containingFile, redirectedReference, resolutionMode) { return ts.resolveTypeReferenceDirective(typesRef, containingFile, options, host, redirectedReference, typeReferenceDirectiveResolutionCache, resolutionMode).resolvedTypeReferenceDirective; }; // TODO: GH#18217 + actualResolveTypeReferenceDirectiveNamesWorker = function (typeReferenceDirectiveNames, containingFile, redirectedReference, containingFileMode) { return loadWithTypeDirectiveCache(ts.Debug.checkEachDefined(typeReferenceDirectiveNames), containingFile, redirectedReference, containingFileMode, loader_2); }; + } + // Map from a stringified PackageId to the source file with that id. + // Only one source file may have a given packageId. Others become redirects (see createRedirectSourceFile). + // `packageIdToSourceFile` is only used while building the program, while `sourceFileToPackageName` and `isSourceFileTargetOfRedirect` are kept around. + var packageIdToSourceFile = new ts.Map(); + // Maps from a SourceFile's `.path` to the name of the package it was imported with. + var sourceFileToPackageName = new ts.Map(); + // Key is a file name. Value is the (non-empty, or undefined) list of files that redirect to it. + var redirectTargetsMap = ts.createMultiMap(); + var usesUriStyleNodeCoreModules = false; + /** + * map with + * - SourceFile if present + * - false if sourceFile missing for source of project reference redirect + * - undefined otherwise + */ + var filesByName = new ts.Map(); + var missingFilePaths; + // stores 'filename -> file association' ignoring case + // used to track cases when two file names differ only in casing + var filesByNameIgnoreCase = host.useCaseSensitiveFileNames() ? new ts.Map() : undefined; + // A parallel array to projectReferences storing the results of reading in the referenced tsconfig files + var resolvedProjectReferences; + var projectReferenceRedirects; + var mapFromFileToProjectReferenceRedirects; + var mapFromToProjectReferenceRedirectSource; + var useSourceOfProjectReferenceRedirect = !!((_b = host.useSourceOfProjectReferenceRedirect) === null || _b === void 0 ? void 0 : _b.call(host)) && + !options.disableSourceOfProjectReferenceRedirect; + var _e = updateHostForUseSourceOfProjectReferenceRedirect({ + compilerHost: host, + getSymlinkCache: getSymlinkCache, + useSourceOfProjectReferenceRedirect: useSourceOfProjectReferenceRedirect, + toPath: toPath, + getResolvedProjectReferences: getResolvedProjectReferences, + getSourceOfProjectReferenceRedirect: getSourceOfProjectReferenceRedirect, + forEachResolvedProjectReference: forEachResolvedProjectReference + }), onProgramCreateComplete = _e.onProgramCreateComplete, fileExists = _e.fileExists, directoryExists = _e.directoryExists; + var readFile = host.readFile.bind(host); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* tracing.Phase.Program */, "shouldProgramCreateNewSourceFiles", { hasOldProgram: !!oldProgram }); + var shouldCreateNewSourceFile = shouldProgramCreateNewSourceFiles(oldProgram, options); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + // We set `structuralIsReused` to `undefined` because `tryReuseStructureFromOldProgram` calls `tryReuseStructureFromOldProgram` which checks + // `structuralIsReused`, which would be a TDZ violation if it was not set in advance to `undefined`. + var structureIsReused; + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* tracing.Phase.Program */, "tryReuseStructureFromOldProgram", {}); + structureIsReused = tryReuseStructureFromOldProgram(); // eslint-disable-line prefer-const + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + if (structureIsReused !== 2 /* StructureIsReused.Completely */) { + processingDefaultLibFiles = []; + processingOtherFiles = []; + if (projectReferences) { + if (!resolvedProjectReferences) { + resolvedProjectReferences = projectReferences.map(parseProjectReferenceConfigFile); + } + if (rootNames.length) { + resolvedProjectReferences === null || resolvedProjectReferences === void 0 ? void 0 : resolvedProjectReferences.forEach(function (parsedRef, index) { + if (!parsedRef) + return; + var out = ts.outFile(parsedRef.commandLine.options); + if (useSourceOfProjectReferenceRedirect) { + if (out || ts.getEmitModuleKind(parsedRef.commandLine.options) === ts.ModuleKind.None) { + for (var _i = 0, _a = parsedRef.commandLine.fileNames; _i < _a.length; _i++) { + var fileName = _a[_i]; + processProjectReferenceFile(fileName, { kind: ts.FileIncludeKind.SourceFromProjectReference, index: index }); + } + } + } + else { + if (out) { + processProjectReferenceFile(ts.changeExtension(out, ".d.ts"), { kind: ts.FileIncludeKind.OutputFromProjectReference, index: index }); + } + else if (ts.getEmitModuleKind(parsedRef.commandLine.options) === ts.ModuleKind.None) { + var getCommonSourceDirectory_2 = ts.memoize(function () { return ts.getCommonSourceDirectoryOfConfig(parsedRef.commandLine, !host.useCaseSensitiveFileNames()); }); + for (var _b = 0, _c = parsedRef.commandLine.fileNames; _b < _c.length; _b++) { + var fileName = _c[_b]; + if (!ts.isDeclarationFileName(fileName) && !ts.fileExtensionIs(fileName, ".json" /* Extension.Json */)) { + processProjectReferenceFile(ts.getOutputDeclarationFileName(fileName, parsedRef.commandLine, !host.useCaseSensitiveFileNames(), getCommonSourceDirectory_2), { kind: ts.FileIncludeKind.OutputFromProjectReference, index: index }); + } + } + } + } + }); + } + } + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* tracing.Phase.Program */, "processRootFiles", { count: rootNames.length }); + ts.forEach(rootNames, function (name, index) { return processRootFile(name, /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false, { kind: ts.FileIncludeKind.RootFile, index: index }); }); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + // load type declarations specified via 'types' argument or implicitly from types/ and node_modules/@types folders + var typeReferences = rootNames.length ? ts.getAutomaticTypeDirectiveNames(options, host) : ts.emptyArray; + if (typeReferences.length) { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* tracing.Phase.Program */, "processTypeReferences", { count: typeReferences.length }); + // This containingFilename needs to match with the one used in managed-side + var containingDirectory = options.configFilePath ? ts.getDirectoryPath(options.configFilePath) : host.getCurrentDirectory(); + var containingFilename = ts.combinePaths(containingDirectory, ts.inferredTypesContainingFile); + var resolutions = resolveTypeReferenceDirectiveNamesWorker(typeReferences, containingFilename); + for (var i = 0; i < typeReferences.length; i++) { + // under node16/nodenext module resolution, load `types`/ata include names as cjs resolution results by passing an `undefined` mode + processTypeReferenceDirective(typeReferences[i], /*mode*/ undefined, resolutions[i], { kind: ts.FileIncludeKind.AutomaticTypeDirectiveFile, typeReference: typeReferences[i], packageId: (_c = resolutions[i]) === null || _c === void 0 ? void 0 : _c.packageId }); + } + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + } + // Do not process the default library if: + // - The '--noLib' flag is used. + // - A 'no-default-lib' reference comment is encountered in + // processing the root files. + if (rootNames.length && !skipDefaultLib) { + // If '--lib' is not specified, include default library file according to '--target' + // otherwise, using options specified in '--lib' instead of '--target' default library file + var defaultLibraryFileName = getDefaultLibraryFileName(); + if (!options.lib && defaultLibraryFileName) { + processRootFile(defaultLibraryFileName, /*isDefaultLib*/ true, /*ignoreNoDefaultLib*/ false, { kind: ts.FileIncludeKind.LibFile }); + } + else { + ts.forEach(options.lib, function (libFileName, index) { + processRootFile(pathForLibFile(libFileName), /*isDefaultLib*/ true, /*ignoreNoDefaultLib*/ false, { kind: ts.FileIncludeKind.LibFile, index: index }); + }); + } + } + missingFilePaths = ts.arrayFrom(ts.mapDefinedIterator(filesByName.entries(), function (_a) { + var path = _a[0], file = _a[1]; + return file === undefined ? path : undefined; + })); + files = ts.stableSort(processingDefaultLibFiles, compareDefaultLibFiles).concat(processingOtherFiles); + processingDefaultLibFiles = undefined; + processingOtherFiles = undefined; + } + ts.Debug.assert(!!missingFilePaths); + // Release any files we have acquired in the old program but are + // not part of the new program. + if (oldProgram && host.onReleaseOldSourceFile) { + var oldSourceFiles = oldProgram.getSourceFiles(); + for (var _i = 0, oldSourceFiles_1 = oldSourceFiles; _i < oldSourceFiles_1.length; _i++) { + var oldSourceFile = oldSourceFiles_1[_i]; + var newFile = getSourceFileByPath(oldSourceFile.resolvedPath); + if (shouldCreateNewSourceFile || !newFile || newFile.impliedNodeFormat !== oldSourceFile.impliedNodeFormat || + // old file wasn't redirect but new file is + (oldSourceFile.resolvedPath === oldSourceFile.path && newFile.resolvedPath !== oldSourceFile.path)) { + host.onReleaseOldSourceFile(oldSourceFile, oldProgram.getCompilerOptions(), !!getSourceFileByPath(oldSourceFile.path)); + } + } + if (!host.getParsedCommandLine) { + oldProgram.forEachResolvedProjectReference(function (resolvedProjectReference) { + if (!getResolvedProjectReferenceByPath(resolvedProjectReference.sourceFile.path)) { + host.onReleaseOldSourceFile(resolvedProjectReference.sourceFile, oldProgram.getCompilerOptions(), /*hasSourceFileByPath*/ false); + } + }); + } + } + // Release commandlines that new program does not use + if (oldProgram && host.onReleaseParsedCommandLine) { + forEachProjectReference(oldProgram.getProjectReferences(), oldProgram.getResolvedProjectReferences(), function (oldResolvedRef, parent, index) { + var oldReference = (parent === null || parent === void 0 ? void 0 : parent.commandLine.projectReferences[index]) || oldProgram.getProjectReferences()[index]; + var oldRefPath = resolveProjectReferencePath(oldReference); + if (!(projectReferenceRedirects === null || projectReferenceRedirects === void 0 ? void 0 : projectReferenceRedirects.has(toPath(oldRefPath)))) { + host.onReleaseParsedCommandLine(oldRefPath, oldResolvedRef, oldProgram.getCompilerOptions()); + } + }); + } + typeReferenceDirectiveResolutionCache = undefined; + // unconditionally set oldProgram to undefined to prevent it from being captured in closure + oldProgram = undefined; + var program = { + getRootFileNames: function () { return rootNames; }, + getSourceFile: getSourceFile, + getSourceFileByPath: getSourceFileByPath, + getSourceFiles: function () { return files; }, + getMissingFilePaths: function () { return missingFilePaths; }, + getModuleResolutionCache: function () { return moduleResolutionCache; }, + getFilesByNameMap: function () { return filesByName; }, + getCompilerOptions: function () { return options; }, + getSyntacticDiagnostics: getSyntacticDiagnostics, + getOptionsDiagnostics: getOptionsDiagnostics, + getGlobalDiagnostics: getGlobalDiagnostics, + getSemanticDiagnostics: getSemanticDiagnostics, + getCachedSemanticDiagnostics: getCachedSemanticDiagnostics, + getSuggestionDiagnostics: getSuggestionDiagnostics, + getDeclarationDiagnostics: getDeclarationDiagnostics, + getBindAndCheckDiagnostics: getBindAndCheckDiagnostics, + getProgramDiagnostics: getProgramDiagnostics, + getTypeChecker: getTypeChecker, + getClassifiableNames: getClassifiableNames, + getCommonSourceDirectory: getCommonSourceDirectory, + emit: emit, + getCurrentDirectory: function () { return currentDirectory; }, + getNodeCount: function () { return getTypeChecker().getNodeCount(); }, + getIdentifierCount: function () { return getTypeChecker().getIdentifierCount(); }, + getSymbolCount: function () { return getTypeChecker().getSymbolCount(); }, + getTypeCount: function () { return getTypeChecker().getTypeCount(); }, + getInstantiationCount: function () { return getTypeChecker().getInstantiationCount(); }, + getRelationCacheSizes: function () { return getTypeChecker().getRelationCacheSizes(); }, + getFileProcessingDiagnostics: function () { return fileProcessingDiagnostics; }, + getResolvedTypeReferenceDirectives: function () { return resolvedTypeReferenceDirectives; }, + isSourceFileFromExternalLibrary: isSourceFileFromExternalLibrary, + isSourceFileDefaultLibrary: isSourceFileDefaultLibrary, + getSourceFileFromReference: getSourceFileFromReference, + getLibFileFromReference: getLibFileFromReference, + sourceFileToPackageName: sourceFileToPackageName, + redirectTargetsMap: redirectTargetsMap, + usesUriStyleNodeCoreModules: usesUriStyleNodeCoreModules, + isEmittedFile: isEmittedFile, + getConfigFileParsingDiagnostics: getConfigFileParsingDiagnostics, + getResolvedModuleWithFailedLookupLocationsFromCache: getResolvedModuleWithFailedLookupLocationsFromCache, + getProjectReferences: getProjectReferences, + getResolvedProjectReferences: getResolvedProjectReferences, + getProjectReferenceRedirect: getProjectReferenceRedirect, + getResolvedProjectReferenceToRedirect: getResolvedProjectReferenceToRedirect, + getResolvedProjectReferenceByPath: getResolvedProjectReferenceByPath, + forEachResolvedProjectReference: forEachResolvedProjectReference, + isSourceOfProjectReferenceRedirect: isSourceOfProjectReferenceRedirect, + emitBuildInfo: emitBuildInfo, + fileExists: fileExists, + readFile: readFile, + directoryExists: directoryExists, + getSymlinkCache: getSymlinkCache, + realpath: (_d = host.realpath) === null || _d === void 0 ? void 0 : _d.bind(host), + useCaseSensitiveFileNames: function () { return host.useCaseSensitiveFileNames(); }, + getFileIncludeReasons: function () { return fileReasons; }, + structureIsReused: structureIsReused, + writeFile: writeFile, + }; + onProgramCreateComplete(); + // Add file processingDiagnostics + fileProcessingDiagnostics === null || fileProcessingDiagnostics === void 0 ? void 0 : fileProcessingDiagnostics.forEach(function (diagnostic) { + switch (diagnostic.kind) { + case 1 /* FilePreprocessingDiagnosticsKind.FilePreprocessingFileExplainingDiagnostic */: + return programDiagnostics.add(createDiagnosticExplainingFile(diagnostic.file && getSourceFileByPath(diagnostic.file), diagnostic.fileProcessingReason, diagnostic.diagnostic, diagnostic.args || ts.emptyArray)); + case 0 /* FilePreprocessingDiagnosticsKind.FilePreprocessingReferencedDiagnostic */: + var _a = getReferencedFileLocation(getSourceFileByPath, diagnostic.reason), file = _a.file, pos = _a.pos, end = _a.end; + return programDiagnostics.add(ts.createFileDiagnostic.apply(void 0, __spreadArray([file, ts.Debug.checkDefined(pos), ts.Debug.checkDefined(end) - pos, diagnostic.diagnostic], diagnostic.args || ts.emptyArray, false))); + default: + ts.Debug.assertNever(diagnostic); + } + }); + verifyCompilerOptions(); + ts.performance.mark("afterProgram"); + ts.performance.measure("Program", "beforeProgram", "afterProgram"); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + return program; + function addResolutionDiagnostics(list) { + if (!list) + return; + for (var _i = 0, list_3 = list; _i < list_3.length; _i++) { + var elem = list_3[_i]; + programDiagnostics.add(elem); + } + } + function pullDiagnosticsFromCache(names, containingFile) { + var _a; + if (!moduleResolutionCache) + return; + var containingFileName = ts.getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory); + var containingFileMode = !ts.isString(containingFile) ? containingFile.impliedNodeFormat : undefined; + var containingDir = ts.getDirectoryPath(containingFileName); + var redirectedReference = getRedirectReferenceForResolution(containingFile); + var i = 0; + for (var _i = 0, names_4 = names; _i < names_4.length; _i++) { + var n = names_4[_i]; + // mimics logic done in the resolution cache, should be resilient to upgrading it to use `FileReference`s for non-type-reference modal lookups to make it rely on the index in the list less + var mode = typeof n === "string" ? getModeForResolutionAtIndex(containingFile, i) : getModeForFileReference(n, containingFileMode); + var name = typeof n === "string" ? n : n.fileName; + i++; + // only nonrelative names hit the cache, and, at least as of right now, only nonrelative names can issue diagnostics + // (Since diagnostics are only issued via import or export map lookup) + // This may totally change if/when the issue of output paths not mapping to input files is fixed in a broader context + // When it is, how we extract diagnostics from the module name resolver will have the be refined - the current cache + // APIs wrapping the underlying resolver make it almost impossible to smuggle the diagnostics out in a generalized way + if (ts.isExternalModuleNameRelative(name)) + continue; + var diags = (_a = moduleResolutionCache.getOrCreateCacheForModuleName(name, mode, redirectedReference).get(containingDir)) === null || _a === void 0 ? void 0 : _a.resolutionDiagnostics; + addResolutionDiagnostics(diags); + } + } + function resolveModuleNamesWorker(moduleNames, containingFile, reusedNames) { + if (!moduleNames.length) + return ts.emptyArray; + var containingFileName = ts.getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory); + var redirectedReference = getRedirectReferenceForResolution(containingFile); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* tracing.Phase.Program */, "resolveModuleNamesWorker", { containingFileName: containingFileName }); + ts.performance.mark("beforeResolveModule"); + var result = actualResolveModuleNamesWorker(moduleNames, containingFile, containingFileName, reusedNames, redirectedReference); + ts.performance.mark("afterResolveModule"); + ts.performance.measure("ResolveModule", "beforeResolveModule", "afterResolveModule"); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + pullDiagnosticsFromCache(moduleNames, containingFile); + return result; + } + function resolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFile) { + if (!typeDirectiveNames.length) + return []; + var containingFileName = !ts.isString(containingFile) ? ts.getNormalizedAbsolutePath(containingFile.originalFileName, currentDirectory) : containingFile; + var redirectedReference = !ts.isString(containingFile) ? getRedirectReferenceForResolution(containingFile) : undefined; + var containingFileMode = !ts.isString(containingFile) ? containingFile.impliedNodeFormat : undefined; + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* tracing.Phase.Program */, "resolveTypeReferenceDirectiveNamesWorker", { containingFileName: containingFileName }); + ts.performance.mark("beforeResolveTypeReference"); + var result = actualResolveTypeReferenceDirectiveNamesWorker(typeDirectiveNames, containingFileName, redirectedReference, containingFileMode); + ts.performance.mark("afterResolveTypeReference"); + ts.performance.measure("ResolveTypeReference", "beforeResolveTypeReference", "afterResolveTypeReference"); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + return result; + } + function getRedirectReferenceForResolution(file) { + var redirect = getResolvedProjectReferenceToRedirect(file.originalFileName); + if (redirect || !ts.isDeclarationFileName(file.originalFileName)) + return redirect; + // The originalFileName could not be actual source file name if file found was d.ts from referecned project + // So in this case try to look up if this is output from referenced project, if it is use the redirected project in that case + var resultFromDts = getRedirectReferenceForResolutionFromSourceOfProject(file.path); + if (resultFromDts) + return resultFromDts; + // If preserveSymlinks is true, module resolution wont jump the symlink + // but the resolved real path may be the .d.ts from project reference + // Note:: Currently we try the real path only if the + // file is from node_modules to avoid having to run real path on all file paths + if (!host.realpath || !options.preserveSymlinks || !ts.stringContains(file.originalFileName, ts.nodeModulesPathPart)) + return undefined; + var realDeclarationPath = toPath(host.realpath(file.originalFileName)); + return realDeclarationPath === file.path ? undefined : getRedirectReferenceForResolutionFromSourceOfProject(realDeclarationPath); + } + function getRedirectReferenceForResolutionFromSourceOfProject(filePath) { + var source = getSourceOfProjectReferenceRedirect(filePath); + if (ts.isString(source)) + return getResolvedProjectReferenceToRedirect(source); + if (!source) + return undefined; + // Output of .d.ts file so return resolved ref that matches the out file name + return forEachResolvedProjectReference(function (resolvedRef) { + var out = ts.outFile(resolvedRef.commandLine.options); + if (!out) + return undefined; + return toPath(out) === filePath ? resolvedRef : undefined; + }); + } + function compareDefaultLibFiles(a, b) { + return ts.compareValues(getDefaultLibFilePriority(a), getDefaultLibFilePriority(b)); + } + function getDefaultLibFilePriority(a) { + if (ts.containsPath(defaultLibraryPath, a.fileName, /*ignoreCase*/ false)) { + var basename = ts.getBaseFileName(a.fileName); + if (basename === "lib.d.ts" || basename === "lib.es6.d.ts") + return 0; + var name = ts.removeSuffix(ts.removePrefix(basename, "lib."), ".d.ts"); + var index = ts.libs.indexOf(name); + if (index !== -1) + return index + 1; + } + return ts.libs.length + 2; + } + function getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile, mode) { + return moduleResolutionCache && ts.resolveModuleNameFromCache(moduleName, containingFile, moduleResolutionCache, mode); + } + function toPath(fileName) { + return ts.toPath(fileName, currentDirectory, getCanonicalFileName); + } + function getCommonSourceDirectory() { + if (commonSourceDirectory === undefined) { + var emittedFiles_1 = ts.filter(files, function (file) { return ts.sourceFileMayBeEmitted(file, program); }); + commonSourceDirectory = ts.getCommonSourceDirectory(options, function () { return ts.mapDefined(emittedFiles_1, function (file) { return file.isDeclarationFile ? undefined : file.fileName; }); }, currentDirectory, getCanonicalFileName, function (commonSourceDirectory) { return checkSourceFilesBelongToPath(emittedFiles_1, commonSourceDirectory); }); + } + return commonSourceDirectory; + } + function getClassifiableNames() { + var _a; + if (!classifiableNames) { + // Initialize a checker so that all our files are bound. + getTypeChecker(); + classifiableNames = new ts.Set(); + for (var _i = 0, files_3 = files; _i < files_3.length; _i++) { + var sourceFile = files_3[_i]; + (_a = sourceFile.classifiableNames) === null || _a === void 0 ? void 0 : _a.forEach(function (value) { return classifiableNames.add(value); }); + } + } + return classifiableNames; + } + function resolveModuleNamesReusingOldState(moduleNames, file) { + if (structureIsReused === 0 /* StructureIsReused.Not */ && !file.ambientModuleNames.length) { + // If the old program state does not permit reusing resolutions and `file` does not contain locally defined ambient modules, + // the best we can do is fallback to the default logic. + return resolveModuleNamesWorker(moduleNames, file, /*reusedNames*/ undefined); + } + var oldSourceFile = oldProgram && oldProgram.getSourceFile(file.fileName); + if (oldSourceFile !== file && file.resolvedModules) { + // `file` was created for the new program. + // + // We only set `file.resolvedModules` via work from the current function, + // so it is defined iff we already called the current function on `file`. + // That call happened no later than the creation of the `file` object, + // which per above occurred during the current program creation. + // Since we assume the filesystem does not change during program creation, + // it is safe to reuse resolutions from the earlier call. + var result_14 = []; + var i = 0; + for (var _i = 0, moduleNames_1 = moduleNames; _i < moduleNames_1.length; _i++) { + var moduleName = moduleNames_1[_i]; + var resolvedModule = file.resolvedModules.get(moduleName, getModeForResolutionAtIndex(file, i)); + i++; + result_14.push(resolvedModule); + } + return result_14; + } + // At this point, we know at least one of the following hold: + // - file has local declarations for ambient modules + // - old program state is available + // With this information, we can infer some module resolutions without performing resolution. + /** An ordered list of module names for which we cannot recover the resolution. */ + var unknownModuleNames; + /** + * The indexing of elements in this list matches that of `moduleNames`. + * + * Before combining results, result[i] is in one of the following states: + * * undefined: needs to be recomputed, + * * predictedToResolveToAmbientModuleMarker: known to be an ambient module. + * Needs to be reset to undefined before returning, + * * ResolvedModuleFull instance: can be reused. + */ + var result; + var reusedNames; + /** A transient placeholder used to mark predicted resolution in the result list. */ + var predictedToResolveToAmbientModuleMarker = {}; + for (var i = 0; i < moduleNames.length; i++) { + var moduleName = moduleNames[i]; + // If the source file is unchanged and doesnt have invalidated resolution, reuse the module resolutions + if (file === oldSourceFile && !hasInvalidatedResolutions(oldSourceFile.path)) { + var oldResolvedModule = ts.getResolvedModule(oldSourceFile, moduleName, getModeForResolutionAtIndex(oldSourceFile, i)); + if (oldResolvedModule) { + if (ts.isTraceEnabled(options, host)) { + ts.trace(host, oldResolvedModule.packageId ? + ts.Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : + ts.Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2, moduleName, ts.getNormalizedAbsolutePath(file.originalFileName, currentDirectory), oldResolvedModule.resolvedFileName, oldResolvedModule.packageId && ts.packageIdToString(oldResolvedModule.packageId)); + } + (result || (result = new Array(moduleNames.length)))[i] = oldResolvedModule; + (reusedNames || (reusedNames = [])).push(moduleName); + continue; + } + } + // We know moduleName resolves to an ambient module provided that moduleName: + // - is in the list of ambient modules locally declared in the current source file. + // - resolved to an ambient module in the old program whose declaration is in an unmodified file + // (so the same module declaration will land in the new program) + var resolvesToAmbientModuleInNonModifiedFile = false; + if (ts.contains(file.ambientModuleNames, moduleName)) { + resolvesToAmbientModuleInNonModifiedFile = true; + if (ts.isTraceEnabled(options, host)) { + ts.trace(host, ts.Diagnostics.Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1, moduleName, ts.getNormalizedAbsolutePath(file.originalFileName, currentDirectory)); + } + } + else { + resolvesToAmbientModuleInNonModifiedFile = moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName, i); + } + if (resolvesToAmbientModuleInNonModifiedFile) { + (result || (result = new Array(moduleNames.length)))[i] = predictedToResolveToAmbientModuleMarker; + } + else { + // Resolution failed in the old program, or resolved to an ambient module for which we can't reuse the result. + (unknownModuleNames || (unknownModuleNames = [])).push(moduleName); + } + } + var resolutions = unknownModuleNames && unknownModuleNames.length + ? resolveModuleNamesWorker(unknownModuleNames, file, reusedNames) + : ts.emptyArray; + // Combine results of resolutions and predicted results + if (!result) { + // There were no unresolved/ambient resolutions. + ts.Debug.assert(resolutions.length === moduleNames.length); + return resolutions; + } + var j = 0; + for (var i = 0; i < result.length; i++) { + if (result[i]) { + // `result[i]` is either a `ResolvedModuleFull` or a marker. + // If it is the former, we can leave it as is. + if (result[i] === predictedToResolveToAmbientModuleMarker) { + result[i] = undefined; + } + } + else { + result[i] = resolutions[j]; + j++; + } + } + ts.Debug.assert(j === resolutions.length); + return result; + // If we change our policy of rechecking failed lookups on each program create, + // we should adjust the value returned here. + function moduleNameResolvesToAmbientModuleInNonModifiedFile(moduleName, index) { + if (index >= ts.length(oldSourceFile === null || oldSourceFile === void 0 ? void 0 : oldSourceFile.imports) + ts.length(oldSourceFile === null || oldSourceFile === void 0 ? void 0 : oldSourceFile.moduleAugmentations)) + return false; // mode index out of bounds, don't reuse resolution + var resolutionToFile = ts.getResolvedModule(oldSourceFile, moduleName, oldSourceFile && getModeForResolutionAtIndex(oldSourceFile, index)); + var resolvedFile = resolutionToFile && oldProgram.getSourceFile(resolutionToFile.resolvedFileName); + if (resolutionToFile && resolvedFile) { + // In the old program, we resolved to an ambient module that was in the same + // place as we expected to find an actual module file. + // We actually need to return 'false' here even though this seems like a 'true' case + // because the normal module resolution algorithm will find this anyway. + return false; + } + // at least one of declarations should come from non-modified source file + var unmodifiedFile = ambientModuleNameToUnmodifiedFileName.get(moduleName); + if (!unmodifiedFile) { + return false; + } + if (ts.isTraceEnabled(options, host)) { + ts.trace(host, ts.Diagnostics.Module_0_was_resolved_as_ambient_module_declared_in_1_since_this_file_was_not_modified, moduleName, unmodifiedFile); + } + return true; + } + } + function canReuseProjectReferences() { + return !forEachProjectReference(oldProgram.getProjectReferences(), oldProgram.getResolvedProjectReferences(), function (oldResolvedRef, parent, index) { + var newRef = (parent ? parent.commandLine.projectReferences : projectReferences)[index]; + var newResolvedRef = parseProjectReferenceConfigFile(newRef); + if (oldResolvedRef) { + // Resolved project reference has gone missing or changed + return !newResolvedRef || + newResolvedRef.sourceFile !== oldResolvedRef.sourceFile || + !ts.arrayIsEqualTo(oldResolvedRef.commandLine.fileNames, newResolvedRef.commandLine.fileNames); + } + else { + // A previously-unresolved reference may be resolved now + return newResolvedRef !== undefined; + } + }, function (oldProjectReferences, parent) { + // If array of references is changed, we cant resue old program + var newReferences = parent ? getResolvedProjectReferenceByPath(parent.sourceFile.path).commandLine.projectReferences : projectReferences; + return !ts.arrayIsEqualTo(oldProjectReferences, newReferences, ts.projectReferenceIsEqualTo); + }); + } + function tryReuseStructureFromOldProgram() { + var _a, _b; + if (!oldProgram) { + return 0 /* StructureIsReused.Not */; + } + // check properties that can affect structure of the program or module resolution strategy + // if any of these properties has changed - structure cannot be reused + var oldOptions = oldProgram.getCompilerOptions(); + if (ts.changesAffectModuleResolution(oldOptions, options)) { + return 0 /* StructureIsReused.Not */; + } + // there is an old program, check if we can reuse its structure + var oldRootNames = oldProgram.getRootFileNames(); + if (!ts.arrayIsEqualTo(oldRootNames, rootNames)) { + return 0 /* StructureIsReused.Not */; + } + // Check if any referenced project tsconfig files are different + if (!canReuseProjectReferences()) { + return 0 /* StructureIsReused.Not */; + } + if (projectReferences) { + resolvedProjectReferences = projectReferences.map(parseProjectReferenceConfigFile); + } + // check if program source files has changed in the way that can affect structure of the program + var newSourceFiles = []; + var modifiedSourceFiles = []; + structureIsReused = 2 /* StructureIsReused.Completely */; + // If the missing file paths are now present, it can change the progam structure, + // and hence cant reuse the structure. + // This is same as how we dont reuse the structure if one of the file from old program is now missing + if (oldProgram.getMissingFilePaths().some(function (missingFilePath) { return host.fileExists(missingFilePath); })) { + return 0 /* StructureIsReused.Not */; + } + var oldSourceFiles = oldProgram.getSourceFiles(); + var SeenPackageName; + (function (SeenPackageName) { + SeenPackageName[SeenPackageName["Exists"] = 0] = "Exists"; + SeenPackageName[SeenPackageName["Modified"] = 1] = "Modified"; + })(SeenPackageName || (SeenPackageName = {})); + var seenPackageNames = new ts.Map(); + for (var _i = 0, oldSourceFiles_2 = oldSourceFiles; _i < oldSourceFiles_2.length; _i++) { + var oldSourceFile = oldSourceFiles_2[_i]; + var sourceFileOptions = getCreateSourceFileOptions(oldSourceFile.fileName, moduleResolutionCache, host, options); + var newSourceFile = host.getSourceFileByPath + ? host.getSourceFileByPath(oldSourceFile.fileName, oldSourceFile.resolvedPath, sourceFileOptions, /*onError*/ undefined, shouldCreateNewSourceFile || sourceFileOptions.impliedNodeFormat !== oldSourceFile.impliedNodeFormat) + : host.getSourceFile(oldSourceFile.fileName, sourceFileOptions, /*onError*/ undefined, shouldCreateNewSourceFile || sourceFileOptions.impliedNodeFormat !== oldSourceFile.impliedNodeFormat); // TODO: GH#18217 + if (!newSourceFile) { + return 0 /* StructureIsReused.Not */; + } + newSourceFile.packageJsonLocations = ((_a = sourceFileOptions.packageJsonLocations) === null || _a === void 0 ? void 0 : _a.length) ? sourceFileOptions.packageJsonLocations : undefined; + newSourceFile.packageJsonScope = sourceFileOptions.packageJsonScope; + ts.Debug.assert(!newSourceFile.redirectInfo, "Host should not return a redirect source file from `getSourceFile`"); + var fileChanged = void 0; + if (oldSourceFile.redirectInfo) { + // We got `newSourceFile` by path, so it is actually for the unredirected file. + // This lets us know if the unredirected file has changed. If it has we should break the redirect. + if (newSourceFile !== oldSourceFile.redirectInfo.unredirected) { + // Underlying file has changed. Might not redirect anymore. Must rebuild program. + return 0 /* StructureIsReused.Not */; + } + fileChanged = false; + newSourceFile = oldSourceFile; // Use the redirect. + } + else if (oldProgram.redirectTargetsMap.has(oldSourceFile.path)) { + // If a redirected-to source file changes, the redirect may be broken. + if (newSourceFile !== oldSourceFile) { + return 0 /* StructureIsReused.Not */; + } + fileChanged = false; + } + else { + fileChanged = newSourceFile !== oldSourceFile; + } + // Since the project references havent changed, its right to set originalFileName and resolvedPath here + newSourceFile.path = oldSourceFile.path; + newSourceFile.originalFileName = oldSourceFile.originalFileName; + newSourceFile.resolvedPath = oldSourceFile.resolvedPath; + newSourceFile.fileName = oldSourceFile.fileName; + var packageName = oldProgram.sourceFileToPackageName.get(oldSourceFile.path); + if (packageName !== undefined) { + // If there are 2 different source files for the same package name and at least one of them changes, + // they might become redirects. So we must rebuild the program. + var prevKind = seenPackageNames.get(packageName); + var newKind = fileChanged ? 1 /* SeenPackageName.Modified */ : 0 /* SeenPackageName.Exists */; + if ((prevKind !== undefined && newKind === 1 /* SeenPackageName.Modified */) || prevKind === 1 /* SeenPackageName.Modified */) { + return 0 /* StructureIsReused.Not */; + } + seenPackageNames.set(packageName, newKind); + } + if (fileChanged) { + if (oldSourceFile.impliedNodeFormat !== newSourceFile.impliedNodeFormat) { + structureIsReused = 1 /* StructureIsReused.SafeModules */; + } + // The `newSourceFile` object was created for the new program. + else if (!ts.arrayIsEqualTo(oldSourceFile.libReferenceDirectives, newSourceFile.libReferenceDirectives, fileReferenceIsEqualTo)) { + // 'lib' references has changed. Matches behavior in changesAffectModuleResolution + structureIsReused = 1 /* StructureIsReused.SafeModules */; + } + else if (oldSourceFile.hasNoDefaultLib !== newSourceFile.hasNoDefaultLib) { + // value of no-default-lib has changed + // this will affect if default library is injected into the list of files + structureIsReused = 1 /* StructureIsReused.SafeModules */; + } + // check tripleslash references + else if (!ts.arrayIsEqualTo(oldSourceFile.referencedFiles, newSourceFile.referencedFiles, fileReferenceIsEqualTo)) { + // tripleslash references has changed + structureIsReused = 1 /* StructureIsReused.SafeModules */; + } + else { + // check imports and module augmentations + collectExternalModuleReferences(newSourceFile); + if (!ts.arrayIsEqualTo(oldSourceFile.imports, newSourceFile.imports, moduleNameIsEqualTo)) { + // imports has changed + structureIsReused = 1 /* StructureIsReused.SafeModules */; + } + else if (!ts.arrayIsEqualTo(oldSourceFile.moduleAugmentations, newSourceFile.moduleAugmentations, moduleNameIsEqualTo)) { + // moduleAugmentations has changed + structureIsReused = 1 /* StructureIsReused.SafeModules */; + } + else if ((oldSourceFile.flags & 6291456 /* NodeFlags.PermanentlySetIncrementalFlags */) !== (newSourceFile.flags & 6291456 /* NodeFlags.PermanentlySetIncrementalFlags */)) { + // dynamicImport has changed + structureIsReused = 1 /* StructureIsReused.SafeModules */; + } + else if (!ts.arrayIsEqualTo(oldSourceFile.typeReferenceDirectives, newSourceFile.typeReferenceDirectives, fileReferenceIsEqualTo)) { + // 'types' references has changed + structureIsReused = 1 /* StructureIsReused.SafeModules */; + } + } + // tentatively approve the file + modifiedSourceFiles.push({ oldFile: oldSourceFile, newFile: newSourceFile }); + } + else if (hasInvalidatedResolutions(oldSourceFile.path)) { + // 'module/types' references could have changed + structureIsReused = 1 /* StructureIsReused.SafeModules */; + // add file to the modified list so that we will resolve it later + modifiedSourceFiles.push({ oldFile: oldSourceFile, newFile: newSourceFile }); + } + // if file has passed all checks it should be safe to reuse it + newSourceFiles.push(newSourceFile); + } + if (structureIsReused !== 2 /* StructureIsReused.Completely */) { + return structureIsReused; + } + var modifiedFiles = modifiedSourceFiles.map(function (f) { return f.oldFile; }); + for (var _c = 0, oldSourceFiles_3 = oldSourceFiles; _c < oldSourceFiles_3.length; _c++) { + var oldFile = oldSourceFiles_3[_c]; + if (!ts.contains(modifiedFiles, oldFile)) { + for (var _d = 0, _e = oldFile.ambientModuleNames; _d < _e.length; _d++) { + var moduleName = _e[_d]; + ambientModuleNameToUnmodifiedFileName.set(moduleName, oldFile.fileName); + } + } + } + // try to verify results of module resolution + for (var _f = 0, modifiedSourceFiles_1 = modifiedSourceFiles; _f < modifiedSourceFiles_1.length; _f++) { + var _g = modifiedSourceFiles_1[_f], oldSourceFile = _g.oldFile, newSourceFile = _g.newFile; + var moduleNames = getModuleNames(newSourceFile); + var resolutions = resolveModuleNamesReusingOldState(moduleNames, newSourceFile); + // ensure that module resolution results are still correct + var resolutionsChanged = ts.hasChangesInResolutions(moduleNames, resolutions, oldSourceFile.resolvedModules, oldSourceFile, ts.moduleResolutionIsEqualTo); + if (resolutionsChanged) { + structureIsReused = 1 /* StructureIsReused.SafeModules */; + newSourceFile.resolvedModules = ts.zipToModeAwareCache(newSourceFile, moduleNames, resolutions); + } + else { + newSourceFile.resolvedModules = oldSourceFile.resolvedModules; + } + var typesReferenceDirectives = newSourceFile.typeReferenceDirectives; + var typeReferenceResolutions = resolveTypeReferenceDirectiveNamesWorker(typesReferenceDirectives, newSourceFile); + // ensure that types resolutions are still correct + var typeReferenceResolutionsChanged = ts.hasChangesInResolutions(typesReferenceDirectives, typeReferenceResolutions, oldSourceFile.resolvedTypeReferenceDirectiveNames, oldSourceFile, ts.typeDirectiveIsEqualTo); + if (typeReferenceResolutionsChanged) { + structureIsReused = 1 /* StructureIsReused.SafeModules */; + newSourceFile.resolvedTypeReferenceDirectiveNames = ts.zipToModeAwareCache(newSourceFile, typesReferenceDirectives, typeReferenceResolutions); + } + else { + newSourceFile.resolvedTypeReferenceDirectiveNames = oldSourceFile.resolvedTypeReferenceDirectiveNames; + } + } + if (structureIsReused !== 2 /* StructureIsReused.Completely */) { + return structureIsReused; + } + if (ts.changesAffectingProgramStructure(oldOptions, options) || ((_b = host.hasChangedAutomaticTypeDirectiveNames) === null || _b === void 0 ? void 0 : _b.call(host))) { + return 1 /* StructureIsReused.SafeModules */; + } + missingFilePaths = oldProgram.getMissingFilePaths(); + // update fileName -> file mapping + ts.Debug.assert(newSourceFiles.length === oldProgram.getSourceFiles().length); + for (var _h = 0, newSourceFiles_1 = newSourceFiles; _h < newSourceFiles_1.length; _h++) { + var newSourceFile = newSourceFiles_1[_h]; + filesByName.set(newSourceFile.path, newSourceFile); + } + var oldFilesByNameMap = oldProgram.getFilesByNameMap(); + oldFilesByNameMap.forEach(function (oldFile, path) { + if (!oldFile) { + filesByName.set(path, oldFile); + return; + } + if (oldFile.path === path) { + // Set the file as found during node modules search if it was found that way in old progra, + if (oldProgram.isSourceFileFromExternalLibrary(oldFile)) { + sourceFilesFoundSearchingNodeModules.set(oldFile.path, true); + } + return; + } + filesByName.set(path, filesByName.get(oldFile.path)); + }); + files = newSourceFiles; + fileReasons = oldProgram.getFileIncludeReasons(); + fileProcessingDiagnostics = oldProgram.getFileProcessingDiagnostics(); + resolvedTypeReferenceDirectives = oldProgram.getResolvedTypeReferenceDirectives(); + sourceFileToPackageName = oldProgram.sourceFileToPackageName; + redirectTargetsMap = oldProgram.redirectTargetsMap; + usesUriStyleNodeCoreModules = oldProgram.usesUriStyleNodeCoreModules; + return 2 /* StructureIsReused.Completely */; + } + function getEmitHost(writeFileCallback) { + return { + getPrependNodes: getPrependNodes, + getCanonicalFileName: getCanonicalFileName, + getCommonSourceDirectory: program.getCommonSourceDirectory, + getCompilerOptions: program.getCompilerOptions, + getCurrentDirectory: function () { return currentDirectory; }, + getNewLine: function () { return host.getNewLine(); }, + getSourceFile: program.getSourceFile, + getSourceFileByPath: program.getSourceFileByPath, + getSourceFiles: program.getSourceFiles, + getLibFileFromReference: program.getLibFileFromReference, + isSourceFileFromExternalLibrary: isSourceFileFromExternalLibrary, + getResolvedProjectReferenceToRedirect: getResolvedProjectReferenceToRedirect, + getProjectReferenceRedirect: getProjectReferenceRedirect, + isSourceOfProjectReferenceRedirect: isSourceOfProjectReferenceRedirect, + getSymlinkCache: getSymlinkCache, + writeFile: writeFileCallback || writeFile, + isEmitBlocked: isEmitBlocked, + readFile: function (f) { return host.readFile(f); }, + fileExists: function (f) { + // Use local caches + var path = toPath(f); + if (getSourceFileByPath(path)) + return true; + if (ts.contains(missingFilePaths, path)) + return false; + // Before falling back to the host + return host.fileExists(f); + }, + useCaseSensitiveFileNames: function () { return host.useCaseSensitiveFileNames(); }, + getProgramBuildInfo: function () { return program.getProgramBuildInfo && program.getProgramBuildInfo(); }, + getSourceFileFromReference: function (file, ref) { return program.getSourceFileFromReference(file, ref); }, + redirectTargetsMap: redirectTargetsMap, + getFileIncludeReasons: program.getFileIncludeReasons, + createHash: ts.maybeBind(host, host.createHash), + }; + } + function writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, data) { + host.writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, data); + } + function emitBuildInfo(writeFileCallback) { + ts.Debug.assert(!ts.outFile(options)); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("emit" /* tracing.Phase.Emit */, "emitBuildInfo", {}, /*separateBeginAndEnd*/ true); + ts.performance.mark("beforeEmit"); + var emitResult = ts.emitFiles(ts.notImplementedResolver, getEmitHost(writeFileCallback), + /*targetSourceFile*/ undefined, + /*transformers*/ ts.noTransformers, + /*emitOnlyDtsFiles*/ false, + /*onlyBuildInfo*/ true); + ts.performance.mark("afterEmit"); + ts.performance.measure("Emit", "beforeEmit", "afterEmit"); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + return emitResult; + } + function getResolvedProjectReferences() { + return resolvedProjectReferences; + } + function getProjectReferences() { + return projectReferences; + } + function getPrependNodes() { + return createPrependNodes(projectReferences, function (_ref, index) { var _a; return (_a = resolvedProjectReferences[index]) === null || _a === void 0 ? void 0 : _a.commandLine; }, function (fileName) { + var path = toPath(fileName); + var sourceFile = getSourceFileByPath(path); + return sourceFile ? sourceFile.text : filesByName.has(path) ? undefined : host.readFile(path); + }); + } + function isSourceFileFromExternalLibrary(file) { + return !!sourceFilesFoundSearchingNodeModules.get(file.path); + } + function isSourceFileDefaultLibrary(file) { + if (!file.isDeclarationFile) { + return false; + } + if (file.hasNoDefaultLib) { + return true; + } + if (!options.noLib) { + return false; + } + // If '--lib' is not specified, include default library file according to '--target' + // otherwise, using options specified in '--lib' instead of '--target' default library file + var equalityComparer = host.useCaseSensitiveFileNames() ? ts.equateStringsCaseSensitive : ts.equateStringsCaseInsensitive; + if (!options.lib) { + return equalityComparer(file.fileName, getDefaultLibraryFileName()); + } + else { + return ts.some(options.lib, function (libFileName) { return equalityComparer(file.fileName, pathForLibFile(libFileName)); }); + } + } + function getTypeChecker() { + return typeChecker || (typeChecker = ts.createTypeChecker(program)); + } + function emit(sourceFile, writeFileCallback, cancellationToken, emitOnlyDtsFiles, transformers, forceDtsEmit) { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("emit" /* tracing.Phase.Emit */, "emit", { path: sourceFile === null || sourceFile === void 0 ? void 0 : sourceFile.path }, /*separateBeginAndEnd*/ true); + var result = runWithCancellationToken(function () { return emitWorker(program, sourceFile, writeFileCallback, cancellationToken, emitOnlyDtsFiles, transformers, forceDtsEmit); }); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + return result; + } + function isEmitBlocked(emitFileName) { + return hasEmitBlockingDiagnostics.has(toPath(emitFileName)); + } + function emitWorker(program, sourceFile, writeFileCallback, cancellationToken, emitOnlyDtsFiles, customTransformers, forceDtsEmit) { + if (!forceDtsEmit) { + var result = handleNoEmitOptions(program, sourceFile, writeFileCallback, cancellationToken); + if (result) + return result; + } + // Create the emit resolver outside of the "emitTime" tracking code below. That way + // any cost associated with it (like type checking) are appropriate associated with + // the type-checking counter. + // + // If the -out option is specified, we should not pass the source file to getEmitResolver. + // This is because in the -out scenario all files need to be emitted, and therefore all + // files need to be type checked. And the way to specify that all files need to be type + // checked is to not pass the file to getEmitResolver. + var emitResolver = getTypeChecker().getEmitResolver(ts.outFile(options) ? undefined : sourceFile, cancellationToken); + ts.performance.mark("beforeEmit"); + var emitResult = ts.emitFiles(emitResolver, getEmitHost(writeFileCallback), sourceFile, ts.getTransformers(options, customTransformers, emitOnlyDtsFiles), emitOnlyDtsFiles, + /*onlyBuildInfo*/ false, forceDtsEmit); + ts.performance.mark("afterEmit"); + ts.performance.measure("Emit", "beforeEmit", "afterEmit"); + return emitResult; + } + function getSourceFile(fileName) { + return getSourceFileByPath(toPath(fileName)); + } + function getSourceFileByPath(path) { + return filesByName.get(path) || undefined; + } + function getDiagnosticsHelper(sourceFile, getDiagnostics, cancellationToken) { + if (sourceFile) { + return getDiagnostics(sourceFile, cancellationToken); + } + return ts.sortAndDeduplicateDiagnostics(ts.flatMap(program.getSourceFiles(), function (sourceFile) { + if (cancellationToken) { + cancellationToken.throwIfCancellationRequested(); + } + return getDiagnostics(sourceFile, cancellationToken); + })); + } + function getSyntacticDiagnostics(sourceFile, cancellationToken) { + return getDiagnosticsHelper(sourceFile, getSyntacticDiagnosticsForFile, cancellationToken); + } + function getSemanticDiagnostics(sourceFile, cancellationToken) { + return getDiagnosticsHelper(sourceFile, getSemanticDiagnosticsForFile, cancellationToken); + } + function getCachedSemanticDiagnostics(sourceFile) { + var _a; + return sourceFile + ? (_a = cachedBindAndCheckDiagnosticsForFile.perFile) === null || _a === void 0 ? void 0 : _a.get(sourceFile.path) + : cachedBindAndCheckDiagnosticsForFile.allDiagnostics; + } + function getBindAndCheckDiagnostics(sourceFile, cancellationToken) { + return getBindAndCheckDiagnosticsForFile(sourceFile, cancellationToken); + } + function getProgramDiagnostics(sourceFile) { + var _a; + if (ts.skipTypeChecking(sourceFile, options, program)) { + return ts.emptyArray; + } + var programDiagnosticsInFile = programDiagnostics.getDiagnostics(sourceFile.fileName); + if (!((_a = sourceFile.commentDirectives) === null || _a === void 0 ? void 0 : _a.length)) { + return programDiagnosticsInFile; + } + return getDiagnosticsWithPrecedingDirectives(sourceFile, sourceFile.commentDirectives, programDiagnosticsInFile).diagnostics; + } + function getDeclarationDiagnostics(sourceFile, cancellationToken) { + var options = program.getCompilerOptions(); + // collect diagnostics from the program only once if either no source file was specified or out/outFile is set (bundled emit) + if (!sourceFile || ts.outFile(options)) { + return getDeclarationDiagnosticsWorker(sourceFile, cancellationToken); + } + else { + return getDiagnosticsHelper(sourceFile, getDeclarationDiagnosticsForFile, cancellationToken); + } + } + function getSyntacticDiagnosticsForFile(sourceFile) { + // For JavaScript files, we report semantic errors for using TypeScript-only + // constructs from within a JavaScript file as syntactic errors. + if (ts.isSourceFileJS(sourceFile)) { + if (!sourceFile.additionalSyntacticDiagnostics) { + sourceFile.additionalSyntacticDiagnostics = getJSSyntacticDiagnosticsForFile(sourceFile); + } + return ts.concatenate(sourceFile.additionalSyntacticDiagnostics, sourceFile.parseDiagnostics); + } + return sourceFile.parseDiagnostics; + } + function runWithCancellationToken(func) { + try { + return func(); + } + catch (e) { + if (e instanceof ts.OperationCanceledException) { + // We were canceled while performing the operation. Because our type checker + // might be a bad state, we need to throw it away. + typeChecker = undefined; + } + throw e; + } + } + function getSemanticDiagnosticsForFile(sourceFile, cancellationToken) { + return ts.concatenate(filterSemanticDiagnostics(getBindAndCheckDiagnosticsForFile(sourceFile, cancellationToken), options), getProgramDiagnostics(sourceFile)); + } + function getBindAndCheckDiagnosticsForFile(sourceFile, cancellationToken) { + return getAndCacheDiagnostics(sourceFile, cancellationToken, cachedBindAndCheckDiagnosticsForFile, getBindAndCheckDiagnosticsForFileNoCache); + } + function getBindAndCheckDiagnosticsForFileNoCache(sourceFile, cancellationToken) { + return runWithCancellationToken(function () { + if (ts.skipTypeChecking(sourceFile, options, program)) { + return ts.emptyArray; + } + var typeChecker = getTypeChecker(); + ts.Debug.assert(!!sourceFile.bindDiagnostics); + var isJs = sourceFile.scriptKind === 1 /* ScriptKind.JS */ || sourceFile.scriptKind === 2 /* ScriptKind.JSX */; + var isCheckJs = isJs && ts.isCheckJsEnabledForFile(sourceFile, options); + var isPlainJs = ts.isPlainJsFile(sourceFile, options.checkJs); + var isTsNoCheck = !!sourceFile.checkJsDirective && sourceFile.checkJsDirective.enabled === false; + // By default, only type-check .ts, .tsx, Deferred, plain JS, checked JS and External + // - plain JS: .js files with no // ts-check and checkJs: undefined + // - check JS: .js files with either // ts-check or checkJs: true + // - external: files that are added by plugins + var includeBindAndCheckDiagnostics = !isTsNoCheck && (sourceFile.scriptKind === 3 /* ScriptKind.TS */ || sourceFile.scriptKind === 4 /* ScriptKind.TSX */ + || sourceFile.scriptKind === 5 /* ScriptKind.External */ || isPlainJs || isCheckJs || sourceFile.scriptKind === 7 /* ScriptKind.Deferred */); + var bindDiagnostics = includeBindAndCheckDiagnostics ? sourceFile.bindDiagnostics : ts.emptyArray; + var checkDiagnostics = includeBindAndCheckDiagnostics ? typeChecker.getDiagnostics(sourceFile, cancellationToken) : ts.emptyArray; + if (isPlainJs) { + bindDiagnostics = ts.filter(bindDiagnostics, function (d) { return ts.plainJSErrors.has(d.code); }); + checkDiagnostics = ts.filter(checkDiagnostics, function (d) { return ts.plainJSErrors.has(d.code); }); + } + // skip ts-expect-error errors in plain JS files, and skip JSDoc errors except in checked JS + return getMergedBindAndCheckDiagnostics(sourceFile, includeBindAndCheckDiagnostics && !isPlainJs, bindDiagnostics, checkDiagnostics, isCheckJs ? sourceFile.jsDocDiagnostics : undefined); + }); + } + function getMergedBindAndCheckDiagnostics(sourceFile, includeBindAndCheckDiagnostics) { + var _a; + var allDiagnostics = []; + for (var _i = 2; _i < arguments.length; _i++) { + allDiagnostics[_i - 2] = arguments[_i]; + } + var flatDiagnostics = ts.flatten(allDiagnostics); + if (!includeBindAndCheckDiagnostics || !((_a = sourceFile.commentDirectives) === null || _a === void 0 ? void 0 : _a.length)) { + return flatDiagnostics; + } + var _b = getDiagnosticsWithPrecedingDirectives(sourceFile, sourceFile.commentDirectives, flatDiagnostics), diagnostics = _b.diagnostics, directives = _b.directives; + for (var _c = 0, _d = directives.getUnusedExpectations(); _c < _d.length; _c++) { + var errorExpectation = _d[_c]; + diagnostics.push(ts.createDiagnosticForRange(sourceFile, errorExpectation.range, ts.Diagnostics.Unused_ts_expect_error_directive)); + } + return diagnostics; + } + /** + * Creates a map of comment directives along with the diagnostics immediately preceded by one of them. + * Comments that match to any of those diagnostics are marked as used. + */ + function getDiagnosticsWithPrecedingDirectives(sourceFile, commentDirectives, flatDiagnostics) { + // Diagnostics are only reported if there is no comment directive preceding them + // This will modify the directives map by marking "used" ones with a corresponding diagnostic + var directives = ts.createCommentDirectivesMap(sourceFile, commentDirectives); + var diagnostics = flatDiagnostics.filter(function (diagnostic) { return markPrecedingCommentDirectiveLine(diagnostic, directives) === -1; }); + return { diagnostics: diagnostics, directives: directives }; + } + function getSuggestionDiagnostics(sourceFile, cancellationToken) { + return runWithCancellationToken(function () { + return getTypeChecker().getSuggestionDiagnostics(sourceFile, cancellationToken); + }); + } + /** + * @returns The line index marked as preceding the diagnostic, or -1 if none was. + */ + function markPrecedingCommentDirectiveLine(diagnostic, directives) { + var file = diagnostic.file, start = diagnostic.start; + if (!file) { + return -1; + } + // Start out with the line just before the text + var lineStarts = ts.getLineStarts(file); + var line = ts.computeLineAndCharacterOfPosition(lineStarts, start).line - 1; // TODO: GH#18217 + while (line >= 0) { + // As soon as that line is known to have a comment directive, use that + if (directives.markUsed(line)) { + return line; + } + // Stop searching if the line is not empty and not a comment + var lineText = file.text.slice(lineStarts[line], lineStarts[line + 1]).trim(); + if (lineText !== "" && !/^(\s*)\/\/(.*)$/.test(lineText)) { + return -1; + } + line--; + } + return -1; + } + function getJSSyntacticDiagnosticsForFile(sourceFile) { + return runWithCancellationToken(function () { + var diagnostics = []; + walk(sourceFile, sourceFile); + ts.forEachChildRecursively(sourceFile, walk, walkArray); + return diagnostics; + function walk(node, parent) { + // Return directly from the case if the given node doesnt want to visit each child + // Otherwise break to visit each child + switch (parent.kind) { + case 166 /* SyntaxKind.Parameter */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 171 /* SyntaxKind.MethodDeclaration */: + if (parent.questionToken === node) { + diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, "?")); + return "skip"; + } + // falls through + case 170 /* SyntaxKind.MethodSignature */: + case 173 /* SyntaxKind.Constructor */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 215 /* SyntaxKind.FunctionExpression */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 216 /* SyntaxKind.ArrowFunction */: + case 257 /* SyntaxKind.VariableDeclaration */: + // type annotation + if (parent.type === node) { + diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.Type_annotations_can_only_be_used_in_TypeScript_files)); + return "skip"; + } + } + switch (node.kind) { + case 270 /* SyntaxKind.ImportClause */: + if (node.isTypeOnly) { + diagnostics.push(createDiagnosticForNode(parent, ts.Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, "import type")); + return "skip"; + } + break; + case 275 /* SyntaxKind.ExportDeclaration */: + if (node.isTypeOnly) { + diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, "export type")); + return "skip"; + } + break; + case 273 /* SyntaxKind.ImportSpecifier */: + case 278 /* SyntaxKind.ExportSpecifier */: + if (node.isTypeOnly) { + diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, ts.isImportSpecifier(node) ? "import...type" : "export...type")); + return "skip"; + } + break; + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.import_can_only_be_used_in_TypeScript_files)); + return "skip"; + case 274 /* SyntaxKind.ExportAssignment */: + if (node.isExportEquals) { + diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.export_can_only_be_used_in_TypeScript_files)); + return "skip"; + } + break; + case 294 /* SyntaxKind.HeritageClause */: + var heritageClause = node; + if (heritageClause.token === 117 /* SyntaxKind.ImplementsKeyword */) { + diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.implements_clauses_can_only_be_used_in_TypeScript_files)); + return "skip"; + } + break; + case 261 /* SyntaxKind.InterfaceDeclaration */: + var interfaceKeyword = ts.tokenToString(118 /* SyntaxKind.InterfaceKeyword */); + ts.Debug.assertIsDefined(interfaceKeyword); + diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, interfaceKeyword)); + return "skip"; + case 264 /* SyntaxKind.ModuleDeclaration */: + var moduleKeyword = node.flags & 16 /* NodeFlags.Namespace */ ? ts.tokenToString(143 /* SyntaxKind.NamespaceKeyword */) : ts.tokenToString(142 /* SyntaxKind.ModuleKeyword */); + ts.Debug.assertIsDefined(moduleKeyword); + diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, moduleKeyword)); + return "skip"; + case 262 /* SyntaxKind.TypeAliasDeclaration */: + diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.Type_aliases_can_only_be_used_in_TypeScript_files)); + return "skip"; + case 263 /* SyntaxKind.EnumDeclaration */: + var enumKeyword = ts.Debug.checkDefined(ts.tokenToString(92 /* SyntaxKind.EnumKeyword */)); + diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics._0_declarations_can_only_be_used_in_TypeScript_files, enumKeyword)); + return "skip"; + case 232 /* SyntaxKind.NonNullExpression */: + diagnostics.push(createDiagnosticForNode(node, ts.Diagnostics.Non_null_assertions_can_only_be_used_in_TypeScript_files)); + return "skip"; + case 231 /* SyntaxKind.AsExpression */: + diagnostics.push(createDiagnosticForNode(node.type, ts.Diagnostics.Type_assertion_expressions_can_only_be_used_in_TypeScript_files)); + return "skip"; + case 235 /* SyntaxKind.SatisfiesExpression */: + diagnostics.push(createDiagnosticForNode(node.type, ts.Diagnostics.Type_satisfaction_expressions_can_only_be_used_in_TypeScript_files)); + return "skip"; + case 213 /* SyntaxKind.TypeAssertionExpression */: + ts.Debug.fail(); // Won't parse these in a JS file anyway, as they are interpreted as JSX. + } + } + function walkArray(nodes, parent) { + if (ts.canHaveModifiers(parent) && parent.modifiers === nodes && ts.some(nodes, ts.isDecorator) && !options.experimentalDecorators) { + diagnostics.push(createDiagnosticForNode(parent, ts.Diagnostics.Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_the_experimentalDecorators_option_in_your_tsconfig_or_jsconfig_to_remove_this_warning)); + } + switch (parent.kind) { + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 173 /* SyntaxKind.Constructor */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 215 /* SyntaxKind.FunctionExpression */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 216 /* SyntaxKind.ArrowFunction */: + // Check type parameters + if (nodes === parent.typeParameters) { + diagnostics.push(createDiagnosticForNodeArray(nodes, ts.Diagnostics.Type_parameter_declarations_can_only_be_used_in_TypeScript_files)); + return "skip"; + } + // falls through + case 240 /* SyntaxKind.VariableStatement */: + // Check modifiers + if (nodes === parent.modifiers) { + checkModifiers(parent.modifiers, parent.kind === 240 /* SyntaxKind.VariableStatement */); + return "skip"; + } + break; + case 169 /* SyntaxKind.PropertyDeclaration */: + // Check modifiers of property declaration + if (nodes === parent.modifiers) { + for (var _i = 0, _a = nodes; _i < _a.length; _i++) { + var modifier = _a[_i]; + if (ts.isModifier(modifier) + && modifier.kind !== 124 /* SyntaxKind.StaticKeyword */ + && modifier.kind !== 127 /* SyntaxKind.AccessorKeyword */) { + diagnostics.push(createDiagnosticForNode(modifier, ts.Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, ts.tokenToString(modifier.kind))); + } + } + return "skip"; + } + break; + case 166 /* SyntaxKind.Parameter */: + // Check modifiers of parameter declaration + if (nodes === parent.modifiers && ts.some(nodes, ts.isModifier)) { + diagnostics.push(createDiagnosticForNodeArray(nodes, ts.Diagnostics.Parameter_modifiers_can_only_be_used_in_TypeScript_files)); + return "skip"; + } + break; + case 210 /* SyntaxKind.CallExpression */: + case 211 /* SyntaxKind.NewExpression */: + case 230 /* SyntaxKind.ExpressionWithTypeArguments */: + case 282 /* SyntaxKind.JsxSelfClosingElement */: + case 283 /* SyntaxKind.JsxOpeningElement */: + case 212 /* SyntaxKind.TaggedTemplateExpression */: + // Check type arguments + if (nodes === parent.typeArguments) { + diagnostics.push(createDiagnosticForNodeArray(nodes, ts.Diagnostics.Type_arguments_can_only_be_used_in_TypeScript_files)); + return "skip"; + } + break; + } + } + function checkModifiers(modifiers, isConstValid) { + for (var _i = 0, modifiers_2 = modifiers; _i < modifiers_2.length; _i++) { + var modifier = modifiers_2[_i]; + switch (modifier.kind) { + case 85 /* SyntaxKind.ConstKeyword */: + if (isConstValid) { + continue; + } + // to report error, + // falls through + case 123 /* SyntaxKind.PublicKeyword */: + case 121 /* SyntaxKind.PrivateKeyword */: + case 122 /* SyntaxKind.ProtectedKeyword */: + case 146 /* SyntaxKind.ReadonlyKeyword */: + case 136 /* SyntaxKind.DeclareKeyword */: + case 126 /* SyntaxKind.AbstractKeyword */: + case 161 /* SyntaxKind.OverrideKeyword */: + case 101 /* SyntaxKind.InKeyword */: + case 145 /* SyntaxKind.OutKeyword */: + diagnostics.push(createDiagnosticForNode(modifier, ts.Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, ts.tokenToString(modifier.kind))); + break; + // These are all legal modifiers. + case 124 /* SyntaxKind.StaticKeyword */: + case 93 /* SyntaxKind.ExportKeyword */: + case 88 /* SyntaxKind.DefaultKeyword */: + case 127 /* SyntaxKind.AccessorKeyword */: + } + } + } + function createDiagnosticForNodeArray(nodes, message, arg0, arg1, arg2) { + var start = nodes.pos; + return ts.createFileDiagnostic(sourceFile, start, nodes.end - start, message, arg0, arg1, arg2); + } + // Since these are syntactic diagnostics, parent might not have been set + // this means the sourceFile cannot be infered from the node + function createDiagnosticForNode(node, message, arg0, arg1, arg2) { + return ts.createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2); + } + }); + } + function getDeclarationDiagnosticsWorker(sourceFile, cancellationToken) { + return getAndCacheDiagnostics(sourceFile, cancellationToken, cachedDeclarationDiagnosticsForFile, getDeclarationDiagnosticsForFileNoCache); + } + function getDeclarationDiagnosticsForFileNoCache(sourceFile, cancellationToken) { + return runWithCancellationToken(function () { + var resolver = getTypeChecker().getEmitResolver(sourceFile, cancellationToken); + // Don't actually write any files since we're just getting diagnostics. + return ts.getDeclarationDiagnostics(getEmitHost(ts.noop), resolver, sourceFile) || ts.emptyArray; + }); + } + function getAndCacheDiagnostics(sourceFile, cancellationToken, cache, getDiagnostics) { + var _a; + var cachedResult = sourceFile + ? (_a = cache.perFile) === null || _a === void 0 ? void 0 : _a.get(sourceFile.path) + : cache.allDiagnostics; + if (cachedResult) { + return cachedResult; + } + var result = getDiagnostics(sourceFile, cancellationToken); + if (sourceFile) { + (cache.perFile || (cache.perFile = new ts.Map())).set(sourceFile.path, result); + } + else { + cache.allDiagnostics = result; + } + return result; + } + function getDeclarationDiagnosticsForFile(sourceFile, cancellationToken) { + return sourceFile.isDeclarationFile ? [] : getDeclarationDiagnosticsWorker(sourceFile, cancellationToken); + } + function getOptionsDiagnostics() { + return ts.sortAndDeduplicateDiagnostics(ts.concatenate(programDiagnostics.getGlobalDiagnostics(), getOptionsDiagnosticsOfConfigFile())); + } + function getOptionsDiagnosticsOfConfigFile() { + if (!options.configFile) + return ts.emptyArray; + var diagnostics = programDiagnostics.getDiagnostics(options.configFile.fileName); + forEachResolvedProjectReference(function (resolvedRef) { + diagnostics = ts.concatenate(diagnostics, programDiagnostics.getDiagnostics(resolvedRef.sourceFile.fileName)); + }); + return diagnostics; + } + function getGlobalDiagnostics() { + return rootNames.length ? ts.sortAndDeduplicateDiagnostics(getTypeChecker().getGlobalDiagnostics().slice()) : ts.emptyArray; + } + function getConfigFileParsingDiagnostics() { + return configFileParsingDiagnostics || ts.emptyArray; + } + function processRootFile(fileName, isDefaultLib, ignoreNoDefaultLib, reason) { + processSourceFile(ts.normalizePath(fileName), isDefaultLib, ignoreNoDefaultLib, /*packageId*/ undefined, reason); + } + function fileReferenceIsEqualTo(a, b) { + return a.fileName === b.fileName; + } + function moduleNameIsEqualTo(a, b) { + return a.kind === 79 /* SyntaxKind.Identifier */ + ? b.kind === 79 /* SyntaxKind.Identifier */ && a.escapedText === b.escapedText + : b.kind === 10 /* SyntaxKind.StringLiteral */ && a.text === b.text; + } + function createSyntheticImport(text, file) { + var externalHelpersModuleReference = ts.factory.createStringLiteral(text); + var importDecl = ts.factory.createImportDeclaration(/*modifiers*/ undefined, /*importClause*/ undefined, externalHelpersModuleReference, /*assertClause*/ undefined); + ts.addEmitFlags(importDecl, 67108864 /* EmitFlags.NeverApplyImportHelper */); + ts.setParent(externalHelpersModuleReference, importDecl); + ts.setParent(importDecl, file); + // explicitly unset the synthesized flag on these declarations so the checker API will answer questions about them + // (which is required to build the dependency graph for incremental emit) + externalHelpersModuleReference.flags &= ~8 /* NodeFlags.Synthesized */; + importDecl.flags &= ~8 /* NodeFlags.Synthesized */; + return externalHelpersModuleReference; + } + function collectExternalModuleReferences(file) { + if (file.imports) { + return; + } + var isJavaScriptFile = ts.isSourceFileJS(file); + var isExternalModuleFile = ts.isExternalModule(file); + // file.imports may not be undefined if there exists dynamic import + var imports; + var moduleAugmentations; + var ambientModules; + // If we are importing helpers, we need to add a synthetic reference to resolve the + // helpers library. + if ((options.isolatedModules || isExternalModuleFile) + && !file.isDeclarationFile) { + if (options.importHelpers) { + // synthesize 'import "tslib"' declaration + imports = [createSyntheticImport(ts.externalHelpersModuleNameText, file)]; + } + var jsxImport = ts.getJSXRuntimeImport(ts.getJSXImplicitImportBase(options, file), options); + if (jsxImport) { + // synthesize `import "base/jsx-runtime"` declaration + (imports || (imports = [])).push(createSyntheticImport(jsxImport, file)); + } + } + for (var _i = 0, _a = file.statements; _i < _a.length; _i++) { + var node = _a[_i]; + collectModuleReferences(node, /*inAmbientModule*/ false); + } + if ((file.flags & 2097152 /* NodeFlags.PossiblyContainsDynamicImport */) || isJavaScriptFile) { + collectDynamicImportOrRequireCalls(file); + } + file.imports = imports || ts.emptyArray; + file.moduleAugmentations = moduleAugmentations || ts.emptyArray; + file.ambientModuleNames = ambientModules || ts.emptyArray; + return; + function collectModuleReferences(node, inAmbientModule) { + if (ts.isAnyImportOrReExport(node)) { + var moduleNameExpr = ts.getExternalModuleName(node); + // TypeScript 1.0 spec (April 2014): 12.1.6 + // An ExternalImportDeclaration in an AmbientExternalModuleDeclaration may reference other external modules + // only through top - level external module names. Relative external module names are not permitted. + if (moduleNameExpr && ts.isStringLiteral(moduleNameExpr) && moduleNameExpr.text && (!inAmbientModule || !ts.isExternalModuleNameRelative(moduleNameExpr.text))) { + ts.setParentRecursive(node, /*incremental*/ false); // we need parent data on imports before the program is fully bound, so we ensure it's set here + imports = ts.append(imports, moduleNameExpr); + if (!usesUriStyleNodeCoreModules && currentNodeModulesDepth === 0 && !file.isDeclarationFile) { + usesUriStyleNodeCoreModules = ts.startsWith(moduleNameExpr.text, "node:"); + } + } + } + else if (ts.isModuleDeclaration(node)) { + if (ts.isAmbientModule(node) && (inAmbientModule || ts.hasSyntacticModifier(node, 2 /* ModifierFlags.Ambient */) || file.isDeclarationFile)) { + node.name.parent = node; + var nameText = ts.getTextOfIdentifierOrLiteral(node.name); + // Ambient module declarations can be interpreted as augmentations for some existing external modules. + // This will happen in two cases: + // - if current file is external module then module augmentation is a ambient module declaration defined in the top level scope + // - if current file is not external module then module augmentation is an ambient module declaration with non-relative module name + // immediately nested in top level ambient module declaration . + if (isExternalModuleFile || (inAmbientModule && !ts.isExternalModuleNameRelative(nameText))) { + (moduleAugmentations || (moduleAugmentations = [])).push(node.name); + } + else if (!inAmbientModule) { + if (file.isDeclarationFile) { + // for global .d.ts files record name of ambient module + (ambientModules || (ambientModules = [])).push(nameText); + } + // An AmbientExternalModuleDeclaration declares an external module. + // This type of declaration is permitted only in the global module. + // The StringLiteral must specify a top - level external module name. + // Relative external module names are not permitted + // NOTE: body of ambient module is always a module block, if it exists + var body = node.body; + if (body) { + for (var _i = 0, _a = body.statements; _i < _a.length; _i++) { + var statement = _a[_i]; + collectModuleReferences(statement, /*inAmbientModule*/ true); + } + } + } + } + } + } + function collectDynamicImportOrRequireCalls(file) { + var r = /import|require/g; + while (r.exec(file.text) !== null) { // eslint-disable-line no-null/no-null + var node = getNodeAtPosition(file, r.lastIndex); + if (isJavaScriptFile && ts.isRequireCall(node, /*checkArgumentIsStringLiteralLike*/ true)) { + ts.setParentRecursive(node, /*incremental*/ false); // we need parent data on imports before the program is fully bound, so we ensure it's set here + imports = ts.append(imports, node.arguments[0]); + } + // we have to check the argument list has length of at least 1. We will still have to process these even though we have parsing error. + else if (ts.isImportCall(node) && node.arguments.length >= 1 && ts.isStringLiteralLike(node.arguments[0])) { + ts.setParentRecursive(node, /*incremental*/ false); // we need parent data on imports before the program is fully bound, so we ensure it's set here + imports = ts.append(imports, node.arguments[0]); + } + else if (ts.isLiteralImportTypeNode(node)) { + ts.setParentRecursive(node, /*incremental*/ false); // we need parent data on imports before the program is fully bound, so we ensure it's set here + imports = ts.append(imports, node.argument.literal); + } + } + } + /** Returns a token if position is in [start-of-leading-trivia, end), includes JSDoc only in JS files */ + function getNodeAtPosition(sourceFile, position) { + var current = sourceFile; + var getContainingChild = function (child) { + if (child.pos <= position && (position < child.end || (position === child.end && (child.kind === 1 /* SyntaxKind.EndOfFileToken */)))) { + return child; + } + }; + while (true) { + var child = isJavaScriptFile && ts.hasJSDocNodes(current) && ts.forEach(current.jsDoc, getContainingChild) || ts.forEachChild(current, getContainingChild); + if (!child) { + return current; + } + current = child; + } + } + } + function getLibFileFromReference(ref) { + var libName = ts.toFileNameLowerCase(ref.fileName); + var libFileName = ts.libMap.get(libName); + if (libFileName) { + return getSourceFile(pathForLibFile(libFileName)); + } + } + /** This should have similar behavior to 'processSourceFile' without diagnostics or mutation. */ + function getSourceFileFromReference(referencingFile, ref) { + return getSourceFileFromReferenceWorker(resolveTripleslashReference(ref.fileName, referencingFile.fileName), getSourceFile); + } + function getSourceFileFromReferenceWorker(fileName, getSourceFile, fail, reason) { + if (ts.hasExtension(fileName)) { + var canonicalFileName_1 = host.getCanonicalFileName(fileName); + if (!options.allowNonTsExtensions && !ts.forEach(ts.flatten(supportedExtensionsWithJsonIfResolveJsonModule), function (extension) { return ts.fileExtensionIs(canonicalFileName_1, extension); })) { + if (fail) { + if (ts.hasJSFileExtension(canonicalFileName_1)) { + fail(ts.Diagnostics.File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option, fileName); + } + else { + fail(ts.Diagnostics.File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1, fileName, "'" + ts.flatten(supportedExtensions).join("', '") + "'"); + } + } + return undefined; + } + var sourceFile = getSourceFile(fileName); + if (fail) { + if (!sourceFile) { + var redirect = getProjectReferenceRedirect(fileName); + if (redirect) { + fail(ts.Diagnostics.Output_file_0_has_not_been_built_from_source_file_1, redirect, fileName); + } + else { + fail(ts.Diagnostics.File_0_not_found, fileName); + } + } + else if (isReferencedFile(reason) && canonicalFileName_1 === host.getCanonicalFileName(getSourceFileByPath(reason.file).fileName)) { + fail(ts.Diagnostics.A_file_cannot_have_a_reference_to_itself); + } + } + return sourceFile; + } + else { + var sourceFileNoExtension = options.allowNonTsExtensions && getSourceFile(fileName); + if (sourceFileNoExtension) + return sourceFileNoExtension; + if (fail && options.allowNonTsExtensions) { + fail(ts.Diagnostics.File_0_not_found, fileName); + return undefined; + } + // Only try adding extensions from the first supported group (which should be .ts/.tsx/.d.ts) + var sourceFileWithAddedExtension = ts.forEach(supportedExtensions[0], function (extension) { return getSourceFile(fileName + extension); }); + if (fail && !sourceFileWithAddedExtension) + fail(ts.Diagnostics.Could_not_resolve_the_path_0_with_the_extensions_Colon_1, fileName, "'" + ts.flatten(supportedExtensions).join("', '") + "'"); + return sourceFileWithAddedExtension; + } + } + /** This has side effects through `findSourceFile`. */ + function processSourceFile(fileName, isDefaultLib, ignoreNoDefaultLib, packageId, reason) { + getSourceFileFromReferenceWorker(fileName, function (fileName) { return findSourceFile(fileName, isDefaultLib, ignoreNoDefaultLib, reason, packageId); }, // TODO: GH#18217 + function (diagnostic) { + var args = []; + for (var _i = 1; _i < arguments.length; _i++) { + args[_i - 1] = arguments[_i]; + } + return addFilePreprocessingFileExplainingDiagnostic(/*file*/ undefined, reason, diagnostic, args); + }, reason); + } + function processProjectReferenceFile(fileName, reason) { + return processSourceFile(fileName, /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false, /*packageId*/ undefined, reason); + } + function reportFileNamesDifferOnlyInCasingError(fileName, existingFile, reason) { + var hasExistingReasonToReportErrorOn = !isReferencedFile(reason) && ts.some(fileReasons.get(existingFile.path), isReferencedFile); + if (hasExistingReasonToReportErrorOn) { + addFilePreprocessingFileExplainingDiagnostic(existingFile, reason, ts.Diagnostics.Already_included_file_name_0_differs_from_file_name_1_only_in_casing, [existingFile.fileName, fileName]); + } + else { + addFilePreprocessingFileExplainingDiagnostic(existingFile, reason, ts.Diagnostics.File_name_0_differs_from_already_included_file_name_1_only_in_casing, [fileName, existingFile.fileName]); + } + } + function createRedirectSourceFile(redirectTarget, unredirected, fileName, path, resolvedPath, originalFileName, sourceFileOptions) { + var _a; + var redirect = Object.create(redirectTarget); + redirect.fileName = fileName; + redirect.path = path; + redirect.resolvedPath = resolvedPath; + redirect.originalFileName = originalFileName; + redirect.redirectInfo = { redirectTarget: redirectTarget, unredirected: unredirected }; + redirect.packageJsonLocations = ((_a = sourceFileOptions.packageJsonLocations) === null || _a === void 0 ? void 0 : _a.length) ? sourceFileOptions.packageJsonLocations : undefined; + redirect.packageJsonScope = sourceFileOptions.packageJsonScope; + sourceFilesFoundSearchingNodeModules.set(path, currentNodeModulesDepth > 0); + Object.defineProperties(redirect, { + id: { + get: function () { return this.redirectInfo.redirectTarget.id; }, + set: function (value) { this.redirectInfo.redirectTarget.id = value; }, + }, + symbol: { + get: function () { return this.redirectInfo.redirectTarget.symbol; }, + set: function (value) { this.redirectInfo.redirectTarget.symbol = value; }, + }, + }); + return redirect; + } + // Get source file from normalized fileName + function findSourceFile(fileName, isDefaultLib, ignoreNoDefaultLib, reason, packageId) { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* tracing.Phase.Program */, "findSourceFile", { + fileName: fileName, + isDefaultLib: isDefaultLib || undefined, + fileIncludeKind: ts.FileIncludeKind[reason.kind], + }); + var result = findSourceFileWorker(fileName, isDefaultLib, ignoreNoDefaultLib, reason, packageId); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + return result; + } + function getCreateSourceFileOptions(fileName, moduleResolutionCache, host, options) { + // It's a _little odd_ that we can't set `impliedNodeFormat` until the program step - but it's the first and only time we have a resolution cache + // and a freshly made source file node on hand at the same time, and we need both to set the field. Persisting the resolution cache all the way + // to the check and emit steps would be bad - so we much prefer detecting and storing the format information on the source file node upfront. + var result = getImpliedNodeFormatForFileWorker(ts.getNormalizedAbsolutePath(fileName, currentDirectory), moduleResolutionCache === null || moduleResolutionCache === void 0 ? void 0 : moduleResolutionCache.getPackageJsonInfoCache(), host, options); + var languageVersion = ts.getEmitScriptTarget(options); + var setExternalModuleIndicator = ts.getSetExternalModuleIndicator(options); + return typeof result === "object" ? __assign(__assign({}, result), { languageVersion: languageVersion, setExternalModuleIndicator: setExternalModuleIndicator }) : + { languageVersion: languageVersion, impliedNodeFormat: result, setExternalModuleIndicator: setExternalModuleIndicator }; + } + function findSourceFileWorker(fileName, isDefaultLib, ignoreNoDefaultLib, reason, packageId) { + var _a, _b; + var path = toPath(fileName); + if (useSourceOfProjectReferenceRedirect) { + var source = getSourceOfProjectReferenceRedirect(path); + // If preserveSymlinks is true, module resolution wont jump the symlink + // but the resolved real path may be the .d.ts from project reference + // Note:: Currently we try the real path only if the + // file is from node_modules to avoid having to run real path on all file paths + if (!source && + host.realpath && + options.preserveSymlinks && + ts.isDeclarationFileName(fileName) && + ts.stringContains(fileName, ts.nodeModulesPathPart)) { + var realPath = toPath(host.realpath(fileName)); + if (realPath !== path) + source = getSourceOfProjectReferenceRedirect(realPath); + } + if (source) { + var file_1 = ts.isString(source) ? + findSourceFile(source, isDefaultLib, ignoreNoDefaultLib, reason, packageId) : + undefined; + if (file_1) + addFileToFilesByName(file_1, path, /*redirectedPath*/ undefined); + return file_1; + } + } + var originalFileName = fileName; + if (filesByName.has(path)) { + var file_2 = filesByName.get(path); + addFileIncludeReason(file_2 || undefined, reason); + // try to check if we've already seen this file but with a different casing in path + // NOTE: this only makes sense for case-insensitive file systems, and only on files which are not redirected + if (file_2 && options.forceConsistentCasingInFileNames) { + var checkedName = file_2.fileName; + var isRedirect = toPath(checkedName) !== toPath(fileName); + if (isRedirect) { + fileName = getProjectReferenceRedirect(fileName) || fileName; + } + // Check if it differs only in drive letters its ok to ignore that error: + var checkedAbsolutePath = ts.getNormalizedAbsolutePathWithoutRoot(checkedName, currentDirectory); + var inputAbsolutePath = ts.getNormalizedAbsolutePathWithoutRoot(fileName, currentDirectory); + if (checkedAbsolutePath !== inputAbsolutePath) { + reportFileNamesDifferOnlyInCasingError(fileName, file_2, reason); + } + } + // If the file was previously found via a node_modules search, but is now being processed as a root file, + // then everything it sucks in may also be marked incorrectly, and needs to be checked again. + if (file_2 && sourceFilesFoundSearchingNodeModules.get(file_2.path) && currentNodeModulesDepth === 0) { + sourceFilesFoundSearchingNodeModules.set(file_2.path, false); + if (!options.noResolve) { + processReferencedFiles(file_2, isDefaultLib); + processTypeReferenceDirectives(file_2); + } + if (!options.noLib) { + processLibReferenceDirectives(file_2); + } + modulesWithElidedImports.set(file_2.path, false); + processImportedModules(file_2); + } + // See if we need to reprocess the imports due to prior skipped imports + else if (file_2 && modulesWithElidedImports.get(file_2.path)) { + if (currentNodeModulesDepth < maxNodeModuleJsDepth) { + modulesWithElidedImports.set(file_2.path, false); + processImportedModules(file_2); + } + } + return file_2 || undefined; + } + var redirectedPath; + if (isReferencedFile(reason) && !useSourceOfProjectReferenceRedirect) { + var redirectProject = getProjectReferenceRedirectProject(fileName); + if (redirectProject) { + if (ts.outFile(redirectProject.commandLine.options)) { + // Shouldnt create many to 1 mapping file in --out scenario + return undefined; + } + var redirect = getProjectReferenceOutputName(redirectProject, fileName); + fileName = redirect; + // Once we start redirecting to a file, we can potentially come back to it + // via a back-reference from another file in the .d.ts folder. If that happens we'll + // end up trying to add it to the program *again* because we were tracking it via its + // original (un-redirected) name. So we have to map both the original path and the redirected path + // to the source file we're about to find/create + redirectedPath = toPath(redirect); + } + } + // We haven't looked for this file, do so now and cache result + var sourceFileOptions = getCreateSourceFileOptions(fileName, moduleResolutionCache, host, options); + var file = host.getSourceFile(fileName, sourceFileOptions, function (hostErrorMessage) { return addFilePreprocessingFileExplainingDiagnostic(/*file*/ undefined, reason, ts.Diagnostics.Cannot_read_file_0_Colon_1, [fileName, hostErrorMessage]); }, shouldCreateNewSourceFile || (((_a = oldProgram === null || oldProgram === void 0 ? void 0 : oldProgram.getSourceFileByPath(toPath(fileName))) === null || _a === void 0 ? void 0 : _a.impliedNodeFormat) !== sourceFileOptions.impliedNodeFormat)); + if (packageId) { + var packageIdKey = ts.packageIdToString(packageId); + var fileFromPackageId = packageIdToSourceFile.get(packageIdKey); + if (fileFromPackageId) { + // Some other SourceFile already exists with this package name and version. + // Instead of creating a duplicate, just redirect to the existing one. + var dupFile = createRedirectSourceFile(fileFromPackageId, file, fileName, path, toPath(fileName), originalFileName, sourceFileOptions); + redirectTargetsMap.add(fileFromPackageId.path, fileName); + addFileToFilesByName(dupFile, path, redirectedPath); + addFileIncludeReason(dupFile, reason); + sourceFileToPackageName.set(path, ts.packageIdToPackageName(packageId)); + processingOtherFiles.push(dupFile); + return dupFile; + } + else if (file) { + // This is the first source file to have this packageId. + packageIdToSourceFile.set(packageIdKey, file); + sourceFileToPackageName.set(path, ts.packageIdToPackageName(packageId)); + } + } + addFileToFilesByName(file, path, redirectedPath); + if (file) { + sourceFilesFoundSearchingNodeModules.set(path, currentNodeModulesDepth > 0); + file.fileName = fileName; // Ensure that source file has same name as what we were looking for + file.path = path; + file.resolvedPath = toPath(fileName); + file.originalFileName = originalFileName; + file.packageJsonLocations = ((_b = sourceFileOptions.packageJsonLocations) === null || _b === void 0 ? void 0 : _b.length) ? sourceFileOptions.packageJsonLocations : undefined; + file.packageJsonScope = sourceFileOptions.packageJsonScope; + addFileIncludeReason(file, reason); + if (host.useCaseSensitiveFileNames()) { + var pathLowerCase = ts.toFileNameLowerCase(path); + // for case-sensitive file systems check if we've already seen some file with similar filename ignoring case + var existingFile = filesByNameIgnoreCase.get(pathLowerCase); + if (existingFile) { + reportFileNamesDifferOnlyInCasingError(fileName, existingFile, reason); + } + else { + filesByNameIgnoreCase.set(pathLowerCase, file); + } + } + skipDefaultLib = skipDefaultLib || (file.hasNoDefaultLib && !ignoreNoDefaultLib); + if (!options.noResolve) { + processReferencedFiles(file, isDefaultLib); + processTypeReferenceDirectives(file); + } + if (!options.noLib) { + processLibReferenceDirectives(file); + } + // always process imported modules to record module name resolutions + processImportedModules(file); + if (isDefaultLib) { + processingDefaultLibFiles.push(file); + } + else { + processingOtherFiles.push(file); + } + } + return file; + } + function addFileIncludeReason(file, reason) { + if (file) + fileReasons.add(file.path, reason); + } + function addFileToFilesByName(file, path, redirectedPath) { + if (redirectedPath) { + filesByName.set(redirectedPath, file); + filesByName.set(path, file || false); + } + else { + filesByName.set(path, file); + } + } + function getProjectReferenceRedirect(fileName) { + var referencedProject = getProjectReferenceRedirectProject(fileName); + return referencedProject && getProjectReferenceOutputName(referencedProject, fileName); + } + function getProjectReferenceRedirectProject(fileName) { + // Ignore dts or any json files + if (!resolvedProjectReferences || !resolvedProjectReferences.length || ts.isDeclarationFileName(fileName) || ts.fileExtensionIs(fileName, ".json" /* Extension.Json */)) { + return undefined; + } + // If this file is produced by a referenced project, we need to rewrite it to + // look in the output folder of the referenced project rather than the input + return getResolvedProjectReferenceToRedirect(fileName); + } + function getProjectReferenceOutputName(referencedProject, fileName) { + var out = ts.outFile(referencedProject.commandLine.options); + return out ? + ts.changeExtension(out, ".d.ts" /* Extension.Dts */) : + ts.getOutputDeclarationFileName(fileName, referencedProject.commandLine, !host.useCaseSensitiveFileNames()); + } + /** + * Get the referenced project if the file is input file from that reference project + */ + function getResolvedProjectReferenceToRedirect(fileName) { + if (mapFromFileToProjectReferenceRedirects === undefined) { + mapFromFileToProjectReferenceRedirects = new ts.Map(); + forEachResolvedProjectReference(function (referencedProject) { + // not input file from the referenced project, ignore + if (toPath(options.configFilePath) !== referencedProject.sourceFile.path) { + referencedProject.commandLine.fileNames.forEach(function (f) { + return mapFromFileToProjectReferenceRedirects.set(toPath(f), referencedProject.sourceFile.path); + }); + } + }); + } + var referencedProjectPath = mapFromFileToProjectReferenceRedirects.get(toPath(fileName)); + return referencedProjectPath && getResolvedProjectReferenceByPath(referencedProjectPath); + } + function forEachResolvedProjectReference(cb) { + return ts.forEachResolvedProjectReference(resolvedProjectReferences, cb); + } + function getSourceOfProjectReferenceRedirect(path) { + if (!ts.isDeclarationFileName(path)) + return undefined; + if (mapFromToProjectReferenceRedirectSource === undefined) { + mapFromToProjectReferenceRedirectSource = new ts.Map(); + forEachResolvedProjectReference(function (resolvedRef) { + var out = ts.outFile(resolvedRef.commandLine.options); + if (out) { + // Dont know which source file it means so return true? + var outputDts = ts.changeExtension(out, ".d.ts" /* Extension.Dts */); + mapFromToProjectReferenceRedirectSource.set(toPath(outputDts), true); + } + else { + var getCommonSourceDirectory_3 = ts.memoize(function () { return ts.getCommonSourceDirectoryOfConfig(resolvedRef.commandLine, !host.useCaseSensitiveFileNames()); }); + ts.forEach(resolvedRef.commandLine.fileNames, function (fileName) { + if (!ts.isDeclarationFileName(fileName) && !ts.fileExtensionIs(fileName, ".json" /* Extension.Json */)) { + var outputDts = ts.getOutputDeclarationFileName(fileName, resolvedRef.commandLine, !host.useCaseSensitiveFileNames(), getCommonSourceDirectory_3); + mapFromToProjectReferenceRedirectSource.set(toPath(outputDts), fileName); + } + }); + } + }); + } + return mapFromToProjectReferenceRedirectSource.get(path); + } + function isSourceOfProjectReferenceRedirect(fileName) { + return useSourceOfProjectReferenceRedirect && !!getResolvedProjectReferenceToRedirect(fileName); + } + function getResolvedProjectReferenceByPath(projectReferencePath) { + if (!projectReferenceRedirects) { + return undefined; + } + return projectReferenceRedirects.get(projectReferencePath) || undefined; + } + function processReferencedFiles(file, isDefaultLib) { + ts.forEach(file.referencedFiles, function (ref, index) { + processSourceFile(resolveTripleslashReference(ref.fileName, file.fileName), isDefaultLib, + /*ignoreNoDefaultLib*/ false, + /*packageId*/ undefined, { kind: ts.FileIncludeKind.ReferenceFile, file: file.path, index: index, }); + }); + } + function processTypeReferenceDirectives(file) { + var typeDirectives = file.typeReferenceDirectives; + if (!typeDirectives) { + return; + } + var resolutions = resolveTypeReferenceDirectiveNamesWorker(typeDirectives, file); + for (var index = 0; index < typeDirectives.length; index++) { + var ref = file.typeReferenceDirectives[index]; + var resolvedTypeReferenceDirective = resolutions[index]; + // store resolved type directive on the file + var fileName = ts.toFileNameLowerCase(ref.fileName); + ts.setResolvedTypeReferenceDirective(file, fileName, resolvedTypeReferenceDirective); + var mode = ref.resolutionMode || file.impliedNodeFormat; + if (mode && ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.Node16 && ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.NodeNext) { + programDiagnostics.add(ts.createDiagnosticForRange(file, ref, ts.Diagnostics.resolution_mode_assertions_are_only_supported_when_moduleResolution_is_node16_or_nodenext)); + } + processTypeReferenceDirective(fileName, mode, resolvedTypeReferenceDirective, { kind: ts.FileIncludeKind.TypeReferenceDirective, file: file.path, index: index, }); + } + } + function processTypeReferenceDirective(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason) { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("program" /* tracing.Phase.Program */, "processTypeReferenceDirective", { directive: typeReferenceDirective, hasResolved: !!resolvedTypeReferenceDirective, refKind: reason.kind, refPath: isReferencedFile(reason) ? reason.file : undefined }); + processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason); + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop(); + } + function processTypeReferenceDirectiveWorker(typeReferenceDirective, mode, resolvedTypeReferenceDirective, reason) { + // If we already found this library as a primary reference - nothing to do + var previousResolution = resolvedTypeReferenceDirectives.get(typeReferenceDirective, mode); + if (previousResolution && previousResolution.primary) { + return; + } + var saveResolution = true; + if (resolvedTypeReferenceDirective) { + if (resolvedTypeReferenceDirective.isExternalLibraryImport) + currentNodeModulesDepth++; + if (resolvedTypeReferenceDirective.primary) { + // resolved from the primary path + processSourceFile(resolvedTypeReferenceDirective.resolvedFileName, /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false, resolvedTypeReferenceDirective.packageId, reason); // TODO: GH#18217 + } + else { + // If we already resolved to this file, it must have been a secondary reference. Check file contents + // for sameness and possibly issue an error + if (previousResolution) { + // Don't bother reading the file again if it's the same file. + if (resolvedTypeReferenceDirective.resolvedFileName !== previousResolution.resolvedFileName) { + var otherFileText = host.readFile(resolvedTypeReferenceDirective.resolvedFileName); + var existingFile = getSourceFile(previousResolution.resolvedFileName); + if (otherFileText !== existingFile.text) { + addFilePreprocessingFileExplainingDiagnostic(existingFile, reason, ts.Diagnostics.Conflicting_definitions_for_0_found_at_1_and_2_Consider_installing_a_specific_version_of_this_library_to_resolve_the_conflict, [typeReferenceDirective, resolvedTypeReferenceDirective.resolvedFileName, previousResolution.resolvedFileName]); + } + } + // don't overwrite previous resolution result + saveResolution = false; + } + else { + // First resolution of this library + processSourceFile(resolvedTypeReferenceDirective.resolvedFileName, /*isDefaultLib*/ false, /*ignoreNoDefaultLib*/ false, resolvedTypeReferenceDirective.packageId, reason); + } + } + if (resolvedTypeReferenceDirective.isExternalLibraryImport) + currentNodeModulesDepth--; + } + else { + addFilePreprocessingFileExplainingDiagnostic(/*file*/ undefined, reason, ts.Diagnostics.Cannot_find_type_definition_file_for_0, [typeReferenceDirective]); + } + if (saveResolution) { + resolvedTypeReferenceDirectives.set(typeReferenceDirective, mode, resolvedTypeReferenceDirective); + } + } + function pathForLibFile(libFileName) { + // Support resolving to lib.dom.d.ts -> @typescript/lib-dom, and + // lib.dom.iterable.d.ts -> @typescript/lib-dom/iterable + // lib.es2015.symbol.wellknown.d.ts -> @typescript/lib-es2015/symbol-wellknown + var components = libFileName.split("."); + var path = components[1]; + var i = 2; + while (components[i] && components[i] !== "d") { + path += (i === 2 ? "/" : "-") + components[i]; + i++; + } + var resolveFrom = ts.combinePaths(currentDirectory, "__lib_node_modules_lookup_".concat(libFileName, "__.ts")); + var localOverrideModuleResult = ts.resolveModuleName("@typescript/lib-" + path, resolveFrom, { moduleResolution: ts.ModuleResolutionKind.NodeJs }, host, moduleResolutionCache); + if (localOverrideModuleResult === null || localOverrideModuleResult === void 0 ? void 0 : localOverrideModuleResult.resolvedModule) { + return localOverrideModuleResult.resolvedModule.resolvedFileName; + } + return ts.combinePaths(defaultLibraryPath, libFileName); + } + function processLibReferenceDirectives(file) { + ts.forEach(file.libReferenceDirectives, function (libReference, index) { + var libName = ts.toFileNameLowerCase(libReference.fileName); + var libFileName = ts.libMap.get(libName); + if (libFileName) { + // we ignore any 'no-default-lib' reference set on this file. + processRootFile(pathForLibFile(libFileName), /*isDefaultLib*/ true, /*ignoreNoDefaultLib*/ true, { kind: ts.FileIncludeKind.LibReferenceDirective, file: file.path, index: index, }); + } + else { + var unqualifiedLibName = ts.removeSuffix(ts.removePrefix(libName, "lib."), ".d.ts"); + var suggestion = ts.getSpellingSuggestion(unqualifiedLibName, ts.libs, ts.identity); + var diagnostic = suggestion ? ts.Diagnostics.Cannot_find_lib_definition_for_0_Did_you_mean_1 : ts.Diagnostics.Cannot_find_lib_definition_for_0; + (fileProcessingDiagnostics || (fileProcessingDiagnostics = [])).push({ + kind: 0 /* FilePreprocessingDiagnosticsKind.FilePreprocessingReferencedDiagnostic */, + reason: { kind: ts.FileIncludeKind.LibReferenceDirective, file: file.path, index: index, }, + diagnostic: diagnostic, + args: [libName, suggestion] + }); + } + }); + } + function getCanonicalFileName(fileName) { + return host.getCanonicalFileName(fileName); + } + function processImportedModules(file) { + var _a; + collectExternalModuleReferences(file); + if (file.imports.length || file.moduleAugmentations.length) { + // Because global augmentation doesn't have string literal name, we can check for global augmentation as such. + var moduleNames = getModuleNames(file); + var resolutions = resolveModuleNamesReusingOldState(moduleNames, file); + ts.Debug.assert(resolutions.length === moduleNames.length); + var optionsForFile = (useSourceOfProjectReferenceRedirect ? (_a = getRedirectReferenceForResolution(file)) === null || _a === void 0 ? void 0 : _a.commandLine.options : undefined) || options; + for (var index = 0; index < moduleNames.length; index++) { + var resolution = resolutions[index]; + ts.setResolvedModule(file, moduleNames[index], resolution, getModeForResolutionAtIndex(file, index)); + if (!resolution) { + continue; + } + var isFromNodeModulesSearch = resolution.isExternalLibraryImport; + var isJsFile = !ts.resolutionExtensionIsTSOrJson(resolution.extension); + var isJsFileFromNodeModules = isFromNodeModulesSearch && isJsFile; + var resolvedFileName = resolution.resolvedFileName; + if (isFromNodeModulesSearch) { + currentNodeModulesDepth++; + } + // add file to program only if: + // - resolution was successful + // - noResolve is falsy + // - module name comes from the list of imports + // - it's not a top level JavaScript module that exceeded the search max + var elideImport = isJsFileFromNodeModules && currentNodeModulesDepth > maxNodeModuleJsDepth; + // Don't add the file if it has a bad extension (e.g. 'tsx' if we don't have '--allowJs') + // This may still end up being an untyped module -- the file won't be included but imports will be allowed. + var shouldAddFile = resolvedFileName + && !getResolutionDiagnostic(optionsForFile, resolution) + && !optionsForFile.noResolve + && index < file.imports.length + && !elideImport + && !(isJsFile && !ts.getAllowJSCompilerOption(optionsForFile)) + && (ts.isInJSFile(file.imports[index]) || !(file.imports[index].flags & 8388608 /* NodeFlags.JSDoc */)); + if (elideImport) { + modulesWithElidedImports.set(file.path, true); + } + else if (shouldAddFile) { + findSourceFile(resolvedFileName, + /*isDefaultLib*/ false, + /*ignoreNoDefaultLib*/ false, { kind: ts.FileIncludeKind.Import, file: file.path, index: index, }, resolution.packageId); + } + if (isFromNodeModulesSearch) { + currentNodeModulesDepth--; + } + } + } + else { + // no imports - drop cached module resolutions + file.resolvedModules = undefined; + } + } + function checkSourceFilesBelongToPath(sourceFiles, rootDirectory) { + var allFilesBelongToPath = true; + var absoluteRootDirectoryPath = host.getCanonicalFileName(ts.getNormalizedAbsolutePath(rootDirectory, currentDirectory)); + for (var _i = 0, sourceFiles_2 = sourceFiles; _i < sourceFiles_2.length; _i++) { + var sourceFile = sourceFiles_2[_i]; + if (!sourceFile.isDeclarationFile) { + var absoluteSourceFilePath = host.getCanonicalFileName(ts.getNormalizedAbsolutePath(sourceFile.fileName, currentDirectory)); + if (absoluteSourceFilePath.indexOf(absoluteRootDirectoryPath) !== 0) { + addProgramDiagnosticExplainingFile(sourceFile, ts.Diagnostics.File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files, [sourceFile.fileName, rootDirectory]); + allFilesBelongToPath = false; + } + } + } + return allFilesBelongToPath; + } + function parseProjectReferenceConfigFile(ref) { + if (!projectReferenceRedirects) { + projectReferenceRedirects = new ts.Map(); + } + // The actual filename (i.e. add "/tsconfig.json" if necessary) + var refPath = resolveProjectReferencePath(ref); + var sourceFilePath = toPath(refPath); + var fromCache = projectReferenceRedirects.get(sourceFilePath); + if (fromCache !== undefined) { + return fromCache || undefined; + } + var commandLine; + var sourceFile; + if (host.getParsedCommandLine) { + commandLine = host.getParsedCommandLine(refPath); + if (!commandLine) { + addFileToFilesByName(/*sourceFile*/ undefined, sourceFilePath, /*redirectedPath*/ undefined); + projectReferenceRedirects.set(sourceFilePath, false); + return undefined; + } + sourceFile = ts.Debug.checkDefined(commandLine.options.configFile); + ts.Debug.assert(!sourceFile.path || sourceFile.path === sourceFilePath); + addFileToFilesByName(sourceFile, sourceFilePath, /*redirectedPath*/ undefined); + } + else { + // An absolute path pointing to the containing directory of the config file + var basePath = ts.getNormalizedAbsolutePath(ts.getDirectoryPath(refPath), host.getCurrentDirectory()); + sourceFile = host.getSourceFile(refPath, 100 /* ScriptTarget.JSON */); + addFileToFilesByName(sourceFile, sourceFilePath, /*redirectedPath*/ undefined); + if (sourceFile === undefined) { + projectReferenceRedirects.set(sourceFilePath, false); + return undefined; + } + commandLine = ts.parseJsonSourceFileConfigFileContent(sourceFile, configParsingHost, basePath, /*existingOptions*/ undefined, refPath); + } + sourceFile.fileName = refPath; + sourceFile.path = sourceFilePath; + sourceFile.resolvedPath = sourceFilePath; + sourceFile.originalFileName = refPath; + var resolvedRef = { commandLine: commandLine, sourceFile: sourceFile }; + projectReferenceRedirects.set(sourceFilePath, resolvedRef); + if (commandLine.projectReferences) { + resolvedRef.references = commandLine.projectReferences.map(parseProjectReferenceConfigFile); + } + return resolvedRef; + } + function verifyCompilerOptions() { + if (options.strictPropertyInitialization && !ts.getStrictOptionValue(options, "strictNullChecks")) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "strictPropertyInitialization", "strictNullChecks"); + } + if (options.exactOptionalPropertyTypes && !ts.getStrictOptionValue(options, "strictNullChecks")) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "exactOptionalPropertyTypes", "strictNullChecks"); + } + if (options.isolatedModules) { + if (options.out) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "out", "isolatedModules"); + } + if (options.outFile) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "outFile", "isolatedModules"); + } + } + if (options.inlineSourceMap) { + if (options.sourceMap) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "sourceMap", "inlineSourceMap"); + } + if (options.mapRoot) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "mapRoot", "inlineSourceMap"); + } + } + if (options.composite) { + if (options.declaration === false) { + createDiagnosticForOptionName(ts.Diagnostics.Composite_projects_may_not_disable_declaration_emit, "declaration"); + } + if (options.incremental === false) { + createDiagnosticForOptionName(ts.Diagnostics.Composite_projects_may_not_disable_incremental_compilation, "declaration"); + } + } + var outputFile = ts.outFile(options); + if (options.tsBuildInfoFile) { + if (!ts.isIncrementalCompilation(options)) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "tsBuildInfoFile", "incremental", "composite"); + } + } + else if (options.incremental && !outputFile && !options.configFilePath) { + programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_incremental_can_only_be_specified_using_tsconfig_emitting_to_single_file_or_when_option_tsBuildInfoFile_is_specified)); + } + verifyProjectReferences(); + // List of collected files is complete; validate exhautiveness if this is a project with a file list + if (options.composite) { + var rootPaths = new ts.Set(rootNames.map(toPath)); + for (var _i = 0, files_4 = files; _i < files_4.length; _i++) { + var file = files_4[_i]; + // Ignore file that is not emitted + if (ts.sourceFileMayBeEmitted(file, program) && !rootPaths.has(file.path)) { + addProgramDiagnosticExplainingFile(file, ts.Diagnostics.File_0_is_not_listed_within_the_file_list_of_project_1_Projects_must_list_all_files_or_use_an_include_pattern, [file.fileName, options.configFilePath || ""]); + } + } + } + if (options.paths) { + for (var key in options.paths) { + if (!ts.hasProperty(options.paths, key)) { + continue; + } + if (!ts.hasZeroOrOneAsteriskCharacter(key)) { + createDiagnosticForOptionPaths(/*onKey*/ true, key, ts.Diagnostics.Pattern_0_can_have_at_most_one_Asterisk_character, key); + } + if (ts.isArray(options.paths[key])) { + var len = options.paths[key].length; + if (len === 0) { + createDiagnosticForOptionPaths(/*onKey*/ false, key, ts.Diagnostics.Substitutions_for_pattern_0_shouldn_t_be_an_empty_array, key); + } + for (var i = 0; i < len; i++) { + var subst = options.paths[key][i]; + var typeOfSubst = typeof subst; + if (typeOfSubst === "string") { + if (!ts.hasZeroOrOneAsteriskCharacter(subst)) { + createDiagnosticForOptionPathKeyValue(key, i, ts.Diagnostics.Substitution_0_in_pattern_1_can_have_at_most_one_Asterisk_character, subst, key); + } + if (!options.baseUrl && !ts.pathIsRelative(subst) && !ts.pathIsAbsolute(subst)) { + createDiagnosticForOptionPathKeyValue(key, i, ts.Diagnostics.Non_relative_paths_are_not_allowed_when_baseUrl_is_not_set_Did_you_forget_a_leading_Slash); + } + } + else { + createDiagnosticForOptionPathKeyValue(key, i, ts.Diagnostics.Substitution_0_for_pattern_1_has_incorrect_type_expected_string_got_2, subst, key, typeOfSubst); + } + } + } + else { + createDiagnosticForOptionPaths(/*onKey*/ false, key, ts.Diagnostics.Substitutions_for_pattern_0_should_be_an_array, key); + } + } + } + if (!options.sourceMap && !options.inlineSourceMap) { + if (options.inlineSources) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided, "inlineSources"); + } + if (options.sourceRoot) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided, "sourceRoot"); + } + } + if (options.out && options.outFile) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "out", "outFile"); + } + if (options.mapRoot && !(options.sourceMap || options.declarationMap)) { + // Error to specify --mapRoot without --sourcemap + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "mapRoot", "sourceMap", "declarationMap"); + } + if (options.declarationDir) { + if (!ts.getEmitDeclarations(options)) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "declarationDir", "declaration", "composite"); + } + if (outputFile) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "declarationDir", options.out ? "out" : "outFile"); + } + } + if (options.declarationMap && !ts.getEmitDeclarations(options)) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "declarationMap", "declaration", "composite"); + } + if (options.lib && options.noLib) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "lib", "noLib"); + } + if (options.noImplicitUseStrict && ts.getStrictOptionValue(options, "alwaysStrict")) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "noImplicitUseStrict", "alwaysStrict"); + } + var languageVersion = ts.getEmitScriptTarget(options); + var firstNonAmbientExternalModuleSourceFile = ts.find(files, function (f) { return ts.isExternalModule(f) && !f.isDeclarationFile; }); + if (options.isolatedModules) { + if (options.module === ts.ModuleKind.None && languageVersion < 2 /* ScriptTarget.ES2015 */) { + createDiagnosticForOptionName(ts.Diagnostics.Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES2015_or_higher, "isolatedModules", "target"); + } + if (options.preserveConstEnums === false) { + createDiagnosticForOptionName(ts.Diagnostics.Option_preserveConstEnums_cannot_be_disabled_when_isolatedModules_is_enabled, "preserveConstEnums", "isolatedModules"); + } + for (var _a = 0, files_5 = files; _a < files_5.length; _a++) { + var file = files_5[_a]; + if (!ts.isExternalModule(file) && !ts.isSourceFileJS(file) && !file.isDeclarationFile && file.scriptKind !== 6 /* ScriptKind.JSON */) { + var span = ts.getErrorSpanForNode(file, file); + programDiagnostics.add(ts.createFileDiagnostic(file, span.start, span.length, ts.Diagnostics._0_cannot_be_compiled_under_isolatedModules_because_it_is_considered_a_global_script_file_Add_an_import_export_or_an_empty_export_statement_to_make_it_a_module, ts.getBaseFileName(file.fileName))); + } + } + } + else if (firstNonAmbientExternalModuleSourceFile && languageVersion < 2 /* ScriptTarget.ES2015 */ && options.module === ts.ModuleKind.None) { + // We cannot use createDiagnosticFromNode because nodes do not have parents yet + var span = ts.getErrorSpanForNode(firstNonAmbientExternalModuleSourceFile, typeof firstNonAmbientExternalModuleSourceFile.externalModuleIndicator === "boolean" ? firstNonAmbientExternalModuleSourceFile : firstNonAmbientExternalModuleSourceFile.externalModuleIndicator); + programDiagnostics.add(ts.createFileDiagnostic(firstNonAmbientExternalModuleSourceFile, span.start, span.length, ts.Diagnostics.Cannot_use_imports_exports_or_module_augmentations_when_module_is_none)); + } + // Cannot specify module gen that isn't amd or system with --out + if (outputFile && !options.emitDeclarationOnly) { + if (options.module && !(options.module === ts.ModuleKind.AMD || options.module === ts.ModuleKind.System)) { + createDiagnosticForOptionName(ts.Diagnostics.Only_amd_and_system_modules_are_supported_alongside_0, options.out ? "out" : "outFile", "module"); + } + else if (options.module === undefined && firstNonAmbientExternalModuleSourceFile) { + var span = ts.getErrorSpanForNode(firstNonAmbientExternalModuleSourceFile, typeof firstNonAmbientExternalModuleSourceFile.externalModuleIndicator === "boolean" ? firstNonAmbientExternalModuleSourceFile : firstNonAmbientExternalModuleSourceFile.externalModuleIndicator); + programDiagnostics.add(ts.createFileDiagnostic(firstNonAmbientExternalModuleSourceFile, span.start, span.length, ts.Diagnostics.Cannot_compile_modules_using_option_0_unless_the_module_flag_is_amd_or_system, options.out ? "out" : "outFile")); + } + } + if (options.resolveJsonModule) { + if (ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.NodeJs && + ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.Node16 && + ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.NodeNext) { + createDiagnosticForOptionName(ts.Diagnostics.Option_resolveJsonModule_cannot_be_specified_without_node_module_resolution_strategy, "resolveJsonModule"); + } + // Any emit other than common js, amd, es2015 or esnext is error + else if (!ts.hasJsonModuleEmitEnabled(options)) { + createDiagnosticForOptionName(ts.Diagnostics.Option_resolveJsonModule_can_only_be_specified_when_module_code_generation_is_commonjs_amd_es2015_or_esNext, "resolveJsonModule", "module"); + } + } + // there has to be common source directory if user specified --outdir || --rootDir || --sourceRoot + // if user specified --mapRoot, there needs to be common source directory if there would be multiple files being emitted + if (options.outDir || // there is --outDir specified + options.rootDir || // there is --rootDir specified + options.sourceRoot || // there is --sourceRoot specified + options.mapRoot) { // there is --mapRoot specified + // Precalculate and cache the common source directory + var dir = getCommonSourceDirectory(); + // If we failed to find a good common directory, but outDir is specified and at least one of our files is on a windows drive/URL/other resource, add a failure + if (options.outDir && dir === "" && files.some(function (file) { return ts.getRootLength(file.fileName) > 1; })) { + createDiagnosticForOptionName(ts.Diagnostics.Cannot_find_the_common_subdirectory_path_for_the_input_files, "outDir"); + } + } + if (options.useDefineForClassFields && languageVersion === 0 /* ScriptTarget.ES3 */) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_when_option_target_is_ES3, "useDefineForClassFields"); + } + if (options.checkJs && !ts.getAllowJSCompilerOption(options)) { + programDiagnostics.add(ts.createCompilerDiagnostic(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "checkJs", "allowJs")); + } + if (options.emitDeclarationOnly) { + if (!ts.getEmitDeclarations(options)) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1_or_option_2, "emitDeclarationOnly", "declaration", "composite"); + } + if (options.noEmit) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "emitDeclarationOnly", "noEmit"); + } + } + if (options.emitDecoratorMetadata && + !options.experimentalDecorators) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "emitDecoratorMetadata", "experimentalDecorators"); + } + if (options.jsxFactory) { + if (options.reactNamespace) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_with_option_1, "reactNamespace", "jsxFactory"); + } + if (options.jsx === 4 /* JsxEmit.ReactJSX */ || options.jsx === 5 /* JsxEmit.ReactJSXDev */) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_when_option_jsx_is_1, "jsxFactory", ts.inverseJsxOptionMap.get("" + options.jsx)); + } + if (!ts.parseIsolatedEntityName(options.jsxFactory, languageVersion)) { + createOptionValueDiagnostic("jsxFactory", ts.Diagnostics.Invalid_value_for_jsxFactory_0_is_not_a_valid_identifier_or_qualified_name, options.jsxFactory); + } + } + else if (options.reactNamespace && !ts.isIdentifierText(options.reactNamespace, languageVersion)) { + createOptionValueDiagnostic("reactNamespace", ts.Diagnostics.Invalid_value_for_reactNamespace_0_is_not_a_valid_identifier, options.reactNamespace); + } + if (options.jsxFragmentFactory) { + if (!options.jsxFactory) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_without_specifying_option_1, "jsxFragmentFactory", "jsxFactory"); + } + if (options.jsx === 4 /* JsxEmit.ReactJSX */ || options.jsx === 5 /* JsxEmit.ReactJSXDev */) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_when_option_jsx_is_1, "jsxFragmentFactory", ts.inverseJsxOptionMap.get("" + options.jsx)); + } + if (!ts.parseIsolatedEntityName(options.jsxFragmentFactory, languageVersion)) { + createOptionValueDiagnostic("jsxFragmentFactory", ts.Diagnostics.Invalid_value_for_jsxFragmentFactory_0_is_not_a_valid_identifier_or_qualified_name, options.jsxFragmentFactory); + } + } + if (options.reactNamespace) { + if (options.jsx === 4 /* JsxEmit.ReactJSX */ || options.jsx === 5 /* JsxEmit.ReactJSXDev */) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_when_option_jsx_is_1, "reactNamespace", ts.inverseJsxOptionMap.get("" + options.jsx)); + } + } + if (options.jsxImportSource) { + if (options.jsx === 2 /* JsxEmit.React */) { + createDiagnosticForOptionName(ts.Diagnostics.Option_0_cannot_be_specified_when_option_jsx_is_1, "jsxImportSource", ts.inverseJsxOptionMap.get("" + options.jsx)); + } + } + if (options.preserveValueImports && ts.getEmitModuleKind(options) < ts.ModuleKind.ES2015) { + createOptionValueDiagnostic("importsNotUsedAsValues", ts.Diagnostics.Option_preserveValueImports_can_only_be_used_when_module_is_set_to_es2015_or_later); + } + // If the emit is enabled make sure that every output file is unique and not overwriting any of the input files + if (!options.noEmit && !options.suppressOutputPathCheck) { + var emitHost = getEmitHost(); + var emitFilesSeen_1 = new ts.Set(); + ts.forEachEmittedFile(emitHost, function (emitFileNames) { + if (!options.emitDeclarationOnly) { + verifyEmitFilePath(emitFileNames.jsFilePath, emitFilesSeen_1); + } + verifyEmitFilePath(emitFileNames.declarationFilePath, emitFilesSeen_1); + }); + } + // Verify that all the emit files are unique and don't overwrite input files + function verifyEmitFilePath(emitFileName, emitFilesSeen) { + if (emitFileName) { + var emitFilePath = toPath(emitFileName); + // Report error if the output overwrites input file + if (filesByName.has(emitFilePath)) { + var chain = void 0; + if (!options.configFilePath) { + // The program is from either an inferred project or an external project + chain = ts.chainDiagnosticMessages(/*details*/ undefined, ts.Diagnostics.Adding_a_tsconfig_json_file_will_help_organize_projects_that_contain_both_TypeScript_and_JavaScript_files_Learn_more_at_https_Colon_Slash_Slashaka_ms_Slashtsconfig); + } + chain = ts.chainDiagnosticMessages(chain, ts.Diagnostics.Cannot_write_file_0_because_it_would_overwrite_input_file, emitFileName); + blockEmittingOfFile(emitFileName, ts.createCompilerDiagnosticFromMessageChain(chain)); + } + var emitFileKey = !host.useCaseSensitiveFileNames() ? ts.toFileNameLowerCase(emitFilePath) : emitFilePath; + // Report error if multiple files write into same file + if (emitFilesSeen.has(emitFileKey)) { + // Already seen the same emit file - report error + blockEmittingOfFile(emitFileName, ts.createCompilerDiagnostic(ts.Diagnostics.Cannot_write_file_0_because_it_would_be_overwritten_by_multiple_input_files, emitFileName)); + } + else { + emitFilesSeen.add(emitFileKey); + } + } + } + } + function createDiagnosticExplainingFile(file, fileProcessingReason, diagnostic, args) { + var _a; + var fileIncludeReasons; + var relatedInfo; + var locationReason = isReferencedFile(fileProcessingReason) ? fileProcessingReason : undefined; + if (file) + (_a = fileReasons.get(file.path)) === null || _a === void 0 ? void 0 : _a.forEach(processReason); + if (fileProcessingReason) + processReason(fileProcessingReason); + // If we have location and there is only one reason file is in which is the location, dont add details for file include + if (locationReason && (fileIncludeReasons === null || fileIncludeReasons === void 0 ? void 0 : fileIncludeReasons.length) === 1) + fileIncludeReasons = undefined; + var location = locationReason && getReferencedFileLocation(getSourceFileByPath, locationReason); + var fileIncludeReasonDetails = fileIncludeReasons && ts.chainDiagnosticMessages(fileIncludeReasons, ts.Diagnostics.The_file_is_in_the_program_because_Colon); + var redirectInfo = file && ts.explainIfFileIsRedirectAndImpliedFormat(file); + var chain = ts.chainDiagnosticMessages.apply(void 0, __spreadArray([redirectInfo ? fileIncludeReasonDetails ? __spreadArray([fileIncludeReasonDetails], redirectInfo, true) : redirectInfo : fileIncludeReasonDetails, diagnostic], args || ts.emptyArray, false)); + return location && isReferenceFileLocation(location) ? + ts.createFileDiagnosticFromMessageChain(location.file, location.pos, location.end - location.pos, chain, relatedInfo) : + ts.createCompilerDiagnosticFromMessageChain(chain, relatedInfo); + function processReason(reason) { + (fileIncludeReasons || (fileIncludeReasons = [])).push(ts.fileIncludeReasonToDiagnostics(program, reason)); + if (!locationReason && isReferencedFile(reason)) { + // Report error at first reference file or file currently in processing and dont report in related information + locationReason = reason; + } + else if (locationReason !== reason) { + relatedInfo = ts.append(relatedInfo, fileIncludeReasonToRelatedInformation(reason)); + } + // Remove fileProcessingReason if its already included in fileReasons of the program + if (reason === fileProcessingReason) + fileProcessingReason = undefined; + } + } + function addFilePreprocessingFileExplainingDiagnostic(file, fileProcessingReason, diagnostic, args) { + (fileProcessingDiagnostics || (fileProcessingDiagnostics = [])).push({ + kind: 1 /* FilePreprocessingDiagnosticsKind.FilePreprocessingFileExplainingDiagnostic */, + file: file && file.path, + fileProcessingReason: fileProcessingReason, + diagnostic: diagnostic, + args: args + }); + } + function addProgramDiagnosticExplainingFile(file, diagnostic, args) { + programDiagnostics.add(createDiagnosticExplainingFile(file, /*fileProcessingReason*/ undefined, diagnostic, args)); + } + function fileIncludeReasonToRelatedInformation(reason) { + if (isReferencedFile(reason)) { + var referenceLocation = getReferencedFileLocation(getSourceFileByPath, reason); + var message_2; + switch (reason.kind) { + case ts.FileIncludeKind.Import: + message_2 = ts.Diagnostics.File_is_included_via_import_here; + break; + case ts.FileIncludeKind.ReferenceFile: + message_2 = ts.Diagnostics.File_is_included_via_reference_here; + break; + case ts.FileIncludeKind.TypeReferenceDirective: + message_2 = ts.Diagnostics.File_is_included_via_type_library_reference_here; + break; + case ts.FileIncludeKind.LibReferenceDirective: + message_2 = ts.Diagnostics.File_is_included_via_library_reference_here; + break; + default: + ts.Debug.assertNever(reason); + } + return isReferenceFileLocation(referenceLocation) ? ts.createFileDiagnostic(referenceLocation.file, referenceLocation.pos, referenceLocation.end - referenceLocation.pos, message_2) : undefined; + } + if (!options.configFile) + return undefined; + var configFileNode; + var message; + switch (reason.kind) { + case ts.FileIncludeKind.RootFile: + if (!options.configFile.configFileSpecs) + return undefined; + var fileName = ts.getNormalizedAbsolutePath(rootNames[reason.index], currentDirectory); + var matchedByFiles = ts.getMatchedFileSpec(program, fileName); + if (matchedByFiles) { + configFileNode = ts.getTsConfigPropArrayElementValue(options.configFile, "files", matchedByFiles); + message = ts.Diagnostics.File_is_matched_by_files_list_specified_here; + break; + } + var matchedByInclude = ts.getMatchedIncludeSpec(program, fileName); + // Could be additional files specified as roots + if (!matchedByInclude || !ts.isString(matchedByInclude)) + return undefined; + configFileNode = ts.getTsConfigPropArrayElementValue(options.configFile, "include", matchedByInclude); + message = ts.Diagnostics.File_is_matched_by_include_pattern_specified_here; + break; + case ts.FileIncludeKind.SourceFromProjectReference: + case ts.FileIncludeKind.OutputFromProjectReference: + var referencedResolvedRef_1 = ts.Debug.checkDefined(resolvedProjectReferences === null || resolvedProjectReferences === void 0 ? void 0 : resolvedProjectReferences[reason.index]); + var referenceInfo = forEachProjectReference(projectReferences, resolvedProjectReferences, function (resolvedRef, parent, index) { + return resolvedRef === referencedResolvedRef_1 ? { sourceFile: (parent === null || parent === void 0 ? void 0 : parent.sourceFile) || options.configFile, index: index } : undefined; + }); + if (!referenceInfo) + return undefined; + var sourceFile = referenceInfo.sourceFile, index = referenceInfo.index; + var referencesSyntax = ts.firstDefined(ts.getTsConfigPropArray(sourceFile, "references"), function (property) { return ts.isArrayLiteralExpression(property.initializer) ? property.initializer : undefined; }); + return referencesSyntax && referencesSyntax.elements.length > index ? + ts.createDiagnosticForNodeInSourceFile(sourceFile, referencesSyntax.elements[index], reason.kind === ts.FileIncludeKind.OutputFromProjectReference ? + ts.Diagnostics.File_is_output_from_referenced_project_specified_here : + ts.Diagnostics.File_is_source_from_referenced_project_specified_here) : + undefined; + case ts.FileIncludeKind.AutomaticTypeDirectiveFile: + if (!options.types) + return undefined; + configFileNode = getOptionsSyntaxByArrayElementValue("types", reason.typeReference); + message = ts.Diagnostics.File_is_entry_point_of_type_library_specified_here; + break; + case ts.FileIncludeKind.LibFile: + if (reason.index !== undefined) { + configFileNode = getOptionsSyntaxByArrayElementValue("lib", options.lib[reason.index]); + message = ts.Diagnostics.File_is_library_specified_here; + break; + } + var target = ts.forEachEntry(ts.targetOptionDeclaration.type, function (value, key) { return value === ts.getEmitScriptTarget(options) ? key : undefined; }); + configFileNode = target ? getOptionsSyntaxByValue("target", target) : undefined; + message = ts.Diagnostics.File_is_default_library_for_target_specified_here; + break; + default: + ts.Debug.assertNever(reason); + } + return configFileNode && ts.createDiagnosticForNodeInSourceFile(options.configFile, configFileNode, message); + } + function verifyProjectReferences() { + var buildInfoPath = !options.suppressOutputPathCheck ? ts.getTsBuildInfoEmitOutputFilePath(options) : undefined; + forEachProjectReference(projectReferences, resolvedProjectReferences, function (resolvedRef, parent, index) { + var ref = (parent ? parent.commandLine.projectReferences : projectReferences)[index]; + var parentFile = parent && parent.sourceFile; + if (!resolvedRef) { + createDiagnosticForReference(parentFile, index, ts.Diagnostics.File_0_not_found, ref.path); + return; + } + var options = resolvedRef.commandLine.options; + if (!options.composite || options.noEmit) { + // ok to not have composite if the current program is container only + var inputs = parent ? parent.commandLine.fileNames : rootNames; + if (inputs.length) { + if (!options.composite) + createDiagnosticForReference(parentFile, index, ts.Diagnostics.Referenced_project_0_must_have_setting_composite_Colon_true, ref.path); + if (options.noEmit) + createDiagnosticForReference(parentFile, index, ts.Diagnostics.Referenced_project_0_may_not_disable_emit, ref.path); + } + } + if (ref.prepend) { + var out = ts.outFile(options); + if (out) { + if (!host.fileExists(out)) { + createDiagnosticForReference(parentFile, index, ts.Diagnostics.Output_file_0_from_project_1_does_not_exist, out, ref.path); + } + } + else { + createDiagnosticForReference(parentFile, index, ts.Diagnostics.Cannot_prepend_project_0_because_it_does_not_have_outFile_set, ref.path); + } + } + if (!parent && buildInfoPath && buildInfoPath === ts.getTsBuildInfoEmitOutputFilePath(options)) { + createDiagnosticForReference(parentFile, index, ts.Diagnostics.Cannot_write_file_0_because_it_will_overwrite_tsbuildinfo_file_generated_by_referenced_project_1, buildInfoPath, ref.path); + hasEmitBlockingDiagnostics.set(toPath(buildInfoPath), true); + } + }); + } + function createDiagnosticForOptionPathKeyValue(key, valueIndex, message, arg0, arg1, arg2) { + var needCompilerDiagnostic = true; + var pathsSyntax = getOptionPathsSyntax(); + for (var _i = 0, pathsSyntax_1 = pathsSyntax; _i < pathsSyntax_1.length; _i++) { + var pathProp = pathsSyntax_1[_i]; + if (ts.isObjectLiteralExpression(pathProp.initializer)) { + for (var _a = 0, _b = ts.getPropertyAssignment(pathProp.initializer, key); _a < _b.length; _a++) { + var keyProps = _b[_a]; + var initializer = keyProps.initializer; + if (ts.isArrayLiteralExpression(initializer) && initializer.elements.length > valueIndex) { + programDiagnostics.add(ts.createDiagnosticForNodeInSourceFile(options.configFile, initializer.elements[valueIndex], message, arg0, arg1, arg2)); + needCompilerDiagnostic = false; + } + } + } + } + if (needCompilerDiagnostic) { + programDiagnostics.add(ts.createCompilerDiagnostic(message, arg0, arg1, arg2)); + } + } + function createDiagnosticForOptionPaths(onKey, key, message, arg0) { + var needCompilerDiagnostic = true; + var pathsSyntax = getOptionPathsSyntax(); + for (var _i = 0, pathsSyntax_2 = pathsSyntax; _i < pathsSyntax_2.length; _i++) { + var pathProp = pathsSyntax_2[_i]; + if (ts.isObjectLiteralExpression(pathProp.initializer) && + createOptionDiagnosticInObjectLiteralSyntax(pathProp.initializer, onKey, key, /*key2*/ undefined, message, arg0)) { + needCompilerDiagnostic = false; + } + } + if (needCompilerDiagnostic) { + programDiagnostics.add(ts.createCompilerDiagnostic(message, arg0)); + } + } + function getOptionsSyntaxByName(name) { + var compilerOptionsObjectLiteralSyntax = getCompilerOptionsObjectLiteralSyntax(); + return compilerOptionsObjectLiteralSyntax && ts.getPropertyAssignment(compilerOptionsObjectLiteralSyntax, name); + } + function getOptionPathsSyntax() { + return getOptionsSyntaxByName("paths") || ts.emptyArray; + } + function getOptionsSyntaxByValue(name, value) { + var syntaxByName = getOptionsSyntaxByName(name); + return syntaxByName && ts.firstDefined(syntaxByName, function (property) { return ts.isStringLiteral(property.initializer) && property.initializer.text === value ? property.initializer : undefined; }); + } + function getOptionsSyntaxByArrayElementValue(name, value) { + var compilerOptionsObjectLiteralSyntax = getCompilerOptionsObjectLiteralSyntax(); + return compilerOptionsObjectLiteralSyntax && ts.getPropertyArrayElementValue(compilerOptionsObjectLiteralSyntax, name, value); + } + function createDiagnosticForOptionName(message, option1, option2, option3) { + createDiagnosticForOption(/*onKey*/ true, option1, option2, message, option1, option2, option3); + } + function createOptionValueDiagnostic(option1, message, arg0, arg1) { + createDiagnosticForOption(/*onKey*/ false, option1, /*option2*/ undefined, message, arg0, arg1); + } + function createDiagnosticForReference(sourceFile, index, message, arg0, arg1) { + var referencesSyntax = ts.firstDefined(ts.getTsConfigPropArray(sourceFile || options.configFile, "references"), function (property) { return ts.isArrayLiteralExpression(property.initializer) ? property.initializer : undefined; }); + if (referencesSyntax && referencesSyntax.elements.length > index) { + programDiagnostics.add(ts.createDiagnosticForNodeInSourceFile(sourceFile || options.configFile, referencesSyntax.elements[index], message, arg0, arg1)); + } + else { + programDiagnostics.add(ts.createCompilerDiagnostic(message, arg0, arg1)); + } + } + function createDiagnosticForOption(onKey, option1, option2, message, arg0, arg1, arg2) { + var compilerOptionsObjectLiteralSyntax = getCompilerOptionsObjectLiteralSyntax(); + var needCompilerDiagnostic = !compilerOptionsObjectLiteralSyntax || + !createOptionDiagnosticInObjectLiteralSyntax(compilerOptionsObjectLiteralSyntax, onKey, option1, option2, message, arg0, arg1, arg2); + if (needCompilerDiagnostic) { + programDiagnostics.add(ts.createCompilerDiagnostic(message, arg0, arg1, arg2)); + } + } + function getCompilerOptionsObjectLiteralSyntax() { + if (_compilerOptionsObjectLiteralSyntax === undefined) { + _compilerOptionsObjectLiteralSyntax = false; + var jsonObjectLiteral = ts.getTsConfigObjectLiteralExpression(options.configFile); + if (jsonObjectLiteral) { + for (var _i = 0, _a = ts.getPropertyAssignment(jsonObjectLiteral, "compilerOptions"); _i < _a.length; _i++) { + var prop = _a[_i]; + if (ts.isObjectLiteralExpression(prop.initializer)) { + _compilerOptionsObjectLiteralSyntax = prop.initializer; + break; + } + } + } + } + return _compilerOptionsObjectLiteralSyntax || undefined; + } + function createOptionDiagnosticInObjectLiteralSyntax(objectLiteral, onKey, key1, key2, message, arg0, arg1, arg2) { + var props = ts.getPropertyAssignment(objectLiteral, key1, key2); + for (var _i = 0, props_3 = props; _i < props_3.length; _i++) { + var prop = props_3[_i]; + programDiagnostics.add(ts.createDiagnosticForNodeInSourceFile(options.configFile, onKey ? prop.name : prop.initializer, message, arg0, arg1, arg2)); + } + return !!props.length; + } + function blockEmittingOfFile(emitFileName, diag) { + hasEmitBlockingDiagnostics.set(toPath(emitFileName), true); + programDiagnostics.add(diag); + } + function isEmittedFile(file) { + if (options.noEmit) { + return false; + } + // If this is source file, its not emitted file + var filePath = toPath(file); + if (getSourceFileByPath(filePath)) { + return false; + } + // If options have --outFile or --out just check that + var out = ts.outFile(options); + if (out) { + return isSameFile(filePath, out) || isSameFile(filePath, ts.removeFileExtension(out) + ".d.ts" /* Extension.Dts */); + } + // If declarationDir is specified, return if its a file in that directory + if (options.declarationDir && ts.containsPath(options.declarationDir, filePath, currentDirectory, !host.useCaseSensitiveFileNames())) { + return true; + } + // If --outDir, check if file is in that directory + if (options.outDir) { + return ts.containsPath(options.outDir, filePath, currentDirectory, !host.useCaseSensitiveFileNames()); + } + if (ts.fileExtensionIsOneOf(filePath, ts.supportedJSExtensionsFlat) || ts.isDeclarationFileName(filePath)) { + // Otherwise just check if sourceFile with the name exists + var filePathWithoutExtension = ts.removeFileExtension(filePath); + return !!getSourceFileByPath((filePathWithoutExtension + ".ts" /* Extension.Ts */)) || + !!getSourceFileByPath((filePathWithoutExtension + ".tsx" /* Extension.Tsx */)); + } + return false; + } + function isSameFile(file1, file2) { + return ts.comparePaths(file1, file2, currentDirectory, !host.useCaseSensitiveFileNames()) === 0 /* Comparison.EqualTo */; + } + function getSymlinkCache() { + if (host.getSymlinkCache) { + return host.getSymlinkCache(); + } + if (!symlinks) { + symlinks = ts.createSymlinkCache(currentDirectory, getCanonicalFileName); + } + if (files && resolvedTypeReferenceDirectives && !symlinks.hasProcessedResolutions()) { + symlinks.setSymlinksFromResolutions(files, resolvedTypeReferenceDirectives); + } + return symlinks; + } + } + ts.createProgram = createProgram; + function updateHostForUseSourceOfProjectReferenceRedirect(host) { + var setOfDeclarationDirectories; + var originalFileExists = host.compilerHost.fileExists; + var originalDirectoryExists = host.compilerHost.directoryExists; + var originalGetDirectories = host.compilerHost.getDirectories; + var originalRealpath = host.compilerHost.realpath; + if (!host.useSourceOfProjectReferenceRedirect) + return { onProgramCreateComplete: ts.noop, fileExists: fileExists }; + host.compilerHost.fileExists = fileExists; + var directoryExists; + if (originalDirectoryExists) { + // This implementation of directoryExists checks if the directory being requested is + // directory of .d.ts file for the referenced Project. + // If it is it returns true irrespective of whether that directory exists on host + directoryExists = host.compilerHost.directoryExists = function (path) { + if (originalDirectoryExists.call(host.compilerHost, path)) { + handleDirectoryCouldBeSymlink(path); + return true; + } + if (!host.getResolvedProjectReferences()) + return false; + if (!setOfDeclarationDirectories) { + setOfDeclarationDirectories = new ts.Set(); + host.forEachResolvedProjectReference(function (ref) { + var out = ts.outFile(ref.commandLine.options); + if (out) { + setOfDeclarationDirectories.add(ts.getDirectoryPath(host.toPath(out))); + } + else { + // Set declaration's in different locations only, if they are next to source the directory present doesnt change + var declarationDir = ref.commandLine.options.declarationDir || ref.commandLine.options.outDir; + if (declarationDir) { + setOfDeclarationDirectories.add(host.toPath(declarationDir)); + } + } + }); + } + return fileOrDirectoryExistsUsingSource(path, /*isFile*/ false); + }; + } + if (originalGetDirectories) { + // Call getDirectories only if directory actually present on the host + // This is needed to ensure that we arent getting directories that we fake about presence for + host.compilerHost.getDirectories = function (path) { + return !host.getResolvedProjectReferences() || (originalDirectoryExists && originalDirectoryExists.call(host.compilerHost, path)) ? + originalGetDirectories.call(host.compilerHost, path) : + []; + }; + } + // This is something we keep for life time of the host + if (originalRealpath) { + host.compilerHost.realpath = function (s) { + var _a; + return ((_a = host.getSymlinkCache().getSymlinkedFiles()) === null || _a === void 0 ? void 0 : _a.get(host.toPath(s))) || + originalRealpath.call(host.compilerHost, s); + }; + } + return { onProgramCreateComplete: onProgramCreateComplete, fileExists: fileExists, directoryExists: directoryExists }; + function onProgramCreateComplete() { + host.compilerHost.fileExists = originalFileExists; + host.compilerHost.directoryExists = originalDirectoryExists; + host.compilerHost.getDirectories = originalGetDirectories; + // DO not revert realpath as it could be used later + } + // This implementation of fileExists checks if the file being requested is + // .d.ts file for the referenced Project. + // If it is it returns true irrespective of whether that file exists on host + function fileExists(file) { + if (originalFileExists.call(host.compilerHost, file)) + return true; + if (!host.getResolvedProjectReferences()) + return false; + if (!ts.isDeclarationFileName(file)) + return false; + // Project references go to source file instead of .d.ts file + return fileOrDirectoryExistsUsingSource(file, /*isFile*/ true); + } + function fileExistsIfProjectReferenceDts(file) { + var source = host.getSourceOfProjectReferenceRedirect(host.toPath(file)); + return source !== undefined ? + ts.isString(source) ? originalFileExists.call(host.compilerHost, source) : true : + undefined; + } + function directoryExistsIfProjectReferenceDeclDir(dir) { + var dirPath = host.toPath(dir); + var dirPathWithTrailingDirectorySeparator = "".concat(dirPath).concat(ts.directorySeparator); + return ts.forEachKey(setOfDeclarationDirectories, function (declDirPath) { return dirPath === declDirPath || + // Any parent directory of declaration dir + ts.startsWith(declDirPath, dirPathWithTrailingDirectorySeparator) || + // Any directory inside declaration dir + ts.startsWith(dirPath, "".concat(declDirPath, "/")); }); + } + function handleDirectoryCouldBeSymlink(directory) { + var _a; + if (!host.getResolvedProjectReferences() || ts.containsIgnoredPath(directory)) + return; + // Because we already watch node_modules, handle symlinks in there + if (!originalRealpath || !ts.stringContains(directory, ts.nodeModulesPathPart)) + return; + var symlinkCache = host.getSymlinkCache(); + var directoryPath = ts.ensureTrailingDirectorySeparator(host.toPath(directory)); + if ((_a = symlinkCache.getSymlinkedDirectories()) === null || _a === void 0 ? void 0 : _a.has(directoryPath)) + return; + var real = ts.normalizePath(originalRealpath.call(host.compilerHost, directory)); + var realPath; + if (real === directory || + (realPath = ts.ensureTrailingDirectorySeparator(host.toPath(real))) === directoryPath) { + // not symlinked + symlinkCache.setSymlinkedDirectory(directoryPath, false); + return; + } + symlinkCache.setSymlinkedDirectory(directory, { + real: ts.ensureTrailingDirectorySeparator(real), + realPath: realPath + }); + } + function fileOrDirectoryExistsUsingSource(fileOrDirectory, isFile) { + var _a; + var fileOrDirectoryExistsUsingSource = isFile ? + function (file) { return fileExistsIfProjectReferenceDts(file); } : + function (dir) { return directoryExistsIfProjectReferenceDeclDir(dir); }; + // Check current directory or file + var result = fileOrDirectoryExistsUsingSource(fileOrDirectory); + if (result !== undefined) + return result; + var symlinkCache = host.getSymlinkCache(); + var symlinkedDirectories = symlinkCache.getSymlinkedDirectories(); + if (!symlinkedDirectories) + return false; + var fileOrDirectoryPath = host.toPath(fileOrDirectory); + if (!ts.stringContains(fileOrDirectoryPath, ts.nodeModulesPathPart)) + return false; + if (isFile && ((_a = symlinkCache.getSymlinkedFiles()) === null || _a === void 0 ? void 0 : _a.has(fileOrDirectoryPath))) + return true; + // If it contains node_modules check if its one of the symlinked path we know of + return ts.firstDefinedIterator(symlinkedDirectories.entries(), function (_a) { + var directoryPath = _a[0], symlinkedDirectory = _a[1]; + if (!symlinkedDirectory || !ts.startsWith(fileOrDirectoryPath, directoryPath)) + return undefined; + var result = fileOrDirectoryExistsUsingSource(fileOrDirectoryPath.replace(directoryPath, symlinkedDirectory.realPath)); + if (isFile && result) { + // Store the real path for the file' + var absolutePath = ts.getNormalizedAbsolutePath(fileOrDirectory, host.compilerHost.getCurrentDirectory()); + symlinkCache.setSymlinkedFile(fileOrDirectoryPath, "".concat(symlinkedDirectory.real).concat(absolutePath.replace(new RegExp(directoryPath, "i"), ""))); + } + return result; + }) || false; + } + } + /*@internal*/ + ts.emitSkippedWithNoDiagnostics = { diagnostics: ts.emptyArray, sourceMaps: undefined, emittedFiles: undefined, emitSkipped: true }; + /*@internal*/ + function handleNoEmitOptions(program, sourceFile, writeFile, cancellationToken) { + var options = program.getCompilerOptions(); + if (options.noEmit) { + // Cache the semantic diagnostics + program.getSemanticDiagnostics(sourceFile, cancellationToken); + return sourceFile || ts.outFile(options) ? + ts.emitSkippedWithNoDiagnostics : + program.emitBuildInfo(writeFile, cancellationToken); + } + // If the noEmitOnError flag is set, then check if we have any errors so far. If so, + // immediately bail out. Note that we pass 'undefined' for 'sourceFile' so that we + // get any preEmit diagnostics, not just the ones + if (!options.noEmitOnError) + return undefined; + var diagnostics = __spreadArray(__spreadArray(__spreadArray(__spreadArray([], program.getOptionsDiagnostics(cancellationToken), true), program.getSyntacticDiagnostics(sourceFile, cancellationToken), true), program.getGlobalDiagnostics(cancellationToken), true), program.getSemanticDiagnostics(sourceFile, cancellationToken), true); + if (diagnostics.length === 0 && ts.getEmitDeclarations(program.getCompilerOptions())) { + diagnostics = program.getDeclarationDiagnostics(/*sourceFile*/ undefined, cancellationToken); + } + if (!diagnostics.length) + return undefined; + var emittedFiles; + if (!sourceFile && !ts.outFile(options)) { + var emitResult = program.emitBuildInfo(writeFile, cancellationToken); + if (emitResult.diagnostics) + diagnostics = __spreadArray(__spreadArray([], diagnostics, true), emitResult.diagnostics, true); + emittedFiles = emitResult.emittedFiles; + } + return { diagnostics: diagnostics, sourceMaps: undefined, emittedFiles: emittedFiles, emitSkipped: true }; + } + ts.handleNoEmitOptions = handleNoEmitOptions; + /*@internal*/ + function filterSemanticDiagnostics(diagnostic, option) { + return ts.filter(diagnostic, function (d) { return !d.skippedOn || !option[d.skippedOn]; }); + } + ts.filterSemanticDiagnostics = filterSemanticDiagnostics; + /* @internal */ + function parseConfigHostFromCompilerHostLike(host, directoryStructureHost) { + if (directoryStructureHost === void 0) { directoryStructureHost = host; } + return { + fileExists: function (f) { return directoryStructureHost.fileExists(f); }, + readDirectory: function (root, extensions, excludes, includes, depth) { + ts.Debug.assertIsDefined(directoryStructureHost.readDirectory, "'CompilerHost.readDirectory' must be implemented to correctly process 'projectReferences'"); + return directoryStructureHost.readDirectory(root, extensions, excludes, includes, depth); + }, + readFile: function (f) { return directoryStructureHost.readFile(f); }, + useCaseSensitiveFileNames: host.useCaseSensitiveFileNames(), + getCurrentDirectory: function () { return host.getCurrentDirectory(); }, + onUnRecoverableConfigFileDiagnostic: host.onUnRecoverableConfigFileDiagnostic || ts.returnUndefined, + trace: host.trace ? function (s) { return host.trace(s); } : undefined + }; + } + ts.parseConfigHostFromCompilerHostLike = parseConfigHostFromCompilerHostLike; + /* @internal */ + function createPrependNodes(projectReferences, getCommandLine, readFile) { + if (!projectReferences) + return ts.emptyArray; + var nodes; + for (var i = 0; i < projectReferences.length; i++) { + var ref = projectReferences[i]; + var resolvedRefOpts = getCommandLine(ref, i); + if (ref.prepend && resolvedRefOpts && resolvedRefOpts.options) { + var out = ts.outFile(resolvedRefOpts.options); + // Upstream project didn't have outFile set -- skip (error will have been issued earlier) + if (!out) + continue; + var _a = ts.getOutputPathsForBundle(resolvedRefOpts.options, /*forceDtsPaths*/ true), jsFilePath = _a.jsFilePath, sourceMapFilePath = _a.sourceMapFilePath, declarationFilePath = _a.declarationFilePath, declarationMapPath = _a.declarationMapPath, buildInfoPath = _a.buildInfoPath; + var node = ts.createInputFiles(readFile, jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath); + (nodes || (nodes = [])).push(node); + } + } + return nodes || ts.emptyArray; + } + ts.createPrependNodes = createPrependNodes; + function resolveProjectReferencePath(hostOrRef, ref) { + var passedInRef = ref ? ref : hostOrRef; + return ts.resolveConfigFileProjectName(passedInRef.path); + } + ts.resolveProjectReferencePath = resolveProjectReferencePath; + /* @internal */ + /** + * Returns a DiagnosticMessage if we won't include a resolved module due to its extension. + * The DiagnosticMessage's parameters are the imported module name, and the filename it resolved to. + * This returns a diagnostic even if the module will be an untyped module. + */ + function getResolutionDiagnostic(options, _a) { + var extension = _a.extension; + switch (extension) { + case ".ts" /* Extension.Ts */: + case ".d.ts" /* Extension.Dts */: + // These are always allowed. + return undefined; + case ".tsx" /* Extension.Tsx */: + return needJsx(); + case ".jsx" /* Extension.Jsx */: + return needJsx() || needAllowJs(); + case ".js" /* Extension.Js */: + return needAllowJs(); + case ".json" /* Extension.Json */: + return needResolveJsonModule(); + } + function needJsx() { + return options.jsx ? undefined : ts.Diagnostics.Module_0_was_resolved_to_1_but_jsx_is_not_set; + } + function needAllowJs() { + return ts.getAllowJSCompilerOption(options) || !ts.getStrictOptionValue(options, "noImplicitAny") ? undefined : ts.Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type; + } + function needResolveJsonModule() { + return options.resolveJsonModule ? undefined : ts.Diagnostics.Module_0_was_resolved_to_1_but_resolveJsonModule_is_not_used; + } + } + ts.getResolutionDiagnostic = getResolutionDiagnostic; + function getModuleNames(_a) { + var imports = _a.imports, moduleAugmentations = _a.moduleAugmentations; + var res = imports.map(function (i) { return i.text; }); + for (var _i = 0, moduleAugmentations_1 = moduleAugmentations; _i < moduleAugmentations_1.length; _i++) { + var aug = moduleAugmentations_1[_i]; + if (aug.kind === 10 /* SyntaxKind.StringLiteral */) { + res.push(aug.text); + } + // Do nothing if it's an Identifier; we don't need to do module resolution for `declare global`. + } + return res; + } + /* @internal */ + function getModuleNameStringLiteralAt(_a, index) { + var imports = _a.imports, moduleAugmentations = _a.moduleAugmentations; + if (index < imports.length) + return imports[index]; + var augIndex = imports.length; + for (var _i = 0, moduleAugmentations_2 = moduleAugmentations; _i < moduleAugmentations_2.length; _i++) { + var aug = moduleAugmentations_2[_i]; + if (aug.kind === 10 /* SyntaxKind.StringLiteral */) { + if (index === augIndex) + return aug; + augIndex++; + } + // Do nothing if it's an Identifier; we don't need to do module resolution for `declare global`. + } + ts.Debug.fail("should never ask for module name at index higher than possible module name"); + } + ts.getModuleNameStringLiteralAt = getModuleNameStringLiteralAt; +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + function getFileEmitOutput(program, sourceFile, emitOnlyDtsFiles, cancellationToken, customTransformers, forceDtsEmit) { + var outputFiles = []; + var _a = program.emit(sourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers, forceDtsEmit), emitSkipped = _a.emitSkipped, diagnostics = _a.diagnostics; + return { outputFiles: outputFiles, emitSkipped: emitSkipped, diagnostics: diagnostics }; + function writeFile(fileName, text, writeByteOrderMark) { + outputFiles.push({ name: fileName, writeByteOrderMark: writeByteOrderMark, text: text }); + } + } + ts.getFileEmitOutput = getFileEmitOutput; + var BuilderState; + (function (BuilderState) { + function createManyToManyPathMap() { + function create(forward, reverse, deleted) { + var map = { + getKeys: function (v) { return reverse.get(v); }, + getValues: function (k) { return forward.get(k); }, + keys: function () { return forward.keys(); }, + deleteKey: function (k) { + (deleted || (deleted = new ts.Set())).add(k); + var set = forward.get(k); + if (!set) { + return false; + } + set.forEach(function (v) { return deleteFromMultimap(reverse, v, k); }); + forward.delete(k); + return true; + }, + set: function (k, vSet) { + deleted === null || deleted === void 0 ? void 0 : deleted.delete(k); + var existingVSet = forward.get(k); + forward.set(k, vSet); + existingVSet === null || existingVSet === void 0 ? void 0 : existingVSet.forEach(function (v) { + if (!vSet.has(v)) { + deleteFromMultimap(reverse, v, k); + } + }); + vSet.forEach(function (v) { + if (!(existingVSet === null || existingVSet === void 0 ? void 0 : existingVSet.has(v))) { + addToMultimap(reverse, v, k); + } + }); + return map; + }, + }; + return map; + } + return create(new ts.Map(), new ts.Map(), /*deleted*/ undefined); + } + BuilderState.createManyToManyPathMap = createManyToManyPathMap; + function addToMultimap(map, k, v) { + var set = map.get(k); + if (!set) { + set = new ts.Set(); + map.set(k, set); + } + set.add(v); + } + function deleteFromMultimap(map, k, v) { + var set = map.get(k); + if (set === null || set === void 0 ? void 0 : set.delete(v)) { + if (!set.size) { + map.delete(k); + } + return true; + } + return false; + } + function getReferencedFilesFromImportedModuleSymbol(symbol) { + return ts.mapDefined(symbol.declarations, function (declaration) { var _a; return (_a = ts.getSourceFileOfNode(declaration)) === null || _a === void 0 ? void 0 : _a.resolvedPath; }); + } + /** + * Get the module source file and all augmenting files from the import name node from file + */ + function getReferencedFilesFromImportLiteral(checker, importName) { + var symbol = checker.getSymbolAtLocation(importName); + return symbol && getReferencedFilesFromImportedModuleSymbol(symbol); + } + /** + * Gets the path to reference file from file name, it could be resolvedPath if present otherwise path + */ + function getReferencedFileFromFileName(program, fileName, sourceFileDirectory, getCanonicalFileName) { + return ts.toPath(program.getProjectReferenceRedirect(fileName) || fileName, sourceFileDirectory, getCanonicalFileName); + } + /** + * Gets the referenced files for a file from the program with values for the keys as referenced file's path to be true + */ + function getReferencedFiles(program, sourceFile, getCanonicalFileName) { + var referencedFiles; + // We need to use a set here since the code can contain the same import twice, + // but that will only be one dependency. + // To avoid invernal conversion, the key of the referencedFiles map must be of type Path + if (sourceFile.imports && sourceFile.imports.length > 0) { + var checker = program.getTypeChecker(); + for (var _i = 0, _a = sourceFile.imports; _i < _a.length; _i++) { + var importName = _a[_i]; + var declarationSourceFilePaths = getReferencedFilesFromImportLiteral(checker, importName); + declarationSourceFilePaths === null || declarationSourceFilePaths === void 0 ? void 0 : declarationSourceFilePaths.forEach(addReferencedFile); + } + } + var sourceFileDirectory = ts.getDirectoryPath(sourceFile.resolvedPath); + // Handle triple slash references + if (sourceFile.referencedFiles && sourceFile.referencedFiles.length > 0) { + for (var _b = 0, _c = sourceFile.referencedFiles; _b < _c.length; _b++) { + var referencedFile = _c[_b]; + var referencedPath = getReferencedFileFromFileName(program, referencedFile.fileName, sourceFileDirectory, getCanonicalFileName); + addReferencedFile(referencedPath); + } + } + // Handle type reference directives + if (sourceFile.resolvedTypeReferenceDirectiveNames) { + sourceFile.resolvedTypeReferenceDirectiveNames.forEach(function (resolvedTypeReferenceDirective) { + if (!resolvedTypeReferenceDirective) { + return; + } + var fileName = resolvedTypeReferenceDirective.resolvedFileName; // TODO: GH#18217 + var typeFilePath = getReferencedFileFromFileName(program, fileName, sourceFileDirectory, getCanonicalFileName); + addReferencedFile(typeFilePath); + }); + } + // Add module augmentation as references + if (sourceFile.moduleAugmentations.length) { + var checker = program.getTypeChecker(); + for (var _d = 0, _e = sourceFile.moduleAugmentations; _d < _e.length; _d++) { + var moduleName = _e[_d]; + if (!ts.isStringLiteral(moduleName)) + continue; + var symbol = checker.getSymbolAtLocation(moduleName); + if (!symbol) + continue; + // Add any file other than our own as reference + addReferenceFromAmbientModule(symbol); + } + } + // From ambient modules + for (var _f = 0, _g = program.getTypeChecker().getAmbientModules(); _f < _g.length; _f++) { + var ambientModule = _g[_f]; + if (ambientModule.declarations && ambientModule.declarations.length > 1) { + addReferenceFromAmbientModule(ambientModule); + } + } + return referencedFiles; + function addReferenceFromAmbientModule(symbol) { + if (!symbol.declarations) { + return; + } + // Add any file other than our own as reference + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + var declarationSourceFile = ts.getSourceFileOfNode(declaration); + if (declarationSourceFile && + declarationSourceFile !== sourceFile) { + addReferencedFile(declarationSourceFile.resolvedPath); + } + } + } + function addReferencedFile(referencedPath) { + (referencedFiles || (referencedFiles = new ts.Set())).add(referencedPath); + } + } + /** + * Returns true if oldState is reusable, that is the emitKind = module/non module has not changed + */ + function canReuseOldState(newReferencedMap, oldState) { + return oldState && !oldState.referencedMap === !newReferencedMap; + } + BuilderState.canReuseOldState = canReuseOldState; + /** + * Creates the state of file references and signature for the new program from oldState if it is safe + */ + function create(newProgram, getCanonicalFileName, oldState, disableUseFileVersionAsSignature) { + var _a, _b, _c; + var fileInfos = new ts.Map(); + var referencedMap = newProgram.getCompilerOptions().module !== ts.ModuleKind.None ? createManyToManyPathMap() : undefined; + var exportedModulesMap = referencedMap ? createManyToManyPathMap() : undefined; + var useOldState = canReuseOldState(referencedMap, oldState); + // Ensure source files have parent pointers set + newProgram.getTypeChecker(); + // Create the reference map, and set the file infos + for (var _i = 0, _d = newProgram.getSourceFiles(); _i < _d.length; _i++) { + var sourceFile = _d[_i]; + var version_2 = ts.Debug.checkDefined(sourceFile.version, "Program intended to be used with Builder should have source files with versions set"); + var oldUncommittedSignature = useOldState ? (_a = oldState.oldSignatures) === null || _a === void 0 ? void 0 : _a.get(sourceFile.resolvedPath) : undefined; + var signature = oldUncommittedSignature === undefined ? + useOldState ? (_b = oldState.fileInfos.get(sourceFile.resolvedPath)) === null || _b === void 0 ? void 0 : _b.signature : undefined : + oldUncommittedSignature || undefined; + if (referencedMap) { + var newReferences = getReferencedFiles(newProgram, sourceFile, getCanonicalFileName); + if (newReferences) { + referencedMap.set(sourceFile.resolvedPath, newReferences); + } + // Copy old visible to outside files map + if (useOldState) { + var oldUncommittedExportedModules = (_c = oldState.oldExportedModulesMap) === null || _c === void 0 ? void 0 : _c.get(sourceFile.resolvedPath); + var exportedModules = oldUncommittedExportedModules === undefined ? + oldState.exportedModulesMap.getValues(sourceFile.resolvedPath) : + oldUncommittedExportedModules || undefined; + if (exportedModules) { + exportedModulesMap.set(sourceFile.resolvedPath, exportedModules); + } + } + } + fileInfos.set(sourceFile.resolvedPath, { + version: version_2, + signature: signature, + affectsGlobalScope: isFileAffectingGlobalScope(sourceFile) || undefined, + impliedFormat: sourceFile.impliedNodeFormat + }); + } + return { + fileInfos: fileInfos, + referencedMap: referencedMap, + exportedModulesMap: exportedModulesMap, + useFileVersionAsSignature: !disableUseFileVersionAsSignature && !useOldState + }; + } + BuilderState.create = create; + /** + * Releases needed properties + */ + function releaseCache(state) { + state.allFilesExcludingDefaultLibraryFile = undefined; + state.allFileNames = undefined; + } + BuilderState.releaseCache = releaseCache; + /** + * Gets the files affected by the path from the program + */ + function getFilesAffectedBy(state, programOfThisState, path, cancellationToken, computeHash, getCanonicalFileName) { + var _a, _b; + var result = getFilesAffectedByWithOldState(state, programOfThisState, path, cancellationToken, computeHash, getCanonicalFileName); + (_a = state.oldSignatures) === null || _a === void 0 ? void 0 : _a.clear(); + (_b = state.oldExportedModulesMap) === null || _b === void 0 ? void 0 : _b.clear(); + return result; + } + BuilderState.getFilesAffectedBy = getFilesAffectedBy; + function getFilesAffectedByWithOldState(state, programOfThisState, path, cancellationToken, computeHash, getCanonicalFileName) { + var sourceFile = programOfThisState.getSourceFileByPath(path); + if (!sourceFile) { + return ts.emptyArray; + } + if (!updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, computeHash, getCanonicalFileName)) { + return [sourceFile]; + } + return (state.referencedMap ? getFilesAffectedByUpdatedShapeWhenModuleEmit : getFilesAffectedByUpdatedShapeWhenNonModuleEmit)(state, programOfThisState, sourceFile, cancellationToken, computeHash, getCanonicalFileName); + } + BuilderState.getFilesAffectedByWithOldState = getFilesAffectedByWithOldState; + function updateSignatureOfFile(state, signature, path) { + state.fileInfos.get(path).signature = signature; + (state.hasCalledUpdateShapeSignature || (state.hasCalledUpdateShapeSignature = new ts.Set())).add(path); + } + BuilderState.updateSignatureOfFile = updateSignatureOfFile; + /** + * Returns if the shape of the signature has changed since last emit + */ + function updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, computeHash, getCanonicalFileName, useFileVersionAsSignature) { + var _a; + if (useFileVersionAsSignature === void 0) { useFileVersionAsSignature = state.useFileVersionAsSignature; } + // If we have cached the result for this file, that means hence forth we should assume file shape is uptodate + if ((_a = state.hasCalledUpdateShapeSignature) === null || _a === void 0 ? void 0 : _a.has(sourceFile.resolvedPath)) + return false; + var info = state.fileInfos.get(sourceFile.resolvedPath); + var prevSignature = info.signature; + var latestSignature; + if (!sourceFile.isDeclarationFile && !useFileVersionAsSignature) { + programOfThisState.emit(sourceFile, function (fileName, text, _writeByteOrderMark, _onError, sourceFiles, data) { + ts.Debug.assert(ts.isDeclarationFileName(fileName), "File extension for signature expected to be dts: Got:: ".concat(fileName)); + latestSignature = ts.computeSignatureWithDiagnostics(sourceFile, text, computeHash, getCanonicalFileName, data); + if (latestSignature !== prevSignature) { + updateExportedModules(state, sourceFile, sourceFiles[0].exportedModulesFromDeclarationEmit); + } + }, cancellationToken, + /*emitOnlyDtsFiles*/ true, + /*customTransformers*/ undefined, + /*forceDtsEmit*/ true); + } + // Default is to use file version as signature + if (latestSignature === undefined) { + latestSignature = sourceFile.version; + if (state.exportedModulesMap && latestSignature !== prevSignature) { + (state.oldExportedModulesMap || (state.oldExportedModulesMap = new ts.Map())).set(sourceFile.resolvedPath, state.exportedModulesMap.getValues(sourceFile.resolvedPath) || false); + // All the references in this file are exported + var references = state.referencedMap ? state.referencedMap.getValues(sourceFile.resolvedPath) : undefined; + if (references) { + state.exportedModulesMap.set(sourceFile.resolvedPath, references); + } + else { + state.exportedModulesMap.deleteKey(sourceFile.resolvedPath); + } + } + } + (state.oldSignatures || (state.oldSignatures = new ts.Map())).set(sourceFile.resolvedPath, prevSignature || false); + (state.hasCalledUpdateShapeSignature || (state.hasCalledUpdateShapeSignature = new ts.Set())).add(sourceFile.resolvedPath); + info.signature = latestSignature; + return latestSignature !== prevSignature; + } + BuilderState.updateShapeSignature = updateShapeSignature; + /** + * Coverts the declaration emit result into exported modules map + */ + function updateExportedModules(state, sourceFile, exportedModulesFromDeclarationEmit) { + if (!state.exportedModulesMap) + return; + (state.oldExportedModulesMap || (state.oldExportedModulesMap = new ts.Map())).set(sourceFile.resolvedPath, state.exportedModulesMap.getValues(sourceFile.resolvedPath) || false); + if (!exportedModulesFromDeclarationEmit) { + state.exportedModulesMap.deleteKey(sourceFile.resolvedPath); + return; + } + var exportedModules; + exportedModulesFromDeclarationEmit.forEach(function (symbol) { return addExportedModule(getReferencedFilesFromImportedModuleSymbol(symbol)); }); + if (exportedModules) { + state.exportedModulesMap.set(sourceFile.resolvedPath, exportedModules); + } + else { + state.exportedModulesMap.deleteKey(sourceFile.resolvedPath); + } + function addExportedModule(exportedModulePaths) { + if (exportedModulePaths === null || exportedModulePaths === void 0 ? void 0 : exportedModulePaths.length) { + if (!exportedModules) { + exportedModules = new ts.Set(); + } + exportedModulePaths.forEach(function (path) { return exportedModules.add(path); }); + } + } + } + BuilderState.updateExportedModules = updateExportedModules; + /** + * Get all the dependencies of the sourceFile + */ + function getAllDependencies(state, programOfThisState, sourceFile) { + var compilerOptions = programOfThisState.getCompilerOptions(); + // With --out or --outFile all outputs go into single file, all files depend on each other + if (ts.outFile(compilerOptions)) { + return getAllFileNames(state, programOfThisState); + } + // If this is non module emit, or its a global file, it depends on all the source files + if (!state.referencedMap || isFileAffectingGlobalScope(sourceFile)) { + return getAllFileNames(state, programOfThisState); + } + // Get the references, traversing deep from the referenceMap + var seenMap = new ts.Set(); + var queue = [sourceFile.resolvedPath]; + while (queue.length) { + var path = queue.pop(); + if (!seenMap.has(path)) { + seenMap.add(path); + var references = state.referencedMap.getValues(path); + if (references) { + var iterator = references.keys(); + for (var iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) { + queue.push(iterResult.value); + } + } + } + } + return ts.arrayFrom(ts.mapDefinedIterator(seenMap.keys(), function (path) { var _a, _b; return (_b = (_a = programOfThisState.getSourceFileByPath(path)) === null || _a === void 0 ? void 0 : _a.fileName) !== null && _b !== void 0 ? _b : path; })); + } + BuilderState.getAllDependencies = getAllDependencies; + /** + * Gets the names of all files from the program + */ + function getAllFileNames(state, programOfThisState) { + if (!state.allFileNames) { + var sourceFiles = programOfThisState.getSourceFiles(); + state.allFileNames = sourceFiles === ts.emptyArray ? ts.emptyArray : sourceFiles.map(function (file) { return file.fileName; }); + } + return state.allFileNames; + } + /** + * Gets the files referenced by the the file path + */ + function getReferencedByPaths(state, referencedFilePath) { + var keys = state.referencedMap.getKeys(referencedFilePath); + return keys ? ts.arrayFrom(keys.keys()) : []; + } + BuilderState.getReferencedByPaths = getReferencedByPaths; + /** + * For script files that contains only ambient external modules, although they are not actually external module files, + * they can only be consumed via importing elements from them. Regular script files cannot consume them. Therefore, + * there are no point to rebuild all script files if these special files have changed. However, if any statement + * in the file is not ambient external module, we treat it as a regular script file. + */ + function containsOnlyAmbientModules(sourceFile) { + for (var _i = 0, _a = sourceFile.statements; _i < _a.length; _i++) { + var statement = _a[_i]; + if (!ts.isModuleWithStringLiteralName(statement)) { + return false; + } + } + return true; + } + /** + * Return true if file contains anything that augments to global scope we need to build them as if + * they are global files as well as module + */ + function containsGlobalScopeAugmentation(sourceFile) { + return ts.some(sourceFile.moduleAugmentations, function (augmentation) { return ts.isGlobalScopeAugmentation(augmentation.parent); }); + } + /** + * Return true if the file will invalidate all files because it affectes global scope + */ + function isFileAffectingGlobalScope(sourceFile) { + return containsGlobalScopeAugmentation(sourceFile) || + !ts.isExternalOrCommonJsModule(sourceFile) && !ts.isJsonSourceFile(sourceFile) && !containsOnlyAmbientModules(sourceFile); + } + /** + * Gets all files of the program excluding the default library file + */ + function getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, firstSourceFile) { + // Use cached result + if (state.allFilesExcludingDefaultLibraryFile) { + return state.allFilesExcludingDefaultLibraryFile; + } + var result; + if (firstSourceFile) + addSourceFile(firstSourceFile); + for (var _i = 0, _a = programOfThisState.getSourceFiles(); _i < _a.length; _i++) { + var sourceFile = _a[_i]; + if (sourceFile !== firstSourceFile) { + addSourceFile(sourceFile); + } + } + state.allFilesExcludingDefaultLibraryFile = result || ts.emptyArray; + return state.allFilesExcludingDefaultLibraryFile; + function addSourceFile(sourceFile) { + if (!programOfThisState.isSourceFileDefaultLibrary(sourceFile)) { + (result || (result = [])).push(sourceFile); + } + } + } + BuilderState.getAllFilesExcludingDefaultLibraryFile = getAllFilesExcludingDefaultLibraryFile; + /** + * When program emits non modular code, gets the files affected by the sourceFile whose shape has changed + */ + function getFilesAffectedByUpdatedShapeWhenNonModuleEmit(state, programOfThisState, sourceFileWithUpdatedShape) { + var compilerOptions = programOfThisState.getCompilerOptions(); + // If `--out` or `--outFile` is specified, any new emit will result in re-emitting the entire project, + // so returning the file itself is good enough. + if (compilerOptions && ts.outFile(compilerOptions)) { + return [sourceFileWithUpdatedShape]; + } + return getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, sourceFileWithUpdatedShape); + } + /** + * When program emits modular code, gets the files affected by the sourceFile whose shape has changed + */ + function getFilesAffectedByUpdatedShapeWhenModuleEmit(state, programOfThisState, sourceFileWithUpdatedShape, cancellationToken, computeHash, getCanonicalFileName) { + if (isFileAffectingGlobalScope(sourceFileWithUpdatedShape)) { + return getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, sourceFileWithUpdatedShape); + } + var compilerOptions = programOfThisState.getCompilerOptions(); + if (compilerOptions && (compilerOptions.isolatedModules || ts.outFile(compilerOptions))) { + return [sourceFileWithUpdatedShape]; + } + // Now we need to if each file in the referencedBy list has a shape change as well. + // Because if so, its own referencedBy files need to be saved as well to make the + // emitting result consistent with files on disk. + var seenFileNamesMap = new ts.Map(); + // Start with the paths this file was referenced by + seenFileNamesMap.set(sourceFileWithUpdatedShape.resolvedPath, sourceFileWithUpdatedShape); + var queue = getReferencedByPaths(state, sourceFileWithUpdatedShape.resolvedPath); + while (queue.length > 0) { + var currentPath = queue.pop(); + if (!seenFileNamesMap.has(currentPath)) { + var currentSourceFile = programOfThisState.getSourceFileByPath(currentPath); + seenFileNamesMap.set(currentPath, currentSourceFile); + if (currentSourceFile && updateShapeSignature(state, programOfThisState, currentSourceFile, cancellationToken, computeHash, getCanonicalFileName)) { + queue.push.apply(queue, getReferencedByPaths(state, currentSourceFile.resolvedPath)); + } + } + } + // Return array of values that needs emit + return ts.arrayFrom(ts.mapDefinedIterator(seenFileNamesMap.values(), function (value) { return value; })); + } + })(BuilderState = ts.BuilderState || (ts.BuilderState = {})); +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + var BuilderFileEmit; + (function (BuilderFileEmit) { + BuilderFileEmit[BuilderFileEmit["DtsOnly"] = 0] = "DtsOnly"; + BuilderFileEmit[BuilderFileEmit["Full"] = 1] = "Full"; + })(BuilderFileEmit = ts.BuilderFileEmit || (ts.BuilderFileEmit = {})); + function hasSameKeys(map1, map2) { + // Has same size and every key is present in both maps + return map1 === map2 || map1 !== undefined && map2 !== undefined && map1.size === map2.size && !ts.forEachKey(map1, function (key) { return !map2.has(key); }); + } + /** + * Create the state so that we can iterate on changedFiles/affected files + */ + function createBuilderProgramState(newProgram, getCanonicalFileName, oldState, disableUseFileVersionAsSignature) { + var _a, _b; + var state = ts.BuilderState.create(newProgram, getCanonicalFileName, oldState, disableUseFileVersionAsSignature); + state.program = newProgram; + var compilerOptions = newProgram.getCompilerOptions(); + state.compilerOptions = compilerOptions; + var outFilePath = ts.outFile(compilerOptions); + // With --out or --outFile, any change affects all semantic diagnostics so no need to cache them + if (!outFilePath) { + state.semanticDiagnosticsPerFile = new ts.Map(); + } + else if (compilerOptions.composite && (oldState === null || oldState === void 0 ? void 0 : oldState.outSignature) && outFilePath === ts.outFile(oldState === null || oldState === void 0 ? void 0 : oldState.compilerOptions)) { + state.outSignature = oldState === null || oldState === void 0 ? void 0 : oldState.outSignature; + } + state.changedFilesSet = new ts.Set(); + state.latestChangedDtsFile = compilerOptions.composite ? oldState === null || oldState === void 0 ? void 0 : oldState.latestChangedDtsFile : undefined; + var useOldState = ts.BuilderState.canReuseOldState(state.referencedMap, oldState); + var oldCompilerOptions = useOldState ? oldState.compilerOptions : undefined; + var canCopySemanticDiagnostics = useOldState && oldState.semanticDiagnosticsPerFile && !!state.semanticDiagnosticsPerFile && + !ts.compilerOptionsAffectSemanticDiagnostics(compilerOptions, oldCompilerOptions); + // We can only reuse emit signatures (i.e. .d.ts signatures) if the .d.ts file is unchanged, + // which will eg be depedent on change in options like declarationDir and outDir options are unchanged. + // We need to look in oldState.compilerOptions, rather than oldCompilerOptions (i.e.we need to disregard useOldState) because + // oldCompilerOptions can be undefined if there was change in say module from None to some other option + // which would make useOldState as false since we can now use reference maps that are needed to track what to emit, what to check etc + // but that option change does not affect d.ts file name so emitSignatures should still be reused. + var canCopyEmitSignatures = compilerOptions.composite && + (oldState === null || oldState === void 0 ? void 0 : oldState.emitSignatures) && + !outFilePath && + !ts.compilerOptionsAffectDeclarationPath(compilerOptions, oldState.compilerOptions); + if (useOldState) { + // Copy old state's changed files set + (_a = oldState.changedFilesSet) === null || _a === void 0 ? void 0 : _a.forEach(function (value) { return state.changedFilesSet.add(value); }); + if (!outFilePath && oldState.affectedFilesPendingEmit) { + state.affectedFilesPendingEmit = oldState.affectedFilesPendingEmit.slice(); + state.affectedFilesPendingEmitKind = oldState.affectedFilesPendingEmitKind && new ts.Map(oldState.affectedFilesPendingEmitKind); + state.affectedFilesPendingEmitIndex = oldState.affectedFilesPendingEmitIndex; + state.seenAffectedFiles = new ts.Set(); + } + } + // Update changed files and copy semantic diagnostics if we can + var referencedMap = state.referencedMap; + var oldReferencedMap = useOldState ? oldState.referencedMap : undefined; + var copyDeclarationFileDiagnostics = canCopySemanticDiagnostics && !compilerOptions.skipLibCheck === !oldCompilerOptions.skipLibCheck; + var copyLibFileDiagnostics = copyDeclarationFileDiagnostics && !compilerOptions.skipDefaultLibCheck === !oldCompilerOptions.skipDefaultLibCheck; + state.fileInfos.forEach(function (info, sourceFilePath) { + var oldInfo; + var newReferences; + // if not using old state, every file is changed + if (!useOldState || + // File wasn't present in old state + !(oldInfo = oldState.fileInfos.get(sourceFilePath)) || + // versions dont match + oldInfo.version !== info.version || + // Implied formats dont match + oldInfo.impliedFormat !== info.impliedFormat || + // Referenced files changed + !hasSameKeys(newReferences = referencedMap && referencedMap.getValues(sourceFilePath), oldReferencedMap && oldReferencedMap.getValues(sourceFilePath)) || + // Referenced file was deleted in the new program + newReferences && ts.forEachKey(newReferences, function (path) { return !state.fileInfos.has(path) && oldState.fileInfos.has(path); })) { + // Register file as changed file and do not copy semantic diagnostics, since all changed files need to be re-evaluated + state.changedFilesSet.add(sourceFilePath); + } + else if (canCopySemanticDiagnostics) { + var sourceFile = newProgram.getSourceFileByPath(sourceFilePath); + if (sourceFile.isDeclarationFile && !copyDeclarationFileDiagnostics) + return; + if (sourceFile.hasNoDefaultLib && !copyLibFileDiagnostics) + return; + // Unchanged file copy diagnostics + var diagnostics = oldState.semanticDiagnosticsPerFile.get(sourceFilePath); + if (diagnostics) { + state.semanticDiagnosticsPerFile.set(sourceFilePath, oldState.hasReusableDiagnostic ? convertToDiagnostics(diagnostics, newProgram, getCanonicalFileName) : diagnostics); + if (!state.semanticDiagnosticsFromOldState) { + state.semanticDiagnosticsFromOldState = new ts.Set(); + } + state.semanticDiagnosticsFromOldState.add(sourceFilePath); + } + } + if (canCopyEmitSignatures) { + var oldEmitSignature = oldState.emitSignatures.get(sourceFilePath); + if (oldEmitSignature) + (state.emitSignatures || (state.emitSignatures = new ts.Map())).set(sourceFilePath, oldEmitSignature); + } + }); + // If the global file is removed, add all files as changed + if (useOldState && ts.forEachEntry(oldState.fileInfos, function (info, sourceFilePath) { return info.affectsGlobalScope && !state.fileInfos.has(sourceFilePath); })) { + ts.BuilderState.getAllFilesExcludingDefaultLibraryFile(state, newProgram, /*firstSourceFile*/ undefined) + .forEach(function (file) { return state.changedFilesSet.add(file.resolvedPath); }); + } + else if (oldCompilerOptions && !outFilePath && ts.compilerOptionsAffectEmit(compilerOptions, oldCompilerOptions)) { + // Add all files to affectedFilesPendingEmit since emit changed + newProgram.getSourceFiles().forEach(function (f) { return addToAffectedFilesPendingEmit(state, f.resolvedPath, 1 /* BuilderFileEmit.Full */); }); + ts.Debug.assert(!state.seenAffectedFiles || !state.seenAffectedFiles.size); + state.seenAffectedFiles = state.seenAffectedFiles || new ts.Set(); + } + // Since old states change files set is copied, any additional change means we would need to emit build info + state.buildInfoEmitPending = !useOldState || state.changedFilesSet.size !== (((_b = oldState.changedFilesSet) === null || _b === void 0 ? void 0 : _b.size) || 0); + return state; + } + function convertToDiagnostics(diagnostics, newProgram, getCanonicalFileName) { + if (!diagnostics.length) + return ts.emptyArray; + var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(ts.getTsBuildInfoEmitOutputFilePath(newProgram.getCompilerOptions()), newProgram.getCurrentDirectory())); + return diagnostics.map(function (diagnostic) { + var result = convertToDiagnosticRelatedInformation(diagnostic, newProgram, toPath); + result.reportsUnnecessary = diagnostic.reportsUnnecessary; + result.reportsDeprecated = diagnostic.reportDeprecated; + result.source = diagnostic.source; + result.skippedOn = diagnostic.skippedOn; + var relatedInformation = diagnostic.relatedInformation; + result.relatedInformation = relatedInformation ? + relatedInformation.length ? + relatedInformation.map(function (r) { return convertToDiagnosticRelatedInformation(r, newProgram, toPath); }) : + [] : + undefined; + return result; + }); + function toPath(path) { + return ts.toPath(path, buildInfoDirectory, getCanonicalFileName); + } + } + function convertToDiagnosticRelatedInformation(diagnostic, newProgram, toPath) { + var file = diagnostic.file; + return __assign(__assign({}, diagnostic), { file: file ? newProgram.getSourceFileByPath(toPath(file)) : undefined }); + } + /** + * Releases program and other related not needed properties + */ + function releaseCache(state) { + ts.BuilderState.releaseCache(state); + state.program = undefined; + } + function backupBuilderProgramEmitState(state) { + var outFilePath = ts.outFile(state.compilerOptions); + // Only in --out changeFileSet is kept around till emit + ts.Debug.assert(!state.changedFilesSet.size || outFilePath); + return { + affectedFilesPendingEmit: state.affectedFilesPendingEmit && state.affectedFilesPendingEmit.slice(), + affectedFilesPendingEmitKind: state.affectedFilesPendingEmitKind && new ts.Map(state.affectedFilesPendingEmitKind), + affectedFilesPendingEmitIndex: state.affectedFilesPendingEmitIndex, + seenEmittedFiles: state.seenEmittedFiles && new ts.Map(state.seenEmittedFiles), + programEmitComplete: state.programEmitComplete, + emitSignatures: state.emitSignatures && new ts.Map(state.emitSignatures), + outSignature: state.outSignature, + latestChangedDtsFile: state.latestChangedDtsFile, + hasChangedEmitSignature: state.hasChangedEmitSignature, + changedFilesSet: outFilePath ? new ts.Set(state.changedFilesSet) : undefined, + }; + } + function restoreBuilderProgramEmitState(state, savedEmitState) { + state.affectedFilesPendingEmit = savedEmitState.affectedFilesPendingEmit; + state.affectedFilesPendingEmitKind = savedEmitState.affectedFilesPendingEmitKind; + state.affectedFilesPendingEmitIndex = savedEmitState.affectedFilesPendingEmitIndex; + state.seenEmittedFiles = savedEmitState.seenEmittedFiles; + state.programEmitComplete = savedEmitState.programEmitComplete; + state.emitSignatures = savedEmitState.emitSignatures; + state.outSignature = savedEmitState.outSignature; + state.latestChangedDtsFile = savedEmitState.latestChangedDtsFile; + state.hasChangedEmitSignature = savedEmitState.hasChangedEmitSignature; + if (savedEmitState.changedFilesSet) + state.changedFilesSet = savedEmitState.changedFilesSet; + } + /** + * Verifies that source file is ok to be used in calls that arent handled by next + */ + function assertSourceFileOkWithoutNextAffectedCall(state, sourceFile) { + ts.Debug.assert(!sourceFile || !state.affectedFiles || state.affectedFiles[state.affectedFilesIndex - 1] !== sourceFile || !state.semanticDiagnosticsPerFile.has(sourceFile.resolvedPath)); + } + /** + * This function returns the next affected file to be processed. + * Note that until doneAffected is called it would keep reporting same result + * This is to allow the callers to be able to actually remove affected file only when the operation is complete + * eg. if during diagnostics check cancellation token ends up cancelling the request, the affected file should be retained + */ + function getNextAffectedFile(state, cancellationToken, computeHash, getCanonicalFileName, host) { + var _a, _b; + while (true) { + var affectedFiles = state.affectedFiles; + if (affectedFiles) { + var seenAffectedFiles = state.seenAffectedFiles; + var affectedFilesIndex = state.affectedFilesIndex; // TODO: GH#18217 + while (affectedFilesIndex < affectedFiles.length) { + var affectedFile = affectedFiles[affectedFilesIndex]; + if (!seenAffectedFiles.has(affectedFile.resolvedPath)) { + // Set the next affected file as seen and remove the cached semantic diagnostics + state.affectedFilesIndex = affectedFilesIndex; + handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, computeHash, getCanonicalFileName, host); + return affectedFile; + } + affectedFilesIndex++; + } + // Remove the changed file from the change set + state.changedFilesSet.delete(state.currentChangedFilePath); + state.currentChangedFilePath = undefined; + // Commit the changes in file signature + (_a = state.oldSignatures) === null || _a === void 0 ? void 0 : _a.clear(); + (_b = state.oldExportedModulesMap) === null || _b === void 0 ? void 0 : _b.clear(); + state.affectedFiles = undefined; + } + // Get next changed file + var nextKey = state.changedFilesSet.keys().next(); + if (nextKey.done) { + // Done + return undefined; + } + // With --out or --outFile all outputs go into single file + // so operations are performed directly on program, return program + var program = ts.Debug.checkDefined(state.program); + var compilerOptions = program.getCompilerOptions(); + if (ts.outFile(compilerOptions)) { + ts.Debug.assert(!state.semanticDiagnosticsPerFile); + return program; + } + // Get next batch of affected files + state.affectedFiles = ts.BuilderState.getFilesAffectedByWithOldState(state, program, nextKey.value, cancellationToken, computeHash, getCanonicalFileName); + state.currentChangedFilePath = nextKey.value; + state.affectedFilesIndex = 0; + if (!state.seenAffectedFiles) + state.seenAffectedFiles = new ts.Set(); + } + } + function clearAffectedFilesPendingEmit(state) { + state.affectedFilesPendingEmit = undefined; + state.affectedFilesPendingEmitKind = undefined; + state.affectedFilesPendingEmitIndex = undefined; + } + /** + * Returns next file to be emitted from files that retrieved semantic diagnostics but did not emit yet + */ + function getNextAffectedFilePendingEmit(state) { + var affectedFilesPendingEmit = state.affectedFilesPendingEmit; + if (affectedFilesPendingEmit) { + var seenEmittedFiles = (state.seenEmittedFiles || (state.seenEmittedFiles = new ts.Map())); + for (var i = state.affectedFilesPendingEmitIndex; i < affectedFilesPendingEmit.length; i++) { + var affectedFile = ts.Debug.checkDefined(state.program).getSourceFileByPath(affectedFilesPendingEmit[i]); + if (affectedFile) { + var seenKind = seenEmittedFiles.get(affectedFile.resolvedPath); + var emitKind = ts.Debug.checkDefined(ts.Debug.checkDefined(state.affectedFilesPendingEmitKind).get(affectedFile.resolvedPath)); + if (seenKind === undefined || seenKind < emitKind) { + // emit this file + state.affectedFilesPendingEmitIndex = i; + return { affectedFile: affectedFile, emitKind: emitKind }; + } + } + } + clearAffectedFilesPendingEmit(state); + } + return undefined; + } + function removeDiagnosticsOfLibraryFiles(state) { + if (!state.cleanedDiagnosticsOfLibFiles) { + state.cleanedDiagnosticsOfLibFiles = true; + var program_1 = ts.Debug.checkDefined(state.program); + var options_2 = program_1.getCompilerOptions(); + ts.forEach(program_1.getSourceFiles(), function (f) { + return program_1.isSourceFileDefaultLibrary(f) && + !ts.skipTypeChecking(f, options_2, program_1) && + removeSemanticDiagnosticsOf(state, f.resolvedPath); + }); + } + } + /** + * Handles semantic diagnostics and dts emit for affectedFile and files, that are referencing modules that export entities from affected file + * This is because even though js emit doesnt change, dts emit / type used can change resulting in need for dts emit and js change + */ + function handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, computeHash, getCanonicalFileName, host) { + removeSemanticDiagnosticsOf(state, affectedFile.resolvedPath); + // If affected files is everything except default library, then nothing more to do + if (state.allFilesExcludingDefaultLibraryFile === state.affectedFiles) { + removeDiagnosticsOfLibraryFiles(state); + // When a change affects the global scope, all files are considered to be affected without updating their signature + // That means when affected file is handled, its signature can be out of date + // To avoid this, ensure that we update the signature for any affected file in this scenario. + ts.BuilderState.updateShapeSignature(state, ts.Debug.checkDefined(state.program), affectedFile, cancellationToken, computeHash, getCanonicalFileName); + return; + } + if (state.compilerOptions.assumeChangesOnlyAffectDirectDependencies) + return; + handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, computeHash, getCanonicalFileName, host); + } + /** + * Handle the dts may change, so they need to be added to pending emit if dts emit is enabled, + * Also we need to make sure signature is updated for these files + */ + function handleDtsMayChangeOf(state, path, cancellationToken, computeHash, getCanonicalFileName, host) { + removeSemanticDiagnosticsOf(state, path); + if (!state.changedFilesSet.has(path)) { + var program = ts.Debug.checkDefined(state.program); + var sourceFile = program.getSourceFileByPath(path); + if (sourceFile) { + // Even though the js emit doesnt change and we are already handling dts emit and semantic diagnostics + // we need to update the signature to reflect correctness of the signature(which is output d.ts emit) of this file + // This ensures that we dont later during incremental builds considering wrong signature. + // Eg where this also is needed to ensure that .tsbuildinfo generated by incremental build should be same as if it was first fresh build + // But we avoid expensive full shape computation, as using file version as shape is enough for correctness. + ts.BuilderState.updateShapeSignature(state, program, sourceFile, cancellationToken, computeHash, getCanonicalFileName, !host.disableUseFileVersionAsSignature); + // If not dts emit, nothing more to do + if (ts.getEmitDeclarations(state.compilerOptions)) { + addToAffectedFilesPendingEmit(state, path, 0 /* BuilderFileEmit.DtsOnly */); + } + } + } + } + /** + * Removes semantic diagnostics for path and + * returns true if there are no more semantic diagnostics from the old state + */ + function removeSemanticDiagnosticsOf(state, path) { + if (!state.semanticDiagnosticsFromOldState) { + return true; + } + state.semanticDiagnosticsFromOldState.delete(path); + state.semanticDiagnosticsPerFile.delete(path); + return !state.semanticDiagnosticsFromOldState.size; + } + function isChangedSignature(state, path) { + var oldSignature = ts.Debug.checkDefined(state.oldSignatures).get(path) || undefined; + var newSignature = ts.Debug.checkDefined(state.fileInfos.get(path)).signature; + return newSignature !== oldSignature; + } + function handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, computeHash, getCanonicalFileName, host) { + var _a; + if (!((_a = state.fileInfos.get(filePath)) === null || _a === void 0 ? void 0 : _a.affectsGlobalScope)) + return false; + // Every file needs to be handled + ts.BuilderState.getAllFilesExcludingDefaultLibraryFile(state, state.program, /*firstSourceFile*/ undefined) + .forEach(function (file) { return handleDtsMayChangeOf(state, file.resolvedPath, cancellationToken, computeHash, getCanonicalFileName, host); }); + removeDiagnosticsOfLibraryFiles(state); + return true; + } + /** + * Iterate on referencing modules that export entities from affected file and delete diagnostics and add pending emit + */ + function handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, computeHash, getCanonicalFileName, host) { + var _a; + // If there was change in signature (dts output) for the changed file, + // then only we need to handle pending file emit + if (!state.exportedModulesMap || !state.changedFilesSet.has(affectedFile.resolvedPath)) + return; + if (!isChangedSignature(state, affectedFile.resolvedPath)) + return; + // Since isolated modules dont change js files, files affected by change in signature is itself + // But we need to cleanup semantic diagnostics and queue dts emit for affected files + if (state.compilerOptions.isolatedModules) { + var seenFileNamesMap = new ts.Map(); + seenFileNamesMap.set(affectedFile.resolvedPath, true); + var queue = ts.BuilderState.getReferencedByPaths(state, affectedFile.resolvedPath); + while (queue.length > 0) { + var currentPath = queue.pop(); + if (!seenFileNamesMap.has(currentPath)) { + seenFileNamesMap.set(currentPath, true); + if (handleDtsMayChangeOfGlobalScope(state, currentPath, cancellationToken, computeHash, getCanonicalFileName, host)) + return; + handleDtsMayChangeOf(state, currentPath, cancellationToken, computeHash, getCanonicalFileName, host); + if (isChangedSignature(state, currentPath)) { + var currentSourceFile = ts.Debug.checkDefined(state.program).getSourceFileByPath(currentPath); + queue.push.apply(queue, ts.BuilderState.getReferencedByPaths(state, currentSourceFile.resolvedPath)); + } + } + } + } + var seenFileAndExportsOfFile = new ts.Set(); + // Go through exported modules from cache first + // If exported modules has path, all files referencing file exported from are affected + (_a = state.exportedModulesMap.getKeys(affectedFile.resolvedPath)) === null || _a === void 0 ? void 0 : _a.forEach(function (exportedFromPath) { + if (handleDtsMayChangeOfGlobalScope(state, exportedFromPath, cancellationToken, computeHash, getCanonicalFileName, host)) + return true; + var references = state.referencedMap.getKeys(exportedFromPath); + return references && ts.forEachKey(references, function (filePath) { + return handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, cancellationToken, computeHash, getCanonicalFileName, host); + }); + }); + } + /** + * handle dts and semantic diagnostics on file and iterate on anything that exports this file + * return true when all work is done and we can exit handling dts emit and semantic diagnostics + */ + function handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, cancellationToken, computeHash, getCanonicalFileName, host) { + var _a, _b; + if (!ts.tryAddToSet(seenFileAndExportsOfFile, filePath)) + return undefined; + if (handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, computeHash, getCanonicalFileName, host)) + return true; + handleDtsMayChangeOf(state, filePath, cancellationToken, computeHash, getCanonicalFileName, host); + // If exported modules has path, all files referencing file exported from are affected + (_a = state.exportedModulesMap.getKeys(filePath)) === null || _a === void 0 ? void 0 : _a.forEach(function (exportedFromPath) { + return handleDtsMayChangeOfFileAndExportsOfFile(state, exportedFromPath, seenFileAndExportsOfFile, cancellationToken, computeHash, getCanonicalFileName, host); + }); + // Remove diagnostics of files that import this file (without going to exports of referencing files) + (_b = state.referencedMap.getKeys(filePath)) === null || _b === void 0 ? void 0 : _b.forEach(function (referencingFilePath) { + return !seenFileAndExportsOfFile.has(referencingFilePath) && // Not already removed diagnostic file + handleDtsMayChangeOf(// Dont add to seen since this is not yet done with the export removal + state, referencingFilePath, cancellationToken, computeHash, getCanonicalFileName, host); + }); + return undefined; + } + /** + * This is called after completing operation on the next affected file. + * The operations here are postponed to ensure that cancellation during the iteration is handled correctly + */ + function doneWithAffectedFile(state, affected, emitKind, isPendingEmit, isBuildInfoEmit) { + if (isBuildInfoEmit) { + state.buildInfoEmitPending = false; + } + else if (affected === state.program) { + state.changedFilesSet.clear(); + state.programEmitComplete = true; + } + else { + state.seenAffectedFiles.add(affected.resolvedPath); + // Change in changeSet/affectedFilesPendingEmit, buildInfo needs to be emitted + state.buildInfoEmitPending = true; + if (emitKind !== undefined) { + (state.seenEmittedFiles || (state.seenEmittedFiles = new ts.Map())).set(affected.resolvedPath, emitKind); + } + if (isPendingEmit) { + state.affectedFilesPendingEmitIndex++; + } + else { + state.affectedFilesIndex++; + } + } + } + /** + * Returns the result with affected file + */ + function toAffectedFileResult(state, result, affected) { + doneWithAffectedFile(state, affected); + return { result: result, affected: affected }; + } + /** + * Returns the result with affected file + */ + function toAffectedFileEmitResult(state, result, affected, emitKind, isPendingEmit, isBuildInfoEmit) { + doneWithAffectedFile(state, affected, emitKind, isPendingEmit, isBuildInfoEmit); + return { result: result, affected: affected }; + } + /** + * Gets semantic diagnostics for the file which are + * bindAndCheckDiagnostics (from cache) and program diagnostics + */ + function getSemanticDiagnosticsOfFile(state, sourceFile, cancellationToken) { + return ts.concatenate(getBinderAndCheckerDiagnosticsOfFile(state, sourceFile, cancellationToken), ts.Debug.checkDefined(state.program).getProgramDiagnostics(sourceFile)); + } + /** + * Gets the binder and checker diagnostics either from cache if present, or otherwise from program and caches it + * Note that it is assumed that when asked about binder and checker diagnostics, the file has been taken out of affected files/changed file set + */ + function getBinderAndCheckerDiagnosticsOfFile(state, sourceFile, cancellationToken) { + var path = sourceFile.resolvedPath; + if (state.semanticDiagnosticsPerFile) { + var cachedDiagnostics = state.semanticDiagnosticsPerFile.get(path); + // Report the bind and check diagnostics from the cache if we already have those diagnostics present + if (cachedDiagnostics) { + return ts.filterSemanticDiagnostics(cachedDiagnostics, state.compilerOptions); + } + } + // Diagnostics werent cached, get them from program, and cache the result + var diagnostics = ts.Debug.checkDefined(state.program).getBindAndCheckDiagnostics(sourceFile, cancellationToken); + if (state.semanticDiagnosticsPerFile) { + state.semanticDiagnosticsPerFile.set(path, diagnostics); + } + return ts.filterSemanticDiagnostics(diagnostics, state.compilerOptions); + } + function isProgramBundleEmitBuildInfo(info) { + return !!ts.outFile(info.options || {}); + } + ts.isProgramBundleEmitBuildInfo = isProgramBundleEmitBuildInfo; + /** + * Gets the program information to be emitted in buildInfo so that we can use it to create new program + */ + function getProgramBuildInfo(state, getCanonicalFileName) { + var outFilePath = ts.outFile(state.compilerOptions); + if (outFilePath && !state.compilerOptions.composite) + return; + var currentDirectory = ts.Debug.checkDefined(state.program).getCurrentDirectory(); + var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(ts.getTsBuildInfoEmitOutputFilePath(state.compilerOptions), currentDirectory)); + // Convert the file name to Path here if we set the fileName instead to optimize multiple d.ts file emits and having to compute Canonical path + var latestChangedDtsFile = state.latestChangedDtsFile ? relativeToBuildInfoEnsuringAbsolutePath(state.latestChangedDtsFile) : undefined; + if (outFilePath) { + var fileNames_1 = []; + var fileInfos_1 = []; + state.program.getRootFileNames().forEach(function (f) { + var sourceFile = state.program.getSourceFile(f); + if (!sourceFile) + return; + fileNames_1.push(relativeToBuildInfo(sourceFile.resolvedPath)); + fileInfos_1.push(sourceFile.version); + }); + var result_15 = { + fileNames: fileNames_1, + fileInfos: fileInfos_1, + options: convertToProgramBuildInfoCompilerOptions(state.compilerOptions, "affectsBundleEmitBuildInfo"), + outSignature: state.outSignature, + latestChangedDtsFile: latestChangedDtsFile, + }; + return result_15; + } + var fileNames = []; + var fileNameToFileId = new ts.Map(); + var fileIdsList; + var fileNamesToFileIdListId; + var emitSignatures; + var fileInfos = ts.arrayFrom(state.fileInfos.entries(), function (_a) { + var _b, _c; + var key = _a[0], value = _a[1]; + // Ensure fileId + var fileId = toFileId(key); + ts.Debug.assert(fileNames[fileId - 1] === relativeToBuildInfo(key)); + var oldSignature = (_b = state.oldSignatures) === null || _b === void 0 ? void 0 : _b.get(key); + var actualSignature = oldSignature !== undefined ? oldSignature || undefined : value.signature; + if (state.compilerOptions.composite) { + var file = state.program.getSourceFileByPath(key); + if (!ts.isJsonSourceFile(file) && ts.sourceFileMayBeEmitted(file, state.program)) { + var emitSignature = (_c = state.emitSignatures) === null || _c === void 0 ? void 0 : _c.get(key); + if (emitSignature !== actualSignature) { + (emitSignatures || (emitSignatures = [])).push(emitSignature === undefined ? fileId : [fileId, emitSignature]); + } + } + } + return value.version === actualSignature ? + value.affectsGlobalScope || value.impliedFormat ? + // If file version is same as signature, dont serialize signature + { version: value.version, signature: undefined, affectsGlobalScope: value.affectsGlobalScope, impliedFormat: value.impliedFormat } : + // If file info only contains version and signature and both are same we can just write string + value.version : + actualSignature !== undefined ? // If signature is not same as version, encode signature in the fileInfo + oldSignature === undefined ? + // If we havent computed signature, use fileInfo as is + value : + // Serialize fileInfo with new updated signature + { version: value.version, signature: actualSignature, affectsGlobalScope: value.affectsGlobalScope, impliedFormat: value.impliedFormat } : + // Signature of the FileInfo is undefined, serialize it as false + { version: value.version, signature: false, affectsGlobalScope: value.affectsGlobalScope, impliedFormat: value.impliedFormat }; + }); + var referencedMap; + if (state.referencedMap) { + referencedMap = ts.arrayFrom(state.referencedMap.keys()).sort(ts.compareStringsCaseSensitive).map(function (key) { return [ + toFileId(key), + toFileIdListId(state.referencedMap.getValues(key)) + ]; }); + } + var exportedModulesMap; + if (state.exportedModulesMap) { + exportedModulesMap = ts.mapDefined(ts.arrayFrom(state.exportedModulesMap.keys()).sort(ts.compareStringsCaseSensitive), function (key) { + var _a; + var oldValue = (_a = state.oldExportedModulesMap) === null || _a === void 0 ? void 0 : _a.get(key); + // Not in temporary cache, use existing value + if (oldValue === undefined) + return [toFileId(key), toFileIdListId(state.exportedModulesMap.getValues(key))]; + if (oldValue) + return [toFileId(key), toFileIdListId(oldValue)]; + return undefined; + }); + } + var semanticDiagnosticsPerFile; + if (state.semanticDiagnosticsPerFile) { + for (var _i = 0, _a = ts.arrayFrom(state.semanticDiagnosticsPerFile.keys()).sort(ts.compareStringsCaseSensitive); _i < _a.length; _i++) { + var key = _a[_i]; + var value = state.semanticDiagnosticsPerFile.get(key); + (semanticDiagnosticsPerFile || (semanticDiagnosticsPerFile = [])).push(value.length ? + [ + toFileId(key), + convertToReusableDiagnostics(value, relativeToBuildInfo) + ] : + toFileId(key)); + } + } + var affectedFilesPendingEmit; + if (state.affectedFilesPendingEmit) { + var seenFiles = new ts.Set(); + for (var _b = 0, _c = state.affectedFilesPendingEmit.slice(state.affectedFilesPendingEmitIndex).sort(ts.compareStringsCaseSensitive); _b < _c.length; _b++) { + var path = _c[_b]; + if (ts.tryAddToSet(seenFiles, path)) { + (affectedFilesPendingEmit || (affectedFilesPendingEmit = [])).push([toFileId(path), state.affectedFilesPendingEmitKind.get(path)]); + } + } + } + var changeFileSet; + if (state.changedFilesSet.size) { + for (var _d = 0, _e = ts.arrayFrom(state.changedFilesSet.keys()).sort(ts.compareStringsCaseSensitive); _d < _e.length; _d++) { + var path = _e[_d]; + (changeFileSet || (changeFileSet = [])).push(toFileId(path)); + } + } + var result = { + fileNames: fileNames, + fileInfos: fileInfos, + options: convertToProgramBuildInfoCompilerOptions(state.compilerOptions, "affectsMultiFileEmitBuildInfo"), + fileIdsList: fileIdsList, + referencedMap: referencedMap, + exportedModulesMap: exportedModulesMap, + semanticDiagnosticsPerFile: semanticDiagnosticsPerFile, + affectedFilesPendingEmit: affectedFilesPendingEmit, + changeFileSet: changeFileSet, + emitSignatures: emitSignatures, + latestChangedDtsFile: latestChangedDtsFile, + }; + return result; + function relativeToBuildInfoEnsuringAbsolutePath(path) { + return relativeToBuildInfo(ts.getNormalizedAbsolutePath(path, currentDirectory)); + } + function relativeToBuildInfo(path) { + return ts.ensurePathIsNonModuleName(ts.getRelativePathFromDirectory(buildInfoDirectory, path, getCanonicalFileName)); + } + function toFileId(path) { + var fileId = fileNameToFileId.get(path); + if (fileId === undefined) { + fileNames.push(relativeToBuildInfo(path)); + fileNameToFileId.set(path, fileId = fileNames.length); + } + return fileId; + } + function toFileIdListId(set) { + var fileIds = ts.arrayFrom(set.keys(), toFileId).sort(ts.compareValues); + var key = fileIds.join(); + var fileIdListId = fileNamesToFileIdListId === null || fileNamesToFileIdListId === void 0 ? void 0 : fileNamesToFileIdListId.get(key); + if (fileIdListId === undefined) { + (fileIdsList || (fileIdsList = [])).push(fileIds); + (fileNamesToFileIdListId || (fileNamesToFileIdListId = new ts.Map())).set(key, fileIdListId = fileIdsList.length); + } + return fileIdListId; + } + /** + * @param optionKey key of CommandLineOption to use to determine if the option should be serialized in tsbuildinfo + */ + function convertToProgramBuildInfoCompilerOptions(options, optionKey) { + var result; + var optionsNameMap = ts.getOptionsNameMap().optionsNameMap; + for (var _i = 0, _a = ts.getOwnKeys(options).sort(ts.compareStringsCaseSensitive); _i < _a.length; _i++) { + var name = _a[_i]; + var optionInfo = optionsNameMap.get(name.toLowerCase()); + if (optionInfo === null || optionInfo === void 0 ? void 0 : optionInfo[optionKey]) { + (result || (result = {}))[name] = convertToReusableCompilerOptionValue(optionInfo, options[name], relativeToBuildInfoEnsuringAbsolutePath); + } + } + return result; + } + } + function convertToReusableCompilerOptionValue(option, value, relativeToBuildInfo) { + if (option) { + if (option.type === "list") { + var values = value; + if (option.element.isFilePath && values.length) { + return values.map(relativeToBuildInfo); + } + } + else if (option.isFilePath) { + return relativeToBuildInfo(value); + } + } + return value; + } + function convertToReusableDiagnostics(diagnostics, relativeToBuildInfo) { + ts.Debug.assert(!!diagnostics.length); + return diagnostics.map(function (diagnostic) { + var result = convertToReusableDiagnosticRelatedInformation(diagnostic, relativeToBuildInfo); + result.reportsUnnecessary = diagnostic.reportsUnnecessary; + result.reportDeprecated = diagnostic.reportsDeprecated; + result.source = diagnostic.source; + result.skippedOn = diagnostic.skippedOn; + var relatedInformation = diagnostic.relatedInformation; + result.relatedInformation = relatedInformation ? + relatedInformation.length ? + relatedInformation.map(function (r) { return convertToReusableDiagnosticRelatedInformation(r, relativeToBuildInfo); }) : + [] : + undefined; + return result; + }); + } + function convertToReusableDiagnosticRelatedInformation(diagnostic, relativeToBuildInfo) { + var file = diagnostic.file; + return __assign(__assign({}, diagnostic), { file: file ? relativeToBuildInfo(file.resolvedPath) : undefined }); + } + var BuilderProgramKind; + (function (BuilderProgramKind) { + BuilderProgramKind[BuilderProgramKind["SemanticDiagnosticsBuilderProgram"] = 0] = "SemanticDiagnosticsBuilderProgram"; + BuilderProgramKind[BuilderProgramKind["EmitAndSemanticDiagnosticsBuilderProgram"] = 1] = "EmitAndSemanticDiagnosticsBuilderProgram"; + })(BuilderProgramKind = ts.BuilderProgramKind || (ts.BuilderProgramKind = {})); + function getBuilderCreationParameters(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences) { + var host; + var newProgram; + var oldProgram; + if (newProgramOrRootNames === undefined) { + ts.Debug.assert(hostOrOptions === undefined); + host = oldProgramOrHost; + oldProgram = configFileParsingDiagnosticsOrOldProgram; + ts.Debug.assert(!!oldProgram); + newProgram = oldProgram.getProgram(); + } + else if (ts.isArray(newProgramOrRootNames)) { + oldProgram = configFileParsingDiagnosticsOrOldProgram; + newProgram = ts.createProgram({ + rootNames: newProgramOrRootNames, + options: hostOrOptions, + host: oldProgramOrHost, + oldProgram: oldProgram && oldProgram.getProgramOrUndefined(), + configFileParsingDiagnostics: configFileParsingDiagnostics, + projectReferences: projectReferences + }); + host = oldProgramOrHost; + } + else { + newProgram = newProgramOrRootNames; + host = hostOrOptions; + oldProgram = oldProgramOrHost; + configFileParsingDiagnostics = configFileParsingDiagnosticsOrOldProgram; + } + return { host: host, newProgram: newProgram, oldProgram: oldProgram, configFileParsingDiagnostics: configFileParsingDiagnostics || ts.emptyArray }; + } + ts.getBuilderCreationParameters = getBuilderCreationParameters; + function getTextHandlingSourceMapForSignature(text, data) { + return (data === null || data === void 0 ? void 0 : data.sourceMapUrlPos) !== undefined ? text.substring(0, data.sourceMapUrlPos) : text; + } + function computeSignatureWithDiagnostics(sourceFile, text, computeHash, getCanonicalFileName, data) { + var _a; + text = getTextHandlingSourceMapForSignature(text, data); + var sourceFileDirectory; + if ((_a = data === null || data === void 0 ? void 0 : data.diagnostics) === null || _a === void 0 ? void 0 : _a.length) { + text += data.diagnostics.map(function (diagnostic) { + return "".concat(locationInfo(diagnostic)).concat(ts.DiagnosticCategory[diagnostic.category]).concat(diagnostic.code, ": ").concat(flattenDiagnosticMessageText(diagnostic.messageText)); + }).join("\n"); + } + return (computeHash !== null && computeHash !== void 0 ? computeHash : ts.generateDjb2Hash)(text); + function flattenDiagnosticMessageText(diagnostic) { + return ts.isString(diagnostic) ? + diagnostic : + diagnostic === undefined ? + "" : + !diagnostic.next ? + diagnostic.messageText : + diagnostic.messageText + diagnostic.next.map(flattenDiagnosticMessageText).join("\n"); + } + function locationInfo(diagnostic) { + if (diagnostic.file.resolvedPath === sourceFile.resolvedPath) + return "(".concat(diagnostic.start, ",").concat(diagnostic.length, ")"); + if (sourceFileDirectory === undefined) + sourceFileDirectory = ts.getDirectoryPath(sourceFile.resolvedPath); + return "".concat(ts.ensurePathIsNonModuleName(ts.getRelativePathFromDirectory(sourceFileDirectory, diagnostic.file.resolvedPath, getCanonicalFileName)), "(").concat(diagnostic.start, ",").concat(diagnostic.length, ")"); + } + } + ts.computeSignatureWithDiagnostics = computeSignatureWithDiagnostics; + function computeSignature(text, computeHash, data) { + return (computeHash !== null && computeHash !== void 0 ? computeHash : ts.generateDjb2Hash)(getTextHandlingSourceMapForSignature(text, data)); + } + ts.computeSignature = computeSignature; + function createBuilderProgram(kind, _a) { + var newProgram = _a.newProgram, host = _a.host, oldProgram = _a.oldProgram, configFileParsingDiagnostics = _a.configFileParsingDiagnostics; + // Return same program if underlying program doesnt change + var oldState = oldProgram && oldProgram.getState(); + if (oldState && newProgram === oldState.program && configFileParsingDiagnostics === newProgram.getConfigFileParsingDiagnostics()) { + newProgram = undefined; // TODO: GH#18217 + oldState = undefined; + return oldProgram; + } + /** + * Create the canonical file name for identity + */ + var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames()); + /** + * Computing hash to for signature verification + */ + var computeHash = ts.maybeBind(host, host.createHash); + var state = createBuilderProgramState(newProgram, getCanonicalFileName, oldState, host.disableUseFileVersionAsSignature); + newProgram.getProgramBuildInfo = function () { return getProgramBuildInfo(state, getCanonicalFileName); }; + // To ensure that we arent storing any references to old program or new program without state + newProgram = undefined; // TODO: GH#18217 + oldProgram = undefined; + oldState = undefined; + var getState = function () { return state; }; + var builderProgram = createRedirectedBuilderProgram(getState, configFileParsingDiagnostics); + builderProgram.getState = getState; + builderProgram.saveEmitState = function () { return backupBuilderProgramEmitState(state); }; + builderProgram.restoreEmitState = function (saved) { return restoreBuilderProgramEmitState(state, saved); }; + builderProgram.hasChangedEmitSignature = function () { return !!state.hasChangedEmitSignature; }; + builderProgram.getAllDependencies = function (sourceFile) { return ts.BuilderState.getAllDependencies(state, ts.Debug.checkDefined(state.program), sourceFile); }; + builderProgram.getSemanticDiagnostics = getSemanticDiagnostics; + builderProgram.emit = emit; + builderProgram.releaseProgram = function () { return releaseCache(state); }; + if (kind === BuilderProgramKind.SemanticDiagnosticsBuilderProgram) { + builderProgram.getSemanticDiagnosticsOfNextAffectedFile = getSemanticDiagnosticsOfNextAffectedFile; + } + else if (kind === BuilderProgramKind.EmitAndSemanticDiagnosticsBuilderProgram) { + builderProgram.getSemanticDiagnosticsOfNextAffectedFile = getSemanticDiagnosticsOfNextAffectedFile; + builderProgram.emitNextAffectedFile = emitNextAffectedFile; + builderProgram.emitBuildInfo = emitBuildInfo; + } + else { + ts.notImplemented(); + } + return builderProgram; + function emitBuildInfo(writeFile, cancellationToken) { + if (state.buildInfoEmitPending) { + var result = ts.Debug.checkDefined(state.program).emitBuildInfo(writeFile || ts.maybeBind(host, host.writeFile), cancellationToken); + state.buildInfoEmitPending = false; + return result; + } + return ts.emitSkippedWithNoDiagnostics; + } + /** + * Emits the next affected file's emit result (EmitResult and sourceFiles emitted) or returns undefined if iteration is complete + * The first of writeFile if provided, writeFile of BuilderProgramHost if provided, writeFile of compiler host + * in that order would be used to write the files + */ + function emitNextAffectedFile(writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) { + var affected = getNextAffectedFile(state, cancellationToken, computeHash, getCanonicalFileName, host); + var emitKind = 1 /* BuilderFileEmit.Full */; + var isPendingEmitFile = false; + if (!affected) { + if (!ts.outFile(state.compilerOptions)) { + var pendingAffectedFile = getNextAffectedFilePendingEmit(state); + if (!pendingAffectedFile) { + if (!state.buildInfoEmitPending) { + return undefined; + } + var affected_1 = ts.Debug.checkDefined(state.program); + return toAffectedFileEmitResult(state, + // When whole program is affected, do emit only once (eg when --out or --outFile is specified) + // Otherwise just affected file + affected_1.emitBuildInfo(writeFile || ts.maybeBind(host, host.writeFile), cancellationToken), affected_1, 1 /* BuilderFileEmit.Full */, + /*isPendingEmitFile*/ false, + /*isBuildInfoEmit*/ true); + } + (affected = pendingAffectedFile.affectedFile, emitKind = pendingAffectedFile.emitKind); + isPendingEmitFile = true; + } + else { + var program = ts.Debug.checkDefined(state.program); + if (state.programEmitComplete) + return undefined; + affected = program; + } + } + return toAffectedFileEmitResult(state, + // When whole program is affected, do emit only once (eg when --out or --outFile is specified) + // Otherwise just affected file + ts.Debug.checkDefined(state.program).emit(affected === state.program ? undefined : affected, ts.getEmitDeclarations(state.compilerOptions) ? + getWriteFileCallback(writeFile, customTransformers) : + writeFile || ts.maybeBind(host, host.writeFile), cancellationToken, emitOnlyDtsFiles || emitKind === 0 /* BuilderFileEmit.DtsOnly */, customTransformers), affected, emitKind, isPendingEmitFile); + } + function getWriteFileCallback(writeFile, customTransformers) { + return function (fileName, text, writeByteOrderMark, onError, sourceFiles, data) { + var _a, _b, _c, _d, _e, _f, _g; + if (ts.isDeclarationFileName(fileName)) { + if (!ts.outFile(state.compilerOptions)) { + ts.Debug.assert((sourceFiles === null || sourceFiles === void 0 ? void 0 : sourceFiles.length) === 1); + var emitSignature = void 0; + if (!customTransformers) { + var file = sourceFiles[0]; + var info = state.fileInfos.get(file.resolvedPath); + if (info.signature === file.version) { + var signature = computeSignatureWithDiagnostics(file, text, computeHash, getCanonicalFileName, data); + // With d.ts diagnostics they are also part of the signature so emitSignature will be different from it since its just hash of d.ts + if (!((_a = data === null || data === void 0 ? void 0 : data.diagnostics) === null || _a === void 0 ? void 0 : _a.length)) + emitSignature = signature; + if (signature !== file.version) { // Update it + if (host.storeFilesChangingSignatureDuringEmit) + ((_b = state.filesChangingSignature) !== null && _b !== void 0 ? _b : (state.filesChangingSignature = new ts.Set())).add(file.resolvedPath); + if (state.exportedModulesMap) + ts.BuilderState.updateExportedModules(state, file, file.exportedModulesFromDeclarationEmit); + if (state.affectedFiles) { + // Keep old signature so we know what to undo if cancellation happens + var existing = (_c = state.oldSignatures) === null || _c === void 0 ? void 0 : _c.get(file.resolvedPath); + if (existing === undefined) + ((_d = state.oldSignatures) !== null && _d !== void 0 ? _d : (state.oldSignatures = new ts.Map())).set(file.resolvedPath, info.signature || false); + info.signature = signature; + } + else { + // These are directly commited + info.signature = signature; + (_e = state.oldExportedModulesMap) === null || _e === void 0 ? void 0 : _e.clear(); + } + } + } + } + // Store d.ts emit hash so later can be compared to check if d.ts has changed. + // Currently we do this only for composite projects since these are the only projects that can be referenced by other projects + // and would need their d.ts change time in --build mode + if (state.compilerOptions.composite) { + var filePath = sourceFiles[0].resolvedPath; + var oldSignature = (_f = state.emitSignatures) === null || _f === void 0 ? void 0 : _f.get(filePath); + emitSignature !== null && emitSignature !== void 0 ? emitSignature : (emitSignature = computeSignature(text, computeHash, data)); + // Dont write dts files if they didn't change + if (emitSignature === oldSignature) + return; + ((_g = state.emitSignatures) !== null && _g !== void 0 ? _g : (state.emitSignatures = new ts.Map())).set(filePath, emitSignature); + state.hasChangedEmitSignature = true; + state.latestChangedDtsFile = fileName; + } + } + else if (state.compilerOptions.composite) { + var newSignature = computeSignature(text, computeHash, data); + // Dont write dts files if they didn't change + if (newSignature === state.outSignature) + return; + state.outSignature = newSignature; + state.hasChangedEmitSignature = true; + state.latestChangedDtsFile = fileName; + } + } + if (writeFile) + writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, data); + else if (host.writeFile) + host.writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, data); + else + state.program.writeFile(fileName, text, writeByteOrderMark, onError, sourceFiles, data); + }; + } + /** + * Emits the JavaScript and declaration files. + * When targetSource file is specified, emits the files corresponding to that source file, + * otherwise for the whole program. + * In case of EmitAndSemanticDiagnosticsBuilderProgram, when targetSourceFile is specified, + * it is assumed that that file is handled from affected file list. If targetSourceFile is not specified, + * it will only emit all the affected files instead of whole program + * + * The first of writeFile if provided, writeFile of BuilderProgramHost if provided, writeFile of compiler host + * in that order would be used to write the files + */ + function emit(targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) { + var _a; + if (kind === BuilderProgramKind.EmitAndSemanticDiagnosticsBuilderProgram) { + assertSourceFileOkWithoutNextAffectedCall(state, targetSourceFile); + } + var result = ts.handleNoEmitOptions(builderProgram, targetSourceFile, writeFile, cancellationToken); + if (result) + return result; + // Emit only affected files if using builder for emit + if (!targetSourceFile) { + if (kind === BuilderProgramKind.EmitAndSemanticDiagnosticsBuilderProgram) { + // Emit and report any errors we ran into. + var sourceMaps = []; + var emitSkipped = false; + var diagnostics = void 0; + var emittedFiles = []; + var affectedEmitResult = void 0; + while (affectedEmitResult = emitNextAffectedFile(writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers)) { + emitSkipped = emitSkipped || affectedEmitResult.result.emitSkipped; + diagnostics = ts.addRange(diagnostics, affectedEmitResult.result.diagnostics); + emittedFiles = ts.addRange(emittedFiles, affectedEmitResult.result.emittedFiles); + sourceMaps = ts.addRange(sourceMaps, affectedEmitResult.result.sourceMaps); + } + return { + emitSkipped: emitSkipped, + diagnostics: diagnostics || ts.emptyArray, + emittedFiles: emittedFiles, + sourceMaps: sourceMaps + }; + } + // In non Emit builder, clear affected files pending emit + else if ((_a = state.affectedFilesPendingEmitKind) === null || _a === void 0 ? void 0 : _a.size) { + ts.Debug.assert(kind === BuilderProgramKind.SemanticDiagnosticsBuilderProgram); + // State can clear affected files pending emit if + if (!emitOnlyDtsFiles // If we are doing complete emit, affected files pending emit can be cleared + // If every file pending emit is pending on only dts emit + || ts.every(state.affectedFilesPendingEmit, function (path, index) { + return index < state.affectedFilesPendingEmitIndex || + state.affectedFilesPendingEmitKind.get(path) === 0 /* BuilderFileEmit.DtsOnly */; + })) { + clearAffectedFilesPendingEmit(state); + } + } + } + return ts.Debug.checkDefined(state.program).emit(targetSourceFile, ts.getEmitDeclarations(state.compilerOptions) ? + getWriteFileCallback(writeFile, customTransformers) : + writeFile || ts.maybeBind(host, host.writeFile), cancellationToken, emitOnlyDtsFiles, customTransformers); + } + /** + * Return the semantic diagnostics for the next affected file or undefined if iteration is complete + * If provided ignoreSourceFile would be called before getting the diagnostics and would ignore the sourceFile if the returned value was true + */ + function getSemanticDiagnosticsOfNextAffectedFile(cancellationToken, ignoreSourceFile) { + while (true) { + var affected = getNextAffectedFile(state, cancellationToken, computeHash, getCanonicalFileName, host); + if (!affected) { + // Done + return undefined; + } + else if (affected === state.program) { + // When whole program is affected, get all semantic diagnostics (eg when --out or --outFile is specified) + return toAffectedFileResult(state, state.program.getSemanticDiagnostics(/*targetSourceFile*/ undefined, cancellationToken), affected); + } + // Add file to affected file pending emit to handle for later emit time + // Apart for emit builder do this for tsbuildinfo, do this for non emit builder when noEmit is set as tsbuildinfo is written and reused between emitters + if (kind === BuilderProgramKind.EmitAndSemanticDiagnosticsBuilderProgram || state.compilerOptions.noEmit || state.compilerOptions.noEmitOnError) { + addToAffectedFilesPendingEmit(state, affected.resolvedPath, 1 /* BuilderFileEmit.Full */); + } + // Get diagnostics for the affected file if its not ignored + if (ignoreSourceFile && ignoreSourceFile(affected)) { + // Get next affected file + doneWithAffectedFile(state, affected); + continue; + } + return toAffectedFileResult(state, getSemanticDiagnosticsOfFile(state, affected, cancellationToken), affected); + } + } + /** + * Gets the semantic diagnostics from the program corresponding to this state of file (if provided) or whole program + * The semantic diagnostics are cached and managed here + * Note that it is assumed that when asked about semantic diagnostics through this API, + * the file has been taken out of affected files so it is safe to use cache or get from program and cache the diagnostics + * In case of SemanticDiagnosticsBuilderProgram if the source file is not provided, + * it will iterate through all the affected files, to ensure that cache stays valid and yet provide a way to get all semantic diagnostics + */ + function getSemanticDiagnostics(sourceFile, cancellationToken) { + assertSourceFileOkWithoutNextAffectedCall(state, sourceFile); + var compilerOptions = ts.Debug.checkDefined(state.program).getCompilerOptions(); + if (ts.outFile(compilerOptions)) { + ts.Debug.assert(!state.semanticDiagnosticsPerFile); + // We dont need to cache the diagnostics just return them from program + return ts.Debug.checkDefined(state.program).getSemanticDiagnostics(sourceFile, cancellationToken); + } + if (sourceFile) { + return getSemanticDiagnosticsOfFile(state, sourceFile, cancellationToken); + } + // When semantic builder asks for diagnostics of the whole program, + // ensure that all the affected files are handled + // eslint-disable-next-line no-empty + while (getSemanticDiagnosticsOfNextAffectedFile(cancellationToken)) { + } + var diagnostics; + for (var _i = 0, _a = ts.Debug.checkDefined(state.program).getSourceFiles(); _i < _a.length; _i++) { + var sourceFile_1 = _a[_i]; + diagnostics = ts.addRange(diagnostics, getSemanticDiagnosticsOfFile(state, sourceFile_1, cancellationToken)); + } + return diagnostics || ts.emptyArray; + } + } + ts.createBuilderProgram = createBuilderProgram; + function addToAffectedFilesPendingEmit(state, affectedFilePendingEmit, kind) { + if (!state.affectedFilesPendingEmit) + state.affectedFilesPendingEmit = []; + if (!state.affectedFilesPendingEmitKind) + state.affectedFilesPendingEmitKind = new ts.Map(); + var existingKind = state.affectedFilesPendingEmitKind.get(affectedFilePendingEmit); + state.affectedFilesPendingEmit.push(affectedFilePendingEmit); + state.affectedFilesPendingEmitKind.set(affectedFilePendingEmit, existingKind || kind); + // affectedFilesPendingEmitIndex === undefined + // - means the emit state.affectedFilesPendingEmit was undefined before adding current affected files + // so start from 0 as array would be affectedFilesPendingEmit + // else, continue to iterate from existing index, the current set is appended to existing files + if (state.affectedFilesPendingEmitIndex === undefined) { + state.affectedFilesPendingEmitIndex = 0; + } + } + function toBuilderStateFileInfo(fileInfo) { + return ts.isString(fileInfo) ? + { version: fileInfo, signature: fileInfo, affectsGlobalScope: undefined, impliedFormat: undefined } : + ts.isString(fileInfo.signature) ? + fileInfo : + { version: fileInfo.version, signature: fileInfo.signature === false ? undefined : fileInfo.version, affectsGlobalScope: fileInfo.affectsGlobalScope, impliedFormat: fileInfo.impliedFormat }; + } + ts.toBuilderStateFileInfo = toBuilderStateFileInfo; + function createBuilderProgramUsingProgramBuildInfo(program, buildInfoPath, host) { + var _a, _b, _c, _d; + var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory())); + var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames()); + var state; + var filePaths; + var filePathsSetList; + var latestChangedDtsFile = program.latestChangedDtsFile ? toAbsolutePath(program.latestChangedDtsFile) : undefined; + if (isProgramBundleEmitBuildInfo(program)) { + state = { + fileInfos: new ts.Map(), + compilerOptions: program.options ? ts.convertToOptionsWithAbsolutePaths(program.options, toAbsolutePath) : {}, + latestChangedDtsFile: latestChangedDtsFile, + outSignature: program.outSignature, + }; + } + else { + filePaths = (_a = program.fileNames) === null || _a === void 0 ? void 0 : _a.map(toPath); + filePathsSetList = (_b = program.fileIdsList) === null || _b === void 0 ? void 0 : _b.map(function (fileIds) { return new ts.Set(fileIds.map(toFilePath)); }); + var fileInfos_2 = new ts.Map(); + var emitSignatures_1 = ((_c = program.options) === null || _c === void 0 ? void 0 : _c.composite) && !ts.outFile(program.options) ? new ts.Map() : undefined; + program.fileInfos.forEach(function (fileInfo, index) { + var path = toFilePath(index + 1); + var stateFileInfo = toBuilderStateFileInfo(fileInfo); + fileInfos_2.set(path, stateFileInfo); + if (emitSignatures_1 && stateFileInfo.signature) + emitSignatures_1.set(path, stateFileInfo.signature); + }); + (_d = program.emitSignatures) === null || _d === void 0 ? void 0 : _d.forEach(function (value) { + if (ts.isNumber(value)) + emitSignatures_1.delete(toFilePath(value)); + else + emitSignatures_1.set(toFilePath(value[0]), value[1]); + }); + state = { + fileInfos: fileInfos_2, + compilerOptions: program.options ? ts.convertToOptionsWithAbsolutePaths(program.options, toAbsolutePath) : {}, + referencedMap: toManyToManyPathMap(program.referencedMap), + exportedModulesMap: toManyToManyPathMap(program.exportedModulesMap), + semanticDiagnosticsPerFile: program.semanticDiagnosticsPerFile && ts.arrayToMap(program.semanticDiagnosticsPerFile, function (value) { return toFilePath(ts.isNumber(value) ? value : value[0]); }, function (value) { return ts.isNumber(value) ? ts.emptyArray : value[1]; }), + hasReusableDiagnostic: true, + affectedFilesPendingEmit: ts.map(program.affectedFilesPendingEmit, function (value) { return toFilePath(value[0]); }), + affectedFilesPendingEmitKind: program.affectedFilesPendingEmit && ts.arrayToMap(program.affectedFilesPendingEmit, function (value) { return toFilePath(value[0]); }, function (value) { return value[1]; }), + affectedFilesPendingEmitIndex: program.affectedFilesPendingEmit && 0, + changedFilesSet: new ts.Set(ts.map(program.changeFileSet, toFilePath)), + latestChangedDtsFile: latestChangedDtsFile, + emitSignatures: (emitSignatures_1 === null || emitSignatures_1 === void 0 ? void 0 : emitSignatures_1.size) ? emitSignatures_1 : undefined, + }; + } + return { + getState: function () { return state; }, + saveEmitState: ts.noop, + restoreEmitState: ts.noop, + getProgram: ts.notImplemented, + getProgramOrUndefined: ts.returnUndefined, + releaseProgram: ts.noop, + getCompilerOptions: function () { return state.compilerOptions; }, + getSourceFile: ts.notImplemented, + getSourceFiles: ts.notImplemented, + getOptionsDiagnostics: ts.notImplemented, + getGlobalDiagnostics: ts.notImplemented, + getConfigFileParsingDiagnostics: ts.notImplemented, + getSyntacticDiagnostics: ts.notImplemented, + getDeclarationDiagnostics: ts.notImplemented, + getSemanticDiagnostics: ts.notImplemented, + emit: ts.notImplemented, + getAllDependencies: ts.notImplemented, + getCurrentDirectory: ts.notImplemented, + emitNextAffectedFile: ts.notImplemented, + getSemanticDiagnosticsOfNextAffectedFile: ts.notImplemented, + emitBuildInfo: ts.notImplemented, + close: ts.noop, + hasChangedEmitSignature: ts.returnFalse, + }; + function toPath(path) { + return ts.toPath(path, buildInfoDirectory, getCanonicalFileName); + } + function toAbsolutePath(path) { + return ts.getNormalizedAbsolutePath(path, buildInfoDirectory); + } + function toFilePath(fileId) { + return filePaths[fileId - 1]; + } + function toFilePathsSet(fileIdsListId) { + return filePathsSetList[fileIdsListId - 1]; + } + function toManyToManyPathMap(referenceMap) { + if (!referenceMap) { + return undefined; + } + var map = ts.BuilderState.createManyToManyPathMap(); + referenceMap.forEach(function (_a) { + var fileId = _a[0], fileIdListId = _a[1]; + return map.set(toFilePath(fileId), toFilePathsSet(fileIdListId)); + }); + return map; + } + } + ts.createBuilderProgramUsingProgramBuildInfo = createBuilderProgramUsingProgramBuildInfo; + function getBuildInfoFileVersionMap(program, buildInfoPath, host) { + var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory())); + var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames()); + var fileInfos = new ts.Map(); + program.fileInfos.forEach(function (fileInfo, index) { + var path = ts.toPath(program.fileNames[index], buildInfoDirectory, getCanonicalFileName); + var version = ts.isString(fileInfo) ? fileInfo : fileInfo.version; // eslint-disable-line @typescript-eslint/no-unnecessary-type-assertion + fileInfos.set(path, version); + }); + return fileInfos; + } + ts.getBuildInfoFileVersionMap = getBuildInfoFileVersionMap; + function createRedirectedBuilderProgram(getState, configFileParsingDiagnostics) { + return { + getState: ts.notImplemented, + saveEmitState: ts.noop, + restoreEmitState: ts.noop, + getProgram: getProgram, + getProgramOrUndefined: function () { return getState().program; }, + releaseProgram: function () { return getState().program = undefined; }, + getCompilerOptions: function () { return getState().compilerOptions; }, + getSourceFile: function (fileName) { return getProgram().getSourceFile(fileName); }, + getSourceFiles: function () { return getProgram().getSourceFiles(); }, + getOptionsDiagnostics: function (cancellationToken) { return getProgram().getOptionsDiagnostics(cancellationToken); }, + getGlobalDiagnostics: function (cancellationToken) { return getProgram().getGlobalDiagnostics(cancellationToken); }, + getConfigFileParsingDiagnostics: function () { return configFileParsingDiagnostics; }, + getSyntacticDiagnostics: function (sourceFile, cancellationToken) { return getProgram().getSyntacticDiagnostics(sourceFile, cancellationToken); }, + getDeclarationDiagnostics: function (sourceFile, cancellationToken) { return getProgram().getDeclarationDiagnostics(sourceFile, cancellationToken); }, + getSemanticDiagnostics: function (sourceFile, cancellationToken) { return getProgram().getSemanticDiagnostics(sourceFile, cancellationToken); }, + emit: function (sourceFile, writeFile, cancellationToken, emitOnlyDts, customTransformers) { return getProgram().emit(sourceFile, writeFile, cancellationToken, emitOnlyDts, customTransformers); }, + emitBuildInfo: function (writeFile, cancellationToken) { return getProgram().emitBuildInfo(writeFile, cancellationToken); }, + getAllDependencies: ts.notImplemented, + getCurrentDirectory: function () { return getProgram().getCurrentDirectory(); }, + close: ts.noop, + }; + function getProgram() { + return ts.Debug.checkDefined(getState().program); + } + } + ts.createRedirectedBuilderProgram = createRedirectedBuilderProgram; +})(ts || (ts = {})); +var ts; +(function (ts) { + function createSemanticDiagnosticsBuilderProgram(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences) { + return ts.createBuilderProgram(ts.BuilderProgramKind.SemanticDiagnosticsBuilderProgram, ts.getBuilderCreationParameters(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences)); + } + ts.createSemanticDiagnosticsBuilderProgram = createSemanticDiagnosticsBuilderProgram; + function createEmitAndSemanticDiagnosticsBuilderProgram(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences) { + return ts.createBuilderProgram(ts.BuilderProgramKind.EmitAndSemanticDiagnosticsBuilderProgram, ts.getBuilderCreationParameters(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences)); + } + ts.createEmitAndSemanticDiagnosticsBuilderProgram = createEmitAndSemanticDiagnosticsBuilderProgram; + function createAbstractBuilder(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences) { + var _a = ts.getBuilderCreationParameters(newProgramOrRootNames, hostOrOptions, oldProgramOrHost, configFileParsingDiagnosticsOrOldProgram, configFileParsingDiagnostics, projectReferences), newProgram = _a.newProgram, newConfigFileParsingDiagnostics = _a.configFileParsingDiagnostics; + return ts.createRedirectedBuilderProgram(function () { return ({ program: newProgram, compilerOptions: newProgram.getCompilerOptions() }); }, newConfigFileParsingDiagnostics); + } + ts.createAbstractBuilder = createAbstractBuilder; +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + function removeIgnoredPath(path) { + // Consider whole staging folder as if node_modules changed. + if (ts.endsWith(path, "/node_modules/.staging")) { + return ts.removeSuffix(path, "/.staging"); + } + return ts.some(ts.ignoredPaths, function (searchPath) { return ts.stringContains(path, searchPath); }) ? + undefined : + path; + } + ts.removeIgnoredPath = removeIgnoredPath; + /** + * Filter out paths like + * "/", "/user", "/user/username", "/user/username/folderAtRoot", + * "c:/", "c:/users", "c:/users/username", "c:/users/username/folderAtRoot", "c:/folderAtRoot" + * @param dirPath + */ + function canWatchDirectoryOrFile(dirPath) { + var rootLength = ts.getRootLength(dirPath); + if (dirPath.length === rootLength) { + // Ignore "/", "c:/" + return false; + } + var nextDirectorySeparator = dirPath.indexOf(ts.directorySeparator, rootLength); + if (nextDirectorySeparator === -1) { + // ignore "/user", "c:/users" or "c:/folderAtRoot" + return false; + } + var pathPartForUserCheck = dirPath.substring(rootLength, nextDirectorySeparator + 1); + var isNonDirectorySeparatorRoot = rootLength > 1 || dirPath.charCodeAt(0) !== 47 /* CharacterCodes.slash */; + if (isNonDirectorySeparatorRoot && + dirPath.search(/[a-zA-Z]:/) !== 0 && // Non dos style paths + pathPartForUserCheck.search(/[a-zA-Z]\$\//) === 0) { // Dos style nextPart + nextDirectorySeparator = dirPath.indexOf(ts.directorySeparator, nextDirectorySeparator + 1); + if (nextDirectorySeparator === -1) { + // ignore "//vda1cs4850/c$/folderAtRoot" + return false; + } + pathPartForUserCheck = dirPath.substring(rootLength + pathPartForUserCheck.length, nextDirectorySeparator + 1); + } + if (isNonDirectorySeparatorRoot && + pathPartForUserCheck.search(/users\//i) !== 0) { + // Paths like c:/folderAtRoot/subFolder are allowed + return true; + } + for (var searchIndex = nextDirectorySeparator + 1, searchLevels = 2; searchLevels > 0; searchLevels--) { + searchIndex = dirPath.indexOf(ts.directorySeparator, searchIndex) + 1; + if (searchIndex === 0) { + // Folder isnt at expected minimum levels + return false; + } + } + return true; + } + ts.canWatchDirectoryOrFile = canWatchDirectoryOrFile; + function createResolutionCache(resolutionHost, rootDirForResolution, logChangesWhenResolvingModule) { + var filesWithChangedSetOfUnresolvedImports; + var filesWithInvalidatedResolutions; + var filesWithInvalidatedNonRelativeUnresolvedImports; + var nonRelativeExternalModuleResolutions = ts.createMultiMap(); + var resolutionsWithFailedLookups = []; + var resolutionsWithOnlyAffectingLocations = []; + var resolvedFileToResolution = ts.createMultiMap(); + var impliedFormatPackageJsons = new ts.Map(); + var hasChangedAutomaticTypeDirectiveNames = false; + var affectingPathChecksForFile; + var affectingPathChecks; + var failedLookupChecks; + var startsWithPathChecks; + var isInDirectoryChecks; + var getCurrentDirectory = ts.memoize(function () { return resolutionHost.getCurrentDirectory(); }); // TODO: GH#18217 + var cachedDirectoryStructureHost = resolutionHost.getCachedDirectoryStructureHost(); + // The resolvedModuleNames and resolvedTypeReferenceDirectives are the cache of resolutions per file. + // The key in the map is source file's path. + // The values are Map of resolutions with key being name lookedup. + var resolvedModuleNames = new ts.Map(); + var perDirectoryResolvedModuleNames = ts.createCacheWithRedirects(); + var nonRelativeModuleNameCache = ts.createCacheWithRedirects(); + var moduleResolutionCache = ts.createModuleResolutionCache(getCurrentDirectory(), resolutionHost.getCanonicalFileName, + /*options*/ undefined, perDirectoryResolvedModuleNames, nonRelativeModuleNameCache); + var resolvedTypeReferenceDirectives = new ts.Map(); + var perDirectoryResolvedTypeReferenceDirectives = ts.createCacheWithRedirects(); + var typeReferenceDirectiveResolutionCache = ts.createTypeReferenceDirectiveResolutionCache(getCurrentDirectory(), resolutionHost.getCanonicalFileName, + /*options*/ undefined, moduleResolutionCache.getPackageJsonInfoCache(), perDirectoryResolvedTypeReferenceDirectives); + /** + * These are the extensions that failed lookup files will have by default, + * any other extension of failed lookup will be store that path in custom failed lookup path + * This helps in not having to comb through all resolutions when files are added/removed + * Note that .d.ts file also has .d.ts extension hence will be part of default extensions + */ + var failedLookupDefaultExtensions = [".ts" /* Extension.Ts */, ".tsx" /* Extension.Tsx */, ".js" /* Extension.Js */, ".jsx" /* Extension.Jsx */, ".json" /* Extension.Json */]; + var customFailedLookupPaths = new ts.Map(); + var directoryWatchesOfFailedLookups = new ts.Map(); + var fileWatchesOfAffectingLocations = new ts.Map(); + var rootDir = rootDirForResolution && ts.removeTrailingDirectorySeparator(ts.getNormalizedAbsolutePath(rootDirForResolution, getCurrentDirectory())); + var rootPath = (rootDir && resolutionHost.toPath(rootDir)); // TODO: GH#18217 + var rootSplitLength = rootPath !== undefined ? rootPath.split(ts.directorySeparator).length : 0; + // TypeRoot watches for the types that get added as part of getAutomaticTypeDirectiveNames + var typeRootsWatches = new ts.Map(); + return { + getModuleResolutionCache: function () { return moduleResolutionCache; }, + startRecordingFilesWithChangedResolutions: startRecordingFilesWithChangedResolutions, + finishRecordingFilesWithChangedResolutions: finishRecordingFilesWithChangedResolutions, + // perDirectoryResolvedModuleNames and perDirectoryResolvedTypeReferenceDirectives could be non empty if there was exception during program update + // (between startCachingPerDirectoryResolution and finishCachingPerDirectoryResolution) + startCachingPerDirectoryResolution: startCachingPerDirectoryResolution, + finishCachingPerDirectoryResolution: finishCachingPerDirectoryResolution, + resolveModuleNames: resolveModuleNames, + getResolvedModuleWithFailedLookupLocationsFromCache: getResolvedModuleWithFailedLookupLocationsFromCache, + resolveTypeReferenceDirectives: resolveTypeReferenceDirectives, + removeResolutionsFromProjectReferenceRedirects: removeResolutionsFromProjectReferenceRedirects, + removeResolutionsOfFile: removeResolutionsOfFile, + hasChangedAutomaticTypeDirectiveNames: function () { return hasChangedAutomaticTypeDirectiveNames; }, + invalidateResolutionOfFile: invalidateResolutionOfFile, + invalidateResolutionsOfFailedLookupLocations: invalidateResolutionsOfFailedLookupLocations, + setFilesWithInvalidatedNonRelativeUnresolvedImports: setFilesWithInvalidatedNonRelativeUnresolvedImports, + createHasInvalidatedResolutions: createHasInvalidatedResolutions, + isFileWithInvalidatedNonRelativeUnresolvedImports: isFileWithInvalidatedNonRelativeUnresolvedImports, + updateTypeRootsWatch: updateTypeRootsWatch, + closeTypeRootsWatch: closeTypeRootsWatch, + clear: clear + }; + function getResolvedModule(resolution) { + return resolution.resolvedModule; + } + function getResolvedTypeReferenceDirective(resolution) { + return resolution.resolvedTypeReferenceDirective; + } + function isInDirectoryPath(dir, file) { + if (dir === undefined || file.length <= dir.length) { + return false; + } + return ts.startsWith(file, dir) && file[dir.length] === ts.directorySeparator; + } + function clear() { + ts.clearMap(directoryWatchesOfFailedLookups, ts.closeFileWatcherOf); + ts.clearMap(fileWatchesOfAffectingLocations, ts.closeFileWatcherOf); + customFailedLookupPaths.clear(); + nonRelativeExternalModuleResolutions.clear(); + closeTypeRootsWatch(); + resolvedModuleNames.clear(); + resolvedTypeReferenceDirectives.clear(); + resolvedFileToResolution.clear(); + resolutionsWithFailedLookups.length = 0; + resolutionsWithOnlyAffectingLocations.length = 0; + failedLookupChecks = undefined; + startsWithPathChecks = undefined; + isInDirectoryChecks = undefined; + affectingPathChecks = undefined; + affectingPathChecksForFile = undefined; + moduleResolutionCache.clear(); + typeReferenceDirectiveResolutionCache.clear(); + impliedFormatPackageJsons.clear(); + hasChangedAutomaticTypeDirectiveNames = false; + } + function startRecordingFilesWithChangedResolutions() { + filesWithChangedSetOfUnresolvedImports = []; + } + function finishRecordingFilesWithChangedResolutions() { + var collected = filesWithChangedSetOfUnresolvedImports; + filesWithChangedSetOfUnresolvedImports = undefined; + return collected; + } + function isFileWithInvalidatedNonRelativeUnresolvedImports(path) { + if (!filesWithInvalidatedNonRelativeUnresolvedImports) { + return false; + } + // Invalidated if file has unresolved imports + var value = filesWithInvalidatedNonRelativeUnresolvedImports.get(path); + return !!value && !!value.length; + } + function createHasInvalidatedResolutions(customHasInvalidatedResolutions) { + // Ensure pending resolutions are applied + invalidateResolutionsOfFailedLookupLocations(); + var collected = filesWithInvalidatedResolutions; + filesWithInvalidatedResolutions = undefined; + return function (path) { return customHasInvalidatedResolutions(path) || + !!(collected === null || collected === void 0 ? void 0 : collected.has(path)) || + isFileWithInvalidatedNonRelativeUnresolvedImports(path); }; + } + function startCachingPerDirectoryResolution() { + moduleResolutionCache.clearAllExceptPackageJsonInfoCache(); + typeReferenceDirectiveResolutionCache.clearAllExceptPackageJsonInfoCache(); + // perDirectoryResolvedModuleNames and perDirectoryResolvedTypeReferenceDirectives could be non empty if there was exception during program update + // (between startCachingPerDirectoryResolution and finishCachingPerDirectoryResolution) + nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfNonRelativeModuleResolutions); + nonRelativeExternalModuleResolutions.clear(); + } + function finishCachingPerDirectoryResolution(newProgram, oldProgram) { + filesWithInvalidatedNonRelativeUnresolvedImports = undefined; + nonRelativeExternalModuleResolutions.forEach(watchFailedLookupLocationOfNonRelativeModuleResolutions); + nonRelativeExternalModuleResolutions.clear(); + // Update file watches + if (newProgram !== oldProgram) { + newProgram === null || newProgram === void 0 ? void 0 : newProgram.getSourceFiles().forEach(function (newFile) { + var _a, _b, _c; + var expected = ts.isExternalOrCommonJsModule(newFile) ? (_b = (_a = newFile.packageJsonLocations) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0 : 0; + var existing = (_c = impliedFormatPackageJsons.get(newFile.path)) !== null && _c !== void 0 ? _c : ts.emptyArray; + for (var i = existing.length; i < expected; i++) { + createFileWatcherOfAffectingLocation(newFile.packageJsonLocations[i], /*forResolution*/ false); + } + if (existing.length > expected) { + for (var i = expected; i < existing.length; i++) { + fileWatchesOfAffectingLocations.get(existing[i]).files--; + } + } + if (expected) + impliedFormatPackageJsons.set(newFile.path, newFile.packageJsonLocations); + else + impliedFormatPackageJsons.delete(newFile.path); + }); + impliedFormatPackageJsons.forEach(function (existing, path) { + if (!(newProgram === null || newProgram === void 0 ? void 0 : newProgram.getSourceFileByPath(path))) { + existing.forEach(function (location) { return fileWatchesOfAffectingLocations.get(location).files--; }); + impliedFormatPackageJsons.delete(path); + } + }); + } + directoryWatchesOfFailedLookups.forEach(function (watcher, path) { + if (watcher.refCount === 0) { + directoryWatchesOfFailedLookups.delete(path); + watcher.watcher.close(); + } + }); + fileWatchesOfAffectingLocations.forEach(function (watcher, path) { + if (watcher.files === 0 && watcher.resolutions === 0) { + fileWatchesOfAffectingLocations.delete(path); + watcher.watcher.close(); + } + }); + hasChangedAutomaticTypeDirectiveNames = false; + } + function resolveModuleName(moduleName, containingFile, compilerOptions, host, redirectedReference, _containingSourceFile, mode) { + var _a, _b; + var primaryResult = ts.resolveModuleName(moduleName, containingFile, compilerOptions, host, moduleResolutionCache, redirectedReference, mode); + // return result immediately only if global cache support is not enabled or if it is .ts, .tsx or .d.ts + if (!resolutionHost.getGlobalCache) { + return primaryResult; + } + // otherwise try to load typings from @types + var globalCache = resolutionHost.getGlobalCache(); + if (globalCache !== undefined && !ts.isExternalModuleNameRelative(moduleName) && !(primaryResult.resolvedModule && ts.extensionIsTS(primaryResult.resolvedModule.extension))) { + // create different collection of failed lookup locations for second pass + // if it will fail and we've already found something during the first pass - we don't want to pollute its results + var _c = ts.loadModuleFromGlobalCache(ts.Debug.checkDefined(resolutionHost.globalCacheResolutionModuleName)(moduleName), resolutionHost.projectName, compilerOptions, host, globalCache, moduleResolutionCache), resolvedModule = _c.resolvedModule, failedLookupLocations = _c.failedLookupLocations, affectingLocations = _c.affectingLocations; + if (resolvedModule) { + // Modify existing resolution so its saved in the directory cache as well + primaryResult.resolvedModule = resolvedModule; + (_a = primaryResult.failedLookupLocations).push.apply(_a, failedLookupLocations); + (_b = primaryResult.affectingLocations).push.apply(_b, affectingLocations); + return primaryResult; + } + } + // Default return the result from the first pass + return primaryResult; + } + function resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, _containingSourceFile, resolutionMode) { + return ts.resolveTypeReferenceDirective(typeReferenceDirectiveName, containingFile, options, host, redirectedReference, typeReferenceDirectiveResolutionCache, resolutionMode); + } + function resolveNamesWithLocalCache(_a) { + var _b, _c, _d; + var names = _a.names, containingFile = _a.containingFile, redirectedReference = _a.redirectedReference, cache = _a.cache, perDirectoryCacheWithRedirects = _a.perDirectoryCacheWithRedirects, loader = _a.loader, getResolutionWithResolvedFileName = _a.getResolutionWithResolvedFileName, shouldRetryResolution = _a.shouldRetryResolution, reusedNames = _a.reusedNames, logChanges = _a.logChanges, containingSourceFile = _a.containingSourceFile, containingSourceFileMode = _a.containingSourceFileMode; + var path = resolutionHost.toPath(containingFile); + var resolutionsInFile = cache.get(path) || cache.set(path, ts.createModeAwareCache()).get(path); + var dirPath = ts.getDirectoryPath(path); + var perDirectoryCache = perDirectoryCacheWithRedirects.getOrCreateMapOfCacheRedirects(redirectedReference); + var perDirectoryResolution = perDirectoryCache.get(dirPath); + if (!perDirectoryResolution) { + perDirectoryResolution = ts.createModeAwareCache(); + perDirectoryCache.set(dirPath, perDirectoryResolution); + } + var resolvedModules = []; + var compilerOptions = resolutionHost.getCompilationSettings(); + var hasInvalidatedNonRelativeUnresolvedImport = logChanges && isFileWithInvalidatedNonRelativeUnresolvedImports(path); + // All the resolutions in this file are invalidated if this file wasn't resolved using same redirect + var program = resolutionHost.getCurrentProgram(); + var oldRedirect = program && program.getResolvedProjectReferenceToRedirect(containingFile); + var unmatchedRedirects = oldRedirect ? + !redirectedReference || redirectedReference.sourceFile.path !== oldRedirect.sourceFile.path : + !!redirectedReference; + var seenNamesInFile = ts.createModeAwareCache(); + var i = 0; + for (var _i = 0, names_5 = names; _i < names_5.length; _i++) { + var entry = names_5[_i]; + var name = ts.isString(entry) ? entry : entry.fileName.toLowerCase(); + // Imports supply a `containingSourceFile` but no `containingSourceFileMode` - it would be redundant + // they require calculating the mode for a given import from it's position in the resolution table, since a given + // import's syntax may override the file's default mode. + // Type references instead supply a `containingSourceFileMode` and a non-string entry which contains + // a default file mode override if applicable. + var mode = !ts.isString(entry) ? ts.getModeForFileReference(entry, containingSourceFileMode) : + containingSourceFile ? ts.getModeForResolutionAtIndex(containingSourceFile, i) : undefined; + i++; + var resolution = resolutionsInFile.get(name, mode); + // Resolution is valid if it is present and not invalidated + if (!seenNamesInFile.has(name, mode) && + unmatchedRedirects || !resolution || resolution.isInvalidated || + // If the name is unresolved import that was invalidated, recalculate + (hasInvalidatedNonRelativeUnresolvedImport && !ts.isExternalModuleNameRelative(name) && shouldRetryResolution(resolution))) { + var existingResolution = resolution; + var resolutionInDirectory = perDirectoryResolution.get(name, mode); + if (resolutionInDirectory) { + resolution = resolutionInDirectory; + var host = ((_b = resolutionHost.getCompilerHost) === null || _b === void 0 ? void 0 : _b.call(resolutionHost)) || resolutionHost; + if (ts.isTraceEnabled(compilerOptions, host)) { + var resolved = getResolutionWithResolvedFileName(resolution); + ts.trace(host, loader === resolveModuleName ? + (resolved === null || resolved === void 0 ? void 0 : resolved.resolvedFileName) ? + resolved.packagetId ? + ts.Diagnostics.Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3_with_Package_ID_4 : + ts.Diagnostics.Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3 : + ts.Diagnostics.Reusing_resolution_of_module_0_from_1_found_in_cache_from_location_2_it_was_not_resolved : + (resolved === null || resolved === void 0 ? void 0 : resolved.resolvedFileName) ? + resolved.packagetId ? + ts.Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3_with_Package_ID_4 : + ts.Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_successfully_resolved_to_3 : + ts.Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_found_in_cache_from_location_2_it_was_not_resolved, name, containingFile, ts.getDirectoryPath(containingFile), resolved === null || resolved === void 0 ? void 0 : resolved.resolvedFileName, (resolved === null || resolved === void 0 ? void 0 : resolved.packagetId) && ts.packageIdToString(resolved.packagetId)); + } + } + else { + resolution = loader(name, containingFile, compilerOptions, ((_c = resolutionHost.getCompilerHost) === null || _c === void 0 ? void 0 : _c.call(resolutionHost)) || resolutionHost, redirectedReference, containingSourceFile, mode); + perDirectoryResolution.set(name, mode, resolution); + if (resolutionHost.onDiscoveredSymlink && resolutionIsSymlink(resolution)) { + resolutionHost.onDiscoveredSymlink(); + } + } + resolutionsInFile.set(name, mode, resolution); + watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, path, getResolutionWithResolvedFileName); + if (existingResolution) { + stopWatchFailedLookupLocationOfResolution(existingResolution, path, getResolutionWithResolvedFileName); + } + if (logChanges && filesWithChangedSetOfUnresolvedImports && !resolutionIsEqualTo(existingResolution, resolution)) { + filesWithChangedSetOfUnresolvedImports.push(path); + // reset log changes to avoid recording the same file multiple times + logChanges = false; + } + } + else { + var host = ((_d = resolutionHost.getCompilerHost) === null || _d === void 0 ? void 0 : _d.call(resolutionHost)) || resolutionHost; + if (ts.isTraceEnabled(compilerOptions, host) && !seenNamesInFile.has(name, mode)) { + var resolved = getResolutionWithResolvedFileName(resolution); + ts.trace(host, loader === resolveModuleName ? + (resolved === null || resolved === void 0 ? void 0 : resolved.resolvedFileName) ? + resolved.packagetId ? + ts.Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : + ts.Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_successfully_resolved_to_2 : + ts.Diagnostics.Reusing_resolution_of_module_0_from_1_of_old_program_it_was_not_resolved : + (resolved === null || resolved === void 0 ? void 0 : resolved.resolvedFileName) ? + resolved.packagetId ? + ts.Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2_with_Package_ID_3 : + ts.Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_successfully_resolved_to_2 : + ts.Diagnostics.Reusing_resolution_of_type_reference_directive_0_from_1_of_old_program_it_was_not_resolved, name, containingFile, resolved === null || resolved === void 0 ? void 0 : resolved.resolvedFileName, (resolved === null || resolved === void 0 ? void 0 : resolved.packagetId) && ts.packageIdToString(resolved.packagetId)); + } + } + ts.Debug.assert(resolution !== undefined && !resolution.isInvalidated); + seenNamesInFile.set(name, mode, true); + resolvedModules.push(getResolutionWithResolvedFileName(resolution)); + } + // Stop watching and remove the unused name + resolutionsInFile.forEach(function (resolution, name, mode) { + if (!seenNamesInFile.has(name, mode) && !ts.contains(reusedNames, name)) { + stopWatchFailedLookupLocationOfResolution(resolution, path, getResolutionWithResolvedFileName); + resolutionsInFile.delete(name, mode); + } + }); + return resolvedModules; + function resolutionIsEqualTo(oldResolution, newResolution) { + if (oldResolution === newResolution) { + return true; + } + if (!oldResolution || !newResolution) { + return false; + } + var oldResult = getResolutionWithResolvedFileName(oldResolution); + var newResult = getResolutionWithResolvedFileName(newResolution); + if (oldResult === newResult) { + return true; + } + if (!oldResult || !newResult) { + return false; + } + return oldResult.resolvedFileName === newResult.resolvedFileName; + } + } + function resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, containingFileMode) { + return resolveNamesWithLocalCache({ + names: typeDirectiveNames, + containingFile: containingFile, + redirectedReference: redirectedReference, + cache: resolvedTypeReferenceDirectives, + perDirectoryCacheWithRedirects: perDirectoryResolvedTypeReferenceDirectives, + loader: resolveTypeReferenceDirective, + getResolutionWithResolvedFileName: getResolvedTypeReferenceDirective, + shouldRetryResolution: function (resolution) { return resolution.resolvedTypeReferenceDirective === undefined; }, + containingSourceFileMode: containingFileMode + }); + } + function resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, containingSourceFile) { + return resolveNamesWithLocalCache({ + names: moduleNames, + containingFile: containingFile, + redirectedReference: redirectedReference, + cache: resolvedModuleNames, + perDirectoryCacheWithRedirects: perDirectoryResolvedModuleNames, + loader: resolveModuleName, + getResolutionWithResolvedFileName: getResolvedModule, + shouldRetryResolution: function (resolution) { return !resolution.resolvedModule || !ts.resolutionExtensionIsTSOrJson(resolution.resolvedModule.extension); }, + reusedNames: reusedNames, + logChanges: logChangesWhenResolvingModule, + containingSourceFile: containingSourceFile, + }); + } + function getResolvedModuleWithFailedLookupLocationsFromCache(moduleName, containingFile, resolutionMode) { + var cache = resolvedModuleNames.get(resolutionHost.toPath(containingFile)); + if (!cache) + return undefined; + return cache.get(moduleName, resolutionMode); + } + function isNodeModulesAtTypesDirectory(dirPath) { + return ts.endsWith(dirPath, "/node_modules/@types"); + } + function getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath) { + if (isInDirectoryPath(rootPath, failedLookupLocationPath)) { + // Ensure failed look up is normalized path + failedLookupLocation = ts.isRootedDiskPath(failedLookupLocation) ? ts.normalizePath(failedLookupLocation) : ts.getNormalizedAbsolutePath(failedLookupLocation, getCurrentDirectory()); + var failedLookupPathSplit = failedLookupLocationPath.split(ts.directorySeparator); + var failedLookupSplit = failedLookupLocation.split(ts.directorySeparator); + ts.Debug.assert(failedLookupSplit.length === failedLookupPathSplit.length, "FailedLookup: ".concat(failedLookupLocation, " failedLookupLocationPath: ").concat(failedLookupLocationPath)); + if (failedLookupPathSplit.length > rootSplitLength + 1) { + // Instead of watching root, watch directory in root to avoid watching excluded directories not needed for module resolution + return { + dir: failedLookupSplit.slice(0, rootSplitLength + 1).join(ts.directorySeparator), + dirPath: failedLookupPathSplit.slice(0, rootSplitLength + 1).join(ts.directorySeparator) + }; + } + else { + // Always watch root directory non recursively + return { + dir: rootDir, + dirPath: rootPath, + nonRecursive: false + }; + } + } + return getDirectoryToWatchFromFailedLookupLocationDirectory(ts.getDirectoryPath(ts.getNormalizedAbsolutePath(failedLookupLocation, getCurrentDirectory())), ts.getDirectoryPath(failedLookupLocationPath)); + } + function getDirectoryToWatchFromFailedLookupLocationDirectory(dir, dirPath) { + // If directory path contains node module, get the most parent node_modules directory for watching + while (ts.pathContainsNodeModules(dirPath)) { + dir = ts.getDirectoryPath(dir); + dirPath = ts.getDirectoryPath(dirPath); + } + // If the directory is node_modules use it to watch, always watch it recursively + if (ts.isNodeModulesDirectory(dirPath)) { + return canWatchDirectoryOrFile(ts.getDirectoryPath(dirPath)) ? { dir: dir, dirPath: dirPath } : undefined; + } + var nonRecursive = true; + // Use some ancestor of the root directory + var subDirectoryPath, subDirectory; + if (rootPath !== undefined) { + while (!isInDirectoryPath(dirPath, rootPath)) { + var parentPath = ts.getDirectoryPath(dirPath); + if (parentPath === dirPath) { + break; + } + nonRecursive = false; + subDirectoryPath = dirPath; + subDirectory = dir; + dirPath = parentPath; + dir = ts.getDirectoryPath(dir); + } + } + return canWatchDirectoryOrFile(dirPath) ? { dir: subDirectory || dir, dirPath: subDirectoryPath || dirPath, nonRecursive: nonRecursive } : undefined; + } + function isPathWithDefaultFailedLookupExtension(path) { + return ts.fileExtensionIsOneOf(path, failedLookupDefaultExtensions); + } + function watchFailedLookupLocationsOfExternalModuleResolutions(name, resolution, filePath, getResolutionWithResolvedFileName) { + if (resolution.refCount) { + resolution.refCount++; + ts.Debug.assertIsDefined(resolution.files); + } + else { + resolution.refCount = 1; + ts.Debug.assert(ts.length(resolution.files) === 0); // This resolution shouldnt be referenced by any file yet + if (ts.isExternalModuleNameRelative(name)) { + watchFailedLookupLocationOfResolution(resolution); + } + else { + nonRelativeExternalModuleResolutions.add(name, resolution); + } + var resolved = getResolutionWithResolvedFileName(resolution); + if (resolved && resolved.resolvedFileName) { + resolvedFileToResolution.add(resolutionHost.toPath(resolved.resolvedFileName), resolution); + } + } + (resolution.files || (resolution.files = [])).push(filePath); + } + function watchFailedLookupLocationOfResolution(resolution) { + ts.Debug.assert(!!resolution.refCount); + var failedLookupLocations = resolution.failedLookupLocations, affectingLocations = resolution.affectingLocations; + if (!failedLookupLocations.length && !affectingLocations.length) + return; + if (failedLookupLocations.length) + resolutionsWithFailedLookups.push(resolution); + var setAtRoot = false; + for (var _i = 0, failedLookupLocations_1 = failedLookupLocations; _i < failedLookupLocations_1.length; _i++) { + var failedLookupLocation = failedLookupLocations_1[_i]; + var failedLookupLocationPath = resolutionHost.toPath(failedLookupLocation); + var toWatch = getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath); + if (toWatch) { + var dir = toWatch.dir, dirPath = toWatch.dirPath, nonRecursive = toWatch.nonRecursive; + // If the failed lookup location path is not one of the supported extensions, + // store it in the custom path + if (!isPathWithDefaultFailedLookupExtension(failedLookupLocationPath)) { + var refCount = customFailedLookupPaths.get(failedLookupLocationPath) || 0; + customFailedLookupPaths.set(failedLookupLocationPath, refCount + 1); + } + if (dirPath === rootPath) { + ts.Debug.assert(!nonRecursive); + setAtRoot = true; + } + else { + setDirectoryWatcher(dir, dirPath, nonRecursive); + } + } + } + if (setAtRoot) { + // This is always non recursive + setDirectoryWatcher(rootDir, rootPath, /*nonRecursive*/ true); // TODO: GH#18217 + } + watchAffectingLocationsOfResolution(resolution, !failedLookupLocations.length); + } + function watchAffectingLocationsOfResolution(resolution, addToResolutionsWithOnlyAffectingLocations) { + ts.Debug.assert(!!resolution.refCount); + var affectingLocations = resolution.affectingLocations; + if (!affectingLocations.length) + return; + if (addToResolutionsWithOnlyAffectingLocations) + resolutionsWithOnlyAffectingLocations.push(resolution); + // Watch package json + for (var _i = 0, affectingLocations_1 = affectingLocations; _i < affectingLocations_1.length; _i++) { + var affectingLocation = affectingLocations_1[_i]; + createFileWatcherOfAffectingLocation(affectingLocation, /*forResolution*/ true); + } + } + function createFileWatcherOfAffectingLocation(affectingLocation, forResolution) { + var fileWatcher = fileWatchesOfAffectingLocations.get(affectingLocation); + if (fileWatcher) { + if (forResolution) + fileWatcher.resolutions++; + else + fileWatcher.files++; + return; + } + var locationToWatch = affectingLocation; + if (resolutionHost.realpath) { + locationToWatch = resolutionHost.realpath(affectingLocation); + if (affectingLocation !== locationToWatch) { + var fileWatcher_1 = fileWatchesOfAffectingLocations.get(locationToWatch); + if (fileWatcher_1) { + if (forResolution) + fileWatcher_1.resolutions++; + else + fileWatcher_1.files++; + fileWatcher_1.paths.add(affectingLocation); + fileWatchesOfAffectingLocations.set(affectingLocation, fileWatcher_1); + return; + } + } + } + var paths = new ts.Set(); + paths.add(locationToWatch); + var actualWatcher = canWatchDirectoryOrFile(resolutionHost.toPath(locationToWatch)) ? + resolutionHost.watchAffectingFileLocation(locationToWatch, function (fileName, eventKind) { + cachedDirectoryStructureHost === null || cachedDirectoryStructureHost === void 0 ? void 0 : cachedDirectoryStructureHost.addOrDeleteFile(fileName, resolutionHost.toPath(locationToWatch), eventKind); + var packageJsonMap = moduleResolutionCache.getPackageJsonInfoCache().getInternalMap(); + paths.forEach(function (path) { + if (watcher.resolutions) + (affectingPathChecks !== null && affectingPathChecks !== void 0 ? affectingPathChecks : (affectingPathChecks = new ts.Set())).add(path); + if (watcher.files) + (affectingPathChecksForFile !== null && affectingPathChecksForFile !== void 0 ? affectingPathChecksForFile : (affectingPathChecksForFile = new ts.Set())).add(path); + packageJsonMap === null || packageJsonMap === void 0 ? void 0 : packageJsonMap.delete(resolutionHost.toPath(path)); + }); + resolutionHost.scheduleInvalidateResolutionsOfFailedLookupLocations(); + }) : ts.noopFileWatcher; + var watcher = { + watcher: actualWatcher !== ts.noopFileWatcher ? { + close: function () { + actualWatcher.close(); + // Ensure when watching symlinked package.json, we can close the actual file watcher only once + actualWatcher = ts.noopFileWatcher; + } + } : actualWatcher, + resolutions: forResolution ? 1 : 0, + files: forResolution ? 0 : 1, + paths: paths, + }; + fileWatchesOfAffectingLocations.set(locationToWatch, watcher); + if (affectingLocation !== locationToWatch) { + fileWatchesOfAffectingLocations.set(affectingLocation, watcher); + paths.add(affectingLocation); + } + } + function watchFailedLookupLocationOfNonRelativeModuleResolutions(resolutions, name) { + var program = resolutionHost.getCurrentProgram(); + if (!program || !program.getTypeChecker().tryFindAmbientModuleWithoutAugmentations(name)) { + resolutions.forEach(watchFailedLookupLocationOfResolution); + } + else { + resolutions.forEach(function (resolution) { return watchAffectingLocationsOfResolution(resolution, /*addToResolutionWithOnlyAffectingLocations*/ true); }); + } + } + function setDirectoryWatcher(dir, dirPath, nonRecursive) { + var dirWatcher = directoryWatchesOfFailedLookups.get(dirPath); + if (dirWatcher) { + ts.Debug.assert(!!nonRecursive === !!dirWatcher.nonRecursive); + dirWatcher.refCount++; + } + else { + directoryWatchesOfFailedLookups.set(dirPath, { watcher: createDirectoryWatcher(dir, dirPath, nonRecursive), refCount: 1, nonRecursive: nonRecursive }); + } + } + function stopWatchFailedLookupLocationOfResolution(resolution, filePath, getResolutionWithResolvedFileName) { + ts.unorderedRemoveItem(ts.Debug.checkDefined(resolution.files), filePath); + resolution.refCount--; + if (resolution.refCount) { + return; + } + var resolved = getResolutionWithResolvedFileName(resolution); + if (resolved && resolved.resolvedFileName) { + resolvedFileToResolution.remove(resolutionHost.toPath(resolved.resolvedFileName), resolution); + } + var failedLookupLocations = resolution.failedLookupLocations, affectingLocations = resolution.affectingLocations; + if (ts.unorderedRemoveItem(resolutionsWithFailedLookups, resolution)) { + var removeAtRoot = false; + for (var _i = 0, failedLookupLocations_2 = failedLookupLocations; _i < failedLookupLocations_2.length; _i++) { + var failedLookupLocation = failedLookupLocations_2[_i]; + var failedLookupLocationPath = resolutionHost.toPath(failedLookupLocation); + var toWatch = getDirectoryToWatchFailedLookupLocation(failedLookupLocation, failedLookupLocationPath); + if (toWatch) { + var dirPath = toWatch.dirPath; + var refCount = customFailedLookupPaths.get(failedLookupLocationPath); + if (refCount) { + if (refCount === 1) { + customFailedLookupPaths.delete(failedLookupLocationPath); + } + else { + ts.Debug.assert(refCount > 1); + customFailedLookupPaths.set(failedLookupLocationPath, refCount - 1); + } + } + if (dirPath === rootPath) { + removeAtRoot = true; + } + else { + removeDirectoryWatcher(dirPath); + } + } + } + if (removeAtRoot) { + removeDirectoryWatcher(rootPath); + } + } + else if (affectingLocations.length) { + ts.unorderedRemoveItem(resolutionsWithOnlyAffectingLocations, resolution); + } + for (var _a = 0, affectingLocations_2 = affectingLocations; _a < affectingLocations_2.length; _a++) { + var affectingLocation = affectingLocations_2[_a]; + var watcher = fileWatchesOfAffectingLocations.get(affectingLocation); + watcher.resolutions--; + } + } + function removeDirectoryWatcher(dirPath) { + var dirWatcher = directoryWatchesOfFailedLookups.get(dirPath); + // Do not close the watcher yet since it might be needed by other failed lookup locations. + dirWatcher.refCount--; + } + function createDirectoryWatcher(directory, dirPath, nonRecursive) { + return resolutionHost.watchDirectoryOfFailedLookupLocation(directory, function (fileOrDirectory) { + var fileOrDirectoryPath = resolutionHost.toPath(fileOrDirectory); + if (cachedDirectoryStructureHost) { + // Since the file existence changed, update the sourceFiles cache + cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath); + } + scheduleInvalidateResolutionOfFailedLookupLocation(fileOrDirectoryPath, dirPath === fileOrDirectoryPath); + }, nonRecursive ? 0 /* WatchDirectoryFlags.None */ : 1 /* WatchDirectoryFlags.Recursive */); + } + function removeResolutionsOfFileFromCache(cache, filePath, getResolutionWithResolvedFileName) { + // Deleted file, stop watching failed lookups for all the resolutions in the file + var resolutions = cache.get(filePath); + if (resolutions) { + resolutions.forEach(function (resolution) { return stopWatchFailedLookupLocationOfResolution(resolution, filePath, getResolutionWithResolvedFileName); }); + cache.delete(filePath); + } + } + function removeResolutionsFromProjectReferenceRedirects(filePath) { + if (!ts.fileExtensionIs(filePath, ".json" /* Extension.Json */)) + return; + var program = resolutionHost.getCurrentProgram(); + if (!program) + return; + // If this file is input file for the referenced project, get it + var resolvedProjectReference = program.getResolvedProjectReferenceByPath(filePath); + if (!resolvedProjectReference) + return; + // filePath is for the projectReference and the containing file is from this project reference, invalidate the resolution + resolvedProjectReference.commandLine.fileNames.forEach(function (f) { return removeResolutionsOfFile(resolutionHost.toPath(f)); }); + } + function removeResolutionsOfFile(filePath) { + removeResolutionsOfFileFromCache(resolvedModuleNames, filePath, getResolvedModule); + removeResolutionsOfFileFromCache(resolvedTypeReferenceDirectives, filePath, getResolvedTypeReferenceDirective); + } + function invalidateResolutions(resolutions, canInvalidate) { + if (!resolutions) + return false; + var invalidated = false; + for (var _i = 0, resolutions_1 = resolutions; _i < resolutions_1.length; _i++) { + var resolution = resolutions_1[_i]; + if (resolution.isInvalidated || !canInvalidate(resolution)) + continue; + resolution.isInvalidated = invalidated = true; + for (var _a = 0, _b = ts.Debug.checkDefined(resolution.files); _a < _b.length; _a++) { + var containingFilePath = _b[_a]; + (filesWithInvalidatedResolutions !== null && filesWithInvalidatedResolutions !== void 0 ? filesWithInvalidatedResolutions : (filesWithInvalidatedResolutions = new ts.Set())).add(containingFilePath); + // When its a file with inferred types resolution, invalidate type reference directive resolution + hasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames || ts.endsWith(containingFilePath, ts.inferredTypesContainingFile); + } + } + return invalidated; + } + function invalidateResolutionOfFile(filePath) { + removeResolutionsOfFile(filePath); + // Resolution is invalidated if the resulting file name is same as the deleted file path + var prevHasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames; + if (invalidateResolutions(resolvedFileToResolution.get(filePath), ts.returnTrue) && + hasChangedAutomaticTypeDirectiveNames && + !prevHasChangedAutomaticTypeDirectiveNames) { + resolutionHost.onChangedAutomaticTypeDirectiveNames(); + } + } + function setFilesWithInvalidatedNonRelativeUnresolvedImports(filesMap) { + ts.Debug.assert(filesWithInvalidatedNonRelativeUnresolvedImports === filesMap || filesWithInvalidatedNonRelativeUnresolvedImports === undefined); + filesWithInvalidatedNonRelativeUnresolvedImports = filesMap; + } + function scheduleInvalidateResolutionOfFailedLookupLocation(fileOrDirectoryPath, isCreatingWatchedDirectory) { + if (isCreatingWatchedDirectory) { + // Watching directory is created + // Invalidate any resolution has failed lookup in this directory + (isInDirectoryChecks || (isInDirectoryChecks = new ts.Set())).add(fileOrDirectoryPath); + } + else { + // If something to do with folder/file starting with "." in node_modules folder, skip it + var updatedPath = removeIgnoredPath(fileOrDirectoryPath); + if (!updatedPath) + return false; + fileOrDirectoryPath = updatedPath; + // prevent saving an open file from over-eagerly triggering invalidation + if (resolutionHost.fileIsOpen(fileOrDirectoryPath)) { + return false; + } + // Some file or directory in the watching directory is created + // Return early if it does not have any of the watching extension or not the custom failed lookup path + var dirOfFileOrDirectory = ts.getDirectoryPath(fileOrDirectoryPath); + if (isNodeModulesAtTypesDirectory(fileOrDirectoryPath) || ts.isNodeModulesDirectory(fileOrDirectoryPath) || + isNodeModulesAtTypesDirectory(dirOfFileOrDirectory) || ts.isNodeModulesDirectory(dirOfFileOrDirectory)) { + // Invalidate any resolution from this directory + (failedLookupChecks || (failedLookupChecks = new ts.Set())).add(fileOrDirectoryPath); + (startsWithPathChecks || (startsWithPathChecks = new ts.Set())).add(fileOrDirectoryPath); + } + else { + if (!isPathWithDefaultFailedLookupExtension(fileOrDirectoryPath) && !customFailedLookupPaths.has(fileOrDirectoryPath)) { + return false; + } + // Ignore emits from the program + if (ts.isEmittedFileOfProgram(resolutionHost.getCurrentProgram(), fileOrDirectoryPath)) { + return false; + } + // Resolution need to be invalidated if failed lookup location is same as the file or directory getting created + (failedLookupChecks || (failedLookupChecks = new ts.Set())).add(fileOrDirectoryPath); + // If the invalidated file is from a node_modules package, invalidate everything else + // in the package since we might not get notifications for other files in the package. + // This hardens our logic against unreliable file watchers. + var packagePath = ts.parseNodeModuleFromPath(fileOrDirectoryPath); + if (packagePath) + (startsWithPathChecks || (startsWithPathChecks = new ts.Set())).add(packagePath); + } + } + resolutionHost.scheduleInvalidateResolutionsOfFailedLookupLocations(); + } + function invalidateResolutionsOfFailedLookupLocations() { + var _a; + var invalidated = false; + if (affectingPathChecksForFile) { + (_a = resolutionHost.getCurrentProgram()) === null || _a === void 0 ? void 0 : _a.getSourceFiles().forEach(function (f) { + if (ts.some(f.packageJsonLocations, function (location) { return affectingPathChecksForFile.has(location); })) { + (filesWithInvalidatedResolutions !== null && filesWithInvalidatedResolutions !== void 0 ? filesWithInvalidatedResolutions : (filesWithInvalidatedResolutions = new ts.Set())).add(f.path); + invalidated = true; + } + }); + affectingPathChecksForFile = undefined; + } + if (!failedLookupChecks && !startsWithPathChecks && !isInDirectoryChecks && !affectingPathChecks) { + return invalidated; + } + invalidated = invalidateResolutions(resolutionsWithFailedLookups, canInvalidateFailedLookupResolution) || invalidated; + var packageJsonMap = moduleResolutionCache.getPackageJsonInfoCache().getInternalMap(); + if (packageJsonMap && (failedLookupChecks || startsWithPathChecks || isInDirectoryChecks)) { + packageJsonMap.forEach(function (_value, path) { return isInvalidatedFailedLookup(path) ? packageJsonMap.delete(path) : undefined; }); + } + failedLookupChecks = undefined; + startsWithPathChecks = undefined; + isInDirectoryChecks = undefined; + invalidated = invalidateResolutions(resolutionsWithOnlyAffectingLocations, canInvalidatedFailedLookupResolutionWithAffectingLocation) || invalidated; + affectingPathChecks = undefined; + return invalidated; + } + function canInvalidateFailedLookupResolution(resolution) { + if (canInvalidatedFailedLookupResolutionWithAffectingLocation(resolution)) + return true; + if (!failedLookupChecks && !startsWithPathChecks && !isInDirectoryChecks) + return false; + return resolution.failedLookupLocations.some(function (location) { return isInvalidatedFailedLookup(resolutionHost.toPath(location)); }); + } + function isInvalidatedFailedLookup(locationPath) { + return (failedLookupChecks === null || failedLookupChecks === void 0 ? void 0 : failedLookupChecks.has(locationPath)) || + ts.firstDefinedIterator((startsWithPathChecks === null || startsWithPathChecks === void 0 ? void 0 : startsWithPathChecks.keys()) || ts.emptyIterator, function (fileOrDirectoryPath) { return ts.startsWith(locationPath, fileOrDirectoryPath) ? true : undefined; }) || + ts.firstDefinedIterator((isInDirectoryChecks === null || isInDirectoryChecks === void 0 ? void 0 : isInDirectoryChecks.keys()) || ts.emptyIterator, function (fileOrDirectoryPath) { return isInDirectoryPath(fileOrDirectoryPath, locationPath) ? true : undefined; }); + } + function canInvalidatedFailedLookupResolutionWithAffectingLocation(resolution) { + return !!affectingPathChecks && resolution.affectingLocations.some(function (location) { return affectingPathChecks.has(location); }); + } + function closeTypeRootsWatch() { + ts.clearMap(typeRootsWatches, ts.closeFileWatcher); + } + function getDirectoryToWatchFailedLookupLocationFromTypeRoot(typeRoot, typeRootPath) { + if (isInDirectoryPath(rootPath, typeRootPath)) { + return rootPath; + } + var toWatch = getDirectoryToWatchFromFailedLookupLocationDirectory(typeRoot, typeRootPath); + return toWatch && directoryWatchesOfFailedLookups.has(toWatch.dirPath) ? toWatch.dirPath : undefined; + } + function createTypeRootsWatch(typeRootPath, typeRoot) { + // Create new watch and recursive info + return resolutionHost.watchTypeRootsDirectory(typeRoot, function (fileOrDirectory) { + var fileOrDirectoryPath = resolutionHost.toPath(fileOrDirectory); + if (cachedDirectoryStructureHost) { + // Since the file existence changed, update the sourceFiles cache + cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath); + } + // For now just recompile + // We could potentially store more data here about whether it was/would be really be used or not + // and with that determine to trigger compilation but for now this is enough + hasChangedAutomaticTypeDirectiveNames = true; + resolutionHost.onChangedAutomaticTypeDirectiveNames(); + // Since directory watchers invoked are flaky, the failed lookup location events might not be triggered + // So handle to failed lookup locations here as well to ensure we are invalidating resolutions + var dirPath = getDirectoryToWatchFailedLookupLocationFromTypeRoot(typeRoot, typeRootPath); + if (dirPath) { + scheduleInvalidateResolutionOfFailedLookupLocation(fileOrDirectoryPath, dirPath === fileOrDirectoryPath); + } + }, 1 /* WatchDirectoryFlags.Recursive */); + } + /** + * Watches the types that would get added as part of getAutomaticTypeDirectiveNames + * To be called when compiler options change + */ + function updateTypeRootsWatch() { + var options = resolutionHost.getCompilationSettings(); + if (options.types) { + // No need to do any watch since resolution cache is going to handle the failed lookups + // for the types added by this + closeTypeRootsWatch(); + return; + } + // we need to assume the directories exist to ensure that we can get all the type root directories that get included + // But filter directories that are at root level to say directory doesnt exist, so that we arent watching them + var typeRoots = ts.getEffectiveTypeRoots(options, { directoryExists: directoryExistsForTypeRootWatch, getCurrentDirectory: getCurrentDirectory }); + if (typeRoots) { + ts.mutateMap(typeRootsWatches, ts.arrayToMap(typeRoots, function (tr) { return resolutionHost.toPath(tr); }), { + createNewValue: createTypeRootsWatch, + onDeleteValue: ts.closeFileWatcher + }); + } + else { + closeTypeRootsWatch(); + } + } + /** + * Use this function to return if directory exists to get type roots to watch + * If we return directory exists then only the paths will be added to type roots + * Hence return true for all directories except root directories which are filtered from watching + */ + function directoryExistsForTypeRootWatch(nodeTypesDirectory) { + var dir = ts.getDirectoryPath(ts.getDirectoryPath(nodeTypesDirectory)); + var dirPath = resolutionHost.toPath(dir); + return dirPath === rootPath || canWatchDirectoryOrFile(dirPath); + } + } + ts.createResolutionCache = createResolutionCache; + function resolutionIsSymlink(resolution) { + var _a, _b; + return !!(((_a = resolution.resolvedModule) === null || _a === void 0 ? void 0 : _a.originalPath) || + ((_b = resolution.resolvedTypeReferenceDirective) === null || _b === void 0 ? void 0 : _b.originalPath)); + } +})(ts || (ts = {})); +// Used by importFixes, getEditsForFileRename, and declaration emit to synthesize import module specifiers. +/* @internal */ +var ts; +(function (ts) { + var moduleSpecifiers; + (function (moduleSpecifiers_1) { + var RelativePreference; + (function (RelativePreference) { + RelativePreference[RelativePreference["Relative"] = 0] = "Relative"; + RelativePreference[RelativePreference["NonRelative"] = 1] = "NonRelative"; + RelativePreference[RelativePreference["Shortest"] = 2] = "Shortest"; + RelativePreference[RelativePreference["ExternalNonRelative"] = 3] = "ExternalNonRelative"; + })(RelativePreference || (RelativePreference = {})); + // See UserPreferences#importPathEnding + var Ending; + (function (Ending) { + Ending[Ending["Minimal"] = 0] = "Minimal"; + Ending[Ending["Index"] = 1] = "Index"; + Ending[Ending["JsExtension"] = 2] = "JsExtension"; + })(Ending || (Ending = {})); + function getPreferences(host, _a, compilerOptions, importingSourceFile) { + var importModuleSpecifierPreference = _a.importModuleSpecifierPreference, importModuleSpecifierEnding = _a.importModuleSpecifierEnding; + return { + relativePreference: importModuleSpecifierPreference === "relative" ? 0 /* RelativePreference.Relative */ : + importModuleSpecifierPreference === "non-relative" ? 1 /* RelativePreference.NonRelative */ : + importModuleSpecifierPreference === "project-relative" ? 3 /* RelativePreference.ExternalNonRelative */ : + 2 /* RelativePreference.Shortest */, + ending: getEnding(), + }; + function getEnding() { + switch (importModuleSpecifierEnding) { + case "minimal": return 0 /* Ending.Minimal */; + case "index": return 1 /* Ending.Index */; + case "js": return 2 /* Ending.JsExtension */; + default: return usesJsExtensionOnImports(importingSourceFile) || isFormatRequiringExtensions(compilerOptions, importingSourceFile.path, host) ? 2 /* Ending.JsExtension */ + : ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.NodeJs ? 1 /* Ending.Index */ : 0 /* Ending.Minimal */; + } + } + } + function getPreferencesForUpdate(compilerOptions, oldImportSpecifier, importingSourceFileName, host) { + return { + relativePreference: ts.isExternalModuleNameRelative(oldImportSpecifier) ? 0 /* RelativePreference.Relative */ : 1 /* RelativePreference.NonRelative */, + ending: ts.hasJSFileExtension(oldImportSpecifier) || isFormatRequiringExtensions(compilerOptions, importingSourceFileName, host) ? + 2 /* Ending.JsExtension */ : + ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.NodeJs || ts.endsWith(oldImportSpecifier, "index") ? 1 /* Ending.Index */ : 0 /* Ending.Minimal */, + }; + } + function isFormatRequiringExtensions(compilerOptions, importingSourceFileName, host) { + var _a; + if (ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.Node16 + && ts.getEmitModuleResolutionKind(compilerOptions) !== ts.ModuleResolutionKind.NodeNext) { + return false; + } + return ts.getImpliedNodeFormatForFile(importingSourceFileName, (_a = host.getPackageJsonInfoCache) === null || _a === void 0 ? void 0 : _a.call(host), getModuleResolutionHost(host), compilerOptions) !== ts.ModuleKind.CommonJS; + } + function getModuleResolutionHost(host) { + var _a; + return { + fileExists: host.fileExists, + readFile: ts.Debug.checkDefined(host.readFile), + directoryExists: host.directoryExists, + getCurrentDirectory: host.getCurrentDirectory, + realpath: host.realpath, + useCaseSensitiveFileNames: (_a = host.useCaseSensitiveFileNames) === null || _a === void 0 ? void 0 : _a.call(host), + }; + } + // `importingSourceFile` and `importingSourceFileName`? Why not just use `importingSourceFile.path`? + // Because when this is called by the file renamer, `importingSourceFile` is the file being renamed, + // while `importingSourceFileName` its *new* name. We need a source file just to get its + // `impliedNodeFormat` and to detect certain preferences from existing import module specifiers. + function updateModuleSpecifier(compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, oldImportSpecifier, options) { + if (options === void 0) { options = {}; } + var res = getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, getPreferencesForUpdate(compilerOptions, oldImportSpecifier, importingSourceFileName, host), {}, options); + if (res === oldImportSpecifier) + return undefined; + return res; + } + moduleSpecifiers_1.updateModuleSpecifier = updateModuleSpecifier; + // `importingSourceFile` and `importingSourceFileName`? Why not just use `importingSourceFile.path`? + // Because when this is called by the declaration emitter, `importingSourceFile` is the implementation + // file, but `importingSourceFileName` and `toFileName` refer to declaration files (the former to the + // one currently being produced; the latter to the one being imported). We need an implementation file + // just to get its `impliedNodeFormat` and to detect certain preferences from existing import module + // specifiers. + function getModuleSpecifier(compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, options) { + if (options === void 0) { options = {}; } + return getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, getPreferences(host, {}, compilerOptions, importingSourceFile), {}, options); + } + moduleSpecifiers_1.getModuleSpecifier = getModuleSpecifier; + function getNodeModulesPackageName(compilerOptions, importingSourceFile, nodeModulesFileName, host, preferences, options) { + if (options === void 0) { options = {}; } + var info = getInfo(importingSourceFile.path, host); + var modulePaths = getAllModulePaths(importingSourceFile.path, nodeModulesFileName, host, preferences, options); + return ts.firstDefined(modulePaths, function (modulePath) { return tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, preferences, /*packageNameOnly*/ true, options.overrideImportMode); }); + } + moduleSpecifiers_1.getNodeModulesPackageName = getNodeModulesPackageName; + function getModuleSpecifierWorker(compilerOptions, importingSourceFile, importingSourceFileName, toFileName, host, preferences, userPreferences, options) { + if (options === void 0) { options = {}; } + var info = getInfo(importingSourceFileName, host); + var modulePaths = getAllModulePaths(importingSourceFileName, toFileName, host, userPreferences, options); + return ts.firstDefined(modulePaths, function (modulePath) { return tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, userPreferences, /*packageNameOnly*/ undefined, options.overrideImportMode); }) || + getLocalModuleSpecifier(toFileName, info, compilerOptions, host, options.overrideImportMode || importingSourceFile.impliedNodeFormat, preferences); + } + function tryGetModuleSpecifiersFromCache(moduleSymbol, importingSourceFile, host, userPreferences, options) { + if (options === void 0) { options = {}; } + return tryGetModuleSpecifiersFromCacheWorker(moduleSymbol, importingSourceFile, host, userPreferences, options)[0]; + } + moduleSpecifiers_1.tryGetModuleSpecifiersFromCache = tryGetModuleSpecifiersFromCache; + function tryGetModuleSpecifiersFromCacheWorker(moduleSymbol, importingSourceFile, host, userPreferences, options) { + var _a; + if (options === void 0) { options = {}; } + var moduleSourceFile = ts.getSourceFileOfModule(moduleSymbol); + if (!moduleSourceFile) { + return ts.emptyArray; + } + var cache = (_a = host.getModuleSpecifierCache) === null || _a === void 0 ? void 0 : _a.call(host); + var cached = cache === null || cache === void 0 ? void 0 : cache.get(importingSourceFile.path, moduleSourceFile.path, userPreferences, options); + return [cached === null || cached === void 0 ? void 0 : cached.moduleSpecifiers, moduleSourceFile, cached === null || cached === void 0 ? void 0 : cached.modulePaths, cache]; + } + /** Returns an import for each symlink and for the realpath. */ + function getModuleSpecifiers(moduleSymbol, checker, compilerOptions, importingSourceFile, host, userPreferences, options) { + if (options === void 0) { options = {}; } + return getModuleSpecifiersWithCacheInfo(moduleSymbol, checker, compilerOptions, importingSourceFile, host, userPreferences, options).moduleSpecifiers; + } + moduleSpecifiers_1.getModuleSpecifiers = getModuleSpecifiers; + function getModuleSpecifiersWithCacheInfo(moduleSymbol, checker, compilerOptions, importingSourceFile, host, userPreferences, options) { + if (options === void 0) { options = {}; } + var computedWithoutCache = false; + var ambient = tryGetModuleNameFromAmbientModule(moduleSymbol, checker); + if (ambient) + return { moduleSpecifiers: [ambient], computedWithoutCache: computedWithoutCache }; + // eslint-disable-next-line prefer-const + var _a = tryGetModuleSpecifiersFromCacheWorker(moduleSymbol, importingSourceFile, host, userPreferences, options), specifiers = _a[0], moduleSourceFile = _a[1], modulePaths = _a[2], cache = _a[3]; + if (specifiers) + return { moduleSpecifiers: specifiers, computedWithoutCache: computedWithoutCache }; + if (!moduleSourceFile) + return { moduleSpecifiers: ts.emptyArray, computedWithoutCache: computedWithoutCache }; + computedWithoutCache = true; + modulePaths || (modulePaths = getAllModulePathsWorker(importingSourceFile.path, moduleSourceFile.originalFileName, host)); + var result = computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFile, host, userPreferences, options); + cache === null || cache === void 0 ? void 0 : cache.set(importingSourceFile.path, moduleSourceFile.path, userPreferences, options, modulePaths, result); + return { moduleSpecifiers: result, computedWithoutCache: computedWithoutCache }; + } + moduleSpecifiers_1.getModuleSpecifiersWithCacheInfo = getModuleSpecifiersWithCacheInfo; + function computeModuleSpecifiers(modulePaths, compilerOptions, importingSourceFile, host, userPreferences, options) { + if (options === void 0) { options = {}; } + var info = getInfo(importingSourceFile.path, host); + var preferences = getPreferences(host, userPreferences, compilerOptions, importingSourceFile); + var existingSpecifier = ts.forEach(modulePaths, function (modulePath) { return ts.forEach(host.getFileIncludeReasons().get(ts.toPath(modulePath.path, host.getCurrentDirectory(), info.getCanonicalFileName)), function (reason) { + if (reason.kind !== ts.FileIncludeKind.Import || reason.file !== importingSourceFile.path) + return undefined; + // If the candidate import mode doesn't match the mode we're generating for, don't consider it + // TODO: maybe useful to keep around as an alternative option for certain contexts where the mode is overridable + if (importingSourceFile.impliedNodeFormat && importingSourceFile.impliedNodeFormat !== ts.getModeForResolutionAtIndex(importingSourceFile, reason.index)) + return undefined; + var specifier = ts.getModuleNameStringLiteralAt(importingSourceFile, reason.index).text; + // If the preference is for non relative and the module specifier is relative, ignore it + return preferences.relativePreference !== 1 /* RelativePreference.NonRelative */ || !ts.pathIsRelative(specifier) ? + specifier : + undefined; + }); }); + if (existingSpecifier) { + var moduleSpecifiers_2 = [existingSpecifier]; + return moduleSpecifiers_2; + } + var importedFileIsInNodeModules = ts.some(modulePaths, function (p) { return p.isInNodeModules; }); + // Module specifier priority: + // 1. "Bare package specifiers" (e.g. "@foo/bar") resulting from a path through node_modules to a package.json's "types" entry + // 2. Specifiers generated using "paths" from tsconfig + // 3. Non-relative specfiers resulting from a path through node_modules (e.g. "@foo/bar/path/to/file") + // 4. Relative paths + var nodeModulesSpecifiers; + var pathsSpecifiers; + var relativeSpecifiers; + for (var _i = 0, modulePaths_1 = modulePaths; _i < modulePaths_1.length; _i++) { + var modulePath = modulePaths_1[_i]; + var specifier = tryGetModuleNameAsNodeModule(modulePath, info, importingSourceFile, host, compilerOptions, userPreferences, /*packageNameOnly*/ undefined, options.overrideImportMode); + nodeModulesSpecifiers = ts.append(nodeModulesSpecifiers, specifier); + if (specifier && modulePath.isRedirect) { + // If we got a specifier for a redirect, it was a bare package specifier (e.g. "@foo/bar", + // not "@foo/bar/path/to/file"). No other specifier will be this good, so stop looking. + return nodeModulesSpecifiers; + } + if (!specifier && !modulePath.isRedirect) { + var local = getLocalModuleSpecifier(modulePath.path, info, compilerOptions, host, options.overrideImportMode || importingSourceFile.impliedNodeFormat, preferences); + if (ts.pathIsBareSpecifier(local)) { + pathsSpecifiers = ts.append(pathsSpecifiers, local); + } + else if (!importedFileIsInNodeModules || modulePath.isInNodeModules) { + // Why this extra conditional, not just an `else`? If some path to the file contained + // 'node_modules', but we can't create a non-relative specifier (e.g. "@foo/bar/path/to/file"), + // that means we had to go through a *sibling's* node_modules, not one we can access directly. + // If some path to the file was in node_modules but another was not, this likely indicates that + // we have a monorepo structure with symlinks. In this case, the non-node_modules path is + // probably the realpath, e.g. "../bar/path/to/file", but a relative path to another package + // in a monorepo is probably not portable. So, the module specifier we actually go with will be + // the relative path through node_modules, so that the declaration emitter can produce a + // portability error. (See declarationEmitReexportedSymlinkReference3) + relativeSpecifiers = ts.append(relativeSpecifiers, local); + } + } + } + return (pathsSpecifiers === null || pathsSpecifiers === void 0 ? void 0 : pathsSpecifiers.length) ? pathsSpecifiers : + (nodeModulesSpecifiers === null || nodeModulesSpecifiers === void 0 ? void 0 : nodeModulesSpecifiers.length) ? nodeModulesSpecifiers : + ts.Debug.checkDefined(relativeSpecifiers); + } + // importingSourceFileName is separate because getEditsForFileRename may need to specify an updated path + function getInfo(importingSourceFileName, host) { + var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames ? host.useCaseSensitiveFileNames() : true); + var sourceDirectory = ts.getDirectoryPath(importingSourceFileName); + return { getCanonicalFileName: getCanonicalFileName, importingSourceFileName: importingSourceFileName, sourceDirectory: sourceDirectory }; + } + function getLocalModuleSpecifier(moduleFileName, info, compilerOptions, host, importMode, _a) { + var ending = _a.ending, relativePreference = _a.relativePreference; + var baseUrl = compilerOptions.baseUrl, paths = compilerOptions.paths, rootDirs = compilerOptions.rootDirs; + var sourceDirectory = info.sourceDirectory, getCanonicalFileName = info.getCanonicalFileName; + var relativePath = rootDirs && tryGetModuleNameFromRootDirs(rootDirs, moduleFileName, sourceDirectory, getCanonicalFileName, ending, compilerOptions) || + removeExtensionAndIndexPostFix(ts.ensurePathIsNonModuleName(ts.getRelativePathFromDirectory(sourceDirectory, moduleFileName, getCanonicalFileName)), ending, compilerOptions); + if (!baseUrl && !paths || relativePreference === 0 /* RelativePreference.Relative */) { + return relativePath; + } + var baseDirectory = ts.getNormalizedAbsolutePath(ts.getPathsBasePath(compilerOptions, host) || baseUrl, host.getCurrentDirectory()); + var relativeToBaseUrl = getRelativePathIfInDirectory(moduleFileName, baseDirectory, getCanonicalFileName); + if (!relativeToBaseUrl) { + return relativePath; + } + var fromPaths = paths && tryGetModuleNameFromPaths(relativeToBaseUrl, paths, getAllowedEndings(ending, compilerOptions, importMode), host, compilerOptions); + var nonRelative = fromPaths === undefined && baseUrl !== undefined ? removeExtensionAndIndexPostFix(relativeToBaseUrl, ending, compilerOptions) : fromPaths; + if (!nonRelative) { + return relativePath; + } + if (relativePreference === 1 /* RelativePreference.NonRelative */) { + return nonRelative; + } + if (relativePreference === 3 /* RelativePreference.ExternalNonRelative */) { + var projectDirectory = compilerOptions.configFilePath ? + ts.toPath(ts.getDirectoryPath(compilerOptions.configFilePath), host.getCurrentDirectory(), info.getCanonicalFileName) : + info.getCanonicalFileName(host.getCurrentDirectory()); + var modulePath = ts.toPath(moduleFileName, projectDirectory, getCanonicalFileName); + var sourceIsInternal = ts.startsWith(sourceDirectory, projectDirectory); + var targetIsInternal = ts.startsWith(modulePath, projectDirectory); + if (sourceIsInternal && !targetIsInternal || !sourceIsInternal && targetIsInternal) { + // 1. The import path crosses the boundary of the tsconfig.json-containing directory. + // + // src/ + // tsconfig.json + // index.ts ------- + // lib/ | (path crosses tsconfig.json) + // imported.ts <--- + // + return nonRelative; + } + var nearestTargetPackageJson = getNearestAncestorDirectoryWithPackageJson(host, ts.getDirectoryPath(modulePath)); + var nearestSourcePackageJson = getNearestAncestorDirectoryWithPackageJson(host, sourceDirectory); + if (nearestSourcePackageJson !== nearestTargetPackageJson) { + // 2. The importing and imported files are part of different packages. + // + // packages/a/ + // package.json + // index.ts -------- + // packages/b/ | (path crosses package.json) + // package.json | + // component.ts <--- + // + return nonRelative; + } + return relativePath; + } + if (relativePreference !== 2 /* RelativePreference.Shortest */) + ts.Debug.assertNever(relativePreference); + // Prefer a relative import over a baseUrl import if it has fewer components. + return isPathRelativeToParent(nonRelative) || countPathComponents(relativePath) < countPathComponents(nonRelative) ? relativePath : nonRelative; + } + function countPathComponents(path) { + var count = 0; + for (var i = ts.startsWith(path, "./") ? 2 : 0; i < path.length; i++) { + if (path.charCodeAt(i) === 47 /* CharacterCodes.slash */) + count++; + } + return count; + } + moduleSpecifiers_1.countPathComponents = countPathComponents; + function usesJsExtensionOnImports(_a) { + var imports = _a.imports; + return ts.firstDefined(imports, function (_a) { + var text = _a.text; + return ts.pathIsRelative(text) ? ts.hasJSFileExtension(text) : undefined; + }) || false; + } + function comparePathsByRedirectAndNumberOfDirectorySeparators(a, b) { + return ts.compareBooleans(b.isRedirect, a.isRedirect) || ts.compareNumberOfDirectorySeparators(a.path, b.path); + } + function getNearestAncestorDirectoryWithPackageJson(host, fileName) { + if (host.getNearestAncestorDirectoryWithPackageJson) { + return host.getNearestAncestorDirectoryWithPackageJson(fileName); + } + return !!ts.forEachAncestorDirectory(fileName, function (directory) { + return host.fileExists(ts.combinePaths(directory, "package.json")) ? true : undefined; + }); + } + function forEachFileNameOfModule(importingFileName, importedFileName, host, preferSymlinks, cb) { + var _a; + var getCanonicalFileName = ts.hostGetCanonicalFileName(host); + var cwd = host.getCurrentDirectory(); + var referenceRedirect = host.isSourceOfProjectReferenceRedirect(importedFileName) ? host.getProjectReferenceRedirect(importedFileName) : undefined; + var importedPath = ts.toPath(importedFileName, cwd, getCanonicalFileName); + var redirects = host.redirectTargetsMap.get(importedPath) || ts.emptyArray; + var importedFileNames = __spreadArray(__spreadArray(__spreadArray([], (referenceRedirect ? [referenceRedirect] : ts.emptyArray), true), [importedFileName], false), redirects, true); + var targets = importedFileNames.map(function (f) { return ts.getNormalizedAbsolutePath(f, cwd); }); + var shouldFilterIgnoredPaths = !ts.every(targets, ts.containsIgnoredPath); + if (!preferSymlinks) { + // Symlinks inside ignored paths are already filtered out of the symlink cache, + // so we only need to remove them from the realpath filenames. + var result_16 = ts.forEach(targets, function (p) { return !(shouldFilterIgnoredPaths && ts.containsIgnoredPath(p)) && cb(p, referenceRedirect === p); }); + if (result_16) + return result_16; + } + var symlinkedDirectories = (_a = host.getSymlinkCache) === null || _a === void 0 ? void 0 : _a.call(host).getSymlinkedDirectoriesByRealpath(); + var fullImportedFileName = ts.getNormalizedAbsolutePath(importedFileName, cwd); + var result = symlinkedDirectories && ts.forEachAncestorDirectory(ts.getDirectoryPath(fullImportedFileName), function (realPathDirectory) { + var symlinkDirectories = symlinkedDirectories.get(ts.ensureTrailingDirectorySeparator(ts.toPath(realPathDirectory, cwd, getCanonicalFileName))); + if (!symlinkDirectories) + return undefined; // Continue to ancestor directory + // Don't want to a package to globally import from itself (importNameCodeFix_symlink_own_package.ts) + if (ts.startsWithDirectory(importingFileName, realPathDirectory, getCanonicalFileName)) { + return false; // Stop search, each ancestor directory will also hit this condition + } + return ts.forEach(targets, function (target) { + if (!ts.startsWithDirectory(target, realPathDirectory, getCanonicalFileName)) { + return; + } + var relative = ts.getRelativePathFromDirectory(realPathDirectory, target, getCanonicalFileName); + for (var _i = 0, symlinkDirectories_1 = symlinkDirectories; _i < symlinkDirectories_1.length; _i++) { + var symlinkDirectory = symlinkDirectories_1[_i]; + var option = ts.resolvePath(symlinkDirectory, relative); + var result_17 = cb(option, target === referenceRedirect); + shouldFilterIgnoredPaths = true; // We found a non-ignored path in symlinks, so we can reject ignored-path realpaths + if (result_17) + return result_17; + } + }); + }); + return result || (preferSymlinks + ? ts.forEach(targets, function (p) { return shouldFilterIgnoredPaths && ts.containsIgnoredPath(p) ? undefined : cb(p, p === referenceRedirect); }) + : undefined); + } + moduleSpecifiers_1.forEachFileNameOfModule = forEachFileNameOfModule; + /** + * Looks for existing imports that use symlinks to this module. + * Symlinks will be returned first so they are preferred over the real path. + */ + function getAllModulePaths(importingFilePath, importedFileName, host, preferences, options) { + var _a; + if (options === void 0) { options = {}; } + var importedFilePath = ts.toPath(importedFileName, host.getCurrentDirectory(), ts.hostGetCanonicalFileName(host)); + var cache = (_a = host.getModuleSpecifierCache) === null || _a === void 0 ? void 0 : _a.call(host); + if (cache) { + var cached = cache.get(importingFilePath, importedFilePath, preferences, options); + if (cached === null || cached === void 0 ? void 0 : cached.modulePaths) + return cached.modulePaths; + } + var modulePaths = getAllModulePathsWorker(importingFilePath, importedFileName, host); + if (cache) { + cache.setModulePaths(importingFilePath, importedFilePath, preferences, options, modulePaths); + } + return modulePaths; + } + function getAllModulePathsWorker(importingFileName, importedFileName, host) { + var getCanonicalFileName = ts.hostGetCanonicalFileName(host); + var allFileNames = new ts.Map(); + var importedFileFromNodeModules = false; + forEachFileNameOfModule(importingFileName, importedFileName, host, + /*preferSymlinks*/ true, function (path, isRedirect) { + var isInNodeModules = ts.pathContainsNodeModules(path); + allFileNames.set(path, { path: getCanonicalFileName(path), isRedirect: isRedirect, isInNodeModules: isInNodeModules }); + importedFileFromNodeModules = importedFileFromNodeModules || isInNodeModules; + // don't return value, so we collect everything + }); + // Sort by paths closest to importing file Name directory + var sortedPaths = []; + var _loop_35 = function (directory) { + var directoryStart = ts.ensureTrailingDirectorySeparator(directory); + var pathsInDirectory; + allFileNames.forEach(function (_a, fileName) { + var path = _a.path, isRedirect = _a.isRedirect, isInNodeModules = _a.isInNodeModules; + if (ts.startsWith(path, directoryStart)) { + (pathsInDirectory || (pathsInDirectory = [])).push({ path: fileName, isRedirect: isRedirect, isInNodeModules: isInNodeModules }); + allFileNames.delete(fileName); + } + }); + if (pathsInDirectory) { + if (pathsInDirectory.length > 1) { + pathsInDirectory.sort(comparePathsByRedirectAndNumberOfDirectorySeparators); + } + sortedPaths.push.apply(sortedPaths, pathsInDirectory); + } + var newDirectory = ts.getDirectoryPath(directory); + if (newDirectory === directory) + return out_directory_1 = directory, "break"; + directory = newDirectory; + out_directory_1 = directory; + }; + var out_directory_1; + for (var directory = ts.getDirectoryPath(importingFileName); allFileNames.size !== 0;) { + var state_11 = _loop_35(directory); + directory = out_directory_1; + if (state_11 === "break") + break; + } + if (allFileNames.size) { + var remainingPaths = ts.arrayFrom(allFileNames.values()); + if (remainingPaths.length > 1) + remainingPaths.sort(comparePathsByRedirectAndNumberOfDirectorySeparators); + sortedPaths.push.apply(sortedPaths, remainingPaths); + } + return sortedPaths; + } + function tryGetModuleNameFromAmbientModule(moduleSymbol, checker) { + var _a; + var decl = (_a = moduleSymbol.declarations) === null || _a === void 0 ? void 0 : _a.find(function (d) { return ts.isNonGlobalAmbientModule(d) && (!ts.isExternalModuleAugmentation(d) || !ts.isExternalModuleNameRelative(ts.getTextOfIdentifierOrLiteral(d.name))); }); + if (decl) { + return decl.name.text; + } + // the module could be a namespace, which is export through "export=" from an ambient module. + /** + * declare module "m" { + * namespace ns { + * class c {} + * } + * export = ns; + * } + */ + // `import {c} from "m";` is valid, in which case, `moduleSymbol` is "ns", but the module name should be "m" + var ambientModuleDeclareCandidates = ts.mapDefined(moduleSymbol.declarations, function (d) { + var _a, _b, _c, _d; + if (!ts.isModuleDeclaration(d)) + return; + var topNamespace = getTopNamespace(d); + if (!(((_a = topNamespace === null || topNamespace === void 0 ? void 0 : topNamespace.parent) === null || _a === void 0 ? void 0 : _a.parent) + && ts.isModuleBlock(topNamespace.parent) && ts.isAmbientModule(topNamespace.parent.parent) && ts.isSourceFile(topNamespace.parent.parent.parent))) + return; + var exportAssignment = (_d = (_c = (_b = topNamespace.parent.parent.symbol.exports) === null || _b === void 0 ? void 0 : _b.get("export=")) === null || _c === void 0 ? void 0 : _c.valueDeclaration) === null || _d === void 0 ? void 0 : _d.expression; + if (!exportAssignment) + return; + var exportSymbol = checker.getSymbolAtLocation(exportAssignment); + if (!exportSymbol) + return; + var originalExportSymbol = (exportSymbol === null || exportSymbol === void 0 ? void 0 : exportSymbol.flags) & 2097152 /* SymbolFlags.Alias */ ? checker.getAliasedSymbol(exportSymbol) : exportSymbol; + if (originalExportSymbol === d.symbol) + return topNamespace.parent.parent; + function getTopNamespace(namespaceDeclaration) { + while (namespaceDeclaration.flags & 4 /* NodeFlags.NestedNamespace */) { + namespaceDeclaration = namespaceDeclaration.parent; + } + return namespaceDeclaration; + } + }); + var ambientModuleDeclare = ambientModuleDeclareCandidates[0]; + if (ambientModuleDeclare) { + return ambientModuleDeclare.name.text; + } + } + function getAllowedEndings(preferredEnding, compilerOptions, importMode) { + if (ts.getEmitModuleResolutionKind(compilerOptions) >= ts.ModuleResolutionKind.Node16 && importMode === ts.ModuleKind.ESNext) { + return [2 /* Ending.JsExtension */]; + } + switch (preferredEnding) { + case 2 /* Ending.JsExtension */: return [2 /* Ending.JsExtension */, 0 /* Ending.Minimal */, 1 /* Ending.Index */]; + case 1 /* Ending.Index */: return [1 /* Ending.Index */, 0 /* Ending.Minimal */, 2 /* Ending.JsExtension */]; + case 0 /* Ending.Minimal */: return [0 /* Ending.Minimal */, 1 /* Ending.Index */, 2 /* Ending.JsExtension */]; + default: ts.Debug.assertNever(preferredEnding); + } + } + function tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, host, compilerOptions) { + for (var key in paths) { + var _loop_36 = function (patternText_1) { + var pattern = ts.normalizePath(patternText_1); + var indexOfStar = pattern.indexOf("*"); + // In module resolution, if `pattern` itself has an extension, a file with that extension is looked up directly, + // meaning a '.ts' or '.d.ts' extension is allowed to resolve. This is distinct from the case where a '*' substitution + // causes a module specifier to have an extension, i.e. the extension comes from the module specifier in a JS/TS file + // and matches the '*'. For example: + // + // Module Specifier | Path Mapping (key: [pattern]) | Interpolation | Resolution Action + // ---------------------->------------------------------->--------------------->--------------------------------------------------------------- + // import "@app/foo" -> "@app/*": ["./src/app/*.ts"] -> "./src/app/foo.ts" -> tryFile("./src/app/foo.ts") || [continue resolution algorithm] + // import "@app/foo.ts" -> "@app/*": ["./src/app/*"] -> "./src/app/foo.ts" -> [continue resolution algorithm] + // + // (https://github.com/microsoft/TypeScript/blob/ad4ded80e1d58f0bf36ac16bea71bc10d9f09895/src/compiler/moduleNameResolver.ts#L2509-L2516) + // + // The interpolation produced by both scenarios is identical, but only in the former, where the extension is encoded in + // the path mapping rather than in the module specifier, will we prioritize a file lookup on the interpolation result. + // (In fact, currently, the latter scenario will necessarily fail since no resolution mode recognizes '.ts' as a valid + // extension for a module specifier.) + // + // Here, this means we need to be careful about whether we generate a match from the target filename (typically with a + // .ts extension) or the possible relative module specifiers representing that file: + // + // Filename | Relative Module Specifier Candidates | Path Mapping | Filename Result | Module Specifier Results + // --------------------<----------------------------------------------<------------------------------<-------------------||---------------------------- + // dist/haha.d.ts <- dist/haha, dist/haha.js <- "@app/*": ["./dist/*.d.ts"] <- @app/haha || (none) + // dist/haha.d.ts <- dist/haha, dist/haha.js <- "@app/*": ["./dist/*"] <- (none) || @app/haha, @app/haha.js + // dist/foo/index.d.ts <- dist/foo, dist/foo/index, dist/foo/index.js <- "@app/*": ["./dist/*.d.ts"] <- @app/foo/index || (none) + // dist/foo/index.d.ts <- dist/foo, dist/foo/index, dist/foo/index.js <- "@app/*": ["./dist/*"] <- (none) || @app/foo, @app/foo/index, @app/foo/index.js + // dist/wow.js.js <- dist/wow.js, dist/wow.js.js <- "@app/*": ["./dist/*.js"] <- @app/wow.js || @app/wow, @app/wow.js + // + // The "Filename Result" can be generated only if `pattern` has an extension. Care must be taken that the list of + // relative module specifiers to run the interpolation (a) is actually valid for the module resolution mode, (b) takes + // into account the existence of other files (e.g. 'dist/wow.js' cannot refer to 'dist/wow.js.js' if 'dist/wow.js' + // exists) and (c) that they are ordered by preference. The last row shows that the filename result and module + // specifier results are not mutually exclusive. Note that the filename result is a higher priority in module + // resolution, but as long criteria (b) above is met, I don't think its result needs to be the highest priority result + // in module specifier generation. I have included it last, as it's difficult to tell exactly where it should be + // sorted among the others for a particular value of `importModuleSpecifierEnding`. + var candidates = allowedEndings.map(function (ending) { return ({ + ending: ending, + value: removeExtensionAndIndexPostFix(relativeToBaseUrl, ending, compilerOptions) + }); }); + if (ts.tryGetExtensionFromPath(pattern)) { + candidates.push({ ending: undefined, value: relativeToBaseUrl }); + } + if (indexOfStar !== -1) { + var prefix = pattern.substring(0, indexOfStar); + var suffix = pattern.substring(indexOfStar + 1); + for (var _b = 0, candidates_3 = candidates; _b < candidates_3.length; _b++) { + var _c = candidates_3[_b], ending = _c.ending, value = _c.value; + if (value.length >= prefix.length + suffix.length && + ts.startsWith(value, prefix) && + ts.endsWith(value, suffix) && + validateEnding({ ending: ending, value: value })) { + var matchedStar = value.substring(prefix.length, value.length - suffix.length); + return { value: key.replace("*", matchedStar) }; + } + } + } + else if (ts.some(candidates, function (c) { return c.ending !== 0 /* Ending.Minimal */ && pattern === c.value; }) || + ts.some(candidates, function (c) { return c.ending === 0 /* Ending.Minimal */ && pattern === c.value && validateEnding(c); })) { + return { value: key }; + } + }; + for (var _i = 0, _a = paths[key]; _i < _a.length; _i++) { + var patternText_1 = _a[_i]; + var state_12 = _loop_36(patternText_1); + if (typeof state_12 === "object") + return state_12.value; + } + } + function validateEnding(_a) { + var ending = _a.ending, value = _a.value; + // Optimization: `removeExtensionAndIndexPostFix` can query the file system (a good bit) if `ending` is `Minimal`, the basename + // is 'index', and a `host` is provided. To avoid that until it's unavoidable, we ran the function with no `host` above. Only + // here, after we've checked that the minimal ending is indeed a match (via the length and prefix/suffix checks / `some` calls), + // do we check that the host-validated result is consistent with the answer we got before. If it's not, it falls back to the + // `Ending.Index` result, which should already be in the list of candidates if `Minimal` was. (Note: the assumption here is + // that every module resolution mode that supports dropping extensions also supports dropping `/index`. Like literally + // everything else in this file, this logic needs to be updated if that's not true in some future module resolution mode.) + return ending !== 0 /* Ending.Minimal */ || value === removeExtensionAndIndexPostFix(relativeToBaseUrl, ending, compilerOptions, host); + } + } + var MatchingMode; + (function (MatchingMode) { + MatchingMode[MatchingMode["Exact"] = 0] = "Exact"; + MatchingMode[MatchingMode["Directory"] = 1] = "Directory"; + MatchingMode[MatchingMode["Pattern"] = 2] = "Pattern"; + })(MatchingMode || (MatchingMode = {})); + function tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, packageName, exports, conditions, mode) { + if (mode === void 0) { mode = 0 /* MatchingMode.Exact */; } + if (typeof exports === "string") { + var pathOrPattern = ts.getNormalizedAbsolutePath(ts.combinePaths(packageDirectory, exports), /*currentDirectory*/ undefined); + var extensionSwappedTarget = ts.hasTSFileExtension(targetFilePath) ? ts.removeFileExtension(targetFilePath) + tryGetJSExtensionForFile(targetFilePath, options) : undefined; + switch (mode) { + case 0 /* MatchingMode.Exact */: + if (ts.comparePaths(targetFilePath, pathOrPattern) === 0 /* Comparison.EqualTo */ || (extensionSwappedTarget && ts.comparePaths(extensionSwappedTarget, pathOrPattern) === 0 /* Comparison.EqualTo */)) { + return { moduleFileToTry: packageName }; + } + break; + case 1 /* MatchingMode.Directory */: + if (ts.containsPath(pathOrPattern, targetFilePath)) { + var fragment = ts.getRelativePathFromDirectory(pathOrPattern, targetFilePath, /*ignoreCase*/ false); + return { moduleFileToTry: ts.getNormalizedAbsolutePath(ts.combinePaths(ts.combinePaths(packageName, exports), fragment), /*currentDirectory*/ undefined) }; + } + break; + case 2 /* MatchingMode.Pattern */: + var starPos = pathOrPattern.indexOf("*"); + var leadingSlice = pathOrPattern.slice(0, starPos); + var trailingSlice = pathOrPattern.slice(starPos + 1); + if (ts.startsWith(targetFilePath, leadingSlice) && ts.endsWith(targetFilePath, trailingSlice)) { + var starReplacement = targetFilePath.slice(leadingSlice.length, targetFilePath.length - trailingSlice.length); + return { moduleFileToTry: packageName.replace("*", starReplacement) }; + } + if (extensionSwappedTarget && ts.startsWith(extensionSwappedTarget, leadingSlice) && ts.endsWith(extensionSwappedTarget, trailingSlice)) { + var starReplacement = extensionSwappedTarget.slice(leadingSlice.length, extensionSwappedTarget.length - trailingSlice.length); + return { moduleFileToTry: packageName.replace("*", starReplacement) }; + } + break; + } + } + else if (Array.isArray(exports)) { + return ts.forEach(exports, function (e) { return tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, packageName, e, conditions); }); + } + else if (typeof exports === "object" && exports !== null) { // eslint-disable-line no-null/no-null + if (ts.allKeysStartWithDot(exports)) { + // sub-mappings + // 3 cases: + // * directory mappings (legacyish, key ends with / (technically allows index/extension resolution under cjs mode)) + // * pattern mappings (contains a *) + // * exact mappings (no *, does not end with /) + return ts.forEach(ts.getOwnKeys(exports), function (k) { + var subPackageName = ts.getNormalizedAbsolutePath(ts.combinePaths(packageName, k), /*currentDirectory*/ undefined); + var mode = ts.endsWith(k, "/") ? 1 /* MatchingMode.Directory */ + : ts.stringContains(k, "*") ? 2 /* MatchingMode.Pattern */ + : 0 /* MatchingMode.Exact */; + return tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, subPackageName, exports[k], conditions, mode); + }); + } + else { + // conditional mapping + for (var _i = 0, _a = ts.getOwnKeys(exports); _i < _a.length; _i++) { + var key = _a[_i]; + if (key === "default" || conditions.indexOf(key) >= 0 || ts.isApplicableVersionedTypesKey(conditions, key)) { + var subTarget = exports[key]; + var result = tryGetModuleNameFromExports(options, targetFilePath, packageDirectory, packageName, subTarget, conditions); + if (result) { + return result; + } + } + } + } + } + return undefined; + } + function tryGetModuleNameFromRootDirs(rootDirs, moduleFileName, sourceDirectory, getCanonicalFileName, ending, compilerOptions) { + var normalizedTargetPaths = getPathsRelativeToRootDirs(moduleFileName, rootDirs, getCanonicalFileName); + if (normalizedTargetPaths === undefined) { + return undefined; + } + var normalizedSourcePaths = getPathsRelativeToRootDirs(sourceDirectory, rootDirs, getCanonicalFileName); + var relativePaths = ts.flatMap(normalizedSourcePaths, function (sourcePath) { + return ts.map(normalizedTargetPaths, function (targetPath) { return ts.ensurePathIsNonModuleName(ts.getRelativePathFromDirectory(sourcePath, targetPath, getCanonicalFileName)); }); + }); + var shortest = ts.min(relativePaths, ts.compareNumberOfDirectorySeparators); + if (!shortest) { + return undefined; + } + return ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeJs + ? removeExtensionAndIndexPostFix(shortest, ending, compilerOptions) + : ts.removeFileExtension(shortest); + } + function tryGetModuleNameAsNodeModule(_a, _b, importingSourceFile, host, options, userPreferences, packageNameOnly, overrideMode) { + var path = _a.path, isRedirect = _a.isRedirect; + var getCanonicalFileName = _b.getCanonicalFileName, sourceDirectory = _b.sourceDirectory; + if (!host.fileExists || !host.readFile) { + return undefined; + } + var parts = ts.getNodeModulePathParts(path); + if (!parts) { + return undefined; + } + // Simplify the full file path to something that can be resolved by Node. + var preferences = getPreferences(host, userPreferences, options, importingSourceFile); + var moduleSpecifier = path; + var isPackageRootPath = false; + if (!packageNameOnly) { + var packageRootIndex = parts.packageRootIndex; + var moduleFileName = void 0; + while (true) { + // If the module could be imported by a directory name, use that directory's name + var _c = tryDirectoryWithPackageJson(packageRootIndex), moduleFileToTry = _c.moduleFileToTry, packageRootPath = _c.packageRootPath, blockedByExports = _c.blockedByExports, verbatimFromExports = _c.verbatimFromExports; + if (ts.getEmitModuleResolutionKind(options) !== ts.ModuleResolutionKind.Classic) { + if (blockedByExports) { + return undefined; // File is under this package.json, but is not publicly exported - there's no way to name it via `node_modules` resolution + } + if (verbatimFromExports) { + return moduleFileToTry; + } + } + if (packageRootPath) { + moduleSpecifier = packageRootPath; + isPackageRootPath = true; + break; + } + if (!moduleFileName) + moduleFileName = moduleFileToTry; + // try with next level of directory + packageRootIndex = path.indexOf(ts.directorySeparator, packageRootIndex + 1); + if (packageRootIndex === -1) { + moduleSpecifier = removeExtensionAndIndexPostFix(moduleFileName, preferences.ending, options, host); + break; + } + } + } + if (isRedirect && !isPackageRootPath) { + return undefined; + } + var globalTypingsCacheLocation = host.getGlobalTypingsCacheLocation && host.getGlobalTypingsCacheLocation(); + // Get a path that's relative to node_modules or the importing file's path + // if node_modules folder is in this folder or any of its parent folders, no need to keep it. + var pathToTopLevelNodeModules = getCanonicalFileName(moduleSpecifier.substring(0, parts.topLevelNodeModulesIndex)); + if (!(ts.startsWith(sourceDirectory, pathToTopLevelNodeModules) || globalTypingsCacheLocation && ts.startsWith(getCanonicalFileName(globalTypingsCacheLocation), pathToTopLevelNodeModules))) { + return undefined; + } + // If the module was found in @types, get the actual Node package name + var nodeModulesDirectoryName = moduleSpecifier.substring(parts.topLevelPackageNameIndex + 1); + var packageName = ts.getPackageNameFromTypesPackageName(nodeModulesDirectoryName); + // For classic resolution, only allow importing from node_modules/@types, not other node_modules + return ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Classic && packageName === nodeModulesDirectoryName ? undefined : packageName; + function tryDirectoryWithPackageJson(packageRootIndex) { + var _a, _b; + var packageRootPath = path.substring(0, packageRootIndex); + var packageJsonPath = ts.combinePaths(packageRootPath, "package.json"); + var moduleFileToTry = path; + var maybeBlockedByTypesVersions = false; + var cachedPackageJson = (_b = (_a = host.getPackageJsonInfoCache) === null || _a === void 0 ? void 0 : _a.call(host)) === null || _b === void 0 ? void 0 : _b.getPackageJsonInfo(packageJsonPath); + if (typeof cachedPackageJson === "object" || cachedPackageJson === undefined && host.fileExists(packageJsonPath)) { + var packageJsonContent = (cachedPackageJson === null || cachedPackageJson === void 0 ? void 0 : cachedPackageJson.contents.packageJsonContent) || JSON.parse(host.readFile(packageJsonPath)); + var importMode = overrideMode || importingSourceFile.impliedNodeFormat; + if (ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.Node16 || ts.getEmitModuleResolutionKind(options) === ts.ModuleResolutionKind.NodeNext) { + var conditions = ["node", importMode === ts.ModuleKind.ESNext ? "import" : "require", "types"]; + var fromExports = packageJsonContent.exports && typeof packageJsonContent.name === "string" + ? tryGetModuleNameFromExports(options, path, packageRootPath, ts.getPackageNameFromTypesPackageName(packageJsonContent.name), packageJsonContent.exports, conditions) + : undefined; + if (fromExports) { + var withJsExtension = !ts.hasTSFileExtension(fromExports.moduleFileToTry) + ? fromExports + : { moduleFileToTry: ts.removeFileExtension(fromExports.moduleFileToTry) + tryGetJSExtensionForFile(fromExports.moduleFileToTry, options) }; + return __assign(__assign({}, withJsExtension), { verbatimFromExports: true }); + } + if (packageJsonContent.exports) { + return { moduleFileToTry: path, blockedByExports: true }; + } + } + var versionPaths = packageJsonContent.typesVersions + ? ts.getPackageJsonTypesVersionsPaths(packageJsonContent.typesVersions) + : undefined; + if (versionPaths) { + var subModuleName = path.slice(packageRootPath.length + 1); + var fromPaths = tryGetModuleNameFromPaths(subModuleName, versionPaths.paths, getAllowedEndings(preferences.ending, options, importMode), host, options); + if (fromPaths === undefined) { + maybeBlockedByTypesVersions = true; + } + else { + moduleFileToTry = ts.combinePaths(packageRootPath, fromPaths); + } + } + // If the file is the main module, it can be imported by the package name + var mainFileRelative = packageJsonContent.typings || packageJsonContent.types || packageJsonContent.main || "index.js"; + if (ts.isString(mainFileRelative) && !(maybeBlockedByTypesVersions && ts.matchPatternOrExact(ts.tryParsePatterns(versionPaths.paths), mainFileRelative))) { + // The 'main' file is also subject to mapping through typesVersions, and we couldn't come up with a path + // explicitly through typesVersions, so if it matches a key in typesVersions now, it's not reachable. + // (The only way this can happen is if some file in a package that's not resolvable from outside the + // package got pulled into the program anyway, e.g. transitively through a file that *is* reachable. It + // happens very easily in fourslash tests though, since every test file listed gets included. See + // importNameCodeFix_typesVersions.ts for an example.) + var mainExportFile = ts.toPath(mainFileRelative, packageRootPath, getCanonicalFileName); + if (ts.removeFileExtension(mainExportFile) === ts.removeFileExtension(getCanonicalFileName(moduleFileToTry))) { + // ^ An arbitrary removal of file extension for this comparison is almost certainly wrong + return { packageRootPath: packageRootPath, moduleFileToTry: moduleFileToTry }; + } + } + } + else { + // No package.json exists; an index.js will still resolve as the package name + var fileName = getCanonicalFileName(moduleFileToTry.substring(parts.packageRootIndex + 1)); + if (fileName === "index.d.ts" || fileName === "index.js" || fileName === "index.ts" || fileName === "index.tsx") { + return { moduleFileToTry: moduleFileToTry, packageRootPath: packageRootPath }; + } + } + return { moduleFileToTry: moduleFileToTry }; + } + } + function tryGetAnyFileFromPath(host, path) { + if (!host.fileExists) + return; + // We check all js, `node` and `json` extensions in addition to TS, since node module resolution would also choose those over the directory + var extensions = ts.flatten(ts.getSupportedExtensions({ allowJs: true }, [{ extension: "node", isMixedContent: false }, { extension: "json", isMixedContent: false, scriptKind: 6 /* ScriptKind.JSON */ }])); + for (var _i = 0, extensions_3 = extensions; _i < extensions_3.length; _i++) { + var e = extensions_3[_i]; + var fullPath = path + e; + if (host.fileExists(fullPath)) { + return fullPath; + } + } + } + function getPathsRelativeToRootDirs(path, rootDirs, getCanonicalFileName) { + return ts.mapDefined(rootDirs, function (rootDir) { + var relativePath = getRelativePathIfInDirectory(path, rootDir, getCanonicalFileName); + return relativePath !== undefined && isPathRelativeToParent(relativePath) ? undefined : relativePath; + }); + } + function removeExtensionAndIndexPostFix(fileName, ending, options, host) { + if (ts.fileExtensionIsOneOf(fileName, [".json" /* Extension.Json */, ".mjs" /* Extension.Mjs */, ".cjs" /* Extension.Cjs */])) + return fileName; + var noExtension = ts.removeFileExtension(fileName); + if (fileName === noExtension) + return fileName; + if (ts.fileExtensionIsOneOf(fileName, [".d.mts" /* Extension.Dmts */, ".mts" /* Extension.Mts */, ".d.cts" /* Extension.Dcts */, ".cts" /* Extension.Cts */])) + return noExtension + getJSExtensionForFile(fileName, options); + switch (ending) { + case 0 /* Ending.Minimal */: + var withoutIndex = ts.removeSuffix(noExtension, "/index"); + if (host && withoutIndex !== noExtension && tryGetAnyFileFromPath(host, withoutIndex)) { + // Can't remove index if there's a file by the same name as the directory. + // Probably more callers should pass `host` so we can determine this? + return noExtension; + } + return withoutIndex; + case 1 /* Ending.Index */: + return noExtension; + case 2 /* Ending.JsExtension */: + return noExtension + getJSExtensionForFile(fileName, options); + default: + return ts.Debug.assertNever(ending); + } + } + function getJSExtensionForFile(fileName, options) { + var _a; + return (_a = tryGetJSExtensionForFile(fileName, options)) !== null && _a !== void 0 ? _a : ts.Debug.fail("Extension ".concat(ts.extensionFromPath(fileName), " is unsupported:: FileName:: ").concat(fileName)); + } + function tryGetJSExtensionForFile(fileName, options) { + var ext = ts.tryGetExtensionFromPath(fileName); + switch (ext) { + case ".ts" /* Extension.Ts */: + case ".d.ts" /* Extension.Dts */: + return ".js" /* Extension.Js */; + case ".tsx" /* Extension.Tsx */: + return options.jsx === 1 /* JsxEmit.Preserve */ ? ".jsx" /* Extension.Jsx */ : ".js" /* Extension.Js */; + case ".js" /* Extension.Js */: + case ".jsx" /* Extension.Jsx */: + case ".json" /* Extension.Json */: + return ext; + case ".d.mts" /* Extension.Dmts */: + case ".mts" /* Extension.Mts */: + case ".mjs" /* Extension.Mjs */: + return ".mjs" /* Extension.Mjs */; + case ".d.cts" /* Extension.Dcts */: + case ".cts" /* Extension.Cts */: + case ".cjs" /* Extension.Cjs */: + return ".cjs" /* Extension.Cjs */; + default: + return undefined; + } + } + moduleSpecifiers_1.tryGetJSExtensionForFile = tryGetJSExtensionForFile; + function getRelativePathIfInDirectory(path, directoryPath, getCanonicalFileName) { + var relativePath = ts.getRelativePathToDirectoryOrUrl(directoryPath, path, directoryPath, getCanonicalFileName, /*isAbsolutePathAnUrl*/ false); + return ts.isRootedDiskPath(relativePath) ? undefined : relativePath; + } + function isPathRelativeToParent(path) { + return ts.startsWith(path, ".."); + } + })(moduleSpecifiers = ts.moduleSpecifiers || (ts.moduleSpecifiers = {})); +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + var sysFormatDiagnosticsHost = ts.sys ? { + getCurrentDirectory: function () { return ts.sys.getCurrentDirectory(); }, + getNewLine: function () { return ts.sys.newLine; }, + getCanonicalFileName: ts.createGetCanonicalFileName(ts.sys.useCaseSensitiveFileNames) + } : undefined; + /** + * Create a function that reports error by writing to the system and handles the formatting of the diagnostic + */ + function createDiagnosticReporter(system, pretty) { + var host = system === ts.sys && sysFormatDiagnosticsHost ? sysFormatDiagnosticsHost : { + getCurrentDirectory: function () { return system.getCurrentDirectory(); }, + getNewLine: function () { return system.newLine; }, + getCanonicalFileName: ts.createGetCanonicalFileName(system.useCaseSensitiveFileNames), + }; + if (!pretty) { + return function (diagnostic) { return system.write(ts.formatDiagnostic(diagnostic, host)); }; + } + var diagnostics = new Array(1); + return function (diagnostic) { + diagnostics[0] = diagnostic; + system.write(ts.formatDiagnosticsWithColorAndContext(diagnostics, host) + host.getNewLine()); + diagnostics[0] = undefined; // TODO: GH#18217 + }; + } + ts.createDiagnosticReporter = createDiagnosticReporter; + /** + * @returns Whether the screen was cleared. + */ + function clearScreenIfNotWatchingForFileChanges(system, diagnostic, options) { + if (system.clearScreen && + !options.preserveWatchOutput && + !options.extendedDiagnostics && + !options.diagnostics && + ts.contains(ts.screenStartingMessageCodes, diagnostic.code)) { + system.clearScreen(); + return true; + } + return false; + } + ts.screenStartingMessageCodes = [ + ts.Diagnostics.Starting_compilation_in_watch_mode.code, + ts.Diagnostics.File_change_detected_Starting_incremental_compilation.code, + ]; + function getPlainDiagnosticFollowingNewLines(diagnostic, newLine) { + return ts.contains(ts.screenStartingMessageCodes, diagnostic.code) + ? newLine + newLine + : newLine; + } + /** + * Get locale specific time based on whether we are in test mode + */ + function getLocaleTimeString(system) { + return !system.now ? + new Date().toLocaleTimeString() : + system.now().toLocaleTimeString("en-US", { timeZone: "UTC" }); + } + ts.getLocaleTimeString = getLocaleTimeString; + /** + * Create a function that reports watch status by writing to the system and handles the formatting of the diagnostic + */ + function createWatchStatusReporter(system, pretty) { + return pretty ? + function (diagnostic, newLine, options) { + clearScreenIfNotWatchingForFileChanges(system, diagnostic, options); + var output = "[".concat(ts.formatColorAndReset(getLocaleTimeString(system), ts.ForegroundColorEscapeSequences.Grey), "] "); + output += "".concat(ts.flattenDiagnosticMessageText(diagnostic.messageText, system.newLine)).concat(newLine + newLine); + system.write(output); + } : + function (diagnostic, newLine, options) { + var output = ""; + if (!clearScreenIfNotWatchingForFileChanges(system, diagnostic, options)) { + output += newLine; + } + output += "".concat(getLocaleTimeString(system), " - "); + output += "".concat(ts.flattenDiagnosticMessageText(diagnostic.messageText, system.newLine)).concat(getPlainDiagnosticFollowingNewLines(diagnostic, newLine)); + system.write(output); + }; + } + ts.createWatchStatusReporter = createWatchStatusReporter; + /** Parses config file using System interface */ + function parseConfigFileWithSystem(configFileName, optionsToExtend, extendedConfigCache, watchOptionsToExtend, system, reportDiagnostic) { + var host = system; + host.onUnRecoverableConfigFileDiagnostic = function (diagnostic) { return reportUnrecoverableDiagnostic(system, reportDiagnostic, diagnostic); }; + var result = ts.getParsedCommandLineOfConfigFile(configFileName, optionsToExtend, host, extendedConfigCache, watchOptionsToExtend); + host.onUnRecoverableConfigFileDiagnostic = undefined; // TODO: GH#18217 + return result; + } + ts.parseConfigFileWithSystem = parseConfigFileWithSystem; + function getErrorCountForSummary(diagnostics) { + return ts.countWhere(diagnostics, function (diagnostic) { return diagnostic.category === ts.DiagnosticCategory.Error; }); + } + ts.getErrorCountForSummary = getErrorCountForSummary; + function getFilesInErrorForSummary(diagnostics) { + var filesInError = ts.filter(diagnostics, function (diagnostic) { return diagnostic.category === ts.DiagnosticCategory.Error; }) + .map(function (errorDiagnostic) { + if (errorDiagnostic.file === undefined) + return; + return "".concat(errorDiagnostic.file.fileName); + }); + return filesInError.map(function (fileName) { + var diagnosticForFileName = ts.find(diagnostics, function (diagnostic) { + return diagnostic.file !== undefined && diagnostic.file.fileName === fileName; + }); + if (diagnosticForFileName !== undefined) { + var line = ts.getLineAndCharacterOfPosition(diagnosticForFileName.file, diagnosticForFileName.start).line; + return { + fileName: fileName, + line: line + 1, + }; + } + }); + } + ts.getFilesInErrorForSummary = getFilesInErrorForSummary; + function getWatchErrorSummaryDiagnosticMessage(errorCount) { + return errorCount === 1 ? + ts.Diagnostics.Found_1_error_Watching_for_file_changes : + ts.Diagnostics.Found_0_errors_Watching_for_file_changes; + } + ts.getWatchErrorSummaryDiagnosticMessage = getWatchErrorSummaryDiagnosticMessage; + function prettyPathForFileError(error, cwd) { + var line = ts.formatColorAndReset(":" + error.line, ts.ForegroundColorEscapeSequences.Grey); + if (ts.pathIsAbsolute(error.fileName) && ts.pathIsAbsolute(cwd)) { + return ts.getRelativePathFromDirectory(cwd, error.fileName, /* ignoreCase */ false) + line; + } + return error.fileName + line; + } + function getErrorSummaryText(errorCount, filesInError, newLine, host) { + if (errorCount === 0) + return ""; + var nonNilFiles = filesInError.filter(function (fileInError) { return fileInError !== undefined; }); + var distinctFileNamesWithLines = nonNilFiles.map(function (fileInError) { return "".concat(fileInError.fileName, ":").concat(fileInError.line); }) + .filter(function (value, index, self) { return self.indexOf(value) === index; }); + var firstFileReference = nonNilFiles[0] && prettyPathForFileError(nonNilFiles[0], host.getCurrentDirectory()); + var d = errorCount === 1 ? + ts.createCompilerDiagnostic(filesInError[0] !== undefined ? + ts.Diagnostics.Found_1_error_in_1 : + ts.Diagnostics.Found_1_error, errorCount, firstFileReference) : + ts.createCompilerDiagnostic(distinctFileNamesWithLines.length === 0 ? + ts.Diagnostics.Found_0_errors : + distinctFileNamesWithLines.length === 1 ? + ts.Diagnostics.Found_0_errors_in_the_same_file_starting_at_Colon_1 : + ts.Diagnostics.Found_0_errors_in_1_files, errorCount, distinctFileNamesWithLines.length === 1 ? firstFileReference : distinctFileNamesWithLines.length); + var suffix = distinctFileNamesWithLines.length > 1 ? createTabularErrorsDisplay(nonNilFiles, host) : ""; + return "".concat(newLine).concat(ts.flattenDiagnosticMessageText(d.messageText, newLine)).concat(newLine).concat(newLine).concat(suffix); + } + ts.getErrorSummaryText = getErrorSummaryText; + function createTabularErrorsDisplay(filesInError, host) { + var distinctFiles = filesInError.filter(function (value, index, self) { return index === self.findIndex(function (file) { return (file === null || file === void 0 ? void 0 : file.fileName) === (value === null || value === void 0 ? void 0 : value.fileName); }); }); + if (distinctFiles.length === 0) + return ""; + var numberLength = function (num) { return Math.log(num) * Math.LOG10E + 1; }; + var fileToErrorCount = distinctFiles.map(function (file) { return [file, ts.countWhere(filesInError, function (fileInError) { return fileInError.fileName === file.fileName; })]; }); + var maxErrors = fileToErrorCount.reduce(function (acc, value) { return Math.max(acc, value[1] || 0); }, 0); + var headerRow = ts.Diagnostics.Errors_Files.message; + var leftColumnHeadingLength = headerRow.split(" ")[0].length; + var leftPaddingGoal = Math.max(leftColumnHeadingLength, numberLength(maxErrors)); + var headerPadding = Math.max(numberLength(maxErrors) - leftColumnHeadingLength, 0); + var tabularData = ""; + tabularData += " ".repeat(headerPadding) + headerRow + "\n"; + fileToErrorCount.forEach(function (row) { + var file = row[0], errorCount = row[1]; + var errorCountDigitsLength = Math.log(errorCount) * Math.LOG10E + 1 | 0; + var leftPadding = errorCountDigitsLength < leftPaddingGoal ? + " ".repeat(leftPaddingGoal - errorCountDigitsLength) + : ""; + var fileRef = prettyPathForFileError(file, host.getCurrentDirectory()); + tabularData += "".concat(leftPadding).concat(errorCount, " ").concat(fileRef, "\n"); + }); + return tabularData; + } + function isBuilderProgram(program) { + return !!program.getState; + } + ts.isBuilderProgram = isBuilderProgram; + function listFiles(program, write) { + var options = program.getCompilerOptions(); + if (options.explainFiles) { + explainFiles(isBuilderProgram(program) ? program.getProgram() : program, write); + } + else if (options.listFiles || options.listFilesOnly) { + ts.forEach(program.getSourceFiles(), function (file) { + write(file.fileName); + }); + } + } + ts.listFiles = listFiles; + function explainFiles(program, write) { + var _a, _b; + var reasons = program.getFileIncludeReasons(); + var getCanonicalFileName = ts.createGetCanonicalFileName(program.useCaseSensitiveFileNames()); + var relativeFileName = function (fileName) { return ts.convertToRelativePath(fileName, program.getCurrentDirectory(), getCanonicalFileName); }; + for (var _i = 0, _c = program.getSourceFiles(); _i < _c.length; _i++) { + var file = _c[_i]; + write("".concat(toFileName(file, relativeFileName))); + (_a = reasons.get(file.path)) === null || _a === void 0 ? void 0 : _a.forEach(function (reason) { return write(" ".concat(fileIncludeReasonToDiagnostics(program, reason, relativeFileName).messageText)); }); + (_b = explainIfFileIsRedirectAndImpliedFormat(file, relativeFileName)) === null || _b === void 0 ? void 0 : _b.forEach(function (d) { return write(" ".concat(d.messageText)); }); + } + } + ts.explainFiles = explainFiles; + function explainIfFileIsRedirectAndImpliedFormat(file, fileNameConvertor) { + var _a; + var result; + if (file.path !== file.resolvedPath) { + (result !== null && result !== void 0 ? result : (result = [])).push(ts.chainDiagnosticMessages( + /*details*/ undefined, ts.Diagnostics.File_is_output_of_project_reference_source_0, toFileName(file.originalFileName, fileNameConvertor))); + } + if (file.redirectInfo) { + (result !== null && result !== void 0 ? result : (result = [])).push(ts.chainDiagnosticMessages( + /*details*/ undefined, ts.Diagnostics.File_redirects_to_file_0, toFileName(file.redirectInfo.redirectTarget, fileNameConvertor))); + } + if (ts.isExternalOrCommonJsModule(file)) { + switch (file.impliedNodeFormat) { + case ts.ModuleKind.ESNext: + if (file.packageJsonScope) { + (result !== null && result !== void 0 ? result : (result = [])).push(ts.chainDiagnosticMessages( + /*details*/ undefined, ts.Diagnostics.File_is_ECMAScript_module_because_0_has_field_type_with_value_module, toFileName(ts.last(file.packageJsonLocations), fileNameConvertor))); + } + break; + case ts.ModuleKind.CommonJS: + if (file.packageJsonScope) { + (result !== null && result !== void 0 ? result : (result = [])).push(ts.chainDiagnosticMessages( + /*details*/ undefined, file.packageJsonScope.contents.packageJsonContent.type ? + ts.Diagnostics.File_is_CommonJS_module_because_0_has_field_type_whose_value_is_not_module : + ts.Diagnostics.File_is_CommonJS_module_because_0_does_not_have_field_type, toFileName(ts.last(file.packageJsonLocations), fileNameConvertor))); + } + else if ((_a = file.packageJsonLocations) === null || _a === void 0 ? void 0 : _a.length) { + (result !== null && result !== void 0 ? result : (result = [])).push(ts.chainDiagnosticMessages( + /*details*/ undefined, ts.Diagnostics.File_is_CommonJS_module_because_package_json_was_not_found)); + } + break; + } + } + return result; + } + ts.explainIfFileIsRedirectAndImpliedFormat = explainIfFileIsRedirectAndImpliedFormat; + function getMatchedFileSpec(program, fileName) { + var _a; + var configFile = program.getCompilerOptions().configFile; + if (!((_a = configFile === null || configFile === void 0 ? void 0 : configFile.configFileSpecs) === null || _a === void 0 ? void 0 : _a.validatedFilesSpec)) + return undefined; + var getCanonicalFileName = ts.createGetCanonicalFileName(program.useCaseSensitiveFileNames()); + var filePath = getCanonicalFileName(fileName); + var basePath = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(configFile.fileName, program.getCurrentDirectory())); + return ts.find(configFile.configFileSpecs.validatedFilesSpec, function (fileSpec) { return getCanonicalFileName(ts.getNormalizedAbsolutePath(fileSpec, basePath)) === filePath; }); + } + ts.getMatchedFileSpec = getMatchedFileSpec; + function getMatchedIncludeSpec(program, fileName) { + var _a, _b; + var configFile = program.getCompilerOptions().configFile; + if (!((_a = configFile === null || configFile === void 0 ? void 0 : configFile.configFileSpecs) === null || _a === void 0 ? void 0 : _a.validatedIncludeSpecs)) + return undefined; + // Return true if its default include spec + if (configFile.configFileSpecs.isDefaultIncludeSpec) + return true; + var isJsonFile = ts.fileExtensionIs(fileName, ".json" /* Extension.Json */); + var basePath = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(configFile.fileName, program.getCurrentDirectory())); + var useCaseSensitiveFileNames = program.useCaseSensitiveFileNames(); + return ts.find((_b = configFile === null || configFile === void 0 ? void 0 : configFile.configFileSpecs) === null || _b === void 0 ? void 0 : _b.validatedIncludeSpecs, function (includeSpec) { + if (isJsonFile && !ts.endsWith(includeSpec, ".json" /* Extension.Json */)) + return false; + var pattern = ts.getPatternFromSpec(includeSpec, basePath, "files"); + return !!pattern && ts.getRegexFromPattern("(".concat(pattern, ")$"), useCaseSensitiveFileNames).test(fileName); + }); + } + ts.getMatchedIncludeSpec = getMatchedIncludeSpec; + function fileIncludeReasonToDiagnostics(program, reason, fileNameConvertor) { + var _a, _b; + var options = program.getCompilerOptions(); + if (ts.isReferencedFile(reason)) { + var referenceLocation = ts.getReferencedFileLocation(function (path) { return program.getSourceFileByPath(path); }, reason); + var referenceText = ts.isReferenceFileLocation(referenceLocation) ? referenceLocation.file.text.substring(referenceLocation.pos, referenceLocation.end) : "\"".concat(referenceLocation.text, "\""); + var message = void 0; + ts.Debug.assert(ts.isReferenceFileLocation(referenceLocation) || reason.kind === ts.FileIncludeKind.Import, "Only synthetic references are imports"); + switch (reason.kind) { + case ts.FileIncludeKind.Import: + if (ts.isReferenceFileLocation(referenceLocation)) { + message = referenceLocation.packageId ? + ts.Diagnostics.Imported_via_0_from_file_1_with_packageId_2 : + ts.Diagnostics.Imported_via_0_from_file_1; + } + else if (referenceLocation.text === ts.externalHelpersModuleNameText) { + message = referenceLocation.packageId ? + ts.Diagnostics.Imported_via_0_from_file_1_with_packageId_2_to_import_importHelpers_as_specified_in_compilerOptions : + ts.Diagnostics.Imported_via_0_from_file_1_to_import_importHelpers_as_specified_in_compilerOptions; + } + else { + message = referenceLocation.packageId ? + ts.Diagnostics.Imported_via_0_from_file_1_with_packageId_2_to_import_jsx_and_jsxs_factory_functions : + ts.Diagnostics.Imported_via_0_from_file_1_to_import_jsx_and_jsxs_factory_functions; + } + break; + case ts.FileIncludeKind.ReferenceFile: + ts.Debug.assert(!referenceLocation.packageId); + message = ts.Diagnostics.Referenced_via_0_from_file_1; + break; + case ts.FileIncludeKind.TypeReferenceDirective: + message = referenceLocation.packageId ? + ts.Diagnostics.Type_library_referenced_via_0_from_file_1_with_packageId_2 : + ts.Diagnostics.Type_library_referenced_via_0_from_file_1; + break; + case ts.FileIncludeKind.LibReferenceDirective: + ts.Debug.assert(!referenceLocation.packageId); + message = ts.Diagnostics.Library_referenced_via_0_from_file_1; + break; + default: + ts.Debug.assertNever(reason); + } + return ts.chainDiagnosticMessages( + /*details*/ undefined, message, referenceText, toFileName(referenceLocation.file, fileNameConvertor), referenceLocation.packageId && ts.packageIdToString(referenceLocation.packageId)); + } + switch (reason.kind) { + case ts.FileIncludeKind.RootFile: + if (!((_a = options.configFile) === null || _a === void 0 ? void 0 : _a.configFileSpecs)) + return ts.chainDiagnosticMessages(/*details*/ undefined, ts.Diagnostics.Root_file_specified_for_compilation); + var fileName = ts.getNormalizedAbsolutePath(program.getRootFileNames()[reason.index], program.getCurrentDirectory()); + var matchedByFiles = getMatchedFileSpec(program, fileName); + if (matchedByFiles) + return ts.chainDiagnosticMessages(/*details*/ undefined, ts.Diagnostics.Part_of_files_list_in_tsconfig_json); + var matchedByInclude = getMatchedIncludeSpec(program, fileName); + return ts.isString(matchedByInclude) ? + ts.chainDiagnosticMessages( + /*details*/ undefined, ts.Diagnostics.Matched_by_include_pattern_0_in_1, matchedByInclude, toFileName(options.configFile, fileNameConvertor)) : + // Could be additional files specified as roots or matched by default include + ts.chainDiagnosticMessages(/*details*/ undefined, matchedByInclude ? + ts.Diagnostics.Matched_by_default_include_pattern_Asterisk_Asterisk_Slash_Asterisk : + ts.Diagnostics.Root_file_specified_for_compilation); + case ts.FileIncludeKind.SourceFromProjectReference: + case ts.FileIncludeKind.OutputFromProjectReference: + var isOutput = reason.kind === ts.FileIncludeKind.OutputFromProjectReference; + var referencedResolvedRef = ts.Debug.checkDefined((_b = program.getResolvedProjectReferences()) === null || _b === void 0 ? void 0 : _b[reason.index]); + return ts.chainDiagnosticMessages( + /*details*/ undefined, ts.outFile(options) ? + isOutput ? + ts.Diagnostics.Output_from_referenced_project_0_included_because_1_specified : + ts.Diagnostics.Source_from_referenced_project_0_included_because_1_specified : + isOutput ? + ts.Diagnostics.Output_from_referenced_project_0_included_because_module_is_specified_as_none : + ts.Diagnostics.Source_from_referenced_project_0_included_because_module_is_specified_as_none, toFileName(referencedResolvedRef.sourceFile.fileName, fileNameConvertor), options.outFile ? "--outFile" : "--out"); + case ts.FileIncludeKind.AutomaticTypeDirectiveFile: + return ts.chainDiagnosticMessages( + /*details*/ undefined, options.types ? + reason.packageId ? + ts.Diagnostics.Entry_point_of_type_library_0_specified_in_compilerOptions_with_packageId_1 : + ts.Diagnostics.Entry_point_of_type_library_0_specified_in_compilerOptions : + reason.packageId ? + ts.Diagnostics.Entry_point_for_implicit_type_library_0_with_packageId_1 : + ts.Diagnostics.Entry_point_for_implicit_type_library_0, reason.typeReference, reason.packageId && ts.packageIdToString(reason.packageId)); + case ts.FileIncludeKind.LibFile: + if (reason.index !== undefined) + return ts.chainDiagnosticMessages(/*details*/ undefined, ts.Diagnostics.Library_0_specified_in_compilerOptions, options.lib[reason.index]); + var target = ts.forEachEntry(ts.targetOptionDeclaration.type, function (value, key) { return value === ts.getEmitScriptTarget(options) ? key : undefined; }); + return ts.chainDiagnosticMessages( + /*details*/ undefined, target ? + ts.Diagnostics.Default_library_for_target_0 : + ts.Diagnostics.Default_library, target); + default: + ts.Debug.assertNever(reason); + } + } + ts.fileIncludeReasonToDiagnostics = fileIncludeReasonToDiagnostics; + function toFileName(file, fileNameConvertor) { + var fileName = ts.isString(file) ? file : file.fileName; + return fileNameConvertor ? fileNameConvertor(fileName) : fileName; + } + /** + * Helper that emit files, report diagnostics and lists emitted and/or source files depending on compiler options + */ + function emitFilesAndReportErrors(program, reportDiagnostic, write, reportSummary, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) { + var isListFilesOnly = !!program.getCompilerOptions().listFilesOnly; + // First get and report any syntactic errors. + var allDiagnostics = program.getConfigFileParsingDiagnostics().slice(); + var configFileParsingDiagnosticsLength = allDiagnostics.length; + ts.addRange(allDiagnostics, program.getSyntacticDiagnostics(/*sourceFile*/ undefined, cancellationToken)); + // If we didn't have any syntactic errors, then also try getting the global and + // semantic errors. + if (allDiagnostics.length === configFileParsingDiagnosticsLength) { + ts.addRange(allDiagnostics, program.getOptionsDiagnostics(cancellationToken)); + if (!isListFilesOnly) { + ts.addRange(allDiagnostics, program.getGlobalDiagnostics(cancellationToken)); + if (allDiagnostics.length === configFileParsingDiagnosticsLength) { + ts.addRange(allDiagnostics, program.getSemanticDiagnostics(/*sourceFile*/ undefined, cancellationToken)); + } + } + } + // Emit and report any errors we ran into. + var emitResult = isListFilesOnly + ? { emitSkipped: true, diagnostics: ts.emptyArray } + : program.emit(/*targetSourceFile*/ undefined, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers); + var emittedFiles = emitResult.emittedFiles, emitDiagnostics = emitResult.diagnostics; + ts.addRange(allDiagnostics, emitDiagnostics); + var diagnostics = ts.sortAndDeduplicateDiagnostics(allDiagnostics); + diagnostics.forEach(reportDiagnostic); + if (write) { + var currentDir_1 = program.getCurrentDirectory(); + ts.forEach(emittedFiles, function (file) { + var filepath = ts.getNormalizedAbsolutePath(file, currentDir_1); + write("TSFILE: ".concat(filepath)); + }); + listFiles(program, write); + } + if (reportSummary) { + reportSummary(getErrorCountForSummary(diagnostics), getFilesInErrorForSummary(diagnostics)); + } + return { + emitResult: emitResult, + diagnostics: diagnostics, + }; + } + ts.emitFilesAndReportErrors = emitFilesAndReportErrors; + function emitFilesAndReportErrorsAndGetExitStatus(program, reportDiagnostic, write, reportSummary, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) { + var _a = emitFilesAndReportErrors(program, reportDiagnostic, write, reportSummary, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers), emitResult = _a.emitResult, diagnostics = _a.diagnostics; + if (emitResult.emitSkipped && diagnostics.length > 0) { + // If the emitter didn't emit anything, then pass that value along. + return ts.ExitStatus.DiagnosticsPresent_OutputsSkipped; + } + else if (diagnostics.length > 0) { + // The emitter emitted something, inform the caller if that happened in the presence + // of diagnostics or not. + return ts.ExitStatus.DiagnosticsPresent_OutputsGenerated; + } + return ts.ExitStatus.Success; + } + ts.emitFilesAndReportErrorsAndGetExitStatus = emitFilesAndReportErrorsAndGetExitStatus; + ts.noopFileWatcher = { close: ts.noop }; + ts.returnNoopFileWatcher = function () { return ts.noopFileWatcher; }; + function createWatchHost(system, reportWatchStatus) { + if (system === void 0) { system = ts.sys; } + var onWatchStatusChange = reportWatchStatus || createWatchStatusReporter(system); + return { + onWatchStatusChange: onWatchStatusChange, + watchFile: ts.maybeBind(system, system.watchFile) || ts.returnNoopFileWatcher, + watchDirectory: ts.maybeBind(system, system.watchDirectory) || ts.returnNoopFileWatcher, + setTimeout: ts.maybeBind(system, system.setTimeout) || ts.noop, + clearTimeout: ts.maybeBind(system, system.clearTimeout) || ts.noop + }; + } + ts.createWatchHost = createWatchHost; + ts.WatchType = { + ConfigFile: "Config file", + ExtendedConfigFile: "Extended config file", + SourceFile: "Source file", + MissingFile: "Missing file", + WildcardDirectory: "Wild card directory", + FailedLookupLocations: "Failed Lookup Locations", + AffectingFileLocation: "File location affecting resolution", + TypeRoots: "Type roots", + ConfigFileOfReferencedProject: "Config file of referened project", + ExtendedConfigOfReferencedProject: "Extended config file of referenced project", + WildcardDirectoryOfReferencedProject: "Wild card directory of referenced project", + PackageJson: "package.json file", + ClosedScriptInfo: "Closed Script info", + ConfigFileForInferredRoot: "Config file for the inferred project root", + NodeModules: "node_modules for closed script infos and package.jsons affecting module specifier cache", + MissingSourceMapFile: "Missing source map file", + NoopConfigFileForInferredRoot: "Noop Config file for the inferred project root", + MissingGeneratedFile: "Missing generated file", + NodeModulesForModuleSpecifierCache: "node_modules for module specifier cache invalidation", + }; + function createWatchFactory(host, options) { + var watchLogLevel = host.trace ? options.extendedDiagnostics ? ts.WatchLogLevel.Verbose : options.diagnostics ? ts.WatchLogLevel.TriggerOnly : ts.WatchLogLevel.None : ts.WatchLogLevel.None; + var writeLog = watchLogLevel !== ts.WatchLogLevel.None ? (function (s) { return host.trace(s); }) : ts.noop; + var result = ts.getWatchFactory(host, watchLogLevel, writeLog); + result.writeLog = writeLog; + return result; + } + ts.createWatchFactory = createWatchFactory; + function createCompilerHostFromProgramHost(host, getCompilerOptions, directoryStructureHost) { + if (directoryStructureHost === void 0) { directoryStructureHost = host; } + var useCaseSensitiveFileNames = host.useCaseSensitiveFileNames(); + var hostGetNewLine = ts.memoize(function () { return host.getNewLine(); }); + return { + getSourceFile: function (fileName, languageVersionOrOptions, onError) { + var text; + try { + ts.performance.mark("beforeIORead"); + text = host.readFile(fileName, getCompilerOptions().charset); + ts.performance.mark("afterIORead"); + ts.performance.measure("I/O Read", "beforeIORead", "afterIORead"); + } + catch (e) { + if (onError) { + onError(e.message); + } + text = ""; + } + return text !== undefined ? ts.createSourceFile(fileName, text, languageVersionOrOptions) : undefined; + }, + getDefaultLibLocation: ts.maybeBind(host, host.getDefaultLibLocation), + getDefaultLibFileName: function (options) { return host.getDefaultLibFileName(options); }, + writeFile: writeFile, + getCurrentDirectory: ts.memoize(function () { return host.getCurrentDirectory(); }), + useCaseSensitiveFileNames: function () { return useCaseSensitiveFileNames; }, + getCanonicalFileName: ts.createGetCanonicalFileName(useCaseSensitiveFileNames), + getNewLine: function () { return ts.getNewLineCharacter(getCompilerOptions(), hostGetNewLine); }, + fileExists: function (f) { return host.fileExists(f); }, + readFile: function (f) { return host.readFile(f); }, + trace: ts.maybeBind(host, host.trace), + directoryExists: ts.maybeBind(directoryStructureHost, directoryStructureHost.directoryExists), + getDirectories: ts.maybeBind(directoryStructureHost, directoryStructureHost.getDirectories), + realpath: ts.maybeBind(host, host.realpath), + getEnvironmentVariable: ts.maybeBind(host, host.getEnvironmentVariable) || (function () { return ""; }), + createHash: ts.maybeBind(host, host.createHash), + readDirectory: ts.maybeBind(host, host.readDirectory), + disableUseFileVersionAsSignature: host.disableUseFileVersionAsSignature, + storeFilesChangingSignatureDuringEmit: host.storeFilesChangingSignatureDuringEmit, + }; + function writeFile(fileName, text, writeByteOrderMark, onError) { + try { + ts.performance.mark("beforeIOWrite"); + // NOTE: If patchWriteFileEnsuringDirectory has been called, + // the host.writeFile will do its own directory creation and + // the ensureDirectoriesExist call will always be redundant. + ts.writeFileEnsuringDirectories(fileName, text, writeByteOrderMark, function (path, data, writeByteOrderMark) { return host.writeFile(path, data, writeByteOrderMark); }, function (path) { return host.createDirectory(path); }, function (path) { return host.directoryExists(path); }); + ts.performance.mark("afterIOWrite"); + ts.performance.measure("I/O Write", "beforeIOWrite", "afterIOWrite"); + } + catch (e) { + if (onError) { + onError(e.message); + } + } + } + } + ts.createCompilerHostFromProgramHost = createCompilerHostFromProgramHost; + function setGetSourceFileAsHashVersioned(compilerHost, host) { + var originalGetSourceFile = compilerHost.getSourceFile; + var computeHash = ts.maybeBind(host, host.createHash) || ts.generateDjb2Hash; + compilerHost.getSourceFile = function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + var result = originalGetSourceFile.call.apply(originalGetSourceFile, __spreadArray([compilerHost], args, false)); + if (result) { + result.version = computeHash(result.text); + } + return result; + }; + } + ts.setGetSourceFileAsHashVersioned = setGetSourceFileAsHashVersioned; + /** + * Creates the watch compiler host that can be extended with config file or root file names and options host + */ + function createProgramHost(system, createProgram) { + var getDefaultLibLocation = ts.memoize(function () { return ts.getDirectoryPath(ts.normalizePath(system.getExecutingFilePath())); }); + return { + useCaseSensitiveFileNames: function () { return system.useCaseSensitiveFileNames; }, + getNewLine: function () { return system.newLine; }, + getCurrentDirectory: ts.memoize(function () { return system.getCurrentDirectory(); }), + getDefaultLibLocation: getDefaultLibLocation, + getDefaultLibFileName: function (options) { return ts.combinePaths(getDefaultLibLocation(), ts.getDefaultLibFileName(options)); }, + fileExists: function (path) { return system.fileExists(path); }, + readFile: function (path, encoding) { return system.readFile(path, encoding); }, + directoryExists: function (path) { return system.directoryExists(path); }, + getDirectories: function (path) { return system.getDirectories(path); }, + readDirectory: function (path, extensions, exclude, include, depth) { return system.readDirectory(path, extensions, exclude, include, depth); }, + realpath: ts.maybeBind(system, system.realpath), + getEnvironmentVariable: ts.maybeBind(system, system.getEnvironmentVariable), + trace: function (s) { return system.write(s + system.newLine); }, + createDirectory: function (path) { return system.createDirectory(path); }, + writeFile: function (path, data, writeByteOrderMark) { return system.writeFile(path, data, writeByteOrderMark); }, + createHash: ts.maybeBind(system, system.createHash), + createProgram: createProgram || ts.createEmitAndSemanticDiagnosticsBuilderProgram, + disableUseFileVersionAsSignature: system.disableUseFileVersionAsSignature, + storeFilesChangingSignatureDuringEmit: system.storeFilesChangingSignatureDuringEmit, + now: ts.maybeBind(system, system.now), + }; + } + ts.createProgramHost = createProgramHost; + /** + * Creates the watch compiler host that can be extended with config file or root file names and options host + */ + function createWatchCompilerHost(system, createProgram, reportDiagnostic, reportWatchStatus) { + if (system === void 0) { system = ts.sys; } + var write = function (s) { return system.write(s + system.newLine); }; + var result = createProgramHost(system, createProgram); + ts.copyProperties(result, createWatchHost(system, reportWatchStatus)); + result.afterProgramCreate = function (builderProgram) { + var compilerOptions = builderProgram.getCompilerOptions(); + var newLine = ts.getNewLineCharacter(compilerOptions, function () { return system.newLine; }); + emitFilesAndReportErrors(builderProgram, reportDiagnostic, write, function (errorCount) { return result.onWatchStatusChange(ts.createCompilerDiagnostic(getWatchErrorSummaryDiagnosticMessage(errorCount), errorCount), newLine, compilerOptions, errorCount); }); + }; + return result; + } + /** + * Report error and exit + */ + function reportUnrecoverableDiagnostic(system, reportDiagnostic, diagnostic) { + reportDiagnostic(diagnostic); + system.exit(ts.ExitStatus.DiagnosticsPresent_OutputsSkipped); + } + /** + * Creates the watch compiler host from system for config file in watch mode + */ + function createWatchCompilerHostOfConfigFile(_a) { + var configFileName = _a.configFileName, optionsToExtend = _a.optionsToExtend, watchOptionsToExtend = _a.watchOptionsToExtend, extraFileExtensions = _a.extraFileExtensions, system = _a.system, createProgram = _a.createProgram, reportDiagnostic = _a.reportDiagnostic, reportWatchStatus = _a.reportWatchStatus; + var diagnosticReporter = reportDiagnostic || createDiagnosticReporter(system); + var host = createWatchCompilerHost(system, createProgram, diagnosticReporter, reportWatchStatus); + host.onUnRecoverableConfigFileDiagnostic = function (diagnostic) { return reportUnrecoverableDiagnostic(system, diagnosticReporter, diagnostic); }; + host.configFileName = configFileName; + host.optionsToExtend = optionsToExtend; + host.watchOptionsToExtend = watchOptionsToExtend; + host.extraFileExtensions = extraFileExtensions; + return host; + } + ts.createWatchCompilerHostOfConfigFile = createWatchCompilerHostOfConfigFile; + /** + * Creates the watch compiler host from system for compiling root files and options in watch mode + */ + function createWatchCompilerHostOfFilesAndCompilerOptions(_a) { + var rootFiles = _a.rootFiles, options = _a.options, watchOptions = _a.watchOptions, projectReferences = _a.projectReferences, system = _a.system, createProgram = _a.createProgram, reportDiagnostic = _a.reportDiagnostic, reportWatchStatus = _a.reportWatchStatus; + var host = createWatchCompilerHost(system, createProgram, reportDiagnostic || createDiagnosticReporter(system), reportWatchStatus); + host.rootFiles = rootFiles; + host.options = options; + host.watchOptions = watchOptions; + host.projectReferences = projectReferences; + return host; + } + ts.createWatchCompilerHostOfFilesAndCompilerOptions = createWatchCompilerHostOfFilesAndCompilerOptions; + function performIncrementalCompilation(input) { + var system = input.system || ts.sys; + var host = input.host || (input.host = ts.createIncrementalCompilerHost(input.options, system)); + var builderProgram = ts.createIncrementalProgram(input); + var exitStatus = emitFilesAndReportErrorsAndGetExitStatus(builderProgram, input.reportDiagnostic || createDiagnosticReporter(system), function (s) { return host.trace && host.trace(s); }, input.reportErrorSummary || input.options.pretty ? function (errorCount, filesInError) { return system.write(getErrorSummaryText(errorCount, filesInError, system.newLine, host)); } : undefined); + if (input.afterProgramEmitAndDiagnostics) + input.afterProgramEmitAndDiagnostics(builderProgram); + return exitStatus; + } + ts.performIncrementalCompilation = performIncrementalCompilation; +})(ts || (ts = {})); +var ts; +(function (ts) { + function readBuilderProgram(compilerOptions, host) { + var buildInfoPath = ts.getTsBuildInfoEmitOutputFilePath(compilerOptions); + if (!buildInfoPath) + return undefined; + var buildInfo; + if (host.getBuildInfo) { + // host provides buildinfo, get it from there. This allows host to cache it + buildInfo = host.getBuildInfo(buildInfoPath, compilerOptions.configFilePath); + } + else { + var content = host.readFile(buildInfoPath); + if (!content) + return undefined; + buildInfo = ts.getBuildInfo(buildInfoPath, content); + } + if (!buildInfo || buildInfo.version !== ts.version || !buildInfo.program) + return undefined; + return ts.createBuilderProgramUsingProgramBuildInfo(buildInfo.program, buildInfoPath, host); + } + ts.readBuilderProgram = readBuilderProgram; + function createIncrementalCompilerHost(options, system) { + if (system === void 0) { system = ts.sys; } + var host = ts.createCompilerHostWorker(options, /*setParentNodes*/ undefined, system); + host.createHash = ts.maybeBind(system, system.createHash); + host.disableUseFileVersionAsSignature = system.disableUseFileVersionAsSignature; + host.storeFilesChangingSignatureDuringEmit = system.storeFilesChangingSignatureDuringEmit; + ts.setGetSourceFileAsHashVersioned(host, system); + ts.changeCompilerHostLikeToUseCache(host, function (fileName) { return ts.toPath(fileName, host.getCurrentDirectory(), host.getCanonicalFileName); }); + return host; + } + ts.createIncrementalCompilerHost = createIncrementalCompilerHost; + function createIncrementalProgram(_a) { + var rootNames = _a.rootNames, options = _a.options, configFileParsingDiagnostics = _a.configFileParsingDiagnostics, projectReferences = _a.projectReferences, host = _a.host, createProgram = _a.createProgram; + host = host || createIncrementalCompilerHost(options); + createProgram = createProgram || ts.createEmitAndSemanticDiagnosticsBuilderProgram; + var oldProgram = readBuilderProgram(options, host); + return createProgram(rootNames, options, host, oldProgram, configFileParsingDiagnostics, projectReferences); + } + ts.createIncrementalProgram = createIncrementalProgram; + function createWatchCompilerHost(rootFilesOrConfigFileName, options, system, createProgram, reportDiagnostic, reportWatchStatus, projectReferencesOrWatchOptionsToExtend, watchOptionsOrExtraFileExtensions) { + if (ts.isArray(rootFilesOrConfigFileName)) { + return ts.createWatchCompilerHostOfFilesAndCompilerOptions({ + rootFiles: rootFilesOrConfigFileName, + options: options, + watchOptions: watchOptionsOrExtraFileExtensions, + projectReferences: projectReferencesOrWatchOptionsToExtend, + system: system, + createProgram: createProgram, + reportDiagnostic: reportDiagnostic, + reportWatchStatus: reportWatchStatus, + }); + } + else { + return ts.createWatchCompilerHostOfConfigFile({ + configFileName: rootFilesOrConfigFileName, + optionsToExtend: options, + watchOptionsToExtend: projectReferencesOrWatchOptionsToExtend, + extraFileExtensions: watchOptionsOrExtraFileExtensions, + system: system, + createProgram: createProgram, + reportDiagnostic: reportDiagnostic, + reportWatchStatus: reportWatchStatus, + }); + } + } + ts.createWatchCompilerHost = createWatchCompilerHost; + function createWatchProgram(host) { + var builderProgram; + var reloadLevel; // level to indicate if the program needs to be reloaded from config file/just filenames etc + var missingFilesMap; // Map of file watchers for the missing files + var watchedWildcardDirectories; // map of watchers for the wild card directories in the config file + var timerToUpdateProgram; // timer callback to recompile the program + var timerToInvalidateFailedLookupResolutions; // timer callback to invalidate resolutions for changes in failed lookup locations + var parsedConfigs; // Parsed commandline and watching cached for referenced projects + var sharedExtendedConfigFileWatchers; // Map of file watchers for extended files, shared between different referenced projects + var extendedConfigCache = host.extendedConfigCache; // Cache for extended config evaluation + var reportFileChangeDetectedOnCreateProgram = false; // True if synchronizeProgram should report "File change detected..." when a new program is created + var sourceFilesCache = new ts.Map(); // Cache that stores the source file and version info + var missingFilePathsRequestedForRelease; // These paths are held temporarily so that we can remove the entry from source file cache if the file is not tracked by missing files + var hasChangedCompilerOptions = false; // True if the compiler options have changed between compilations + var useCaseSensitiveFileNames = host.useCaseSensitiveFileNames(); + var currentDirectory = host.getCurrentDirectory(); + var configFileName = host.configFileName, _a = host.optionsToExtend, optionsToExtendForConfigFile = _a === void 0 ? {} : _a, watchOptionsToExtend = host.watchOptionsToExtend, extraFileExtensions = host.extraFileExtensions, createProgram = host.createProgram; + var rootFileNames = host.rootFiles, compilerOptions = host.options, watchOptions = host.watchOptions, projectReferences = host.projectReferences; + var wildcardDirectories; + var configFileParsingDiagnostics; + var canConfigFileJsonReportNoInputFiles = false; + var hasChangedConfigFileParsingErrors = false; + var cachedDirectoryStructureHost = configFileName === undefined ? undefined : ts.createCachedDirectoryStructureHost(host, currentDirectory, useCaseSensitiveFileNames); + var directoryStructureHost = cachedDirectoryStructureHost || host; + var parseConfigFileHost = ts.parseConfigHostFromCompilerHostLike(host, directoryStructureHost); + // From tsc we want to get already parsed result and hence check for rootFileNames + var newLine = updateNewLine(); + if (configFileName && host.configFileParsingResult) { + setConfigFileParsingResult(host.configFileParsingResult); + newLine = updateNewLine(); + } + reportWatchDiagnostic(ts.Diagnostics.Starting_compilation_in_watch_mode); + if (configFileName && !host.configFileParsingResult) { + newLine = ts.getNewLineCharacter(optionsToExtendForConfigFile, function () { return host.getNewLine(); }); + ts.Debug.assert(!rootFileNames); + parseConfigFile(); + newLine = updateNewLine(); + } + var _b = ts.createWatchFactory(host, compilerOptions), watchFile = _b.watchFile, watchDirectory = _b.watchDirectory, writeLog = _b.writeLog; + var getCanonicalFileName = ts.createGetCanonicalFileName(useCaseSensitiveFileNames); + writeLog("Current directory: ".concat(currentDirectory, " CaseSensitiveFileNames: ").concat(useCaseSensitiveFileNames)); + var configFileWatcher; + if (configFileName) { + configFileWatcher = watchFile(configFileName, scheduleProgramReload, ts.PollingInterval.High, watchOptions, ts.WatchType.ConfigFile); + } + var compilerHost = ts.createCompilerHostFromProgramHost(host, function () { return compilerOptions; }, directoryStructureHost); + ts.setGetSourceFileAsHashVersioned(compilerHost, host); + // Members for CompilerHost + var getNewSourceFile = compilerHost.getSourceFile; + compilerHost.getSourceFile = function (fileName) { + var args = []; + for (var _i = 1; _i < arguments.length; _i++) { + args[_i - 1] = arguments[_i]; + } + return getVersionedSourceFileByPath.apply(void 0, __spreadArray([fileName, toPath(fileName)], args, false)); + }; + compilerHost.getSourceFileByPath = getVersionedSourceFileByPath; + compilerHost.getNewLine = function () { return newLine; }; + compilerHost.fileExists = fileExists; + compilerHost.onReleaseOldSourceFile = onReleaseOldSourceFile; + compilerHost.onReleaseParsedCommandLine = onReleaseParsedCommandLine; + // Members for ResolutionCacheHost + compilerHost.toPath = toPath; + compilerHost.getCompilationSettings = function () { return compilerOptions; }; + compilerHost.useSourceOfProjectReferenceRedirect = ts.maybeBind(host, host.useSourceOfProjectReferenceRedirect); + compilerHost.watchDirectoryOfFailedLookupLocation = function (dir, cb, flags) { return watchDirectory(dir, cb, flags, watchOptions, ts.WatchType.FailedLookupLocations); }; + compilerHost.watchAffectingFileLocation = function (file, cb) { return watchFile(file, cb, ts.PollingInterval.High, watchOptions, ts.WatchType.AffectingFileLocation); }; + compilerHost.watchTypeRootsDirectory = function (dir, cb, flags) { return watchDirectory(dir, cb, flags, watchOptions, ts.WatchType.TypeRoots); }; + compilerHost.getCachedDirectoryStructureHost = function () { return cachedDirectoryStructureHost; }; + compilerHost.scheduleInvalidateResolutionsOfFailedLookupLocations = scheduleInvalidateResolutionsOfFailedLookupLocations; + compilerHost.onInvalidatedResolution = scheduleProgramUpdate; + compilerHost.onChangedAutomaticTypeDirectiveNames = scheduleProgramUpdate; + compilerHost.fileIsOpen = ts.returnFalse; + compilerHost.getCurrentProgram = getCurrentProgram; + compilerHost.writeLog = writeLog; + compilerHost.getParsedCommandLine = getParsedCommandLine; + // Cache for the module resolution + var resolutionCache = ts.createResolutionCache(compilerHost, configFileName ? + ts.getDirectoryPath(ts.getNormalizedAbsolutePath(configFileName, currentDirectory)) : + currentDirectory, + /*logChangesWhenResolvingModule*/ false); + // Resolve module using host module resolution strategy if provided otherwise use resolution cache to resolve module names + compilerHost.resolveModuleNames = host.resolveModuleNames ? + (function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + return host.resolveModuleNames.apply(host, args); + }) : + (function (moduleNames, containingFile, reusedNames, redirectedReference, _options, sourceFile) { return resolutionCache.resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, sourceFile); }); + compilerHost.resolveTypeReferenceDirectives = host.resolveTypeReferenceDirectives ? + (function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + return host.resolveTypeReferenceDirectives.apply(host, args); + }) : + (function (typeDirectiveNames, containingFile, redirectedReference, _options, containingFileMode) { return resolutionCache.resolveTypeReferenceDirectives(typeDirectiveNames, containingFile, redirectedReference, containingFileMode); }); + compilerHost.getModuleResolutionCache = host.resolveModuleNames ? + ts.maybeBind(host, host.getModuleResolutionCache) : + (function () { return resolutionCache.getModuleResolutionCache(); }); + var userProvidedResolution = !!host.resolveModuleNames || !!host.resolveTypeReferenceDirectives; + // All resolutions are invalid if user provided resolutions and didnt supply hasInvalidatedResolutions + var customHasInvalidatedResolutions = userProvidedResolution ? + ts.maybeBind(host, host.hasInvalidatedResolutions) || ts.returnTrue : + ts.returnFalse; + builderProgram = readBuilderProgram(compilerOptions, compilerHost); + synchronizeProgram(); + // Update the wild card directory watch + watchConfigFileWildCardDirectories(); + // Update extended config file watch + if (configFileName) + updateExtendedConfigFilesWatches(toPath(configFileName), compilerOptions, watchOptions, ts.WatchType.ExtendedConfigFile); + return configFileName ? + { getCurrentProgram: getCurrentBuilderProgram, getProgram: updateProgram, close: close } : + { getCurrentProgram: getCurrentBuilderProgram, getProgram: updateProgram, updateRootFileNames: updateRootFileNames, close: close }; + function close() { + clearInvalidateResolutionsOfFailedLookupLocations(); + resolutionCache.clear(); + ts.clearMap(sourceFilesCache, function (value) { + if (value && value.fileWatcher) { + value.fileWatcher.close(); + value.fileWatcher = undefined; + } + }); + if (configFileWatcher) { + configFileWatcher.close(); + configFileWatcher = undefined; + } + extendedConfigCache === null || extendedConfigCache === void 0 ? void 0 : extendedConfigCache.clear(); + extendedConfigCache = undefined; + if (sharedExtendedConfigFileWatchers) { + ts.clearMap(sharedExtendedConfigFileWatchers, ts.closeFileWatcherOf); + sharedExtendedConfigFileWatchers = undefined; + } + if (watchedWildcardDirectories) { + ts.clearMap(watchedWildcardDirectories, ts.closeFileWatcherOf); + watchedWildcardDirectories = undefined; + } + if (missingFilesMap) { + ts.clearMap(missingFilesMap, ts.closeFileWatcher); + missingFilesMap = undefined; + } + if (parsedConfigs) { + ts.clearMap(parsedConfigs, function (config) { + var _a; + (_a = config.watcher) === null || _a === void 0 ? void 0 : _a.close(); + config.watcher = undefined; + if (config.watchedDirectories) + ts.clearMap(config.watchedDirectories, ts.closeFileWatcherOf); + config.watchedDirectories = undefined; + }); + parsedConfigs = undefined; + } + } + function getCurrentBuilderProgram() { + return builderProgram; + } + function getCurrentProgram() { + return builderProgram && builderProgram.getProgramOrUndefined(); + } + function synchronizeProgram() { + writeLog("Synchronizing program"); + clearInvalidateResolutionsOfFailedLookupLocations(); + var program = getCurrentBuilderProgram(); + if (hasChangedCompilerOptions) { + newLine = updateNewLine(); + if (program && ts.changesAffectModuleResolution(program.getCompilerOptions(), compilerOptions)) { + resolutionCache.clear(); + } + } + var hasInvalidatedResolutions = resolutionCache.createHasInvalidatedResolutions(customHasInvalidatedResolutions); + var _a = ts.changeCompilerHostLikeToUseCache(compilerHost, toPath), originalReadFile = _a.originalReadFile, originalFileExists = _a.originalFileExists, originalDirectoryExists = _a.originalDirectoryExists, originalCreateDirectory = _a.originalCreateDirectory, originalWriteFile = _a.originalWriteFile; + if (ts.isProgramUptoDate(getCurrentProgram(), rootFileNames, compilerOptions, getSourceVersion, function (fileName) { return compilerHost.fileExists(fileName); }, hasInvalidatedResolutions, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) { + if (hasChangedConfigFileParsingErrors) { + if (reportFileChangeDetectedOnCreateProgram) { + reportWatchDiagnostic(ts.Diagnostics.File_change_detected_Starting_incremental_compilation); + } + builderProgram = createProgram(/*rootNames*/ undefined, /*options*/ undefined, compilerHost, builderProgram, configFileParsingDiagnostics, projectReferences); + hasChangedConfigFileParsingErrors = false; + } + } + else { + if (reportFileChangeDetectedOnCreateProgram) { + reportWatchDiagnostic(ts.Diagnostics.File_change_detected_Starting_incremental_compilation); + } + createNewProgram(hasInvalidatedResolutions); + } + reportFileChangeDetectedOnCreateProgram = false; + if (host.afterProgramCreate && program !== builderProgram) { + host.afterProgramCreate(builderProgram); + } + compilerHost.readFile = originalReadFile; + compilerHost.fileExists = originalFileExists; + compilerHost.directoryExists = originalDirectoryExists; + compilerHost.createDirectory = originalCreateDirectory; + compilerHost.writeFile = originalWriteFile; + return builderProgram; + } + function createNewProgram(hasInvalidatedResolutions) { + // Compile the program + writeLog("CreatingProgramWith::"); + writeLog(" roots: ".concat(JSON.stringify(rootFileNames))); + writeLog(" options: ".concat(JSON.stringify(compilerOptions))); + if (projectReferences) + writeLog(" projectReferences: ".concat(JSON.stringify(projectReferences))); + var needsUpdateInTypeRootWatch = hasChangedCompilerOptions || !getCurrentProgram(); + hasChangedCompilerOptions = false; + hasChangedConfigFileParsingErrors = false; + resolutionCache.startCachingPerDirectoryResolution(); + compilerHost.hasInvalidatedResolutions = hasInvalidatedResolutions; + compilerHost.hasChangedAutomaticTypeDirectiveNames = hasChangedAutomaticTypeDirectiveNames; + var oldProgram = getCurrentProgram(); + builderProgram = createProgram(rootFileNames, compilerOptions, compilerHost, builderProgram, configFileParsingDiagnostics, projectReferences); + resolutionCache.finishCachingPerDirectoryResolution(builderProgram.getProgram(), oldProgram); + // Update watches + ts.updateMissingFilePathsWatch(builderProgram.getProgram(), missingFilesMap || (missingFilesMap = new ts.Map()), watchMissingFilePath); + if (needsUpdateInTypeRootWatch) { + resolutionCache.updateTypeRootsWatch(); + } + if (missingFilePathsRequestedForRelease) { + // These are the paths that program creater told us as not in use any more but were missing on the disk. + // We didnt remove the entry for them from sourceFiles cache so that we dont have to do File IO, + // if there is already watcher for it (for missing files) + // At this point our watches were updated, hence now we know that these paths are not tracked and need to be removed + // so that at later time we have correct result of their presence + for (var _i = 0, missingFilePathsRequestedForRelease_1 = missingFilePathsRequestedForRelease; _i < missingFilePathsRequestedForRelease_1.length; _i++) { + var missingFilePath = missingFilePathsRequestedForRelease_1[_i]; + if (!missingFilesMap.has(missingFilePath)) { + sourceFilesCache.delete(missingFilePath); + } + } + missingFilePathsRequestedForRelease = undefined; + } + } + function updateRootFileNames(files) { + ts.Debug.assert(!configFileName, "Cannot update root file names with config file watch mode"); + rootFileNames = files; + scheduleProgramUpdate(); + } + function updateNewLine() { + return ts.getNewLineCharacter(compilerOptions || optionsToExtendForConfigFile, function () { return host.getNewLine(); }); + } + function toPath(fileName) { + return ts.toPath(fileName, currentDirectory, getCanonicalFileName); + } + function isFileMissingOnHost(hostSourceFile) { + return typeof hostSourceFile === "boolean"; + } + function isFilePresenceUnknownOnHost(hostSourceFile) { + return typeof hostSourceFile.version === "boolean"; + } + function fileExists(fileName) { + var path = toPath(fileName); + // If file is missing on host from cache, we can definitely say file doesnt exist + // otherwise we need to ensure from the disk + if (isFileMissingOnHost(sourceFilesCache.get(path))) { + return false; + } + return directoryStructureHost.fileExists(fileName); + } + function getVersionedSourceFileByPath(fileName, path, languageVersionOrOptions, onError, shouldCreateNewSourceFile) { + var hostSourceFile = sourceFilesCache.get(path); + // No source file on the host + if (isFileMissingOnHost(hostSourceFile)) { + return undefined; + } + // Create new source file if requested or the versions dont match + if (hostSourceFile === undefined || shouldCreateNewSourceFile || isFilePresenceUnknownOnHost(hostSourceFile)) { + var sourceFile = getNewSourceFile(fileName, languageVersionOrOptions, onError); + if (hostSourceFile) { + if (sourceFile) { + // Set the source file and create file watcher now that file was present on the disk + hostSourceFile.sourceFile = sourceFile; + hostSourceFile.version = sourceFile.version; + if (!hostSourceFile.fileWatcher) { + hostSourceFile.fileWatcher = watchFilePath(path, fileName, onSourceFileChange, ts.PollingInterval.Low, watchOptions, ts.WatchType.SourceFile); + } + } + else { + // There is no source file on host any more, close the watch, missing file paths will track it + if (hostSourceFile.fileWatcher) { + hostSourceFile.fileWatcher.close(); + } + sourceFilesCache.set(path, false); + } + } + else { + if (sourceFile) { + var fileWatcher = watchFilePath(path, fileName, onSourceFileChange, ts.PollingInterval.Low, watchOptions, ts.WatchType.SourceFile); + sourceFilesCache.set(path, { sourceFile: sourceFile, version: sourceFile.version, fileWatcher: fileWatcher }); + } + else { + sourceFilesCache.set(path, false); + } + } + return sourceFile; + } + return hostSourceFile.sourceFile; + } + function nextSourceFileVersion(path) { + var hostSourceFile = sourceFilesCache.get(path); + if (hostSourceFile !== undefined) { + if (isFileMissingOnHost(hostSourceFile)) { + // The next version, lets set it as presence unknown file + sourceFilesCache.set(path, { version: false }); + } + else { + hostSourceFile.version = false; + } + } + } + function getSourceVersion(path) { + var hostSourceFile = sourceFilesCache.get(path); + return !hostSourceFile || !hostSourceFile.version ? undefined : hostSourceFile.version; + } + function onReleaseOldSourceFile(oldSourceFile, _oldOptions, hasSourceFileByPath) { + var hostSourceFileInfo = sourceFilesCache.get(oldSourceFile.resolvedPath); + // If this is the source file thats in the cache and new program doesnt need it, + // remove the cached entry. + // Note we arent deleting entry if file became missing in new program or + // there was version update and new source file was created. + if (hostSourceFileInfo !== undefined) { + // record the missing file paths so they can be removed later if watchers arent tracking them + if (isFileMissingOnHost(hostSourceFileInfo)) { + (missingFilePathsRequestedForRelease || (missingFilePathsRequestedForRelease = [])).push(oldSourceFile.path); + } + else if (hostSourceFileInfo.sourceFile === oldSourceFile) { + if (hostSourceFileInfo.fileWatcher) { + hostSourceFileInfo.fileWatcher.close(); + } + sourceFilesCache.delete(oldSourceFile.resolvedPath); + if (!hasSourceFileByPath) { + resolutionCache.removeResolutionsOfFile(oldSourceFile.path); + } + } + } + } + function reportWatchDiagnostic(message) { + if (host.onWatchStatusChange) { + host.onWatchStatusChange(ts.createCompilerDiagnostic(message), newLine, compilerOptions || optionsToExtendForConfigFile); + } + } + function hasChangedAutomaticTypeDirectiveNames() { + return resolutionCache.hasChangedAutomaticTypeDirectiveNames(); + } + function clearInvalidateResolutionsOfFailedLookupLocations() { + if (!timerToInvalidateFailedLookupResolutions) + return false; + host.clearTimeout(timerToInvalidateFailedLookupResolutions); + timerToInvalidateFailedLookupResolutions = undefined; + return true; + } + function scheduleInvalidateResolutionsOfFailedLookupLocations() { + if (!host.setTimeout || !host.clearTimeout) { + return resolutionCache.invalidateResolutionsOfFailedLookupLocations(); + } + var pending = clearInvalidateResolutionsOfFailedLookupLocations(); + writeLog("Scheduling invalidateFailedLookup".concat(pending ? ", Cancelled earlier one" : "")); + timerToInvalidateFailedLookupResolutions = host.setTimeout(invalidateResolutionsOfFailedLookup, 250); + } + function invalidateResolutionsOfFailedLookup() { + timerToInvalidateFailedLookupResolutions = undefined; + if (resolutionCache.invalidateResolutionsOfFailedLookupLocations()) { + scheduleProgramUpdate(); + } + } + // Upon detecting a file change, wait for 250ms and then perform a recompilation. This gives batch + // operations (such as saving all modified files in an editor) a chance to complete before we kick + // off a new compilation. + function scheduleProgramUpdate() { + if (!host.setTimeout || !host.clearTimeout) { + return; + } + if (timerToUpdateProgram) { + host.clearTimeout(timerToUpdateProgram); + } + writeLog("Scheduling update"); + timerToUpdateProgram = host.setTimeout(updateProgramWithWatchStatus, 250); + } + function scheduleProgramReload() { + ts.Debug.assert(!!configFileName); + reloadLevel = ts.ConfigFileProgramReloadLevel.Full; + scheduleProgramUpdate(); + } + function updateProgramWithWatchStatus() { + timerToUpdateProgram = undefined; + reportFileChangeDetectedOnCreateProgram = true; + updateProgram(); + } + function updateProgram() { + switch (reloadLevel) { + case ts.ConfigFileProgramReloadLevel.Partial: + ts.perfLogger.logStartUpdateProgram("PartialConfigReload"); + reloadFileNamesFromConfigFile(); + break; + case ts.ConfigFileProgramReloadLevel.Full: + ts.perfLogger.logStartUpdateProgram("FullConfigReload"); + reloadConfigFile(); + break; + default: + ts.perfLogger.logStartUpdateProgram("SynchronizeProgram"); + synchronizeProgram(); + break; + } + ts.perfLogger.logStopUpdateProgram("Done"); + return getCurrentBuilderProgram(); + } + function reloadFileNamesFromConfigFile() { + writeLog("Reloading new file names and options"); + reloadLevel = ts.ConfigFileProgramReloadLevel.None; + rootFileNames = ts.getFileNamesFromConfigSpecs(compilerOptions.configFile.configFileSpecs, ts.getNormalizedAbsolutePath(ts.getDirectoryPath(configFileName), currentDirectory), compilerOptions, parseConfigFileHost, extraFileExtensions); + if (ts.updateErrorForNoInputFiles(rootFileNames, ts.getNormalizedAbsolutePath(configFileName, currentDirectory), compilerOptions.configFile.configFileSpecs, configFileParsingDiagnostics, canConfigFileJsonReportNoInputFiles)) { + hasChangedConfigFileParsingErrors = true; + } + // Update the program + synchronizeProgram(); + } + function reloadConfigFile() { + writeLog("Reloading config file: ".concat(configFileName)); + reloadLevel = ts.ConfigFileProgramReloadLevel.None; + if (cachedDirectoryStructureHost) { + cachedDirectoryStructureHost.clearCache(); + } + parseConfigFile(); + hasChangedCompilerOptions = true; + synchronizeProgram(); + // Update the wild card directory watch + watchConfigFileWildCardDirectories(); + // Update extended config file watch + updateExtendedConfigFilesWatches(toPath(configFileName), compilerOptions, watchOptions, ts.WatchType.ExtendedConfigFile); + } + function parseConfigFile() { + setConfigFileParsingResult(ts.getParsedCommandLineOfConfigFile(configFileName, optionsToExtendForConfigFile, parseConfigFileHost, extendedConfigCache || (extendedConfigCache = new ts.Map()), watchOptionsToExtend, extraFileExtensions)); // TODO: GH#18217 + } + function setConfigFileParsingResult(configFileParseResult) { + rootFileNames = configFileParseResult.fileNames; + compilerOptions = configFileParseResult.options; + watchOptions = configFileParseResult.watchOptions; + projectReferences = configFileParseResult.projectReferences; + wildcardDirectories = configFileParseResult.wildcardDirectories; + configFileParsingDiagnostics = ts.getConfigFileParsingDiagnostics(configFileParseResult).slice(); + canConfigFileJsonReportNoInputFiles = ts.canJsonReportNoInputFiles(configFileParseResult.raw); + hasChangedConfigFileParsingErrors = true; + } + function getParsedCommandLine(configFileName) { + var configPath = toPath(configFileName); + var config = parsedConfigs === null || parsedConfigs === void 0 ? void 0 : parsedConfigs.get(configPath); + if (config) { + if (!config.reloadLevel) + return config.parsedCommandLine; + // With host implementing getParsedCommandLine we cant just update file names + if (config.parsedCommandLine && config.reloadLevel === ts.ConfigFileProgramReloadLevel.Partial && !host.getParsedCommandLine) { + writeLog("Reloading new file names and options"); + var fileNames = ts.getFileNamesFromConfigSpecs(config.parsedCommandLine.options.configFile.configFileSpecs, ts.getNormalizedAbsolutePath(ts.getDirectoryPath(configFileName), currentDirectory), compilerOptions, parseConfigFileHost); + config.parsedCommandLine = __assign(__assign({}, config.parsedCommandLine), { fileNames: fileNames }); + config.reloadLevel = undefined; + return config.parsedCommandLine; + } + } + writeLog("Loading config file: ".concat(configFileName)); + var parsedCommandLine = host.getParsedCommandLine ? + host.getParsedCommandLine(configFileName) : + getParsedCommandLineFromConfigFileHost(configFileName); + if (config) { + config.parsedCommandLine = parsedCommandLine; + config.reloadLevel = undefined; + } + else { + (parsedConfigs || (parsedConfigs = new ts.Map())).set(configPath, config = { parsedCommandLine: parsedCommandLine }); + } + watchReferencedProject(configFileName, configPath, config); + return parsedCommandLine; + } + function getParsedCommandLineFromConfigFileHost(configFileName) { + // Ignore the file absent errors + var onUnRecoverableConfigFileDiagnostic = parseConfigFileHost.onUnRecoverableConfigFileDiagnostic; + parseConfigFileHost.onUnRecoverableConfigFileDiagnostic = ts.noop; + var parsedCommandLine = ts.getParsedCommandLineOfConfigFile(configFileName, + /*optionsToExtend*/ undefined, parseConfigFileHost, extendedConfigCache || (extendedConfigCache = new ts.Map()), watchOptionsToExtend); + parseConfigFileHost.onUnRecoverableConfigFileDiagnostic = onUnRecoverableConfigFileDiagnostic; + return parsedCommandLine; + } + function onReleaseParsedCommandLine(fileName) { + var _a; + var path = toPath(fileName); + var config = parsedConfigs === null || parsedConfigs === void 0 ? void 0 : parsedConfigs.get(path); + if (!config) + return; + parsedConfigs.delete(path); + if (config.watchedDirectories) + ts.clearMap(config.watchedDirectories, ts.closeFileWatcherOf); + (_a = config.watcher) === null || _a === void 0 ? void 0 : _a.close(); + ts.clearSharedExtendedConfigFileWatcher(path, sharedExtendedConfigFileWatchers); + } + function watchFilePath(path, file, callback, pollingInterval, options, watchType) { + return watchFile(file, function (fileName, eventKind) { return callback(fileName, eventKind, path); }, pollingInterval, options, watchType); + } + function onSourceFileChange(fileName, eventKind, path) { + updateCachedSystemWithFile(fileName, path, eventKind); + // Update the source file cache + if (eventKind === ts.FileWatcherEventKind.Deleted && sourceFilesCache.has(path)) { + resolutionCache.invalidateResolutionOfFile(path); + } + nextSourceFileVersion(path); + // Update the program + scheduleProgramUpdate(); + } + function updateCachedSystemWithFile(fileName, path, eventKind) { + if (cachedDirectoryStructureHost) { + cachedDirectoryStructureHost.addOrDeleteFile(fileName, path, eventKind); + } + } + function watchMissingFilePath(missingFilePath) { + // If watching missing referenced config file, we are already watching it so no need for separate watcher + return (parsedConfigs === null || parsedConfigs === void 0 ? void 0 : parsedConfigs.has(missingFilePath)) ? + ts.noopFileWatcher : + watchFilePath(missingFilePath, missingFilePath, onMissingFileChange, ts.PollingInterval.Medium, watchOptions, ts.WatchType.MissingFile); + } + function onMissingFileChange(fileName, eventKind, missingFilePath) { + updateCachedSystemWithFile(fileName, missingFilePath, eventKind); + if (eventKind === ts.FileWatcherEventKind.Created && missingFilesMap.has(missingFilePath)) { + missingFilesMap.get(missingFilePath).close(); + missingFilesMap.delete(missingFilePath); + // Delete the entry in the source files cache so that new source file is created + nextSourceFileVersion(missingFilePath); + // When a missing file is created, we should update the graph. + scheduleProgramUpdate(); + } + } + function watchConfigFileWildCardDirectories() { + if (wildcardDirectories) { + ts.updateWatchingWildcardDirectories(watchedWildcardDirectories || (watchedWildcardDirectories = new ts.Map()), new ts.Map(ts.getEntries(wildcardDirectories)), watchWildcardDirectory); + } + else if (watchedWildcardDirectories) { + ts.clearMap(watchedWildcardDirectories, ts.closeFileWatcherOf); + } + } + function watchWildcardDirectory(directory, flags) { + return watchDirectory(directory, function (fileOrDirectory) { + ts.Debug.assert(!!configFileName); + var fileOrDirectoryPath = toPath(fileOrDirectory); + // Since the file existence changed, update the sourceFiles cache + if (cachedDirectoryStructureHost) { + cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath); + } + nextSourceFileVersion(fileOrDirectoryPath); + if (ts.isIgnoredFileFromWildCardWatching({ + watchedDirPath: toPath(directory), + fileOrDirectory: fileOrDirectory, + fileOrDirectoryPath: fileOrDirectoryPath, + configFileName: configFileName, + extraFileExtensions: extraFileExtensions, + options: compilerOptions, + program: getCurrentBuilderProgram() || rootFileNames, + currentDirectory: currentDirectory, + useCaseSensitiveFileNames: useCaseSensitiveFileNames, + writeLog: writeLog, + toPath: toPath, + })) + return; + // Reload is pending, do the reload + if (reloadLevel !== ts.ConfigFileProgramReloadLevel.Full) { + reloadLevel = ts.ConfigFileProgramReloadLevel.Partial; + // Schedule Update the program + scheduleProgramUpdate(); + } + }, flags, watchOptions, ts.WatchType.WildcardDirectory); + } + function updateExtendedConfigFilesWatches(forProjectPath, options, watchOptions, watchType) { + ts.updateSharedExtendedConfigFileWatcher(forProjectPath, options, sharedExtendedConfigFileWatchers || (sharedExtendedConfigFileWatchers = new ts.Map()), function (extendedConfigFileName, extendedConfigFilePath) { return watchFile(extendedConfigFileName, function (_fileName, eventKind) { + var _a; + updateCachedSystemWithFile(extendedConfigFileName, extendedConfigFilePath, eventKind); + // Update extended config cache + if (extendedConfigCache) + ts.cleanExtendedConfigCache(extendedConfigCache, extendedConfigFilePath, toPath); + // Update projects + var projects = (_a = sharedExtendedConfigFileWatchers.get(extendedConfigFilePath)) === null || _a === void 0 ? void 0 : _a.projects; + // If there are no referenced projects this extended config file watcher depend on ignore + if (!(projects === null || projects === void 0 ? void 0 : projects.size)) + return; + projects.forEach(function (projectPath) { + if (toPath(configFileName) === projectPath) { + // If this is the config file of the project, reload completely + reloadLevel = ts.ConfigFileProgramReloadLevel.Full; + } + else { + // Reload config for the referenced projects and remove the resolutions from referenced projects since the config file changed + var config = parsedConfigs === null || parsedConfigs === void 0 ? void 0 : parsedConfigs.get(projectPath); + if (config) + config.reloadLevel = ts.ConfigFileProgramReloadLevel.Full; + resolutionCache.removeResolutionsFromProjectReferenceRedirects(projectPath); + } + scheduleProgramUpdate(); + }); + }, ts.PollingInterval.High, watchOptions, watchType); }, toPath); + } + function watchReferencedProject(configFileName, configPath, commandLine) { + var _a, _b, _c, _d, _e; + // Watch file + commandLine.watcher || (commandLine.watcher = watchFile(configFileName, function (_fileName, eventKind) { + updateCachedSystemWithFile(configFileName, configPath, eventKind); + var config = parsedConfigs === null || parsedConfigs === void 0 ? void 0 : parsedConfigs.get(configPath); + if (config) + config.reloadLevel = ts.ConfigFileProgramReloadLevel.Full; + resolutionCache.removeResolutionsFromProjectReferenceRedirects(configPath); + scheduleProgramUpdate(); + }, ts.PollingInterval.High, ((_a = commandLine.parsedCommandLine) === null || _a === void 0 ? void 0 : _a.watchOptions) || watchOptions, ts.WatchType.ConfigFileOfReferencedProject)); + // Watch Wild card + if ((_b = commandLine.parsedCommandLine) === null || _b === void 0 ? void 0 : _b.wildcardDirectories) { + ts.updateWatchingWildcardDirectories(commandLine.watchedDirectories || (commandLine.watchedDirectories = new ts.Map()), new ts.Map(ts.getEntries((_c = commandLine.parsedCommandLine) === null || _c === void 0 ? void 0 : _c.wildcardDirectories)), function (directory, flags) { + var _a; + return watchDirectory(directory, function (fileOrDirectory) { + var fileOrDirectoryPath = toPath(fileOrDirectory); + // Since the file existence changed, update the sourceFiles cache + if (cachedDirectoryStructureHost) { + cachedDirectoryStructureHost.addOrDeleteFileOrDirectory(fileOrDirectory, fileOrDirectoryPath); + } + nextSourceFileVersion(fileOrDirectoryPath); + var config = parsedConfigs === null || parsedConfigs === void 0 ? void 0 : parsedConfigs.get(configPath); + if (!(config === null || config === void 0 ? void 0 : config.parsedCommandLine)) + return; + if (ts.isIgnoredFileFromWildCardWatching({ + watchedDirPath: toPath(directory), + fileOrDirectory: fileOrDirectory, + fileOrDirectoryPath: fileOrDirectoryPath, + configFileName: configFileName, + options: config.parsedCommandLine.options, + program: config.parsedCommandLine.fileNames, + currentDirectory: currentDirectory, + useCaseSensitiveFileNames: useCaseSensitiveFileNames, + writeLog: writeLog, + toPath: toPath, + })) + return; + // Reload is pending, do the reload + if (config.reloadLevel !== ts.ConfigFileProgramReloadLevel.Full) { + config.reloadLevel = ts.ConfigFileProgramReloadLevel.Partial; + // Schedule Update the program + scheduleProgramUpdate(); + } + }, flags, ((_a = commandLine.parsedCommandLine) === null || _a === void 0 ? void 0 : _a.watchOptions) || watchOptions, ts.WatchType.WildcardDirectoryOfReferencedProject); + }); + } + else if (commandLine.watchedDirectories) { + ts.clearMap(commandLine.watchedDirectories, ts.closeFileWatcherOf); + commandLine.watchedDirectories = undefined; + } + // Watch extended config files + updateExtendedConfigFilesWatches(configPath, (_d = commandLine.parsedCommandLine) === null || _d === void 0 ? void 0 : _d.options, ((_e = commandLine.parsedCommandLine) === null || _e === void 0 ? void 0 : _e.watchOptions) || watchOptions, ts.WatchType.ExtendedConfigOfReferencedProject); + } + } + ts.createWatchProgram = createWatchProgram; +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + var UpToDateStatusType; + (function (UpToDateStatusType) { + UpToDateStatusType[UpToDateStatusType["Unbuildable"] = 0] = "Unbuildable"; + UpToDateStatusType[UpToDateStatusType["UpToDate"] = 1] = "UpToDate"; + /** + * The project appears out of date because its upstream inputs are newer than its outputs, + * but all of its outputs are actually newer than the previous identical outputs of its (.d.ts) inputs. + * This means we can Pseudo-build (just touch timestamps), as if we had actually built this project. + */ + UpToDateStatusType[UpToDateStatusType["UpToDateWithUpstreamTypes"] = 2] = "UpToDateWithUpstreamTypes"; + /** + * The project appears out of date because its upstream inputs are newer than its outputs, + * but all of its outputs are actually newer than the previous identical outputs of its (.d.ts) inputs. + * This means we can Pseudo-build (just manipulate outputs), as if we had actually built this project. + */ + UpToDateStatusType[UpToDateStatusType["OutOfDateWithPrepend"] = 3] = "OutOfDateWithPrepend"; + UpToDateStatusType[UpToDateStatusType["OutputMissing"] = 4] = "OutputMissing"; + UpToDateStatusType[UpToDateStatusType["ErrorReadingFile"] = 5] = "ErrorReadingFile"; + UpToDateStatusType[UpToDateStatusType["OutOfDateWithSelf"] = 6] = "OutOfDateWithSelf"; + UpToDateStatusType[UpToDateStatusType["OutOfDateWithUpstream"] = 7] = "OutOfDateWithUpstream"; + UpToDateStatusType[UpToDateStatusType["OutOfDateBuildInfo"] = 8] = "OutOfDateBuildInfo"; + UpToDateStatusType[UpToDateStatusType["UpstreamOutOfDate"] = 9] = "UpstreamOutOfDate"; + UpToDateStatusType[UpToDateStatusType["UpstreamBlocked"] = 10] = "UpstreamBlocked"; + UpToDateStatusType[UpToDateStatusType["ComputingUpstream"] = 11] = "ComputingUpstream"; + UpToDateStatusType[UpToDateStatusType["TsVersionOutputOfDate"] = 12] = "TsVersionOutputOfDate"; + UpToDateStatusType[UpToDateStatusType["UpToDateWithInputFileText"] = 13] = "UpToDateWithInputFileText"; + /** + * Projects with no outputs (i.e. "solution" files) + */ + UpToDateStatusType[UpToDateStatusType["ContainerOnly"] = 14] = "ContainerOnly"; + UpToDateStatusType[UpToDateStatusType["ForceBuild"] = 15] = "ForceBuild"; + })(UpToDateStatusType = ts.UpToDateStatusType || (ts.UpToDateStatusType = {})); + function resolveConfigFileProjectName(project) { + if (ts.fileExtensionIs(project, ".json" /* Extension.Json */)) { + return project; + } + return ts.combinePaths(project, "tsconfig.json"); + } + ts.resolveConfigFileProjectName = resolveConfigFileProjectName; +})(ts || (ts = {})); +var ts; +(function (ts) { + var minimumDate = new Date(-8640000000000000); + var maximumDate = new Date(8640000000000000); + var BuildResultFlags; + (function (BuildResultFlags) { + BuildResultFlags[BuildResultFlags["None"] = 0] = "None"; + /** + * No errors of any kind occurred during build + */ + BuildResultFlags[BuildResultFlags["Success"] = 1] = "Success"; + /** + * None of the .d.ts files emitted by this build were + * different from the existing files on disk + */ + BuildResultFlags[BuildResultFlags["DeclarationOutputUnchanged"] = 2] = "DeclarationOutputUnchanged"; + BuildResultFlags[BuildResultFlags["ConfigFileErrors"] = 4] = "ConfigFileErrors"; + BuildResultFlags[BuildResultFlags["SyntaxErrors"] = 8] = "SyntaxErrors"; + BuildResultFlags[BuildResultFlags["TypeErrors"] = 16] = "TypeErrors"; + BuildResultFlags[BuildResultFlags["DeclarationEmitErrors"] = 32] = "DeclarationEmitErrors"; + BuildResultFlags[BuildResultFlags["EmitErrors"] = 64] = "EmitErrors"; + BuildResultFlags[BuildResultFlags["AnyErrors"] = 124] = "AnyErrors"; + })(BuildResultFlags || (BuildResultFlags = {})); + function getOrCreateValueFromConfigFileMap(configFileMap, resolved, createT) { + var existingValue = configFileMap.get(resolved); + var newValue; + if (!existingValue) { + newValue = createT(); + configFileMap.set(resolved, newValue); + } + return existingValue || newValue; + } + function getOrCreateValueMapFromConfigFileMap(configFileMap, resolved) { + return getOrCreateValueFromConfigFileMap(configFileMap, resolved, function () { return new ts.Map(); }); + } + /*@internal*/ + /** Helper to use now method instead of current date for testing purposes to get consistent baselines */ + function getCurrentTime(host) { + return host.now ? host.now() : new Date(); + } + ts.getCurrentTime = getCurrentTime; + /*@internal*/ + function isCircularBuildOrder(buildOrder) { + return !!buildOrder && !!buildOrder.buildOrder; + } + ts.isCircularBuildOrder = isCircularBuildOrder; + /*@internal*/ + function getBuildOrderFromAnyBuildOrder(anyBuildOrder) { + return isCircularBuildOrder(anyBuildOrder) ? anyBuildOrder.buildOrder : anyBuildOrder; + } + ts.getBuildOrderFromAnyBuildOrder = getBuildOrderFromAnyBuildOrder; + /** + * Create a function that reports watch status by writing to the system and handles the formating of the diagnostic + */ + function createBuilderStatusReporter(system, pretty) { + return function (diagnostic) { + var output = pretty ? "[".concat(ts.formatColorAndReset(ts.getLocaleTimeString(system), ts.ForegroundColorEscapeSequences.Grey), "] ") : "".concat(ts.getLocaleTimeString(system), " - "); + output += "".concat(ts.flattenDiagnosticMessageText(diagnostic.messageText, system.newLine)).concat(system.newLine + system.newLine); + system.write(output); + }; + } + ts.createBuilderStatusReporter = createBuilderStatusReporter; + function createSolutionBuilderHostBase(system, createProgram, reportDiagnostic, reportSolutionBuilderStatus) { + var host = ts.createProgramHost(system, createProgram); + host.getModifiedTime = system.getModifiedTime ? function (path) { return system.getModifiedTime(path); } : ts.returnUndefined; + host.setModifiedTime = system.setModifiedTime ? function (path, date) { return system.setModifiedTime(path, date); } : ts.noop; + host.deleteFile = system.deleteFile ? function (path) { return system.deleteFile(path); } : ts.noop; + host.reportDiagnostic = reportDiagnostic || ts.createDiagnosticReporter(system); + host.reportSolutionBuilderStatus = reportSolutionBuilderStatus || createBuilderStatusReporter(system); + host.now = ts.maybeBind(system, system.now); // For testing + return host; + } + function createSolutionBuilderHost(system, createProgram, reportDiagnostic, reportSolutionBuilderStatus, reportErrorSummary) { + if (system === void 0) { system = ts.sys; } + var host = createSolutionBuilderHostBase(system, createProgram, reportDiagnostic, reportSolutionBuilderStatus); + host.reportErrorSummary = reportErrorSummary; + return host; + } + ts.createSolutionBuilderHost = createSolutionBuilderHost; + function createSolutionBuilderWithWatchHost(system, createProgram, reportDiagnostic, reportSolutionBuilderStatus, reportWatchStatus) { + if (system === void 0) { system = ts.sys; } + var host = createSolutionBuilderHostBase(system, createProgram, reportDiagnostic, reportSolutionBuilderStatus); + var watchHost = ts.createWatchHost(system, reportWatchStatus); + ts.copyProperties(host, watchHost); + return host; + } + ts.createSolutionBuilderWithWatchHost = createSolutionBuilderWithWatchHost; + function getCompilerOptionsOfBuildOptions(buildOptions) { + var result = {}; + ts.commonOptionsWithBuild.forEach(function (option) { + if (ts.hasProperty(buildOptions, option.name)) + result[option.name] = buildOptions[option.name]; + }); + return result; + } + function createSolutionBuilder(host, rootNames, defaultOptions) { + return createSolutionBuilderWorker(/*watch*/ false, host, rootNames, defaultOptions); + } + ts.createSolutionBuilder = createSolutionBuilder; + function createSolutionBuilderWithWatch(host, rootNames, defaultOptions, baseWatchOptions) { + return createSolutionBuilderWorker(/*watch*/ true, host, rootNames, defaultOptions, baseWatchOptions); + } + ts.createSolutionBuilderWithWatch = createSolutionBuilderWithWatch; + function createSolutionBuilderState(watch, hostOrHostWithWatch, rootNames, options, baseWatchOptions) { + var host = hostOrHostWithWatch; + var hostWithWatch = hostOrHostWithWatch; + var currentDirectory = host.getCurrentDirectory(); + var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames()); + // State of the solution + var baseCompilerOptions = getCompilerOptionsOfBuildOptions(options); + var compilerHost = ts.createCompilerHostFromProgramHost(host, function () { return state.projectCompilerOptions; }); + ts.setGetSourceFileAsHashVersioned(compilerHost, host); + compilerHost.getParsedCommandLine = function (fileName) { return parseConfigFile(state, fileName, toResolvedConfigFilePath(state, fileName)); }; + compilerHost.resolveModuleNames = ts.maybeBind(host, host.resolveModuleNames); + compilerHost.resolveTypeReferenceDirectives = ts.maybeBind(host, host.resolveTypeReferenceDirectives); + compilerHost.getModuleResolutionCache = ts.maybeBind(host, host.getModuleResolutionCache); + var moduleResolutionCache = !compilerHost.resolveModuleNames ? ts.createModuleResolutionCache(currentDirectory, getCanonicalFileName) : undefined; + var typeReferenceDirectiveResolutionCache = !compilerHost.resolveTypeReferenceDirectives ? ts.createTypeReferenceDirectiveResolutionCache(currentDirectory, getCanonicalFileName, /*options*/ undefined, moduleResolutionCache === null || moduleResolutionCache === void 0 ? void 0 : moduleResolutionCache.getPackageJsonInfoCache()) : undefined; + if (!compilerHost.resolveModuleNames) { + var loader_3 = function (moduleName, resolverMode, containingFile, redirectedReference) { return ts.resolveModuleName(moduleName, containingFile, state.projectCompilerOptions, compilerHost, moduleResolutionCache, redirectedReference, resolverMode).resolvedModule; }; + compilerHost.resolveModuleNames = function (moduleNames, containingFile, _reusedNames, redirectedReference, _options, containingSourceFile) { + return ts.loadWithModeAwareCache(ts.Debug.checkEachDefined(moduleNames), ts.Debug.checkDefined(containingSourceFile), containingFile, redirectedReference, loader_3); + }; + compilerHost.getModuleResolutionCache = function () { return moduleResolutionCache; }; + } + if (!compilerHost.resolveTypeReferenceDirectives) { + var loader_4 = function (moduleName, containingFile, redirectedReference, containingFileMode) { return ts.resolveTypeReferenceDirective(moduleName, containingFile, state.projectCompilerOptions, compilerHost, redirectedReference, state.typeReferenceDirectiveResolutionCache, containingFileMode).resolvedTypeReferenceDirective; }; + compilerHost.resolveTypeReferenceDirectives = function (typeReferenceDirectiveNames, containingFile, redirectedReference, _options, containingFileMode) { + return ts.loadWithTypeDirectiveCache(ts.Debug.checkEachDefined(typeReferenceDirectiveNames), containingFile, redirectedReference, containingFileMode, loader_4); + }; + } + compilerHost.getBuildInfo = function (fileName, configFilePath) { return getBuildInfo(state, fileName, toResolvedConfigFilePath(state, configFilePath), /*modifiedTime*/ undefined); }; + var _a = ts.createWatchFactory(hostWithWatch, options), watchFile = _a.watchFile, watchDirectory = _a.watchDirectory, writeLog = _a.writeLog; + var state = { + host: host, + hostWithWatch: hostWithWatch, + currentDirectory: currentDirectory, + getCanonicalFileName: getCanonicalFileName, + parseConfigFileHost: ts.parseConfigHostFromCompilerHostLike(host), + write: ts.maybeBind(host, host.trace), + // State of solution + options: options, + baseCompilerOptions: baseCompilerOptions, + rootNames: rootNames, + baseWatchOptions: baseWatchOptions, + resolvedConfigFilePaths: new ts.Map(), + configFileCache: new ts.Map(), + projectStatus: new ts.Map(), + extendedConfigCache: new ts.Map(), + buildInfoCache: new ts.Map(), + outputTimeStamps: new ts.Map(), + builderPrograms: new ts.Map(), + diagnostics: new ts.Map(), + projectPendingBuild: new ts.Map(), + projectErrorsReported: new ts.Map(), + compilerHost: compilerHost, + moduleResolutionCache: moduleResolutionCache, + typeReferenceDirectiveResolutionCache: typeReferenceDirectiveResolutionCache, + // Mutable state + buildOrder: undefined, + readFileWithCache: function (f) { return host.readFile(f); }, + projectCompilerOptions: baseCompilerOptions, + cache: undefined, + allProjectBuildPending: true, + needsSummary: true, + watchAllProjectsPending: watch, + // Watch state + watch: watch, + allWatchedWildcardDirectories: new ts.Map(), + allWatchedInputFiles: new ts.Map(), + allWatchedConfigFiles: new ts.Map(), + allWatchedExtendedConfigFiles: new ts.Map(), + allWatchedPackageJsonFiles: new ts.Map(), + filesWatched: new ts.Map(), + lastCachedPackageJsonLookups: new ts.Map(), + timerToBuildInvalidatedProject: undefined, + reportFileChangeDetected: false, + watchFile: watchFile, + watchDirectory: watchDirectory, + writeLog: writeLog, + }; + return state; + } + function toPath(state, fileName) { + return ts.toPath(fileName, state.currentDirectory, state.getCanonicalFileName); + } + function toResolvedConfigFilePath(state, fileName) { + var resolvedConfigFilePaths = state.resolvedConfigFilePaths; + var path = resolvedConfigFilePaths.get(fileName); + if (path !== undefined) + return path; + var resolvedPath = toPath(state, fileName); + resolvedConfigFilePaths.set(fileName, resolvedPath); + return resolvedPath; + } + function isParsedCommandLine(entry) { + return !!entry.options; + } + function getCachedParsedConfigFile(state, configFilePath) { + var value = state.configFileCache.get(configFilePath); + return value && isParsedCommandLine(value) ? value : undefined; + } + function parseConfigFile(state, configFileName, configFilePath) { + var configFileCache = state.configFileCache; + var value = configFileCache.get(configFilePath); + if (value) { + return isParsedCommandLine(value) ? value : undefined; + } + ts.performance.mark("SolutionBuilder::beforeConfigFileParsing"); + var diagnostic; + var parseConfigFileHost = state.parseConfigFileHost, baseCompilerOptions = state.baseCompilerOptions, baseWatchOptions = state.baseWatchOptions, extendedConfigCache = state.extendedConfigCache, host = state.host; + var parsed; + if (host.getParsedCommandLine) { + parsed = host.getParsedCommandLine(configFileName); + if (!parsed) + diagnostic = ts.createCompilerDiagnostic(ts.Diagnostics.File_0_not_found, configFileName); + } + else { + parseConfigFileHost.onUnRecoverableConfigFileDiagnostic = function (d) { return diagnostic = d; }; + parsed = ts.getParsedCommandLineOfConfigFile(configFileName, baseCompilerOptions, parseConfigFileHost, extendedConfigCache, baseWatchOptions); + parseConfigFileHost.onUnRecoverableConfigFileDiagnostic = ts.noop; + } + configFileCache.set(configFilePath, parsed || diagnostic); + ts.performance.mark("SolutionBuilder::afterConfigFileParsing"); + ts.performance.measure("SolutionBuilder::Config file parsing", "SolutionBuilder::beforeConfigFileParsing", "SolutionBuilder::afterConfigFileParsing"); + return parsed; + } + function resolveProjectName(state, name) { + return ts.resolveConfigFileProjectName(ts.resolvePath(state.currentDirectory, name)); + } + function createBuildOrder(state, roots) { + var temporaryMarks = new ts.Map(); + var permanentMarks = new ts.Map(); + var circularityReportStack = []; + var buildOrder; + var circularDiagnostics; + for (var _i = 0, roots_1 = roots; _i < roots_1.length; _i++) { + var root = roots_1[_i]; + visit(root); + } + return circularDiagnostics ? + { buildOrder: buildOrder || ts.emptyArray, circularDiagnostics: circularDiagnostics } : + buildOrder || ts.emptyArray; + function visit(configFileName, inCircularContext) { + var projPath = toResolvedConfigFilePath(state, configFileName); + // Already visited + if (permanentMarks.has(projPath)) + return; + // Circular + if (temporaryMarks.has(projPath)) { + if (!inCircularContext) { + (circularDiagnostics || (circularDiagnostics = [])).push(ts.createCompilerDiagnostic(ts.Diagnostics.Project_references_may_not_form_a_circular_graph_Cycle_detected_Colon_0, circularityReportStack.join("\r\n"))); + } + return; + } + temporaryMarks.set(projPath, true); + circularityReportStack.push(configFileName); + var parsed = parseConfigFile(state, configFileName, projPath); + if (parsed && parsed.projectReferences) { + for (var _i = 0, _a = parsed.projectReferences; _i < _a.length; _i++) { + var ref = _a[_i]; + var resolvedRefPath = resolveProjectName(state, ref.path); + visit(resolvedRefPath, inCircularContext || ref.circular); + } + } + circularityReportStack.pop(); + permanentMarks.set(projPath, true); + (buildOrder || (buildOrder = [])).push(configFileName); + } + } + function getBuildOrder(state) { + return state.buildOrder || createStateBuildOrder(state); + } + function createStateBuildOrder(state) { + var buildOrder = createBuildOrder(state, state.rootNames.map(function (f) { return resolveProjectName(state, f); })); + // Clear all to ResolvedConfigFilePaths cache to start fresh + state.resolvedConfigFilePaths.clear(); + // TODO(rbuckton): Should be a `Set`, but that requires changing the code below that uses `mutateMapSkippingNewValues` + var currentProjects = new ts.Map(getBuildOrderFromAnyBuildOrder(buildOrder).map(function (resolved) { return [toResolvedConfigFilePath(state, resolved), true]; })); + var noopOnDelete = { onDeleteValue: ts.noop }; + // Config file cache + ts.mutateMapSkippingNewValues(state.configFileCache, currentProjects, noopOnDelete); + ts.mutateMapSkippingNewValues(state.projectStatus, currentProjects, noopOnDelete); + ts.mutateMapSkippingNewValues(state.builderPrograms, currentProjects, noopOnDelete); + ts.mutateMapSkippingNewValues(state.diagnostics, currentProjects, noopOnDelete); + ts.mutateMapSkippingNewValues(state.projectPendingBuild, currentProjects, noopOnDelete); + ts.mutateMapSkippingNewValues(state.projectErrorsReported, currentProjects, noopOnDelete); + ts.mutateMapSkippingNewValues(state.buildInfoCache, currentProjects, noopOnDelete); + ts.mutateMapSkippingNewValues(state.outputTimeStamps, currentProjects, noopOnDelete); + // Remove watches for the program no longer in the solution + if (state.watch) { + ts.mutateMapSkippingNewValues(state.allWatchedConfigFiles, currentProjects, { onDeleteValue: ts.closeFileWatcher }); + state.allWatchedExtendedConfigFiles.forEach(function (watcher) { + watcher.projects.forEach(function (project) { + if (!currentProjects.has(project)) { + watcher.projects.delete(project); + } + }); + watcher.close(); + }); + ts.mutateMapSkippingNewValues(state.allWatchedWildcardDirectories, currentProjects, { onDeleteValue: function (existingMap) { return existingMap.forEach(ts.closeFileWatcherOf); } }); + ts.mutateMapSkippingNewValues(state.allWatchedInputFiles, currentProjects, { onDeleteValue: function (existingMap) { return existingMap.forEach(ts.closeFileWatcher); } }); + ts.mutateMapSkippingNewValues(state.allWatchedPackageJsonFiles, currentProjects, { onDeleteValue: function (existingMap) { return existingMap.forEach(ts.closeFileWatcher); } }); + } + return state.buildOrder = buildOrder; + } + function getBuildOrderFor(state, project, onlyReferences) { + var resolvedProject = project && resolveProjectName(state, project); + var buildOrderFromState = getBuildOrder(state); + if (isCircularBuildOrder(buildOrderFromState)) + return buildOrderFromState; + if (resolvedProject) { + var projectPath_1 = toResolvedConfigFilePath(state, resolvedProject); + var projectIndex = ts.findIndex(buildOrderFromState, function (configFileName) { return toResolvedConfigFilePath(state, configFileName) === projectPath_1; }); + if (projectIndex === -1) + return undefined; + } + var buildOrder = resolvedProject ? createBuildOrder(state, [resolvedProject]) : buildOrderFromState; + ts.Debug.assert(!isCircularBuildOrder(buildOrder)); + ts.Debug.assert(!onlyReferences || resolvedProject !== undefined); + ts.Debug.assert(!onlyReferences || buildOrder[buildOrder.length - 1] === resolvedProject); + return onlyReferences ? buildOrder.slice(0, buildOrder.length - 1) : buildOrder; + } + function enableCache(state) { + if (state.cache) { + disableCache(state); + } + var compilerHost = state.compilerHost, host = state.host; + var originalReadFileWithCache = state.readFileWithCache; + var originalGetSourceFile = compilerHost.getSourceFile; + var _a = ts.changeCompilerHostLikeToUseCache(host, function (fileName) { return toPath(state, fileName); }, function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + return originalGetSourceFile.call.apply(originalGetSourceFile, __spreadArray([compilerHost], args, false)); + }), originalReadFile = _a.originalReadFile, originalFileExists = _a.originalFileExists, originalDirectoryExists = _a.originalDirectoryExists, originalCreateDirectory = _a.originalCreateDirectory, originalWriteFile = _a.originalWriteFile, getSourceFileWithCache = _a.getSourceFileWithCache, readFileWithCache = _a.readFileWithCache; + state.readFileWithCache = readFileWithCache; + compilerHost.getSourceFile = getSourceFileWithCache; + state.cache = { + originalReadFile: originalReadFile, + originalFileExists: originalFileExists, + originalDirectoryExists: originalDirectoryExists, + originalCreateDirectory: originalCreateDirectory, + originalWriteFile: originalWriteFile, + originalReadFileWithCache: originalReadFileWithCache, + originalGetSourceFile: originalGetSourceFile, + }; + } + function disableCache(state) { + if (!state.cache) + return; + var cache = state.cache, host = state.host, compilerHost = state.compilerHost, extendedConfigCache = state.extendedConfigCache, moduleResolutionCache = state.moduleResolutionCache, typeReferenceDirectiveResolutionCache = state.typeReferenceDirectiveResolutionCache; + host.readFile = cache.originalReadFile; + host.fileExists = cache.originalFileExists; + host.directoryExists = cache.originalDirectoryExists; + host.createDirectory = cache.originalCreateDirectory; + host.writeFile = cache.originalWriteFile; + compilerHost.getSourceFile = cache.originalGetSourceFile; + state.readFileWithCache = cache.originalReadFileWithCache; + extendedConfigCache.clear(); + moduleResolutionCache === null || moduleResolutionCache === void 0 ? void 0 : moduleResolutionCache.clear(); + typeReferenceDirectiveResolutionCache === null || typeReferenceDirectiveResolutionCache === void 0 ? void 0 : typeReferenceDirectiveResolutionCache.clear(); + state.cache = undefined; + } + function clearProjectStatus(state, resolved) { + state.projectStatus.delete(resolved); + state.diagnostics.delete(resolved); + } + function addProjToQueue(_a, proj, reloadLevel) { + var projectPendingBuild = _a.projectPendingBuild; + var value = projectPendingBuild.get(proj); + if (value === undefined) { + projectPendingBuild.set(proj, reloadLevel); + } + else if (value < reloadLevel) { + projectPendingBuild.set(proj, reloadLevel); + } + } + function setupInitialBuild(state, cancellationToken) { + // Set initial build if not already built + if (!state.allProjectBuildPending) + return; + state.allProjectBuildPending = false; + if (state.options.watch) + reportWatchStatus(state, ts.Diagnostics.Starting_compilation_in_watch_mode); + enableCache(state); + var buildOrder = getBuildOrderFromAnyBuildOrder(getBuildOrder(state)); + buildOrder.forEach(function (configFileName) { + return state.projectPendingBuild.set(toResolvedConfigFilePath(state, configFileName), ts.ConfigFileProgramReloadLevel.None); + }); + if (cancellationToken) { + cancellationToken.throwIfCancellationRequested(); + } + } + var InvalidatedProjectKind; + (function (InvalidatedProjectKind) { + InvalidatedProjectKind[InvalidatedProjectKind["Build"] = 0] = "Build"; + InvalidatedProjectKind[InvalidatedProjectKind["UpdateBundle"] = 1] = "UpdateBundle"; + InvalidatedProjectKind[InvalidatedProjectKind["UpdateOutputFileStamps"] = 2] = "UpdateOutputFileStamps"; + })(InvalidatedProjectKind = ts.InvalidatedProjectKind || (ts.InvalidatedProjectKind = {})); + function doneInvalidatedProject(state, projectPath) { + state.projectPendingBuild.delete(projectPath); + return state.diagnostics.has(projectPath) ? + ts.ExitStatus.DiagnosticsPresent_OutputsSkipped : + ts.ExitStatus.Success; + } + function createUpdateOutputFileStampsProject(state, project, projectPath, config, buildOrder) { + var updateOutputFileStampsPending = true; + return { + kind: InvalidatedProjectKind.UpdateOutputFileStamps, + project: project, + projectPath: projectPath, + buildOrder: buildOrder, + getCompilerOptions: function () { return config.options; }, + getCurrentDirectory: function () { return state.currentDirectory; }, + updateOutputFileStatmps: function () { + updateOutputTimestamps(state, config, projectPath); + updateOutputFileStampsPending = false; + }, + done: function () { + if (updateOutputFileStampsPending) { + updateOutputTimestamps(state, config, projectPath); + } + ts.performance.mark("SolutionBuilder::Timestamps only updates"); + return doneInvalidatedProject(state, projectPath); + } + }; + } + var BuildStep; + (function (BuildStep) { + BuildStep[BuildStep["CreateProgram"] = 0] = "CreateProgram"; + BuildStep[BuildStep["SyntaxDiagnostics"] = 1] = "SyntaxDiagnostics"; + BuildStep[BuildStep["SemanticDiagnostics"] = 2] = "SemanticDiagnostics"; + BuildStep[BuildStep["Emit"] = 3] = "Emit"; + BuildStep[BuildStep["EmitBundle"] = 4] = "EmitBundle"; + BuildStep[BuildStep["EmitBuildInfo"] = 5] = "EmitBuildInfo"; + BuildStep[BuildStep["BuildInvalidatedProjectOfBundle"] = 6] = "BuildInvalidatedProjectOfBundle"; + BuildStep[BuildStep["QueueReferencingProjects"] = 7] = "QueueReferencingProjects"; + BuildStep[BuildStep["Done"] = 8] = "Done"; + })(BuildStep || (BuildStep = {})); + function createBuildOrUpdateInvalidedProject(kind, state, project, projectPath, projectIndex, config, buildOrder) { + var step = kind === InvalidatedProjectKind.Build ? BuildStep.CreateProgram : BuildStep.EmitBundle; + var program; + var buildResult; + var invalidatedProjectOfBundle; + return kind === InvalidatedProjectKind.Build ? + { + kind: kind, + project: project, + projectPath: projectPath, + buildOrder: buildOrder, + getCompilerOptions: function () { return config.options; }, + getCurrentDirectory: function () { return state.currentDirectory; }, + getBuilderProgram: function () { return withProgramOrUndefined(ts.identity); }, + getProgram: function () { + return withProgramOrUndefined(function (program) { return program.getProgramOrUndefined(); }); + }, + getSourceFile: function (fileName) { + return withProgramOrUndefined(function (program) { return program.getSourceFile(fileName); }); + }, + getSourceFiles: function () { + return withProgramOrEmptyArray(function (program) { return program.getSourceFiles(); }); + }, + getOptionsDiagnostics: function (cancellationToken) { + return withProgramOrEmptyArray(function (program) { return program.getOptionsDiagnostics(cancellationToken); }); + }, + getGlobalDiagnostics: function (cancellationToken) { + return withProgramOrEmptyArray(function (program) { return program.getGlobalDiagnostics(cancellationToken); }); + }, + getConfigFileParsingDiagnostics: function () { + return withProgramOrEmptyArray(function (program) { return program.getConfigFileParsingDiagnostics(); }); + }, + getSyntacticDiagnostics: function (sourceFile, cancellationToken) { + return withProgramOrEmptyArray(function (program) { return program.getSyntacticDiagnostics(sourceFile, cancellationToken); }); + }, + getAllDependencies: function (sourceFile) { + return withProgramOrEmptyArray(function (program) { return program.getAllDependencies(sourceFile); }); + }, + getSemanticDiagnostics: function (sourceFile, cancellationToken) { + return withProgramOrEmptyArray(function (program) { return program.getSemanticDiagnostics(sourceFile, cancellationToken); }); + }, + getSemanticDiagnosticsOfNextAffectedFile: function (cancellationToken, ignoreSourceFile) { + return withProgramOrUndefined(function (program) { + return (program.getSemanticDiagnosticsOfNextAffectedFile) && + program.getSemanticDiagnosticsOfNextAffectedFile(cancellationToken, ignoreSourceFile); + }); + }, + emit: function (targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) { + if (targetSourceFile || emitOnlyDtsFiles) { + return withProgramOrUndefined(function (program) { var _a, _b; return program.emit(targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers || ((_b = (_a = state.host).getCustomTransformers) === null || _b === void 0 ? void 0 : _b.call(_a, project))); }); + } + executeSteps(BuildStep.SemanticDiagnostics, cancellationToken); + if (step === BuildStep.EmitBuildInfo) { + return emitBuildInfo(writeFile, cancellationToken); + } + if (step !== BuildStep.Emit) + return undefined; + return emit(writeFile, cancellationToken, customTransformers); + }, + done: done + } : + { + kind: kind, + project: project, + projectPath: projectPath, + buildOrder: buildOrder, + getCompilerOptions: function () { return config.options; }, + getCurrentDirectory: function () { return state.currentDirectory; }, + emit: function (writeFile, customTransformers) { + if (step !== BuildStep.EmitBundle) + return invalidatedProjectOfBundle; + return emitBundle(writeFile, customTransformers); + }, + done: done, + }; + function done(cancellationToken, writeFile, customTransformers) { + executeSteps(BuildStep.Done, cancellationToken, writeFile, customTransformers); + if (kind === InvalidatedProjectKind.Build) + ts.performance.mark("SolutionBuilder::Projects built"); + else + ts.performance.mark("SolutionBuilder::Bundles updated"); + return doneInvalidatedProject(state, projectPath); + } + function withProgramOrUndefined(action) { + executeSteps(BuildStep.CreateProgram); + return program && action(program); + } + function withProgramOrEmptyArray(action) { + return withProgramOrUndefined(action) || ts.emptyArray; + } + function createProgram() { + var _a, _b; + ts.Debug.assert(program === undefined); + if (state.options.dry) { + reportStatus(state, ts.Diagnostics.A_non_dry_build_would_build_project_0, project); + buildResult = BuildResultFlags.Success; + step = BuildStep.QueueReferencingProjects; + return; + } + if (state.options.verbose) + reportStatus(state, ts.Diagnostics.Building_project_0, project); + if (config.fileNames.length === 0) { + reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config)); + // Nothing to build - must be a solution file, basically + buildResult = BuildResultFlags.None; + step = BuildStep.QueueReferencingProjects; + return; + } + var host = state.host, compilerHost = state.compilerHost; + state.projectCompilerOptions = config.options; + // Update module resolution cache if needed + (_a = state.moduleResolutionCache) === null || _a === void 0 ? void 0 : _a.update(config.options); + (_b = state.typeReferenceDirectiveResolutionCache) === null || _b === void 0 ? void 0 : _b.update(config.options); + // Create program + program = host.createProgram(config.fileNames, config.options, compilerHost, getOldProgram(state, projectPath, config), ts.getConfigFileParsingDiagnostics(config), config.projectReferences); + if (state.watch) { + state.lastCachedPackageJsonLookups.set(projectPath, state.moduleResolutionCache && ts.map(state.moduleResolutionCache.getPackageJsonInfoCache().entries(), function (_a) { + var path = _a[0], data = _a[1]; + return [state.host.realpath && data ? toPath(state, state.host.realpath(path)) : path, data]; + })); + state.builderPrograms.set(projectPath, program); + } + step++; + } + function handleDiagnostics(diagnostics, errorFlags, errorType) { + var _a; + if (diagnostics.length) { + (_a = buildErrors(state, projectPath, program, config, diagnostics, errorFlags, errorType), buildResult = _a.buildResult, step = _a.step); + } + else { + step++; + } + } + function getSyntaxDiagnostics(cancellationToken) { + ts.Debug.assertIsDefined(program); + handleDiagnostics(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], program.getConfigFileParsingDiagnostics(), true), program.getOptionsDiagnostics(cancellationToken), true), program.getGlobalDiagnostics(cancellationToken), true), program.getSyntacticDiagnostics(/*sourceFile*/ undefined, cancellationToken), true), BuildResultFlags.SyntaxErrors, "Syntactic"); + } + function getSemanticDiagnostics(cancellationToken) { + handleDiagnostics(ts.Debug.checkDefined(program).getSemanticDiagnostics(/*sourceFile*/ undefined, cancellationToken), BuildResultFlags.TypeErrors, "Semantic"); + } + function emit(writeFileCallback, cancellationToken, customTransformers) { + var _a; + var _b, _c, _d; + ts.Debug.assertIsDefined(program); + ts.Debug.assert(step === BuildStep.Emit); + // Before emitting lets backup state, so we can revert it back if there are declaration errors to handle emit and declaration errors correctly + var saved = program.saveEmitState(); + var declDiagnostics; + var reportDeclarationDiagnostics = function (d) { return (declDiagnostics || (declDiagnostics = [])).push(d); }; + var outputFiles = []; + var emitResult = ts.emitFilesAndReportErrors(program, reportDeclarationDiagnostics, + /*write*/ undefined, + /*reportSummary*/ undefined, function (name, text, writeByteOrderMark, _onError, _sourceFiles, data) { return outputFiles.push({ name: name, text: text, writeByteOrderMark: writeByteOrderMark, buildInfo: data === null || data === void 0 ? void 0 : data.buildInfo }); }, cancellationToken, + /*emitOnlyDts*/ false, customTransformers || ((_c = (_b = state.host).getCustomTransformers) === null || _c === void 0 ? void 0 : _c.call(_b, project))).emitResult; + // Don't emit .d.ts if there are decl file errors + if (declDiagnostics) { + program.restoreEmitState(saved); + (_a = buildErrors(state, projectPath, program, config, declDiagnostics, BuildResultFlags.DeclarationEmitErrors, "Declaration file"), buildResult = _a.buildResult, step = _a.step); + return { + emitSkipped: true, + diagnostics: emitResult.diagnostics + }; + } + // Actual Emit + var host = state.host, compilerHost = state.compilerHost; + var resultFlags = ((_d = program.hasChangedEmitSignature) === null || _d === void 0 ? void 0 : _d.call(program)) ? BuildResultFlags.None : BuildResultFlags.DeclarationOutputUnchanged; + var emitterDiagnostics = ts.createDiagnosticCollection(); + var emittedOutputs = new ts.Map(); + var options = program.getCompilerOptions(); + var isIncremental = ts.isIncrementalCompilation(options); + var outputTimeStampMap; + var now; + outputFiles.forEach(function (_a) { + var name = _a.name, text = _a.text, writeByteOrderMark = _a.writeByteOrderMark, buildInfo = _a.buildInfo; + var path = toPath(state, name); + emittedOutputs.set(toPath(state, name), name); + if (buildInfo) + setBuildInfo(state, buildInfo, projectPath, options, resultFlags); + ts.writeFile(writeFileCallback ? { writeFile: writeFileCallback } : compilerHost, emitterDiagnostics, name, text, writeByteOrderMark); + if (!isIncremental && state.watch) { + (outputTimeStampMap || (outputTimeStampMap = getOutputTimeStampMap(state, projectPath))).set(path, now || (now = getCurrentTime(state.host))); + } + }); + finishEmit(emitterDiagnostics, emittedOutputs, outputFiles.length ? outputFiles[0].name : ts.getFirstProjectOutput(config, !host.useCaseSensitiveFileNames()), resultFlags); + return emitResult; + } + function emitBuildInfo(writeFileCallback, cancellationToken) { + ts.Debug.assertIsDefined(program); + ts.Debug.assert(step === BuildStep.EmitBuildInfo); + var emitResult = program.emitBuildInfo(function (name, text, writeByteOrderMark, onError, sourceFiles, data) { + if (data === null || data === void 0 ? void 0 : data.buildInfo) + setBuildInfo(state, data.buildInfo, projectPath, program.getCompilerOptions(), BuildResultFlags.DeclarationOutputUnchanged); + if (writeFileCallback) + writeFileCallback(name, text, writeByteOrderMark, onError, sourceFiles, data); + else + state.compilerHost.writeFile(name, text, writeByteOrderMark, onError, sourceFiles, data); + }, cancellationToken); + if (emitResult.diagnostics.length) { + reportErrors(state, emitResult.diagnostics); + state.diagnostics.set(projectPath, __spreadArray(__spreadArray([], state.diagnostics.get(projectPath), true), emitResult.diagnostics, true)); + buildResult = BuildResultFlags.EmitErrors & buildResult; + } + if (emitResult.emittedFiles && state.write) { + emitResult.emittedFiles.forEach(function (name) { return listEmittedFile(state, config, name); }); + } + afterProgramDone(state, program, config); + step = BuildStep.QueueReferencingProjects; + return emitResult; + } + function finishEmit(emitterDiagnostics, emittedOutputs, oldestOutputFileName, resultFlags) { + var _a; + var emitDiagnostics = emitterDiagnostics.getDiagnostics(); + if (emitDiagnostics.length) { + (_a = buildErrors(state, projectPath, program, config, emitDiagnostics, BuildResultFlags.EmitErrors, "Emit"), buildResult = _a.buildResult, step = _a.step); + return emitDiagnostics; + } + if (state.write) { + emittedOutputs.forEach(function (name) { return listEmittedFile(state, config, name); }); + } + // Update time stamps for rest of the outputs + updateOutputTimestampsWorker(state, config, projectPath, ts.Diagnostics.Updating_unchanged_output_timestamps_of_project_0, emittedOutputs); + state.diagnostics.delete(projectPath); + state.projectStatus.set(projectPath, { + type: ts.UpToDateStatusType.UpToDate, + oldestOutputFileName: oldestOutputFileName + }); + afterProgramDone(state, program, config); + step = BuildStep.QueueReferencingProjects; + buildResult = resultFlags; + return emitDiagnostics; + } + function emitBundle(writeFileCallback, customTransformers) { + var _a, _b; + ts.Debug.assert(kind === InvalidatedProjectKind.UpdateBundle); + if (state.options.dry) { + reportStatus(state, ts.Diagnostics.A_non_dry_build_would_update_output_of_project_0, project); + buildResult = BuildResultFlags.Success; + step = BuildStep.QueueReferencingProjects; + return undefined; + } + if (state.options.verbose) + reportStatus(state, ts.Diagnostics.Updating_output_of_project_0, project); + // Update js, and source map + var compilerHost = state.compilerHost; + state.projectCompilerOptions = config.options; + var outputFiles = ts.emitUsingBuildInfo(config, compilerHost, function (ref) { + var refName = resolveProjectName(state, ref.path); + return parseConfigFile(state, refName, toResolvedConfigFilePath(state, refName)); + }, customTransformers || ((_b = (_a = state.host).getCustomTransformers) === null || _b === void 0 ? void 0 : _b.call(_a, project))); + if (ts.isString(outputFiles)) { + reportStatus(state, ts.Diagnostics.Cannot_update_output_of_project_0_because_there_was_error_reading_file_1, project, relName(state, outputFiles)); + step = BuildStep.BuildInvalidatedProjectOfBundle; + return invalidatedProjectOfBundle = createBuildOrUpdateInvalidedProject(InvalidatedProjectKind.Build, state, project, projectPath, projectIndex, config, buildOrder); + } + // Actual Emit + ts.Debug.assert(!!outputFiles.length); + var emitterDiagnostics = ts.createDiagnosticCollection(); + var emittedOutputs = new ts.Map(); + var resultFlags = BuildResultFlags.DeclarationOutputUnchanged; + var existingBuildInfo = state.buildInfoCache.get(projectPath).buildInfo || undefined; + outputFiles.forEach(function (_a) { + var _b, _c; + var name = _a.name, text = _a.text, writeByteOrderMark = _a.writeByteOrderMark, buildInfo = _a.buildInfo; + emittedOutputs.set(toPath(state, name), name); + if (buildInfo) { + if (((_b = buildInfo.program) === null || _b === void 0 ? void 0 : _b.outSignature) !== ((_c = existingBuildInfo === null || existingBuildInfo === void 0 ? void 0 : existingBuildInfo.program) === null || _c === void 0 ? void 0 : _c.outSignature)) { + resultFlags &= ~BuildResultFlags.DeclarationOutputUnchanged; + } + setBuildInfo(state, buildInfo, projectPath, config.options, resultFlags); + } + ts.writeFile(writeFileCallback ? { writeFile: writeFileCallback } : compilerHost, emitterDiagnostics, name, text, writeByteOrderMark); + }); + var emitDiagnostics = finishEmit(emitterDiagnostics, emittedOutputs, outputFiles[0].name, resultFlags); + return { emitSkipped: false, diagnostics: emitDiagnostics }; + } + function executeSteps(till, cancellationToken, writeFile, customTransformers) { + while (step <= till && step < BuildStep.Done) { + var currentStep = step; + switch (step) { + case BuildStep.CreateProgram: + createProgram(); + break; + case BuildStep.SyntaxDiagnostics: + getSyntaxDiagnostics(cancellationToken); + break; + case BuildStep.SemanticDiagnostics: + getSemanticDiagnostics(cancellationToken); + break; + case BuildStep.Emit: + emit(writeFile, cancellationToken, customTransformers); + break; + case BuildStep.EmitBuildInfo: + emitBuildInfo(writeFile, cancellationToken); + break; + case BuildStep.EmitBundle: + emitBundle(writeFile, customTransformers); + break; + case BuildStep.BuildInvalidatedProjectOfBundle: + ts.Debug.checkDefined(invalidatedProjectOfBundle).done(cancellationToken, writeFile, customTransformers); + step = BuildStep.Done; + break; + case BuildStep.QueueReferencingProjects: + queueReferencingProjects(state, project, projectPath, projectIndex, config, buildOrder, ts.Debug.checkDefined(buildResult)); + step++; + break; + // Should never be done + case BuildStep.Done: + default: + ts.assertType(step); + } + ts.Debug.assert(step > currentStep); + } + } + } + function needsBuild(_a, status, config) { + var options = _a.options; + if (status.type !== ts.UpToDateStatusType.OutOfDateWithPrepend || options.force) + return true; + return config.fileNames.length === 0 || + !!ts.getConfigFileParsingDiagnostics(config).length || + !ts.isIncrementalCompilation(config.options); + } + function getNextInvalidatedProjectCreateInfo(state, buildOrder, reportQueue) { + if (!state.projectPendingBuild.size) + return undefined; + if (isCircularBuildOrder(buildOrder)) + return undefined; + var options = state.options, projectPendingBuild = state.projectPendingBuild; + for (var projectIndex = 0; projectIndex < buildOrder.length; projectIndex++) { + var project = buildOrder[projectIndex]; + var projectPath = toResolvedConfigFilePath(state, project); + var reloadLevel = state.projectPendingBuild.get(projectPath); + if (reloadLevel === undefined) + continue; + if (reportQueue) { + reportQueue = false; + reportBuildQueue(state, buildOrder); + } + var config = parseConfigFile(state, project, projectPath); + if (!config) { + reportParseConfigFileDiagnostic(state, projectPath); + projectPendingBuild.delete(projectPath); + continue; + } + if (reloadLevel === ts.ConfigFileProgramReloadLevel.Full) { + watchConfigFile(state, project, projectPath, config); + watchExtendedConfigFiles(state, projectPath, config); + watchWildCardDirectories(state, project, projectPath, config); + watchInputFiles(state, project, projectPath, config); + watchPackageJsonFiles(state, project, projectPath, config); + } + else if (reloadLevel === ts.ConfigFileProgramReloadLevel.Partial) { + // Update file names + config.fileNames = ts.getFileNamesFromConfigSpecs(config.options.configFile.configFileSpecs, ts.getDirectoryPath(project), config.options, state.parseConfigFileHost); + ts.updateErrorForNoInputFiles(config.fileNames, project, config.options.configFile.configFileSpecs, config.errors, ts.canJsonReportNoInputFiles(config.raw)); + watchInputFiles(state, project, projectPath, config); + watchPackageJsonFiles(state, project, projectPath, config); + } + var status = getUpToDateStatus(state, config, projectPath); + if (!options.force) { + if (status.type === ts.UpToDateStatusType.UpToDate) { + verboseReportProjectStatus(state, project, status); + reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config)); + projectPendingBuild.delete(projectPath); + // Up to date, skip + if (options.dry) { + // In a dry build, inform the user of this fact + reportStatus(state, ts.Diagnostics.Project_0_is_up_to_date, project); + } + continue; + } + if (status.type === ts.UpToDateStatusType.UpToDateWithUpstreamTypes || status.type === ts.UpToDateStatusType.UpToDateWithInputFileText) { + reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config)); + return { + kind: InvalidatedProjectKind.UpdateOutputFileStamps, + status: status, + project: project, + projectPath: projectPath, + projectIndex: projectIndex, + config: config + }; + } + } + if (status.type === ts.UpToDateStatusType.UpstreamBlocked) { + verboseReportProjectStatus(state, project, status); + reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config)); + projectPendingBuild.delete(projectPath); + if (options.verbose) { + reportStatus(state, status.upstreamProjectBlocked ? + ts.Diagnostics.Skipping_build_of_project_0_because_its_dependency_1_was_not_built : + ts.Diagnostics.Skipping_build_of_project_0_because_its_dependency_1_has_errors, project, status.upstreamProjectName); + } + continue; + } + if (status.type === ts.UpToDateStatusType.ContainerOnly) { + verboseReportProjectStatus(state, project, status); + reportAndStoreErrors(state, projectPath, ts.getConfigFileParsingDiagnostics(config)); + projectPendingBuild.delete(projectPath); + // Do nothing + continue; + } + return { + kind: needsBuild(state, status, config) ? + InvalidatedProjectKind.Build : + InvalidatedProjectKind.UpdateBundle, + status: status, + project: project, + projectPath: projectPath, + projectIndex: projectIndex, + config: config, + }; + } + return undefined; + } + function createInvalidatedProjectWithInfo(state, info, buildOrder) { + verboseReportProjectStatus(state, info.project, info.status); + return info.kind !== InvalidatedProjectKind.UpdateOutputFileStamps ? + createBuildOrUpdateInvalidedProject(info.kind, state, info.project, info.projectPath, info.projectIndex, info.config, buildOrder) : + createUpdateOutputFileStampsProject(state, info.project, info.projectPath, info.config, buildOrder); + } + function getNextInvalidatedProject(state, buildOrder, reportQueue) { + var info = getNextInvalidatedProjectCreateInfo(state, buildOrder, reportQueue); + if (!info) + return info; + return createInvalidatedProjectWithInfo(state, info, buildOrder); + } + function listEmittedFile(_a, proj, file) { + var write = _a.write; + if (write && proj.options.listEmittedFiles) { + write("TSFILE: ".concat(file)); + } + } + function getOldProgram(_a, proj, parsed) { + var options = _a.options, builderPrograms = _a.builderPrograms, compilerHost = _a.compilerHost; + if (options.force) + return undefined; + var value = builderPrograms.get(proj); + if (value) + return value; + return ts.readBuilderProgram(parsed.options, compilerHost); + } + function afterProgramDone(state, program, config) { + if (program) { + if (state.write) + ts.listFiles(program, state.write); + if (state.host.afterProgramEmitAndDiagnostics) { + state.host.afterProgramEmitAndDiagnostics(program); + } + program.releaseProgram(); + } + else if (state.host.afterEmitBundle) { + state.host.afterEmitBundle(config); + } + state.projectCompilerOptions = state.baseCompilerOptions; + } + function buildErrors(state, resolvedPath, program, config, diagnostics, buildResult, errorType) { + // Since buildinfo has changeset and diagnostics when doing multi file emit, only --out cannot emit buildinfo if it has errors + var canEmitBuildInfo = program && !ts.outFile(program.getCompilerOptions()); + reportAndStoreErrors(state, resolvedPath, diagnostics); + state.projectStatus.set(resolvedPath, { type: ts.UpToDateStatusType.Unbuildable, reason: "".concat(errorType, " errors") }); + if (canEmitBuildInfo) + return { buildResult: buildResult, step: BuildStep.EmitBuildInfo }; + afterProgramDone(state, program, config); + return { buildResult: buildResult, step: BuildStep.QueueReferencingProjects }; + } + function isFileWatcherWithModifiedTime(value) { + return !!value.watcher; + } + function getModifiedTime(state, fileName) { + var path = toPath(state, fileName); + var existing = state.filesWatched.get(path); + if (state.watch && !!existing) { + if (!isFileWatcherWithModifiedTime(existing)) + return existing; + if (existing.modifiedTime) + return existing.modifiedTime; + } + // In watch mode we store the modified times in the cache + // This is either Date | FileWatcherWithModifiedTime because we query modified times first and + // then after complete compilation of the project, watch the files so we dont want to loose these modified times. + var result = ts.getModifiedTime(state.host, fileName); + if (state.watch) { + if (existing) + existing.modifiedTime = result; + else + state.filesWatched.set(path, result); + } + return result; + } + function watchFile(state, file, callback, pollingInterval, options, watchType, project) { + var path = toPath(state, file); + var existing = state.filesWatched.get(path); + if (existing && isFileWatcherWithModifiedTime(existing)) { + existing.callbacks.push(callback); + } + else { + var watcher = state.watchFile(file, function (fileName, eventKind, modifiedTime) { + var existing = ts.Debug.checkDefined(state.filesWatched.get(path)); + ts.Debug.assert(isFileWatcherWithModifiedTime(existing)); + existing.modifiedTime = modifiedTime; + existing.callbacks.forEach(function (cb) { return cb(fileName, eventKind, modifiedTime); }); + }, pollingInterval, options, watchType, project); + state.filesWatched.set(path, { callbacks: [callback], watcher: watcher, modifiedTime: existing }); + } + return { + close: function () { + var existing = ts.Debug.checkDefined(state.filesWatched.get(path)); + ts.Debug.assert(isFileWatcherWithModifiedTime(existing)); + if (existing.callbacks.length === 1) { + state.filesWatched.delete(path); + ts.closeFileWatcherOf(existing); + } + else { + ts.unorderedRemoveItem(existing.callbacks, callback); + } + } + }; + } + function getOutputTimeStampMap(state, resolvedConfigFilePath) { + // Output timestamps are stored only in watch mode + if (!state.watch) + return undefined; + var result = state.outputTimeStamps.get(resolvedConfigFilePath); + if (!result) + state.outputTimeStamps.set(resolvedConfigFilePath, result = new ts.Map()); + return result; + } + function setBuildInfo(state, buildInfo, resolvedConfigPath, options, resultFlags) { + var buildInfoPath = ts.getTsBuildInfoEmitOutputFilePath(options); + var existing = getBuildInfoCacheEntry(state, buildInfoPath, resolvedConfigPath); + var modifiedTime = getCurrentTime(state.host); + if (existing) { + existing.buildInfo = buildInfo; + existing.modifiedTime = modifiedTime; + if (!(resultFlags & BuildResultFlags.DeclarationOutputUnchanged)) + existing.latestChangedDtsTime = modifiedTime; + } + else { + state.buildInfoCache.set(resolvedConfigPath, { + path: toPath(state, buildInfoPath), + buildInfo: buildInfo, + modifiedTime: modifiedTime, + latestChangedDtsTime: resultFlags & BuildResultFlags.DeclarationOutputUnchanged ? undefined : modifiedTime, + }); + } + } + function getBuildInfoCacheEntry(state, buildInfoPath, resolvedConfigPath) { + var path = toPath(state, buildInfoPath); + var existing = state.buildInfoCache.get(resolvedConfigPath); + return (existing === null || existing === void 0 ? void 0 : existing.path) === path ? existing : undefined; + } + function getBuildInfo(state, buildInfoPath, resolvedConfigPath, modifiedTime) { + var path = toPath(state, buildInfoPath); + var existing = state.buildInfoCache.get(resolvedConfigPath); + if (existing !== undefined && existing.path === path) { + return existing.buildInfo || undefined; + } + var value = state.readFileWithCache(buildInfoPath); + var buildInfo = value ? ts.getBuildInfo(buildInfoPath, value) : undefined; + state.buildInfoCache.set(resolvedConfigPath, { path: path, buildInfo: buildInfo || false, modifiedTime: modifiedTime || ts.missingFileModifiedTime }); + return buildInfo; + } + function checkConfigFileUpToDateStatus(state, configFile, oldestOutputFileTime, oldestOutputFileName) { + // Check tsconfig time + var tsconfigTime = getModifiedTime(state, configFile); + if (oldestOutputFileTime < tsconfigTime) { + return { + type: ts.UpToDateStatusType.OutOfDateWithSelf, + outOfDateOutputFileName: oldestOutputFileName, + newerInputFileName: configFile + }; + } + } + function getUpToDateStatusWorker(state, project, resolvedPath) { + var _a, _b; + // Container if no files are specified in the project + if (!project.fileNames.length && !ts.canJsonReportNoInputFiles(project.raw)) { + return { + type: ts.UpToDateStatusType.ContainerOnly + }; + } + // Fast check to see if reference projects are upto date and error free + var referenceStatuses; + var force = !!state.options.force; + if (project.projectReferences) { + state.projectStatus.set(resolvedPath, { type: ts.UpToDateStatusType.ComputingUpstream }); + for (var _i = 0, _c = project.projectReferences; _i < _c.length; _i++) { + var ref = _c[_i]; + var resolvedRef = ts.resolveProjectReferencePath(ref); + var resolvedRefPath = toResolvedConfigFilePath(state, resolvedRef); + var resolvedConfig = parseConfigFile(state, resolvedRef, resolvedRefPath); + var refStatus = getUpToDateStatus(state, resolvedConfig, resolvedRefPath); + // Its a circular reference ignore the status of this project + if (refStatus.type === ts.UpToDateStatusType.ComputingUpstream || + refStatus.type === ts.UpToDateStatusType.ContainerOnly) { // Container only ignore this project + continue; + } + // An upstream project is blocked + if (refStatus.type === ts.UpToDateStatusType.Unbuildable || + refStatus.type === ts.UpToDateStatusType.UpstreamBlocked) { + return { + type: ts.UpToDateStatusType.UpstreamBlocked, + upstreamProjectName: ref.path, + upstreamProjectBlocked: refStatus.type === ts.UpToDateStatusType.UpstreamBlocked + }; + } + // If the upstream project is out of date, then so are we (someone shouldn't have asked, though?) + if (refStatus.type !== ts.UpToDateStatusType.UpToDate) { + return { + type: ts.UpToDateStatusType.UpstreamOutOfDate, + upstreamProjectName: ref.path + }; + } + if (!force) + (referenceStatuses || (referenceStatuses = [])).push({ ref: ref, refStatus: refStatus, resolvedRefPath: resolvedRefPath, resolvedConfig: resolvedConfig }); + } + } + if (force) + return { type: ts.UpToDateStatusType.ForceBuild }; + // Check buildinfo first + var host = state.host; + var buildInfoPath = ts.getTsBuildInfoEmitOutputFilePath(project.options); + var oldestOutputFileName; + var oldestOutputFileTime = maximumDate; + var buildInfoTime; + var buildInfoProgram; + var buildInfoVersionMap; + if (buildInfoPath) { + var buildInfoCacheEntry_1 = getBuildInfoCacheEntry(state, buildInfoPath, resolvedPath); + buildInfoTime = (buildInfoCacheEntry_1 === null || buildInfoCacheEntry_1 === void 0 ? void 0 : buildInfoCacheEntry_1.modifiedTime) || ts.getModifiedTime(host, buildInfoPath); + if (buildInfoTime === ts.missingFileModifiedTime) { + if (!buildInfoCacheEntry_1) { + state.buildInfoCache.set(resolvedPath, { + path: toPath(state, buildInfoPath), + buildInfo: false, + modifiedTime: buildInfoTime + }); + } + return { + type: ts.UpToDateStatusType.OutputMissing, + missingOutputFileName: buildInfoPath + }; + } + var buildInfo = getBuildInfo(state, buildInfoPath, resolvedPath, buildInfoTime); + if (!buildInfo) { + // Error reading buildInfo + return { + type: ts.UpToDateStatusType.ErrorReadingFile, + fileName: buildInfoPath + }; + } + if ((buildInfo.bundle || buildInfo.program) && buildInfo.version !== ts.version) { + return { + type: ts.UpToDateStatusType.TsVersionOutputOfDate, + version: buildInfo.version + }; + } + if (buildInfo.program) { + // If there are pending changes that are not emitted, project is out of date + // When there are syntax errors, changeFileSet will have list of files changed (irrespective of noEmit) + // But in case of semantic error we need special treatment. + // Checking presence of affectedFilesPendingEmit list is fast and good way to tell if there were semantic errors and file emit was blocked + // But if noEmit is true, affectedFilesPendingEmit will have file list even if there are no semantic errors to preserve list of files to be emitted when running with noEmit false + // So with noEmit set to true, check on semantic diagnostics needs to be explicit as oppose to when it is false when only files pending emit is sufficient + if (((_a = buildInfo.program.changeFileSet) === null || _a === void 0 ? void 0 : _a.length) || + (!project.options.noEmit ? + (_b = buildInfo.program.affectedFilesPendingEmit) === null || _b === void 0 ? void 0 : _b.length : + ts.some(buildInfo.program.semanticDiagnosticsPerFile, ts.isArray))) { + return { + type: ts.UpToDateStatusType.OutOfDateBuildInfo, + buildInfoFile: buildInfoPath + }; + } + buildInfoProgram = buildInfo.program; + } + oldestOutputFileTime = buildInfoTime; + oldestOutputFileName = buildInfoPath; + } + // Check input files + var newestInputFileName = undefined; + var newestInputFileTime = minimumDate; + /** True if input file has changed timestamp but text is not changed, we can then do only timestamp updates on output to make it look up-to-date later */ + var pseudoInputUpToDate = false; + // Get timestamps of input files + for (var _d = 0, _e = project.fileNames; _d < _e.length; _d++) { + var inputFile = _e[_d]; + var inputTime = getModifiedTime(state, inputFile); + if (inputTime === ts.missingFileModifiedTime) { + return { + type: ts.UpToDateStatusType.Unbuildable, + reason: "".concat(inputFile, " does not exist") + }; + } + // If an buildInfo is older than the newest input, we can stop checking + if (buildInfoTime && buildInfoTime < inputTime) { + var version_3 = void 0; + var currentVersion = void 0; + if (buildInfoProgram) { + // Read files and see if they are same, read is anyways cached + if (!buildInfoVersionMap) + buildInfoVersionMap = ts.getBuildInfoFileVersionMap(buildInfoProgram, buildInfoPath, host); + version_3 = buildInfoVersionMap.get(toPath(state, inputFile)); + var text = version_3 ? state.readFileWithCache(inputFile) : undefined; + currentVersion = text && (host.createHash || ts.generateDjb2Hash)(text); + if (version_3 && version_3 === currentVersion) + pseudoInputUpToDate = true; + } + if (!version_3 || version_3 !== currentVersion) { + return { + type: ts.UpToDateStatusType.OutOfDateWithSelf, + outOfDateOutputFileName: buildInfoPath, + newerInputFileName: inputFile + }; + } + } + if (inputTime > newestInputFileTime) { + newestInputFileName = inputFile; + newestInputFileTime = inputTime; + } + } + // Now see if all outputs are newer than the newest input + // Dont check output timestamps if we have buildinfo telling us output is uptodate + if (!buildInfoPath) { + // Collect the expected outputs of this project + var outputs = ts.getAllProjectOutputs(project, !host.useCaseSensitiveFileNames()); + var outputTimeStampMap = getOutputTimeStampMap(state, resolvedPath); + for (var _f = 0, outputs_1 = outputs; _f < outputs_1.length; _f++) { + var output = outputs_1[_f]; + var path = toPath(state, output); + // Output is missing; can stop checking + var outputTime = outputTimeStampMap === null || outputTimeStampMap === void 0 ? void 0 : outputTimeStampMap.get(path); + if (!outputTime) { + outputTime = ts.getModifiedTime(state.host, output); + outputTimeStampMap === null || outputTimeStampMap === void 0 ? void 0 : outputTimeStampMap.set(path, outputTime); + } + if (outputTime === ts.missingFileModifiedTime) { + return { + type: ts.UpToDateStatusType.OutputMissing, + missingOutputFileName: output + }; + } + // If an output is older than the newest input, we can stop checking + if (outputTime < newestInputFileTime) { + return { + type: ts.UpToDateStatusType.OutOfDateWithSelf, + outOfDateOutputFileName: output, + newerInputFileName: newestInputFileName + }; + } + // No need to get newestDeclarationFileContentChangedTime since thats needed only for composite projects + // And composite projects are the only ones that can be referenced + if (outputTime < oldestOutputFileTime) { + oldestOutputFileTime = outputTime; + oldestOutputFileName = output; + } + } + } + var buildInfoCacheEntry = state.buildInfoCache.get(resolvedPath); + /** Inputs are up-to-date, just need either timestamp update or bundle prepend manipulation to make it look up-to-date */ + var pseudoUpToDate = false; + var usesPrepend = false; + var upstreamChangedProject; + if (referenceStatuses) { + for (var _g = 0, referenceStatuses_1 = referenceStatuses; _g < referenceStatuses_1.length; _g++) { + var _h = referenceStatuses_1[_g], ref = _h.ref, refStatus = _h.refStatus, resolvedConfig = _h.resolvedConfig, resolvedRefPath = _h.resolvedRefPath; + usesPrepend = usesPrepend || !!(ref.prepend); + // If the upstream project's newest file is older than our oldest output, we + // can't be out of date because of it + if (refStatus.newestInputFileTime && refStatus.newestInputFileTime <= oldestOutputFileTime) { + continue; + } + // Check if tsbuildinfo path is shared, then we need to rebuild + if (buildInfoCacheEntry && hasSameBuildInfo(state, buildInfoCacheEntry, resolvedRefPath)) { + return { + type: ts.UpToDateStatusType.OutOfDateWithUpstream, + outOfDateOutputFileName: buildInfoPath, + newerProjectName: ref.path + }; + } + // If the upstream project has only change .d.ts files, and we've built + // *after* those files, then we're "psuedo up to date" and eligible for a fast rebuild + var newestDeclarationFileContentChangedTime = getLatestChangedDtsTime(state, resolvedConfig.options, resolvedRefPath); + if (newestDeclarationFileContentChangedTime && newestDeclarationFileContentChangedTime <= oldestOutputFileTime) { + pseudoUpToDate = true; + upstreamChangedProject = ref.path; + continue; + } + // We have an output older than an upstream output - we are out of date + ts.Debug.assert(oldestOutputFileName !== undefined, "Should have an oldest output filename here"); + return { + type: ts.UpToDateStatusType.OutOfDateWithUpstream, + outOfDateOutputFileName: oldestOutputFileName, + newerProjectName: ref.path + }; + } + } + // Check tsconfig time + var configStatus = checkConfigFileUpToDateStatus(state, project.options.configFilePath, oldestOutputFileTime, oldestOutputFileName); + if (configStatus) + return configStatus; + // Check extended config time + var extendedConfigStatus = ts.forEach(project.options.configFile.extendedSourceFiles || ts.emptyArray, function (configFile) { return checkConfigFileUpToDateStatus(state, configFile, oldestOutputFileTime, oldestOutputFileName); }); + if (extendedConfigStatus) + return extendedConfigStatus; + // Check package file time + var dependentPackageFileStatus = ts.forEach(state.lastCachedPackageJsonLookups.get(resolvedPath) || ts.emptyArray, function (_a) { + var path = _a[0]; + return checkConfigFileUpToDateStatus(state, path, oldestOutputFileTime, oldestOutputFileName); + }); + if (dependentPackageFileStatus) + return dependentPackageFileStatus; + if (usesPrepend && pseudoUpToDate) { + return { + type: ts.UpToDateStatusType.OutOfDateWithPrepend, + outOfDateOutputFileName: oldestOutputFileName, + newerProjectName: upstreamChangedProject + }; + } + // Up to date + return { + type: pseudoUpToDate ? + ts.UpToDateStatusType.UpToDateWithUpstreamTypes : + pseudoInputUpToDate ? + ts.UpToDateStatusType.UpToDateWithInputFileText : + ts.UpToDateStatusType.UpToDate, + newestInputFileTime: newestInputFileTime, + newestInputFileName: newestInputFileName, + oldestOutputFileName: oldestOutputFileName + }; + } + function hasSameBuildInfo(state, buildInfoCacheEntry, resolvedRefPath) { + var refBuildInfo = state.buildInfoCache.get(resolvedRefPath); + return refBuildInfo.path === buildInfoCacheEntry.path; + } + function getUpToDateStatus(state, project, resolvedPath) { + if (project === undefined) { + return { type: ts.UpToDateStatusType.Unbuildable, reason: "File deleted mid-build" }; + } + var prior = state.projectStatus.get(resolvedPath); + if (prior !== undefined) { + return prior; + } + ts.performance.mark("SolutionBuilder::beforeUpToDateCheck"); + var actual = getUpToDateStatusWorker(state, project, resolvedPath); + ts.performance.mark("SolutionBuilder::afterUpToDateCheck"); + ts.performance.measure("SolutionBuilder::Up-to-date check", "SolutionBuilder::beforeUpToDateCheck", "SolutionBuilder::afterUpToDateCheck"); + state.projectStatus.set(resolvedPath, actual); + return actual; + } + function updateOutputTimestampsWorker(state, proj, projectPath, verboseMessage, skipOutputs) { + if (proj.options.noEmit) + return; + var now; + var buildInfoPath = ts.getTsBuildInfoEmitOutputFilePath(proj.options); + if (buildInfoPath) { + // For incremental projects, only buildinfo needs to be upto date with timestamp check + // as we dont check output files for up-to-date ness + if (!(skipOutputs === null || skipOutputs === void 0 ? void 0 : skipOutputs.has(toPath(state, buildInfoPath)))) { + if (!!state.options.verbose) + reportStatus(state, verboseMessage, proj.options.configFilePath); + state.host.setModifiedTime(buildInfoPath, now = getCurrentTime(state.host)); + getBuildInfoCacheEntry(state, buildInfoPath, projectPath).modifiedTime = now; + } + state.outputTimeStamps.delete(projectPath); + return; + } + var host = state.host; + var outputs = ts.getAllProjectOutputs(proj, !host.useCaseSensitiveFileNames()); + var outputTimeStampMap = getOutputTimeStampMap(state, projectPath); + var modifiedOutputs = outputTimeStampMap ? new ts.Set() : undefined; + if (!skipOutputs || outputs.length !== skipOutputs.size) { + var reportVerbose = !!state.options.verbose; + for (var _i = 0, outputs_2 = outputs; _i < outputs_2.length; _i++) { + var file = outputs_2[_i]; + var path = toPath(state, file); + if (skipOutputs === null || skipOutputs === void 0 ? void 0 : skipOutputs.has(path)) + continue; + if (reportVerbose) { + reportVerbose = false; + reportStatus(state, verboseMessage, proj.options.configFilePath); + } + host.setModifiedTime(file, now || (now = getCurrentTime(state.host))); + // Store output timestamps in a map because non incremental build will need to check them to determine up-to-dateness + if (outputTimeStampMap) { + outputTimeStampMap.set(path, now); + modifiedOutputs.add(path); + } + } + } + // Clear out timestamps not in output list any more + outputTimeStampMap === null || outputTimeStampMap === void 0 ? void 0 : outputTimeStampMap.forEach(function (_value, key) { + if (!(skipOutputs === null || skipOutputs === void 0 ? void 0 : skipOutputs.has(key)) && !modifiedOutputs.has(key)) + outputTimeStampMap.delete(key); + }); + } + function getLatestChangedDtsTime(state, options, resolvedConfigPath) { + if (!options.composite) + return undefined; + var entry = ts.Debug.checkDefined(state.buildInfoCache.get(resolvedConfigPath)); + if (entry.latestChangedDtsTime !== undefined) + return entry.latestChangedDtsTime || undefined; + var latestChangedDtsTime = entry.buildInfo && entry.buildInfo.program && entry.buildInfo.program.latestChangedDtsFile ? + state.host.getModifiedTime(ts.getNormalizedAbsolutePath(entry.buildInfo.program.latestChangedDtsFile, ts.getDirectoryPath(entry.path))) : + undefined; + entry.latestChangedDtsTime = latestChangedDtsTime || false; + return latestChangedDtsTime; + } + function updateOutputTimestamps(state, proj, resolvedPath) { + if (state.options.dry) { + return reportStatus(state, ts.Diagnostics.A_non_dry_build_would_update_timestamps_for_output_of_project_0, proj.options.configFilePath); + } + updateOutputTimestampsWorker(state, proj, resolvedPath, ts.Diagnostics.Updating_output_timestamps_of_project_0); + state.projectStatus.set(resolvedPath, { + type: ts.UpToDateStatusType.UpToDate, + oldestOutputFileName: ts.getFirstProjectOutput(proj, !state.host.useCaseSensitiveFileNames()) + }); + } + function queueReferencingProjects(state, project, projectPath, projectIndex, config, buildOrder, buildResult) { + // Queue only if there are no errors + if (buildResult & BuildResultFlags.AnyErrors) + return; + // Only composite projects can be referenced by other projects + if (!config.options.composite) + return; + // Always use build order to queue projects + for (var index = projectIndex + 1; index < buildOrder.length; index++) { + var nextProject = buildOrder[index]; + var nextProjectPath = toResolvedConfigFilePath(state, nextProject); + if (state.projectPendingBuild.has(nextProjectPath)) + continue; + var nextProjectConfig = parseConfigFile(state, nextProject, nextProjectPath); + if (!nextProjectConfig || !nextProjectConfig.projectReferences) + continue; + for (var _i = 0, _a = nextProjectConfig.projectReferences; _i < _a.length; _i++) { + var ref = _a[_i]; + var resolvedRefPath = resolveProjectName(state, ref.path); + if (toResolvedConfigFilePath(state, resolvedRefPath) !== projectPath) + continue; + // If the project is referenced with prepend, always build downstream projects, + // If declaration output is changed, build the project + // otherwise mark the project UpToDateWithUpstreamTypes so it updates output time stamps + var status = state.projectStatus.get(nextProjectPath); + if (status) { + switch (status.type) { + case ts.UpToDateStatusType.UpToDate: + if (buildResult & BuildResultFlags.DeclarationOutputUnchanged) { + if (ref.prepend) { + state.projectStatus.set(nextProjectPath, { + type: ts.UpToDateStatusType.OutOfDateWithPrepend, + outOfDateOutputFileName: status.oldestOutputFileName, + newerProjectName: project + }); + } + else { + status.type = ts.UpToDateStatusType.UpToDateWithUpstreamTypes; + } + break; + } + // falls through + case ts.UpToDateStatusType.UpToDateWithInputFileText: + case ts.UpToDateStatusType.UpToDateWithUpstreamTypes: + case ts.UpToDateStatusType.OutOfDateWithPrepend: + if (!(buildResult & BuildResultFlags.DeclarationOutputUnchanged)) { + state.projectStatus.set(nextProjectPath, { + type: ts.UpToDateStatusType.OutOfDateWithUpstream, + outOfDateOutputFileName: status.type === ts.UpToDateStatusType.OutOfDateWithPrepend ? status.outOfDateOutputFileName : status.oldestOutputFileName, + newerProjectName: project + }); + } + break; + case ts.UpToDateStatusType.UpstreamBlocked: + if (toResolvedConfigFilePath(state, resolveProjectName(state, status.upstreamProjectName)) === projectPath) { + clearProjectStatus(state, nextProjectPath); + } + break; + } + } + addProjToQueue(state, nextProjectPath, ts.ConfigFileProgramReloadLevel.None); + break; + } + } + } + function build(state, project, cancellationToken, writeFile, getCustomTransformers, onlyReferences) { + ts.performance.mark("SolutionBuilder::beforeBuild"); + var result = buildWorker(state, project, cancellationToken, writeFile, getCustomTransformers, onlyReferences); + ts.performance.mark("SolutionBuilder::afterBuild"); + ts.performance.measure("SolutionBuilder::Build", "SolutionBuilder::beforeBuild", "SolutionBuilder::afterBuild"); + return result; + } + function buildWorker(state, project, cancellationToken, writeFile, getCustomTransformers, onlyReferences) { + var buildOrder = getBuildOrderFor(state, project, onlyReferences); + if (!buildOrder) + return ts.ExitStatus.InvalidProject_OutputsSkipped; + setupInitialBuild(state, cancellationToken); + var reportQueue = true; + var successfulProjects = 0; + while (true) { + var invalidatedProject = getNextInvalidatedProject(state, buildOrder, reportQueue); + if (!invalidatedProject) + break; + reportQueue = false; + invalidatedProject.done(cancellationToken, writeFile, getCustomTransformers === null || getCustomTransformers === void 0 ? void 0 : getCustomTransformers(invalidatedProject.project)); + if (!state.diagnostics.has(invalidatedProject.projectPath)) + successfulProjects++; + } + disableCache(state); + reportErrorSummary(state, buildOrder); + startWatching(state, buildOrder); + return isCircularBuildOrder(buildOrder) + ? ts.ExitStatus.ProjectReferenceCycle_OutputsSkipped + : !buildOrder.some(function (p) { return state.diagnostics.has(toResolvedConfigFilePath(state, p)); }) + ? ts.ExitStatus.Success + : successfulProjects + ? ts.ExitStatus.DiagnosticsPresent_OutputsGenerated + : ts.ExitStatus.DiagnosticsPresent_OutputsSkipped; + } + function clean(state, project, onlyReferences) { + ts.performance.mark("SolutionBuilder::beforeClean"); + var result = cleanWorker(state, project, onlyReferences); + ts.performance.mark("SolutionBuilder::afterClean"); + ts.performance.measure("SolutionBuilder::Clean", "SolutionBuilder::beforeClean", "SolutionBuilder::afterClean"); + return result; + } + function cleanWorker(state, project, onlyReferences) { + var buildOrder = getBuildOrderFor(state, project, onlyReferences); + if (!buildOrder) + return ts.ExitStatus.InvalidProject_OutputsSkipped; + if (isCircularBuildOrder(buildOrder)) { + reportErrors(state, buildOrder.circularDiagnostics); + return ts.ExitStatus.ProjectReferenceCycle_OutputsSkipped; + } + var options = state.options, host = state.host; + var filesToDelete = options.dry ? [] : undefined; + for (var _i = 0, buildOrder_1 = buildOrder; _i < buildOrder_1.length; _i++) { + var proj = buildOrder_1[_i]; + var resolvedPath = toResolvedConfigFilePath(state, proj); + var parsed = parseConfigFile(state, proj, resolvedPath); + if (parsed === undefined) { + // File has gone missing; fine to ignore here + reportParseConfigFileDiagnostic(state, resolvedPath); + continue; + } + var outputs = ts.getAllProjectOutputs(parsed, !host.useCaseSensitiveFileNames()); + if (!outputs.length) + continue; + var inputFileNames = new ts.Set(parsed.fileNames.map(function (f) { return toPath(state, f); })); + for (var _a = 0, outputs_3 = outputs; _a < outputs_3.length; _a++) { + var output = outputs_3[_a]; + // If output name is same as input file name, do not delete and ignore the error + if (inputFileNames.has(toPath(state, output))) + continue; + if (host.fileExists(output)) { + if (filesToDelete) { + filesToDelete.push(output); + } + else { + host.deleteFile(output); + invalidateProject(state, resolvedPath, ts.ConfigFileProgramReloadLevel.None); + } + } + } + } + if (filesToDelete) { + reportStatus(state, ts.Diagnostics.A_non_dry_build_would_delete_the_following_files_Colon_0, filesToDelete.map(function (f) { return "\r\n * ".concat(f); }).join("")); + } + return ts.ExitStatus.Success; + } + function invalidateProject(state, resolved, reloadLevel) { + // If host implements getParsedCommandLine, we cant get list of files from parseConfigFileHost + if (state.host.getParsedCommandLine && reloadLevel === ts.ConfigFileProgramReloadLevel.Partial) { + reloadLevel = ts.ConfigFileProgramReloadLevel.Full; + } + if (reloadLevel === ts.ConfigFileProgramReloadLevel.Full) { + state.configFileCache.delete(resolved); + state.buildOrder = undefined; + } + state.needsSummary = true; + clearProjectStatus(state, resolved); + addProjToQueue(state, resolved, reloadLevel); + enableCache(state); + } + function invalidateProjectAndScheduleBuilds(state, resolvedPath, reloadLevel) { + state.reportFileChangeDetected = true; + invalidateProject(state, resolvedPath, reloadLevel); + scheduleBuildInvalidatedProject(state, 250, /*changeDetected*/ true); + } + function scheduleBuildInvalidatedProject(state, time, changeDetected) { + var hostWithWatch = state.hostWithWatch; + if (!hostWithWatch.setTimeout || !hostWithWatch.clearTimeout) { + return; + } + if (state.timerToBuildInvalidatedProject) { + hostWithWatch.clearTimeout(state.timerToBuildInvalidatedProject); + } + state.timerToBuildInvalidatedProject = hostWithWatch.setTimeout(buildNextInvalidatedProject, time, state, changeDetected); + } + function buildNextInvalidatedProject(state, changeDetected) { + ts.performance.mark("SolutionBuilder::beforeBuild"); + var buildOrder = buildNextInvalidatedProjectWorker(state, changeDetected); + ts.performance.mark("SolutionBuilder::afterBuild"); + ts.performance.measure("SolutionBuilder::Build", "SolutionBuilder::beforeBuild", "SolutionBuilder::afterBuild"); + if (buildOrder) + reportErrorSummary(state, buildOrder); + } + function buildNextInvalidatedProjectWorker(state, changeDetected) { + state.timerToBuildInvalidatedProject = undefined; + if (state.reportFileChangeDetected) { + state.reportFileChangeDetected = false; + state.projectErrorsReported.clear(); + reportWatchStatus(state, ts.Diagnostics.File_change_detected_Starting_incremental_compilation); + } + var projectsBuilt = 0; + var buildOrder = getBuildOrder(state); + var invalidatedProject = getNextInvalidatedProject(state, buildOrder, /*reportQueue*/ false); + if (invalidatedProject) { + invalidatedProject.done(); + projectsBuilt++; + while (state.projectPendingBuild.size) { + // If already scheduled, skip + if (state.timerToBuildInvalidatedProject) + return; + // Before scheduling check if the next project needs build + var info = getNextInvalidatedProjectCreateInfo(state, buildOrder, /*reportQueue*/ false); + if (!info) + break; // Nothing to build any more + if (info.kind !== InvalidatedProjectKind.UpdateOutputFileStamps && (changeDetected || projectsBuilt === 5)) { + // Schedule next project for build + scheduleBuildInvalidatedProject(state, 100, /*changeDetected*/ false); + return; + } + var project = createInvalidatedProjectWithInfo(state, info, buildOrder); + project.done(); + if (info.kind !== InvalidatedProjectKind.UpdateOutputFileStamps) + projectsBuilt++; + } + } + disableCache(state); + return buildOrder; + } + function watchConfigFile(state, resolved, resolvedPath, parsed) { + if (!state.watch || state.allWatchedConfigFiles.has(resolvedPath)) + return; + state.allWatchedConfigFiles.set(resolvedPath, watchFile(state, resolved, function () { return invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.Full); }, ts.PollingInterval.High, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.ConfigFile, resolved)); + } + function watchExtendedConfigFiles(state, resolvedPath, parsed) { + ts.updateSharedExtendedConfigFileWatcher(resolvedPath, parsed === null || parsed === void 0 ? void 0 : parsed.options, state.allWatchedExtendedConfigFiles, function (extendedConfigFileName, extendedConfigFilePath) { return watchFile(state, extendedConfigFileName, function () { + var _a; + return (_a = state.allWatchedExtendedConfigFiles.get(extendedConfigFilePath)) === null || _a === void 0 ? void 0 : _a.projects.forEach(function (projectConfigFilePath) { + return invalidateProjectAndScheduleBuilds(state, projectConfigFilePath, ts.ConfigFileProgramReloadLevel.Full); + }); + }, ts.PollingInterval.High, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.ExtendedConfigFile); }, function (fileName) { return toPath(state, fileName); }); + } + function watchWildCardDirectories(state, resolved, resolvedPath, parsed) { + if (!state.watch) + return; + ts.updateWatchingWildcardDirectories(getOrCreateValueMapFromConfigFileMap(state.allWatchedWildcardDirectories, resolvedPath), new ts.Map(ts.getEntries(parsed.wildcardDirectories)), function (dir, flags) { return state.watchDirectory(dir, function (fileOrDirectory) { + var _a; + if (ts.isIgnoredFileFromWildCardWatching({ + watchedDirPath: toPath(state, dir), + fileOrDirectory: fileOrDirectory, + fileOrDirectoryPath: toPath(state, fileOrDirectory), + configFileName: resolved, + currentDirectory: state.currentDirectory, + options: parsed.options, + program: state.builderPrograms.get(resolvedPath) || ((_a = getCachedParsedConfigFile(state, resolvedPath)) === null || _a === void 0 ? void 0 : _a.fileNames), + useCaseSensitiveFileNames: state.parseConfigFileHost.useCaseSensitiveFileNames, + writeLog: function (s) { return state.writeLog(s); }, + toPath: function (fileName) { return toPath(state, fileName); } + })) + return; + invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.Partial); + }, flags, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.WildcardDirectory, resolved); }); + } + function watchInputFiles(state, resolved, resolvedPath, parsed) { + if (!state.watch) + return; + ts.mutateMap(getOrCreateValueMapFromConfigFileMap(state.allWatchedInputFiles, resolvedPath), ts.arrayToMap(parsed.fileNames, function (fileName) { return toPath(state, fileName); }), { + createNewValue: function (_path, input) { return watchFile(state, input, function () { return invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.None); }, ts.PollingInterval.Low, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.SourceFile, resolved); }, + onDeleteValue: ts.closeFileWatcher, + }); + } + function watchPackageJsonFiles(state, resolved, resolvedPath, parsed) { + if (!state.watch || !state.lastCachedPackageJsonLookups) + return; + ts.mutateMap(getOrCreateValueMapFromConfigFileMap(state.allWatchedPackageJsonFiles, resolvedPath), new ts.Map(state.lastCachedPackageJsonLookups.get(resolvedPath)), { + createNewValue: function (path, _input) { return watchFile(state, path, function () { return invalidateProjectAndScheduleBuilds(state, resolvedPath, ts.ConfigFileProgramReloadLevel.None); }, ts.PollingInterval.High, parsed === null || parsed === void 0 ? void 0 : parsed.watchOptions, ts.WatchType.PackageJson, resolved); }, + onDeleteValue: ts.closeFileWatcher, + }); + } + function startWatching(state, buildOrder) { + if (!state.watchAllProjectsPending) + return; + ts.performance.mark("SolutionBuilder::beforeWatcherCreation"); + state.watchAllProjectsPending = false; + for (var _i = 0, _a = getBuildOrderFromAnyBuildOrder(buildOrder); _i < _a.length; _i++) { + var resolved = _a[_i]; + var resolvedPath = toResolvedConfigFilePath(state, resolved); + var cfg = parseConfigFile(state, resolved, resolvedPath); + // Watch this file + watchConfigFile(state, resolved, resolvedPath, cfg); + watchExtendedConfigFiles(state, resolvedPath, cfg); + if (cfg) { + // Update watchers for wildcard directories + watchWildCardDirectories(state, resolved, resolvedPath, cfg); + // Watch input files + watchInputFiles(state, resolved, resolvedPath, cfg); + // Watch package json files + watchPackageJsonFiles(state, resolved, resolvedPath, cfg); + } + } + ts.performance.mark("SolutionBuilder::afterWatcherCreation"); + ts.performance.measure("SolutionBuilder::Watcher creation", "SolutionBuilder::beforeWatcherCreation", "SolutionBuilder::afterWatcherCreation"); + } + function stopWatching(state) { + ts.clearMap(state.allWatchedConfigFiles, ts.closeFileWatcher); + ts.clearMap(state.allWatchedExtendedConfigFiles, ts.closeFileWatcherOf); + ts.clearMap(state.allWatchedWildcardDirectories, function (watchedWildcardDirectories) { return ts.clearMap(watchedWildcardDirectories, ts.closeFileWatcherOf); }); + ts.clearMap(state.allWatchedInputFiles, function (watchedWildcardDirectories) { return ts.clearMap(watchedWildcardDirectories, ts.closeFileWatcher); }); + ts.clearMap(state.allWatchedPackageJsonFiles, function (watchedPacageJsonFiles) { return ts.clearMap(watchedPacageJsonFiles, ts.closeFileWatcher); }); + } + function createSolutionBuilderWorker(watch, hostOrHostWithWatch, rootNames, options, baseWatchOptions) { + var state = createSolutionBuilderState(watch, hostOrHostWithWatch, rootNames, options, baseWatchOptions); + return { + build: function (project, cancellationToken, writeFile, getCustomTransformers) { return build(state, project, cancellationToken, writeFile, getCustomTransformers); }, + clean: function (project) { return clean(state, project); }, + buildReferences: function (project, cancellationToken, writeFile, getCustomTransformers) { return build(state, project, cancellationToken, writeFile, getCustomTransformers, /*onlyReferences*/ true); }, + cleanReferences: function (project) { return clean(state, project, /*onlyReferences*/ true); }, + getNextInvalidatedProject: function (cancellationToken) { + setupInitialBuild(state, cancellationToken); + return getNextInvalidatedProject(state, getBuildOrder(state), /*reportQueue*/ false); + }, + getBuildOrder: function () { return getBuildOrder(state); }, + getUpToDateStatusOfProject: function (project) { + var configFileName = resolveProjectName(state, project); + var configFilePath = toResolvedConfigFilePath(state, configFileName); + return getUpToDateStatus(state, parseConfigFile(state, configFileName, configFilePath), configFilePath); + }, + invalidateProject: function (configFilePath, reloadLevel) { return invalidateProject(state, configFilePath, reloadLevel || ts.ConfigFileProgramReloadLevel.None); }, + close: function () { return stopWatching(state); }, + }; + } + function relName(state, path) { + return ts.convertToRelativePath(path, state.currentDirectory, function (f) { return state.getCanonicalFileName(f); }); + } + function reportStatus(state, message) { + var args = []; + for (var _i = 2; _i < arguments.length; _i++) { + args[_i - 2] = arguments[_i]; + } + state.host.reportSolutionBuilderStatus(ts.createCompilerDiagnostic.apply(void 0, __spreadArray([message], args, false))); + } + function reportWatchStatus(state, message) { + var _a, _b; + var args = []; + for (var _i = 2; _i < arguments.length; _i++) { + args[_i - 2] = arguments[_i]; + } + (_b = (_a = state.hostWithWatch).onWatchStatusChange) === null || _b === void 0 ? void 0 : _b.call(_a, ts.createCompilerDiagnostic.apply(void 0, __spreadArray([message], args, false)), state.host.getNewLine(), state.baseCompilerOptions); + } + function reportErrors(_a, errors) { + var host = _a.host; + errors.forEach(function (err) { return host.reportDiagnostic(err); }); + } + function reportAndStoreErrors(state, proj, errors) { + reportErrors(state, errors); + state.projectErrorsReported.set(proj, true); + if (errors.length) { + state.diagnostics.set(proj, errors); + } + } + function reportParseConfigFileDiagnostic(state, proj) { + reportAndStoreErrors(state, proj, [state.configFileCache.get(proj)]); + } + function reportErrorSummary(state, buildOrder) { + if (!state.needsSummary) + return; + state.needsSummary = false; + var canReportSummary = state.watch || !!state.host.reportErrorSummary; + var diagnostics = state.diagnostics; + var totalErrors = 0; + var filesInError = []; + if (isCircularBuildOrder(buildOrder)) { + reportBuildQueue(state, buildOrder.buildOrder); + reportErrors(state, buildOrder.circularDiagnostics); + if (canReportSummary) + totalErrors += ts.getErrorCountForSummary(buildOrder.circularDiagnostics); + if (canReportSummary) + filesInError = __spreadArray(__spreadArray([], filesInError, true), ts.getFilesInErrorForSummary(buildOrder.circularDiagnostics), true); + } + else { + // Report errors from the other projects + buildOrder.forEach(function (project) { + var projectPath = toResolvedConfigFilePath(state, project); + if (!state.projectErrorsReported.has(projectPath)) { + reportErrors(state, diagnostics.get(projectPath) || ts.emptyArray); + } + }); + if (canReportSummary) + diagnostics.forEach(function (singleProjectErrors) { return totalErrors += ts.getErrorCountForSummary(singleProjectErrors); }); + if (canReportSummary) + diagnostics.forEach(function (singleProjectErrors) { return __spreadArray(__spreadArray([], filesInError, true), ts.getFilesInErrorForSummary(singleProjectErrors), true); }); + } + if (state.watch) { + reportWatchStatus(state, ts.getWatchErrorSummaryDiagnosticMessage(totalErrors), totalErrors); + } + else if (state.host.reportErrorSummary) { + state.host.reportErrorSummary(totalErrors, filesInError); + } + } + /** + * Report the build ordering inferred from the current project graph if we're in verbose mode + */ + function reportBuildQueue(state, buildQueue) { + if (state.options.verbose) { + reportStatus(state, ts.Diagnostics.Projects_in_this_build_Colon_0, buildQueue.map(function (s) { return "\r\n * " + relName(state, s); }).join("")); + } + } + function reportUpToDateStatus(state, configFileName, status) { + switch (status.type) { + case ts.UpToDateStatusType.OutOfDateWithSelf: + return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_output_1_is_older_than_input_2, relName(state, configFileName), relName(state, status.outOfDateOutputFileName), relName(state, status.newerInputFileName)); + case ts.UpToDateStatusType.OutOfDateWithUpstream: + return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_output_1_is_older_than_input_2, relName(state, configFileName), relName(state, status.outOfDateOutputFileName), relName(state, status.newerProjectName)); + case ts.UpToDateStatusType.OutputMissing: + return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_output_file_1_does_not_exist, relName(state, configFileName), relName(state, status.missingOutputFileName)); + case ts.UpToDateStatusType.ErrorReadingFile: + return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_there_was_error_reading_file_1, relName(state, configFileName), relName(state, status.fileName)); + case ts.UpToDateStatusType.OutOfDateBuildInfo: + return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_some_of_the_changes_were_not_emitted, relName(state, configFileName), relName(state, status.buildInfoFile)); + case ts.UpToDateStatusType.UpToDate: + if (status.newestInputFileTime !== undefined) { + return reportStatus(state, ts.Diagnostics.Project_0_is_up_to_date_because_newest_input_1_is_older_than_output_2, relName(state, configFileName), relName(state, status.newestInputFileName || ""), relName(state, status.oldestOutputFileName || "")); + } + // Don't report anything for "up to date because it was already built" -- too verbose + break; + case ts.UpToDateStatusType.OutOfDateWithPrepend: + return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_output_of_its_dependency_1_has_changed, relName(state, configFileName), relName(state, status.newerProjectName)); + case ts.UpToDateStatusType.UpToDateWithUpstreamTypes: + return reportStatus(state, ts.Diagnostics.Project_0_is_up_to_date_with_d_ts_files_from_its_dependencies, relName(state, configFileName)); + case ts.UpToDateStatusType.UpToDateWithInputFileText: + return reportStatus(state, ts.Diagnostics.Project_0_is_up_to_date_but_needs_to_update_timestamps_of_output_files_that_are_older_than_input_files, relName(state, configFileName)); + case ts.UpToDateStatusType.UpstreamOutOfDate: + return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_its_dependency_1_is_out_of_date, relName(state, configFileName), relName(state, status.upstreamProjectName)); + case ts.UpToDateStatusType.UpstreamBlocked: + return reportStatus(state, status.upstreamProjectBlocked ? + ts.Diagnostics.Project_0_can_t_be_built_because_its_dependency_1_was_not_built : + ts.Diagnostics.Project_0_can_t_be_built_because_its_dependency_1_has_errors, relName(state, configFileName), relName(state, status.upstreamProjectName)); + case ts.UpToDateStatusType.Unbuildable: + return reportStatus(state, ts.Diagnostics.Failed_to_parse_file_0_Colon_1, relName(state, configFileName), status.reason); + case ts.UpToDateStatusType.TsVersionOutputOfDate: + return reportStatus(state, ts.Diagnostics.Project_0_is_out_of_date_because_output_for_it_was_generated_with_version_1_that_differs_with_current_version_2, relName(state, configFileName), status.version, ts.version); + case ts.UpToDateStatusType.ForceBuild: + return reportStatus(state, ts.Diagnostics.Project_0_is_being_forcibly_rebuilt, relName(state, configFileName)); + case ts.UpToDateStatusType.ContainerOnly: + // Don't report status on "solution" projects + // falls through + case ts.UpToDateStatusType.ComputingUpstream: + // Should never leak from getUptoDateStatusWorker + break; + default: + ts.assertType(status); + } + } + /** + * Report the up-to-date status of a project if we're in verbose mode + */ + function verboseReportProjectStatus(state, configFileName, status) { + if (state.options.verbose) { + reportUpToDateStatus(state, configFileName, status); + } + } +})(ts || (ts = {})); +var ts; +(function (ts) { + var server; + (function (server) { + /* @internal */ + server.ActionSet = "action::set"; + /* @internal */ + server.ActionInvalidate = "action::invalidate"; + /* @internal */ + server.ActionPackageInstalled = "action::packageInstalled"; + /* @internal */ + server.EventTypesRegistry = "event::typesRegistry"; + /* @internal */ + server.EventBeginInstallTypes = "event::beginInstallTypes"; + /* @internal */ + server.EventEndInstallTypes = "event::endInstallTypes"; + /* @internal */ + server.EventInitializationFailed = "event::initializationFailed"; + /* @internal */ + var Arguments; + (function (Arguments) { + Arguments.GlobalCacheLocation = "--globalTypingsCacheLocation"; + Arguments.LogFile = "--logFile"; + Arguments.EnableTelemetry = "--enableTelemetry"; + Arguments.TypingSafeListLocation = "--typingSafeListLocation"; + Arguments.TypesMapLocation = "--typesMapLocation"; + /** + * This argument specifies the location of the NPM executable. + * typingsInstaller will run the command with `${npmLocation} install ...`. + */ + Arguments.NpmLocation = "--npmLocation"; + /** + * Flag indicating that the typings installer should try to validate the default npm location. + * If the default npm is not found when this flag is enabled, fallback to `npm install` + */ + Arguments.ValidateDefaultNpmLocation = "--validateDefaultNpmLocation"; + })(Arguments = server.Arguments || (server.Arguments = {})); + /* @internal */ + function hasArgument(argumentName) { + return ts.sys.args.indexOf(argumentName) >= 0; + } + server.hasArgument = hasArgument; + /* @internal */ + function findArgument(argumentName) { + var index = ts.sys.args.indexOf(argumentName); + return index >= 0 && index < ts.sys.args.length - 1 + ? ts.sys.args[index + 1] + : undefined; + } + server.findArgument = findArgument; + /* @internal */ + function nowString() { + // E.g. "12:34:56.789" + var d = new Date(); + return "".concat(ts.padLeft(d.getHours().toString(), 2, "0"), ":").concat(ts.padLeft(d.getMinutes().toString(), 2, "0"), ":").concat(ts.padLeft(d.getSeconds().toString(), 2, "0"), ".").concat(ts.padLeft(d.getMilliseconds().toString(), 3, "0")); + } + server.nowString = nowString; + })(server = ts.server || (ts.server = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var JsTyping; + (function (JsTyping) { + function isTypingUpToDate(cachedTyping, availableTypingVersions) { + var availableVersion = new ts.Version(ts.getProperty(availableTypingVersions, "ts".concat(ts.versionMajorMinor)) || ts.getProperty(availableTypingVersions, "latest")); + return availableVersion.compareTo(cachedTyping.version) <= 0; + } + JsTyping.isTypingUpToDate = isTypingUpToDate; + var unprefixedNodeCoreModuleList = [ + "assert", + "assert/strict", + "async_hooks", + "buffer", + "child_process", + "cluster", + "console", + "constants", + "crypto", + "dgram", + "diagnostics_channel", + "dns", + "dns/promises", + "domain", + "events", + "fs", + "fs/promises", + "http", + "https", + "http2", + "inspector", + "module", + "net", + "os", + "path", + "perf_hooks", + "process", + "punycode", + "querystring", + "readline", + "repl", + "stream", + "stream/promises", + "string_decoder", + "timers", + "timers/promises", + "tls", + "trace_events", + "tty", + "url", + "util", + "util/types", + "v8", + "vm", + "wasi", + "worker_threads", + "zlib" + ]; + JsTyping.prefixedNodeCoreModuleList = unprefixedNodeCoreModuleList.map(function (name) { return "node:".concat(name); }); + JsTyping.nodeCoreModuleList = __spreadArray(__spreadArray([], unprefixedNodeCoreModuleList, true), JsTyping.prefixedNodeCoreModuleList, true); + JsTyping.nodeCoreModules = new ts.Set(JsTyping.nodeCoreModuleList); + function nonRelativeModuleNameForTypingCache(moduleName) { + return JsTyping.nodeCoreModules.has(moduleName) ? "node" : moduleName; + } + JsTyping.nonRelativeModuleNameForTypingCache = nonRelativeModuleNameForTypingCache; + function loadSafeList(host, safeListPath) { + var result = ts.readConfigFile(safeListPath, function (path) { return host.readFile(path); }); + return new ts.Map(ts.getEntries(result.config)); + } + JsTyping.loadSafeList = loadSafeList; + function loadTypesMap(host, typesMapPath) { + var result = ts.readConfigFile(typesMapPath, function (path) { return host.readFile(path); }); + if (result.config) { + return new ts.Map(ts.getEntries(result.config.simpleMap)); + } + return undefined; + } + JsTyping.loadTypesMap = loadTypesMap; + /** + * @param host is the object providing I/O related operations. + * @param fileNames are the file names that belong to the same project + * @param projectRootPath is the path to the project root directory + * @param safeListPath is the path used to retrieve the safe list + * @param packageNameToTypingLocation is the map of package names to their cached typing locations and installed versions + * @param typeAcquisition is used to customize the typing acquisition process + * @param compilerOptions are used as a source for typing inference + */ + function discoverTypings(host, log, fileNames, projectRootPath, safeList, packageNameToTypingLocation, typeAcquisition, unresolvedImports, typesRegistry, compilerOptions) { + if (!typeAcquisition || !typeAcquisition.enable) { + return { cachedTypingPaths: [], newTypingNames: [], filesToWatch: [] }; + } + // A typing name to typing file path mapping + var inferredTypings = new ts.Map(); + // Only infer typings for .js and .jsx files + fileNames = ts.mapDefined(fileNames, function (fileName) { + var path = ts.normalizePath(fileName); + if (ts.hasJSFileExtension(path)) { + return path; + } + }); + var filesToWatch = []; + if (typeAcquisition.include) + addInferredTypings(typeAcquisition.include, "Explicitly included types"); + var exclude = typeAcquisition.exclude || []; + // Directories to search for package.json, bower.json and other typing information + if (!compilerOptions.types) { + var possibleSearchDirs = new ts.Set(fileNames.map(ts.getDirectoryPath)); + possibleSearchDirs.add(projectRootPath); + possibleSearchDirs.forEach(function (searchDir) { + getTypingNames(searchDir, "bower.json", "bower_components", filesToWatch); + getTypingNames(searchDir, "package.json", "node_modules", filesToWatch); + }); + } + if (!typeAcquisition.disableFilenameBasedTypeAcquisition) { + getTypingNamesFromSourceFileNames(fileNames); + } + // add typings for unresolved imports + if (unresolvedImports) { + var module_1 = ts.deduplicate(unresolvedImports.map(nonRelativeModuleNameForTypingCache), ts.equateStringsCaseSensitive, ts.compareStringsCaseSensitive); + addInferredTypings(module_1, "Inferred typings from unresolved imports"); + } + // Add the cached typing locations for inferred typings that are already installed + packageNameToTypingLocation.forEach(function (typing, name) { + var registryEntry = typesRegistry.get(name); + if (inferredTypings.has(name) && inferredTypings.get(name) === undefined && registryEntry !== undefined && isTypingUpToDate(typing, registryEntry)) { + inferredTypings.set(name, typing.typingLocation); + } + }); + // Remove typings that the user has added to the exclude list + for (var _i = 0, exclude_1 = exclude; _i < exclude_1.length; _i++) { + var excludeTypingName = exclude_1[_i]; + var didDelete = inferredTypings.delete(excludeTypingName); + if (didDelete && log) + log("Typing for ".concat(excludeTypingName, " is in exclude list, will be ignored.")); + } + var newTypingNames = []; + var cachedTypingPaths = []; + inferredTypings.forEach(function (inferred, typing) { + if (inferred !== undefined) { + cachedTypingPaths.push(inferred); + } + else { + newTypingNames.push(typing); + } + }); + var result = { cachedTypingPaths: cachedTypingPaths, newTypingNames: newTypingNames, filesToWatch: filesToWatch }; + if (log) + log("Result: ".concat(JSON.stringify(result))); + return result; + function addInferredTyping(typingName) { + if (!inferredTypings.has(typingName)) { + inferredTypings.set(typingName, undefined); // TODO: GH#18217 + } + } + function addInferredTypings(typingNames, message) { + if (log) + log("".concat(message, ": ").concat(JSON.stringify(typingNames))); + ts.forEach(typingNames, addInferredTyping); + } + /** + * Adds inferred typings from manifest/module pairs (think package.json + node_modules) + * + * @param projectRootPath is the path to the directory where to look for package.json, bower.json and other typing information + * @param manifestName is the name of the manifest (package.json or bower.json) + * @param modulesDirName is the directory name for modules (node_modules or bower_components). Should be lowercase! + * @param filesToWatch are the files to watch for changes. We will push things into this array. + */ + function getTypingNames(projectRootPath, manifestName, modulesDirName, filesToWatch) { + // First, we check the manifests themselves. They're not + // _required_, but they allow us to do some filtering when dealing + // with big flat dep directories. + var manifestPath = ts.combinePaths(projectRootPath, manifestName); + var manifest; + var manifestTypingNames; + if (host.fileExists(manifestPath)) { + filesToWatch.push(manifestPath); + manifest = ts.readConfigFile(manifestPath, function (path) { return host.readFile(path); }).config; + manifestTypingNames = ts.flatMap([manifest.dependencies, manifest.devDependencies, manifest.optionalDependencies, manifest.peerDependencies], ts.getOwnKeys); + addInferredTypings(manifestTypingNames, "Typing names in '".concat(manifestPath, "' dependencies")); + } + // Now we scan the directories for typing information in + // already-installed dependencies (if present). Note that this + // step happens regardless of whether a manifest was present, + // which is certainly a valid configuration, if an unusual one. + var packagesFolderPath = ts.combinePaths(projectRootPath, modulesDirName); + filesToWatch.push(packagesFolderPath); + if (!host.directoryExists(packagesFolderPath)) { + return; + } + // There's two cases we have to take into account here: + // 1. If manifest is undefined, then we're not using a manifest. + // That means that we should scan _all_ dependencies at the top + // level of the modulesDir. + // 2. If manifest is defined, then we can do some special + // filtering to reduce the amount of scanning we need to do. + // + // Previous versions of this algorithm checked for a `_requiredBy` + // field in the package.json, but that field is only present in + // `npm@>=3 <7`. + // Package names that do **not** provide their own typings, so + // we'll look them up. + var packageNames = []; + var dependencyManifestNames = manifestTypingNames + // This is #1 described above. + ? manifestTypingNames.map(function (typingName) { return ts.combinePaths(packagesFolderPath, typingName, manifestName); }) + // And #2. Depth = 3 because scoped packages look like `node_modules/@foo/bar/package.json` + : host.readDirectory(packagesFolderPath, [".json" /* Extension.Json */], /*excludes*/ undefined, /*includes*/ undefined, /*depth*/ 3) + .filter(function (manifestPath) { + if (ts.getBaseFileName(manifestPath) !== manifestName) { + return false; + } + // It's ok to treat + // `node_modules/@foo/bar/package.json` as a manifest, + // but not `node_modules/jquery/nested/package.json`. + // We only assume depth 3 is ok for formally scoped + // packages. So that needs this dance here. + var pathComponents = ts.getPathComponents(ts.normalizePath(manifestPath)); + var isScoped = pathComponents[pathComponents.length - 3][0] === "@"; + return isScoped && pathComponents[pathComponents.length - 4].toLowerCase() === modulesDirName || // `node_modules/@foo/bar` + !isScoped && pathComponents[pathComponents.length - 3].toLowerCase() === modulesDirName; // `node_modules/foo` + }); + if (log) + log("Searching for typing names in ".concat(packagesFolderPath, "; all files: ").concat(JSON.stringify(dependencyManifestNames))); + // Once we have the names of things to look up, we iterate over + // and either collect their included typings, or add them to the + // list of typings we need to look up separately. + for (var _i = 0, dependencyManifestNames_1 = dependencyManifestNames; _i < dependencyManifestNames_1.length; _i++) { + var manifestPath_1 = dependencyManifestNames_1[_i]; + var normalizedFileName = ts.normalizePath(manifestPath_1); + var result_1 = ts.readConfigFile(normalizedFileName, function (path) { return host.readFile(path); }); + var manifest_1 = result_1.config; + // If the package has its own d.ts typings, those will take precedence. Otherwise the package name will be used + // to download d.ts files from DefinitelyTyped + if (!manifest_1.name) { + continue; + } + var ownTypes = manifest_1.types || manifest_1.typings; + if (ownTypes) { + var absolutePath = ts.getNormalizedAbsolutePath(ownTypes, ts.getDirectoryPath(normalizedFileName)); + if (host.fileExists(absolutePath)) { + if (log) + log(" Package '".concat(manifest_1.name, "' provides its own types.")); + inferredTypings.set(manifest_1.name, absolutePath); + } + else { + if (log) + log(" Package '".concat(manifest_1.name, "' provides its own types but they are missing.")); + } + } + else { + packageNames.push(manifest_1.name); + } + } + addInferredTypings(packageNames, " Found package names"); + } + /** + * Infer typing names from given file names. For example, the file name "jquery-min.2.3.4.js" + * should be inferred to the 'jquery' typing name; and "angular-route.1.2.3.js" should be inferred + * to the 'angular-route' typing name. + * @param fileNames are the names for source files in the project + */ + function getTypingNamesFromSourceFileNames(fileNames) { + var fromFileNames = ts.mapDefined(fileNames, function (j) { + if (!ts.hasJSFileExtension(j)) + return undefined; + var inferredTypingName = ts.removeFileExtension(ts.getBaseFileName(j.toLowerCase())); + var cleanedTypingName = ts.removeMinAndVersionNumbers(inferredTypingName); + return safeList.get(cleanedTypingName); + }); + if (fromFileNames.length) { + addInferredTypings(fromFileNames, "Inferred typings from file names"); + } + var hasJsxFile = ts.some(fileNames, function (f) { return ts.fileExtensionIs(f, ".jsx" /* Extension.Jsx */); }); + if (hasJsxFile) { + if (log) + log("Inferred 'react' typings due to presence of '.jsx' extension"); + addInferredTyping("react"); + } + } + } + JsTyping.discoverTypings = discoverTypings; + var NameValidationResult; + (function (NameValidationResult) { + NameValidationResult[NameValidationResult["Ok"] = 0] = "Ok"; + NameValidationResult[NameValidationResult["EmptyName"] = 1] = "EmptyName"; + NameValidationResult[NameValidationResult["NameTooLong"] = 2] = "NameTooLong"; + NameValidationResult[NameValidationResult["NameStartsWithDot"] = 3] = "NameStartsWithDot"; + NameValidationResult[NameValidationResult["NameStartsWithUnderscore"] = 4] = "NameStartsWithUnderscore"; + NameValidationResult[NameValidationResult["NameContainsNonURISafeCharacters"] = 5] = "NameContainsNonURISafeCharacters"; + })(NameValidationResult = JsTyping.NameValidationResult || (JsTyping.NameValidationResult = {})); + var maxPackageNameLength = 214; + /** + * Validates package name using rules defined at https://docs.npmjs.com/files/package.json + */ + function validatePackageName(packageName) { + return validatePackageNameWorker(packageName, /*supportScopedPackage*/ true); + } + JsTyping.validatePackageName = validatePackageName; + function validatePackageNameWorker(packageName, supportScopedPackage) { + if (!packageName) { + return 1 /* NameValidationResult.EmptyName */; + } + if (packageName.length > maxPackageNameLength) { + return 2 /* NameValidationResult.NameTooLong */; + } + if (packageName.charCodeAt(0) === 46 /* CharacterCodes.dot */) { + return 3 /* NameValidationResult.NameStartsWithDot */; + } + if (packageName.charCodeAt(0) === 95 /* CharacterCodes._ */) { + return 4 /* NameValidationResult.NameStartsWithUnderscore */; + } + // check if name is scope package like: starts with @ and has one '/' in the middle + // scoped packages are not currently supported + if (supportScopedPackage) { + var matches = /^@([^/]+)\/([^/]+)$/.exec(packageName); + if (matches) { + var scopeResult = validatePackageNameWorker(matches[1], /*supportScopedPackage*/ false); + if (scopeResult !== 0 /* NameValidationResult.Ok */) { + return { name: matches[1], isScopeName: true, result: scopeResult }; + } + var packageResult = validatePackageNameWorker(matches[2], /*supportScopedPackage*/ false); + if (packageResult !== 0 /* NameValidationResult.Ok */) { + return { name: matches[2], isScopeName: false, result: packageResult }; + } + return 0 /* NameValidationResult.Ok */; + } + } + if (encodeURIComponent(packageName) !== packageName) { + return 5 /* NameValidationResult.NameContainsNonURISafeCharacters */; + } + return 0 /* NameValidationResult.Ok */; + } + function renderPackageNameValidationFailure(result, typing) { + return typeof result === "object" ? + renderPackageNameValidationFailureWorker(typing, result.result, result.name, result.isScopeName) : + renderPackageNameValidationFailureWorker(typing, result, typing, /*isScopeName*/ false); + } + JsTyping.renderPackageNameValidationFailure = renderPackageNameValidationFailure; + function renderPackageNameValidationFailureWorker(typing, result, name, isScopeName) { + var kind = isScopeName ? "Scope" : "Package"; + switch (result) { + case 1 /* NameValidationResult.EmptyName */: + return "'".concat(typing, "':: ").concat(kind, " name '").concat(name, "' cannot be empty"); + case 2 /* NameValidationResult.NameTooLong */: + return "'".concat(typing, "':: ").concat(kind, " name '").concat(name, "' should be less than ").concat(maxPackageNameLength, " characters"); + case 3 /* NameValidationResult.NameStartsWithDot */: + return "'".concat(typing, "':: ").concat(kind, " name '").concat(name, "' cannot start with '.'"); + case 4 /* NameValidationResult.NameStartsWithUnderscore */: + return "'".concat(typing, "':: ").concat(kind, " name '").concat(name, "' cannot start with '_'"); + case 5 /* NameValidationResult.NameContainsNonURISafeCharacters */: + return "'".concat(typing, "':: ").concat(kind, " name '").concat(name, "' contains non URI safe characters"); + case 0 /* NameValidationResult.Ok */: + return ts.Debug.fail(); // Shouldn't have called this. + default: + throw ts.Debug.assertNever(result); + } + } + })(JsTyping = ts.JsTyping || (ts.JsTyping = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + var ScriptSnapshot; + (function (ScriptSnapshot) { + var StringScriptSnapshot = /** @class */ (function () { + function StringScriptSnapshot(text) { + this.text = text; + } + StringScriptSnapshot.prototype.getText = function (start, end) { + return start === 0 && end === this.text.length + ? this.text + : this.text.substring(start, end); + }; + StringScriptSnapshot.prototype.getLength = function () { + return this.text.length; + }; + StringScriptSnapshot.prototype.getChangeRange = function () { + // Text-based snapshots do not support incremental parsing. Return undefined + // to signal that to the caller. + return undefined; + }; + return StringScriptSnapshot; + }()); + function fromString(text) { + return new StringScriptSnapshot(text); + } + ScriptSnapshot.fromString = fromString; + })(ScriptSnapshot = ts.ScriptSnapshot || (ts.ScriptSnapshot = {})); + /* @internal */ + var PackageJsonDependencyGroup; + (function (PackageJsonDependencyGroup) { + PackageJsonDependencyGroup[PackageJsonDependencyGroup["Dependencies"] = 1] = "Dependencies"; + PackageJsonDependencyGroup[PackageJsonDependencyGroup["DevDependencies"] = 2] = "DevDependencies"; + PackageJsonDependencyGroup[PackageJsonDependencyGroup["PeerDependencies"] = 4] = "PeerDependencies"; + PackageJsonDependencyGroup[PackageJsonDependencyGroup["OptionalDependencies"] = 8] = "OptionalDependencies"; + PackageJsonDependencyGroup[PackageJsonDependencyGroup["All"] = 15] = "All"; + })(PackageJsonDependencyGroup = ts.PackageJsonDependencyGroup || (ts.PackageJsonDependencyGroup = {})); + /* @internal */ + var PackageJsonAutoImportPreference; + (function (PackageJsonAutoImportPreference) { + PackageJsonAutoImportPreference[PackageJsonAutoImportPreference["Off"] = 0] = "Off"; + PackageJsonAutoImportPreference[PackageJsonAutoImportPreference["On"] = 1] = "On"; + PackageJsonAutoImportPreference[PackageJsonAutoImportPreference["Auto"] = 2] = "Auto"; + })(PackageJsonAutoImportPreference = ts.PackageJsonAutoImportPreference || (ts.PackageJsonAutoImportPreference = {})); + var LanguageServiceMode; + (function (LanguageServiceMode) { + LanguageServiceMode[LanguageServiceMode["Semantic"] = 0] = "Semantic"; + LanguageServiceMode[LanguageServiceMode["PartialSemantic"] = 1] = "PartialSemantic"; + LanguageServiceMode[LanguageServiceMode["Syntactic"] = 2] = "Syntactic"; + })(LanguageServiceMode = ts.LanguageServiceMode || (ts.LanguageServiceMode = {})); + /* @internal */ + ts.emptyOptions = {}; + var SemanticClassificationFormat; + (function (SemanticClassificationFormat) { + SemanticClassificationFormat["Original"] = "original"; + SemanticClassificationFormat["TwentyTwenty"] = "2020"; + })(SemanticClassificationFormat = ts.SemanticClassificationFormat || (ts.SemanticClassificationFormat = {})); + var OrganizeImportsMode; + (function (OrganizeImportsMode) { + OrganizeImportsMode["All"] = "All"; + OrganizeImportsMode["SortAndCombine"] = "SortAndCombine"; + OrganizeImportsMode["RemoveUnused"] = "RemoveUnused"; + })(OrganizeImportsMode = ts.OrganizeImportsMode || (ts.OrganizeImportsMode = {})); + var CompletionTriggerKind; + (function (CompletionTriggerKind) { + /** Completion was triggered by typing an identifier, manual invocation (e.g Ctrl+Space) or via API. */ + CompletionTriggerKind[CompletionTriggerKind["Invoked"] = 1] = "Invoked"; + /** Completion was triggered by a trigger character. */ + CompletionTriggerKind[CompletionTriggerKind["TriggerCharacter"] = 2] = "TriggerCharacter"; + /** Completion was re-triggered as the current completion list is incomplete. */ + CompletionTriggerKind[CompletionTriggerKind["TriggerForIncompleteCompletions"] = 3] = "TriggerForIncompleteCompletions"; + })(CompletionTriggerKind = ts.CompletionTriggerKind || (ts.CompletionTriggerKind = {})); + var InlayHintKind; + (function (InlayHintKind) { + InlayHintKind["Type"] = "Type"; + InlayHintKind["Parameter"] = "Parameter"; + InlayHintKind["Enum"] = "Enum"; + })(InlayHintKind = ts.InlayHintKind || (ts.InlayHintKind = {})); + var HighlightSpanKind; + (function (HighlightSpanKind) { + HighlightSpanKind["none"] = "none"; + HighlightSpanKind["definition"] = "definition"; + HighlightSpanKind["reference"] = "reference"; + HighlightSpanKind["writtenReference"] = "writtenReference"; + })(HighlightSpanKind = ts.HighlightSpanKind || (ts.HighlightSpanKind = {})); + var IndentStyle; + (function (IndentStyle) { + IndentStyle[IndentStyle["None"] = 0] = "None"; + IndentStyle[IndentStyle["Block"] = 1] = "Block"; + IndentStyle[IndentStyle["Smart"] = 2] = "Smart"; + })(IndentStyle = ts.IndentStyle || (ts.IndentStyle = {})); + var SemicolonPreference; + (function (SemicolonPreference) { + SemicolonPreference["Ignore"] = "ignore"; + SemicolonPreference["Insert"] = "insert"; + SemicolonPreference["Remove"] = "remove"; + })(SemicolonPreference = ts.SemicolonPreference || (ts.SemicolonPreference = {})); + function getDefaultFormatCodeSettings(newLineCharacter) { + return { + indentSize: 4, + tabSize: 4, + newLineCharacter: newLineCharacter || "\n", + convertTabsToSpaces: true, + indentStyle: IndentStyle.Smart, + insertSpaceAfterConstructor: false, + insertSpaceAfterCommaDelimiter: true, + insertSpaceAfterSemicolonInForStatements: true, + insertSpaceBeforeAndAfterBinaryOperators: true, + insertSpaceAfterKeywordsInControlFlowStatements: true, + insertSpaceAfterFunctionKeywordForAnonymousFunctions: false, + insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: false, + insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: false, + insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces: true, + insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: false, + insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces: false, + insertSpaceBeforeFunctionParenthesis: false, + placeOpenBraceOnNewLineForFunctions: false, + placeOpenBraceOnNewLineForControlBlocks: false, + semicolons: SemicolonPreference.Ignore, + trimTrailingWhitespace: true + }; + } + ts.getDefaultFormatCodeSettings = getDefaultFormatCodeSettings; + /* @internal */ + ts.testFormatSettings = getDefaultFormatCodeSettings("\n"); + var SymbolDisplayPartKind; + (function (SymbolDisplayPartKind) { + SymbolDisplayPartKind[SymbolDisplayPartKind["aliasName"] = 0] = "aliasName"; + SymbolDisplayPartKind[SymbolDisplayPartKind["className"] = 1] = "className"; + SymbolDisplayPartKind[SymbolDisplayPartKind["enumName"] = 2] = "enumName"; + SymbolDisplayPartKind[SymbolDisplayPartKind["fieldName"] = 3] = "fieldName"; + SymbolDisplayPartKind[SymbolDisplayPartKind["interfaceName"] = 4] = "interfaceName"; + SymbolDisplayPartKind[SymbolDisplayPartKind["keyword"] = 5] = "keyword"; + SymbolDisplayPartKind[SymbolDisplayPartKind["lineBreak"] = 6] = "lineBreak"; + SymbolDisplayPartKind[SymbolDisplayPartKind["numericLiteral"] = 7] = "numericLiteral"; + SymbolDisplayPartKind[SymbolDisplayPartKind["stringLiteral"] = 8] = "stringLiteral"; + SymbolDisplayPartKind[SymbolDisplayPartKind["localName"] = 9] = "localName"; + SymbolDisplayPartKind[SymbolDisplayPartKind["methodName"] = 10] = "methodName"; + SymbolDisplayPartKind[SymbolDisplayPartKind["moduleName"] = 11] = "moduleName"; + SymbolDisplayPartKind[SymbolDisplayPartKind["operator"] = 12] = "operator"; + SymbolDisplayPartKind[SymbolDisplayPartKind["parameterName"] = 13] = "parameterName"; + SymbolDisplayPartKind[SymbolDisplayPartKind["propertyName"] = 14] = "propertyName"; + SymbolDisplayPartKind[SymbolDisplayPartKind["punctuation"] = 15] = "punctuation"; + SymbolDisplayPartKind[SymbolDisplayPartKind["space"] = 16] = "space"; + SymbolDisplayPartKind[SymbolDisplayPartKind["text"] = 17] = "text"; + SymbolDisplayPartKind[SymbolDisplayPartKind["typeParameterName"] = 18] = "typeParameterName"; + SymbolDisplayPartKind[SymbolDisplayPartKind["enumMemberName"] = 19] = "enumMemberName"; + SymbolDisplayPartKind[SymbolDisplayPartKind["functionName"] = 20] = "functionName"; + SymbolDisplayPartKind[SymbolDisplayPartKind["regularExpressionLiteral"] = 21] = "regularExpressionLiteral"; + SymbolDisplayPartKind[SymbolDisplayPartKind["link"] = 22] = "link"; + SymbolDisplayPartKind[SymbolDisplayPartKind["linkName"] = 23] = "linkName"; + SymbolDisplayPartKind[SymbolDisplayPartKind["linkText"] = 24] = "linkText"; + })(SymbolDisplayPartKind = ts.SymbolDisplayPartKind || (ts.SymbolDisplayPartKind = {})); + // Do not change existing values, as they exist in telemetry. + var CompletionInfoFlags; + (function (CompletionInfoFlags) { + CompletionInfoFlags[CompletionInfoFlags["None"] = 0] = "None"; + CompletionInfoFlags[CompletionInfoFlags["MayIncludeAutoImports"] = 1] = "MayIncludeAutoImports"; + CompletionInfoFlags[CompletionInfoFlags["IsImportStatementCompletion"] = 2] = "IsImportStatementCompletion"; + CompletionInfoFlags[CompletionInfoFlags["IsContinuation"] = 4] = "IsContinuation"; + CompletionInfoFlags[CompletionInfoFlags["ResolvedModuleSpecifiers"] = 8] = "ResolvedModuleSpecifiers"; + CompletionInfoFlags[CompletionInfoFlags["ResolvedModuleSpecifiersBeyondLimit"] = 16] = "ResolvedModuleSpecifiersBeyondLimit"; + CompletionInfoFlags[CompletionInfoFlags["MayIncludeMethodSnippets"] = 32] = "MayIncludeMethodSnippets"; + })(CompletionInfoFlags = ts.CompletionInfoFlags || (ts.CompletionInfoFlags = {})); + var OutliningSpanKind; + (function (OutliningSpanKind) { + /** Single or multi-line comments */ + OutliningSpanKind["Comment"] = "comment"; + /** Sections marked by '// #region' and '// #endregion' comments */ + OutliningSpanKind["Region"] = "region"; + /** Declarations and expressions */ + OutliningSpanKind["Code"] = "code"; + /** Contiguous blocks of import declarations */ + OutliningSpanKind["Imports"] = "imports"; + })(OutliningSpanKind = ts.OutliningSpanKind || (ts.OutliningSpanKind = {})); + var OutputFileType; + (function (OutputFileType) { + OutputFileType[OutputFileType["JavaScript"] = 0] = "JavaScript"; + OutputFileType[OutputFileType["SourceMap"] = 1] = "SourceMap"; + OutputFileType[OutputFileType["Declaration"] = 2] = "Declaration"; + })(OutputFileType = ts.OutputFileType || (ts.OutputFileType = {})); + var EndOfLineState; + (function (EndOfLineState) { + EndOfLineState[EndOfLineState["None"] = 0] = "None"; + EndOfLineState[EndOfLineState["InMultiLineCommentTrivia"] = 1] = "InMultiLineCommentTrivia"; + EndOfLineState[EndOfLineState["InSingleQuoteStringLiteral"] = 2] = "InSingleQuoteStringLiteral"; + EndOfLineState[EndOfLineState["InDoubleQuoteStringLiteral"] = 3] = "InDoubleQuoteStringLiteral"; + EndOfLineState[EndOfLineState["InTemplateHeadOrNoSubstitutionTemplate"] = 4] = "InTemplateHeadOrNoSubstitutionTemplate"; + EndOfLineState[EndOfLineState["InTemplateMiddleOrTail"] = 5] = "InTemplateMiddleOrTail"; + EndOfLineState[EndOfLineState["InTemplateSubstitutionPosition"] = 6] = "InTemplateSubstitutionPosition"; + })(EndOfLineState = ts.EndOfLineState || (ts.EndOfLineState = {})); + var TokenClass; + (function (TokenClass) { + TokenClass[TokenClass["Punctuation"] = 0] = "Punctuation"; + TokenClass[TokenClass["Keyword"] = 1] = "Keyword"; + TokenClass[TokenClass["Operator"] = 2] = "Operator"; + TokenClass[TokenClass["Comment"] = 3] = "Comment"; + TokenClass[TokenClass["Whitespace"] = 4] = "Whitespace"; + TokenClass[TokenClass["Identifier"] = 5] = "Identifier"; + TokenClass[TokenClass["NumberLiteral"] = 6] = "NumberLiteral"; + TokenClass[TokenClass["BigIntLiteral"] = 7] = "BigIntLiteral"; + TokenClass[TokenClass["StringLiteral"] = 8] = "StringLiteral"; + TokenClass[TokenClass["RegExpLiteral"] = 9] = "RegExpLiteral"; + })(TokenClass = ts.TokenClass || (ts.TokenClass = {})); + var ScriptElementKind; + (function (ScriptElementKind) { + ScriptElementKind["unknown"] = ""; + ScriptElementKind["warning"] = "warning"; + /** predefined type (void) or keyword (class) */ + ScriptElementKind["keyword"] = "keyword"; + /** top level script node */ + ScriptElementKind["scriptElement"] = "script"; + /** module foo {} */ + ScriptElementKind["moduleElement"] = "module"; + /** class X {} */ + ScriptElementKind["classElement"] = "class"; + /** var x = class X {} */ + ScriptElementKind["localClassElement"] = "local class"; + /** interface Y {} */ + ScriptElementKind["interfaceElement"] = "interface"; + /** type T = ... */ + ScriptElementKind["typeElement"] = "type"; + /** enum E */ + ScriptElementKind["enumElement"] = "enum"; + ScriptElementKind["enumMemberElement"] = "enum member"; + /** + * Inside module and script only + * const v = .. + */ + ScriptElementKind["variableElement"] = "var"; + /** Inside function */ + ScriptElementKind["localVariableElement"] = "local var"; + /** + * Inside module and script only + * function f() { } + */ + ScriptElementKind["functionElement"] = "function"; + /** Inside function */ + ScriptElementKind["localFunctionElement"] = "local function"; + /** class X { [public|private]* foo() {} } */ + ScriptElementKind["memberFunctionElement"] = "method"; + /** class X { [public|private]* [get|set] foo:number; } */ + ScriptElementKind["memberGetAccessorElement"] = "getter"; + ScriptElementKind["memberSetAccessorElement"] = "setter"; + /** + * class X { [public|private]* foo:number; } + * interface Y { foo:number; } + */ + ScriptElementKind["memberVariableElement"] = "property"; + /** class X { [public|private]* accessor foo: number; } */ + ScriptElementKind["memberAccessorVariableElement"] = "accessor"; + /** + * class X { constructor() { } } + * class X { static { } } + */ + ScriptElementKind["constructorImplementationElement"] = "constructor"; + /** interface Y { ():number; } */ + ScriptElementKind["callSignatureElement"] = "call"; + /** interface Y { []:number; } */ + ScriptElementKind["indexSignatureElement"] = "index"; + /** interface Y { new():Y; } */ + ScriptElementKind["constructSignatureElement"] = "construct"; + /** function foo(*Y*: string) */ + ScriptElementKind["parameterElement"] = "parameter"; + ScriptElementKind["typeParameterElement"] = "type parameter"; + ScriptElementKind["primitiveType"] = "primitive type"; + ScriptElementKind["label"] = "label"; + ScriptElementKind["alias"] = "alias"; + ScriptElementKind["constElement"] = "const"; + ScriptElementKind["letElement"] = "let"; + ScriptElementKind["directory"] = "directory"; + ScriptElementKind["externalModuleName"] = "external module name"; + /** + * + * @deprecated + */ + ScriptElementKind["jsxAttribute"] = "JSX attribute"; + /** String literal */ + ScriptElementKind["string"] = "string"; + /** Jsdoc @link: in `{@link C link text}`, the before and after text "{@link " and "}" */ + ScriptElementKind["link"] = "link"; + /** Jsdoc @link: in `{@link C link text}`, the entity name "C" */ + ScriptElementKind["linkName"] = "link name"; + /** Jsdoc @link: in `{@link C link text}`, the link text "link text" */ + ScriptElementKind["linkText"] = "link text"; + })(ScriptElementKind = ts.ScriptElementKind || (ts.ScriptElementKind = {})); + var ScriptElementKindModifier; + (function (ScriptElementKindModifier) { + ScriptElementKindModifier["none"] = ""; + ScriptElementKindModifier["publicMemberModifier"] = "public"; + ScriptElementKindModifier["privateMemberModifier"] = "private"; + ScriptElementKindModifier["protectedMemberModifier"] = "protected"; + ScriptElementKindModifier["exportedModifier"] = "export"; + ScriptElementKindModifier["ambientModifier"] = "declare"; + ScriptElementKindModifier["staticModifier"] = "static"; + ScriptElementKindModifier["abstractModifier"] = "abstract"; + ScriptElementKindModifier["optionalModifier"] = "optional"; + ScriptElementKindModifier["deprecatedModifier"] = "deprecated"; + ScriptElementKindModifier["dtsModifier"] = ".d.ts"; + ScriptElementKindModifier["tsModifier"] = ".ts"; + ScriptElementKindModifier["tsxModifier"] = ".tsx"; + ScriptElementKindModifier["jsModifier"] = ".js"; + ScriptElementKindModifier["jsxModifier"] = ".jsx"; + ScriptElementKindModifier["jsonModifier"] = ".json"; + ScriptElementKindModifier["dmtsModifier"] = ".d.mts"; + ScriptElementKindModifier["mtsModifier"] = ".mts"; + ScriptElementKindModifier["mjsModifier"] = ".mjs"; + ScriptElementKindModifier["dctsModifier"] = ".d.cts"; + ScriptElementKindModifier["ctsModifier"] = ".cts"; + ScriptElementKindModifier["cjsModifier"] = ".cjs"; + })(ScriptElementKindModifier = ts.ScriptElementKindModifier || (ts.ScriptElementKindModifier = {})); + var ClassificationTypeNames; + (function (ClassificationTypeNames) { + ClassificationTypeNames["comment"] = "comment"; + ClassificationTypeNames["identifier"] = "identifier"; + ClassificationTypeNames["keyword"] = "keyword"; + ClassificationTypeNames["numericLiteral"] = "number"; + ClassificationTypeNames["bigintLiteral"] = "bigint"; + ClassificationTypeNames["operator"] = "operator"; + ClassificationTypeNames["stringLiteral"] = "string"; + ClassificationTypeNames["whiteSpace"] = "whitespace"; + ClassificationTypeNames["text"] = "text"; + ClassificationTypeNames["punctuation"] = "punctuation"; + ClassificationTypeNames["className"] = "class name"; + ClassificationTypeNames["enumName"] = "enum name"; + ClassificationTypeNames["interfaceName"] = "interface name"; + ClassificationTypeNames["moduleName"] = "module name"; + ClassificationTypeNames["typeParameterName"] = "type parameter name"; + ClassificationTypeNames["typeAliasName"] = "type alias name"; + ClassificationTypeNames["parameterName"] = "parameter name"; + ClassificationTypeNames["docCommentTagName"] = "doc comment tag name"; + ClassificationTypeNames["jsxOpenTagName"] = "jsx open tag name"; + ClassificationTypeNames["jsxCloseTagName"] = "jsx close tag name"; + ClassificationTypeNames["jsxSelfClosingTagName"] = "jsx self closing tag name"; + ClassificationTypeNames["jsxAttribute"] = "jsx attribute"; + ClassificationTypeNames["jsxText"] = "jsx text"; + ClassificationTypeNames["jsxAttributeStringLiteralValue"] = "jsx attribute string literal value"; + })(ClassificationTypeNames = ts.ClassificationTypeNames || (ts.ClassificationTypeNames = {})); + var ClassificationType; + (function (ClassificationType) { + ClassificationType[ClassificationType["comment"] = 1] = "comment"; + ClassificationType[ClassificationType["identifier"] = 2] = "identifier"; + ClassificationType[ClassificationType["keyword"] = 3] = "keyword"; + ClassificationType[ClassificationType["numericLiteral"] = 4] = "numericLiteral"; + ClassificationType[ClassificationType["operator"] = 5] = "operator"; + ClassificationType[ClassificationType["stringLiteral"] = 6] = "stringLiteral"; + ClassificationType[ClassificationType["regularExpressionLiteral"] = 7] = "regularExpressionLiteral"; + ClassificationType[ClassificationType["whiteSpace"] = 8] = "whiteSpace"; + ClassificationType[ClassificationType["text"] = 9] = "text"; + ClassificationType[ClassificationType["punctuation"] = 10] = "punctuation"; + ClassificationType[ClassificationType["className"] = 11] = "className"; + ClassificationType[ClassificationType["enumName"] = 12] = "enumName"; + ClassificationType[ClassificationType["interfaceName"] = 13] = "interfaceName"; + ClassificationType[ClassificationType["moduleName"] = 14] = "moduleName"; + ClassificationType[ClassificationType["typeParameterName"] = 15] = "typeParameterName"; + ClassificationType[ClassificationType["typeAliasName"] = 16] = "typeAliasName"; + ClassificationType[ClassificationType["parameterName"] = 17] = "parameterName"; + ClassificationType[ClassificationType["docCommentTagName"] = 18] = "docCommentTagName"; + ClassificationType[ClassificationType["jsxOpenTagName"] = 19] = "jsxOpenTagName"; + ClassificationType[ClassificationType["jsxCloseTagName"] = 20] = "jsxCloseTagName"; + ClassificationType[ClassificationType["jsxSelfClosingTagName"] = 21] = "jsxSelfClosingTagName"; + ClassificationType[ClassificationType["jsxAttribute"] = 22] = "jsxAttribute"; + ClassificationType[ClassificationType["jsxText"] = 23] = "jsxText"; + ClassificationType[ClassificationType["jsxAttributeStringLiteralValue"] = 24] = "jsxAttributeStringLiteralValue"; + ClassificationType[ClassificationType["bigintLiteral"] = 25] = "bigintLiteral"; + })(ClassificationType = ts.ClassificationType || (ts.ClassificationType = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + // These utilities are common to multiple language service features. + //#region + ts.scanner = ts.createScanner(99 /* ScriptTarget.Latest */, /*skipTrivia*/ true); + var SemanticMeaning; + (function (SemanticMeaning) { + SemanticMeaning[SemanticMeaning["None"] = 0] = "None"; + SemanticMeaning[SemanticMeaning["Value"] = 1] = "Value"; + SemanticMeaning[SemanticMeaning["Type"] = 2] = "Type"; + SemanticMeaning[SemanticMeaning["Namespace"] = 4] = "Namespace"; + SemanticMeaning[SemanticMeaning["All"] = 7] = "All"; + })(SemanticMeaning = ts.SemanticMeaning || (ts.SemanticMeaning = {})); + function getMeaningFromDeclaration(node) { + switch (node.kind) { + case 257 /* SyntaxKind.VariableDeclaration */: + return ts.isInJSFile(node) && ts.getJSDocEnumTag(node) ? 7 /* SemanticMeaning.All */ : 1 /* SemanticMeaning.Value */; + case 166 /* SyntaxKind.Parameter */: + case 205 /* SyntaxKind.BindingElement */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 168 /* SyntaxKind.PropertySignature */: + case 299 /* SyntaxKind.PropertyAssignment */: + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + case 173 /* SyntaxKind.Constructor */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + case 295 /* SyntaxKind.CatchClause */: + case 288 /* SyntaxKind.JsxAttribute */: + return 1 /* SemanticMeaning.Value */; + case 165 /* SyntaxKind.TypeParameter */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 184 /* SyntaxKind.TypeLiteral */: + return 2 /* SemanticMeaning.Type */; + case 348 /* SyntaxKind.JSDocTypedefTag */: + // If it has no name node, it shares the name with the value declaration below it. + return node.name === undefined ? 1 /* SemanticMeaning.Value */ | 2 /* SemanticMeaning.Type */ : 2 /* SemanticMeaning.Type */; + case 302 /* SyntaxKind.EnumMember */: + case 260 /* SyntaxKind.ClassDeclaration */: + return 1 /* SemanticMeaning.Value */ | 2 /* SemanticMeaning.Type */; + case 264 /* SyntaxKind.ModuleDeclaration */: + if (ts.isAmbientModule(node)) { + return 4 /* SemanticMeaning.Namespace */ | 1 /* SemanticMeaning.Value */; + } + else if (ts.getModuleInstanceState(node) === 1 /* ModuleInstanceState.Instantiated */) { + return 4 /* SemanticMeaning.Namespace */ | 1 /* SemanticMeaning.Value */; + } + else { + return 4 /* SemanticMeaning.Namespace */; + } + case 263 /* SyntaxKind.EnumDeclaration */: + case 272 /* SyntaxKind.NamedImports */: + case 273 /* SyntaxKind.ImportSpecifier */: + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + case 269 /* SyntaxKind.ImportDeclaration */: + case 274 /* SyntaxKind.ExportAssignment */: + case 275 /* SyntaxKind.ExportDeclaration */: + return 7 /* SemanticMeaning.All */; + // An external module can be a Value + case 308 /* SyntaxKind.SourceFile */: + return 4 /* SemanticMeaning.Namespace */ | 1 /* SemanticMeaning.Value */; + } + return 7 /* SemanticMeaning.All */; + } + ts.getMeaningFromDeclaration = getMeaningFromDeclaration; + function getMeaningFromLocation(node) { + node = getAdjustedReferenceLocation(node); + var parent = node.parent; + if (node.kind === 308 /* SyntaxKind.SourceFile */) { + return 1 /* SemanticMeaning.Value */; + } + else if (ts.isExportAssignment(parent) + || ts.isExportSpecifier(parent) + || ts.isExternalModuleReference(parent) + || ts.isImportSpecifier(parent) + || ts.isImportClause(parent) + || ts.isImportEqualsDeclaration(parent) && node === parent.name) { + return 7 /* SemanticMeaning.All */; + } + else if (isInRightSideOfInternalImportEqualsDeclaration(node)) { + return getMeaningFromRightHandSideOfImportEquals(node); + } + else if (ts.isDeclarationName(node)) { + return getMeaningFromDeclaration(parent); + } + else if (ts.isEntityName(node) && ts.findAncestor(node, ts.or(ts.isJSDocNameReference, ts.isJSDocLinkLike, ts.isJSDocMemberName))) { + return 7 /* SemanticMeaning.All */; + } + else if (isTypeReference(node)) { + return 2 /* SemanticMeaning.Type */; + } + else if (isNamespaceReference(node)) { + return 4 /* SemanticMeaning.Namespace */; + } + else if (ts.isTypeParameterDeclaration(parent)) { + ts.Debug.assert(ts.isJSDocTemplateTag(parent.parent)); // Else would be handled by isDeclarationName + return 2 /* SemanticMeaning.Type */; + } + else if (ts.isLiteralTypeNode(parent)) { + // This might be T["name"], which is actually referencing a property and not a type. So allow both meanings. + return 2 /* SemanticMeaning.Type */ | 1 /* SemanticMeaning.Value */; + } + else { + return 1 /* SemanticMeaning.Value */; + } + } + ts.getMeaningFromLocation = getMeaningFromLocation; + function getMeaningFromRightHandSideOfImportEquals(node) { + // import a = |b|; // Namespace + // import a = |b.c|; // Value, type, namespace + // import a = |b.c|.d; // Namespace + var name = node.kind === 163 /* SyntaxKind.QualifiedName */ ? node : ts.isQualifiedName(node.parent) && node.parent.right === node ? node.parent : undefined; + return name && name.parent.kind === 268 /* SyntaxKind.ImportEqualsDeclaration */ ? 7 /* SemanticMeaning.All */ : 4 /* SemanticMeaning.Namespace */; + } + function isInRightSideOfInternalImportEqualsDeclaration(node) { + while (node.parent.kind === 163 /* SyntaxKind.QualifiedName */) { + node = node.parent; + } + return ts.isInternalModuleImportEqualsDeclaration(node.parent) && node.parent.moduleReference === node; + } + ts.isInRightSideOfInternalImportEqualsDeclaration = isInRightSideOfInternalImportEqualsDeclaration; + function isNamespaceReference(node) { + return isQualifiedNameNamespaceReference(node) || isPropertyAccessNamespaceReference(node); + } + function isQualifiedNameNamespaceReference(node) { + var root = node; + var isLastClause = true; + if (root.parent.kind === 163 /* SyntaxKind.QualifiedName */) { + while (root.parent && root.parent.kind === 163 /* SyntaxKind.QualifiedName */) { + root = root.parent; + } + isLastClause = root.right === node; + } + return root.parent.kind === 180 /* SyntaxKind.TypeReference */ && !isLastClause; + } + function isPropertyAccessNamespaceReference(node) { + var root = node; + var isLastClause = true; + if (root.parent.kind === 208 /* SyntaxKind.PropertyAccessExpression */) { + while (root.parent && root.parent.kind === 208 /* SyntaxKind.PropertyAccessExpression */) { + root = root.parent; + } + isLastClause = root.name === node; + } + if (!isLastClause && root.parent.kind === 230 /* SyntaxKind.ExpressionWithTypeArguments */ && root.parent.parent.kind === 294 /* SyntaxKind.HeritageClause */) { + var decl = root.parent.parent.parent; + return (decl.kind === 260 /* SyntaxKind.ClassDeclaration */ && root.parent.parent.token === 117 /* SyntaxKind.ImplementsKeyword */) || + (decl.kind === 261 /* SyntaxKind.InterfaceDeclaration */ && root.parent.parent.token === 94 /* SyntaxKind.ExtendsKeyword */); + } + return false; + } + function isTypeReference(node) { + if (ts.isRightSideOfQualifiedNameOrPropertyAccess(node)) { + node = node.parent; + } + switch (node.kind) { + case 108 /* SyntaxKind.ThisKeyword */: + return !ts.isExpressionNode(node); + case 194 /* SyntaxKind.ThisType */: + return true; + } + switch (node.parent.kind) { + case 180 /* SyntaxKind.TypeReference */: + return true; + case 202 /* SyntaxKind.ImportType */: + return !node.parent.isTypeOf; + case 230 /* SyntaxKind.ExpressionWithTypeArguments */: + return ts.isPartOfTypeNode(node.parent); + } + return false; + } + function isCallExpressionTarget(node, includeElementAccess, skipPastOuterExpressions) { + if (includeElementAccess === void 0) { includeElementAccess = false; } + if (skipPastOuterExpressions === void 0) { skipPastOuterExpressions = false; } + return isCalleeWorker(node, ts.isCallExpression, selectExpressionOfCallOrNewExpressionOrDecorator, includeElementAccess, skipPastOuterExpressions); + } + ts.isCallExpressionTarget = isCallExpressionTarget; + function isNewExpressionTarget(node, includeElementAccess, skipPastOuterExpressions) { + if (includeElementAccess === void 0) { includeElementAccess = false; } + if (skipPastOuterExpressions === void 0) { skipPastOuterExpressions = false; } + return isCalleeWorker(node, ts.isNewExpression, selectExpressionOfCallOrNewExpressionOrDecorator, includeElementAccess, skipPastOuterExpressions); + } + ts.isNewExpressionTarget = isNewExpressionTarget; + function isCallOrNewExpressionTarget(node, includeElementAccess, skipPastOuterExpressions) { + if (includeElementAccess === void 0) { includeElementAccess = false; } + if (skipPastOuterExpressions === void 0) { skipPastOuterExpressions = false; } + return isCalleeWorker(node, ts.isCallOrNewExpression, selectExpressionOfCallOrNewExpressionOrDecorator, includeElementAccess, skipPastOuterExpressions); + } + ts.isCallOrNewExpressionTarget = isCallOrNewExpressionTarget; + function isTaggedTemplateTag(node, includeElementAccess, skipPastOuterExpressions) { + if (includeElementAccess === void 0) { includeElementAccess = false; } + if (skipPastOuterExpressions === void 0) { skipPastOuterExpressions = false; } + return isCalleeWorker(node, ts.isTaggedTemplateExpression, selectTagOfTaggedTemplateExpression, includeElementAccess, skipPastOuterExpressions); + } + ts.isTaggedTemplateTag = isTaggedTemplateTag; + function isDecoratorTarget(node, includeElementAccess, skipPastOuterExpressions) { + if (includeElementAccess === void 0) { includeElementAccess = false; } + if (skipPastOuterExpressions === void 0) { skipPastOuterExpressions = false; } + return isCalleeWorker(node, ts.isDecorator, selectExpressionOfCallOrNewExpressionOrDecorator, includeElementAccess, skipPastOuterExpressions); + } + ts.isDecoratorTarget = isDecoratorTarget; + function isJsxOpeningLikeElementTagName(node, includeElementAccess, skipPastOuterExpressions) { + if (includeElementAccess === void 0) { includeElementAccess = false; } + if (skipPastOuterExpressions === void 0) { skipPastOuterExpressions = false; } + return isCalleeWorker(node, ts.isJsxOpeningLikeElement, selectTagNameOfJsxOpeningLikeElement, includeElementAccess, skipPastOuterExpressions); + } + ts.isJsxOpeningLikeElementTagName = isJsxOpeningLikeElementTagName; + function selectExpressionOfCallOrNewExpressionOrDecorator(node) { + return node.expression; + } + function selectTagOfTaggedTemplateExpression(node) { + return node.tag; + } + function selectTagNameOfJsxOpeningLikeElement(node) { + return node.tagName; + } + function isCalleeWorker(node, pred, calleeSelector, includeElementAccess, skipPastOuterExpressions) { + var target = includeElementAccess ? climbPastPropertyOrElementAccess(node) : climbPastPropertyAccess(node); + if (skipPastOuterExpressions) { + target = ts.skipOuterExpressions(target); + } + return !!target && !!target.parent && pred(target.parent) && calleeSelector(target.parent) === target; + } + function climbPastPropertyAccess(node) { + return isRightSideOfPropertyAccess(node) ? node.parent : node; + } + ts.climbPastPropertyAccess = climbPastPropertyAccess; + function climbPastPropertyOrElementAccess(node) { + return isRightSideOfPropertyAccess(node) || isArgumentExpressionOfElementAccess(node) ? node.parent : node; + } + ts.climbPastPropertyOrElementAccess = climbPastPropertyOrElementAccess; + function getTargetLabel(referenceNode, labelName) { + while (referenceNode) { + if (referenceNode.kind === 253 /* SyntaxKind.LabeledStatement */ && referenceNode.label.escapedText === labelName) { + return referenceNode.label; + } + referenceNode = referenceNode.parent; + } + return undefined; + } + ts.getTargetLabel = getTargetLabel; + function hasPropertyAccessExpressionWithName(node, funcName) { + if (!ts.isPropertyAccessExpression(node.expression)) { + return false; + } + return node.expression.name.text === funcName; + } + ts.hasPropertyAccessExpressionWithName = hasPropertyAccessExpressionWithName; + function isJumpStatementTarget(node) { + var _a; + return ts.isIdentifier(node) && ((_a = ts.tryCast(node.parent, ts.isBreakOrContinueStatement)) === null || _a === void 0 ? void 0 : _a.label) === node; + } + ts.isJumpStatementTarget = isJumpStatementTarget; + function isLabelOfLabeledStatement(node) { + var _a; + return ts.isIdentifier(node) && ((_a = ts.tryCast(node.parent, ts.isLabeledStatement)) === null || _a === void 0 ? void 0 : _a.label) === node; + } + ts.isLabelOfLabeledStatement = isLabelOfLabeledStatement; + function isLabelName(node) { + return isLabelOfLabeledStatement(node) || isJumpStatementTarget(node); + } + ts.isLabelName = isLabelName; + function isTagName(node) { + var _a; + return ((_a = ts.tryCast(node.parent, ts.isJSDocTag)) === null || _a === void 0 ? void 0 : _a.tagName) === node; + } + ts.isTagName = isTagName; + function isRightSideOfQualifiedName(node) { + var _a; + return ((_a = ts.tryCast(node.parent, ts.isQualifiedName)) === null || _a === void 0 ? void 0 : _a.right) === node; + } + ts.isRightSideOfQualifiedName = isRightSideOfQualifiedName; + function isRightSideOfPropertyAccess(node) { + var _a; + return ((_a = ts.tryCast(node.parent, ts.isPropertyAccessExpression)) === null || _a === void 0 ? void 0 : _a.name) === node; + } + ts.isRightSideOfPropertyAccess = isRightSideOfPropertyAccess; + function isArgumentExpressionOfElementAccess(node) { + var _a; + return ((_a = ts.tryCast(node.parent, ts.isElementAccessExpression)) === null || _a === void 0 ? void 0 : _a.argumentExpression) === node; + } + ts.isArgumentExpressionOfElementAccess = isArgumentExpressionOfElementAccess; + function isNameOfModuleDeclaration(node) { + var _a; + return ((_a = ts.tryCast(node.parent, ts.isModuleDeclaration)) === null || _a === void 0 ? void 0 : _a.name) === node; + } + ts.isNameOfModuleDeclaration = isNameOfModuleDeclaration; + function isNameOfFunctionDeclaration(node) { + var _a; + return ts.isIdentifier(node) && ((_a = ts.tryCast(node.parent, ts.isFunctionLike)) === null || _a === void 0 ? void 0 : _a.name) === node; + } + ts.isNameOfFunctionDeclaration = isNameOfFunctionDeclaration; + function isLiteralNameOfPropertyDeclarationOrIndexAccess(node) { + switch (node.parent.kind) { + case 169 /* SyntaxKind.PropertyDeclaration */: + case 168 /* SyntaxKind.PropertySignature */: + case 299 /* SyntaxKind.PropertyAssignment */: + case 302 /* SyntaxKind.EnumMember */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 264 /* SyntaxKind.ModuleDeclaration */: + return ts.getNameOfDeclaration(node.parent) === node; + case 209 /* SyntaxKind.ElementAccessExpression */: + return node.parent.argumentExpression === node; + case 164 /* SyntaxKind.ComputedPropertyName */: + return true; + case 198 /* SyntaxKind.LiteralType */: + return node.parent.parent.kind === 196 /* SyntaxKind.IndexedAccessType */; + default: + return false; + } + } + ts.isLiteralNameOfPropertyDeclarationOrIndexAccess = isLiteralNameOfPropertyDeclarationOrIndexAccess; + function isExpressionOfExternalModuleImportEqualsDeclaration(node) { + return ts.isExternalModuleImportEqualsDeclaration(node.parent.parent) && + ts.getExternalModuleImportEqualsDeclarationExpression(node.parent.parent) === node; + } + ts.isExpressionOfExternalModuleImportEqualsDeclaration = isExpressionOfExternalModuleImportEqualsDeclaration; + function getContainerNode(node) { + if (ts.isJSDocTypeAlias(node)) { + // This doesn't just apply to the node immediately under the comment, but to everything in its parent's scope. + // node.parent = the JSDoc comment, node.parent.parent = the node having the comment. + // Then we get parent again in the loop. + node = node.parent.parent; + } + while (true) { + node = node.parent; + if (!node) { + return undefined; + } + switch (node.kind) { + case 308 /* SyntaxKind.SourceFile */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 264 /* SyntaxKind.ModuleDeclaration */: + return node; + } + } + } + ts.getContainerNode = getContainerNode; + function getNodeKind(node) { + switch (node.kind) { + case 308 /* SyntaxKind.SourceFile */: + return ts.isExternalModule(node) ? "module" /* ScriptElementKind.moduleElement */ : "script" /* ScriptElementKind.scriptElement */; + case 264 /* SyntaxKind.ModuleDeclaration */: + return "module" /* ScriptElementKind.moduleElement */; + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + return "class" /* ScriptElementKind.classElement */; + case 261 /* SyntaxKind.InterfaceDeclaration */: return "interface" /* ScriptElementKind.interfaceElement */; + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 341 /* SyntaxKind.JSDocCallbackTag */: + case 348 /* SyntaxKind.JSDocTypedefTag */: + return "type" /* ScriptElementKind.typeElement */; + case 263 /* SyntaxKind.EnumDeclaration */: return "enum" /* ScriptElementKind.enumElement */; + case 257 /* SyntaxKind.VariableDeclaration */: + return getKindOfVariableDeclaration(node); + case 205 /* SyntaxKind.BindingElement */: + return getKindOfVariableDeclaration(ts.getRootDeclaration(node)); + case 216 /* SyntaxKind.ArrowFunction */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + return "function" /* ScriptElementKind.functionElement */; + case 174 /* SyntaxKind.GetAccessor */: return "getter" /* ScriptElementKind.memberGetAccessorElement */; + case 175 /* SyntaxKind.SetAccessor */: return "setter" /* ScriptElementKind.memberSetAccessorElement */; + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + return "method" /* ScriptElementKind.memberFunctionElement */; + case 299 /* SyntaxKind.PropertyAssignment */: + var initializer = node.initializer; + return ts.isFunctionLike(initializer) ? "method" /* ScriptElementKind.memberFunctionElement */ : "property" /* ScriptElementKind.memberVariableElement */; + case 169 /* SyntaxKind.PropertyDeclaration */: + case 168 /* SyntaxKind.PropertySignature */: + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + case 301 /* SyntaxKind.SpreadAssignment */: + return "property" /* ScriptElementKind.memberVariableElement */; + case 178 /* SyntaxKind.IndexSignature */: return "index" /* ScriptElementKind.indexSignatureElement */; + case 177 /* SyntaxKind.ConstructSignature */: return "construct" /* ScriptElementKind.constructSignatureElement */; + case 176 /* SyntaxKind.CallSignature */: return "call" /* ScriptElementKind.callSignatureElement */; + case 173 /* SyntaxKind.Constructor */: + case 172 /* SyntaxKind.ClassStaticBlockDeclaration */: + return "constructor" /* ScriptElementKind.constructorImplementationElement */; + case 165 /* SyntaxKind.TypeParameter */: return "type parameter" /* ScriptElementKind.typeParameterElement */; + case 302 /* SyntaxKind.EnumMember */: return "enum member" /* ScriptElementKind.enumMemberElement */; + case 166 /* SyntaxKind.Parameter */: return ts.hasSyntacticModifier(node, 16476 /* ModifierFlags.ParameterPropertyModifier */) ? "property" /* ScriptElementKind.memberVariableElement */ : "parameter" /* ScriptElementKind.parameterElement */; + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + case 273 /* SyntaxKind.ImportSpecifier */: + case 278 /* SyntaxKind.ExportSpecifier */: + case 271 /* SyntaxKind.NamespaceImport */: + case 277 /* SyntaxKind.NamespaceExport */: + return "alias" /* ScriptElementKind.alias */; + case 223 /* SyntaxKind.BinaryExpression */: + var kind = ts.getAssignmentDeclarationKind(node); + var right = node.right; + switch (kind) { + case 7 /* AssignmentDeclarationKind.ObjectDefinePropertyValue */: + case 8 /* AssignmentDeclarationKind.ObjectDefinePropertyExports */: + case 9 /* AssignmentDeclarationKind.ObjectDefinePrototypeProperty */: + case 0 /* AssignmentDeclarationKind.None */: + return "" /* ScriptElementKind.unknown */; + case 1 /* AssignmentDeclarationKind.ExportsProperty */: + case 2 /* AssignmentDeclarationKind.ModuleExports */: + var rightKind = getNodeKind(right); + return rightKind === "" /* ScriptElementKind.unknown */ ? "const" /* ScriptElementKind.constElement */ : rightKind; + case 3 /* AssignmentDeclarationKind.PrototypeProperty */: + return ts.isFunctionExpression(right) ? "method" /* ScriptElementKind.memberFunctionElement */ : "property" /* ScriptElementKind.memberVariableElement */; + case 4 /* AssignmentDeclarationKind.ThisProperty */: + return "property" /* ScriptElementKind.memberVariableElement */; // property + case 5 /* AssignmentDeclarationKind.Property */: + // static method / property + return ts.isFunctionExpression(right) ? "method" /* ScriptElementKind.memberFunctionElement */ : "property" /* ScriptElementKind.memberVariableElement */; + case 6 /* AssignmentDeclarationKind.Prototype */: + return "local class" /* ScriptElementKind.localClassElement */; + default: { + ts.assertType(kind); + return "" /* ScriptElementKind.unknown */; + } + } + case 79 /* SyntaxKind.Identifier */: + return ts.isImportClause(node.parent) ? "alias" /* ScriptElementKind.alias */ : "" /* ScriptElementKind.unknown */; + case 274 /* SyntaxKind.ExportAssignment */: + var scriptKind = getNodeKind(node.expression); + // If the expression didn't come back with something (like it does for an identifiers) + return scriptKind === "" /* ScriptElementKind.unknown */ ? "const" /* ScriptElementKind.constElement */ : scriptKind; + default: + return "" /* ScriptElementKind.unknown */; + } + function getKindOfVariableDeclaration(v) { + return ts.isVarConst(v) + ? "const" /* ScriptElementKind.constElement */ + : ts.isLet(v) + ? "let" /* ScriptElementKind.letElement */ + : "var" /* ScriptElementKind.variableElement */; + } + } + ts.getNodeKind = getNodeKind; + function isThis(node) { + switch (node.kind) { + case 108 /* SyntaxKind.ThisKeyword */: + // case SyntaxKind.ThisType: TODO: GH#9267 + return true; + case 79 /* SyntaxKind.Identifier */: + // 'this' as a parameter + return ts.identifierIsThisKeyword(node) && node.parent.kind === 166 /* SyntaxKind.Parameter */; + default: + return false; + } + } + ts.isThis = isThis; + // Matches the beginning of a triple slash directive + var tripleSlashDirectivePrefixRegex = /^\/\/\/\s*= range.end; + } + ts.startEndContainsRange = startEndContainsRange; + function rangeContainsStartEnd(range, start, end) { + return range.pos <= start && range.end >= end; + } + ts.rangeContainsStartEnd = rangeContainsStartEnd; + function rangeOverlapsWithStartEnd(r1, start, end) { + return startEndOverlapsWithStartEnd(r1.pos, r1.end, start, end); + } + ts.rangeOverlapsWithStartEnd = rangeOverlapsWithStartEnd; + function nodeOverlapsWithStartEnd(node, sourceFile, start, end) { + return startEndOverlapsWithStartEnd(node.getStart(sourceFile), node.end, start, end); + } + ts.nodeOverlapsWithStartEnd = nodeOverlapsWithStartEnd; + function startEndOverlapsWithStartEnd(start1, end1, start2, end2) { + var start = Math.max(start1, start2); + var end = Math.min(end1, end2); + return start < end; + } + ts.startEndOverlapsWithStartEnd = startEndOverlapsWithStartEnd; + /** + * Assumes `candidate.start <= position` holds. + */ + function positionBelongsToNode(candidate, position, sourceFile) { + ts.Debug.assert(candidate.pos <= position); + return position < candidate.end || !isCompletedNode(candidate, sourceFile); + } + ts.positionBelongsToNode = positionBelongsToNode; + function isCompletedNode(n, sourceFile) { + if (n === undefined || ts.nodeIsMissing(n)) { + return false; + } + switch (n.kind) { + case 260 /* SyntaxKind.ClassDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 207 /* SyntaxKind.ObjectLiteralExpression */: + case 203 /* SyntaxKind.ObjectBindingPattern */: + case 184 /* SyntaxKind.TypeLiteral */: + case 238 /* SyntaxKind.Block */: + case 265 /* SyntaxKind.ModuleBlock */: + case 266 /* SyntaxKind.CaseBlock */: + case 272 /* SyntaxKind.NamedImports */: + case 276 /* SyntaxKind.NamedExports */: + return nodeEndsWith(n, 19 /* SyntaxKind.CloseBraceToken */, sourceFile); + case 295 /* SyntaxKind.CatchClause */: + return isCompletedNode(n.block, sourceFile); + case 211 /* SyntaxKind.NewExpression */: + if (!n.arguments) { + return true; + } + // falls through + case 210 /* SyntaxKind.CallExpression */: + case 214 /* SyntaxKind.ParenthesizedExpression */: + case 193 /* SyntaxKind.ParenthesizedType */: + return nodeEndsWith(n, 21 /* SyntaxKind.CloseParenToken */, sourceFile); + case 181 /* SyntaxKind.FunctionType */: + case 182 /* SyntaxKind.ConstructorType */: + return isCompletedNode(n.type, sourceFile); + case 173 /* SyntaxKind.Constructor */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + case 177 /* SyntaxKind.ConstructSignature */: + case 176 /* SyntaxKind.CallSignature */: + case 216 /* SyntaxKind.ArrowFunction */: + if (n.body) { + return isCompletedNode(n.body, sourceFile); + } + if (n.type) { + return isCompletedNode(n.type, sourceFile); + } + // Even though type parameters can be unclosed, we can get away with + // having at least a closing paren. + return hasChildOfKind(n, 21 /* SyntaxKind.CloseParenToken */, sourceFile); + case 264 /* SyntaxKind.ModuleDeclaration */: + return !!n.body && isCompletedNode(n.body, sourceFile); + case 242 /* SyntaxKind.IfStatement */: + if (n.elseStatement) { + return isCompletedNode(n.elseStatement, sourceFile); + } + return isCompletedNode(n.thenStatement, sourceFile); + case 241 /* SyntaxKind.ExpressionStatement */: + return isCompletedNode(n.expression, sourceFile) || + hasChildOfKind(n, 26 /* SyntaxKind.SemicolonToken */, sourceFile); + case 206 /* SyntaxKind.ArrayLiteralExpression */: + case 204 /* SyntaxKind.ArrayBindingPattern */: + case 209 /* SyntaxKind.ElementAccessExpression */: + case 164 /* SyntaxKind.ComputedPropertyName */: + case 186 /* SyntaxKind.TupleType */: + return nodeEndsWith(n, 23 /* SyntaxKind.CloseBracketToken */, sourceFile); + case 178 /* SyntaxKind.IndexSignature */: + if (n.type) { + return isCompletedNode(n.type, sourceFile); + } + return hasChildOfKind(n, 23 /* SyntaxKind.CloseBracketToken */, sourceFile); + case 292 /* SyntaxKind.CaseClause */: + case 293 /* SyntaxKind.DefaultClause */: + // there is no such thing as terminator token for CaseClause/DefaultClause so for simplicity always consider them non-completed + return false; + case 245 /* SyntaxKind.ForStatement */: + case 246 /* SyntaxKind.ForInStatement */: + case 247 /* SyntaxKind.ForOfStatement */: + case 244 /* SyntaxKind.WhileStatement */: + return isCompletedNode(n.statement, sourceFile); + case 243 /* SyntaxKind.DoStatement */: + // rough approximation: if DoStatement has While keyword - then if node is completed is checking the presence of ')'; + return hasChildOfKind(n, 115 /* SyntaxKind.WhileKeyword */, sourceFile) + ? nodeEndsWith(n, 21 /* SyntaxKind.CloseParenToken */, sourceFile) + : isCompletedNode(n.statement, sourceFile); + case 183 /* SyntaxKind.TypeQuery */: + return isCompletedNode(n.exprName, sourceFile); + case 218 /* SyntaxKind.TypeOfExpression */: + case 217 /* SyntaxKind.DeleteExpression */: + case 219 /* SyntaxKind.VoidExpression */: + case 226 /* SyntaxKind.YieldExpression */: + case 227 /* SyntaxKind.SpreadElement */: + var unaryWordExpression = n; + return isCompletedNode(unaryWordExpression.expression, sourceFile); + case 212 /* SyntaxKind.TaggedTemplateExpression */: + return isCompletedNode(n.template, sourceFile); + case 225 /* SyntaxKind.TemplateExpression */: + var lastSpan = ts.lastOrUndefined(n.templateSpans); + return isCompletedNode(lastSpan, sourceFile); + case 236 /* SyntaxKind.TemplateSpan */: + return ts.nodeIsPresent(n.literal); + case 275 /* SyntaxKind.ExportDeclaration */: + case 269 /* SyntaxKind.ImportDeclaration */: + return ts.nodeIsPresent(n.moduleSpecifier); + case 221 /* SyntaxKind.PrefixUnaryExpression */: + return isCompletedNode(n.operand, sourceFile); + case 223 /* SyntaxKind.BinaryExpression */: + return isCompletedNode(n.right, sourceFile); + case 224 /* SyntaxKind.ConditionalExpression */: + return isCompletedNode(n.whenFalse, sourceFile); + default: + return true; + } + } + /* + * Checks if node ends with 'expectedLastToken'. + * If child at position 'length - 1' is 'SemicolonToken' it is skipped and 'expectedLastToken' is compared with child at position 'length - 2'. + */ + function nodeEndsWith(n, expectedLastToken, sourceFile) { + var children = n.getChildren(sourceFile); + if (children.length) { + var lastChild = ts.last(children); + if (lastChild.kind === expectedLastToken) { + return true; + } + else if (lastChild.kind === 26 /* SyntaxKind.SemicolonToken */ && children.length !== 1) { + return children[children.length - 2].kind === expectedLastToken; + } + } + return false; + } + function findListItemInfo(node) { + var list = findContainingList(node); + // It is possible at this point for syntaxList to be undefined, either if + // node.parent had no list child, or if none of its list children contained + // the span of node. If this happens, return undefined. The caller should + // handle this case. + if (!list) { + return undefined; + } + var children = list.getChildren(); + var listItemIndex = ts.indexOfNode(children, node); + return { + listItemIndex: listItemIndex, + list: list + }; + } + ts.findListItemInfo = findListItemInfo; + function hasChildOfKind(n, kind, sourceFile) { + return !!findChildOfKind(n, kind, sourceFile); + } + ts.hasChildOfKind = hasChildOfKind; + function findChildOfKind(n, kind, sourceFile) { + return ts.find(n.getChildren(sourceFile), function (c) { return c.kind === kind; }); + } + ts.findChildOfKind = findChildOfKind; + function findContainingList(node) { + // The node might be a list element (nonsynthetic) or a comma (synthetic). Either way, it will + // be parented by the container of the SyntaxList, not the SyntaxList itself. + // In order to find the list item index, we first need to locate SyntaxList itself and then search + // for the position of the relevant node (or comma). + var syntaxList = ts.find(node.parent.getChildren(), function (c) { return ts.isSyntaxList(c) && rangeContainsRange(c, node); }); + // Either we didn't find an appropriate list, or the list must contain us. + ts.Debug.assert(!syntaxList || ts.contains(syntaxList.getChildren(), node)); + return syntaxList; + } + ts.findContainingList = findContainingList; + function isDefaultModifier(node) { + return node.kind === 88 /* SyntaxKind.DefaultKeyword */; + } + function isClassKeyword(node) { + return node.kind === 84 /* SyntaxKind.ClassKeyword */; + } + function isFunctionKeyword(node) { + return node.kind === 98 /* SyntaxKind.FunctionKeyword */; + } + function getAdjustedLocationForClass(node) { + if (ts.isNamedDeclaration(node)) { + return node.name; + } + if (ts.isClassDeclaration(node)) { + // for class and function declarations, use the `default` modifier + // when the declaration is unnamed. + var defaultModifier = node.modifiers && ts.find(node.modifiers, isDefaultModifier); + if (defaultModifier) + return defaultModifier; + } + if (ts.isClassExpression(node)) { + // for class expressions, use the `class` keyword when the class is unnamed + var classKeyword = ts.find(node.getChildren(), isClassKeyword); + if (classKeyword) + return classKeyword; + } + } + function getAdjustedLocationForFunction(node) { + if (ts.isNamedDeclaration(node)) { + return node.name; + } + if (ts.isFunctionDeclaration(node)) { + // for class and function declarations, use the `default` modifier + // when the declaration is unnamed. + var defaultModifier = ts.find(node.modifiers, isDefaultModifier); + if (defaultModifier) + return defaultModifier; + } + if (ts.isFunctionExpression(node)) { + // for function expressions, use the `function` keyword when the function is unnamed + var functionKeyword = ts.find(node.getChildren(), isFunctionKeyword); + if (functionKeyword) + return functionKeyword; + } + } + function getAncestorTypeNode(node) { + var lastTypeNode; + ts.findAncestor(node, function (a) { + if (ts.isTypeNode(a)) { + lastTypeNode = a; + } + return !ts.isQualifiedName(a.parent) && !ts.isTypeNode(a.parent) && !ts.isTypeElement(a.parent); + }); + return lastTypeNode; + } + function getContextualTypeFromParentOrAncestorTypeNode(node, checker) { + if (node.flags & (8388608 /* NodeFlags.JSDoc */ & ~262144 /* NodeFlags.JavaScriptFile */)) + return undefined; + var contextualType = getContextualTypeFromParent(node, checker); + if (contextualType) + return contextualType; + var ancestorTypeNode = getAncestorTypeNode(node); + return ancestorTypeNode && checker.getTypeAtLocation(ancestorTypeNode); + } + ts.getContextualTypeFromParentOrAncestorTypeNode = getContextualTypeFromParentOrAncestorTypeNode; + function getAdjustedLocationForDeclaration(node, forRename) { + if (!forRename) { + switch (node.kind) { + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + return getAdjustedLocationForClass(node); + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + return getAdjustedLocationForFunction(node); + case 173 /* SyntaxKind.Constructor */: + return node; + } + } + if (ts.isNamedDeclaration(node)) { + return node.name; + } + } + function getAdjustedLocationForImportDeclaration(node, forRename) { + if (node.importClause) { + if (node.importClause.name && node.importClause.namedBindings) { + // do not adjust if we have both a name and named bindings + return; + } + // /**/import [|name|] from ...; + // import /**/type [|name|] from ...; + if (node.importClause.name) { + return node.importClause.name; + } + // /**/import { [|name|] } from ...; + // /**/import { propertyName as [|name|] } from ...; + // /**/import * as [|name|] from ...; + // import /**/type { [|name|] } from ...; + // import /**/type { propertyName as [|name|] } from ...; + // import /**/type * as [|name|] from ...; + if (node.importClause.namedBindings) { + if (ts.isNamedImports(node.importClause.namedBindings)) { + // do nothing if there is more than one binding + var onlyBinding = ts.singleOrUndefined(node.importClause.namedBindings.elements); + if (!onlyBinding) { + return; + } + return onlyBinding.name; + } + else if (ts.isNamespaceImport(node.importClause.namedBindings)) { + return node.importClause.namedBindings.name; + } + } + } + if (!forRename) { + // /**/import "[|module|]"; + // /**/import ... from "[|module|]"; + // import /**/type ... from "[|module|]"; + return node.moduleSpecifier; + } + } + function getAdjustedLocationForExportDeclaration(node, forRename) { + if (node.exportClause) { + // /**/export { [|name|] } ... + // /**/export { propertyName as [|name|] } ... + // /**/export * as [|name|] ... + // export /**/type { [|name|] } from ... + // export /**/type { propertyName as [|name|] } from ... + // export /**/type * as [|name|] ... + if (ts.isNamedExports(node.exportClause)) { + // do nothing if there is more than one binding + var onlyBinding = ts.singleOrUndefined(node.exportClause.elements); + if (!onlyBinding) { + return; + } + return node.exportClause.elements[0].name; + } + else if (ts.isNamespaceExport(node.exportClause)) { + return node.exportClause.name; + } + } + if (!forRename) { + // /**/export * from "[|module|]"; + // export /**/type * from "[|module|]"; + return node.moduleSpecifier; + } + } + function getAdjustedLocationForHeritageClause(node) { + // /**/extends [|name|] + // /**/implements [|name|] + if (node.types.length === 1) { + return node.types[0].expression; + } + // /**/extends name1, name2 ... + // /**/implements name1, name2 ... + } + function getAdjustedLocation(node, forRename) { + var parent = node.parent; + // /**/ [|name|] ... + // /**/ [|name|] ... + // /**/ [|name|] ... + // /**/import [|name|] = ... + // + // NOTE: If the node is a modifier, we don't adjust its location if it is the `default` modifier as that is handled + // specially by `getSymbolAtLocation`. + if (ts.isModifier(node) && (forRename || node.kind !== 88 /* SyntaxKind.DefaultKeyword */) ? ts.canHaveModifiers(parent) && ts.contains(parent.modifiers, node) : + node.kind === 84 /* SyntaxKind.ClassKeyword */ ? ts.isClassDeclaration(parent) || ts.isClassExpression(node) : + node.kind === 98 /* SyntaxKind.FunctionKeyword */ ? ts.isFunctionDeclaration(parent) || ts.isFunctionExpression(node) : + node.kind === 118 /* SyntaxKind.InterfaceKeyword */ ? ts.isInterfaceDeclaration(parent) : + node.kind === 92 /* SyntaxKind.EnumKeyword */ ? ts.isEnumDeclaration(parent) : + node.kind === 154 /* SyntaxKind.TypeKeyword */ ? ts.isTypeAliasDeclaration(parent) : + node.kind === 143 /* SyntaxKind.NamespaceKeyword */ || node.kind === 142 /* SyntaxKind.ModuleKeyword */ ? ts.isModuleDeclaration(parent) : + node.kind === 100 /* SyntaxKind.ImportKeyword */ ? ts.isImportEqualsDeclaration(parent) : + node.kind === 137 /* SyntaxKind.GetKeyword */ ? ts.isGetAccessorDeclaration(parent) : + node.kind === 151 /* SyntaxKind.SetKeyword */ && ts.isSetAccessorDeclaration(parent)) { + var location = getAdjustedLocationForDeclaration(parent, forRename); + if (location) { + return location; + } + } + // /**/ [|name|] ... + if ((node.kind === 113 /* SyntaxKind.VarKeyword */ || node.kind === 85 /* SyntaxKind.ConstKeyword */ || node.kind === 119 /* SyntaxKind.LetKeyword */) && + ts.isVariableDeclarationList(parent) && parent.declarations.length === 1) { + var decl = parent.declarations[0]; + if (ts.isIdentifier(decl.name)) { + return decl.name; + } + } + if (node.kind === 154 /* SyntaxKind.TypeKeyword */) { + // import /**/type [|name|] from ...; + // import /**/type { [|name|] } from ...; + // import /**/type { propertyName as [|name|] } from ...; + // import /**/type ... from "[|module|]"; + if (ts.isImportClause(parent) && parent.isTypeOnly) { + var location = getAdjustedLocationForImportDeclaration(parent.parent, forRename); + if (location) { + return location; + } + } + // export /**/type { [|name|] } from ...; + // export /**/type { propertyName as [|name|] } from ...; + // export /**/type * from "[|module|]"; + // export /**/type * as ... from "[|module|]"; + if (ts.isExportDeclaration(parent) && parent.isTypeOnly) { + var location = getAdjustedLocationForExportDeclaration(parent, forRename); + if (location) { + return location; + } + } + } + // import { propertyName /**/as [|name|] } ... + // import * /**/as [|name|] ... + // export { propertyName /**/as [|name|] } ... + // export * /**/as [|name|] ... + if (node.kind === 128 /* SyntaxKind.AsKeyword */) { + if (ts.isImportSpecifier(parent) && parent.propertyName || + ts.isExportSpecifier(parent) && parent.propertyName || + ts.isNamespaceImport(parent) || + ts.isNamespaceExport(parent)) { + return parent.name; + } + if (ts.isExportDeclaration(parent) && parent.exportClause && ts.isNamespaceExport(parent.exportClause)) { + return parent.exportClause.name; + } + } + // /**/import [|name|] from ...; + // /**/import { [|name|] } from ...; + // /**/import { propertyName as [|name|] } from ...; + // /**/import ... from "[|module|]"; + // /**/import "[|module|]"; + if (node.kind === 100 /* SyntaxKind.ImportKeyword */ && ts.isImportDeclaration(parent)) { + var location = getAdjustedLocationForImportDeclaration(parent, forRename); + if (location) { + return location; + } + } + if (node.kind === 93 /* SyntaxKind.ExportKeyword */) { + // /**/export { [|name|] } ...; + // /**/export { propertyName as [|name|] } ...; + // /**/export * from "[|module|]"; + // /**/export * as ... from "[|module|]"; + if (ts.isExportDeclaration(parent)) { + var location = getAdjustedLocationForExportDeclaration(parent, forRename); + if (location) { + return location; + } + } + // NOTE: We don't adjust the location of the `default` keyword as that is handled specially by `getSymbolAtLocation`. + // /**/export default [|name|]; + // /**/export = [|name|]; + if (ts.isExportAssignment(parent)) { + return ts.skipOuterExpressions(parent.expression); + } + } + // import name = /**/require("[|module|]"); + if (node.kind === 147 /* SyntaxKind.RequireKeyword */ && ts.isExternalModuleReference(parent)) { + return parent.expression; + } + // import ... /**/from "[|module|]"; + // export ... /**/from "[|module|]"; + if (node.kind === 158 /* SyntaxKind.FromKeyword */ && (ts.isImportDeclaration(parent) || ts.isExportDeclaration(parent)) && parent.moduleSpecifier) { + return parent.moduleSpecifier; + } + // class ... /**/extends [|name|] ... + // class ... /**/implements [|name|] ... + // class ... /**/implements name1, name2 ... + // interface ... /**/extends [|name|] ... + // interface ... /**/extends name1, name2 ... + if ((node.kind === 94 /* SyntaxKind.ExtendsKeyword */ || node.kind === 117 /* SyntaxKind.ImplementsKeyword */) && ts.isHeritageClause(parent) && parent.token === node.kind) { + var location = getAdjustedLocationForHeritageClause(parent); + if (location) { + return location; + } + } + if (node.kind === 94 /* SyntaxKind.ExtendsKeyword */) { + // ... ... + if (ts.isTypeParameterDeclaration(parent) && parent.constraint && ts.isTypeReferenceNode(parent.constraint)) { + return parent.constraint.typeName; + } + // ... T /**/extends [|U|] ? ... + if (ts.isConditionalTypeNode(parent) && ts.isTypeReferenceNode(parent.extendsType)) { + return parent.extendsType.typeName; + } + } + // ... T extends /**/infer [|U|] ? ... + if (node.kind === 138 /* SyntaxKind.InferKeyword */ && ts.isInferTypeNode(parent)) { + return parent.typeParameter.name; + } + // { [ [|K|] /**/in keyof T]: ... } + if (node.kind === 101 /* SyntaxKind.InKeyword */ && ts.isTypeParameterDeclaration(parent) && ts.isMappedTypeNode(parent.parent)) { + return parent.name; + } + // /**/keyof [|T|] + if (node.kind === 141 /* SyntaxKind.KeyOfKeyword */ && ts.isTypeOperatorNode(parent) && parent.operator === 141 /* SyntaxKind.KeyOfKeyword */ && + ts.isTypeReferenceNode(parent.type)) { + return parent.type.typeName; + } + // /**/readonly [|name|][] + if (node.kind === 146 /* SyntaxKind.ReadonlyKeyword */ && ts.isTypeOperatorNode(parent) && parent.operator === 146 /* SyntaxKind.ReadonlyKeyword */ && + ts.isArrayTypeNode(parent.type) && ts.isTypeReferenceNode(parent.type.elementType)) { + return parent.type.elementType.typeName; + } + if (!forRename) { + // /**/new [|name|] + // /**/void [|name|] + // /**/void obj.[|name|] + // /**/typeof [|name|] + // /**/typeof obj.[|name|] + // /**/await [|name|] + // /**/await obj.[|name|] + // /**/yield [|name|] + // /**/yield obj.[|name|] + // /**/delete obj.[|name|] + if (node.kind === 103 /* SyntaxKind.NewKeyword */ && ts.isNewExpression(parent) || + node.kind === 114 /* SyntaxKind.VoidKeyword */ && ts.isVoidExpression(parent) || + node.kind === 112 /* SyntaxKind.TypeOfKeyword */ && ts.isTypeOfExpression(parent) || + node.kind === 133 /* SyntaxKind.AwaitKeyword */ && ts.isAwaitExpression(parent) || + node.kind === 125 /* SyntaxKind.YieldKeyword */ && ts.isYieldExpression(parent) || + node.kind === 89 /* SyntaxKind.DeleteKeyword */ && ts.isDeleteExpression(parent)) { + if (parent.expression) { + return ts.skipOuterExpressions(parent.expression); + } + } + // left /**/in [|name|] + // left /**/instanceof [|name|] + if ((node.kind === 101 /* SyntaxKind.InKeyword */ || node.kind === 102 /* SyntaxKind.InstanceOfKeyword */) && ts.isBinaryExpression(parent) && parent.operatorToken === node) { + return ts.skipOuterExpressions(parent.right); + } + // left /**/as [|name|] + if (node.kind === 128 /* SyntaxKind.AsKeyword */ && ts.isAsExpression(parent) && ts.isTypeReferenceNode(parent.type)) { + return parent.type.typeName; + } + // for (... /**/in [|name|]) + // for (... /**/of [|name|]) + if (node.kind === 101 /* SyntaxKind.InKeyword */ && ts.isForInStatement(parent) || + node.kind === 162 /* SyntaxKind.OfKeyword */ && ts.isForOfStatement(parent)) { + return ts.skipOuterExpressions(parent.expression); + } + } + return node; + } + /** + * Adjusts the location used for "find references" and "go to definition" when the cursor was not + * on a property name. + */ + function getAdjustedReferenceLocation(node) { + return getAdjustedLocation(node, /*forRename*/ false); + } + ts.getAdjustedReferenceLocation = getAdjustedReferenceLocation; + /** + * Adjusts the location used for "rename" when the cursor was not on a property name. + */ + function getAdjustedRenameLocation(node) { + return getAdjustedLocation(node, /*forRename*/ true); + } + ts.getAdjustedRenameLocation = getAdjustedRenameLocation; + /** + * Gets the token whose text has range [start, end) and + * position >= start and (position < end or (position === end && token is literal or keyword or identifier)) + */ + function getTouchingPropertyName(sourceFile, position) { + return getTouchingToken(sourceFile, position, function (n) { return ts.isPropertyNameLiteral(n) || ts.isKeyword(n.kind) || ts.isPrivateIdentifier(n); }); + } + ts.getTouchingPropertyName = getTouchingPropertyName; + /** + * Returns the token if position is in [start, end). + * If position === end, returns the preceding token if includeItemAtEndPosition(previousToken) === true + */ + function getTouchingToken(sourceFile, position, includePrecedingTokenAtEndPosition) { + return getTokenAtPositionWorker(sourceFile, position, /*allowPositionInLeadingTrivia*/ false, includePrecedingTokenAtEndPosition, /*includeEndPosition*/ false); + } + ts.getTouchingToken = getTouchingToken; + /** Returns a token if position is in [start-of-leading-trivia, end) */ + function getTokenAtPosition(sourceFile, position) { + return getTokenAtPositionWorker(sourceFile, position, /*allowPositionInLeadingTrivia*/ true, /*includePrecedingTokenAtEndPosition*/ undefined, /*includeEndPosition*/ false); + } + ts.getTokenAtPosition = getTokenAtPosition; + /** Get the token whose text contains the position */ + function getTokenAtPositionWorker(sourceFile, position, allowPositionInLeadingTrivia, includePrecedingTokenAtEndPosition, includeEndPosition) { + var current = sourceFile; + var foundToken; + var _loop_1 = function () { + // find the child that contains 'position' + var children = current.getChildren(sourceFile); + var i = ts.binarySearchKey(children, position, function (_, i) { return i; }, function (middle, _) { + // This last callback is more of a selector than a comparator - + // `EqualTo` causes the `middle` result to be returned + // `GreaterThan` causes recursion on the left of the middle + // `LessThan` causes recursion on the right of the middle + // Let's say you have 3 nodes, spanning positons + // pos: 1, end: 3 + // pos: 3, end: 3 + // pos: 3, end: 5 + // and you're looking for the token at positon 3 - all 3 of these nodes are overlapping with position 3. + // In fact, there's a _good argument_ that node 2 shouldn't even be allowed to exist - depending on if + // the start or end of the ranges are considered inclusive, it's either wholly subsumed by the first or the last node. + // Unfortunately, such nodes do exist. :( - See fourslash/completionsImport_tsx.tsx - empty jsx attributes create + // a zero-length node. + // What also you may not expect is that which node we return depends on the includePrecedingTokenAtEndPosition flag. + // Specifically, if includePrecedingTokenAtEndPosition is set, we return the 1-3 node, while if it's unset, we + // return the 3-5 node. (The zero length node is never correct.) This is because the includePrecedingTokenAtEndPosition + // flag causes us to return the first node whose end position matches the position and which produces and acceptable token + // kind. Meanwhile, if includePrecedingTokenAtEndPosition is unset, we look for the first node whose start is <= the + // position and whose end is greater than the position. + // There are more sophisticated end tests later, but this one is very fast + // and allows us to skip a bunch of work + var end = children[middle].getEnd(); + if (end < position) { + return -1 /* Comparison.LessThan */; + } + var start = allowPositionInLeadingTrivia ? children[middle].getFullStart() : children[middle].getStart(sourceFile, /*includeJsDoc*/ true); + if (start > position) { + return 1 /* Comparison.GreaterThan */; + } + // first element whose start position is before the input and whose end position is after or equal to the input + if (nodeContainsPosition(children[middle], start, end)) { + if (children[middle - 1]) { + // we want the _first_ element that contains the position, so left-recur if the prior node also contains the position + if (nodeContainsPosition(children[middle - 1])) { + return 1 /* Comparison.GreaterThan */; + } + } + return 0 /* Comparison.EqualTo */; + } + // this complex condition makes us left-recur around a zero-length node when includePrecedingTokenAtEndPosition is set, rather than right-recur on it + if (includePrecedingTokenAtEndPosition && start === position && children[middle - 1] && children[middle - 1].getEnd() === position && nodeContainsPosition(children[middle - 1])) { + return 1 /* Comparison.GreaterThan */; + } + return -1 /* Comparison.LessThan */; + }); + if (foundToken) { + return { value: foundToken }; + } + if (i >= 0 && children[i]) { + current = children[i]; + return "continue-outer"; + } + return { value: current }; + }; + outer: while (true) { + var state_1 = _loop_1(); + if (typeof state_1 === "object") + return state_1.value; + switch (state_1) { + case "continue-outer": continue outer; + } + } + function nodeContainsPosition(node, start, end) { + end !== null && end !== void 0 ? end : (end = node.getEnd()); + if (end < position) { + return false; + } + start !== null && start !== void 0 ? start : (start = allowPositionInLeadingTrivia ? node.getFullStart() : node.getStart(sourceFile, /*includeJsDoc*/ true)); + if (start > position) { + // If this child begins after position, then all subsequent children will as well. + return false; + } + if (position < end || (position === end && (node.kind === 1 /* SyntaxKind.EndOfFileToken */ || includeEndPosition))) { + return true; + } + else if (includePrecedingTokenAtEndPosition && end === position) { + var previousToken = findPrecedingToken(position, sourceFile, node); + if (previousToken && includePrecedingTokenAtEndPosition(previousToken)) { + foundToken = previousToken; + return true; + } + } + return false; + } + } + /** + * Returns the first token where position is in [start, end), + * excluding `JsxText` tokens containing only whitespace. + */ + function findFirstNonJsxWhitespaceToken(sourceFile, position) { + var tokenAtPosition = getTokenAtPosition(sourceFile, position); + while (isWhiteSpaceOnlyJsxText(tokenAtPosition)) { + var nextToken = findNextToken(tokenAtPosition, tokenAtPosition.parent, sourceFile); + if (!nextToken) + return; + tokenAtPosition = nextToken; + } + return tokenAtPosition; + } + ts.findFirstNonJsxWhitespaceToken = findFirstNonJsxWhitespaceToken; + /** + * The token on the left of the position is the token that strictly includes the position + * or sits to the left of the cursor if it is on a boundary. For example + * + * fo|o -> will return foo + * foo |bar -> will return foo + * + */ + function findTokenOnLeftOfPosition(file, position) { + // Ideally, getTokenAtPosition should return a token. However, it is currently + // broken, so we do a check to make sure the result was indeed a token. + var tokenAtPosition = getTokenAtPosition(file, position); + if (ts.isToken(tokenAtPosition) && position > tokenAtPosition.getStart(file) && position < tokenAtPosition.getEnd()) { + return tokenAtPosition; + } + return findPrecedingToken(position, file); + } + ts.findTokenOnLeftOfPosition = findTokenOnLeftOfPosition; + function findNextToken(previousToken, parent, sourceFile) { + return find(parent); + function find(n) { + if (ts.isToken(n) && n.pos === previousToken.end) { + // this is token that starts at the end of previous token - return it + return n; + } + return ts.firstDefined(n.getChildren(sourceFile), function (child) { + var shouldDiveInChildNode = + // previous token is enclosed somewhere in the child + (child.pos <= previousToken.pos && child.end > previousToken.end) || + // previous token ends exactly at the beginning of child + (child.pos === previousToken.end); + return shouldDiveInChildNode && nodeHasTokens(child, sourceFile) ? find(child) : undefined; + }); + } + } + ts.findNextToken = findNextToken; + function findPrecedingToken(position, sourceFile, startNode, excludeJsdoc) { + var result = find((startNode || sourceFile)); + ts.Debug.assert(!(result && isWhiteSpaceOnlyJsxText(result))); + return result; + function find(n) { + if (isNonWhitespaceToken(n) && n.kind !== 1 /* SyntaxKind.EndOfFileToken */) { + return n; + } + var children = n.getChildren(sourceFile); + var i = ts.binarySearchKey(children, position, function (_, i) { return i; }, function (middle, _) { + // This last callback is more of a selector than a comparator - + // `EqualTo` causes the `middle` result to be returned + // `GreaterThan` causes recursion on the left of the middle + // `LessThan` causes recursion on the right of the middle + if (position < children[middle].end) { + // first element whose end position is greater than the input position + if (!children[middle - 1] || position >= children[middle - 1].end) { + return 0 /* Comparison.EqualTo */; + } + return 1 /* Comparison.GreaterThan */; + } + return -1 /* Comparison.LessThan */; + }); + if (i >= 0 && children[i]) { + var child = children[i]; + // Note that the span of a node's tokens is [node.getStart(...), node.end). + // Given that `position < child.end` and child has constituent tokens, we distinguish these cases: + // 1) `position` precedes `child`'s tokens or `child` has no tokens (ie: in a comment or whitespace preceding `child`): + // we need to find the last token in a previous child. + // 2) `position` is within the same span: we recurse on `child`. + if (position < child.end) { + var start = child.getStart(sourceFile, /*includeJsDoc*/ !excludeJsdoc); + var lookInPreviousChild = (start >= position) || // cursor in the leading trivia + !nodeHasTokens(child, sourceFile) || + isWhiteSpaceOnlyJsxText(child); + if (lookInPreviousChild) { + // actual start of the node is past the position - previous token should be at the end of previous child + var candidate_1 = findRightmostChildNodeWithTokens(children, /*exclusiveStartPosition*/ i, sourceFile, n.kind); + return candidate_1 && findRightmostToken(candidate_1, sourceFile); + } + else { + // candidate should be in this node + return find(child); + } + } + } + ts.Debug.assert(startNode !== undefined || n.kind === 308 /* SyntaxKind.SourceFile */ || n.kind === 1 /* SyntaxKind.EndOfFileToken */ || ts.isJSDocCommentContainingNode(n)); + // Here we know that none of child token nodes embrace the position, + // the only known case is when position is at the end of the file. + // Try to find the rightmost token in the file without filtering. + // Namely we are skipping the check: 'position < node.end' + var candidate = findRightmostChildNodeWithTokens(children, /*exclusiveStartPosition*/ children.length, sourceFile, n.kind); + return candidate && findRightmostToken(candidate, sourceFile); + } + } + ts.findPrecedingToken = findPrecedingToken; + function isNonWhitespaceToken(n) { + return ts.isToken(n) && !isWhiteSpaceOnlyJsxText(n); + } + function findRightmostToken(n, sourceFile) { + if (isNonWhitespaceToken(n)) { + return n; + } + var children = n.getChildren(sourceFile); + if (children.length === 0) { + return n; + } + var candidate = findRightmostChildNodeWithTokens(children, /*exclusiveStartPosition*/ children.length, sourceFile, n.kind); + return candidate && findRightmostToken(candidate, sourceFile); + } + /** + * Finds the rightmost child to the left of `children[exclusiveStartPosition]` which is a non-all-whitespace token or has constituent tokens. + */ + function findRightmostChildNodeWithTokens(children, exclusiveStartPosition, sourceFile, parentKind) { + for (var i = exclusiveStartPosition - 1; i >= 0; i--) { + var child = children[i]; + if (isWhiteSpaceOnlyJsxText(child)) { + if (i === 0 && (parentKind === 11 /* SyntaxKind.JsxText */ || parentKind === 282 /* SyntaxKind.JsxSelfClosingElement */)) { + ts.Debug.fail("`JsxText` tokens should not be the first child of `JsxElement | JsxSelfClosingElement`"); + } + } + else if (nodeHasTokens(children[i], sourceFile)) { + return children[i]; + } + } + } + function isInString(sourceFile, position, previousToken) { + if (previousToken === void 0) { previousToken = findPrecedingToken(position, sourceFile); } + if (previousToken && ts.isStringTextContainingNode(previousToken)) { + var start = previousToken.getStart(sourceFile); + var end = previousToken.getEnd(); + // To be "in" one of these literals, the position has to be: + // 1. entirely within the token text. + // 2. at the end position of an unterminated token. + // 3. at the end of a regular expression (due to trailing flags like '/foo/g'). + if (start < position && position < end) { + return true; + } + if (position === end) { + return !!previousToken.isUnterminated; + } + } + return false; + } + ts.isInString = isInString; + /** + * returns true if the position is in between the open and close elements of an JSX expression. + */ + function isInsideJsxElementOrAttribute(sourceFile, position) { + var token = getTokenAtPosition(sourceFile, position); + if (!token) { + return false; + } + if (token.kind === 11 /* SyntaxKind.JsxText */) { + return true; + } + //
Hello |
+ if (token.kind === 29 /* SyntaxKind.LessThanToken */ && token.parent.kind === 11 /* SyntaxKind.JsxText */) { + return true; + } + //
{ |
or
+ if (token.kind === 29 /* SyntaxKind.LessThanToken */ && token.parent.kind === 291 /* SyntaxKind.JsxExpression */) { + return true; + } + //
{ + // | + // } < /div> + if (token && token.kind === 19 /* SyntaxKind.CloseBraceToken */ && token.parent.kind === 291 /* SyntaxKind.JsxExpression */) { + return true; + } + //
|
+ if (token.kind === 29 /* SyntaxKind.LessThanToken */ && token.parent.kind === 284 /* SyntaxKind.JsxClosingElement */) { + return true; + } + return false; + } + ts.isInsideJsxElementOrAttribute = isInsideJsxElementOrAttribute; + function isWhiteSpaceOnlyJsxText(node) { + return ts.isJsxText(node) && node.containsOnlyTriviaWhiteSpaces; + } + function isInTemplateString(sourceFile, position) { + var token = getTokenAtPosition(sourceFile, position); + return ts.isTemplateLiteralKind(token.kind) && position > token.getStart(sourceFile); + } + ts.isInTemplateString = isInTemplateString; + function isInJSXText(sourceFile, position) { + var token = getTokenAtPosition(sourceFile, position); + if (ts.isJsxText(token)) { + return true; + } + if (token.kind === 18 /* SyntaxKind.OpenBraceToken */ && ts.isJsxExpression(token.parent) && ts.isJsxElement(token.parent.parent)) { + return true; + } + if (token.kind === 29 /* SyntaxKind.LessThanToken */ && ts.isJsxOpeningLikeElement(token.parent) && ts.isJsxElement(token.parent.parent)) { + return true; + } + return false; + } + ts.isInJSXText = isInJSXText; + function isInsideJsxElement(sourceFile, position) { + function isInsideJsxElementTraversal(node) { + while (node) { + if (node.kind >= 282 /* SyntaxKind.JsxSelfClosingElement */ && node.kind <= 291 /* SyntaxKind.JsxExpression */ + || node.kind === 11 /* SyntaxKind.JsxText */ + || node.kind === 29 /* SyntaxKind.LessThanToken */ + || node.kind === 31 /* SyntaxKind.GreaterThanToken */ + || node.kind === 79 /* SyntaxKind.Identifier */ + || node.kind === 19 /* SyntaxKind.CloseBraceToken */ + || node.kind === 18 /* SyntaxKind.OpenBraceToken */ + || node.kind === 43 /* SyntaxKind.SlashToken */) { + node = node.parent; + } + else if (node.kind === 281 /* SyntaxKind.JsxElement */) { + if (position > node.getStart(sourceFile)) + return true; + node = node.parent; + } + else { + return false; + } + } + return false; + } + return isInsideJsxElementTraversal(getTokenAtPosition(sourceFile, position)); + } + ts.isInsideJsxElement = isInsideJsxElement; + function findPrecedingMatchingToken(token, matchingTokenKind, sourceFile) { + var closeTokenText = ts.tokenToString(token.kind); + var matchingTokenText = ts.tokenToString(matchingTokenKind); + var tokenFullStart = token.getFullStart(); + // Text-scan based fast path - can be bamboozled by comments and other trivia, but often provides + // a good, fast approximation without too much extra work in the cases where it fails. + var bestGuessIndex = sourceFile.text.lastIndexOf(matchingTokenText, tokenFullStart); + if (bestGuessIndex === -1) { + return undefined; // if the token text doesn't appear in the file, there can't be a match - super fast bail + } + // we can only use the textual result directly if we didn't have to count any close tokens within the range + if (sourceFile.text.lastIndexOf(closeTokenText, tokenFullStart - 1) < bestGuessIndex) { + var nodeAtGuess = findPrecedingToken(bestGuessIndex + 1, sourceFile); + if (nodeAtGuess && nodeAtGuess.kind === matchingTokenKind) { + return nodeAtGuess; + } + } + var tokenKind = token.kind; + var remainingMatchingTokens = 0; + while (true) { + var preceding = findPrecedingToken(token.getFullStart(), sourceFile); + if (!preceding) { + return undefined; + } + token = preceding; + if (token.kind === matchingTokenKind) { + if (remainingMatchingTokens === 0) { + return token; + } + remainingMatchingTokens--; + } + else if (token.kind === tokenKind) { + remainingMatchingTokens++; + } + } + } + ts.findPrecedingMatchingToken = findPrecedingMatchingToken; + function removeOptionality(type, isOptionalExpression, isOptionalChain) { + return isOptionalExpression ? type.getNonNullableType() : + isOptionalChain ? type.getNonOptionalType() : + type; + } + ts.removeOptionality = removeOptionality; + function isPossiblyTypeArgumentPosition(token, sourceFile, checker) { + var info = getPossibleTypeArgumentsInfo(token, sourceFile); + return info !== undefined && (ts.isPartOfTypeNode(info.called) || + getPossibleGenericSignatures(info.called, info.nTypeArguments, checker).length !== 0 || + isPossiblyTypeArgumentPosition(info.called, sourceFile, checker)); + } + ts.isPossiblyTypeArgumentPosition = isPossiblyTypeArgumentPosition; + function getPossibleGenericSignatures(called, typeArgumentCount, checker) { + var type = checker.getTypeAtLocation(called); + if (ts.isOptionalChain(called.parent)) { + type = removeOptionality(type, ts.isOptionalChainRoot(called.parent), /*isOptionalChain*/ true); + } + var signatures = ts.isNewExpression(called.parent) ? type.getConstructSignatures() : type.getCallSignatures(); + return signatures.filter(function (candidate) { return !!candidate.typeParameters && candidate.typeParameters.length >= typeArgumentCount; }); + } + ts.getPossibleGenericSignatures = getPossibleGenericSignatures; + // Get info for an expression like `f <` that may be the start of type arguments. + function getPossibleTypeArgumentsInfo(tokenIn, sourceFile) { + // This is a rare case, but one that saves on a _lot_ of work if true - if the source file has _no_ `<` character, + // then there obviously can't be any type arguments - no expensive brace-matching backwards scanning required + if (sourceFile.text.lastIndexOf("<", tokenIn ? tokenIn.pos : sourceFile.text.length) === -1) { + return undefined; + } + var token = tokenIn; + // This function determines if the node could be type argument position + // Since during editing, when type argument list is not complete, + // the tree could be of any shape depending on the tokens parsed before current node, + // scanning of the previous identifier followed by "<" before current node would give us better result + // Note that we also balance out the already provided type arguments, arrays, object literals while doing so + var remainingLessThanTokens = 0; + var nTypeArguments = 0; + while (token) { + switch (token.kind) { + case 29 /* SyntaxKind.LessThanToken */: + // Found the beginning of the generic argument expression + token = findPrecedingToken(token.getFullStart(), sourceFile); + if (token && token.kind === 28 /* SyntaxKind.QuestionDotToken */) { + token = findPrecedingToken(token.getFullStart(), sourceFile); + } + if (!token || !ts.isIdentifier(token)) + return undefined; + if (!remainingLessThanTokens) { + return ts.isDeclarationName(token) ? undefined : { called: token, nTypeArguments: nTypeArguments }; + } + remainingLessThanTokens--; + break; + case 49 /* SyntaxKind.GreaterThanGreaterThanGreaterThanToken */: + remainingLessThanTokens = +3; + break; + case 48 /* SyntaxKind.GreaterThanGreaterThanToken */: + remainingLessThanTokens = +2; + break; + case 31 /* SyntaxKind.GreaterThanToken */: + remainingLessThanTokens++; + break; + case 19 /* SyntaxKind.CloseBraceToken */: + // This can be object type, skip until we find the matching open brace token + // Skip until the matching open brace token + token = findPrecedingMatchingToken(token, 18 /* SyntaxKind.OpenBraceToken */, sourceFile); + if (!token) + return undefined; + break; + case 21 /* SyntaxKind.CloseParenToken */: + // This can be object type, skip until we find the matching open brace token + // Skip until the matching open brace token + token = findPrecedingMatchingToken(token, 20 /* SyntaxKind.OpenParenToken */, sourceFile); + if (!token) + return undefined; + break; + case 23 /* SyntaxKind.CloseBracketToken */: + // This can be object type, skip until we find the matching open brace token + // Skip until the matching open brace token + token = findPrecedingMatchingToken(token, 22 /* SyntaxKind.OpenBracketToken */, sourceFile); + if (!token) + return undefined; + break; + // Valid tokens in a type name. Skip. + case 27 /* SyntaxKind.CommaToken */: + nTypeArguments++; + break; + case 38 /* SyntaxKind.EqualsGreaterThanToken */: + // falls through + case 79 /* SyntaxKind.Identifier */: + case 10 /* SyntaxKind.StringLiteral */: + case 8 /* SyntaxKind.NumericLiteral */: + case 9 /* SyntaxKind.BigIntLiteral */: + case 110 /* SyntaxKind.TrueKeyword */: + case 95 /* SyntaxKind.FalseKeyword */: + // falls through + case 112 /* SyntaxKind.TypeOfKeyword */: + case 94 /* SyntaxKind.ExtendsKeyword */: + case 141 /* SyntaxKind.KeyOfKeyword */: + case 24 /* SyntaxKind.DotToken */: + case 51 /* SyntaxKind.BarToken */: + case 57 /* SyntaxKind.QuestionToken */: + case 58 /* SyntaxKind.ColonToken */: + break; + default: + if (ts.isTypeNode(token)) { + break; + } + // Invalid token in type + return undefined; + } + token = findPrecedingToken(token.getFullStart(), sourceFile); + } + return undefined; + } + ts.getPossibleTypeArgumentsInfo = getPossibleTypeArgumentsInfo; + /** + * Returns true if the cursor at position in sourceFile is within a comment. + * + * @param tokenAtPosition Must equal `getTokenAtPosition(sourceFile, position)` + * @param predicate Additional predicate to test on the comment range. + */ + function isInComment(sourceFile, position, tokenAtPosition) { + return ts.formatting.getRangeOfEnclosingComment(sourceFile, position, /*precedingToken*/ undefined, tokenAtPosition); + } + ts.isInComment = isInComment; + function hasDocComment(sourceFile, position) { + var token = getTokenAtPosition(sourceFile, position); + return !!ts.findAncestor(token, ts.isJSDoc); + } + ts.hasDocComment = hasDocComment; + function nodeHasTokens(n, sourceFile) { + // If we have a token or node that has a non-zero width, it must have tokens. + // Note: getWidth() does not take trivia into account. + return n.kind === 1 /* SyntaxKind.EndOfFileToken */ ? !!n.jsDoc : n.getWidth(sourceFile) !== 0; + } + function getNodeModifiers(node, excludeFlags) { + if (excludeFlags === void 0) { excludeFlags = 0 /* ModifierFlags.None */; } + var result = []; + var flags = ts.isDeclaration(node) + ? ts.getCombinedNodeFlagsAlwaysIncludeJSDoc(node) & ~excludeFlags + : 0 /* ModifierFlags.None */; + if (flags & 8 /* ModifierFlags.Private */) + result.push("private" /* ScriptElementKindModifier.privateMemberModifier */); + if (flags & 16 /* ModifierFlags.Protected */) + result.push("protected" /* ScriptElementKindModifier.protectedMemberModifier */); + if (flags & 4 /* ModifierFlags.Public */) + result.push("public" /* ScriptElementKindModifier.publicMemberModifier */); + if (flags & 32 /* ModifierFlags.Static */ || ts.isClassStaticBlockDeclaration(node)) + result.push("static" /* ScriptElementKindModifier.staticModifier */); + if (flags & 256 /* ModifierFlags.Abstract */) + result.push("abstract" /* ScriptElementKindModifier.abstractModifier */); + if (flags & 1 /* ModifierFlags.Export */) + result.push("export" /* ScriptElementKindModifier.exportedModifier */); + if (flags & 8192 /* ModifierFlags.Deprecated */) + result.push("deprecated" /* ScriptElementKindModifier.deprecatedModifier */); + if (node.flags & 16777216 /* NodeFlags.Ambient */) + result.push("declare" /* ScriptElementKindModifier.ambientModifier */); + if (node.kind === 274 /* SyntaxKind.ExportAssignment */) + result.push("export" /* ScriptElementKindModifier.exportedModifier */); + return result.length > 0 ? result.join(",") : "" /* ScriptElementKindModifier.none */; + } + ts.getNodeModifiers = getNodeModifiers; + function getTypeArgumentOrTypeParameterList(node) { + if (node.kind === 180 /* SyntaxKind.TypeReference */ || node.kind === 210 /* SyntaxKind.CallExpression */) { + return node.typeArguments; + } + if (ts.isFunctionLike(node) || node.kind === 260 /* SyntaxKind.ClassDeclaration */ || node.kind === 261 /* SyntaxKind.InterfaceDeclaration */) { + return node.typeParameters; + } + return undefined; + } + ts.getTypeArgumentOrTypeParameterList = getTypeArgumentOrTypeParameterList; + function isComment(kind) { + return kind === 2 /* SyntaxKind.SingleLineCommentTrivia */ || kind === 3 /* SyntaxKind.MultiLineCommentTrivia */; + } + ts.isComment = isComment; + function isStringOrRegularExpressionOrTemplateLiteral(kind) { + if (kind === 10 /* SyntaxKind.StringLiteral */ + || kind === 13 /* SyntaxKind.RegularExpressionLiteral */ + || ts.isTemplateLiteralKind(kind)) { + return true; + } + return false; + } + ts.isStringOrRegularExpressionOrTemplateLiteral = isStringOrRegularExpressionOrTemplateLiteral; + function isPunctuation(kind) { + return 18 /* SyntaxKind.FirstPunctuation */ <= kind && kind <= 78 /* SyntaxKind.LastPunctuation */; + } + ts.isPunctuation = isPunctuation; + function isInsideTemplateLiteral(node, position, sourceFile) { + return ts.isTemplateLiteralKind(node.kind) + && (node.getStart(sourceFile) < position && position < node.end) || (!!node.isUnterminated && position === node.end); + } + ts.isInsideTemplateLiteral = isInsideTemplateLiteral; + function isAccessibilityModifier(kind) { + switch (kind) { + case 123 /* SyntaxKind.PublicKeyword */: + case 121 /* SyntaxKind.PrivateKeyword */: + case 122 /* SyntaxKind.ProtectedKeyword */: + return true; + } + return false; + } + ts.isAccessibilityModifier = isAccessibilityModifier; + function cloneCompilerOptions(options) { + var result = ts.clone(options); + ts.setConfigFileInOptions(result, options && options.configFile); + return result; + } + ts.cloneCompilerOptions = cloneCompilerOptions; + function isArrayLiteralOrObjectLiteralDestructuringPattern(node) { + if (node.kind === 206 /* SyntaxKind.ArrayLiteralExpression */ || + node.kind === 207 /* SyntaxKind.ObjectLiteralExpression */) { + // [a,b,c] from: + // [a, b, c] = someExpression; + if (node.parent.kind === 223 /* SyntaxKind.BinaryExpression */ && + node.parent.left === node && + node.parent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */) { + return true; + } + // [a, b, c] from: + // for([a, b, c] of expression) + if (node.parent.kind === 247 /* SyntaxKind.ForOfStatement */ && + node.parent.initializer === node) { + return true; + } + // [a, b, c] of + // [x, [a, b, c] ] = someExpression + // or + // {x, a: {a, b, c} } = someExpression + if (isArrayLiteralOrObjectLiteralDestructuringPattern(node.parent.kind === 299 /* SyntaxKind.PropertyAssignment */ ? node.parent.parent : node.parent)) { + return true; + } + } + return false; + } + ts.isArrayLiteralOrObjectLiteralDestructuringPattern = isArrayLiteralOrObjectLiteralDestructuringPattern; + function isInReferenceComment(sourceFile, position) { + return isInReferenceCommentWorker(sourceFile, position, /*shouldBeReference*/ true); + } + ts.isInReferenceComment = isInReferenceComment; + function isInNonReferenceComment(sourceFile, position) { + return isInReferenceCommentWorker(sourceFile, position, /*shouldBeReference*/ false); + } + ts.isInNonReferenceComment = isInNonReferenceComment; + function isInReferenceCommentWorker(sourceFile, position, shouldBeReference) { + var range = isInComment(sourceFile, position, /*tokenAtPosition*/ undefined); + return !!range && shouldBeReference === tripleSlashDirectivePrefixRegex.test(sourceFile.text.substring(range.pos, range.end)); + } + function getReplacementSpanForContextToken(contextToken) { + if (!contextToken) + return undefined; + switch (contextToken.kind) { + case 10 /* SyntaxKind.StringLiteral */: + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + return createTextSpanFromStringLiteralLikeContent(contextToken); + default: + return createTextSpanFromNode(contextToken); + } + } + ts.getReplacementSpanForContextToken = getReplacementSpanForContextToken; + function createTextSpanFromNode(node, sourceFile, endNode) { + return ts.createTextSpanFromBounds(node.getStart(sourceFile), (endNode || node).getEnd()); + } + ts.createTextSpanFromNode = createTextSpanFromNode; + function createTextSpanFromStringLiteralLikeContent(node) { + if (node.isUnterminated) + return undefined; + return ts.createTextSpanFromBounds(node.getStart() + 1, node.getEnd() - 1); + } + ts.createTextSpanFromStringLiteralLikeContent = createTextSpanFromStringLiteralLikeContent; + function createTextRangeFromNode(node, sourceFile) { + return ts.createRange(node.getStart(sourceFile), node.end); + } + ts.createTextRangeFromNode = createTextRangeFromNode; + function createTextSpanFromRange(range) { + return ts.createTextSpanFromBounds(range.pos, range.end); + } + ts.createTextSpanFromRange = createTextSpanFromRange; + function createTextRangeFromSpan(span) { + return ts.createRange(span.start, span.start + span.length); + } + ts.createTextRangeFromSpan = createTextRangeFromSpan; + function createTextChangeFromStartLength(start, length, newText) { + return createTextChange(ts.createTextSpan(start, length), newText); + } + ts.createTextChangeFromStartLength = createTextChangeFromStartLength; + function createTextChange(span, newText) { + return { span: span, newText: newText }; + } + ts.createTextChange = createTextChange; + ts.typeKeywords = [ + 131 /* SyntaxKind.AnyKeyword */, + 129 /* SyntaxKind.AssertsKeyword */, + 160 /* SyntaxKind.BigIntKeyword */, + 134 /* SyntaxKind.BooleanKeyword */, + 95 /* SyntaxKind.FalseKeyword */, + 138 /* SyntaxKind.InferKeyword */, + 141 /* SyntaxKind.KeyOfKeyword */, + 144 /* SyntaxKind.NeverKeyword */, + 104 /* SyntaxKind.NullKeyword */, + 148 /* SyntaxKind.NumberKeyword */, + 149 /* SyntaxKind.ObjectKeyword */, + 146 /* SyntaxKind.ReadonlyKeyword */, + 152 /* SyntaxKind.StringKeyword */, + 153 /* SyntaxKind.SymbolKeyword */, + 110 /* SyntaxKind.TrueKeyword */, + 114 /* SyntaxKind.VoidKeyword */, + 155 /* SyntaxKind.UndefinedKeyword */, + 156 /* SyntaxKind.UniqueKeyword */, + 157 /* SyntaxKind.UnknownKeyword */, + ]; + function isTypeKeyword(kind) { + return ts.contains(ts.typeKeywords, kind); + } + ts.isTypeKeyword = isTypeKeyword; + function isTypeKeywordToken(node) { + return node.kind === 154 /* SyntaxKind.TypeKeyword */; + } + ts.isTypeKeywordToken = isTypeKeywordToken; + function isTypeKeywordTokenOrIdentifier(node) { + return isTypeKeywordToken(node) || ts.isIdentifier(node) && node.text === "type"; + } + ts.isTypeKeywordTokenOrIdentifier = isTypeKeywordTokenOrIdentifier; + /** True if the symbol is for an external module, as opposed to a namespace. */ + function isExternalModuleSymbol(moduleSymbol) { + return !!(moduleSymbol.flags & 1536 /* SymbolFlags.Module */) && moduleSymbol.name.charCodeAt(0) === 34 /* CharacterCodes.doubleQuote */; + } + ts.isExternalModuleSymbol = isExternalModuleSymbol; + function nodeSeenTracker() { + var seen = []; + return function (node) { + var id = ts.getNodeId(node); + return !seen[id] && (seen[id] = true); + }; + } + ts.nodeSeenTracker = nodeSeenTracker; + function getSnapshotText(snap) { + return snap.getText(0, snap.getLength()); + } + ts.getSnapshotText = getSnapshotText; + function repeatString(str, count) { + var result = ""; + for (var i = 0; i < count; i++) { + result += str; + } + return result; + } + ts.repeatString = repeatString; + function skipConstraint(type) { + return type.isTypeParameter() ? type.getConstraint() || type : type; + } + ts.skipConstraint = skipConstraint; + function getNameFromPropertyName(name) { + return name.kind === 164 /* SyntaxKind.ComputedPropertyName */ + // treat computed property names where expression is string/numeric literal as just string/numeric literal + ? ts.isStringOrNumericLiteralLike(name.expression) ? name.expression.text : undefined + : ts.isPrivateIdentifier(name) ? ts.idText(name) : ts.getTextOfIdentifierOrLiteral(name); + } + ts.getNameFromPropertyName = getNameFromPropertyName; + function programContainsModules(program) { + return program.getSourceFiles().some(function (s) { return !s.isDeclarationFile && !program.isSourceFileFromExternalLibrary(s) && !!(s.externalModuleIndicator || s.commonJsModuleIndicator); }); + } + ts.programContainsModules = programContainsModules; + function programContainsEsModules(program) { + return program.getSourceFiles().some(function (s) { return !s.isDeclarationFile && !program.isSourceFileFromExternalLibrary(s) && !!s.externalModuleIndicator; }); + } + ts.programContainsEsModules = programContainsEsModules; + function compilerOptionsIndicateEsModules(compilerOptions) { + return !!compilerOptions.module || ts.getEmitScriptTarget(compilerOptions) >= 2 /* ScriptTarget.ES2015 */ || !!compilerOptions.noEmit; + } + ts.compilerOptionsIndicateEsModules = compilerOptionsIndicateEsModules; + function createModuleSpecifierResolutionHost(program, host) { + // Mix in `getSymlinkCache` from Program when host doesn't have it + // in order for non-Project hosts to have a symlinks cache. + return { + fileExists: function (fileName) { return program.fileExists(fileName); }, + getCurrentDirectory: function () { return host.getCurrentDirectory(); }, + readFile: ts.maybeBind(host, host.readFile), + useCaseSensitiveFileNames: ts.maybeBind(host, host.useCaseSensitiveFileNames), + getSymlinkCache: ts.maybeBind(host, host.getSymlinkCache) || program.getSymlinkCache, + getModuleSpecifierCache: ts.maybeBind(host, host.getModuleSpecifierCache), + getPackageJsonInfoCache: function () { var _a; return (_a = program.getModuleResolutionCache()) === null || _a === void 0 ? void 0 : _a.getPackageJsonInfoCache(); }, + getGlobalTypingsCacheLocation: ts.maybeBind(host, host.getGlobalTypingsCacheLocation), + redirectTargetsMap: program.redirectTargetsMap, + getProjectReferenceRedirect: function (fileName) { return program.getProjectReferenceRedirect(fileName); }, + isSourceOfProjectReferenceRedirect: function (fileName) { return program.isSourceOfProjectReferenceRedirect(fileName); }, + getNearestAncestorDirectoryWithPackageJson: ts.maybeBind(host, host.getNearestAncestorDirectoryWithPackageJson), + getFileIncludeReasons: function () { return program.getFileIncludeReasons(); }, + }; + } + ts.createModuleSpecifierResolutionHost = createModuleSpecifierResolutionHost; + function getModuleSpecifierResolverHost(program, host) { + return __assign(__assign({}, createModuleSpecifierResolutionHost(program, host)), { getCommonSourceDirectory: function () { return program.getCommonSourceDirectory(); } }); + } + ts.getModuleSpecifierResolverHost = getModuleSpecifierResolverHost; + function moduleResolutionRespectsExports(moduleResolution) { + return moduleResolution >= ts.ModuleResolutionKind.Node16 && moduleResolution <= ts.ModuleResolutionKind.NodeNext; + } + ts.moduleResolutionRespectsExports = moduleResolutionRespectsExports; + function moduleResolutionUsesNodeModules(moduleResolution) { + return moduleResolution === ts.ModuleResolutionKind.NodeJs || moduleResolution >= ts.ModuleResolutionKind.Node16 && moduleResolution <= ts.ModuleResolutionKind.NodeNext; + } + ts.moduleResolutionUsesNodeModules = moduleResolutionUsesNodeModules; + function makeImportIfNecessary(defaultImport, namedImports, moduleSpecifier, quotePreference) { + return defaultImport || namedImports && namedImports.length ? makeImport(defaultImport, namedImports, moduleSpecifier, quotePreference) : undefined; + } + ts.makeImportIfNecessary = makeImportIfNecessary; + function makeImport(defaultImport, namedImports, moduleSpecifier, quotePreference, isTypeOnly) { + return ts.factory.createImportDeclaration( + /*modifiers*/ undefined, defaultImport || namedImports + ? ts.factory.createImportClause(!!isTypeOnly, defaultImport, namedImports && namedImports.length ? ts.factory.createNamedImports(namedImports) : undefined) + : undefined, typeof moduleSpecifier === "string" ? makeStringLiteral(moduleSpecifier, quotePreference) : moduleSpecifier, + /*assertClause*/ undefined); + } + ts.makeImport = makeImport; + function makeStringLiteral(text, quotePreference) { + return ts.factory.createStringLiteral(text, quotePreference === 0 /* QuotePreference.Single */); + } + ts.makeStringLiteral = makeStringLiteral; + var QuotePreference; + (function (QuotePreference) { + QuotePreference[QuotePreference["Single"] = 0] = "Single"; + QuotePreference[QuotePreference["Double"] = 1] = "Double"; + })(QuotePreference = ts.QuotePreference || (ts.QuotePreference = {})); + function quotePreferenceFromString(str, sourceFile) { + return ts.isStringDoubleQuoted(str, sourceFile) ? 1 /* QuotePreference.Double */ : 0 /* QuotePreference.Single */; + } + ts.quotePreferenceFromString = quotePreferenceFromString; + function getQuotePreference(sourceFile, preferences) { + if (preferences.quotePreference && preferences.quotePreference !== "auto") { + return preferences.quotePreference === "single" ? 0 /* QuotePreference.Single */ : 1 /* QuotePreference.Double */; + } + else { + // ignore synthetic import added when importHelpers: true + var firstModuleSpecifier = sourceFile.imports && + ts.find(sourceFile.imports, function (n) { return ts.isStringLiteral(n) && !ts.nodeIsSynthesized(n.parent); }); + return firstModuleSpecifier ? quotePreferenceFromString(firstModuleSpecifier, sourceFile) : 1 /* QuotePreference.Double */; + } + } + ts.getQuotePreference = getQuotePreference; + function getQuoteFromPreference(qp) { + switch (qp) { + case 0 /* QuotePreference.Single */: return "'"; + case 1 /* QuotePreference.Double */: return '"'; + default: return ts.Debug.assertNever(qp); + } + } + ts.getQuoteFromPreference = getQuoteFromPreference; + function symbolNameNoDefault(symbol) { + var escaped = symbolEscapedNameNoDefault(symbol); + return escaped === undefined ? undefined : ts.unescapeLeadingUnderscores(escaped); + } + ts.symbolNameNoDefault = symbolNameNoDefault; + function symbolEscapedNameNoDefault(symbol) { + if (symbol.escapedName !== "default" /* InternalSymbolName.Default */) { + return symbol.escapedName; + } + return ts.firstDefined(symbol.declarations, function (decl) { + var name = ts.getNameOfDeclaration(decl); + return name && name.kind === 79 /* SyntaxKind.Identifier */ ? name.escapedText : undefined; + }); + } + ts.symbolEscapedNameNoDefault = symbolEscapedNameNoDefault; + function isModuleSpecifierLike(node) { + return ts.isStringLiteralLike(node) && (ts.isExternalModuleReference(node.parent) || + ts.isImportDeclaration(node.parent) || + ts.isRequireCall(node.parent, /*requireStringLiteralLikeArgument*/ false) && node.parent.arguments[0] === node || + ts.isImportCall(node.parent) && node.parent.arguments[0] === node); + } + ts.isModuleSpecifierLike = isModuleSpecifierLike; + function isObjectBindingElementWithoutPropertyName(bindingElement) { + return ts.isBindingElement(bindingElement) && + ts.isObjectBindingPattern(bindingElement.parent) && + ts.isIdentifier(bindingElement.name) && + !bindingElement.propertyName; + } + ts.isObjectBindingElementWithoutPropertyName = isObjectBindingElementWithoutPropertyName; + function getPropertySymbolFromBindingElement(checker, bindingElement) { + var typeOfPattern = checker.getTypeAtLocation(bindingElement.parent); + return typeOfPattern && checker.getPropertyOfType(typeOfPattern, bindingElement.name.text); + } + ts.getPropertySymbolFromBindingElement = getPropertySymbolFromBindingElement; + function getParentNodeInSpan(node, file, span) { + if (!node) + return undefined; + while (node.parent) { + if (ts.isSourceFile(node.parent) || !spanContainsNode(span, node.parent, file)) { + return node; + } + node = node.parent; + } + } + ts.getParentNodeInSpan = getParentNodeInSpan; + function spanContainsNode(span, node, file) { + return ts.textSpanContainsPosition(span, node.getStart(file)) && + node.getEnd() <= ts.textSpanEnd(span); + } + function findModifier(node, kind) { + return ts.canHaveModifiers(node) ? ts.find(node.modifiers, function (m) { return m.kind === kind; }) : undefined; + } + ts.findModifier = findModifier; + function insertImports(changes, sourceFile, imports, blankLineBetween) { + var decl = ts.isArray(imports) ? imports[0] : imports; + var importKindPredicate = decl.kind === 240 /* SyntaxKind.VariableStatement */ ? ts.isRequireVariableStatement : ts.isAnyImportSyntax; + var existingImportStatements = ts.filter(sourceFile.statements, importKindPredicate); + var sortedNewImports = ts.isArray(imports) ? ts.stableSort(imports, ts.OrganizeImports.compareImportsOrRequireStatements) : [imports]; + if (!existingImportStatements.length) { + changes.insertNodesAtTopOfFile(sourceFile, sortedNewImports, blankLineBetween); + } + else if (existingImportStatements && ts.OrganizeImports.importsAreSorted(existingImportStatements)) { + for (var _i = 0, sortedNewImports_1 = sortedNewImports; _i < sortedNewImports_1.length; _i++) { + var newImport = sortedNewImports_1[_i]; + var insertionIndex = ts.OrganizeImports.getImportDeclarationInsertionIndex(existingImportStatements, newImport); + if (insertionIndex === 0) { + // If the first import is top-of-file, insert after the leading comment which is likely the header. + var options = existingImportStatements[0] === sourceFile.statements[0] ? + { leadingTriviaOption: ts.textChanges.LeadingTriviaOption.Exclude } : {}; + changes.insertNodeBefore(sourceFile, existingImportStatements[0], newImport, /*blankLineBetween*/ false, options); + } + else { + var prevImport = existingImportStatements[insertionIndex - 1]; + changes.insertNodeAfter(sourceFile, prevImport, newImport); + } + } + } + else { + var lastExistingImport = ts.lastOrUndefined(existingImportStatements); + if (lastExistingImport) { + changes.insertNodesAfter(sourceFile, lastExistingImport, sortedNewImports); + } + else { + changes.insertNodesAtTopOfFile(sourceFile, sortedNewImports, blankLineBetween); + } + } + } + ts.insertImports = insertImports; + function getTypeKeywordOfTypeOnlyImport(importClause, sourceFile) { + ts.Debug.assert(importClause.isTypeOnly); + return ts.cast(importClause.getChildAt(0, sourceFile), isTypeKeywordToken); + } + ts.getTypeKeywordOfTypeOnlyImport = getTypeKeywordOfTypeOnlyImport; + function textSpansEqual(a, b) { + return !!a && !!b && a.start === b.start && a.length === b.length; + } + ts.textSpansEqual = textSpansEqual; + function documentSpansEqual(a, b) { + return a.fileName === b.fileName && textSpansEqual(a.textSpan, b.textSpan); + } + ts.documentSpansEqual = documentSpansEqual; + /** + * Iterates through 'array' by index and performs the callback on each element of array until the callback + * returns a truthy value, then returns that value. + * If no such value is found, the callback is applied to each element of array and undefined is returned. + */ + function forEachUnique(array, callback) { + if (array) { + for (var i = 0; i < array.length; i++) { + if (array.indexOf(array[i]) === i) { + var result = callback(array[i], i); + if (result) { + return result; + } + } + } + } + return undefined; + } + ts.forEachUnique = forEachUnique; + function isTextWhiteSpaceLike(text, startPos, endPos) { + for (var i = startPos; i < endPos; i++) { + if (!ts.isWhiteSpaceLike(text.charCodeAt(i))) { + return false; + } + } + return true; + } + ts.isTextWhiteSpaceLike = isTextWhiteSpaceLike; + function getMappedLocation(location, sourceMapper, fileExists) { + var mapsTo = sourceMapper.tryGetSourcePosition(location); + return mapsTo && (!fileExists || fileExists(ts.normalizePath(mapsTo.fileName)) ? mapsTo : undefined); + } + ts.getMappedLocation = getMappedLocation; + function getMappedDocumentSpan(documentSpan, sourceMapper, fileExists) { + var fileName = documentSpan.fileName, textSpan = documentSpan.textSpan; + var newPosition = getMappedLocation({ fileName: fileName, pos: textSpan.start }, sourceMapper, fileExists); + if (!newPosition) + return undefined; + var newEndPosition = getMappedLocation({ fileName: fileName, pos: textSpan.start + textSpan.length }, sourceMapper, fileExists); + var newLength = newEndPosition + ? newEndPosition.pos - newPosition.pos + : textSpan.length; // This shouldn't happen + return { + fileName: newPosition.fileName, + textSpan: { + start: newPosition.pos, + length: newLength, + }, + originalFileName: documentSpan.fileName, + originalTextSpan: documentSpan.textSpan, + contextSpan: getMappedContextSpan(documentSpan, sourceMapper, fileExists), + originalContextSpan: documentSpan.contextSpan + }; + } + ts.getMappedDocumentSpan = getMappedDocumentSpan; + function getMappedContextSpan(documentSpan, sourceMapper, fileExists) { + var contextSpanStart = documentSpan.contextSpan && getMappedLocation({ fileName: documentSpan.fileName, pos: documentSpan.contextSpan.start }, sourceMapper, fileExists); + var contextSpanEnd = documentSpan.contextSpan && getMappedLocation({ fileName: documentSpan.fileName, pos: documentSpan.contextSpan.start + documentSpan.contextSpan.length }, sourceMapper, fileExists); + return contextSpanStart && contextSpanEnd ? + { start: contextSpanStart.pos, length: contextSpanEnd.pos - contextSpanStart.pos } : + undefined; + } + ts.getMappedContextSpan = getMappedContextSpan; + // #endregion + // Display-part writer helpers + // #region + function isFirstDeclarationOfSymbolParameter(symbol) { + var declaration = symbol.declarations ? ts.firstOrUndefined(symbol.declarations) : undefined; + return !!ts.findAncestor(declaration, function (n) { + return ts.isParameter(n) ? true : ts.isBindingElement(n) || ts.isObjectBindingPattern(n) || ts.isArrayBindingPattern(n) ? false : "quit"; + }); + } + ts.isFirstDeclarationOfSymbolParameter = isFirstDeclarationOfSymbolParameter; + var displayPartWriter = getDisplayPartWriter(); + function getDisplayPartWriter() { + var absoluteMaximumLength = ts.defaultMaximumTruncationLength * 10; // A hard cutoff to avoid overloading the messaging channel in worst-case scenarios + var displayParts; + var lineStart; + var indent; + var length; + resetWriter(); + var unknownWrite = function (text) { return writeKind(text, ts.SymbolDisplayPartKind.text); }; + return { + displayParts: function () { + var finalText = displayParts.length && displayParts[displayParts.length - 1].text; + if (length > absoluteMaximumLength && finalText && finalText !== "...") { + if (!ts.isWhiteSpaceLike(finalText.charCodeAt(finalText.length - 1))) { + displayParts.push(displayPart(" ", ts.SymbolDisplayPartKind.space)); + } + displayParts.push(displayPart("...", ts.SymbolDisplayPartKind.punctuation)); + } + return displayParts; + }, + writeKeyword: function (text) { return writeKind(text, ts.SymbolDisplayPartKind.keyword); }, + writeOperator: function (text) { return writeKind(text, ts.SymbolDisplayPartKind.operator); }, + writePunctuation: function (text) { return writeKind(text, ts.SymbolDisplayPartKind.punctuation); }, + writeTrailingSemicolon: function (text) { return writeKind(text, ts.SymbolDisplayPartKind.punctuation); }, + writeSpace: function (text) { return writeKind(text, ts.SymbolDisplayPartKind.space); }, + writeStringLiteral: function (text) { return writeKind(text, ts.SymbolDisplayPartKind.stringLiteral); }, + writeParameter: function (text) { return writeKind(text, ts.SymbolDisplayPartKind.parameterName); }, + writeProperty: function (text) { return writeKind(text, ts.SymbolDisplayPartKind.propertyName); }, + writeLiteral: function (text) { return writeKind(text, ts.SymbolDisplayPartKind.stringLiteral); }, + writeSymbol: writeSymbol, + writeLine: writeLine, + write: unknownWrite, + writeComment: unknownWrite, + getText: function () { return ""; }, + getTextPos: function () { return 0; }, + getColumn: function () { return 0; }, + getLine: function () { return 0; }, + isAtStartOfLine: function () { return false; }, + hasTrailingWhitespace: function () { return false; }, + hasTrailingComment: function () { return false; }, + rawWrite: ts.notImplemented, + getIndent: function () { return indent; }, + increaseIndent: function () { indent++; }, + decreaseIndent: function () { indent--; }, + clear: resetWriter, + trackSymbol: function () { return false; }, + reportInaccessibleThisError: ts.noop, + reportInaccessibleUniqueSymbolError: ts.noop, + reportPrivateInBaseOfClassExpression: ts.noop, + }; + function writeIndent() { + if (length > absoluteMaximumLength) + return; + if (lineStart) { + var indentString = ts.getIndentString(indent); + if (indentString) { + length += indentString.length; + displayParts.push(displayPart(indentString, ts.SymbolDisplayPartKind.space)); + } + lineStart = false; + } + } + function writeKind(text, kind) { + if (length > absoluteMaximumLength) + return; + writeIndent(); + length += text.length; + displayParts.push(displayPart(text, kind)); + } + function writeSymbol(text, symbol) { + if (length > absoluteMaximumLength) + return; + writeIndent(); + length += text.length; + displayParts.push(symbolPart(text, symbol)); + } + function writeLine() { + if (length > absoluteMaximumLength) + return; + length += 1; + displayParts.push(lineBreakPart()); + lineStart = true; + } + function resetWriter() { + displayParts = []; + lineStart = true; + indent = 0; + length = 0; + } + } + function symbolPart(text, symbol) { + return displayPart(text, displayPartKind(symbol)); + function displayPartKind(symbol) { + var flags = symbol.flags; + if (flags & 3 /* SymbolFlags.Variable */) { + return isFirstDeclarationOfSymbolParameter(symbol) ? ts.SymbolDisplayPartKind.parameterName : ts.SymbolDisplayPartKind.localName; + } + if (flags & 4 /* SymbolFlags.Property */) + return ts.SymbolDisplayPartKind.propertyName; + if (flags & 32768 /* SymbolFlags.GetAccessor */) + return ts.SymbolDisplayPartKind.propertyName; + if (flags & 65536 /* SymbolFlags.SetAccessor */) + return ts.SymbolDisplayPartKind.propertyName; + if (flags & 8 /* SymbolFlags.EnumMember */) + return ts.SymbolDisplayPartKind.enumMemberName; + if (flags & 16 /* SymbolFlags.Function */) + return ts.SymbolDisplayPartKind.functionName; + if (flags & 32 /* SymbolFlags.Class */) + return ts.SymbolDisplayPartKind.className; + if (flags & 64 /* SymbolFlags.Interface */) + return ts.SymbolDisplayPartKind.interfaceName; + if (flags & 384 /* SymbolFlags.Enum */) + return ts.SymbolDisplayPartKind.enumName; + if (flags & 1536 /* SymbolFlags.Module */) + return ts.SymbolDisplayPartKind.moduleName; + if (flags & 8192 /* SymbolFlags.Method */) + return ts.SymbolDisplayPartKind.methodName; + if (flags & 262144 /* SymbolFlags.TypeParameter */) + return ts.SymbolDisplayPartKind.typeParameterName; + if (flags & 524288 /* SymbolFlags.TypeAlias */) + return ts.SymbolDisplayPartKind.aliasName; + if (flags & 2097152 /* SymbolFlags.Alias */) + return ts.SymbolDisplayPartKind.aliasName; + return ts.SymbolDisplayPartKind.text; + } + } + ts.symbolPart = symbolPart; + function displayPart(text, kind) { + return { text: text, kind: ts.SymbolDisplayPartKind[kind] }; + } + ts.displayPart = displayPart; + function spacePart() { + return displayPart(" ", ts.SymbolDisplayPartKind.space); + } + ts.spacePart = spacePart; + function keywordPart(kind) { + return displayPart(ts.tokenToString(kind), ts.SymbolDisplayPartKind.keyword); + } + ts.keywordPart = keywordPart; + function punctuationPart(kind) { + return displayPart(ts.tokenToString(kind), ts.SymbolDisplayPartKind.punctuation); + } + ts.punctuationPart = punctuationPart; + function operatorPart(kind) { + return displayPart(ts.tokenToString(kind), ts.SymbolDisplayPartKind.operator); + } + ts.operatorPart = operatorPart; + function parameterNamePart(text) { + return displayPart(text, ts.SymbolDisplayPartKind.parameterName); + } + ts.parameterNamePart = parameterNamePart; + function propertyNamePart(text) { + return displayPart(text, ts.SymbolDisplayPartKind.propertyName); + } + ts.propertyNamePart = propertyNamePart; + function textOrKeywordPart(text) { + var kind = ts.stringToToken(text); + return kind === undefined + ? textPart(text) + : keywordPart(kind); + } + ts.textOrKeywordPart = textOrKeywordPart; + function textPart(text) { + return displayPart(text, ts.SymbolDisplayPartKind.text); + } + ts.textPart = textPart; + function typeAliasNamePart(text) { + return displayPart(text, ts.SymbolDisplayPartKind.aliasName); + } + ts.typeAliasNamePart = typeAliasNamePart; + function typeParameterNamePart(text) { + return displayPart(text, ts.SymbolDisplayPartKind.typeParameterName); + } + ts.typeParameterNamePart = typeParameterNamePart; + function linkTextPart(text) { + return displayPart(text, ts.SymbolDisplayPartKind.linkText); + } + ts.linkTextPart = linkTextPart; + function linkNamePart(text, target) { + return { + text: text, + kind: ts.SymbolDisplayPartKind[ts.SymbolDisplayPartKind.linkName], + target: { + fileName: ts.getSourceFileOfNode(target).fileName, + textSpan: createTextSpanFromNode(target), + }, + }; + } + ts.linkNamePart = linkNamePart; + function linkPart(text) { + return displayPart(text, ts.SymbolDisplayPartKind.link); + } + ts.linkPart = linkPart; + function buildLinkParts(link, checker) { + var _a; + var prefix = ts.isJSDocLink(link) ? "link" + : ts.isJSDocLinkCode(link) ? "linkcode" + : "linkplain"; + var parts = [linkPart("{@".concat(prefix, " "))]; + if (!link.name) { + if (link.text) { + parts.push(linkTextPart(link.text)); + } + } + else { + var symbol = checker === null || checker === void 0 ? void 0 : checker.getSymbolAtLocation(link.name); + var suffix = findLinkNameEnd(link.text); + var name = ts.getTextOfNode(link.name) + link.text.slice(0, suffix); + var text = skipSeparatorFromLinkText(link.text.slice(suffix)); + var decl = (symbol === null || symbol === void 0 ? void 0 : symbol.valueDeclaration) || ((_a = symbol === null || symbol === void 0 ? void 0 : symbol.declarations) === null || _a === void 0 ? void 0 : _a[0]); + if (decl) { + parts.push(linkNamePart(name, decl)); + if (text) + parts.push(linkTextPart(text)); + } + else { + parts.push(linkTextPart(name + (suffix || text.indexOf("://") === 0 ? "" : " ") + text)); + } + } + parts.push(linkPart("}")); + return parts; + } + ts.buildLinkParts = buildLinkParts; + function skipSeparatorFromLinkText(text) { + var pos = 0; + if (text.charCodeAt(pos++) === 124 /* CharacterCodes.bar */) { + while (pos < text.length && text.charCodeAt(pos) === 32 /* CharacterCodes.space */) + pos++; + return text.slice(pos); + } + return text; + } + function findLinkNameEnd(text) { + if (text.indexOf("()") === 0) + return 2; + if (text[0] !== "<") + return 0; + var brackets = 0; + var i = 0; + while (i < text.length) { + if (text[i] === "<") + brackets++; + if (text[i] === ">") + brackets--; + i++; + if (!brackets) + return i; + } + return 0; + } + var carriageReturnLineFeed = "\r\n"; + /** + * The default is CRLF. + */ + function getNewLineOrDefaultFromHost(host, formatSettings) { + var _a; + return (formatSettings === null || formatSettings === void 0 ? void 0 : formatSettings.newLineCharacter) || + ((_a = host.getNewLine) === null || _a === void 0 ? void 0 : _a.call(host)) || + carriageReturnLineFeed; + } + ts.getNewLineOrDefaultFromHost = getNewLineOrDefaultFromHost; + function lineBreakPart() { + return displayPart("\n", ts.SymbolDisplayPartKind.lineBreak); + } + ts.lineBreakPart = lineBreakPart; + function mapToDisplayParts(writeDisplayParts) { + try { + writeDisplayParts(displayPartWriter); + return displayPartWriter.displayParts(); + } + finally { + displayPartWriter.clear(); + } + } + ts.mapToDisplayParts = mapToDisplayParts; + function typeToDisplayParts(typechecker, type, enclosingDeclaration, flags) { + if (flags === void 0) { flags = 0 /* TypeFormatFlags.None */; } + return mapToDisplayParts(function (writer) { + typechecker.writeType(type, enclosingDeclaration, flags | 1024 /* TypeFormatFlags.MultilineObjectLiterals */ | 16384 /* TypeFormatFlags.UseAliasDefinedOutsideCurrentScope */, writer); + }); + } + ts.typeToDisplayParts = typeToDisplayParts; + function symbolToDisplayParts(typeChecker, symbol, enclosingDeclaration, meaning, flags) { + if (flags === void 0) { flags = 0 /* SymbolFormatFlags.None */; } + return mapToDisplayParts(function (writer) { + typeChecker.writeSymbol(symbol, enclosingDeclaration, meaning, flags | 8 /* SymbolFormatFlags.UseAliasDefinedOutsideCurrentScope */, writer); + }); + } + ts.symbolToDisplayParts = symbolToDisplayParts; + function signatureToDisplayParts(typechecker, signature, enclosingDeclaration, flags) { + if (flags === void 0) { flags = 0 /* TypeFormatFlags.None */; } + flags |= 16384 /* TypeFormatFlags.UseAliasDefinedOutsideCurrentScope */ | 1024 /* TypeFormatFlags.MultilineObjectLiterals */ | 32 /* TypeFormatFlags.WriteTypeArgumentsOfSignature */ | 8192 /* TypeFormatFlags.OmitParameterModifiers */; + return mapToDisplayParts(function (writer) { + typechecker.writeSignature(signature, enclosingDeclaration, flags, /*signatureKind*/ undefined, writer); + }); + } + ts.signatureToDisplayParts = signatureToDisplayParts; + function nodeToDisplayParts(node, enclosingDeclaration) { + var file = enclosingDeclaration.getSourceFile(); + return mapToDisplayParts(function (writer) { + var printer = ts.createPrinter({ removeComments: true, omitTrailingSemicolon: true }); + printer.writeNode(4 /* EmitHint.Unspecified */, node, file, writer); + }); + } + ts.nodeToDisplayParts = nodeToDisplayParts; + function isImportOrExportSpecifierName(location) { + return !!location.parent && ts.isImportOrExportSpecifier(location.parent) && location.parent.propertyName === location; + } + ts.isImportOrExportSpecifierName = isImportOrExportSpecifierName; + function getScriptKind(fileName, host) { + // First check to see if the script kind was specified by the host. Chances are the host + // may override the default script kind for the file extension. + return ts.ensureScriptKind(fileName, host.getScriptKind && host.getScriptKind(fileName)); + } + ts.getScriptKind = getScriptKind; + function getSymbolTarget(symbol, checker) { + var next = symbol; + while (isAliasSymbol(next) || (isTransientSymbol(next) && next.target)) { + if (isTransientSymbol(next) && next.target) { + next = next.target; + } + else { + next = ts.skipAlias(next, checker); + } + } + return next; + } + ts.getSymbolTarget = getSymbolTarget; + function isTransientSymbol(symbol) { + return (symbol.flags & 33554432 /* SymbolFlags.Transient */) !== 0; + } + function isAliasSymbol(symbol) { + return (symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0; + } + function getUniqueSymbolId(symbol, checker) { + return ts.getSymbolId(ts.skipAlias(symbol, checker)); + } + ts.getUniqueSymbolId = getUniqueSymbolId; + function getFirstNonSpaceCharacterPosition(text, position) { + while (ts.isWhiteSpaceLike(text.charCodeAt(position))) { + position += 1; + } + return position; + } + ts.getFirstNonSpaceCharacterPosition = getFirstNonSpaceCharacterPosition; + function getPrecedingNonSpaceCharacterPosition(text, position) { + while (position > -1 && ts.isWhiteSpaceSingleLine(text.charCodeAt(position))) { + position -= 1; + } + return position + 1; + } + ts.getPrecedingNonSpaceCharacterPosition = getPrecedingNonSpaceCharacterPosition; + /** + * Creates a deep, memberwise clone of a node with no source map location. + * + * WARNING: This is an expensive operation and is only intended to be used in refactorings + * and code fixes (because those are triggered by explicit user actions). + */ + function getSynthesizedDeepClone(node, includeTrivia) { + if (includeTrivia === void 0) { includeTrivia = true; } + var clone = node && getSynthesizedDeepCloneWorker(node); + if (clone && !includeTrivia) + suppressLeadingAndTrailingTrivia(clone); + return clone; + } + ts.getSynthesizedDeepClone = getSynthesizedDeepClone; + function getSynthesizedDeepCloneWithReplacements(node, includeTrivia, replaceNode) { + var clone = replaceNode(node); + if (clone) { + ts.setOriginalNode(clone, node); + } + else { + clone = getSynthesizedDeepCloneWorker(node, replaceNode); + } + if (clone && !includeTrivia) + suppressLeadingAndTrailingTrivia(clone); + return clone; + } + ts.getSynthesizedDeepCloneWithReplacements = getSynthesizedDeepCloneWithReplacements; + function getSynthesizedDeepCloneWorker(node, replaceNode) { + var nodeClone = replaceNode + ? function (n) { return getSynthesizedDeepCloneWithReplacements(n, /*includeTrivia*/ true, replaceNode); } + : getSynthesizedDeepClone; + var nodesClone = replaceNode + ? function (ns) { return ns && getSynthesizedDeepClonesWithReplacements(ns, /*includeTrivia*/ true, replaceNode); } + : function (ns) { return ns && getSynthesizedDeepClones(ns); }; + var visited = ts.visitEachChild(node, nodeClone, ts.nullTransformationContext, nodesClone, nodeClone); + if (visited === node) { + // This only happens for leaf nodes - internal nodes always see their children change. + var clone_1 = ts.isStringLiteral(node) ? ts.setOriginalNode(ts.factory.createStringLiteralFromNode(node), node) : + ts.isNumericLiteral(node) ? ts.setOriginalNode(ts.factory.createNumericLiteral(node.text, node.numericLiteralFlags), node) : + ts.factory.cloneNode(node); + return ts.setTextRange(clone_1, node); + } + // PERF: As an optimization, rather than calling factory.cloneNode, we'll update + // the new node created by visitEachChild with the extra changes factory.cloneNode + // would have made. + visited.parent = undefined; + return visited; + } + function getSynthesizedDeepClones(nodes, includeTrivia) { + if (includeTrivia === void 0) { includeTrivia = true; } + return nodes && ts.factory.createNodeArray(nodes.map(function (n) { return getSynthesizedDeepClone(n, includeTrivia); }), nodes.hasTrailingComma); + } + ts.getSynthesizedDeepClones = getSynthesizedDeepClones; + function getSynthesizedDeepClonesWithReplacements(nodes, includeTrivia, replaceNode) { + return ts.factory.createNodeArray(nodes.map(function (n) { return getSynthesizedDeepCloneWithReplacements(n, includeTrivia, replaceNode); }), nodes.hasTrailingComma); + } + ts.getSynthesizedDeepClonesWithReplacements = getSynthesizedDeepClonesWithReplacements; + /** + * Sets EmitFlags to suppress leading and trailing trivia on the node. + */ + function suppressLeadingAndTrailingTrivia(node) { + suppressLeadingTrivia(node); + suppressTrailingTrivia(node); + } + ts.suppressLeadingAndTrailingTrivia = suppressLeadingAndTrailingTrivia; + /** + * Sets EmitFlags to suppress leading trivia on the node. + */ + function suppressLeadingTrivia(node) { + addEmitFlagsRecursively(node, 512 /* EmitFlags.NoLeadingComments */, getFirstChild); + } + ts.suppressLeadingTrivia = suppressLeadingTrivia; + /** + * Sets EmitFlags to suppress trailing trivia on the node. + */ + function suppressTrailingTrivia(node) { + addEmitFlagsRecursively(node, 1024 /* EmitFlags.NoTrailingComments */, ts.getLastChild); + } + ts.suppressTrailingTrivia = suppressTrailingTrivia; + function copyComments(sourceNode, targetNode) { + var sourceFile = sourceNode.getSourceFile(); + var text = sourceFile.text; + if (hasLeadingLineBreak(sourceNode, text)) { + copyLeadingComments(sourceNode, targetNode, sourceFile); + } + else { + copyTrailingAsLeadingComments(sourceNode, targetNode, sourceFile); + } + copyTrailingComments(sourceNode, targetNode, sourceFile); + } + ts.copyComments = copyComments; + function hasLeadingLineBreak(node, text) { + var start = node.getFullStart(); + var end = node.getStart(); + for (var i = start; i < end; i++) { + if (text.charCodeAt(i) === 10 /* CharacterCodes.lineFeed */) + return true; + } + return false; + } + function addEmitFlagsRecursively(node, flag, getChild) { + ts.addEmitFlags(node, flag); + var child = getChild(node); + if (child) + addEmitFlagsRecursively(child, flag, getChild); + } + function getFirstChild(node) { + return node.forEachChild(function (child) { return child; }); + } + function getUniqueName(baseName, sourceFile) { + var nameText = baseName; + for (var i = 1; !ts.isFileLevelUniqueName(sourceFile, nameText); i++) { + nameText = "".concat(baseName, "_").concat(i); + } + return nameText; + } + ts.getUniqueName = getUniqueName; + /** + * @return The index of the (only) reference to the extracted symbol. We want the cursor + * to be on the reference, rather than the declaration, because it's closer to where the + * user was before extracting it. + */ + function getRenameLocation(edits, renameFilename, name, preferLastLocation) { + var delta = 0; + var lastPos = -1; + for (var _i = 0, edits_1 = edits; _i < edits_1.length; _i++) { + var _a = edits_1[_i], fileName = _a.fileName, textChanges_2 = _a.textChanges; + ts.Debug.assert(fileName === renameFilename); + for (var _b = 0, textChanges_1 = textChanges_2; _b < textChanges_1.length; _b++) { + var change = textChanges_1[_b]; + var span = change.span, newText = change.newText; + var index = indexInTextChange(newText, ts.escapeString(name)); + if (index !== -1) { + lastPos = span.start + delta + index; + // If the reference comes first, return immediately. + if (!preferLastLocation) { + return lastPos; + } + } + delta += newText.length - span.length; + } + } + // If the declaration comes first, return the position of the last occurrence. + ts.Debug.assert(preferLastLocation); + ts.Debug.assert(lastPos >= 0); + return lastPos; + } + ts.getRenameLocation = getRenameLocation; + function copyLeadingComments(sourceNode, targetNode, sourceFile, commentKind, hasTrailingNewLine) { + ts.forEachLeadingCommentRange(sourceFile.text, sourceNode.pos, getAddCommentsFunction(targetNode, sourceFile, commentKind, hasTrailingNewLine, ts.addSyntheticLeadingComment)); + } + ts.copyLeadingComments = copyLeadingComments; + function copyTrailingComments(sourceNode, targetNode, sourceFile, commentKind, hasTrailingNewLine) { + ts.forEachTrailingCommentRange(sourceFile.text, sourceNode.end, getAddCommentsFunction(targetNode, sourceFile, commentKind, hasTrailingNewLine, ts.addSyntheticTrailingComment)); + } + ts.copyTrailingComments = copyTrailingComments; + /** + * This function copies the trailing comments for the token that comes before `sourceNode`, as leading comments of `targetNode`. + * This is useful because sometimes a comment that refers to `sourceNode` will be a leading comment for `sourceNode`, according to the + * notion of trivia ownership, and instead will be a trailing comment for the token before `sourceNode`, e.g.: + * `function foo(\* not leading comment for a *\ a: string) {}` + * The comment refers to `a` but belongs to the `(` token, but we might want to copy it. + */ + function copyTrailingAsLeadingComments(sourceNode, targetNode, sourceFile, commentKind, hasTrailingNewLine) { + ts.forEachTrailingCommentRange(sourceFile.text, sourceNode.pos, getAddCommentsFunction(targetNode, sourceFile, commentKind, hasTrailingNewLine, ts.addSyntheticLeadingComment)); + } + ts.copyTrailingAsLeadingComments = copyTrailingAsLeadingComments; + function getAddCommentsFunction(targetNode, sourceFile, commentKind, hasTrailingNewLine, cb) { + return function (pos, end, kind, htnl) { + if (kind === 3 /* SyntaxKind.MultiLineCommentTrivia */) { + // Remove leading /* + pos += 2; + // Remove trailing */ + end -= 2; + } + else { + // Remove leading // + pos += 2; + } + cb(targetNode, commentKind || kind, sourceFile.text.slice(pos, end), hasTrailingNewLine !== undefined ? hasTrailingNewLine : htnl); + }; + } + function indexInTextChange(change, name) { + if (ts.startsWith(change, name)) + return 0; + // Add a " " to avoid references inside words + var idx = change.indexOf(" " + name); + if (idx === -1) + idx = change.indexOf("." + name); + if (idx === -1) + idx = change.indexOf('"' + name); + return idx === -1 ? -1 : idx + 1; + } + /* @internal */ + function needsParentheses(expression) { + return ts.isBinaryExpression(expression) && expression.operatorToken.kind === 27 /* SyntaxKind.CommaToken */ + || ts.isObjectLiteralExpression(expression) + || ts.isAsExpression(expression) && ts.isObjectLiteralExpression(expression.expression); + } + ts.needsParentheses = needsParentheses; + function getContextualTypeFromParent(node, checker) { + var parent = node.parent; + switch (parent.kind) { + case 211 /* SyntaxKind.NewExpression */: + return checker.getContextualType(parent); + case 223 /* SyntaxKind.BinaryExpression */: { + var _a = parent, left = _a.left, operatorToken = _a.operatorToken, right = _a.right; + return isEqualityOperatorKind(operatorToken.kind) + ? checker.getTypeAtLocation(node === right ? left : right) + : checker.getContextualType(node); + } + case 292 /* SyntaxKind.CaseClause */: + return parent.expression === node ? getSwitchedType(parent, checker) : undefined; + default: + return checker.getContextualType(node); + } + } + ts.getContextualTypeFromParent = getContextualTypeFromParent; + function quote(sourceFile, preferences, text) { + // Editors can pass in undefined or empty string - we want to infer the preference in those cases. + var quotePreference = getQuotePreference(sourceFile, preferences); + var quoted = JSON.stringify(text); + return quotePreference === 0 /* QuotePreference.Single */ ? "'".concat(ts.stripQuotes(quoted).replace(/'/g, "\\'").replace(/\\"/g, '"'), "'") : quoted; + } + ts.quote = quote; + function isEqualityOperatorKind(kind) { + switch (kind) { + case 36 /* SyntaxKind.EqualsEqualsEqualsToken */: + case 34 /* SyntaxKind.EqualsEqualsToken */: + case 37 /* SyntaxKind.ExclamationEqualsEqualsToken */: + case 35 /* SyntaxKind.ExclamationEqualsToken */: + return true; + default: + return false; + } + } + ts.isEqualityOperatorKind = isEqualityOperatorKind; + function isStringLiteralOrTemplate(node) { + switch (node.kind) { + case 10 /* SyntaxKind.StringLiteral */: + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + case 225 /* SyntaxKind.TemplateExpression */: + case 212 /* SyntaxKind.TaggedTemplateExpression */: + return true; + default: + return false; + } + } + ts.isStringLiteralOrTemplate = isStringLiteralOrTemplate; + function hasIndexSignature(type) { + return !!type.getStringIndexType() || !!type.getNumberIndexType(); + } + ts.hasIndexSignature = hasIndexSignature; + function getSwitchedType(caseClause, checker) { + return checker.getTypeAtLocation(caseClause.parent.parent.expression); + } + ts.getSwitchedType = getSwitchedType; + ts.ANONYMOUS = "anonymous function"; + function getTypeNodeIfAccessible(type, enclosingScope, program, host) { + var checker = program.getTypeChecker(); + var typeIsAccessible = true; + var notAccessible = function () { return typeIsAccessible = false; }; + var res = checker.typeToTypeNode(type, enclosingScope, 1 /* NodeBuilderFlags.NoTruncation */, { + trackSymbol: function (symbol, declaration, meaning) { + typeIsAccessible = typeIsAccessible && checker.isSymbolAccessible(symbol, declaration, meaning, /*shouldComputeAliasToMarkVisible*/ false).accessibility === 0 /* SymbolAccessibility.Accessible */; + return !typeIsAccessible; + }, + reportInaccessibleThisError: notAccessible, + reportPrivateInBaseOfClassExpression: notAccessible, + reportInaccessibleUniqueSymbolError: notAccessible, + moduleResolverHost: getModuleSpecifierResolverHost(program, host) + }); + return typeIsAccessible ? res : undefined; + } + ts.getTypeNodeIfAccessible = getTypeNodeIfAccessible; + function syntaxRequiresTrailingCommaOrSemicolonOrASI(kind) { + return kind === 176 /* SyntaxKind.CallSignature */ + || kind === 177 /* SyntaxKind.ConstructSignature */ + || kind === 178 /* SyntaxKind.IndexSignature */ + || kind === 168 /* SyntaxKind.PropertySignature */ + || kind === 170 /* SyntaxKind.MethodSignature */; + } + function syntaxRequiresTrailingFunctionBlockOrSemicolonOrASI(kind) { + return kind === 259 /* SyntaxKind.FunctionDeclaration */ + || kind === 173 /* SyntaxKind.Constructor */ + || kind === 171 /* SyntaxKind.MethodDeclaration */ + || kind === 174 /* SyntaxKind.GetAccessor */ + || kind === 175 /* SyntaxKind.SetAccessor */; + } + function syntaxRequiresTrailingModuleBlockOrSemicolonOrASI(kind) { + return kind === 264 /* SyntaxKind.ModuleDeclaration */; + } + function syntaxRequiresTrailingSemicolonOrASI(kind) { + return kind === 240 /* SyntaxKind.VariableStatement */ + || kind === 241 /* SyntaxKind.ExpressionStatement */ + || kind === 243 /* SyntaxKind.DoStatement */ + || kind === 248 /* SyntaxKind.ContinueStatement */ + || kind === 249 /* SyntaxKind.BreakStatement */ + || kind === 250 /* SyntaxKind.ReturnStatement */ + || kind === 254 /* SyntaxKind.ThrowStatement */ + || kind === 256 /* SyntaxKind.DebuggerStatement */ + || kind === 169 /* SyntaxKind.PropertyDeclaration */ + || kind === 262 /* SyntaxKind.TypeAliasDeclaration */ + || kind === 269 /* SyntaxKind.ImportDeclaration */ + || kind === 268 /* SyntaxKind.ImportEqualsDeclaration */ + || kind === 275 /* SyntaxKind.ExportDeclaration */ + || kind === 267 /* SyntaxKind.NamespaceExportDeclaration */ + || kind === 274 /* SyntaxKind.ExportAssignment */; + } + ts.syntaxRequiresTrailingSemicolonOrASI = syntaxRequiresTrailingSemicolonOrASI; + ts.syntaxMayBeASICandidate = ts.or(syntaxRequiresTrailingCommaOrSemicolonOrASI, syntaxRequiresTrailingFunctionBlockOrSemicolonOrASI, syntaxRequiresTrailingModuleBlockOrSemicolonOrASI, syntaxRequiresTrailingSemicolonOrASI); + function nodeIsASICandidate(node, sourceFile) { + var lastToken = node.getLastToken(sourceFile); + if (lastToken && lastToken.kind === 26 /* SyntaxKind.SemicolonToken */) { + return false; + } + if (syntaxRequiresTrailingCommaOrSemicolonOrASI(node.kind)) { + if (lastToken && lastToken.kind === 27 /* SyntaxKind.CommaToken */) { + return false; + } + } + else if (syntaxRequiresTrailingModuleBlockOrSemicolonOrASI(node.kind)) { + var lastChild = ts.last(node.getChildren(sourceFile)); + if (lastChild && ts.isModuleBlock(lastChild)) { + return false; + } + } + else if (syntaxRequiresTrailingFunctionBlockOrSemicolonOrASI(node.kind)) { + var lastChild = ts.last(node.getChildren(sourceFile)); + if (lastChild && ts.isFunctionBlock(lastChild)) { + return false; + } + } + else if (!syntaxRequiresTrailingSemicolonOrASI(node.kind)) { + return false; + } + // See comment in parser’s `parseDoStatement` + if (node.kind === 243 /* SyntaxKind.DoStatement */) { + return true; + } + var topNode = ts.findAncestor(node, function (ancestor) { return !ancestor.parent; }); + var nextToken = findNextToken(node, topNode, sourceFile); + if (!nextToken || nextToken.kind === 19 /* SyntaxKind.CloseBraceToken */) { + return true; + } + var startLine = sourceFile.getLineAndCharacterOfPosition(node.getEnd()).line; + var endLine = sourceFile.getLineAndCharacterOfPosition(nextToken.getStart(sourceFile)).line; + return startLine !== endLine; + } + function positionIsASICandidate(pos, context, sourceFile) { + var contextAncestor = ts.findAncestor(context, function (ancestor) { + if (ancestor.end !== pos) { + return "quit"; + } + return ts.syntaxMayBeASICandidate(ancestor.kind); + }); + return !!contextAncestor && nodeIsASICandidate(contextAncestor, sourceFile); + } + ts.positionIsASICandidate = positionIsASICandidate; + function probablyUsesSemicolons(sourceFile) { + var withSemicolon = 0; + var withoutSemicolon = 0; + var nStatementsToObserve = 5; + ts.forEachChild(sourceFile, function visit(node) { + if (syntaxRequiresTrailingSemicolonOrASI(node.kind)) { + var lastToken = node.getLastToken(sourceFile); + if ((lastToken === null || lastToken === void 0 ? void 0 : lastToken.kind) === 26 /* SyntaxKind.SemicolonToken */) { + withSemicolon++; + } + else { + withoutSemicolon++; + } + } + else if (syntaxRequiresTrailingCommaOrSemicolonOrASI(node.kind)) { + var lastToken = node.getLastToken(sourceFile); + if ((lastToken === null || lastToken === void 0 ? void 0 : lastToken.kind) === 26 /* SyntaxKind.SemicolonToken */) { + withSemicolon++; + } + else if (lastToken && lastToken.kind !== 27 /* SyntaxKind.CommaToken */) { + var lastTokenLine = ts.getLineAndCharacterOfPosition(sourceFile, lastToken.getStart(sourceFile)).line; + var nextTokenLine = ts.getLineAndCharacterOfPosition(sourceFile, ts.getSpanOfTokenAtPosition(sourceFile, lastToken.end).start).line; + // Avoid counting missing semicolon in single-line objects: + // `function f(p: { x: string /*no semicolon here is insignificant*/ }) {` + if (lastTokenLine !== nextTokenLine) { + withoutSemicolon++; + } + } + } + if (withSemicolon + withoutSemicolon >= nStatementsToObserve) { + return true; + } + return ts.forEachChild(node, visit); + }); + // One statement missing a semicolon isn't sufficient evidence to say the user + // doesn’t want semicolons, because they may not even be done writing that statement. + if (withSemicolon === 0 && withoutSemicolon <= 1) { + return true; + } + // If even 2/5 places have a semicolon, the user probably wants semicolons + return withSemicolon / withoutSemicolon > 1 / nStatementsToObserve; + } + ts.probablyUsesSemicolons = probablyUsesSemicolons; + function tryGetDirectories(host, directoryName) { + return tryIOAndConsumeErrors(host, host.getDirectories, directoryName) || []; + } + ts.tryGetDirectories = tryGetDirectories; + function tryReadDirectory(host, path, extensions, exclude, include) { + return tryIOAndConsumeErrors(host, host.readDirectory, path, extensions, exclude, include) || ts.emptyArray; + } + ts.tryReadDirectory = tryReadDirectory; + function tryFileExists(host, path) { + return tryIOAndConsumeErrors(host, host.fileExists, path); + } + ts.tryFileExists = tryFileExists; + function tryDirectoryExists(host, path) { + return tryAndIgnoreErrors(function () { return ts.directoryProbablyExists(path, host); }) || false; + } + ts.tryDirectoryExists = tryDirectoryExists; + function tryAndIgnoreErrors(cb) { + try { + return cb(); + } + catch (_a) { + return undefined; + } + } + ts.tryAndIgnoreErrors = tryAndIgnoreErrors; + function tryIOAndConsumeErrors(host, toApply) { + var args = []; + for (var _i = 2; _i < arguments.length; _i++) { + args[_i - 2] = arguments[_i]; + } + return tryAndIgnoreErrors(function () { return toApply && toApply.apply(host, args); }); + } + ts.tryIOAndConsumeErrors = tryIOAndConsumeErrors; + function findPackageJsons(startDirectory, host, stopDirectory) { + var paths = []; + ts.forEachAncestorDirectory(startDirectory, function (ancestor) { + if (ancestor === stopDirectory) { + return true; + } + var currentConfigPath = ts.combinePaths(ancestor, "package.json"); + if (tryFileExists(host, currentConfigPath)) { + paths.push(currentConfigPath); + } + }); + return paths; + } + ts.findPackageJsons = findPackageJsons; + function findPackageJson(directory, host) { + var packageJson; + ts.forEachAncestorDirectory(directory, function (ancestor) { + if (ancestor === "node_modules") + return true; + packageJson = ts.findConfigFile(ancestor, function (f) { return tryFileExists(host, f); }, "package.json"); + if (packageJson) { + return true; // break out + } + }); + return packageJson; + } + ts.findPackageJson = findPackageJson; + function getPackageJsonsVisibleToFile(fileName, host) { + if (!host.fileExists) { + return []; + } + var packageJsons = []; + ts.forEachAncestorDirectory(ts.getDirectoryPath(fileName), function (ancestor) { + var packageJsonFileName = ts.combinePaths(ancestor, "package.json"); + if (host.fileExists(packageJsonFileName)) { + var info = createPackageJsonInfo(packageJsonFileName, host); + if (info) { + packageJsons.push(info); + } + } + }); + return packageJsons; + } + ts.getPackageJsonsVisibleToFile = getPackageJsonsVisibleToFile; + function createPackageJsonInfo(fileName, host) { + if (!host.readFile) { + return undefined; + } + var dependencyKeys = ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"]; + var stringContent = host.readFile(fileName) || ""; + var content = tryParseJson(stringContent); + var info = {}; + if (content) { + for (var _i = 0, dependencyKeys_1 = dependencyKeys; _i < dependencyKeys_1.length; _i++) { + var key = dependencyKeys_1[_i]; + var dependencies = content[key]; + if (!dependencies) { + continue; + } + var dependencyMap = new ts.Map(); + for (var packageName in dependencies) { + dependencyMap.set(packageName, dependencies[packageName]); + } + info[key] = dependencyMap; + } + } + var dependencyGroups = [ + [1 /* PackageJsonDependencyGroup.Dependencies */, info.dependencies], + [2 /* PackageJsonDependencyGroup.DevDependencies */, info.devDependencies], + [8 /* PackageJsonDependencyGroup.OptionalDependencies */, info.optionalDependencies], + [4 /* PackageJsonDependencyGroup.PeerDependencies */, info.peerDependencies], + ]; + return __assign(__assign({}, info), { parseable: !!content, fileName: fileName, get: get, has: function (dependencyName, inGroups) { + return !!get(dependencyName, inGroups); + } }); + function get(dependencyName, inGroups) { + if (inGroups === void 0) { inGroups = 15 /* PackageJsonDependencyGroup.All */; } + for (var _i = 0, dependencyGroups_1 = dependencyGroups; _i < dependencyGroups_1.length; _i++) { + var _a = dependencyGroups_1[_i], group_1 = _a[0], deps = _a[1]; + if (deps && (inGroups & group_1)) { + var dep = deps.get(dependencyName); + if (dep !== undefined) { + return dep; + } + } + } + } + } + ts.createPackageJsonInfo = createPackageJsonInfo; + function createPackageJsonImportFilter(fromFile, preferences, host) { + var packageJsons = ((host.getPackageJsonsVisibleToFile && host.getPackageJsonsVisibleToFile(fromFile.fileName)) || getPackageJsonsVisibleToFile(fromFile.fileName, host)).filter(function (p) { return p.parseable; }); + var usesNodeCoreModules; + return { allowsImportingAmbientModule: allowsImportingAmbientModule, allowsImportingSourceFile: allowsImportingSourceFile, allowsImportingSpecifier: allowsImportingSpecifier }; + function moduleSpecifierIsCoveredByPackageJson(specifier) { + var packageName = getNodeModuleRootSpecifier(specifier); + for (var _i = 0, packageJsons_1 = packageJsons; _i < packageJsons_1.length; _i++) { + var packageJson = packageJsons_1[_i]; + if (packageJson.has(packageName) || packageJson.has(ts.getTypesPackageName(packageName))) { + return true; + } + } + return false; + } + function allowsImportingAmbientModule(moduleSymbol, moduleSpecifierResolutionHost) { + if (!packageJsons.length || !moduleSymbol.valueDeclaration) { + return true; + } + var declaringSourceFile = moduleSymbol.valueDeclaration.getSourceFile(); + var declaringNodeModuleName = getNodeModulesPackageNameFromFileName(declaringSourceFile.fileName, moduleSpecifierResolutionHost); + if (typeof declaringNodeModuleName === "undefined") { + return true; + } + var declaredModuleSpecifier = ts.stripQuotes(moduleSymbol.getName()); + if (isAllowedCoreNodeModulesImport(declaredModuleSpecifier)) { + return true; + } + return moduleSpecifierIsCoveredByPackageJson(declaringNodeModuleName) + || moduleSpecifierIsCoveredByPackageJson(declaredModuleSpecifier); + } + function allowsImportingSourceFile(sourceFile, moduleSpecifierResolutionHost) { + if (!packageJsons.length) { + return true; + } + var moduleSpecifier = getNodeModulesPackageNameFromFileName(sourceFile.fileName, moduleSpecifierResolutionHost); + if (!moduleSpecifier) { + return true; + } + return moduleSpecifierIsCoveredByPackageJson(moduleSpecifier); + } + function allowsImportingSpecifier(moduleSpecifier) { + if (!packageJsons.length || isAllowedCoreNodeModulesImport(moduleSpecifier)) { + return true; + } + if (ts.pathIsRelative(moduleSpecifier) || ts.isRootedDiskPath(moduleSpecifier)) { + return true; + } + return moduleSpecifierIsCoveredByPackageJson(moduleSpecifier); + } + function isAllowedCoreNodeModulesImport(moduleSpecifier) { + // If we’re in JavaScript, it can be difficult to tell whether the user wants to import + // from Node core modules or not. We can start by seeing if the user is actually using + // any node core modules, as opposed to simply having @types/node accidentally as a + // dependency of a dependency. + if (ts.isSourceFileJS(fromFile) && ts.JsTyping.nodeCoreModules.has(moduleSpecifier)) { + if (usesNodeCoreModules === undefined) { + usesNodeCoreModules = consumesNodeCoreModules(fromFile); + } + if (usesNodeCoreModules) { + return true; + } + } + return false; + } + function getNodeModulesPackageNameFromFileName(importedFileName, moduleSpecifierResolutionHost) { + if (!ts.stringContains(importedFileName, "node_modules")) { + return undefined; + } + var specifier = ts.moduleSpecifiers.getNodeModulesPackageName(host.getCompilationSettings(), fromFile, importedFileName, moduleSpecifierResolutionHost, preferences); + if (!specifier) { + return undefined; + } + // Paths here are not node_modules, so we don’t care about them; + // returning anything will trigger a lookup in package.json. + if (!ts.pathIsRelative(specifier) && !ts.isRootedDiskPath(specifier)) { + return getNodeModuleRootSpecifier(specifier); + } + } + function getNodeModuleRootSpecifier(fullSpecifier) { + var components = ts.getPathComponents(ts.getPackageNameFromTypesPackageName(fullSpecifier)).slice(1); + // Scoped packages + if (ts.startsWith(components[0], "@")) { + return "".concat(components[0], "/").concat(components[1]); + } + return components[0]; + } + } + ts.createPackageJsonImportFilter = createPackageJsonImportFilter; + function tryParseJson(text) { + try { + return JSON.parse(text); + } + catch (_a) { + return undefined; + } + } + function consumesNodeCoreModules(sourceFile) { + return ts.some(sourceFile.imports, function (_a) { + var text = _a.text; + return ts.JsTyping.nodeCoreModules.has(text); + }); + } + ts.consumesNodeCoreModules = consumesNodeCoreModules; + function isInsideNodeModules(fileOrDirectory) { + return ts.contains(ts.getPathComponents(fileOrDirectory), "node_modules"); + } + ts.isInsideNodeModules = isInsideNodeModules; + function isDiagnosticWithLocation(diagnostic) { + return diagnostic.file !== undefined && diagnostic.start !== undefined && diagnostic.length !== undefined; + } + ts.isDiagnosticWithLocation = isDiagnosticWithLocation; + function findDiagnosticForNode(node, sortedFileDiagnostics) { + var span = createTextSpanFromNode(node); + var index = ts.binarySearchKey(sortedFileDiagnostics, span, ts.identity, ts.compareTextSpans); + if (index >= 0) { + var diagnostic = sortedFileDiagnostics[index]; + ts.Debug.assertEqual(diagnostic.file, node.getSourceFile(), "Diagnostics proided to 'findDiagnosticForNode' must be from a single SourceFile"); + return ts.cast(diagnostic, isDiagnosticWithLocation); + } + } + ts.findDiagnosticForNode = findDiagnosticForNode; + function getDiagnosticsWithinSpan(span, sortedFileDiagnostics) { + var _a; + var index = ts.binarySearchKey(sortedFileDiagnostics, span.start, function (diag) { return diag.start; }, ts.compareValues); + if (index < 0) { + index = ~index; + } + while (((_a = sortedFileDiagnostics[index - 1]) === null || _a === void 0 ? void 0 : _a.start) === span.start) { + index--; + } + var result = []; + var end = ts.textSpanEnd(span); + while (true) { + var diagnostic = ts.tryCast(sortedFileDiagnostics[index], isDiagnosticWithLocation); + if (!diagnostic || diagnostic.start > end) { + break; + } + if (ts.textSpanContainsTextSpan(span, diagnostic)) { + result.push(diagnostic); + } + index++; + } + return result; + } + ts.getDiagnosticsWithinSpan = getDiagnosticsWithinSpan; + /* @internal */ + function getRefactorContextSpan(_a) { + var startPosition = _a.startPosition, endPosition = _a.endPosition; + return ts.createTextSpanFromBounds(startPosition, endPosition === undefined ? startPosition : endPosition); + } + ts.getRefactorContextSpan = getRefactorContextSpan; + /* @internal */ + function getFixableErrorSpanExpression(sourceFile, span) { + var token = getTokenAtPosition(sourceFile, span.start); + // Checker has already done work to determine that await might be possible, and has attached + // related info to the node, so start by finding the expression that exactly matches up + // with the diagnostic range. + var expression = ts.findAncestor(token, function (node) { + if (node.getStart(sourceFile) < span.start || node.getEnd() > ts.textSpanEnd(span)) { + return "quit"; + } + return ts.isExpression(node) && textSpansEqual(span, createTextSpanFromNode(node, sourceFile)); + }); + return expression; + } + ts.getFixableErrorSpanExpression = getFixableErrorSpanExpression; + function mapOneOrMany(valueOrArray, f, resultSelector) { + if (resultSelector === void 0) { resultSelector = ts.identity; } + return valueOrArray ? ts.isArray(valueOrArray) ? resultSelector(ts.map(valueOrArray, f)) : f(valueOrArray, 0) : undefined; + } + ts.mapOneOrMany = mapOneOrMany; + /** + * If the provided value is an array, the first element of the array is returned; otherwise, the provided value is returned instead. + */ + function firstOrOnly(valueOrArray) { + return ts.isArray(valueOrArray) ? ts.first(valueOrArray) : valueOrArray; + } + ts.firstOrOnly = firstOrOnly; + function getNamesForExportedSymbol(symbol, scriptTarget) { + if (needsNameFromDeclaration(symbol)) { + var fromDeclaration = getDefaultLikeExportNameFromDeclaration(symbol); + if (fromDeclaration) + return fromDeclaration; + var fileNameCase = ts.codefix.moduleSymbolToValidIdentifier(getSymbolParentOrFail(symbol), scriptTarget, /*preferCapitalized*/ false); + var capitalized = ts.codefix.moduleSymbolToValidIdentifier(getSymbolParentOrFail(symbol), scriptTarget, /*preferCapitalized*/ true); + if (fileNameCase === capitalized) + return fileNameCase; + return [fileNameCase, capitalized]; + } + return symbol.name; + } + ts.getNamesForExportedSymbol = getNamesForExportedSymbol; + function getNameForExportedSymbol(symbol, scriptTarget, preferCapitalized) { + if (needsNameFromDeclaration(symbol)) { + // Name of "export default foo;" is "foo". Name of "export default 0" is the filename converted to camelCase. + return getDefaultLikeExportNameFromDeclaration(symbol) + || ts.codefix.moduleSymbolToValidIdentifier(getSymbolParentOrFail(symbol), scriptTarget, !!preferCapitalized); + } + return symbol.name; + } + ts.getNameForExportedSymbol = getNameForExportedSymbol; + function needsNameFromDeclaration(symbol) { + return !(symbol.flags & 33554432 /* SymbolFlags.Transient */) && (symbol.escapedName === "export=" /* InternalSymbolName.ExportEquals */ || symbol.escapedName === "default" /* InternalSymbolName.Default */); + } + function getDefaultLikeExportNameFromDeclaration(symbol) { + return ts.firstDefined(symbol.declarations, function (d) { var _a; return ts.isExportAssignment(d) ? (_a = ts.tryCast(ts.skipOuterExpressions(d.expression), ts.isIdentifier)) === null || _a === void 0 ? void 0 : _a.text : undefined; }); + } + function getSymbolParentOrFail(symbol) { + var _a; + return ts.Debug.checkDefined(symbol.parent, "Symbol parent was undefined. Flags: ".concat(ts.Debug.formatSymbolFlags(symbol.flags), ". ") + + "Declarations: ".concat((_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.map(function (d) { + var kind = ts.Debug.formatSyntaxKind(d.kind); + var inJS = ts.isInJSFile(d); + var expression = d.expression; + return (inJS ? "[JS]" : "") + kind + (expression ? " (expression: ".concat(ts.Debug.formatSyntaxKind(expression.kind), ")") : ""); + }).join(", "), ".")); + } + /** + * Useful to check whether a string contains another string at a specific index + * without allocating another string or traversing the entire contents of the outer string. + * + * This function is useful in place of either of the following: + * + * ```ts + * // Allocates + * haystack.substr(startIndex, needle.length) === needle + * + * // Full traversal + * haystack.indexOf(needle, startIndex) === startIndex + * ``` + * + * @param haystack The string that potentially contains `needle`. + * @param needle The string whose content might sit within `haystack`. + * @param startIndex The index within `haystack` to start searching for `needle`. + */ + function stringContainsAt(haystack, needle, startIndex) { + var needleLength = needle.length; + if (needleLength + startIndex > haystack.length) { + return false; + } + for (var i = 0; i < needleLength; i++) { + if (needle.charCodeAt(i) !== haystack.charCodeAt(i + startIndex)) + return false; + } + return true; + } + ts.stringContainsAt = stringContainsAt; + function startsWithUnderscore(name) { + return name.charCodeAt(0) === 95 /* CharacterCodes._ */; + } + ts.startsWithUnderscore = startsWithUnderscore; + function isGlobalDeclaration(declaration) { + return !isNonGlobalDeclaration(declaration); + } + ts.isGlobalDeclaration = isGlobalDeclaration; + function isNonGlobalDeclaration(declaration) { + var sourceFile = declaration.getSourceFile(); + // If the file is not a module, the declaration is global + if (!sourceFile.externalModuleIndicator && !sourceFile.commonJsModuleIndicator) { + return false; + } + // If the file is a module written in TypeScript, it still might be in a `declare global` augmentation + return ts.isInJSFile(declaration) || !ts.findAncestor(declaration, ts.isGlobalScopeAugmentation); + } + ts.isNonGlobalDeclaration = isNonGlobalDeclaration; + function isDeprecatedDeclaration(decl) { + return !!(ts.getCombinedNodeFlagsAlwaysIncludeJSDoc(decl) & 8192 /* ModifierFlags.Deprecated */); + } + ts.isDeprecatedDeclaration = isDeprecatedDeclaration; + function shouldUseUriStyleNodeCoreModules(file, program) { + var decisionFromFile = ts.firstDefined(file.imports, function (node) { + if (ts.JsTyping.nodeCoreModules.has(node.text)) { + return ts.startsWith(node.text, "node:"); + } + }); + return decisionFromFile !== null && decisionFromFile !== void 0 ? decisionFromFile : program.usesUriStyleNodeCoreModules; + } + ts.shouldUseUriStyleNodeCoreModules = shouldUseUriStyleNodeCoreModules; + function getNewLineKind(newLineCharacter) { + return newLineCharacter === "\n" ? 1 /* NewLineKind.LineFeed */ : 0 /* NewLineKind.CarriageReturnLineFeed */; + } + ts.getNewLineKind = getNewLineKind; + function diagnosticToString(diag) { + return ts.isArray(diag) + ? ts.formatStringFromArgs(ts.getLocaleSpecificMessage(diag[0]), diag.slice(1)) + : ts.getLocaleSpecificMessage(diag); + } + ts.diagnosticToString = diagnosticToString; + /** + * Get format code settings for a code writing context (e.g. when formatting text changes or completions code). + */ + function getFormatCodeSettingsForWriting(_a, sourceFile) { + var options = _a.options; + var shouldAutoDetectSemicolonPreference = !options.semicolons || options.semicolons === ts.SemicolonPreference.Ignore; + var shouldRemoveSemicolons = options.semicolons === ts.SemicolonPreference.Remove || shouldAutoDetectSemicolonPreference && !probablyUsesSemicolons(sourceFile); + return __assign(__assign({}, options), { semicolons: shouldRemoveSemicolons ? ts.SemicolonPreference.Remove : ts.SemicolonPreference.Ignore }); + } + ts.getFormatCodeSettingsForWriting = getFormatCodeSettingsForWriting; + function jsxModeNeedsExplicitImport(jsx) { + return jsx === 2 /* JsxEmit.React */ || jsx === 3 /* JsxEmit.ReactNative */; + } + ts.jsxModeNeedsExplicitImport = jsxModeNeedsExplicitImport; + function isSourceFileFromLibrary(program, node) { + return program.isSourceFileFromExternalLibrary(node) || program.isSourceFileDefaultLibrary(node); + } + ts.isSourceFileFromLibrary = isSourceFileFromLibrary; + // #endregion +})(ts || (ts = {})); +/*@internal*/ +var ts; +(function (ts) { + var ImportKind; + (function (ImportKind) { + ImportKind[ImportKind["Named"] = 0] = "Named"; + ImportKind[ImportKind["Default"] = 1] = "Default"; + ImportKind[ImportKind["Namespace"] = 2] = "Namespace"; + ImportKind[ImportKind["CommonJS"] = 3] = "CommonJS"; + })(ImportKind = ts.ImportKind || (ts.ImportKind = {})); + var ExportKind; + (function (ExportKind) { + ExportKind[ExportKind["Named"] = 0] = "Named"; + ExportKind[ExportKind["Default"] = 1] = "Default"; + ExportKind[ExportKind["ExportEquals"] = 2] = "ExportEquals"; + ExportKind[ExportKind["UMD"] = 3] = "UMD"; + })(ExportKind = ts.ExportKind || (ts.ExportKind = {})); + function createCacheableExportInfoMap(host) { + var exportInfoId = 1; + var exportInfo = ts.createMultiMap(); + var symbols = new ts.Map(); + /** + * Key: node_modules package name (no @types). + * Value: path to deepest node_modules folder seen that is + * both visible to `usableByFileName` and contains the package. + * + * Later, we can see if a given SymbolExportInfo is shadowed by + * a another installation of the same package in a deeper + * node_modules folder by seeing if its path starts with the + * value stored here. + */ + var packages = new ts.Map(); + var usableByFileName; + var cache = { + isUsableByFile: function (importingFile) { return importingFile === usableByFileName; }, + isEmpty: function () { return !exportInfo.size; }, + clear: function () { + exportInfo.clear(); + symbols.clear(); + usableByFileName = undefined; + }, + add: function (importingFile, symbol, symbolTableKey, moduleSymbol, moduleFile, exportKind, isFromPackageJson, checker) { + if (importingFile !== usableByFileName) { + cache.clear(); + usableByFileName = importingFile; + } + var packageName; + if (moduleFile) { + var nodeModulesPathParts = ts.getNodeModulePathParts(moduleFile.fileName); + if (nodeModulesPathParts) { + var topLevelNodeModulesIndex = nodeModulesPathParts.topLevelNodeModulesIndex, topLevelPackageNameIndex = nodeModulesPathParts.topLevelPackageNameIndex, packageRootIndex = nodeModulesPathParts.packageRootIndex; + packageName = ts.unmangleScopedPackageName(ts.getPackageNameFromTypesPackageName(moduleFile.fileName.substring(topLevelPackageNameIndex + 1, packageRootIndex))); + if (ts.startsWith(importingFile, moduleFile.path.substring(0, topLevelNodeModulesIndex))) { + var prevDeepestNodeModulesPath = packages.get(packageName); + var nodeModulesPath = moduleFile.fileName.substring(0, topLevelPackageNameIndex + 1); + if (prevDeepestNodeModulesPath) { + var prevDeepestNodeModulesIndex = prevDeepestNodeModulesPath.indexOf(ts.nodeModulesPathPart); + if (topLevelNodeModulesIndex > prevDeepestNodeModulesIndex) { + packages.set(packageName, nodeModulesPath); + } + } + else { + packages.set(packageName, nodeModulesPath); + } + } + } + } + var isDefault = exportKind === 1 /* ExportKind.Default */; + var namedSymbol = isDefault && ts.getLocalSymbolForExportDefault(symbol) || symbol; + // 1. A named export must be imported by its key in `moduleSymbol.exports` or `moduleSymbol.members`. + // 2. A re-export merged with an export from a module augmentation can result in `symbol` + // being an external module symbol; the name it is re-exported by will be `symbolTableKey` + // (which comes from the keys of `moduleSymbol.exports`.) + // 3. Otherwise, we have a default/namespace import that can be imported by any name, and + // `symbolTableKey` will be something undesirable like `export=` or `default`, so we try to + // get a better name. + var names = exportKind === 0 /* ExportKind.Named */ || ts.isExternalModuleSymbol(namedSymbol) + ? ts.unescapeLeadingUnderscores(symbolTableKey) + : ts.getNamesForExportedSymbol(namedSymbol, /*scriptTarget*/ undefined); + var symbolName = typeof names === "string" ? names : names[0]; + var capitalizedSymbolName = typeof names === "string" ? undefined : names[1]; + var moduleName = ts.stripQuotes(moduleSymbol.name); + var id = exportInfoId++; + var target = ts.skipAlias(symbol, checker); + var storedSymbol = symbol.flags & 33554432 /* SymbolFlags.Transient */ ? undefined : symbol; + var storedModuleSymbol = moduleSymbol.flags & 33554432 /* SymbolFlags.Transient */ ? undefined : moduleSymbol; + if (!storedSymbol || !storedModuleSymbol) + symbols.set(id, [symbol, moduleSymbol]); + exportInfo.add(key(symbolName, symbol, ts.isExternalModuleNameRelative(moduleName) ? undefined : moduleName, checker), { + id: id, + symbolTableKey: symbolTableKey, + symbolName: symbolName, + capitalizedSymbolName: capitalizedSymbolName, + moduleName: moduleName, + moduleFile: moduleFile, + moduleFileName: moduleFile === null || moduleFile === void 0 ? void 0 : moduleFile.fileName, + packageName: packageName, + exportKind: exportKind, + targetFlags: target.flags, + isFromPackageJson: isFromPackageJson, + symbol: storedSymbol, + moduleSymbol: storedModuleSymbol, + }); + }, + get: function (importingFile, key) { + if (importingFile !== usableByFileName) + return; + var result = exportInfo.get(key); + return result === null || result === void 0 ? void 0 : result.map(rehydrateCachedInfo); + }, + search: function (importingFile, preferCapitalized, matches, action) { + if (importingFile !== usableByFileName) + return; + return ts.forEachEntry(exportInfo, function (info, key) { + var _a = parseKey(key), symbolName = _a.symbolName, ambientModuleName = _a.ambientModuleName; + var name = preferCapitalized && info[0].capitalizedSymbolName || symbolName; + if (matches(name, info[0].targetFlags)) { + var rehydrated = info.map(rehydrateCachedInfo); + var filtered = rehydrated.filter(function (r, i) { return isNotShadowedByDeeperNodeModulesPackage(r, info[i].packageName); }); + if (filtered.length) { + var res = action(filtered, name, !!ambientModuleName, key); + if (res !== undefined) + return res; + } + } + }); + }, + releaseSymbols: function () { + symbols.clear(); + }, + onFileChanged: function (oldSourceFile, newSourceFile, typeAcquisitionEnabled) { + if (fileIsGlobalOnly(oldSourceFile) && fileIsGlobalOnly(newSourceFile)) { + // File is purely global; doesn't affect export map + return false; + } + if (usableByFileName && usableByFileName !== newSourceFile.path || + // If ATA is enabled, auto-imports uses existing imports to guess whether you want auto-imports from node. + // Adding or removing imports from node could change the outcome of that guess, so could change the suggestions list. + typeAcquisitionEnabled && ts.consumesNodeCoreModules(oldSourceFile) !== ts.consumesNodeCoreModules(newSourceFile) || + // Module agumentation and ambient module changes can add or remove exports available to be auto-imported. + // Changes elsewhere in the file can change the *type* of an export in a module augmentation, + // but type info is gathered in getCompletionEntryDetails, which doesn’t use the cache. + !ts.arrayIsEqualTo(oldSourceFile.moduleAugmentations, newSourceFile.moduleAugmentations) || + !ambientModuleDeclarationsAreEqual(oldSourceFile, newSourceFile)) { + cache.clear(); + return true; + } + usableByFileName = newSourceFile.path; + return false; + }, + }; + if (ts.Debug.isDebugging) { + Object.defineProperty(cache, "__cache", { get: function () { return exportInfo; } }); + } + return cache; + function rehydrateCachedInfo(info) { + if (info.symbol && info.moduleSymbol) + return info; + var id = info.id, exportKind = info.exportKind, targetFlags = info.targetFlags, isFromPackageJson = info.isFromPackageJson, moduleFileName = info.moduleFileName; + var _a = symbols.get(id) || ts.emptyArray, cachedSymbol = _a[0], cachedModuleSymbol = _a[1]; + if (cachedSymbol && cachedModuleSymbol) { + return { + symbol: cachedSymbol, + moduleSymbol: cachedModuleSymbol, + moduleFileName: moduleFileName, + exportKind: exportKind, + targetFlags: targetFlags, + isFromPackageJson: isFromPackageJson, + }; + } + var checker = (isFromPackageJson + ? host.getPackageJsonAutoImportProvider() + : host.getCurrentProgram()).getTypeChecker(); + var moduleSymbol = info.moduleSymbol || cachedModuleSymbol || ts.Debug.checkDefined(info.moduleFile + ? checker.getMergedSymbol(info.moduleFile.symbol) + : checker.tryFindAmbientModule(info.moduleName)); + var symbol = info.symbol || cachedSymbol || ts.Debug.checkDefined(exportKind === 2 /* ExportKind.ExportEquals */ + ? checker.resolveExternalModuleSymbol(moduleSymbol) + : checker.tryGetMemberInModuleExportsAndProperties(ts.unescapeLeadingUnderscores(info.symbolTableKey), moduleSymbol), "Could not find symbol '".concat(info.symbolName, "' by key '").concat(info.symbolTableKey, "' in module ").concat(moduleSymbol.name)); + symbols.set(id, [symbol, moduleSymbol]); + return { + symbol: symbol, + moduleSymbol: moduleSymbol, + moduleFileName: moduleFileName, + exportKind: exportKind, + targetFlags: targetFlags, + isFromPackageJson: isFromPackageJson, + }; + } + function key(importedName, symbol, ambientModuleName, checker) { + var moduleKey = ambientModuleName || ""; + return "".concat(importedName, "|").concat(ts.getSymbolId(ts.skipAlias(symbol, checker)), "|").concat(moduleKey); + } + function parseKey(key) { + var symbolName = key.substring(0, key.indexOf("|")); + var moduleKey = key.substring(key.lastIndexOf("|") + 1); + var ambientModuleName = moduleKey === "" ? undefined : moduleKey; + return { symbolName: symbolName, ambientModuleName: ambientModuleName }; + } + function fileIsGlobalOnly(file) { + return !file.commonJsModuleIndicator && !file.externalModuleIndicator && !file.moduleAugmentations && !file.ambientModuleNames; + } + function ambientModuleDeclarationsAreEqual(oldSourceFile, newSourceFile) { + if (!ts.arrayIsEqualTo(oldSourceFile.ambientModuleNames, newSourceFile.ambientModuleNames)) { + return false; + } + var oldFileStatementIndex = -1; + var newFileStatementIndex = -1; + var _loop_2 = function (ambientModuleName) { + var isMatchingModuleDeclaration = function (node) { return ts.isNonGlobalAmbientModule(node) && node.name.text === ambientModuleName; }; + oldFileStatementIndex = ts.findIndex(oldSourceFile.statements, isMatchingModuleDeclaration, oldFileStatementIndex + 1); + newFileStatementIndex = ts.findIndex(newSourceFile.statements, isMatchingModuleDeclaration, newFileStatementIndex + 1); + if (oldSourceFile.statements[oldFileStatementIndex] !== newSourceFile.statements[newFileStatementIndex]) { + return { value: false }; + } + }; + for (var _i = 0, _a = newSourceFile.ambientModuleNames; _i < _a.length; _i++) { + var ambientModuleName = _a[_i]; + var state_2 = _loop_2(ambientModuleName); + if (typeof state_2 === "object") + return state_2.value; + } + return true; + } + function isNotShadowedByDeeperNodeModulesPackage(info, packageName) { + if (!packageName || !info.moduleFileName) + return true; + var typingsCacheLocation = host.getGlobalTypingsCacheLocation(); + if (typingsCacheLocation && ts.startsWith(info.moduleFileName, typingsCacheLocation)) + return true; + var packageDeepestNodeModulesPath = packages.get(packageName); + return !packageDeepestNodeModulesPath || ts.startsWith(info.moduleFileName, packageDeepestNodeModulesPath); + } + } + ts.createCacheableExportInfoMap = createCacheableExportInfoMap; + function isImportableFile(program, from, to, preferences, packageJsonFilter, moduleSpecifierResolutionHost, moduleSpecifierCache) { + var _a; + if (from === to) + return false; + var cachedResult = moduleSpecifierCache === null || moduleSpecifierCache === void 0 ? void 0 : moduleSpecifierCache.get(from.path, to.path, preferences, {}); + if ((cachedResult === null || cachedResult === void 0 ? void 0 : cachedResult.isBlockedByPackageJsonDependencies) !== undefined) { + return !cachedResult.isBlockedByPackageJsonDependencies; + } + var getCanonicalFileName = ts.hostGetCanonicalFileName(moduleSpecifierResolutionHost); + var globalTypingsCache = (_a = moduleSpecifierResolutionHost.getGlobalTypingsCacheLocation) === null || _a === void 0 ? void 0 : _a.call(moduleSpecifierResolutionHost); + var hasImportablePath = !!ts.moduleSpecifiers.forEachFileNameOfModule(from.fileName, to.fileName, moduleSpecifierResolutionHost, + /*preferSymlinks*/ false, function (toPath) { + var toFile = program.getSourceFile(toPath); + // Determine to import using toPath only if toPath is what we were looking at + // or there doesnt exist the file in the program by the symlink + return (toFile === to || !toFile) && + isImportablePath(from.fileName, toPath, getCanonicalFileName, globalTypingsCache); + }); + if (packageJsonFilter) { + var isAutoImportable = hasImportablePath && packageJsonFilter.allowsImportingSourceFile(to, moduleSpecifierResolutionHost); + moduleSpecifierCache === null || moduleSpecifierCache === void 0 ? void 0 : moduleSpecifierCache.setBlockedByPackageJsonDependencies(from.path, to.path, preferences, {}, !isAutoImportable); + return isAutoImportable; + } + return hasImportablePath; + } + ts.isImportableFile = isImportableFile; + /** + * Don't include something from a `node_modules` that isn't actually reachable by a global import. + * A relative import to node_modules is usually a bad idea. + */ + function isImportablePath(fromPath, toPath, getCanonicalFileName, globalCachePath) { + // If it's in a `node_modules` but is not reachable from here via a global import, don't bother. + var toNodeModules = ts.forEachAncestorDirectory(toPath, function (ancestor) { return ts.getBaseFileName(ancestor) === "node_modules" ? ancestor : undefined; }); + var toNodeModulesParent = toNodeModules && ts.getDirectoryPath(getCanonicalFileName(toNodeModules)); + return toNodeModulesParent === undefined + || ts.startsWith(getCanonicalFileName(fromPath), toNodeModulesParent) + || (!!globalCachePath && ts.startsWith(getCanonicalFileName(globalCachePath), toNodeModulesParent)); + } + function forEachExternalModuleToImportFrom(program, host, preferences, useAutoImportProvider, cb) { + var _a, _b; + var useCaseSensitiveFileNames = ts.hostUsesCaseSensitiveFileNames(host); + var excludePatterns = preferences.autoImportFileExcludePatterns && ts.mapDefined(preferences.autoImportFileExcludePatterns, function (spec) { + // The client is expected to send rooted path specs since we don't know + // what directory a relative path is relative to. + var pattern = ts.getPatternFromSpec(spec, "", "exclude"); + return pattern ? ts.getRegexFromPattern(pattern, useCaseSensitiveFileNames) : undefined; + }); + forEachExternalModule(program.getTypeChecker(), program.getSourceFiles(), excludePatterns, function (module, file) { return cb(module, file, program, /*isFromPackageJson*/ false); }); + var autoImportProvider = useAutoImportProvider && ((_a = host.getPackageJsonAutoImportProvider) === null || _a === void 0 ? void 0 : _a.call(host)); + if (autoImportProvider) { + var start = ts.timestamp(); + forEachExternalModule(autoImportProvider.getTypeChecker(), autoImportProvider.getSourceFiles(), excludePatterns, function (module, file) { return cb(module, file, autoImportProvider, /*isFromPackageJson*/ true); }); + (_b = host.log) === null || _b === void 0 ? void 0 : _b.call(host, "forEachExternalModuleToImportFrom autoImportProvider: ".concat(ts.timestamp() - start)); + } + } + ts.forEachExternalModuleToImportFrom = forEachExternalModuleToImportFrom; + function forEachExternalModule(checker, allSourceFiles, excludePatterns, cb) { + var _a; + var isExcluded = function (fileName) { return excludePatterns === null || excludePatterns === void 0 ? void 0 : excludePatterns.some(function (p) { return p.test(fileName); }); }; + for (var _i = 0, _b = checker.getAmbientModules(); _i < _b.length; _i++) { + var ambient = _b[_i]; + if (!ts.stringContains(ambient.name, "*") && !(excludePatterns && ((_a = ambient.declarations) === null || _a === void 0 ? void 0 : _a.every(function (d) { return isExcluded(d.getSourceFile().fileName); })))) { + cb(ambient, /*sourceFile*/ undefined); + } + } + for (var _c = 0, allSourceFiles_1 = allSourceFiles; _c < allSourceFiles_1.length; _c++) { + var sourceFile = allSourceFiles_1[_c]; + if (ts.isExternalOrCommonJsModule(sourceFile) && !isExcluded(sourceFile.fileName)) { + cb(checker.getMergedSymbol(sourceFile.symbol), sourceFile); + } + } + } + function getExportInfoMap(importingFile, host, program, preferences, cancellationToken) { + var _a, _b, _c, _d, _e; + var start = ts.timestamp(); + // Pulling the AutoImportProvider project will trigger its updateGraph if pending, + // which will invalidate the export map cache if things change, so pull it before + // checking the cache. + (_a = host.getPackageJsonAutoImportProvider) === null || _a === void 0 ? void 0 : _a.call(host); + var cache = ((_b = host.getCachedExportInfoMap) === null || _b === void 0 ? void 0 : _b.call(host)) || createCacheableExportInfoMap({ + getCurrentProgram: function () { return program; }, + getPackageJsonAutoImportProvider: function () { var _a; return (_a = host.getPackageJsonAutoImportProvider) === null || _a === void 0 ? void 0 : _a.call(host); }, + getGlobalTypingsCacheLocation: function () { var _a; return (_a = host.getGlobalTypingsCacheLocation) === null || _a === void 0 ? void 0 : _a.call(host); }, + }); + if (cache.isUsableByFile(importingFile.path)) { + (_c = host.log) === null || _c === void 0 ? void 0 : _c.call(host, "getExportInfoMap: cache hit"); + return cache; + } + (_d = host.log) === null || _d === void 0 ? void 0 : _d.call(host, "getExportInfoMap: cache miss or empty; calculating new results"); + var compilerOptions = program.getCompilerOptions(); + var moduleCount = 0; + try { + forEachExternalModuleToImportFrom(program, host, preferences, /*useAutoImportProvider*/ true, function (moduleSymbol, moduleFile, program, isFromPackageJson) { + if (++moduleCount % 100 === 0) + cancellationToken === null || cancellationToken === void 0 ? void 0 : cancellationToken.throwIfCancellationRequested(); + var seenExports = new ts.Map(); + var checker = program.getTypeChecker(); + var defaultInfo = getDefaultLikeExportInfo(moduleSymbol, checker, compilerOptions); + // Note: I think we shouldn't actually see resolved module symbols here, but weird merges + // can cause it to happen: see 'completionsImport_mergedReExport.ts' + if (defaultInfo && isImportableSymbol(defaultInfo.symbol, checker)) { + cache.add(importingFile.path, defaultInfo.symbol, defaultInfo.exportKind === 1 /* ExportKind.Default */ ? "default" /* InternalSymbolName.Default */ : "export=" /* InternalSymbolName.ExportEquals */, moduleSymbol, moduleFile, defaultInfo.exportKind, isFromPackageJson, checker); + } + checker.forEachExportAndPropertyOfModule(moduleSymbol, function (exported, key) { + if (exported !== (defaultInfo === null || defaultInfo === void 0 ? void 0 : defaultInfo.symbol) && isImportableSymbol(exported, checker) && ts.addToSeen(seenExports, key)) { + cache.add(importingFile.path, exported, key, moduleSymbol, moduleFile, 0 /* ExportKind.Named */, isFromPackageJson, checker); + } + }); + }); + } + catch (err) { + // Ensure cache is reset if operation is cancelled + cache.clear(); + throw err; + } + (_e = host.log) === null || _e === void 0 ? void 0 : _e.call(host, "getExportInfoMap: done in ".concat(ts.timestamp() - start, " ms")); + return cache; + } + ts.getExportInfoMap = getExportInfoMap; + function getDefaultLikeExportInfo(moduleSymbol, checker, compilerOptions) { + var exported = getDefaultLikeExportWorker(moduleSymbol, checker); + if (!exported) + return undefined; + var symbol = exported.symbol, exportKind = exported.exportKind; + var info = getDefaultExportInfoWorker(symbol, checker, compilerOptions); + return info && __assign({ symbol: symbol, exportKind: exportKind }, info); + } + ts.getDefaultLikeExportInfo = getDefaultLikeExportInfo; + function isImportableSymbol(symbol, checker) { + return !checker.isUndefinedSymbol(symbol) && !checker.isUnknownSymbol(symbol) && !ts.isKnownSymbol(symbol) && !ts.isPrivateIdentifierSymbol(symbol); + } + function getDefaultLikeExportWorker(moduleSymbol, checker) { + var exportEquals = checker.resolveExternalModuleSymbol(moduleSymbol); + if (exportEquals !== moduleSymbol) + return { symbol: exportEquals, exportKind: 2 /* ExportKind.ExportEquals */ }; + var defaultExport = checker.tryGetMemberInModuleExports("default" /* InternalSymbolName.Default */, moduleSymbol); + if (defaultExport) + return { symbol: defaultExport, exportKind: 1 /* ExportKind.Default */ }; + } + function getDefaultExportInfoWorker(defaultExport, checker, compilerOptions) { + var localSymbol = ts.getLocalSymbolForExportDefault(defaultExport); + if (localSymbol) + return { symbolForMeaning: localSymbol, name: localSymbol.name }; + var name = getNameForExportDefault(defaultExport); + if (name !== undefined) + return { symbolForMeaning: defaultExport, name: name }; + if (defaultExport.flags & 2097152 /* SymbolFlags.Alias */) { + var aliased = checker.getImmediateAliasedSymbol(defaultExport); + if (aliased && aliased.parent) { + // - `aliased` will be undefined if the module is exporting an unresolvable name, + // but we can still offer completions for it. + // - `aliased.parent` will be undefined if the module is exporting `globalThis.something`, + // or another expression that resolves to a global. + return getDefaultExportInfoWorker(aliased, checker, compilerOptions); + } + } + if (defaultExport.escapedName !== "default" /* InternalSymbolName.Default */ && + defaultExport.escapedName !== "export=" /* InternalSymbolName.ExportEquals */) { + return { symbolForMeaning: defaultExport, name: defaultExport.getName() }; + } + return { symbolForMeaning: defaultExport, name: ts.getNameForExportedSymbol(defaultExport, compilerOptions.target) }; + } + function getNameForExportDefault(symbol) { + return symbol.declarations && ts.firstDefined(symbol.declarations, function (declaration) { + var _a; + if (ts.isExportAssignment(declaration)) { + return (_a = ts.tryCast(ts.skipOuterExpressions(declaration.expression), ts.isIdentifier)) === null || _a === void 0 ? void 0 : _a.text; + } + else if (ts.isExportSpecifier(declaration)) { + ts.Debug.assert(declaration.name.text === "default" /* InternalSymbolName.Default */, "Expected the specifier to be a default export"); + return declaration.propertyName && declaration.propertyName.text; + } + }); + } +})(ts || (ts = {})); +var ts; +(function (ts) { + /** The classifier is used for syntactic highlighting in editors via the TSServer */ + function createClassifier() { + var scanner = ts.createScanner(99 /* ScriptTarget.Latest */, /*skipTrivia*/ false); + function getClassificationsForLine(text, lexState, syntacticClassifierAbsent) { + return convertClassificationsToResult(getEncodedLexicalClassifications(text, lexState, syntacticClassifierAbsent), text); + } + // If there is a syntactic classifier ('syntacticClassifierAbsent' is false), + // we will be more conservative in order to avoid conflicting with the syntactic classifier. + function getEncodedLexicalClassifications(text, lexState, syntacticClassifierAbsent) { + var token = 0 /* SyntaxKind.Unknown */; + var lastNonTriviaToken = 0 /* SyntaxKind.Unknown */; + // Just a stack of TemplateHeads and OpenCurlyBraces, used to perform rudimentary (inexact) + // classification on template strings. Because of the context free nature of templates, + // the only precise way to classify a template portion would be by propagating the stack across + // lines, just as we do with the end-of-line state. However, this is a burden for implementers, + // and the behavior is entirely subsumed by the syntactic classifier anyway, so we instead + // flatten any nesting when the template stack is non-empty and encode it in the end-of-line state. + // Situations in which this fails are + // 1) When template strings are nested across different lines: + // `hello ${ `world + // ` }` + // + // Where on the second line, you will get the closing of a template, + // a closing curly, and a new template. + // + // 2) When substitution expressions have curly braces and the curly brace falls on the next line: + // `hello ${ () => { + // return "world" } } ` + // + // Where on the second line, you will get the 'return' keyword, + // a string literal, and a template end consisting of '} } `'. + var templateStack = []; + var _a = getPrefixFromLexState(lexState), prefix = _a.prefix, pushTemplate = _a.pushTemplate; + text = prefix + text; + var offset = prefix.length; + if (pushTemplate) { + templateStack.push(15 /* SyntaxKind.TemplateHead */); + } + scanner.setText(text); + var endOfLineState = 0 /* EndOfLineState.None */; + var spans = []; + // We can run into an unfortunate interaction between the lexical and syntactic classifier + // when the user is typing something generic. Consider the case where the user types: + // + // Foo tokens. It's a weak heuristic, but should + // work well enough in practice. + var angleBracketStack = 0; + do { + token = scanner.scan(); + if (!ts.isTrivia(token)) { + handleToken(); + lastNonTriviaToken = token; + } + var end = scanner.getTextPos(); + pushEncodedClassification(scanner.getTokenPos(), end, offset, classFromKind(token), spans); + if (end >= text.length) { + var end_1 = getNewEndOfLineState(scanner, token, ts.lastOrUndefined(templateStack)); + if (end_1 !== undefined) { + endOfLineState = end_1; + } + } + } while (token !== 1 /* SyntaxKind.EndOfFileToken */); + function handleToken() { + switch (token) { + case 43 /* SyntaxKind.SlashToken */: + case 68 /* SyntaxKind.SlashEqualsToken */: + if (!noRegexTable[lastNonTriviaToken] && scanner.reScanSlashToken() === 13 /* SyntaxKind.RegularExpressionLiteral */) { + token = 13 /* SyntaxKind.RegularExpressionLiteral */; + } + break; + case 29 /* SyntaxKind.LessThanToken */: + if (lastNonTriviaToken === 79 /* SyntaxKind.Identifier */) { + // Could be the start of something generic. Keep track of that by bumping + // up the current count of generic contexts we may be in. + angleBracketStack++; + } + break; + case 31 /* SyntaxKind.GreaterThanToken */: + if (angleBracketStack > 0) { + // If we think we're currently in something generic, then mark that that + // generic entity is complete. + angleBracketStack--; + } + break; + case 131 /* SyntaxKind.AnyKeyword */: + case 152 /* SyntaxKind.StringKeyword */: + case 148 /* SyntaxKind.NumberKeyword */: + case 134 /* SyntaxKind.BooleanKeyword */: + case 153 /* SyntaxKind.SymbolKeyword */: + if (angleBracketStack > 0 && !syntacticClassifierAbsent) { + // If it looks like we're could be in something generic, don't classify this + // as a keyword. We may just get overwritten by the syntactic classifier, + // causing a noisy experience for the user. + token = 79 /* SyntaxKind.Identifier */; + } + break; + case 15 /* SyntaxKind.TemplateHead */: + templateStack.push(token); + break; + case 18 /* SyntaxKind.OpenBraceToken */: + // If we don't have anything on the template stack, + // then we aren't trying to keep track of a previously scanned template head. + if (templateStack.length > 0) { + templateStack.push(token); + } + break; + case 19 /* SyntaxKind.CloseBraceToken */: + // If we don't have anything on the template stack, + // then we aren't trying to keep track of a previously scanned template head. + if (templateStack.length > 0) { + var lastTemplateStackToken = ts.lastOrUndefined(templateStack); + if (lastTemplateStackToken === 15 /* SyntaxKind.TemplateHead */) { + token = scanner.reScanTemplateToken(/* isTaggedTemplate */ false); + // Only pop on a TemplateTail; a TemplateMiddle indicates there is more for us. + if (token === 17 /* SyntaxKind.TemplateTail */) { + templateStack.pop(); + } + else { + ts.Debug.assertEqual(token, 16 /* SyntaxKind.TemplateMiddle */, "Should have been a template middle."); + } + } + else { + ts.Debug.assertEqual(lastTemplateStackToken, 18 /* SyntaxKind.OpenBraceToken */, "Should have been an open brace"); + templateStack.pop(); + } + } + break; + default: + if (!ts.isKeyword(token)) { + break; + } + if (lastNonTriviaToken === 24 /* SyntaxKind.DotToken */) { + token = 79 /* SyntaxKind.Identifier */; + } + else if (ts.isKeyword(lastNonTriviaToken) && ts.isKeyword(token) && !canFollow(lastNonTriviaToken, token)) { + // We have two keywords in a row. Only treat the second as a keyword if + // it's a sequence that could legally occur in the language. Otherwise + // treat it as an identifier. This way, if someone writes "private var" + // we recognize that 'var' is actually an identifier here. + token = 79 /* SyntaxKind.Identifier */; + } + } + } + return { endOfLineState: endOfLineState, spans: spans }; + } + return { getClassificationsForLine: getClassificationsForLine, getEncodedLexicalClassifications: getEncodedLexicalClassifications }; + } + ts.createClassifier = createClassifier; + /// We do not have a full parser support to know when we should parse a regex or not + /// If we consider every slash token to be a regex, we could be missing cases like "1/2/3", where + /// we have a series of divide operator. this list allows us to be more accurate by ruling out + /// locations where a regexp cannot exist. + var noRegexTable = ts.arrayToNumericMap([ + 79 /* SyntaxKind.Identifier */, + 10 /* SyntaxKind.StringLiteral */, + 8 /* SyntaxKind.NumericLiteral */, + 9 /* SyntaxKind.BigIntLiteral */, + 13 /* SyntaxKind.RegularExpressionLiteral */, + 108 /* SyntaxKind.ThisKeyword */, + 45 /* SyntaxKind.PlusPlusToken */, + 46 /* SyntaxKind.MinusMinusToken */, + 21 /* SyntaxKind.CloseParenToken */, + 23 /* SyntaxKind.CloseBracketToken */, + 19 /* SyntaxKind.CloseBraceToken */, + 110 /* SyntaxKind.TrueKeyword */, + 95 /* SyntaxKind.FalseKeyword */, + ], function (token) { return token; }, function () { return true; }); + function getNewEndOfLineState(scanner, token, lastOnTemplateStack) { + switch (token) { + case 10 /* SyntaxKind.StringLiteral */: { + // Check to see if we finished up on a multiline string literal. + if (!scanner.isUnterminated()) + return undefined; + var tokenText = scanner.getTokenText(); + var lastCharIndex = tokenText.length - 1; + var numBackslashes = 0; + while (tokenText.charCodeAt(lastCharIndex - numBackslashes) === 92 /* CharacterCodes.backslash */) { + numBackslashes++; + } + // If we have an odd number of backslashes, then the multiline string is unclosed + if ((numBackslashes & 1) === 0) + return undefined; + return tokenText.charCodeAt(0) === 34 /* CharacterCodes.doubleQuote */ ? 3 /* EndOfLineState.InDoubleQuoteStringLiteral */ : 2 /* EndOfLineState.InSingleQuoteStringLiteral */; + } + case 3 /* SyntaxKind.MultiLineCommentTrivia */: + // Check to see if the multiline comment was unclosed. + return scanner.isUnterminated() ? 1 /* EndOfLineState.InMultiLineCommentTrivia */ : undefined; + default: + if (ts.isTemplateLiteralKind(token)) { + if (!scanner.isUnterminated()) { + return undefined; + } + switch (token) { + case 17 /* SyntaxKind.TemplateTail */: + return 5 /* EndOfLineState.InTemplateMiddleOrTail */; + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + return 4 /* EndOfLineState.InTemplateHeadOrNoSubstitutionTemplate */; + default: + return ts.Debug.fail("Only 'NoSubstitutionTemplateLiteral's and 'TemplateTail's can be unterminated; got SyntaxKind #" + token); + } + } + return lastOnTemplateStack === 15 /* SyntaxKind.TemplateHead */ ? 6 /* EndOfLineState.InTemplateSubstitutionPosition */ : undefined; + } + } + function pushEncodedClassification(start, end, offset, classification, result) { + if (classification === 8 /* ClassificationType.whiteSpace */) { + // Don't bother with whitespace classifications. They're not needed. + return; + } + if (start === 0 && offset > 0) { + // We're classifying the first token, and this was a case where we prepended text. + // We should consider the start of this token to be at the start of the original text. + start += offset; + } + var length = end - start; + if (length > 0) { + // All our tokens are in relation to the augmented text. Move them back to be + // relative to the original text. + result.push(start - offset, length, classification); + } + } + function convertClassificationsToResult(classifications, text) { + var entries = []; + var dense = classifications.spans; + var lastEnd = 0; + for (var i = 0; i < dense.length; i += 3) { + var start = dense[i]; + var length_1 = dense[i + 1]; + var type = dense[i + 2]; + // Make a whitespace entry between the last item and this one. + if (lastEnd >= 0) { + var whitespaceLength_1 = start - lastEnd; + if (whitespaceLength_1 > 0) { + entries.push({ length: whitespaceLength_1, classification: ts.TokenClass.Whitespace }); + } + } + entries.push({ length: length_1, classification: convertClassification(type) }); + lastEnd = start + length_1; + } + var whitespaceLength = text.length - lastEnd; + if (whitespaceLength > 0) { + entries.push({ length: whitespaceLength, classification: ts.TokenClass.Whitespace }); + } + return { entries: entries, finalLexState: classifications.endOfLineState }; + } + function convertClassification(type) { + switch (type) { + case 1 /* ClassificationType.comment */: return ts.TokenClass.Comment; + case 3 /* ClassificationType.keyword */: return ts.TokenClass.Keyword; + case 4 /* ClassificationType.numericLiteral */: return ts.TokenClass.NumberLiteral; + case 25 /* ClassificationType.bigintLiteral */: return ts.TokenClass.BigIntLiteral; + case 5 /* ClassificationType.operator */: return ts.TokenClass.Operator; + case 6 /* ClassificationType.stringLiteral */: return ts.TokenClass.StringLiteral; + case 8 /* ClassificationType.whiteSpace */: return ts.TokenClass.Whitespace; + case 10 /* ClassificationType.punctuation */: return ts.TokenClass.Punctuation; + case 2 /* ClassificationType.identifier */: + case 11 /* ClassificationType.className */: + case 12 /* ClassificationType.enumName */: + case 13 /* ClassificationType.interfaceName */: + case 14 /* ClassificationType.moduleName */: + case 15 /* ClassificationType.typeParameterName */: + case 16 /* ClassificationType.typeAliasName */: + case 9 /* ClassificationType.text */: + case 17 /* ClassificationType.parameterName */: + return ts.TokenClass.Identifier; + default: + return undefined; // TODO: GH#18217 Debug.assertNever(type); + } + } + /** Returns true if 'keyword2' can legally follow 'keyword1' in any language construct. */ + function canFollow(keyword1, keyword2) { + if (!ts.isAccessibilityModifier(keyword1)) { + // Assume any other keyword combination is legal. + // This can be refined in the future if there are more cases we want the classifier to be better at. + return true; + } + switch (keyword2) { + case 137 /* SyntaxKind.GetKeyword */: + case 151 /* SyntaxKind.SetKeyword */: + case 135 /* SyntaxKind.ConstructorKeyword */: + case 124 /* SyntaxKind.StaticKeyword */: + case 127 /* SyntaxKind.AccessorKeyword */: + return true; // Allow things like "public get", "public constructor" and "public static". + default: + return false; // Any other keyword following "public" is actually an identifier, not a real keyword. + } + } + function getPrefixFromLexState(lexState) { + // If we're in a string literal, then prepend: "\ + // (and a newline). That way when we lex we'll think we're still in a string literal. + // + // If we're in a multiline comment, then prepend: /* + // (and a newline). That way when we lex we'll think we're still in a multiline comment. + switch (lexState) { + case 3 /* EndOfLineState.InDoubleQuoteStringLiteral */: + return { prefix: "\"\\\n" }; + case 2 /* EndOfLineState.InSingleQuoteStringLiteral */: + return { prefix: "'\\\n" }; + case 1 /* EndOfLineState.InMultiLineCommentTrivia */: + return { prefix: "/*\n" }; + case 4 /* EndOfLineState.InTemplateHeadOrNoSubstitutionTemplate */: + return { prefix: "`\n" }; + case 5 /* EndOfLineState.InTemplateMiddleOrTail */: + return { prefix: "}\n", pushTemplate: true }; + case 6 /* EndOfLineState.InTemplateSubstitutionPosition */: + return { prefix: "", pushTemplate: true }; + case 0 /* EndOfLineState.None */: + return { prefix: "" }; + default: + return ts.Debug.assertNever(lexState); + } + } + function isBinaryExpressionOperatorToken(token) { + switch (token) { + case 41 /* SyntaxKind.AsteriskToken */: + case 43 /* SyntaxKind.SlashToken */: + case 44 /* SyntaxKind.PercentToken */: + case 39 /* SyntaxKind.PlusToken */: + case 40 /* SyntaxKind.MinusToken */: + case 47 /* SyntaxKind.LessThanLessThanToken */: + case 48 /* SyntaxKind.GreaterThanGreaterThanToken */: + case 49 /* SyntaxKind.GreaterThanGreaterThanGreaterThanToken */: + case 29 /* SyntaxKind.LessThanToken */: + case 31 /* SyntaxKind.GreaterThanToken */: + case 32 /* SyntaxKind.LessThanEqualsToken */: + case 33 /* SyntaxKind.GreaterThanEqualsToken */: + case 102 /* SyntaxKind.InstanceOfKeyword */: + case 101 /* SyntaxKind.InKeyword */: + case 128 /* SyntaxKind.AsKeyword */: + case 150 /* SyntaxKind.SatisfiesKeyword */: + case 34 /* SyntaxKind.EqualsEqualsToken */: + case 35 /* SyntaxKind.ExclamationEqualsToken */: + case 36 /* SyntaxKind.EqualsEqualsEqualsToken */: + case 37 /* SyntaxKind.ExclamationEqualsEqualsToken */: + case 50 /* SyntaxKind.AmpersandToken */: + case 52 /* SyntaxKind.CaretToken */: + case 51 /* SyntaxKind.BarToken */: + case 55 /* SyntaxKind.AmpersandAmpersandToken */: + case 56 /* SyntaxKind.BarBarToken */: + case 74 /* SyntaxKind.BarEqualsToken */: + case 73 /* SyntaxKind.AmpersandEqualsToken */: + case 78 /* SyntaxKind.CaretEqualsToken */: + case 70 /* SyntaxKind.LessThanLessThanEqualsToken */: + case 71 /* SyntaxKind.GreaterThanGreaterThanEqualsToken */: + case 72 /* SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken */: + case 64 /* SyntaxKind.PlusEqualsToken */: + case 65 /* SyntaxKind.MinusEqualsToken */: + case 66 /* SyntaxKind.AsteriskEqualsToken */: + case 68 /* SyntaxKind.SlashEqualsToken */: + case 69 /* SyntaxKind.PercentEqualsToken */: + case 63 /* SyntaxKind.EqualsToken */: + case 27 /* SyntaxKind.CommaToken */: + case 60 /* SyntaxKind.QuestionQuestionToken */: + case 75 /* SyntaxKind.BarBarEqualsToken */: + case 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */: + case 77 /* SyntaxKind.QuestionQuestionEqualsToken */: + return true; + default: + return false; + } + } + function isPrefixUnaryExpressionOperatorToken(token) { + switch (token) { + case 39 /* SyntaxKind.PlusToken */: + case 40 /* SyntaxKind.MinusToken */: + case 54 /* SyntaxKind.TildeToken */: + case 53 /* SyntaxKind.ExclamationToken */: + case 45 /* SyntaxKind.PlusPlusToken */: + case 46 /* SyntaxKind.MinusMinusToken */: + return true; + default: + return false; + } + } + function classFromKind(token) { + if (ts.isKeyword(token)) { + return 3 /* ClassificationType.keyword */; + } + else if (isBinaryExpressionOperatorToken(token) || isPrefixUnaryExpressionOperatorToken(token)) { + return 5 /* ClassificationType.operator */; + } + else if (token >= 18 /* SyntaxKind.FirstPunctuation */ && token <= 78 /* SyntaxKind.LastPunctuation */) { + return 10 /* ClassificationType.punctuation */; + } + switch (token) { + case 8 /* SyntaxKind.NumericLiteral */: + return 4 /* ClassificationType.numericLiteral */; + case 9 /* SyntaxKind.BigIntLiteral */: + return 25 /* ClassificationType.bigintLiteral */; + case 10 /* SyntaxKind.StringLiteral */: + return 6 /* ClassificationType.stringLiteral */; + case 13 /* SyntaxKind.RegularExpressionLiteral */: + return 7 /* ClassificationType.regularExpressionLiteral */; + case 7 /* SyntaxKind.ConflictMarkerTrivia */: + case 3 /* SyntaxKind.MultiLineCommentTrivia */: + case 2 /* SyntaxKind.SingleLineCommentTrivia */: + return 1 /* ClassificationType.comment */; + case 5 /* SyntaxKind.WhitespaceTrivia */: + case 4 /* SyntaxKind.NewLineTrivia */: + return 8 /* ClassificationType.whiteSpace */; + case 79 /* SyntaxKind.Identifier */: + default: + if (ts.isTemplateLiteralKind(token)) { + return 6 /* ClassificationType.stringLiteral */; + } + return 2 /* ClassificationType.identifier */; + } + } + /* @internal */ + function getSemanticClassifications(typeChecker, cancellationToken, sourceFile, classifiableNames, span) { + return convertClassificationsToSpans(getEncodedSemanticClassifications(typeChecker, cancellationToken, sourceFile, classifiableNames, span)); + } + ts.getSemanticClassifications = getSemanticClassifications; + function checkForClassificationCancellation(cancellationToken, kind) { + // We don't want to actually call back into our host on every node to find out if we've + // been canceled. That would be an enormous amount of chattyness, along with the all + // the overhead of marshalling the data to/from the host. So instead we pick a few + // reasonable node kinds to bother checking on. These node kinds represent high level + // constructs that we would expect to see commonly, but just at a far less frequent + // interval. + // + // For example, in checker.ts (around 750k) we only have around 600 of these constructs. + // That means we're calling back into the host around every 1.2k of the file we process. + // Lib.d.ts has similar numbers. + switch (kind) { + case 264 /* SyntaxKind.ModuleDeclaration */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + cancellationToken.throwIfCancellationRequested(); + } + } + /* @internal */ + function getEncodedSemanticClassifications(typeChecker, cancellationToken, sourceFile, classifiableNames, span) { + var spans = []; + sourceFile.forEachChild(function cb(node) { + // Only walk into nodes that intersect the requested span. + if (!node || !ts.textSpanIntersectsWith(span, node.pos, node.getFullWidth())) { + return; + } + checkForClassificationCancellation(cancellationToken, node.kind); + // Only bother calling into the typechecker if this is an identifier that + // could possibly resolve to a type name. This makes classification run + // in a third of the time it would normally take. + if (ts.isIdentifier(node) && !ts.nodeIsMissing(node) && classifiableNames.has(node.escapedText)) { + var symbol = typeChecker.getSymbolAtLocation(node); + var type = symbol && classifySymbol(symbol, ts.getMeaningFromLocation(node), typeChecker); + if (type) { + pushClassification(node.getStart(sourceFile), node.getEnd(), type); + } + } + node.forEachChild(cb); + }); + return { spans: spans, endOfLineState: 0 /* EndOfLineState.None */ }; + function pushClassification(start, end, type) { + var length = end - start; + ts.Debug.assert(length > 0, "Classification had non-positive length of ".concat(length)); + spans.push(start); + spans.push(length); + spans.push(type); + } + } + ts.getEncodedSemanticClassifications = getEncodedSemanticClassifications; + function classifySymbol(symbol, meaningAtPosition, checker) { + var flags = symbol.getFlags(); + if ((flags & 2885600 /* SymbolFlags.Classifiable */) === 0 /* SymbolFlags.None */) { + return undefined; + } + else if (flags & 32 /* SymbolFlags.Class */) { + return 11 /* ClassificationType.className */; + } + else if (flags & 384 /* SymbolFlags.Enum */) { + return 12 /* ClassificationType.enumName */; + } + else if (flags & 524288 /* SymbolFlags.TypeAlias */) { + return 16 /* ClassificationType.typeAliasName */; + } + else if (flags & 1536 /* SymbolFlags.Module */) { + // Only classify a module as such if + // - It appears in a namespace context. + // - There exists a module declaration which actually impacts the value side. + return meaningAtPosition & 4 /* SemanticMeaning.Namespace */ || meaningAtPosition & 1 /* SemanticMeaning.Value */ && hasValueSideModule(symbol) ? 14 /* ClassificationType.moduleName */ : undefined; + } + else if (flags & 2097152 /* SymbolFlags.Alias */) { + return classifySymbol(checker.getAliasedSymbol(symbol), meaningAtPosition, checker); + } + else if (meaningAtPosition & 2 /* SemanticMeaning.Type */) { + return flags & 64 /* SymbolFlags.Interface */ ? 13 /* ClassificationType.interfaceName */ : flags & 262144 /* SymbolFlags.TypeParameter */ ? 15 /* ClassificationType.typeParameterName */ : undefined; + } + else { + return undefined; + } + } + /** Returns true if there exists a module that introduces entities on the value side. */ + function hasValueSideModule(symbol) { + return ts.some(symbol.declarations, function (declaration) { + return ts.isModuleDeclaration(declaration) && ts.getModuleInstanceState(declaration) === 1 /* ModuleInstanceState.Instantiated */; + }); + } + function getClassificationTypeName(type) { + switch (type) { + case 1 /* ClassificationType.comment */: return "comment" /* ClassificationTypeNames.comment */; + case 2 /* ClassificationType.identifier */: return "identifier" /* ClassificationTypeNames.identifier */; + case 3 /* ClassificationType.keyword */: return "keyword" /* ClassificationTypeNames.keyword */; + case 4 /* ClassificationType.numericLiteral */: return "number" /* ClassificationTypeNames.numericLiteral */; + case 25 /* ClassificationType.bigintLiteral */: return "bigint" /* ClassificationTypeNames.bigintLiteral */; + case 5 /* ClassificationType.operator */: return "operator" /* ClassificationTypeNames.operator */; + case 6 /* ClassificationType.stringLiteral */: return "string" /* ClassificationTypeNames.stringLiteral */; + case 8 /* ClassificationType.whiteSpace */: return "whitespace" /* ClassificationTypeNames.whiteSpace */; + case 9 /* ClassificationType.text */: return "text" /* ClassificationTypeNames.text */; + case 10 /* ClassificationType.punctuation */: return "punctuation" /* ClassificationTypeNames.punctuation */; + case 11 /* ClassificationType.className */: return "class name" /* ClassificationTypeNames.className */; + case 12 /* ClassificationType.enumName */: return "enum name" /* ClassificationTypeNames.enumName */; + case 13 /* ClassificationType.interfaceName */: return "interface name" /* ClassificationTypeNames.interfaceName */; + case 14 /* ClassificationType.moduleName */: return "module name" /* ClassificationTypeNames.moduleName */; + case 15 /* ClassificationType.typeParameterName */: return "type parameter name" /* ClassificationTypeNames.typeParameterName */; + case 16 /* ClassificationType.typeAliasName */: return "type alias name" /* ClassificationTypeNames.typeAliasName */; + case 17 /* ClassificationType.parameterName */: return "parameter name" /* ClassificationTypeNames.parameterName */; + case 18 /* ClassificationType.docCommentTagName */: return "doc comment tag name" /* ClassificationTypeNames.docCommentTagName */; + case 19 /* ClassificationType.jsxOpenTagName */: return "jsx open tag name" /* ClassificationTypeNames.jsxOpenTagName */; + case 20 /* ClassificationType.jsxCloseTagName */: return "jsx close tag name" /* ClassificationTypeNames.jsxCloseTagName */; + case 21 /* ClassificationType.jsxSelfClosingTagName */: return "jsx self closing tag name" /* ClassificationTypeNames.jsxSelfClosingTagName */; + case 22 /* ClassificationType.jsxAttribute */: return "jsx attribute" /* ClassificationTypeNames.jsxAttribute */; + case 23 /* ClassificationType.jsxText */: return "jsx text" /* ClassificationTypeNames.jsxText */; + case 24 /* ClassificationType.jsxAttributeStringLiteralValue */: return "jsx attribute string literal value" /* ClassificationTypeNames.jsxAttributeStringLiteralValue */; + default: return undefined; // TODO: GH#18217 throw Debug.assertNever(type); + } + } + function convertClassificationsToSpans(classifications) { + ts.Debug.assert(classifications.spans.length % 3 === 0); + var dense = classifications.spans; + var result = []; + for (var i = 0; i < dense.length; i += 3) { + result.push({ + textSpan: ts.createTextSpan(dense[i], dense[i + 1]), + classificationType: getClassificationTypeName(dense[i + 2]) + }); + } + return result; + } + /* @internal */ + function getSyntacticClassifications(cancellationToken, sourceFile, span) { + return convertClassificationsToSpans(getEncodedSyntacticClassifications(cancellationToken, sourceFile, span)); + } + ts.getSyntacticClassifications = getSyntacticClassifications; + /* @internal */ + function getEncodedSyntacticClassifications(cancellationToken, sourceFile, span) { + var spanStart = span.start; + var spanLength = span.length; + // Make a scanner we can get trivia from. + var triviaScanner = ts.createScanner(99 /* ScriptTarget.Latest */, /*skipTrivia*/ false, sourceFile.languageVariant, sourceFile.text); + var mergeConflictScanner = ts.createScanner(99 /* ScriptTarget.Latest */, /*skipTrivia*/ false, sourceFile.languageVariant, sourceFile.text); + var result = []; + processElement(sourceFile); + return { spans: result, endOfLineState: 0 /* EndOfLineState.None */ }; + function pushClassification(start, length, type) { + result.push(start); + result.push(length); + result.push(type); + } + function classifyLeadingTriviaAndGetTokenStart(token) { + triviaScanner.setTextPos(token.pos); + while (true) { + var start = triviaScanner.getTextPos(); + // only bother scanning if we have something that could be trivia. + if (!ts.couldStartTrivia(sourceFile.text, start)) { + return start; + } + var kind = triviaScanner.scan(); + var end = triviaScanner.getTextPos(); + var width = end - start; + // The moment we get something that isn't trivia, then stop processing. + if (!ts.isTrivia(kind)) { + return start; + } + switch (kind) { + case 4 /* SyntaxKind.NewLineTrivia */: + case 5 /* SyntaxKind.WhitespaceTrivia */: + // Don't bother with newlines/whitespace. + continue; + case 2 /* SyntaxKind.SingleLineCommentTrivia */: + case 3 /* SyntaxKind.MultiLineCommentTrivia */: + // Only bother with the trivia if it at least intersects the span of interest. + classifyComment(token, kind, start, width); + // Classifying a comment might cause us to reuse the trivia scanner + // (because of jsdoc comments). So after we classify the comment make + // sure we set the scanner position back to where it needs to be. + triviaScanner.setTextPos(end); + continue; + case 7 /* SyntaxKind.ConflictMarkerTrivia */: + var text = sourceFile.text; + var ch = text.charCodeAt(start); + // for the <<<<<<< and >>>>>>> markers, we just add them in as comments + // in the classification stream. + if (ch === 60 /* CharacterCodes.lessThan */ || ch === 62 /* CharacterCodes.greaterThan */) { + pushClassification(start, width, 1 /* ClassificationType.comment */); + continue; + } + // for the ||||||| and ======== markers, add a comment for the first line, + // and then lex all subsequent lines up until the end of the conflict marker. + ts.Debug.assert(ch === 124 /* CharacterCodes.bar */ || ch === 61 /* CharacterCodes.equals */); + classifyDisabledMergeCode(text, start, end); + break; + case 6 /* SyntaxKind.ShebangTrivia */: + // TODO: Maybe we should classify these. + break; + default: + ts.Debug.assertNever(kind); + } + } + } + function classifyComment(token, kind, start, width) { + if (kind === 3 /* SyntaxKind.MultiLineCommentTrivia */) { + // See if this is a doc comment. If so, we'll classify certain portions of it + // specially. + var docCommentAndDiagnostics = ts.parseIsolatedJSDocComment(sourceFile.text, start, width); + if (docCommentAndDiagnostics && docCommentAndDiagnostics.jsDoc) { + // TODO: This should be predicated on `token["kind"]` being compatible with `HasJSDoc["kind"]` + ts.setParent(docCommentAndDiagnostics.jsDoc, token); + classifyJSDocComment(docCommentAndDiagnostics.jsDoc); + return; + } + } + else if (kind === 2 /* SyntaxKind.SingleLineCommentTrivia */) { + if (tryClassifyTripleSlashComment(start, width)) { + return; + } + } + // Simple comment. Just add as is. + pushCommentRange(start, width); + } + function pushCommentRange(start, width) { + pushClassification(start, width, 1 /* ClassificationType.comment */); + } + function classifyJSDocComment(docComment) { + var _a, _b, _c, _d, _e, _f, _g; + var pos = docComment.pos; + if (docComment.tags) { + for (var _i = 0, _h = docComment.tags; _i < _h.length; _i++) { + var tag = _h[_i]; + // As we walk through each tag, classify the portion of text from the end of + // the last tag (or the start of the entire doc comment) as 'comment'. + if (tag.pos !== pos) { + pushCommentRange(pos, tag.pos - pos); + } + pushClassification(tag.pos, 1, 10 /* ClassificationType.punctuation */); // "@" + pushClassification(tag.tagName.pos, tag.tagName.end - tag.tagName.pos, 18 /* ClassificationType.docCommentTagName */); // e.g. "param" + pos = tag.tagName.end; + var commentStart = tag.tagName.end; + switch (tag.kind) { + case 343 /* SyntaxKind.JSDocParameterTag */: + var param = tag; + processJSDocParameterTag(param); + commentStart = param.isNameFirst && ((_a = param.typeExpression) === null || _a === void 0 ? void 0 : _a.end) || param.name.end; + break; + case 350 /* SyntaxKind.JSDocPropertyTag */: + var prop = tag; + commentStart = prop.isNameFirst && ((_b = prop.typeExpression) === null || _b === void 0 ? void 0 : _b.end) || prop.name.end; + break; + case 347 /* SyntaxKind.JSDocTemplateTag */: + processJSDocTemplateTag(tag); + pos = tag.end; + commentStart = tag.typeParameters.end; + break; + case 348 /* SyntaxKind.JSDocTypedefTag */: + var type = tag; + commentStart = ((_c = type.typeExpression) === null || _c === void 0 ? void 0 : _c.kind) === 312 /* SyntaxKind.JSDocTypeExpression */ && ((_d = type.fullName) === null || _d === void 0 ? void 0 : _d.end) || ((_e = type.typeExpression) === null || _e === void 0 ? void 0 : _e.end) || commentStart; + break; + case 341 /* SyntaxKind.JSDocCallbackTag */: + commentStart = tag.typeExpression.end; + break; + case 346 /* SyntaxKind.JSDocTypeTag */: + processElement(tag.typeExpression); + pos = tag.end; + commentStart = tag.typeExpression.end; + break; + case 345 /* SyntaxKind.JSDocThisTag */: + case 342 /* SyntaxKind.JSDocEnumTag */: + commentStart = tag.typeExpression.end; + break; + case 344 /* SyntaxKind.JSDocReturnTag */: + processElement(tag.typeExpression); + pos = tag.end; + commentStart = ((_f = tag.typeExpression) === null || _f === void 0 ? void 0 : _f.end) || commentStart; + break; + case 349 /* SyntaxKind.JSDocSeeTag */: + commentStart = ((_g = tag.name) === null || _g === void 0 ? void 0 : _g.end) || commentStart; + break; + case 331 /* SyntaxKind.JSDocAugmentsTag */: + case 332 /* SyntaxKind.JSDocImplementsTag */: + commentStart = tag.class.end; + break; + } + if (typeof tag.comment === "object") { + pushCommentRange(tag.comment.pos, tag.comment.end - tag.comment.pos); + } + else if (typeof tag.comment === "string") { + pushCommentRange(commentStart, tag.end - commentStart); + } + } + } + if (pos !== docComment.end) { + pushCommentRange(pos, docComment.end - pos); + } + return; + function processJSDocParameterTag(tag) { + if (tag.isNameFirst) { + pushCommentRange(pos, tag.name.pos - pos); + pushClassification(tag.name.pos, tag.name.end - tag.name.pos, 17 /* ClassificationType.parameterName */); + pos = tag.name.end; + } + if (tag.typeExpression) { + pushCommentRange(pos, tag.typeExpression.pos - pos); + processElement(tag.typeExpression); + pos = tag.typeExpression.end; + } + if (!tag.isNameFirst) { + pushCommentRange(pos, tag.name.pos - pos); + pushClassification(tag.name.pos, tag.name.end - tag.name.pos, 17 /* ClassificationType.parameterName */); + pos = tag.name.end; + } + } + } + function tryClassifyTripleSlashComment(start, width) { + var tripleSlashXMLCommentRegEx = /^(\/\/\/\s*)(<)(?:(\S+)((?:[^/]|\/[^>])*)(\/>)?)?/im; + // Require a leading whitespace character (the parser already does) to prevent terrible backtracking performance + var attributeRegex = /(\s)(\S+)(\s*)(=)(\s*)('[^']+'|"[^"]+")/img; + var text = sourceFile.text.substr(start, width); + var match = tripleSlashXMLCommentRegEx.exec(text); + if (!match) { + return false; + } + // Limiting classification to exactly the elements and attributes + // defined in `ts.commentPragmas` would be excessive, but we can avoid + // some obvious false positives (e.g. in XML-like doc comments) by + // checking the element name. + // eslint-disable-next-line local/no-in-operator + if (!match[3] || !(match[3] in ts.commentPragmas)) { + return false; + } + var pos = start; + pushCommentRange(pos, match[1].length); // /// + pos += match[1].length; + pushClassification(pos, match[2].length, 10 /* ClassificationType.punctuation */); // < + pos += match[2].length; + pushClassification(pos, match[3].length, 21 /* ClassificationType.jsxSelfClosingTagName */); // element name + pos += match[3].length; + var attrText = match[4]; + var attrPos = pos; + while (true) { + var attrMatch = attributeRegex.exec(attrText); + if (!attrMatch) { + break; + } + var newAttrPos = pos + attrMatch.index + attrMatch[1].length; // whitespace + if (newAttrPos > attrPos) { + pushCommentRange(attrPos, newAttrPos - attrPos); + attrPos = newAttrPos; + } + pushClassification(attrPos, attrMatch[2].length, 22 /* ClassificationType.jsxAttribute */); // attribute name + attrPos += attrMatch[2].length; + if (attrMatch[3].length) { + pushCommentRange(attrPos, attrMatch[3].length); // whitespace + attrPos += attrMatch[3].length; + } + pushClassification(attrPos, attrMatch[4].length, 5 /* ClassificationType.operator */); // = + attrPos += attrMatch[4].length; + if (attrMatch[5].length) { + pushCommentRange(attrPos, attrMatch[5].length); // whitespace + attrPos += attrMatch[5].length; + } + pushClassification(attrPos, attrMatch[6].length, 24 /* ClassificationType.jsxAttributeStringLiteralValue */); // attribute value + attrPos += attrMatch[6].length; + } + pos += match[4].length; + if (pos > attrPos) { + pushCommentRange(attrPos, pos - attrPos); + } + if (match[5]) { + pushClassification(pos, match[5].length, 10 /* ClassificationType.punctuation */); // /> + pos += match[5].length; + } + var end = start + width; + if (pos < end) { + pushCommentRange(pos, end - pos); + } + return true; + } + function processJSDocTemplateTag(tag) { + for (var _i = 0, _a = tag.getChildren(); _i < _a.length; _i++) { + var child = _a[_i]; + processElement(child); + } + } + function classifyDisabledMergeCode(text, start, end) { + // Classify the line that the ||||||| or ======= marker is on as a comment. + // Then just lex all further tokens and add them to the result. + var i; + for (i = start; i < end; i++) { + if (ts.isLineBreak(text.charCodeAt(i))) { + break; + } + } + pushClassification(start, i - start, 1 /* ClassificationType.comment */); + mergeConflictScanner.setTextPos(i); + while (mergeConflictScanner.getTextPos() < end) { + classifyDisabledCodeToken(); + } + } + function classifyDisabledCodeToken() { + var start = mergeConflictScanner.getTextPos(); + var tokenKind = mergeConflictScanner.scan(); + var end = mergeConflictScanner.getTextPos(); + var type = classifyTokenType(tokenKind); + if (type) { + pushClassification(start, end - start, type); + } + } + /** + * Returns true if node should be treated as classified and no further processing is required. + * False will mean that node is not classified and traverse routine should recurse into node contents. + */ + function tryClassifyNode(node) { + if (ts.isJSDoc(node)) { + return true; + } + if (ts.nodeIsMissing(node)) { + return true; + } + var classifiedElementName = tryClassifyJsxElementName(node); + if (!ts.isToken(node) && node.kind !== 11 /* SyntaxKind.JsxText */ && classifiedElementName === undefined) { + return false; + } + var tokenStart = node.kind === 11 /* SyntaxKind.JsxText */ ? node.pos : classifyLeadingTriviaAndGetTokenStart(node); + var tokenWidth = node.end - tokenStart; + ts.Debug.assert(tokenWidth >= 0); + if (tokenWidth > 0) { + var type = classifiedElementName || classifyTokenType(node.kind, node); + if (type) { + pushClassification(tokenStart, tokenWidth, type); + } + } + return true; + } + function tryClassifyJsxElementName(token) { + switch (token.parent && token.parent.kind) { + case 283 /* SyntaxKind.JsxOpeningElement */: + if (token.parent.tagName === token) { + return 19 /* ClassificationType.jsxOpenTagName */; + } + break; + case 284 /* SyntaxKind.JsxClosingElement */: + if (token.parent.tagName === token) { + return 20 /* ClassificationType.jsxCloseTagName */; + } + break; + case 282 /* SyntaxKind.JsxSelfClosingElement */: + if (token.parent.tagName === token) { + return 21 /* ClassificationType.jsxSelfClosingTagName */; + } + break; + case 288 /* SyntaxKind.JsxAttribute */: + if (token.parent.name === token) { + return 22 /* ClassificationType.jsxAttribute */; + } + break; + } + return undefined; + } + // for accurate classification, the actual token should be passed in. however, for + // cases like 'disabled merge code' classification, we just get the token kind and + // classify based on that instead. + function classifyTokenType(tokenKind, token) { + if (ts.isKeyword(tokenKind)) { + return 3 /* ClassificationType.keyword */; + } + // Special case `<` and `>`: If they appear in a generic context they are punctuation, + // not operators. + if (tokenKind === 29 /* SyntaxKind.LessThanToken */ || tokenKind === 31 /* SyntaxKind.GreaterThanToken */) { + // If the node owning the token has a type argument list or type parameter list, then + // we can effectively assume that a '<' and '>' belong to those lists. + if (token && ts.getTypeArgumentOrTypeParameterList(token.parent)) { + return 10 /* ClassificationType.punctuation */; + } + } + if (ts.isPunctuation(tokenKind)) { + if (token) { + var parent = token.parent; + if (tokenKind === 63 /* SyntaxKind.EqualsToken */) { + // the '=' in a variable declaration is special cased here. + if (parent.kind === 257 /* SyntaxKind.VariableDeclaration */ || + parent.kind === 169 /* SyntaxKind.PropertyDeclaration */ || + parent.kind === 166 /* SyntaxKind.Parameter */ || + parent.kind === 288 /* SyntaxKind.JsxAttribute */) { + return 5 /* ClassificationType.operator */; + } + } + if (parent.kind === 223 /* SyntaxKind.BinaryExpression */ || + parent.kind === 221 /* SyntaxKind.PrefixUnaryExpression */ || + parent.kind === 222 /* SyntaxKind.PostfixUnaryExpression */ || + parent.kind === 224 /* SyntaxKind.ConditionalExpression */) { + return 5 /* ClassificationType.operator */; + } + } + return 10 /* ClassificationType.punctuation */; + } + else if (tokenKind === 8 /* SyntaxKind.NumericLiteral */) { + return 4 /* ClassificationType.numericLiteral */; + } + else if (tokenKind === 9 /* SyntaxKind.BigIntLiteral */) { + return 25 /* ClassificationType.bigintLiteral */; + } + else if (tokenKind === 10 /* SyntaxKind.StringLiteral */) { + return token && token.parent.kind === 288 /* SyntaxKind.JsxAttribute */ ? 24 /* ClassificationType.jsxAttributeStringLiteralValue */ : 6 /* ClassificationType.stringLiteral */; + } + else if (tokenKind === 13 /* SyntaxKind.RegularExpressionLiteral */) { + // TODO: we should get another classification type for these literals. + return 6 /* ClassificationType.stringLiteral */; + } + else if (ts.isTemplateLiteralKind(tokenKind)) { + // TODO (drosen): we should *also* get another classification type for these literals. + return 6 /* ClassificationType.stringLiteral */; + } + else if (tokenKind === 11 /* SyntaxKind.JsxText */) { + return 23 /* ClassificationType.jsxText */; + } + else if (tokenKind === 79 /* SyntaxKind.Identifier */) { + if (token) { + switch (token.parent.kind) { + case 260 /* SyntaxKind.ClassDeclaration */: + if (token.parent.name === token) { + return 11 /* ClassificationType.className */; + } + return; + case 165 /* SyntaxKind.TypeParameter */: + if (token.parent.name === token) { + return 15 /* ClassificationType.typeParameterName */; + } + return; + case 261 /* SyntaxKind.InterfaceDeclaration */: + if (token.parent.name === token) { + return 13 /* ClassificationType.interfaceName */; + } + return; + case 263 /* SyntaxKind.EnumDeclaration */: + if (token.parent.name === token) { + return 12 /* ClassificationType.enumName */; + } + return; + case 264 /* SyntaxKind.ModuleDeclaration */: + if (token.parent.name === token) { + return 14 /* ClassificationType.moduleName */; + } + return; + case 166 /* SyntaxKind.Parameter */: + if (token.parent.name === token) { + return ts.isThisIdentifier(token) ? 3 /* ClassificationType.keyword */ : 17 /* ClassificationType.parameterName */; + } + return; + } + if (ts.isConstTypeReference(token.parent)) { + return 3 /* ClassificationType.keyword */; + } + } + return 2 /* ClassificationType.identifier */; + } + } + function processElement(element) { + if (!element) { + return; + } + // Ignore nodes that don't intersect the original span to classify. + if (ts.decodedTextSpanIntersectsWith(spanStart, spanLength, element.pos, element.getFullWidth())) { + checkForClassificationCancellation(cancellationToken, element.kind); + for (var _i = 0, _a = element.getChildren(sourceFile); _i < _a.length; _i++) { + var child = _a[_i]; + if (!tryClassifyNode(child)) { + // Recurse into our child nodes. + processElement(child); + } + } + } + } + } + ts.getEncodedSyntacticClassifications = getEncodedSyntacticClassifications; +})(ts || (ts = {})); +/** @internal */ +var ts; +(function (ts) { + var classifier; + (function (classifier) { + var v2020; + (function (v2020) { + var TokenEncodingConsts; + (function (TokenEncodingConsts) { + TokenEncodingConsts[TokenEncodingConsts["typeOffset"] = 8] = "typeOffset"; + TokenEncodingConsts[TokenEncodingConsts["modifierMask"] = 255] = "modifierMask"; + })(TokenEncodingConsts = v2020.TokenEncodingConsts || (v2020.TokenEncodingConsts = {})); + var TokenType; + (function (TokenType) { + TokenType[TokenType["class"] = 0] = "class"; + TokenType[TokenType["enum"] = 1] = "enum"; + TokenType[TokenType["interface"] = 2] = "interface"; + TokenType[TokenType["namespace"] = 3] = "namespace"; + TokenType[TokenType["typeParameter"] = 4] = "typeParameter"; + TokenType[TokenType["type"] = 5] = "type"; + TokenType[TokenType["parameter"] = 6] = "parameter"; + TokenType[TokenType["variable"] = 7] = "variable"; + TokenType[TokenType["enumMember"] = 8] = "enumMember"; + TokenType[TokenType["property"] = 9] = "property"; + TokenType[TokenType["function"] = 10] = "function"; + TokenType[TokenType["member"] = 11] = "member"; + })(TokenType = v2020.TokenType || (v2020.TokenType = {})); + var TokenModifier; + (function (TokenModifier) { + TokenModifier[TokenModifier["declaration"] = 0] = "declaration"; + TokenModifier[TokenModifier["static"] = 1] = "static"; + TokenModifier[TokenModifier["async"] = 2] = "async"; + TokenModifier[TokenModifier["readonly"] = 3] = "readonly"; + TokenModifier[TokenModifier["defaultLibrary"] = 4] = "defaultLibrary"; + TokenModifier[TokenModifier["local"] = 5] = "local"; + })(TokenModifier = v2020.TokenModifier || (v2020.TokenModifier = {})); + /** This is mainly used internally for testing */ + function getSemanticClassifications(program, cancellationToken, sourceFile, span) { + var classifications = getEncodedSemanticClassifications(program, cancellationToken, sourceFile, span); + ts.Debug.assert(classifications.spans.length % 3 === 0); + var dense = classifications.spans; + var result = []; + for (var i = 0; i < dense.length; i += 3) { + result.push({ + textSpan: ts.createTextSpan(dense[i], dense[i + 1]), + classificationType: dense[i + 2] + }); + } + return result; + } + v2020.getSemanticClassifications = getSemanticClassifications; + function getEncodedSemanticClassifications(program, cancellationToken, sourceFile, span) { + return { + spans: getSemanticTokens(program, sourceFile, span, cancellationToken), + endOfLineState: 0 /* EndOfLineState.None */ + }; + } + v2020.getEncodedSemanticClassifications = getEncodedSemanticClassifications; + function getSemanticTokens(program, sourceFile, span, cancellationToken) { + var resultTokens = []; + var collector = function (node, typeIdx, modifierSet) { + resultTokens.push(node.getStart(sourceFile), node.getWidth(sourceFile), ((typeIdx + 1) << 8 /* TokenEncodingConsts.typeOffset */) + modifierSet); + }; + if (program && sourceFile) { + collectTokens(program, sourceFile, span, collector, cancellationToken); + } + return resultTokens; + } + function collectTokens(program, sourceFile, span, collector, cancellationToken) { + var typeChecker = program.getTypeChecker(); + var inJSXElement = false; + function visit(node) { + switch (node.kind) { + case 264 /* SyntaxKind.ModuleDeclaration */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + cancellationToken.throwIfCancellationRequested(); + } + if (!node || !ts.textSpanIntersectsWith(span, node.pos, node.getFullWidth()) || node.getFullWidth() === 0) { + return; + } + var prevInJSXElement = inJSXElement; + if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node)) { + inJSXElement = true; + } + if (ts.isJsxExpression(node)) { + inJSXElement = false; + } + if (ts.isIdentifier(node) && !inJSXElement && !inImportClause(node) && !ts.isInfinityOrNaNString(node.escapedText)) { + var symbol = typeChecker.getSymbolAtLocation(node); + if (symbol) { + if (symbol.flags & 2097152 /* SymbolFlags.Alias */) { + symbol = typeChecker.getAliasedSymbol(symbol); + } + var typeIdx = classifySymbol(symbol, ts.getMeaningFromLocation(node)); + if (typeIdx !== undefined) { + var modifierSet = 0; + if (node.parent) { + var parentIsDeclaration = (ts.isBindingElement(node.parent) || tokenFromDeclarationMapping.get(node.parent.kind) === typeIdx); + if (parentIsDeclaration && node.parent.name === node) { + modifierSet = 1 << 0 /* TokenModifier.declaration */; + } + } + // property declaration in constructor + if (typeIdx === 6 /* TokenType.parameter */ && isRightSideOfQualifiedNameOrPropertyAccess(node)) { + typeIdx = 9 /* TokenType.property */; + } + typeIdx = reclassifyByType(typeChecker, node, typeIdx); + var decl = symbol.valueDeclaration; + if (decl) { + var modifiers = ts.getCombinedModifierFlags(decl); + var nodeFlags = ts.getCombinedNodeFlags(decl); + if (modifiers & 32 /* ModifierFlags.Static */) { + modifierSet |= 1 << 1 /* TokenModifier.static */; + } + if (modifiers & 512 /* ModifierFlags.Async */) { + modifierSet |= 1 << 2 /* TokenModifier.async */; + } + if (typeIdx !== 0 /* TokenType.class */ && typeIdx !== 2 /* TokenType.interface */) { + if ((modifiers & 64 /* ModifierFlags.Readonly */) || (nodeFlags & 2 /* NodeFlags.Const */) || (symbol.getFlags() & 8 /* SymbolFlags.EnumMember */)) { + modifierSet |= 1 << 3 /* TokenModifier.readonly */; + } + } + if ((typeIdx === 7 /* TokenType.variable */ || typeIdx === 10 /* TokenType.function */) && isLocalDeclaration(decl, sourceFile)) { + modifierSet |= 1 << 5 /* TokenModifier.local */; + } + if (program.isSourceFileDefaultLibrary(decl.getSourceFile())) { + modifierSet |= 1 << 4 /* TokenModifier.defaultLibrary */; + } + } + else if (symbol.declarations && symbol.declarations.some(function (d) { return program.isSourceFileDefaultLibrary(d.getSourceFile()); })) { + modifierSet |= 1 << 4 /* TokenModifier.defaultLibrary */; + } + collector(node, typeIdx, modifierSet); + } + } + } + ts.forEachChild(node, visit); + inJSXElement = prevInJSXElement; + } + visit(sourceFile); + } + function classifySymbol(symbol, meaning) { + var flags = symbol.getFlags(); + if (flags & 32 /* SymbolFlags.Class */) { + return 0 /* TokenType.class */; + } + else if (flags & 384 /* SymbolFlags.Enum */) { + return 1 /* TokenType.enum */; + } + else if (flags & 524288 /* SymbolFlags.TypeAlias */) { + return 5 /* TokenType.type */; + } + else if (flags & 64 /* SymbolFlags.Interface */) { + if (meaning & 2 /* SemanticMeaning.Type */) { + return 2 /* TokenType.interface */; + } + } + else if (flags & 262144 /* SymbolFlags.TypeParameter */) { + return 4 /* TokenType.typeParameter */; + } + var decl = symbol.valueDeclaration || symbol.declarations && symbol.declarations[0]; + if (decl && ts.isBindingElement(decl)) { + decl = getDeclarationForBindingElement(decl); + } + return decl && tokenFromDeclarationMapping.get(decl.kind); + } + function reclassifyByType(typeChecker, node, typeIdx) { + // type based classifications + if (typeIdx === 7 /* TokenType.variable */ || typeIdx === 9 /* TokenType.property */ || typeIdx === 6 /* TokenType.parameter */) { + var type_1 = typeChecker.getTypeAtLocation(node); + if (type_1) { + var test = function (condition) { + return condition(type_1) || type_1.isUnion() && type_1.types.some(condition); + }; + if (typeIdx !== 6 /* TokenType.parameter */ && test(function (t) { return t.getConstructSignatures().length > 0; })) { + return 0 /* TokenType.class */; + } + if (test(function (t) { return t.getCallSignatures().length > 0; }) && !test(function (t) { return t.getProperties().length > 0; }) || isExpressionInCallExpression(node)) { + return typeIdx === 9 /* TokenType.property */ ? 11 /* TokenType.member */ : 10 /* TokenType.function */; + } + } + } + return typeIdx; + } + function isLocalDeclaration(decl, sourceFile) { + if (ts.isBindingElement(decl)) { + decl = getDeclarationForBindingElement(decl); + } + if (ts.isVariableDeclaration(decl)) { + return (!ts.isSourceFile(decl.parent.parent.parent) || ts.isCatchClause(decl.parent)) && decl.getSourceFile() === sourceFile; + } + else if (ts.isFunctionDeclaration(decl)) { + return !ts.isSourceFile(decl.parent) && decl.getSourceFile() === sourceFile; + } + return false; + } + function getDeclarationForBindingElement(element) { + while (true) { + if (ts.isBindingElement(element.parent.parent)) { + element = element.parent.parent; + } + else { + return element.parent.parent; + } + } + } + function inImportClause(node) { + var parent = node.parent; + return parent && (ts.isImportClause(parent) || ts.isImportSpecifier(parent) || ts.isNamespaceImport(parent)); + } + function isExpressionInCallExpression(node) { + while (isRightSideOfQualifiedNameOrPropertyAccess(node)) { + node = node.parent; + } + return ts.isCallExpression(node.parent) && node.parent.expression === node; + } + function isRightSideOfQualifiedNameOrPropertyAccess(node) { + return (ts.isQualifiedName(node.parent) && node.parent.right === node) || (ts.isPropertyAccessExpression(node.parent) && node.parent.name === node); + } + var tokenFromDeclarationMapping = new ts.Map([ + [257 /* SyntaxKind.VariableDeclaration */, 7 /* TokenType.variable */], + [166 /* SyntaxKind.Parameter */, 6 /* TokenType.parameter */], + [169 /* SyntaxKind.PropertyDeclaration */, 9 /* TokenType.property */], + [264 /* SyntaxKind.ModuleDeclaration */, 3 /* TokenType.namespace */], + [263 /* SyntaxKind.EnumDeclaration */, 1 /* TokenType.enum */], + [302 /* SyntaxKind.EnumMember */, 8 /* TokenType.enumMember */], + [260 /* SyntaxKind.ClassDeclaration */, 0 /* TokenType.class */], + [171 /* SyntaxKind.MethodDeclaration */, 11 /* TokenType.member */], + [259 /* SyntaxKind.FunctionDeclaration */, 10 /* TokenType.function */], + [215 /* SyntaxKind.FunctionExpression */, 10 /* TokenType.function */], + [170 /* SyntaxKind.MethodSignature */, 11 /* TokenType.member */], + [174 /* SyntaxKind.GetAccessor */, 9 /* TokenType.property */], + [175 /* SyntaxKind.SetAccessor */, 9 /* TokenType.property */], + [168 /* SyntaxKind.PropertySignature */, 9 /* TokenType.property */], + [261 /* SyntaxKind.InterfaceDeclaration */, 2 /* TokenType.interface */], + [262 /* SyntaxKind.TypeAliasDeclaration */, 5 /* TokenType.type */], + [165 /* SyntaxKind.TypeParameter */, 4 /* TokenType.typeParameter */], + [299 /* SyntaxKind.PropertyAssignment */, 9 /* TokenType.property */], + [300 /* SyntaxKind.ShorthandPropertyAssignment */, 9 /* TokenType.property */] + ]); + })(v2020 = classifier.v2020 || (classifier.v2020 = {})); + })(classifier = ts.classifier || (ts.classifier = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var Completions; + (function (Completions) { + var StringCompletions; + (function (StringCompletions) { + var _a; + var kindPrecedence = (_a = {}, + _a["directory" /* ScriptElementKind.directory */] = 0, + _a["script" /* ScriptElementKind.scriptElement */] = 1, + _a["external module name" /* ScriptElementKind.externalModuleName */] = 2, + _a); + function createNameAndKindSet() { + var map = new ts.Map(); + function add(value) { + var existing = map.get(value.name); + if (!existing || kindPrecedence[existing.kind] < kindPrecedence[value.kind]) { + map.set(value.name, value); + } + } + return { + add: add, + has: map.has.bind(map), + values: map.values.bind(map), + }; + } + function getStringLiteralCompletions(sourceFile, position, contextToken, options, host, program, log, preferences) { + if (ts.isInReferenceComment(sourceFile, position)) { + var entries = getTripleSlashReferenceCompletion(sourceFile, position, options, host); + return entries && convertPathCompletions(entries); + } + if (ts.isInString(sourceFile, position, contextToken)) { + if (!contextToken || !ts.isStringLiteralLike(contextToken)) + return undefined; + var entries = getStringLiteralCompletionEntries(sourceFile, contextToken, position, program.getTypeChecker(), options, host, preferences); + return convertStringLiteralCompletions(entries, contextToken, sourceFile, host, program, log, options, preferences); + } + } + StringCompletions.getStringLiteralCompletions = getStringLiteralCompletions; + function convertStringLiteralCompletions(completion, contextToken, sourceFile, host, program, log, options, preferences) { + if (completion === undefined) { + return undefined; + } + var optionalReplacementSpan = ts.createTextSpanFromStringLiteralLikeContent(contextToken); + switch (completion.kind) { + case 0 /* StringLiteralCompletionKind.Paths */: + return convertPathCompletions(completion.paths); + case 1 /* StringLiteralCompletionKind.Properties */: { + var entries = ts.createSortedArray(); + Completions.getCompletionEntriesFromSymbols(completion.symbols, entries, contextToken, contextToken, sourceFile, sourceFile, host, program, 99 /* ScriptTarget.ESNext */, log, 4 /* CompletionKind.String */, preferences, options, + /*formatContext*/ undefined); // Target will not be used, so arbitrary + return { isGlobalCompletion: false, isMemberCompletion: true, isNewIdentifierLocation: completion.hasIndexSignature, optionalReplacementSpan: optionalReplacementSpan, entries: entries }; + } + case 2 /* StringLiteralCompletionKind.Types */: { + var entries = completion.types.map(function (type) { return ({ + name: type.value, + kindModifiers: "" /* ScriptElementKindModifier.none */, + kind: "string" /* ScriptElementKind.string */, + sortText: Completions.SortText.LocationPriority, + replacementSpan: ts.getReplacementSpanForContextToken(contextToken) + }); }); + return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: completion.isNewIdentifier, optionalReplacementSpan: optionalReplacementSpan, entries: entries }; + } + default: + return ts.Debug.assertNever(completion); + } + } + function getStringLiteralCompletionDetails(name, sourceFile, position, contextToken, checker, options, host, cancellationToken, preferences) { + if (!contextToken || !ts.isStringLiteralLike(contextToken)) + return undefined; + var completions = getStringLiteralCompletionEntries(sourceFile, contextToken, position, checker, options, host, preferences); + return completions && stringLiteralCompletionDetails(name, contextToken, completions, sourceFile, checker, cancellationToken); + } + StringCompletions.getStringLiteralCompletionDetails = getStringLiteralCompletionDetails; + function stringLiteralCompletionDetails(name, location, completion, sourceFile, checker, cancellationToken) { + switch (completion.kind) { + case 0 /* StringLiteralCompletionKind.Paths */: { + var match = ts.find(completion.paths, function (p) { return p.name === name; }); + return match && Completions.createCompletionDetails(name, kindModifiersFromExtension(match.extension), match.kind, [ts.textPart(name)]); + } + case 1 /* StringLiteralCompletionKind.Properties */: { + var match = ts.find(completion.symbols, function (s) { return s.name === name; }); + return match && Completions.createCompletionDetailsForSymbol(match, checker, sourceFile, location, cancellationToken); + } + case 2 /* StringLiteralCompletionKind.Types */: + return ts.find(completion.types, function (t) { return t.value === name; }) ? Completions.createCompletionDetails(name, "" /* ScriptElementKindModifier.none */, "type" /* ScriptElementKind.typeElement */, [ts.textPart(name)]) : undefined; + default: + return ts.Debug.assertNever(completion); + } + } + function convertPathCompletions(pathCompletions) { + var isGlobalCompletion = false; // We don't want the editor to offer any other completions, such as snippets, inside a comment. + var isNewIdentifierLocation = true; // The user may type in a path that doesn't yet exist, creating a "new identifier" with respect to the collection of identifiers the server is aware of. + var entries = pathCompletions.map(function (_a) { + var name = _a.name, kind = _a.kind, span = _a.span, extension = _a.extension; + return ({ name: name, kind: kind, kindModifiers: kindModifiersFromExtension(extension), sortText: Completions.SortText.LocationPriority, replacementSpan: span }); + }); + return { isGlobalCompletion: isGlobalCompletion, isMemberCompletion: false, isNewIdentifierLocation: isNewIdentifierLocation, entries: entries }; + } + function kindModifiersFromExtension(extension) { + switch (extension) { + case ".d.ts" /* Extension.Dts */: return ".d.ts" /* ScriptElementKindModifier.dtsModifier */; + case ".js" /* Extension.Js */: return ".js" /* ScriptElementKindModifier.jsModifier */; + case ".json" /* Extension.Json */: return ".json" /* ScriptElementKindModifier.jsonModifier */; + case ".jsx" /* Extension.Jsx */: return ".jsx" /* ScriptElementKindModifier.jsxModifier */; + case ".ts" /* Extension.Ts */: return ".ts" /* ScriptElementKindModifier.tsModifier */; + case ".tsx" /* Extension.Tsx */: return ".tsx" /* ScriptElementKindModifier.tsxModifier */; + case ".d.mts" /* Extension.Dmts */: return ".d.mts" /* ScriptElementKindModifier.dmtsModifier */; + case ".mjs" /* Extension.Mjs */: return ".mjs" /* ScriptElementKindModifier.mjsModifier */; + case ".mts" /* Extension.Mts */: return ".mts" /* ScriptElementKindModifier.mtsModifier */; + case ".d.cts" /* Extension.Dcts */: return ".d.cts" /* ScriptElementKindModifier.dctsModifier */; + case ".cjs" /* Extension.Cjs */: return ".cjs" /* ScriptElementKindModifier.cjsModifier */; + case ".cts" /* Extension.Cts */: return ".cts" /* ScriptElementKindModifier.ctsModifier */; + case ".tsbuildinfo" /* Extension.TsBuildInfo */: return ts.Debug.fail("Extension ".concat(".tsbuildinfo" /* Extension.TsBuildInfo */, " is unsupported.")); + case undefined: return "" /* ScriptElementKindModifier.none */; + default: + return ts.Debug.assertNever(extension); + } + } + var StringLiteralCompletionKind; + (function (StringLiteralCompletionKind) { + StringLiteralCompletionKind[StringLiteralCompletionKind["Paths"] = 0] = "Paths"; + StringLiteralCompletionKind[StringLiteralCompletionKind["Properties"] = 1] = "Properties"; + StringLiteralCompletionKind[StringLiteralCompletionKind["Types"] = 2] = "Types"; + })(StringLiteralCompletionKind || (StringLiteralCompletionKind = {})); + function getStringLiteralCompletionEntries(sourceFile, node, position, typeChecker, compilerOptions, host, preferences) { + var parent = walkUpParentheses(node.parent); + switch (parent.kind) { + case 198 /* SyntaxKind.LiteralType */: { + var grandParent_1 = walkUpParentheses(parent.parent); + switch (grandParent_1.kind) { + case 230 /* SyntaxKind.ExpressionWithTypeArguments */: + case 180 /* SyntaxKind.TypeReference */: { + var typeArgument = ts.findAncestor(parent, function (n) { return n.parent === grandParent_1; }); + if (typeArgument) { + return { kind: 2 /* StringLiteralCompletionKind.Types */, types: getStringLiteralTypes(typeChecker.getTypeArgumentConstraint(typeArgument)), isNewIdentifier: false }; + } + return undefined; + } + case 196 /* SyntaxKind.IndexedAccessType */: + // Get all apparent property names + // i.e. interface Foo { + // foo: string; + // bar: string; + // } + // let x: Foo["/*completion position*/"] + var _a = grandParent_1, indexType = _a.indexType, objectType = _a.objectType; + if (!ts.rangeContainsPosition(indexType, position)) { + return undefined; + } + return stringLiteralCompletionsFromProperties(typeChecker.getTypeFromTypeNode(objectType)); + case 202 /* SyntaxKind.ImportType */: + return { kind: 0 /* StringLiteralCompletionKind.Paths */, paths: getStringLiteralCompletionsFromModuleNames(sourceFile, node, compilerOptions, host, typeChecker, preferences) }; + case 189 /* SyntaxKind.UnionType */: { + if (!ts.isTypeReferenceNode(grandParent_1.parent)) { + return undefined; + } + var alreadyUsedTypes_1 = getAlreadyUsedTypesInStringLiteralUnion(grandParent_1, parent); + var types = getStringLiteralTypes(typeChecker.getTypeArgumentConstraint(grandParent_1)).filter(function (t) { return !ts.contains(alreadyUsedTypes_1, t.value); }); + return { kind: 2 /* StringLiteralCompletionKind.Types */, types: types, isNewIdentifier: false }; + } + default: + return undefined; + } + } + case 299 /* SyntaxKind.PropertyAssignment */: + if (ts.isObjectLiteralExpression(parent.parent) && parent.name === node) { + // Get quoted name of properties of the object literal expression + // i.e. interface ConfigFiles { + // 'jspm:dev': string + // } + // let files: ConfigFiles = { + // '/*completion position*/' + // } + // + // function foo(c: ConfigFiles) {} + // foo({ + // '/*completion position*/' + // }); + return stringLiteralCompletionsForObjectLiteral(typeChecker, parent.parent); + } + return fromContextualType(); + case 209 /* SyntaxKind.ElementAccessExpression */: { + var _b = parent, expression = _b.expression, argumentExpression = _b.argumentExpression; + if (node === ts.skipParentheses(argumentExpression)) { + // Get all names of properties on the expression + // i.e. interface A { + // 'prop1': string + // } + // let a: A; + // a['/*completion position*/'] + return stringLiteralCompletionsFromProperties(typeChecker.getTypeAtLocation(expression)); + } + return undefined; + } + case 210 /* SyntaxKind.CallExpression */: + case 211 /* SyntaxKind.NewExpression */: + case 288 /* SyntaxKind.JsxAttribute */: + if (!isRequireCallArgument(node) && !ts.isImportCall(parent)) { + var argumentInfo = ts.SignatureHelp.getArgumentInfoForCompletions(parent.kind === 288 /* SyntaxKind.JsxAttribute */ ? parent.parent : node, position, sourceFile); + // Get string literal completions from specialized signatures of the target + // i.e. declare function f(a: 'A'); + // f("/*completion position*/") + return argumentInfo && getStringLiteralCompletionsFromSignature(argumentInfo.invocation, node, argumentInfo, typeChecker) || fromContextualType(); + } + // falls through (is `require("")` or `require(""` or `import("")`) + case 269 /* SyntaxKind.ImportDeclaration */: + case 275 /* SyntaxKind.ExportDeclaration */: + case 280 /* SyntaxKind.ExternalModuleReference */: + // Get all known external module names or complete a path to a module + // i.e. import * as ns from "/*completion position*/"; + // var y = import("/*completion position*/"); + // import x = require("/*completion position*/"); + // var y = require("/*completion position*/"); + // export * from "/*completion position*/"; + return { kind: 0 /* StringLiteralCompletionKind.Paths */, paths: getStringLiteralCompletionsFromModuleNames(sourceFile, node, compilerOptions, host, typeChecker, preferences) }; + default: + return fromContextualType(); + } + function fromContextualType() { + // Get completion for string literal from string literal type + // i.e. var x: "hi" | "hello" = "/*completion position*/" + return { kind: 2 /* StringLiteralCompletionKind.Types */, types: getStringLiteralTypes(ts.getContextualTypeFromParent(node, typeChecker)), isNewIdentifier: false }; + } + } + function walkUpParentheses(node) { + switch (node.kind) { + case 193 /* SyntaxKind.ParenthesizedType */: + return ts.walkUpParenthesizedTypes(node); + case 214 /* SyntaxKind.ParenthesizedExpression */: + return ts.walkUpParenthesizedExpressions(node); + default: + return node; + } + } + function getAlreadyUsedTypesInStringLiteralUnion(union, current) { + return ts.mapDefined(union.types, function (type) { + return type !== current && ts.isLiteralTypeNode(type) && ts.isStringLiteral(type.literal) ? type.literal.text : undefined; + }); + } + function getStringLiteralCompletionsFromSignature(call, arg, argumentInfo, checker) { + var isNewIdentifier = false; + var uniques = new ts.Map(); + var candidates = []; + var editingArgument = ts.isJsxOpeningLikeElement(call) ? ts.Debug.checkDefined(ts.findAncestor(arg.parent, ts.isJsxAttribute)) : arg; + checker.getResolvedSignatureForStringLiteralCompletions(call, editingArgument, candidates); + var types = ts.flatMap(candidates, function (candidate) { + if (!ts.signatureHasRestParameter(candidate) && argumentInfo.argumentCount > candidate.parameters.length) + return; + var type = candidate.getTypeParameterAtPosition(argumentInfo.argumentIndex); + if (ts.isJsxOpeningLikeElement(call)) { + var propType = checker.getTypeOfPropertyOfType(type, editingArgument.name.text); + if (propType) { + type = propType; + } + } + isNewIdentifier = isNewIdentifier || !!(type.flags & 4 /* TypeFlags.String */); + return getStringLiteralTypes(type, uniques); + }); + return ts.length(types) ? { kind: 2 /* StringLiteralCompletionKind.Types */, types: types, isNewIdentifier: isNewIdentifier } : undefined; + } + function stringLiteralCompletionsFromProperties(type) { + return type && { + kind: 1 /* StringLiteralCompletionKind.Properties */, + symbols: ts.filter(type.getApparentProperties(), function (prop) { return !(prop.valueDeclaration && ts.isPrivateIdentifierClassElementDeclaration(prop.valueDeclaration)); }), + hasIndexSignature: ts.hasIndexSignature(type) + }; + } + function stringLiteralCompletionsForObjectLiteral(checker, objectLiteralExpression) { + var contextualType = checker.getContextualType(objectLiteralExpression); + if (!contextualType) + return undefined; + var completionsType = checker.getContextualType(objectLiteralExpression, 4 /* ContextFlags.Completions */); + var symbols = Completions.getPropertiesForObjectExpression(contextualType, completionsType, objectLiteralExpression, checker); + return { + kind: 1 /* StringLiteralCompletionKind.Properties */, + symbols: symbols, + hasIndexSignature: ts.hasIndexSignature(contextualType) + }; + } + function getStringLiteralTypes(type, uniques) { + if (uniques === void 0) { uniques = new ts.Map(); } + if (!type) + return ts.emptyArray; + type = ts.skipConstraint(type); + return type.isUnion() ? ts.flatMap(type.types, function (t) { return getStringLiteralTypes(t, uniques); }) : + type.isStringLiteral() && !(type.flags & 1024 /* TypeFlags.EnumLiteral */) && ts.addToSeen(uniques, type.value) ? [type] : ts.emptyArray; + } + function nameAndKind(name, kind, extension) { + return { name: name, kind: kind, extension: extension }; + } + function directoryResult(name) { + return nameAndKind(name, "directory" /* ScriptElementKind.directory */, /*extension*/ undefined); + } + function addReplacementSpans(text, textStart, names) { + var span = getDirectoryFragmentTextSpan(text, textStart); + var wholeSpan = text.length === 0 ? undefined : ts.createTextSpan(textStart, text.length); + return names.map(function (_a) { + var name = _a.name, kind = _a.kind, extension = _a.extension; + return Math.max(name.indexOf(ts.directorySeparator), name.indexOf(ts.altDirectorySeparator)) !== -1 ? { name: name, kind: kind, extension: extension, span: wholeSpan } : { name: name, kind: kind, extension: extension, span: span }; + }); + } + function getStringLiteralCompletionsFromModuleNames(sourceFile, node, compilerOptions, host, typeChecker, preferences) { + return addReplacementSpans(node.text, node.getStart(sourceFile) + 1, getStringLiteralCompletionsFromModuleNamesWorker(sourceFile, node, compilerOptions, host, typeChecker, preferences)); + } + function getStringLiteralCompletionsFromModuleNamesWorker(sourceFile, node, compilerOptions, host, typeChecker, preferences) { + var literalValue = ts.normalizeSlashes(node.text); + var mode = ts.isStringLiteralLike(node) ? ts.getModeForUsageLocation(sourceFile, node) : undefined; + var scriptPath = sourceFile.path; + var scriptDirectory = ts.getDirectoryPath(scriptPath); + return isPathRelativeToScript(literalValue) || !compilerOptions.baseUrl && (ts.isRootedDiskPath(literalValue) || ts.isUrl(literalValue)) + ? getCompletionEntriesForRelativeModules(literalValue, scriptDirectory, compilerOptions, host, scriptPath, getIncludeExtensionOption()) + : getCompletionEntriesForNonRelativeModules(literalValue, scriptDirectory, mode, compilerOptions, host, getIncludeExtensionOption(), typeChecker); + function getIncludeExtensionOption() { + var mode = ts.isStringLiteralLike(node) ? ts.getModeForUsageLocation(sourceFile, node) : undefined; + return preferences.importModuleSpecifierEnding === "js" || mode === ts.ModuleKind.ESNext ? 2 /* IncludeExtensionsOption.ModuleSpecifierCompletion */ : 0 /* IncludeExtensionsOption.Exclude */; + } + } + function getExtensionOptions(compilerOptions, includeExtensionsOption) { + if (includeExtensionsOption === void 0) { includeExtensionsOption = 0 /* IncludeExtensionsOption.Exclude */; } + return { extensions: ts.flatten(getSupportedExtensionsForModuleResolution(compilerOptions)), includeExtensionsOption: includeExtensionsOption }; + } + function getCompletionEntriesForRelativeModules(literalValue, scriptDirectory, compilerOptions, host, scriptPath, includeExtensions) { + var extensionOptions = getExtensionOptions(compilerOptions, includeExtensions); + if (compilerOptions.rootDirs) { + return getCompletionEntriesForDirectoryFragmentWithRootDirs(compilerOptions.rootDirs, literalValue, scriptDirectory, extensionOptions, compilerOptions, host, scriptPath); + } + else { + return ts.arrayFrom(getCompletionEntriesForDirectoryFragment(literalValue, scriptDirectory, extensionOptions, host, scriptPath).values()); + } + } + function isEmitResolutionKindUsingNodeModules(compilerOptions) { + return ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeJs || + ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.Node16 || + ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeNext; + } + function isEmitModuleResolutionRespectingExportMaps(compilerOptions) { + return ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.Node16 || + ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeNext; + } + function getSupportedExtensionsForModuleResolution(compilerOptions) { + var extensions = ts.getSupportedExtensions(compilerOptions); + return isEmitResolutionKindUsingNodeModules(compilerOptions) ? + ts.getSupportedExtensionsWithJsonIfResolveJsonModule(compilerOptions, extensions) : + extensions; + } + /** + * Takes a script path and returns paths for all potential folders that could be merged with its + * containing folder via the "rootDirs" compiler option + */ + function getBaseDirectoriesFromRootDirs(rootDirs, basePath, scriptDirectory, ignoreCase) { + // Make all paths absolute/normalized if they are not already + rootDirs = rootDirs.map(function (rootDirectory) { return ts.normalizePath(ts.isRootedDiskPath(rootDirectory) ? rootDirectory : ts.combinePaths(basePath, rootDirectory)); }); + // Determine the path to the directory containing the script relative to the root directory it is contained within + var relativeDirectory = ts.firstDefined(rootDirs, function (rootDirectory) { + return ts.containsPath(rootDirectory, scriptDirectory, basePath, ignoreCase) ? scriptDirectory.substr(rootDirectory.length) : undefined; + }); // TODO: GH#18217 + // Now find a path for each potential directory that is to be merged with the one containing the script + return ts.deduplicate(__spreadArray(__spreadArray([], rootDirs.map(function (rootDirectory) { return ts.combinePaths(rootDirectory, relativeDirectory); }), true), [scriptDirectory], false), ts.equateStringsCaseSensitive, ts.compareStringsCaseSensitive); + } + function getCompletionEntriesForDirectoryFragmentWithRootDirs(rootDirs, fragment, scriptDirectory, extensionOptions, compilerOptions, host, exclude) { + var basePath = compilerOptions.project || host.getCurrentDirectory(); + var ignoreCase = !(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames()); + var baseDirectories = getBaseDirectoriesFromRootDirs(rootDirs, basePath, scriptDirectory, ignoreCase); + return ts.flatMap(baseDirectories, function (baseDirectory) { return ts.arrayFrom(getCompletionEntriesForDirectoryFragment(fragment, baseDirectory, extensionOptions, host, exclude).values()); }); + } + var IncludeExtensionsOption; + (function (IncludeExtensionsOption) { + IncludeExtensionsOption[IncludeExtensionsOption["Exclude"] = 0] = "Exclude"; + IncludeExtensionsOption[IncludeExtensionsOption["Include"] = 1] = "Include"; + IncludeExtensionsOption[IncludeExtensionsOption["ModuleSpecifierCompletion"] = 2] = "ModuleSpecifierCompletion"; + })(IncludeExtensionsOption || (IncludeExtensionsOption = {})); + /** + * Given a path ending at a directory, gets the completions for the path, and filters for those entries containing the basename. + */ + function getCompletionEntriesForDirectoryFragment(fragment, scriptPath, extensionOptions, host, exclude, result) { + var _a; + if (result === void 0) { result = createNameAndKindSet(); } + if (fragment === undefined) { + fragment = ""; + } + fragment = ts.normalizeSlashes(fragment); + /** + * Remove the basename from the path. Note that we don't use the basename to filter completions; + * the client is responsible for refining completions. + */ + if (!ts.hasTrailingDirectorySeparator(fragment)) { + fragment = ts.getDirectoryPath(fragment); + } + if (fragment === "") { + fragment = "." + ts.directorySeparator; + } + fragment = ts.ensureTrailingDirectorySeparator(fragment); + var absolutePath = ts.resolvePath(scriptPath, fragment); + var baseDirectory = ts.hasTrailingDirectorySeparator(absolutePath) ? absolutePath : ts.getDirectoryPath(absolutePath); + // check for a version redirect + var packageJsonPath = ts.findPackageJson(baseDirectory, host); + if (packageJsonPath) { + var packageJson = ts.readJson(packageJsonPath, host); + var typesVersions = packageJson.typesVersions; + if (typeof typesVersions === "object") { + var versionPaths = (_a = ts.getPackageJsonTypesVersionsPaths(typesVersions)) === null || _a === void 0 ? void 0 : _a.paths; + if (versionPaths) { + var packageDirectory = ts.getDirectoryPath(packageJsonPath); + var pathInPackage = absolutePath.slice(ts.ensureTrailingDirectorySeparator(packageDirectory).length); + if (addCompletionEntriesFromPaths(result, pathInPackage, packageDirectory, extensionOptions, host, versionPaths)) { + // A true result means one of the `versionPaths` was matched, which will block relative resolution + // to files and folders from here. All reachable paths given the pattern match are already added. + return result; + } + } + } + } + var ignoreCase = !(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames()); + if (!ts.tryDirectoryExists(host, baseDirectory)) + return result; + // Enumerate the available files if possible + var files = ts.tryReadDirectory(host, baseDirectory, extensionOptions.extensions, /*exclude*/ undefined, /*include*/ ["./*"]); + if (files) { + for (var _i = 0, files_1 = files; _i < files_1.length; _i++) { + var filePath = files_1[_i]; + filePath = ts.normalizePath(filePath); + if (exclude && ts.comparePaths(filePath, exclude, scriptPath, ignoreCase) === 0 /* Comparison.EqualTo */) { + continue; + } + var _b = getFilenameWithExtensionOption(ts.getBaseFileName(filePath), host.getCompilationSettings(), extensionOptions.includeExtensionsOption), name = _b.name, extension = _b.extension; + result.add(nameAndKind(name, "script" /* ScriptElementKind.scriptElement */, extension)); + } + } + // If possible, get folder completion as well + var directories = ts.tryGetDirectories(host, baseDirectory); + if (directories) { + for (var _c = 0, directories_1 = directories; _c < directories_1.length; _c++) { + var directory = directories_1[_c]; + var directoryName = ts.getBaseFileName(ts.normalizePath(directory)); + if (directoryName !== "@types") { + result.add(directoryResult(directoryName)); + } + } + } + return result; + } + function getFilenameWithExtensionOption(name, compilerOptions, includeExtensionsOption) { + var outputExtension = ts.moduleSpecifiers.tryGetJSExtensionForFile(name, compilerOptions); + if (includeExtensionsOption === 0 /* IncludeExtensionsOption.Exclude */ && !ts.fileExtensionIsOneOf(name, [".json" /* Extension.Json */, ".mts" /* Extension.Mts */, ".cts" /* Extension.Cts */, ".d.mts" /* Extension.Dmts */, ".d.cts" /* Extension.Dcts */, ".mjs" /* Extension.Mjs */, ".cjs" /* Extension.Cjs */])) { + return { name: ts.removeFileExtension(name), extension: ts.tryGetExtensionFromPath(name) }; + } + else if ((ts.fileExtensionIsOneOf(name, [".mts" /* Extension.Mts */, ".cts" /* Extension.Cts */, ".d.mts" /* Extension.Dmts */, ".d.cts" /* Extension.Dcts */, ".mjs" /* Extension.Mjs */, ".cjs" /* Extension.Cjs */]) || includeExtensionsOption === 2 /* IncludeExtensionsOption.ModuleSpecifierCompletion */) && outputExtension) { + return { name: ts.changeExtension(name, outputExtension), extension: outputExtension }; + } + else { + return { name: name, extension: ts.tryGetExtensionFromPath(name) }; + } + } + /** @returns whether `fragment` was a match for any `paths` (which should indicate whether any other path completions should be offered) */ + function addCompletionEntriesFromPaths(result, fragment, baseDirectory, extensionOptions, host, paths) { + var getPatternsForKey = function (key) { return paths[key]; }; + var comparePaths = function (a, b) { + var patternA = ts.tryParsePattern(a); + var patternB = ts.tryParsePattern(b); + var lengthA = typeof patternA === "object" ? patternA.prefix.length : a.length; + var lengthB = typeof patternB === "object" ? patternB.prefix.length : b.length; + return ts.compareValues(lengthB, lengthA); + }; + return addCompletionEntriesFromPathsOrExports(result, fragment, baseDirectory, extensionOptions, host, ts.getOwnKeys(paths), getPatternsForKey, comparePaths); + } + /** @returns whether `fragment` was a match for any `paths` (which should indicate whether any other path completions should be offered) */ + function addCompletionEntriesFromPathsOrExports(result, fragment, baseDirectory, extensionOptions, host, keys, getPatternsForKey, comparePaths) { + var pathResults = []; + var matchedPath; + for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) { + var key = keys_1[_i]; + if (key === ".") + continue; + var keyWithoutLeadingDotSlash = key.replace(/^\.\//, ""); // remove leading "./" + var patterns = getPatternsForKey(key); + if (patterns) { + var pathPattern = ts.tryParsePattern(keyWithoutLeadingDotSlash); + if (!pathPattern) + continue; + var isMatch = typeof pathPattern === "object" && ts.isPatternMatch(pathPattern, fragment); + var isLongestMatch = isMatch && (matchedPath === undefined || comparePaths(key, matchedPath) === -1 /* Comparison.LessThan */); + if (isLongestMatch) { + // If this is a higher priority match than anything we've seen so far, previous results from matches are invalid, e.g. + // for `import {} from "some-package/|"` with a typesVersions: + // { + // "bar/*": ["bar/*"], // <-- 1. We add 'bar', but 'bar/*' doesn't match yet. + // "*": ["dist/*"], // <-- 2. We match here and add files from dist. 'bar' is still ok because it didn't come from a match. + // "foo/*": ["foo/*"] // <-- 3. We matched '*' earlier and added results from dist, but if 'foo/*' also matched, + // } results in dist would not be visible. 'bar' still stands because it didn't come from a match. + // This is especially important if `dist/foo` is a folder, because if we fail to clear results + // added by the '*' match, after typing `"some-package/foo/|"` we would get file results from both + // ./dist/foo and ./foo, when only the latter will actually be resolvable. + // See pathCompletionsTypesVersionsWildcard6.ts. + matchedPath = key; + pathResults = pathResults.filter(function (r) { return !r.matchedPattern; }); + } + if (typeof pathPattern === "string" || matchedPath === undefined || comparePaths(key, matchedPath) !== 1 /* Comparison.GreaterThan */) { + pathResults.push({ + matchedPattern: isMatch, + results: getCompletionsForPathMapping(keyWithoutLeadingDotSlash, patterns, fragment, baseDirectory, extensionOptions, host) + .map(function (_a) { + var name = _a.name, kind = _a.kind, extension = _a.extension; + return nameAndKind(name, kind, extension); + }), + }); + } + } + } + pathResults.forEach(function (pathResult) { return pathResult.results.forEach(function (r) { return result.add(r); }); }); + return matchedPath !== undefined; + } + /** + * Check all of the declared modules and those in node modules. Possible sources of modules: + * Modules that are found by the type checker + * Modules found relative to "baseUrl" compliler options (including patterns from "paths" compiler option) + * Modules from node_modules (i.e. those listed in package.json) + * This includes all files that are found in node_modules/moduleName/ with acceptable file extensions + */ + function getCompletionEntriesForNonRelativeModules(fragment, scriptPath, mode, compilerOptions, host, includeExtensionsOption, typeChecker) { + var baseUrl = compilerOptions.baseUrl, paths = compilerOptions.paths; + var result = createNameAndKindSet(); + var extensionOptions = getExtensionOptions(compilerOptions, includeExtensionsOption); + if (baseUrl) { + var projectDir = compilerOptions.project || host.getCurrentDirectory(); + var absolute = ts.normalizePath(ts.combinePaths(projectDir, baseUrl)); + getCompletionEntriesForDirectoryFragment(fragment, absolute, extensionOptions, host, /*exclude*/ undefined, result); + if (paths) { + addCompletionEntriesFromPaths(result, fragment, absolute, extensionOptions, host, paths); + } + } + var fragmentDirectory = getFragmentDirectory(fragment); + for (var _i = 0, _a = getAmbientModuleCompletions(fragment, fragmentDirectory, typeChecker); _i < _a.length; _i++) { + var ambientName = _a[_i]; + result.add(nameAndKind(ambientName, "external module name" /* ScriptElementKind.externalModuleName */, /*extension*/ undefined)); + } + getCompletionEntriesFromTypings(host, compilerOptions, scriptPath, fragmentDirectory, extensionOptions, result); + if (isEmitResolutionKindUsingNodeModules(compilerOptions)) { + // If looking for a global package name, don't just include everything in `node_modules` because that includes dependencies' own dependencies. + // (But do if we didn't find anything, e.g. 'package.json' missing.) + var foundGlobal = false; + if (fragmentDirectory === undefined) { + for (var _b = 0, _c = enumerateNodeModulesVisibleToScript(host, scriptPath); _b < _c.length; _b++) { + var moduleName = _c[_b]; + var moduleResult = nameAndKind(moduleName, "external module name" /* ScriptElementKind.externalModuleName */, /*extension*/ undefined); + if (!result.has(moduleResult.name)) { + foundGlobal = true; + result.add(moduleResult); + } + } + } + if (!foundGlobal) { + var ancestorLookup = function (ancestor) { + var nodeModules = ts.combinePaths(ancestor, "node_modules"); + if (ts.tryDirectoryExists(host, nodeModules)) { + getCompletionEntriesForDirectoryFragment(fragment, nodeModules, extensionOptions, host, /*exclude*/ undefined, result); + } + }; + if (fragmentDirectory && isEmitModuleResolutionRespectingExportMaps(compilerOptions)) { + var nodeModulesDirectoryLookup_1 = ancestorLookup; + ancestorLookup = function (ancestor) { + var components = ts.getPathComponents(fragment); + components.shift(); // shift off empty root + var packagePath = components.shift(); + if (!packagePath) { + return nodeModulesDirectoryLookup_1(ancestor); + } + if (ts.startsWith(packagePath, "@")) { + var subName = components.shift(); + if (!subName) { + return nodeModulesDirectoryLookup_1(ancestor); + } + packagePath = ts.combinePaths(packagePath, subName); + } + var packageDirectory = ts.combinePaths(ancestor, "node_modules", packagePath); + var packageFile = ts.combinePaths(packageDirectory, "package.json"); + if (ts.tryFileExists(host, packageFile)) { + var packageJson = ts.readJson(packageFile, host); + var exports_1 = packageJson.exports; + if (exports_1) { + if (typeof exports_1 !== "object" || exports_1 === null) { // eslint-disable-line no-null/no-null + return; // null exports or entrypoint only, no sub-modules available + } + var keys = ts.getOwnKeys(exports_1); + var fragmentSubpath = components.join("/") + (components.length && ts.hasTrailingDirectorySeparator(fragment) ? "/" : ""); + var conditions_1 = mode === ts.ModuleKind.ESNext ? ["node", "import", "types"] : ["node", "require", "types"]; + addCompletionEntriesFromPathsOrExports(result, fragmentSubpath, packageDirectory, extensionOptions, host, keys, function (key) { return ts.singleElementArray(getPatternFromFirstMatchingCondition(exports_1[key], conditions_1)); }, ts.comparePatternKeys); + return; + } + } + return nodeModulesDirectoryLookup_1(ancestor); + }; + } + ts.forEachAncestorDirectory(scriptPath, ancestorLookup); + } + } + return ts.arrayFrom(result.values()); + } + function getPatternFromFirstMatchingCondition(target, conditions) { + if (typeof target === "string") { + return target; + } + if (target && typeof target === "object" && !ts.isArray(target)) { + for (var condition in target) { + if (condition === "default" || conditions.indexOf(condition) > -1 || ts.isApplicableVersionedTypesKey(conditions, condition)) { + var pattern = target[condition]; + return getPatternFromFirstMatchingCondition(pattern, conditions); + } + } + } + } + function getFragmentDirectory(fragment) { + return containsSlash(fragment) ? ts.hasTrailingDirectorySeparator(fragment) ? fragment : ts.getDirectoryPath(fragment) : undefined; + } + function getCompletionsForPathMapping(path, patterns, fragment, packageDirectory, extensionOptions, host) { + if (!ts.endsWith(path, "*")) { + // For a path mapping "foo": ["/x/y/z.ts"], add "foo" itself as a completion. + return !ts.stringContains(path, "*") ? justPathMappingName(path, "script" /* ScriptElementKind.scriptElement */) : ts.emptyArray; + } + var pathPrefix = path.slice(0, path.length - 1); + var remainingFragment = ts.tryRemovePrefix(fragment, pathPrefix); + if (remainingFragment === undefined) { + var starIsFullPathComponent = path[path.length - 2] === "/"; + return starIsFullPathComponent ? justPathMappingName(pathPrefix, "directory" /* ScriptElementKind.directory */) : ts.flatMap(patterns, function (pattern) { var _a; return (_a = getModulesForPathsPattern("", packageDirectory, pattern, extensionOptions, host)) === null || _a === void 0 ? void 0 : _a.map(function (_a) { + var name = _a.name, rest = __rest(_a, ["name"]); + return (__assign({ name: pathPrefix + name }, rest)); + }); }); + } + return ts.flatMap(patterns, function (pattern) { return getModulesForPathsPattern(remainingFragment, packageDirectory, pattern, extensionOptions, host); }); + function justPathMappingName(name, kind) { + return ts.startsWith(name, fragment) ? [{ name: ts.removeTrailingDirectorySeparator(name), kind: kind, extension: undefined }] : ts.emptyArray; + } + } + function getModulesForPathsPattern(fragment, packageDirectory, pattern, extensionOptions, host) { + if (!host.readDirectory) { + return undefined; + } + var parsed = ts.tryParsePattern(pattern); + if (parsed === undefined || ts.isString(parsed)) { + return undefined; + } + // The prefix has two effective parts: the directory path and the base component after the filepath that is not a + // full directory component. For example: directory/path/of/prefix/base* + var normalizedPrefix = ts.resolvePath(parsed.prefix); + var normalizedPrefixDirectory = ts.hasTrailingDirectorySeparator(parsed.prefix) ? normalizedPrefix : ts.getDirectoryPath(normalizedPrefix); + var normalizedPrefixBase = ts.hasTrailingDirectorySeparator(parsed.prefix) ? "" : ts.getBaseFileName(normalizedPrefix); + var fragmentHasPath = containsSlash(fragment); + var fragmentDirectory = fragmentHasPath ? ts.hasTrailingDirectorySeparator(fragment) ? fragment : ts.getDirectoryPath(fragment) : undefined; + // Try and expand the prefix to include any path from the fragment so that we can limit the readDirectory call + var expandedPrefixDirectory = fragmentHasPath ? ts.combinePaths(normalizedPrefixDirectory, normalizedPrefixBase + fragmentDirectory) : normalizedPrefixDirectory; + var normalizedSuffix = ts.normalizePath(parsed.suffix); + // Need to normalize after combining: If we combinePaths("a", "../b"), we want "b" and not "a/../b". + var baseDirectory = ts.normalizePath(ts.combinePaths(packageDirectory, expandedPrefixDirectory)); + var completePrefix = fragmentHasPath ? baseDirectory : ts.ensureTrailingDirectorySeparator(baseDirectory) + normalizedPrefixBase; + // If we have a suffix, then we read the directory all the way down to avoid returning completions for + // directories that don't contain files that would match the suffix. A previous comment here was concerned + // about the case where `normalizedSuffix` includes a `?` character, which should be interpreted literally, + // but will match any single character as part of the `include` pattern in `tryReadDirectory`. This is not + // a problem, because (in the extremely unusual circumstance where the suffix has a `?` in it) a `?` + // interpreted as "any character" can only return *too many* results as compared to the literal + // interpretation, so we can filter those superfluous results out via `trimPrefixAndSuffix` as we've always + // done. + var includeGlob = normalizedSuffix ? "**/*" + normalizedSuffix : "./*"; + var matches = ts.mapDefined(ts.tryReadDirectory(host, baseDirectory, extensionOptions.extensions, /*exclude*/ undefined, [includeGlob]), function (match) { + var trimmedWithPattern = trimPrefixAndSuffix(match); + if (trimmedWithPattern) { + if (containsSlash(trimmedWithPattern)) { + return directoryResult(ts.getPathComponents(removeLeadingDirectorySeparator(trimmedWithPattern))[1]); + } + var _a = getFilenameWithExtensionOption(trimmedWithPattern, host.getCompilationSettings(), extensionOptions.includeExtensionsOption), name = _a.name, extension = _a.extension; + return nameAndKind(name, "script" /* ScriptElementKind.scriptElement */, extension); + } + }); + // If we had a suffix, we already recursively searched for all possible files that could match + // it and returned the directories leading to those files. Otherwise, assume any directory could + // have something valid to import. + var directories = normalizedSuffix + ? ts.emptyArray + : ts.mapDefined(ts.tryGetDirectories(host, baseDirectory), function (dir) { return dir === "node_modules" ? undefined : directoryResult(dir); }); + return __spreadArray(__spreadArray([], matches, true), directories, true); + function trimPrefixAndSuffix(path) { + var inner = withoutStartAndEnd(ts.normalizePath(path), completePrefix, normalizedSuffix); + return inner === undefined ? undefined : removeLeadingDirectorySeparator(inner); + } + } + function withoutStartAndEnd(s, start, end) { + return ts.startsWith(s, start) && ts.endsWith(s, end) ? s.slice(start.length, s.length - end.length) : undefined; + } + function removeLeadingDirectorySeparator(path) { + return path[0] === ts.directorySeparator ? path.slice(1) : path; + } + function getAmbientModuleCompletions(fragment, fragmentDirectory, checker) { + // Get modules that the type checker picked up + var ambientModules = checker.getAmbientModules().map(function (sym) { return ts.stripQuotes(sym.name); }); + var nonRelativeModuleNames = ambientModules.filter(function (moduleName) { return ts.startsWith(moduleName, fragment); }); + // Nested modules of the form "module-name/sub" need to be adjusted to only return the string + // after the last '/' that appears in the fragment because that's where the replacement span + // starts + if (fragmentDirectory !== undefined) { + var moduleNameWithSeparator_1 = ts.ensureTrailingDirectorySeparator(fragmentDirectory); + return nonRelativeModuleNames.map(function (nonRelativeModuleName) { return ts.removePrefix(nonRelativeModuleName, moduleNameWithSeparator_1); }); + } + return nonRelativeModuleNames; + } + function getTripleSlashReferenceCompletion(sourceFile, position, compilerOptions, host) { + var token = ts.getTokenAtPosition(sourceFile, position); + var commentRanges = ts.getLeadingCommentRanges(sourceFile.text, token.pos); + var range = commentRanges && ts.find(commentRanges, function (commentRange) { return position >= commentRange.pos && position <= commentRange.end; }); + if (!range) { + return undefined; + } + var text = sourceFile.text.slice(range.pos, position); + var match = tripleSlashDirectiveFragmentRegex.exec(text); + if (!match) { + return undefined; + } + var prefix = match[1], kind = match[2], toComplete = match[3]; + var scriptPath = ts.getDirectoryPath(sourceFile.path); + var names = kind === "path" ? getCompletionEntriesForDirectoryFragment(toComplete, scriptPath, getExtensionOptions(compilerOptions, 1 /* IncludeExtensionsOption.Include */), host, sourceFile.path) + : kind === "types" ? getCompletionEntriesFromTypings(host, compilerOptions, scriptPath, getFragmentDirectory(toComplete), getExtensionOptions(compilerOptions)) + : ts.Debug.fail(); + return addReplacementSpans(toComplete, range.pos + prefix.length, ts.arrayFrom(names.values())); + } + function getCompletionEntriesFromTypings(host, options, scriptPath, fragmentDirectory, extensionOptions, result) { + if (result === void 0) { result = createNameAndKindSet(); } + // Check for typings specified in compiler options + var seen = new ts.Map(); + var typeRoots = ts.tryAndIgnoreErrors(function () { return ts.getEffectiveTypeRoots(options, host); }) || ts.emptyArray; + for (var _i = 0, typeRoots_1 = typeRoots; _i < typeRoots_1.length; _i++) { + var root = typeRoots_1[_i]; + getCompletionEntriesFromDirectories(root); + } + // Also get all @types typings installed in visible node_modules directories + for (var _a = 0, _b = ts.findPackageJsons(scriptPath, host); _a < _b.length; _a++) { + var packageJson = _b[_a]; + var typesDir = ts.combinePaths(ts.getDirectoryPath(packageJson), "node_modules/@types"); + getCompletionEntriesFromDirectories(typesDir); + } + return result; + function getCompletionEntriesFromDirectories(directory) { + if (!ts.tryDirectoryExists(host, directory)) + return; + for (var _i = 0, _a = ts.tryGetDirectories(host, directory); _i < _a.length; _i++) { + var typeDirectoryName = _a[_i]; + var packageName = ts.unmangleScopedPackageName(typeDirectoryName); + if (options.types && !ts.contains(options.types, packageName)) + continue; + if (fragmentDirectory === undefined) { + if (!seen.has(packageName)) { + result.add(nameAndKind(packageName, "external module name" /* ScriptElementKind.externalModuleName */, /*extension*/ undefined)); + seen.set(packageName, true); + } + } + else { + var baseDirectory = ts.combinePaths(directory, typeDirectoryName); + var remainingFragment = ts.tryRemoveDirectoryPrefix(fragmentDirectory, packageName, ts.hostGetCanonicalFileName(host)); + if (remainingFragment !== undefined) { + getCompletionEntriesForDirectoryFragment(remainingFragment, baseDirectory, extensionOptions, host, /*exclude*/ undefined, result); + } + } + } + } + } + function enumerateNodeModulesVisibleToScript(host, scriptPath) { + if (!host.readFile || !host.fileExists) + return ts.emptyArray; + var result = []; + for (var _i = 0, _a = ts.findPackageJsons(scriptPath, host); _i < _a.length; _i++) { + var packageJson = _a[_i]; + var contents = ts.readJson(packageJson, host); // Cast to assert that readFile is defined + // Provide completions for all non @types dependencies + for (var _b = 0, nodeModulesDependencyKeys_1 = nodeModulesDependencyKeys; _b < nodeModulesDependencyKeys_1.length; _b++) { + var key = nodeModulesDependencyKeys_1[_b]; + var dependencies = contents[key]; + if (!dependencies) + continue; + for (var dep in dependencies) { + if (ts.hasProperty(dependencies, dep) && !ts.startsWith(dep, "@types/")) { + result.push(dep); + } + } + } + } + return result; + } + // Replace everything after the last directory separator that appears + function getDirectoryFragmentTextSpan(text, textStart) { + var index = Math.max(text.lastIndexOf(ts.directorySeparator), text.lastIndexOf(ts.altDirectorySeparator)); + var offset = index !== -1 ? index + 1 : 0; + // If the range is an identifier, span is unnecessary. + var length = text.length - offset; + return length === 0 || ts.isIdentifierText(text.substr(offset, length), 99 /* ScriptTarget.ESNext */) ? undefined : ts.createTextSpan(textStart + offset, length); + } + // Returns true if the path is explicitly relative to the script (i.e. relative to . or ..) + function isPathRelativeToScript(path) { + if (path && path.length >= 2 && path.charCodeAt(0) === 46 /* CharacterCodes.dot */) { + var slashIndex = path.length >= 3 && path.charCodeAt(1) === 46 /* CharacterCodes.dot */ ? 2 : 1; + var slashCharCode = path.charCodeAt(slashIndex); + return slashCharCode === 47 /* CharacterCodes.slash */ || slashCharCode === 92 /* CharacterCodes.backslash */; + } + return false; + } + /** + * Matches a triple slash reference directive with an incomplete string literal for its path. Used + * to determine if the caret is currently within the string literal and capture the literal fragment + * for completions. + * For example, this matches + * + * /// 0; }, + resolvedBeyondLimit: function () { return resolvedCount > Completions.moduleSpecifierResolutionLimit; }, + }); + var hitRateMessage = cacheAttemptCount ? " (".concat((resolvedFromCacheCount / cacheAttemptCount * 100).toFixed(1), "% hit rate)") : ""; + (_a = host.log) === null || _a === void 0 ? void 0 : _a.call(host, "".concat(logPrefix, ": resolved ").concat(resolvedCount, " module specifiers, plus ").concat(ambientCount, " ambient and ").concat(resolvedFromCacheCount, " from cache").concat(hitRateMessage)); + (_b = host.log) === null || _b === void 0 ? void 0 : _b.call(host, "".concat(logPrefix, ": response is ").concat(skippedAny ? "incomplete" : "complete")); + (_c = host.log) === null || _c === void 0 ? void 0 : _c.call(host, "".concat(logPrefix, ": ").concat(ts.timestamp() - start)); + return result; + function tryResolve(exportInfo, symbolName, isFromAmbientModule) { + if (isFromAmbientModule) { + var result_1 = resolver.getModuleSpecifierForBestExportInfo(exportInfo, symbolName, position, isValidTypeOnlyUseSite); + if (result_1) { + ambientCount++; + } + return result_1 || "failed"; + } + var shouldResolveModuleSpecifier = needsFullResolution || preferences.allowIncompleteCompletions && resolvedCount < Completions.moduleSpecifierResolutionLimit; + var shouldGetModuleSpecifierFromCache = !shouldResolveModuleSpecifier && preferences.allowIncompleteCompletions && cacheAttemptCount < Completions.moduleSpecifierResolutionCacheAttemptLimit; + var result = (shouldResolveModuleSpecifier || shouldGetModuleSpecifierFromCache) + ? resolver.getModuleSpecifierForBestExportInfo(exportInfo, symbolName, position, isValidTypeOnlyUseSite, shouldGetModuleSpecifierFromCache) + : undefined; + if (!shouldResolveModuleSpecifier && !shouldGetModuleSpecifierFromCache || shouldGetModuleSpecifierFromCache && !result) { + skippedAny = true; + } + resolvedCount += (result === null || result === void 0 ? void 0 : result.computedWithoutCacheCount) || 0; + resolvedFromCacheCount += exportInfo.length - ((result === null || result === void 0 ? void 0 : result.computedWithoutCacheCount) || 0); + if (shouldGetModuleSpecifierFromCache) { + cacheAttemptCount++; + } + return result || (needsFullResolution ? "failed" : "skipped"); + } + } + function getCompletionsAtPosition(host, program, log, sourceFile, position, preferences, triggerCharacter, completionKind, cancellationToken, formatContext) { + var _a; + var previousToken = getRelevantTokens(position, sourceFile).previousToken; + if (triggerCharacter && !ts.isInString(sourceFile, position, previousToken) && !isValidTrigger(sourceFile, triggerCharacter, previousToken, position)) { + return undefined; + } + if (triggerCharacter === " ") { + // `isValidTrigger` ensures we are at `import |` + if (preferences.includeCompletionsForImportStatements && preferences.includeCompletionsWithInsertText) { + return { isGlobalCompletion: true, isMemberCompletion: false, isNewIdentifierLocation: true, isIncomplete: true, entries: [] }; + } + return undefined; + } + // If the request is a continuation of an earlier `isIncomplete` response, + // we can continue it from the cached previous response. + var compilerOptions = program.getCompilerOptions(); + var incompleteCompletionsCache = preferences.allowIncompleteCompletions ? (_a = host.getIncompleteCompletionsCache) === null || _a === void 0 ? void 0 : _a.call(host) : undefined; + if (incompleteCompletionsCache && completionKind === 3 /* CompletionTriggerKind.TriggerForIncompleteCompletions */ && previousToken && ts.isIdentifier(previousToken)) { + var incompleteContinuation = continuePreviousIncompleteResponse(incompleteCompletionsCache, sourceFile, previousToken, program, host, preferences, cancellationToken); + if (incompleteContinuation) { + return incompleteContinuation; + } + } + else { + incompleteCompletionsCache === null || incompleteCompletionsCache === void 0 ? void 0 : incompleteCompletionsCache.clear(); + } + var stringCompletions = Completions.StringCompletions.getStringLiteralCompletions(sourceFile, position, previousToken, compilerOptions, host, program, log, preferences); + if (stringCompletions) { + return stringCompletions; + } + if (previousToken && ts.isBreakOrContinueStatement(previousToken.parent) + && (previousToken.kind === 81 /* SyntaxKind.BreakKeyword */ || previousToken.kind === 86 /* SyntaxKind.ContinueKeyword */ || previousToken.kind === 79 /* SyntaxKind.Identifier */)) { + return getLabelCompletionAtPosition(previousToken.parent); + } + var completionData = getCompletionData(program, log, sourceFile, compilerOptions, position, preferences, /*detailsEntryId*/ undefined, host, formatContext, cancellationToken); + if (!completionData) { + return undefined; + } + switch (completionData.kind) { + case 0 /* CompletionDataKind.Data */: + var response = completionInfoFromData(sourceFile, host, program, compilerOptions, log, completionData, preferences, formatContext, position); + if (response === null || response === void 0 ? void 0 : response.isIncomplete) { + incompleteCompletionsCache === null || incompleteCompletionsCache === void 0 ? void 0 : incompleteCompletionsCache.set(response); + } + return response; + case 1 /* CompletionDataKind.JsDocTagName */: + // If the current position is a jsDoc tag name, only tag names should be provided for completion + return jsdocCompletionInfo(ts.JsDoc.getJSDocTagNameCompletions()); + case 2 /* CompletionDataKind.JsDocTag */: + // If the current position is a jsDoc tag, only tags should be provided for completion + return jsdocCompletionInfo(ts.JsDoc.getJSDocTagCompletions()); + case 3 /* CompletionDataKind.JsDocParameterName */: + return jsdocCompletionInfo(ts.JsDoc.getJSDocParameterNameCompletions(completionData.tag)); + case 4 /* CompletionDataKind.Keywords */: + return specificKeywordCompletionInfo(completionData.keywordCompletions, completionData.isNewIdentifierLocation); + default: + return ts.Debug.assertNever(completionData); + } + } + Completions.getCompletionsAtPosition = getCompletionsAtPosition; + // Editors will use the `sortText` and then fall back to `name` for sorting, but leave ties in response order. + // So, it's important that we sort those ties in the order we want them displayed if it matters. We don't + // strictly need to sort by name or SortText here since clients are going to do it anyway, but we have to + // do the work of comparing them so we can sort those ties appropriately; plus, it makes the order returned + // by the language service consistent with what TS Server does and what editors typically do. This also makes + // completions tests make more sense. We used to sort only alphabetically and only in the server layer, but + // this made tests really weird, since most fourslash tests don't use the server. + function compareCompletionEntries(entryInArray, entryToInsert) { + var _a, _b; + var result = ts.compareStringsCaseSensitiveUI(entryInArray.sortText, entryToInsert.sortText); + if (result === 0 /* Comparison.EqualTo */) { + result = ts.compareStringsCaseSensitiveUI(entryInArray.name, entryToInsert.name); + } + if (result === 0 /* Comparison.EqualTo */ && ((_a = entryInArray.data) === null || _a === void 0 ? void 0 : _a.moduleSpecifier) && ((_b = entryToInsert.data) === null || _b === void 0 ? void 0 : _b.moduleSpecifier)) { + // Sort same-named auto-imports by module specifier + result = ts.compareNumberOfDirectorySeparators(entryInArray.data.moduleSpecifier, entryToInsert.data.moduleSpecifier); + } + if (result === 0 /* Comparison.EqualTo */) { + // Fall back to symbol order - if we return `EqualTo`, `insertSorted` will put later symbols first. + return -1 /* Comparison.LessThan */; + } + return result; + } + function completionEntryDataIsResolved(data) { + return !!(data === null || data === void 0 ? void 0 : data.moduleSpecifier); + } + function continuePreviousIncompleteResponse(cache, file, location, program, host, preferences, cancellationToken) { + var previousResponse = cache.get(); + if (!previousResponse) + return undefined; + var lowerCaseTokenText = location.text.toLowerCase(); + var exportMap = ts.getExportInfoMap(file, host, program, preferences, cancellationToken); + var newEntries = resolvingModuleSpecifiers("continuePreviousIncompleteResponse", host, ts.codefix.createImportSpecifierResolver(file, program, host, preferences), program, location.getStart(), preferences, + /*isForImportStatementCompletion*/ false, ts.isValidTypeOnlyAliasUseSite(location), function (context) { + var entries = ts.mapDefined(previousResponse.entries, function (entry) { + var _a; + if (!entry.hasAction || !entry.source || !entry.data || completionEntryDataIsResolved(entry.data)) { + // Not an auto import or already resolved; keep as is + return entry; + } + if (!charactersFuzzyMatchInString(entry.name, lowerCaseTokenText)) { + // No longer matches typed characters; filter out + return undefined; + } + var origin = ts.Debug.checkDefined(getAutoImportSymbolFromCompletionEntryData(entry.name, entry.data, program, host)).origin; + var info = exportMap.get(file.path, entry.data.exportMapKey); + var result = info && context.tryResolve(info, entry.name, !ts.isExternalModuleNameRelative(ts.stripQuotes(origin.moduleSymbol.name))); + if (result === "skipped") + return entry; + if (!result || result === "failed") { + (_a = host.log) === null || _a === void 0 ? void 0 : _a.call(host, "Unexpected failure resolving auto import for '".concat(entry.name, "' from '").concat(entry.source, "'")); + return undefined; + } + var newOrigin = __assign(__assign({}, origin), { kind: 32 /* SymbolOriginInfoKind.ResolvedExport */, moduleSpecifier: result.moduleSpecifier }); + // Mutating for performance... feels sketchy but nobody else uses the cache, + // so why bother allocating a bunch of new objects? + entry.data = originToCompletionEntryData(newOrigin); + entry.source = getSourceFromOrigin(newOrigin); + entry.sourceDisplay = [ts.textPart(newOrigin.moduleSpecifier)]; + return entry; + }); + if (!context.skippedAny()) { + previousResponse.isIncomplete = undefined; + } + return entries; + }); + previousResponse.entries = newEntries; + previousResponse.flags = (previousResponse.flags || 0) | 4 /* CompletionInfoFlags.IsContinuation */; + return previousResponse; + } + function jsdocCompletionInfo(entries) { + return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false, entries: entries }; + } + function keywordToCompletionEntry(keyword) { + return { + name: ts.tokenToString(keyword), + kind: "keyword" /* ScriptElementKind.keyword */, + kindModifiers: "" /* ScriptElementKindModifier.none */, + sortText: Completions.SortText.GlobalsOrKeywords, + }; + } + function specificKeywordCompletionInfo(entries, isNewIdentifierLocation) { + return { + isGlobalCompletion: false, + isMemberCompletion: false, + isNewIdentifierLocation: isNewIdentifierLocation, + entries: entries.slice(), + }; + } + function keywordCompletionData(keywordFilters, filterOutTsOnlyKeywords, isNewIdentifierLocation) { + return { + kind: 4 /* CompletionDataKind.Keywords */, + keywordCompletions: getKeywordCompletions(keywordFilters, filterOutTsOnlyKeywords), + isNewIdentifierLocation: isNewIdentifierLocation, + }; + } + function keywordFiltersFromSyntaxKind(keywordCompletion) { + switch (keywordCompletion) { + case 154 /* SyntaxKind.TypeKeyword */: return 8 /* KeywordCompletionFilters.TypeKeyword */; + default: ts.Debug.fail("Unknown mapping from SyntaxKind to KeywordCompletionFilters"); + } + } + function getOptionalReplacementSpan(location) { + // StringLiteralLike locations are handled separately in stringCompletions.ts + return (location === null || location === void 0 ? void 0 : location.kind) === 79 /* SyntaxKind.Identifier */ ? ts.createTextSpanFromNode(location) : undefined; + } + function completionInfoFromData(sourceFile, host, program, compilerOptions, log, completionData, preferences, formatContext, position) { + var symbols = completionData.symbols, contextToken = completionData.contextToken, completionKind = completionData.completionKind, isInSnippetScope = completionData.isInSnippetScope, isNewIdentifierLocation = completionData.isNewIdentifierLocation, location = completionData.location, propertyAccessToConvert = completionData.propertyAccessToConvert, keywordFilters = completionData.keywordFilters, literals = completionData.literals, symbolToOriginInfoMap = completionData.symbolToOriginInfoMap, recommendedCompletion = completionData.recommendedCompletion, isJsxInitializer = completionData.isJsxInitializer, isTypeOnlyLocation = completionData.isTypeOnlyLocation, isJsxIdentifierExpected = completionData.isJsxIdentifierExpected, isRightOfOpenTag = completionData.isRightOfOpenTag, importStatementCompletion = completionData.importStatementCompletion, insideJsDocTagTypeExpression = completionData.insideJsDocTagTypeExpression, symbolToSortTextMap = completionData.symbolToSortTextMap, hasUnresolvedAutoImports = completionData.hasUnresolvedAutoImports; + // Verify if the file is JSX language variant + if (ts.getLanguageVariant(sourceFile.scriptKind) === 1 /* LanguageVariant.JSX */) { + var completionInfo = getJsxClosingTagCompletion(location, sourceFile); + if (completionInfo) { + return completionInfo; + } + } + var entries = ts.createSortedArray(); + var isChecked = isCheckedFile(sourceFile, compilerOptions); + if (isChecked && !isNewIdentifierLocation && (!symbols || symbols.length === 0) && keywordFilters === 0 /* KeywordCompletionFilters.None */) { + return undefined; + } + var uniqueNames = getCompletionEntriesFromSymbols(symbols, entries, + /*replacementToken*/ undefined, contextToken, location, sourceFile, host, program, ts.getEmitScriptTarget(compilerOptions), log, completionKind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, isJsxIdentifierExpected, isJsxInitializer, importStatementCompletion, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextMap, isJsxIdentifierExpected, isRightOfOpenTag); + if (keywordFilters !== 0 /* KeywordCompletionFilters.None */) { + for (var _i = 0, _a = getKeywordCompletions(keywordFilters, !insideJsDocTagTypeExpression && ts.isSourceFileJS(sourceFile)); _i < _a.length; _i++) { + var keywordEntry = _a[_i]; + if (isTypeOnlyLocation && ts.isTypeKeyword(ts.stringToToken(keywordEntry.name)) || !uniqueNames.has(keywordEntry.name)) { + uniqueNames.add(keywordEntry.name); + ts.insertSorted(entries, keywordEntry, compareCompletionEntries, /*allowDuplicates*/ true); + } + } + } + for (var _b = 0, _c = getContextualKeywords(contextToken, position); _b < _c.length; _b++) { + var keywordEntry = _c[_b]; + if (!uniqueNames.has(keywordEntry.name)) { + uniqueNames.add(keywordEntry.name); + ts.insertSorted(entries, keywordEntry, compareCompletionEntries, /*allowDuplicates*/ true); + } + } + for (var _d = 0, literals_1 = literals; _d < literals_1.length; _d++) { + var literal = literals_1[_d]; + var literalEntry = createCompletionEntryForLiteral(sourceFile, preferences, literal); + uniqueNames.add(literalEntry.name); + ts.insertSorted(entries, literalEntry, compareCompletionEntries, /*allowDuplicates*/ true); + } + if (!isChecked) { + getJSCompletionEntries(sourceFile, location.pos, uniqueNames, ts.getEmitScriptTarget(compilerOptions), entries); + } + return { + flags: completionData.flags, + isGlobalCompletion: isInSnippetScope, + isIncomplete: preferences.allowIncompleteCompletions && hasUnresolvedAutoImports ? true : undefined, + isMemberCompletion: isMemberCompletionKind(completionKind), + isNewIdentifierLocation: isNewIdentifierLocation, + optionalReplacementSpan: getOptionalReplacementSpan(location), + entries: entries, + }; + } + function isCheckedFile(sourceFile, compilerOptions) { + return !ts.isSourceFileJS(sourceFile) || !!ts.isCheckJsEnabledForFile(sourceFile, compilerOptions); + } + function isMemberCompletionKind(kind) { + switch (kind) { + case 0 /* CompletionKind.ObjectPropertyDeclaration */: + case 3 /* CompletionKind.MemberLike */: + case 2 /* CompletionKind.PropertyAccess */: + return true; + default: + return false; + } + } + function getJsxClosingTagCompletion(location, sourceFile) { + // We wanna walk up the tree till we find a JSX closing element + var jsxClosingElement = ts.findAncestor(location, function (node) { + switch (node.kind) { + case 284 /* SyntaxKind.JsxClosingElement */: + return true; + case 43 /* SyntaxKind.SlashToken */: + case 31 /* SyntaxKind.GreaterThanToken */: + case 79 /* SyntaxKind.Identifier */: + case 208 /* SyntaxKind.PropertyAccessExpression */: + return false; + default: + return "quit"; + } + }); + if (jsxClosingElement) { + // In the TypeScript JSX element, if such element is not defined. When users query for completion at closing tag, + // instead of simply giving unknown value, the completion will return the tag-name of an associated opening-element. + // For example: + // var x =
" with type any + // And at `
` (with a closing `>`), the completion list will contain "div". + // And at property access expressions ` ` the completion will + // return full closing tag with an optional replacement span + // For example: + // var x = + // var y = + // the completion list at "1" and "2" will contain "MainComponent.Child" with a replacement span of closing tag name + var hasClosingAngleBracket = !!ts.findChildOfKind(jsxClosingElement, 31 /* SyntaxKind.GreaterThanToken */, sourceFile); + var tagName = jsxClosingElement.parent.openingElement.tagName; + var closingTag = tagName.getText(sourceFile); + var fullClosingTag = closingTag + (hasClosingAngleBracket ? "" : ">"); + var replacementSpan = ts.createTextSpanFromNode(jsxClosingElement.tagName); + var entry = { + name: fullClosingTag, + kind: "class" /* ScriptElementKind.classElement */, + kindModifiers: undefined, + sortText: Completions.SortText.LocationPriority, + }; + return { isGlobalCompletion: false, isMemberCompletion: true, isNewIdentifierLocation: false, optionalReplacementSpan: replacementSpan, entries: [entry] }; + } + return; + } + function getJSCompletionEntries(sourceFile, position, uniqueNames, target, entries) { + ts.getNameTable(sourceFile).forEach(function (pos, name) { + // Skip identifiers produced only from the current location + if (pos === position) { + return; + } + var realName = ts.unescapeLeadingUnderscores(name); + if (!uniqueNames.has(realName) && ts.isIdentifierText(realName, target)) { + uniqueNames.add(realName); + ts.insertSorted(entries, { + name: realName, + kind: "warning" /* ScriptElementKind.warning */, + kindModifiers: "", + sortText: Completions.SortText.JavascriptIdentifiers, + isFromUncheckedFile: true + }, compareCompletionEntries); + } + }); + } + function completionNameForLiteral(sourceFile, preferences, literal) { + return typeof literal === "object" ? ts.pseudoBigIntToString(literal) + "n" : + ts.isString(literal) ? ts.quote(sourceFile, preferences, literal) : JSON.stringify(literal); + } + function createCompletionEntryForLiteral(sourceFile, preferences, literal) { + return { name: completionNameForLiteral(sourceFile, preferences, literal), kind: "string" /* ScriptElementKind.string */, kindModifiers: "" /* ScriptElementKindModifier.none */, sortText: Completions.SortText.LocationPriority }; + } + function createCompletionEntry(symbol, sortText, replacementToken, contextToken, location, sourceFile, host, program, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importStatementCompletion, useSemicolons, options, preferences, completionKind, formatContext, isJsxIdentifierExpected, isRightOfOpenTag) { + var _a, _b; + var insertText; + var replacementSpan = ts.getReplacementSpanForContextToken(replacementToken); + var data; + var isSnippet; + var source = getSourceFromOrigin(origin); + var sourceDisplay; + var hasAction; + var labelDetails; + var typeChecker = program.getTypeChecker(); + var insertQuestionDot = origin && originIsNullableMember(origin); + var useBraces = origin && originIsSymbolMember(origin) || needsConvertPropertyAccess; + if (origin && originIsThisType(origin)) { + insertText = needsConvertPropertyAccess + ? "this".concat(insertQuestionDot ? "?." : "", "[").concat(quotePropertyName(sourceFile, preferences, name), "]") + : "this".concat(insertQuestionDot ? "?." : ".").concat(name); + } + // We should only have needsConvertPropertyAccess if there's a property access to convert. But see #21790. + // Somehow there was a global with a non-identifier name. Hopefully someone will complain about getting a "foo bar" global completion and provide a repro. + else if ((useBraces || insertQuestionDot) && propertyAccessToConvert) { + insertText = useBraces ? needsConvertPropertyAccess ? "[".concat(quotePropertyName(sourceFile, preferences, name), "]") : "[".concat(name, "]") : name; + if (insertQuestionDot || propertyAccessToConvert.questionDotToken) { + insertText = "?.".concat(insertText); + } + var dot = ts.findChildOfKind(propertyAccessToConvert, 24 /* SyntaxKind.DotToken */, sourceFile) || + ts.findChildOfKind(propertyAccessToConvert, 28 /* SyntaxKind.QuestionDotToken */, sourceFile); + if (!dot) { + return undefined; + } + // If the text after the '.' starts with this name, write over it. Else, add new text. + var end = ts.startsWith(name, propertyAccessToConvert.name.text) ? propertyAccessToConvert.name.end : dot.end; + replacementSpan = ts.createTextSpanFromBounds(dot.getStart(sourceFile), end); + } + if (isJsxInitializer) { + if (insertText === undefined) + insertText = name; + insertText = "{".concat(insertText, "}"); + if (typeof isJsxInitializer !== "boolean") { + replacementSpan = ts.createTextSpanFromNode(isJsxInitializer, sourceFile); + } + } + if (origin && originIsPromise(origin) && propertyAccessToConvert) { + if (insertText === undefined) + insertText = name; + var precedingToken = ts.findPrecedingToken(propertyAccessToConvert.pos, sourceFile); + var awaitText = ""; + if (precedingToken && ts.positionIsASICandidate(precedingToken.end, precedingToken.parent, sourceFile)) { + awaitText = ";"; + } + awaitText += "(await ".concat(propertyAccessToConvert.expression.getText(), ")"); + insertText = needsConvertPropertyAccess ? "".concat(awaitText).concat(insertText) : "".concat(awaitText).concat(insertQuestionDot ? "?." : ".").concat(insertText); + replacementSpan = ts.createTextSpanFromBounds(propertyAccessToConvert.getStart(sourceFile), propertyAccessToConvert.end); + } + if (originIsResolvedExport(origin)) { + sourceDisplay = [ts.textPart(origin.moduleSpecifier)]; + if (importStatementCompletion) { + (_a = getInsertTextAndReplacementSpanForImportCompletion(name, importStatementCompletion, origin, useSemicolons, sourceFile, options, preferences), insertText = _a.insertText, replacementSpan = _a.replacementSpan); + isSnippet = preferences.includeCompletionsWithSnippetText ? true : undefined; + } + } + if ((origin === null || origin === void 0 ? void 0 : origin.kind) === 64 /* SymbolOriginInfoKind.TypeOnlyAlias */) { + hasAction = true; + } + if (preferences.includeCompletionsWithClassMemberSnippets && + preferences.includeCompletionsWithInsertText && + completionKind === 3 /* CompletionKind.MemberLike */ && + isClassLikeMemberCompletion(symbol, location, sourceFile)) { + var importAdder = void 0; + (_b = getEntryForMemberCompletion(host, program, options, preferences, name, symbol, location, contextToken, formatContext), insertText = _b.insertText, isSnippet = _b.isSnippet, importAdder = _b.importAdder, replacementSpan = _b.replacementSpan); + sortText = Completions.SortText.ClassMemberSnippets; // sortText has to be lower priority than the sortText for keywords. See #47852. + if (importAdder === null || importAdder === void 0 ? void 0 : importAdder.hasFixes()) { + hasAction = true; + source = CompletionSource.ClassMemberSnippet; + } + } + if (origin && originIsObjectLiteralMethod(origin)) { + (insertText = origin.insertText, isSnippet = origin.isSnippet, labelDetails = origin.labelDetails); + if (!preferences.useLabelDetailsInCompletionEntries) { + name = name + labelDetails.detail; + labelDetails = undefined; + } + source = CompletionSource.ObjectLiteralMethodSnippet; + sortText = Completions.SortText.SortBelow(sortText); + } + if (isJsxIdentifierExpected && !isRightOfOpenTag && preferences.includeCompletionsWithSnippetText && preferences.jsxAttributeCompletionStyle && preferences.jsxAttributeCompletionStyle !== "none") { + var useBraces_1 = preferences.jsxAttributeCompletionStyle === "braces"; + var type = typeChecker.getTypeOfSymbolAtLocation(symbol, location); + // If is boolean like or undefined, don't return a snippet we want just to return the completion. + if (preferences.jsxAttributeCompletionStyle === "auto" + && !(type.flags & 528 /* TypeFlags.BooleanLike */) + && !(type.flags & 1048576 /* TypeFlags.Union */ && ts.find(type.types, function (type) { return !!(type.flags & 528 /* TypeFlags.BooleanLike */); }))) { + if (type.flags & 402653316 /* TypeFlags.StringLike */ || (type.flags & 1048576 /* TypeFlags.Union */ && ts.every(type.types, function (type) { return !!(type.flags & (402653316 /* TypeFlags.StringLike */ | 32768 /* TypeFlags.Undefined */)); }))) { + // If is string like or undefined use quotes + insertText = "".concat(ts.escapeSnippetText(name), "=").concat(ts.quote(sourceFile, preferences, "$1")); + isSnippet = true; + } + else { + // Use braces for everything else + useBraces_1 = true; + } + } + if (useBraces_1) { + insertText = "".concat(ts.escapeSnippetText(name), "={$1}"); + isSnippet = true; + } + } + if (insertText !== undefined && !preferences.includeCompletionsWithInsertText) { + return undefined; + } + if (originIsExport(origin) || originIsResolvedExport(origin)) { + data = originToCompletionEntryData(origin); + hasAction = !importStatementCompletion; + } + // TODO(drosen): Right now we just permit *all* semantic meanings when calling + // 'getSymbolKind' which is permissible given that it is backwards compatible; but + // really we should consider passing the meaning for the node so that we don't report + // that a suggestion for a value is an interface. We COULD also just do what + // 'getSymbolModifiers' does, which is to use the first declaration. + // Use a 'sortText' of 0' so that all symbol completion entries come before any other + // entries (like JavaScript identifier entries). + return { + name: name, + kind: ts.SymbolDisplay.getSymbolKind(typeChecker, symbol, location), + kindModifiers: ts.SymbolDisplay.getSymbolModifiers(typeChecker, symbol), + sortText: sortText, + source: source, + hasAction: hasAction ? true : undefined, + isRecommended: isRecommendedCompletionMatch(symbol, recommendedCompletion, typeChecker) || undefined, + insertText: insertText, + replacementSpan: replacementSpan, + sourceDisplay: sourceDisplay, + labelDetails: labelDetails, + isSnippet: isSnippet, + isPackageJsonImport: originIsPackageJsonImport(origin) || undefined, + isImportStatementCompletion: !!importStatementCompletion || undefined, + data: data, + }; + } + function isClassLikeMemberCompletion(symbol, location, sourceFile) { + // TODO: support JS files. + if (ts.isInJSFile(location)) { + return false; + } + // Completion symbol must be for a class member. + var memberFlags = 106500 /* SymbolFlags.ClassMember */ + & 900095 /* SymbolFlags.EnumMemberExcludes */; + /* In + `class C { + | + }` + `location` is a class-like declaration. + In + `class C { + m| + }` + `location` is an identifier, + `location.parent` is a class element declaration, + and `location.parent.parent` is a class-like declaration. + In + `abstract class C { + abstract + abstract m| + }` + `location` is a syntax list (with modifiers as children), + and `location.parent` is a class-like declaration. + */ + return !!(symbol.flags & memberFlags) && + (ts.isClassLike(location) || + (location.parent && + location.parent.parent && + ts.isClassElement(location.parent) && + location === location.parent.name && + location.parent.getLastToken(sourceFile) === location.parent.name && + ts.isClassLike(location.parent.parent)) || + (location.parent && + ts.isSyntaxList(location) && + ts.isClassLike(location.parent))); + } + function getEntryForMemberCompletion(host, program, options, preferences, name, symbol, location, contextToken, formatContext) { + var classLikeDeclaration = ts.findAncestor(location, ts.isClassLike); + if (!classLikeDeclaration) { + return { insertText: name }; + } + var isSnippet; + var replacementSpan; + var insertText = name; + var checker = program.getTypeChecker(); + var sourceFile = location.getSourceFile(); + var printer = createSnippetPrinter({ + removeComments: true, + module: options.module, + target: options.target, + omitTrailingSemicolon: false, + newLine: ts.getNewLineKind(ts.getNewLineCharacter(options, ts.maybeBind(host, host.getNewLine))), + }); + var importAdder = ts.codefix.createImportAdder(sourceFile, program, preferences, host); + // Create empty body for possible method implementation. + var body; + if (preferences.includeCompletionsWithSnippetText) { + isSnippet = true; + // We are adding a tabstop (i.e. `$0`) in the body of the suggested member, + // if it has one, so that the cursor ends up in the body once the completion is inserted. + // Note: this assumes we won't have more than one body in the completion nodes, which should be the case. + var emptyStmt = ts.factory.createEmptyStatement(); + body = ts.factory.createBlock([emptyStmt], /* multiline */ true); + ts.setSnippetElement(emptyStmt, { kind: 0 /* SnippetKind.TabStop */, order: 0 }); + } + else { + body = ts.factory.createBlock([], /* multiline */ true); + } + var modifiers = 0 /* ModifierFlags.None */; + // Whether the suggested member should be abstract. + // e.g. in `abstract class C { abstract | }`, we should offer abstract method signatures at position `|`. + var _a = getPresentModifiers(contextToken), presentModifiers = _a.modifiers, modifiersSpan = _a.span; + var isAbstract = !!(presentModifiers & 256 /* ModifierFlags.Abstract */); + var completionNodes = []; + ts.codefix.addNewNodeForMemberSymbol(symbol, classLikeDeclaration, sourceFile, { program: program, host: host }, preferences, importAdder, + // `addNewNodeForMemberSymbol` calls this callback function for each new member node + // it adds for the given member symbol. + // We store these member nodes in the `completionNodes` array. + // Note: there might be: + // - No nodes if `addNewNodeForMemberSymbol` cannot figure out a node for the member; + // - One node; + // - More than one node if the member is overloaded (e.g. a method with overload signatures). + function (node) { + var requiredModifiers = 0 /* ModifierFlags.None */; + if (isAbstract) { + requiredModifiers |= 256 /* ModifierFlags.Abstract */; + } + if (ts.isClassElement(node) + && checker.getMemberOverrideModifierStatus(classLikeDeclaration, node) === 1 /* MemberOverrideStatus.NeedsOverride */) { + requiredModifiers |= 16384 /* ModifierFlags.Override */; + } + if (!completionNodes.length) { + // Keep track of added missing required modifiers and modifiers already present. + // This is needed when we have overloaded signatures, + // so this callback will be called for multiple nodes/signatures, + // and we need to make sure the modifiers are uniform for all nodes/signatures. + modifiers = node.modifierFlagsCache | requiredModifiers | presentModifiers; + } + node = ts.factory.updateModifiers(node, modifiers); + completionNodes.push(node); + }, body, 2 /* codefix.PreserveOptionalFlags.Property */, isAbstract); + if (completionNodes.length) { + var format = 1 /* ListFormat.MultiLine */ | 131072 /* ListFormat.NoTrailingNewLine */; + replacementSpan = modifiersSpan; + // If we have access to formatting settings, we print the nodes using the emitter, + // and then format the printed text. + if (formatContext) { + insertText = printer.printAndFormatSnippetList(format, ts.factory.createNodeArray(completionNodes), sourceFile, formatContext); + } + else { // Otherwise, just use emitter to print the new nodes. + insertText = printer.printSnippetList(format, ts.factory.createNodeArray(completionNodes), sourceFile); + } + } + return { insertText: insertText, isSnippet: isSnippet, importAdder: importAdder, replacementSpan: replacementSpan }; + } + function getPresentModifiers(contextToken) { + if (!contextToken) { + return { modifiers: 0 /* ModifierFlags.None */ }; + } + var modifiers = 0 /* ModifierFlags.None */; + var span; + var contextMod; + /* + Cases supported: + In + `class C { + public abstract | + }` + `contextToken` is ``abstract`` (as an identifier), + `contextToken.parent` is property declaration, + `location` is class declaration ``class C { ... }``. + In + `class C { + protected override m| + }` + `contextToken` is ``override`` (as a keyword), + `contextToken.parent` is property declaration, + `location` is identifier ``m``, + `location.parent` is property declaration ``protected override m``, + `location.parent.parent` is class declaration ``class C { ... }``. + */ + if (contextMod = isModifierLike(contextToken)) { + modifiers |= ts.modifierToFlag(contextMod); + span = ts.createTextSpanFromNode(contextToken); + } + if (ts.isPropertyDeclaration(contextToken.parent)) { + modifiers |= ts.modifiersToFlags(contextToken.parent.modifiers) & 126975 /* ModifierFlags.Modifier */; + span = ts.createTextSpanFromNode(contextToken.parent); + } + return { modifiers: modifiers, span: span }; + } + function isModifierLike(node) { + if (ts.isModifier(node)) { + return node.kind; + } + if (ts.isIdentifier(node) && node.originalKeywordKind && ts.isModifierKind(node.originalKeywordKind)) { + return node.originalKeywordKind; + } + return undefined; + } + function getEntryForObjectLiteralMethodCompletion(symbol, name, enclosingDeclaration, program, host, options, preferences, formatContext) { + var isSnippet = preferences.includeCompletionsWithSnippetText || undefined; + var insertText = name; + var sourceFile = enclosingDeclaration.getSourceFile(); + var method = createObjectLiteralMethod(symbol, enclosingDeclaration, sourceFile, program, host, preferences); + if (!method) { + return undefined; + } + var printer = createSnippetPrinter({ + removeComments: true, + module: options.module, + target: options.target, + omitTrailingSemicolon: false, + newLine: ts.getNewLineKind(ts.getNewLineCharacter(options, ts.maybeBind(host, host.getNewLine))), + }); + if (formatContext) { + insertText = printer.printAndFormatSnippetList(16 /* ListFormat.CommaDelimited */ | 64 /* ListFormat.AllowTrailingComma */, ts.factory.createNodeArray([method], /*hasTrailingComma*/ true), sourceFile, formatContext); + } + else { + insertText = printer.printSnippetList(16 /* ListFormat.CommaDelimited */ | 64 /* ListFormat.AllowTrailingComma */, ts.factory.createNodeArray([method], /*hasTrailingComma*/ true), sourceFile); + } + var signaturePrinter = ts.createPrinter({ + removeComments: true, + module: options.module, + target: options.target, + omitTrailingSemicolon: true, + }); + // The `labelDetails.detail` will be displayed right beside the method name, + // so we drop the name (and modifiers) from the signature. + var methodSignature = ts.factory.createMethodSignature( + /*modifiers*/ undefined, + /*name*/ "", method.questionToken, method.typeParameters, method.parameters, method.type); + var labelDetails = { detail: signaturePrinter.printNode(4 /* EmitHint.Unspecified */, methodSignature, sourceFile) }; + return { isSnippet: isSnippet, insertText: insertText, labelDetails: labelDetails }; + } + function createObjectLiteralMethod(symbol, enclosingDeclaration, sourceFile, program, host, preferences) { + var declarations = symbol.getDeclarations(); + if (!(declarations && declarations.length)) { + return undefined; + } + var checker = program.getTypeChecker(); + var declaration = declarations[0]; + var name = ts.getSynthesizedDeepClone(ts.getNameOfDeclaration(declaration), /*includeTrivia*/ false); + var type = checker.getWidenedType(checker.getTypeOfSymbolAtLocation(symbol, enclosingDeclaration)); + var quotePreference = ts.getQuotePreference(sourceFile, preferences); + var builderFlags = 33554432 /* NodeBuilderFlags.OmitThisParameter */ | (quotePreference === 0 /* QuotePreference.Single */ ? 268435456 /* NodeBuilderFlags.UseSingleQuotesForStringLiteralType */ : 0 /* NodeBuilderFlags.None */); + switch (declaration.kind) { + case 168 /* SyntaxKind.PropertySignature */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + case 171 /* SyntaxKind.MethodDeclaration */: { + var effectiveType = type.flags & 1048576 /* TypeFlags.Union */ && type.types.length < 10 + ? checker.getUnionType(type.types, 2 /* UnionReduction.Subtype */) + : type; + if (effectiveType.flags & 1048576 /* TypeFlags.Union */) { + // Only offer the completion if there's a single function type component. + var functionTypes = ts.filter(effectiveType.types, function (type) { return checker.getSignaturesOfType(type, 0 /* SignatureKind.Call */).length > 0; }); + if (functionTypes.length === 1) { + effectiveType = functionTypes[0]; + } + else { + return undefined; + } + } + var signatures = checker.getSignaturesOfType(effectiveType, 0 /* SignatureKind.Call */); + if (signatures.length !== 1) { + // We don't support overloads in object literals. + return undefined; + } + var typeNode = checker.typeToTypeNode(effectiveType, enclosingDeclaration, builderFlags, ts.codefix.getNoopSymbolTrackerWithResolver({ program: program, host: host })); + if (!typeNode || !ts.isFunctionTypeNode(typeNode)) { + return undefined; + } + var body = void 0; + if (preferences.includeCompletionsWithSnippetText) { + var emptyStmt = ts.factory.createEmptyStatement(); + body = ts.factory.createBlock([emptyStmt], /* multiline */ true); + ts.setSnippetElement(emptyStmt, { kind: 0 /* SnippetKind.TabStop */, order: 0 }); + } + else { + body = ts.factory.createBlock([], /* multiline */ true); + } + var parameters = typeNode.parameters.map(function (typedParam) { + return ts.factory.createParameterDeclaration( + /*modifiers*/ undefined, typedParam.dotDotDotToken, typedParam.name, + /*questionToken*/ undefined, + /*type*/ undefined, typedParam.initializer); + }); + return ts.factory.createMethodDeclaration( + /*modifiers*/ undefined, + /*asteriskToken*/ undefined, name, + /*questionToken*/ undefined, + /*typeParameters*/ undefined, parameters, + /*type*/ undefined, body); + } + default: + return undefined; + } + } + function createSnippetPrinter(printerOptions) { + var escapes; + var baseWriter = ts.textChanges.createWriter(ts.getNewLineCharacter(printerOptions)); + var printer = ts.createPrinter(printerOptions, baseWriter); + var writer = __assign(__assign({}, baseWriter), { write: function (s) { return escapingWrite(s, function () { return baseWriter.write(s); }); }, nonEscapingWrite: baseWriter.write, writeLiteral: function (s) { return escapingWrite(s, function () { return baseWriter.writeLiteral(s); }); }, writeStringLiteral: function (s) { return escapingWrite(s, function () { return baseWriter.writeStringLiteral(s); }); }, writeSymbol: function (s, symbol) { return escapingWrite(s, function () { return baseWriter.writeSymbol(s, symbol); }); }, writeParameter: function (s) { return escapingWrite(s, function () { return baseWriter.writeParameter(s); }); }, writeComment: function (s) { return escapingWrite(s, function () { return baseWriter.writeComment(s); }); }, writeProperty: function (s) { return escapingWrite(s, function () { return baseWriter.writeProperty(s); }); } }); + return { + printSnippetList: printSnippetList, + printAndFormatSnippetList: printAndFormatSnippetList, + }; + // The formatter/scanner will have issues with snippet-escaped text, + // so instead of writing the escaped text directly to the writer, + // generate a set of changes that can be applied to the unescaped text + // to escape it post-formatting. + function escapingWrite(s, write) { + var escaped = ts.escapeSnippetText(s); + if (escaped !== s) { + var start = baseWriter.getTextPos(); + write(); + var end = baseWriter.getTextPos(); + escapes = ts.append(escapes || (escapes = []), { newText: escaped, span: { start: start, length: end - start } }); + } + else { + write(); + } + } + /* Snippet-escaping version of `printer.printList`. */ + function printSnippetList(format, list, sourceFile) { + var unescaped = printUnescapedSnippetList(format, list, sourceFile); + return escapes ? ts.textChanges.applyChanges(unescaped, escapes) : unescaped; + } + function printUnescapedSnippetList(format, list, sourceFile) { + escapes = undefined; + writer.clear(); + printer.writeList(format, list, sourceFile, writer); + return writer.getText(); + } + function printAndFormatSnippetList(format, list, sourceFile, formatContext) { + var syntheticFile = { + text: printUnescapedSnippetList(format, list, sourceFile), + getLineAndCharacterOfPosition: function (pos) { + return ts.getLineAndCharacterOfPosition(this, pos); + }, + }; + var formatOptions = ts.getFormatCodeSettingsForWriting(formatContext, sourceFile); + var changes = ts.flatMap(list, function (node) { + var nodeWithPos = ts.textChanges.assignPositionsToNode(node); + return ts.formatting.formatNodeGivenIndentation(nodeWithPos, syntheticFile, sourceFile.languageVariant, + /* indentation */ 0, + /* delta */ 0, __assign(__assign({}, formatContext), { options: formatOptions })); + }); + var allChanges = escapes + ? ts.stableSort(ts.concatenate(changes, escapes), function (a, b) { return ts.compareTextSpans(a.span, b.span); }) + : changes; + return ts.textChanges.applyChanges(syntheticFile.text, allChanges); + } + } + function originToCompletionEntryData(origin) { + var ambientModuleName = origin.fileName ? undefined : ts.stripQuotes(origin.moduleSymbol.name); + var isPackageJsonImport = origin.isFromPackageJson ? true : undefined; + if (originIsResolvedExport(origin)) { + var resolvedData = { + exportName: origin.exportName, + moduleSpecifier: origin.moduleSpecifier, + ambientModuleName: ambientModuleName, + fileName: origin.fileName, + isPackageJsonImport: isPackageJsonImport, + }; + return resolvedData; + } + var unresolvedData = { + exportName: origin.exportName, + exportMapKey: origin.exportMapKey, + fileName: origin.fileName, + ambientModuleName: origin.fileName ? undefined : ts.stripQuotes(origin.moduleSymbol.name), + isPackageJsonImport: origin.isFromPackageJson ? true : undefined, + }; + return unresolvedData; + } + function completionEntryDataToSymbolOriginInfo(data, completionName, moduleSymbol) { + var isDefaultExport = data.exportName === "default" /* InternalSymbolName.Default */; + var isFromPackageJson = !!data.isPackageJsonImport; + if (completionEntryDataIsResolved(data)) { + var resolvedOrigin = { + kind: 32 /* SymbolOriginInfoKind.ResolvedExport */, + exportName: data.exportName, + moduleSpecifier: data.moduleSpecifier, + symbolName: completionName, + fileName: data.fileName, + moduleSymbol: moduleSymbol, + isDefaultExport: isDefaultExport, + isFromPackageJson: isFromPackageJson, + }; + return resolvedOrigin; + } + var unresolvedOrigin = { + kind: 4 /* SymbolOriginInfoKind.Export */, + exportName: data.exportName, + exportMapKey: data.exportMapKey, + symbolName: completionName, + fileName: data.fileName, + moduleSymbol: moduleSymbol, + isDefaultExport: isDefaultExport, + isFromPackageJson: isFromPackageJson, + }; + return unresolvedOrigin; + } + function getInsertTextAndReplacementSpanForImportCompletion(name, importStatementCompletion, origin, useSemicolons, sourceFile, options, preferences) { + var replacementSpan = importStatementCompletion.replacementSpan; + var quotedModuleSpecifier = ts.quote(sourceFile, preferences, origin.moduleSpecifier); + var exportKind = origin.isDefaultExport ? 1 /* ExportKind.Default */ : + origin.exportName === "export=" /* InternalSymbolName.ExportEquals */ ? 2 /* ExportKind.ExportEquals */ : + 0 /* ExportKind.Named */; + var tabStop = preferences.includeCompletionsWithSnippetText ? "$1" : ""; + var importKind = ts.codefix.getImportKind(sourceFile, exportKind, options, /*forceImportKeyword*/ true); + var isImportSpecifierTypeOnly = importStatementCompletion.couldBeTypeOnlyImportSpecifier; + var topLevelTypeOnlyText = importStatementCompletion.isTopLevelTypeOnly ? " ".concat(ts.tokenToString(154 /* SyntaxKind.TypeKeyword */), " ") : " "; + var importSpecifierTypeOnlyText = isImportSpecifierTypeOnly ? "".concat(ts.tokenToString(154 /* SyntaxKind.TypeKeyword */), " ") : ""; + var suffix = useSemicolons ? ";" : ""; + switch (importKind) { + case 3 /* ImportKind.CommonJS */: return { replacementSpan: replacementSpan, insertText: "import".concat(topLevelTypeOnlyText).concat(ts.escapeSnippetText(name)).concat(tabStop, " = require(").concat(quotedModuleSpecifier, ")").concat(suffix) }; + case 1 /* ImportKind.Default */: return { replacementSpan: replacementSpan, insertText: "import".concat(topLevelTypeOnlyText).concat(ts.escapeSnippetText(name)).concat(tabStop, " from ").concat(quotedModuleSpecifier).concat(suffix) }; + case 2 /* ImportKind.Namespace */: return { replacementSpan: replacementSpan, insertText: "import".concat(topLevelTypeOnlyText, "* as ").concat(ts.escapeSnippetText(name), " from ").concat(quotedModuleSpecifier).concat(suffix) }; + case 0 /* ImportKind.Named */: return { replacementSpan: replacementSpan, insertText: "import".concat(topLevelTypeOnlyText, "{ ").concat(importSpecifierTypeOnlyText).concat(ts.escapeSnippetText(name)).concat(tabStop, " } from ").concat(quotedModuleSpecifier).concat(suffix) }; + } + } + function quotePropertyName(sourceFile, preferences, name) { + if (/^\d+$/.test(name)) { + return name; + } + return ts.quote(sourceFile, preferences, name); + } + function isRecommendedCompletionMatch(localSymbol, recommendedCompletion, checker) { + return localSymbol === recommendedCompletion || + !!(localSymbol.flags & 1048576 /* SymbolFlags.ExportValue */) && checker.getExportSymbolOfSymbol(localSymbol) === recommendedCompletion; + } + function getSourceFromOrigin(origin) { + if (originIsExport(origin)) { + return ts.stripQuotes(origin.moduleSymbol.name); + } + if (originIsResolvedExport(origin)) { + return origin.moduleSpecifier; + } + if ((origin === null || origin === void 0 ? void 0 : origin.kind) === 1 /* SymbolOriginInfoKind.ThisType */) { + return CompletionSource.ThisProperty; + } + if ((origin === null || origin === void 0 ? void 0 : origin.kind) === 64 /* SymbolOriginInfoKind.TypeOnlyAlias */) { + return CompletionSource.TypeOnlyAlias; + } + } + function getCompletionEntriesFromSymbols(symbols, entries, replacementToken, contextToken, location, sourceFile, host, program, target, log, kind, preferences, compilerOptions, formatContext, isTypeOnlyLocation, propertyAccessToConvert, jsxIdentifierExpected, isJsxInitializer, importStatementCompletion, recommendedCompletion, symbolToOriginInfoMap, symbolToSortTextMap, isJsxIdentifierExpected, isRightOfOpenTag) { + var _a; + var start = ts.timestamp(); + var variableDeclaration = getVariableDeclaration(location); + var useSemicolons = ts.probablyUsesSemicolons(sourceFile); + var typeChecker = program.getTypeChecker(); + // Tracks unique names. + // Value is set to false for global variables or completions from external module exports, because we can have multiple of those; + // true otherwise. Based on the order we add things we will always see locals first, then globals, then module exports. + // So adding a completion for a local will prevent us from adding completions for external module exports sharing the same name. + var uniques = new ts.Map(); + for (var i = 0; i < symbols.length; i++) { + var symbol = symbols[i]; + var origin = symbolToOriginInfoMap === null || symbolToOriginInfoMap === void 0 ? void 0 : symbolToOriginInfoMap[i]; + var info = getCompletionEntryDisplayNameForSymbol(symbol, target, origin, kind, !!jsxIdentifierExpected); + if (!info || (uniques.get(info.name) && (!origin || !originIsObjectLiteralMethod(origin))) || kind === 1 /* CompletionKind.Global */ && symbolToSortTextMap && !shouldIncludeSymbol(symbol, symbolToSortTextMap)) { + continue; + } + var name = info.name, needsConvertPropertyAccess = info.needsConvertPropertyAccess; + var originalSortText = (_a = symbolToSortTextMap === null || symbolToSortTextMap === void 0 ? void 0 : symbolToSortTextMap[ts.getSymbolId(symbol)]) !== null && _a !== void 0 ? _a : Completions.SortText.LocationPriority; + var sortText = (isDeprecated(symbol, typeChecker) ? Completions.SortText.Deprecated(originalSortText) : originalSortText); + var entry = createCompletionEntry(symbol, sortText, replacementToken, contextToken, location, sourceFile, host, program, name, needsConvertPropertyAccess, origin, recommendedCompletion, propertyAccessToConvert, isJsxInitializer, importStatementCompletion, useSemicolons, compilerOptions, preferences, kind, formatContext, isJsxIdentifierExpected, isRightOfOpenTag); + if (!entry) { + continue; + } + /** True for locals; false for globals, module exports from other files, `this.` completions. */ + var shouldShadowLaterSymbols = (!origin || originIsTypeOnlyAlias(origin)) && !(symbol.parent === undefined && !ts.some(symbol.declarations, function (d) { return d.getSourceFile() === location.getSourceFile(); })); + uniques.set(name, shouldShadowLaterSymbols); + ts.insertSorted(entries, entry, compareCompletionEntries, /*allowDuplicates*/ true); + } + log("getCompletionsAtPosition: getCompletionEntriesFromSymbols: " + (ts.timestamp() - start)); + // Prevent consumers of this map from having to worry about + // the boolean value. Externally, it should be seen as the + // set of all names. + return { + has: function (name) { return uniques.has(name); }, + add: function (name) { return uniques.set(name, true); }, + }; + function shouldIncludeSymbol(symbol, symbolToSortTextMap) { + var allFlags = symbol.flags; + if (!ts.isSourceFile(location)) { + // export = /**/ here we want to get all meanings, so any symbol is ok + if (ts.isExportAssignment(location.parent)) { + return true; + } + // Filter out variables from their own initializers + // `const a = /* no 'a' here */` + if (variableDeclaration && symbol.valueDeclaration === variableDeclaration) { + return false; + } + // External modules can have global export declarations that will be + // available as global keywords in all scopes. But if the external module + // already has an explicit export and user only wants to user explicit + // module imports then the global keywords will be filtered out so auto + // import suggestions will win in the completion + var symbolOrigin = ts.skipAlias(symbol, typeChecker); + // We only want to filter out the global keywords + // Auto Imports are not available for scripts so this conditional is always false + if (!!sourceFile.externalModuleIndicator + && !compilerOptions.allowUmdGlobalAccess + && symbolToSortTextMap[ts.getSymbolId(symbol)] === Completions.SortText.GlobalsOrKeywords + && (symbolToSortTextMap[ts.getSymbolId(symbolOrigin)] === Completions.SortText.AutoImportSuggestions + || symbolToSortTextMap[ts.getSymbolId(symbolOrigin)] === Completions.SortText.LocationPriority)) { + return false; + } + allFlags |= ts.getCombinedLocalAndExportSymbolFlags(symbolOrigin); + // import m = /**/ <-- It can only access namespace (if typing import = x. this would get member symbols and not namespace) + if (ts.isInRightSideOfInternalImportEqualsDeclaration(location)) { + return !!(allFlags & 1920 /* SymbolFlags.Namespace */); + } + if (isTypeOnlyLocation) { + // It's a type, but you can reach it by namespace.type as well + return symbolCanBeReferencedAtTypeLocation(symbol, typeChecker); + } + } + // expressions are value space (which includes the value namespaces) + return !!(allFlags & 111551 /* SymbolFlags.Value */); + } + } + Completions.getCompletionEntriesFromSymbols = getCompletionEntriesFromSymbols; + function getLabelCompletionAtPosition(node) { + var entries = getLabelStatementCompletions(node); + if (entries.length) { + return { isGlobalCompletion: false, isMemberCompletion: false, isNewIdentifierLocation: false, entries: entries }; + } + } + function getLabelStatementCompletions(node) { + var entries = []; + var uniques = new ts.Map(); + var current = node; + while (current) { + if (ts.isFunctionLike(current)) { + break; + } + if (ts.isLabeledStatement(current)) { + var name = current.label.text; + if (!uniques.has(name)) { + uniques.set(name, true); + entries.push({ + name: name, + kindModifiers: "" /* ScriptElementKindModifier.none */, + kind: "label" /* ScriptElementKind.label */, + sortText: Completions.SortText.LocationPriority + }); + } + } + current = current.parent; + } + return entries; + } + function getSymbolCompletionFromEntryId(program, log, sourceFile, position, entryId, host, preferences) { + if (entryId.data) { + var autoImport = getAutoImportSymbolFromCompletionEntryData(entryId.name, entryId.data, program, host); + if (autoImport) { + var _a = getRelevantTokens(position, sourceFile), contextToken_1 = _a.contextToken, previousToken_1 = _a.previousToken; + return { + type: "symbol", + symbol: autoImport.symbol, + location: ts.getTouchingPropertyName(sourceFile, position), + previousToken: previousToken_1, + contextToken: contextToken_1, + isJsxInitializer: false, + isTypeOnlyLocation: false, + origin: autoImport.origin, + }; + } + } + var compilerOptions = program.getCompilerOptions(); + var completionData = getCompletionData(program, log, sourceFile, compilerOptions, position, { includeCompletionsForModuleExports: true, includeCompletionsWithInsertText: true }, entryId, host, /*formatContext*/ undefined); + if (!completionData) { + return { type: "none" }; + } + if (completionData.kind !== 0 /* CompletionDataKind.Data */) { + return { type: "request", request: completionData }; + } + var symbols = completionData.symbols, literals = completionData.literals, location = completionData.location, completionKind = completionData.completionKind, symbolToOriginInfoMap = completionData.symbolToOriginInfoMap, contextToken = completionData.contextToken, previousToken = completionData.previousToken, isJsxInitializer = completionData.isJsxInitializer, isTypeOnlyLocation = completionData.isTypeOnlyLocation; + var literal = ts.find(literals, function (l) { return completionNameForLiteral(sourceFile, preferences, l) === entryId.name; }); + if (literal !== undefined) + return { type: "literal", literal: literal }; + // Find the symbol with the matching entry name. + // We don't need to perform character checks here because we're only comparing the + // name against 'entryName' (which is known to be good), not building a new + // completion entry. + return ts.firstDefined(symbols, function (symbol, index) { + var origin = symbolToOriginInfoMap[index]; + var info = getCompletionEntryDisplayNameForSymbol(symbol, ts.getEmitScriptTarget(compilerOptions), origin, completionKind, completionData.isJsxIdentifierExpected); + return info && info.name === entryId.name && (entryId.source === CompletionSource.ClassMemberSnippet && symbol.flags & 106500 /* SymbolFlags.ClassMember */ + || entryId.source === CompletionSource.ObjectLiteralMethodSnippet && symbol.flags & (4 /* SymbolFlags.Property */ | 8192 /* SymbolFlags.Method */) + || getSourceFromOrigin(origin) === entryId.source) + ? { type: "symbol", symbol: symbol, location: location, origin: origin, contextToken: contextToken, previousToken: previousToken, isJsxInitializer: isJsxInitializer, isTypeOnlyLocation: isTypeOnlyLocation } + : undefined; + }) || { type: "none" }; + } + function getCompletionEntryDetails(program, log, sourceFile, position, entryId, host, formatContext, preferences, cancellationToken) { + var typeChecker = program.getTypeChecker(); + var compilerOptions = program.getCompilerOptions(); + var name = entryId.name, source = entryId.source, data = entryId.data; + var contextToken = ts.findPrecedingToken(position, sourceFile); + if (ts.isInString(sourceFile, position, contextToken)) { + return Completions.StringCompletions.getStringLiteralCompletionDetails(name, sourceFile, position, contextToken, typeChecker, compilerOptions, host, cancellationToken, preferences); + } + // Compute all the completion symbols again. + var symbolCompletion = getSymbolCompletionFromEntryId(program, log, sourceFile, position, entryId, host, preferences); + switch (symbolCompletion.type) { + case "request": { + var request = symbolCompletion.request; + switch (request.kind) { + case 1 /* CompletionDataKind.JsDocTagName */: + return ts.JsDoc.getJSDocTagNameCompletionDetails(name); + case 2 /* CompletionDataKind.JsDocTag */: + return ts.JsDoc.getJSDocTagCompletionDetails(name); + case 3 /* CompletionDataKind.JsDocParameterName */: + return ts.JsDoc.getJSDocParameterNameCompletionDetails(name); + case 4 /* CompletionDataKind.Keywords */: + return ts.some(request.keywordCompletions, function (c) { return c.name === name; }) ? createSimpleDetails(name, "keyword" /* ScriptElementKind.keyword */, ts.SymbolDisplayPartKind.keyword) : undefined; + default: + return ts.Debug.assertNever(request); + } + } + case "symbol": { + var symbol = symbolCompletion.symbol, location = symbolCompletion.location, contextToken_2 = symbolCompletion.contextToken, origin = symbolCompletion.origin, previousToken = symbolCompletion.previousToken; + var _a = getCompletionEntryCodeActionsAndSourceDisplay(name, location, contextToken_2, origin, symbol, program, host, compilerOptions, sourceFile, position, previousToken, formatContext, preferences, data, source, cancellationToken), codeActions = _a.codeActions, sourceDisplay = _a.sourceDisplay; + return createCompletionDetailsForSymbol(symbol, typeChecker, sourceFile, location, cancellationToken, codeActions, sourceDisplay); // TODO: GH#18217 + } + case "literal": { + var literal = symbolCompletion.literal; + return createSimpleDetails(completionNameForLiteral(sourceFile, preferences, literal), "string" /* ScriptElementKind.string */, typeof literal === "string" ? ts.SymbolDisplayPartKind.stringLiteral : ts.SymbolDisplayPartKind.numericLiteral); + } + case "none": + // Didn't find a symbol with this name. See if we can find a keyword instead. + return allKeywordsCompletions().some(function (c) { return c.name === name; }) ? createSimpleDetails(name, "keyword" /* ScriptElementKind.keyword */, ts.SymbolDisplayPartKind.keyword) : undefined; + default: + ts.Debug.assertNever(symbolCompletion); + } + } + Completions.getCompletionEntryDetails = getCompletionEntryDetails; + function createSimpleDetails(name, kind, kind2) { + return createCompletionDetails(name, "" /* ScriptElementKindModifier.none */, kind, [ts.displayPart(name, kind2)]); + } + function createCompletionDetailsForSymbol(symbol, checker, sourceFile, location, cancellationToken, codeActions, sourceDisplay) { + var _a = checker.runWithCancellationToken(cancellationToken, function (checker) { + return ts.SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(checker, symbol, sourceFile, location, location, 7 /* SemanticMeaning.All */); + }), displayParts = _a.displayParts, documentation = _a.documentation, symbolKind = _a.symbolKind, tags = _a.tags; + return createCompletionDetails(symbol.name, ts.SymbolDisplay.getSymbolModifiers(checker, symbol), symbolKind, displayParts, documentation, tags, codeActions, sourceDisplay); + } + Completions.createCompletionDetailsForSymbol = createCompletionDetailsForSymbol; + function createCompletionDetails(name, kindModifiers, kind, displayParts, documentation, tags, codeActions, source) { + return { name: name, kindModifiers: kindModifiers, kind: kind, displayParts: displayParts, documentation: documentation, tags: tags, codeActions: codeActions, source: source, sourceDisplay: source }; + } + Completions.createCompletionDetails = createCompletionDetails; + function getCompletionEntryCodeActionsAndSourceDisplay(name, location, contextToken, origin, symbol, program, host, compilerOptions, sourceFile, position, previousToken, formatContext, preferences, data, source, cancellationToken) { + if (data === null || data === void 0 ? void 0 : data.moduleSpecifier) { + if (previousToken && getImportStatementCompletionInfo(contextToken || previousToken).replacementSpan) { + // Import statement completion: 'import c|' + return { codeActions: undefined, sourceDisplay: [ts.textPart(data.moduleSpecifier)] }; + } + } + if (source === CompletionSource.ClassMemberSnippet) { + var importAdder = getEntryForMemberCompletion(host, program, compilerOptions, preferences, name, symbol, location, contextToken, formatContext).importAdder; + if (importAdder) { + var changes = ts.textChanges.ChangeTracker.with({ host: host, formatContext: formatContext, preferences: preferences }, importAdder.writeFixes); + return { + sourceDisplay: undefined, + codeActions: [{ + changes: changes, + description: ts.diagnosticToString([ts.Diagnostics.Includes_imports_of_types_referenced_by_0, name]), + }], + }; + } + } + if (originIsTypeOnlyAlias(origin)) { + var codeAction_1 = ts.codefix.getPromoteTypeOnlyCompletionAction(sourceFile, origin.declaration.name, program, host, formatContext, preferences); + ts.Debug.assertIsDefined(codeAction_1, "Expected to have a code action for promoting type-only alias"); + return { codeActions: [codeAction_1], sourceDisplay: undefined }; + } + if (!origin || !(originIsExport(origin) || originIsResolvedExport(origin))) { + return { codeActions: undefined, sourceDisplay: undefined }; + } + var checker = origin.isFromPackageJson ? host.getPackageJsonAutoImportProvider().getTypeChecker() : program.getTypeChecker(); + var moduleSymbol = origin.moduleSymbol; + var targetSymbol = checker.getMergedSymbol(ts.skipAlias(symbol.exportSymbol || symbol, checker)); + var isJsxOpeningTagName = (contextToken === null || contextToken === void 0 ? void 0 : contextToken.kind) === 29 /* SyntaxKind.LessThanToken */ && ts.isJsxOpeningLikeElement(contextToken.parent); + var _a = ts.codefix.getImportCompletionAction(targetSymbol, moduleSymbol, sourceFile, ts.getNameForExportedSymbol(symbol, ts.getEmitScriptTarget(compilerOptions), isJsxOpeningTagName), isJsxOpeningTagName, host, program, formatContext, previousToken && ts.isIdentifier(previousToken) ? previousToken.getStart(sourceFile) : position, preferences, cancellationToken), moduleSpecifier = _a.moduleSpecifier, codeAction = _a.codeAction; + ts.Debug.assert(!(data === null || data === void 0 ? void 0 : data.moduleSpecifier) || moduleSpecifier === data.moduleSpecifier); + return { sourceDisplay: [ts.textPart(moduleSpecifier)], codeActions: [codeAction] }; + } + function getCompletionEntrySymbol(program, log, sourceFile, position, entryId, host, preferences) { + var completion = getSymbolCompletionFromEntryId(program, log, sourceFile, position, entryId, host, preferences); + return completion.type === "symbol" ? completion.symbol : undefined; + } + Completions.getCompletionEntrySymbol = getCompletionEntrySymbol; + var CompletionDataKind; + (function (CompletionDataKind) { + CompletionDataKind[CompletionDataKind["Data"] = 0] = "Data"; + CompletionDataKind[CompletionDataKind["JsDocTagName"] = 1] = "JsDocTagName"; + CompletionDataKind[CompletionDataKind["JsDocTag"] = 2] = "JsDocTag"; + CompletionDataKind[CompletionDataKind["JsDocParameterName"] = 3] = "JsDocParameterName"; + CompletionDataKind[CompletionDataKind["Keywords"] = 4] = "Keywords"; + })(CompletionDataKind || (CompletionDataKind = {})); + var CompletionKind; + (function (CompletionKind) { + CompletionKind[CompletionKind["ObjectPropertyDeclaration"] = 0] = "ObjectPropertyDeclaration"; + CompletionKind[CompletionKind["Global"] = 1] = "Global"; + CompletionKind[CompletionKind["PropertyAccess"] = 2] = "PropertyAccess"; + CompletionKind[CompletionKind["MemberLike"] = 3] = "MemberLike"; + CompletionKind[CompletionKind["String"] = 4] = "String"; + CompletionKind[CompletionKind["None"] = 5] = "None"; + })(CompletionKind = Completions.CompletionKind || (Completions.CompletionKind = {})); + function getRecommendedCompletion(previousToken, contextualType, checker) { + // For a union, return the first one with a recommended completion. + return ts.firstDefined(contextualType && (contextualType.isUnion() ? contextualType.types : [contextualType]), function (type) { + var symbol = type && type.symbol; + // Don't include make a recommended completion for an abstract class + return symbol && (symbol.flags & (8 /* SymbolFlags.EnumMember */ | 384 /* SymbolFlags.Enum */ | 32 /* SymbolFlags.Class */) && !ts.isAbstractConstructorSymbol(symbol)) + ? getFirstSymbolInChain(symbol, previousToken, checker) + : undefined; + }); + } + function getContextualType(previousToken, position, sourceFile, checker) { + var parent = previousToken.parent; + switch (previousToken.kind) { + case 79 /* SyntaxKind.Identifier */: + return ts.getContextualTypeFromParent(previousToken, checker); + case 63 /* SyntaxKind.EqualsToken */: + switch (parent.kind) { + case 257 /* SyntaxKind.VariableDeclaration */: + return checker.getContextualType(parent.initializer); // TODO: GH#18217 + case 223 /* SyntaxKind.BinaryExpression */: + return checker.getTypeAtLocation(parent.left); + case 288 /* SyntaxKind.JsxAttribute */: + return checker.getContextualTypeForJsxAttribute(parent); + default: + return undefined; + } + case 103 /* SyntaxKind.NewKeyword */: + return checker.getContextualType(parent); + case 82 /* SyntaxKind.CaseKeyword */: + var caseClause = ts.tryCast(parent, ts.isCaseClause); + return caseClause ? ts.getSwitchedType(caseClause, checker) : undefined; + case 18 /* SyntaxKind.OpenBraceToken */: + return ts.isJsxExpression(parent) && !ts.isJsxElement(parent.parent) && !ts.isJsxFragment(parent.parent) ? checker.getContextualTypeForJsxAttribute(parent.parent) : undefined; + default: + var argInfo = ts.SignatureHelp.getArgumentInfoForCompletions(previousToken, position, sourceFile); + return argInfo ? + // At `,`, treat this as the next argument after the comma. + checker.getContextualTypeForArgumentAtIndex(argInfo.invocation, argInfo.argumentIndex + (previousToken.kind === 27 /* SyntaxKind.CommaToken */ ? 1 : 0)) : + ts.isEqualityOperatorKind(previousToken.kind) && ts.isBinaryExpression(parent) && ts.isEqualityOperatorKind(parent.operatorToken.kind) ? + // completion at `x ===/**/` should be for the right side + checker.getTypeAtLocation(parent.left) : + checker.getContextualType(previousToken); + } + } + function getFirstSymbolInChain(symbol, enclosingDeclaration, checker) { + var chain = checker.getAccessibleSymbolChain(symbol, enclosingDeclaration, /*meaning*/ 67108863 /* SymbolFlags.All */, /*useOnlyExternalAliasing*/ false); + if (chain) + return ts.first(chain); + return symbol.parent && (isModuleSymbol(symbol.parent) ? symbol : getFirstSymbolInChain(symbol.parent, enclosingDeclaration, checker)); + } + function isModuleSymbol(symbol) { + var _a; + return !!((_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.some(function (d) { return d.kind === 308 /* SyntaxKind.SourceFile */; })); + } + function getCompletionData(program, log, sourceFile, compilerOptions, position, preferences, detailsEntryId, host, formatContext, cancellationToken) { + var typeChecker = program.getTypeChecker(); + var inCheckedFile = isCheckedFile(sourceFile, compilerOptions); + var start = ts.timestamp(); + var currentToken = ts.getTokenAtPosition(sourceFile, position); // TODO: GH#15853 + // We will check for jsdoc comments with insideComment and getJsDocTagAtPosition. (TODO: that seems rather inefficient to check the same thing so many times.) + log("getCompletionData: Get current token: " + (ts.timestamp() - start)); + start = ts.timestamp(); + var insideComment = ts.isInComment(sourceFile, position, currentToken); + log("getCompletionData: Is inside comment: " + (ts.timestamp() - start)); + var insideJsDocTagTypeExpression = false; + var isInSnippetScope = false; + if (insideComment) { + if (ts.hasDocComment(sourceFile, position)) { + if (sourceFile.text.charCodeAt(position - 1) === 64 /* CharacterCodes.at */) { + // The current position is next to the '@' sign, when no tag name being provided yet. + // Provide a full list of tag names + return { kind: 1 /* CompletionDataKind.JsDocTagName */ }; + } + else { + // When completion is requested without "@", we will have check to make sure that + // there are no comments prefix the request position. We will only allow "*" and space. + // e.g + // /** |c| /* + // + // /** + // |c| + // */ + // + // /** + // * |c| + // */ + // + // /** + // * |c| + // */ + var lineStart = ts.getLineStartPositionForPosition(position, sourceFile); + if (!/[^\*|\s(/)]/.test(sourceFile.text.substring(lineStart, position))) { + return { kind: 2 /* CompletionDataKind.JsDocTag */ }; + } + } + } + // Completion should work inside certain JsDoc tags. For example: + // /** @type {number | string} */ + // Completion should work in the brackets + var tag = getJsDocTagAtPosition(currentToken, position); + if (tag) { + if (tag.tagName.pos <= position && position <= tag.tagName.end) { + return { kind: 1 /* CompletionDataKind.JsDocTagName */ }; + } + var typeExpression = tryGetTypeExpressionFromTag(tag); + if (typeExpression) { + currentToken = ts.getTokenAtPosition(sourceFile, position); + if (!currentToken || + (!ts.isDeclarationName(currentToken) && + (currentToken.parent.kind !== 350 /* SyntaxKind.JSDocPropertyTag */ || + currentToken.parent.name !== currentToken))) { + // Use as type location if inside tag's type expression + insideJsDocTagTypeExpression = isCurrentlyEditingNode(typeExpression); + } + } + if (!insideJsDocTagTypeExpression && ts.isJSDocParameterTag(tag) && (ts.nodeIsMissing(tag.name) || tag.name.pos <= position && position <= tag.name.end)) { + return { kind: 3 /* CompletionDataKind.JsDocParameterName */, tag: tag }; + } + } + if (!insideJsDocTagTypeExpression) { + // Proceed if the current position is in jsDoc tag expression; otherwise it is a normal + // comment or the plain text part of a jsDoc comment, so no completion should be available + log("Returning an empty list because completion was inside a regular comment or plain text part of a JsDoc comment."); + return undefined; + } + } + start = ts.timestamp(); + // The decision to provide completion depends on the contextToken, which is determined through the previousToken. + // Note: 'previousToken' (and thus 'contextToken') can be undefined if we are the beginning of the file + var isJsOnlyLocation = !insideJsDocTagTypeExpression && ts.isSourceFileJS(sourceFile); + var tokens = getRelevantTokens(position, sourceFile); + var previousToken = tokens.previousToken; + var contextToken = tokens.contextToken; + log("getCompletionData: Get previous token: " + (ts.timestamp() - start)); + // Find the node where completion is requested on. + // Also determine whether we are trying to complete with members of that node + // or attributes of a JSX tag. + var node = currentToken; + var propertyAccessToConvert; + var isRightOfDot = false; + var isRightOfQuestionDot = false; + var isRightOfOpenTag = false; + var isStartingCloseTag = false; + var isJsxInitializer = false; + var isJsxIdentifierExpected = false; + var importStatementCompletion; + var location = ts.getTouchingPropertyName(sourceFile, position); + var keywordFilters = 0 /* KeywordCompletionFilters.None */; + var isNewIdentifierLocation = false; + var flags = 0 /* CompletionInfoFlags.None */; + if (contextToken) { + var importStatementCompletionInfo = getImportStatementCompletionInfo(contextToken); + if (importStatementCompletionInfo.keywordCompletion) { + if (importStatementCompletionInfo.isKeywordOnlyCompletion) { + return { + kind: 4 /* CompletionDataKind.Keywords */, + keywordCompletions: [keywordToCompletionEntry(importStatementCompletionInfo.keywordCompletion)], + isNewIdentifierLocation: importStatementCompletionInfo.isNewIdentifierLocation, + }; + } + keywordFilters = keywordFiltersFromSyntaxKind(importStatementCompletionInfo.keywordCompletion); + } + if (importStatementCompletionInfo.replacementSpan && preferences.includeCompletionsForImportStatements && preferences.includeCompletionsWithInsertText) { + // Import statement completions use `insertText`, and also require the `data` property of `CompletionEntryIdentifier` + // added in TypeScript 4.3 to be sent back from the client during `getCompletionEntryDetails`. Since this feature + // is not backward compatible with older clients, the language service defaults to disabling it, allowing newer clients + // to opt in with the `includeCompletionsForImportStatements` user preference. + flags |= 2 /* CompletionInfoFlags.IsImportStatementCompletion */; + importStatementCompletion = importStatementCompletionInfo; + isNewIdentifierLocation = importStatementCompletionInfo.isNewIdentifierLocation; + } + // Bail out if this is a known invalid completion location + if (!importStatementCompletionInfo.replacementSpan && isCompletionListBlocker(contextToken)) { + log("Returning an empty list because completion was requested in an invalid position."); + return keywordFilters + ? keywordCompletionData(keywordFilters, isJsOnlyLocation, isNewIdentifierDefinitionLocation()) + : undefined; + } + var parent = contextToken.parent; + if (contextToken.kind === 24 /* SyntaxKind.DotToken */ || contextToken.kind === 28 /* SyntaxKind.QuestionDotToken */) { + isRightOfDot = contextToken.kind === 24 /* SyntaxKind.DotToken */; + isRightOfQuestionDot = contextToken.kind === 28 /* SyntaxKind.QuestionDotToken */; + switch (parent.kind) { + case 208 /* SyntaxKind.PropertyAccessExpression */: + propertyAccessToConvert = parent; + node = propertyAccessToConvert.expression; + var leftmostAccessExpression = ts.getLeftmostAccessExpression(propertyAccessToConvert); + if (ts.nodeIsMissing(leftmostAccessExpression) || + ((ts.isCallExpression(node) || ts.isFunctionLike(node)) && + node.end === contextToken.pos && + node.getChildCount(sourceFile) && + ts.last(node.getChildren(sourceFile)).kind !== 21 /* SyntaxKind.CloseParenToken */)) { + // This is likely dot from incorrectly parsed expression and user is starting to write spread + // eg: Math.min(./**/) + // const x = function (./**/) {} + // ({./**/}) + return undefined; + } + break; + case 163 /* SyntaxKind.QualifiedName */: + node = parent.left; + break; + case 264 /* SyntaxKind.ModuleDeclaration */: + node = parent.name; + break; + case 202 /* SyntaxKind.ImportType */: + node = parent; + break; + case 233 /* SyntaxKind.MetaProperty */: + node = parent.getFirstToken(sourceFile); + ts.Debug.assert(node.kind === 100 /* SyntaxKind.ImportKeyword */ || node.kind === 103 /* SyntaxKind.NewKeyword */); + break; + default: + // There is nothing that precedes the dot, so this likely just a stray character + // or leading into a '...' token. Just bail out instead. + return undefined; + } + } + else if (!importStatementCompletion) { + // + // If the tagname is a property access expression, we will then walk up to the top most of property access expression. + // Then, try to get a JSX container and its associated attributes type. + if (parent && parent.kind === 208 /* SyntaxKind.PropertyAccessExpression */) { + contextToken = parent; + parent = parent.parent; + } + // Fix location + if (currentToken.parent === location) { + switch (currentToken.kind) { + case 31 /* SyntaxKind.GreaterThanToken */: + if (currentToken.parent.kind === 281 /* SyntaxKind.JsxElement */ || currentToken.parent.kind === 283 /* SyntaxKind.JsxOpeningElement */) { + location = currentToken; + } + break; + case 43 /* SyntaxKind.SlashToken */: + if (currentToken.parent.kind === 282 /* SyntaxKind.JsxSelfClosingElement */) { + location = currentToken; + } + break; + } + } + switch (parent.kind) { + case 284 /* SyntaxKind.JsxClosingElement */: + if (contextToken.kind === 43 /* SyntaxKind.SlashToken */) { + isStartingCloseTag = true; + location = contextToken; + } + break; + case 223 /* SyntaxKind.BinaryExpression */: + if (!binaryExpressionMayBeOpenTag(parent)) { + break; + } + // falls through + case 282 /* SyntaxKind.JsxSelfClosingElement */: + case 281 /* SyntaxKind.JsxElement */: + case 283 /* SyntaxKind.JsxOpeningElement */: + isJsxIdentifierExpected = true; + if (contextToken.kind === 29 /* SyntaxKind.LessThanToken */) { + isRightOfOpenTag = true; + location = contextToken; + } + break; + case 291 /* SyntaxKind.JsxExpression */: + case 290 /* SyntaxKind.JsxSpreadAttribute */: + // For `
`, `parent` will be `{true}` and `previousToken` will be `}` + if (previousToken.kind === 19 /* SyntaxKind.CloseBraceToken */ && currentToken.kind === 31 /* SyntaxKind.GreaterThanToken */) { + isJsxIdentifierExpected = true; + } + break; + case 288 /* SyntaxKind.JsxAttribute */: + // For `
`, `parent` will be JsxAttribute and `previousToken` will be its initializer + if (parent.initializer === previousToken && + previousToken.end < position) { + isJsxIdentifierExpected = true; + break; + } + switch (previousToken.kind) { + case 63 /* SyntaxKind.EqualsToken */: + isJsxInitializer = true; + break; + case 79 /* SyntaxKind.Identifier */: + isJsxIdentifierExpected = true; + // For `
` we don't want to treat this as a jsx inializer, instead it's the attribute name. + if (parent !== previousToken.parent && + !parent.initializer && + ts.findChildOfKind(parent, 63 /* SyntaxKind.EqualsToken */, sourceFile)) { + isJsxInitializer = previousToken; + } + } + break; + } + } + } + var semanticStart = ts.timestamp(); + var completionKind = 5 /* CompletionKind.None */; + var isNonContextualObjectLiteral = false; + var hasUnresolvedAutoImports = false; + // This also gets mutated in nested-functions after the return + var symbols = []; + var importSpecifierResolver; + var symbolToOriginInfoMap = []; + var symbolToSortTextMap = []; + var seenPropertySymbols = new ts.Map(); + var isTypeOnlyLocation = isTypeOnlyCompletion(); + var getModuleSpecifierResolutionHost = ts.memoizeOne(function (isFromPackageJson) { + return ts.createModuleSpecifierResolutionHost(isFromPackageJson ? host.getPackageJsonAutoImportProvider() : program, host); + }); + if (isRightOfDot || isRightOfQuestionDot) { + getTypeScriptMemberSymbols(); + } + else if (isRightOfOpenTag) { + symbols = typeChecker.getJsxIntrinsicTagNamesAt(location); + ts.Debug.assertEachIsDefined(symbols, "getJsxIntrinsicTagNames() should all be defined"); + tryGetGlobalSymbols(); + completionKind = 1 /* CompletionKind.Global */; + keywordFilters = 0 /* KeywordCompletionFilters.None */; + } + else if (isStartingCloseTag) { + var tagName = contextToken.parent.parent.openingElement.tagName; + var tagSymbol = typeChecker.getSymbolAtLocation(tagName); + if (tagSymbol) { + symbols = [tagSymbol]; + } + completionKind = 1 /* CompletionKind.Global */; + keywordFilters = 0 /* KeywordCompletionFilters.None */; + } + else { + // For JavaScript or TypeScript, if we're not after a dot, then just try to get the + // global symbols in scope. These results should be valid for either language as + // the set of symbols that can be referenced from this location. + if (!tryGetGlobalSymbols()) { + return keywordFilters + ? keywordCompletionData(keywordFilters, isJsOnlyLocation, isNewIdentifierLocation) + : undefined; + } + } + log("getCompletionData: Semantic work: " + (ts.timestamp() - semanticStart)); + var contextualType = previousToken && getContextualType(previousToken, position, sourceFile, typeChecker); + var literals = ts.mapDefined(contextualType && (contextualType.isUnion() ? contextualType.types : [contextualType]), function (t) { return t.isLiteral() && !(t.flags & 1024 /* TypeFlags.EnumLiteral */) ? t.value : undefined; }); + var recommendedCompletion = previousToken && contextualType && getRecommendedCompletion(previousToken, contextualType, typeChecker); + return { + kind: 0 /* CompletionDataKind.Data */, + symbols: symbols, + completionKind: completionKind, + isInSnippetScope: isInSnippetScope, + propertyAccessToConvert: propertyAccessToConvert, + isNewIdentifierLocation: isNewIdentifierLocation, + location: location, + keywordFilters: keywordFilters, + literals: literals, + symbolToOriginInfoMap: symbolToOriginInfoMap, + recommendedCompletion: recommendedCompletion, + previousToken: previousToken, + contextToken: contextToken, + isJsxInitializer: isJsxInitializer, + insideJsDocTagTypeExpression: insideJsDocTagTypeExpression, + symbolToSortTextMap: symbolToSortTextMap, + isTypeOnlyLocation: isTypeOnlyLocation, + isJsxIdentifierExpected: isJsxIdentifierExpected, + isRightOfOpenTag: isRightOfOpenTag, + importStatementCompletion: importStatementCompletion, + hasUnresolvedAutoImports: hasUnresolvedAutoImports, + flags: flags, + }; + function isTagWithTypeExpression(tag) { + switch (tag.kind) { + case 343 /* SyntaxKind.JSDocParameterTag */: + case 350 /* SyntaxKind.JSDocPropertyTag */: + case 344 /* SyntaxKind.JSDocReturnTag */: + case 346 /* SyntaxKind.JSDocTypeTag */: + case 348 /* SyntaxKind.JSDocTypedefTag */: + return true; + case 347 /* SyntaxKind.JSDocTemplateTag */: + return !!tag.constraint; + default: + return false; + } + } + function tryGetTypeExpressionFromTag(tag) { + if (isTagWithTypeExpression(tag)) { + var typeExpression = ts.isJSDocTemplateTag(tag) ? tag.constraint : tag.typeExpression; + return typeExpression && typeExpression.kind === 312 /* SyntaxKind.JSDocTypeExpression */ ? typeExpression : undefined; + } + return undefined; + } + function getTypeScriptMemberSymbols() { + // Right of dot member completion list + completionKind = 2 /* CompletionKind.PropertyAccess */; + // Since this is qualified name check it's a type node location + var isImportType = ts.isLiteralImportTypeNode(node); + var isTypeLocation = insideJsDocTagTypeExpression + || (isImportType && !node.isTypeOf) + || ts.isPartOfTypeNode(node.parent) + || ts.isPossiblyTypeArgumentPosition(contextToken, sourceFile, typeChecker); + var isRhsOfImportDeclaration = ts.isInRightSideOfInternalImportEqualsDeclaration(node); + if (ts.isEntityName(node) || isImportType || ts.isPropertyAccessExpression(node)) { + var isNamespaceName = ts.isModuleDeclaration(node.parent); + if (isNamespaceName) + isNewIdentifierLocation = true; + var symbol = typeChecker.getSymbolAtLocation(node); + if (symbol) { + symbol = ts.skipAlias(symbol, typeChecker); + if (symbol.flags & (1536 /* SymbolFlags.Module */ | 384 /* SymbolFlags.Enum */)) { + // Extract module or enum members + var exportedSymbols = typeChecker.getExportsOfModule(symbol); + ts.Debug.assertEachIsDefined(exportedSymbols, "getExportsOfModule() should all be defined"); + var isValidValueAccess_1 = function (symbol) { return typeChecker.isValidPropertyAccess(isImportType ? node : node.parent, symbol.name); }; + var isValidTypeAccess_1 = function (symbol) { return symbolCanBeReferencedAtTypeLocation(symbol, typeChecker); }; + var isValidAccess = isNamespaceName + // At `namespace N.M/**/`, if this is the only declaration of `M`, don't include `M` as a completion. + ? function (symbol) { var _a; return !!(symbol.flags & 1920 /* SymbolFlags.Namespace */) && !((_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.every(function (d) { return d.parent === node.parent; })); } + : isRhsOfImportDeclaration ? + // Any kind is allowed when dotting off namespace in internal import equals declaration + function (symbol) { return isValidTypeAccess_1(symbol) || isValidValueAccess_1(symbol); } : + isTypeLocation ? isValidTypeAccess_1 : isValidValueAccess_1; + for (var _i = 0, exportedSymbols_1 = exportedSymbols; _i < exportedSymbols_1.length; _i++) { + var exportedSymbol = exportedSymbols_1[_i]; + if (isValidAccess(exportedSymbol)) { + symbols.push(exportedSymbol); + } + } + // If the module is merged with a value, we must get the type of the class and add its propertes (for inherited static methods). + if (!isTypeLocation && + symbol.declarations && + symbol.declarations.some(function (d) { return d.kind !== 308 /* SyntaxKind.SourceFile */ && d.kind !== 264 /* SyntaxKind.ModuleDeclaration */ && d.kind !== 263 /* SyntaxKind.EnumDeclaration */; })) { + var type = typeChecker.getTypeOfSymbolAtLocation(symbol, node).getNonOptionalType(); + var insertQuestionDot = false; + if (type.isNullableType()) { + var canCorrectToQuestionDot = isRightOfDot && + !isRightOfQuestionDot && + preferences.includeAutomaticOptionalChainCompletions !== false; + if (canCorrectToQuestionDot || isRightOfQuestionDot) { + type = type.getNonNullableType(); + if (canCorrectToQuestionDot) { + insertQuestionDot = true; + } + } + } + addTypeProperties(type, !!(node.flags & 32768 /* NodeFlags.AwaitContext */), insertQuestionDot); + } + return; + } + } + } + if (!isTypeLocation) { + // GH#39946. Pulling on the type of a node inside of a function with a contextual `this` parameter can result in a circularity + // if the `node` is part of the exprssion of a `yield` or `return`. This circularity doesn't exist at compile time because + // we will check (and cache) the type of `this` *before* checking the type of the node. + typeChecker.tryGetThisTypeAt(node, /*includeGlobalThis*/ false); + var type = typeChecker.getTypeAtLocation(node).getNonOptionalType(); + var insertQuestionDot = false; + if (type.isNullableType()) { + var canCorrectToQuestionDot = isRightOfDot && + !isRightOfQuestionDot && + preferences.includeAutomaticOptionalChainCompletions !== false; + if (canCorrectToQuestionDot || isRightOfQuestionDot) { + type = type.getNonNullableType(); + if (canCorrectToQuestionDot) { + insertQuestionDot = true; + } + } + } + addTypeProperties(type, !!(node.flags & 32768 /* NodeFlags.AwaitContext */), insertQuestionDot); + } + } + function addTypeProperties(type, insertAwait, insertQuestionDot) { + isNewIdentifierLocation = !!type.getStringIndexType(); + if (isRightOfQuestionDot && ts.some(type.getCallSignatures())) { + isNewIdentifierLocation = true; + } + var propertyAccess = node.kind === 202 /* SyntaxKind.ImportType */ ? node : node.parent; + if (inCheckedFile) { + for (var _i = 0, _a = type.getApparentProperties(); _i < _a.length; _i++) { + var symbol = _a[_i]; + if (typeChecker.isValidPropertyAccessForCompletions(propertyAccess, type, symbol)) { + addPropertySymbol(symbol, /* insertAwait */ false, insertQuestionDot); + } + } + } + else { + // In javascript files, for union types, we don't just get the members that + // the individual types have in common, we also include all the members that + // each individual type has. This is because we're going to add all identifiers + // anyways. So we might as well elevate the members that were at least part + // of the individual types to a higher status since we know what they are. + symbols.push.apply(symbols, ts.filter(getPropertiesForCompletion(type, typeChecker), function (s) { return typeChecker.isValidPropertyAccessForCompletions(propertyAccess, type, s); })); + } + if (insertAwait && preferences.includeCompletionsWithInsertText) { + var promiseType = typeChecker.getPromisedTypeOfPromise(type); + if (promiseType) { + for (var _b = 0, _c = promiseType.getApparentProperties(); _b < _c.length; _b++) { + var symbol = _c[_b]; + if (typeChecker.isValidPropertyAccessForCompletions(propertyAccess, promiseType, symbol)) { + addPropertySymbol(symbol, /* insertAwait */ true, insertQuestionDot); + } + } + } + } + } + function addPropertySymbol(symbol, insertAwait, insertQuestionDot) { + var _a; + // For a computed property with an accessible name like `Symbol.iterator`, + // we'll add a completion for the *name* `Symbol` instead of for the property. + // If this is e.g. [Symbol.iterator], add a completion for `Symbol`. + var computedPropertyName = ts.firstDefined(symbol.declarations, function (decl) { return ts.tryCast(ts.getNameOfDeclaration(decl), ts.isComputedPropertyName); }); + if (computedPropertyName) { + var leftMostName = getLeftMostName(computedPropertyName.expression); // The completion is for `Symbol`, not `iterator`. + var nameSymbol = leftMostName && typeChecker.getSymbolAtLocation(leftMostName); + // If this is nested like for `namespace N { export const sym = Symbol(); }`, we'll add the completion for `N`. + var firstAccessibleSymbol = nameSymbol && getFirstSymbolInChain(nameSymbol, contextToken, typeChecker); + if (firstAccessibleSymbol && ts.addToSeen(seenPropertySymbols, ts.getSymbolId(firstAccessibleSymbol))) { + var index = symbols.length; + symbols.push(firstAccessibleSymbol); + var moduleSymbol = firstAccessibleSymbol.parent; + if (!moduleSymbol || + !ts.isExternalModuleSymbol(moduleSymbol) || + typeChecker.tryGetMemberInModuleExportsAndProperties(firstAccessibleSymbol.name, moduleSymbol) !== firstAccessibleSymbol) { + symbolToOriginInfoMap[index] = { kind: getNullableSymbolOriginInfoKind(2 /* SymbolOriginInfoKind.SymbolMemberNoExport */) }; + } + else { + var fileName = ts.isExternalModuleNameRelative(ts.stripQuotes(moduleSymbol.name)) ? (_a = ts.getSourceFileOfModule(moduleSymbol)) === null || _a === void 0 ? void 0 : _a.fileName : undefined; + var moduleSpecifier = ((importSpecifierResolver || (importSpecifierResolver = ts.codefix.createImportSpecifierResolver(sourceFile, program, host, preferences))).getModuleSpecifierForBestExportInfo([{ + exportKind: 0 /* ExportKind.Named */, + moduleFileName: fileName, + isFromPackageJson: false, + moduleSymbol: moduleSymbol, + symbol: firstAccessibleSymbol, + targetFlags: ts.skipAlias(firstAccessibleSymbol, typeChecker).flags, + }], firstAccessibleSymbol.name, position, ts.isValidTypeOnlyAliasUseSite(location)) || {}).moduleSpecifier; + if (moduleSpecifier) { + var origin = { + kind: getNullableSymbolOriginInfoKind(6 /* SymbolOriginInfoKind.SymbolMemberExport */), + moduleSymbol: moduleSymbol, + isDefaultExport: false, + symbolName: firstAccessibleSymbol.name, + exportName: firstAccessibleSymbol.name, + fileName: fileName, + moduleSpecifier: moduleSpecifier, + }; + symbolToOriginInfoMap[index] = origin; + } + } + } + else if (preferences.includeCompletionsWithInsertText) { + addSymbolOriginInfo(symbol); + addSymbolSortInfo(symbol); + symbols.push(symbol); + } + } + else { + addSymbolOriginInfo(symbol); + addSymbolSortInfo(symbol); + symbols.push(symbol); + } + function addSymbolSortInfo(symbol) { + if (isStaticProperty(symbol)) { + symbolToSortTextMap[ts.getSymbolId(symbol)] = Completions.SortText.LocalDeclarationPriority; + } + } + function addSymbolOriginInfo(symbol) { + if (preferences.includeCompletionsWithInsertText) { + if (insertAwait && ts.addToSeen(seenPropertySymbols, ts.getSymbolId(symbol))) { + symbolToOriginInfoMap[symbols.length] = { kind: getNullableSymbolOriginInfoKind(8 /* SymbolOriginInfoKind.Promise */) }; + } + else if (insertQuestionDot) { + symbolToOriginInfoMap[symbols.length] = { kind: 16 /* SymbolOriginInfoKind.Nullable */ }; + } + } + } + function getNullableSymbolOriginInfoKind(kind) { + return insertQuestionDot ? kind | 16 /* SymbolOriginInfoKind.Nullable */ : kind; + } + } + /** Given 'a.b.c', returns 'a'. */ + function getLeftMostName(e) { + return ts.isIdentifier(e) ? e : ts.isPropertyAccessExpression(e) ? getLeftMostName(e.expression) : undefined; + } + function tryGetGlobalSymbols() { + var result = tryGetObjectTypeLiteralInTypeArgumentCompletionSymbols() + || tryGetObjectLikeCompletionSymbols() + || tryGetImportCompletionSymbols() + || tryGetImportOrExportClauseCompletionSymbols() + || tryGetLocalNamedExportCompletionSymbols() + || tryGetConstructorCompletion() + || tryGetClassLikeCompletionSymbols() + || tryGetJsxCompletionSymbols() + || (getGlobalCompletions(), 1 /* GlobalsSearch.Success */); + return result === 1 /* GlobalsSearch.Success */; + } + function tryGetConstructorCompletion() { + if (!tryGetConstructorLikeCompletionContainer(contextToken)) + return 0 /* GlobalsSearch.Continue */; + // no members, only keywords + completionKind = 5 /* CompletionKind.None */; + // Declaring new property/method/accessor + isNewIdentifierLocation = true; + // Has keywords for constructor parameter + keywordFilters = 4 /* KeywordCompletionFilters.ConstructorParameterKeywords */; + return 1 /* GlobalsSearch.Success */; + } + function tryGetJsxCompletionSymbols() { + var jsxContainer = tryGetContainingJsxElement(contextToken); + // Cursor is inside a JSX self-closing element or opening element + var attrsType = jsxContainer && typeChecker.getContextualType(jsxContainer.attributes); + if (!attrsType) + return 0 /* GlobalsSearch.Continue */; + var completionsType = jsxContainer && typeChecker.getContextualType(jsxContainer.attributes, 4 /* ContextFlags.Completions */); + symbols = ts.concatenate(symbols, filterJsxAttributes(getPropertiesForObjectExpression(attrsType, completionsType, jsxContainer.attributes, typeChecker), jsxContainer.attributes.properties)); + setSortTextToOptionalMember(); + completionKind = 3 /* CompletionKind.MemberLike */; + isNewIdentifierLocation = false; + return 1 /* GlobalsSearch.Success */; + } + function tryGetImportCompletionSymbols() { + if (!importStatementCompletion) + return 0 /* GlobalsSearch.Continue */; + isNewIdentifierLocation = true; + collectAutoImports(); + return 1 /* GlobalsSearch.Success */; + } + function getGlobalCompletions() { + keywordFilters = tryGetFunctionLikeBodyCompletionContainer(contextToken) ? 5 /* KeywordCompletionFilters.FunctionLikeBodyKeywords */ : 1 /* KeywordCompletionFilters.All */; + // Get all entities in the current scope. + completionKind = 1 /* CompletionKind.Global */; + isNewIdentifierLocation = isNewIdentifierDefinitionLocation(); + if (previousToken !== contextToken) { + ts.Debug.assert(!!previousToken, "Expected 'contextToken' to be defined when different from 'previousToken'."); + } + // We need to find the node that will give us an appropriate scope to begin + // aggregating completion candidates. This is achieved in 'getScopeNode' + // by finding the first node that encompasses a position, accounting for whether a node + // is "complete" to decide whether a position belongs to the node. + // + // However, at the end of an identifier, we are interested in the scope of the identifier + // itself, but fall outside of the identifier. For instance: + // + // xyz => x$ + // + // the cursor is outside of both the 'x' and the arrow function 'xyz => x', + // so 'xyz' is not returned in our results. + // + // We define 'adjustedPosition' so that we may appropriately account for + // being at the end of an identifier. The intention is that if requesting completion + // at the end of an identifier, it should be effectively equivalent to requesting completion + // anywhere inside/at the beginning of the identifier. So in the previous case, the + // 'adjustedPosition' will work as if requesting completion in the following: + // + // xyz => $x + // + // If previousToken !== contextToken, then + // - 'contextToken' was adjusted to the token prior to 'previousToken' + // because we were at the end of an identifier. + // - 'previousToken' is defined. + var adjustedPosition = previousToken !== contextToken ? + previousToken.getStart() : + position; + var scopeNode = getScopeNode(contextToken, adjustedPosition, sourceFile) || sourceFile; + isInSnippetScope = isSnippetScope(scopeNode); + var symbolMeanings = (isTypeOnlyLocation ? 0 /* SymbolFlags.None */ : 111551 /* SymbolFlags.Value */) | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */ | 2097152 /* SymbolFlags.Alias */; + var typeOnlyAliasNeedsPromotion = previousToken && !ts.isValidTypeOnlyAliasUseSite(previousToken); + symbols = ts.concatenate(symbols, typeChecker.getSymbolsInScope(scopeNode, symbolMeanings)); + ts.Debug.assertEachIsDefined(symbols, "getSymbolsInScope() should all be defined"); + for (var i = 0; i < symbols.length; i++) { + var symbol = symbols[i]; + if (!typeChecker.isArgumentsSymbol(symbol) && + !ts.some(symbol.declarations, function (d) { return d.getSourceFile() === sourceFile; })) { + symbolToSortTextMap[ts.getSymbolId(symbol)] = Completions.SortText.GlobalsOrKeywords; + } + if (typeOnlyAliasNeedsPromotion && !(symbol.flags & 111551 /* SymbolFlags.Value */)) { + var typeOnlyAliasDeclaration = symbol.declarations && ts.find(symbol.declarations, ts.isTypeOnlyImportOrExportDeclaration); + if (typeOnlyAliasDeclaration) { + var origin = { kind: 64 /* SymbolOriginInfoKind.TypeOnlyAlias */, declaration: typeOnlyAliasDeclaration }; + symbolToOriginInfoMap[i] = origin; + } + } + } + // Need to insert 'this.' before properties of `this` type, so only do that if `includeInsertTextCompletions` + if (preferences.includeCompletionsWithInsertText && scopeNode.kind !== 308 /* SyntaxKind.SourceFile */) { + var thisType = typeChecker.tryGetThisTypeAt(scopeNode, /*includeGlobalThis*/ false, ts.isClassLike(scopeNode.parent) ? scopeNode : undefined); + if (thisType && !isProbablyGlobalType(thisType, sourceFile, typeChecker)) { + for (var _i = 0, _a = getPropertiesForCompletion(thisType, typeChecker); _i < _a.length; _i++) { + var symbol = _a[_i]; + symbolToOriginInfoMap[symbols.length] = { kind: 1 /* SymbolOriginInfoKind.ThisType */ }; + symbols.push(symbol); + symbolToSortTextMap[ts.getSymbolId(symbol)] = Completions.SortText.SuggestedClassMembers; + } + } + } + collectAutoImports(); + if (isTypeOnlyLocation) { + keywordFilters = contextToken && ts.isAssertionExpression(contextToken.parent) + ? 6 /* KeywordCompletionFilters.TypeAssertionKeywords */ + : 7 /* KeywordCompletionFilters.TypeKeywords */; + } + } + function shouldOfferImportCompletions() { + // If already typing an import statement, provide completions for it. + if (importStatementCompletion) + return true; + // If current completion is for non-contextual Object literal shortahands, ignore auto-import symbols + if (isNonContextualObjectLiteral) + return false; + // If not already a module, must have modules enabled. + if (!preferences.includeCompletionsForModuleExports) + return false; + // If already using ES modules, OK to continue using them. + if (sourceFile.externalModuleIndicator || sourceFile.commonJsModuleIndicator) + return true; + // If module transpilation is enabled or we're targeting es6 or above, or not emitting, OK. + if (ts.compilerOptionsIndicateEsModules(program.getCompilerOptions())) + return true; + // If some file is using ES6 modules, assume that it's OK to add more. + return ts.programContainsModules(program); + } + function isSnippetScope(scopeNode) { + switch (scopeNode.kind) { + case 308 /* SyntaxKind.SourceFile */: + case 225 /* SyntaxKind.TemplateExpression */: + case 291 /* SyntaxKind.JsxExpression */: + case 238 /* SyntaxKind.Block */: + return true; + default: + return ts.isStatement(scopeNode); + } + } + function isTypeOnlyCompletion() { + return insideJsDocTagTypeExpression + || !!importStatementCompletion && ts.isTypeOnlyImportOrExportDeclaration(location.parent) + || !isContextTokenValueLocation(contextToken) && + (ts.isPossiblyTypeArgumentPosition(contextToken, sourceFile, typeChecker) + || ts.isPartOfTypeNode(location) + || isContextTokenTypeLocation(contextToken)); + } + function isContextTokenValueLocation(contextToken) { + return contextToken && + ((contextToken.kind === 112 /* SyntaxKind.TypeOfKeyword */ && + (contextToken.parent.kind === 183 /* SyntaxKind.TypeQuery */ || ts.isTypeOfExpression(contextToken.parent))) || + (contextToken.kind === 129 /* SyntaxKind.AssertsKeyword */ && contextToken.parent.kind === 179 /* SyntaxKind.TypePredicate */)); + } + function isContextTokenTypeLocation(contextToken) { + if (contextToken) { + var parentKind = contextToken.parent.kind; + switch (contextToken.kind) { + case 58 /* SyntaxKind.ColonToken */: + return parentKind === 169 /* SyntaxKind.PropertyDeclaration */ || + parentKind === 168 /* SyntaxKind.PropertySignature */ || + parentKind === 166 /* SyntaxKind.Parameter */ || + parentKind === 257 /* SyntaxKind.VariableDeclaration */ || + ts.isFunctionLikeKind(parentKind); + case 63 /* SyntaxKind.EqualsToken */: + return parentKind === 262 /* SyntaxKind.TypeAliasDeclaration */; + case 128 /* SyntaxKind.AsKeyword */: + return parentKind === 231 /* SyntaxKind.AsExpression */; + case 29 /* SyntaxKind.LessThanToken */: + return parentKind === 180 /* SyntaxKind.TypeReference */ || + parentKind === 213 /* SyntaxKind.TypeAssertionExpression */; + case 94 /* SyntaxKind.ExtendsKeyword */: + return parentKind === 165 /* SyntaxKind.TypeParameter */; + case 150 /* SyntaxKind.SatisfiesKeyword */: + return parentKind === 235 /* SyntaxKind.SatisfiesExpression */; + } + } + return false; + } + /** Mutates `symbols`, `symbolToOriginInfoMap`, and `symbolToSortTextMap` */ + function collectAutoImports() { + var _a, _b; + if (!shouldOfferImportCompletions()) + return; + ts.Debug.assert(!(detailsEntryId === null || detailsEntryId === void 0 ? void 0 : detailsEntryId.data), "Should not run 'collectAutoImports' when faster path is available via `data`"); + if (detailsEntryId && !detailsEntryId.source) { + // Asking for completion details for an item that is not an auto-import + return; + } + flags |= 1 /* CompletionInfoFlags.MayIncludeAutoImports */; + // import { type | -> token text should be blank + var isAfterTypeOnlyImportSpecifierModifier = previousToken === contextToken + && importStatementCompletion; + var lowerCaseTokenText = isAfterTypeOnlyImportSpecifierModifier ? "" : + previousToken && ts.isIdentifier(previousToken) ? previousToken.text.toLowerCase() : + ""; + var moduleSpecifierCache = (_a = host.getModuleSpecifierCache) === null || _a === void 0 ? void 0 : _a.call(host); + var exportInfo = ts.getExportInfoMap(sourceFile, host, program, preferences, cancellationToken); + var packageJsonAutoImportProvider = (_b = host.getPackageJsonAutoImportProvider) === null || _b === void 0 ? void 0 : _b.call(host); + var packageJsonFilter = detailsEntryId ? undefined : ts.createPackageJsonImportFilter(sourceFile, preferences, host); + resolvingModuleSpecifiers("collectAutoImports", host, importSpecifierResolver || (importSpecifierResolver = ts.codefix.createImportSpecifierResolver(sourceFile, program, host, preferences)), program, position, preferences, !!importStatementCompletion, ts.isValidTypeOnlyAliasUseSite(location), function (context) { + exportInfo.search(sourceFile.path, + /*preferCapitalized*/ isRightOfOpenTag, function (symbolName, targetFlags) { + if (!ts.isIdentifierText(symbolName, ts.getEmitScriptTarget(host.getCompilationSettings()))) + return false; + if (!detailsEntryId && ts.isStringANonContextualKeyword(symbolName)) + return false; + if (!isTypeOnlyLocation && !importStatementCompletion && !(targetFlags & 111551 /* SymbolFlags.Value */)) + return false; + if (isTypeOnlyLocation && !(targetFlags & (1536 /* SymbolFlags.Module */ | 788968 /* SymbolFlags.Type */))) + return false; + // Do not try to auto-import something with a lowercase first letter for a JSX tag + var firstChar = symbolName.charCodeAt(0); + if (isRightOfOpenTag && (firstChar < 65 /* CharacterCodes.A */ || firstChar > 90 /* CharacterCodes.Z */)) + return false; + if (detailsEntryId) + return true; + return charactersFuzzyMatchInString(symbolName, lowerCaseTokenText); + }, function (info, symbolName, isFromAmbientModule, exportMapKey) { + var _a; + if (detailsEntryId && !ts.some(info, function (i) { return detailsEntryId.source === ts.stripQuotes(i.moduleSymbol.name); })) { + return; + } + // Do a relatively cheap check to bail early if all re-exports are non-importable + // due to file location or package.json dependency filtering. For non-node16+ + // module resolution modes, getting past this point guarantees that we'll be + // able to generate a suitable module specifier, so we can safely show a completion, + // even if we defer computing the module specifier. + var firstImportableExportInfo = ts.find(info, isImportableExportInfo); + if (!firstImportableExportInfo) { + return; + } + // In node16+, module specifier resolution can fail due to modules being blocked + // by package.json `exports`. If that happens, don't show a completion item. + // N.B. in this resolution mode we always try to resolve module specifiers here, + // because we have to know now if it's going to fail so we can omit the completion + // from the list. + var result = context.tryResolve(info, symbolName, isFromAmbientModule) || {}; + if (result === "failed") + return; + // If we skipped resolving module specifiers, our selection of which ExportInfo + // to use here is arbitrary, since the info shown in the completion list derived from + // it should be identical regardless of which one is used. During the subsequent + // `CompletionEntryDetails` request, we'll get all the ExportInfos again and pick + // the best one based on the module specifier it produces. + var exportInfo = firstImportableExportInfo, moduleSpecifier; + if (result !== "skipped") { + (_a = result.exportInfo, exportInfo = _a === void 0 ? firstImportableExportInfo : _a, moduleSpecifier = result.moduleSpecifier); + } + var isDefaultExport = exportInfo.exportKind === 1 /* ExportKind.Default */; + var symbol = isDefaultExport && ts.getLocalSymbolForExportDefault(exportInfo.symbol) || exportInfo.symbol; + pushAutoImportSymbol(symbol, { + kind: moduleSpecifier ? 32 /* SymbolOriginInfoKind.ResolvedExport */ : 4 /* SymbolOriginInfoKind.Export */, + moduleSpecifier: moduleSpecifier, + symbolName: symbolName, + exportMapKey: exportMapKey, + exportName: exportInfo.exportKind === 2 /* ExportKind.ExportEquals */ ? "export=" /* InternalSymbolName.ExportEquals */ : exportInfo.symbol.name, + fileName: exportInfo.moduleFileName, + isDefaultExport: isDefaultExport, + moduleSymbol: exportInfo.moduleSymbol, + isFromPackageJson: exportInfo.isFromPackageJson, + }); + }); + hasUnresolvedAutoImports = context.skippedAny(); + flags |= context.resolvedAny() ? 8 /* CompletionInfoFlags.ResolvedModuleSpecifiers */ : 0; + flags |= context.resolvedBeyondLimit() ? 16 /* CompletionInfoFlags.ResolvedModuleSpecifiersBeyondLimit */ : 0; + }); + function isImportableExportInfo(info) { + var moduleFile = ts.tryCast(info.moduleSymbol.valueDeclaration, ts.isSourceFile); + if (!moduleFile) { + var moduleName = ts.stripQuotes(info.moduleSymbol.name); + if (ts.JsTyping.nodeCoreModules.has(moduleName) && ts.startsWith(moduleName, "node:") !== ts.shouldUseUriStyleNodeCoreModules(sourceFile, program)) { + return false; + } + return packageJsonFilter + ? packageJsonFilter.allowsImportingAmbientModule(info.moduleSymbol, getModuleSpecifierResolutionHost(info.isFromPackageJson)) + : true; + } + return ts.isImportableFile(info.isFromPackageJson ? packageJsonAutoImportProvider : program, sourceFile, moduleFile, preferences, packageJsonFilter, getModuleSpecifierResolutionHost(info.isFromPackageJson), moduleSpecifierCache); + } + } + function pushAutoImportSymbol(symbol, origin) { + var symbolId = ts.getSymbolId(symbol); + if (symbolToSortTextMap[symbolId] === Completions.SortText.GlobalsOrKeywords) { + // If an auto-importable symbol is available as a global, don't add the auto import + return; + } + symbolToOriginInfoMap[symbols.length] = origin; + symbolToSortTextMap[symbolId] = importStatementCompletion ? Completions.SortText.LocationPriority : Completions.SortText.AutoImportSuggestions; + symbols.push(symbol); + } + /* Mutates `symbols` and `symbolToOriginInfoMap`. */ + function collectObjectLiteralMethodSymbols(members, enclosingDeclaration) { + // TODO: support JS files. + if (ts.isInJSFile(location)) { + return; + } + members.forEach(function (member) { + if (!isObjectLiteralMethodSymbol(member)) { + return; + } + var displayName = getCompletionEntryDisplayNameForSymbol(member, ts.getEmitScriptTarget(compilerOptions), + /*origin*/ undefined, 0 /* CompletionKind.ObjectPropertyDeclaration */, + /*jsxIdentifierExpected*/ false); + if (!displayName) { + return; + } + var name = displayName.name; + var entryProps = getEntryForObjectLiteralMethodCompletion(member, name, enclosingDeclaration, program, host, compilerOptions, preferences, formatContext); + if (!entryProps) { + return; + } + var origin = __assign({ kind: 128 /* SymbolOriginInfoKind.ObjectLiteralMethod */ }, entryProps); + flags |= 32 /* CompletionInfoFlags.MayIncludeMethodSnippets */; + symbolToOriginInfoMap[symbols.length] = origin; + symbols.push(member); + }); + } + function isObjectLiteralMethodSymbol(symbol) { + /* + For an object type + `type Foo = { + bar(x: number): void; + foo: (x: string) => string; + }`, + `bar` will have symbol flag `Method`, + `foo` will have symbol flag `Property`. + */ + if (!(symbol.flags & (4 /* SymbolFlags.Property */ | 8192 /* SymbolFlags.Method */))) { + return false; + } + return true; + } + /** + * Finds the first node that "embraces" the position, so that one may + * accurately aggregate locals from the closest containing scope. + */ + function getScopeNode(initialToken, position, sourceFile) { + var scope = initialToken; + while (scope && !ts.positionBelongsToNode(scope, position, sourceFile)) { + scope = scope.parent; + } + return scope; + } + function isCompletionListBlocker(contextToken) { + var start = ts.timestamp(); + var result = isInStringOrRegularExpressionOrTemplateLiteral(contextToken) || + isSolelyIdentifierDefinitionLocation(contextToken) || + isDotOfNumericLiteral(contextToken) || + isInJsxText(contextToken) || + ts.isBigIntLiteral(contextToken); + log("getCompletionsAtPosition: isCompletionListBlocker: " + (ts.timestamp() - start)); + return result; + } + function isInJsxText(contextToken) { + if (contextToken.kind === 11 /* SyntaxKind.JsxText */) { + return true; + } + if (contextToken.kind === 31 /* SyntaxKind.GreaterThanToken */ && contextToken.parent) { + // /**/ /> + // /**/ > + // - contextToken: GreaterThanToken (before cursor) + // - location: JsxSelfClosingElement or JsxOpeningElement + // - contextToken.parent === location + if (location === contextToken.parent && (location.kind === 283 /* SyntaxKind.JsxOpeningElement */ || location.kind === 282 /* SyntaxKind.JsxSelfClosingElement */)) { + return false; + } + if (contextToken.parent.kind === 283 /* SyntaxKind.JsxOpeningElement */) { + //
/**/ + // - contextToken: GreaterThanToken (before cursor) + // - location: JSXElement + // - different parents (JSXOpeningElement, JSXElement) + return location.parent.kind !== 283 /* SyntaxKind.JsxOpeningElement */; + } + if (contextToken.parent.kind === 284 /* SyntaxKind.JsxClosingElement */ || contextToken.parent.kind === 282 /* SyntaxKind.JsxSelfClosingElement */) { + return !!contextToken.parent.parent && contextToken.parent.parent.kind === 281 /* SyntaxKind.JsxElement */; + } + } + return false; + } + function isNewIdentifierDefinitionLocation() { + if (contextToken) { + var containingNodeKind = contextToken.parent.kind; + var tokenKind = keywordForNode(contextToken); + // Previous token may have been a keyword that was converted to an identifier. + switch (tokenKind) { + case 27 /* SyntaxKind.CommaToken */: + return containingNodeKind === 210 /* SyntaxKind.CallExpression */ // func( a, | + || containingNodeKind === 173 /* SyntaxKind.Constructor */ // constructor( a, | /* public, protected, private keywords are allowed here, so show completion */ + || containingNodeKind === 211 /* SyntaxKind.NewExpression */ // new C(a, | + || containingNodeKind === 206 /* SyntaxKind.ArrayLiteralExpression */ // [a, | + || containingNodeKind === 223 /* SyntaxKind.BinaryExpression */ // const x = (a, | + || containingNodeKind === 181 /* SyntaxKind.FunctionType */ // var x: (s: string, list| + || containingNodeKind === 207 /* SyntaxKind.ObjectLiteralExpression */; // const obj = { x, | + case 20 /* SyntaxKind.OpenParenToken */: + return containingNodeKind === 210 /* SyntaxKind.CallExpression */ // func( | + || containingNodeKind === 173 /* SyntaxKind.Constructor */ // constructor( | + || containingNodeKind === 211 /* SyntaxKind.NewExpression */ // new C(a| + || containingNodeKind === 214 /* SyntaxKind.ParenthesizedExpression */ // const x = (a| + || containingNodeKind === 193 /* SyntaxKind.ParenthesizedType */; // function F(pred: (a| /* this can become an arrow function, where 'a' is the argument */ + case 22 /* SyntaxKind.OpenBracketToken */: + return containingNodeKind === 206 /* SyntaxKind.ArrayLiteralExpression */ // [ | + || containingNodeKind === 178 /* SyntaxKind.IndexSignature */ // [ | : string ] + || containingNodeKind === 164 /* SyntaxKind.ComputedPropertyName */; // [ | /* this can become an index signature */ + case 142 /* SyntaxKind.ModuleKeyword */: // module | + case 143 /* SyntaxKind.NamespaceKeyword */: // namespace | + case 100 /* SyntaxKind.ImportKeyword */: // import | + return true; + case 24 /* SyntaxKind.DotToken */: + return containingNodeKind === 264 /* SyntaxKind.ModuleDeclaration */; // module A.| + case 18 /* SyntaxKind.OpenBraceToken */: + return containingNodeKind === 260 /* SyntaxKind.ClassDeclaration */ // class A { | + || containingNodeKind === 207 /* SyntaxKind.ObjectLiteralExpression */; // const obj = { | + case 63 /* SyntaxKind.EqualsToken */: + return containingNodeKind === 257 /* SyntaxKind.VariableDeclaration */ // const x = a| + || containingNodeKind === 223 /* SyntaxKind.BinaryExpression */; // x = a| + case 15 /* SyntaxKind.TemplateHead */: + return containingNodeKind === 225 /* SyntaxKind.TemplateExpression */; // `aa ${| + case 16 /* SyntaxKind.TemplateMiddle */: + return containingNodeKind === 236 /* SyntaxKind.TemplateSpan */; // `aa ${10} dd ${| + case 132 /* SyntaxKind.AsyncKeyword */: + return containingNodeKind === 171 /* SyntaxKind.MethodDeclaration */ // const obj = { async c|() + || containingNodeKind === 300 /* SyntaxKind.ShorthandPropertyAssignment */; // const obj = { async c| + case 41 /* SyntaxKind.AsteriskToken */: + return containingNodeKind === 171 /* SyntaxKind.MethodDeclaration */; // const obj = { * c| + } + if (isClassMemberCompletionKeyword(tokenKind)) { + return true; + } + } + return false; + } + function isInStringOrRegularExpressionOrTemplateLiteral(contextToken) { + // To be "in" one of these literals, the position has to be: + // 1. entirely within the token text. + // 2. at the end position of an unterminated token. + // 3. at the end of a regular expression (due to trailing flags like '/foo/g'). + return (ts.isRegularExpressionLiteral(contextToken) || ts.isStringTextContainingNode(contextToken)) && (ts.rangeContainsPositionExclusive(ts.createTextRangeFromSpan(ts.createTextSpanFromNode(contextToken)), position) || + position === contextToken.end && (!!contextToken.isUnterminated || ts.isRegularExpressionLiteral(contextToken))); + } + function tryGetObjectTypeLiteralInTypeArgumentCompletionSymbols() { + var typeLiteralNode = tryGetTypeLiteralNode(contextToken); + if (!typeLiteralNode) + return 0 /* GlobalsSearch.Continue */; + var intersectionTypeNode = ts.isIntersectionTypeNode(typeLiteralNode.parent) ? typeLiteralNode.parent : undefined; + var containerTypeNode = intersectionTypeNode || typeLiteralNode; + var containerExpectedType = getConstraintOfTypeArgumentProperty(containerTypeNode, typeChecker); + if (!containerExpectedType) + return 0 /* GlobalsSearch.Continue */; + var containerActualType = typeChecker.getTypeFromTypeNode(containerTypeNode); + var members = getPropertiesForCompletion(containerExpectedType, typeChecker); + var existingMembers = getPropertiesForCompletion(containerActualType, typeChecker); + var existingMemberEscapedNames = new ts.Set(); + existingMembers.forEach(function (s) { return existingMemberEscapedNames.add(s.escapedName); }); + symbols = ts.concatenate(symbols, ts.filter(members, function (s) { return !existingMemberEscapedNames.has(s.escapedName); })); + completionKind = 0 /* CompletionKind.ObjectPropertyDeclaration */; + isNewIdentifierLocation = true; + return 1 /* GlobalsSearch.Success */; + } + /** + * Aggregates relevant symbols for completion in object literals and object binding patterns. + * Relevant symbols are stored in the captured 'symbols' variable. + * + * @returns true if 'symbols' was successfully populated; false otherwise. + */ + function tryGetObjectLikeCompletionSymbols() { + var symbolsStartIndex = symbols.length; + var objectLikeContainer = tryGetObjectLikeCompletionContainer(contextToken); + if (!objectLikeContainer) + return 0 /* GlobalsSearch.Continue */; + // We're looking up possible property names from contextual/inferred/declared type. + completionKind = 0 /* CompletionKind.ObjectPropertyDeclaration */; + var typeMembers; + var existingMembers; + if (objectLikeContainer.kind === 207 /* SyntaxKind.ObjectLiteralExpression */) { + var instantiatedType = tryGetObjectLiteralContextualType(objectLikeContainer, typeChecker); + // Check completions for Object property value shorthand + if (instantiatedType === undefined) { + if (objectLikeContainer.flags & 33554432 /* NodeFlags.InWithStatement */) { + return 2 /* GlobalsSearch.Fail */; + } + isNonContextualObjectLiteral = true; + return 0 /* GlobalsSearch.Continue */; + } + var completionsType = typeChecker.getContextualType(objectLikeContainer, 4 /* ContextFlags.Completions */); + var hasStringIndexType = (completionsType || instantiatedType).getStringIndexType(); + var hasNumberIndextype = (completionsType || instantiatedType).getNumberIndexType(); + isNewIdentifierLocation = !!hasStringIndexType || !!hasNumberIndextype; + typeMembers = getPropertiesForObjectExpression(instantiatedType, completionsType, objectLikeContainer, typeChecker); + existingMembers = objectLikeContainer.properties; + if (typeMembers.length === 0) { + // Edge case: If NumberIndexType exists + if (!hasNumberIndextype) { + isNonContextualObjectLiteral = true; + return 0 /* GlobalsSearch.Continue */; + } + } + } + else { + ts.Debug.assert(objectLikeContainer.kind === 203 /* SyntaxKind.ObjectBindingPattern */); + // We are *only* completing on properties from the type being destructured. + isNewIdentifierLocation = false; + var rootDeclaration = ts.getRootDeclaration(objectLikeContainer.parent); + if (!ts.isVariableLike(rootDeclaration)) + return ts.Debug.fail("Root declaration is not variable-like."); + // We don't want to complete using the type acquired by the shape + // of the binding pattern; we are only interested in types acquired + // through type declaration or inference. + // Also proceed if rootDeclaration is a parameter and if its containing function expression/arrow function is contextually typed - + // type of parameter will flow in from the contextual type of the function + var canGetType = ts.hasInitializer(rootDeclaration) || !!ts.getEffectiveTypeAnnotationNode(rootDeclaration) || rootDeclaration.parent.parent.kind === 247 /* SyntaxKind.ForOfStatement */; + if (!canGetType && rootDeclaration.kind === 166 /* SyntaxKind.Parameter */) { + if (ts.isExpression(rootDeclaration.parent)) { + canGetType = !!typeChecker.getContextualType(rootDeclaration.parent); + } + else if (rootDeclaration.parent.kind === 171 /* SyntaxKind.MethodDeclaration */ || rootDeclaration.parent.kind === 175 /* SyntaxKind.SetAccessor */) { + canGetType = ts.isExpression(rootDeclaration.parent.parent) && !!typeChecker.getContextualType(rootDeclaration.parent.parent); + } + } + if (canGetType) { + var typeForObject_1 = typeChecker.getTypeAtLocation(objectLikeContainer); + if (!typeForObject_1) + return 2 /* GlobalsSearch.Fail */; + typeMembers = typeChecker.getPropertiesOfType(typeForObject_1).filter(function (propertySymbol) { + return typeChecker.isPropertyAccessible(objectLikeContainer, /*isSuper*/ false, /*writing*/ false, typeForObject_1, propertySymbol); + }); + existingMembers = objectLikeContainer.elements; + } + } + if (typeMembers && typeMembers.length > 0) { + // Add filtered items to the completion list + var filteredMembers = filterObjectMembersList(typeMembers, ts.Debug.checkDefined(existingMembers)); + symbols = ts.concatenate(symbols, filteredMembers); + setSortTextToOptionalMember(); + if (objectLikeContainer.kind === 207 /* SyntaxKind.ObjectLiteralExpression */ + && preferences.includeCompletionsWithObjectLiteralMethodSnippets + && preferences.includeCompletionsWithInsertText) { + transformObjectLiteralMembersSortText(symbolsStartIndex); + collectObjectLiteralMethodSymbols(filteredMembers, objectLikeContainer); + } + } + return 1 /* GlobalsSearch.Success */; + } + /** + * Aggregates relevant symbols for completion in import clauses and export clauses + * whose declarations have a module specifier; for instance, symbols will be aggregated for + * + * import { | } from "moduleName"; + * export { a as foo, | } from "moduleName"; + * + * but not for + * + * export { | }; + * + * Relevant symbols are stored in the captured 'symbols' variable. + */ + function tryGetImportOrExportClauseCompletionSymbols() { + if (!contextToken) + return 0 /* GlobalsSearch.Continue */; + // `import { |` or `import { a as 0, | }` or `import { type | }` + var namedImportsOrExports = contextToken.kind === 18 /* SyntaxKind.OpenBraceToken */ || contextToken.kind === 27 /* SyntaxKind.CommaToken */ ? ts.tryCast(contextToken.parent, ts.isNamedImportsOrExports) : + ts.isTypeKeywordTokenOrIdentifier(contextToken) ? ts.tryCast(contextToken.parent.parent, ts.isNamedImportsOrExports) : undefined; + if (!namedImportsOrExports) + return 0 /* GlobalsSearch.Continue */; + // We can at least offer `type` at `import { |` + if (!ts.isTypeKeywordTokenOrIdentifier(contextToken)) { + keywordFilters = 8 /* KeywordCompletionFilters.TypeKeyword */; + } + // try to show exported member for imported/re-exported module + var moduleSpecifier = (namedImportsOrExports.kind === 272 /* SyntaxKind.NamedImports */ ? namedImportsOrExports.parent.parent : namedImportsOrExports.parent).moduleSpecifier; + if (!moduleSpecifier) { + isNewIdentifierLocation = true; + return namedImportsOrExports.kind === 272 /* SyntaxKind.NamedImports */ ? 2 /* GlobalsSearch.Fail */ : 0 /* GlobalsSearch.Continue */; + } + var moduleSpecifierSymbol = typeChecker.getSymbolAtLocation(moduleSpecifier); // TODO: GH#18217 + if (!moduleSpecifierSymbol) { + isNewIdentifierLocation = true; + return 2 /* GlobalsSearch.Fail */; + } + completionKind = 3 /* CompletionKind.MemberLike */; + isNewIdentifierLocation = false; + var exports = typeChecker.getExportsAndPropertiesOfModule(moduleSpecifierSymbol); + var existing = new ts.Set(namedImportsOrExports.elements.filter(function (n) { return !isCurrentlyEditingNode(n); }).map(function (n) { return (n.propertyName || n.name).escapedText; })); + var uniques = exports.filter(function (e) { return e.escapedName !== "default" /* InternalSymbolName.Default */ && !existing.has(e.escapedName); }); + symbols = ts.concatenate(symbols, uniques); + if (!uniques.length) { + // If there's nothing else to import, don't offer `type` either + keywordFilters = 0 /* KeywordCompletionFilters.None */; + } + return 1 /* GlobalsSearch.Success */; + } + /** + * Adds local declarations for completions in named exports: + * + * export { | }; + * + * Does not check for the absence of a module specifier (`export {} from "./other"`) + * because `tryGetImportOrExportClauseCompletionSymbols` runs first and handles that, + * preventing this function from running. + */ + function tryGetLocalNamedExportCompletionSymbols() { + var _a; + var namedExports = contextToken && (contextToken.kind === 18 /* SyntaxKind.OpenBraceToken */ || contextToken.kind === 27 /* SyntaxKind.CommaToken */) + ? ts.tryCast(contextToken.parent, ts.isNamedExports) + : undefined; + if (!namedExports) { + return 0 /* GlobalsSearch.Continue */; + } + var localsContainer = ts.findAncestor(namedExports, ts.or(ts.isSourceFile, ts.isModuleDeclaration)); + completionKind = 5 /* CompletionKind.None */; + isNewIdentifierLocation = false; + (_a = localsContainer.locals) === null || _a === void 0 ? void 0 : _a.forEach(function (symbol, name) { + var _a, _b; + symbols.push(symbol); + if ((_b = (_a = localsContainer.symbol) === null || _a === void 0 ? void 0 : _a.exports) === null || _b === void 0 ? void 0 : _b.has(name)) { + symbolToSortTextMap[ts.getSymbolId(symbol)] = Completions.SortText.OptionalMember; + } + }); + return 1 /* GlobalsSearch.Success */; + } + /** + * Aggregates relevant symbols for completion in class declaration + * Relevant symbols are stored in the captured 'symbols' variable. + */ + function tryGetClassLikeCompletionSymbols() { + var decl = tryGetObjectTypeDeclarationCompletionContainer(sourceFile, contextToken, location, position); + if (!decl) + return 0 /* GlobalsSearch.Continue */; + // We're looking up possible property names from parent type. + completionKind = 3 /* CompletionKind.MemberLike */; + // Declaring new property/method/accessor + isNewIdentifierLocation = true; + keywordFilters = contextToken.kind === 41 /* SyntaxKind.AsteriskToken */ ? 0 /* KeywordCompletionFilters.None */ : + ts.isClassLike(decl) ? 2 /* KeywordCompletionFilters.ClassElementKeywords */ : 3 /* KeywordCompletionFilters.InterfaceElementKeywords */; + // If you're in an interface you don't want to repeat things from super-interface. So just stop here. + if (!ts.isClassLike(decl)) + return 1 /* GlobalsSearch.Success */; + var classElement = contextToken.kind === 26 /* SyntaxKind.SemicolonToken */ ? contextToken.parent.parent : contextToken.parent; + var classElementModifierFlags = ts.isClassElement(classElement) ? ts.getEffectiveModifierFlags(classElement) : 0 /* ModifierFlags.None */; + // If this is context token is not something we are editing now, consider if this would lead to be modifier + if (contextToken.kind === 79 /* SyntaxKind.Identifier */ && !isCurrentlyEditingNode(contextToken)) { + switch (contextToken.getText()) { + case "private": + classElementModifierFlags = classElementModifierFlags | 8 /* ModifierFlags.Private */; + break; + case "static": + classElementModifierFlags = classElementModifierFlags | 32 /* ModifierFlags.Static */; + break; + case "override": + classElementModifierFlags = classElementModifierFlags | 16384 /* ModifierFlags.Override */; + break; + } + } + if (ts.isClassStaticBlockDeclaration(classElement)) { + classElementModifierFlags |= 32 /* ModifierFlags.Static */; + } + // No member list for private methods + if (!(classElementModifierFlags & 8 /* ModifierFlags.Private */)) { + // List of property symbols of base type that are not private and already implemented + var baseTypeNodes = ts.isClassLike(decl) && classElementModifierFlags & 16384 /* ModifierFlags.Override */ ? ts.singleElementArray(ts.getEffectiveBaseTypeNode(decl)) : ts.getAllSuperTypeNodes(decl); + var baseSymbols = ts.flatMap(baseTypeNodes, function (baseTypeNode) { + var type = typeChecker.getTypeAtLocation(baseTypeNode); + return classElementModifierFlags & 32 /* ModifierFlags.Static */ ? + (type === null || type === void 0 ? void 0 : type.symbol) && typeChecker.getPropertiesOfType(typeChecker.getTypeOfSymbolAtLocation(type.symbol, decl)) : + type && typeChecker.getPropertiesOfType(type); + }); + symbols = ts.concatenate(symbols, filterClassMembersList(baseSymbols, decl.members, classElementModifierFlags)); + } + return 1 /* GlobalsSearch.Success */; + } + function isConstructorParameterCompletion(node) { + return !!node.parent && ts.isParameter(node.parent) && ts.isConstructorDeclaration(node.parent.parent) + && (ts.isParameterPropertyModifier(node.kind) || ts.isDeclarationName(node)); + } + /** + * Returns the immediate owning class declaration of a context token, + * on the condition that one exists and that the context implies completion should be given. + */ + function tryGetConstructorLikeCompletionContainer(contextToken) { + if (contextToken) { + var parent = contextToken.parent; + switch (contextToken.kind) { + case 20 /* SyntaxKind.OpenParenToken */: + case 27 /* SyntaxKind.CommaToken */: + return ts.isConstructorDeclaration(contextToken.parent) ? contextToken.parent : undefined; + default: + if (isConstructorParameterCompletion(contextToken)) { + return parent.parent; + } + } + } + return undefined; + } + function tryGetFunctionLikeBodyCompletionContainer(contextToken) { + if (contextToken) { + var prev_1; + var container = ts.findAncestor(contextToken.parent, function (node) { + if (ts.isClassLike(node)) { + return "quit"; + } + if (ts.isFunctionLikeDeclaration(node) && prev_1 === node.body) { + return true; + } + prev_1 = node; + return false; + }); + return container && container; + } + } + function tryGetContainingJsxElement(contextToken) { + if (contextToken) { + var parent = contextToken.parent; + switch (contextToken.kind) { + case 31 /* SyntaxKind.GreaterThanToken */: // End of a type argument list + case 30 /* SyntaxKind.LessThanSlashToken */: + case 43 /* SyntaxKind.SlashToken */: + case 79 /* SyntaxKind.Identifier */: + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 289 /* SyntaxKind.JsxAttributes */: + case 288 /* SyntaxKind.JsxAttribute */: + case 290 /* SyntaxKind.JsxSpreadAttribute */: + if (parent && (parent.kind === 282 /* SyntaxKind.JsxSelfClosingElement */ || parent.kind === 283 /* SyntaxKind.JsxOpeningElement */)) { + if (contextToken.kind === 31 /* SyntaxKind.GreaterThanToken */) { + var precedingToken = ts.findPrecedingToken(contextToken.pos, sourceFile, /*startNode*/ undefined); + if (!parent.typeArguments || (precedingToken && precedingToken.kind === 43 /* SyntaxKind.SlashToken */)) + break; + } + return parent; + } + else if (parent.kind === 288 /* SyntaxKind.JsxAttribute */) { + // Currently we parse JsxOpeningLikeElement as: + // JsxOpeningLikeElement + // attributes: JsxAttributes + // properties: NodeArray + return parent.parent.parent; + } + break; + // The context token is the closing } or " of an attribute, which means + // its parent is a JsxExpression, whose parent is a JsxAttribute, + // whose parent is a JsxOpeningLikeElement + case 10 /* SyntaxKind.StringLiteral */: + if (parent && ((parent.kind === 288 /* SyntaxKind.JsxAttribute */) || (parent.kind === 290 /* SyntaxKind.JsxSpreadAttribute */))) { + // Currently we parse JsxOpeningLikeElement as: + // JsxOpeningLikeElement + // attributes: JsxAttributes + // properties: NodeArray + return parent.parent.parent; + } + break; + case 19 /* SyntaxKind.CloseBraceToken */: + if (parent && + parent.kind === 291 /* SyntaxKind.JsxExpression */ && + parent.parent && parent.parent.kind === 288 /* SyntaxKind.JsxAttribute */) { + // Currently we parse JsxOpeningLikeElement as: + // JsxOpeningLikeElement + // attributes: JsxAttributes + // properties: NodeArray + // each JsxAttribute can have initializer as JsxExpression + return parent.parent.parent.parent; + } + if (parent && parent.kind === 290 /* SyntaxKind.JsxSpreadAttribute */) { + // Currently we parse JsxOpeningLikeElement as: + // JsxOpeningLikeElement + // attributes: JsxAttributes + // properties: NodeArray + return parent.parent.parent; + } + break; + } + } + return undefined; + } + /** + * @returns true if we are certain that the currently edited location must define a new location; false otherwise. + */ + function isSolelyIdentifierDefinitionLocation(contextToken) { + var parent = contextToken.parent; + var containingNodeKind = parent.kind; + switch (contextToken.kind) { + case 27 /* SyntaxKind.CommaToken */: + return containingNodeKind === 257 /* SyntaxKind.VariableDeclaration */ || + isVariableDeclarationListButNotTypeArgument(contextToken) || + containingNodeKind === 240 /* SyntaxKind.VariableStatement */ || + containingNodeKind === 263 /* SyntaxKind.EnumDeclaration */ || // enum a { foo, | + isFunctionLikeButNotConstructor(containingNodeKind) || + containingNodeKind === 261 /* SyntaxKind.InterfaceDeclaration */ || // interface A= contextToken.pos); + case 24 /* SyntaxKind.DotToken */: + return containingNodeKind === 204 /* SyntaxKind.ArrayBindingPattern */; // var [.| + case 58 /* SyntaxKind.ColonToken */: + return containingNodeKind === 205 /* SyntaxKind.BindingElement */; // var {x :html| + case 22 /* SyntaxKind.OpenBracketToken */: + return containingNodeKind === 204 /* SyntaxKind.ArrayBindingPattern */; // var [x| + case 20 /* SyntaxKind.OpenParenToken */: + return containingNodeKind === 295 /* SyntaxKind.CatchClause */ || + isFunctionLikeButNotConstructor(containingNodeKind); + case 18 /* SyntaxKind.OpenBraceToken */: + return containingNodeKind === 263 /* SyntaxKind.EnumDeclaration */; // enum a { | + case 29 /* SyntaxKind.LessThanToken */: + return containingNodeKind === 260 /* SyntaxKind.ClassDeclaration */ || // class A< | + containingNodeKind === 228 /* SyntaxKind.ClassExpression */ || // var C = class D< | + containingNodeKind === 261 /* SyntaxKind.InterfaceDeclaration */ || // interface A< | + containingNodeKind === 262 /* SyntaxKind.TypeAliasDeclaration */ || // type List< | + ts.isFunctionLikeKind(containingNodeKind); + case 124 /* SyntaxKind.StaticKeyword */: + return containingNodeKind === 169 /* SyntaxKind.PropertyDeclaration */ && !ts.isClassLike(parent.parent); + case 25 /* SyntaxKind.DotDotDotToken */: + return containingNodeKind === 166 /* SyntaxKind.Parameter */ || + (!!parent.parent && parent.parent.kind === 204 /* SyntaxKind.ArrayBindingPattern */); // var [...z| + case 123 /* SyntaxKind.PublicKeyword */: + case 121 /* SyntaxKind.PrivateKeyword */: + case 122 /* SyntaxKind.ProtectedKeyword */: + return containingNodeKind === 166 /* SyntaxKind.Parameter */ && !ts.isConstructorDeclaration(parent.parent); + case 128 /* SyntaxKind.AsKeyword */: + return containingNodeKind === 273 /* SyntaxKind.ImportSpecifier */ || + containingNodeKind === 278 /* SyntaxKind.ExportSpecifier */ || + containingNodeKind === 271 /* SyntaxKind.NamespaceImport */; + case 137 /* SyntaxKind.GetKeyword */: + case 151 /* SyntaxKind.SetKeyword */: + return !isFromObjectTypeDeclaration(contextToken); + case 79 /* SyntaxKind.Identifier */: + if (containingNodeKind === 273 /* SyntaxKind.ImportSpecifier */ && + contextToken === parent.name && + contextToken.text === "type") { + // import { type | } + return false; + } + break; + case 84 /* SyntaxKind.ClassKeyword */: + case 92 /* SyntaxKind.EnumKeyword */: + case 118 /* SyntaxKind.InterfaceKeyword */: + case 98 /* SyntaxKind.FunctionKeyword */: + case 113 /* SyntaxKind.VarKeyword */: + case 100 /* SyntaxKind.ImportKeyword */: + case 119 /* SyntaxKind.LetKeyword */: + case 85 /* SyntaxKind.ConstKeyword */: + case 138 /* SyntaxKind.InferKeyword */: + return true; + case 154 /* SyntaxKind.TypeKeyword */: + // import { type foo| } + return containingNodeKind !== 273 /* SyntaxKind.ImportSpecifier */; + case 41 /* SyntaxKind.AsteriskToken */: + return ts.isFunctionLike(contextToken.parent) && !ts.isMethodDeclaration(contextToken.parent); + } + // If the previous token is keyword corresponding to class member completion keyword + // there will be completion available here + if (isClassMemberCompletionKeyword(keywordForNode(contextToken)) && isFromObjectTypeDeclaration(contextToken)) { + return false; + } + if (isConstructorParameterCompletion(contextToken)) { + // constructor parameter completion is available only if + // - its modifier of the constructor parameter or + // - its name of the parameter and not being edited + // eg. constructor(a |<- this shouldnt show completion + if (!ts.isIdentifier(contextToken) || + ts.isParameterPropertyModifier(keywordForNode(contextToken)) || + isCurrentlyEditingNode(contextToken)) { + return false; + } + } + // Previous token may have been a keyword that was converted to an identifier. + switch (keywordForNode(contextToken)) { + case 126 /* SyntaxKind.AbstractKeyword */: + case 84 /* SyntaxKind.ClassKeyword */: + case 85 /* SyntaxKind.ConstKeyword */: + case 136 /* SyntaxKind.DeclareKeyword */: + case 92 /* SyntaxKind.EnumKeyword */: + case 98 /* SyntaxKind.FunctionKeyword */: + case 118 /* SyntaxKind.InterfaceKeyword */: + case 119 /* SyntaxKind.LetKeyword */: + case 121 /* SyntaxKind.PrivateKeyword */: + case 122 /* SyntaxKind.ProtectedKeyword */: + case 123 /* SyntaxKind.PublicKeyword */: + case 124 /* SyntaxKind.StaticKeyword */: + case 113 /* SyntaxKind.VarKeyword */: + return true; + case 132 /* SyntaxKind.AsyncKeyword */: + return ts.isPropertyDeclaration(contextToken.parent); + } + // If we are inside a class declaration, and `constructor` is totally not present, + // but we request a completion manually at a whitespace... + var ancestorClassLike = ts.findAncestor(contextToken.parent, ts.isClassLike); + if (ancestorClassLike && contextToken === previousToken && isPreviousPropertyDeclarationTerminated(contextToken, position)) { + return false; // Don't block completions. + } + var ancestorPropertyDeclaraion = ts.getAncestor(contextToken.parent, 169 /* SyntaxKind.PropertyDeclaration */); + // If we are inside a class declaration and typing `constructor` after property declaration... + if (ancestorPropertyDeclaraion + && contextToken !== previousToken + && ts.isClassLike(previousToken.parent.parent) + // And the cursor is at the token... + && position <= previousToken.end) { + // If we are sure that the previous property declaration is terminated according to newline or semicolon... + if (isPreviousPropertyDeclarationTerminated(contextToken, previousToken.end)) { + return false; // Don't block completions. + } + else if (contextToken.kind !== 63 /* SyntaxKind.EqualsToken */ + // Should not block: `class C { blah = c/**/ }` + // But should block: `class C { blah = somewhat c/**/ }` and `class C { blah: SomeType c/**/ }` + && (ts.isInitializedProperty(ancestorPropertyDeclaraion) + || ts.hasType(ancestorPropertyDeclaraion))) { + return true; + } + } + return ts.isDeclarationName(contextToken) + && !ts.isShorthandPropertyAssignment(contextToken.parent) + && !ts.isJsxAttribute(contextToken.parent) + // Don't block completions if we're in `class C /**/`, because we're *past* the end of the identifier and might want to complete `extends`. + // If `contextToken !== previousToken`, this is `class C ex/**/`. + && !(ts.isClassLike(contextToken.parent) && (contextToken !== previousToken || position > previousToken.end)); + } + function isPreviousPropertyDeclarationTerminated(contextToken, position) { + return contextToken.kind !== 63 /* SyntaxKind.EqualsToken */ && + (contextToken.kind === 26 /* SyntaxKind.SemicolonToken */ + || !ts.positionsAreOnSameLine(contextToken.end, position, sourceFile)); + } + function isFunctionLikeButNotConstructor(kind) { + return ts.isFunctionLikeKind(kind) && kind !== 173 /* SyntaxKind.Constructor */; + } + function isDotOfNumericLiteral(contextToken) { + if (contextToken.kind === 8 /* SyntaxKind.NumericLiteral */) { + var text = contextToken.getFullText(); + return text.charAt(text.length - 1) === "."; + } + return false; + } + function isVariableDeclarationListButNotTypeArgument(node) { + return node.parent.kind === 258 /* SyntaxKind.VariableDeclarationList */ + && !ts.isPossiblyTypeArgumentPosition(node, sourceFile, typeChecker); + } + /** + * Filters out completion suggestions for named imports or exports. + * + * @returns Symbols to be suggested in an object binding pattern or object literal expression, barring those whose declarations + * do not occur at the current position and have not otherwise been typed. + */ + function filterObjectMembersList(contextualMemberSymbols, existingMembers) { + if (existingMembers.length === 0) { + return contextualMemberSymbols; + } + var membersDeclaredBySpreadAssignment = new ts.Set(); + var existingMemberNames = new ts.Set(); + for (var _i = 0, existingMembers_1 = existingMembers; _i < existingMembers_1.length; _i++) { + var m = existingMembers_1[_i]; + // Ignore omitted expressions for missing members + if (m.kind !== 299 /* SyntaxKind.PropertyAssignment */ && + m.kind !== 300 /* SyntaxKind.ShorthandPropertyAssignment */ && + m.kind !== 205 /* SyntaxKind.BindingElement */ && + m.kind !== 171 /* SyntaxKind.MethodDeclaration */ && + m.kind !== 174 /* SyntaxKind.GetAccessor */ && + m.kind !== 175 /* SyntaxKind.SetAccessor */ && + m.kind !== 301 /* SyntaxKind.SpreadAssignment */) { + continue; + } + // If this is the current item we are editing right now, do not filter it out + if (isCurrentlyEditingNode(m)) { + continue; + } + var existingName = void 0; + if (ts.isSpreadAssignment(m)) { + setMembersDeclaredBySpreadAssignment(m, membersDeclaredBySpreadAssignment); + } + else if (ts.isBindingElement(m) && m.propertyName) { + // include only identifiers in completion list + if (m.propertyName.kind === 79 /* SyntaxKind.Identifier */) { + existingName = m.propertyName.escapedText; + } + } + else { + // TODO: Account for computed property name + // NOTE: if one only performs this step when m.name is an identifier, + // things like '__proto__' are not filtered out. + var name = ts.getNameOfDeclaration(m); + existingName = name && ts.isPropertyNameLiteral(name) ? ts.getEscapedTextOfIdentifierOrLiteral(name) : undefined; + } + if (existingName !== undefined) { + existingMemberNames.add(existingName); + } + } + var filteredSymbols = contextualMemberSymbols.filter(function (m) { return !existingMemberNames.has(m.escapedName); }); + setSortTextToMemberDeclaredBySpreadAssignment(membersDeclaredBySpreadAssignment, filteredSymbols); + return filteredSymbols; + } + function setMembersDeclaredBySpreadAssignment(declaration, membersDeclaredBySpreadAssignment) { + var expression = declaration.expression; + var symbol = typeChecker.getSymbolAtLocation(expression); + var type = symbol && typeChecker.getTypeOfSymbolAtLocation(symbol, expression); + var properties = type && type.properties; + if (properties) { + properties.forEach(function (property) { + membersDeclaredBySpreadAssignment.add(property.name); + }); + } + } + // Set SortText to OptionalMember if it is an optional member + function setSortTextToOptionalMember() { + symbols.forEach(function (m) { + var _a; + if (m.flags & 16777216 /* SymbolFlags.Optional */) { + var symbolId = ts.getSymbolId(m); + symbolToSortTextMap[symbolId] = (_a = symbolToSortTextMap[symbolId]) !== null && _a !== void 0 ? _a : Completions.SortText.OptionalMember; + } + }); + } + // Set SortText to MemberDeclaredBySpreadAssignment if it is fulfilled by spread assignment + function setSortTextToMemberDeclaredBySpreadAssignment(membersDeclaredBySpreadAssignment, contextualMemberSymbols) { + if (membersDeclaredBySpreadAssignment.size === 0) { + return; + } + for (var _i = 0, contextualMemberSymbols_1 = contextualMemberSymbols; _i < contextualMemberSymbols_1.length; _i++) { + var contextualMemberSymbol = contextualMemberSymbols_1[_i]; + if (membersDeclaredBySpreadAssignment.has(contextualMemberSymbol.name)) { + symbolToSortTextMap[ts.getSymbolId(contextualMemberSymbol)] = Completions.SortText.MemberDeclaredBySpreadAssignment; + } + } + } + function transformObjectLiteralMembersSortText(start) { + var _a; + for (var i = start; i < symbols.length; i++) { + var symbol = symbols[i]; + var symbolId = ts.getSymbolId(symbol); + var origin = symbolToOriginInfoMap === null || symbolToOriginInfoMap === void 0 ? void 0 : symbolToOriginInfoMap[i]; + var target = ts.getEmitScriptTarget(compilerOptions); + var displayName = getCompletionEntryDisplayNameForSymbol(symbol, target, origin, 0 /* CompletionKind.ObjectPropertyDeclaration */, + /*jsxIdentifierExpected*/ false); + if (displayName) { + var originalSortText = (_a = symbolToSortTextMap[symbolId]) !== null && _a !== void 0 ? _a : Completions.SortText.LocationPriority; + var name = displayName.name; + symbolToSortTextMap[symbolId] = Completions.SortText.ObjectLiteralProperty(originalSortText, name); + } + } + } + /** + * Filters out completion suggestions for class elements. + * + * @returns Symbols to be suggested in an class element depending on existing memebers and symbol flags + */ + function filterClassMembersList(baseSymbols, existingMembers, currentClassElementModifierFlags) { + var existingMemberNames = new ts.Set(); + for (var _i = 0, existingMembers_2 = existingMembers; _i < existingMembers_2.length; _i++) { + var m = existingMembers_2[_i]; + // Ignore omitted expressions for missing members + if (m.kind !== 169 /* SyntaxKind.PropertyDeclaration */ && + m.kind !== 171 /* SyntaxKind.MethodDeclaration */ && + m.kind !== 174 /* SyntaxKind.GetAccessor */ && + m.kind !== 175 /* SyntaxKind.SetAccessor */) { + continue; + } + // If this is the current item we are editing right now, do not filter it out + if (isCurrentlyEditingNode(m)) { + continue; + } + // Dont filter member even if the name matches if it is declared private in the list + if (ts.hasEffectiveModifier(m, 8 /* ModifierFlags.Private */)) { + continue; + } + // do not filter it out if the static presence doesnt match + if (ts.isStatic(m) !== !!(currentClassElementModifierFlags & 32 /* ModifierFlags.Static */)) { + continue; + } + var existingName = ts.getPropertyNameForPropertyNameNode(m.name); + if (existingName) { + existingMemberNames.add(existingName); + } + } + return baseSymbols.filter(function (propertySymbol) { + return !existingMemberNames.has(propertySymbol.escapedName) && + !!propertySymbol.declarations && + !(ts.getDeclarationModifierFlagsFromSymbol(propertySymbol) & 8 /* ModifierFlags.Private */) && + !(propertySymbol.valueDeclaration && ts.isPrivateIdentifierClassElementDeclaration(propertySymbol.valueDeclaration)); + }); + } + /** + * Filters out completion suggestions from 'symbols' according to existing JSX attributes. + * + * @returns Symbols to be suggested in a JSX element, barring those whose attributes + * do not occur at the current position and have not otherwise been typed. + */ + function filterJsxAttributes(symbols, attributes) { + var seenNames = new ts.Set(); + var membersDeclaredBySpreadAssignment = new ts.Set(); + for (var _i = 0, attributes_1 = attributes; _i < attributes_1.length; _i++) { + var attr = attributes_1[_i]; + // If this is the current item we are editing right now, do not filter it out + if (isCurrentlyEditingNode(attr)) { + continue; + } + if (attr.kind === 288 /* SyntaxKind.JsxAttribute */) { + seenNames.add(attr.name.escapedText); + } + else if (ts.isJsxSpreadAttribute(attr)) { + setMembersDeclaredBySpreadAssignment(attr, membersDeclaredBySpreadAssignment); + } + } + var filteredSymbols = symbols.filter(function (a) { return !seenNames.has(a.escapedName); }); + setSortTextToMemberDeclaredBySpreadAssignment(membersDeclaredBySpreadAssignment, filteredSymbols); + return filteredSymbols; + } + function isCurrentlyEditingNode(node) { + return node.getStart(sourceFile) <= position && position <= node.getEnd(); + } + } + /** + * Returns the immediate owning object literal or binding pattern of a context token, + * on the condition that one exists and that the context implies completion should be given. + */ + function tryGetObjectLikeCompletionContainer(contextToken) { + if (contextToken) { + var parent = contextToken.parent; + switch (contextToken.kind) { + case 18 /* SyntaxKind.OpenBraceToken */: // const x = { | + case 27 /* SyntaxKind.CommaToken */: // const x = { a: 0, | + if (ts.isObjectLiteralExpression(parent) || ts.isObjectBindingPattern(parent)) { + return parent; + } + break; + case 41 /* SyntaxKind.AsteriskToken */: + return ts.isMethodDeclaration(parent) ? ts.tryCast(parent.parent, ts.isObjectLiteralExpression) : undefined; + case 79 /* SyntaxKind.Identifier */: + return contextToken.text === "async" && ts.isShorthandPropertyAssignment(contextToken.parent) + ? contextToken.parent.parent : undefined; + } + } + return undefined; + } + function getRelevantTokens(position, sourceFile) { + var previousToken = ts.findPrecedingToken(position, sourceFile); + if (previousToken && position <= previousToken.end && (ts.isMemberName(previousToken) || ts.isKeyword(previousToken.kind))) { + var contextToken = ts.findPrecedingToken(previousToken.getFullStart(), sourceFile, /*startNode*/ undefined); // TODO: GH#18217 + return { contextToken: contextToken, previousToken: previousToken }; + } + return { contextToken: previousToken, previousToken: previousToken }; + } + function getAutoImportSymbolFromCompletionEntryData(name, data, program, host) { + var containingProgram = data.isPackageJsonImport ? host.getPackageJsonAutoImportProvider() : program; + var checker = containingProgram.getTypeChecker(); + var moduleSymbol = data.ambientModuleName ? checker.tryFindAmbientModule(data.ambientModuleName) : + data.fileName ? checker.getMergedSymbol(ts.Debug.checkDefined(containingProgram.getSourceFile(data.fileName)).symbol) : + undefined; + if (!moduleSymbol) + return undefined; + var symbol = data.exportName === "export=" /* InternalSymbolName.ExportEquals */ + ? checker.resolveExternalModuleSymbol(moduleSymbol) + : checker.tryGetMemberInModuleExportsAndProperties(data.exportName, moduleSymbol); + if (!symbol) + return undefined; + var isDefaultExport = data.exportName === "default" /* InternalSymbolName.Default */; + symbol = isDefaultExport && ts.getLocalSymbolForExportDefault(symbol) || symbol; + return { symbol: symbol, origin: completionEntryDataToSymbolOriginInfo(data, name, moduleSymbol) }; + } + function getCompletionEntryDisplayNameForSymbol(symbol, target, origin, kind, jsxIdentifierExpected) { + var name = originIncludesSymbolName(origin) ? origin.symbolName : symbol.name; + if (name === undefined + // If the symbol is external module, don't show it in the completion list + // (i.e declare module "http" { const x; } | // <= request completion here, "http" should not be there) + || symbol.flags & 1536 /* SymbolFlags.Module */ && ts.isSingleOrDoubleQuote(name.charCodeAt(0)) + // If the symbol is the internal name of an ES symbol, it is not a valid entry. Internal names for ES symbols start with "__@" + || ts.isKnownSymbol(symbol)) { + return undefined; + } + var validNameResult = { name: name, needsConvertPropertyAccess: false }; + if (ts.isIdentifierText(name, target, jsxIdentifierExpected ? 1 /* LanguageVariant.JSX */ : 0 /* LanguageVariant.Standard */) || symbol.valueDeclaration && ts.isPrivateIdentifierClassElementDeclaration(symbol.valueDeclaration)) { + return validNameResult; + } + switch (kind) { + case 3 /* CompletionKind.MemberLike */: + return undefined; + case 0 /* CompletionKind.ObjectPropertyDeclaration */: + // TODO: GH#18169 + return { name: JSON.stringify(name), needsConvertPropertyAccess: false }; + case 2 /* CompletionKind.PropertyAccess */: + case 1 /* CompletionKind.Global */: // For a 'this.' completion it will be in a global context, but may have a non-identifier name. + // Don't add a completion for a name starting with a space. See https://github.com/Microsoft/TypeScript/pull/20547 + return name.charCodeAt(0) === 32 /* CharacterCodes.space */ ? undefined : { name: name, needsConvertPropertyAccess: true }; + case 5 /* CompletionKind.None */: + case 4 /* CompletionKind.String */: + return validNameResult; + default: + ts.Debug.assertNever(kind); + } + } + // A cache of completion entries for keywords, these do not change between sessions + var _keywordCompletions = []; + var allKeywordsCompletions = ts.memoize(function () { + var res = []; + for (var i = 81 /* SyntaxKind.FirstKeyword */; i <= 162 /* SyntaxKind.LastKeyword */; i++) { + res.push({ + name: ts.tokenToString(i), + kind: "keyword" /* ScriptElementKind.keyword */, + kindModifiers: "" /* ScriptElementKindModifier.none */, + sortText: Completions.SortText.GlobalsOrKeywords + }); + } + return res; + }); + function getKeywordCompletions(keywordFilter, filterOutTsOnlyKeywords) { + if (!filterOutTsOnlyKeywords) + return getTypescriptKeywordCompletions(keywordFilter); + var index = keywordFilter + 8 /* KeywordCompletionFilters.Last */ + 1; + return _keywordCompletions[index] || + (_keywordCompletions[index] = getTypescriptKeywordCompletions(keywordFilter) + .filter(function (entry) { return !isTypeScriptOnlyKeyword(ts.stringToToken(entry.name)); })); + } + function getTypescriptKeywordCompletions(keywordFilter) { + return _keywordCompletions[keywordFilter] || (_keywordCompletions[keywordFilter] = allKeywordsCompletions().filter(function (entry) { + var kind = ts.stringToToken(entry.name); + switch (keywordFilter) { + case 0 /* KeywordCompletionFilters.None */: + return false; + case 1 /* KeywordCompletionFilters.All */: + return isFunctionLikeBodyKeyword(kind) + || kind === 136 /* SyntaxKind.DeclareKeyword */ + || kind === 142 /* SyntaxKind.ModuleKeyword */ + || kind === 154 /* SyntaxKind.TypeKeyword */ + || kind === 143 /* SyntaxKind.NamespaceKeyword */ + || kind === 126 /* SyntaxKind.AbstractKeyword */ + || ts.isTypeKeyword(kind) && kind !== 155 /* SyntaxKind.UndefinedKeyword */; + case 5 /* KeywordCompletionFilters.FunctionLikeBodyKeywords */: + return isFunctionLikeBodyKeyword(kind); + case 2 /* KeywordCompletionFilters.ClassElementKeywords */: + return isClassMemberCompletionKeyword(kind); + case 3 /* KeywordCompletionFilters.InterfaceElementKeywords */: + return isInterfaceOrTypeLiteralCompletionKeyword(kind); + case 4 /* KeywordCompletionFilters.ConstructorParameterKeywords */: + return ts.isParameterPropertyModifier(kind); + case 6 /* KeywordCompletionFilters.TypeAssertionKeywords */: + return ts.isTypeKeyword(kind) || kind === 85 /* SyntaxKind.ConstKeyword */; + case 7 /* KeywordCompletionFilters.TypeKeywords */: + return ts.isTypeKeyword(kind); + case 8 /* KeywordCompletionFilters.TypeKeyword */: + return kind === 154 /* SyntaxKind.TypeKeyword */; + default: + return ts.Debug.assertNever(keywordFilter); + } + })); + } + function isTypeScriptOnlyKeyword(kind) { + switch (kind) { + case 126 /* SyntaxKind.AbstractKeyword */: + case 131 /* SyntaxKind.AnyKeyword */: + case 160 /* SyntaxKind.BigIntKeyword */: + case 134 /* SyntaxKind.BooleanKeyword */: + case 136 /* SyntaxKind.DeclareKeyword */: + case 92 /* SyntaxKind.EnumKeyword */: + case 159 /* SyntaxKind.GlobalKeyword */: + case 117 /* SyntaxKind.ImplementsKeyword */: + case 138 /* SyntaxKind.InferKeyword */: + case 118 /* SyntaxKind.InterfaceKeyword */: + case 140 /* SyntaxKind.IsKeyword */: + case 141 /* SyntaxKind.KeyOfKeyword */: + case 142 /* SyntaxKind.ModuleKeyword */: + case 143 /* SyntaxKind.NamespaceKeyword */: + case 144 /* SyntaxKind.NeverKeyword */: + case 148 /* SyntaxKind.NumberKeyword */: + case 149 /* SyntaxKind.ObjectKeyword */: + case 161 /* SyntaxKind.OverrideKeyword */: + case 121 /* SyntaxKind.PrivateKeyword */: + case 122 /* SyntaxKind.ProtectedKeyword */: + case 123 /* SyntaxKind.PublicKeyword */: + case 146 /* SyntaxKind.ReadonlyKeyword */: + case 152 /* SyntaxKind.StringKeyword */: + case 153 /* SyntaxKind.SymbolKeyword */: + case 154 /* SyntaxKind.TypeKeyword */: + case 156 /* SyntaxKind.UniqueKeyword */: + case 157 /* SyntaxKind.UnknownKeyword */: + return true; + default: + return false; + } + } + function isInterfaceOrTypeLiteralCompletionKeyword(kind) { + return kind === 146 /* SyntaxKind.ReadonlyKeyword */; + } + function isClassMemberCompletionKeyword(kind) { + switch (kind) { + case 126 /* SyntaxKind.AbstractKeyword */: + case 127 /* SyntaxKind.AccessorKeyword */: + case 135 /* SyntaxKind.ConstructorKeyword */: + case 137 /* SyntaxKind.GetKeyword */: + case 151 /* SyntaxKind.SetKeyword */: + case 132 /* SyntaxKind.AsyncKeyword */: + case 136 /* SyntaxKind.DeclareKeyword */: + case 161 /* SyntaxKind.OverrideKeyword */: + return true; + default: + return ts.isClassMemberModifier(kind); + } + } + function isFunctionLikeBodyKeyword(kind) { + return kind === 132 /* SyntaxKind.AsyncKeyword */ + || kind === 133 /* SyntaxKind.AwaitKeyword */ + || kind === 128 /* SyntaxKind.AsKeyword */ + || kind === 150 /* SyntaxKind.SatisfiesKeyword */ + || kind === 154 /* SyntaxKind.TypeKeyword */ + || !ts.isContextualKeyword(kind) && !isClassMemberCompletionKeyword(kind); + } + function keywordForNode(node) { + return ts.isIdentifier(node) ? node.originalKeywordKind || 0 /* SyntaxKind.Unknown */ : node.kind; + } + function getContextualKeywords(contextToken, position) { + var entries = []; + /** + * An `AssertClause` can come after an import declaration: + * import * from "foo" | + * import "foo" | + * or after a re-export declaration that has a module specifier: + * export { foo } from "foo" | + * Source: https://tc39.es/proposal-import-assertions/ + */ + if (contextToken) { + var file = contextToken.getSourceFile(); + var parent = contextToken.parent; + var tokenLine = file.getLineAndCharacterOfPosition(contextToken.end).line; + var currentLine = file.getLineAndCharacterOfPosition(position).line; + if ((ts.isImportDeclaration(parent) || ts.isExportDeclaration(parent) && parent.moduleSpecifier) + && contextToken === parent.moduleSpecifier + && tokenLine === currentLine) { + entries.push({ + name: ts.tokenToString(130 /* SyntaxKind.AssertKeyword */), + kind: "keyword" /* ScriptElementKind.keyword */, + kindModifiers: "" /* ScriptElementKindModifier.none */, + sortText: Completions.SortText.GlobalsOrKeywords, + }); + } + } + return entries; + } + /** Get the corresponding JSDocTag node if the position is in a jsDoc comment */ + function getJsDocTagAtPosition(node, position) { + return ts.findAncestor(node, function (n) { + return ts.isJSDocTag(n) && ts.rangeContainsPosition(n, position) ? true : + ts.isJSDoc(n) ? "quit" : false; + }); + } + function getPropertiesForObjectExpression(contextualType, completionsType, obj, checker) { + var hasCompletionsType = completionsType && completionsType !== contextualType; + var type = hasCompletionsType && !(completionsType.flags & 3 /* TypeFlags.AnyOrUnknown */) + ? checker.getUnionType([contextualType, completionsType]) + : contextualType; + var properties = getApparentProperties(type, obj, checker); + return type.isClass() && containsNonPublicProperties(properties) ? [] : + hasCompletionsType ? ts.filter(properties, hasDeclarationOtherThanSelf) : properties; + // Filter out members whose only declaration is the object literal itself to avoid + // self-fulfilling completions like: + // + // function f(x: T) {} + // f({ abc/**/: "" }) // `abc` is a member of `T` but only because it declares itself + function hasDeclarationOtherThanSelf(member) { + if (!ts.length(member.declarations)) + return true; + return ts.some(member.declarations, function (decl) { return decl.parent !== obj; }); + } + } + Completions.getPropertiesForObjectExpression = getPropertiesForObjectExpression; + function getApparentProperties(type, node, checker) { + if (!type.isUnion()) + return type.getApparentProperties(); + return checker.getAllPossiblePropertiesOfTypes(ts.filter(type.types, function (memberType) { + return !(memberType.flags & 131068 /* TypeFlags.Primitive */ + || checker.isArrayLikeType(memberType) + || checker.isTypeInvalidDueToUnionDiscriminant(memberType, node) + || ts.typeHasCallOrConstructSignatures(memberType, checker) + || memberType.isClass() && containsNonPublicProperties(memberType.getApparentProperties())); + })); + } + function containsNonPublicProperties(props) { + return ts.some(props, function (p) { return !!(ts.getDeclarationModifierFlagsFromSymbol(p) & 24 /* ModifierFlags.NonPublicAccessibilityModifier */); }); + } + /** + * Gets all properties on a type, but if that type is a union of several types, + * excludes array-like types or callable/constructable types. + */ + function getPropertiesForCompletion(type, checker) { + return type.isUnion() + ? ts.Debug.checkEachDefined(checker.getAllPossiblePropertiesOfTypes(type.types), "getAllPossiblePropertiesOfTypes() should all be defined") + : ts.Debug.checkEachDefined(type.getApparentProperties(), "getApparentProperties() should all be defined"); + } + /** + * Returns the immediate owning class declaration of a context token, + * on the condition that one exists and that the context implies completion should be given. + */ + function tryGetObjectTypeDeclarationCompletionContainer(sourceFile, contextToken, location, position) { + // class c { method() { } | method2() { } } + switch (location.kind) { + case 351 /* SyntaxKind.SyntaxList */: + return ts.tryCast(location.parent, ts.isObjectTypeDeclaration); + case 1 /* SyntaxKind.EndOfFileToken */: + var cls = ts.tryCast(ts.lastOrUndefined(ts.cast(location.parent, ts.isSourceFile).statements), ts.isObjectTypeDeclaration); + if (cls && !ts.findChildOfKind(cls, 19 /* SyntaxKind.CloseBraceToken */, sourceFile)) { + return cls; + } + break; + case 79 /* SyntaxKind.Identifier */: { + var originalKeywordKind = location.originalKeywordKind; + if (originalKeywordKind && ts.isKeyword(originalKeywordKind)) { + return undefined; + } + // class c { public prop = c| } + if (ts.isPropertyDeclaration(location.parent) && location.parent.initializer === location) { + return undefined; + } + // class c extends React.Component { a: () => 1\n compon| } + if (isFromObjectTypeDeclaration(location)) { + return ts.findAncestor(location, ts.isObjectTypeDeclaration); + } + } + } + if (!contextToken) + return undefined; + // class C { blah; constructor/**/ } and so on + if (location.kind === 135 /* SyntaxKind.ConstructorKeyword */ + // class C { blah \n constructor/**/ } + || (ts.isIdentifier(contextToken) && ts.isPropertyDeclaration(contextToken.parent) && ts.isClassLike(location))) { + return ts.findAncestor(contextToken, ts.isClassLike); + } + switch (contextToken.kind) { + case 63 /* SyntaxKind.EqualsToken */: // class c { public prop = | /* global completions */ } + return undefined; + case 26 /* SyntaxKind.SemicolonToken */: // class c {getValue(): number; | } + case 19 /* SyntaxKind.CloseBraceToken */: // class c { method() { } | } + // class c { method() { } b| } + return isFromObjectTypeDeclaration(location) && location.parent.name === location + ? location.parent.parent + : ts.tryCast(location, ts.isObjectTypeDeclaration); + case 18 /* SyntaxKind.OpenBraceToken */: // class c { | + case 27 /* SyntaxKind.CommaToken */: // class c {getValue(): number, | } + return ts.tryCast(contextToken.parent, ts.isObjectTypeDeclaration); + default: + if (!isFromObjectTypeDeclaration(contextToken)) { + // class c extends React.Component { a: () => 1\n| } + if (ts.getLineAndCharacterOfPosition(sourceFile, contextToken.getEnd()).line !== ts.getLineAndCharacterOfPosition(sourceFile, position).line && ts.isObjectTypeDeclaration(location)) { + return location; + } + return undefined; + } + var isValidKeyword = ts.isClassLike(contextToken.parent.parent) ? isClassMemberCompletionKeyword : isInterfaceOrTypeLiteralCompletionKeyword; + return (isValidKeyword(contextToken.kind) || contextToken.kind === 41 /* SyntaxKind.AsteriskToken */ || ts.isIdentifier(contextToken) && isValidKeyword(ts.stringToToken(contextToken.text))) // TODO: GH#18217 + ? contextToken.parent.parent : undefined; + } + } + function tryGetTypeLiteralNode(node) { + if (!node) + return undefined; + var parent = node.parent; + switch (node.kind) { + case 18 /* SyntaxKind.OpenBraceToken */: + if (ts.isTypeLiteralNode(parent)) { + return parent; + } + break; + case 26 /* SyntaxKind.SemicolonToken */: + case 27 /* SyntaxKind.CommaToken */: + case 79 /* SyntaxKind.Identifier */: + if (parent.kind === 168 /* SyntaxKind.PropertySignature */ && ts.isTypeLiteralNode(parent.parent)) { + return parent.parent; + } + break; + } + return undefined; + } + function getConstraintOfTypeArgumentProperty(node, checker) { + if (!node) + return undefined; + if (ts.isTypeNode(node) && ts.isTypeReferenceType(node.parent)) { + return checker.getTypeArgumentConstraint(node); + } + var t = getConstraintOfTypeArgumentProperty(node.parent, checker); + if (!t) + return undefined; + switch (node.kind) { + case 168 /* SyntaxKind.PropertySignature */: + return checker.getTypeOfPropertyOfContextualType(t, node.symbol.escapedName); + case 190 /* SyntaxKind.IntersectionType */: + case 184 /* SyntaxKind.TypeLiteral */: + case 189 /* SyntaxKind.UnionType */: + return t; + } + } + // TODO: GH#19856 Would like to return `node is Node & { parent: (ClassElement | TypeElement) & { parent: ObjectTypeDeclaration } }` but then compilation takes > 10 minutes + function isFromObjectTypeDeclaration(node) { + return node.parent && ts.isClassOrTypeElement(node.parent) && ts.isObjectTypeDeclaration(node.parent.parent); + } + function isValidTrigger(sourceFile, triggerCharacter, contextToken, position) { + switch (triggerCharacter) { + case ".": + case "@": + return true; + case '"': + case "'": + case "`": + // Only automatically bring up completions if this is an opening quote. + return !!contextToken && ts.isStringLiteralOrTemplate(contextToken) && position === contextToken.getStart(sourceFile) + 1; + case "#": + return !!contextToken && ts.isPrivateIdentifier(contextToken) && !!ts.getContainingClass(contextToken); + case "<": + // Opening JSX tag + return !!contextToken && contextToken.kind === 29 /* SyntaxKind.LessThanToken */ && (!ts.isBinaryExpression(contextToken.parent) || binaryExpressionMayBeOpenTag(contextToken.parent)); + case "/": + return !!contextToken && (ts.isStringLiteralLike(contextToken) + ? !!ts.tryGetImportFromModuleSpecifier(contextToken) + : contextToken.kind === 43 /* SyntaxKind.SlashToken */ && ts.isJsxClosingElement(contextToken.parent)); + case " ": + return !!contextToken && ts.isImportKeyword(contextToken) && contextToken.parent.kind === 308 /* SyntaxKind.SourceFile */; + default: + return ts.Debug.assertNever(triggerCharacter); + } + } + function binaryExpressionMayBeOpenTag(_a) { + var left = _a.left; + return ts.nodeIsMissing(left); + } + /** Determines if a type is exactly the same type resolved by the global 'self', 'global', or 'globalThis'. */ + function isProbablyGlobalType(type, sourceFile, checker) { + // The type of `self` and `window` is the same in lib.dom.d.ts, but `window` does not exist in + // lib.webworker.d.ts, so checking against `self` is also a check against `window` when it exists. + var selfSymbol = checker.resolveName("self", /*location*/ undefined, 111551 /* SymbolFlags.Value */, /*excludeGlobals*/ false); + if (selfSymbol && checker.getTypeOfSymbolAtLocation(selfSymbol, sourceFile) === type) { + return true; + } + var globalSymbol = checker.resolveName("global", /*location*/ undefined, 111551 /* SymbolFlags.Value */, /*excludeGlobals*/ false); + if (globalSymbol && checker.getTypeOfSymbolAtLocation(globalSymbol, sourceFile) === type) { + return true; + } + var globalThisSymbol = checker.resolveName("globalThis", /*location*/ undefined, 111551 /* SymbolFlags.Value */, /*excludeGlobals*/ false); + if (globalThisSymbol && checker.getTypeOfSymbolAtLocation(globalThisSymbol, sourceFile) === type) { + return true; + } + return false; + } + function isStaticProperty(symbol) { + return !!(symbol.valueDeclaration && ts.getEffectiveModifierFlags(symbol.valueDeclaration) & 32 /* ModifierFlags.Static */ && ts.isClassLike(symbol.valueDeclaration.parent)); + } + function tryGetObjectLiteralContextualType(node, typeChecker) { + var type = typeChecker.getContextualType(node); + if (type) { + return type; + } + var parent = ts.walkUpParenthesizedExpressions(node.parent); + if (ts.isBinaryExpression(parent) && parent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ && node === parent.left) { + // Object literal is assignment pattern: ({ | } = x) + return typeChecker.getTypeAtLocation(parent); + } + if (ts.isExpression(parent)) { + // f(() => (({ | }))); + return typeChecker.getContextualType(parent); + } + return undefined; + } + function getImportStatementCompletionInfo(contextToken) { + var _a, _b, _c; + var keywordCompletion; + var isKeywordOnlyCompletion = false; + var candidate = getCandidate(); + return { + isKeywordOnlyCompletion: isKeywordOnlyCompletion, + keywordCompletion: keywordCompletion, + isNewIdentifierLocation: !!(candidate || keywordCompletion === 154 /* SyntaxKind.TypeKeyword */), + isTopLevelTypeOnly: !!((_b = (_a = ts.tryCast(candidate, ts.isImportDeclaration)) === null || _a === void 0 ? void 0 : _a.importClause) === null || _b === void 0 ? void 0 : _b.isTypeOnly) || !!((_c = ts.tryCast(candidate, ts.isImportEqualsDeclaration)) === null || _c === void 0 ? void 0 : _c.isTypeOnly), + couldBeTypeOnlyImportSpecifier: !!candidate && couldBeTypeOnlyImportSpecifier(candidate, contextToken), + replacementSpan: getSingleLineReplacementSpanForImportCompletionNode(candidate), + }; + function getCandidate() { + var parent = contextToken.parent; + if (ts.isImportEqualsDeclaration(parent)) { + keywordCompletion = contextToken.kind === 154 /* SyntaxKind.TypeKeyword */ ? undefined : 154 /* SyntaxKind.TypeKeyword */; + return isModuleSpecifierMissingOrEmpty(parent.moduleReference) ? parent : undefined; + } + if (couldBeTypeOnlyImportSpecifier(parent, contextToken) && canCompleteFromNamedBindings(parent.parent)) { + return parent; + } + if (ts.isNamedImports(parent) || ts.isNamespaceImport(parent)) { + if (!parent.parent.isTypeOnly && (contextToken.kind === 18 /* SyntaxKind.OpenBraceToken */ || + contextToken.kind === 100 /* SyntaxKind.ImportKeyword */ || + contextToken.kind === 27 /* SyntaxKind.CommaToken */)) { + keywordCompletion = 154 /* SyntaxKind.TypeKeyword */; + } + if (canCompleteFromNamedBindings(parent)) { + // At `import { ... } |` or `import * as Foo |`, the only possible completion is `from` + if (contextToken.kind === 19 /* SyntaxKind.CloseBraceToken */ || contextToken.kind === 79 /* SyntaxKind.Identifier */) { + isKeywordOnlyCompletion = true; + keywordCompletion = 158 /* SyntaxKind.FromKeyword */; + } + else { + return parent.parent.parent; + } + } + return undefined; + } + if (ts.isImportKeyword(contextToken) && ts.isSourceFile(parent)) { + // A lone import keyword with nothing following it does not parse as a statement at all + keywordCompletion = 154 /* SyntaxKind.TypeKeyword */; + return contextToken; + } + if (ts.isImportKeyword(contextToken) && ts.isImportDeclaration(parent)) { + // `import s| from` + keywordCompletion = 154 /* SyntaxKind.TypeKeyword */; + return isModuleSpecifierMissingOrEmpty(parent.moduleSpecifier) ? parent : undefined; + } + return undefined; + } + } + function getSingleLineReplacementSpanForImportCompletionNode(node) { + var _a, _b, _c; + if (!node) + return undefined; + var top = (_a = ts.findAncestor(node, ts.or(ts.isImportDeclaration, ts.isImportEqualsDeclaration))) !== null && _a !== void 0 ? _a : node; + var sourceFile = top.getSourceFile(); + if (ts.rangeIsOnSingleLine(top, sourceFile)) { + return ts.createTextSpanFromNode(top, sourceFile); + } + // ImportKeyword was necessarily on one line; ImportSpecifier was necessarily parented in an ImportDeclaration + ts.Debug.assert(top.kind !== 100 /* SyntaxKind.ImportKeyword */ && top.kind !== 273 /* SyntaxKind.ImportSpecifier */); + // Guess which point in the import might actually be a later statement parsed as part of the import + // during parser recovery - either in the middle of named imports, or the module specifier. + var potentialSplitPoint = top.kind === 269 /* SyntaxKind.ImportDeclaration */ + ? (_c = getPotentiallyInvalidImportSpecifier((_b = top.importClause) === null || _b === void 0 ? void 0 : _b.namedBindings)) !== null && _c !== void 0 ? _c : top.moduleSpecifier + : top.moduleReference; + var withoutModuleSpecifier = { + pos: top.getFirstToken().getStart(), + end: potentialSplitPoint.pos, + }; + // The module specifier/reference was previously found to be missing, empty, or + // not a string literal - in this last case, it's likely that statement on a following + // line was parsed as the module specifier of a partially-typed import, e.g. + // import Foo| + // interface Blah {} + // This appears to be a multiline-import, and editors can't replace multiple lines. + // But if everything but the "module specifier" is on one line, by this point we can + // assume that the "module specifier" is actually just another statement, and return + // the single-line range of the import excluding that probable statement. + if (ts.rangeIsOnSingleLine(withoutModuleSpecifier, sourceFile)) { + return ts.createTextSpanFromRange(withoutModuleSpecifier); + } + } + // Tries to identify the first named import that is not really a named import, but rather + // just parser recovery for a situation like: + // import { Foo| + // interface Bar {} + // in which `Foo`, `interface`, and `Bar` are all parsed as import specifiers. The caller + // will also check if this token is on a separate line from the rest of the import. + function getPotentiallyInvalidImportSpecifier(namedBindings) { + var _a; + return ts.find((_a = ts.tryCast(namedBindings, ts.isNamedImports)) === null || _a === void 0 ? void 0 : _a.elements, function (e) { + var _a; + return !e.propertyName && + ts.isStringANonContextualKeyword(e.name.text) && + ((_a = ts.findPrecedingToken(e.name.pos, namedBindings.getSourceFile(), namedBindings)) === null || _a === void 0 ? void 0 : _a.kind) !== 27 /* SyntaxKind.CommaToken */; + }); + } + function couldBeTypeOnlyImportSpecifier(importSpecifier, contextToken) { + return ts.isImportSpecifier(importSpecifier) + && (importSpecifier.isTypeOnly || contextToken === importSpecifier.name && ts.isTypeKeywordTokenOrIdentifier(contextToken)); + } + function canCompleteFromNamedBindings(namedBindings) { + if (!isModuleSpecifierMissingOrEmpty(namedBindings.parent.parent.moduleSpecifier) || namedBindings.parent.name) { + return false; + } + if (ts.isNamedImports(namedBindings)) { + // We can only complete on named imports if there are no other named imports already, + // but parser recovery sometimes puts later statements in the named imports list, so + // we try to only consider the probably-valid ones. + var invalidNamedImport = getPotentiallyInvalidImportSpecifier(namedBindings); + var validImports = invalidNamedImport ? namedBindings.elements.indexOf(invalidNamedImport) : namedBindings.elements.length; + return validImports < 2; + } + return true; + } + function isModuleSpecifierMissingOrEmpty(specifier) { + var _a; + if (ts.nodeIsMissing(specifier)) + return true; + return !((_a = ts.tryCast(ts.isExternalModuleReference(specifier) ? specifier.expression : specifier, ts.isStringLiteralLike)) === null || _a === void 0 ? void 0 : _a.text); + } + function getVariableDeclaration(property) { + var variableDeclaration = ts.findAncestor(property, function (node) { + return ts.isFunctionBlock(node) || isArrowFunctionBody(node) || ts.isBindingPattern(node) + ? "quit" + : ts.isVariableDeclaration(node); + }); + return variableDeclaration; + } + function isArrowFunctionBody(node) { + return node.parent && ts.isArrowFunction(node.parent) && node.parent.body === node; + } + /** True if symbol is a type or a module containing at least one type. */ + function symbolCanBeReferencedAtTypeLocation(symbol, checker, seenModules) { + if (seenModules === void 0) { seenModules = new ts.Map(); } + // Since an alias can be merged with a local declaration, we need to test both the alias and its target. + // This code used to just test the result of `skipAlias`, but that would ignore any locally introduced meanings. + return nonAliasCanBeReferencedAtTypeLocation(symbol) || nonAliasCanBeReferencedAtTypeLocation(ts.skipAlias(symbol.exportSymbol || symbol, checker)); + function nonAliasCanBeReferencedAtTypeLocation(symbol) { + return !!(symbol.flags & 788968 /* SymbolFlags.Type */) || checker.isUnknownSymbol(symbol) || + !!(symbol.flags & 1536 /* SymbolFlags.Module */) && ts.addToSeen(seenModules, ts.getSymbolId(symbol)) && + checker.getExportsOfModule(symbol).some(function (e) { return symbolCanBeReferencedAtTypeLocation(e, checker, seenModules); }); + } + } + function isDeprecated(symbol, checker) { + var declarations = ts.skipAlias(symbol, checker).declarations; + return !!ts.length(declarations) && ts.every(declarations, ts.isDeprecatedDeclaration); + } + /** + * True if the first character of `lowercaseCharacters` is the first character + * of some "word" in `identiferString` (where the string is split into "words" + * by camelCase and snake_case segments), then if the remaining characters of + * `lowercaseCharacters` appear, in order, in the rest of `identifierString`. + * + * True: + * 'state' in 'useState' + * 'sae' in 'useState' + * 'viable' in 'ENVIRONMENT_VARIABLE' + * + * False: + * 'staet' in 'useState' + * 'tate' in 'useState' + * 'ment' in 'ENVIRONMENT_VARIABLE' + */ + function charactersFuzzyMatchInString(identifierString, lowercaseCharacters) { + if (lowercaseCharacters.length === 0) { + return true; + } + var matchedFirstCharacter = false; + var prevChar; + var characterIndex = 0; + var len = identifierString.length; + for (var strIndex = 0; strIndex < len; strIndex++) { + var strChar = identifierString.charCodeAt(strIndex); + var testChar = lowercaseCharacters.charCodeAt(characterIndex); + if (strChar === testChar || strChar === toUpperCharCode(testChar)) { + matchedFirstCharacter || (matchedFirstCharacter = prevChar === undefined || // Beginning of word + 97 /* CharacterCodes.a */ <= prevChar && prevChar <= 122 /* CharacterCodes.z */ && 65 /* CharacterCodes.A */ <= strChar && strChar <= 90 /* CharacterCodes.Z */ || // camelCase transition + prevChar === 95 /* CharacterCodes._ */ && strChar !== 95 /* CharacterCodes._ */); // snake_case transition + if (matchedFirstCharacter) { + characterIndex++; + } + if (characterIndex === lowercaseCharacters.length) { + return true; + } + } + prevChar = strChar; + } + // Did not find all characters + return false; + } + function toUpperCharCode(charCode) { + if (97 /* CharacterCodes.a */ <= charCode && charCode <= 122 /* CharacterCodes.z */) { + return charCode - 32; + } + return charCode; + } + })(Completions = ts.Completions || (ts.Completions = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + /* @internal */ + var DocumentHighlights; + (function (DocumentHighlights) { + function getDocumentHighlights(program, cancellationToken, sourceFile, position, sourceFilesToSearch) { + var node = ts.getTouchingPropertyName(sourceFile, position); + if (node.parent && (ts.isJsxOpeningElement(node.parent) && node.parent.tagName === node || ts.isJsxClosingElement(node.parent))) { + // For a JSX element, just highlight the matching tag, not all references. + var _a = node.parent.parent, openingElement = _a.openingElement, closingElement = _a.closingElement; + var highlightSpans = [openingElement, closingElement].map(function (_a) { + var tagName = _a.tagName; + return getHighlightSpanForNode(tagName, sourceFile); + }); + return [{ fileName: sourceFile.fileName, highlightSpans: highlightSpans }]; + } + return getSemanticDocumentHighlights(position, node, program, cancellationToken, sourceFilesToSearch) || getSyntacticDocumentHighlights(node, sourceFile); + } + DocumentHighlights.getDocumentHighlights = getDocumentHighlights; + function getHighlightSpanForNode(node, sourceFile) { + return { + fileName: sourceFile.fileName, + textSpan: ts.createTextSpanFromNode(node, sourceFile), + kind: "none" /* HighlightSpanKind.none */ + }; + } + function getSemanticDocumentHighlights(position, node, program, cancellationToken, sourceFilesToSearch) { + var sourceFilesSet = new ts.Set(sourceFilesToSearch.map(function (f) { return f.fileName; })); + var referenceEntries = ts.FindAllReferences.getReferenceEntriesForNode(position, node, program, sourceFilesToSearch, cancellationToken, /*options*/ undefined, sourceFilesSet); + if (!referenceEntries) + return undefined; + var map = ts.arrayToMultiMap(referenceEntries.map(ts.FindAllReferences.toHighlightSpan), function (e) { return e.fileName; }, function (e) { return e.span; }); + var getCanonicalFileName = ts.createGetCanonicalFileName(program.useCaseSensitiveFileNames()); + return ts.mapDefined(ts.arrayFrom(map.entries()), function (_a) { + var fileName = _a[0], highlightSpans = _a[1]; + if (!sourceFilesSet.has(fileName)) { + if (!program.redirectTargetsMap.has(ts.toPath(fileName, program.getCurrentDirectory(), getCanonicalFileName))) { + return undefined; + } + var redirectTarget_1 = program.getSourceFile(fileName); + var redirect = ts.find(sourceFilesToSearch, function (f) { return !!f.redirectInfo && f.redirectInfo.redirectTarget === redirectTarget_1; }); + fileName = redirect.fileName; + ts.Debug.assert(sourceFilesSet.has(fileName)); + } + return { fileName: fileName, highlightSpans: highlightSpans }; + }); + } + function getSyntacticDocumentHighlights(node, sourceFile) { + var highlightSpans = getHighlightSpans(node, sourceFile); + return highlightSpans && [{ fileName: sourceFile.fileName, highlightSpans: highlightSpans }]; + } + function getHighlightSpans(node, sourceFile) { + switch (node.kind) { + case 99 /* SyntaxKind.IfKeyword */: + case 91 /* SyntaxKind.ElseKeyword */: + return ts.isIfStatement(node.parent) ? getIfElseOccurrences(node.parent, sourceFile) : undefined; + case 105 /* SyntaxKind.ReturnKeyword */: + return useParent(node.parent, ts.isReturnStatement, getReturnOccurrences); + case 109 /* SyntaxKind.ThrowKeyword */: + return useParent(node.parent, ts.isThrowStatement, getThrowOccurrences); + case 111 /* SyntaxKind.TryKeyword */: + case 83 /* SyntaxKind.CatchKeyword */: + case 96 /* SyntaxKind.FinallyKeyword */: + var tryStatement = node.kind === 83 /* SyntaxKind.CatchKeyword */ ? node.parent.parent : node.parent; + return useParent(tryStatement, ts.isTryStatement, getTryCatchFinallyOccurrences); + case 107 /* SyntaxKind.SwitchKeyword */: + return useParent(node.parent, ts.isSwitchStatement, getSwitchCaseDefaultOccurrences); + case 82 /* SyntaxKind.CaseKeyword */: + case 88 /* SyntaxKind.DefaultKeyword */: { + if (ts.isDefaultClause(node.parent) || ts.isCaseClause(node.parent)) { + return useParent(node.parent.parent.parent, ts.isSwitchStatement, getSwitchCaseDefaultOccurrences); + } + return undefined; + } + case 81 /* SyntaxKind.BreakKeyword */: + case 86 /* SyntaxKind.ContinueKeyword */: + return useParent(node.parent, ts.isBreakOrContinueStatement, getBreakOrContinueStatementOccurrences); + case 97 /* SyntaxKind.ForKeyword */: + case 115 /* SyntaxKind.WhileKeyword */: + case 90 /* SyntaxKind.DoKeyword */: + return useParent(node.parent, function (n) { return ts.isIterationStatement(n, /*lookInLabeledStatements*/ true); }, getLoopBreakContinueOccurrences); + case 135 /* SyntaxKind.ConstructorKeyword */: + return getFromAllDeclarations(ts.isConstructorDeclaration, [135 /* SyntaxKind.ConstructorKeyword */]); + case 137 /* SyntaxKind.GetKeyword */: + case 151 /* SyntaxKind.SetKeyword */: + return getFromAllDeclarations(ts.isAccessor, [137 /* SyntaxKind.GetKeyword */, 151 /* SyntaxKind.SetKeyword */]); + case 133 /* SyntaxKind.AwaitKeyword */: + return useParent(node.parent, ts.isAwaitExpression, getAsyncAndAwaitOccurrences); + case 132 /* SyntaxKind.AsyncKeyword */: + return highlightSpans(getAsyncAndAwaitOccurrences(node)); + case 125 /* SyntaxKind.YieldKeyword */: + return highlightSpans(getYieldOccurrences(node)); + case 101 /* SyntaxKind.InKeyword */: + return undefined; + default: + return ts.isModifierKind(node.kind) && (ts.isDeclaration(node.parent) || ts.isVariableStatement(node.parent)) + ? highlightSpans(getModifierOccurrences(node.kind, node.parent)) + : undefined; + } + function getFromAllDeclarations(nodeTest, keywords) { + return useParent(node.parent, nodeTest, function (decl) { return ts.mapDefined(decl.symbol.declarations, function (d) { + return nodeTest(d) ? ts.find(d.getChildren(sourceFile), function (c) { return ts.contains(keywords, c.kind); }) : undefined; + }); }); + } + function useParent(node, nodeTest, getNodes) { + return nodeTest(node) ? highlightSpans(getNodes(node, sourceFile)) : undefined; + } + function highlightSpans(nodes) { + return nodes && nodes.map(function (node) { return getHighlightSpanForNode(node, sourceFile); }); + } + } + /** + * Aggregates all throw-statements within this node *without* crossing + * into function boundaries and try-blocks with catch-clauses. + */ + function aggregateOwnedThrowStatements(node) { + if (ts.isThrowStatement(node)) { + return [node]; + } + else if (ts.isTryStatement(node)) { + // Exceptions thrown within a try block lacking a catch clause are "owned" in the current context. + return ts.concatenate(node.catchClause ? aggregateOwnedThrowStatements(node.catchClause) : node.tryBlock && aggregateOwnedThrowStatements(node.tryBlock), node.finallyBlock && aggregateOwnedThrowStatements(node.finallyBlock)); + } + // Do not cross function boundaries. + return ts.isFunctionLike(node) ? undefined : flatMapChildren(node, aggregateOwnedThrowStatements); + } + /** + * For lack of a better name, this function takes a throw statement and returns the + * nearest ancestor that is a try-block (whose try statement has a catch clause), + * function-block, or source file. + */ + function getThrowStatementOwner(throwStatement) { + var child = throwStatement; + while (child.parent) { + var parent = child.parent; + if (ts.isFunctionBlock(parent) || parent.kind === 308 /* SyntaxKind.SourceFile */) { + return parent; + } + // A throw-statement is only owned by a try-statement if the try-statement has + // a catch clause, and if the throw-statement occurs within the try block. + if (ts.isTryStatement(parent) && parent.tryBlock === child && parent.catchClause) { + return child; + } + child = parent; + } + return undefined; + } + function aggregateAllBreakAndContinueStatements(node) { + return ts.isBreakOrContinueStatement(node) ? [node] : ts.isFunctionLike(node) ? undefined : flatMapChildren(node, aggregateAllBreakAndContinueStatements); + } + function flatMapChildren(node, cb) { + var result = []; + node.forEachChild(function (child) { + var value = cb(child); + if (value !== undefined) { + result.push.apply(result, ts.toArray(value)); + } + }); + return result; + } + function ownsBreakOrContinueStatement(owner, statement) { + var actualOwner = getBreakOrContinueOwner(statement); + return !!actualOwner && actualOwner === owner; + } + function getBreakOrContinueOwner(statement) { + return ts.findAncestor(statement, function (node) { + switch (node.kind) { + case 252 /* SyntaxKind.SwitchStatement */: + if (statement.kind === 248 /* SyntaxKind.ContinueStatement */) { + return false; + } + // falls through + case 245 /* SyntaxKind.ForStatement */: + case 246 /* SyntaxKind.ForInStatement */: + case 247 /* SyntaxKind.ForOfStatement */: + case 244 /* SyntaxKind.WhileStatement */: + case 243 /* SyntaxKind.DoStatement */: + return !statement.label || isLabeledBy(node, statement.label.escapedText); + default: + // Don't cross function boundaries. + // TODO: GH#20090 + return ts.isFunctionLike(node) && "quit"; + } + }); + } + function getModifierOccurrences(modifier, declaration) { + return ts.mapDefined(getNodesToSearchForModifier(declaration, ts.modifierToFlag(modifier)), function (node) { return ts.findModifier(node, modifier); }); + } + function getNodesToSearchForModifier(declaration, modifierFlag) { + // Types of node whose children might have modifiers. + var container = declaration.parent; + switch (container.kind) { + case 265 /* SyntaxKind.ModuleBlock */: + case 308 /* SyntaxKind.SourceFile */: + case 238 /* SyntaxKind.Block */: + case 292 /* SyntaxKind.CaseClause */: + case 293 /* SyntaxKind.DefaultClause */: + // Container is either a class declaration or the declaration is a classDeclaration + if (modifierFlag & 256 /* ModifierFlags.Abstract */ && ts.isClassDeclaration(declaration)) { + return __spreadArray(__spreadArray([], declaration.members, true), [declaration], false); + } + else { + return container.statements; + } + case 173 /* SyntaxKind.Constructor */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 259 /* SyntaxKind.FunctionDeclaration */: + return __spreadArray(__spreadArray([], container.parameters, true), (ts.isClassLike(container.parent) ? container.parent.members : []), true); + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 184 /* SyntaxKind.TypeLiteral */: + var nodes = container.members; + // If we're an accessibility modifier, we're in an instance member and should search + // the constructor's parameter list for instance members as well. + if (modifierFlag & (28 /* ModifierFlags.AccessibilityModifier */ | 64 /* ModifierFlags.Readonly */)) { + var constructor = ts.find(container.members, ts.isConstructorDeclaration); + if (constructor) { + return __spreadArray(__spreadArray([], nodes, true), constructor.parameters, true); + } + } + else if (modifierFlag & 256 /* ModifierFlags.Abstract */) { + return __spreadArray(__spreadArray([], nodes, true), [container], false); + } + return nodes; + // Syntactically invalid positions that the parser might produce anyway + case 207 /* SyntaxKind.ObjectLiteralExpression */: + return undefined; + default: + ts.Debug.assertNever(container, "Invalid container kind."); + } + } + function pushKeywordIf(keywordList, token) { + var expected = []; + for (var _i = 2; _i < arguments.length; _i++) { + expected[_i - 2] = arguments[_i]; + } + if (token && ts.contains(expected, token.kind)) { + keywordList.push(token); + return true; + } + return false; + } + function getLoopBreakContinueOccurrences(loopNode) { + var keywords = []; + if (pushKeywordIf(keywords, loopNode.getFirstToken(), 97 /* SyntaxKind.ForKeyword */, 115 /* SyntaxKind.WhileKeyword */, 90 /* SyntaxKind.DoKeyword */)) { + // If we succeeded and got a do-while loop, then start looking for a 'while' keyword. + if (loopNode.kind === 243 /* SyntaxKind.DoStatement */) { + var loopTokens = loopNode.getChildren(); + for (var i = loopTokens.length - 1; i >= 0; i--) { + if (pushKeywordIf(keywords, loopTokens[i], 115 /* SyntaxKind.WhileKeyword */)) { + break; + } + } + } + } + ts.forEach(aggregateAllBreakAndContinueStatements(loopNode.statement), function (statement) { + if (ownsBreakOrContinueStatement(loopNode, statement)) { + pushKeywordIf(keywords, statement.getFirstToken(), 81 /* SyntaxKind.BreakKeyword */, 86 /* SyntaxKind.ContinueKeyword */); + } + }); + return keywords; + } + function getBreakOrContinueStatementOccurrences(breakOrContinueStatement) { + var owner = getBreakOrContinueOwner(breakOrContinueStatement); + if (owner) { + switch (owner.kind) { + case 245 /* SyntaxKind.ForStatement */: + case 246 /* SyntaxKind.ForInStatement */: + case 247 /* SyntaxKind.ForOfStatement */: + case 243 /* SyntaxKind.DoStatement */: + case 244 /* SyntaxKind.WhileStatement */: + return getLoopBreakContinueOccurrences(owner); + case 252 /* SyntaxKind.SwitchStatement */: + return getSwitchCaseDefaultOccurrences(owner); + } + } + return undefined; + } + function getSwitchCaseDefaultOccurrences(switchStatement) { + var keywords = []; + pushKeywordIf(keywords, switchStatement.getFirstToken(), 107 /* SyntaxKind.SwitchKeyword */); + // Go through each clause in the switch statement, collecting the 'case'/'default' keywords. + ts.forEach(switchStatement.caseBlock.clauses, function (clause) { + pushKeywordIf(keywords, clause.getFirstToken(), 82 /* SyntaxKind.CaseKeyword */, 88 /* SyntaxKind.DefaultKeyword */); + ts.forEach(aggregateAllBreakAndContinueStatements(clause), function (statement) { + if (ownsBreakOrContinueStatement(switchStatement, statement)) { + pushKeywordIf(keywords, statement.getFirstToken(), 81 /* SyntaxKind.BreakKeyword */); + } + }); + }); + return keywords; + } + function getTryCatchFinallyOccurrences(tryStatement, sourceFile) { + var keywords = []; + pushKeywordIf(keywords, tryStatement.getFirstToken(), 111 /* SyntaxKind.TryKeyword */); + if (tryStatement.catchClause) { + pushKeywordIf(keywords, tryStatement.catchClause.getFirstToken(), 83 /* SyntaxKind.CatchKeyword */); + } + if (tryStatement.finallyBlock) { + var finallyKeyword = ts.findChildOfKind(tryStatement, 96 /* SyntaxKind.FinallyKeyword */, sourceFile); + pushKeywordIf(keywords, finallyKeyword, 96 /* SyntaxKind.FinallyKeyword */); + } + return keywords; + } + function getThrowOccurrences(throwStatement, sourceFile) { + var owner = getThrowStatementOwner(throwStatement); + if (!owner) { + return undefined; + } + var keywords = []; + ts.forEach(aggregateOwnedThrowStatements(owner), function (throwStatement) { + keywords.push(ts.findChildOfKind(throwStatement, 109 /* SyntaxKind.ThrowKeyword */, sourceFile)); + }); + // If the "owner" is a function, then we equate 'return' and 'throw' statements in their + // ability to "jump out" of the function, and include occurrences for both. + if (ts.isFunctionBlock(owner)) { + ts.forEachReturnStatement(owner, function (returnStatement) { + keywords.push(ts.findChildOfKind(returnStatement, 105 /* SyntaxKind.ReturnKeyword */, sourceFile)); + }); + } + return keywords; + } + function getReturnOccurrences(returnStatement, sourceFile) { + var func = ts.getContainingFunction(returnStatement); + if (!func) { + return undefined; + } + var keywords = []; + ts.forEachReturnStatement(ts.cast(func.body, ts.isBlock), function (returnStatement) { + keywords.push(ts.findChildOfKind(returnStatement, 105 /* SyntaxKind.ReturnKeyword */, sourceFile)); + }); + // Include 'throw' statements that do not occur within a try block. + ts.forEach(aggregateOwnedThrowStatements(func.body), function (throwStatement) { + keywords.push(ts.findChildOfKind(throwStatement, 109 /* SyntaxKind.ThrowKeyword */, sourceFile)); + }); + return keywords; + } + function getAsyncAndAwaitOccurrences(node) { + var func = ts.getContainingFunction(node); + if (!func) { + return undefined; + } + var keywords = []; + if (func.modifiers) { + func.modifiers.forEach(function (modifier) { + pushKeywordIf(keywords, modifier, 132 /* SyntaxKind.AsyncKeyword */); + }); + } + ts.forEachChild(func, function (child) { + traverseWithoutCrossingFunction(child, function (node) { + if (ts.isAwaitExpression(node)) { + pushKeywordIf(keywords, node.getFirstToken(), 133 /* SyntaxKind.AwaitKeyword */); + } + }); + }); + return keywords; + } + function getYieldOccurrences(node) { + var func = ts.getContainingFunction(node); + if (!func) { + return undefined; + } + var keywords = []; + ts.forEachChild(func, function (child) { + traverseWithoutCrossingFunction(child, function (node) { + if (ts.isYieldExpression(node)) { + pushKeywordIf(keywords, node.getFirstToken(), 125 /* SyntaxKind.YieldKeyword */); + } + }); + }); + return keywords; + } + // Do not cross function/class/interface/module/type boundaries. + function traverseWithoutCrossingFunction(node, cb) { + cb(node); + if (!ts.isFunctionLike(node) && !ts.isClassLike(node) && !ts.isInterfaceDeclaration(node) && !ts.isModuleDeclaration(node) && !ts.isTypeAliasDeclaration(node) && !ts.isTypeNode(node)) { + ts.forEachChild(node, function (child) { return traverseWithoutCrossingFunction(child, cb); }); + } + } + function getIfElseOccurrences(ifStatement, sourceFile) { + var keywords = getIfElseKeywords(ifStatement, sourceFile); + var result = []; + // We'd like to highlight else/ifs together if they are only separated by whitespace + // (i.e. the keywords are separated by no comments, no newlines). + for (var i = 0; i < keywords.length; i++) { + if (keywords[i].kind === 91 /* SyntaxKind.ElseKeyword */ && i < keywords.length - 1) { + var elseKeyword = keywords[i]; + var ifKeyword = keywords[i + 1]; // this *should* always be an 'if' keyword. + var shouldCombineElseAndIf = true; + // Avoid recalculating getStart() by iterating backwards. + for (var j = ifKeyword.getStart(sourceFile) - 1; j >= elseKeyword.end; j--) { + if (!ts.isWhiteSpaceSingleLine(sourceFile.text.charCodeAt(j))) { + shouldCombineElseAndIf = false; + break; + } + } + if (shouldCombineElseAndIf) { + result.push({ + fileName: sourceFile.fileName, + textSpan: ts.createTextSpanFromBounds(elseKeyword.getStart(), ifKeyword.end), + kind: "reference" /* HighlightSpanKind.reference */ + }); + i++; // skip the next keyword + continue; + } + } + // Ordinary case: just highlight the keyword. + result.push(getHighlightSpanForNode(keywords[i], sourceFile)); + } + return result; + } + function getIfElseKeywords(ifStatement, sourceFile) { + var keywords = []; + // Traverse upwards through all parent if-statements linked by their else-branches. + while (ts.isIfStatement(ifStatement.parent) && ifStatement.parent.elseStatement === ifStatement) { + ifStatement = ifStatement.parent; + } + // Now traverse back down through the else branches, aggregating if/else keywords of if-statements. + while (true) { + var children = ifStatement.getChildren(sourceFile); + pushKeywordIf(keywords, children[0], 99 /* SyntaxKind.IfKeyword */); + // Generally the 'else' keyword is second-to-last, so we traverse backwards. + for (var i = children.length - 1; i >= 0; i--) { + if (pushKeywordIf(keywords, children[i], 91 /* SyntaxKind.ElseKeyword */)) { + break; + } + } + if (!ifStatement.elseStatement || !ts.isIfStatement(ifStatement.elseStatement)) { + break; + } + ifStatement = ifStatement.elseStatement; + } + return keywords; + } + /** + * Whether or not a 'node' is preceded by a label of the given string. + * Note: 'node' cannot be a SourceFile. + */ + function isLabeledBy(node, labelName) { + return !!ts.findAncestor(node.parent, function (owner) { return !ts.isLabeledStatement(owner) ? "quit" : owner.label.escapedText === labelName; }); + } + })(DocumentHighlights = ts.DocumentHighlights || (ts.DocumentHighlights = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + function isDocumentRegistryEntry(entry) { + return !!entry.sourceFile; + } + function createDocumentRegistry(useCaseSensitiveFileNames, currentDirectory) { + return createDocumentRegistryInternal(useCaseSensitiveFileNames, currentDirectory); + } + ts.createDocumentRegistry = createDocumentRegistry; + /*@internal*/ + function createDocumentRegistryInternal(useCaseSensitiveFileNames, currentDirectory, externalCache) { + if (currentDirectory === void 0) { currentDirectory = ""; } + // Maps from compiler setting target (ES3, ES5, etc.) to all the cached documents we have + // for those settings. + var buckets = new ts.Map(); + var getCanonicalFileName = ts.createGetCanonicalFileName(!!useCaseSensitiveFileNames); + function reportStats() { + var bucketInfoArray = ts.arrayFrom(buckets.keys()).filter(function (name) { return name && name.charAt(0) === "_"; }).map(function (name) { + var entries = buckets.get(name); + var sourceFiles = []; + entries.forEach(function (entry, name) { + if (isDocumentRegistryEntry(entry)) { + sourceFiles.push({ + name: name, + scriptKind: entry.sourceFile.scriptKind, + refCount: entry.languageServiceRefCount + }); + } + else { + entry.forEach(function (value, scriptKind) { return sourceFiles.push({ name: name, scriptKind: scriptKind, refCount: value.languageServiceRefCount }); }); + } + }); + sourceFiles.sort(function (x, y) { return y.refCount - x.refCount; }); + return { + bucket: name, + sourceFiles: sourceFiles + }; + }); + return JSON.stringify(bucketInfoArray, undefined, 2); + } + function getCompilationSettings(settingsOrHost) { + if (typeof settingsOrHost.getCompilationSettings === "function") { + return settingsOrHost.getCompilationSettings(); + } + return settingsOrHost; + } + function acquireDocument(fileName, compilationSettings, scriptSnapshot, version, scriptKind, languageVersionOrOptions) { + var path = ts.toPath(fileName, currentDirectory, getCanonicalFileName); + var key = getKeyForCompilationSettings(getCompilationSettings(compilationSettings)); + return acquireDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version, scriptKind, languageVersionOrOptions); + } + function acquireDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version, scriptKind, languageVersionOrOptions) { + return acquireOrUpdateDocument(fileName, path, compilationSettings, key, scriptSnapshot, version, /*acquiring*/ true, scriptKind, languageVersionOrOptions); + } + function updateDocument(fileName, compilationSettings, scriptSnapshot, version, scriptKind, languageVersionOrOptions) { + var path = ts.toPath(fileName, currentDirectory, getCanonicalFileName); + var key = getKeyForCompilationSettings(getCompilationSettings(compilationSettings)); + return updateDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version, scriptKind, languageVersionOrOptions); + } + function updateDocumentWithKey(fileName, path, compilationSettings, key, scriptSnapshot, version, scriptKind, languageVersionOrOptions) { + return acquireOrUpdateDocument(fileName, path, getCompilationSettings(compilationSettings), key, scriptSnapshot, version, /*acquiring*/ false, scriptKind, languageVersionOrOptions); + } + function getDocumentRegistryEntry(bucketEntry, scriptKind) { + var entry = isDocumentRegistryEntry(bucketEntry) ? bucketEntry : bucketEntry.get(ts.Debug.checkDefined(scriptKind, "If there are more than one scriptKind's for same document the scriptKind should be provided")); + ts.Debug.assert(scriptKind === undefined || !entry || entry.sourceFile.scriptKind === scriptKind, "Script kind should match provided ScriptKind:".concat(scriptKind, " and sourceFile.scriptKind: ").concat(entry === null || entry === void 0 ? void 0 : entry.sourceFile.scriptKind, ", !entry: ").concat(!entry)); + return entry; + } + function acquireOrUpdateDocument(fileName, path, compilationSettingsOrHost, key, scriptSnapshot, version, acquiring, scriptKind, languageVersionOrOptions) { + var _a, _b, _c, _d; + scriptKind = ts.ensureScriptKind(fileName, scriptKind); + var compilationSettings = getCompilationSettings(compilationSettingsOrHost); + var host = compilationSettingsOrHost === compilationSettings ? undefined : compilationSettingsOrHost; + var scriptTarget = scriptKind === 6 /* ScriptKind.JSON */ ? 100 /* ScriptTarget.JSON */ : ts.getEmitScriptTarget(compilationSettings); + var sourceFileOptions = typeof languageVersionOrOptions === "object" ? + languageVersionOrOptions : + { + languageVersion: scriptTarget, + impliedNodeFormat: host && ts.getImpliedNodeFormatForFile(path, (_d = (_c = (_b = (_a = host.getCompilerHost) === null || _a === void 0 ? void 0 : _a.call(host)) === null || _b === void 0 ? void 0 : _b.getModuleResolutionCache) === null || _c === void 0 ? void 0 : _c.call(_b)) === null || _d === void 0 ? void 0 : _d.getPackageJsonInfoCache(), host, compilationSettings), + setExternalModuleIndicator: ts.getSetExternalModuleIndicator(compilationSettings) + }; + sourceFileOptions.languageVersion = scriptTarget; + var oldBucketCount = buckets.size; + var keyWithMode = getDocumentRegistryBucketKeyWithMode(key, sourceFileOptions.impliedNodeFormat); + var bucket = ts.getOrUpdate(buckets, keyWithMode, function () { return new ts.Map(); }); + if (ts.tracing) { + if (buckets.size > oldBucketCount) { + // It is interesting, but not definitively problematic if a build requires multiple document registry buckets - + // perhaps they are for two projects that don't have any overlap. + // Bonus: these events can help us interpret the more interesting event below. + ts.tracing.instant("session" /* tracing.Phase.Session */, "createdDocumentRegistryBucket", { configFilePath: compilationSettings.configFilePath, key: keyWithMode }); + } + // It is fairly suspicious to have one path in two buckets - you'd expect dependencies to have similar configurations. + // If this occurs unexpectedly, the fix is likely to synchronize the project settings. + // Skip .d.ts files to reduce noise (should also cover most of node_modules). + var otherBucketKey = !ts.isDeclarationFileName(path) && + ts.forEachEntry(buckets, function (bucket, bucketKey) { return bucketKey !== keyWithMode && bucket.has(path) && bucketKey; }); + if (otherBucketKey) { + ts.tracing.instant("session" /* tracing.Phase.Session */, "documentRegistryBucketOverlap", { path: path, key1: otherBucketKey, key2: keyWithMode }); + } + } + var bucketEntry = bucket.get(path); + var entry = bucketEntry && getDocumentRegistryEntry(bucketEntry, scriptKind); + if (!entry && externalCache) { + var sourceFile = externalCache.getDocument(keyWithMode, path); + if (sourceFile) { + ts.Debug.assert(acquiring); + entry = { + sourceFile: sourceFile, + languageServiceRefCount: 0 + }; + setBucketEntry(); + } + } + if (!entry) { + // Have never seen this file with these settings. Create a new source file for it. + var sourceFile = ts.createLanguageServiceSourceFile(fileName, scriptSnapshot, sourceFileOptions, version, /*setNodeParents*/ false, scriptKind); + if (externalCache) { + externalCache.setDocument(keyWithMode, path, sourceFile); + } + entry = { + sourceFile: sourceFile, + languageServiceRefCount: 1, + }; + setBucketEntry(); + } + else { + // We have an entry for this file. However, it may be for a different version of + // the script snapshot. If so, update it appropriately. Otherwise, we can just + // return it as is. + if (entry.sourceFile.version !== version) { + entry.sourceFile = ts.updateLanguageServiceSourceFile(entry.sourceFile, scriptSnapshot, version, scriptSnapshot.getChangeRange(entry.sourceFile.scriptSnapshot)); // TODO: GH#18217 + if (externalCache) { + externalCache.setDocument(keyWithMode, path, entry.sourceFile); + } + } + // If we're acquiring, then this is the first time this LS is asking for this document. + // Increase our ref count so we know there's another LS using the document. If we're + // not acquiring, then that means the LS is 'updating' the file instead, and that means + // it has already acquired the document previously. As such, we do not need to increase + // the ref count. + if (acquiring) { + entry.languageServiceRefCount++; + } + } + ts.Debug.assert(entry.languageServiceRefCount !== 0); + return entry.sourceFile; + function setBucketEntry() { + if (!bucketEntry) { + bucket.set(path, entry); + } + else if (isDocumentRegistryEntry(bucketEntry)) { + var scriptKindMap = new ts.Map(); + scriptKindMap.set(bucketEntry.sourceFile.scriptKind, bucketEntry); + scriptKindMap.set(scriptKind, entry); + bucket.set(path, scriptKindMap); + } + else { + bucketEntry.set(scriptKind, entry); + } + } + } + function releaseDocument(fileName, compilationSettings, scriptKind, impliedNodeFormat) { + var path = ts.toPath(fileName, currentDirectory, getCanonicalFileName); + var key = getKeyForCompilationSettings(compilationSettings); + return releaseDocumentWithKey(path, key, scriptKind, impliedNodeFormat); + } + function releaseDocumentWithKey(path, key, scriptKind, impliedNodeFormat) { + var bucket = ts.Debug.checkDefined(buckets.get(getDocumentRegistryBucketKeyWithMode(key, impliedNodeFormat))); + var bucketEntry = bucket.get(path); + var entry = getDocumentRegistryEntry(bucketEntry, scriptKind); + entry.languageServiceRefCount--; + ts.Debug.assert(entry.languageServiceRefCount >= 0); + if (entry.languageServiceRefCount === 0) { + if (isDocumentRegistryEntry(bucketEntry)) { + bucket.delete(path); + } + else { + bucketEntry.delete(scriptKind); + if (bucketEntry.size === 1) { + bucket.set(path, ts.firstDefinedIterator(bucketEntry.values(), ts.identity)); + } + } + } + } + function getLanguageServiceRefCounts(path, scriptKind) { + return ts.arrayFrom(buckets.entries(), function (_a) { + var key = _a[0], bucket = _a[1]; + var bucketEntry = bucket.get(path); + var entry = bucketEntry && getDocumentRegistryEntry(bucketEntry, scriptKind); + return [key, entry && entry.languageServiceRefCount]; + }); + } + return { + acquireDocument: acquireDocument, + acquireDocumentWithKey: acquireDocumentWithKey, + updateDocument: updateDocument, + updateDocumentWithKey: updateDocumentWithKey, + releaseDocument: releaseDocument, + releaseDocumentWithKey: releaseDocumentWithKey, + getLanguageServiceRefCounts: getLanguageServiceRefCounts, + reportStats: reportStats, + getKeyForCompilationSettings: getKeyForCompilationSettings + }; + } + ts.createDocumentRegistryInternal = createDocumentRegistryInternal; + function compilerOptionValueToString(value) { + var _a; + if (value === null || typeof value !== "object") { // eslint-disable-line no-null/no-null + return "" + value; + } + if (ts.isArray(value)) { + return "[".concat((_a = ts.map(value, function (e) { return compilerOptionValueToString(e); })) === null || _a === void 0 ? void 0 : _a.join(","), "]"); + } + var str = "{"; + for (var key in value) { + if (ts.hasProperty(value, key)) { + str += "".concat(key, ": ").concat(compilerOptionValueToString(value[key])); + } + } + return str + "}"; + } + function getKeyForCompilationSettings(settings) { + return ts.sourceFileAffectingCompilerOptions.map(function (option) { return compilerOptionValueToString(ts.getCompilerOptionValue(settings, option)); }).join("|") + (settings.pathsBasePath ? "|".concat(settings.pathsBasePath) : undefined); + } + function getDocumentRegistryBucketKeyWithMode(key, mode) { + return (mode ? "".concat(key, "|").concat(mode) : key); + } +})(ts || (ts = {})); +/* Code for finding imports of an exported symbol. Used only by FindAllReferences. */ +/* @internal */ +var ts; +(function (ts) { + var FindAllReferences; + (function (FindAllReferences) { + /** Creates the imports map and returns an ImportTracker that uses it. Call this lazily to avoid calling `getDirectImportsMap` unnecessarily. */ + function createImportTracker(sourceFiles, sourceFilesSet, checker, cancellationToken) { + var allDirectImports = getDirectImportsMap(sourceFiles, checker, cancellationToken); + return function (exportSymbol, exportInfo, isForRename) { + var _a = getImportersForExport(sourceFiles, sourceFilesSet, allDirectImports, exportInfo, checker, cancellationToken), directImports = _a.directImports, indirectUsers = _a.indirectUsers; + return __assign({ indirectUsers: indirectUsers }, getSearchesFromDirectImports(directImports, exportSymbol, exportInfo.exportKind, checker, isForRename)); + }; + } + FindAllReferences.createImportTracker = createImportTracker; + var ExportKind; + (function (ExportKind) { + ExportKind[ExportKind["Named"] = 0] = "Named"; + ExportKind[ExportKind["Default"] = 1] = "Default"; + ExportKind[ExportKind["ExportEquals"] = 2] = "ExportEquals"; + })(ExportKind = FindAllReferences.ExportKind || (FindAllReferences.ExportKind = {})); + var ImportExport; + (function (ImportExport) { + ImportExport[ImportExport["Import"] = 0] = "Import"; + ImportExport[ImportExport["Export"] = 1] = "Export"; + })(ImportExport = FindAllReferences.ImportExport || (FindAllReferences.ImportExport = {})); + /** Returns import statements that directly reference the exporting module, and a list of files that may access the module through a namespace. */ + function getImportersForExport(sourceFiles, sourceFilesSet, allDirectImports, _a, checker, cancellationToken) { + var exportingModuleSymbol = _a.exportingModuleSymbol, exportKind = _a.exportKind; + var markSeenDirectImport = ts.nodeSeenTracker(); + var markSeenIndirectUser = ts.nodeSeenTracker(); + var directImports = []; + var isAvailableThroughGlobal = !!exportingModuleSymbol.globalExports; + var indirectUserDeclarations = isAvailableThroughGlobal ? undefined : []; + handleDirectImports(exportingModuleSymbol); + return { directImports: directImports, indirectUsers: getIndirectUsers() }; + function getIndirectUsers() { + if (isAvailableThroughGlobal) { + // It has `export as namespace`, so anything could potentially use it. + return sourceFiles; + } + // Module augmentations may use this module's exports without importing it. + if (exportingModuleSymbol.declarations) { + for (var _i = 0, _a = exportingModuleSymbol.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + if (ts.isExternalModuleAugmentation(decl) && sourceFilesSet.has(decl.getSourceFile().fileName)) { + addIndirectUser(decl); + } + } + } + // This may return duplicates (if there are multiple module declarations in a single source file, all importing the same thing as a namespace), but `State.markSearchedSymbol` will handle that. + return indirectUserDeclarations.map(ts.getSourceFileOfNode); + } + function handleDirectImports(exportingModuleSymbol) { + var theseDirectImports = getDirectImports(exportingModuleSymbol); + if (theseDirectImports) { + for (var _i = 0, theseDirectImports_1 = theseDirectImports; _i < theseDirectImports_1.length; _i++) { + var direct = theseDirectImports_1[_i]; + if (!markSeenDirectImport(direct)) { + continue; + } + if (cancellationToken) + cancellationToken.throwIfCancellationRequested(); + switch (direct.kind) { + case 210 /* SyntaxKind.CallExpression */: + if (ts.isImportCall(direct)) { + handleImportCall(direct); + break; + } + if (!isAvailableThroughGlobal) { + var parent = direct.parent; + if (exportKind === 2 /* ExportKind.ExportEquals */ && parent.kind === 257 /* SyntaxKind.VariableDeclaration */) { + var name = parent.name; + if (name.kind === 79 /* SyntaxKind.Identifier */) { + directImports.push(name); + break; + } + } + } + break; + case 79 /* SyntaxKind.Identifier */: // for 'const x = require("y"); + break; // TODO: GH#23879 + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + handleNamespaceImport(direct, direct.name, ts.hasSyntacticModifier(direct, 1 /* ModifierFlags.Export */), /*alreadyAddedDirect*/ false); + break; + case 269 /* SyntaxKind.ImportDeclaration */: + directImports.push(direct); + var namedBindings = direct.importClause && direct.importClause.namedBindings; + if (namedBindings && namedBindings.kind === 271 /* SyntaxKind.NamespaceImport */) { + handleNamespaceImport(direct, namedBindings.name, /*isReExport*/ false, /*alreadyAddedDirect*/ true); + } + else if (!isAvailableThroughGlobal && ts.isDefaultImport(direct)) { + addIndirectUser(getSourceFileLikeForImportDeclaration(direct)); // Add a check for indirect uses to handle synthetic default imports + } + break; + case 275 /* SyntaxKind.ExportDeclaration */: + if (!direct.exportClause) { + // This is `export * from "foo"`, so imports of this module may import the export too. + handleDirectImports(getContainingModuleSymbol(direct, checker)); + } + else if (direct.exportClause.kind === 277 /* SyntaxKind.NamespaceExport */) { + // `export * as foo from "foo"` add to indirect uses + addIndirectUser(getSourceFileLikeForImportDeclaration(direct), /** addTransitiveDependencies */ true); + } + else { + // This is `export { foo } from "foo"` and creates an alias symbol, so recursive search will get handle re-exports. + directImports.push(direct); + } + break; + case 202 /* SyntaxKind.ImportType */: + // Only check for typeof import('xyz') + if (!isAvailableThroughGlobal && direct.isTypeOf && !direct.qualifier && isExported(direct)) { + addIndirectUser(direct.getSourceFile(), /** addTransitiveDependencies */ true); + } + directImports.push(direct); + break; + default: + ts.Debug.failBadSyntaxKind(direct, "Unexpected import kind."); + } + } + } + } + function handleImportCall(importCall) { + var top = ts.findAncestor(importCall, isAmbientModuleDeclaration) || importCall.getSourceFile(); + addIndirectUser(top, /** addTransitiveDependencies */ !!isExported(importCall, /** stopAtAmbientModule */ true)); + } + function isExported(node, stopAtAmbientModule) { + if (stopAtAmbientModule === void 0) { stopAtAmbientModule = false; } + return ts.findAncestor(node, function (node) { + if (stopAtAmbientModule && isAmbientModuleDeclaration(node)) + return "quit"; + return ts.canHaveModifiers(node) && ts.some(node.modifiers, ts.isExportModifier); + }); + } + function handleNamespaceImport(importDeclaration, name, isReExport, alreadyAddedDirect) { + if (exportKind === 2 /* ExportKind.ExportEquals */) { + // This is a direct import, not import-as-namespace. + if (!alreadyAddedDirect) + directImports.push(importDeclaration); + } + else if (!isAvailableThroughGlobal) { + var sourceFileLike = getSourceFileLikeForImportDeclaration(importDeclaration); + ts.Debug.assert(sourceFileLike.kind === 308 /* SyntaxKind.SourceFile */ || sourceFileLike.kind === 264 /* SyntaxKind.ModuleDeclaration */); + if (isReExport || findNamespaceReExports(sourceFileLike, name, checker)) { + addIndirectUser(sourceFileLike, /** addTransitiveDependencies */ true); + } + else { + addIndirectUser(sourceFileLike); + } + } + } + /** Adds a module and all of its transitive dependencies as possible indirect users. */ + function addIndirectUser(sourceFileLike, addTransitiveDependencies) { + if (addTransitiveDependencies === void 0) { addTransitiveDependencies = false; } + ts.Debug.assert(!isAvailableThroughGlobal); + var isNew = markSeenIndirectUser(sourceFileLike); + if (!isNew) + return; + indirectUserDeclarations.push(sourceFileLike); // TODO: GH#18217 + if (!addTransitiveDependencies) + return; + var moduleSymbol = checker.getMergedSymbol(sourceFileLike.symbol); + if (!moduleSymbol) + return; + ts.Debug.assert(!!(moduleSymbol.flags & 1536 /* SymbolFlags.Module */)); + var directImports = getDirectImports(moduleSymbol); + if (directImports) { + for (var _i = 0, directImports_1 = directImports; _i < directImports_1.length; _i++) { + var directImport = directImports_1[_i]; + if (!ts.isImportTypeNode(directImport)) { + addIndirectUser(getSourceFileLikeForImportDeclaration(directImport), /** addTransitiveDependencies */ true); + } + } + } + } + function getDirectImports(moduleSymbol) { + return allDirectImports.get(ts.getSymbolId(moduleSymbol).toString()); + } + } + /** + * Given the set of direct imports of a module, we need to find which ones import the particular exported symbol. + * The returned `importSearches` will result in the entire source file being searched. + * But re-exports will be placed in 'singleReferences' since they cannot be locally referenced. + */ + function getSearchesFromDirectImports(directImports, exportSymbol, exportKind, checker, isForRename) { + var importSearches = []; + var singleReferences = []; + function addSearch(location, symbol) { + importSearches.push([location, symbol]); + } + if (directImports) { + for (var _i = 0, directImports_2 = directImports; _i < directImports_2.length; _i++) { + var decl = directImports_2[_i]; + handleImport(decl); + } + } + return { importSearches: importSearches, singleReferences: singleReferences }; + function handleImport(decl) { + if (decl.kind === 268 /* SyntaxKind.ImportEqualsDeclaration */) { + if (isExternalModuleImportEquals(decl)) { + handleNamespaceImportLike(decl.name); + } + return; + } + if (decl.kind === 79 /* SyntaxKind.Identifier */) { + handleNamespaceImportLike(decl); + return; + } + if (decl.kind === 202 /* SyntaxKind.ImportType */) { + if (decl.qualifier) { + var firstIdentifier = ts.getFirstIdentifier(decl.qualifier); + if (firstIdentifier.escapedText === ts.symbolName(exportSymbol)) { + singleReferences.push(firstIdentifier); + } + } + else if (exportKind === 2 /* ExportKind.ExportEquals */) { + singleReferences.push(decl.argument.literal); + } + return; + } + // Ignore if there's a grammar error + if (decl.moduleSpecifier.kind !== 10 /* SyntaxKind.StringLiteral */) { + return; + } + if (decl.kind === 275 /* SyntaxKind.ExportDeclaration */) { + if (decl.exportClause && ts.isNamedExports(decl.exportClause)) { + searchForNamedImport(decl.exportClause); + } + return; + } + var _a = decl.importClause || { name: undefined, namedBindings: undefined }, name = _a.name, namedBindings = _a.namedBindings; + if (namedBindings) { + switch (namedBindings.kind) { + case 271 /* SyntaxKind.NamespaceImport */: + handleNamespaceImportLike(namedBindings.name); + break; + case 272 /* SyntaxKind.NamedImports */: + // 'default' might be accessed as a named import `{ default as foo }`. + if (exportKind === 0 /* ExportKind.Named */ || exportKind === 1 /* ExportKind.Default */) { + searchForNamedImport(namedBindings); + } + break; + default: + ts.Debug.assertNever(namedBindings); + } + } + // `export =` might be imported by a default import if `--allowSyntheticDefaultImports` is on, so this handles both ExportKind.Default and ExportKind.ExportEquals. + // If a default import has the same name as the default export, allow to rename it. + // Given `import f` and `export default function f`, we will rename both, but for `import g` we will rename just that. + if (name && (exportKind === 1 /* ExportKind.Default */ || exportKind === 2 /* ExportKind.ExportEquals */) && (!isForRename || name.escapedText === ts.symbolEscapedNameNoDefault(exportSymbol))) { + var defaultImportAlias = checker.getSymbolAtLocation(name); + addSearch(name, defaultImportAlias); + } + } + /** + * `import x = require("./x")` or `import * as x from "./x"`. + * An `export =` may be imported by this syntax, so it may be a direct import. + * If it's not a direct import, it will be in `indirectUsers`, so we don't have to do anything here. + */ + function handleNamespaceImportLike(importName) { + // Don't rename an import that already has a different name than the export. + if (exportKind === 2 /* ExportKind.ExportEquals */ && (!isForRename || isNameMatch(importName.escapedText))) { + addSearch(importName, checker.getSymbolAtLocation(importName)); + } + } + function searchForNamedImport(namedBindings) { + if (!namedBindings) { + return; + } + for (var _i = 0, _a = namedBindings.elements; _i < _a.length; _i++) { + var element = _a[_i]; + var name = element.name, propertyName = element.propertyName; + if (!isNameMatch((propertyName || name).escapedText)) { + continue; + } + if (propertyName) { + // This is `import { foo as bar } from "./a"` or `export { foo as bar } from "./a"`. `foo` isn't a local in the file, so just add it as a single reference. + singleReferences.push(propertyName); + // If renaming `{ foo as bar }`, don't touch `bar`, just `foo`. + // But do rename `foo` in ` { default as foo }` if that's the original export name. + if (!isForRename || name.escapedText === exportSymbol.escapedName) { + // Search locally for `bar`. + addSearch(name, checker.getSymbolAtLocation(name)); + } + } + else { + var localSymbol = element.kind === 278 /* SyntaxKind.ExportSpecifier */ && element.propertyName + ? checker.getExportSpecifierLocalTargetSymbol(element) // For re-exporting under a different name, we want to get the re-exported symbol. + : checker.getSymbolAtLocation(name); + addSearch(name, localSymbol); + } + } + } + function isNameMatch(name) { + // Use name of "default" even in `export =` case because we may have allowSyntheticDefaultImports + return name === exportSymbol.escapedName || exportKind !== 0 /* ExportKind.Named */ && name === "default" /* InternalSymbolName.Default */; + } + } + /** Returns 'true' is the namespace 'name' is re-exported from this module, and 'false' if it is only used locally. */ + function findNamespaceReExports(sourceFileLike, name, checker) { + var namespaceImportSymbol = checker.getSymbolAtLocation(name); + return !!forEachPossibleImportOrExportStatement(sourceFileLike, function (statement) { + if (!ts.isExportDeclaration(statement)) + return; + var exportClause = statement.exportClause, moduleSpecifier = statement.moduleSpecifier; + return !moduleSpecifier && exportClause && ts.isNamedExports(exportClause) && + exportClause.elements.some(function (element) { return checker.getExportSpecifierLocalTargetSymbol(element) === namespaceImportSymbol; }); + }); + } + function findModuleReferences(program, sourceFiles, searchModuleSymbol) { + var refs = []; + var checker = program.getTypeChecker(); + for (var _i = 0, sourceFiles_1 = sourceFiles; _i < sourceFiles_1.length; _i++) { + var referencingFile = sourceFiles_1[_i]; + var searchSourceFile = searchModuleSymbol.valueDeclaration; + if ((searchSourceFile === null || searchSourceFile === void 0 ? void 0 : searchSourceFile.kind) === 308 /* SyntaxKind.SourceFile */) { + for (var _a = 0, _b = referencingFile.referencedFiles; _a < _b.length; _a++) { + var ref = _b[_a]; + if (program.getSourceFileFromReference(referencingFile, ref) === searchSourceFile) { + refs.push({ kind: "reference", referencingFile: referencingFile, ref: ref }); + } + } + for (var _c = 0, _d = referencingFile.typeReferenceDirectives; _c < _d.length; _c++) { + var ref = _d[_c]; + var referenced = program.getResolvedTypeReferenceDirectives().get(ref.fileName, ref.resolutionMode || referencingFile.impliedNodeFormat); + if (referenced !== undefined && referenced.resolvedFileName === searchSourceFile.fileName) { + refs.push({ kind: "reference", referencingFile: referencingFile, ref: ref }); + } + } + } + forEachImport(referencingFile, function (_importDecl, moduleSpecifier) { + var moduleSymbol = checker.getSymbolAtLocation(moduleSpecifier); + if (moduleSymbol === searchModuleSymbol) { + refs.push({ kind: "import", literal: moduleSpecifier }); + } + }); + } + return refs; + } + FindAllReferences.findModuleReferences = findModuleReferences; + /** Returns a map from a module symbol Id to all import statements that directly reference the module. */ + function getDirectImportsMap(sourceFiles, checker, cancellationToken) { + var map = new ts.Map(); + for (var _i = 0, sourceFiles_2 = sourceFiles; _i < sourceFiles_2.length; _i++) { + var sourceFile = sourceFiles_2[_i]; + if (cancellationToken) + cancellationToken.throwIfCancellationRequested(); + forEachImport(sourceFile, function (importDecl, moduleSpecifier) { + var moduleSymbol = checker.getSymbolAtLocation(moduleSpecifier); + if (moduleSymbol) { + var id = ts.getSymbolId(moduleSymbol).toString(); + var imports = map.get(id); + if (!imports) { + map.set(id, imports = []); + } + imports.push(importDecl); + } + }); + } + return map; + } + /** Iterates over all statements at the top level or in module declarations. Returns the first truthy result. */ + function forEachPossibleImportOrExportStatement(sourceFileLike, action) { + return ts.forEach(sourceFileLike.kind === 308 /* SyntaxKind.SourceFile */ ? sourceFileLike.statements : sourceFileLike.body.statements, function (statement) { + return action(statement) || (isAmbientModuleDeclaration(statement) && ts.forEach(statement.body && statement.body.statements, action)); + }); + } + /** Calls `action` for each import, re-export, or require() in a file. */ + function forEachImport(sourceFile, action) { + if (sourceFile.externalModuleIndicator || sourceFile.imports !== undefined) { + for (var _i = 0, _a = sourceFile.imports; _i < _a.length; _i++) { + var i = _a[_i]; + action(ts.importFromModuleSpecifier(i), i); + } + } + else { + forEachPossibleImportOrExportStatement(sourceFile, function (statement) { + switch (statement.kind) { + case 275 /* SyntaxKind.ExportDeclaration */: + case 269 /* SyntaxKind.ImportDeclaration */: { + var decl = statement; + if (decl.moduleSpecifier && ts.isStringLiteral(decl.moduleSpecifier)) { + action(decl, decl.moduleSpecifier); + } + break; + } + case 268 /* SyntaxKind.ImportEqualsDeclaration */: { + var decl = statement; + if (isExternalModuleImportEquals(decl)) { + action(decl, decl.moduleReference.expression); + } + break; + } + } + }); + } + } + /** + * Given a local reference, we might notice that it's an import/export and recursively search for references of that. + * If at an import, look locally for the symbol it imports. + * If at an export, look for all imports of it. + * This doesn't handle export specifiers; that is done in `getReferencesAtExportSpecifier`. + * @param comingFromExport If we are doing a search for all exports, don't bother looking backwards for the imported symbol, since that's the reason we're here. + */ + function getImportOrExportSymbol(node, symbol, checker, comingFromExport) { + return comingFromExport ? getExport() : getExport() || getImport(); + function getExport() { + var _a; + var parent = node.parent; + var grandparent = parent.parent; + if (symbol.exportSymbol) { + if (parent.kind === 208 /* SyntaxKind.PropertyAccessExpression */) { + // When accessing an export of a JS module, there's no alias. The symbol will still be flagged as an export even though we're at the use. + // So check that we are at the declaration. + return ((_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.some(function (d) { return d === parent; })) && ts.isBinaryExpression(grandparent) + ? getSpecialPropertyExport(grandparent, /*useLhsSymbol*/ false) + : undefined; + } + else { + return exportInfo(symbol.exportSymbol, getExportKindForDeclaration(parent)); + } + } + else { + var exportNode = getExportNode(parent, node); + if (exportNode && ts.hasSyntacticModifier(exportNode, 1 /* ModifierFlags.Export */)) { + if (ts.isImportEqualsDeclaration(exportNode) && exportNode.moduleReference === node) { + // We're at `Y` in `export import X = Y`. This is not the exported symbol, the left-hand-side is. So treat this as an import statement. + if (comingFromExport) { + return undefined; + } + var lhsSymbol = checker.getSymbolAtLocation(exportNode.name); + return { kind: 0 /* ImportExport.Import */, symbol: lhsSymbol }; + } + else { + return exportInfo(symbol, getExportKindForDeclaration(exportNode)); + } + } + else if (ts.isNamespaceExport(parent)) { + return exportInfo(symbol, 0 /* ExportKind.Named */); + } + // If we are in `export = a;` or `export default a;`, `parent` is the export assignment. + else if (ts.isExportAssignment(parent)) { + return getExportAssignmentExport(parent); + } + // If we are in `export = class A {};` (or `export = class A {};`) at `A`, `parent.parent` is the export assignment. + else if (ts.isExportAssignment(grandparent)) { + return getExportAssignmentExport(grandparent); + } + // Similar for `module.exports =` and `exports.A =`. + else if (ts.isBinaryExpression(parent)) { + return getSpecialPropertyExport(parent, /*useLhsSymbol*/ true); + } + else if (ts.isBinaryExpression(grandparent)) { + return getSpecialPropertyExport(grandparent, /*useLhsSymbol*/ true); + } + else if (ts.isJSDocTypedefTag(parent)) { + return exportInfo(symbol, 0 /* ExportKind.Named */); + } + } + function getExportAssignmentExport(ex) { + // Get the symbol for the `export =` node; its parent is the module it's the export of. + if (!ex.symbol.parent) + return undefined; + var exportKind = ex.isExportEquals ? 2 /* ExportKind.ExportEquals */ : 1 /* ExportKind.Default */; + return { kind: 1 /* ImportExport.Export */, symbol: symbol, exportInfo: { exportingModuleSymbol: ex.symbol.parent, exportKind: exportKind } }; + } + function getSpecialPropertyExport(node, useLhsSymbol) { + var kind; + switch (ts.getAssignmentDeclarationKind(node)) { + case 1 /* AssignmentDeclarationKind.ExportsProperty */: + kind = 0 /* ExportKind.Named */; + break; + case 2 /* AssignmentDeclarationKind.ModuleExports */: + kind = 2 /* ExportKind.ExportEquals */; + break; + default: + return undefined; + } + var sym = useLhsSymbol ? checker.getSymbolAtLocation(ts.getNameOfAccessExpression(ts.cast(node.left, ts.isAccessExpression))) : symbol; + return sym && exportInfo(sym, kind); + } + } + function getImport() { + var isImport = isNodeImport(node); + if (!isImport) + return undefined; + // A symbol being imported is always an alias. So get what that aliases to find the local symbol. + var importedSymbol = checker.getImmediateAliasedSymbol(symbol); + if (!importedSymbol) + return undefined; + // Search on the local symbol in the exporting module, not the exported symbol. + importedSymbol = skipExportSpecifierSymbol(importedSymbol, checker); + // Similarly, skip past the symbol for 'export =' + if (importedSymbol.escapedName === "export=") { + importedSymbol = getExportEqualsLocalSymbol(importedSymbol, checker); + if (importedSymbol === undefined) + return undefined; + } + // If the import has a different name than the export, do not continue searching. + // If `importedName` is undefined, do continue searching as the export is anonymous. + // (All imports returned from this function will be ignored anyway if we are in rename and this is a not a named export.) + var importedName = ts.symbolEscapedNameNoDefault(importedSymbol); + if (importedName === undefined || importedName === "default" /* InternalSymbolName.Default */ || importedName === symbol.escapedName) { + return { kind: 0 /* ImportExport.Import */, symbol: importedSymbol }; + } + } + function exportInfo(symbol, kind) { + var exportInfo = getExportInfo(symbol, kind, checker); + return exportInfo && { kind: 1 /* ImportExport.Export */, symbol: symbol, exportInfo: exportInfo }; + } + // Not meant for use with export specifiers or export assignment. + function getExportKindForDeclaration(node) { + return ts.hasSyntacticModifier(node, 1024 /* ModifierFlags.Default */) ? 1 /* ExportKind.Default */ : 0 /* ExportKind.Named */; + } + } + FindAllReferences.getImportOrExportSymbol = getImportOrExportSymbol; + function getExportEqualsLocalSymbol(importedSymbol, checker) { + if (importedSymbol.flags & 2097152 /* SymbolFlags.Alias */) { + return checker.getImmediateAliasedSymbol(importedSymbol); + } + var decl = ts.Debug.checkDefined(importedSymbol.valueDeclaration); + if (ts.isExportAssignment(decl)) { // `export = class {}` + return decl.expression.symbol; + } + else if (ts.isBinaryExpression(decl)) { // `module.exports = class {}` + return decl.right.symbol; + } + else if (ts.isSourceFile(decl)) { // json module + return decl.symbol; + } + return undefined; + } + // If a reference is a class expression, the exported node would be its parent. + // If a reference is a variable declaration, the exported node would be the variable statement. + function getExportNode(parent, node) { + var declaration = ts.isVariableDeclaration(parent) ? parent : ts.isBindingElement(parent) ? ts.walkUpBindingElementsAndPatterns(parent) : undefined; + if (declaration) { + return parent.name !== node ? undefined : + ts.isCatchClause(declaration.parent) ? undefined : ts.isVariableStatement(declaration.parent.parent) ? declaration.parent.parent : undefined; + } + else { + return parent; + } + } + function isNodeImport(node) { + var parent = node.parent; + switch (parent.kind) { + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return parent.name === node && isExternalModuleImportEquals(parent); + case 273 /* SyntaxKind.ImportSpecifier */: + // For a rename import `{ foo as bar }`, don't search for the imported symbol. Just find local uses of `bar`. + return !parent.propertyName; + case 270 /* SyntaxKind.ImportClause */: + case 271 /* SyntaxKind.NamespaceImport */: + ts.Debug.assert(parent.name === node); + return true; + case 205 /* SyntaxKind.BindingElement */: + return ts.isInJSFile(node) && ts.isVariableDeclarationInitializedToBareOrAccessedRequire(parent.parent.parent); + default: + return false; + } + } + function getExportInfo(exportSymbol, exportKind, checker) { + var moduleSymbol = exportSymbol.parent; + if (!moduleSymbol) + return undefined; // This can happen if an `export` is not at the top-level (which is a compile error). + var exportingModuleSymbol = checker.getMergedSymbol(moduleSymbol); // Need to get merged symbol in case there's an augmentation. + // `export` may appear in a namespace. In that case, just rely on global search. + return ts.isExternalModuleSymbol(exportingModuleSymbol) ? { exportingModuleSymbol: exportingModuleSymbol, exportKind: exportKind } : undefined; + } + FindAllReferences.getExportInfo = getExportInfo; + /** If at an export specifier, go to the symbol it refers to. */ + function skipExportSpecifierSymbol(symbol, checker) { + // For `export { foo } from './bar", there's nothing to skip, because it does not create a new alias. But `export { foo } does. + if (symbol.declarations) { + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + if (ts.isExportSpecifier(declaration) && !declaration.propertyName && !declaration.parent.parent.moduleSpecifier) { + return checker.getExportSpecifierLocalTargetSymbol(declaration); + } + else if (ts.isPropertyAccessExpression(declaration) && ts.isModuleExportsAccessExpression(declaration.expression) && !ts.isPrivateIdentifier(declaration.name)) { + // Export of form 'module.exports.propName = expr'; + return checker.getSymbolAtLocation(declaration); + } + else if (ts.isShorthandPropertyAssignment(declaration) + && ts.isBinaryExpression(declaration.parent.parent) + && ts.getAssignmentDeclarationKind(declaration.parent.parent) === 2 /* AssignmentDeclarationKind.ModuleExports */) { + return checker.getExportSpecifierLocalTargetSymbol(declaration.name); + } + } + } + return symbol; + } + function getContainingModuleSymbol(importer, checker) { + return checker.getMergedSymbol(getSourceFileLikeForImportDeclaration(importer).symbol); + } + function getSourceFileLikeForImportDeclaration(node) { + if (node.kind === 210 /* SyntaxKind.CallExpression */) { + return node.getSourceFile(); + } + var parent = node.parent; + if (parent.kind === 308 /* SyntaxKind.SourceFile */) { + return parent; + } + ts.Debug.assert(parent.kind === 265 /* SyntaxKind.ModuleBlock */); + return ts.cast(parent.parent, isAmbientModuleDeclaration); + } + function isAmbientModuleDeclaration(node) { + return node.kind === 264 /* SyntaxKind.ModuleDeclaration */ && node.name.kind === 10 /* SyntaxKind.StringLiteral */; + } + function isExternalModuleImportEquals(eq) { + return eq.moduleReference.kind === 280 /* SyntaxKind.ExternalModuleReference */ && eq.moduleReference.expression.kind === 10 /* SyntaxKind.StringLiteral */; + } + })(FindAllReferences = ts.FindAllReferences || (ts.FindAllReferences = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var FindAllReferences; + (function (FindAllReferences) { + var DefinitionKind; + (function (DefinitionKind) { + DefinitionKind[DefinitionKind["Symbol"] = 0] = "Symbol"; + DefinitionKind[DefinitionKind["Label"] = 1] = "Label"; + DefinitionKind[DefinitionKind["Keyword"] = 2] = "Keyword"; + DefinitionKind[DefinitionKind["This"] = 3] = "This"; + DefinitionKind[DefinitionKind["String"] = 4] = "String"; + DefinitionKind[DefinitionKind["TripleSlashReference"] = 5] = "TripleSlashReference"; + })(DefinitionKind = FindAllReferences.DefinitionKind || (FindAllReferences.DefinitionKind = {})); + var EntryKind; + (function (EntryKind) { + EntryKind[EntryKind["Span"] = 0] = "Span"; + EntryKind[EntryKind["Node"] = 1] = "Node"; + EntryKind[EntryKind["StringLiteral"] = 2] = "StringLiteral"; + EntryKind[EntryKind["SearchedLocalFoundProperty"] = 3] = "SearchedLocalFoundProperty"; + EntryKind[EntryKind["SearchedPropertyFoundLocal"] = 4] = "SearchedPropertyFoundLocal"; + })(EntryKind = FindAllReferences.EntryKind || (FindAllReferences.EntryKind = {})); + function nodeEntry(node, kind) { + if (kind === void 0) { kind = 1 /* EntryKind.Node */; } + return { + kind: kind, + node: node.name || node, + context: getContextNodeForNodeEntry(node) + }; + } + FindAllReferences.nodeEntry = nodeEntry; + function isContextWithStartAndEndNode(node) { + return node && node.kind === undefined; + } + FindAllReferences.isContextWithStartAndEndNode = isContextWithStartAndEndNode; + function getContextNodeForNodeEntry(node) { + if (ts.isDeclaration(node)) { + return getContextNode(node); + } + if (!node.parent) + return undefined; + if (!ts.isDeclaration(node.parent) && !ts.isExportAssignment(node.parent)) { + // Special property assignment in javascript + if (ts.isInJSFile(node)) { + var binaryExpression = ts.isBinaryExpression(node.parent) ? + node.parent : + ts.isAccessExpression(node.parent) && + ts.isBinaryExpression(node.parent.parent) && + node.parent.parent.left === node.parent ? + node.parent.parent : + undefined; + if (binaryExpression && ts.getAssignmentDeclarationKind(binaryExpression) !== 0 /* AssignmentDeclarationKind.None */) { + return getContextNode(binaryExpression); + } + } + // Jsx Tags + if (ts.isJsxOpeningElement(node.parent) || ts.isJsxClosingElement(node.parent)) { + return node.parent.parent; + } + else if (ts.isJsxSelfClosingElement(node.parent) || + ts.isLabeledStatement(node.parent) || + ts.isBreakOrContinueStatement(node.parent)) { + return node.parent; + } + else if (ts.isStringLiteralLike(node)) { + var validImport = ts.tryGetImportFromModuleSpecifier(node); + if (validImport) { + var declOrStatement = ts.findAncestor(validImport, function (node) { + return ts.isDeclaration(node) || + ts.isStatement(node) || + ts.isJSDocTag(node); + }); + return ts.isDeclaration(declOrStatement) ? + getContextNode(declOrStatement) : + declOrStatement; + } + } + // Handle computed property name + var propertyName = ts.findAncestor(node, ts.isComputedPropertyName); + return propertyName ? + getContextNode(propertyName.parent) : + undefined; + } + if (node.parent.name === node || // node is name of declaration, use parent + ts.isConstructorDeclaration(node.parent) || + ts.isExportAssignment(node.parent) || + // Property name of the import export specifier or binding pattern, use parent + ((ts.isImportOrExportSpecifier(node.parent) || ts.isBindingElement(node.parent)) + && node.parent.propertyName === node) || + // Is default export + (node.kind === 88 /* SyntaxKind.DefaultKeyword */ && ts.hasSyntacticModifier(node.parent, 1025 /* ModifierFlags.ExportDefault */))) { + return getContextNode(node.parent); + } + return undefined; + } + function getContextNode(node) { + if (!node) + return undefined; + switch (node.kind) { + case 257 /* SyntaxKind.VariableDeclaration */: + return !ts.isVariableDeclarationList(node.parent) || node.parent.declarations.length !== 1 ? + node : + ts.isVariableStatement(node.parent.parent) ? + node.parent.parent : + ts.isForInOrOfStatement(node.parent.parent) ? + getContextNode(node.parent.parent) : + node.parent; + case 205 /* SyntaxKind.BindingElement */: + return getContextNode(node.parent.parent); + case 273 /* SyntaxKind.ImportSpecifier */: + return node.parent.parent.parent; + case 278 /* SyntaxKind.ExportSpecifier */: + case 271 /* SyntaxKind.NamespaceImport */: + return node.parent.parent; + case 270 /* SyntaxKind.ImportClause */: + case 277 /* SyntaxKind.NamespaceExport */: + return node.parent; + case 223 /* SyntaxKind.BinaryExpression */: + return ts.isExpressionStatement(node.parent) ? + node.parent : + node; + case 247 /* SyntaxKind.ForOfStatement */: + case 246 /* SyntaxKind.ForInStatement */: + return { + start: node.initializer, + end: node.expression + }; + case 299 /* SyntaxKind.PropertyAssignment */: + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + return ts.isArrayLiteralOrObjectLiteralDestructuringPattern(node.parent) ? + getContextNode(ts.findAncestor(node.parent, function (node) { + return ts.isBinaryExpression(node) || ts.isForInOrOfStatement(node); + })) : + node; + default: + return node; + } + } + FindAllReferences.getContextNode = getContextNode; + function toContextSpan(textSpan, sourceFile, context) { + if (!context) + return undefined; + var contextSpan = isContextWithStartAndEndNode(context) ? + getTextSpan(context.start, sourceFile, context.end) : + getTextSpan(context, sourceFile); + return contextSpan.start !== textSpan.start || contextSpan.length !== textSpan.length ? + { contextSpan: contextSpan } : + undefined; + } + FindAllReferences.toContextSpan = toContextSpan; + var FindReferencesUse; + (function (FindReferencesUse) { + /** + * When searching for references to a symbol, the location will not be adjusted (this is the default behavior when not specified). + */ + FindReferencesUse[FindReferencesUse["Other"] = 0] = "Other"; + /** + * When searching for references to a symbol, the location will be adjusted if the cursor was on a keyword. + */ + FindReferencesUse[FindReferencesUse["References"] = 1] = "References"; + /** + * When searching for references to a symbol, the location will be adjusted if the cursor was on a keyword. + * Unlike `References`, the location will only be adjusted keyword belonged to a declaration with a valid name. + * If set, we will find fewer references -- if it is referenced by several different names, we still only find references for the original name. + */ + FindReferencesUse[FindReferencesUse["Rename"] = 2] = "Rename"; + })(FindReferencesUse = FindAllReferences.FindReferencesUse || (FindAllReferences.FindReferencesUse = {})); + function findReferencedSymbols(program, cancellationToken, sourceFiles, sourceFile, position) { + var node = ts.getTouchingPropertyName(sourceFile, position); + var options = { use: 1 /* FindReferencesUse.References */ }; + var referencedSymbols = Core.getReferencedSymbolsForNode(position, node, program, sourceFiles, cancellationToken, options); + var checker = program.getTypeChecker(); + // Unless the starting node is a declaration (vs e.g. JSDoc), don't attempt to compute isDefinition + var adjustedNode = Core.getAdjustedNode(node, options); + var symbol = isDefinitionForReference(adjustedNode) ? checker.getSymbolAtLocation(adjustedNode) : undefined; + return !referencedSymbols || !referencedSymbols.length ? undefined : ts.mapDefined(referencedSymbols, function (_a) { + var definition = _a.definition, references = _a.references; + // Only include referenced symbols that have a valid definition. + return definition && { + definition: checker.runWithCancellationToken(cancellationToken, function (checker) { return definitionToReferencedSymbolDefinitionInfo(definition, checker, node); }), + references: references.map(function (r) { return toReferencedSymbolEntry(r, symbol); }) + }; + }); + } + FindAllReferences.findReferencedSymbols = findReferencedSymbols; + function isDefinitionForReference(node) { + return node.kind === 88 /* SyntaxKind.DefaultKeyword */ + || !!ts.getDeclarationFromName(node) + || ts.isLiteralComputedPropertyDeclarationName(node) + || (node.kind === 135 /* SyntaxKind.ConstructorKeyword */ && ts.isConstructorDeclaration(node.parent)); + } + function getImplementationsAtPosition(program, cancellationToken, sourceFiles, sourceFile, position) { + var node = ts.getTouchingPropertyName(sourceFile, position); + var referenceEntries; + var entries = getImplementationReferenceEntries(program, cancellationToken, sourceFiles, node, position); + if (node.parent.kind === 208 /* SyntaxKind.PropertyAccessExpression */ + || node.parent.kind === 205 /* SyntaxKind.BindingElement */ + || node.parent.kind === 209 /* SyntaxKind.ElementAccessExpression */ + || node.kind === 106 /* SyntaxKind.SuperKeyword */) { + referenceEntries = entries && __spreadArray([], entries, true); + } + else if (entries) { + var queue = ts.createQueue(entries); + var seenNodes = new ts.Map(); + while (!queue.isEmpty()) { + var entry = queue.dequeue(); + if (!ts.addToSeen(seenNodes, ts.getNodeId(entry.node))) { + continue; + } + referenceEntries = ts.append(referenceEntries, entry); + var entries_1 = getImplementationReferenceEntries(program, cancellationToken, sourceFiles, entry.node, entry.node.pos); + if (entries_1) { + queue.enqueue.apply(queue, entries_1); + } + } + } + var checker = program.getTypeChecker(); + return ts.map(referenceEntries, function (entry) { return toImplementationLocation(entry, checker); }); + } + FindAllReferences.getImplementationsAtPosition = getImplementationsAtPosition; + function getImplementationReferenceEntries(program, cancellationToken, sourceFiles, node, position) { + if (node.kind === 308 /* SyntaxKind.SourceFile */) { + return undefined; + } + var checker = program.getTypeChecker(); + // If invoked directly on a shorthand property assignment, then return + // the declaration of the symbol being assigned (not the symbol being assigned to). + if (node.parent.kind === 300 /* SyntaxKind.ShorthandPropertyAssignment */) { + var result_2 = []; + Core.getReferenceEntriesForShorthandPropertyAssignment(node, checker, function (node) { return result_2.push(nodeEntry(node)); }); + return result_2; + } + else if (node.kind === 106 /* SyntaxKind.SuperKeyword */ || ts.isSuperProperty(node.parent)) { + // References to and accesses on the super keyword only have one possible implementation, so no + // need to "Find all References" + var symbol = checker.getSymbolAtLocation(node); + return symbol.valueDeclaration && [nodeEntry(symbol.valueDeclaration)]; + } + else { + // Perform "Find all References" and retrieve only those that are implementations + return getReferenceEntriesForNode(position, node, program, sourceFiles, cancellationToken, { implementations: true, use: 1 /* FindReferencesUse.References */ }); + } + } + function findReferenceOrRenameEntries(program, cancellationToken, sourceFiles, node, position, options, convertEntry) { + return ts.map(flattenEntries(Core.getReferencedSymbolsForNode(position, node, program, sourceFiles, cancellationToken, options)), function (entry) { return convertEntry(entry, node, program.getTypeChecker()); }); + } + FindAllReferences.findReferenceOrRenameEntries = findReferenceOrRenameEntries; + function getReferenceEntriesForNode(position, node, program, sourceFiles, cancellationToken, options, sourceFilesSet) { + if (options === void 0) { options = {}; } + if (sourceFilesSet === void 0) { sourceFilesSet = new ts.Set(sourceFiles.map(function (f) { return f.fileName; })); } + return flattenEntries(Core.getReferencedSymbolsForNode(position, node, program, sourceFiles, cancellationToken, options, sourceFilesSet)); + } + FindAllReferences.getReferenceEntriesForNode = getReferenceEntriesForNode; + function flattenEntries(referenceSymbols) { + return referenceSymbols && ts.flatMap(referenceSymbols, function (r) { return r.references; }); + } + function definitionToReferencedSymbolDefinitionInfo(def, checker, originalNode) { + var info = (function () { + switch (def.type) { + case 0 /* DefinitionKind.Symbol */: { + var symbol = def.symbol; + var _a = getDefinitionKindAndDisplayParts(symbol, checker, originalNode), displayParts_1 = _a.displayParts, kind_1 = _a.kind; + var name_1 = displayParts_1.map(function (p) { return p.text; }).join(""); + var declaration = symbol.declarations && ts.firstOrUndefined(symbol.declarations); + var node = declaration ? (ts.getNameOfDeclaration(declaration) || declaration) : originalNode; + return __assign(__assign({}, getFileAndTextSpanFromNode(node)), { name: name_1, kind: kind_1, displayParts: displayParts_1, context: getContextNode(declaration) }); + } + case 1 /* DefinitionKind.Label */: { + var node = def.node; + return __assign(__assign({}, getFileAndTextSpanFromNode(node)), { name: node.text, kind: "label" /* ScriptElementKind.label */, displayParts: [ts.displayPart(node.text, ts.SymbolDisplayPartKind.text)] }); + } + case 2 /* DefinitionKind.Keyword */: { + var node = def.node; + var name_2 = ts.tokenToString(node.kind); + return __assign(__assign({}, getFileAndTextSpanFromNode(node)), { name: name_2, kind: "keyword" /* ScriptElementKind.keyword */, displayParts: [{ text: name_2, kind: "keyword" /* ScriptElementKind.keyword */ }] }); + } + case 3 /* DefinitionKind.This */: { + var node = def.node; + var symbol = checker.getSymbolAtLocation(node); + var displayParts_2 = symbol && ts.SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(checker, symbol, node.getSourceFile(), ts.getContainerNode(node), node).displayParts || [ts.textPart("this")]; + return __assign(__assign({}, getFileAndTextSpanFromNode(node)), { name: "this", kind: "var" /* ScriptElementKind.variableElement */, displayParts: displayParts_2 }); + } + case 4 /* DefinitionKind.String */: { + var node = def.node; + return __assign(__assign({}, getFileAndTextSpanFromNode(node)), { name: node.text, kind: "var" /* ScriptElementKind.variableElement */, displayParts: [ts.displayPart(ts.getTextOfNode(node), ts.SymbolDisplayPartKind.stringLiteral)] }); + } + case 5 /* DefinitionKind.TripleSlashReference */: { + return { + textSpan: ts.createTextSpanFromRange(def.reference), + sourceFile: def.file, + name: def.reference.fileName, + kind: "string" /* ScriptElementKind.string */, + displayParts: [ts.displayPart("\"".concat(def.reference.fileName, "\""), ts.SymbolDisplayPartKind.stringLiteral)] + }; + } + default: + return ts.Debug.assertNever(def); + } + })(); + var sourceFile = info.sourceFile, textSpan = info.textSpan, name = info.name, kind = info.kind, displayParts = info.displayParts, context = info.context; + return __assign({ containerKind: "" /* ScriptElementKind.unknown */, containerName: "", fileName: sourceFile.fileName, kind: kind, name: name, textSpan: textSpan, displayParts: displayParts }, toContextSpan(textSpan, sourceFile, context)); + } + function getFileAndTextSpanFromNode(node) { + var sourceFile = node.getSourceFile(); + return { + sourceFile: sourceFile, + textSpan: getTextSpan(ts.isComputedPropertyName(node) ? node.expression : node, sourceFile) + }; + } + function getDefinitionKindAndDisplayParts(symbol, checker, node) { + var meaning = Core.getIntersectingMeaningFromDeclarations(node, symbol); + var enclosingDeclaration = symbol.declarations && ts.firstOrUndefined(symbol.declarations) || node; + var _a = ts.SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(checker, symbol, enclosingDeclaration.getSourceFile(), enclosingDeclaration, enclosingDeclaration, meaning), displayParts = _a.displayParts, symbolKind = _a.symbolKind; + return { displayParts: displayParts, kind: symbolKind }; + } + function toRenameLocation(entry, originalNode, checker, providePrefixAndSuffixText) { + return __assign(__assign({}, entryToDocumentSpan(entry)), (providePrefixAndSuffixText && getPrefixAndSuffixText(entry, originalNode, checker))); + } + FindAllReferences.toRenameLocation = toRenameLocation; + function toReferencedSymbolEntry(entry, symbol) { + var referenceEntry = toReferenceEntry(entry); + if (!symbol) + return referenceEntry; + return __assign(__assign({}, referenceEntry), { isDefinition: entry.kind !== 0 /* EntryKind.Span */ && isDeclarationOfSymbol(entry.node, symbol) }); + } + function toReferenceEntry(entry) { + var documentSpan = entryToDocumentSpan(entry); + if (entry.kind === 0 /* EntryKind.Span */) { + return __assign(__assign({}, documentSpan), { isWriteAccess: false }); + } + var kind = entry.kind, node = entry.node; + return __assign(__assign({}, documentSpan), { isWriteAccess: isWriteAccessForReference(node), isInString: kind === 2 /* EntryKind.StringLiteral */ ? true : undefined }); + } + FindAllReferences.toReferenceEntry = toReferenceEntry; + function entryToDocumentSpan(entry) { + if (entry.kind === 0 /* EntryKind.Span */) { + return { textSpan: entry.textSpan, fileName: entry.fileName }; + } + else { + var sourceFile = entry.node.getSourceFile(); + var textSpan = getTextSpan(entry.node, sourceFile); + return __assign({ textSpan: textSpan, fileName: sourceFile.fileName }, toContextSpan(textSpan, sourceFile, entry.context)); + } + } + function getPrefixAndSuffixText(entry, originalNode, checker) { + if (entry.kind !== 0 /* EntryKind.Span */ && ts.isIdentifier(originalNode)) { + var node = entry.node, kind = entry.kind; + var parent = node.parent; + var name = originalNode.text; + var isShorthandAssignment = ts.isShorthandPropertyAssignment(parent); + if (isShorthandAssignment || (ts.isObjectBindingElementWithoutPropertyName(parent) && parent.name === node && parent.dotDotDotToken === undefined)) { + var prefixColon = { prefixText: name + ": " }; + var suffixColon = { suffixText: ": " + name }; + if (kind === 3 /* EntryKind.SearchedLocalFoundProperty */) { + return prefixColon; + } + if (kind === 4 /* EntryKind.SearchedPropertyFoundLocal */) { + return suffixColon; + } + // In `const o = { x }; o.x`, symbolAtLocation at `x` in `{ x }` is the property symbol. + // For a binding element `const { x } = o;`, symbolAtLocation at `x` is the property symbol. + if (isShorthandAssignment) { + var grandParent = parent.parent; + if (ts.isObjectLiteralExpression(grandParent) && + ts.isBinaryExpression(grandParent.parent) && + ts.isModuleExportsAccessExpression(grandParent.parent.left)) { + return prefixColon; + } + return suffixColon; + } + else { + return prefixColon; + } + } + else if (ts.isImportSpecifier(parent) && !parent.propertyName) { + // If the original symbol was using this alias, just rename the alias. + var originalSymbol = ts.isExportSpecifier(originalNode.parent) ? checker.getExportSpecifierLocalTargetSymbol(originalNode.parent) : checker.getSymbolAtLocation(originalNode); + return ts.contains(originalSymbol.declarations, parent) ? { prefixText: name + " as " } : ts.emptyOptions; + } + else if (ts.isExportSpecifier(parent) && !parent.propertyName) { + // If the symbol for the node is same as declared node symbol use prefix text + return originalNode === entry.node || checker.getSymbolAtLocation(originalNode) === checker.getSymbolAtLocation(entry.node) ? + { prefixText: name + " as " } : + { suffixText: " as " + name }; + } + } + return ts.emptyOptions; + } + function toImplementationLocation(entry, checker) { + var documentSpan = entryToDocumentSpan(entry); + if (entry.kind !== 0 /* EntryKind.Span */) { + var node = entry.node; + return __assign(__assign({}, documentSpan), implementationKindDisplayParts(node, checker)); + } + else { + return __assign(__assign({}, documentSpan), { kind: "" /* ScriptElementKind.unknown */, displayParts: [] }); + } + } + function implementationKindDisplayParts(node, checker) { + var symbol = checker.getSymbolAtLocation(ts.isDeclaration(node) && node.name ? node.name : node); + if (symbol) { + return getDefinitionKindAndDisplayParts(symbol, checker, node); + } + else if (node.kind === 207 /* SyntaxKind.ObjectLiteralExpression */) { + return { + kind: "interface" /* ScriptElementKind.interfaceElement */, + displayParts: [ts.punctuationPart(20 /* SyntaxKind.OpenParenToken */), ts.textPart("object literal"), ts.punctuationPart(21 /* SyntaxKind.CloseParenToken */)] + }; + } + else if (node.kind === 228 /* SyntaxKind.ClassExpression */) { + return { + kind: "local class" /* ScriptElementKind.localClassElement */, + displayParts: [ts.punctuationPart(20 /* SyntaxKind.OpenParenToken */), ts.textPart("anonymous local class"), ts.punctuationPart(21 /* SyntaxKind.CloseParenToken */)] + }; + } + else { + return { kind: ts.getNodeKind(node), displayParts: [] }; + } + } + function toHighlightSpan(entry) { + var documentSpan = entryToDocumentSpan(entry); + if (entry.kind === 0 /* EntryKind.Span */) { + return { + fileName: documentSpan.fileName, + span: { + textSpan: documentSpan.textSpan, + kind: "reference" /* HighlightSpanKind.reference */ + } + }; + } + var writeAccess = isWriteAccessForReference(entry.node); + var span = __assign({ textSpan: documentSpan.textSpan, kind: writeAccess ? "writtenReference" /* HighlightSpanKind.writtenReference */ : "reference" /* HighlightSpanKind.reference */, isInString: entry.kind === 2 /* EntryKind.StringLiteral */ ? true : undefined }, documentSpan.contextSpan && { contextSpan: documentSpan.contextSpan }); + return { fileName: documentSpan.fileName, span: span }; + } + FindAllReferences.toHighlightSpan = toHighlightSpan; + function getTextSpan(node, sourceFile, endNode) { + var start = node.getStart(sourceFile); + var end = (endNode || node).getEnd(); + if (ts.isStringLiteralLike(node) && (end - start) > 2) { + ts.Debug.assert(endNode === undefined); + start += 1; + end -= 1; + } + return ts.createTextSpanFromBounds(start, end); + } + function getTextSpanOfEntry(entry) { + return entry.kind === 0 /* EntryKind.Span */ ? entry.textSpan : + getTextSpan(entry.node, entry.node.getSourceFile()); + } + FindAllReferences.getTextSpanOfEntry = getTextSpanOfEntry; + /** A node is considered a writeAccess iff it is a name of a declaration or a target of an assignment */ + function isWriteAccessForReference(node) { + var decl = ts.getDeclarationFromName(node); + return !!decl && declarationIsWriteAccess(decl) || node.kind === 88 /* SyntaxKind.DefaultKeyword */ || ts.isWriteAccess(node); + } + /** Whether a reference, `node`, is a definition of the `target` symbol */ + function isDeclarationOfSymbol(node, target) { + var _a; + if (!target) + return false; + var source = ts.getDeclarationFromName(node) || + (node.kind === 88 /* SyntaxKind.DefaultKeyword */ ? node.parent + : ts.isLiteralComputedPropertyDeclarationName(node) ? node.parent.parent + : node.kind === 135 /* SyntaxKind.ConstructorKeyword */ && ts.isConstructorDeclaration(node.parent) ? node.parent.parent + : undefined); + var commonjsSource = source && ts.isBinaryExpression(source) ? source.left : undefined; + return !!(source && ((_a = target.declarations) === null || _a === void 0 ? void 0 : _a.some(function (d) { return d === source || d === commonjsSource; }))); + } + FindAllReferences.isDeclarationOfSymbol = isDeclarationOfSymbol; + /** + * True if 'decl' provides a value, as in `function f() {}`; + * false if 'decl' is just a location for a future write, as in 'let x;' + */ + function declarationIsWriteAccess(decl) { + // Consider anything in an ambient declaration to be a write access since it may be coming from JS. + if (!!(decl.flags & 16777216 /* NodeFlags.Ambient */)) + return true; + switch (decl.kind) { + case 223 /* SyntaxKind.BinaryExpression */: + case 205 /* SyntaxKind.BindingElement */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + case 88 /* SyntaxKind.DefaultKeyword */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 302 /* SyntaxKind.EnumMember */: + case 278 /* SyntaxKind.ExportSpecifier */: + case 270 /* SyntaxKind.ImportClause */: // default import + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + case 273 /* SyntaxKind.ImportSpecifier */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 341 /* SyntaxKind.JSDocCallbackTag */: + case 348 /* SyntaxKind.JSDocTypedefTag */: + case 288 /* SyntaxKind.JsxAttribute */: + case 264 /* SyntaxKind.ModuleDeclaration */: + case 267 /* SyntaxKind.NamespaceExportDeclaration */: + case 271 /* SyntaxKind.NamespaceImport */: + case 277 /* SyntaxKind.NamespaceExport */: + case 166 /* SyntaxKind.Parameter */: + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 165 /* SyntaxKind.TypeParameter */: + return true; + case 299 /* SyntaxKind.PropertyAssignment */: + // In `({ x: y } = 0);`, `x` is not a write access. (Won't call this function for `y`.) + return !ts.isArrayLiteralOrObjectLiteralDestructuringPattern(decl.parent); + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 173 /* SyntaxKind.Constructor */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + return !!decl.body; + case 257 /* SyntaxKind.VariableDeclaration */: + case 169 /* SyntaxKind.PropertyDeclaration */: + return !!decl.initializer || ts.isCatchClause(decl.parent); + case 170 /* SyntaxKind.MethodSignature */: + case 168 /* SyntaxKind.PropertySignature */: + case 350 /* SyntaxKind.JSDocPropertyTag */: + case 343 /* SyntaxKind.JSDocParameterTag */: + return false; + default: + return ts.Debug.failBadSyntaxKind(decl); + } + } + /** Encapsulates the core find-all-references algorithm. */ + var Core; + (function (Core) { + /** Core find-all-references algorithm. Handles special cases before delegating to `getReferencedSymbolsForSymbol`. */ + function getReferencedSymbolsForNode(position, node, program, sourceFiles, cancellationToken, options, sourceFilesSet) { + var _a, _b; + if (options === void 0) { options = {}; } + if (sourceFilesSet === void 0) { sourceFilesSet = new ts.Set(sourceFiles.map(function (f) { return f.fileName; })); } + node = getAdjustedNode(node, options); + if (ts.isSourceFile(node)) { + var resolvedRef = ts.GoToDefinition.getReferenceAtPosition(node, position, program); + if (!(resolvedRef === null || resolvedRef === void 0 ? void 0 : resolvedRef.file)) { + return undefined; + } + var moduleSymbol = program.getTypeChecker().getMergedSymbol(resolvedRef.file.symbol); + if (moduleSymbol) { + return getReferencedSymbolsForModule(program, moduleSymbol, /*excludeImportTypeOfExportEquals*/ false, sourceFiles, sourceFilesSet); + } + var fileIncludeReasons = program.getFileIncludeReasons(); + if (!fileIncludeReasons) { + return undefined; + } + return [{ + definition: { type: 5 /* DefinitionKind.TripleSlashReference */, reference: resolvedRef.reference, file: node }, + references: getReferencesForNonModule(resolvedRef.file, fileIncludeReasons, program) || ts.emptyArray + }]; + } + if (!options.implementations) { + var special = getReferencedSymbolsSpecial(node, sourceFiles, cancellationToken); + if (special) { + return special; + } + } + var checker = program.getTypeChecker(); + // constructors should use the class symbol, detected by name, if present + var symbol = checker.getSymbolAtLocation(ts.isConstructorDeclaration(node) && node.parent.name || node); + // Could not find a symbol e.g. unknown identifier + if (!symbol) { + // String literal might be a property (and thus have a symbol), so do this here rather than in getReferencedSymbolsSpecial. + if (!options.implementations && ts.isStringLiteralLike(node)) { + if (ts.isModuleSpecifierLike(node)) { + var fileIncludeReasons = program.getFileIncludeReasons(); + var referencedFileName = (_b = (_a = node.getSourceFile().resolvedModules) === null || _a === void 0 ? void 0 : _a.get(node.text, ts.getModeForUsageLocation(node.getSourceFile(), node))) === null || _b === void 0 ? void 0 : _b.resolvedFileName; + var referencedFile = referencedFileName ? program.getSourceFile(referencedFileName) : undefined; + if (referencedFile) { + return [{ definition: { type: 4 /* DefinitionKind.String */, node: node }, references: getReferencesForNonModule(referencedFile, fileIncludeReasons, program) || ts.emptyArray }]; + } + // Fall through to string literal references. This is not very likely to return + // anything useful, but I guess it's better than nothing, and there's an existing + // test that expects this to happen (fourslash/cases/untypedModuleImport.ts). + } + return getReferencesForStringLiteral(node, sourceFiles, checker, cancellationToken); + } + return undefined; + } + if (symbol.escapedName === "export=" /* InternalSymbolName.ExportEquals */) { + return getReferencedSymbolsForModule(program, symbol.parent, /*excludeImportTypeOfExportEquals*/ false, sourceFiles, sourceFilesSet); + } + var moduleReferences = getReferencedSymbolsForModuleIfDeclaredBySourceFile(symbol, program, sourceFiles, cancellationToken, options, sourceFilesSet); + if (moduleReferences && !(symbol.flags & 33554432 /* SymbolFlags.Transient */)) { + return moduleReferences; + } + var aliasedSymbol = getMergedAliasedSymbolOfNamespaceExportDeclaration(node, symbol, checker); + var moduleReferencesOfExportTarget = aliasedSymbol && + getReferencedSymbolsForModuleIfDeclaredBySourceFile(aliasedSymbol, program, sourceFiles, cancellationToken, options, sourceFilesSet); + var references = getReferencedSymbolsForSymbol(symbol, node, sourceFiles, sourceFilesSet, checker, cancellationToken, options); + return mergeReferences(program, moduleReferences, references, moduleReferencesOfExportTarget); + } + Core.getReferencedSymbolsForNode = getReferencedSymbolsForNode; + function getAdjustedNode(node, options) { + if (options.use === 1 /* FindReferencesUse.References */) { + node = ts.getAdjustedReferenceLocation(node); + } + else if (options.use === 2 /* FindReferencesUse.Rename */) { + node = ts.getAdjustedRenameLocation(node); + } + return node; + } + Core.getAdjustedNode = getAdjustedNode; + function getReferencesForFileName(fileName, program, sourceFiles, sourceFilesSet) { + var _a, _b; + if (sourceFilesSet === void 0) { sourceFilesSet = new ts.Set(sourceFiles.map(function (f) { return f.fileName; })); } + var moduleSymbol = (_a = program.getSourceFile(fileName)) === null || _a === void 0 ? void 0 : _a.symbol; + if (moduleSymbol) { + return ((_b = getReferencedSymbolsForModule(program, moduleSymbol, /*excludeImportTypeOfExportEquals*/ false, sourceFiles, sourceFilesSet)[0]) === null || _b === void 0 ? void 0 : _b.references) || ts.emptyArray; + } + var fileIncludeReasons = program.getFileIncludeReasons(); + var referencedFile = program.getSourceFile(fileName); + return referencedFile && fileIncludeReasons && getReferencesForNonModule(referencedFile, fileIncludeReasons, program) || ts.emptyArray; + } + Core.getReferencesForFileName = getReferencesForFileName; + function getReferencesForNonModule(referencedFile, refFileMap, program) { + var entries; + var references = refFileMap.get(referencedFile.path) || ts.emptyArray; + for (var _i = 0, references_1 = references; _i < references_1.length; _i++) { + var ref = references_1[_i]; + if (ts.isReferencedFile(ref)) { + var referencingFile = program.getSourceFileByPath(ref.file); + var location = ts.getReferencedFileLocation(program.getSourceFileByPath, ref); + if (ts.isReferenceFileLocation(location)) { + entries = ts.append(entries, { + kind: 0 /* EntryKind.Span */, + fileName: referencingFile.fileName, + textSpan: ts.createTextSpanFromRange(location) + }); + } + } + } + return entries; + } + function getMergedAliasedSymbolOfNamespaceExportDeclaration(node, symbol, checker) { + if (node.parent && ts.isNamespaceExportDeclaration(node.parent)) { + var aliasedSymbol = checker.getAliasedSymbol(symbol); + var targetSymbol = checker.getMergedSymbol(aliasedSymbol); + if (aliasedSymbol !== targetSymbol) { + return targetSymbol; + } + } + return undefined; + } + function getReferencedSymbolsForModuleIfDeclaredBySourceFile(symbol, program, sourceFiles, cancellationToken, options, sourceFilesSet) { + var moduleSourceFile = (symbol.flags & 1536 /* SymbolFlags.Module */) && symbol.declarations && ts.find(symbol.declarations, ts.isSourceFile); + if (!moduleSourceFile) + return undefined; + var exportEquals = symbol.exports.get("export=" /* InternalSymbolName.ExportEquals */); + // If !!exportEquals, we're about to add references to `import("mod")` anyway, so don't double-count them. + var moduleReferences = getReferencedSymbolsForModule(program, symbol, !!exportEquals, sourceFiles, sourceFilesSet); + if (!exportEquals || !sourceFilesSet.has(moduleSourceFile.fileName)) + return moduleReferences; + // Continue to get references to 'export ='. + var checker = program.getTypeChecker(); + symbol = ts.skipAlias(exportEquals, checker); + return mergeReferences(program, moduleReferences, getReferencedSymbolsForSymbol(symbol, /*node*/ undefined, sourceFiles, sourceFilesSet, checker, cancellationToken, options)); + } + /** + * Merges the references by sorting them (by file index in sourceFiles and their location in it) that point to same definition symbol + */ + function mergeReferences(program) { + var referencesToMerge = []; + for (var _i = 1; _i < arguments.length; _i++) { + referencesToMerge[_i - 1] = arguments[_i]; + } + var result; + for (var _a = 0, referencesToMerge_1 = referencesToMerge; _a < referencesToMerge_1.length; _a++) { + var references = referencesToMerge_1[_a]; + if (!references || !references.length) + continue; + if (!result) { + result = references; + continue; + } + var _loop_3 = function (entry) { + if (!entry.definition || entry.definition.type !== 0 /* DefinitionKind.Symbol */) { + result.push(entry); + return "continue"; + } + var symbol = entry.definition.symbol; + var refIndex = ts.findIndex(result, function (ref) { return !!ref.definition && + ref.definition.type === 0 /* DefinitionKind.Symbol */ && + ref.definition.symbol === symbol; }); + if (refIndex === -1) { + result.push(entry); + return "continue"; + } + var reference = result[refIndex]; + result[refIndex] = { + definition: reference.definition, + references: reference.references.concat(entry.references).sort(function (entry1, entry2) { + var entry1File = getSourceFileIndexOfEntry(program, entry1); + var entry2File = getSourceFileIndexOfEntry(program, entry2); + if (entry1File !== entry2File) { + return ts.compareValues(entry1File, entry2File); + } + var entry1Span = getTextSpanOfEntry(entry1); + var entry2Span = getTextSpanOfEntry(entry2); + return entry1Span.start !== entry2Span.start ? + ts.compareValues(entry1Span.start, entry2Span.start) : + ts.compareValues(entry1Span.length, entry2Span.length); + }) + }; + }; + for (var _b = 0, references_2 = references; _b < references_2.length; _b++) { + var entry = references_2[_b]; + _loop_3(entry); + } + } + return result; + } + function getSourceFileIndexOfEntry(program, entry) { + var sourceFile = entry.kind === 0 /* EntryKind.Span */ ? + program.getSourceFile(entry.fileName) : + entry.node.getSourceFile(); + return program.getSourceFiles().indexOf(sourceFile); + } + function getReferencedSymbolsForModule(program, symbol, excludeImportTypeOfExportEquals, sourceFiles, sourceFilesSet) { + ts.Debug.assert(!!symbol.valueDeclaration); + var references = ts.mapDefined(FindAllReferences.findModuleReferences(program, sourceFiles, symbol), function (reference) { + if (reference.kind === "import") { + var parent = reference.literal.parent; + if (ts.isLiteralTypeNode(parent)) { + var importType = ts.cast(parent.parent, ts.isImportTypeNode); + if (excludeImportTypeOfExportEquals && !importType.qualifier) { + return undefined; + } + } + // import("foo") with no qualifier will reference the `export =` of the module, which may be referenced anyway. + return nodeEntry(reference.literal); + } + else { + return { + kind: 0 /* EntryKind.Span */, + fileName: reference.referencingFile.fileName, + textSpan: ts.createTextSpanFromRange(reference.ref), + }; + } + }); + if (symbol.declarations) { + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + switch (decl.kind) { + case 308 /* SyntaxKind.SourceFile */: + // Don't include the source file itself. (This may not be ideal behavior, but awkward to include an entire file as a reference.) + break; + case 264 /* SyntaxKind.ModuleDeclaration */: + if (sourceFilesSet.has(decl.getSourceFile().fileName)) { + references.push(nodeEntry(decl.name)); + } + break; + default: + // This may be merged with something. + ts.Debug.assert(!!(symbol.flags & 33554432 /* SymbolFlags.Transient */), "Expected a module symbol to be declared by a SourceFile or ModuleDeclaration."); + } + } + } + var exported = symbol.exports.get("export=" /* InternalSymbolName.ExportEquals */); + if (exported === null || exported === void 0 ? void 0 : exported.declarations) { + for (var _b = 0, _c = exported.declarations; _b < _c.length; _b++) { + var decl = _c[_b]; + var sourceFile = decl.getSourceFile(); + if (sourceFilesSet.has(sourceFile.fileName)) { + // At `module.exports = ...`, reference node is `module` + var node = ts.isBinaryExpression(decl) && ts.isPropertyAccessExpression(decl.left) ? decl.left.expression : + ts.isExportAssignment(decl) ? ts.Debug.checkDefined(ts.findChildOfKind(decl, 93 /* SyntaxKind.ExportKeyword */, sourceFile)) : + ts.getNameOfDeclaration(decl) || decl; + references.push(nodeEntry(node)); + } + } + } + return references.length ? [{ definition: { type: 0 /* DefinitionKind.Symbol */, symbol: symbol }, references: references }] : ts.emptyArray; + } + /** As in a `readonly prop: any` or `constructor(readonly prop: any)`, not a `readonly any[]`. */ + function isReadonlyTypeOperator(node) { + return node.kind === 146 /* SyntaxKind.ReadonlyKeyword */ + && ts.isTypeOperatorNode(node.parent) + && node.parent.operator === 146 /* SyntaxKind.ReadonlyKeyword */; + } + /** getReferencedSymbols for special node kinds. */ + function getReferencedSymbolsSpecial(node, sourceFiles, cancellationToken) { + if (ts.isTypeKeyword(node.kind)) { + // A void expression (i.e., `void foo()`) is not special, but the `void` type is. + if (node.kind === 114 /* SyntaxKind.VoidKeyword */ && ts.isVoidExpression(node.parent)) { + return undefined; + } + // A modifier readonly (like on a property declaration) is not special; + // a readonly type keyword (like `readonly string[]`) is. + if (node.kind === 146 /* SyntaxKind.ReadonlyKeyword */ && !isReadonlyTypeOperator(node)) { + return undefined; + } + // Likewise, when we *are* looking for a special keyword, make sure we + // *don’t* include readonly member modifiers. + return getAllReferencesForKeyword(sourceFiles, node.kind, cancellationToken, node.kind === 146 /* SyntaxKind.ReadonlyKeyword */ ? isReadonlyTypeOperator : undefined); + } + if (ts.isImportMeta(node.parent) && node.parent.name === node) { + return getAllReferencesForImportMeta(sourceFiles, cancellationToken); + } + if (ts.isStaticModifier(node) && ts.isClassStaticBlockDeclaration(node.parent)) { + return [{ definition: { type: 2 /* DefinitionKind.Keyword */, node: node }, references: [nodeEntry(node)] }]; + } + // Labels + if (ts.isJumpStatementTarget(node)) { + var labelDefinition = ts.getTargetLabel(node.parent, node.text); + // if we have a label definition, look within its statement for references, if not, then + // the label is undefined and we have no results.. + return labelDefinition && getLabelReferencesInNode(labelDefinition.parent, labelDefinition); + } + else if (ts.isLabelOfLabeledStatement(node)) { + // it is a label definition and not a target, search within the parent labeledStatement + return getLabelReferencesInNode(node.parent, node); + } + if (ts.isThis(node)) { + return getReferencesForThisKeyword(node, sourceFiles, cancellationToken); + } + if (node.kind === 106 /* SyntaxKind.SuperKeyword */) { + return getReferencesForSuperKeyword(node); + } + return undefined; + } + /** Core find-all-references algorithm for a normal symbol. */ + function getReferencedSymbolsForSymbol(originalSymbol, node, sourceFiles, sourceFilesSet, checker, cancellationToken, options) { + var symbol = node && skipPastExportOrImportSpecifierOrUnion(originalSymbol, node, checker, /*useLocalSymbolForExportSpecifier*/ !isForRenameWithPrefixAndSuffixText(options)) || originalSymbol; + // Compute the meaning from the location and the symbol it references + var searchMeaning = node ? getIntersectingMeaningFromDeclarations(node, symbol) : 7 /* SemanticMeaning.All */; + var result = []; + var state = new State(sourceFiles, sourceFilesSet, node ? getSpecialSearchKind(node) : 0 /* SpecialSearchKind.None */, checker, cancellationToken, searchMeaning, options, result); + var exportSpecifier = !isForRenameWithPrefixAndSuffixText(options) || !symbol.declarations ? undefined : ts.find(symbol.declarations, ts.isExportSpecifier); + if (exportSpecifier) { + // When renaming at an export specifier, rename the export and not the thing being exported. + getReferencesAtExportSpecifier(exportSpecifier.name, symbol, exportSpecifier, state.createSearch(node, originalSymbol, /*comingFrom*/ undefined), state, /*addReferencesHere*/ true, /*alwaysGetReferences*/ true); + } + else if (node && node.kind === 88 /* SyntaxKind.DefaultKeyword */ && symbol.escapedName === "default" /* InternalSymbolName.Default */ && symbol.parent) { + addReference(node, symbol, state); + searchForImportsOfExport(node, symbol, { exportingModuleSymbol: symbol.parent, exportKind: 1 /* ExportKind.Default */ }, state); + } + else { + var search = state.createSearch(node, symbol, /*comingFrom*/ undefined, { allSearchSymbols: node ? populateSearchSymbolSet(symbol, node, checker, options.use === 2 /* FindReferencesUse.Rename */, !!options.providePrefixAndSuffixTextForRename, !!options.implementations) : [symbol] }); + getReferencesInContainerOrFiles(symbol, state, search); + } + return result; + } + function getReferencesInContainerOrFiles(symbol, state, search) { + // Try to get the smallest valid scope that we can limit our search to; + // otherwise we'll need to search globally (i.e. include each file). + var scope = getSymbolScope(symbol); + if (scope) { + getReferencesInContainer(scope, scope.getSourceFile(), search, state, /*addReferencesHere*/ !(ts.isSourceFile(scope) && !ts.contains(state.sourceFiles, scope))); + } + else { + // Global search + for (var _i = 0, _a = state.sourceFiles; _i < _a.length; _i++) { + var sourceFile = _a[_i]; + state.cancellationToken.throwIfCancellationRequested(); + searchForName(sourceFile, search, state); + } + } + } + function getSpecialSearchKind(node) { + switch (node.kind) { + case 173 /* SyntaxKind.Constructor */: + case 135 /* SyntaxKind.ConstructorKeyword */: + return 1 /* SpecialSearchKind.Constructor */; + case 79 /* SyntaxKind.Identifier */: + if (ts.isClassLike(node.parent)) { + ts.Debug.assert(node.parent.name === node); + return 2 /* SpecialSearchKind.Class */; + } + // falls through + default: + return 0 /* SpecialSearchKind.None */; + } + } + /** Handle a few special cases relating to export/import specifiers. */ + function skipPastExportOrImportSpecifierOrUnion(symbol, node, checker, useLocalSymbolForExportSpecifier) { + var parent = node.parent; + if (ts.isExportSpecifier(parent) && useLocalSymbolForExportSpecifier) { + return getLocalSymbolForExportSpecifier(node, symbol, parent, checker); + } + // If the symbol is declared as part of a declaration like `{ type: "a" } | { type: "b" }`, use the property on the union type to get more references. + return ts.firstDefined(symbol.declarations, function (decl) { + if (!decl.parent) { + // Ignore UMD module and global merge + if (symbol.flags & 33554432 /* SymbolFlags.Transient */) + return undefined; + // Assertions for GH#21814. We should be handling SourceFile symbols in `getReferencedSymbolsForModule` instead of getting here. + ts.Debug.fail("Unexpected symbol at ".concat(ts.Debug.formatSyntaxKind(node.kind), ": ").concat(ts.Debug.formatSymbol(symbol))); + } + return ts.isTypeLiteralNode(decl.parent) && ts.isUnionTypeNode(decl.parent.parent) + ? checker.getPropertyOfType(checker.getTypeFromTypeNode(decl.parent.parent), symbol.name) + : undefined; + }); + } + var SpecialSearchKind; + (function (SpecialSearchKind) { + SpecialSearchKind[SpecialSearchKind["None"] = 0] = "None"; + SpecialSearchKind[SpecialSearchKind["Constructor"] = 1] = "Constructor"; + SpecialSearchKind[SpecialSearchKind["Class"] = 2] = "Class"; + })(SpecialSearchKind || (SpecialSearchKind = {})); + function getNonModuleSymbolOfMergedModuleSymbol(symbol) { + if (!(symbol.flags & (1536 /* SymbolFlags.Module */ | 33554432 /* SymbolFlags.Transient */))) + return undefined; + var decl = symbol.declarations && ts.find(symbol.declarations, function (d) { return !ts.isSourceFile(d) && !ts.isModuleDeclaration(d); }); + return decl && decl.symbol; + } + /** + * Holds all state needed for the finding references. + * Unlike `Search`, there is only one `State`. + */ + var State = /** @class */ (function () { + function State(sourceFiles, sourceFilesSet, specialSearchKind, checker, cancellationToken, searchMeaning, options, result) { + this.sourceFiles = sourceFiles; + this.sourceFilesSet = sourceFilesSet; + this.specialSearchKind = specialSearchKind; + this.checker = checker; + this.cancellationToken = cancellationToken; + this.searchMeaning = searchMeaning; + this.options = options; + this.result = result; + /** Cache for `explicitlyinheritsFrom`. */ + this.inheritsFromCache = new ts.Map(); + /** + * Type nodes can contain multiple references to the same type. For example: + * let x: Foo & (Foo & Bar) = ... + * Because we are returning the implementation locations and not the identifier locations, + * duplicate entries would be returned here as each of the type references is part of + * the same implementation. For that reason, check before we add a new entry. + */ + this.markSeenContainingTypeReference = ts.nodeSeenTracker(); + /** + * It's possible that we will encounter the right side of `export { foo as bar } from "x";` more than once. + * For example: + * // b.ts + * export { foo as bar } from "./a"; + * import { bar } from "./b"; + * + * Normally at `foo as bar` we directly add `foo` and do not locally search for it (since it doesn't declare a local). + * But another reference to it may appear in the same source file. + * See `tests/cases/fourslash/transitiveExportImports3.ts`. + */ + this.markSeenReExportRHS = ts.nodeSeenTracker(); + this.symbolIdToReferences = []; + // Source file ID → symbol ID → Whether the symbol has been searched for in the source file. + this.sourceFileToSeenSymbols = []; + } + State.prototype.includesSourceFile = function (sourceFile) { + return this.sourceFilesSet.has(sourceFile.fileName); + }; + /** Gets every place to look for references of an exported symbols. See `ImportsResult` in `importTracker.ts` for more documentation. */ + State.prototype.getImportSearches = function (exportSymbol, exportInfo) { + if (!this.importTracker) + this.importTracker = FindAllReferences.createImportTracker(this.sourceFiles, this.sourceFilesSet, this.checker, this.cancellationToken); + return this.importTracker(exportSymbol, exportInfo, this.options.use === 2 /* FindReferencesUse.Rename */); + }; + /** @param allSearchSymbols set of additional symbols for use by `includes`. */ + State.prototype.createSearch = function (location, symbol, comingFrom, searchOptions) { + if (searchOptions === void 0) { searchOptions = {}; } + // Note: if this is an external module symbol, the name doesn't include quotes. + // Note: getLocalSymbolForExportDefault handles `export default class C {}`, but not `export default C` or `export { C as default }`. + // The other two forms seem to be handled downstream (e.g. in `skipPastExportOrImportSpecifier`), so special-casing the first form + // here appears to be intentional). + var _a = searchOptions.text, text = _a === void 0 ? ts.stripQuotes(ts.symbolName(ts.getLocalSymbolForExportDefault(symbol) || getNonModuleSymbolOfMergedModuleSymbol(symbol) || symbol)) : _a, _b = searchOptions.allSearchSymbols, allSearchSymbols = _b === void 0 ? [symbol] : _b; + var escapedText = ts.escapeLeadingUnderscores(text); + var parents = this.options.implementations && location ? getParentSymbolsOfPropertyAccess(location, symbol, this.checker) : undefined; + return { symbol: symbol, comingFrom: comingFrom, text: text, escapedText: escapedText, parents: parents, allSearchSymbols: allSearchSymbols, includes: function (sym) { return ts.contains(allSearchSymbols, sym); } }; + }; + /** + * Callback to add references for a particular searched symbol. + * This initializes a reference group, so only call this if you will add at least one reference. + */ + State.prototype.referenceAdder = function (searchSymbol) { + var symbolId = ts.getSymbolId(searchSymbol); + var references = this.symbolIdToReferences[symbolId]; + if (!references) { + references = this.symbolIdToReferences[symbolId] = []; + this.result.push({ definition: { type: 0 /* DefinitionKind.Symbol */, symbol: searchSymbol }, references: references }); + } + return function (node, kind) { return references.push(nodeEntry(node, kind)); }; + }; + /** Add a reference with no associated definition. */ + State.prototype.addStringOrCommentReference = function (fileName, textSpan) { + this.result.push({ + definition: undefined, + references: [{ kind: 0 /* EntryKind.Span */, fileName: fileName, textSpan: textSpan }] + }); + }; + /** Returns `true` the first time we search for a symbol in a file and `false` afterwards. */ + State.prototype.markSearchedSymbols = function (sourceFile, symbols) { + var sourceId = ts.getNodeId(sourceFile); + var seenSymbols = this.sourceFileToSeenSymbols[sourceId] || (this.sourceFileToSeenSymbols[sourceId] = new ts.Set()); + var anyNewSymbols = false; + for (var _i = 0, symbols_1 = symbols; _i < symbols_1.length; _i++) { + var sym = symbols_1[_i]; + anyNewSymbols = ts.tryAddToSet(seenSymbols, ts.getSymbolId(sym)) || anyNewSymbols; + } + return anyNewSymbols; + }; + return State; + }()); + /** Search for all imports of a given exported symbol using `State.getImportSearches`. */ + function searchForImportsOfExport(exportLocation, exportSymbol, exportInfo, state) { + var _a = state.getImportSearches(exportSymbol, exportInfo), importSearches = _a.importSearches, singleReferences = _a.singleReferences, indirectUsers = _a.indirectUsers; + // For `import { foo as bar }` just add the reference to `foo`, and don't otherwise search in the file. + if (singleReferences.length) { + var addRef = state.referenceAdder(exportSymbol); + for (var _i = 0, singleReferences_1 = singleReferences; _i < singleReferences_1.length; _i++) { + var singleRef = singleReferences_1[_i]; + if (shouldAddSingleReference(singleRef, state)) + addRef(singleRef); + } + } + // For each import, find all references to that import in its source file. + for (var _b = 0, importSearches_1 = importSearches; _b < importSearches_1.length; _b++) { + var _c = importSearches_1[_b], importLocation = _c[0], importSymbol = _c[1]; + getReferencesInSourceFile(importLocation.getSourceFile(), state.createSearch(importLocation, importSymbol, 1 /* ImportExport.Export */), state); + } + if (indirectUsers.length) { + var indirectSearch = void 0; + switch (exportInfo.exportKind) { + case 0 /* ExportKind.Named */: + indirectSearch = state.createSearch(exportLocation, exportSymbol, 1 /* ImportExport.Export */); + break; + case 1 /* ExportKind.Default */: + // Search for a property access to '.default'. This can't be renamed. + indirectSearch = state.options.use === 2 /* FindReferencesUse.Rename */ ? undefined : state.createSearch(exportLocation, exportSymbol, 1 /* ImportExport.Export */, { text: "default" }); + break; + case 2 /* ExportKind.ExportEquals */: + break; + } + if (indirectSearch) { + for (var _d = 0, indirectUsers_1 = indirectUsers; _d < indirectUsers_1.length; _d++) { + var indirectUser = indirectUsers_1[_d]; + searchForName(indirectUser, indirectSearch, state); + } + } + } + } + function eachExportReference(sourceFiles, checker, cancellationToken, exportSymbol, exportingModuleSymbol, exportName, isDefaultExport, cb) { + var importTracker = FindAllReferences.createImportTracker(sourceFiles, new ts.Set(sourceFiles.map(function (f) { return f.fileName; })), checker, cancellationToken); + var _a = importTracker(exportSymbol, { exportKind: isDefaultExport ? 1 /* ExportKind.Default */ : 0 /* ExportKind.Named */, exportingModuleSymbol: exportingModuleSymbol }, /*isForRename*/ false), importSearches = _a.importSearches, indirectUsers = _a.indirectUsers, singleReferences = _a.singleReferences; + for (var _i = 0, importSearches_2 = importSearches; _i < importSearches_2.length; _i++) { + var importLocation = importSearches_2[_i][0]; + cb(importLocation); + } + for (var _b = 0, singleReferences_2 = singleReferences; _b < singleReferences_2.length; _b++) { + var singleReference = singleReferences_2[_b]; + if (ts.isIdentifier(singleReference) && ts.isImportTypeNode(singleReference.parent)) { + cb(singleReference); + } + } + for (var _c = 0, indirectUsers_2 = indirectUsers; _c < indirectUsers_2.length; _c++) { + var indirectUser = indirectUsers_2[_c]; + for (var _d = 0, _e = getPossibleSymbolReferenceNodes(indirectUser, isDefaultExport ? "default" : exportName); _d < _e.length; _d++) { + var node = _e[_d]; + // Import specifiers should be handled by importSearches + var symbol = checker.getSymbolAtLocation(node); + var hasExportAssignmentDeclaration = ts.some(symbol === null || symbol === void 0 ? void 0 : symbol.declarations, function (d) { return ts.tryCast(d, ts.isExportAssignment) ? true : false; }); + if (ts.isIdentifier(node) && !ts.isImportOrExportSpecifier(node.parent) && (symbol === exportSymbol || hasExportAssignmentDeclaration)) { + cb(node); + } + } + } + } + Core.eachExportReference = eachExportReference; + function shouldAddSingleReference(singleRef, state) { + if (!hasMatchingMeaning(singleRef, state)) + return false; + if (state.options.use !== 2 /* FindReferencesUse.Rename */) + return true; + // Don't rename an import type `import("./module-name")` when renaming `name` in `export = name;` + if (!ts.isIdentifier(singleRef)) + return false; + // At `default` in `import { default as x }` or `export { default as x }`, do add a reference, but do not rename. + return !(ts.isImportOrExportSpecifier(singleRef.parent) && singleRef.escapedText === "default" /* InternalSymbolName.Default */); + } + // Go to the symbol we imported from and find references for it. + function searchForImportedSymbol(symbol, state) { + if (!symbol.declarations) + return; + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + var exportingFile = declaration.getSourceFile(); + // Need to search in the file even if it's not in the search-file set, because it might export the symbol. + getReferencesInSourceFile(exportingFile, state.createSearch(declaration, symbol, 0 /* ImportExport.Import */), state, state.includesSourceFile(exportingFile)); + } + } + /** Search for all occurrences of an identifier in a source file (and filter out the ones that match). */ + function searchForName(sourceFile, search, state) { + if (ts.getNameTable(sourceFile).get(search.escapedText) !== undefined) { + getReferencesInSourceFile(sourceFile, search, state); + } + } + function getPropertySymbolOfDestructuringAssignment(location, checker) { + return ts.isArrayLiteralOrObjectLiteralDestructuringPattern(location.parent.parent) + ? checker.getPropertySymbolOfDestructuringAssignment(location) + : undefined; + } + /** + * Determines the smallest scope in which a symbol may have named references. + * Note that not every construct has been accounted for. This function can + * probably be improved. + * + * @returns undefined if the scope cannot be determined, implying that + * a reference to a symbol can occur anywhere. + */ + function getSymbolScope(symbol) { + // If this is the symbol of a named function expression or named class expression, + // then named references are limited to its own scope. + var declarations = symbol.declarations, flags = symbol.flags, parent = symbol.parent, valueDeclaration = symbol.valueDeclaration; + if (valueDeclaration && (valueDeclaration.kind === 215 /* SyntaxKind.FunctionExpression */ || valueDeclaration.kind === 228 /* SyntaxKind.ClassExpression */)) { + return valueDeclaration; + } + if (!declarations) { + return undefined; + } + // If this is private property or method, the scope is the containing class + if (flags & (4 /* SymbolFlags.Property */ | 8192 /* SymbolFlags.Method */)) { + var privateDeclaration = ts.find(declarations, function (d) { return ts.hasEffectiveModifier(d, 8 /* ModifierFlags.Private */) || ts.isPrivateIdentifierClassElementDeclaration(d); }); + if (privateDeclaration) { + return ts.getAncestor(privateDeclaration, 260 /* SyntaxKind.ClassDeclaration */); + } + // Else this is a public property and could be accessed from anywhere. + return undefined; + } + // If symbol is of object binding pattern element without property name we would want to + // look for property too and that could be anywhere + if (declarations.some(ts.isObjectBindingElementWithoutPropertyName)) { + return undefined; + } + /* + If the symbol has a parent, it's globally visible unless: + - It's a private property (handled above). + - It's a type parameter. + - The parent is an external module: then we should only search in the module (and recurse on the export later). + - But if the parent has `export as namespace`, the symbol is globally visible through that namespace. + */ + var exposedByParent = parent && !(symbol.flags & 262144 /* SymbolFlags.TypeParameter */); + if (exposedByParent && !(ts.isExternalModuleSymbol(parent) && !parent.globalExports)) { + return undefined; + } + var scope; + for (var _i = 0, declarations_1 = declarations; _i < declarations_1.length; _i++) { + var declaration = declarations_1[_i]; + var container = ts.getContainerNode(declaration); + if (scope && scope !== container) { + // Different declarations have different containers, bail out + return undefined; + } + if (!container || container.kind === 308 /* SyntaxKind.SourceFile */ && !ts.isExternalOrCommonJsModule(container)) { + // This is a global variable and not an external module, any declaration defined + // within this scope is visible outside the file + return undefined; + } + scope = container; + if (ts.isFunctionExpression(scope)) { + var next = void 0; + while (next = ts.getNextJSDocCommentLocation(scope)) { + scope = next; + } + } + } + // If symbol.parent, this means we are in an export of an external module. (Otherwise we would have returned `undefined` above.) + // For an export of a module, we may be in a declaration file, and it may be accessed elsewhere. E.g.: + // declare module "a" { export type T = number; } + // declare module "b" { import { T } from "a"; export const x: T; } + // So we must search the whole source file. (Because we will mark the source file as seen, we we won't return to it when searching for imports.) + return exposedByParent ? scope.getSourceFile() : scope; // TODO: GH#18217 + } + /** Used as a quick check for whether a symbol is used at all in a file (besides its definition). */ + function isSymbolReferencedInFile(definition, checker, sourceFile, searchContainer) { + if (searchContainer === void 0) { searchContainer = sourceFile; } + return eachSymbolReferenceInFile(definition, checker, sourceFile, function () { return true; }, searchContainer) || false; + } + Core.isSymbolReferencedInFile = isSymbolReferencedInFile; + function eachSymbolReferenceInFile(definition, checker, sourceFile, cb, searchContainer) { + if (searchContainer === void 0) { searchContainer = sourceFile; } + var symbol = ts.isParameterPropertyDeclaration(definition.parent, definition.parent.parent) + ? ts.first(checker.getSymbolsOfParameterPropertyDeclaration(definition.parent, definition.text)) + : checker.getSymbolAtLocation(definition); + if (!symbol) + return undefined; + for (var _i = 0, _a = getPossibleSymbolReferenceNodes(sourceFile, symbol.name, searchContainer); _i < _a.length; _i++) { + var token = _a[_i]; + if (!ts.isIdentifier(token) || token === definition || token.escapedText !== definition.escapedText) + continue; + var referenceSymbol = checker.getSymbolAtLocation(token); + if (referenceSymbol === symbol + || checker.getShorthandAssignmentValueSymbol(token.parent) === symbol + || ts.isExportSpecifier(token.parent) && getLocalSymbolForExportSpecifier(token, referenceSymbol, token.parent, checker) === symbol) { + var res = cb(token); + if (res) + return res; + } + } + } + Core.eachSymbolReferenceInFile = eachSymbolReferenceInFile; + function getTopMostDeclarationNamesInFile(declarationName, sourceFile) { + var candidates = ts.filter(getPossibleSymbolReferenceNodes(sourceFile, declarationName), function (name) { return !!ts.getDeclarationFromName(name); }); + return candidates.reduce(function (topMost, decl) { + var depth = getDepth(decl); + if (!ts.some(topMost.declarationNames) || depth === topMost.depth) { + topMost.declarationNames.push(decl); + topMost.depth = depth; + } + else if (depth < topMost.depth) { + topMost.declarationNames = [decl]; + topMost.depth = depth; + } + return topMost; + }, { depth: Infinity, declarationNames: [] }).declarationNames; + function getDepth(declaration) { + var depth = 0; + while (declaration) { + declaration = ts.getContainerNode(declaration); + depth++; + } + return depth; + } + } + Core.getTopMostDeclarationNamesInFile = getTopMostDeclarationNamesInFile; + function someSignatureUsage(signature, sourceFiles, checker, cb) { + if (!signature.name || !ts.isIdentifier(signature.name)) + return false; + var symbol = ts.Debug.checkDefined(checker.getSymbolAtLocation(signature.name)); + for (var _i = 0, sourceFiles_3 = sourceFiles; _i < sourceFiles_3.length; _i++) { + var sourceFile = sourceFiles_3[_i]; + for (var _a = 0, _b = getPossibleSymbolReferenceNodes(sourceFile, symbol.name); _a < _b.length; _a++) { + var name = _b[_a]; + if (!ts.isIdentifier(name) || name === signature.name || name.escapedText !== signature.name.escapedText) + continue; + var called = ts.climbPastPropertyAccess(name); + var call = ts.isCallExpression(called.parent) && called.parent.expression === called ? called.parent : undefined; + var referenceSymbol = checker.getSymbolAtLocation(name); + if (referenceSymbol && checker.getRootSymbols(referenceSymbol).some(function (s) { return s === symbol; })) { + if (cb(name, call)) { + return true; + } + } + } + } + return false; + } + Core.someSignatureUsage = someSignatureUsage; + function getPossibleSymbolReferenceNodes(sourceFile, symbolName, container) { + if (container === void 0) { container = sourceFile; } + return getPossibleSymbolReferencePositions(sourceFile, symbolName, container).map(function (pos) { return ts.getTouchingPropertyName(sourceFile, pos); }); + } + function getPossibleSymbolReferencePositions(sourceFile, symbolName, container) { + if (container === void 0) { container = sourceFile; } + var positions = []; + /// TODO: Cache symbol existence for files to save text search + // Also, need to make this work for unicode escapes. + // Be resilient in the face of a symbol with no name or zero length name + if (!symbolName || !symbolName.length) { + return positions; + } + var text = sourceFile.text; + var sourceLength = text.length; + var symbolNameLength = symbolName.length; + var position = text.indexOf(symbolName, container.pos); + while (position >= 0) { + // If we are past the end, stop looking + if (position > container.end) + break; + // We found a match. Make sure it's not part of a larger word (i.e. the char + // before and after it have to be a non-identifier char). + var endPosition = position + symbolNameLength; + if ((position === 0 || !ts.isIdentifierPart(text.charCodeAt(position - 1), 99 /* ScriptTarget.Latest */)) && + (endPosition === sourceLength || !ts.isIdentifierPart(text.charCodeAt(endPosition), 99 /* ScriptTarget.Latest */))) { + // Found a real match. Keep searching. + positions.push(position); + } + position = text.indexOf(symbolName, position + symbolNameLength + 1); + } + return positions; + } + function getLabelReferencesInNode(container, targetLabel) { + var sourceFile = container.getSourceFile(); + var labelName = targetLabel.text; + var references = ts.mapDefined(getPossibleSymbolReferenceNodes(sourceFile, labelName, container), function (node) { + // Only pick labels that are either the target label, or have a target that is the target label + return node === targetLabel || (ts.isJumpStatementTarget(node) && ts.getTargetLabel(node, labelName) === targetLabel) ? nodeEntry(node) : undefined; + }); + return [{ definition: { type: 1 /* DefinitionKind.Label */, node: targetLabel }, references: references }]; + } + function isValidReferencePosition(node, searchSymbolName) { + // Compare the length so we filter out strict superstrings of the symbol we are looking for + switch (node.kind) { + case 80 /* SyntaxKind.PrivateIdentifier */: + if (ts.isJSDocMemberName(node.parent)) { + return true; + } + // falls through I guess + case 79 /* SyntaxKind.Identifier */: + return node.text.length === searchSymbolName.length; + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + case 10 /* SyntaxKind.StringLiteral */: { + var str = node; + return (ts.isLiteralNameOfPropertyDeclarationOrIndexAccess(str) || ts.isNameOfModuleDeclaration(node) || ts.isExpressionOfExternalModuleImportEqualsDeclaration(node) || (ts.isCallExpression(node.parent) && ts.isBindableObjectDefinePropertyCall(node.parent) && node.parent.arguments[1] === node)) && + str.text.length === searchSymbolName.length; + } + case 8 /* SyntaxKind.NumericLiteral */: + return ts.isLiteralNameOfPropertyDeclarationOrIndexAccess(node) && node.text.length === searchSymbolName.length; + case 88 /* SyntaxKind.DefaultKeyword */: + return "default".length === searchSymbolName.length; + default: + return false; + } + } + function getAllReferencesForImportMeta(sourceFiles, cancellationToken) { + var references = ts.flatMap(sourceFiles, function (sourceFile) { + cancellationToken.throwIfCancellationRequested(); + return ts.mapDefined(getPossibleSymbolReferenceNodes(sourceFile, "meta", sourceFile), function (node) { + var parent = node.parent; + if (ts.isImportMeta(parent)) { + return nodeEntry(parent); + } + }); + }); + return references.length ? [{ definition: { type: 2 /* DefinitionKind.Keyword */, node: references[0].node }, references: references }] : undefined; + } + function getAllReferencesForKeyword(sourceFiles, keywordKind, cancellationToken, filter) { + var references = ts.flatMap(sourceFiles, function (sourceFile) { + cancellationToken.throwIfCancellationRequested(); + return ts.mapDefined(getPossibleSymbolReferenceNodes(sourceFile, ts.tokenToString(keywordKind), sourceFile), function (referenceLocation) { + if (referenceLocation.kind === keywordKind && (!filter || filter(referenceLocation))) { + return nodeEntry(referenceLocation); + } + }); + }); + return references.length ? [{ definition: { type: 2 /* DefinitionKind.Keyword */, node: references[0].node }, references: references }] : undefined; + } + function getReferencesInSourceFile(sourceFile, search, state, addReferencesHere) { + if (addReferencesHere === void 0) { addReferencesHere = true; } + state.cancellationToken.throwIfCancellationRequested(); + return getReferencesInContainer(sourceFile, sourceFile, search, state, addReferencesHere); + } + /** + * Search within node "container" for references for a search value, where the search value is defined as a + * tuple of(searchSymbol, searchText, searchLocation, and searchMeaning). + * searchLocation: a node where the search value + */ + function getReferencesInContainer(container, sourceFile, search, state, addReferencesHere) { + if (!state.markSearchedSymbols(sourceFile, search.allSearchSymbols)) { + return; + } + for (var _i = 0, _a = getPossibleSymbolReferencePositions(sourceFile, search.text, container); _i < _a.length; _i++) { + var position = _a[_i]; + getReferencesAtLocation(sourceFile, position, search, state, addReferencesHere); + } + } + function hasMatchingMeaning(referenceLocation, state) { + return !!(ts.getMeaningFromLocation(referenceLocation) & state.searchMeaning); + } + function getReferencesAtLocation(sourceFile, position, search, state, addReferencesHere) { + var referenceLocation = ts.getTouchingPropertyName(sourceFile, position); + if (!isValidReferencePosition(referenceLocation, search.text)) { + // This wasn't the start of a token. Check to see if it might be a + // match in a comment or string if that's what the caller is asking + // for. + if (!state.options.implementations && (state.options.findInStrings && ts.isInString(sourceFile, position) || state.options.findInComments && ts.isInNonReferenceComment(sourceFile, position))) { + // In the case where we're looking inside comments/strings, we don't have + // an actual definition. So just use 'undefined' here. Features like + // 'Rename' won't care (as they ignore the definitions), and features like + // 'FindReferences' will just filter out these results. + state.addStringOrCommentReference(sourceFile.fileName, ts.createTextSpan(position, search.text.length)); + } + return; + } + if (!hasMatchingMeaning(referenceLocation, state)) + return; + var referenceSymbol = state.checker.getSymbolAtLocation(referenceLocation); + if (!referenceSymbol) { + return; + } + var parent = referenceLocation.parent; + if (ts.isImportSpecifier(parent) && parent.propertyName === referenceLocation) { + // This is added through `singleReferences` in ImportsResult. If we happen to see it again, don't add it again. + return; + } + if (ts.isExportSpecifier(parent)) { + ts.Debug.assert(referenceLocation.kind === 79 /* SyntaxKind.Identifier */); + getReferencesAtExportSpecifier(referenceLocation, referenceSymbol, parent, search, state, addReferencesHere); + return; + } + var relatedSymbol = getRelatedSymbol(search, referenceSymbol, referenceLocation, state); + if (!relatedSymbol) { + getReferenceForShorthandProperty(referenceSymbol, search, state); + return; + } + switch (state.specialSearchKind) { + case 0 /* SpecialSearchKind.None */: + if (addReferencesHere) + addReference(referenceLocation, relatedSymbol, state); + break; + case 1 /* SpecialSearchKind.Constructor */: + addConstructorReferences(referenceLocation, sourceFile, search, state); + break; + case 2 /* SpecialSearchKind.Class */: + addClassStaticThisReferences(referenceLocation, search, state); + break; + default: + ts.Debug.assertNever(state.specialSearchKind); + } + // Use the parent symbol if the location is commonjs require syntax on javascript files only. + if (ts.isInJSFile(referenceLocation) + && referenceLocation.parent.kind === 205 /* SyntaxKind.BindingElement */ + && ts.isVariableDeclarationInitializedToBareOrAccessedRequire(referenceLocation.parent.parent.parent)) { + referenceSymbol = referenceLocation.parent.symbol; + // The parent will not have a symbol if it's an ObjectBindingPattern (when destructuring is used). In + // this case, just skip it, since the bound identifiers are not an alias of the import. + if (!referenceSymbol) + return; + } + getImportOrExportReferences(referenceLocation, referenceSymbol, search, state); + } + function getReferencesAtExportSpecifier(referenceLocation, referenceSymbol, exportSpecifier, search, state, addReferencesHere, alwaysGetReferences) { + ts.Debug.assert(!alwaysGetReferences || !!state.options.providePrefixAndSuffixTextForRename, "If alwaysGetReferences is true, then prefix/suffix text must be enabled"); + var parent = exportSpecifier.parent, propertyName = exportSpecifier.propertyName, name = exportSpecifier.name; + var exportDeclaration = parent.parent; + var localSymbol = getLocalSymbolForExportSpecifier(referenceLocation, referenceSymbol, exportSpecifier, state.checker); + if (!alwaysGetReferences && !search.includes(localSymbol)) { + return; + } + if (!propertyName) { + // Don't rename at `export { default } from "m";`. (but do continue to search for imports of the re-export) + if (!(state.options.use === 2 /* FindReferencesUse.Rename */ && (name.escapedText === "default" /* InternalSymbolName.Default */))) { + addRef(); + } + } + else if (referenceLocation === propertyName) { + // For `export { foo as bar } from "baz"`, "`foo`" will be added from the singleReferences for import searches of the original export. + // For `export { foo as bar };`, where `foo` is a local, so add it now. + if (!exportDeclaration.moduleSpecifier) { + addRef(); + } + if (addReferencesHere && state.options.use !== 2 /* FindReferencesUse.Rename */ && state.markSeenReExportRHS(name)) { + addReference(name, ts.Debug.checkDefined(exportSpecifier.symbol), state); + } + } + else { + if (state.markSeenReExportRHS(referenceLocation)) { + addRef(); + } + } + // For `export { foo as bar }`, rename `foo`, but not `bar`. + if (!isForRenameWithPrefixAndSuffixText(state.options) || alwaysGetReferences) { + var isDefaultExport = referenceLocation.originalKeywordKind === 88 /* SyntaxKind.DefaultKeyword */ + || exportSpecifier.name.originalKeywordKind === 88 /* SyntaxKind.DefaultKeyword */; + var exportKind = isDefaultExport ? 1 /* ExportKind.Default */ : 0 /* ExportKind.Named */; + var exportSymbol = ts.Debug.checkDefined(exportSpecifier.symbol); + var exportInfo = FindAllReferences.getExportInfo(exportSymbol, exportKind, state.checker); + if (exportInfo) { + searchForImportsOfExport(referenceLocation, exportSymbol, exportInfo, state); + } + } + // At `export { x } from "foo"`, also search for the imported symbol `"foo".x`. + if (search.comingFrom !== 1 /* ImportExport.Export */ && exportDeclaration.moduleSpecifier && !propertyName && !isForRenameWithPrefixAndSuffixText(state.options)) { + var imported = state.checker.getExportSpecifierLocalTargetSymbol(exportSpecifier); + if (imported) + searchForImportedSymbol(imported, state); + } + function addRef() { + if (addReferencesHere) + addReference(referenceLocation, localSymbol, state); + } + } + function getLocalSymbolForExportSpecifier(referenceLocation, referenceSymbol, exportSpecifier, checker) { + return isExportSpecifierAlias(referenceLocation, exportSpecifier) && checker.getExportSpecifierLocalTargetSymbol(exportSpecifier) || referenceSymbol; + } + function isExportSpecifierAlias(referenceLocation, exportSpecifier) { + var parent = exportSpecifier.parent, propertyName = exportSpecifier.propertyName, name = exportSpecifier.name; + ts.Debug.assert(propertyName === referenceLocation || name === referenceLocation); + if (propertyName) { + // Given `export { foo as bar } [from "someModule"]`: It's an alias at `foo`, but at `bar` it's a new symbol. + return propertyName === referenceLocation; + } + else { + // `export { foo } from "foo"` is a re-export. + // `export { foo };` is not a re-export, it creates an alias for the local variable `foo`. + return !parent.parent.moduleSpecifier; + } + } + function getImportOrExportReferences(referenceLocation, referenceSymbol, search, state) { + var importOrExport = FindAllReferences.getImportOrExportSymbol(referenceLocation, referenceSymbol, state.checker, search.comingFrom === 1 /* ImportExport.Export */); + if (!importOrExport) + return; + var symbol = importOrExport.symbol; + if (importOrExport.kind === 0 /* ImportExport.Import */) { + if (!(isForRenameWithPrefixAndSuffixText(state.options))) { + searchForImportedSymbol(symbol, state); + } + } + else { + searchForImportsOfExport(referenceLocation, symbol, importOrExport.exportInfo, state); + } + } + function getReferenceForShorthandProperty(_a, search, state) { + var flags = _a.flags, valueDeclaration = _a.valueDeclaration; + var shorthandValueSymbol = state.checker.getShorthandAssignmentValueSymbol(valueDeclaration); + var name = valueDeclaration && ts.getNameOfDeclaration(valueDeclaration); + /* + * Because in short-hand property assignment, an identifier which stored as name of the short-hand property assignment + * has two meanings: property name and property value. Therefore when we do findAllReference at the position where + * an identifier is declared, the language service should return the position of the variable declaration as well as + * the position in short-hand property assignment excluding property accessing. However, if we do findAllReference at the + * position of property accessing, the referenceEntry of such position will be handled in the first case. + */ + if (!(flags & 33554432 /* SymbolFlags.Transient */) && name && search.includes(shorthandValueSymbol)) { + addReference(name, shorthandValueSymbol, state); + } + } + function addReference(referenceLocation, relatedSymbol, state) { + var _a = "kind" in relatedSymbol ? relatedSymbol : { kind: undefined, symbol: relatedSymbol }, kind = _a.kind, symbol = _a.symbol; // eslint-disable-line local/no-in-operator + // if rename symbol from default export anonymous function, for example `export default function() {}`, we do not need to add reference + if (state.options.use === 2 /* FindReferencesUse.Rename */ && referenceLocation.kind === 88 /* SyntaxKind.DefaultKeyword */) { + return; + } + var addRef = state.referenceAdder(symbol); + if (state.options.implementations) { + addImplementationReferences(referenceLocation, addRef, state); + } + else { + addRef(referenceLocation, kind); + } + } + /** Adds references when a constructor is used with `new this()` in its own class and `super()` calls in subclasses. */ + function addConstructorReferences(referenceLocation, sourceFile, search, state) { + if (ts.isNewExpressionTarget(referenceLocation)) { + addReference(referenceLocation, search.symbol, state); + } + var pusher = function () { return state.referenceAdder(search.symbol); }; + if (ts.isClassLike(referenceLocation.parent)) { + ts.Debug.assert(referenceLocation.kind === 88 /* SyntaxKind.DefaultKeyword */ || referenceLocation.parent.name === referenceLocation); + // This is the class declaration containing the constructor. + findOwnConstructorReferences(search.symbol, sourceFile, pusher()); + } + else { + // If this class appears in `extends C`, then the extending class' "super" calls are references. + var classExtending = tryGetClassByExtendingIdentifier(referenceLocation); + if (classExtending) { + findSuperConstructorAccesses(classExtending, pusher()); + findInheritedConstructorReferences(classExtending, state); + } + } + } + function addClassStaticThisReferences(referenceLocation, search, state) { + addReference(referenceLocation, search.symbol, state); + var classLike = referenceLocation.parent; + if (state.options.use === 2 /* FindReferencesUse.Rename */ || !ts.isClassLike(classLike)) + return; + ts.Debug.assert(classLike.name === referenceLocation); + var addRef = state.referenceAdder(search.symbol); + for (var _i = 0, _a = classLike.members; _i < _a.length; _i++) { + var member = _a[_i]; + if (!(ts.isMethodOrAccessor(member) && ts.isStatic(member))) { + continue; + } + if (member.body) { + member.body.forEachChild(function cb(node) { + if (node.kind === 108 /* SyntaxKind.ThisKeyword */) { + addRef(node); + } + else if (!ts.isFunctionLike(node) && !ts.isClassLike(node)) { + node.forEachChild(cb); + } + }); + } + } + } + /** + * `classSymbol` is the class where the constructor was defined. + * Reference the constructor and all calls to `new this()`. + */ + function findOwnConstructorReferences(classSymbol, sourceFile, addNode) { + var constructorSymbol = getClassConstructorSymbol(classSymbol); + if (constructorSymbol && constructorSymbol.declarations) { + for (var _i = 0, _a = constructorSymbol.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + var ctrKeyword = ts.findChildOfKind(decl, 135 /* SyntaxKind.ConstructorKeyword */, sourceFile); + ts.Debug.assert(decl.kind === 173 /* SyntaxKind.Constructor */ && !!ctrKeyword); + addNode(ctrKeyword); + } + } + if (classSymbol.exports) { + classSymbol.exports.forEach(function (member) { + var decl = member.valueDeclaration; + if (decl && decl.kind === 171 /* SyntaxKind.MethodDeclaration */) { + var body = decl.body; + if (body) { + forEachDescendantOfKind(body, 108 /* SyntaxKind.ThisKeyword */, function (thisKeyword) { + if (ts.isNewExpressionTarget(thisKeyword)) { + addNode(thisKeyword); + } + }); + } + } + }); + } + } + function getClassConstructorSymbol(classSymbol) { + return classSymbol.members && classSymbol.members.get("__constructor" /* InternalSymbolName.Constructor */); + } + /** Find references to `super` in the constructor of an extending class. */ + function findSuperConstructorAccesses(classDeclaration, addNode) { + var constructor = getClassConstructorSymbol(classDeclaration.symbol); + if (!(constructor && constructor.declarations)) { + return; + } + for (var _i = 0, _a = constructor.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + ts.Debug.assert(decl.kind === 173 /* SyntaxKind.Constructor */); + var body = decl.body; + if (body) { + forEachDescendantOfKind(body, 106 /* SyntaxKind.SuperKeyword */, function (node) { + if (ts.isCallExpressionTarget(node)) { + addNode(node); + } + }); + } + } + } + function hasOwnConstructor(classDeclaration) { + return !!getClassConstructorSymbol(classDeclaration.symbol); + } + function findInheritedConstructorReferences(classDeclaration, state) { + if (hasOwnConstructor(classDeclaration)) + return; + var classSymbol = classDeclaration.symbol; + var search = state.createSearch(/*location*/ undefined, classSymbol, /*comingFrom*/ undefined); + getReferencesInContainerOrFiles(classSymbol, state, search); + } + function addImplementationReferences(refNode, addReference, state) { + // Check if we found a function/propertyAssignment/method with an implementation or initializer + if (ts.isDeclarationName(refNode) && isImplementation(refNode.parent)) { + addReference(refNode); + return; + } + if (refNode.kind !== 79 /* SyntaxKind.Identifier */) { + return; + } + if (refNode.parent.kind === 300 /* SyntaxKind.ShorthandPropertyAssignment */) { + // Go ahead and dereference the shorthand assignment by going to its definition + getReferenceEntriesForShorthandPropertyAssignment(refNode, state.checker, addReference); + } + // Check if the node is within an extends or implements clause + var containingClass = getContainingClassIfInHeritageClause(refNode); + if (containingClass) { + addReference(containingClass); + return; + } + // If we got a type reference, try and see if the reference applies to any expressions that can implement an interface + // Find the first node whose parent isn't a type node -- i.e., the highest type node. + var typeNode = ts.findAncestor(refNode, function (a) { return !ts.isQualifiedName(a.parent) && !ts.isTypeNode(a.parent) && !ts.isTypeElement(a.parent); }); + var typeHavingNode = typeNode.parent; + if (ts.hasType(typeHavingNode) && typeHavingNode.type === typeNode && state.markSeenContainingTypeReference(typeHavingNode)) { + if (ts.hasInitializer(typeHavingNode)) { + addIfImplementation(typeHavingNode.initializer); + } + else if (ts.isFunctionLike(typeHavingNode) && typeHavingNode.body) { + var body = typeHavingNode.body; + if (body.kind === 238 /* SyntaxKind.Block */) { + ts.forEachReturnStatement(body, function (returnStatement) { + if (returnStatement.expression) + addIfImplementation(returnStatement.expression); + }); + } + else { + addIfImplementation(body); + } + } + else if (ts.isAssertionExpression(typeHavingNode)) { + addIfImplementation(typeHavingNode.expression); + } + } + function addIfImplementation(e) { + if (isImplementationExpression(e)) + addReference(e); + } + } + function getContainingClassIfInHeritageClause(node) { + return ts.isIdentifier(node) || ts.isPropertyAccessExpression(node) ? getContainingClassIfInHeritageClause(node.parent) + : ts.isExpressionWithTypeArguments(node) ? ts.tryCast(node.parent.parent, ts.isClassLike) : undefined; + } + /** + * Returns true if this is an expression that can be considered an implementation + */ + function isImplementationExpression(node) { + switch (node.kind) { + case 214 /* SyntaxKind.ParenthesizedExpression */: + return isImplementationExpression(node.expression); + case 216 /* SyntaxKind.ArrowFunction */: + case 215 /* SyntaxKind.FunctionExpression */: + case 207 /* SyntaxKind.ObjectLiteralExpression */: + case 228 /* SyntaxKind.ClassExpression */: + case 206 /* SyntaxKind.ArrayLiteralExpression */: + return true; + default: + return false; + } + } + /** + * Determines if the parent symbol occurs somewhere in the child's ancestry. If the parent symbol + * is an interface, determines if some ancestor of the child symbol extends or inherits from it. + * Also takes in a cache of previous results which makes this slightly more efficient and is + * necessary to avoid potential loops like so: + * class A extends B { } + * class B extends A { } + * + * We traverse the AST rather than using the type checker because users are typically only interested + * in explicit implementations of an interface/class when calling "Go to Implementation". Sibling + * implementations of types that share a common ancestor with the type whose implementation we are + * searching for need to be filtered out of the results. The type checker doesn't let us make the + * distinction between structurally compatible implementations and explicit implementations, so we + * must use the AST. + * + * @param symbol A class or interface Symbol + * @param parent Another class or interface Symbol + * @param cachedResults A map of symbol id pairs (i.e. "child,parent") to booleans indicating previous results + */ + function explicitlyInheritsFrom(symbol, parent, cachedResults, checker) { + if (symbol === parent) { + return true; + } + var key = ts.getSymbolId(symbol) + "," + ts.getSymbolId(parent); + var cached = cachedResults.get(key); + if (cached !== undefined) { + return cached; + } + // Set the key so that we don't infinitely recurse + cachedResults.set(key, false); + var inherits = !!symbol.declarations && symbol.declarations.some(function (declaration) { + return ts.getAllSuperTypeNodes(declaration).some(function (typeReference) { + var type = checker.getTypeAtLocation(typeReference); + return !!type && !!type.symbol && explicitlyInheritsFrom(type.symbol, parent, cachedResults, checker); + }); + }); + cachedResults.set(key, inherits); + return inherits; + } + function getReferencesForSuperKeyword(superKeyword) { + var searchSpaceNode = ts.getSuperContainer(superKeyword, /*stopOnFunctions*/ false); + if (!searchSpaceNode) { + return undefined; + } + // Whether 'super' occurs in a static context within a class. + var staticFlag = 32 /* ModifierFlags.Static */; + switch (searchSpaceNode.kind) { + case 169 /* SyntaxKind.PropertyDeclaration */: + case 168 /* SyntaxKind.PropertySignature */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + case 173 /* SyntaxKind.Constructor */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + staticFlag &= ts.getSyntacticModifierFlags(searchSpaceNode); + searchSpaceNode = searchSpaceNode.parent; // re-assign to be the owning class + break; + default: + return undefined; + } + var sourceFile = searchSpaceNode.getSourceFile(); + var references = ts.mapDefined(getPossibleSymbolReferenceNodes(sourceFile, "super", searchSpaceNode), function (node) { + if (node.kind !== 106 /* SyntaxKind.SuperKeyword */) { + return; + } + var container = ts.getSuperContainer(node, /*stopOnFunctions*/ false); + // If we have a 'super' container, we must have an enclosing class. + // Now make sure the owning class is the same as the search-space + // and has the same static qualifier as the original 'super's owner. + return container && ts.isStatic(container) === !!staticFlag && container.parent.symbol === searchSpaceNode.symbol ? nodeEntry(node) : undefined; + }); + return [{ definition: { type: 0 /* DefinitionKind.Symbol */, symbol: searchSpaceNode.symbol }, references: references }]; + } + function isParameterName(node) { + return node.kind === 79 /* SyntaxKind.Identifier */ && node.parent.kind === 166 /* SyntaxKind.Parameter */ && node.parent.name === node; + } + function getReferencesForThisKeyword(thisOrSuperKeyword, sourceFiles, cancellationToken) { + var searchSpaceNode = ts.getThisContainer(thisOrSuperKeyword, /* includeArrowFunctions */ false); + // Whether 'this' occurs in a static context within a class. + var staticFlag = 32 /* ModifierFlags.Static */; + switch (searchSpaceNode.kind) { + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + if (ts.isObjectLiteralMethod(searchSpaceNode)) { + staticFlag &= ts.getSyntacticModifierFlags(searchSpaceNode); + searchSpaceNode = searchSpaceNode.parent; // re-assign to be the owning object literals + break; + } + // falls through + case 169 /* SyntaxKind.PropertyDeclaration */: + case 168 /* SyntaxKind.PropertySignature */: + case 173 /* SyntaxKind.Constructor */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + staticFlag &= ts.getSyntacticModifierFlags(searchSpaceNode); + searchSpaceNode = searchSpaceNode.parent; // re-assign to be the owning class + break; + case 308 /* SyntaxKind.SourceFile */: + if (ts.isExternalModule(searchSpaceNode) || isParameterName(thisOrSuperKeyword)) { + return undefined; + } + // falls through + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + break; + // Computed properties in classes are not handled here because references to this are illegal, + // so there is no point finding references to them. + default: + return undefined; + } + var references = ts.flatMap(searchSpaceNode.kind === 308 /* SyntaxKind.SourceFile */ ? sourceFiles : [searchSpaceNode.getSourceFile()], function (sourceFile) { + cancellationToken.throwIfCancellationRequested(); + return getPossibleSymbolReferenceNodes(sourceFile, "this", ts.isSourceFile(searchSpaceNode) ? sourceFile : searchSpaceNode).filter(function (node) { + if (!ts.isThis(node)) { + return false; + } + var container = ts.getThisContainer(node, /* includeArrowFunctions */ false); + switch (searchSpaceNode.kind) { + case 215 /* SyntaxKind.FunctionExpression */: + case 259 /* SyntaxKind.FunctionDeclaration */: + return searchSpaceNode.symbol === container.symbol; + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + return ts.isObjectLiteralMethod(searchSpaceNode) && searchSpaceNode.symbol === container.symbol; + case 228 /* SyntaxKind.ClassExpression */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 207 /* SyntaxKind.ObjectLiteralExpression */: + // Make sure the container belongs to the same class/object literals + // and has the appropriate static modifier from the original container. + return container.parent && searchSpaceNode.symbol === container.parent.symbol && ts.isStatic(container) === !!staticFlag; + case 308 /* SyntaxKind.SourceFile */: + return container.kind === 308 /* SyntaxKind.SourceFile */ && !ts.isExternalModule(container) && !isParameterName(node); + } + }); + }).map(function (n) { return nodeEntry(n); }); + var thisParameter = ts.firstDefined(references, function (r) { return ts.isParameter(r.node.parent) ? r.node : undefined; }); + return [{ + definition: { type: 3 /* DefinitionKind.This */, node: thisParameter || thisOrSuperKeyword }, + references: references + }]; + } + function getReferencesForStringLiteral(node, sourceFiles, checker, cancellationToken) { + var type = ts.getContextualTypeFromParentOrAncestorTypeNode(node, checker); + var references = ts.flatMap(sourceFiles, function (sourceFile) { + cancellationToken.throwIfCancellationRequested(); + return ts.mapDefined(getPossibleSymbolReferenceNodes(sourceFile, node.text), function (ref) { + if (ts.isStringLiteralLike(ref) && ref.text === node.text) { + if (type) { + var refType = ts.getContextualTypeFromParentOrAncestorTypeNode(ref, checker); + if (type !== checker.getStringType() && type === refType) { + return nodeEntry(ref, 2 /* EntryKind.StringLiteral */); + } + } + else { + return ts.isNoSubstitutionTemplateLiteral(ref) && !ts.rangeIsOnSingleLine(ref, sourceFile) ? undefined : + nodeEntry(ref, 2 /* EntryKind.StringLiteral */); + } + } + }); + }); + return [{ + definition: { type: 4 /* DefinitionKind.String */, node: node }, + references: references + }]; + } + // For certain symbol kinds, we need to include other symbols in the search set. + // This is not needed when searching for re-exports. + function populateSearchSymbolSet(symbol, location, checker, isForRename, providePrefixAndSuffixText, implementations) { + var result = []; + forEachRelatedSymbol(symbol, location, checker, isForRename, !(isForRename && providePrefixAndSuffixText), function (sym, root, base) { + // static method/property and instance method/property might have the same name. Only include static or only include instance. + if (base) { + if (isStaticSymbol(symbol) !== isStaticSymbol(base)) { + base = undefined; + } + } + result.push(base || root || sym); + }, + // when try to find implementation, implementations is true, and not allowed to find base class + /*allowBaseTypes*/ function () { return !implementations; }); + return result; + } + /** + * @param allowBaseTypes return true means it would try to find in base class or interface. + */ + function forEachRelatedSymbol(symbol, location, checker, isForRenamePopulateSearchSymbolSet, onlyIncludeBindingElementAtReferenceLocation, + /** + * @param baseSymbol This symbol means one property/mehtod from base class or interface when it is not null or undefined, + */ + cbSymbol, allowBaseTypes) { + var containingObjectLiteralElement = ts.getContainingObjectLiteralElement(location); + if (containingObjectLiteralElement) { + /* Because in short-hand property assignment, location has two meaning : property name and as value of the property + * When we do findAllReference at the position of the short-hand property assignment, we would want to have references to position of + * property name and variable declaration of the identifier. + * Like in below example, when querying for all references for an identifier 'name', of the property assignment, the language service + * should show both 'name' in 'obj' and 'name' in variable declaration + * const name = "Foo"; + * const obj = { name }; + * In order to do that, we will populate the search set with the value symbol of the identifier as a value of the property assignment + * so that when matching with potential reference symbol, both symbols from property declaration and variable declaration + * will be included correctly. + */ + var shorthandValueSymbol = checker.getShorthandAssignmentValueSymbol(location.parent); // gets the local symbol + if (shorthandValueSymbol && isForRenamePopulateSearchSymbolSet) { + // When renaming 'x' in `const o = { x }`, just rename the local variable, not the property. + return cbSymbol(shorthandValueSymbol, /*rootSymbol*/ undefined, /*baseSymbol*/ undefined, 3 /* EntryKind.SearchedLocalFoundProperty */); + } + // If the location is in a context sensitive location (i.e. in an object literal) try + // to get a contextual type for it, and add the property symbol from the contextual + // type to the search set + var contextualType = checker.getContextualType(containingObjectLiteralElement.parent); + var res_1 = contextualType && ts.firstDefined(ts.getPropertySymbolsFromContextualType(containingObjectLiteralElement, checker, contextualType, /*unionSymbolOk*/ true), function (sym) { return fromRoot(sym, 4 /* EntryKind.SearchedPropertyFoundLocal */); }); + if (res_1) + return res_1; + // If the location is name of property symbol from object literal destructuring pattern + // Search the property symbol + // for ( { property: p2 } of elems) { } + var propertySymbol = getPropertySymbolOfDestructuringAssignment(location, checker); + var res1 = propertySymbol && cbSymbol(propertySymbol, /*rootSymbol*/ undefined, /*baseSymbol*/ undefined, 4 /* EntryKind.SearchedPropertyFoundLocal */); + if (res1) + return res1; + var res2 = shorthandValueSymbol && cbSymbol(shorthandValueSymbol, /*rootSymbol*/ undefined, /*baseSymbol*/ undefined, 3 /* EntryKind.SearchedLocalFoundProperty */); + if (res2) + return res2; + } + var aliasedSymbol = getMergedAliasedSymbolOfNamespaceExportDeclaration(location, symbol, checker); + if (aliasedSymbol) { + // In case of UMD module and global merging, search for global as well + var res_2 = cbSymbol(aliasedSymbol, /*rootSymbol*/ undefined, /*baseSymbol*/ undefined, 1 /* EntryKind.Node */); + if (res_2) + return res_2; + } + var res = fromRoot(symbol); + if (res) + return res; + if (symbol.valueDeclaration && ts.isParameterPropertyDeclaration(symbol.valueDeclaration, symbol.valueDeclaration.parent)) { + // For a parameter property, now try on the other symbol (property if this was a parameter, parameter if this was a property). + var paramProps = checker.getSymbolsOfParameterPropertyDeclaration(ts.cast(symbol.valueDeclaration, ts.isParameter), symbol.name); + ts.Debug.assert(paramProps.length === 2 && !!(paramProps[0].flags & 1 /* SymbolFlags.FunctionScopedVariable */) && !!(paramProps[1].flags & 4 /* SymbolFlags.Property */)); // is [parameter, property] + return fromRoot(symbol.flags & 1 /* SymbolFlags.FunctionScopedVariable */ ? paramProps[1] : paramProps[0]); + } + var exportSpecifier = ts.getDeclarationOfKind(symbol, 278 /* SyntaxKind.ExportSpecifier */); + if (!isForRenamePopulateSearchSymbolSet || exportSpecifier && !exportSpecifier.propertyName) { + var localSymbol = exportSpecifier && checker.getExportSpecifierLocalTargetSymbol(exportSpecifier); + if (localSymbol) { + var res_3 = cbSymbol(localSymbol, /*rootSymbol*/ undefined, /*baseSymbol*/ undefined, 1 /* EntryKind.Node */); + if (res_3) + return res_3; + } + } + // symbolAtLocation for a binding element is the local symbol. See if the search symbol is the property. + // Don't do this when populating search set for a rename when prefix and suffix text will be provided -- just rename the local. + if (!isForRenamePopulateSearchSymbolSet) { + var bindingElementPropertySymbol = void 0; + if (onlyIncludeBindingElementAtReferenceLocation) { + bindingElementPropertySymbol = ts.isObjectBindingElementWithoutPropertyName(location.parent) ? ts.getPropertySymbolFromBindingElement(checker, location.parent) : undefined; + } + else { + bindingElementPropertySymbol = getPropertySymbolOfObjectBindingPatternWithoutPropertyName(symbol, checker); + } + return bindingElementPropertySymbol && fromRoot(bindingElementPropertySymbol, 4 /* EntryKind.SearchedPropertyFoundLocal */); + } + ts.Debug.assert(isForRenamePopulateSearchSymbolSet); + // due to the above assert and the arguments at the uses of this function, + // (onlyIncludeBindingElementAtReferenceLocation <=> !providePrefixAndSuffixTextForRename) holds + var includeOriginalSymbolOfBindingElement = onlyIncludeBindingElementAtReferenceLocation; + if (includeOriginalSymbolOfBindingElement) { + var bindingElementPropertySymbol = getPropertySymbolOfObjectBindingPatternWithoutPropertyName(symbol, checker); + return bindingElementPropertySymbol && fromRoot(bindingElementPropertySymbol, 4 /* EntryKind.SearchedPropertyFoundLocal */); + } + function fromRoot(sym, kind) { + // If this is a union property: + // - In populateSearchSymbolsSet we will add all the symbols from all its source symbols in all unioned types. + // - In findRelatedSymbol, we will just use the union symbol if any source symbol is included in the search. + // If the symbol is an instantiation from a another symbol (e.g. widened symbol): + // - In populateSearchSymbolsSet, add the root the list + // - In findRelatedSymbol, return the source symbol if that is in the search. (Do not return the instantiation symbol.) + return ts.firstDefined(checker.getRootSymbols(sym), function (rootSymbol) { + return cbSymbol(sym, rootSymbol, /*baseSymbol*/ undefined, kind) + // Add symbol of properties/methods of the same name in base classes and implemented interfaces definitions + || (rootSymbol.parent && rootSymbol.parent.flags & (32 /* SymbolFlags.Class */ | 64 /* SymbolFlags.Interface */) && allowBaseTypes(rootSymbol) + ? getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.name, checker, function (base) { return cbSymbol(sym, rootSymbol, base, kind); }) + : undefined); + }); + } + function getPropertySymbolOfObjectBindingPatternWithoutPropertyName(symbol, checker) { + var bindingElement = ts.getDeclarationOfKind(symbol, 205 /* SyntaxKind.BindingElement */); + if (bindingElement && ts.isObjectBindingElementWithoutPropertyName(bindingElement)) { + return ts.getPropertySymbolFromBindingElement(checker, bindingElement); + } + } + } + /** + * Find symbol of the given property-name and add the symbol to the given result array + * @param symbol a symbol to start searching for the given propertyName + * @param propertyName a name of property to search for + * @param result an array of symbol of found property symbols + * @param previousIterationSymbolsCache a cache of symbol from previous iterations of calling this function to prevent infinite revisiting of the same symbol. + * The value of previousIterationSymbol is undefined when the function is first called. + */ + function getPropertySymbolsFromBaseTypes(symbol, propertyName, checker, cb) { + var seen = new ts.Map(); + return recur(symbol); + function recur(symbol) { + // Use `addToSeen` to ensure we don't infinitely recurse in this situation: + // interface C extends C { + // /*findRef*/propName: string; + // } + if (!(symbol.flags & (32 /* SymbolFlags.Class */ | 64 /* SymbolFlags.Interface */)) || !ts.addToSeen(seen, ts.getSymbolId(symbol))) + return; + return ts.firstDefined(symbol.declarations, function (declaration) { return ts.firstDefined(ts.getAllSuperTypeNodes(declaration), function (typeReference) { + var type = checker.getTypeAtLocation(typeReference); + var propertySymbol = type && type.symbol && checker.getPropertyOfType(type, propertyName); + // Visit the typeReference as well to see if it directly or indirectly uses that property + return type && propertySymbol && (ts.firstDefined(checker.getRootSymbols(propertySymbol), cb) || recur(type.symbol)); + }); }); + } + } + function isStaticSymbol(symbol) { + if (!symbol.valueDeclaration) + return false; + var modifierFlags = ts.getEffectiveModifierFlags(symbol.valueDeclaration); + return !!(modifierFlags & 32 /* ModifierFlags.Static */); + } + function getRelatedSymbol(search, referenceSymbol, referenceLocation, state) { + var checker = state.checker; + return forEachRelatedSymbol(referenceSymbol, referenceLocation, checker, /*isForRenamePopulateSearchSymbolSet*/ false, + /*onlyIncludeBindingElementAtReferenceLocation*/ state.options.use !== 2 /* FindReferencesUse.Rename */ || !!state.options.providePrefixAndSuffixTextForRename, function (sym, rootSymbol, baseSymbol, kind) { + // check whether the symbol used to search itself is just the searched one. + if (baseSymbol) { + // static method/property and instance method/property might have the same name. Only check static or only check instance. + if (isStaticSymbol(referenceSymbol) !== isStaticSymbol(baseSymbol)) { + baseSymbol = undefined; + } + } + return search.includes(baseSymbol || rootSymbol || sym) + // For a base type, use the symbol for the derived type. For a synthetic (e.g. union) property, use the union symbol. + ? { symbol: rootSymbol && !(ts.getCheckFlags(sym) & 6 /* CheckFlags.Synthetic */) ? rootSymbol : sym, kind: kind } + : undefined; + }, + /*allowBaseTypes*/ function (rootSymbol) { + return !(search.parents && !search.parents.some(function (parent) { return explicitlyInheritsFrom(rootSymbol.parent, parent, state.inheritsFromCache, checker); })); + }); + } + /** + * Given an initial searchMeaning, extracted from a location, widen the search scope based on the declarations + * of the corresponding symbol. e.g. if we are searching for "Foo" in value position, but "Foo" references a class + * then we need to widen the search to include type positions as well. + * On the contrary, if we are searching for "Bar" in type position and we trace bar to an interface, and an uninstantiated + * module, we want to keep the search limited to only types, as the two declarations (interface and uninstantiated module) + * do not intersect in any of the three spaces. + */ + function getIntersectingMeaningFromDeclarations(node, symbol) { + var meaning = ts.getMeaningFromLocation(node); + var declarations = symbol.declarations; + if (declarations) { + var lastIterationMeaning = void 0; + do { + // The result is order-sensitive, for instance if initialMeaning === Namespace, and declarations = [class, instantiated module] + // we need to consider both as they initialMeaning intersects with the module in the namespace space, and the module + // intersects with the class in the value space. + // To achieve that we will keep iterating until the result stabilizes. + // Remember the last meaning + lastIterationMeaning = meaning; + for (var _i = 0, declarations_2 = declarations; _i < declarations_2.length; _i++) { + var declaration = declarations_2[_i]; + var declarationMeaning = ts.getMeaningFromDeclaration(declaration); + if (declarationMeaning & meaning) { + meaning |= declarationMeaning; + } + } + } while (meaning !== lastIterationMeaning); + } + return meaning; + } + Core.getIntersectingMeaningFromDeclarations = getIntersectingMeaningFromDeclarations; + function isImplementation(node) { + return !!(node.flags & 16777216 /* NodeFlags.Ambient */) ? !(ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node)) : + (ts.isVariableLike(node) ? ts.hasInitializer(node) : + ts.isFunctionLikeDeclaration(node) ? !!node.body : + ts.isClassLike(node) || ts.isModuleOrEnumDeclaration(node)); + } + function getReferenceEntriesForShorthandPropertyAssignment(node, checker, addReference) { + var refSymbol = checker.getSymbolAtLocation(node); + var shorthandSymbol = checker.getShorthandAssignmentValueSymbol(refSymbol.valueDeclaration); + if (shorthandSymbol) { + for (var _i = 0, _a = shorthandSymbol.getDeclarations(); _i < _a.length; _i++) { + var declaration = _a[_i]; + if (ts.getMeaningFromDeclaration(declaration) & 1 /* SemanticMeaning.Value */) { + addReference(declaration); + } + } + } + } + Core.getReferenceEntriesForShorthandPropertyAssignment = getReferenceEntriesForShorthandPropertyAssignment; + function forEachDescendantOfKind(node, kind, action) { + ts.forEachChild(node, function (child) { + if (child.kind === kind) { + action(child); + } + forEachDescendantOfKind(child, kind, action); + }); + } + /** Get `C` given `N` if `N` is in the position `class C extends N` or `class C extends foo.N` where `N` is an identifier. */ + function tryGetClassByExtendingIdentifier(node) { + return ts.tryGetClassExtendingExpressionWithTypeArguments(ts.climbPastPropertyAccess(node).parent); + } + /** + * If we are just looking for implementations and this is a property access expression, we need to get the + * symbol of the local type of the symbol the property is being accessed on. This is because our search + * symbol may have a different parent symbol if the local type's symbol does not declare the property + * being accessed (i.e. it is declared in some parent class or interface) + */ + function getParentSymbolsOfPropertyAccess(location, symbol, checker) { + var propertyAccessExpression = ts.isRightSideOfPropertyAccess(location) ? location.parent : undefined; + var lhsType = propertyAccessExpression && checker.getTypeAtLocation(propertyAccessExpression.expression); + var res = ts.mapDefined(lhsType && (lhsType.isUnionOrIntersection() ? lhsType.types : lhsType.symbol === symbol.parent ? undefined : [lhsType]), function (t) { + return t.symbol && t.symbol.flags & (32 /* SymbolFlags.Class */ | 64 /* SymbolFlags.Interface */) ? t.symbol : undefined; + }); + return res.length === 0 ? undefined : res; + } + function isForRenameWithPrefixAndSuffixText(options) { + return options.use === 2 /* FindReferencesUse.Rename */ && options.providePrefixAndSuffixTextForRename; + } + })(Core = FindAllReferences.Core || (FindAllReferences.Core = {})); + })(FindAllReferences = ts.FindAllReferences || (ts.FindAllReferences = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var CallHierarchy; + (function (CallHierarchy) { + /** Indictates whether a node is named function or class expression. */ + function isNamedExpression(node) { + return (ts.isFunctionExpression(node) || ts.isClassExpression(node)) && ts.isNamedDeclaration(node); + } + /** Indicates whether a node is a function, arrow, or class expression assigned to a constant variable. */ + function isConstNamedExpression(node) { + return (ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isClassExpression(node)) + && ts.isVariableDeclaration(node.parent) + && node === node.parent.initializer + && ts.isIdentifier(node.parent.name) + && !!(ts.getCombinedNodeFlags(node.parent) & 2 /* NodeFlags.Const */); + } + /** + * Indicates whether a node could possibly be a call hierarchy declaration. + * + * See `resolveCallHierarchyDeclaration` for the specific rules. + */ + function isPossibleCallHierarchyDeclaration(node) { + return ts.isSourceFile(node) + || ts.isModuleDeclaration(node) + || ts.isFunctionDeclaration(node) + || ts.isFunctionExpression(node) + || ts.isClassDeclaration(node) + || ts.isClassExpression(node) + || ts.isClassStaticBlockDeclaration(node) + || ts.isMethodDeclaration(node) + || ts.isMethodSignature(node) + || ts.isGetAccessorDeclaration(node) + || ts.isSetAccessorDeclaration(node); + } + /** + * Indicates whether a node is a valid a call hierarchy declaration. + * + * See `resolveCallHierarchyDeclaration` for the specific rules. + */ + function isValidCallHierarchyDeclaration(node) { + return ts.isSourceFile(node) + || ts.isModuleDeclaration(node) && ts.isIdentifier(node.name) + || ts.isFunctionDeclaration(node) + || ts.isClassDeclaration(node) + || ts.isClassStaticBlockDeclaration(node) + || ts.isMethodDeclaration(node) + || ts.isMethodSignature(node) + || ts.isGetAccessorDeclaration(node) + || ts.isSetAccessorDeclaration(node) + || isNamedExpression(node) + || isConstNamedExpression(node); + } + /** Gets the node that can be used as a reference to a call hierarchy declaration. */ + function getCallHierarchyDeclarationReferenceNode(node) { + if (ts.isSourceFile(node)) + return node; + if (ts.isNamedDeclaration(node)) + return node.name; + if (isConstNamedExpression(node)) + return node.parent.name; + return ts.Debug.checkDefined(node.modifiers && ts.find(node.modifiers, isDefaultModifier)); + } + function isDefaultModifier(node) { + return node.kind === 88 /* SyntaxKind.DefaultKeyword */; + } + /** Gets the symbol for a call hierarchy declaration. */ + function getSymbolOfCallHierarchyDeclaration(typeChecker, node) { + var location = getCallHierarchyDeclarationReferenceNode(node); + return location && typeChecker.getSymbolAtLocation(location); + } + /** Gets the text and range for the name of a call hierarchy declaration. */ + function getCallHierarchyItemName(program, node) { + if (ts.isSourceFile(node)) { + return { text: node.fileName, pos: 0, end: 0 }; + } + if ((ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)) && !ts.isNamedDeclaration(node)) { + var defaultModifier = node.modifiers && ts.find(node.modifiers, isDefaultModifier); + if (defaultModifier) { + return { text: "default", pos: defaultModifier.getStart(), end: defaultModifier.getEnd() }; + } + } + if (ts.isClassStaticBlockDeclaration(node)) { + var sourceFile = node.getSourceFile(); + var pos = ts.skipTrivia(sourceFile.text, ts.moveRangePastModifiers(node).pos); + var end = pos + 6; /* "static".length */ + var typeChecker = program.getTypeChecker(); + var symbol = typeChecker.getSymbolAtLocation(node.parent); + var prefix = symbol ? "".concat(typeChecker.symbolToString(symbol, node.parent), " ") : ""; + return { text: "".concat(prefix, "static {}"), pos: pos, end: end }; + } + var declName = isConstNamedExpression(node) ? node.parent.name : + ts.Debug.checkDefined(ts.getNameOfDeclaration(node), "Expected call hierarchy item to have a name"); + var text = ts.isIdentifier(declName) ? ts.idText(declName) : + ts.isStringOrNumericLiteralLike(declName) ? declName.text : + ts.isComputedPropertyName(declName) ? + ts.isStringOrNumericLiteralLike(declName.expression) ? declName.expression.text : + undefined : + undefined; + if (text === undefined) { + var typeChecker = program.getTypeChecker(); + var symbol = typeChecker.getSymbolAtLocation(declName); + if (symbol) { + text = typeChecker.symbolToString(symbol, node); + } + } + if (text === undefined) { + // get the text from printing the node on a single line without comments... + var printer_1 = ts.createPrinter({ removeComments: true, omitTrailingSemicolon: true }); + text = ts.usingSingleLineStringWriter(function (writer) { return printer_1.writeNode(4 /* EmitHint.Unspecified */, node, node.getSourceFile(), writer); }); + } + return { text: text, pos: declName.getStart(), end: declName.getEnd() }; + } + function getCallHierarchItemContainerName(node) { + var _a, _b; + if (isConstNamedExpression(node)) { + if (ts.isModuleBlock(node.parent.parent.parent.parent) && ts.isIdentifier(node.parent.parent.parent.parent.parent.name)) { + return node.parent.parent.parent.parent.parent.name.getText(); + } + return; + } + switch (node.kind) { + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 171 /* SyntaxKind.MethodDeclaration */: + if (node.parent.kind === 207 /* SyntaxKind.ObjectLiteralExpression */) { + return (_a = ts.getAssignedName(node.parent)) === null || _a === void 0 ? void 0 : _a.getText(); + } + return (_b = ts.getNameOfDeclaration(node.parent)) === null || _b === void 0 ? void 0 : _b.getText(); + case 259 /* SyntaxKind.FunctionDeclaration */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 264 /* SyntaxKind.ModuleDeclaration */: + if (ts.isModuleBlock(node.parent) && ts.isIdentifier(node.parent.parent.name)) { + return node.parent.parent.name.getText(); + } + } + } + function findImplementation(typeChecker, node) { + if (node.body) { + return node; + } + if (ts.isConstructorDeclaration(node)) { + return ts.getFirstConstructorWithBody(node.parent); + } + if (ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node)) { + var symbol = getSymbolOfCallHierarchyDeclaration(typeChecker, node); + if (symbol && symbol.valueDeclaration && ts.isFunctionLikeDeclaration(symbol.valueDeclaration) && symbol.valueDeclaration.body) { + return symbol.valueDeclaration; + } + return undefined; + } + return node; + } + function findAllInitialDeclarations(typeChecker, node) { + var symbol = getSymbolOfCallHierarchyDeclaration(typeChecker, node); + var declarations; + if (symbol && symbol.declarations) { + var indices = ts.indicesOf(symbol.declarations); + var keys_2 = ts.map(symbol.declarations, function (decl) { return ({ file: decl.getSourceFile().fileName, pos: decl.pos }); }); + indices.sort(function (a, b) { return ts.compareStringsCaseSensitive(keys_2[a].file, keys_2[b].file) || keys_2[a].pos - keys_2[b].pos; }); + var sortedDeclarations = ts.map(indices, function (i) { return symbol.declarations[i]; }); + var lastDecl = void 0; + for (var _i = 0, sortedDeclarations_1 = sortedDeclarations; _i < sortedDeclarations_1.length; _i++) { + var decl = sortedDeclarations_1[_i]; + if (isValidCallHierarchyDeclaration(decl)) { + if (!lastDecl || lastDecl.parent !== decl.parent || lastDecl.end !== decl.pos) { + declarations = ts.append(declarations, decl); + } + lastDecl = decl; + } + } + } + return declarations; + } + /** Find the implementation or the first declaration for a call hierarchy declaration. */ + function findImplementationOrAllInitialDeclarations(typeChecker, node) { + var _a, _b, _c; + if (ts.isClassStaticBlockDeclaration(node)) { + return node; + } + if (ts.isFunctionLikeDeclaration(node)) { + return (_b = (_a = findImplementation(typeChecker, node)) !== null && _a !== void 0 ? _a : findAllInitialDeclarations(typeChecker, node)) !== null && _b !== void 0 ? _b : node; + } + return (_c = findAllInitialDeclarations(typeChecker, node)) !== null && _c !== void 0 ? _c : node; + } + /** Resolves the call hierarchy declaration for a node. */ + function resolveCallHierarchyDeclaration(program, location) { + // A call hierarchy item must refer to either a SourceFile, Module Declaration, Class Static Block, or something intrinsically callable that has a name: + // - Class Declarations + // - Class Expressions (with a name) + // - Function Declarations + // - Function Expressions (with a name or assigned to a const variable) + // - Arrow Functions (assigned to a const variable) + // - Constructors + // - Class `static {}` initializer blocks + // - Methods + // - Accessors + // + // If a call is contained in a non-named callable Node (function expression, arrow function, etc.), then + // its containing `CallHierarchyItem` is a containing function or SourceFile that matches the above list. + var typeChecker = program.getTypeChecker(); + var followingSymbol = false; + while (true) { + if (isValidCallHierarchyDeclaration(location)) { + return findImplementationOrAllInitialDeclarations(typeChecker, location); + } + if (isPossibleCallHierarchyDeclaration(location)) { + var ancestor = ts.findAncestor(location, isValidCallHierarchyDeclaration); + return ancestor && findImplementationOrAllInitialDeclarations(typeChecker, ancestor); + } + if (ts.isDeclarationName(location)) { + if (isValidCallHierarchyDeclaration(location.parent)) { + return findImplementationOrAllInitialDeclarations(typeChecker, location.parent); + } + if (isPossibleCallHierarchyDeclaration(location.parent)) { + var ancestor = ts.findAncestor(location.parent, isValidCallHierarchyDeclaration); + return ancestor && findImplementationOrAllInitialDeclarations(typeChecker, ancestor); + } + if (ts.isVariableDeclaration(location.parent) && location.parent.initializer && isConstNamedExpression(location.parent.initializer)) { + return location.parent.initializer; + } + return undefined; + } + if (ts.isConstructorDeclaration(location)) { + if (isValidCallHierarchyDeclaration(location.parent)) { + return location.parent; + } + return undefined; + } + if (location.kind === 124 /* SyntaxKind.StaticKeyword */ && ts.isClassStaticBlockDeclaration(location.parent)) { + location = location.parent; + continue; + } + // #39453 + if (ts.isVariableDeclaration(location) && location.initializer && isConstNamedExpression(location.initializer)) { + return location.initializer; + } + if (!followingSymbol) { + var symbol = typeChecker.getSymbolAtLocation(location); + if (symbol) { + if (symbol.flags & 2097152 /* SymbolFlags.Alias */) { + symbol = typeChecker.getAliasedSymbol(symbol); + } + if (symbol.valueDeclaration) { + followingSymbol = true; + location = symbol.valueDeclaration; + continue; + } + } + } + return undefined; + } + } + CallHierarchy.resolveCallHierarchyDeclaration = resolveCallHierarchyDeclaration; + /** Creates a `CallHierarchyItem` for a call hierarchy declaration. */ + function createCallHierarchyItem(program, node) { + var sourceFile = node.getSourceFile(); + var name = getCallHierarchyItemName(program, node); + var containerName = getCallHierarchItemContainerName(node); + var kind = ts.getNodeKind(node); + var kindModifiers = ts.getNodeModifiers(node); + var span = ts.createTextSpanFromBounds(ts.skipTrivia(sourceFile.text, node.getFullStart(), /*stopAfterLineBreak*/ false, /*stopAtComments*/ true), node.getEnd()); + var selectionSpan = ts.createTextSpanFromBounds(name.pos, name.end); + return { file: sourceFile.fileName, kind: kind, kindModifiers: kindModifiers, name: name.text, containerName: containerName, span: span, selectionSpan: selectionSpan }; + } + CallHierarchy.createCallHierarchyItem = createCallHierarchyItem; + function isDefined(x) { + return x !== undefined; + } + function convertEntryToCallSite(entry) { + if (entry.kind === 1 /* FindAllReferences.EntryKind.Node */) { + var node = entry.node; + if (ts.isCallOrNewExpressionTarget(node, /*includeElementAccess*/ true, /*skipPastOuterExpressions*/ true) + || ts.isTaggedTemplateTag(node, /*includeElementAccess*/ true, /*skipPastOuterExpressions*/ true) + || ts.isDecoratorTarget(node, /*includeElementAccess*/ true, /*skipPastOuterExpressions*/ true) + || ts.isJsxOpeningLikeElementTagName(node, /*includeElementAccess*/ true, /*skipPastOuterExpressions*/ true) + || ts.isRightSideOfPropertyAccess(node) + || ts.isArgumentExpressionOfElementAccess(node)) { + var sourceFile = node.getSourceFile(); + var ancestor = ts.findAncestor(node, isValidCallHierarchyDeclaration) || sourceFile; + return { declaration: ancestor, range: ts.createTextRangeFromNode(node, sourceFile) }; + } + } + } + function getCallSiteGroupKey(entry) { + return ts.getNodeId(entry.declaration); + } + function createCallHierarchyIncomingCall(from, fromSpans) { + return { from: from, fromSpans: fromSpans }; + } + function convertCallSiteGroupToIncomingCall(program, entries) { + return createCallHierarchyIncomingCall(createCallHierarchyItem(program, entries[0].declaration), ts.map(entries, function (entry) { return ts.createTextSpanFromRange(entry.range); })); + } + /** Gets the call sites that call into the provided call hierarchy declaration. */ + function getIncomingCalls(program, declaration, cancellationToken) { + // Source files and modules have no incoming calls. + if (ts.isSourceFile(declaration) || ts.isModuleDeclaration(declaration) || ts.isClassStaticBlockDeclaration(declaration)) { + return []; + } + var location = getCallHierarchyDeclarationReferenceNode(declaration); + var calls = ts.filter(ts.FindAllReferences.findReferenceOrRenameEntries(program, cancellationToken, program.getSourceFiles(), location, /*position*/ 0, { use: 1 /* FindAllReferences.FindReferencesUse.References */ }, convertEntryToCallSite), isDefined); + return calls ? ts.group(calls, getCallSiteGroupKey, function (entries) { return convertCallSiteGroupToIncomingCall(program, entries); }) : []; + } + CallHierarchy.getIncomingCalls = getIncomingCalls; + function createCallSiteCollector(program, callSites) { + function recordCallSite(node) { + var target = ts.isTaggedTemplateExpression(node) ? node.tag : + ts.isJsxOpeningLikeElement(node) ? node.tagName : + ts.isAccessExpression(node) ? node : + ts.isClassStaticBlockDeclaration(node) ? node : + node.expression; + var declaration = resolveCallHierarchyDeclaration(program, target); + if (declaration) { + var range = ts.createTextRangeFromNode(target, node.getSourceFile()); + if (ts.isArray(declaration)) { + for (var _i = 0, declaration_1 = declaration; _i < declaration_1.length; _i++) { + var decl = declaration_1[_i]; + callSites.push({ declaration: decl, range: range }); + } + } + else { + callSites.push({ declaration: declaration, range: range }); + } + } + } + function collect(node) { + if (!node) + return; + if (node.flags & 16777216 /* NodeFlags.Ambient */) { + // do not descend into ambient nodes. + return; + } + if (isValidCallHierarchyDeclaration(node)) { + // do not descend into other call site declarations, other than class member names + if (ts.isClassLike(node)) { + for (var _i = 0, _a = node.members; _i < _a.length; _i++) { + var member = _a[_i]; + if (member.name && ts.isComputedPropertyName(member.name)) { + collect(member.name.expression); + } + } + } + return; + } + switch (node.kind) { + case 79 /* SyntaxKind.Identifier */: + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + case 269 /* SyntaxKind.ImportDeclaration */: + case 275 /* SyntaxKind.ExportDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + // do not descend into nodes that cannot contain callable nodes + return; + case 172 /* SyntaxKind.ClassStaticBlockDeclaration */: + recordCallSite(node); + return; + case 213 /* SyntaxKind.TypeAssertionExpression */: + case 231 /* SyntaxKind.AsExpression */: + // do not descend into the type side of an assertion + collect(node.expression); + return; + case 257 /* SyntaxKind.VariableDeclaration */: + case 166 /* SyntaxKind.Parameter */: + // do not descend into the type of a variable or parameter declaration + collect(node.name); + collect(node.initializer); + return; + case 210 /* SyntaxKind.CallExpression */: + // do not descend into the type arguments of a call expression + recordCallSite(node); + collect(node.expression); + ts.forEach(node.arguments, collect); + return; + case 211 /* SyntaxKind.NewExpression */: + // do not descend into the type arguments of a new expression + recordCallSite(node); + collect(node.expression); + ts.forEach(node.arguments, collect); + return; + case 212 /* SyntaxKind.TaggedTemplateExpression */: + // do not descend into the type arguments of a tagged template expression + recordCallSite(node); + collect(node.tag); + collect(node.template); + return; + case 283 /* SyntaxKind.JsxOpeningElement */: + case 282 /* SyntaxKind.JsxSelfClosingElement */: + // do not descend into the type arguments of a JsxOpeningLikeElement + recordCallSite(node); + collect(node.tagName); + collect(node.attributes); + return; + case 167 /* SyntaxKind.Decorator */: + recordCallSite(node); + collect(node.expression); + return; + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 209 /* SyntaxKind.ElementAccessExpression */: + recordCallSite(node); + ts.forEachChild(node, collect); + break; + case 235 /* SyntaxKind.SatisfiesExpression */: + // do not descend into the type side of an assertion + collect(node.expression); + return; + } + if (ts.isPartOfTypeNode(node)) { + // do not descend into types + return; + } + ts.forEachChild(node, collect); + } + return collect; + } + function collectCallSitesOfSourceFile(node, collect) { + ts.forEach(node.statements, collect); + } + function collectCallSitesOfModuleDeclaration(node, collect) { + if (!ts.hasSyntacticModifier(node, 2 /* ModifierFlags.Ambient */) && node.body && ts.isModuleBlock(node.body)) { + ts.forEach(node.body.statements, collect); + } + } + function collectCallSitesOfFunctionLikeDeclaration(typeChecker, node, collect) { + var implementation = findImplementation(typeChecker, node); + if (implementation) { + ts.forEach(implementation.parameters, collect); + collect(implementation.body); + } + } + function collectCallSitesOfClassStaticBlockDeclaration(node, collect) { + collect(node.body); + } + function collectCallSitesOfClassLikeDeclaration(node, collect) { + ts.forEach(node.modifiers, collect); + var heritage = ts.getClassExtendsHeritageElement(node); + if (heritage) { + collect(heritage.expression); + } + for (var _i = 0, _a = node.members; _i < _a.length; _i++) { + var member = _a[_i]; + if (ts.canHaveModifiers(member)) { + ts.forEach(member.modifiers, collect); + } + if (ts.isPropertyDeclaration(member)) { + collect(member.initializer); + } + else if (ts.isConstructorDeclaration(member) && member.body) { + ts.forEach(member.parameters, collect); + collect(member.body); + } + else if (ts.isClassStaticBlockDeclaration(member)) { + collect(member); + } + } + } + function collectCallSites(program, node) { + var callSites = []; + var collect = createCallSiteCollector(program, callSites); + switch (node.kind) { + case 308 /* SyntaxKind.SourceFile */: + collectCallSitesOfSourceFile(node, collect); + break; + case 264 /* SyntaxKind.ModuleDeclaration */: + collectCallSitesOfModuleDeclaration(node, collect); + break; + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + collectCallSitesOfFunctionLikeDeclaration(program.getTypeChecker(), node, collect); + break; + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + collectCallSitesOfClassLikeDeclaration(node, collect); + break; + case 172 /* SyntaxKind.ClassStaticBlockDeclaration */: + collectCallSitesOfClassStaticBlockDeclaration(node, collect); + break; + default: + ts.Debug.assertNever(node); + } + return callSites; + } + function createCallHierarchyOutgoingCall(to, fromSpans) { + return { to: to, fromSpans: fromSpans }; + } + function convertCallSiteGroupToOutgoingCall(program, entries) { + return createCallHierarchyOutgoingCall(createCallHierarchyItem(program, entries[0].declaration), ts.map(entries, function (entry) { return ts.createTextSpanFromRange(entry.range); })); + } + /** Gets the call sites that call out of the provided call hierarchy declaration. */ + function getOutgoingCalls(program, declaration) { + if (declaration.flags & 16777216 /* NodeFlags.Ambient */ || ts.isMethodSignature(declaration)) { + return []; + } + return ts.group(collectCallSites(program, declaration), getCallSiteGroupKey, function (entries) { return convertCallSiteGroupToOutgoingCall(program, entries); }); + } + CallHierarchy.getOutgoingCalls = getOutgoingCalls; + })(CallHierarchy = ts.CallHierarchy || (ts.CallHierarchy = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + function getEditsForFileRename(program, oldFileOrDirPath, newFileOrDirPath, host, formatContext, preferences, sourceMapper) { + var useCaseSensitiveFileNames = ts.hostUsesCaseSensitiveFileNames(host); + var getCanonicalFileName = ts.createGetCanonicalFileName(useCaseSensitiveFileNames); + var oldToNew = getPathUpdater(oldFileOrDirPath, newFileOrDirPath, getCanonicalFileName, sourceMapper); + var newToOld = getPathUpdater(newFileOrDirPath, oldFileOrDirPath, getCanonicalFileName, sourceMapper); + return ts.textChanges.ChangeTracker.with({ host: host, formatContext: formatContext, preferences: preferences }, function (changeTracker) { + updateTsconfigFiles(program, changeTracker, oldToNew, oldFileOrDirPath, newFileOrDirPath, host.getCurrentDirectory(), useCaseSensitiveFileNames); + updateImports(program, changeTracker, oldToNew, newToOld, host, getCanonicalFileName); + }); + } + ts.getEditsForFileRename = getEditsForFileRename; + // exported for tests + function getPathUpdater(oldFileOrDirPath, newFileOrDirPath, getCanonicalFileName, sourceMapper) { + var canonicalOldPath = getCanonicalFileName(oldFileOrDirPath); + return function (path) { + var originalPath = sourceMapper && sourceMapper.tryGetSourcePosition({ fileName: path, pos: 0 }); + var updatedPath = getUpdatedPath(originalPath ? originalPath.fileName : path); + return originalPath + ? updatedPath === undefined ? undefined : makeCorrespondingRelativeChange(originalPath.fileName, updatedPath, path, getCanonicalFileName) + : updatedPath; + }; + function getUpdatedPath(pathToUpdate) { + if (getCanonicalFileName(pathToUpdate) === canonicalOldPath) + return newFileOrDirPath; + var suffix = ts.tryRemoveDirectoryPrefix(pathToUpdate, canonicalOldPath, getCanonicalFileName); + return suffix === undefined ? undefined : newFileOrDirPath + "/" + suffix; + } + } + ts.getPathUpdater = getPathUpdater; + // Relative path from a0 to b0 should be same as relative path from a1 to b1. Returns b1. + function makeCorrespondingRelativeChange(a0, b0, a1, getCanonicalFileName) { + var rel = ts.getRelativePathFromFile(a0, b0, getCanonicalFileName); + return combinePathsSafe(ts.getDirectoryPath(a1), rel); + } + function updateTsconfigFiles(program, changeTracker, oldToNew, oldFileOrDirPath, newFileOrDirPath, currentDirectory, useCaseSensitiveFileNames) { + var configFile = program.getCompilerOptions().configFile; + if (!configFile) + return; + var configDir = ts.getDirectoryPath(configFile.fileName); + var jsonObjectLiteral = ts.getTsConfigObjectLiteralExpression(configFile); + if (!jsonObjectLiteral) + return; + forEachProperty(jsonObjectLiteral, function (property, propertyName) { + switch (propertyName) { + case "files": + case "include": + case "exclude": { + var foundExactMatch = updatePaths(property); + if (foundExactMatch || propertyName !== "include" || !ts.isArrayLiteralExpression(property.initializer)) + return; + var includes = ts.mapDefined(property.initializer.elements, function (e) { return ts.isStringLiteral(e) ? e.text : undefined; }); + if (includes.length === 0) + return; + var matchers = ts.getFileMatcherPatterns(configDir, /*excludes*/ [], includes, useCaseSensitiveFileNames, currentDirectory); + // If there isn't some include for this, add a new one. + if (ts.getRegexFromPattern(ts.Debug.checkDefined(matchers.includeFilePattern), useCaseSensitiveFileNames).test(oldFileOrDirPath) && + !ts.getRegexFromPattern(ts.Debug.checkDefined(matchers.includeFilePattern), useCaseSensitiveFileNames).test(newFileOrDirPath)) { + changeTracker.insertNodeAfter(configFile, ts.last(property.initializer.elements), ts.factory.createStringLiteral(relativePath(newFileOrDirPath))); + } + return; + } + case "compilerOptions": + forEachProperty(property.initializer, function (property, propertyName) { + var option = ts.getOptionFromName(propertyName); + if (option && (option.isFilePath || option.type === "list" && option.element.isFilePath)) { + updatePaths(property); + } + else if (propertyName === "paths") { + forEachProperty(property.initializer, function (pathsProperty) { + if (!ts.isArrayLiteralExpression(pathsProperty.initializer)) + return; + for (var _i = 0, _a = pathsProperty.initializer.elements; _i < _a.length; _i++) { + var e = _a[_i]; + tryUpdateString(e); + } + }); + } + }); + return; + } + }); + function updatePaths(property) { + var elements = ts.isArrayLiteralExpression(property.initializer) ? property.initializer.elements : [property.initializer]; + var foundExactMatch = false; + for (var _i = 0, elements_1 = elements; _i < elements_1.length; _i++) { + var element = elements_1[_i]; + foundExactMatch = tryUpdateString(element) || foundExactMatch; + } + return foundExactMatch; + } + function tryUpdateString(element) { + if (!ts.isStringLiteral(element)) + return false; + var elementFileName = combinePathsSafe(configDir, element.text); + var updated = oldToNew(elementFileName); + if (updated !== undefined) { + changeTracker.replaceRangeWithText(configFile, createStringRange(element, configFile), relativePath(updated)); + return true; + } + return false; + } + function relativePath(path) { + return ts.getRelativePathFromDirectory(configDir, path, /*ignoreCase*/ !useCaseSensitiveFileNames); + } + } + function updateImports(program, changeTracker, oldToNew, newToOld, host, getCanonicalFileName) { + var allFiles = program.getSourceFiles(); + var _loop_4 = function (sourceFile) { + var newFromOld = oldToNew(sourceFile.fileName); + var newImportFromPath = newFromOld !== null && newFromOld !== void 0 ? newFromOld : sourceFile.fileName; + var newImportFromDirectory = ts.getDirectoryPath(newImportFromPath); + var oldFromNew = newToOld(sourceFile.fileName); + var oldImportFromPath = oldFromNew || sourceFile.fileName; + var oldImportFromDirectory = ts.getDirectoryPath(oldImportFromPath); + var importingSourceFileMoved = newFromOld !== undefined || oldFromNew !== undefined; + updateImportsWorker(sourceFile, changeTracker, function (referenceText) { + if (!ts.pathIsRelative(referenceText)) + return undefined; + var oldAbsolute = combinePathsSafe(oldImportFromDirectory, referenceText); + var newAbsolute = oldToNew(oldAbsolute); + return newAbsolute === undefined ? undefined : ts.ensurePathIsNonModuleName(ts.getRelativePathFromDirectory(newImportFromDirectory, newAbsolute, getCanonicalFileName)); + }, function (importLiteral) { + var importedModuleSymbol = program.getTypeChecker().getSymbolAtLocation(importLiteral); + // No need to update if it's an ambient module^M + if ((importedModuleSymbol === null || importedModuleSymbol === void 0 ? void 0 : importedModuleSymbol.declarations) && importedModuleSymbol.declarations.some(function (d) { return ts.isAmbientModule(d); })) + return undefined; + var toImport = oldFromNew !== undefined + // If we're at the new location (file was already renamed), need to redo module resolution starting from the old location. + // TODO:GH#18217 + ? getSourceFileToImportFromResolved(importLiteral, ts.resolveModuleName(importLiteral.text, oldImportFromPath, program.getCompilerOptions(), host), oldToNew, allFiles) + : getSourceFileToImport(importedModuleSymbol, importLiteral, sourceFile, program, host, oldToNew); + // Need an update if the imported file moved, or the importing file moved and was using a relative path. + return toImport !== undefined && (toImport.updated || (importingSourceFileMoved && ts.pathIsRelative(importLiteral.text))) + ? ts.moduleSpecifiers.updateModuleSpecifier(program.getCompilerOptions(), sourceFile, getCanonicalFileName(newImportFromPath), toImport.newFileName, ts.createModuleSpecifierResolutionHost(program, host), importLiteral.text) + : undefined; + }); + }; + for (var _i = 0, allFiles_1 = allFiles; _i < allFiles_1.length; _i++) { + var sourceFile = allFiles_1[_i]; + _loop_4(sourceFile); + } + } + function combineNormal(pathA, pathB) { + return ts.normalizePath(ts.combinePaths(pathA, pathB)); + } + function combinePathsSafe(pathA, pathB) { + return ts.ensurePathIsNonModuleName(combineNormal(pathA, pathB)); + } + function getSourceFileToImport(importedModuleSymbol, importLiteral, importingSourceFile, program, host, oldToNew) { + if (importedModuleSymbol) { + // `find` should succeed because we checked for ambient modules before calling this function. + var oldFileName = ts.find(importedModuleSymbol.declarations, ts.isSourceFile).fileName; + var newFileName = oldToNew(oldFileName); + return newFileName === undefined ? { newFileName: oldFileName, updated: false } : { newFileName: newFileName, updated: true }; + } + else { + var mode = ts.getModeForUsageLocation(importingSourceFile, importLiteral); + var resolved = host.resolveModuleNames + ? host.getResolvedModuleWithFailedLookupLocationsFromCache && host.getResolvedModuleWithFailedLookupLocationsFromCache(importLiteral.text, importingSourceFile.fileName, mode) + : program.getResolvedModuleWithFailedLookupLocationsFromCache(importLiteral.text, importingSourceFile.fileName, mode); + return getSourceFileToImportFromResolved(importLiteral, resolved, oldToNew, program.getSourceFiles()); + } + } + function getSourceFileToImportFromResolved(importLiteral, resolved, oldToNew, sourceFiles) { + // Search through all locations looking for a moved file, and only then test already existing files. + // This is because if `a.ts` is compiled to `a.js` and `a.ts` is moved, we don't want to resolve anything to `a.js`, but to `a.ts`'s new location. + if (!resolved) + return undefined; + // First try resolved module + if (resolved.resolvedModule) { + var result_3 = tryChange(resolved.resolvedModule.resolvedFileName); + if (result_3) + return result_3; + } + // Then failed lookups that are in the list of sources + var result = ts.forEach(resolved.failedLookupLocations, tryChangeWithIgnoringPackageJsonExisting) + // Then failed lookups except package.json since we dont want to touch them (only included ts/js files). + // At this point, the confidence level of this fix being correct is too low to change bare specifiers or absolute paths. + || ts.pathIsRelative(importLiteral.text) && ts.forEach(resolved.failedLookupLocations, tryChangeWithIgnoringPackageJson); + if (result) + return result; + // If nothing changed, then result is resolved module file thats not updated + return resolved.resolvedModule && { newFileName: resolved.resolvedModule.resolvedFileName, updated: false }; + function tryChangeWithIgnoringPackageJsonExisting(oldFileName) { + var newFileName = oldToNew(oldFileName); + return newFileName && ts.find(sourceFiles, function (src) { return src.fileName === newFileName; }) + ? tryChangeWithIgnoringPackageJson(oldFileName) : undefined; + } + function tryChangeWithIgnoringPackageJson(oldFileName) { + return !ts.endsWith(oldFileName, "/package.json") ? tryChange(oldFileName) : undefined; + } + function tryChange(oldFileName) { + var newFileName = oldToNew(oldFileName); + return newFileName && { newFileName: newFileName, updated: true }; + } + } + function updateImportsWorker(sourceFile, changeTracker, updateRef, updateImport) { + for (var _i = 0, _a = sourceFile.referencedFiles || ts.emptyArray; _i < _a.length; _i++) { // TODO: GH#26162 + var ref = _a[_i]; + var updated = updateRef(ref.fileName); + if (updated !== undefined && updated !== sourceFile.text.slice(ref.pos, ref.end)) + changeTracker.replaceRangeWithText(sourceFile, ref, updated); + } + for (var _b = 0, _c = sourceFile.imports; _b < _c.length; _b++) { + var importStringLiteral = _c[_b]; + var updated = updateImport(importStringLiteral); + if (updated !== undefined && updated !== importStringLiteral.text) + changeTracker.replaceRangeWithText(sourceFile, createStringRange(importStringLiteral, sourceFile), updated); + } + } + function createStringRange(node, sourceFile) { + return ts.createRange(node.getStart(sourceFile) + 1, node.end - 1); + } + function forEachProperty(objectLiteral, cb) { + if (!ts.isObjectLiteralExpression(objectLiteral)) + return; + for (var _i = 0, _a = objectLiteral.properties; _i < _a.length; _i++) { + var property = _a[_i]; + if (ts.isPropertyAssignment(property) && ts.isStringLiteral(property.name)) { + cb(property, property.name.text); + } + } + } +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var GoToDefinition; + (function (GoToDefinition) { + function getDefinitionAtPosition(program, sourceFile, position, searchOtherFilesOnly, stopAtAlias) { + var _a; + var _b; + var resolvedRef = getReferenceAtPosition(sourceFile, position, program); + var fileReferenceDefinition = resolvedRef && [getDefinitionInfoForFileReference(resolvedRef.reference.fileName, resolvedRef.fileName, resolvedRef.unverified)] || ts.emptyArray; + if (resolvedRef === null || resolvedRef === void 0 ? void 0 : resolvedRef.file) { + // If `file` is missing, do a symbol-based lookup as well + return fileReferenceDefinition; + } + var node = ts.getTouchingPropertyName(sourceFile, position); + if (node === sourceFile) { + return undefined; + } + var parent = node.parent; + var typeChecker = program.getTypeChecker(); + if (node.kind === 161 /* SyntaxKind.OverrideKeyword */ || (ts.isIdentifier(node) && ts.isJSDocOverrideTag(parent) && parent.tagName === node)) { + return getDefinitionFromOverriddenMember(typeChecker, node) || ts.emptyArray; + } + // Labels + if (ts.isJumpStatementTarget(node)) { + var label = ts.getTargetLabel(node.parent, node.text); + return label ? [createDefinitionInfoFromName(typeChecker, label, "label" /* ScriptElementKind.label */, node.text, /*containerName*/ undefined)] : undefined; // TODO: GH#18217 + } + if (node.kind === 105 /* SyntaxKind.ReturnKeyword */) { + var functionDeclaration = ts.findAncestor(node.parent, function (n) { + return ts.isClassStaticBlockDeclaration(n) ? "quit" : ts.isFunctionLikeDeclaration(n); + }); + return functionDeclaration ? [createDefinitionFromSignatureDeclaration(typeChecker, functionDeclaration)] : undefined; + } + if (ts.isStaticModifier(node) && ts.isClassStaticBlockDeclaration(node.parent)) { + var classDecl = node.parent.parent; + var _c = getSymbol(classDecl, typeChecker, stopAtAlias), symbol_1 = _c.symbol, failedAliasResolution_1 = _c.failedAliasResolution; + var staticBlocks = ts.filter(classDecl.members, ts.isClassStaticBlockDeclaration); + var containerName_1 = symbol_1 ? typeChecker.symbolToString(symbol_1, classDecl) : ""; + var sourceFile_1 = node.getSourceFile(); + return ts.map(staticBlocks, function (staticBlock) { + var pos = ts.moveRangePastModifiers(staticBlock).pos; + pos = ts.skipTrivia(sourceFile_1.text, pos); + return createDefinitionInfoFromName(typeChecker, staticBlock, "constructor" /* ScriptElementKind.constructorImplementationElement */, "static {}", containerName_1, /*unverified*/ false, failedAliasResolution_1, { start: pos, length: "static".length }); + }); + } + var _d = getSymbol(node, typeChecker, stopAtAlias), symbol = _d.symbol, failedAliasResolution = _d.failedAliasResolution; + var fallbackNode = node; + if (searchOtherFilesOnly && failedAliasResolution) { + // We couldn't resolve the specific import, try on the module specifier. + var importDeclaration = ts.forEach(__spreadArray([node], (symbol === null || symbol === void 0 ? void 0 : symbol.declarations) || ts.emptyArray, true), function (n) { return ts.findAncestor(n, ts.isAnyImportOrBareOrAccessedRequire); }); + var moduleSpecifier = importDeclaration && ts.tryGetModuleSpecifierFromDeclaration(importDeclaration); + if (moduleSpecifier) { + (_a = getSymbol(moduleSpecifier, typeChecker, stopAtAlias), symbol = _a.symbol, failedAliasResolution = _a.failedAliasResolution); + fallbackNode = moduleSpecifier; + } + } + if (!symbol && ts.isModuleSpecifierLike(fallbackNode)) { + // We couldn't resolve the module specifier as an external module, but it could + // be that module resolution succeeded but the target was not a module. + var ref = (_b = sourceFile.resolvedModules) === null || _b === void 0 ? void 0 : _b.get(fallbackNode.text, ts.getModeForUsageLocation(sourceFile, fallbackNode)); + if (ref) { + return [{ + name: fallbackNode.text, + fileName: ref.resolvedFileName, + containerName: undefined, + containerKind: undefined, + kind: "script" /* ScriptElementKind.scriptElement */, + textSpan: ts.createTextSpan(0, 0), + failedAliasResolution: failedAliasResolution, + isAmbient: ts.isDeclarationFileName(ref.resolvedFileName), + unverified: fallbackNode !== node, + }]; + } + } + // Could not find a symbol e.g. node is string or number keyword, + // or the symbol was an internal symbol and does not have a declaration e.g. undefined symbol + if (!symbol) { + return ts.concatenate(fileReferenceDefinition, getDefinitionInfoForIndexSignatures(node, typeChecker)); + } + if (searchOtherFilesOnly && ts.every(symbol.declarations, function (d) { return d.getSourceFile().fileName === sourceFile.fileName; })) + return undefined; + var calledDeclaration = tryGetSignatureDeclaration(typeChecker, node); + // Don't go to the component constructor definition for a JSX element, just go to the component definition. + if (calledDeclaration && !(ts.isJsxOpeningLikeElement(node.parent) && isConstructorLike(calledDeclaration))) { + var sigInfo = createDefinitionFromSignatureDeclaration(typeChecker, calledDeclaration, failedAliasResolution); + // For a function, if this is the original function definition, return just sigInfo. + // If this is the original constructor definition, parent is the class. + if (typeChecker.getRootSymbols(symbol).some(function (s) { return symbolMatchesSignature(s, calledDeclaration); })) { + return [sigInfo]; + } + else { + var defs = getDefinitionFromSymbol(typeChecker, symbol, node, failedAliasResolution, calledDeclaration) || ts.emptyArray; + // For a 'super()' call, put the signature first, else put the variable first. + return node.kind === 106 /* SyntaxKind.SuperKeyword */ ? __spreadArray([sigInfo], defs, true) : __spreadArray(__spreadArray([], defs, true), [sigInfo], false); + } + } + // Because name in short-hand property assignment has two different meanings: property name and property value, + // using go-to-definition at such position should go to the variable declaration of the property value rather than + // go to the declaration of the property name (in this case stay at the same position). However, if go-to-definition + // is performed at the location of property access, we would like to go to definition of the property in the short-hand + // assignment. This case and others are handled by the following code. + if (node.parent.kind === 300 /* SyntaxKind.ShorthandPropertyAssignment */) { + var shorthandSymbol_1 = typeChecker.getShorthandAssignmentValueSymbol(symbol.valueDeclaration); + var definitions = (shorthandSymbol_1 === null || shorthandSymbol_1 === void 0 ? void 0 : shorthandSymbol_1.declarations) ? shorthandSymbol_1.declarations.map(function (decl) { return createDefinitionInfo(decl, typeChecker, shorthandSymbol_1, node, /*unverified*/ false, failedAliasResolution); }) : ts.emptyArray; + return ts.concatenate(definitions, getDefinitionFromObjectLiteralElement(typeChecker, node) || ts.emptyArray); + } + // If the node is the name of a BindingElement within an ObjectBindingPattern instead of just returning the + // declaration the symbol (which is itself), we should try to get to the original type of the ObjectBindingPattern + // and return the property declaration for the referenced property. + // For example: + // import('./foo').then(({ b/*goto*/ar }) => undefined); => should get use to the declaration in file "./foo" + // + // function bar(onfulfilled: (value: T) => void) { //....} + // interface Test { + // pr/*destination*/op1: number + // } + // bar(({pr/*goto*/op1})=>{}); + if (ts.isPropertyName(node) && ts.isBindingElement(parent) && ts.isObjectBindingPattern(parent.parent) && + (node === (parent.propertyName || parent.name))) { + var name_3 = ts.getNameFromPropertyName(node); + var type = typeChecker.getTypeAtLocation(parent.parent); + return name_3 === undefined ? ts.emptyArray : ts.flatMap(type.isUnion() ? type.types : [type], function (t) { + var prop = t.getProperty(name_3); + return prop && getDefinitionFromSymbol(typeChecker, prop, node); + }); + } + return ts.concatenate(fileReferenceDefinition, getDefinitionFromObjectLiteralElement(typeChecker, node) || getDefinitionFromSymbol(typeChecker, symbol, node, failedAliasResolution)); + } + GoToDefinition.getDefinitionAtPosition = getDefinitionAtPosition; + /** + * True if we should not add definitions for both the signature symbol and the definition symbol. + * True for `const |f = |() => 0`, false for `function |f() {} const |g = f;`. + * Also true for any assignment RHS. + */ + function symbolMatchesSignature(s, calledDeclaration) { + return s === calledDeclaration.symbol + || s === calledDeclaration.symbol.parent + || ts.isAssignmentExpression(calledDeclaration.parent) + || (!ts.isCallLikeExpression(calledDeclaration.parent) && s === calledDeclaration.parent.symbol); + } + // If the current location we want to find its definition is in an object literal, try to get the contextual type for the + // object literal, lookup the property symbol in the contextual type, and use this for goto-definition. + // For example + // interface Props{ + // /*first*/prop1: number + // prop2: boolean + // } + // function Foo(arg: Props) {} + // Foo( { pr/*1*/op1: 10, prop2: true }) + function getDefinitionFromObjectLiteralElement(typeChecker, node) { + var element = ts.getContainingObjectLiteralElement(node); + if (element) { + var contextualType = element && typeChecker.getContextualType(element.parent); + if (contextualType) { + return ts.flatMap(ts.getPropertySymbolsFromContextualType(element, typeChecker, contextualType, /*unionSymbolOk*/ false), function (propertySymbol) { + return getDefinitionFromSymbol(typeChecker, propertySymbol, node); + }); + } + } + } + function getDefinitionFromOverriddenMember(typeChecker, node) { + var classElement = ts.findAncestor(node, ts.isClassElement); + if (!(classElement && classElement.name)) + return; + var baseDeclaration = ts.findAncestor(classElement, ts.isClassLike); + if (!baseDeclaration) + return; + var baseTypeNode = ts.getEffectiveBaseTypeNode(baseDeclaration); + if (!baseTypeNode) + return; + var expression = ts.skipParentheses(baseTypeNode.expression); + var base = ts.isClassExpression(expression) ? expression.symbol : typeChecker.getSymbolAtLocation(expression); + if (!base) + return; + var name = ts.unescapeLeadingUnderscores(ts.getTextOfPropertyName(classElement.name)); + var symbol = ts.hasStaticModifier(classElement) + ? typeChecker.getPropertyOfType(typeChecker.getTypeOfSymbol(base), name) + : typeChecker.getPropertyOfType(typeChecker.getDeclaredTypeOfSymbol(base), name); + if (!symbol) + return; + return getDefinitionFromSymbol(typeChecker, symbol, node); + } + function getReferenceAtPosition(sourceFile, position, program) { + var _a, _b; + var referencePath = findReferenceInPosition(sourceFile.referencedFiles, position); + if (referencePath) { + var file = program.getSourceFileFromReference(sourceFile, referencePath); + return file && { reference: referencePath, fileName: file.fileName, file: file, unverified: false }; + } + var typeReferenceDirective = findReferenceInPosition(sourceFile.typeReferenceDirectives, position); + if (typeReferenceDirective) { + var reference = program.getResolvedTypeReferenceDirectives().get(typeReferenceDirective.fileName, typeReferenceDirective.resolutionMode || sourceFile.impliedNodeFormat); + var file = reference && program.getSourceFile(reference.resolvedFileName); // TODO:GH#18217 + return file && { reference: typeReferenceDirective, fileName: file.fileName, file: file, unverified: false }; + } + var libReferenceDirective = findReferenceInPosition(sourceFile.libReferenceDirectives, position); + if (libReferenceDirective) { + var file = program.getLibFileFromReference(libReferenceDirective); + return file && { reference: libReferenceDirective, fileName: file.fileName, file: file, unverified: false }; + } + if ((_a = sourceFile.resolvedModules) === null || _a === void 0 ? void 0 : _a.size()) { + var node = ts.getTouchingToken(sourceFile, position); + if (ts.isModuleSpecifierLike(node) && ts.isExternalModuleNameRelative(node.text) && sourceFile.resolvedModules.has(node.text, ts.getModeForUsageLocation(sourceFile, node))) { + var verifiedFileName = (_b = sourceFile.resolvedModules.get(node.text, ts.getModeForUsageLocation(sourceFile, node))) === null || _b === void 0 ? void 0 : _b.resolvedFileName; + var fileName = verifiedFileName || ts.resolvePath(ts.getDirectoryPath(sourceFile.fileName), node.text); + return { + file: program.getSourceFile(fileName), + fileName: fileName, + reference: { + pos: node.getStart(), + end: node.getEnd(), + fileName: node.text + }, + unverified: !verifiedFileName, + }; + } + } + return undefined; + } + GoToDefinition.getReferenceAtPosition = getReferenceAtPosition; + /// Goto type + function getTypeDefinitionAtPosition(typeChecker, sourceFile, position) { + var node = ts.getTouchingPropertyName(sourceFile, position); + if (node === sourceFile) { + return undefined; + } + if (ts.isImportMeta(node.parent) && node.parent.name === node) { + return definitionFromType(typeChecker.getTypeAtLocation(node.parent), typeChecker, node.parent, /*failedAliasResolution*/ false); + } + var _a = getSymbol(node, typeChecker, /*stopAtAlias*/ false), symbol = _a.symbol, failedAliasResolution = _a.failedAliasResolution; + if (!symbol) + return undefined; + var typeAtLocation = typeChecker.getTypeOfSymbolAtLocation(symbol, node); + var returnType = tryGetReturnTypeOfFunction(symbol, typeAtLocation, typeChecker); + var fromReturnType = returnType && definitionFromType(returnType, typeChecker, node, failedAliasResolution); + // If a function returns 'void' or some other type with no definition, just return the function definition. + var typeDefinitions = fromReturnType && fromReturnType.length !== 0 ? fromReturnType : definitionFromType(typeAtLocation, typeChecker, node, failedAliasResolution); + return typeDefinitions.length ? typeDefinitions + : !(symbol.flags & 111551 /* SymbolFlags.Value */) && symbol.flags & 788968 /* SymbolFlags.Type */ ? getDefinitionFromSymbol(typeChecker, ts.skipAlias(symbol, typeChecker), node, failedAliasResolution) + : undefined; + } + GoToDefinition.getTypeDefinitionAtPosition = getTypeDefinitionAtPosition; + function definitionFromType(type, checker, node, failedAliasResolution) { + return ts.flatMap(type.isUnion() && !(type.flags & 32 /* TypeFlags.Enum */) ? type.types : [type], function (t) { + return t.symbol && getDefinitionFromSymbol(checker, t.symbol, node, failedAliasResolution); + }); + } + function tryGetReturnTypeOfFunction(symbol, type, checker) { + // If the type is just a function's inferred type, + // go-to-type should go to the return type instead, since go-to-definition takes you to the function anyway. + if (type.symbol === symbol || + // At `const f = () => {}`, the symbol is `f` and the type symbol is at `() => {}` + symbol.valueDeclaration && type.symbol && ts.isVariableDeclaration(symbol.valueDeclaration) && symbol.valueDeclaration.initializer === type.symbol.valueDeclaration) { + var sigs = type.getCallSignatures(); + if (sigs.length === 1) + return checker.getReturnTypeOfSignature(ts.first(sigs)); + } + return undefined; + } + function getDefinitionAndBoundSpan(program, sourceFile, position) { + var definitions = getDefinitionAtPosition(program, sourceFile, position); + if (!definitions || definitions.length === 0) { + return undefined; + } + // Check if position is on triple slash reference. + var comment = findReferenceInPosition(sourceFile.referencedFiles, position) || + findReferenceInPosition(sourceFile.typeReferenceDirectives, position) || + findReferenceInPosition(sourceFile.libReferenceDirectives, position); + if (comment) { + return { definitions: definitions, textSpan: ts.createTextSpanFromRange(comment) }; + } + var node = ts.getTouchingPropertyName(sourceFile, position); + var textSpan = ts.createTextSpan(node.getStart(), node.getWidth()); + return { definitions: definitions, textSpan: textSpan }; + } + GoToDefinition.getDefinitionAndBoundSpan = getDefinitionAndBoundSpan; + // At 'x.foo', see if the type of 'x' has an index signature, and if so find its declarations. + function getDefinitionInfoForIndexSignatures(node, checker) { + return ts.mapDefined(checker.getIndexInfosAtLocation(node), function (info) { return info.declaration && createDefinitionFromSignatureDeclaration(checker, info.declaration); }); + } + function getSymbol(node, checker, stopAtAlias) { + var symbol = checker.getSymbolAtLocation(node); + // If this is an alias, and the request came at the declaration location + // get the aliased symbol instead. This allows for goto def on an import e.g. + // import {A, B} from "mod"; + // to jump to the implementation directly. + var failedAliasResolution = false; + if ((symbol === null || symbol === void 0 ? void 0 : symbol.declarations) && symbol.flags & 2097152 /* SymbolFlags.Alias */ && !stopAtAlias && shouldSkipAlias(node, symbol.declarations[0])) { + var aliased = checker.getAliasedSymbol(symbol); + if (aliased.declarations) { + return { symbol: aliased }; + } + else { + failedAliasResolution = true; + } + } + return { symbol: symbol, failedAliasResolution: failedAliasResolution }; + } + // Go to the original declaration for cases: + // + // (1) when the aliased symbol was declared in the location(parent). + // (2) when the aliased symbol is originating from an import. + // + function shouldSkipAlias(node, declaration) { + if (node.kind !== 79 /* SyntaxKind.Identifier */) { + return false; + } + if (node.parent === declaration) { + return true; + } + if (declaration.kind === 271 /* SyntaxKind.NamespaceImport */) { + return false; + } + return true; + } + /** + * ```ts + * function f() {} + * f.foo = 0; + * ``` + * + * Here, `f` has two declarations: the function declaration, and the identifier in the next line. + * The latter is a declaration for `f` because it gives `f` the `SymbolFlags.Namespace` meaning so + * it can contain `foo`. However, that declaration is pretty uninteresting and not intuitively a + * "definition" for `f`. Ideally, the question we'd like to answer is "what SymbolFlags does this + * declaration contribute to the symbol for `f`?" If the answer is just `Namespace` and the + * declaration looks like an assignment, that declaration is in no sense a definition for `f`. + * But that information is totally lost during binding and/or symbol merging, so we need to do + * our best to reconstruct it or use other heuristics. This function (and the logic around its + * calling) covers our tests but feels like a hack, and it would be great if someone could come + * up with a more precise definition of what counts as a definition. + */ + function isExpandoDeclaration(node) { + if (!ts.isAssignmentDeclaration(node)) + return false; + var containingAssignment = ts.findAncestor(node, function (p) { + if (ts.isAssignmentExpression(p)) + return true; + if (!ts.isAssignmentDeclaration(p)) + return "quit"; + return false; + }); + return !!containingAssignment && ts.getAssignmentDeclarationKind(containingAssignment) === 5 /* AssignmentDeclarationKind.Property */; + } + function getDefinitionFromSymbol(typeChecker, symbol, node, failedAliasResolution, excludeDeclaration) { + var filteredDeclarations = ts.filter(symbol.declarations, function (d) { return d !== excludeDeclaration; }); + var withoutExpandos = ts.filter(filteredDeclarations, function (d) { return !isExpandoDeclaration(d); }); + var results = ts.some(withoutExpandos) ? withoutExpandos : filteredDeclarations; + return getConstructSignatureDefinition() || getCallSignatureDefinition() || ts.map(results, function (declaration) { return createDefinitionInfo(declaration, typeChecker, symbol, node, /*unverified*/ false, failedAliasResolution); }); + function getConstructSignatureDefinition() { + // Applicable only if we are in a new expression, or we are on a constructor declaration + // and in either case the symbol has a construct signature definition, i.e. class + if (symbol.flags & 32 /* SymbolFlags.Class */ && !(symbol.flags & (16 /* SymbolFlags.Function */ | 3 /* SymbolFlags.Variable */)) && (ts.isNewExpressionTarget(node) || node.kind === 135 /* SyntaxKind.ConstructorKeyword */)) { + var cls = ts.find(filteredDeclarations, ts.isClassLike) || ts.Debug.fail("Expected declaration to have at least one class-like declaration"); + return getSignatureDefinition(cls.members, /*selectConstructors*/ true); + } + } + function getCallSignatureDefinition() { + return ts.isCallOrNewExpressionTarget(node) || ts.isNameOfFunctionDeclaration(node) + ? getSignatureDefinition(filteredDeclarations, /*selectConstructors*/ false) + : undefined; + } + function getSignatureDefinition(signatureDeclarations, selectConstructors) { + if (!signatureDeclarations) { + return undefined; + } + var declarations = signatureDeclarations.filter(selectConstructors ? ts.isConstructorDeclaration : ts.isFunctionLike); + var declarationsWithBody = declarations.filter(function (d) { return !!d.body; }); + // declarations defined on the global scope can be defined on multiple files. Get all of them. + return declarations.length + ? declarationsWithBody.length !== 0 + ? declarationsWithBody.map(function (x) { return createDefinitionInfo(x, typeChecker, symbol, node); }) + : [createDefinitionInfo(ts.last(declarations), typeChecker, symbol, node, /*unverified*/ false, failedAliasResolution)] + : undefined; + } + } + /** Creates a DefinitionInfo from a Declaration, using the declaration's name if possible. */ + function createDefinitionInfo(declaration, checker, symbol, node, unverified, failedAliasResolution) { + var symbolName = checker.symbolToString(symbol); // Do not get scoped name, just the name of the symbol + var symbolKind = ts.SymbolDisplay.getSymbolKind(checker, symbol, node); + var containerName = symbol.parent ? checker.symbolToString(symbol.parent, node) : ""; + return createDefinitionInfoFromName(checker, declaration, symbolKind, symbolName, containerName, unverified, failedAliasResolution); + } + GoToDefinition.createDefinitionInfo = createDefinitionInfo; + /** Creates a DefinitionInfo directly from the name of a declaration. */ + function createDefinitionInfoFromName(checker, declaration, symbolKind, symbolName, containerName, unverified, failedAliasResolution, textSpan) { + var sourceFile = declaration.getSourceFile(); + if (!textSpan) { + var name = ts.getNameOfDeclaration(declaration) || declaration; + textSpan = ts.createTextSpanFromNode(name, sourceFile); + } + return __assign(__assign({ fileName: sourceFile.fileName, textSpan: textSpan, kind: symbolKind, name: symbolName, containerKind: undefined, // TODO: GH#18217 + containerName: containerName }, ts.FindAllReferences.toContextSpan(textSpan, sourceFile, ts.FindAllReferences.getContextNode(declaration))), { isLocal: !isDefinitionVisible(checker, declaration), isAmbient: !!(declaration.flags & 16777216 /* NodeFlags.Ambient */), unverified: unverified, failedAliasResolution: failedAliasResolution }); + } + function isDefinitionVisible(checker, declaration) { + if (checker.isDeclarationVisible(declaration)) + return true; + if (!declaration.parent) + return false; + // Variable initializers are visible if variable is visible + if (ts.hasInitializer(declaration.parent) && declaration.parent.initializer === declaration) + return isDefinitionVisible(checker, declaration.parent); + // Handle some exceptions here like arrow function, members of class and object literal expression which are technically not visible but we want the definition to be determined by its parent + switch (declaration.kind) { + case 169 /* SyntaxKind.PropertyDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 171 /* SyntaxKind.MethodDeclaration */: + // Private/protected properties/methods are not visible + if (ts.hasEffectiveModifier(declaration, 8 /* ModifierFlags.Private */)) + return false; + // Public properties/methods are visible if its parents are visible, so: + // falls through + case 173 /* SyntaxKind.Constructor */: + case 299 /* SyntaxKind.PropertyAssignment */: + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + case 207 /* SyntaxKind.ObjectLiteralExpression */: + case 228 /* SyntaxKind.ClassExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + case 215 /* SyntaxKind.FunctionExpression */: + return isDefinitionVisible(checker, declaration.parent); + default: + return false; + } + } + function createDefinitionFromSignatureDeclaration(typeChecker, decl, failedAliasResolution) { + return createDefinitionInfo(decl, typeChecker, decl.symbol, decl, /*unverified*/ false, failedAliasResolution); + } + function findReferenceInPosition(refs, pos) { + return ts.find(refs, function (ref) { return ts.textRangeContainsPositionInclusive(ref, pos); }); + } + GoToDefinition.findReferenceInPosition = findReferenceInPosition; + function getDefinitionInfoForFileReference(name, targetFileName, unverified) { + return { + fileName: targetFileName, + textSpan: ts.createTextSpanFromBounds(0, 0), + kind: "script" /* ScriptElementKind.scriptElement */, + name: name, + containerName: undefined, + containerKind: undefined, + unverified: unverified, + }; + } + /** Returns a CallLikeExpression where `node` is the target being invoked. */ + function getAncestorCallLikeExpression(node) { + var target = ts.findAncestor(node, function (n) { return !ts.isRightSideOfPropertyAccess(n); }); + var callLike = target === null || target === void 0 ? void 0 : target.parent; + return callLike && ts.isCallLikeExpression(callLike) && ts.getInvokedExpression(callLike) === target ? callLike : undefined; + } + function tryGetSignatureDeclaration(typeChecker, node) { + var callLike = getAncestorCallLikeExpression(node); + var signature = callLike && typeChecker.getResolvedSignature(callLike); + // Don't go to a function type, go to the value having that type. + return ts.tryCast(signature && signature.declaration, function (d) { return ts.isFunctionLike(d) && !ts.isFunctionTypeNode(d); }); + } + function isConstructorLike(node) { + switch (node.kind) { + case 173 /* SyntaxKind.Constructor */: + case 182 /* SyntaxKind.ConstructorType */: + case 177 /* SyntaxKind.ConstructSignature */: + return true; + default: + return false; + } + } + })(GoToDefinition = ts.GoToDefinition || (ts.GoToDefinition = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var JsDoc; + (function (JsDoc) { + var jsDocTagNames = [ + "abstract", + "access", + "alias", + "argument", + "async", + "augments", + "author", + "borrows", + "callback", + "class", + "classdesc", + "constant", + "constructor", + "constructs", + "copyright", + "default", + "deprecated", + "description", + "emits", + "enum", + "event", + "example", + "exports", + "extends", + "external", + "field", + "file", + "fileoverview", + "fires", + "function", + "generator", + "global", + "hideconstructor", + "host", + "ignore", + "implements", + "inheritdoc", + "inner", + "instance", + "interface", + "kind", + "lends", + "license", + "link", + "listens", + "member", + "memberof", + "method", + "mixes", + "module", + "name", + "namespace", + "override", + "package", + "param", + "private", + "property", + "protected", + "public", + "readonly", + "requires", + "returns", + "see", + "since", + "static", + "summary", + "template", + "this", + "throws", + "todo", + "tutorial", + "type", + "typedef", + "var", + "variation", + "version", + "virtual", + "yields" + ]; + var jsDocTagNameCompletionEntries; + var jsDocTagCompletionEntries; + function getJsDocCommentsFromDeclarations(declarations, checker) { + // Only collect doc comments from duplicate declarations once: + // In case of a union property there might be same declaration multiple times + // which only varies in type parameter + // Eg. const a: Array | Array; a.length + // The property length will have two declarations of property length coming + // from Array - Array and Array + var parts = []; + ts.forEachUnique(declarations, function (declaration) { + for (var _i = 0, _a = getCommentHavingNodes(declaration); _i < _a.length; _i++) { + var jsdoc = _a[_i]; + var inheritDoc = ts.isJSDoc(jsdoc) && jsdoc.tags && ts.find(jsdoc.tags, function (t) { return t.kind === 330 /* SyntaxKind.JSDocTag */ && (t.tagName.escapedText === "inheritDoc" || t.tagName.escapedText === "inheritdoc"); }); + // skip comments containing @typedefs since they're not associated with particular declarations + // Exceptions: + // - @typedefs are themselves declarations with associated comments + // - @param or @return indicate that the author thinks of it as a 'local' @typedef that's part of the function documentation + if (jsdoc.comment === undefined && !inheritDoc + || ts.isJSDoc(jsdoc) + && declaration.kind !== 348 /* SyntaxKind.JSDocTypedefTag */ && declaration.kind !== 341 /* SyntaxKind.JSDocCallbackTag */ + && jsdoc.tags + && jsdoc.tags.some(function (t) { return t.kind === 348 /* SyntaxKind.JSDocTypedefTag */ || t.kind === 341 /* SyntaxKind.JSDocCallbackTag */; }) + && !jsdoc.tags.some(function (t) { return t.kind === 343 /* SyntaxKind.JSDocParameterTag */ || t.kind === 344 /* SyntaxKind.JSDocReturnTag */; })) { + continue; + } + var newparts = jsdoc.comment ? getDisplayPartsFromComment(jsdoc.comment, checker) : []; + if (inheritDoc && inheritDoc.comment) { + newparts = newparts.concat(getDisplayPartsFromComment(inheritDoc.comment, checker)); + } + if (!ts.contains(parts, newparts, isIdenticalListOfDisplayParts)) { + parts.push(newparts); + } + } + }); + return ts.flatten(ts.intersperse(parts, [ts.lineBreakPart()])); + } + JsDoc.getJsDocCommentsFromDeclarations = getJsDocCommentsFromDeclarations; + function isIdenticalListOfDisplayParts(parts1, parts2) { + return ts.arraysEqual(parts1, parts2, function (p1, p2) { return p1.kind === p2.kind && p1.text === p2.text; }); + } + function getCommentHavingNodes(declaration) { + switch (declaration.kind) { + case 343 /* SyntaxKind.JSDocParameterTag */: + case 350 /* SyntaxKind.JSDocPropertyTag */: + return [declaration]; + case 341 /* SyntaxKind.JSDocCallbackTag */: + case 348 /* SyntaxKind.JSDocTypedefTag */: + return [declaration, declaration.parent]; + default: + return ts.getJSDocCommentsAndTags(declaration); + } + } + function getJsDocTagsFromDeclarations(declarations, checker) { + // Only collect doc comments from duplicate declarations once. + var infos = []; + ts.forEachUnique(declarations, function (declaration) { + var tags = ts.getJSDocTags(declaration); + // skip comments containing @typedefs since they're not associated with particular declarations + // Exceptions: + // - @param or @return indicate that the author thinks of it as a 'local' @typedef that's part of the function documentation + if (tags.some(function (t) { return t.kind === 348 /* SyntaxKind.JSDocTypedefTag */ || t.kind === 341 /* SyntaxKind.JSDocCallbackTag */; }) + && !tags.some(function (t) { return t.kind === 343 /* SyntaxKind.JSDocParameterTag */ || t.kind === 344 /* SyntaxKind.JSDocReturnTag */; })) { + return; + } + for (var _i = 0, tags_1 = tags; _i < tags_1.length; _i++) { + var tag = tags_1[_i]; + infos.push({ name: tag.tagName.text, text: getCommentDisplayParts(tag, checker) }); + } + }); + return infos; + } + JsDoc.getJsDocTagsFromDeclarations = getJsDocTagsFromDeclarations; + function getDisplayPartsFromComment(comment, checker) { + if (typeof comment === "string") { + return [ts.textPart(comment)]; + } + return ts.flatMap(comment, function (node) { return node.kind === 324 /* SyntaxKind.JSDocText */ ? [ts.textPart(node.text)] : ts.buildLinkParts(node, checker); }); + } + function getCommentDisplayParts(tag, checker) { + var comment = tag.comment, kind = tag.kind; + var namePart = getTagNameDisplayPart(kind); + switch (kind) { + case 332 /* SyntaxKind.JSDocImplementsTag */: + return withNode(tag.class); + case 331 /* SyntaxKind.JSDocAugmentsTag */: + return withNode(tag.class); + case 347 /* SyntaxKind.JSDocTemplateTag */: + var templateTag = tag; + var displayParts_3 = []; + if (templateTag.constraint) { + displayParts_3.push(ts.textPart(templateTag.constraint.getText())); + } + if (ts.length(templateTag.typeParameters)) { + if (ts.length(displayParts_3)) { + displayParts_3.push(ts.spacePart()); + } + var lastTypeParameter_1 = templateTag.typeParameters[templateTag.typeParameters.length - 1]; + ts.forEach(templateTag.typeParameters, function (tp) { + displayParts_3.push(namePart(tp.getText())); + if (lastTypeParameter_1 !== tp) { + displayParts_3.push.apply(displayParts_3, [ts.punctuationPart(27 /* SyntaxKind.CommaToken */), ts.spacePart()]); + } + }); + } + if (comment) { + displayParts_3.push.apply(displayParts_3, __spreadArray([ts.spacePart()], getDisplayPartsFromComment(comment, checker), true)); + } + return displayParts_3; + case 346 /* SyntaxKind.JSDocTypeTag */: + return withNode(tag.typeExpression); + case 348 /* SyntaxKind.JSDocTypedefTag */: + case 341 /* SyntaxKind.JSDocCallbackTag */: + case 350 /* SyntaxKind.JSDocPropertyTag */: + case 343 /* SyntaxKind.JSDocParameterTag */: + case 349 /* SyntaxKind.JSDocSeeTag */: + var name = tag.name; + return name ? withNode(name) + : comment === undefined ? undefined + : getDisplayPartsFromComment(comment, checker); + default: + return comment === undefined ? undefined : getDisplayPartsFromComment(comment, checker); + } + function withNode(node) { + return addComment(node.getText()); + } + function addComment(s) { + if (comment) { + if (s.match(/^https?$/)) { + return __spreadArray([ts.textPart(s)], getDisplayPartsFromComment(comment, checker), true); + } + else { + return __spreadArray([namePart(s), ts.spacePart()], getDisplayPartsFromComment(comment, checker), true); + } + } + else { + return [ts.textPart(s)]; + } + } + } + function getTagNameDisplayPart(kind) { + switch (kind) { + case 343 /* SyntaxKind.JSDocParameterTag */: + return ts.parameterNamePart; + case 350 /* SyntaxKind.JSDocPropertyTag */: + return ts.propertyNamePart; + case 347 /* SyntaxKind.JSDocTemplateTag */: + return ts.typeParameterNamePart; + case 348 /* SyntaxKind.JSDocTypedefTag */: + case 341 /* SyntaxKind.JSDocCallbackTag */: + return ts.typeAliasNamePart; + default: + return ts.textPart; + } + } + function getJSDocTagNameCompletions() { + return jsDocTagNameCompletionEntries || (jsDocTagNameCompletionEntries = ts.map(jsDocTagNames, function (tagName) { + return { + name: tagName, + kind: "keyword" /* ScriptElementKind.keyword */, + kindModifiers: "", + sortText: ts.Completions.SortText.LocationPriority, + }; + })); + } + JsDoc.getJSDocTagNameCompletions = getJSDocTagNameCompletions; + JsDoc.getJSDocTagNameCompletionDetails = getJSDocTagCompletionDetails; + function getJSDocTagCompletions() { + return jsDocTagCompletionEntries || (jsDocTagCompletionEntries = ts.map(jsDocTagNames, function (tagName) { + return { + name: "@".concat(tagName), + kind: "keyword" /* ScriptElementKind.keyword */, + kindModifiers: "", + sortText: ts.Completions.SortText.LocationPriority + }; + })); + } + JsDoc.getJSDocTagCompletions = getJSDocTagCompletions; + function getJSDocTagCompletionDetails(name) { + return { + name: name, + kind: "" /* ScriptElementKind.unknown */, + kindModifiers: "", + displayParts: [ts.textPart(name)], + documentation: ts.emptyArray, + tags: undefined, + codeActions: undefined, + }; + } + JsDoc.getJSDocTagCompletionDetails = getJSDocTagCompletionDetails; + function getJSDocParameterNameCompletions(tag) { + if (!ts.isIdentifier(tag.name)) { + return ts.emptyArray; + } + var nameThusFar = tag.name.text; + var jsdoc = tag.parent; + var fn = jsdoc.parent; + if (!ts.isFunctionLike(fn)) + return []; + return ts.mapDefined(fn.parameters, function (param) { + if (!ts.isIdentifier(param.name)) + return undefined; + var name = param.name.text; + if (jsdoc.tags.some(function (t) { return t !== tag && ts.isJSDocParameterTag(t) && ts.isIdentifier(t.name) && t.name.escapedText === name; }) // TODO: GH#18217 + || nameThusFar !== undefined && !ts.startsWith(name, nameThusFar)) { + return undefined; + } + return { name: name, kind: "parameter" /* ScriptElementKind.parameterElement */, kindModifiers: "", sortText: ts.Completions.SortText.LocationPriority }; + }); + } + JsDoc.getJSDocParameterNameCompletions = getJSDocParameterNameCompletions; + function getJSDocParameterNameCompletionDetails(name) { + return { + name: name, + kind: "parameter" /* ScriptElementKind.parameterElement */, + kindModifiers: "", + displayParts: [ts.textPart(name)], + documentation: ts.emptyArray, + tags: undefined, + codeActions: undefined, + }; + } + JsDoc.getJSDocParameterNameCompletionDetails = getJSDocParameterNameCompletionDetails; + /** + * Checks if position points to a valid position to add JSDoc comments, and if so, + * returns the appropriate template. Otherwise returns an empty string. + * Valid positions are + * - outside of comments, statements, and expressions, and + * - preceding a: + * - function/constructor/method declaration + * - class declarations + * - variable statements + * - namespace declarations + * - interface declarations + * - method signatures + * - type alias declarations + * + * Hosts should ideally check that: + * - The line is all whitespace up to 'position' before performing the insertion. + * - If the keystroke sequence "/\*\*" induced the call, we also check that the next + * non-whitespace character is '*', which (approximately) indicates whether we added + * the second '*' to complete an existing (JSDoc) comment. + * @param fileName The file in which to perform the check. + * @param position The (character-indexed) position in the file where the check should + * be performed. + */ + function getDocCommentTemplateAtPosition(newLine, sourceFile, position, options) { + var tokenAtPos = ts.getTokenAtPosition(sourceFile, position); + var existingDocComment = ts.findAncestor(tokenAtPos, ts.isJSDoc); + if (existingDocComment && (existingDocComment.comment !== undefined || ts.length(existingDocComment.tags))) { + // Non-empty comment already exists. + return undefined; + } + var tokenStart = tokenAtPos.getStart(sourceFile); + // Don't provide a doc comment template based on a *previous* node. (But an existing empty jsdoc comment will likely start before `position`.) + if (!existingDocComment && tokenStart < position) { + return undefined; + } + var commentOwnerInfo = getCommentOwnerInfo(tokenAtPos, options); + if (!commentOwnerInfo) { + return undefined; + } + var commentOwner = commentOwnerInfo.commentOwner, parameters = commentOwnerInfo.parameters, hasReturn = commentOwnerInfo.hasReturn; + var commentOwnerJsDoc = ts.hasJSDocNodes(commentOwner) && commentOwner.jsDoc ? commentOwner.jsDoc : undefined; + var lastJsDoc = ts.lastOrUndefined(commentOwnerJsDoc); + if (commentOwner.getStart(sourceFile) < position + || lastJsDoc + && existingDocComment + && lastJsDoc !== existingDocComment) { + return undefined; + } + var indentationStr = getIndentationStringAtPosition(sourceFile, position); + var isJavaScriptFile = ts.hasJSFileExtension(sourceFile.fileName); + var tags = (parameters ? parameterDocComments(parameters || [], isJavaScriptFile, indentationStr, newLine) : "") + + (hasReturn ? returnsDocComment(indentationStr, newLine) : ""); + // A doc comment consists of the following + // * The opening comment line + // * the first line (without a param) for the object's untagged info (this is also where the caret ends up) + // * the '@param'-tagged lines + // * the '@returns'-tag + // * TODO: other tags. + // * the closing comment line + // * if the caret was directly in front of the object, then we add an extra line and indentation. + var openComment = "/**"; + var closeComment = " */"; + // If any of the existing jsDoc has tags, ignore adding new ones. + var hasTag = (commentOwnerJsDoc || []).some(function (jsDoc) { return !!jsDoc.tags; }); + if (tags && !hasTag) { + var preamble = openComment + newLine + indentationStr + " * "; + var endLine = tokenStart === position ? newLine + indentationStr : ""; + var result = preamble + newLine + tags + indentationStr + closeComment + endLine; + return { newText: result, caretOffset: preamble.length }; + } + return { newText: openComment + closeComment, caretOffset: 3 }; + } + JsDoc.getDocCommentTemplateAtPosition = getDocCommentTemplateAtPosition; + function getIndentationStringAtPosition(sourceFile, position) { + var text = sourceFile.text; + var lineStart = ts.getLineStartPositionForPosition(position, sourceFile); + var pos = lineStart; + for (; pos <= position && ts.isWhiteSpaceSingleLine(text.charCodeAt(pos)); pos++) + ; + return text.slice(lineStart, pos); + } + function parameterDocComments(parameters, isJavaScriptFile, indentationStr, newLine) { + return parameters.map(function (_a, i) { + var name = _a.name, dotDotDotToken = _a.dotDotDotToken; + var paramName = name.kind === 79 /* SyntaxKind.Identifier */ ? name.text : "param" + i; + var type = isJavaScriptFile ? (dotDotDotToken ? "{...any} " : "{any} ") : ""; + return "".concat(indentationStr, " * @param ").concat(type).concat(paramName).concat(newLine); + }).join(""); + } + function returnsDocComment(indentationStr, newLine) { + return "".concat(indentationStr, " * @returns").concat(newLine); + } + function getCommentOwnerInfo(tokenAtPos, options) { + return ts.forEachAncestor(tokenAtPos, function (n) { return getCommentOwnerInfoWorker(n, options); }); + } + function getCommentOwnerInfoWorker(commentOwner, options) { + switch (commentOwner.kind) { + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 173 /* SyntaxKind.Constructor */: + case 170 /* SyntaxKind.MethodSignature */: + case 216 /* SyntaxKind.ArrowFunction */: + var host = commentOwner; + return { commentOwner: commentOwner, parameters: host.parameters, hasReturn: hasReturn(host, options) }; + case 299 /* SyntaxKind.PropertyAssignment */: + return getCommentOwnerInfoWorker(commentOwner.initializer, options); + case 260 /* SyntaxKind.ClassDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 302 /* SyntaxKind.EnumMember */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + return { commentOwner: commentOwner }; + case 168 /* SyntaxKind.PropertySignature */: { + var host_1 = commentOwner; + return host_1.type && ts.isFunctionTypeNode(host_1.type) + ? { commentOwner: commentOwner, parameters: host_1.type.parameters, hasReturn: hasReturn(host_1.type, options) } + : { commentOwner: commentOwner }; + } + case 240 /* SyntaxKind.VariableStatement */: { + var varStatement = commentOwner; + var varDeclarations = varStatement.declarationList.declarations; + var host_2 = varDeclarations.length === 1 && varDeclarations[0].initializer + ? getRightHandSideOfAssignment(varDeclarations[0].initializer) + : undefined; + return host_2 + ? { commentOwner: commentOwner, parameters: host_2.parameters, hasReturn: hasReturn(host_2, options) } + : { commentOwner: commentOwner }; + } + case 308 /* SyntaxKind.SourceFile */: + return "quit"; + case 264 /* SyntaxKind.ModuleDeclaration */: + // If in walking up the tree, we hit a a nested namespace declaration, + // then we must be somewhere within a dotted namespace name; however we don't + // want to give back a JSDoc template for the 'b' or 'c' in 'namespace a.b.c { }'. + return commentOwner.parent.kind === 264 /* SyntaxKind.ModuleDeclaration */ ? undefined : { commentOwner: commentOwner }; + case 241 /* SyntaxKind.ExpressionStatement */: + return getCommentOwnerInfoWorker(commentOwner.expression, options); + case 223 /* SyntaxKind.BinaryExpression */: { + var be = commentOwner; + if (ts.getAssignmentDeclarationKind(be) === 0 /* AssignmentDeclarationKind.None */) { + return "quit"; + } + return ts.isFunctionLike(be.right) + ? { commentOwner: commentOwner, parameters: be.right.parameters, hasReturn: hasReturn(be.right, options) } + : { commentOwner: commentOwner }; + } + case 169 /* SyntaxKind.PropertyDeclaration */: + var init = commentOwner.initializer; + if (init && (ts.isFunctionExpression(init) || ts.isArrowFunction(init))) { + return { commentOwner: commentOwner, parameters: init.parameters, hasReturn: hasReturn(init, options) }; + } + } + } + function hasReturn(node, options) { + return !!(options === null || options === void 0 ? void 0 : options.generateReturnInDocTemplate) && + (ts.isFunctionTypeNode(node) || ts.isArrowFunction(node) && ts.isExpression(node.body) + || ts.isFunctionLikeDeclaration(node) && node.body && ts.isBlock(node.body) && !!ts.forEachReturnStatement(node.body, function (n) { return n; })); + } + function getRightHandSideOfAssignment(rightHandSide) { + while (rightHandSide.kind === 214 /* SyntaxKind.ParenthesizedExpression */) { + rightHandSide = rightHandSide.expression; + } + switch (rightHandSide.kind) { + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + return rightHandSide; + case 228 /* SyntaxKind.ClassExpression */: + return ts.find(rightHandSide.members, ts.isConstructorDeclaration); + } + } + })(JsDoc = ts.JsDoc || (ts.JsDoc = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var NavigateTo; + (function (NavigateTo) { + function getNavigateToItems(sourceFiles, checker, cancellationToken, searchValue, maxResultCount, excludeDtsFiles) { + var patternMatcher = ts.createPatternMatcher(searchValue); + if (!patternMatcher) + return ts.emptyArray; + var rawItems = []; + var _loop_5 = function (sourceFile) { + cancellationToken.throwIfCancellationRequested(); + if (excludeDtsFiles && sourceFile.isDeclarationFile) { + return "continue"; + } + sourceFile.getNamedDeclarations().forEach(function (declarations, name) { + getItemsFromNamedDeclaration(patternMatcher, name, declarations, checker, sourceFile.fileName, rawItems); + }); + }; + // Search the declarations in all files and output matched NavigateToItem into array of NavigateToItem[] + for (var _i = 0, sourceFiles_4 = sourceFiles; _i < sourceFiles_4.length; _i++) { + var sourceFile = sourceFiles_4[_i]; + _loop_5(sourceFile); + } + rawItems.sort(compareNavigateToItems); + return (maxResultCount === undefined ? rawItems : rawItems.slice(0, maxResultCount)).map(createNavigateToItem); + } + NavigateTo.getNavigateToItems = getNavigateToItems; + function getItemsFromNamedDeclaration(patternMatcher, name, declarations, checker, fileName, rawItems) { + // First do a quick check to see if the name of the declaration matches the + // last portion of the (possibly) dotted name they're searching for. + var match = patternMatcher.getMatchForLastSegmentOfPattern(name); + if (!match) { + return; // continue to next named declarations + } + for (var _i = 0, declarations_3 = declarations; _i < declarations_3.length; _i++) { + var declaration = declarations_3[_i]; + if (!shouldKeepItem(declaration, checker)) + continue; + if (patternMatcher.patternContainsDots) { + // If the pattern has dots in it, then also see if the declaration container matches as well. + var fullMatch = patternMatcher.getFullMatch(getContainers(declaration), name); + if (fullMatch) { + rawItems.push({ name: name, fileName: fileName, matchKind: fullMatch.kind, isCaseSensitive: fullMatch.isCaseSensitive, declaration: declaration }); + } + } + else { + rawItems.push({ name: name, fileName: fileName, matchKind: match.kind, isCaseSensitive: match.isCaseSensitive, declaration: declaration }); + } + } + } + function shouldKeepItem(declaration, checker) { + switch (declaration.kind) { + case 270 /* SyntaxKind.ImportClause */: + case 273 /* SyntaxKind.ImportSpecifier */: + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + var importer = checker.getSymbolAtLocation(declaration.name); // TODO: GH#18217 + var imported = checker.getAliasedSymbol(importer); + return importer.escapedName !== imported.escapedName; + default: + return true; + } + } + function tryAddSingleDeclarationName(declaration, containers) { + var name = ts.getNameOfDeclaration(declaration); + return !!name && (pushLiteral(name, containers) || name.kind === 164 /* SyntaxKind.ComputedPropertyName */ && tryAddComputedPropertyName(name.expression, containers)); + } + // Only added the names of computed properties if they're simple dotted expressions, like: + // + // [X.Y.Z]() { } + function tryAddComputedPropertyName(expression, containers) { + return pushLiteral(expression, containers) + || ts.isPropertyAccessExpression(expression) && (containers.push(expression.name.text), true) && tryAddComputedPropertyName(expression.expression, containers); + } + function pushLiteral(node, containers) { + return ts.isPropertyNameLiteral(node) && (containers.push(ts.getTextOfIdentifierOrLiteral(node)), true); + } + function getContainers(declaration) { + var containers = []; + // First, if we started with a computed property name, then add all but the last + // portion into the container array. + var name = ts.getNameOfDeclaration(declaration); + if (name && name.kind === 164 /* SyntaxKind.ComputedPropertyName */ && !tryAddComputedPropertyName(name.expression, containers)) { + return ts.emptyArray; + } + // Don't include the last portion. + containers.shift(); + // Now, walk up our containers, adding all their names to the container array. + var container = ts.getContainerNode(declaration); + while (container) { + if (!tryAddSingleDeclarationName(container, containers)) { + return ts.emptyArray; + } + container = ts.getContainerNode(container); + } + return containers.reverse(); + } + function compareNavigateToItems(i1, i2) { + // TODO(cyrusn): get the gamut of comparisons that VS already uses here. + return ts.compareValues(i1.matchKind, i2.matchKind) + || ts.compareStringsCaseSensitiveUI(i1.name, i2.name); + } + function createNavigateToItem(rawItem) { + var declaration = rawItem.declaration; + var container = ts.getContainerNode(declaration); + var containerName = container && ts.getNameOfDeclaration(container); + return { + name: rawItem.name, + kind: ts.getNodeKind(declaration), + kindModifiers: ts.getNodeModifiers(declaration), + matchKind: ts.PatternMatchKind[rawItem.matchKind], + isCaseSensitive: rawItem.isCaseSensitive, + fileName: rawItem.fileName, + textSpan: ts.createTextSpanFromNode(declaration), + // TODO(jfreeman): What should be the containerName when the container has a computed name? + containerName: containerName ? containerName.text : "", + containerKind: containerName ? ts.getNodeKind(container) : "" /* ScriptElementKind.unknown */, + }; + } + })(NavigateTo = ts.NavigateTo || (ts.NavigateTo = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var NavigationBar; + (function (NavigationBar) { + var _a; + /** + * Matches all whitespace characters in a string. Eg: + * + * "app. + * + * onactivated" + * + * matches because of the newline, whereas + * + * "app.onactivated" + * + * does not match. + */ + var whiteSpaceRegex = /\s+/g; + /** + * Maximum amount of characters to return + * The amount was chosen arbitrarily. + */ + var maxLength = 150; + // Keep sourceFile handy so we don't have to search for it every time we need to call `getText`. + var curCancellationToken; + var curSourceFile; + /** + * For performance, we keep navigation bar parents on a stack rather than passing them through each recursion. + * `parent` is the current parent and is *not* stored in parentsStack. + * `startNode` sets a new parent and `endNode` returns to the previous parent. + */ + var parentsStack = []; + var parent; + var trackedEs5ClassesStack = []; + var trackedEs5Classes; + // NavigationBarItem requires an array, but will not mutate it, so just give it this for performance. + var emptyChildItemArray = []; + function getNavigationBarItems(sourceFile, cancellationToken) { + curCancellationToken = cancellationToken; + curSourceFile = sourceFile; + try { + return ts.map(primaryNavBarMenuItems(rootNavigationBarNode(sourceFile)), convertToPrimaryNavBarMenuItem); + } + finally { + reset(); + } + } + NavigationBar.getNavigationBarItems = getNavigationBarItems; + function getNavigationTree(sourceFile, cancellationToken) { + curCancellationToken = cancellationToken; + curSourceFile = sourceFile; + try { + return convertToTree(rootNavigationBarNode(sourceFile)); + } + finally { + reset(); + } + } + NavigationBar.getNavigationTree = getNavigationTree; + function reset() { + curSourceFile = undefined; + curCancellationToken = undefined; + parentsStack = []; + parent = undefined; + emptyChildItemArray = []; + } + function nodeText(node) { + return cleanText(node.getText(curSourceFile)); + } + function navigationBarNodeKind(n) { + return n.node.kind; + } + function pushChild(parent, child) { + if (parent.children) { + parent.children.push(child); + } + else { + parent.children = [child]; + } + } + function rootNavigationBarNode(sourceFile) { + ts.Debug.assert(!parentsStack.length); + var root = { node: sourceFile, name: undefined, additionalNodes: undefined, parent: undefined, children: undefined, indent: 0 }; + parent = root; + for (var _i = 0, _a = sourceFile.statements; _i < _a.length; _i++) { + var statement = _a[_i]; + addChildrenRecursively(statement); + } + endNode(); + ts.Debug.assert(!parent && !parentsStack.length); + return root; + } + function addLeafNode(node, name) { + pushChild(parent, emptyNavigationBarNode(node, name)); + } + function emptyNavigationBarNode(node, name) { + return { + node: node, + name: name || (ts.isDeclaration(node) || ts.isExpression(node) ? ts.getNameOfDeclaration(node) : undefined), + additionalNodes: undefined, + parent: parent, + children: undefined, + indent: parent.indent + 1 + }; + } + function addTrackedEs5Class(name) { + if (!trackedEs5Classes) { + trackedEs5Classes = new ts.Map(); + } + trackedEs5Classes.set(name, true); + } + function endNestedNodes(depth) { + for (var i = 0; i < depth; i++) + endNode(); + } + function startNestedNodes(targetNode, entityName) { + var names = []; + while (!ts.isPropertyNameLiteral(entityName)) { + var name = ts.getNameOrArgument(entityName); + var nameText = ts.getElementOrPropertyAccessName(entityName); + entityName = entityName.expression; + if (nameText === "prototype" || ts.isPrivateIdentifier(name)) + continue; + names.push(name); + } + names.push(entityName); + for (var i = names.length - 1; i > 0; i--) { + var name = names[i]; + startNode(targetNode, name); + } + return [names.length - 1, names[0]]; + } + /** + * Add a new level of NavigationBarNodes. + * This pushes to the stack, so you must call `endNode` when you are done adding to this node. + */ + function startNode(node, name) { + var navNode = emptyNavigationBarNode(node, name); + pushChild(parent, navNode); + // Save the old parent + parentsStack.push(parent); + trackedEs5ClassesStack.push(trackedEs5Classes); + trackedEs5Classes = undefined; + parent = navNode; + } + /** Call after calling `startNode` and adding children to it. */ + function endNode() { + if (parent.children) { + mergeChildren(parent.children, parent); + sortChildren(parent.children); + } + parent = parentsStack.pop(); + trackedEs5Classes = trackedEs5ClassesStack.pop(); + } + function addNodeWithRecursiveChild(node, child, name) { + startNode(node, name); + addChildrenRecursively(child); + endNode(); + } + function addNodeWithRecursiveInitializer(node) { + if (node.initializer && isFunctionOrClassExpression(node.initializer)) { + startNode(node); + ts.forEachChild(node.initializer, addChildrenRecursively); + endNode(); + } + else { + addNodeWithRecursiveChild(node, node.initializer); + } + } + /** + * Historically, we've elided dynamic names from the nav tree (including late bound names), + * but included certain "well known" symbol names. While we no longer distinguish those well-known + * symbols from other unique symbols, we do the below to retain those members in the nav tree. + */ + function hasNavigationBarName(node) { + return !ts.hasDynamicName(node) || + (node.kind !== 223 /* SyntaxKind.BinaryExpression */ && + ts.isPropertyAccessExpression(node.name.expression) && + ts.isIdentifier(node.name.expression.expression) && + ts.idText(node.name.expression.expression) === "Symbol"); + } + /** Look for navigation bar items in node's subtree, adding them to the current `parent`. */ + function addChildrenRecursively(node) { + var _a; + curCancellationToken.throwIfCancellationRequested(); + if (!node || ts.isToken(node)) { + return; + } + switch (node.kind) { + case 173 /* SyntaxKind.Constructor */: + // Get parameter properties, and treat them as being on the *same* level as the constructor, not under it. + var ctr = node; + addNodeWithRecursiveChild(ctr, ctr.body); + // Parameter properties are children of the class, not the constructor. + for (var _i = 0, _b = ctr.parameters; _i < _b.length; _i++) { + var param = _b[_i]; + if (ts.isParameterPropertyDeclaration(param, ctr)) { + addLeafNode(param); + } + } + break; + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 170 /* SyntaxKind.MethodSignature */: + if (hasNavigationBarName(node)) { + addNodeWithRecursiveChild(node, node.body); + } + break; + case 169 /* SyntaxKind.PropertyDeclaration */: + if (hasNavigationBarName(node)) { + addNodeWithRecursiveInitializer(node); + } + break; + case 168 /* SyntaxKind.PropertySignature */: + if (hasNavigationBarName(node)) { + addLeafNode(node); + } + break; + case 270 /* SyntaxKind.ImportClause */: + var importClause = node; + // Handle default import case e.g.: + // import d from "mod"; + if (importClause.name) { + addLeafNode(importClause.name); + } + // Handle named bindings in imports e.g.: + // import * as NS from "mod"; + // import {a, b as B} from "mod"; + var namedBindings = importClause.namedBindings; + if (namedBindings) { + if (namedBindings.kind === 271 /* SyntaxKind.NamespaceImport */) { + addLeafNode(namedBindings); + } + else { + for (var _c = 0, _d = namedBindings.elements; _c < _d.length; _c++) { + var element = _d[_c]; + addLeafNode(element); + } + } + } + break; + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + addNodeWithRecursiveChild(node, node.name); + break; + case 301 /* SyntaxKind.SpreadAssignment */: + var expression = node.expression; + // Use the expression as the name of the SpreadAssignment, otherwise show as . + ts.isIdentifier(expression) ? addLeafNode(node, expression) : addLeafNode(node); + break; + case 205 /* SyntaxKind.BindingElement */: + case 299 /* SyntaxKind.PropertyAssignment */: + case 257 /* SyntaxKind.VariableDeclaration */: { + var child = node; + if (ts.isBindingPattern(child.name)) { + addChildrenRecursively(child.name); + } + else { + addNodeWithRecursiveInitializer(child); + } + break; + } + case 259 /* SyntaxKind.FunctionDeclaration */: + var nameNode = node.name; + // If we see a function declaration track as a possible ES5 class + if (nameNode && ts.isIdentifier(nameNode)) { + addTrackedEs5Class(nameNode.text); + } + addNodeWithRecursiveChild(node, node.body); + break; + case 216 /* SyntaxKind.ArrowFunction */: + case 215 /* SyntaxKind.FunctionExpression */: + addNodeWithRecursiveChild(node, node.body); + break; + case 263 /* SyntaxKind.EnumDeclaration */: + startNode(node); + for (var _e = 0, _f = node.members; _e < _f.length; _e++) { + var member = _f[_e]; + if (!isComputedProperty(member)) { + addLeafNode(member); + } + } + endNode(); + break; + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + startNode(node); + for (var _g = 0, _h = node.members; _g < _h.length; _g++) { + var member = _h[_g]; + addChildrenRecursively(member); + } + endNode(); + break; + case 264 /* SyntaxKind.ModuleDeclaration */: + addNodeWithRecursiveChild(node, getInteriorModule(node).body); + break; + case 274 /* SyntaxKind.ExportAssignment */: { + var expression_1 = node.expression; + var child = ts.isObjectLiteralExpression(expression_1) || ts.isCallExpression(expression_1) ? expression_1 : + ts.isArrowFunction(expression_1) || ts.isFunctionExpression(expression_1) ? expression_1.body : undefined; + if (child) { + startNode(node); + addChildrenRecursively(child); + endNode(); + } + else { + addLeafNode(node); + } + break; + } + case 278 /* SyntaxKind.ExportSpecifier */: + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + case 178 /* SyntaxKind.IndexSignature */: + case 176 /* SyntaxKind.CallSignature */: + case 177 /* SyntaxKind.ConstructSignature */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + addLeafNode(node); + break; + case 210 /* SyntaxKind.CallExpression */: + case 223 /* SyntaxKind.BinaryExpression */: { + var special = ts.getAssignmentDeclarationKind(node); + switch (special) { + case 1 /* AssignmentDeclarationKind.ExportsProperty */: + case 2 /* AssignmentDeclarationKind.ModuleExports */: + addNodeWithRecursiveChild(node, node.right); + return; + case 6 /* AssignmentDeclarationKind.Prototype */: + case 3 /* AssignmentDeclarationKind.PrototypeProperty */: { + var binaryExpression = node; + var assignmentTarget = binaryExpression.left; + var prototypeAccess = special === 3 /* AssignmentDeclarationKind.PrototypeProperty */ ? + assignmentTarget.expression : + assignmentTarget; + var depth = 0; + var className = void 0; + // If we see a prototype assignment, start tracking the target as a class + // This is only done for simple classes not nested assignments. + if (ts.isIdentifier(prototypeAccess.expression)) { + addTrackedEs5Class(prototypeAccess.expression.text); + className = prototypeAccess.expression; + } + else { + _a = startNestedNodes(binaryExpression, prototypeAccess.expression), depth = _a[0], className = _a[1]; + } + if (special === 6 /* AssignmentDeclarationKind.Prototype */) { + if (ts.isObjectLiteralExpression(binaryExpression.right)) { + if (binaryExpression.right.properties.length > 0) { + startNode(binaryExpression, className); + ts.forEachChild(binaryExpression.right, addChildrenRecursively); + endNode(); + } + } + } + else if (ts.isFunctionExpression(binaryExpression.right) || ts.isArrowFunction(binaryExpression.right)) { + addNodeWithRecursiveChild(node, binaryExpression.right, className); + } + else { + startNode(binaryExpression, className); + addNodeWithRecursiveChild(node, binaryExpression.right, assignmentTarget.name); + endNode(); + } + endNestedNodes(depth); + return; + } + case 7 /* AssignmentDeclarationKind.ObjectDefinePropertyValue */: + case 9 /* AssignmentDeclarationKind.ObjectDefinePrototypeProperty */: { + var defineCall = node; + var className = special === 7 /* AssignmentDeclarationKind.ObjectDefinePropertyValue */ ? + defineCall.arguments[0] : + defineCall.arguments[0].expression; + var memberName = defineCall.arguments[1]; + var _j = startNestedNodes(node, className), depth = _j[0], classNameIdentifier = _j[1]; + startNode(node, classNameIdentifier); + startNode(node, ts.setTextRange(ts.factory.createIdentifier(memberName.text), memberName)); + addChildrenRecursively(node.arguments[2]); + endNode(); + endNode(); + endNestedNodes(depth); + return; + } + case 5 /* AssignmentDeclarationKind.Property */: { + var binaryExpression = node; + var assignmentTarget = binaryExpression.left; + var targetFunction = assignmentTarget.expression; + if (ts.isIdentifier(targetFunction) && ts.getElementOrPropertyAccessName(assignmentTarget) !== "prototype" && + trackedEs5Classes && trackedEs5Classes.has(targetFunction.text)) { + if (ts.isFunctionExpression(binaryExpression.right) || ts.isArrowFunction(binaryExpression.right)) { + addNodeWithRecursiveChild(node, binaryExpression.right, targetFunction); + } + else if (ts.isBindableStaticAccessExpression(assignmentTarget)) { + startNode(binaryExpression, targetFunction); + addNodeWithRecursiveChild(binaryExpression.left, binaryExpression.right, ts.getNameOrArgument(assignmentTarget)); + endNode(); + } + return; + } + break; + } + case 4 /* AssignmentDeclarationKind.ThisProperty */: + case 0 /* AssignmentDeclarationKind.None */: + case 8 /* AssignmentDeclarationKind.ObjectDefinePropertyExports */: + break; + default: + ts.Debug.assertNever(special); + } + } + // falls through + default: + if (ts.hasJSDocNodes(node)) { + ts.forEach(node.jsDoc, function (jsDoc) { + ts.forEach(jsDoc.tags, function (tag) { + if (ts.isJSDocTypeAlias(tag)) { + addLeafNode(tag); + } + }); + }); + } + ts.forEachChild(node, addChildrenRecursively); + } + } + /** Merge declarations of the same kind. */ + function mergeChildren(children, node) { + var nameToItems = new ts.Map(); + ts.filterMutate(children, function (child, index) { + var declName = child.name || ts.getNameOfDeclaration(child.node); + var name = declName && nodeText(declName); + if (!name) { + // Anonymous items are never merged. + return true; + } + var itemsWithSameName = nameToItems.get(name); + if (!itemsWithSameName) { + nameToItems.set(name, child); + return true; + } + if (itemsWithSameName instanceof Array) { + for (var _i = 0, itemsWithSameName_1 = itemsWithSameName; _i < itemsWithSameName_1.length; _i++) { + var itemWithSameName = itemsWithSameName_1[_i]; + if (tryMerge(itemWithSameName, child, index, node)) { + return false; + } + } + itemsWithSameName.push(child); + return true; + } + else { + var itemWithSameName = itemsWithSameName; + if (tryMerge(itemWithSameName, child, index, node)) { + return false; + } + nameToItems.set(name, [itemWithSameName, child]); + return true; + } + }); + } + var isEs5ClassMember = (_a = {}, + _a[5 /* AssignmentDeclarationKind.Property */] = true, + _a[3 /* AssignmentDeclarationKind.PrototypeProperty */] = true, + _a[7 /* AssignmentDeclarationKind.ObjectDefinePropertyValue */] = true, + _a[9 /* AssignmentDeclarationKind.ObjectDefinePrototypeProperty */] = true, + _a[0 /* AssignmentDeclarationKind.None */] = false, + _a[1 /* AssignmentDeclarationKind.ExportsProperty */] = false, + _a[2 /* AssignmentDeclarationKind.ModuleExports */] = false, + _a[8 /* AssignmentDeclarationKind.ObjectDefinePropertyExports */] = false, + _a[6 /* AssignmentDeclarationKind.Prototype */] = true, + _a[4 /* AssignmentDeclarationKind.ThisProperty */] = false, + _a); + function tryMergeEs5Class(a, b, bIndex, parent) { + function isPossibleConstructor(node) { + return ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node) || ts.isVariableDeclaration(node); + } + var bAssignmentDeclarationKind = ts.isBinaryExpression(b.node) || ts.isCallExpression(b.node) ? + ts.getAssignmentDeclarationKind(b.node) : + 0 /* AssignmentDeclarationKind.None */; + var aAssignmentDeclarationKind = ts.isBinaryExpression(a.node) || ts.isCallExpression(a.node) ? + ts.getAssignmentDeclarationKind(a.node) : + 0 /* AssignmentDeclarationKind.None */; + // We treat this as an es5 class and merge the nodes in in one of several cases + if ((isEs5ClassMember[bAssignmentDeclarationKind] && isEs5ClassMember[aAssignmentDeclarationKind]) // merge two class elements + || (isPossibleConstructor(a.node) && isEs5ClassMember[bAssignmentDeclarationKind]) // ctor function & member + || (isPossibleConstructor(b.node) && isEs5ClassMember[aAssignmentDeclarationKind]) // member & ctor function + || (ts.isClassDeclaration(a.node) && isSynthesized(a.node) && isEs5ClassMember[bAssignmentDeclarationKind]) // class (generated) & member + || (ts.isClassDeclaration(b.node) && isEs5ClassMember[aAssignmentDeclarationKind]) // member & class (generated) + || (ts.isClassDeclaration(a.node) && isSynthesized(a.node) && isPossibleConstructor(b.node)) // class (generated) & ctor + || (ts.isClassDeclaration(b.node) && isPossibleConstructor(a.node) && isSynthesized(a.node)) // ctor & class (generated) + ) { + var lastANode = a.additionalNodes && ts.lastOrUndefined(a.additionalNodes) || a.node; + if ((!ts.isClassDeclaration(a.node) && !ts.isClassDeclaration(b.node)) // If neither outline node is a class + || isPossibleConstructor(a.node) || isPossibleConstructor(b.node) // If either function is a constructor function + ) { + var ctorFunction = isPossibleConstructor(a.node) ? a.node : + isPossibleConstructor(b.node) ? b.node : + undefined; + if (ctorFunction !== undefined) { + var ctorNode = ts.setTextRange(ts.factory.createConstructorDeclaration(/* modifiers */ undefined, [], /* body */ undefined), ctorFunction); + var ctor = emptyNavigationBarNode(ctorNode); + ctor.indent = a.indent + 1; + ctor.children = a.node === ctorFunction ? a.children : b.children; + a.children = a.node === ctorFunction ? ts.concatenate([ctor], b.children || [b]) : ts.concatenate(a.children || [__assign({}, a)], [ctor]); + } + else { + if (a.children || b.children) { + a.children = ts.concatenate(a.children || [__assign({}, a)], b.children || [b]); + if (a.children) { + mergeChildren(a.children, a); + sortChildren(a.children); + } + } + } + lastANode = a.node = ts.setTextRange(ts.factory.createClassDeclaration( + /* modifiers */ undefined, a.name || ts.factory.createIdentifier("__class__"), + /* typeParameters */ undefined, + /* heritageClauses */ undefined, []), a.node); + } + else { + a.children = ts.concatenate(a.children, b.children); + if (a.children) { + mergeChildren(a.children, a); + } + } + var bNode = b.node; + // We merge if the outline node previous to b (bIndex - 1) is already part of the current class + // We do this so that statements between class members that do not generate outline nodes do not split up the class outline: + // Ex This should produce one outline node C: + // function C() {}; a = 1; C.prototype.m = function () {} + // Ex This will produce 3 outline nodes: C, a, C + // function C() {}; let a = 1; C.prototype.m = function () {} + if (parent.children[bIndex - 1].node.end === lastANode.end) { + ts.setTextRange(lastANode, { pos: lastANode.pos, end: bNode.end }); + } + else { + if (!a.additionalNodes) + a.additionalNodes = []; + a.additionalNodes.push(ts.setTextRange(ts.factory.createClassDeclaration( + /* modifiers */ undefined, a.name || ts.factory.createIdentifier("__class__"), + /* typeParameters */ undefined, + /* heritageClauses */ undefined, []), b.node)); + } + return true; + } + return bAssignmentDeclarationKind === 0 /* AssignmentDeclarationKind.None */ ? false : true; + } + function tryMerge(a, b, bIndex, parent) { + // const v = false as boolean; + if (tryMergeEs5Class(a, b, bIndex, parent)) { + return true; + } + if (shouldReallyMerge(a.node, b.node, parent)) { + merge(a, b); + return true; + } + return false; + } + /** a and b have the same name, but they may not be mergeable. */ + function shouldReallyMerge(a, b, parent) { + if (a.kind !== b.kind || a.parent !== b.parent && !(isOwnChild(a, parent) && isOwnChild(b, parent))) { + return false; + } + switch (a.kind) { + case 169 /* SyntaxKind.PropertyDeclaration */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + return ts.isStatic(a) === ts.isStatic(b); + case 264 /* SyntaxKind.ModuleDeclaration */: + return areSameModule(a, b) + && getFullyQualifiedModuleName(a) === getFullyQualifiedModuleName(b); + default: + return true; + } + } + function isSynthesized(node) { + return !!(node.flags & 8 /* NodeFlags.Synthesized */); + } + // We want to merge own children like `I` in in `module A { interface I {} } module A { interface I {} }` + // We don't want to merge unrelated children like `m` in `const o = { a: { m() {} }, b: { m() {} } };` + function isOwnChild(n, parent) { + var par = ts.isModuleBlock(n.parent) ? n.parent.parent : n.parent; + return par === parent.node || ts.contains(parent.additionalNodes, par); + } + // We use 1 NavNode to represent 'A.B.C', but there are multiple source nodes. + // Only merge module nodes that have the same chain. Don't merge 'A.B.C' with 'A'! + function areSameModule(a, b) { + if (!a.body || !b.body) { + return a.body === b.body; + } + return a.body.kind === b.body.kind && (a.body.kind !== 264 /* SyntaxKind.ModuleDeclaration */ || areSameModule(a.body, b.body)); + } + /** Merge source into target. Source should be thrown away after this is called. */ + function merge(target, source) { + var _a; + target.additionalNodes = target.additionalNodes || []; + target.additionalNodes.push(source.node); + if (source.additionalNodes) { + (_a = target.additionalNodes).push.apply(_a, source.additionalNodes); + } + target.children = ts.concatenate(target.children, source.children); + if (target.children) { + mergeChildren(target.children, target); + sortChildren(target.children); + } + } + /** Recursively ensure that each NavNode's children are in sorted order. */ + function sortChildren(children) { + children.sort(compareChildren); + } + function compareChildren(child1, child2) { + return ts.compareStringsCaseSensitiveUI(tryGetName(child1.node), tryGetName(child2.node)) // TODO: GH#18217 + || ts.compareValues(navigationBarNodeKind(child1), navigationBarNodeKind(child2)); + } + /** + * This differs from getItemName because this is just used for sorting. + * We only sort nodes by name that have a more-or-less "direct" name, as opposed to `new()` and the like. + * So `new()` can still come before an `aardvark` method. + */ + function tryGetName(node) { + if (node.kind === 264 /* SyntaxKind.ModuleDeclaration */) { + return getModuleName(node); + } + var declName = ts.getNameOfDeclaration(node); + if (declName && ts.isPropertyName(declName)) { + var propertyName = ts.getPropertyNameForPropertyNameNode(declName); + return propertyName && ts.unescapeLeadingUnderscores(propertyName); + } + switch (node.kind) { + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + case 228 /* SyntaxKind.ClassExpression */: + return getFunctionOrClassName(node); + default: + return undefined; + } + } + function getItemName(node, name) { + if (node.kind === 264 /* SyntaxKind.ModuleDeclaration */) { + return cleanText(getModuleName(node)); + } + if (name) { + var text = ts.isIdentifier(name) ? name.text + : ts.isElementAccessExpression(name) ? "[".concat(nodeText(name.argumentExpression), "]") + : nodeText(name); + if (text.length > 0) { + return cleanText(text); + } + } + switch (node.kind) { + case 308 /* SyntaxKind.SourceFile */: + var sourceFile = node; + return ts.isExternalModule(sourceFile) + ? "\"".concat(ts.escapeString(ts.getBaseFileName(ts.removeFileExtension(ts.normalizePath(sourceFile.fileName)))), "\"") + : ""; + case 274 /* SyntaxKind.ExportAssignment */: + return ts.isExportAssignment(node) && node.isExportEquals ? "export=" /* InternalSymbolName.ExportEquals */ : "default" /* InternalSymbolName.Default */; + case 216 /* SyntaxKind.ArrowFunction */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + if (ts.getSyntacticModifierFlags(node) & 1024 /* ModifierFlags.Default */) { + return "default"; + } + // We may get a string with newlines or other whitespace in the case of an object dereference + // (eg: "app\n.onactivated"), so we should remove the whitespace for readability in the + // navigation bar. + return getFunctionOrClassName(node); + case 173 /* SyntaxKind.Constructor */: + return "constructor"; + case 177 /* SyntaxKind.ConstructSignature */: + return "new()"; + case 176 /* SyntaxKind.CallSignature */: + return "()"; + case 178 /* SyntaxKind.IndexSignature */: + return "[]"; + default: + return ""; + } + } + /** Flattens the NavNode tree to a list of items to appear in the primary navbar menu. */ + function primaryNavBarMenuItems(root) { + // The primary (middle) navbar menu displays the general code navigation hierarchy, similar to the navtree. + // The secondary (right) navbar menu displays the child items of whichever primary item is selected. + // Some less interesting items without their own child navigation items (e.g. a local variable declaration) only show up in the secondary menu. + var primaryNavBarMenuItems = []; + function recur(item) { + if (shouldAppearInPrimaryNavBarMenu(item)) { + primaryNavBarMenuItems.push(item); + if (item.children) { + for (var _i = 0, _a = item.children; _i < _a.length; _i++) { + var child = _a[_i]; + recur(child); + } + } + } + } + recur(root); + return primaryNavBarMenuItems; + /** Determines if a node should appear in the primary navbar menu. */ + function shouldAppearInPrimaryNavBarMenu(item) { + // Items with children should always appear in the primary navbar menu. + if (item.children) { + return true; + } + // Some nodes are otherwise important enough to always include in the primary navigation menu. + switch (navigationBarNodeKind(item)) { + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 264 /* SyntaxKind.ModuleDeclaration */: + case 308 /* SyntaxKind.SourceFile */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 348 /* SyntaxKind.JSDocTypedefTag */: + case 341 /* SyntaxKind.JSDocCallbackTag */: + return true; + case 216 /* SyntaxKind.ArrowFunction */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + return isTopLevelFunctionDeclaration(item); + default: + return false; + } + function isTopLevelFunctionDeclaration(item) { + if (!item.node.body) { + return false; + } + switch (navigationBarNodeKind(item.parent)) { + case 265 /* SyntaxKind.ModuleBlock */: + case 308 /* SyntaxKind.SourceFile */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 173 /* SyntaxKind.Constructor */: + return true; + default: + return false; + } + } + } + } + function convertToTree(n) { + return { + text: getItemName(n.node, n.name), + kind: ts.getNodeKind(n.node), + kindModifiers: getModifiers(n.node), + spans: getSpans(n), + nameSpan: n.name && getNodeSpan(n.name), + childItems: ts.map(n.children, convertToTree) + }; + } + function convertToPrimaryNavBarMenuItem(n) { + return { + text: getItemName(n.node, n.name), + kind: ts.getNodeKind(n.node), + kindModifiers: getModifiers(n.node), + spans: getSpans(n), + childItems: ts.map(n.children, convertToSecondaryNavBarMenuItem) || emptyChildItemArray, + indent: n.indent, + bolded: false, + grayed: false + }; + function convertToSecondaryNavBarMenuItem(n) { + return { + text: getItemName(n.node, n.name), + kind: ts.getNodeKind(n.node), + kindModifiers: ts.getNodeModifiers(n.node), + spans: getSpans(n), + childItems: emptyChildItemArray, + indent: 0, + bolded: false, + grayed: false + }; + } + } + function getSpans(n) { + var spans = [getNodeSpan(n.node)]; + if (n.additionalNodes) { + for (var _i = 0, _a = n.additionalNodes; _i < _a.length; _i++) { + var node = _a[_i]; + spans.push(getNodeSpan(node)); + } + } + return spans; + } + function getModuleName(moduleDeclaration) { + // We want to maintain quotation marks. + if (ts.isAmbientModule(moduleDeclaration)) { + return ts.getTextOfNode(moduleDeclaration.name); + } + return getFullyQualifiedModuleName(moduleDeclaration); + } + function getFullyQualifiedModuleName(moduleDeclaration) { + // Otherwise, we need to aggregate each identifier to build up the qualified name. + var result = [ts.getTextOfIdentifierOrLiteral(moduleDeclaration.name)]; + while (moduleDeclaration.body && moduleDeclaration.body.kind === 264 /* SyntaxKind.ModuleDeclaration */) { + moduleDeclaration = moduleDeclaration.body; + result.push(ts.getTextOfIdentifierOrLiteral(moduleDeclaration.name)); + } + return result.join("."); + } + /** + * For 'module A.B.C', we want to get the node for 'C'. + * We store 'A' as associated with a NavNode, and use getModuleName to traverse down again. + */ + function getInteriorModule(decl) { + return decl.body && ts.isModuleDeclaration(decl.body) ? getInteriorModule(decl.body) : decl; + } + function isComputedProperty(member) { + return !member.name || member.name.kind === 164 /* SyntaxKind.ComputedPropertyName */; + } + function getNodeSpan(node) { + return node.kind === 308 /* SyntaxKind.SourceFile */ ? ts.createTextSpanFromRange(node) : ts.createTextSpanFromNode(node, curSourceFile); + } + function getModifiers(node) { + if (node.parent && node.parent.kind === 257 /* SyntaxKind.VariableDeclaration */) { + node = node.parent; + } + return ts.getNodeModifiers(node); + } + function getFunctionOrClassName(node) { + var parent = node.parent; + if (node.name && ts.getFullWidth(node.name) > 0) { + return cleanText(ts.declarationNameToString(node.name)); + } + // See if it is a var initializer. If so, use the var name. + else if (ts.isVariableDeclaration(parent)) { + return cleanText(ts.declarationNameToString(parent.name)); + } + // See if it is of the form " = function(){...}". If so, use the text from the left-hand side. + else if (ts.isBinaryExpression(parent) && parent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */) { + return nodeText(parent.left).replace(whiteSpaceRegex, ""); + } + // See if it is a property assignment, and if so use the property name + else if (ts.isPropertyAssignment(parent)) { + return nodeText(parent.name); + } + // Default exports are named "default" + else if (ts.getSyntacticModifierFlags(node) & 1024 /* ModifierFlags.Default */) { + return "default"; + } + else if (ts.isClassLike(node)) { + return ""; + } + else if (ts.isCallExpression(parent)) { + var name = getCalledExpressionName(parent.expression); + if (name !== undefined) { + name = cleanText(name); + if (name.length > maxLength) { + return "".concat(name, " callback"); + } + var args = cleanText(ts.mapDefined(parent.arguments, function (a) { return ts.isStringLiteralLike(a) ? a.getText(curSourceFile) : undefined; }).join(", ")); + return "".concat(name, "(").concat(args, ") callback"); + } + } + return ""; + } + // See also 'tryGetPropertyAccessOrIdentifierToString' + function getCalledExpressionName(expr) { + if (ts.isIdentifier(expr)) { + return expr.text; + } + else if (ts.isPropertyAccessExpression(expr)) { + var left = getCalledExpressionName(expr.expression); + var right = expr.name.text; + return left === undefined ? right : "".concat(left, ".").concat(right); + } + else { + return undefined; + } + } + function isFunctionOrClassExpression(node) { + switch (node.kind) { + case 216 /* SyntaxKind.ArrowFunction */: + case 215 /* SyntaxKind.FunctionExpression */: + case 228 /* SyntaxKind.ClassExpression */: + return true; + default: + return false; + } + } + function cleanText(text) { + // Truncate to maximum amount of characters as we don't want to do a big replace operation. + text = text.length > maxLength ? text.substring(0, maxLength) + "..." : text; + // Replaces ECMAScript line terminators and removes the trailing `\` from each line: + // \n - Line Feed + // \r - Carriage Return + // \u2028 - Line separator + // \u2029 - Paragraph separator + return text.replace(/\\?(\r?\n|\r|\u2028|\u2029)/g, ""); + } + })(NavigationBar = ts.NavigationBar || (ts.NavigationBar = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var OrganizeImports; + (function (OrganizeImports) { + /** + * Organize imports by: + * 1) Removing unused imports + * 2) Coalescing imports from the same module + * 3) Sorting imports + */ + function organizeImports(sourceFile, formatContext, host, program, preferences, mode) { + var changeTracker = ts.textChanges.ChangeTracker.fromContext({ host: host, formatContext: formatContext, preferences: preferences }); + var shouldSort = mode === "SortAndCombine" /* OrganizeImportsMode.SortAndCombine */ || mode === "All" /* OrganizeImportsMode.All */; + var shouldCombine = shouldSort; // These are currently inseparable, but I draw a distinction for clarity and in case we add modes in the future. + var shouldRemove = mode === "RemoveUnused" /* OrganizeImportsMode.RemoveUnused */ || mode === "All" /* OrganizeImportsMode.All */; + var maybeRemove = shouldRemove ? removeUnusedImports : ts.identity; + var maybeCoalesce = shouldCombine ? coalesceImports : ts.identity; + var processImportsOfSameModuleSpecifier = function (importGroup) { + var processedDeclarations = maybeCoalesce(maybeRemove(importGroup, sourceFile, program)); + return shouldSort + ? ts.stableSort(processedDeclarations, function (s1, s2) { return compareImportsOrRequireStatements(s1, s2); }) + : processedDeclarations; + }; + // All of the old ImportDeclarations in the file, in syntactic order. + var topLevelImportGroupDecls = groupImportsByNewlineContiguous(sourceFile, sourceFile.statements.filter(ts.isImportDeclaration)); + topLevelImportGroupDecls.forEach(function (importGroupDecl) { return organizeImportsWorker(importGroupDecl, processImportsOfSameModuleSpecifier); }); + // Exports are always used + if (mode !== "RemoveUnused" /* OrganizeImportsMode.RemoveUnused */) { + // All of the old ExportDeclarations in the file, in syntactic order. + var topLevelExportDecls = sourceFile.statements.filter(ts.isExportDeclaration); + organizeImportsWorker(topLevelExportDecls, coalesceExports); + } + for (var _i = 0, _a = sourceFile.statements.filter(ts.isAmbientModule); _i < _a.length; _i++) { + var ambientModule = _a[_i]; + if (!ambientModule.body) + continue; + var ambientModuleImportGroupDecls = groupImportsByNewlineContiguous(sourceFile, ambientModule.body.statements.filter(ts.isImportDeclaration)); + ambientModuleImportGroupDecls.forEach(function (importGroupDecl) { return organizeImportsWorker(importGroupDecl, processImportsOfSameModuleSpecifier); }); + // Exports are always used + if (mode !== "RemoveUnused" /* OrganizeImportsMode.RemoveUnused */) { + var ambientModuleExportDecls = ambientModule.body.statements.filter(ts.isExportDeclaration); + organizeImportsWorker(ambientModuleExportDecls, coalesceExports); + } + } + return changeTracker.getChanges(); + function organizeImportsWorker(oldImportDecls, coalesce) { + if (ts.length(oldImportDecls) === 0) { + return; + } + // Special case: normally, we'd expect leading and trailing trivia to follow each import + // around as it's sorted. However, we do not want this to happen for leading trivia + // on the first import because it is probably the header comment for the file. + // Consider: we could do a more careful check that this trivia is actually a header, + // but the consequences of being wrong are very minor. + ts.suppressLeadingTrivia(oldImportDecls[0]); + var oldImportGroups = shouldCombine + ? ts.group(oldImportDecls, function (importDecl) { return getExternalModuleName(importDecl.moduleSpecifier); }) + : [oldImportDecls]; + var sortedImportGroups = shouldSort + ? ts.stableSort(oldImportGroups, function (group1, group2) { return compareModuleSpecifiers(group1[0].moduleSpecifier, group2[0].moduleSpecifier); }) + : oldImportGroups; + var newImportDecls = ts.flatMap(sortedImportGroups, function (importGroup) { + return getExternalModuleName(importGroup[0].moduleSpecifier) + ? coalesce(importGroup) + : importGroup; + }); + // Delete all nodes if there are no imports. + if (newImportDecls.length === 0) { + // Consider the first node to have trailingTrivia as we want to exclude the + // "header" comment. + changeTracker.deleteNodes(sourceFile, oldImportDecls, { + trailingTriviaOption: ts.textChanges.TrailingTriviaOption.Include, + }, /*hasTrailingComment*/ true); + } + else { + // Note: Delete the surrounding trivia because it will have been retained in newImportDecls. + var replaceOptions = { + leadingTriviaOption: ts.textChanges.LeadingTriviaOption.Exclude, + trailingTriviaOption: ts.textChanges.TrailingTriviaOption.Include, + suffix: ts.getNewLineOrDefaultFromHost(host, formatContext.options), + }; + changeTracker.replaceNodeWithNodes(sourceFile, oldImportDecls[0], newImportDecls, replaceOptions); + var hasTrailingComment = changeTracker.nodeHasTrailingComment(sourceFile, oldImportDecls[0], replaceOptions); + changeTracker.deleteNodes(sourceFile, oldImportDecls.slice(1), { + trailingTriviaOption: ts.textChanges.TrailingTriviaOption.Include, + }, hasTrailingComment); + } + } + } + OrganizeImports.organizeImports = organizeImports; + function groupImportsByNewlineContiguous(sourceFile, importDecls) { + var scanner = ts.createScanner(sourceFile.languageVersion, /*skipTrivia*/ false, sourceFile.languageVariant); + var groupImports = []; + var groupIndex = 0; + for (var _i = 0, importDecls_1 = importDecls; _i < importDecls_1.length; _i++) { + var topLevelImportDecl = importDecls_1[_i]; + if (isNewGroup(sourceFile, topLevelImportDecl, scanner)) { + groupIndex++; + } + if (!groupImports[groupIndex]) { + groupImports[groupIndex] = []; + } + groupImports[groupIndex].push(topLevelImportDecl); + } + return groupImports; + } + // a new group is created if an import includes at least two new line + // new line from multi-line comment doesn't count + function isNewGroup(sourceFile, topLevelImportDecl, scanner) { + var startPos = topLevelImportDecl.getFullStart(); + var endPos = topLevelImportDecl.getStart(); + scanner.setText(sourceFile.text, startPos, endPos - startPos); + var numberOfNewLines = 0; + while (scanner.getTokenPos() < endPos) { + var tokenKind = scanner.scan(); + if (tokenKind === 4 /* SyntaxKind.NewLineTrivia */) { + numberOfNewLines++; + if (numberOfNewLines >= 2) { + return true; + } + } + } + return false; + } + function removeUnusedImports(oldImports, sourceFile, program) { + var typeChecker = program.getTypeChecker(); + var compilerOptions = program.getCompilerOptions(); + var jsxNamespace = typeChecker.getJsxNamespace(sourceFile); + var jsxFragmentFactory = typeChecker.getJsxFragmentFactory(sourceFile); + var jsxElementsPresent = !!(sourceFile.transformFlags & 2 /* TransformFlags.ContainsJsx */); + var usedImports = []; + for (var _i = 0, oldImports_1 = oldImports; _i < oldImports_1.length; _i++) { + var importDecl = oldImports_1[_i]; + var importClause = importDecl.importClause, moduleSpecifier = importDecl.moduleSpecifier; + if (!importClause) { + // Imports without import clauses are assumed to be included for their side effects and are not removed. + usedImports.push(importDecl); + continue; + } + var name = importClause.name, namedBindings = importClause.namedBindings; + // Default import + if (name && !isDeclarationUsed(name)) { + name = undefined; + } + if (namedBindings) { + if (ts.isNamespaceImport(namedBindings)) { + // Namespace import + if (!isDeclarationUsed(namedBindings.name)) { + namedBindings = undefined; + } + } + else { + // List of named imports + var newElements = namedBindings.elements.filter(function (e) { return isDeclarationUsed(e.name); }); + if (newElements.length < namedBindings.elements.length) { + namedBindings = newElements.length + ? ts.factory.updateNamedImports(namedBindings, newElements) + : undefined; + } + } + } + if (name || namedBindings) { + usedImports.push(updateImportDeclarationAndClause(importDecl, name, namedBindings)); + } + // If a module is imported to be augmented, it’s used + else if (hasModuleDeclarationMatchingSpecifier(sourceFile, moduleSpecifier)) { + // If we’re in a declaration file, it’s safe to remove the import clause from it + if (sourceFile.isDeclarationFile) { + usedImports.push(ts.factory.createImportDeclaration(importDecl.modifiers, + /*importClause*/ undefined, moduleSpecifier, + /*assertClause*/ undefined)); + } + // If we’re not in a declaration file, we can’t remove the import clause even though + // the imported symbols are unused, because removing them makes it look like the import + // declaration has side effects, which will cause it to be preserved in the JS emit. + else { + usedImports.push(importDecl); + } + } + } + return usedImports; + function isDeclarationUsed(identifier) { + // The JSX factory symbol is always used if JSX elements are present - even if they are not allowed. + return jsxElementsPresent && (identifier.text === jsxNamespace || jsxFragmentFactory && identifier.text === jsxFragmentFactory) && ts.jsxModeNeedsExplicitImport(compilerOptions.jsx) || + ts.FindAllReferences.Core.isSymbolReferencedInFile(identifier, typeChecker, sourceFile); + } + } + function hasModuleDeclarationMatchingSpecifier(sourceFile, moduleSpecifier) { + var moduleSpecifierText = ts.isStringLiteral(moduleSpecifier) && moduleSpecifier.text; + return ts.isString(moduleSpecifierText) && ts.some(sourceFile.moduleAugmentations, function (moduleName) { + return ts.isStringLiteral(moduleName) + && moduleName.text === moduleSpecifierText; + }); + } + function getExternalModuleName(specifier) { + return specifier !== undefined && ts.isStringLiteralLike(specifier) + ? specifier.text + : undefined; + } + // Internal for testing + /** + * @param importGroup a list of ImportDeclarations, all with the same module name. + */ + function coalesceImports(importGroup) { + var _a; + if (importGroup.length === 0) { + return importGroup; + } + var _b = getCategorizedImports(importGroup), importWithoutClause = _b.importWithoutClause, typeOnlyImports = _b.typeOnlyImports, regularImports = _b.regularImports; + var coalescedImports = []; + if (importWithoutClause) { + coalescedImports.push(importWithoutClause); + } + for (var _i = 0, _c = [regularImports, typeOnlyImports]; _i < _c.length; _i++) { + var group_2 = _c[_i]; + var isTypeOnly = group_2 === typeOnlyImports; + var defaultImports = group_2.defaultImports, namespaceImports = group_2.namespaceImports, namedImports = group_2.namedImports; + // Normally, we don't combine default and namespace imports, but it would be silly to + // produce two import declarations in this special case. + if (!isTypeOnly && defaultImports.length === 1 && namespaceImports.length === 1 && namedImports.length === 0) { + // Add the namespace import to the existing default ImportDeclaration. + var defaultImport = defaultImports[0]; + coalescedImports.push(updateImportDeclarationAndClause(defaultImport, defaultImport.importClause.name, namespaceImports[0].importClause.namedBindings)); // TODO: GH#18217 + continue; + } + var sortedNamespaceImports = ts.stableSort(namespaceImports, function (i1, i2) { + return compareIdentifiers(i1.importClause.namedBindings.name, i2.importClause.namedBindings.name); + }); // TODO: GH#18217 + for (var _d = 0, sortedNamespaceImports_1 = sortedNamespaceImports; _d < sortedNamespaceImports_1.length; _d++) { + var namespaceImport = sortedNamespaceImports_1[_d]; + // Drop the name, if any + coalescedImports.push(updateImportDeclarationAndClause(namespaceImport, /*name*/ undefined, namespaceImport.importClause.namedBindings)); // TODO: GH#18217 + } + if (defaultImports.length === 0 && namedImports.length === 0) { + continue; + } + var newDefaultImport = void 0; + var newImportSpecifiers = []; + if (defaultImports.length === 1) { + newDefaultImport = defaultImports[0].importClause.name; + } + else { + for (var _e = 0, defaultImports_1 = defaultImports; _e < defaultImports_1.length; _e++) { + var defaultImport = defaultImports_1[_e]; + newImportSpecifiers.push(ts.factory.createImportSpecifier(/*isTypeOnly*/ false, ts.factory.createIdentifier("default"), defaultImport.importClause.name)); // TODO: GH#18217 + } + } + newImportSpecifiers.push.apply(newImportSpecifiers, getNewImportSpecifiers(namedImports)); + var sortedImportSpecifiers = sortSpecifiers(newImportSpecifiers); + var importDecl = defaultImports.length > 0 + ? defaultImports[0] + : namedImports[0]; + var newNamedImports = sortedImportSpecifiers.length === 0 + ? newDefaultImport + ? undefined + : ts.factory.createNamedImports(ts.emptyArray) + : namedImports.length === 0 + ? ts.factory.createNamedImports(sortedImportSpecifiers) + : ts.factory.updateNamedImports(namedImports[0].importClause.namedBindings, sortedImportSpecifiers); // TODO: GH#18217 + // Type-only imports are not allowed to mix default, namespace, and named imports in any combination. + // We could rewrite a default import as a named import (`import { default as name }`), but we currently + // choose not to as a stylistic preference. + if (isTypeOnly && newDefaultImport && newNamedImports) { + coalescedImports.push(updateImportDeclarationAndClause(importDecl, newDefaultImport, /*namedBindings*/ undefined)); + coalescedImports.push(updateImportDeclarationAndClause((_a = namedImports[0]) !== null && _a !== void 0 ? _a : importDecl, /*name*/ undefined, newNamedImports)); + } + else { + coalescedImports.push(updateImportDeclarationAndClause(importDecl, newDefaultImport, newNamedImports)); + } + } + return coalescedImports; + } + OrganizeImports.coalesceImports = coalesceImports; + /* + * Returns entire import declarations because they may already have been rewritten and + * may lack parent pointers. The desired parts can easily be recovered based on the + * categorization. + * + * NB: There may be overlap between `defaultImports` and `namespaceImports`/`namedImports`. + */ + function getCategorizedImports(importGroup) { + var importWithoutClause; + var typeOnlyImports = { defaultImports: [], namespaceImports: [], namedImports: [] }; + var regularImports = { defaultImports: [], namespaceImports: [], namedImports: [] }; + for (var _i = 0, importGroup_1 = importGroup; _i < importGroup_1.length; _i++) { + var importDeclaration = importGroup_1[_i]; + if (importDeclaration.importClause === undefined) { + // Only the first such import is interesting - the others are redundant. + // Note: Unfortunately, we will lose trivia that was on this node. + importWithoutClause = importWithoutClause || importDeclaration; + continue; + } + var group_3 = importDeclaration.importClause.isTypeOnly ? typeOnlyImports : regularImports; + var _a = importDeclaration.importClause, name = _a.name, namedBindings = _a.namedBindings; + if (name) { + group_3.defaultImports.push(importDeclaration); + } + if (namedBindings) { + if (ts.isNamespaceImport(namedBindings)) { + group_3.namespaceImports.push(importDeclaration); + } + else { + group_3.namedImports.push(importDeclaration); + } + } + } + return { + importWithoutClause: importWithoutClause, + typeOnlyImports: typeOnlyImports, + regularImports: regularImports, + }; + } + // Internal for testing + /** + * @param exportGroup a list of ExportDeclarations, all with the same module name. + */ + function coalesceExports(exportGroup) { + if (exportGroup.length === 0) { + return exportGroup; + } + var _a = getCategorizedExports(exportGroup), exportWithoutClause = _a.exportWithoutClause, namedExports = _a.namedExports, typeOnlyExports = _a.typeOnlyExports; + var coalescedExports = []; + if (exportWithoutClause) { + coalescedExports.push(exportWithoutClause); + } + for (var _i = 0, _b = [namedExports, typeOnlyExports]; _i < _b.length; _i++) { + var exportGroup_1 = _b[_i]; + if (exportGroup_1.length === 0) { + continue; + } + var newExportSpecifiers = []; + newExportSpecifiers.push.apply(newExportSpecifiers, ts.flatMap(exportGroup_1, function (i) { return i.exportClause && ts.isNamedExports(i.exportClause) ? i.exportClause.elements : ts.emptyArray; })); + var sortedExportSpecifiers = sortSpecifiers(newExportSpecifiers); + var exportDecl = exportGroup_1[0]; + coalescedExports.push(ts.factory.updateExportDeclaration(exportDecl, exportDecl.modifiers, exportDecl.isTypeOnly, exportDecl.exportClause && (ts.isNamedExports(exportDecl.exportClause) ? + ts.factory.updateNamedExports(exportDecl.exportClause, sortedExportSpecifiers) : + ts.factory.updateNamespaceExport(exportDecl.exportClause, exportDecl.exportClause.name)), exportDecl.moduleSpecifier, exportDecl.assertClause)); + } + return coalescedExports; + /* + * Returns entire export declarations because they may already have been rewritten and + * may lack parent pointers. The desired parts can easily be recovered based on the + * categorization. + */ + function getCategorizedExports(exportGroup) { + var exportWithoutClause; + var namedExports = []; + var typeOnlyExports = []; + for (var _i = 0, exportGroup_2 = exportGroup; _i < exportGroup_2.length; _i++) { + var exportDeclaration = exportGroup_2[_i]; + if (exportDeclaration.exportClause === undefined) { + // Only the first such export is interesting - the others are redundant. + // Note: Unfortunately, we will lose trivia that was on this node. + exportWithoutClause = exportWithoutClause || exportDeclaration; + } + else if (exportDeclaration.isTypeOnly) { + typeOnlyExports.push(exportDeclaration); + } + else { + namedExports.push(exportDeclaration); + } + } + return { + exportWithoutClause: exportWithoutClause, + namedExports: namedExports, + typeOnlyExports: typeOnlyExports, + }; + } + } + OrganizeImports.coalesceExports = coalesceExports; + function updateImportDeclarationAndClause(importDeclaration, name, namedBindings) { + return ts.factory.updateImportDeclaration(importDeclaration, importDeclaration.modifiers, ts.factory.updateImportClause(importDeclaration.importClause, importDeclaration.importClause.isTypeOnly, name, namedBindings), // TODO: GH#18217 + importDeclaration.moduleSpecifier, importDeclaration.assertClause); + } + function sortSpecifiers(specifiers) { + return ts.stableSort(specifiers, compareImportOrExportSpecifiers); + } + function compareImportOrExportSpecifiers(s1, s2) { + return ts.compareBooleans(s1.isTypeOnly, s2.isTypeOnly) + || compareIdentifiers(s1.propertyName || s1.name, s2.propertyName || s2.name) + || compareIdentifiers(s1.name, s2.name); + } + OrganizeImports.compareImportOrExportSpecifiers = compareImportOrExportSpecifiers; + /* internal */ // Exported for testing + function compareModuleSpecifiers(m1, m2) { + var name1 = m1 === undefined ? undefined : getExternalModuleName(m1); + var name2 = m2 === undefined ? undefined : getExternalModuleName(m2); + return ts.compareBooleans(name1 === undefined, name2 === undefined) || + ts.compareBooleans(ts.isExternalModuleNameRelative(name1), ts.isExternalModuleNameRelative(name2)) || + ts.compareStringsCaseInsensitive(name1, name2); + } + OrganizeImports.compareModuleSpecifiers = compareModuleSpecifiers; + function compareIdentifiers(s1, s2) { + return ts.compareStringsCaseInsensitive(s1.text, s2.text); + } + function getModuleSpecifierExpression(declaration) { + var _a; + switch (declaration.kind) { + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return (_a = ts.tryCast(declaration.moduleReference, ts.isExternalModuleReference)) === null || _a === void 0 ? void 0 : _a.expression; + case 269 /* SyntaxKind.ImportDeclaration */: + return declaration.moduleSpecifier; + case 240 /* SyntaxKind.VariableStatement */: + return declaration.declarationList.declarations[0].initializer.arguments[0]; + } + } + function importsAreSorted(imports) { + return ts.arrayIsSorted(imports, compareImportsOrRequireStatements); + } + OrganizeImports.importsAreSorted = importsAreSorted; + function importSpecifiersAreSorted(imports) { + return ts.arrayIsSorted(imports, compareImportOrExportSpecifiers); + } + OrganizeImports.importSpecifiersAreSorted = importSpecifiersAreSorted; + function getImportDeclarationInsertionIndex(sortedImports, newImport) { + var index = ts.binarySearch(sortedImports, newImport, ts.identity, compareImportsOrRequireStatements); + return index < 0 ? ~index : index; + } + OrganizeImports.getImportDeclarationInsertionIndex = getImportDeclarationInsertionIndex; + function getImportSpecifierInsertionIndex(sortedImports, newImport) { + var index = ts.binarySearch(sortedImports, newImport, ts.identity, compareImportOrExportSpecifiers); + return index < 0 ? ~index : index; + } + OrganizeImports.getImportSpecifierInsertionIndex = getImportSpecifierInsertionIndex; + function compareImportsOrRequireStatements(s1, s2) { + return compareModuleSpecifiers(getModuleSpecifierExpression(s1), getModuleSpecifierExpression(s2)) || compareImportKind(s1, s2); + } + OrganizeImports.compareImportsOrRequireStatements = compareImportsOrRequireStatements; + function compareImportKind(s1, s2) { + return ts.compareValues(getImportKindOrder(s1), getImportKindOrder(s2)); + } + // 1. Side-effect imports + // 2. Type-only imports + // 3. Namespace imports + // 4. Default imports + // 5. Named imports + // 6. ImportEqualsDeclarations + // 7. Require variable statements + function getImportKindOrder(s1) { + var _a; + switch (s1.kind) { + case 269 /* SyntaxKind.ImportDeclaration */: + if (!s1.importClause) + return 0; + if (s1.importClause.isTypeOnly) + return 1; + if (((_a = s1.importClause.namedBindings) === null || _a === void 0 ? void 0 : _a.kind) === 271 /* SyntaxKind.NamespaceImport */) + return 2; + if (s1.importClause.name) + return 3; + return 4; + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return 5; + case 240 /* SyntaxKind.VariableStatement */: + return 6; + } + } + function getNewImportSpecifiers(namedImports) { + return ts.flatMap(namedImports, function (namedImport) { + return ts.map(tryGetNamedBindingElements(namedImport), function (importSpecifier) { + return importSpecifier.name && importSpecifier.propertyName && importSpecifier.name.escapedText === importSpecifier.propertyName.escapedText + ? ts.factory.updateImportSpecifier(importSpecifier, importSpecifier.isTypeOnly, /*propertyName*/ undefined, importSpecifier.name) + : importSpecifier; + }); + }); + } + function tryGetNamedBindingElements(namedImport) { + var _a; + return ((_a = namedImport.importClause) === null || _a === void 0 ? void 0 : _a.namedBindings) && ts.isNamedImports(namedImport.importClause.namedBindings) + ? namedImport.importClause.namedBindings.elements + : undefined; + } + })(OrganizeImports = ts.OrganizeImports || (ts.OrganizeImports = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var OutliningElementsCollector; + (function (OutliningElementsCollector) { + function collectElements(sourceFile, cancellationToken) { + var res = []; + addNodeOutliningSpans(sourceFile, cancellationToken, res); + addRegionOutliningSpans(sourceFile, res); + return res.sort(function (span1, span2) { return span1.textSpan.start - span2.textSpan.start; }); + } + OutliningElementsCollector.collectElements = collectElements; + function addNodeOutliningSpans(sourceFile, cancellationToken, out) { + var depthRemaining = 40; + var current = 0; + // Includes the EOF Token so that comments which aren't attached to statements are included + var statements = __spreadArray(__spreadArray([], sourceFile.statements, true), [sourceFile.endOfFileToken], false); + var n = statements.length; + while (current < n) { + while (current < n && !ts.isAnyImportSyntax(statements[current])) { + visitNonImportNode(statements[current]); + current++; + } + if (current === n) + break; + var firstImport = current; + while (current < n && ts.isAnyImportSyntax(statements[current])) { + addOutliningForLeadingCommentsForNode(statements[current], sourceFile, cancellationToken, out); + current++; + } + var lastImport = current - 1; + if (lastImport !== firstImport) { + out.push(createOutliningSpanFromBounds(ts.findChildOfKind(statements[firstImport], 100 /* SyntaxKind.ImportKeyword */, sourceFile).getStart(sourceFile), statements[lastImport].getEnd(), "imports" /* OutliningSpanKind.Imports */)); + } + } + function visitNonImportNode(n) { + var _a; + if (depthRemaining === 0) + return; + cancellationToken.throwIfCancellationRequested(); + if (ts.isDeclaration(n) || ts.isVariableStatement(n) || ts.isReturnStatement(n) || ts.isCallOrNewExpression(n) || n.kind === 1 /* SyntaxKind.EndOfFileToken */) { + addOutliningForLeadingCommentsForNode(n, sourceFile, cancellationToken, out); + } + if (ts.isFunctionLike(n) && ts.isBinaryExpression(n.parent) && ts.isPropertyAccessExpression(n.parent.left)) { + addOutliningForLeadingCommentsForNode(n.parent.left, sourceFile, cancellationToken, out); + } + if (ts.isBlock(n) || ts.isModuleBlock(n)) { + addOutliningForLeadingCommentsForPos(n.statements.end, sourceFile, cancellationToken, out); + } + if (ts.isClassLike(n) || ts.isInterfaceDeclaration(n)) { + addOutliningForLeadingCommentsForPos(n.members.end, sourceFile, cancellationToken, out); + } + var span = getOutliningSpanForNode(n, sourceFile); + if (span) + out.push(span); + depthRemaining--; + if (ts.isCallExpression(n)) { + depthRemaining++; + visitNonImportNode(n.expression); + depthRemaining--; + n.arguments.forEach(visitNonImportNode); + (_a = n.typeArguments) === null || _a === void 0 ? void 0 : _a.forEach(visitNonImportNode); + } + else if (ts.isIfStatement(n) && n.elseStatement && ts.isIfStatement(n.elseStatement)) { + // Consider an 'else if' to be on the same depth as the 'if'. + visitNonImportNode(n.expression); + visitNonImportNode(n.thenStatement); + depthRemaining++; + visitNonImportNode(n.elseStatement); + depthRemaining--; + } + else { + n.forEachChild(visitNonImportNode); + } + depthRemaining++; + } + } + function addRegionOutliningSpans(sourceFile, out) { + var regions = []; + var lineStarts = sourceFile.getLineStarts(); + for (var _i = 0, lineStarts_1 = lineStarts; _i < lineStarts_1.length; _i++) { + var currentLineStart = lineStarts_1[_i]; + var lineEnd = sourceFile.getLineEndOfPosition(currentLineStart); + var lineText = sourceFile.text.substring(currentLineStart, lineEnd); + var result = isRegionDelimiter(lineText); + if (!result || ts.isInComment(sourceFile, currentLineStart)) { + continue; + } + if (!result[1]) { + var span = ts.createTextSpanFromBounds(sourceFile.text.indexOf("//", currentLineStart), lineEnd); + regions.push(createOutliningSpan(span, "region" /* OutliningSpanKind.Region */, span, /*autoCollapse*/ false, result[2] || "#region")); + } + else { + var region = regions.pop(); + if (region) { + region.textSpan.length = lineEnd - region.textSpan.start; + region.hintSpan.length = lineEnd - region.textSpan.start; + out.push(region); + } + } + } + } + var regionDelimiterRegExp = /^#(end)?region(?:\s+(.*))?(?:\r)?$/; + function isRegionDelimiter(lineText) { + // We trim the leading whitespace and // without the regex since the + // multiple potential whitespace matches can make for some gnarly backtracking behavior + lineText = ts.trimStringStart(lineText); + if (!ts.startsWith(lineText, "\/\/")) { + return null; // eslint-disable-line no-null/no-null + } + lineText = ts.trimString(lineText.slice(2)); + return regionDelimiterRegExp.exec(lineText); + } + function addOutliningForLeadingCommentsForPos(pos, sourceFile, cancellationToken, out) { + var comments = ts.getLeadingCommentRanges(sourceFile.text, pos); + if (!comments) + return; + var firstSingleLineCommentStart = -1; + var lastSingleLineCommentEnd = -1; + var singleLineCommentCount = 0; + var sourceText = sourceFile.getFullText(); + for (var _i = 0, comments_1 = comments; _i < comments_1.length; _i++) { + var _a = comments_1[_i], kind = _a.kind, pos_1 = _a.pos, end = _a.end; + cancellationToken.throwIfCancellationRequested(); + switch (kind) { + case 2 /* SyntaxKind.SingleLineCommentTrivia */: + // never fold region delimiters into single-line comment regions + var commentText = sourceText.slice(pos_1, end); + if (isRegionDelimiter(commentText)) { + combineAndAddMultipleSingleLineComments(); + singleLineCommentCount = 0; + break; + } + // For single line comments, combine consecutive ones (2 or more) into + // a single span from the start of the first till the end of the last + if (singleLineCommentCount === 0) { + firstSingleLineCommentStart = pos_1; + } + lastSingleLineCommentEnd = end; + singleLineCommentCount++; + break; + case 3 /* SyntaxKind.MultiLineCommentTrivia */: + combineAndAddMultipleSingleLineComments(); + out.push(createOutliningSpanFromBounds(pos_1, end, "comment" /* OutliningSpanKind.Comment */)); + singleLineCommentCount = 0; + break; + default: + ts.Debug.assertNever(kind); + } + } + combineAndAddMultipleSingleLineComments(); + function combineAndAddMultipleSingleLineComments() { + // Only outline spans of two or more consecutive single line comments + if (singleLineCommentCount > 1) { + out.push(createOutliningSpanFromBounds(firstSingleLineCommentStart, lastSingleLineCommentEnd, "comment" /* OutliningSpanKind.Comment */)); + } + } + } + function addOutliningForLeadingCommentsForNode(n, sourceFile, cancellationToken, out) { + if (ts.isJsxText(n)) + return; + addOutliningForLeadingCommentsForPos(n.pos, sourceFile, cancellationToken, out); + } + function createOutliningSpanFromBounds(pos, end, kind) { + return createOutliningSpan(ts.createTextSpanFromBounds(pos, end), kind); + } + function getOutliningSpanForNode(n, sourceFile) { + switch (n.kind) { + case 238 /* SyntaxKind.Block */: + if (ts.isFunctionLike(n.parent)) { + return functionSpan(n.parent, n, sourceFile); + } + // Check if the block is standalone, or 'attached' to some parent statement. + // If the latter, we want to collapse the block, but consider its hint span + // to be the entire span of the parent. + switch (n.parent.kind) { + case 243 /* SyntaxKind.DoStatement */: + case 246 /* SyntaxKind.ForInStatement */: + case 247 /* SyntaxKind.ForOfStatement */: + case 245 /* SyntaxKind.ForStatement */: + case 242 /* SyntaxKind.IfStatement */: + case 244 /* SyntaxKind.WhileStatement */: + case 251 /* SyntaxKind.WithStatement */: + case 295 /* SyntaxKind.CatchClause */: + return spanForNode(n.parent); + case 255 /* SyntaxKind.TryStatement */: + // Could be the try-block, or the finally-block. + var tryStatement = n.parent; + if (tryStatement.tryBlock === n) { + return spanForNode(n.parent); + } + else if (tryStatement.finallyBlock === n) { + var node = ts.findChildOfKind(tryStatement, 96 /* SyntaxKind.FinallyKeyword */, sourceFile); + if (node) + return spanForNode(node); + } + // falls through + default: + // Block was a standalone block. In this case we want to only collapse + // the span of the block, independent of any parent span. + return createOutliningSpan(ts.createTextSpanFromNode(n, sourceFile), "code" /* OutliningSpanKind.Code */); + } + case 265 /* SyntaxKind.ModuleBlock */: + return spanForNode(n.parent); + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 266 /* SyntaxKind.CaseBlock */: + case 184 /* SyntaxKind.TypeLiteral */: + case 203 /* SyntaxKind.ObjectBindingPattern */: + return spanForNode(n); + case 186 /* SyntaxKind.TupleType */: + return spanForNode(n, /*autoCollapse*/ false, /*useFullStart*/ !ts.isTupleTypeNode(n.parent), 22 /* SyntaxKind.OpenBracketToken */); + case 292 /* SyntaxKind.CaseClause */: + case 293 /* SyntaxKind.DefaultClause */: + return spanForNodeArray(n.statements); + case 207 /* SyntaxKind.ObjectLiteralExpression */: + return spanForObjectOrArrayLiteral(n); + case 206 /* SyntaxKind.ArrayLiteralExpression */: + return spanForObjectOrArrayLiteral(n, 22 /* SyntaxKind.OpenBracketToken */); + case 281 /* SyntaxKind.JsxElement */: + return spanForJSXElement(n); + case 285 /* SyntaxKind.JsxFragment */: + return spanForJSXFragment(n); + case 282 /* SyntaxKind.JsxSelfClosingElement */: + case 283 /* SyntaxKind.JsxOpeningElement */: + return spanForJSXAttributes(n.attributes); + case 225 /* SyntaxKind.TemplateExpression */: + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + return spanForTemplateLiteral(n); + case 204 /* SyntaxKind.ArrayBindingPattern */: + return spanForNode(n, /*autoCollapse*/ false, /*useFullStart*/ !ts.isBindingElement(n.parent), 22 /* SyntaxKind.OpenBracketToken */); + case 216 /* SyntaxKind.ArrowFunction */: + return spanForArrowFunction(n); + case 210 /* SyntaxKind.CallExpression */: + return spanForCallExpression(n); + case 214 /* SyntaxKind.ParenthesizedExpression */: + return spanForParenthesizedExpression(n); + } + function spanForCallExpression(node) { + if (!node.arguments.length) { + return undefined; + } + var openToken = ts.findChildOfKind(node, 20 /* SyntaxKind.OpenParenToken */, sourceFile); + var closeToken = ts.findChildOfKind(node, 21 /* SyntaxKind.CloseParenToken */, sourceFile); + if (!openToken || !closeToken || ts.positionsAreOnSameLine(openToken.pos, closeToken.pos, sourceFile)) { + return undefined; + } + return spanBetweenTokens(openToken, closeToken, node, sourceFile, /*autoCollapse*/ false, /*useFullStart*/ true); + } + function spanForArrowFunction(node) { + if (ts.isBlock(node.body) || ts.isParenthesizedExpression(node.body) || ts.positionsAreOnSameLine(node.body.getFullStart(), node.body.getEnd(), sourceFile)) { + return undefined; + } + var textSpan = ts.createTextSpanFromBounds(node.body.getFullStart(), node.body.getEnd()); + return createOutliningSpan(textSpan, "code" /* OutliningSpanKind.Code */, ts.createTextSpanFromNode(node)); + } + function spanForJSXElement(node) { + var textSpan = ts.createTextSpanFromBounds(node.openingElement.getStart(sourceFile), node.closingElement.getEnd()); + var tagName = node.openingElement.tagName.getText(sourceFile); + var bannerText = "<" + tagName + ">..."; + return createOutliningSpan(textSpan, "code" /* OutliningSpanKind.Code */, textSpan, /*autoCollapse*/ false, bannerText); + } + function spanForJSXFragment(node) { + var textSpan = ts.createTextSpanFromBounds(node.openingFragment.getStart(sourceFile), node.closingFragment.getEnd()); + var bannerText = "<>..."; + return createOutliningSpan(textSpan, "code" /* OutliningSpanKind.Code */, textSpan, /*autoCollapse*/ false, bannerText); + } + function spanForJSXAttributes(node) { + if (node.properties.length === 0) { + return undefined; + } + return createOutliningSpanFromBounds(node.getStart(sourceFile), node.getEnd(), "code" /* OutliningSpanKind.Code */); + } + function spanForTemplateLiteral(node) { + if (node.kind === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */ && node.text.length === 0) { + return undefined; + } + return createOutliningSpanFromBounds(node.getStart(sourceFile), node.getEnd(), "code" /* OutliningSpanKind.Code */); + } + function spanForObjectOrArrayLiteral(node, open) { + if (open === void 0) { open = 18 /* SyntaxKind.OpenBraceToken */; } + // If the block has no leading keywords and is inside an array literal or call expression, + // we only want to collapse the span of the block. + // Otherwise, the collapsed section will include the end of the previous line. + return spanForNode(node, /*autoCollapse*/ false, /*useFullStart*/ !ts.isArrayLiteralExpression(node.parent) && !ts.isCallExpression(node.parent), open); + } + function spanForNode(hintSpanNode, autoCollapse, useFullStart, open, close) { + if (autoCollapse === void 0) { autoCollapse = false; } + if (useFullStart === void 0) { useFullStart = true; } + if (open === void 0) { open = 18 /* SyntaxKind.OpenBraceToken */; } + if (close === void 0) { close = open === 18 /* SyntaxKind.OpenBraceToken */ ? 19 /* SyntaxKind.CloseBraceToken */ : 23 /* SyntaxKind.CloseBracketToken */; } + var openToken = ts.findChildOfKind(n, open, sourceFile); + var closeToken = ts.findChildOfKind(n, close, sourceFile); + return openToken && closeToken && spanBetweenTokens(openToken, closeToken, hintSpanNode, sourceFile, autoCollapse, useFullStart); + } + function spanForNodeArray(nodeArray) { + return nodeArray.length ? createOutliningSpan(ts.createTextSpanFromRange(nodeArray), "code" /* OutliningSpanKind.Code */) : undefined; + } + function spanForParenthesizedExpression(node) { + if (ts.positionsAreOnSameLine(node.getStart(), node.getEnd(), sourceFile)) + return undefined; + var textSpan = ts.createTextSpanFromBounds(node.getStart(), node.getEnd()); + return createOutliningSpan(textSpan, "code" /* OutliningSpanKind.Code */, ts.createTextSpanFromNode(node)); + } + } + function functionSpan(node, body, sourceFile) { + var openToken = tryGetFunctionOpenToken(node, body, sourceFile); + var closeToken = ts.findChildOfKind(body, 19 /* SyntaxKind.CloseBraceToken */, sourceFile); + return openToken && closeToken && spanBetweenTokens(openToken, closeToken, node, sourceFile, /*autoCollapse*/ node.kind !== 216 /* SyntaxKind.ArrowFunction */); + } + function spanBetweenTokens(openToken, closeToken, hintSpanNode, sourceFile, autoCollapse, useFullStart) { + if (autoCollapse === void 0) { autoCollapse = false; } + if (useFullStart === void 0) { useFullStart = true; } + var textSpan = ts.createTextSpanFromBounds(useFullStart ? openToken.getFullStart() : openToken.getStart(sourceFile), closeToken.getEnd()); + return createOutliningSpan(textSpan, "code" /* OutliningSpanKind.Code */, ts.createTextSpanFromNode(hintSpanNode, sourceFile), autoCollapse); + } + function createOutliningSpan(textSpan, kind, hintSpan, autoCollapse, bannerText) { + if (hintSpan === void 0) { hintSpan = textSpan; } + if (autoCollapse === void 0) { autoCollapse = false; } + if (bannerText === void 0) { bannerText = "..."; } + return { textSpan: textSpan, kind: kind, hintSpan: hintSpan, bannerText: bannerText, autoCollapse: autoCollapse }; + } + function tryGetFunctionOpenToken(node, body, sourceFile) { + if (ts.isNodeArrayMultiLine(node.parameters, sourceFile)) { + var openParenToken = ts.findChildOfKind(node, 20 /* SyntaxKind.OpenParenToken */, sourceFile); + if (openParenToken) { + return openParenToken; + } + } + return ts.findChildOfKind(body, 18 /* SyntaxKind.OpenBraceToken */, sourceFile); + } + })(OutliningElementsCollector = ts.OutliningElementsCollector || (ts.OutliningElementsCollector = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + // Note(cyrusn): this enum is ordered from strongest match type to weakest match type. + var PatternMatchKind; + (function (PatternMatchKind) { + PatternMatchKind[PatternMatchKind["exact"] = 0] = "exact"; + PatternMatchKind[PatternMatchKind["prefix"] = 1] = "prefix"; + PatternMatchKind[PatternMatchKind["substring"] = 2] = "substring"; + PatternMatchKind[PatternMatchKind["camelCase"] = 3] = "camelCase"; + })(PatternMatchKind = ts.PatternMatchKind || (ts.PatternMatchKind = {})); + function createPatternMatch(kind, isCaseSensitive) { + return { + kind: kind, + isCaseSensitive: isCaseSensitive + }; + } + function createPatternMatcher(pattern) { + // We'll often see the same candidate string many times when searching (For example, when + // we see the name of a module that is used everywhere, or the name of an overload). As + // such, we cache the information we compute about the candidate for the life of this + // pattern matcher so we don't have to compute it multiple times. + var stringToWordSpans = new ts.Map(); + var dotSeparatedSegments = pattern.trim().split(".").map(function (p) { return createSegment(p.trim()); }); + // A segment is considered invalid if we couldn't find any words in it. + if (dotSeparatedSegments.some(function (segment) { return !segment.subWordTextChunks.length; })) + return undefined; + return { + getFullMatch: function (containers, candidate) { return getFullMatch(containers, candidate, dotSeparatedSegments, stringToWordSpans); }, + getMatchForLastSegmentOfPattern: function (candidate) { return matchSegment(candidate, ts.last(dotSeparatedSegments), stringToWordSpans); }, + patternContainsDots: dotSeparatedSegments.length > 1 + }; + } + ts.createPatternMatcher = createPatternMatcher; + function getFullMatch(candidateContainers, candidate, dotSeparatedSegments, stringToWordSpans) { + // First, check that the last part of the dot separated pattern matches the name of the + // candidate. If not, then there's no point in proceeding and doing the more + // expensive work. + var candidateMatch = matchSegment(candidate, ts.last(dotSeparatedSegments), stringToWordSpans); + if (!candidateMatch) { + return undefined; + } + // -1 because the last part was checked against the name, and only the rest + // of the parts are checked against the container. + if (dotSeparatedSegments.length - 1 > candidateContainers.length) { + // There weren't enough container parts to match against the pattern parts. + // So this definitely doesn't match. + return undefined; + } + var bestMatch; + for (var i = dotSeparatedSegments.length - 2, j = candidateContainers.length - 1; i >= 0; i -= 1, j -= 1) { + bestMatch = betterMatch(bestMatch, matchSegment(candidateContainers[j], dotSeparatedSegments[i], stringToWordSpans)); + } + return bestMatch; + } + function getWordSpans(word, stringToWordSpans) { + var spans = stringToWordSpans.get(word); + if (!spans) { + stringToWordSpans.set(word, spans = breakIntoWordSpans(word)); + } + return spans; + } + function matchTextChunk(candidate, chunk, stringToWordSpans) { + var index = indexOfIgnoringCase(candidate, chunk.textLowerCase); + if (index === 0) { + // a) Check if the word is a prefix of the candidate, in a case insensitive or + // sensitive manner. If it does, return that there was an exact match if the word and candidate are the same length, else a prefix match. + return createPatternMatch(chunk.text.length === candidate.length ? PatternMatchKind.exact : PatternMatchKind.prefix, /*isCaseSensitive:*/ ts.startsWith(candidate, chunk.text)); + } + if (chunk.isLowerCase) { + if (index === -1) + return undefined; + // b) If the part is entirely lowercase, then check if it is contained anywhere in the + // candidate in a case insensitive manner. If so, return that there was a substring + // match. + // + // Note: We only have a substring match if the lowercase part is prefix match of some + // word part. That way we don't match something like 'Class' when the user types 'a'. + // But we would match 'FooAttribute' (since 'Attribute' starts with 'a'). + var wordSpans = getWordSpans(candidate, stringToWordSpans); + for (var _i = 0, wordSpans_1 = wordSpans; _i < wordSpans_1.length; _i++) { + var span = wordSpans_1[_i]; + if (partStartsWith(candidate, span, chunk.text, /*ignoreCase:*/ true)) { + return createPatternMatch(PatternMatchKind.substring, /*isCaseSensitive:*/ partStartsWith(candidate, span, chunk.text, /*ignoreCase:*/ false)); + } + } + // c) Is the pattern a substring of the candidate starting on one of the candidate's word boundaries? + // We could check every character boundary start of the candidate for the pattern. However, that's + // an m * n operation in the wost case. Instead, find the first instance of the pattern + // substring, and see if it starts on a capital letter. It seems unlikely that the user will try to + // filter the list based on a substring that starts on a capital letter and also with a lowercase one. + // (Pattern: fogbar, Candidate: quuxfogbarFogBar). + if (chunk.text.length < candidate.length && isUpperCaseLetter(candidate.charCodeAt(index))) { + return createPatternMatch(PatternMatchKind.substring, /*isCaseSensitive:*/ false); + } + } + else { + // d) If the part was not entirely lowercase, then check if it is contained in the + // candidate in a case *sensitive* manner. If so, return that there was a substring + // match. + if (candidate.indexOf(chunk.text) > 0) { + return createPatternMatch(PatternMatchKind.substring, /*isCaseSensitive:*/ true); + } + // e) If the part was not entirely lowercase, then attempt a camel cased match as well. + if (chunk.characterSpans.length > 0) { + var candidateParts = getWordSpans(candidate, stringToWordSpans); + var isCaseSensitive = tryCamelCaseMatch(candidate, candidateParts, chunk, /*ignoreCase:*/ false) ? true + : tryCamelCaseMatch(candidate, candidateParts, chunk, /*ignoreCase:*/ true) ? false : undefined; + if (isCaseSensitive !== undefined) { + return createPatternMatch(PatternMatchKind.camelCase, isCaseSensitive); + } + } + } + } + function matchSegment(candidate, segment, stringToWordSpans) { + // First check if the segment matches as is. This is also useful if the segment contains + // characters we would normally strip when splitting into parts that we also may want to + // match in the candidate. For example if the segment is "@int" and the candidate is + // "@int", then that will show up as an exact match here. + // + // Note: if the segment contains a space or an asterisk then we must assume that it's a + // multi-word segment. + if (every(segment.totalTextChunk.text, function (ch) { return ch !== 32 /* CharacterCodes.space */ && ch !== 42 /* CharacterCodes.asterisk */; })) { + var match = matchTextChunk(candidate, segment.totalTextChunk, stringToWordSpans); + if (match) + return match; + } + // The logic for pattern matching is now as follows: + // + // 1) Break the segment passed in into words. Breaking is rather simple and a + // good way to think about it that if gives you all the individual alphanumeric words + // of the pattern. + // + // 2) For each word try to match the word against the candidate value. + // + // 3) Matching is as follows: + // + // a) Check if the word is a prefix of the candidate, in a case insensitive or + // sensitive manner. If it does, return that there was an exact match if the word and candidate are the same length, else a prefix match. + // + // If the word is entirely lowercase: + // b) Then check if it is contained anywhere in the + // candidate in a case insensitive manner. If so, return that there was a substring + // match. + // + // Note: We only have a substring match if the lowercase part is prefix match of + // some word part. That way we don't match something like 'Class' when the user + // types 'a'. But we would match 'FooAttribute' (since 'Attribute' starts with + // 'a'). + // + // c) The word is all lower case. Is it a case insensitive substring of the candidate starting + // on a part boundary of the candidate? + // + // Else: + // d) If the word was not entirely lowercase, then check if it is contained in the + // candidate in a case *sensitive* manner. If so, return that there was a substring + // match. + // + // e) If the word was not entirely lowercase, then attempt a camel cased match as + // well. + // + // Only if all words have some sort of match is the pattern considered matched. + var subWordTextChunks = segment.subWordTextChunks; + var bestMatch; + for (var _i = 0, subWordTextChunks_1 = subWordTextChunks; _i < subWordTextChunks_1.length; _i++) { + var subWordTextChunk = subWordTextChunks_1[_i]; + bestMatch = betterMatch(bestMatch, matchTextChunk(candidate, subWordTextChunk, stringToWordSpans)); + } + return bestMatch; + } + function betterMatch(a, b) { + return ts.min([a, b], compareMatches); + } + function compareMatches(a, b) { + return a === undefined ? 1 /* Comparison.GreaterThan */ : b === undefined ? -1 /* Comparison.LessThan */ + : ts.compareValues(a.kind, b.kind) || ts.compareBooleans(!a.isCaseSensitive, !b.isCaseSensitive); + } + function partStartsWith(candidate, candidateSpan, pattern, ignoreCase, patternSpan) { + if (patternSpan === void 0) { patternSpan = { start: 0, length: pattern.length }; } + return patternSpan.length <= candidateSpan.length // If pattern part is longer than the candidate part there can never be a match. + && everyInRange(0, patternSpan.length, function (i) { return equalChars(pattern.charCodeAt(patternSpan.start + i), candidate.charCodeAt(candidateSpan.start + i), ignoreCase); }); + } + function equalChars(ch1, ch2, ignoreCase) { + return ignoreCase ? toLowerCase(ch1) === toLowerCase(ch2) : ch1 === ch2; + } + function tryCamelCaseMatch(candidate, candidateParts, chunk, ignoreCase) { + var chunkCharacterSpans = chunk.characterSpans; + // Note: we may have more pattern parts than candidate parts. This is because multiple + // pattern parts may match a candidate part. For example "SiUI" against "SimpleUI". + // We'll have 3 pattern parts Si/U/I against two candidate parts Simple/UI. However, U + // and I will both match in UI. + var currentCandidate = 0; + var currentChunkSpan = 0; + var firstMatch; + var contiguous; + while (true) { + // Let's consider our termination cases + if (currentChunkSpan === chunkCharacterSpans.length) { + return true; + } + else if (currentCandidate === candidateParts.length) { + // No match, since we still have more of the pattern to hit + return false; + } + var candidatePart = candidateParts[currentCandidate]; + var gotOneMatchThisCandidate = false; + // Consider the case of matching SiUI against SimpleUIElement. The candidate parts + // will be Simple/UI/Element, and the pattern parts will be Si/U/I. We'll match 'Si' + // against 'Simple' first. Then we'll match 'U' against 'UI'. However, we want to + // still keep matching pattern parts against that candidate part. + for (; currentChunkSpan < chunkCharacterSpans.length; currentChunkSpan++) { + var chunkCharacterSpan = chunkCharacterSpans[currentChunkSpan]; + if (gotOneMatchThisCandidate) { + // We've already gotten one pattern part match in this candidate. We will + // only continue trying to consumer pattern parts if the last part and this + // part are both upper case. + if (!isUpperCaseLetter(chunk.text.charCodeAt(chunkCharacterSpans[currentChunkSpan - 1].start)) || + !isUpperCaseLetter(chunk.text.charCodeAt(chunkCharacterSpans[currentChunkSpan].start))) { + break; + } + } + if (!partStartsWith(candidate, candidatePart, chunk.text, ignoreCase, chunkCharacterSpan)) { + break; + } + gotOneMatchThisCandidate = true; + firstMatch = firstMatch === undefined ? currentCandidate : firstMatch; + // If we were contiguous, then keep that value. If we weren't, then keep that + // value. If we don't know, then set the value to 'true' as an initial match is + // obviously contiguous. + contiguous = contiguous === undefined ? true : contiguous; + candidatePart = ts.createTextSpan(candidatePart.start + chunkCharacterSpan.length, candidatePart.length - chunkCharacterSpan.length); + } + // Check if we matched anything at all. If we didn't, then we need to unset the + // contiguous bit if we currently had it set. + // If we haven't set the bit yet, then that means we haven't matched anything so + // far, and we don't want to change that. + if (!gotOneMatchThisCandidate && contiguous !== undefined) { + contiguous = false; + } + // Move onto the next candidate. + currentCandidate++; + } + } + function createSegment(text) { + return { + totalTextChunk: createTextChunk(text), + subWordTextChunks: breakPatternIntoTextChunks(text) + }; + } + function isUpperCaseLetter(ch) { + // Fast check for the ascii range. + if (ch >= 65 /* CharacterCodes.A */ && ch <= 90 /* CharacterCodes.Z */) { + return true; + } + if (ch < 127 /* CharacterCodes.maxAsciiCharacter */ || !ts.isUnicodeIdentifierStart(ch, 99 /* ScriptTarget.Latest */)) { + return false; + } + // TODO: find a way to determine this for any unicode characters in a + // non-allocating manner. + var str = String.fromCharCode(ch); + return str === str.toUpperCase(); + } + function isLowerCaseLetter(ch) { + // Fast check for the ascii range. + if (ch >= 97 /* CharacterCodes.a */ && ch <= 122 /* CharacterCodes.z */) { + return true; + } + if (ch < 127 /* CharacterCodes.maxAsciiCharacter */ || !ts.isUnicodeIdentifierStart(ch, 99 /* ScriptTarget.Latest */)) { + return false; + } + // TODO: find a way to determine this for any unicode characters in a + // non-allocating manner. + var str = String.fromCharCode(ch); + return str === str.toLowerCase(); + } + // Assumes 'value' is already lowercase. + function indexOfIgnoringCase(str, value) { + var n = str.length - value.length; + var _loop_6 = function (start) { + if (every(value, function (valueChar, i) { return toLowerCase(str.charCodeAt(i + start)) === valueChar; })) { + return { value: start }; + } + }; + for (var start = 0; start <= n; start++) { + var state_3 = _loop_6(start); + if (typeof state_3 === "object") + return state_3.value; + } + return -1; + } + function toLowerCase(ch) { + // Fast convert for the ascii range. + if (ch >= 65 /* CharacterCodes.A */ && ch <= 90 /* CharacterCodes.Z */) { + return 97 /* CharacterCodes.a */ + (ch - 65 /* CharacterCodes.A */); + } + if (ch < 127 /* CharacterCodes.maxAsciiCharacter */) { + return ch; + } + // TODO: find a way to compute this for any unicode characters in a + // non-allocating manner. + return String.fromCharCode(ch).toLowerCase().charCodeAt(0); + } + function isDigit(ch) { + // TODO(cyrusn): Find a way to support this for unicode digits. + return ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */; + } + function isWordChar(ch) { + return isUpperCaseLetter(ch) || isLowerCaseLetter(ch) || isDigit(ch) || ch === 95 /* CharacterCodes._ */ || ch === 36 /* CharacterCodes.$ */; + } + function breakPatternIntoTextChunks(pattern) { + var result = []; + var wordStart = 0; + var wordLength = 0; + for (var i = 0; i < pattern.length; i++) { + var ch = pattern.charCodeAt(i); + if (isWordChar(ch)) { + if (wordLength === 0) { + wordStart = i; + } + wordLength++; + } + else { + if (wordLength > 0) { + result.push(createTextChunk(pattern.substr(wordStart, wordLength))); + wordLength = 0; + } + } + } + if (wordLength > 0) { + result.push(createTextChunk(pattern.substr(wordStart, wordLength))); + } + return result; + } + function createTextChunk(text) { + var textLowerCase = text.toLowerCase(); + return { + text: text, + textLowerCase: textLowerCase, + isLowerCase: text === textLowerCase, + characterSpans: breakIntoCharacterSpans(text) + }; + } + function breakIntoCharacterSpans(identifier) { + return breakIntoSpans(identifier, /*word:*/ false); + } + ts.breakIntoCharacterSpans = breakIntoCharacterSpans; + function breakIntoWordSpans(identifier) { + return breakIntoSpans(identifier, /*word:*/ true); + } + ts.breakIntoWordSpans = breakIntoWordSpans; + function breakIntoSpans(identifier, word) { + var result = []; + var wordStart = 0; + for (var i = 1; i < identifier.length; i++) { + var lastIsDigit = isDigit(identifier.charCodeAt(i - 1)); + var currentIsDigit = isDigit(identifier.charCodeAt(i)); + var hasTransitionFromLowerToUpper = transitionFromLowerToUpper(identifier, word, i); + var hasTransitionFromUpperToLower = word && transitionFromUpperToLower(identifier, i, wordStart); + if (charIsPunctuation(identifier.charCodeAt(i - 1)) || + charIsPunctuation(identifier.charCodeAt(i)) || + lastIsDigit !== currentIsDigit || + hasTransitionFromLowerToUpper || + hasTransitionFromUpperToLower) { + if (!isAllPunctuation(identifier, wordStart, i)) { + result.push(ts.createTextSpan(wordStart, i - wordStart)); + } + wordStart = i; + } + } + if (!isAllPunctuation(identifier, wordStart, identifier.length)) { + result.push(ts.createTextSpan(wordStart, identifier.length - wordStart)); + } + return result; + } + function charIsPunctuation(ch) { + switch (ch) { + case 33 /* CharacterCodes.exclamation */: + case 34 /* CharacterCodes.doubleQuote */: + case 35 /* CharacterCodes.hash */: + case 37 /* CharacterCodes.percent */: + case 38 /* CharacterCodes.ampersand */: + case 39 /* CharacterCodes.singleQuote */: + case 40 /* CharacterCodes.openParen */: + case 41 /* CharacterCodes.closeParen */: + case 42 /* CharacterCodes.asterisk */: + case 44 /* CharacterCodes.comma */: + case 45 /* CharacterCodes.minus */: + case 46 /* CharacterCodes.dot */: + case 47 /* CharacterCodes.slash */: + case 58 /* CharacterCodes.colon */: + case 59 /* CharacterCodes.semicolon */: + case 63 /* CharacterCodes.question */: + case 64 /* CharacterCodes.at */: + case 91 /* CharacterCodes.openBracket */: + case 92 /* CharacterCodes.backslash */: + case 93 /* CharacterCodes.closeBracket */: + case 95 /* CharacterCodes._ */: + case 123 /* CharacterCodes.openBrace */: + case 125 /* CharacterCodes.closeBrace */: + return true; + } + return false; + } + function isAllPunctuation(identifier, start, end) { + return every(identifier, function (ch) { return charIsPunctuation(ch) && ch !== 95 /* CharacterCodes._ */; }, start, end); + } + function transitionFromUpperToLower(identifier, index, wordStart) { + // Cases this supports: + // 1) IDisposable -> I, Disposable + // 2) UIElement -> UI, Element + // 3) HTMLDocument -> HTML, Document + // + // etc. + // We have a transition from an upper to a lower letter here. But we only + // want to break if all the letters that preceded are uppercase. i.e. if we + // have "Foo" we don't want to break that into "F, oo". But if we have + // "IFoo" or "UIFoo", then we want to break that into "I, Foo" and "UI, + // Foo". i.e. the last uppercase letter belongs to the lowercase letters + // that follows. Note: this will make the following not split properly: + // "HELLOthere". However, these sorts of names do not show up in .Net + // programs. + return index !== wordStart + && index + 1 < identifier.length + && isUpperCaseLetter(identifier.charCodeAt(index)) + && isLowerCaseLetter(identifier.charCodeAt(index + 1)) + && every(identifier, isUpperCaseLetter, wordStart, index); + } + function transitionFromLowerToUpper(identifier, word, index) { + var lastIsUpper = isUpperCaseLetter(identifier.charCodeAt(index - 1)); + var currentIsUpper = isUpperCaseLetter(identifier.charCodeAt(index)); + // See if the casing indicates we're starting a new word. Note: if we're breaking on + // words, then just seeing an upper case character isn't enough. Instead, it has to + // be uppercase and the previous character can't be uppercase. + // + // For example, breaking "AddMetadata" on words would make: Add Metadata + // + // on characters would be: A dd M etadata + // + // Break "AM" on words would be: AM + // + // on characters would be: A M + // + // We break the search string on characters. But we break the symbol name on words. + return currentIsUpper && (!word || !lastIsUpper); + } + function everyInRange(start, end, pred) { + for (var i = start; i < end; i++) { + if (!pred(i)) { + return false; + } + } + return true; + } + function every(s, pred, start, end) { + if (start === void 0) { start = 0; } + if (end === void 0) { end = s.length; } + return everyInRange(start, end, function (i) { return pred(s.charCodeAt(i), i); }); + } +})(ts || (ts = {})); +var ts; +(function (ts) { + function preProcessFile(sourceText, readImportFiles, detectJavaScriptImports) { + if (readImportFiles === void 0) { readImportFiles = true; } + if (detectJavaScriptImports === void 0) { detectJavaScriptImports = false; } + var pragmaContext = { + languageVersion: 1 /* ScriptTarget.ES5 */, + pragmas: undefined, + checkJsDirective: undefined, + referencedFiles: [], + typeReferenceDirectives: [], + libReferenceDirectives: [], + amdDependencies: [], + hasNoDefaultLib: undefined, + moduleName: undefined + }; + var importedFiles = []; + var ambientExternalModules; + var lastToken; + var currentToken; + var braceNesting = 0; + // assume that text represent an external module if it contains at least one top level import/export + // ambient modules that are found inside external modules are interpreted as module augmentations + var externalModule = false; + function nextToken() { + lastToken = currentToken; + currentToken = ts.scanner.scan(); + if (currentToken === 18 /* SyntaxKind.OpenBraceToken */) { + braceNesting++; + } + else if (currentToken === 19 /* SyntaxKind.CloseBraceToken */) { + braceNesting--; + } + return currentToken; + } + function getFileReference() { + var fileName = ts.scanner.getTokenValue(); + var pos = ts.scanner.getTokenPos(); + return { fileName: fileName, pos: pos, end: pos + fileName.length }; + } + function recordAmbientExternalModule() { + if (!ambientExternalModules) { + ambientExternalModules = []; + } + ambientExternalModules.push({ ref: getFileReference(), depth: braceNesting }); + } + function recordModuleName() { + importedFiles.push(getFileReference()); + markAsExternalModuleIfTopLevel(); + } + function markAsExternalModuleIfTopLevel() { + if (braceNesting === 0) { + externalModule = true; + } + } + /** + * Returns true if at least one token was consumed from the stream + */ + function tryConsumeDeclare() { + var token = ts.scanner.getToken(); + if (token === 136 /* SyntaxKind.DeclareKeyword */) { + // declare module "mod" + token = nextToken(); + if (token === 142 /* SyntaxKind.ModuleKeyword */) { + token = nextToken(); + if (token === 10 /* SyntaxKind.StringLiteral */) { + recordAmbientExternalModule(); + } + } + return true; + } + return false; + } + /** + * Returns true if at least one token was consumed from the stream + */ + function tryConsumeImport() { + if (lastToken === 24 /* SyntaxKind.DotToken */) { + return false; + } + var token = ts.scanner.getToken(); + if (token === 100 /* SyntaxKind.ImportKeyword */) { + token = nextToken(); + if (token === 20 /* SyntaxKind.OpenParenToken */) { + token = nextToken(); + if (token === 10 /* SyntaxKind.StringLiteral */ || token === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */) { + // import("mod"); + recordModuleName(); + return true; + } + } + else if (token === 10 /* SyntaxKind.StringLiteral */) { + // import "mod"; + recordModuleName(); + return true; + } + else { + if (token === 154 /* SyntaxKind.TypeKeyword */) { + var skipTypeKeyword = ts.scanner.lookAhead(function () { + var token = ts.scanner.scan(); + return token !== 158 /* SyntaxKind.FromKeyword */ && (token === 41 /* SyntaxKind.AsteriskToken */ || + token === 18 /* SyntaxKind.OpenBraceToken */ || + token === 79 /* SyntaxKind.Identifier */ || + ts.isKeyword(token)); + }); + if (skipTypeKeyword) { + token = nextToken(); + } + } + if (token === 79 /* SyntaxKind.Identifier */ || ts.isKeyword(token)) { + token = nextToken(); + if (token === 158 /* SyntaxKind.FromKeyword */) { + token = nextToken(); + if (token === 10 /* SyntaxKind.StringLiteral */) { + // import d from "mod"; + recordModuleName(); + return true; + } + } + else if (token === 63 /* SyntaxKind.EqualsToken */) { + if (tryConsumeRequireCall(/*skipCurrentToken*/ true)) { + return true; + } + } + else if (token === 27 /* SyntaxKind.CommaToken */) { + // consume comma and keep going + token = nextToken(); + } + else { + // unknown syntax + return true; + } + } + if (token === 18 /* SyntaxKind.OpenBraceToken */) { + token = nextToken(); + // consume "{ a as B, c, d as D}" clauses + // make sure that it stops on EOF + while (token !== 19 /* SyntaxKind.CloseBraceToken */ && token !== 1 /* SyntaxKind.EndOfFileToken */) { + token = nextToken(); + } + if (token === 19 /* SyntaxKind.CloseBraceToken */) { + token = nextToken(); + if (token === 158 /* SyntaxKind.FromKeyword */) { + token = nextToken(); + if (token === 10 /* SyntaxKind.StringLiteral */) { + // import {a as A} from "mod"; + // import d, {a, b as B} from "mod" + recordModuleName(); + } + } + } + } + else if (token === 41 /* SyntaxKind.AsteriskToken */) { + token = nextToken(); + if (token === 128 /* SyntaxKind.AsKeyword */) { + token = nextToken(); + if (token === 79 /* SyntaxKind.Identifier */ || ts.isKeyword(token)) { + token = nextToken(); + if (token === 158 /* SyntaxKind.FromKeyword */) { + token = nextToken(); + if (token === 10 /* SyntaxKind.StringLiteral */) { + // import * as NS from "mod" + // import d, * as NS from "mod" + recordModuleName(); + } + } + } + } + } + } + return true; + } + return false; + } + function tryConsumeExport() { + var token = ts.scanner.getToken(); + if (token === 93 /* SyntaxKind.ExportKeyword */) { + markAsExternalModuleIfTopLevel(); + token = nextToken(); + if (token === 154 /* SyntaxKind.TypeKeyword */) { + var skipTypeKeyword = ts.scanner.lookAhead(function () { + var token = ts.scanner.scan(); + return token === 41 /* SyntaxKind.AsteriskToken */ || + token === 18 /* SyntaxKind.OpenBraceToken */; + }); + if (skipTypeKeyword) { + token = nextToken(); + } + } + if (token === 18 /* SyntaxKind.OpenBraceToken */) { + token = nextToken(); + // consume "{ a as B, c, d as D}" clauses + // make sure it stops on EOF + while (token !== 19 /* SyntaxKind.CloseBraceToken */ && token !== 1 /* SyntaxKind.EndOfFileToken */) { + token = nextToken(); + } + if (token === 19 /* SyntaxKind.CloseBraceToken */) { + token = nextToken(); + if (token === 158 /* SyntaxKind.FromKeyword */) { + token = nextToken(); + if (token === 10 /* SyntaxKind.StringLiteral */) { + // export {a as A} from "mod"; + // export {a, b as B} from "mod" + recordModuleName(); + } + } + } + } + else if (token === 41 /* SyntaxKind.AsteriskToken */) { + token = nextToken(); + if (token === 158 /* SyntaxKind.FromKeyword */) { + token = nextToken(); + if (token === 10 /* SyntaxKind.StringLiteral */) { + // export * from "mod" + recordModuleName(); + } + } + } + else if (token === 100 /* SyntaxKind.ImportKeyword */) { + token = nextToken(); + if (token === 154 /* SyntaxKind.TypeKeyword */) { + var skipTypeKeyword = ts.scanner.lookAhead(function () { + var token = ts.scanner.scan(); + return token === 79 /* SyntaxKind.Identifier */ || + ts.isKeyword(token); + }); + if (skipTypeKeyword) { + token = nextToken(); + } + } + if (token === 79 /* SyntaxKind.Identifier */ || ts.isKeyword(token)) { + token = nextToken(); + if (token === 63 /* SyntaxKind.EqualsToken */) { + if (tryConsumeRequireCall(/*skipCurrentToken*/ true)) { + return true; + } + } + } + } + return true; + } + return false; + } + function tryConsumeRequireCall(skipCurrentToken, allowTemplateLiterals) { + if (allowTemplateLiterals === void 0) { allowTemplateLiterals = false; } + var token = skipCurrentToken ? nextToken() : ts.scanner.getToken(); + if (token === 147 /* SyntaxKind.RequireKeyword */) { + token = nextToken(); + if (token === 20 /* SyntaxKind.OpenParenToken */) { + token = nextToken(); + if (token === 10 /* SyntaxKind.StringLiteral */ || + allowTemplateLiterals && token === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */) { + // require("mod"); + recordModuleName(); + } + } + return true; + } + return false; + } + function tryConsumeDefine() { + var token = ts.scanner.getToken(); + if (token === 79 /* SyntaxKind.Identifier */ && ts.scanner.getTokenValue() === "define") { + token = nextToken(); + if (token !== 20 /* SyntaxKind.OpenParenToken */) { + return true; + } + token = nextToken(); + if (token === 10 /* SyntaxKind.StringLiteral */ || token === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */) { + // looks like define ("modname", ... - skip string literal and comma + token = nextToken(); + if (token === 27 /* SyntaxKind.CommaToken */) { + token = nextToken(); + } + else { + // unexpected token + return true; + } + } + // should be start of dependency list + if (token !== 22 /* SyntaxKind.OpenBracketToken */) { + return true; + } + // skip open bracket + token = nextToken(); + // scan until ']' or EOF + while (token !== 23 /* SyntaxKind.CloseBracketToken */ && token !== 1 /* SyntaxKind.EndOfFileToken */) { + // record string literals as module names + if (token === 10 /* SyntaxKind.StringLiteral */ || token === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */) { + recordModuleName(); + } + token = nextToken(); + } + return true; + } + return false; + } + function processImports() { + ts.scanner.setText(sourceText); + nextToken(); + // Look for: + // import "mod"; + // import d from "mod" + // import {a as A } from "mod"; + // import * as NS from "mod" + // import d, {a, b as B} from "mod" + // import i = require("mod"); + // import("mod"); + // export * from "mod" + // export {a as b} from "mod" + // export import i = require("mod") + // (for JavaScript files) require("mod") + // Do not look for: + // AnySymbol.import("mod") + // AnySymbol.nested.import("mod") + while (true) { + if (ts.scanner.getToken() === 1 /* SyntaxKind.EndOfFileToken */) { + break; + } + if (ts.scanner.getToken() === 15 /* SyntaxKind.TemplateHead */) { + var stack = [ts.scanner.getToken()]; + loop: while (ts.length(stack)) { + var token = ts.scanner.scan(); + switch (token) { + case 1 /* SyntaxKind.EndOfFileToken */: + break loop; + case 100 /* SyntaxKind.ImportKeyword */: + tryConsumeImport(); + break; + case 15 /* SyntaxKind.TemplateHead */: + stack.push(token); + break; + case 18 /* SyntaxKind.OpenBraceToken */: + if (ts.length(stack)) { + stack.push(token); + } + break; + case 19 /* SyntaxKind.CloseBraceToken */: + if (ts.length(stack)) { + if (ts.lastOrUndefined(stack) === 15 /* SyntaxKind.TemplateHead */) { + if (ts.scanner.reScanTemplateToken(/* isTaggedTemplate */ false) === 17 /* SyntaxKind.TemplateTail */) { + stack.pop(); + } + } + else { + stack.pop(); + } + } + break; + } + } + nextToken(); + } + // check if at least one of alternative have moved scanner forward + if (tryConsumeDeclare() || + tryConsumeImport() || + tryConsumeExport() || + (detectJavaScriptImports && (tryConsumeRequireCall(/*skipCurrentToken*/ false, /*allowTemplateLiterals*/ true) || + tryConsumeDefine()))) { + continue; + } + else { + nextToken(); + } + } + ts.scanner.setText(undefined); + } + if (readImportFiles) { + processImports(); + } + ts.processCommentPragmas(pragmaContext, sourceText); + ts.processPragmasIntoFields(pragmaContext, ts.noop); + if (externalModule) { + // for external modules module all nested ambient modules are augmentations + if (ambientExternalModules) { + // move all detected ambient modules to imported files since they need to be resolved + for (var _i = 0, ambientExternalModules_1 = ambientExternalModules; _i < ambientExternalModules_1.length; _i++) { + var decl = ambientExternalModules_1[_i]; + importedFiles.push(decl.ref); + } + } + return { referencedFiles: pragmaContext.referencedFiles, typeReferenceDirectives: pragmaContext.typeReferenceDirectives, libReferenceDirectives: pragmaContext.libReferenceDirectives, importedFiles: importedFiles, isLibFile: !!pragmaContext.hasNoDefaultLib, ambientExternalModules: undefined }; + } + else { + // for global scripts ambient modules still can have augmentations - look for ambient modules with depth > 0 + var ambientModuleNames = void 0; + if (ambientExternalModules) { + for (var _a = 0, ambientExternalModules_2 = ambientExternalModules; _a < ambientExternalModules_2.length; _a++) { + var decl = ambientExternalModules_2[_a]; + if (decl.depth === 0) { + if (!ambientModuleNames) { + ambientModuleNames = []; + } + ambientModuleNames.push(decl.ref.fileName); + } + else { + importedFiles.push(decl.ref); + } + } + } + return { referencedFiles: pragmaContext.referencedFiles, typeReferenceDirectives: pragmaContext.typeReferenceDirectives, libReferenceDirectives: pragmaContext.libReferenceDirectives, importedFiles: importedFiles, isLibFile: !!pragmaContext.hasNoDefaultLib, ambientExternalModules: ambientModuleNames }; + } + } + ts.preProcessFile = preProcessFile; +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var Rename; + (function (Rename) { + function getRenameInfo(program, sourceFile, position, preferences) { + var node = ts.getAdjustedRenameLocation(ts.getTouchingPropertyName(sourceFile, position)); + if (nodeIsEligibleForRename(node)) { + var renameInfo = getRenameInfoForNode(node, program.getTypeChecker(), sourceFile, program, preferences); + if (renameInfo) { + return renameInfo; + } + } + return getRenameInfoError(ts.Diagnostics.You_cannot_rename_this_element); + } + Rename.getRenameInfo = getRenameInfo; + function getRenameInfoForNode(node, typeChecker, sourceFile, program, preferences) { + var symbol = typeChecker.getSymbolAtLocation(node); + if (!symbol) { + if (ts.isStringLiteralLike(node)) { + var type = ts.getContextualTypeFromParentOrAncestorTypeNode(node, typeChecker); + if (type && ((type.flags & 128 /* TypeFlags.StringLiteral */) || ((type.flags & 1048576 /* TypeFlags.Union */) && ts.every(type.types, function (type) { return !!(type.flags & 128 /* TypeFlags.StringLiteral */); })))) { + return getRenameInfoSuccess(node.text, node.text, "string" /* ScriptElementKind.string */, "", node, sourceFile); + } + } + else if (ts.isLabelName(node)) { + var name = ts.getTextOfNode(node); + return getRenameInfoSuccess(name, name, "label" /* ScriptElementKind.label */, "" /* ScriptElementKindModifier.none */, node, sourceFile); + } + return undefined; + } + // Only allow a symbol to be renamed if it actually has at least one declaration. + var declarations = symbol.declarations; + if (!declarations || declarations.length === 0) + return; + // Disallow rename for elements that are defined in the standard TypeScript library. + if (declarations.some(function (declaration) { return isDefinedInLibraryFile(program, declaration); })) { + return getRenameInfoError(ts.Diagnostics.You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library); + } + // Cannot rename `default` as in `import { default as foo } from "./someModule"; + if (ts.isIdentifier(node) && node.originalKeywordKind === 88 /* SyntaxKind.DefaultKeyword */ && symbol.parent && symbol.parent.flags & 1536 /* SymbolFlags.Module */) { + return undefined; + } + if (ts.isStringLiteralLike(node) && ts.tryGetImportFromModuleSpecifier(node)) { + return preferences.allowRenameOfImportPath ? getRenameInfoForModule(node, sourceFile, symbol) : undefined; + } + // Disallow rename for elements that would rename across `*/node_modules/*` packages. + var wouldRenameNodeModules = wouldRenameInOtherNodeModules(sourceFile, symbol, typeChecker, preferences); + if (wouldRenameNodeModules) { + return getRenameInfoError(wouldRenameNodeModules); + } + var kind = ts.SymbolDisplay.getSymbolKind(typeChecker, symbol, node); + var specifierName = (ts.isImportOrExportSpecifierName(node) || ts.isStringOrNumericLiteralLike(node) && node.parent.kind === 164 /* SyntaxKind.ComputedPropertyName */) + ? ts.stripQuotes(ts.getTextOfIdentifierOrLiteral(node)) + : undefined; + var displayName = specifierName || typeChecker.symbolToString(symbol); + var fullDisplayName = specifierName || typeChecker.getFullyQualifiedName(symbol); + return getRenameInfoSuccess(displayName, fullDisplayName, kind, ts.SymbolDisplay.getSymbolModifiers(typeChecker, symbol), node, sourceFile); + } + function isDefinedInLibraryFile(program, declaration) { + var sourceFile = declaration.getSourceFile(); + return program.isSourceFileDefaultLibrary(sourceFile) && ts.fileExtensionIs(sourceFile.fileName, ".d.ts" /* Extension.Dts */); + } + function wouldRenameInOtherNodeModules(originalFile, symbol, checker, preferences) { + if (!preferences.providePrefixAndSuffixTextForRename && symbol.flags & 2097152 /* SymbolFlags.Alias */) { + var importSpecifier = symbol.declarations && ts.find(symbol.declarations, function (decl) { return ts.isImportSpecifier(decl); }); + if (importSpecifier && !importSpecifier.propertyName) { + symbol = checker.getAliasedSymbol(symbol); + } + } + var declarations = symbol.declarations; + if (!declarations) { + return undefined; + } + var originalPackage = getPackagePathComponents(originalFile.path); + if (originalPackage === undefined) { // original source file is not in node_modules + if (ts.some(declarations, function (declaration) { return ts.isInsideNodeModules(declaration.getSourceFile().path); })) { + return ts.Diagnostics.You_cannot_rename_elements_that_are_defined_in_a_node_modules_folder; + } + else { + return undefined; + } + } + // original source file is in node_modules + for (var _i = 0, declarations_4 = declarations; _i < declarations_4.length; _i++) { + var declaration = declarations_4[_i]; + var declPackage = getPackagePathComponents(declaration.getSourceFile().path); + if (declPackage) { + var length_2 = Math.min(originalPackage.length, declPackage.length); + for (var i = 0; i <= length_2; i++) { + if (ts.compareStringsCaseSensitive(originalPackage[i], declPackage[i]) !== 0 /* Comparison.EqualTo */) { + return ts.Diagnostics.You_cannot_rename_elements_that_are_defined_in_another_node_modules_folder; + } + } + } + } + return undefined; + } + function getPackagePathComponents(filePath) { + var components = ts.getPathComponents(filePath); + var nodeModulesIdx = components.lastIndexOf("node_modules"); + if (nodeModulesIdx === -1) { + return undefined; + } + return components.slice(0, nodeModulesIdx + 2); + } + function getRenameInfoForModule(node, sourceFile, moduleSymbol) { + if (!ts.isExternalModuleNameRelative(node.text)) { + return getRenameInfoError(ts.Diagnostics.You_cannot_rename_a_module_via_a_global_import); + } + var moduleSourceFile = moduleSymbol.declarations && ts.find(moduleSymbol.declarations, ts.isSourceFile); + if (!moduleSourceFile) + return undefined; + var withoutIndex = ts.endsWith(node.text, "/index") || ts.endsWith(node.text, "/index.js") ? undefined : ts.tryRemoveSuffix(ts.removeFileExtension(moduleSourceFile.fileName), "/index"); + var name = withoutIndex === undefined ? moduleSourceFile.fileName : withoutIndex; + var kind = withoutIndex === undefined ? "module" /* ScriptElementKind.moduleElement */ : "directory" /* ScriptElementKind.directory */; + var indexAfterLastSlash = node.text.lastIndexOf("/") + 1; + // Span should only be the last component of the path. + 1 to account for the quote character. + var triggerSpan = ts.createTextSpan(node.getStart(sourceFile) + 1 + indexAfterLastSlash, node.text.length - indexAfterLastSlash); + return { + canRename: true, + fileToRename: name, + kind: kind, + displayName: name, + fullDisplayName: name, + kindModifiers: "" /* ScriptElementKindModifier.none */, + triggerSpan: triggerSpan, + }; + } + function getRenameInfoSuccess(displayName, fullDisplayName, kind, kindModifiers, node, sourceFile) { + return { + canRename: true, + fileToRename: undefined, + kind: kind, + displayName: displayName, + fullDisplayName: fullDisplayName, + kindModifiers: kindModifiers, + triggerSpan: createTriggerSpanForNode(node, sourceFile) + }; + } + function getRenameInfoError(diagnostic) { + return { canRename: false, localizedErrorMessage: ts.getLocaleSpecificMessage(diagnostic) }; + } + function createTriggerSpanForNode(node, sourceFile) { + var start = node.getStart(sourceFile); + var width = node.getWidth(sourceFile); + if (ts.isStringLiteralLike(node)) { + // Exclude the quotes + start += 1; + width -= 2; + } + return ts.createTextSpan(start, width); + } + function nodeIsEligibleForRename(node) { + switch (node.kind) { + case 79 /* SyntaxKind.Identifier */: + case 80 /* SyntaxKind.PrivateIdentifier */: + case 10 /* SyntaxKind.StringLiteral */: + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + case 108 /* SyntaxKind.ThisKeyword */: + return true; + case 8 /* SyntaxKind.NumericLiteral */: + return ts.isLiteralNameOfPropertyDeclarationOrIndexAccess(node); + default: + return false; + } + } + Rename.nodeIsEligibleForRename = nodeIsEligibleForRename; + })(Rename = ts.Rename || (ts.Rename = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var SmartSelectionRange; + (function (SmartSelectionRange) { + function getSmartSelectionRange(pos, sourceFile) { + var _a, _b; + var selectionRange = { + textSpan: ts.createTextSpanFromBounds(sourceFile.getFullStart(), sourceFile.getEnd()) + }; + var parentNode = sourceFile; + outer: while (true) { + var children = getSelectionChildren(parentNode); + if (!children.length) + break; + for (var i = 0; i < children.length; i++) { + var prevNode = children[i - 1]; + var node = children[i]; + var nextNode = children[i + 1]; + if (ts.getTokenPosOfNode(node, sourceFile, /*includeJsDoc*/ true) > pos) { + break outer; + } + var comment = ts.singleOrUndefined(ts.getTrailingCommentRanges(sourceFile.text, node.end)); + if (comment && comment.kind === 2 /* SyntaxKind.SingleLineCommentTrivia */) { + pushSelectionCommentRange(comment.pos, comment.end); + } + if (positionShouldSnapToNode(sourceFile, pos, node)) { + if (ts.isFunctionBody(node) + && ts.isFunctionLikeDeclaration(parentNode) && !ts.positionsAreOnSameLine(node.getStart(sourceFile), node.getEnd(), sourceFile)) { + pushSelectionRange(node.getStart(sourceFile), node.getEnd()); + } + // 1. Blocks are effectively redundant with SyntaxLists. + // 2. TemplateSpans, along with the SyntaxLists containing them, are a somewhat unintuitive grouping + // of things that should be considered independently. + // 3. A VariableStatement’s children are just a VaraiableDeclarationList and a semicolon. + // 4. A lone VariableDeclaration in a VaraibleDeclaration feels redundant with the VariableStatement. + // Dive in without pushing a selection range. + if (ts.isBlock(node) + || ts.isTemplateSpan(node) || ts.isTemplateHead(node) || ts.isTemplateTail(node) + || prevNode && ts.isTemplateHead(prevNode) + || ts.isVariableDeclarationList(node) && ts.isVariableStatement(parentNode) + || ts.isSyntaxList(node) && ts.isVariableDeclarationList(parentNode) + || ts.isVariableDeclaration(node) && ts.isSyntaxList(parentNode) && children.length === 1 + || ts.isJSDocTypeExpression(node) || ts.isJSDocSignature(node) || ts.isJSDocTypeLiteral(node)) { + parentNode = node; + break; + } + // Synthesize a stop for '${ ... }' since '${' and '}' actually belong to siblings. + if (ts.isTemplateSpan(parentNode) && nextNode && ts.isTemplateMiddleOrTemplateTail(nextNode)) { + var start_1 = node.getFullStart() - "${".length; + var end_2 = nextNode.getStart() + "}".length; + pushSelectionRange(start_1, end_2); + } + // Blocks with braces, brackets, parens, or JSX tags on separate lines should be + // selected from open to close, including whitespace but not including the braces/etc. themselves. + var isBetweenMultiLineBookends = ts.isSyntaxList(node) && isListOpener(prevNode) && isListCloser(nextNode) + && !ts.positionsAreOnSameLine(prevNode.getStart(), nextNode.getStart(), sourceFile); + var start = isBetweenMultiLineBookends ? prevNode.getEnd() : node.getStart(); + var end = isBetweenMultiLineBookends ? nextNode.getStart() : getEndPos(sourceFile, node); + if (ts.hasJSDocNodes(node) && ((_a = node.jsDoc) === null || _a === void 0 ? void 0 : _a.length)) { + pushSelectionRange(ts.first(node.jsDoc).getStart(), end); + } + // (#39618 & #49807) + // When the node is a SyntaxList and its first child has a JSDoc comment, then the node's + // `start` (which usually is the result of calling `node.getStart()`) points to the first + // token after the JSDoc comment. So, we have to make sure we'd pushed the selection + // covering the JSDoc comment before diving further. + if (ts.isSyntaxList(node)) { + var firstChild = node.getChildren()[0]; + if (firstChild && ts.hasJSDocNodes(firstChild) && ((_b = firstChild.jsDoc) === null || _b === void 0 ? void 0 : _b.length) && firstChild.getStart() !== node.pos) { + start = Math.min(start, ts.first(firstChild.jsDoc).getStart()); + } + } + pushSelectionRange(start, end); + // String literals should have a stop both inside and outside their quotes. + if (ts.isStringLiteral(node) || ts.isTemplateLiteral(node)) { + pushSelectionRange(start + 1, end - 1); + } + parentNode = node; + break; + } + // If we made it to the end of the for loop, we’re done. + // In practice, I’ve only seen this happen at the very end + // of a SourceFile. + if (i === children.length - 1) { + break outer; + } + } + } + return selectionRange; + function pushSelectionRange(start, end) { + // Skip empty ranges + if (start !== end) { + var textSpan = ts.createTextSpanFromBounds(start, end); + if (!selectionRange || ( + // Skip ranges that are identical to the parent + !ts.textSpansEqual(textSpan, selectionRange.textSpan) && + // Skip ranges that don’t contain the original position + ts.textSpanIntersectsWithPosition(textSpan, pos))) { + selectionRange = __assign({ textSpan: textSpan }, selectionRange && { parent: selectionRange }); + } + } + } + function pushSelectionCommentRange(start, end) { + pushSelectionRange(start, end); + var pos = start; + while (sourceFile.text.charCodeAt(pos) === 47 /* CharacterCodes.slash */) { + pos++; + } + pushSelectionRange(pos, end); + } + } + SmartSelectionRange.getSmartSelectionRange = getSmartSelectionRange; + /** + * Like `ts.positionBelongsToNode`, except positions immediately after nodes + * count too, unless that position belongs to the next node. In effect, makes + * selections able to snap to preceding tokens when the cursor is on the tail + * end of them with only whitespace ahead. + * @param sourceFile The source file containing the nodes. + * @param pos The position to check. + * @param node The candidate node to snap to. + */ + function positionShouldSnapToNode(sourceFile, pos, node) { + // Can’t use 'ts.positionBelongsToNode()' here because it cleverly accounts + // for missing nodes, which can’t really be considered when deciding what + // to select. + ts.Debug.assert(node.pos <= pos); + if (pos < node.end) { + return true; + } + var nodeEnd = node.getEnd(); + if (nodeEnd === pos) { + return ts.getTouchingPropertyName(sourceFile, pos).pos < node.end; + } + return false; + } + var isImport = ts.or(ts.isImportDeclaration, ts.isImportEqualsDeclaration); + /** + * Gets the children of a node to be considered for selection ranging, + * transforming them into an artificial tree according to their intuitive + * grouping where no grouping actually exists in the parse tree. For example, + * top-level imports are grouped into their own SyntaxList so they can be + * selected all together, even though in the AST they’re just siblings of each + * other as well as of other top-level statements and declarations. + */ + function getSelectionChildren(node) { + var _a; + // Group top-level imports + if (ts.isSourceFile(node)) { + return groupChildren(node.getChildAt(0).getChildren(), isImport); + } + // Mapped types _look_ like ObjectTypes with a single member, + // but in fact don’t contain a SyntaxList or a node containing + // the “key/value” pair like ObjectTypes do, but it seems intuitive + // that the selection would snap to those points. The philosophy + // of choosing a selection range is not so much about what the + // syntax currently _is_ as what the syntax might easily become + // if the user is making a selection; e.g., we synthesize a selection + // around the “key/value” pair not because there’s a node there, but + // because it allows the mapped type to become an object type with a + // few keystrokes. + if (ts.isMappedTypeNode(node)) { + var _b = node.getChildren(), openBraceToken = _b[0], children = _b.slice(1); + var closeBraceToken = ts.Debug.checkDefined(children.pop()); + ts.Debug.assertEqual(openBraceToken.kind, 18 /* SyntaxKind.OpenBraceToken */); + ts.Debug.assertEqual(closeBraceToken.kind, 19 /* SyntaxKind.CloseBraceToken */); + // Group `-/+readonly` and `-/+?` + var groupedWithPlusMinusTokens = groupChildren(children, function (child) { + return child === node.readonlyToken || child.kind === 146 /* SyntaxKind.ReadonlyKeyword */ || + child === node.questionToken || child.kind === 57 /* SyntaxKind.QuestionToken */; + }); + // Group type parameter with surrounding brackets + var groupedWithBrackets = groupChildren(groupedWithPlusMinusTokens, function (_a) { + var kind = _a.kind; + return kind === 22 /* SyntaxKind.OpenBracketToken */ || + kind === 165 /* SyntaxKind.TypeParameter */ || + kind === 23 /* SyntaxKind.CloseBracketToken */; + }); + return [ + openBraceToken, + // Pivot on `:` + createSyntaxList(splitChildren(groupedWithBrackets, function (_a) { + var kind = _a.kind; + return kind === 58 /* SyntaxKind.ColonToken */; + })), + closeBraceToken, + ]; + } + // Group modifiers and property name, then pivot on `:`. + if (ts.isPropertySignature(node)) { + var children = groupChildren(node.getChildren(), function (child) { + return child === node.name || ts.contains(node.modifiers, child); + }); + var firstJSDocChild = ((_a = children[0]) === null || _a === void 0 ? void 0 : _a.kind) === 323 /* SyntaxKind.JSDoc */ ? children[0] : undefined; + var withJSDocSeparated = firstJSDocChild ? children.slice(1) : children; + var splittedChildren = splitChildren(withJSDocSeparated, function (_a) { + var kind = _a.kind; + return kind === 58 /* SyntaxKind.ColonToken */; + }); + return firstJSDocChild ? [firstJSDocChild, createSyntaxList(splittedChildren)] : splittedChildren; + } + // Group the parameter name with its `...`, then that group with its `?`, then pivot on `=`. + if (ts.isParameter(node)) { + var groupedDotDotDotAndName_1 = groupChildren(node.getChildren(), function (child) { + return child === node.dotDotDotToken || child === node.name; + }); + var groupedWithQuestionToken = groupChildren(groupedDotDotDotAndName_1, function (child) { + return child === groupedDotDotDotAndName_1[0] || child === node.questionToken; + }); + return splitChildren(groupedWithQuestionToken, function (_a) { + var kind = _a.kind; + return kind === 63 /* SyntaxKind.EqualsToken */; + }); + } + // Pivot on '=' + if (ts.isBindingElement(node)) { + return splitChildren(node.getChildren(), function (_a) { + var kind = _a.kind; + return kind === 63 /* SyntaxKind.EqualsToken */; + }); + } + return node.getChildren(); + } + /** + * Groups sibling nodes together into their own SyntaxList if they + * a) are adjacent, AND b) match a predicate function. + */ + function groupChildren(children, groupOn) { + var result = []; + var group; + for (var _i = 0, children_1 = children; _i < children_1.length; _i++) { + var child = children_1[_i]; + if (groupOn(child)) { + group = group || []; + group.push(child); + } + else { + if (group) { + result.push(createSyntaxList(group)); + group = undefined; + } + result.push(child); + } + } + if (group) { + result.push(createSyntaxList(group)); + } + return result; + } + /** + * Splits sibling nodes into up to four partitions: + * 1) everything left of the first node matched by `pivotOn`, + * 2) the first node matched by `pivotOn`, + * 3) everything right of the first node matched by `pivotOn`, + * 4) a trailing semicolon, if `separateTrailingSemicolon` is enabled. + * The left and right groups, if not empty, will each be grouped into their own containing SyntaxList. + * @param children The sibling nodes to split. + * @param pivotOn The predicate function to match the node to be the pivot. The first node that matches + * the predicate will be used; any others that may match will be included into the right-hand group. + * @param separateTrailingSemicolon If the last token is a semicolon, it will be returned as a separate + * child rather than be included in the right-hand group. + */ + function splitChildren(children, pivotOn, separateTrailingSemicolon) { + if (separateTrailingSemicolon === void 0) { separateTrailingSemicolon = true; } + if (children.length < 2) { + return children; + } + var splitTokenIndex = ts.findIndex(children, pivotOn); + if (splitTokenIndex === -1) { + return children; + } + var leftChildren = children.slice(0, splitTokenIndex); + var splitToken = children[splitTokenIndex]; + var lastToken = ts.last(children); + var separateLastToken = separateTrailingSemicolon && lastToken.kind === 26 /* SyntaxKind.SemicolonToken */; + var rightChildren = children.slice(splitTokenIndex + 1, separateLastToken ? children.length - 1 : undefined); + var result = ts.compact([ + leftChildren.length ? createSyntaxList(leftChildren) : undefined, + splitToken, + rightChildren.length ? createSyntaxList(rightChildren) : undefined, + ]); + return separateLastToken ? result.concat(lastToken) : result; + } + function createSyntaxList(children) { + ts.Debug.assertGreaterThanOrEqual(children.length, 1); + return ts.setTextRangePosEnd(ts.parseNodeFactory.createSyntaxList(children), children[0].pos, ts.last(children).end); + } + function isListOpener(token) { + var kind = token && token.kind; + return kind === 18 /* SyntaxKind.OpenBraceToken */ + || kind === 22 /* SyntaxKind.OpenBracketToken */ + || kind === 20 /* SyntaxKind.OpenParenToken */ + || kind === 283 /* SyntaxKind.JsxOpeningElement */; + } + function isListCloser(token) { + var kind = token && token.kind; + return kind === 19 /* SyntaxKind.CloseBraceToken */ + || kind === 23 /* SyntaxKind.CloseBracketToken */ + || kind === 21 /* SyntaxKind.CloseParenToken */ + || kind === 284 /* SyntaxKind.JsxClosingElement */; + } + function getEndPos(sourceFile, node) { + switch (node.kind) { + case 343 /* SyntaxKind.JSDocParameterTag */: + case 341 /* SyntaxKind.JSDocCallbackTag */: + case 350 /* SyntaxKind.JSDocPropertyTag */: + case 348 /* SyntaxKind.JSDocTypedefTag */: + case 345 /* SyntaxKind.JSDocThisTag */: + return sourceFile.getLineEndOfPosition(node.getStart()); + default: + return node.getEnd(); + } + } + })(SmartSelectionRange = ts.SmartSelectionRange || (ts.SmartSelectionRange = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var SignatureHelp; + (function (SignatureHelp) { + var InvocationKind; + (function (InvocationKind) { + InvocationKind[InvocationKind["Call"] = 0] = "Call"; + InvocationKind[InvocationKind["TypeArgs"] = 1] = "TypeArgs"; + InvocationKind[InvocationKind["Contextual"] = 2] = "Contextual"; + })(InvocationKind || (InvocationKind = {})); + function getSignatureHelpItems(program, sourceFile, position, triggerReason, cancellationToken) { + var typeChecker = program.getTypeChecker(); + // Decide whether to show signature help + var startingToken = ts.findTokenOnLeftOfPosition(sourceFile, position); + if (!startingToken) { + // We are at the beginning of the file + return undefined; + } + // Only need to be careful if the user typed a character and signature help wasn't showing. + var onlyUseSyntacticOwners = !!triggerReason && triggerReason.kind === "characterTyped"; + // Bail out quickly in the middle of a string or comment, don't provide signature help unless the user explicitly requested it. + if (onlyUseSyntacticOwners && (ts.isInString(sourceFile, position, startingToken) || ts.isInComment(sourceFile, position))) { + return undefined; + } + var isManuallyInvoked = !!triggerReason && triggerReason.kind === "invoked"; + var argumentInfo = getContainingArgumentInfo(startingToken, position, sourceFile, typeChecker, isManuallyInvoked); + if (!argumentInfo) + return undefined; + cancellationToken.throwIfCancellationRequested(); + // Extra syntactic and semantic filtering of signature help + var candidateInfo = getCandidateOrTypeInfo(argumentInfo, typeChecker, sourceFile, startingToken, onlyUseSyntacticOwners); + cancellationToken.throwIfCancellationRequested(); + if (!candidateInfo) { + // We didn't have any sig help items produced by the TS compiler. If this is a JS + // file, then see if we can figure out anything better. + return ts.isSourceFileJS(sourceFile) ? createJSSignatureHelpItems(argumentInfo, program, cancellationToken) : undefined; + } + return typeChecker.runWithCancellationToken(cancellationToken, function (typeChecker) { + return candidateInfo.kind === 0 /* CandidateOrTypeKind.Candidate */ + ? createSignatureHelpItems(candidateInfo.candidates, candidateInfo.resolvedSignature, argumentInfo, sourceFile, typeChecker) + : createTypeHelpItems(candidateInfo.symbol, argumentInfo, sourceFile, typeChecker); + }); + } + SignatureHelp.getSignatureHelpItems = getSignatureHelpItems; + var CandidateOrTypeKind; + (function (CandidateOrTypeKind) { + CandidateOrTypeKind[CandidateOrTypeKind["Candidate"] = 0] = "Candidate"; + CandidateOrTypeKind[CandidateOrTypeKind["Type"] = 1] = "Type"; + })(CandidateOrTypeKind || (CandidateOrTypeKind = {})); + function getCandidateOrTypeInfo(_a, checker, sourceFile, startingToken, onlyUseSyntacticOwners) { + var invocation = _a.invocation, argumentCount = _a.argumentCount; + switch (invocation.kind) { + case 0 /* InvocationKind.Call */: { + if (onlyUseSyntacticOwners && !isSyntacticOwner(startingToken, invocation.node, sourceFile)) { + return undefined; + } + var candidates = []; + var resolvedSignature = checker.getResolvedSignatureForSignatureHelp(invocation.node, candidates, argumentCount); // TODO: GH#18217 + return candidates.length === 0 ? undefined : { kind: 0 /* CandidateOrTypeKind.Candidate */, candidates: candidates, resolvedSignature: resolvedSignature }; + } + case 1 /* InvocationKind.TypeArgs */: { + var called = invocation.called; + if (onlyUseSyntacticOwners && !containsPrecedingToken(startingToken, sourceFile, ts.isIdentifier(called) ? called.parent : called)) { + return undefined; + } + var candidates = ts.getPossibleGenericSignatures(called, argumentCount, checker); + if (candidates.length !== 0) + return { kind: 0 /* CandidateOrTypeKind.Candidate */, candidates: candidates, resolvedSignature: ts.first(candidates) }; + var symbol = checker.getSymbolAtLocation(called); + return symbol && { kind: 1 /* CandidateOrTypeKind.Type */, symbol: symbol }; + } + case 2 /* InvocationKind.Contextual */: + return { kind: 0 /* CandidateOrTypeKind.Candidate */, candidates: [invocation.signature], resolvedSignature: invocation.signature }; + default: + return ts.Debug.assertNever(invocation); + } + } + function isSyntacticOwner(startingToken, node, sourceFile) { + if (!ts.isCallOrNewExpression(node)) + return false; + var invocationChildren = node.getChildren(sourceFile); + switch (startingToken.kind) { + case 20 /* SyntaxKind.OpenParenToken */: + return ts.contains(invocationChildren, startingToken); + case 27 /* SyntaxKind.CommaToken */: { + var containingList = ts.findContainingList(startingToken); + return !!containingList && ts.contains(invocationChildren, containingList); + } + case 29 /* SyntaxKind.LessThanToken */: + return containsPrecedingToken(startingToken, sourceFile, node.expression); + default: + return false; + } + } + function createJSSignatureHelpItems(argumentInfo, program, cancellationToken) { + if (argumentInfo.invocation.kind === 2 /* InvocationKind.Contextual */) + return undefined; + // See if we can find some symbol with the call expression name that has call signatures. + var expression = getExpressionFromInvocation(argumentInfo.invocation); + var name = ts.isPropertyAccessExpression(expression) ? expression.name.text : undefined; + var typeChecker = program.getTypeChecker(); + return name === undefined ? undefined : ts.firstDefined(program.getSourceFiles(), function (sourceFile) { + return ts.firstDefined(sourceFile.getNamedDeclarations().get(name), function (declaration) { + var type = declaration.symbol && typeChecker.getTypeOfSymbolAtLocation(declaration.symbol, declaration); + var callSignatures = type && type.getCallSignatures(); + if (callSignatures && callSignatures.length) { + return typeChecker.runWithCancellationToken(cancellationToken, function (typeChecker) { return createSignatureHelpItems(callSignatures, callSignatures[0], argumentInfo, sourceFile, typeChecker, + /*useFullPrefix*/ true); }); + } + }); + }); + } + function containsPrecedingToken(startingToken, sourceFile, container) { + var pos = startingToken.getFullStart(); + // There’s a possibility that `startingToken.parent` contains only `startingToken` and + // missing nodes, none of which are valid to be returned by `findPrecedingToken`. In that + // case, the preceding token we want is actually higher up the tree—almost definitely the + // next parent, but theoretically the situation with missing nodes might be happening on + // multiple nested levels. + var currentParent = startingToken.parent; + while (currentParent) { + var precedingToken = ts.findPrecedingToken(pos, sourceFile, currentParent, /*excludeJsdoc*/ true); + if (precedingToken) { + return ts.rangeContainsRange(container, precedingToken); + } + currentParent = currentParent.parent; + } + return ts.Debug.fail("Could not find preceding token"); + } + function getArgumentInfoForCompletions(node, position, sourceFile) { + var info = getImmediatelyContainingArgumentInfo(node, position, sourceFile); + return !info || info.isTypeParameterList || info.invocation.kind !== 0 /* InvocationKind.Call */ ? undefined + : { invocation: info.invocation.node, argumentCount: info.argumentCount, argumentIndex: info.argumentIndex }; + } + SignatureHelp.getArgumentInfoForCompletions = getArgumentInfoForCompletions; + function getArgumentOrParameterListInfo(node, position, sourceFile) { + var info = getArgumentOrParameterListAndIndex(node, sourceFile); + if (!info) + return undefined; + var list = info.list, argumentIndex = info.argumentIndex; + var argumentCount = getArgumentCount(list, /*ignoreTrailingComma*/ ts.isInString(sourceFile, position, node)); + if (argumentIndex !== 0) { + ts.Debug.assertLessThan(argumentIndex, argumentCount); + } + var argumentsSpan = getApplicableSpanForArguments(list, sourceFile); + return { list: list, argumentIndex: argumentIndex, argumentCount: argumentCount, argumentsSpan: argumentsSpan }; + } + function getArgumentOrParameterListAndIndex(node, sourceFile) { + if (node.kind === 29 /* SyntaxKind.LessThanToken */ || node.kind === 20 /* SyntaxKind.OpenParenToken */) { + // Find the list that starts right *after* the < or ( token. + // If the user has just opened a list, consider this item 0. + return { list: getChildListThatStartsWithOpenerToken(node.parent, node, sourceFile), argumentIndex: 0 }; + } + else { + // findListItemInfo can return undefined if we are not in parent's argument list + // or type argument list. This includes cases where the cursor is: + // - To the right of the closing parenthesis, non-substitution template, or template tail. + // - Between the type arguments and the arguments (greater than token) + // - On the target of the call (parent.func) + // - On the 'new' keyword in a 'new' expression + var list = ts.findContainingList(node); + return list && { list: list, argumentIndex: getArgumentIndex(list, node) }; + } + } + /** + * Returns relevant information for the argument list and the current argument if we are + * in the argument of an invocation; returns undefined otherwise. + */ + function getImmediatelyContainingArgumentInfo(node, position, sourceFile) { + var parent = node.parent; + if (ts.isCallOrNewExpression(parent)) { + var invocation = parent; + // There are 3 cases to handle: + // 1. The token introduces a list, and should begin a signature help session + // 2. The token is either not associated with a list, or ends a list, so the session should end + // 3. The token is buried inside a list, and should give signature help + // + // The following are examples of each: + // + // Case 1: + // foo<#T, U>(#a, b) -> The token introduces a list, and should begin a signature help session + // Case 2: + // fo#o#(a, b)# -> The token is either not associated with a list, or ends a list, so the session should end + // Case 3: + // foo(a#, #b#) -> The token is buried inside a list, and should give signature help + // Find out if 'node' is an argument, a type argument, or neither + var info = getArgumentOrParameterListInfo(node, position, sourceFile); + if (!info) + return undefined; + var list = info.list, argumentIndex = info.argumentIndex, argumentCount = info.argumentCount, argumentsSpan = info.argumentsSpan; + var isTypeParameterList = !!parent.typeArguments && parent.typeArguments.pos === list.pos; + return { isTypeParameterList: isTypeParameterList, invocation: { kind: 0 /* InvocationKind.Call */, node: invocation }, argumentsSpan: argumentsSpan, argumentIndex: argumentIndex, argumentCount: argumentCount }; + } + else if (ts.isNoSubstitutionTemplateLiteral(node) && ts.isTaggedTemplateExpression(parent)) { + // Check if we're actually inside the template; + // otherwise we'll fall out and return undefined. + if (ts.isInsideTemplateLiteral(node, position, sourceFile)) { + return getArgumentListInfoForTemplate(parent, /*argumentIndex*/ 0, sourceFile); + } + return undefined; + } + else if (ts.isTemplateHead(node) && parent.parent.kind === 212 /* SyntaxKind.TaggedTemplateExpression */) { + var templateExpression = parent; + var tagExpression = templateExpression.parent; + ts.Debug.assert(templateExpression.kind === 225 /* SyntaxKind.TemplateExpression */); + var argumentIndex = ts.isInsideTemplateLiteral(node, position, sourceFile) ? 0 : 1; + return getArgumentListInfoForTemplate(tagExpression, argumentIndex, sourceFile); + } + else if (ts.isTemplateSpan(parent) && ts.isTaggedTemplateExpression(parent.parent.parent)) { + var templateSpan = parent; + var tagExpression = parent.parent.parent; + // If we're just after a template tail, don't show signature help. + if (ts.isTemplateTail(node) && !ts.isInsideTemplateLiteral(node, position, sourceFile)) { + return undefined; + } + var spanIndex = templateSpan.parent.templateSpans.indexOf(templateSpan); + var argumentIndex = getArgumentIndexForTemplatePiece(spanIndex, node, position, sourceFile); + return getArgumentListInfoForTemplate(tagExpression, argumentIndex, sourceFile); + } + else if (ts.isJsxOpeningLikeElement(parent)) { + // Provide a signature help for JSX opening element or JSX self-closing element. + // This is not guarantee that JSX tag-name is resolved into stateless function component. (that is done in "getSignatureHelpItems") + // i.e + // export function MainButton(props: ButtonProps, context: any): JSX.Element { ... } + // ' 'b'. So, in this case the arg count will be 2. However, there + // is a small subtlety. If you have "Foo(a,)", then the child list will just have + // 'a' ''. So, in the case where the last child is a comma, we increase the + // arg count by one to compensate. + // + // Note: this subtlety only applies to the last comma. If you had "Foo(a,," then + // we'll have: 'a' '' '' + // That will give us 2 non-commas. We then add one for the last comma, giving us an + // arg count of 3. + var listChildren = argumentsList.getChildren(); + var argumentCount = ts.countWhere(listChildren, function (arg) { return arg.kind !== 27 /* SyntaxKind.CommaToken */; }); + if (!ignoreTrailingComma && listChildren.length > 0 && ts.last(listChildren).kind === 27 /* SyntaxKind.CommaToken */) { + argumentCount++; + } + return argumentCount; + } + // spanIndex is either the index for a given template span. + // This does not give appropriate results for a NoSubstitutionTemplateLiteral + function getArgumentIndexForTemplatePiece(spanIndex, node, position, sourceFile) { + // Because the TemplateStringsArray is the first argument, we have to offset each substitution expression by 1. + // There are three cases we can encounter: + // 1. We are precisely in the template literal (argIndex = 0). + // 2. We are in or to the right of the substitution expression (argIndex = spanIndex + 1). + // 3. We are directly to the right of the template literal, but because we look for the token on the left, + // not enough to put us in the substitution expression; we should consider ourselves part of + // the *next* span's expression by offsetting the index (argIndex = (spanIndex + 1) + 1). + // + /* eslint-disable local/no-double-space */ + // Example: f `# abcd $#{# 1 + 1# }# efghi ${ #"#hello"# } # ` + // ^ ^ ^ ^ ^ ^ ^ ^ ^ + // Case: 1 1 3 2 1 3 2 2 1 + /* eslint-enable local/no-double-space */ + ts.Debug.assert(position >= node.getStart(), "Assumed 'position' could not occur before node."); + if (ts.isTemplateLiteralToken(node)) { + if (ts.isInsideTemplateLiteral(node, position, sourceFile)) { + return 0; + } + return spanIndex + 2; + } + return spanIndex + 1; + } + function getArgumentListInfoForTemplate(tagExpression, argumentIndex, sourceFile) { + // argumentCount is either 1 or (numSpans + 1) to account for the template strings array argument. + var argumentCount = ts.isNoSubstitutionTemplateLiteral(tagExpression.template) ? 1 : tagExpression.template.templateSpans.length + 1; + if (argumentIndex !== 0) { + ts.Debug.assertLessThan(argumentIndex, argumentCount); + } + return { + isTypeParameterList: false, + invocation: { kind: 0 /* InvocationKind.Call */, node: tagExpression }, + argumentsSpan: getApplicableSpanForTaggedTemplate(tagExpression, sourceFile), + argumentIndex: argumentIndex, + argumentCount: argumentCount + }; + } + function getApplicableSpanForArguments(argumentsList, sourceFile) { + // We use full start and skip trivia on the end because we want to include trivia on + // both sides. For example, + // + // foo( /*comment */ a, b, c /*comment*/ ) + // | | + // + // The applicable span is from the first bar to the second bar (inclusive, + // but not including parentheses) + var applicableSpanStart = argumentsList.getFullStart(); + var applicableSpanEnd = ts.skipTrivia(sourceFile.text, argumentsList.getEnd(), /*stopAfterLineBreak*/ false); + return ts.createTextSpan(applicableSpanStart, applicableSpanEnd - applicableSpanStart); + } + function getApplicableSpanForTaggedTemplate(taggedTemplate, sourceFile) { + var template = taggedTemplate.template; + var applicableSpanStart = template.getStart(); + var applicableSpanEnd = template.getEnd(); + // We need to adjust the end position for the case where the template does not have a tail. + // Otherwise, we will not show signature help past the expression. + // For example, + // + // ` ${ 1 + 1 foo(10) + // | | + // This is because a Missing node has no width. However, what we actually want is to include trivia + // leading up to the next token in case the user is about to type in a TemplateMiddle or TemplateTail. + if (template.kind === 225 /* SyntaxKind.TemplateExpression */) { + var lastSpan = ts.last(template.templateSpans); + if (lastSpan.literal.getFullWidth() === 0) { + applicableSpanEnd = ts.skipTrivia(sourceFile.text, applicableSpanEnd, /*stopAfterLineBreak*/ false); + } + } + return ts.createTextSpan(applicableSpanStart, applicableSpanEnd - applicableSpanStart); + } + function getContainingArgumentInfo(node, position, sourceFile, checker, isManuallyInvoked) { + var _loop_7 = function (n) { + // If the node is not a subspan of its parent, this is a big problem. + // There have been crashes that might be caused by this violation. + ts.Debug.assert(ts.rangeContainsRange(n.parent, n), "Not a subspan", function () { return "Child: ".concat(ts.Debug.formatSyntaxKind(n.kind), ", parent: ").concat(ts.Debug.formatSyntaxKind(n.parent.kind)); }); + var argumentInfo = getImmediatelyContainingArgumentOrContextualParameterInfo(n, position, sourceFile, checker); + if (argumentInfo) { + return { value: argumentInfo }; + } + }; + for (var n = node; !ts.isSourceFile(n) && (isManuallyInvoked || !ts.isBlock(n)); n = n.parent) { + var state_4 = _loop_7(n); + if (typeof state_4 === "object") + return state_4.value; + } + return undefined; + } + function getChildListThatStartsWithOpenerToken(parent, openerToken, sourceFile) { + var children = parent.getChildren(sourceFile); + var indexOfOpenerToken = children.indexOf(openerToken); + ts.Debug.assert(indexOfOpenerToken >= 0 && children.length > indexOfOpenerToken + 1); + return children[indexOfOpenerToken + 1]; + } + function getExpressionFromInvocation(invocation) { + return invocation.kind === 0 /* InvocationKind.Call */ ? ts.getInvokedExpression(invocation.node) : invocation.called; + } + function getEnclosingDeclarationFromInvocation(invocation) { + return invocation.kind === 0 /* InvocationKind.Call */ ? invocation.node : invocation.kind === 1 /* InvocationKind.TypeArgs */ ? invocation.called : invocation.node; + } + var signatureHelpNodeBuilderFlags = 8192 /* NodeBuilderFlags.OmitParameterModifiers */ | 70221824 /* NodeBuilderFlags.IgnoreErrors */ | 16384 /* NodeBuilderFlags.UseAliasDefinedOutsideCurrentScope */; + function createSignatureHelpItems(candidates, resolvedSignature, _a, sourceFile, typeChecker, useFullPrefix) { + var _b; + var isTypeParameterList = _a.isTypeParameterList, argumentCount = _a.argumentCount, applicableSpan = _a.argumentsSpan, invocation = _a.invocation, argumentIndex = _a.argumentIndex; + var enclosingDeclaration = getEnclosingDeclarationFromInvocation(invocation); + var callTargetSymbol = invocation.kind === 2 /* InvocationKind.Contextual */ ? invocation.symbol : (typeChecker.getSymbolAtLocation(getExpressionFromInvocation(invocation)) || useFullPrefix && ((_b = resolvedSignature.declaration) === null || _b === void 0 ? void 0 : _b.symbol)); + var callTargetDisplayParts = callTargetSymbol ? ts.symbolToDisplayParts(typeChecker, callTargetSymbol, useFullPrefix ? sourceFile : undefined, /*meaning*/ undefined) : ts.emptyArray; + var items = ts.map(candidates, function (candidateSignature) { return getSignatureHelpItem(candidateSignature, callTargetDisplayParts, isTypeParameterList, typeChecker, enclosingDeclaration, sourceFile); }); + if (argumentIndex !== 0) { + ts.Debug.assertLessThan(argumentIndex, argumentCount); + } + var selectedItemIndex = 0; + var itemsSeen = 0; + for (var i = 0; i < items.length; i++) { + var item = items[i]; + if (candidates[i] === resolvedSignature) { + selectedItemIndex = itemsSeen; + if (item.length > 1) { + // check to see if any items in the list better match than the first one, as the checker isn't filtering the nested lists + // (those come from tuple parameter expansion) + var count = 0; + for (var _i = 0, item_1 = item; _i < item_1.length; _i++) { + var i_1 = item_1[_i]; + if (i_1.isVariadic || i_1.parameters.length >= argumentCount) { + selectedItemIndex = itemsSeen + count; + break; + } + count++; + } + } + } + itemsSeen += item.length; + } + ts.Debug.assert(selectedItemIndex !== -1); // If candidates is non-empty it should always include bestSignature. We check for an empty candidates before calling this function. + var help = { items: ts.flatMapToMutable(items, ts.identity), applicableSpan: applicableSpan, selectedItemIndex: selectedItemIndex, argumentIndex: argumentIndex, argumentCount: argumentCount }; + var selected = help.items[selectedItemIndex]; + if (selected.isVariadic) { + var firstRest = ts.findIndex(selected.parameters, function (p) { return !!p.isRest; }); + if (-1 < firstRest && firstRest < selected.parameters.length - 1) { + // We don't have any code to get this correct; instead, don't highlight a current parameter AT ALL + help.argumentIndex = selected.parameters.length; + } + else { + help.argumentIndex = Math.min(help.argumentIndex, selected.parameters.length - 1); + } + } + return help; + } + function createTypeHelpItems(symbol, _a, sourceFile, checker) { + var argumentCount = _a.argumentCount, applicableSpan = _a.argumentsSpan, invocation = _a.invocation, argumentIndex = _a.argumentIndex; + var typeParameters = checker.getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol); + if (!typeParameters) + return undefined; + var items = [getTypeHelpItem(symbol, typeParameters, checker, getEnclosingDeclarationFromInvocation(invocation), sourceFile)]; + return { items: items, applicableSpan: applicableSpan, selectedItemIndex: 0, argumentIndex: argumentIndex, argumentCount: argumentCount }; + } + function getTypeHelpItem(symbol, typeParameters, checker, enclosingDeclaration, sourceFile) { + var typeSymbolDisplay = ts.symbolToDisplayParts(checker, symbol); + var printer = ts.createPrinter({ removeComments: true }); + var parameters = typeParameters.map(function (t) { return createSignatureHelpParameterForTypeParameter(t, checker, enclosingDeclaration, sourceFile, printer); }); + var documentation = symbol.getDocumentationComment(checker); + var tags = symbol.getJsDocTags(checker); + var prefixDisplayParts = __spreadArray(__spreadArray([], typeSymbolDisplay, true), [ts.punctuationPart(29 /* SyntaxKind.LessThanToken */)], false); + return { isVariadic: false, prefixDisplayParts: prefixDisplayParts, suffixDisplayParts: [ts.punctuationPart(31 /* SyntaxKind.GreaterThanToken */)], separatorDisplayParts: separatorDisplayParts, parameters: parameters, documentation: documentation, tags: tags }; + } + var separatorDisplayParts = [ts.punctuationPart(27 /* SyntaxKind.CommaToken */), ts.spacePart()]; + function getSignatureHelpItem(candidateSignature, callTargetDisplayParts, isTypeParameterList, checker, enclosingDeclaration, sourceFile) { + var infos = (isTypeParameterList ? itemInfoForTypeParameters : itemInfoForParameters)(candidateSignature, checker, enclosingDeclaration, sourceFile); + return ts.map(infos, function (_a) { + var isVariadic = _a.isVariadic, parameters = _a.parameters, prefix = _a.prefix, suffix = _a.suffix; + var prefixDisplayParts = __spreadArray(__spreadArray([], callTargetDisplayParts, true), prefix, true); + var suffixDisplayParts = __spreadArray(__spreadArray([], suffix, true), returnTypeToDisplayParts(candidateSignature, enclosingDeclaration, checker), true); + var documentation = candidateSignature.getDocumentationComment(checker); + var tags = candidateSignature.getJsDocTags(); + return { isVariadic: isVariadic, prefixDisplayParts: prefixDisplayParts, suffixDisplayParts: suffixDisplayParts, separatorDisplayParts: separatorDisplayParts, parameters: parameters, documentation: documentation, tags: tags }; + }); + } + function returnTypeToDisplayParts(candidateSignature, enclosingDeclaration, checker) { + return ts.mapToDisplayParts(function (writer) { + writer.writePunctuation(":"); + writer.writeSpace(" "); + var predicate = checker.getTypePredicateOfSignature(candidateSignature); + if (predicate) { + checker.writeTypePredicate(predicate, enclosingDeclaration, /*flags*/ undefined, writer); + } + else { + checker.writeType(checker.getReturnTypeOfSignature(candidateSignature), enclosingDeclaration, /*flags*/ undefined, writer); + } + }); + } + function itemInfoForTypeParameters(candidateSignature, checker, enclosingDeclaration, sourceFile) { + var typeParameters = (candidateSignature.target || candidateSignature).typeParameters; + var printer = ts.createPrinter({ removeComments: true }); + var parameters = (typeParameters || ts.emptyArray).map(function (t) { return createSignatureHelpParameterForTypeParameter(t, checker, enclosingDeclaration, sourceFile, printer); }); + var thisParameter = candidateSignature.thisParameter ? [checker.symbolToParameterDeclaration(candidateSignature.thisParameter, enclosingDeclaration, signatureHelpNodeBuilderFlags)] : []; + return checker.getExpandedParameters(candidateSignature).map(function (paramList) { + var params = ts.factory.createNodeArray(__spreadArray(__spreadArray([], thisParameter, true), ts.map(paramList, function (param) { return checker.symbolToParameterDeclaration(param, enclosingDeclaration, signatureHelpNodeBuilderFlags); }), true)); + var parameterParts = ts.mapToDisplayParts(function (writer) { + printer.writeList(2576 /* ListFormat.CallExpressionArguments */, params, sourceFile, writer); + }); + return { isVariadic: false, parameters: parameters, prefix: [ts.punctuationPart(29 /* SyntaxKind.LessThanToken */)], suffix: __spreadArray([ts.punctuationPart(31 /* SyntaxKind.GreaterThanToken */)], parameterParts, true) }; + }); + } + function itemInfoForParameters(candidateSignature, checker, enclosingDeclaration, sourceFile) { + var printer = ts.createPrinter({ removeComments: true }); + var typeParameterParts = ts.mapToDisplayParts(function (writer) { + if (candidateSignature.typeParameters && candidateSignature.typeParameters.length) { + var args = ts.factory.createNodeArray(candidateSignature.typeParameters.map(function (p) { return checker.typeParameterToDeclaration(p, enclosingDeclaration, signatureHelpNodeBuilderFlags); })); + printer.writeList(53776 /* ListFormat.TypeParameters */, args, sourceFile, writer); + } + }); + var lists = checker.getExpandedParameters(candidateSignature); + var isVariadic = !checker.hasEffectiveRestParameter(candidateSignature) ? function (_) { return false; } + : lists.length === 1 ? function (_) { return true; } + : function (pList) { return !!(pList.length && pList[pList.length - 1].checkFlags & 32768 /* CheckFlags.RestParameter */); }; + return lists.map(function (parameterList) { return ({ + isVariadic: isVariadic(parameterList), + parameters: parameterList.map(function (p) { return createSignatureHelpParameterForParameter(p, checker, enclosingDeclaration, sourceFile, printer); }), + prefix: __spreadArray(__spreadArray([], typeParameterParts, true), [ts.punctuationPart(20 /* SyntaxKind.OpenParenToken */)], false), + suffix: [ts.punctuationPart(21 /* SyntaxKind.CloseParenToken */)] + }); }); + } + function createSignatureHelpParameterForParameter(parameter, checker, enclosingDeclaration, sourceFile, printer) { + var displayParts = ts.mapToDisplayParts(function (writer) { + var param = checker.symbolToParameterDeclaration(parameter, enclosingDeclaration, signatureHelpNodeBuilderFlags); + printer.writeNode(4 /* EmitHint.Unspecified */, param, sourceFile, writer); + }); + var isOptional = checker.isOptionalParameter(parameter.valueDeclaration); + var isRest = !!(parameter.checkFlags & 32768 /* CheckFlags.RestParameter */); + return { name: parameter.name, documentation: parameter.getDocumentationComment(checker), displayParts: displayParts, isOptional: isOptional, isRest: isRest }; + } + function createSignatureHelpParameterForTypeParameter(typeParameter, checker, enclosingDeclaration, sourceFile, printer) { + var displayParts = ts.mapToDisplayParts(function (writer) { + var param = checker.typeParameterToDeclaration(typeParameter, enclosingDeclaration, signatureHelpNodeBuilderFlags); + printer.writeNode(4 /* EmitHint.Unspecified */, param, sourceFile, writer); + }); + return { name: typeParameter.symbol.name, documentation: typeParameter.symbol.getDocumentationComment(checker), displayParts: displayParts, isOptional: false, isRest: false }; + } + })(SignatureHelp = ts.SignatureHelp || (ts.SignatureHelp = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var InlayHints; + (function (InlayHints) { + var maxHintsLength = 30; + var leadingParameterNameCommentRegexFactory = function (name) { + return new RegExp("^\\s?/\\*\\*?\\s?".concat(name, "\\s?\\*\\/\\s?$")); + }; + function shouldShowParameterNameHints(preferences) { + return preferences.includeInlayParameterNameHints === "literals" || preferences.includeInlayParameterNameHints === "all"; + } + function shouldShowLiteralParameterNameHintsOnly(preferences) { + return preferences.includeInlayParameterNameHints === "literals"; + } + function provideInlayHints(context) { + var file = context.file, program = context.program, span = context.span, cancellationToken = context.cancellationToken, preferences = context.preferences; + var sourceFileText = file.text; + var compilerOptions = program.getCompilerOptions(); + var checker = program.getTypeChecker(); + var result = []; + visitor(file); + return result; + function visitor(node) { + if (!node || node.getFullWidth() === 0) { + return; + } + switch (node.kind) { + case 264 /* SyntaxKind.ModuleDeclaration */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + case 215 /* SyntaxKind.FunctionExpression */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 216 /* SyntaxKind.ArrowFunction */: + cancellationToken.throwIfCancellationRequested(); + } + if (!ts.textSpanIntersectsWith(span, node.pos, node.getFullWidth())) { + return; + } + if (ts.isTypeNode(node) && !ts.isExpressionWithTypeArguments(node)) { + return; + } + if (preferences.includeInlayVariableTypeHints && ts.isVariableDeclaration(node)) { + visitVariableLikeDeclaration(node); + } + else if (preferences.includeInlayPropertyDeclarationTypeHints && ts.isPropertyDeclaration(node)) { + visitVariableLikeDeclaration(node); + } + else if (preferences.includeInlayEnumMemberValueHints && ts.isEnumMember(node)) { + visitEnumMember(node); + } + else if (shouldShowParameterNameHints(preferences) && (ts.isCallExpression(node) || ts.isNewExpression(node))) { + visitCallOrNewExpression(node); + } + else { + if (preferences.includeInlayFunctionParameterTypeHints && ts.isFunctionLikeDeclaration(node) && ts.hasContextSensitiveParameters(node)) { + visitFunctionLikeForParameterType(node); + } + if (preferences.includeInlayFunctionLikeReturnTypeHints && isSignatureSupportingReturnAnnotation(node)) { + visitFunctionDeclarationLikeForReturnType(node); + } + } + return ts.forEachChild(node, visitor); + } + function isSignatureSupportingReturnAnnotation(node) { + return ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node) || ts.isMethodDeclaration(node) || ts.isGetAccessorDeclaration(node); + } + function addParameterHints(text, position, isFirstVariadicArgument) { + result.push({ + text: "".concat(isFirstVariadicArgument ? "..." : "").concat(truncation(text, maxHintsLength), ":"), + position: position, + kind: "Parameter" /* InlayHintKind.Parameter */, + whitespaceAfter: true, + }); + } + function addTypeHints(text, position) { + result.push({ + text: ": ".concat(truncation(text, maxHintsLength)), + position: position, + kind: "Type" /* InlayHintKind.Type */, + whitespaceBefore: true, + }); + } + function addEnumMemberValueHints(text, position) { + result.push({ + text: "= ".concat(truncation(text, maxHintsLength)), + position: position, + kind: "Enum" /* InlayHintKind.Enum */, + whitespaceBefore: true, + }); + } + function visitEnumMember(member) { + if (member.initializer) { + return; + } + var enumValue = checker.getConstantValue(member); + if (enumValue !== undefined) { + addEnumMemberValueHints(enumValue.toString(), member.end); + } + } + function isModuleReferenceType(type) { + return type.symbol && (type.symbol.flags & 1536 /* SymbolFlags.Module */); + } + function visitVariableLikeDeclaration(decl) { + if (!decl.initializer || ts.isBindingPattern(decl.name) || ts.isVariableDeclaration(decl) && !isHintableDeclaration(decl)) { + return; + } + var effectiveTypeAnnotation = ts.getEffectiveTypeAnnotationNode(decl); + if (effectiveTypeAnnotation) { + return; + } + var declarationType = checker.getTypeAtLocation(decl); + if (isModuleReferenceType(declarationType)) { + return; + } + var typeDisplayString = printTypeInSingleLine(declarationType); + if (typeDisplayString) { + var isVariableNameMatchesType = preferences.includeInlayVariableTypeHintsWhenTypeMatchesName === false && ts.equateStringsCaseInsensitive(decl.name.getText(), typeDisplayString); + if (isVariableNameMatchesType) { + return; + } + addTypeHints(typeDisplayString, decl.name.end); + } + } + function visitCallOrNewExpression(expr) { + var args = expr.arguments; + if (!args || !args.length) { + return; + } + var candidates = []; + var signature = checker.getResolvedSignatureForSignatureHelp(expr, candidates); + if (!signature || !candidates.length) { + return; + } + for (var i = 0; i < args.length; ++i) { + var originalArg = args[i]; + var arg = ts.skipParentheses(originalArg); + if (shouldShowLiteralParameterNameHintsOnly(preferences) && !isHintableLiteral(arg)) { + continue; + } + var identifierNameInfo = checker.getParameterIdentifierNameAtPosition(signature, i); + if (identifierNameInfo) { + var parameterName = identifierNameInfo[0], isFirstVariadicArgument = identifierNameInfo[1]; + var isParameterNameNotSameAsArgument = preferences.includeInlayParameterNameHintsWhenArgumentMatchesName || !identifierOrAccessExpressionPostfixMatchesParameterName(arg, parameterName); + if (!isParameterNameNotSameAsArgument && !isFirstVariadicArgument) { + continue; + } + var name = ts.unescapeLeadingUnderscores(parameterName); + if (leadingCommentsContainsParameterName(arg, name)) { + continue; + } + addParameterHints(name, originalArg.getStart(), isFirstVariadicArgument); + } + } + } + function identifierOrAccessExpressionPostfixMatchesParameterName(expr, parameterName) { + if (ts.isIdentifier(expr)) { + return expr.text === parameterName; + } + if (ts.isPropertyAccessExpression(expr)) { + return expr.name.text === parameterName; + } + return false; + } + function leadingCommentsContainsParameterName(node, name) { + if (!ts.isIdentifierText(name, compilerOptions.target, ts.getLanguageVariant(file.scriptKind))) { + return false; + } + var ranges = ts.getLeadingCommentRanges(sourceFileText, node.pos); + if (!(ranges === null || ranges === void 0 ? void 0 : ranges.length)) { + return false; + } + var regex = leadingParameterNameCommentRegexFactory(name); + return ts.some(ranges, function (range) { return regex.test(sourceFileText.substring(range.pos, range.end)); }); + } + function isHintableLiteral(node) { + switch (node.kind) { + case 221 /* SyntaxKind.PrefixUnaryExpression */: { + var operand = node.operand; + return ts.isLiteralExpression(operand) || ts.isIdentifier(operand) && ts.isInfinityOrNaNString(operand.escapedText); + } + case 110 /* SyntaxKind.TrueKeyword */: + case 95 /* SyntaxKind.FalseKeyword */: + case 104 /* SyntaxKind.NullKeyword */: + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + case 225 /* SyntaxKind.TemplateExpression */: + return true; + case 79 /* SyntaxKind.Identifier */: { + var name = node.escapedText; + return isUndefined(name) || ts.isInfinityOrNaNString(name); + } + } + return ts.isLiteralExpression(node); + } + function visitFunctionDeclarationLikeForReturnType(decl) { + if (ts.isArrowFunction(decl)) { + if (!ts.findChildOfKind(decl, 20 /* SyntaxKind.OpenParenToken */, file)) { + return; + } + } + var effectiveTypeAnnotation = ts.getEffectiveReturnTypeNode(decl); + if (effectiveTypeAnnotation || !decl.body) { + return; + } + var signature = checker.getSignatureFromDeclaration(decl); + if (!signature) { + return; + } + var returnType = checker.getReturnTypeOfSignature(signature); + if (isModuleReferenceType(returnType)) { + return; + } + var typeDisplayString = printTypeInSingleLine(returnType); + if (!typeDisplayString) { + return; + } + addTypeHints(typeDisplayString, getTypeAnnotationPosition(decl)); + } + function getTypeAnnotationPosition(decl) { + var closeParenToken = ts.findChildOfKind(decl, 21 /* SyntaxKind.CloseParenToken */, file); + if (closeParenToken) { + return closeParenToken.end; + } + return decl.parameters.end; + } + function visitFunctionLikeForParameterType(node) { + var signature = checker.getSignatureFromDeclaration(node); + if (!signature) { + return; + } + for (var i = 0; i < node.parameters.length && i < signature.parameters.length; ++i) { + var param = node.parameters[i]; + if (!isHintableDeclaration(param)) { + continue; + } + var effectiveTypeAnnotation = ts.getEffectiveTypeAnnotationNode(param); + if (effectiveTypeAnnotation) { + continue; + } + var typeDisplayString = getParameterDeclarationTypeDisplayString(signature.parameters[i]); + if (!typeDisplayString) { + continue; + } + addTypeHints(typeDisplayString, param.questionToken ? param.questionToken.end : param.name.end); + } + } + function getParameterDeclarationTypeDisplayString(symbol) { + var valueDeclaration = symbol.valueDeclaration; + if (!valueDeclaration || !ts.isParameter(valueDeclaration)) { + return undefined; + } + var signatureParamType = checker.getTypeOfSymbolAtLocation(symbol, valueDeclaration); + if (isModuleReferenceType(signatureParamType)) { + return undefined; + } + return printTypeInSingleLine(signatureParamType); + } + function truncation(text, maxLength) { + if (text.length > maxLength) { + return text.substr(0, maxLength - "...".length) + "..."; + } + return text; + } + function printTypeInSingleLine(type) { + var flags = 70221824 /* NodeBuilderFlags.IgnoreErrors */ | 1048576 /* TypeFormatFlags.AllowUniqueESSymbolType */ | 16384 /* TypeFormatFlags.UseAliasDefinedOutsideCurrentScope */; + var options = { removeComments: true }; + var printer = ts.createPrinter(options); + return ts.usingSingleLineStringWriter(function (writer) { + var typeNode = checker.typeToTypeNode(type, /*enclosingDeclaration*/ undefined, flags, writer); + ts.Debug.assertIsDefined(typeNode, "should always get typenode"); + printer.writeNode(4 /* EmitHint.Unspecified */, typeNode, /*sourceFile*/ file, writer); + }); + } + function isUndefined(name) { + return name === "undefined"; + } + function isHintableDeclaration(node) { + if ((ts.isParameterDeclaration(node) || ts.isVariableDeclaration(node) && ts.isVarConst(node)) && node.initializer) { + var initializer = ts.skipParentheses(node.initializer); + return !(isHintableLiteral(initializer) || ts.isNewExpression(initializer) || ts.isObjectLiteralExpression(initializer) || ts.isAssertionExpression(initializer)); + } + return true; + } + } + InlayHints.provideInlayHints = provideInlayHints; + })(InlayHints = ts.InlayHints || (ts.InlayHints = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var base64UrlRegExp = /^data:(?:application\/json(?:;charset=[uU][tT][fF]-8);base64,([A-Za-z0-9+\/=]+)$)?/; + function getSourceMapper(host) { + var getCanonicalFileName = ts.createGetCanonicalFileName(host.useCaseSensitiveFileNames()); + var currentDirectory = host.getCurrentDirectory(); + var sourceFileLike = new ts.Map(); + var documentPositionMappers = new ts.Map(); + return { tryGetSourcePosition: tryGetSourcePosition, tryGetGeneratedPosition: tryGetGeneratedPosition, toLineColumnOffset: toLineColumnOffset, clearCache: clearCache }; + function toPath(fileName) { + return ts.toPath(fileName, currentDirectory, getCanonicalFileName); + } + function getDocumentPositionMapper(generatedFileName, sourceFileName) { + var path = toPath(generatedFileName); + var value = documentPositionMappers.get(path); + if (value) + return value; + var mapper; + if (host.getDocumentPositionMapper) { + mapper = host.getDocumentPositionMapper(generatedFileName, sourceFileName); + } + else if (host.readFile) { + var file = getSourceFileLike(generatedFileName); + mapper = file && ts.getDocumentPositionMapper({ getSourceFileLike: getSourceFileLike, getCanonicalFileName: getCanonicalFileName, log: function (s) { return host.log(s); } }, generatedFileName, ts.getLineInfo(file.text, ts.getLineStarts(file)), function (f) { return !host.fileExists || host.fileExists(f) ? host.readFile(f) : undefined; }); + } + documentPositionMappers.set(path, mapper || ts.identitySourceMapConsumer); + return mapper || ts.identitySourceMapConsumer; + } + function tryGetSourcePosition(info) { + if (!ts.isDeclarationFileName(info.fileName)) + return undefined; + var file = getSourceFile(info.fileName); + if (!file) + return undefined; + var newLoc = getDocumentPositionMapper(info.fileName).getSourcePosition(info); + return !newLoc || newLoc === info ? undefined : tryGetSourcePosition(newLoc) || newLoc; + } + function tryGetGeneratedPosition(info) { + if (ts.isDeclarationFileName(info.fileName)) + return undefined; + var sourceFile = getSourceFile(info.fileName); + if (!sourceFile) + return undefined; + var program = host.getProgram(); + // If this is source file of project reference source (instead of redirect) there is no generated position + if (program.isSourceOfProjectReferenceRedirect(sourceFile.fileName)) { + return undefined; + } + var options = program.getCompilerOptions(); + var outPath = ts.outFile(options); + var declarationPath = outPath ? + ts.removeFileExtension(outPath) + ".d.ts" /* Extension.Dts */ : + ts.getDeclarationEmitOutputFilePathWorker(info.fileName, program.getCompilerOptions(), currentDirectory, program.getCommonSourceDirectory(), getCanonicalFileName); + if (declarationPath === undefined) + return undefined; + var newLoc = getDocumentPositionMapper(declarationPath, info.fileName).getGeneratedPosition(info); + return newLoc === info ? undefined : newLoc; + } + function getSourceFile(fileName) { + var program = host.getProgram(); + if (!program) + return undefined; + var path = toPath(fileName); + // file returned here could be .d.ts when asked for .ts file if projectReferences and module resolution created this source file + var file = program.getSourceFileByPath(path); + return file && file.resolvedPath === path ? file : undefined; + } + function getOrCreateSourceFileLike(fileName) { + var path = toPath(fileName); + var fileFromCache = sourceFileLike.get(path); + if (fileFromCache !== undefined) + return fileFromCache ? fileFromCache : undefined; + if (!host.readFile || host.fileExists && !host.fileExists(path)) { + sourceFileLike.set(path, false); + return undefined; + } + // And failing that, check the disk + var text = host.readFile(path); + var file = text ? createSourceFileLike(text) : false; + sourceFileLike.set(path, file); + return file ? file : undefined; + } + // This can be called from source mapper in either source program or program that includes generated file + function getSourceFileLike(fileName) { + return !host.getSourceFileLike ? + getSourceFile(fileName) || getOrCreateSourceFileLike(fileName) : + host.getSourceFileLike(fileName); + } + function toLineColumnOffset(fileName, position) { + var file = getSourceFileLike(fileName); // TODO: GH#18217 + return file.getLineAndCharacterOfPosition(position); + } + function clearCache() { + sourceFileLike.clear(); + documentPositionMappers.clear(); + } + } + ts.getSourceMapper = getSourceMapper; + function getDocumentPositionMapper(host, generatedFileName, generatedFileLineInfo, readMapFile) { + var mapFileName = ts.tryGetSourceMappingURL(generatedFileLineInfo); + if (mapFileName) { + var match = base64UrlRegExp.exec(mapFileName); + if (match) { + if (match[1]) { + var base64Object = match[1]; + return convertDocumentToSourceMapper(host, ts.base64decode(ts.sys, base64Object), generatedFileName); + } + // Not a data URL we can parse, skip it + mapFileName = undefined; + } + } + var possibleMapLocations = []; + if (mapFileName) { + possibleMapLocations.push(mapFileName); + } + possibleMapLocations.push(generatedFileName + ".map"); + var originalMapFileName = mapFileName && ts.getNormalizedAbsolutePath(mapFileName, ts.getDirectoryPath(generatedFileName)); + for (var _i = 0, possibleMapLocations_1 = possibleMapLocations; _i < possibleMapLocations_1.length; _i++) { + var location = possibleMapLocations_1[_i]; + var mapFileName_1 = ts.getNormalizedAbsolutePath(location, ts.getDirectoryPath(generatedFileName)); + var mapFileContents = readMapFile(mapFileName_1, originalMapFileName); + if (ts.isString(mapFileContents)) { + return convertDocumentToSourceMapper(host, mapFileContents, mapFileName_1); + } + if (mapFileContents !== undefined) { + return mapFileContents || undefined; + } + } + return undefined; + } + ts.getDocumentPositionMapper = getDocumentPositionMapper; + function convertDocumentToSourceMapper(host, contents, mapFileName) { + var map = ts.tryParseRawSourceMap(contents); + if (!map || !map.sources || !map.file || !map.mappings) { + // obviously invalid map + return undefined; + } + // Dont support sourcemaps that contain inlined sources + if (map.sourcesContent && map.sourcesContent.some(ts.isString)) + return undefined; + return ts.createDocumentPositionMapper(host, map, mapFileName); + } + function createSourceFileLike(text, lineMap) { + return { + text: text, + lineMap: lineMap, + getLineAndCharacterOfPosition: function (pos) { + return ts.computeLineAndCharacterOfPosition(ts.getLineStarts(this), pos); + } + }; + } +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var visitedNestedConvertibleFunctions = new ts.Map(); + function computeSuggestionDiagnostics(sourceFile, program, cancellationToken) { + program.getSemanticDiagnostics(sourceFile, cancellationToken); + var diags = []; + var checker = program.getTypeChecker(); + var isCommonJSFile = sourceFile.impliedNodeFormat === ts.ModuleKind.CommonJS || ts.fileExtensionIsOneOf(sourceFile.fileName, [".cts" /* Extension.Cts */, ".cjs" /* Extension.Cjs */]); + if (!isCommonJSFile && + sourceFile.commonJsModuleIndicator && + (ts.programContainsEsModules(program) || ts.compilerOptionsIndicateEsModules(program.getCompilerOptions())) && + containsTopLevelCommonjs(sourceFile)) { + diags.push(ts.createDiagnosticForNode(getErrorNodeFromCommonJsIndicator(sourceFile.commonJsModuleIndicator), ts.Diagnostics.File_is_a_CommonJS_module_it_may_be_converted_to_an_ES_module)); + } + var isJsFile = ts.isSourceFileJS(sourceFile); + visitedNestedConvertibleFunctions.clear(); + check(sourceFile); + if (ts.getAllowSyntheticDefaultImports(program.getCompilerOptions())) { + for (var _i = 0, _a = sourceFile.imports; _i < _a.length; _i++) { + var moduleSpecifier = _a[_i]; + var importNode = ts.importFromModuleSpecifier(moduleSpecifier); + var name = importNameForConvertToDefaultImport(importNode); + if (!name) + continue; + var module_1 = ts.getResolvedModule(sourceFile, moduleSpecifier.text, ts.getModeForUsageLocation(sourceFile, moduleSpecifier)); + var resolvedFile = module_1 && program.getSourceFile(module_1.resolvedFileName); + if (resolvedFile && resolvedFile.externalModuleIndicator && resolvedFile.externalModuleIndicator !== true && ts.isExportAssignment(resolvedFile.externalModuleIndicator) && resolvedFile.externalModuleIndicator.isExportEquals) { + diags.push(ts.createDiagnosticForNode(name, ts.Diagnostics.Import_may_be_converted_to_a_default_import)); + } + } + } + ts.addRange(diags, sourceFile.bindSuggestionDiagnostics); + ts.addRange(diags, program.getSuggestionDiagnostics(sourceFile, cancellationToken)); + return diags.sort(function (d1, d2) { return d1.start - d2.start; }); + function check(node) { + if (isJsFile) { + if (canBeConvertedToClass(node, checker)) { + diags.push(ts.createDiagnosticForNode(ts.isVariableDeclaration(node.parent) ? node.parent.name : node, ts.Diagnostics.This_constructor_function_may_be_converted_to_a_class_declaration)); + } + } + else { + if (ts.isVariableStatement(node) && + node.parent === sourceFile && + node.declarationList.flags & 2 /* NodeFlags.Const */ && + node.declarationList.declarations.length === 1) { + var init = node.declarationList.declarations[0].initializer; + if (init && ts.isRequireCall(init, /*checkArgumentIsStringLiteralLike*/ true)) { + diags.push(ts.createDiagnosticForNode(init, ts.Diagnostics.require_call_may_be_converted_to_an_import)); + } + } + if (ts.codefix.parameterShouldGetTypeFromJSDoc(node)) { + diags.push(ts.createDiagnosticForNode(node.name || node, ts.Diagnostics.JSDoc_types_may_be_moved_to_TypeScript_types)); + } + } + if (canBeConvertedToAsync(node)) { + addConvertToAsyncFunctionDiagnostics(node, checker, diags); + } + node.forEachChild(check); + } + } + ts.computeSuggestionDiagnostics = computeSuggestionDiagnostics; + // convertToEsModule only works on top-level, so don't trigger it if commonjs code only appears in nested scopes. + function containsTopLevelCommonjs(sourceFile) { + return sourceFile.statements.some(function (statement) { + switch (statement.kind) { + case 240 /* SyntaxKind.VariableStatement */: + return statement.declarationList.declarations.some(function (decl) { + return !!decl.initializer && ts.isRequireCall(propertyAccessLeftHandSide(decl.initializer), /*checkArgumentIsStringLiteralLike*/ true); + }); + case 241 /* SyntaxKind.ExpressionStatement */: { + var expression = statement.expression; + if (!ts.isBinaryExpression(expression)) + return ts.isRequireCall(expression, /*checkArgumentIsStringLiteralLike*/ true); + var kind = ts.getAssignmentDeclarationKind(expression); + return kind === 1 /* AssignmentDeclarationKind.ExportsProperty */ || kind === 2 /* AssignmentDeclarationKind.ModuleExports */; + } + default: + return false; + } + }); + } + function propertyAccessLeftHandSide(node) { + return ts.isPropertyAccessExpression(node) ? propertyAccessLeftHandSide(node.expression) : node; + } + function importNameForConvertToDefaultImport(node) { + switch (node.kind) { + case 269 /* SyntaxKind.ImportDeclaration */: + var importClause = node.importClause, moduleSpecifier = node.moduleSpecifier; + return importClause && !importClause.name && importClause.namedBindings && importClause.namedBindings.kind === 271 /* SyntaxKind.NamespaceImport */ && ts.isStringLiteral(moduleSpecifier) + ? importClause.namedBindings.name + : undefined; + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return node.name; + default: + return undefined; + } + } + function addConvertToAsyncFunctionDiagnostics(node, checker, diags) { + // need to check function before checking map so that deeper levels of nested callbacks are checked + if (isConvertibleFunction(node, checker) && !visitedNestedConvertibleFunctions.has(getKeyFromNode(node))) { + diags.push(ts.createDiagnosticForNode(!node.name && ts.isVariableDeclaration(node.parent) && ts.isIdentifier(node.parent.name) ? node.parent.name : node, ts.Diagnostics.This_may_be_converted_to_an_async_function)); + } + } + function isConvertibleFunction(node, checker) { + return !ts.isAsyncFunction(node) && + node.body && + ts.isBlock(node.body) && + hasReturnStatementWithPromiseHandler(node.body, checker) && + returnsPromise(node, checker); + } + function returnsPromise(node, checker) { + var signature = checker.getSignatureFromDeclaration(node); + var returnType = signature ? checker.getReturnTypeOfSignature(signature) : undefined; + return !!returnType && !!checker.getPromisedTypeOfPromise(returnType); + } + ts.returnsPromise = returnsPromise; + function getErrorNodeFromCommonJsIndicator(commonJsModuleIndicator) { + return ts.isBinaryExpression(commonJsModuleIndicator) ? commonJsModuleIndicator.left : commonJsModuleIndicator; + } + function hasReturnStatementWithPromiseHandler(body, checker) { + return !!ts.forEachReturnStatement(body, function (statement) { return isReturnStatementWithFixablePromiseHandler(statement, checker); }); + } + function isReturnStatementWithFixablePromiseHandler(node, checker) { + return ts.isReturnStatement(node) && !!node.expression && isFixablePromiseHandler(node.expression, checker); + } + ts.isReturnStatementWithFixablePromiseHandler = isReturnStatementWithFixablePromiseHandler; + // Should be kept up to date with transformExpression in convertToAsyncFunction.ts + function isFixablePromiseHandler(node, checker) { + // ensure outermost call exists and is a promise handler + if (!isPromiseHandler(node) || !hasSupportedNumberOfArguments(node) || !node.arguments.every(function (arg) { return isFixablePromiseArgument(arg, checker); })) { + return false; + } + // ensure all chained calls are valid + var currentNode = node.expression.expression; + while (isPromiseHandler(currentNode) || ts.isPropertyAccessExpression(currentNode)) { + if (ts.isCallExpression(currentNode)) { + if (!hasSupportedNumberOfArguments(currentNode) || !currentNode.arguments.every(function (arg) { return isFixablePromiseArgument(arg, checker); })) { + return false; + } + currentNode = currentNode.expression.expression; + } + else { + currentNode = currentNode.expression; + } + } + return true; + } + ts.isFixablePromiseHandler = isFixablePromiseHandler; + function isPromiseHandler(node) { + return ts.isCallExpression(node) && (ts.hasPropertyAccessExpressionWithName(node, "then") || + ts.hasPropertyAccessExpressionWithName(node, "catch") || + ts.hasPropertyAccessExpressionWithName(node, "finally")); + } + function hasSupportedNumberOfArguments(node) { + var name = node.expression.name.text; + var maxArguments = name === "then" ? 2 : name === "catch" ? 1 : name === "finally" ? 1 : 0; + if (node.arguments.length > maxArguments) + return false; + if (node.arguments.length < maxArguments) + return true; + return maxArguments === 1 || ts.some(node.arguments, function (arg) { + return arg.kind === 104 /* SyntaxKind.NullKeyword */ || ts.isIdentifier(arg) && arg.text === "undefined"; + }); + } + // should be kept up to date with getTransformationBody in convertToAsyncFunction.ts + function isFixablePromiseArgument(arg, checker) { + switch (arg.kind) { + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + var functionFlags = ts.getFunctionFlags(arg); + if (functionFlags & 1 /* FunctionFlags.Generator */) { + return false; + } + // falls through + case 216 /* SyntaxKind.ArrowFunction */: + visitedNestedConvertibleFunctions.set(getKeyFromNode(arg), true); + // falls through + case 104 /* SyntaxKind.NullKeyword */: + return true; + case 79 /* SyntaxKind.Identifier */: + case 208 /* SyntaxKind.PropertyAccessExpression */: { + var symbol = checker.getSymbolAtLocation(arg); + if (!symbol) { + return false; + } + return checker.isUndefinedSymbol(symbol) || + ts.some(ts.skipAlias(symbol, checker).declarations, function (d) { return ts.isFunctionLike(d) || ts.hasInitializer(d) && !!d.initializer && ts.isFunctionLike(d.initializer); }); + } + default: + return false; + } + } + function getKeyFromNode(exp) { + return "".concat(exp.pos.toString(), ":").concat(exp.end.toString()); + } + function canBeConvertedToClass(node, checker) { + var _a, _b, _c, _d; + if (node.kind === 215 /* SyntaxKind.FunctionExpression */) { + if (ts.isVariableDeclaration(node.parent) && ((_a = node.symbol.members) === null || _a === void 0 ? void 0 : _a.size)) { + return true; + } + var symbol = checker.getSymbolOfExpando(node, /*allowDeclaration*/ false); + return !!(symbol && (((_b = symbol.exports) === null || _b === void 0 ? void 0 : _b.size) || ((_c = symbol.members) === null || _c === void 0 ? void 0 : _c.size))); + } + if (node.kind === 259 /* SyntaxKind.FunctionDeclaration */) { + return !!((_d = node.symbol.members) === null || _d === void 0 ? void 0 : _d.size); + } + return false; + } + function canBeConvertedToAsync(node) { + switch (node.kind) { + case 259 /* SyntaxKind.FunctionDeclaration */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + return true; + default: + return false; + } + } + ts.canBeConvertedToAsync = canBeConvertedToAsync; +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var SymbolDisplay; + (function (SymbolDisplay) { + var symbolDisplayNodeBuilderFlags = 8192 /* NodeBuilderFlags.OmitParameterModifiers */ | 70221824 /* NodeBuilderFlags.IgnoreErrors */ | 16384 /* NodeBuilderFlags.UseAliasDefinedOutsideCurrentScope */; + // TODO(drosen): use contextual SemanticMeaning. + function getSymbolKind(typeChecker, symbol, location) { + var result = getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(typeChecker, symbol, location); + if (result !== "" /* ScriptElementKind.unknown */) { + return result; + } + var flags = ts.getCombinedLocalAndExportSymbolFlags(symbol); + if (flags & 32 /* SymbolFlags.Class */) { + return ts.getDeclarationOfKind(symbol, 228 /* SyntaxKind.ClassExpression */) ? + "local class" /* ScriptElementKind.localClassElement */ : "class" /* ScriptElementKind.classElement */; + } + if (flags & 384 /* SymbolFlags.Enum */) + return "enum" /* ScriptElementKind.enumElement */; + if (flags & 524288 /* SymbolFlags.TypeAlias */) + return "type" /* ScriptElementKind.typeElement */; + if (flags & 64 /* SymbolFlags.Interface */) + return "interface" /* ScriptElementKind.interfaceElement */; + if (flags & 262144 /* SymbolFlags.TypeParameter */) + return "type parameter" /* ScriptElementKind.typeParameterElement */; + if (flags & 8 /* SymbolFlags.EnumMember */) + return "enum member" /* ScriptElementKind.enumMemberElement */; + if (flags & 2097152 /* SymbolFlags.Alias */) + return "alias" /* ScriptElementKind.alias */; + if (flags & 1536 /* SymbolFlags.Module */) + return "module" /* ScriptElementKind.moduleElement */; + return result; + } + SymbolDisplay.getSymbolKind = getSymbolKind; + function getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(typeChecker, symbol, location) { + var roots = typeChecker.getRootSymbols(symbol); + // If this is a method from a mapped type, leave as a method so long as it still has a call signature. + if (roots.length === 1 + && ts.first(roots).flags & 8192 /* SymbolFlags.Method */ + // Ensure the mapped version is still a method, as opposed to `{ [K in keyof I]: number }`. + && typeChecker.getTypeOfSymbolAtLocation(symbol, location).getNonNullableType().getCallSignatures().length !== 0) { + return "method" /* ScriptElementKind.memberFunctionElement */; + } + if (typeChecker.isUndefinedSymbol(symbol)) { + return "var" /* ScriptElementKind.variableElement */; + } + if (typeChecker.isArgumentsSymbol(symbol)) { + return "local var" /* ScriptElementKind.localVariableElement */; + } + if (location.kind === 108 /* SyntaxKind.ThisKeyword */ && ts.isExpression(location) || ts.isThisInTypeQuery(location)) { + return "parameter" /* ScriptElementKind.parameterElement */; + } + var flags = ts.getCombinedLocalAndExportSymbolFlags(symbol); + if (flags & 3 /* SymbolFlags.Variable */) { + if (ts.isFirstDeclarationOfSymbolParameter(symbol)) { + return "parameter" /* ScriptElementKind.parameterElement */; + } + else if (symbol.valueDeclaration && ts.isVarConst(symbol.valueDeclaration)) { + return "const" /* ScriptElementKind.constElement */; + } + else if (ts.forEach(symbol.declarations, ts.isLet)) { + return "let" /* ScriptElementKind.letElement */; + } + return isLocalVariableOrFunction(symbol) ? "local var" /* ScriptElementKind.localVariableElement */ : "var" /* ScriptElementKind.variableElement */; + } + if (flags & 16 /* SymbolFlags.Function */) + return isLocalVariableOrFunction(symbol) ? "local function" /* ScriptElementKind.localFunctionElement */ : "function" /* ScriptElementKind.functionElement */; + // FIXME: getter and setter use the same symbol. And it is rare to use only setter without getter, so in most cases the symbol always has getter flag. + // So, even when the location is just on the declaration of setter, this function returns getter. + if (flags & 32768 /* SymbolFlags.GetAccessor */) + return "getter" /* ScriptElementKind.memberGetAccessorElement */; + if (flags & 65536 /* SymbolFlags.SetAccessor */) + return "setter" /* ScriptElementKind.memberSetAccessorElement */; + if (flags & 8192 /* SymbolFlags.Method */) + return "method" /* ScriptElementKind.memberFunctionElement */; + if (flags & 16384 /* SymbolFlags.Constructor */) + return "constructor" /* ScriptElementKind.constructorImplementationElement */; + if (flags & 131072 /* SymbolFlags.Signature */) + return "index" /* ScriptElementKind.indexSignatureElement */; + if (flags & 4 /* SymbolFlags.Property */) { + if (flags & 33554432 /* SymbolFlags.Transient */ && symbol.checkFlags & 6 /* CheckFlags.Synthetic */) { + // If union property is result of union of non method (property/accessors/variables), it is labeled as property + var unionPropertyKind = ts.forEach(typeChecker.getRootSymbols(symbol), function (rootSymbol) { + var rootSymbolFlags = rootSymbol.getFlags(); + if (rootSymbolFlags & (98308 /* SymbolFlags.PropertyOrAccessor */ | 3 /* SymbolFlags.Variable */)) { + return "property" /* ScriptElementKind.memberVariableElement */; + } + }); + if (!unionPropertyKind) { + // If this was union of all methods, + // make sure it has call signatures before we can label it as method + var typeOfUnionProperty = typeChecker.getTypeOfSymbolAtLocation(symbol, location); + if (typeOfUnionProperty.getCallSignatures().length) { + return "method" /* ScriptElementKind.memberFunctionElement */; + } + return "property" /* ScriptElementKind.memberVariableElement */; + } + return unionPropertyKind; + } + return "property" /* ScriptElementKind.memberVariableElement */; + } + return "" /* ScriptElementKind.unknown */; + } + function getNormalizedSymbolModifiers(symbol) { + if (symbol.declarations && symbol.declarations.length) { + var _a = symbol.declarations, declaration = _a[0], declarations = _a.slice(1); + // omit deprecated flag if some declarations are not deprecated + var excludeFlags = ts.length(declarations) && ts.isDeprecatedDeclaration(declaration) && ts.some(declarations, function (d) { return !ts.isDeprecatedDeclaration(d); }) + ? 8192 /* ModifierFlags.Deprecated */ + : 0 /* ModifierFlags.None */; + var modifiers = ts.getNodeModifiers(declaration, excludeFlags); + if (modifiers) { + return modifiers.split(","); + } + } + return []; + } + function getSymbolModifiers(typeChecker, symbol) { + if (!symbol) { + return "" /* ScriptElementKindModifier.none */; + } + var modifiers = new ts.Set(getNormalizedSymbolModifiers(symbol)); + if (symbol.flags & 2097152 /* SymbolFlags.Alias */) { + var resolvedSymbol = typeChecker.getAliasedSymbol(symbol); + if (resolvedSymbol !== symbol) { + ts.forEach(getNormalizedSymbolModifiers(resolvedSymbol), function (modifier) { + modifiers.add(modifier); + }); + } + } + if (symbol.flags & 16777216 /* SymbolFlags.Optional */) { + modifiers.add("optional" /* ScriptElementKindModifier.optionalModifier */); + } + return modifiers.size > 0 ? ts.arrayFrom(modifiers.values()).join(",") : "" /* ScriptElementKindModifier.none */; + } + SymbolDisplay.getSymbolModifiers = getSymbolModifiers; + // TODO(drosen): Currently completion entry details passes the SemanticMeaning.All instead of using semanticMeaning of location + function getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, sourceFile, enclosingDeclaration, location, semanticMeaning, alias) { + var _a; + if (semanticMeaning === void 0) { semanticMeaning = ts.getMeaningFromLocation(location); } + var displayParts = []; + var documentation = []; + var tags = []; + var symbolFlags = ts.getCombinedLocalAndExportSymbolFlags(symbol); + var symbolKind = semanticMeaning & 1 /* SemanticMeaning.Value */ ? getSymbolKindOfConstructorPropertyMethodAccessorFunctionOrVar(typeChecker, symbol, location) : "" /* ScriptElementKind.unknown */; + var hasAddedSymbolInfo = false; + var isThisExpression = location.kind === 108 /* SyntaxKind.ThisKeyword */ && ts.isInExpressionContext(location) || ts.isThisInTypeQuery(location); + var type; + var printer; + var documentationFromAlias; + var tagsFromAlias; + var hasMultipleSignatures = false; + if (location.kind === 108 /* SyntaxKind.ThisKeyword */ && !isThisExpression) { + return { displayParts: [ts.keywordPart(108 /* SyntaxKind.ThisKeyword */)], documentation: [], symbolKind: "primitive type" /* ScriptElementKind.primitiveType */, tags: undefined }; + } + // Class at constructor site need to be shown as constructor apart from property,method, vars + if (symbolKind !== "" /* ScriptElementKind.unknown */ || symbolFlags & 32 /* SymbolFlags.Class */ || symbolFlags & 2097152 /* SymbolFlags.Alias */) { + // If symbol is accessor, they are allowed only if location is at declaration identifier of the accessor + if (symbolKind === "getter" /* ScriptElementKind.memberGetAccessorElement */ || symbolKind === "setter" /* ScriptElementKind.memberSetAccessorElement */) { + var declaration = ts.find(symbol.declarations, function (declaration) { return declaration.name === location; }); + if (declaration) { + switch (declaration.kind) { + case 174 /* SyntaxKind.GetAccessor */: + symbolKind = "getter" /* ScriptElementKind.memberGetAccessorElement */; + break; + case 175 /* SyntaxKind.SetAccessor */: + symbolKind = "setter" /* ScriptElementKind.memberSetAccessorElement */; + break; + case 169 /* SyntaxKind.PropertyDeclaration */: + symbolKind = "accessor" /* ScriptElementKind.memberAccessorVariableElement */; + break; + default: + ts.Debug.assertNever(declaration); + } + } + else { + symbolKind = "property" /* ScriptElementKind.memberVariableElement */; + } + } + var signature = void 0; + type = isThisExpression ? typeChecker.getTypeAtLocation(location) : typeChecker.getTypeOfSymbolAtLocation(symbol, location); + if (location.parent && location.parent.kind === 208 /* SyntaxKind.PropertyAccessExpression */) { + var right = location.parent.name; + // Either the location is on the right of a property access, or on the left and the right is missing + if (right === location || (right && right.getFullWidth() === 0)) { + location = location.parent; + } + } + // try get the call/construct signature from the type if it matches + var callExpressionLike = void 0; + if (ts.isCallOrNewExpression(location)) { + callExpressionLike = location; + } + else if (ts.isCallExpressionTarget(location) || ts.isNewExpressionTarget(location)) { + callExpressionLike = location.parent; + } + else if (location.parent && (ts.isJsxOpeningLikeElement(location.parent) || ts.isTaggedTemplateExpression(location.parent)) && ts.isFunctionLike(symbol.valueDeclaration)) { + callExpressionLike = location.parent; + } + if (callExpressionLike) { + signature = typeChecker.getResolvedSignature(callExpressionLike); // TODO: GH#18217 + var useConstructSignatures = callExpressionLike.kind === 211 /* SyntaxKind.NewExpression */ || (ts.isCallExpression(callExpressionLike) && callExpressionLike.expression.kind === 106 /* SyntaxKind.SuperKeyword */); + var allSignatures = useConstructSignatures ? type.getConstructSignatures() : type.getCallSignatures(); + if (signature && !ts.contains(allSignatures, signature.target) && !ts.contains(allSignatures, signature)) { + // Get the first signature if there is one -- allSignatures may contain + // either the original signature or its target, so check for either + signature = allSignatures.length ? allSignatures[0] : undefined; + } + if (signature) { + if (useConstructSignatures && (symbolFlags & 32 /* SymbolFlags.Class */)) { + // Constructor + symbolKind = "constructor" /* ScriptElementKind.constructorImplementationElement */; + addPrefixForAnyFunctionOrVar(type.symbol, symbolKind); + } + else if (symbolFlags & 2097152 /* SymbolFlags.Alias */) { + symbolKind = "alias" /* ScriptElementKind.alias */; + pushSymbolKind(symbolKind); + displayParts.push(ts.spacePart()); + if (useConstructSignatures) { + if (signature.flags & 4 /* SignatureFlags.Abstract */) { + displayParts.push(ts.keywordPart(126 /* SyntaxKind.AbstractKeyword */)); + displayParts.push(ts.spacePart()); + } + displayParts.push(ts.keywordPart(103 /* SyntaxKind.NewKeyword */)); + displayParts.push(ts.spacePart()); + } + addFullSymbolName(symbol); + } + else { + addPrefixForAnyFunctionOrVar(symbol, symbolKind); + } + switch (symbolKind) { + case "JSX attribute" /* ScriptElementKind.jsxAttribute */: + case "property" /* ScriptElementKind.memberVariableElement */: + case "var" /* ScriptElementKind.variableElement */: + case "const" /* ScriptElementKind.constElement */: + case "let" /* ScriptElementKind.letElement */: + case "parameter" /* ScriptElementKind.parameterElement */: + case "local var" /* ScriptElementKind.localVariableElement */: + // If it is call or construct signature of lambda's write type name + displayParts.push(ts.punctuationPart(58 /* SyntaxKind.ColonToken */)); + displayParts.push(ts.spacePart()); + if (!(ts.getObjectFlags(type) & 16 /* ObjectFlags.Anonymous */) && type.symbol) { + ts.addRange(displayParts, ts.symbolToDisplayParts(typeChecker, type.symbol, enclosingDeclaration, /*meaning*/ undefined, 4 /* SymbolFormatFlags.AllowAnyNodeKind */ | 1 /* SymbolFormatFlags.WriteTypeParametersOrArguments */)); + displayParts.push(ts.lineBreakPart()); + } + if (useConstructSignatures) { + if (signature.flags & 4 /* SignatureFlags.Abstract */) { + displayParts.push(ts.keywordPart(126 /* SyntaxKind.AbstractKeyword */)); + displayParts.push(ts.spacePart()); + } + displayParts.push(ts.keywordPart(103 /* SyntaxKind.NewKeyword */)); + displayParts.push(ts.spacePart()); + } + addSignatureDisplayParts(signature, allSignatures, 262144 /* TypeFormatFlags.WriteArrowStyleSignature */); + break; + default: + // Just signature + addSignatureDisplayParts(signature, allSignatures); + } + hasAddedSymbolInfo = true; + hasMultipleSignatures = allSignatures.length > 1; + } + } + else if ((ts.isNameOfFunctionDeclaration(location) && !(symbolFlags & 98304 /* SymbolFlags.Accessor */)) || // name of function declaration + (location.kind === 135 /* SyntaxKind.ConstructorKeyword */ && location.parent.kind === 173 /* SyntaxKind.Constructor */)) { // At constructor keyword of constructor declaration + // get the signature from the declaration and write it + var functionDeclaration_1 = location.parent; + // Use function declaration to write the signatures only if the symbol corresponding to this declaration + var locationIsSymbolDeclaration = symbol.declarations && ts.find(symbol.declarations, function (declaration) { + return declaration === (location.kind === 135 /* SyntaxKind.ConstructorKeyword */ ? functionDeclaration_1.parent : functionDeclaration_1); + }); + if (locationIsSymbolDeclaration) { + var allSignatures = functionDeclaration_1.kind === 173 /* SyntaxKind.Constructor */ ? type.getNonNullableType().getConstructSignatures() : type.getNonNullableType().getCallSignatures(); + if (!typeChecker.isImplementationOfOverload(functionDeclaration_1)) { + signature = typeChecker.getSignatureFromDeclaration(functionDeclaration_1); // TODO: GH#18217 + } + else { + signature = allSignatures[0]; + } + if (functionDeclaration_1.kind === 173 /* SyntaxKind.Constructor */) { + // show (constructor) Type(...) signature + symbolKind = "constructor" /* ScriptElementKind.constructorImplementationElement */; + addPrefixForAnyFunctionOrVar(type.symbol, symbolKind); + } + else { + // (function/method) symbol(..signature) + addPrefixForAnyFunctionOrVar(functionDeclaration_1.kind === 176 /* SyntaxKind.CallSignature */ && + !(type.symbol.flags & 2048 /* SymbolFlags.TypeLiteral */ || type.symbol.flags & 4096 /* SymbolFlags.ObjectLiteral */) ? type.symbol : symbol, symbolKind); + } + if (signature) { + addSignatureDisplayParts(signature, allSignatures); + } + hasAddedSymbolInfo = true; + hasMultipleSignatures = allSignatures.length > 1; + } + } + } + if (symbolFlags & 32 /* SymbolFlags.Class */ && !hasAddedSymbolInfo && !isThisExpression) { + addAliasPrefixIfNecessary(); + if (ts.getDeclarationOfKind(symbol, 228 /* SyntaxKind.ClassExpression */)) { + // Special case for class expressions because we would like to indicate that + // the class name is local to the class body (similar to function expression) + // (local class) class + pushSymbolKind("local class" /* ScriptElementKind.localClassElement */); + } + else { + // Class declaration has name which is not local. + displayParts.push(ts.keywordPart(84 /* SyntaxKind.ClassKeyword */)); + } + displayParts.push(ts.spacePart()); + addFullSymbolName(symbol); + writeTypeParametersOfSymbol(symbol, sourceFile); + } + if ((symbolFlags & 64 /* SymbolFlags.Interface */) && (semanticMeaning & 2 /* SemanticMeaning.Type */)) { + prefixNextMeaning(); + displayParts.push(ts.keywordPart(118 /* SyntaxKind.InterfaceKeyword */)); + displayParts.push(ts.spacePart()); + addFullSymbolName(symbol); + writeTypeParametersOfSymbol(symbol, sourceFile); + } + if ((symbolFlags & 524288 /* SymbolFlags.TypeAlias */) && (semanticMeaning & 2 /* SemanticMeaning.Type */)) { + prefixNextMeaning(); + displayParts.push(ts.keywordPart(154 /* SyntaxKind.TypeKeyword */)); + displayParts.push(ts.spacePart()); + addFullSymbolName(symbol); + writeTypeParametersOfSymbol(symbol, sourceFile); + displayParts.push(ts.spacePart()); + displayParts.push(ts.operatorPart(63 /* SyntaxKind.EqualsToken */)); + displayParts.push(ts.spacePart()); + ts.addRange(displayParts, ts.typeToDisplayParts(typeChecker, ts.isConstTypeReference(location.parent) ? typeChecker.getTypeAtLocation(location.parent) : typeChecker.getDeclaredTypeOfSymbol(symbol), enclosingDeclaration, 8388608 /* TypeFormatFlags.InTypeAlias */)); + } + if (symbolFlags & 384 /* SymbolFlags.Enum */) { + prefixNextMeaning(); + if (ts.some(symbol.declarations, function (d) { return ts.isEnumDeclaration(d) && ts.isEnumConst(d); })) { + displayParts.push(ts.keywordPart(85 /* SyntaxKind.ConstKeyword */)); + displayParts.push(ts.spacePart()); + } + displayParts.push(ts.keywordPart(92 /* SyntaxKind.EnumKeyword */)); + displayParts.push(ts.spacePart()); + addFullSymbolName(symbol); + } + if (symbolFlags & 1536 /* SymbolFlags.Module */ && !isThisExpression) { + prefixNextMeaning(); + var declaration = ts.getDeclarationOfKind(symbol, 264 /* SyntaxKind.ModuleDeclaration */); + var isNamespace = declaration && declaration.name && declaration.name.kind === 79 /* SyntaxKind.Identifier */; + displayParts.push(ts.keywordPart(isNamespace ? 143 /* SyntaxKind.NamespaceKeyword */ : 142 /* SyntaxKind.ModuleKeyword */)); + displayParts.push(ts.spacePart()); + addFullSymbolName(symbol); + } + if ((symbolFlags & 262144 /* SymbolFlags.TypeParameter */) && (semanticMeaning & 2 /* SemanticMeaning.Type */)) { + prefixNextMeaning(); + displayParts.push(ts.punctuationPart(20 /* SyntaxKind.OpenParenToken */)); + displayParts.push(ts.textPart("type parameter")); + displayParts.push(ts.punctuationPart(21 /* SyntaxKind.CloseParenToken */)); + displayParts.push(ts.spacePart()); + addFullSymbolName(symbol); + if (symbol.parent) { + // Class/Interface type parameter + addInPrefix(); + addFullSymbolName(symbol.parent, enclosingDeclaration); + writeTypeParametersOfSymbol(symbol.parent, enclosingDeclaration); + } + else { + // Method/function type parameter + var decl = ts.getDeclarationOfKind(symbol, 165 /* SyntaxKind.TypeParameter */); + if (decl === undefined) + return ts.Debug.fail(); + var declaration = decl.parent; + if (declaration) { + if (ts.isFunctionLikeKind(declaration.kind)) { + addInPrefix(); + var signature = typeChecker.getSignatureFromDeclaration(declaration); // TODO: GH#18217 + if (declaration.kind === 177 /* SyntaxKind.ConstructSignature */) { + displayParts.push(ts.keywordPart(103 /* SyntaxKind.NewKeyword */)); + displayParts.push(ts.spacePart()); + } + else if (declaration.kind !== 176 /* SyntaxKind.CallSignature */ && declaration.name) { + addFullSymbolName(declaration.symbol); + } + ts.addRange(displayParts, ts.signatureToDisplayParts(typeChecker, signature, sourceFile, 32 /* TypeFormatFlags.WriteTypeArgumentsOfSignature */)); + } + else if (declaration.kind === 262 /* SyntaxKind.TypeAliasDeclaration */) { + // Type alias type parameter + // For example + // type list = T[]; // Both T will go through same code path + addInPrefix(); + displayParts.push(ts.keywordPart(154 /* SyntaxKind.TypeKeyword */)); + displayParts.push(ts.spacePart()); + addFullSymbolName(declaration.symbol); + writeTypeParametersOfSymbol(declaration.symbol, sourceFile); + } + } + } + } + if (symbolFlags & 8 /* SymbolFlags.EnumMember */) { + symbolKind = "enum member" /* ScriptElementKind.enumMemberElement */; + addPrefixForAnyFunctionOrVar(symbol, "enum member"); + var declaration = (_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a[0]; + if ((declaration === null || declaration === void 0 ? void 0 : declaration.kind) === 302 /* SyntaxKind.EnumMember */) { + var constantValue = typeChecker.getConstantValue(declaration); + if (constantValue !== undefined) { + displayParts.push(ts.spacePart()); + displayParts.push(ts.operatorPart(63 /* SyntaxKind.EqualsToken */)); + displayParts.push(ts.spacePart()); + displayParts.push(ts.displayPart(ts.getTextOfConstantValue(constantValue), typeof constantValue === "number" ? ts.SymbolDisplayPartKind.numericLiteral : ts.SymbolDisplayPartKind.stringLiteral)); + } + } + } + // don't use symbolFlags since getAliasedSymbol requires the flag on the symbol itself + if (symbol.flags & 2097152 /* SymbolFlags.Alias */) { + prefixNextMeaning(); + if (!hasAddedSymbolInfo) { + var resolvedSymbol = typeChecker.getAliasedSymbol(symbol); + if (resolvedSymbol !== symbol && resolvedSymbol.declarations && resolvedSymbol.declarations.length > 0) { + var resolvedNode = resolvedSymbol.declarations[0]; + var declarationName = ts.getNameOfDeclaration(resolvedNode); + if (declarationName) { + var isExternalModuleDeclaration = ts.isModuleWithStringLiteralName(resolvedNode) && + ts.hasSyntacticModifier(resolvedNode, 2 /* ModifierFlags.Ambient */); + var shouldUseAliasName = symbol.name !== "default" && !isExternalModuleDeclaration; + var resolvedInfo = getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, resolvedSymbol, ts.getSourceFileOfNode(resolvedNode), resolvedNode, declarationName, semanticMeaning, shouldUseAliasName ? symbol : resolvedSymbol); + displayParts.push.apply(displayParts, resolvedInfo.displayParts); + displayParts.push(ts.lineBreakPart()); + documentationFromAlias = resolvedInfo.documentation; + tagsFromAlias = resolvedInfo.tags; + } + else { + documentationFromAlias = resolvedSymbol.getContextualDocumentationComment(resolvedNode, typeChecker); + tagsFromAlias = resolvedSymbol.getJsDocTags(typeChecker); + } + } + } + if (symbol.declarations) { + switch (symbol.declarations[0].kind) { + case 267 /* SyntaxKind.NamespaceExportDeclaration */: + displayParts.push(ts.keywordPart(93 /* SyntaxKind.ExportKeyword */)); + displayParts.push(ts.spacePart()); + displayParts.push(ts.keywordPart(143 /* SyntaxKind.NamespaceKeyword */)); + break; + case 274 /* SyntaxKind.ExportAssignment */: + displayParts.push(ts.keywordPart(93 /* SyntaxKind.ExportKeyword */)); + displayParts.push(ts.spacePart()); + displayParts.push(ts.keywordPart(symbol.declarations[0].isExportEquals ? 63 /* SyntaxKind.EqualsToken */ : 88 /* SyntaxKind.DefaultKeyword */)); + break; + case 278 /* SyntaxKind.ExportSpecifier */: + displayParts.push(ts.keywordPart(93 /* SyntaxKind.ExportKeyword */)); + break; + default: + displayParts.push(ts.keywordPart(100 /* SyntaxKind.ImportKeyword */)); + } + } + displayParts.push(ts.spacePart()); + addFullSymbolName(symbol); + ts.forEach(symbol.declarations, function (declaration) { + if (declaration.kind === 268 /* SyntaxKind.ImportEqualsDeclaration */) { + var importEqualsDeclaration = declaration; + if (ts.isExternalModuleImportEqualsDeclaration(importEqualsDeclaration)) { + displayParts.push(ts.spacePart()); + displayParts.push(ts.operatorPart(63 /* SyntaxKind.EqualsToken */)); + displayParts.push(ts.spacePart()); + displayParts.push(ts.keywordPart(147 /* SyntaxKind.RequireKeyword */)); + displayParts.push(ts.punctuationPart(20 /* SyntaxKind.OpenParenToken */)); + displayParts.push(ts.displayPart(ts.getTextOfNode(ts.getExternalModuleImportEqualsDeclarationExpression(importEqualsDeclaration)), ts.SymbolDisplayPartKind.stringLiteral)); + displayParts.push(ts.punctuationPart(21 /* SyntaxKind.CloseParenToken */)); + } + else { + var internalAliasSymbol = typeChecker.getSymbolAtLocation(importEqualsDeclaration.moduleReference); + if (internalAliasSymbol) { + displayParts.push(ts.spacePart()); + displayParts.push(ts.operatorPart(63 /* SyntaxKind.EqualsToken */)); + displayParts.push(ts.spacePart()); + addFullSymbolName(internalAliasSymbol, enclosingDeclaration); + } + } + return true; + } + }); + } + if (!hasAddedSymbolInfo) { + if (symbolKind !== "" /* ScriptElementKind.unknown */) { + if (type) { + if (isThisExpression) { + prefixNextMeaning(); + displayParts.push(ts.keywordPart(108 /* SyntaxKind.ThisKeyword */)); + } + else { + addPrefixForAnyFunctionOrVar(symbol, symbolKind); + } + // For properties, variables and local vars: show the type + if (symbolKind === "property" /* ScriptElementKind.memberVariableElement */ || + symbolKind === "accessor" /* ScriptElementKind.memberAccessorVariableElement */ || + symbolKind === "getter" /* ScriptElementKind.memberGetAccessorElement */ || + symbolKind === "setter" /* ScriptElementKind.memberSetAccessorElement */ || + symbolKind === "JSX attribute" /* ScriptElementKind.jsxAttribute */ || + symbolFlags & 3 /* SymbolFlags.Variable */ || + symbolKind === "local var" /* ScriptElementKind.localVariableElement */ || + symbolKind === "index" /* ScriptElementKind.indexSignatureElement */ || + isThisExpression) { + displayParts.push(ts.punctuationPart(58 /* SyntaxKind.ColonToken */)); + displayParts.push(ts.spacePart()); + // If the type is type parameter, format it specially + if (type.symbol && type.symbol.flags & 262144 /* SymbolFlags.TypeParameter */ && symbolKind !== "index" /* ScriptElementKind.indexSignatureElement */) { + var typeParameterParts = ts.mapToDisplayParts(function (writer) { + var param = typeChecker.typeParameterToDeclaration(type, enclosingDeclaration, symbolDisplayNodeBuilderFlags); + getPrinter().writeNode(4 /* EmitHint.Unspecified */, param, ts.getSourceFileOfNode(ts.getParseTreeNode(enclosingDeclaration)), writer); + }); + ts.addRange(displayParts, typeParameterParts); + } + else { + ts.addRange(displayParts, ts.typeToDisplayParts(typeChecker, type, enclosingDeclaration)); + } + if (symbol.target && symbol.target.tupleLabelDeclaration) { + var labelDecl = symbol.target.tupleLabelDeclaration; + ts.Debug.assertNode(labelDecl.name, ts.isIdentifier); + displayParts.push(ts.spacePart()); + displayParts.push(ts.punctuationPart(20 /* SyntaxKind.OpenParenToken */)); + displayParts.push(ts.textPart(ts.idText(labelDecl.name))); + displayParts.push(ts.punctuationPart(21 /* SyntaxKind.CloseParenToken */)); + } + } + else if (symbolFlags & 16 /* SymbolFlags.Function */ || + symbolFlags & 8192 /* SymbolFlags.Method */ || + symbolFlags & 16384 /* SymbolFlags.Constructor */ || + symbolFlags & 131072 /* SymbolFlags.Signature */ || + symbolFlags & 98304 /* SymbolFlags.Accessor */ || + symbolKind === "method" /* ScriptElementKind.memberFunctionElement */) { + var allSignatures = type.getNonNullableType().getCallSignatures(); + if (allSignatures.length) { + addSignatureDisplayParts(allSignatures[0], allSignatures); + hasMultipleSignatures = allSignatures.length > 1; + } + } + } + } + else { + symbolKind = getSymbolKind(typeChecker, symbol, location); + } + } + if (documentation.length === 0 && !hasMultipleSignatures) { + documentation = symbol.getContextualDocumentationComment(enclosingDeclaration, typeChecker); + } + if (documentation.length === 0 && symbolFlags & 4 /* SymbolFlags.Property */) { + // For some special property access expressions like `exports.foo = foo` or `module.exports.foo = foo` + // there documentation comments might be attached to the right hand side symbol of their declarations. + // The pattern of such special property access is that the parent symbol is the symbol of the file. + if (symbol.parent && symbol.declarations && ts.forEach(symbol.parent.declarations, function (declaration) { return declaration.kind === 308 /* SyntaxKind.SourceFile */; })) { + for (var _i = 0, _b = symbol.declarations; _i < _b.length; _i++) { + var declaration = _b[_i]; + if (!declaration.parent || declaration.parent.kind !== 223 /* SyntaxKind.BinaryExpression */) { + continue; + } + var rhsSymbol = typeChecker.getSymbolAtLocation(declaration.parent.right); + if (!rhsSymbol) { + continue; + } + documentation = rhsSymbol.getDocumentationComment(typeChecker); + tags = rhsSymbol.getJsDocTags(typeChecker); + if (documentation.length > 0) { + break; + } + } + } + } + if (documentation.length === 0 && ts.isIdentifier(location) && symbol.valueDeclaration && ts.isBindingElement(symbol.valueDeclaration)) { + var declaration = symbol.valueDeclaration; + var parent = declaration.parent; + if (ts.isIdentifier(declaration.name) && ts.isObjectBindingPattern(parent)) { + var name_4 = ts.getTextOfIdentifierOrLiteral(declaration.name); + var objectType = typeChecker.getTypeAtLocation(parent); + documentation = ts.firstDefined(objectType.isUnion() ? objectType.types : [objectType], function (t) { + var prop = t.getProperty(name_4); + return prop ? prop.getDocumentationComment(typeChecker) : undefined; + }) || ts.emptyArray; + } + } + if (tags.length === 0 && !hasMultipleSignatures) { + tags = symbol.getContextualJsDocTags(enclosingDeclaration, typeChecker); + } + if (documentation.length === 0 && documentationFromAlias) { + documentation = documentationFromAlias; + } + if (tags.length === 0 && tagsFromAlias) { + tags = tagsFromAlias; + } + return { displayParts: displayParts, documentation: documentation, symbolKind: symbolKind, tags: tags.length === 0 ? undefined : tags }; + function getPrinter() { + if (!printer) { + printer = ts.createPrinter({ removeComments: true }); + } + return printer; + } + function prefixNextMeaning() { + if (displayParts.length) { + displayParts.push(ts.lineBreakPart()); + } + addAliasPrefixIfNecessary(); + } + function addAliasPrefixIfNecessary() { + if (alias) { + pushSymbolKind("alias" /* ScriptElementKind.alias */); + displayParts.push(ts.spacePart()); + } + } + function addInPrefix() { + displayParts.push(ts.spacePart()); + displayParts.push(ts.keywordPart(101 /* SyntaxKind.InKeyword */)); + displayParts.push(ts.spacePart()); + } + function addFullSymbolName(symbolToDisplay, enclosingDeclaration) { + var indexInfos; + if (alias && symbolToDisplay === symbol) { + symbolToDisplay = alias; + } + if (symbolKind === "index" /* ScriptElementKind.indexSignatureElement */) { + indexInfos = typeChecker.getIndexInfosOfIndexSymbol(symbolToDisplay); + } + var fullSymbolDisplayParts = []; + if (symbolToDisplay.flags & 131072 /* SymbolFlags.Signature */ && indexInfos) { + if (symbolToDisplay.parent) { + fullSymbolDisplayParts = ts.symbolToDisplayParts(typeChecker, symbolToDisplay.parent); + } + fullSymbolDisplayParts.push(ts.punctuationPart(22 /* SyntaxKind.OpenBracketToken */)); + //Needed to handle more than one type of index + indexInfos.forEach(function (info, i) { + //Needed to handle template literals + fullSymbolDisplayParts.push.apply(fullSymbolDisplayParts, ts.typeToDisplayParts(typeChecker, info.keyType)); + if (i !== indexInfos.length - 1) { + fullSymbolDisplayParts.push(ts.spacePart()); + fullSymbolDisplayParts.push(ts.punctuationPart(51 /* SyntaxKind.BarToken */)); + fullSymbolDisplayParts.push(ts.spacePart()); + } + }); + fullSymbolDisplayParts.push(ts.punctuationPart(23 /* SyntaxKind.CloseBracketToken */)); + } + else { + fullSymbolDisplayParts = ts.symbolToDisplayParts(typeChecker, symbolToDisplay, enclosingDeclaration || sourceFile, /*meaning*/ undefined, 1 /* SymbolFormatFlags.WriteTypeParametersOrArguments */ | 2 /* SymbolFormatFlags.UseOnlyExternalAliasing */ | 4 /* SymbolFormatFlags.AllowAnyNodeKind */); + } + ts.addRange(displayParts, fullSymbolDisplayParts); + if (symbol.flags & 16777216 /* SymbolFlags.Optional */) { + displayParts.push(ts.punctuationPart(57 /* SyntaxKind.QuestionToken */)); + } + } + function addPrefixForAnyFunctionOrVar(symbol, symbolKind) { + prefixNextMeaning(); + if (symbolKind) { + pushSymbolKind(symbolKind); + if (symbol && !ts.some(symbol.declarations, function (d) { return ts.isArrowFunction(d) || (ts.isFunctionExpression(d) || ts.isClassExpression(d)) && !d.name; })) { + displayParts.push(ts.spacePart()); + addFullSymbolName(symbol); + } + } + } + function pushSymbolKind(symbolKind) { + switch (symbolKind) { + case "var" /* ScriptElementKind.variableElement */: + case "function" /* ScriptElementKind.functionElement */: + case "let" /* ScriptElementKind.letElement */: + case "const" /* ScriptElementKind.constElement */: + case "constructor" /* ScriptElementKind.constructorImplementationElement */: + displayParts.push(ts.textOrKeywordPart(symbolKind)); + return; + default: + displayParts.push(ts.punctuationPart(20 /* SyntaxKind.OpenParenToken */)); + displayParts.push(ts.textOrKeywordPart(symbolKind)); + displayParts.push(ts.punctuationPart(21 /* SyntaxKind.CloseParenToken */)); + return; + } + } + function addSignatureDisplayParts(signature, allSignatures, flags) { + if (flags === void 0) { flags = 0 /* TypeFormatFlags.None */; } + ts.addRange(displayParts, ts.signatureToDisplayParts(typeChecker, signature, enclosingDeclaration, flags | 32 /* TypeFormatFlags.WriteTypeArgumentsOfSignature */)); + if (allSignatures.length > 1) { + displayParts.push(ts.spacePart()); + displayParts.push(ts.punctuationPart(20 /* SyntaxKind.OpenParenToken */)); + displayParts.push(ts.operatorPart(39 /* SyntaxKind.PlusToken */)); + displayParts.push(ts.displayPart((allSignatures.length - 1).toString(), ts.SymbolDisplayPartKind.numericLiteral)); + displayParts.push(ts.spacePart()); + displayParts.push(ts.textPart(allSignatures.length === 2 ? "overload" : "overloads")); + displayParts.push(ts.punctuationPart(21 /* SyntaxKind.CloseParenToken */)); + } + documentation = signature.getDocumentationComment(typeChecker); + tags = signature.getJsDocTags(); + if (allSignatures.length > 1 && documentation.length === 0 && tags.length === 0) { + documentation = allSignatures[0].getDocumentationComment(typeChecker); + tags = allSignatures[0].getJsDocTags().filter(function (tag) { return tag.name !== "deprecated"; }); // should only include @deprecated JSDoc tag on the first overload (#49368) + } + } + function writeTypeParametersOfSymbol(symbol, enclosingDeclaration) { + var typeParameterParts = ts.mapToDisplayParts(function (writer) { + var params = typeChecker.symbolToTypeParameterDeclarations(symbol, enclosingDeclaration, symbolDisplayNodeBuilderFlags); + getPrinter().writeList(53776 /* ListFormat.TypeParameters */, params, ts.getSourceFileOfNode(ts.getParseTreeNode(enclosingDeclaration)), writer); + }); + ts.addRange(displayParts, typeParameterParts); + } + } + SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind = getSymbolDisplayPartsDocumentationAndSymbolKind; + function isLocalVariableOrFunction(symbol) { + if (symbol.parent) { + return false; // This is exported symbol + } + return ts.forEach(symbol.declarations, function (declaration) { + // Function expressions are local + if (declaration.kind === 215 /* SyntaxKind.FunctionExpression */) { + return true; + } + if (declaration.kind !== 257 /* SyntaxKind.VariableDeclaration */ && declaration.kind !== 259 /* SyntaxKind.FunctionDeclaration */) { + return false; + } + // If the parent is not sourceFile or module block it is local variable + for (var parent = declaration.parent; !ts.isFunctionBlock(parent); parent = parent.parent) { + // Reached source file or module block + if (parent.kind === 308 /* SyntaxKind.SourceFile */ || parent.kind === 265 /* SyntaxKind.ModuleBlock */) { + return false; + } + } + // parent is in function block + return true; + }); + } + })(SymbolDisplay = ts.SymbolDisplay || (ts.SymbolDisplay = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + /* + * This function will compile source text from 'input' argument using specified compiler options. + * If not options are provided - it will use a set of default compiler options. + * Extra compiler options that will unconditionally be used by this function are: + * - isolatedModules = true + * - allowNonTsExtensions = true + * - noLib = true + * - noResolve = true + */ + function transpileModule(input, transpileOptions) { + var diagnostics = []; + var options = transpileOptions.compilerOptions ? fixupCompilerOptions(transpileOptions.compilerOptions, diagnostics) : {}; + // mix in default options + var defaultOptions = ts.getDefaultCompilerOptions(); + for (var key in defaultOptions) { + if (ts.hasProperty(defaultOptions, key) && options[key] === undefined) { + options[key] = defaultOptions[key]; + } + } + for (var _i = 0, transpileOptionValueCompilerOptions_1 = ts.transpileOptionValueCompilerOptions; _i < transpileOptionValueCompilerOptions_1.length; _i++) { + var option = transpileOptionValueCompilerOptions_1[_i]; + options[option.name] = option.transpileOptionValue; + } + // transpileModule does not write anything to disk so there is no need to verify that there are no conflicts between input and output paths. + options.suppressOutputPathCheck = true; + // Filename can be non-ts file. + options.allowNonTsExtensions = true; + var newLine = ts.getNewLineCharacter(options); + // Create a compilerHost object to allow the compiler to read and write files + var compilerHost = { + getSourceFile: function (fileName) { return fileName === ts.normalizePath(inputFileName) ? sourceFile : undefined; }, + writeFile: function (name, text) { + if (ts.fileExtensionIs(name, ".map")) { + ts.Debug.assertEqual(sourceMapText, undefined, "Unexpected multiple source map outputs, file:", name); + sourceMapText = text; + } + else { + ts.Debug.assertEqual(outputText, undefined, "Unexpected multiple outputs, file:", name); + outputText = text; + } + }, + getDefaultLibFileName: function () { return "lib.d.ts"; }, + useCaseSensitiveFileNames: function () { return false; }, + getCanonicalFileName: function (fileName) { return fileName; }, + getCurrentDirectory: function () { return ""; }, + getNewLine: function () { return newLine; }, + fileExists: function (fileName) { return fileName === inputFileName; }, + readFile: function () { return ""; }, + directoryExists: function () { return true; }, + getDirectories: function () { return []; } + }; + // if jsx is specified then treat file as .tsx + var inputFileName = transpileOptions.fileName || (transpileOptions.compilerOptions && transpileOptions.compilerOptions.jsx ? "module.tsx" : "module.ts"); + var sourceFile = ts.createSourceFile(inputFileName, input, { + languageVersion: ts.getEmitScriptTarget(options), + impliedNodeFormat: ts.getImpliedNodeFormatForFile(ts.toPath(inputFileName, "", compilerHost.getCanonicalFileName), /*cache*/ undefined, compilerHost, options), + setExternalModuleIndicator: ts.getSetExternalModuleIndicator(options) + }); + if (transpileOptions.moduleName) { + sourceFile.moduleName = transpileOptions.moduleName; + } + if (transpileOptions.renamedDependencies) { + sourceFile.renamedDependencies = new ts.Map(ts.getEntries(transpileOptions.renamedDependencies)); + } + // Output + var outputText; + var sourceMapText; + var program = ts.createProgram([inputFileName], options, compilerHost); + if (transpileOptions.reportDiagnostics) { + ts.addRange(/*to*/ diagnostics, /*from*/ program.getSyntacticDiagnostics(sourceFile)); + ts.addRange(/*to*/ diagnostics, /*from*/ program.getOptionsDiagnostics()); + } + // Emit + program.emit(/*targetSourceFile*/ undefined, /*writeFile*/ undefined, /*cancellationToken*/ undefined, /*emitOnlyDtsFiles*/ undefined, transpileOptions.transformers); + if (outputText === undefined) + return ts.Debug.fail("Output generation failed"); + return { outputText: outputText, diagnostics: diagnostics, sourceMapText: sourceMapText }; + } + ts.transpileModule = transpileModule; + /* + * This is a shortcut function for transpileModule - it accepts transpileOptions as parameters and returns only outputText part of the result. + */ + function transpile(input, compilerOptions, fileName, diagnostics, moduleName) { + var output = transpileModule(input, { compilerOptions: compilerOptions, fileName: fileName, reportDiagnostics: !!diagnostics, moduleName: moduleName }); + // addRange correctly handles cases when wither 'from' or 'to' argument is missing + ts.addRange(diagnostics, output.diagnostics); + return output.outputText; + } + ts.transpile = transpile; + var commandLineOptionsStringToEnum; + /** JS users may pass in string values for enum compiler options (such as ModuleKind), so convert. */ + /*@internal*/ + function fixupCompilerOptions(options, diagnostics) { + // Lazily create this value to fix module loading errors. + commandLineOptionsStringToEnum = commandLineOptionsStringToEnum || + ts.filter(ts.optionDeclarations, function (o) { return typeof o.type === "object" && !ts.forEachEntry(o.type, function (v) { return typeof v !== "number"; }); }); + options = ts.cloneCompilerOptions(options); + var _loop_8 = function (opt) { + if (!ts.hasProperty(options, opt.name)) { + return "continue"; + } + var value = options[opt.name]; + // Value should be a key of opt.type + if (ts.isString(value)) { + // If value is not a string, this will fail + options[opt.name] = ts.parseCustomTypeOption(opt, value, diagnostics); + } + else { + if (!ts.forEachEntry(opt.type, function (v) { return v === value; })) { + // Supplied value isn't a valid enum value. + diagnostics.push(ts.createCompilerDiagnosticForInvalidCustomType(opt)); + } + } + }; + for (var _i = 0, commandLineOptionsStringToEnum_1 = commandLineOptionsStringToEnum; _i < commandLineOptionsStringToEnum_1.length; _i++) { + var opt = commandLineOptionsStringToEnum_1[_i]; + _loop_8(opt); + } + return options; + } + ts.fixupCompilerOptions = fixupCompilerOptions; +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var formatting; + (function (formatting) { + var FormattingRequestKind; + (function (FormattingRequestKind) { + FormattingRequestKind[FormattingRequestKind["FormatDocument"] = 0] = "FormatDocument"; + FormattingRequestKind[FormattingRequestKind["FormatSelection"] = 1] = "FormatSelection"; + FormattingRequestKind[FormattingRequestKind["FormatOnEnter"] = 2] = "FormatOnEnter"; + FormattingRequestKind[FormattingRequestKind["FormatOnSemicolon"] = 3] = "FormatOnSemicolon"; + FormattingRequestKind[FormattingRequestKind["FormatOnOpeningCurlyBrace"] = 4] = "FormatOnOpeningCurlyBrace"; + FormattingRequestKind[FormattingRequestKind["FormatOnClosingCurlyBrace"] = 5] = "FormatOnClosingCurlyBrace"; + })(FormattingRequestKind = formatting.FormattingRequestKind || (formatting.FormattingRequestKind = {})); + var FormattingContext = /** @class */ (function () { + function FormattingContext(sourceFile, formattingRequestKind, options) { + this.sourceFile = sourceFile; + this.formattingRequestKind = formattingRequestKind; + this.options = options; + } + FormattingContext.prototype.updateContext = function (currentRange, currentTokenParent, nextRange, nextTokenParent, commonParent) { + this.currentTokenSpan = ts.Debug.checkDefined(currentRange); + this.currentTokenParent = ts.Debug.checkDefined(currentTokenParent); + this.nextTokenSpan = ts.Debug.checkDefined(nextRange); + this.nextTokenParent = ts.Debug.checkDefined(nextTokenParent); + this.contextNode = ts.Debug.checkDefined(commonParent); + // drop cached results + this.contextNodeAllOnSameLine = undefined; + this.nextNodeAllOnSameLine = undefined; + this.tokensAreOnSameLine = undefined; + this.contextNodeBlockIsOnOneLine = undefined; + this.nextNodeBlockIsOnOneLine = undefined; + }; + FormattingContext.prototype.ContextNodeAllOnSameLine = function () { + if (this.contextNodeAllOnSameLine === undefined) { + this.contextNodeAllOnSameLine = this.NodeIsOnOneLine(this.contextNode); + } + return this.contextNodeAllOnSameLine; + }; + FormattingContext.prototype.NextNodeAllOnSameLine = function () { + if (this.nextNodeAllOnSameLine === undefined) { + this.nextNodeAllOnSameLine = this.NodeIsOnOneLine(this.nextTokenParent); + } + return this.nextNodeAllOnSameLine; + }; + FormattingContext.prototype.TokensAreOnSameLine = function () { + if (this.tokensAreOnSameLine === undefined) { + var startLine = this.sourceFile.getLineAndCharacterOfPosition(this.currentTokenSpan.pos).line; + var endLine = this.sourceFile.getLineAndCharacterOfPosition(this.nextTokenSpan.pos).line; + this.tokensAreOnSameLine = (startLine === endLine); + } + return this.tokensAreOnSameLine; + }; + FormattingContext.prototype.ContextNodeBlockIsOnOneLine = function () { + if (this.contextNodeBlockIsOnOneLine === undefined) { + this.contextNodeBlockIsOnOneLine = this.BlockIsOnOneLine(this.contextNode); + } + return this.contextNodeBlockIsOnOneLine; + }; + FormattingContext.prototype.NextNodeBlockIsOnOneLine = function () { + if (this.nextNodeBlockIsOnOneLine === undefined) { + this.nextNodeBlockIsOnOneLine = this.BlockIsOnOneLine(this.nextTokenParent); + } + return this.nextNodeBlockIsOnOneLine; + }; + FormattingContext.prototype.NodeIsOnOneLine = function (node) { + var startLine = this.sourceFile.getLineAndCharacterOfPosition(node.getStart(this.sourceFile)).line; + var endLine = this.sourceFile.getLineAndCharacterOfPosition(node.getEnd()).line; + return startLine === endLine; + }; + FormattingContext.prototype.BlockIsOnOneLine = function (node) { + var openBrace = ts.findChildOfKind(node, 18 /* SyntaxKind.OpenBraceToken */, this.sourceFile); + var closeBrace = ts.findChildOfKind(node, 19 /* SyntaxKind.CloseBraceToken */, this.sourceFile); + if (openBrace && closeBrace) { + var startLine = this.sourceFile.getLineAndCharacterOfPosition(openBrace.getEnd()).line; + var endLine = this.sourceFile.getLineAndCharacterOfPosition(closeBrace.getStart(this.sourceFile)).line; + return startLine === endLine; + } + return false; + }; + return FormattingContext; + }()); + formatting.FormattingContext = FormattingContext; + })(formatting = ts.formatting || (ts.formatting = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var formatting; + (function (formatting) { + var standardScanner = ts.createScanner(99 /* ScriptTarget.Latest */, /*skipTrivia*/ false, 0 /* LanguageVariant.Standard */); + var jsxScanner = ts.createScanner(99 /* ScriptTarget.Latest */, /*skipTrivia*/ false, 1 /* LanguageVariant.JSX */); + var ScanAction; + (function (ScanAction) { + ScanAction[ScanAction["Scan"] = 0] = "Scan"; + ScanAction[ScanAction["RescanGreaterThanToken"] = 1] = "RescanGreaterThanToken"; + ScanAction[ScanAction["RescanSlashToken"] = 2] = "RescanSlashToken"; + ScanAction[ScanAction["RescanTemplateToken"] = 3] = "RescanTemplateToken"; + ScanAction[ScanAction["RescanJsxIdentifier"] = 4] = "RescanJsxIdentifier"; + ScanAction[ScanAction["RescanJsxText"] = 5] = "RescanJsxText"; + ScanAction[ScanAction["RescanJsxAttributeValue"] = 6] = "RescanJsxAttributeValue"; + })(ScanAction || (ScanAction = {})); + function getFormattingScanner(text, languageVariant, startPos, endPos, cb) { + var scanner = languageVariant === 1 /* LanguageVariant.JSX */ ? jsxScanner : standardScanner; + scanner.setText(text); + scanner.setTextPos(startPos); + var wasNewLine = true; + var leadingTrivia; + var trailingTrivia; + var savedPos; + var lastScanAction; + var lastTokenInfo; + var res = cb({ + advance: advance, + readTokenInfo: readTokenInfo, + readEOFTokenRange: readEOFTokenRange, + isOnToken: isOnToken, + isOnEOF: isOnEOF, + getCurrentLeadingTrivia: function () { return leadingTrivia; }, + lastTrailingTriviaWasNewLine: function () { return wasNewLine; }, + skipToEndOf: skipToEndOf, + skipToStartOf: skipToStartOf, + getStartPos: function () { var _a; return (_a = lastTokenInfo === null || lastTokenInfo === void 0 ? void 0 : lastTokenInfo.token.pos) !== null && _a !== void 0 ? _a : scanner.getTokenPos(); }, + }); + lastTokenInfo = undefined; + scanner.setText(undefined); + return res; + function advance() { + lastTokenInfo = undefined; + var isStarted = scanner.getStartPos() !== startPos; + if (isStarted) { + wasNewLine = !!trailingTrivia && ts.last(trailingTrivia).kind === 4 /* SyntaxKind.NewLineTrivia */; + } + else { + scanner.scan(); + } + leadingTrivia = undefined; + trailingTrivia = undefined; + var pos = scanner.getStartPos(); + // Read leading trivia and token + while (pos < endPos) { + var t = scanner.getToken(); + if (!ts.isTrivia(t)) { + break; + } + // consume leading trivia + scanner.scan(); + var item = { + pos: pos, + end: scanner.getStartPos(), + kind: t + }; + pos = scanner.getStartPos(); + leadingTrivia = ts.append(leadingTrivia, item); + } + savedPos = scanner.getStartPos(); + } + function shouldRescanGreaterThanToken(node) { + switch (node.kind) { + case 33 /* SyntaxKind.GreaterThanEqualsToken */: + case 71 /* SyntaxKind.GreaterThanGreaterThanEqualsToken */: + case 72 /* SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken */: + case 49 /* SyntaxKind.GreaterThanGreaterThanGreaterThanToken */: + case 48 /* SyntaxKind.GreaterThanGreaterThanToken */: + return true; + } + return false; + } + function shouldRescanJsxIdentifier(node) { + if (node.parent) { + switch (node.parent.kind) { + case 288 /* SyntaxKind.JsxAttribute */: + case 283 /* SyntaxKind.JsxOpeningElement */: + case 284 /* SyntaxKind.JsxClosingElement */: + case 282 /* SyntaxKind.JsxSelfClosingElement */: + // May parse an identifier like `module-layout`; that will be scanned as a keyword at first, but we should parse the whole thing to get an identifier. + return ts.isKeyword(node.kind) || node.kind === 79 /* SyntaxKind.Identifier */; + } + } + return false; + } + function shouldRescanJsxText(node) { + return ts.isJsxText(node) || ts.isJsxElement(node) && (lastTokenInfo === null || lastTokenInfo === void 0 ? void 0 : lastTokenInfo.token.kind) === 11 /* SyntaxKind.JsxText */; + } + function shouldRescanSlashToken(container) { + return container.kind === 13 /* SyntaxKind.RegularExpressionLiteral */; + } + function shouldRescanTemplateToken(container) { + return container.kind === 16 /* SyntaxKind.TemplateMiddle */ || + container.kind === 17 /* SyntaxKind.TemplateTail */; + } + function shouldRescanJsxAttributeValue(node) { + return node.parent && ts.isJsxAttribute(node.parent) && node.parent.initializer === node; + } + function startsWithSlashToken(t) { + return t === 43 /* SyntaxKind.SlashToken */ || t === 68 /* SyntaxKind.SlashEqualsToken */; + } + function readTokenInfo(n) { + ts.Debug.assert(isOnToken()); + // normally scanner returns the smallest available token + // check the kind of context node to determine if scanner should have more greedy behavior and consume more text. + var expectedScanAction = shouldRescanGreaterThanToken(n) ? 1 /* ScanAction.RescanGreaterThanToken */ : + shouldRescanSlashToken(n) ? 2 /* ScanAction.RescanSlashToken */ : + shouldRescanTemplateToken(n) ? 3 /* ScanAction.RescanTemplateToken */ : + shouldRescanJsxIdentifier(n) ? 4 /* ScanAction.RescanJsxIdentifier */ : + shouldRescanJsxText(n) ? 5 /* ScanAction.RescanJsxText */ : + shouldRescanJsxAttributeValue(n) ? 6 /* ScanAction.RescanJsxAttributeValue */ : + 0 /* ScanAction.Scan */; + if (lastTokenInfo && expectedScanAction === lastScanAction) { + // readTokenInfo was called before with the same expected scan action. + // No need to re-scan text, return existing 'lastTokenInfo' + // it is ok to call fixTokenKind here since it does not affect + // what portion of text is consumed. In contrast rescanning can change it, + // i.e. for '>=' when originally scanner eats just one character + // and rescanning forces it to consume more. + return fixTokenKind(lastTokenInfo, n); + } + if (scanner.getStartPos() !== savedPos) { + ts.Debug.assert(lastTokenInfo !== undefined); + // readTokenInfo was called before but scan action differs - rescan text + scanner.setTextPos(savedPos); + scanner.scan(); + } + var currentToken = getNextToken(n, expectedScanAction); + var token = formatting.createTextRangeWithKind(scanner.getStartPos(), scanner.getTextPos(), currentToken); + // consume trailing trivia + if (trailingTrivia) { + trailingTrivia = undefined; + } + while (scanner.getStartPos() < endPos) { + currentToken = scanner.scan(); + if (!ts.isTrivia(currentToken)) { + break; + } + var trivia = formatting.createTextRangeWithKind(scanner.getStartPos(), scanner.getTextPos(), currentToken); + if (!trailingTrivia) { + trailingTrivia = []; + } + trailingTrivia.push(trivia); + if (currentToken === 4 /* SyntaxKind.NewLineTrivia */) { + // move past new line + scanner.scan(); + break; + } + } + lastTokenInfo = { leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia, token: token }; + return fixTokenKind(lastTokenInfo, n); + } + function getNextToken(n, expectedScanAction) { + var token = scanner.getToken(); + lastScanAction = 0 /* ScanAction.Scan */; + switch (expectedScanAction) { + case 1 /* ScanAction.RescanGreaterThanToken */: + if (token === 31 /* SyntaxKind.GreaterThanToken */) { + lastScanAction = 1 /* ScanAction.RescanGreaterThanToken */; + var newToken = scanner.reScanGreaterToken(); + ts.Debug.assert(n.kind === newToken); + return newToken; + } + break; + case 2 /* ScanAction.RescanSlashToken */: + if (startsWithSlashToken(token)) { + lastScanAction = 2 /* ScanAction.RescanSlashToken */; + var newToken = scanner.reScanSlashToken(); + ts.Debug.assert(n.kind === newToken); + return newToken; + } + break; + case 3 /* ScanAction.RescanTemplateToken */: + if (token === 19 /* SyntaxKind.CloseBraceToken */) { + lastScanAction = 3 /* ScanAction.RescanTemplateToken */; + return scanner.reScanTemplateToken(/* isTaggedTemplate */ false); + } + break; + case 4 /* ScanAction.RescanJsxIdentifier */: + lastScanAction = 4 /* ScanAction.RescanJsxIdentifier */; + return scanner.scanJsxIdentifier(); + case 5 /* ScanAction.RescanJsxText */: + lastScanAction = 5 /* ScanAction.RescanJsxText */; + return scanner.reScanJsxToken(/* allowMultilineJsxText */ false); + case 6 /* ScanAction.RescanJsxAttributeValue */: + lastScanAction = 6 /* ScanAction.RescanJsxAttributeValue */; + return scanner.reScanJsxAttributeValue(); + case 0 /* ScanAction.Scan */: + break; + default: + ts.Debug.assertNever(expectedScanAction); + } + return token; + } + function readEOFTokenRange() { + ts.Debug.assert(isOnEOF()); + return formatting.createTextRangeWithKind(scanner.getStartPos(), scanner.getTextPos(), 1 /* SyntaxKind.EndOfFileToken */); + } + function isOnToken() { + var current = lastTokenInfo ? lastTokenInfo.token.kind : scanner.getToken(); + return current !== 1 /* SyntaxKind.EndOfFileToken */ && !ts.isTrivia(current); + } + function isOnEOF() { + var current = lastTokenInfo ? lastTokenInfo.token.kind : scanner.getToken(); + return current === 1 /* SyntaxKind.EndOfFileToken */; + } + // when containing node in the tree is token + // but its kind differs from the kind that was returned by the scanner, + // then kind needs to be fixed. This might happen in cases + // when parser interprets token differently, i.e keyword treated as identifier + function fixTokenKind(tokenInfo, container) { + if (ts.isToken(container) && tokenInfo.token.kind !== container.kind) { + tokenInfo.token.kind = container.kind; + } + return tokenInfo; + } + function skipToEndOf(node) { + scanner.setTextPos(node.end); + savedPos = scanner.getStartPos(); + lastScanAction = undefined; + lastTokenInfo = undefined; + wasNewLine = false; + leadingTrivia = undefined; + trailingTrivia = undefined; + } + function skipToStartOf(node) { + scanner.setTextPos(node.pos); + savedPos = scanner.getStartPos(); + lastScanAction = undefined; + lastTokenInfo = undefined; + wasNewLine = false; + leadingTrivia = undefined; + trailingTrivia = undefined; + } + } + formatting.getFormattingScanner = getFormattingScanner; + })(formatting = ts.formatting || (ts.formatting = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var formatting; + (function (formatting) { + formatting.anyContext = ts.emptyArray; + var RuleAction; + (function (RuleAction) { + RuleAction[RuleAction["StopProcessingSpaceActions"] = 1] = "StopProcessingSpaceActions"; + RuleAction[RuleAction["StopProcessingTokenActions"] = 2] = "StopProcessingTokenActions"; + RuleAction[RuleAction["InsertSpace"] = 4] = "InsertSpace"; + RuleAction[RuleAction["InsertNewLine"] = 8] = "InsertNewLine"; + RuleAction[RuleAction["DeleteSpace"] = 16] = "DeleteSpace"; + RuleAction[RuleAction["DeleteToken"] = 32] = "DeleteToken"; + RuleAction[RuleAction["InsertTrailingSemicolon"] = 64] = "InsertTrailingSemicolon"; + RuleAction[RuleAction["StopAction"] = 3] = "StopAction"; + RuleAction[RuleAction["ModifySpaceAction"] = 28] = "ModifySpaceAction"; + RuleAction[RuleAction["ModifyTokenAction"] = 96] = "ModifyTokenAction"; + })(RuleAction = formatting.RuleAction || (formatting.RuleAction = {})); + var RuleFlags; + (function (RuleFlags) { + RuleFlags[RuleFlags["None"] = 0] = "None"; + RuleFlags[RuleFlags["CanDeleteNewLines"] = 1] = "CanDeleteNewLines"; + })(RuleFlags = formatting.RuleFlags || (formatting.RuleFlags = {})); + })(formatting = ts.formatting || (ts.formatting = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var formatting; + (function (formatting) { + function getAllRules() { + var allTokens = []; + for (var token = 0 /* SyntaxKind.FirstToken */; token <= 162 /* SyntaxKind.LastToken */; token++) { + if (token !== 1 /* SyntaxKind.EndOfFileToken */) { + allTokens.push(token); + } + } + function anyTokenExcept() { + var tokens = []; + for (var _i = 0; _i < arguments.length; _i++) { + tokens[_i] = arguments[_i]; + } + return { tokens: allTokens.filter(function (t) { return !tokens.some(function (t2) { return t2 === t; }); }), isSpecific: false }; + } + var anyToken = { tokens: allTokens, isSpecific: false }; + var anyTokenIncludingMultilineComments = tokenRangeFrom(__spreadArray(__spreadArray([], allTokens, true), [3 /* SyntaxKind.MultiLineCommentTrivia */], false)); + var anyTokenIncludingEOF = tokenRangeFrom(__spreadArray(__spreadArray([], allTokens, true), [1 /* SyntaxKind.EndOfFileToken */], false)); + var keywords = tokenRangeFromRange(81 /* SyntaxKind.FirstKeyword */, 162 /* SyntaxKind.LastKeyword */); + var binaryOperators = tokenRangeFromRange(29 /* SyntaxKind.FirstBinaryOperator */, 78 /* SyntaxKind.LastBinaryOperator */); + var binaryKeywordOperators = [101 /* SyntaxKind.InKeyword */, 102 /* SyntaxKind.InstanceOfKeyword */, 162 /* SyntaxKind.OfKeyword */, 128 /* SyntaxKind.AsKeyword */, 140 /* SyntaxKind.IsKeyword */]; + var unaryPrefixOperators = [45 /* SyntaxKind.PlusPlusToken */, 46 /* SyntaxKind.MinusMinusToken */, 54 /* SyntaxKind.TildeToken */, 53 /* SyntaxKind.ExclamationToken */]; + var unaryPrefixExpressions = [ + 8 /* SyntaxKind.NumericLiteral */, 9 /* SyntaxKind.BigIntLiteral */, 79 /* SyntaxKind.Identifier */, 20 /* SyntaxKind.OpenParenToken */, + 22 /* SyntaxKind.OpenBracketToken */, 18 /* SyntaxKind.OpenBraceToken */, 108 /* SyntaxKind.ThisKeyword */, 103 /* SyntaxKind.NewKeyword */ + ]; + var unaryPreincrementExpressions = [79 /* SyntaxKind.Identifier */, 20 /* SyntaxKind.OpenParenToken */, 108 /* SyntaxKind.ThisKeyword */, 103 /* SyntaxKind.NewKeyword */]; + var unaryPostincrementExpressions = [79 /* SyntaxKind.Identifier */, 21 /* SyntaxKind.CloseParenToken */, 23 /* SyntaxKind.CloseBracketToken */, 103 /* SyntaxKind.NewKeyword */]; + var unaryPredecrementExpressions = [79 /* SyntaxKind.Identifier */, 20 /* SyntaxKind.OpenParenToken */, 108 /* SyntaxKind.ThisKeyword */, 103 /* SyntaxKind.NewKeyword */]; + var unaryPostdecrementExpressions = [79 /* SyntaxKind.Identifier */, 21 /* SyntaxKind.CloseParenToken */, 23 /* SyntaxKind.CloseBracketToken */, 103 /* SyntaxKind.NewKeyword */]; + var comments = [2 /* SyntaxKind.SingleLineCommentTrivia */, 3 /* SyntaxKind.MultiLineCommentTrivia */]; + var typeNames = __spreadArray([79 /* SyntaxKind.Identifier */], ts.typeKeywords, true); + // Place a space before open brace in a function declaration + // TypeScript: Function can have return types, which can be made of tons of different token kinds + var functionOpenBraceLeftTokenRange = anyTokenIncludingMultilineComments; + // Place a space before open brace in a TypeScript declaration that has braces as children (class, module, enum, etc) + var typeScriptOpenBraceLeftTokenRange = tokenRangeFrom([79 /* SyntaxKind.Identifier */, 3 /* SyntaxKind.MultiLineCommentTrivia */, 84 /* SyntaxKind.ClassKeyword */, 93 /* SyntaxKind.ExportKeyword */, 100 /* SyntaxKind.ImportKeyword */]); + // Place a space before open brace in a control flow construct + var controlOpenBraceLeftTokenRange = tokenRangeFrom([21 /* SyntaxKind.CloseParenToken */, 3 /* SyntaxKind.MultiLineCommentTrivia */, 90 /* SyntaxKind.DoKeyword */, 111 /* SyntaxKind.TryKeyword */, 96 /* SyntaxKind.FinallyKeyword */, 91 /* SyntaxKind.ElseKeyword */]); + // These rules are higher in priority than user-configurable + var highPriorityCommonRules = [ + // Leave comments alone + rule("IgnoreBeforeComment", anyToken, comments, formatting.anyContext, 1 /* RuleAction.StopProcessingSpaceActions */), + rule("IgnoreAfterLineComment", 2 /* SyntaxKind.SingleLineCommentTrivia */, anyToken, formatting.anyContext, 1 /* RuleAction.StopProcessingSpaceActions */), + rule("NotSpaceBeforeColon", anyToken, 58 /* SyntaxKind.ColonToken */, [isNonJsxSameLineTokenContext, isNotBinaryOpContext, isNotTypeAnnotationContext], 16 /* RuleAction.DeleteSpace */), + rule("SpaceAfterColon", 58 /* SyntaxKind.ColonToken */, anyToken, [isNonJsxSameLineTokenContext, isNotBinaryOpContext], 4 /* RuleAction.InsertSpace */), + rule("NoSpaceBeforeQuestionMark", anyToken, 57 /* SyntaxKind.QuestionToken */, [isNonJsxSameLineTokenContext, isNotBinaryOpContext, isNotTypeAnnotationContext], 16 /* RuleAction.DeleteSpace */), + // insert space after '?' only when it is used in conditional operator + rule("SpaceAfterQuestionMarkInConditionalOperator", 57 /* SyntaxKind.QuestionToken */, anyToken, [isNonJsxSameLineTokenContext, isConditionalOperatorContext], 4 /* RuleAction.InsertSpace */), + // in other cases there should be no space between '?' and next token + rule("NoSpaceAfterQuestionMark", 57 /* SyntaxKind.QuestionToken */, anyToken, [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + rule("NoSpaceBeforeDot", anyToken, [24 /* SyntaxKind.DotToken */, 28 /* SyntaxKind.QuestionDotToken */], [isNonJsxSameLineTokenContext, isNotPropertyAccessOnIntegerLiteral], 16 /* RuleAction.DeleteSpace */), + rule("NoSpaceAfterDot", [24 /* SyntaxKind.DotToken */, 28 /* SyntaxKind.QuestionDotToken */], anyToken, [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + rule("NoSpaceBetweenImportParenInImportType", 100 /* SyntaxKind.ImportKeyword */, 20 /* SyntaxKind.OpenParenToken */, [isNonJsxSameLineTokenContext, isImportTypeContext], 16 /* RuleAction.DeleteSpace */), + // Special handling of unary operators. + // Prefix operators generally shouldn't have a space between + // them and their target unary expression. + rule("NoSpaceAfterUnaryPrefixOperator", unaryPrefixOperators, unaryPrefixExpressions, [isNonJsxSameLineTokenContext, isNotBinaryOpContext], 16 /* RuleAction.DeleteSpace */), + rule("NoSpaceAfterUnaryPreincrementOperator", 45 /* SyntaxKind.PlusPlusToken */, unaryPreincrementExpressions, [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + rule("NoSpaceAfterUnaryPredecrementOperator", 46 /* SyntaxKind.MinusMinusToken */, unaryPredecrementExpressions, [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + rule("NoSpaceBeforeUnaryPostincrementOperator", unaryPostincrementExpressions, 45 /* SyntaxKind.PlusPlusToken */, [isNonJsxSameLineTokenContext, isNotStatementConditionContext], 16 /* RuleAction.DeleteSpace */), + rule("NoSpaceBeforeUnaryPostdecrementOperator", unaryPostdecrementExpressions, 46 /* SyntaxKind.MinusMinusToken */, [isNonJsxSameLineTokenContext, isNotStatementConditionContext], 16 /* RuleAction.DeleteSpace */), + // More unary operator special-casing. + // DevDiv 181814: Be careful when removing leading whitespace + // around unary operators. Examples: + // 1 - -2 --X--> 1--2 + // a + ++b --X--> a+++b + rule("SpaceAfterPostincrementWhenFollowedByAdd", 45 /* SyntaxKind.PlusPlusToken */, 39 /* SyntaxKind.PlusToken */, [isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* RuleAction.InsertSpace */), + rule("SpaceAfterAddWhenFollowedByUnaryPlus", 39 /* SyntaxKind.PlusToken */, 39 /* SyntaxKind.PlusToken */, [isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* RuleAction.InsertSpace */), + rule("SpaceAfterAddWhenFollowedByPreincrement", 39 /* SyntaxKind.PlusToken */, 45 /* SyntaxKind.PlusPlusToken */, [isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* RuleAction.InsertSpace */), + rule("SpaceAfterPostdecrementWhenFollowedBySubtract", 46 /* SyntaxKind.MinusMinusToken */, 40 /* SyntaxKind.MinusToken */, [isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* RuleAction.InsertSpace */), + rule("SpaceAfterSubtractWhenFollowedByUnaryMinus", 40 /* SyntaxKind.MinusToken */, 40 /* SyntaxKind.MinusToken */, [isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* RuleAction.InsertSpace */), + rule("SpaceAfterSubtractWhenFollowedByPredecrement", 40 /* SyntaxKind.MinusToken */, 46 /* SyntaxKind.MinusMinusToken */, [isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* RuleAction.InsertSpace */), + rule("NoSpaceAfterCloseBrace", 19 /* SyntaxKind.CloseBraceToken */, [27 /* SyntaxKind.CommaToken */, 26 /* SyntaxKind.SemicolonToken */], [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + // For functions and control block place } on a new line [multi-line rule] + rule("NewLineBeforeCloseBraceInBlockContext", anyTokenIncludingMultilineComments, 19 /* SyntaxKind.CloseBraceToken */, [isMultilineBlockContext], 8 /* RuleAction.InsertNewLine */), + // Space/new line after }. + rule("SpaceAfterCloseBrace", 19 /* SyntaxKind.CloseBraceToken */, anyTokenExcept(21 /* SyntaxKind.CloseParenToken */), [isNonJsxSameLineTokenContext, isAfterCodeBlockContext], 4 /* RuleAction.InsertSpace */), + // Special case for (}, else) and (}, while) since else & while tokens are not part of the tree which makes SpaceAfterCloseBrace rule not applied + // Also should not apply to }) + rule("SpaceBetweenCloseBraceAndElse", 19 /* SyntaxKind.CloseBraceToken */, 91 /* SyntaxKind.ElseKeyword */, [isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */), + rule("SpaceBetweenCloseBraceAndWhile", 19 /* SyntaxKind.CloseBraceToken */, 115 /* SyntaxKind.WhileKeyword */, [isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */), + rule("NoSpaceBetweenEmptyBraceBrackets", 18 /* SyntaxKind.OpenBraceToken */, 19 /* SyntaxKind.CloseBraceToken */, [isNonJsxSameLineTokenContext, isObjectContext], 16 /* RuleAction.DeleteSpace */), + // Add a space after control dec context if the next character is an open bracket ex: 'if (false)[a, b] = [1, 2];' -> 'if (false) [a, b] = [1, 2];' + rule("SpaceAfterConditionalClosingParen", 21 /* SyntaxKind.CloseParenToken */, 22 /* SyntaxKind.OpenBracketToken */, [isControlDeclContext], 4 /* RuleAction.InsertSpace */), + rule("NoSpaceBetweenFunctionKeywordAndStar", 98 /* SyntaxKind.FunctionKeyword */, 41 /* SyntaxKind.AsteriskToken */, [isFunctionDeclarationOrFunctionExpressionContext], 16 /* RuleAction.DeleteSpace */), + rule("SpaceAfterStarInGeneratorDeclaration", 41 /* SyntaxKind.AsteriskToken */, 79 /* SyntaxKind.Identifier */, [isFunctionDeclarationOrFunctionExpressionContext], 4 /* RuleAction.InsertSpace */), + rule("SpaceAfterFunctionInFuncDecl", 98 /* SyntaxKind.FunctionKeyword */, anyToken, [isFunctionDeclContext], 4 /* RuleAction.InsertSpace */), + // Insert new line after { and before } in multi-line contexts. + rule("NewLineAfterOpenBraceInBlockContext", 18 /* SyntaxKind.OpenBraceToken */, anyToken, [isMultilineBlockContext], 8 /* RuleAction.InsertNewLine */), + // For get/set members, we check for (identifier,identifier) since get/set don't have tokens and they are represented as just an identifier token. + // Though, we do extra check on the context to make sure we are dealing with get/set node. Example: + // get x() {} + // set x(val) {} + rule("SpaceAfterGetSetInMember", [137 /* SyntaxKind.GetKeyword */, 151 /* SyntaxKind.SetKeyword */], 79 /* SyntaxKind.Identifier */, [isFunctionDeclContext], 4 /* RuleAction.InsertSpace */), + rule("NoSpaceBetweenYieldKeywordAndStar", 125 /* SyntaxKind.YieldKeyword */, 41 /* SyntaxKind.AsteriskToken */, [isNonJsxSameLineTokenContext, isYieldOrYieldStarWithOperand], 16 /* RuleAction.DeleteSpace */), + rule("SpaceBetweenYieldOrYieldStarAndOperand", [125 /* SyntaxKind.YieldKeyword */, 41 /* SyntaxKind.AsteriskToken */], anyToken, [isNonJsxSameLineTokenContext, isYieldOrYieldStarWithOperand], 4 /* RuleAction.InsertSpace */), + rule("NoSpaceBetweenReturnAndSemicolon", 105 /* SyntaxKind.ReturnKeyword */, 26 /* SyntaxKind.SemicolonToken */, [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + rule("SpaceAfterCertainKeywords", [113 /* SyntaxKind.VarKeyword */, 109 /* SyntaxKind.ThrowKeyword */, 103 /* SyntaxKind.NewKeyword */, 89 /* SyntaxKind.DeleteKeyword */, 105 /* SyntaxKind.ReturnKeyword */, 112 /* SyntaxKind.TypeOfKeyword */, 133 /* SyntaxKind.AwaitKeyword */], anyToken, [isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */), + rule("SpaceAfterLetConstInVariableDeclaration", [119 /* SyntaxKind.LetKeyword */, 85 /* SyntaxKind.ConstKeyword */], anyToken, [isNonJsxSameLineTokenContext, isStartOfVariableDeclarationList], 4 /* RuleAction.InsertSpace */), + rule("NoSpaceBeforeOpenParenInFuncCall", anyToken, 20 /* SyntaxKind.OpenParenToken */, [isNonJsxSameLineTokenContext, isFunctionCallOrNewContext, isPreviousTokenNotComma], 16 /* RuleAction.DeleteSpace */), + // Special case for binary operators (that are keywords). For these we have to add a space and shouldn't follow any user options. + rule("SpaceBeforeBinaryKeywordOperator", anyToken, binaryKeywordOperators, [isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* RuleAction.InsertSpace */), + rule("SpaceAfterBinaryKeywordOperator", binaryKeywordOperators, anyToken, [isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* RuleAction.InsertSpace */), + rule("SpaceAfterVoidOperator", 114 /* SyntaxKind.VoidKeyword */, anyToken, [isNonJsxSameLineTokenContext, isVoidOpContext], 4 /* RuleAction.InsertSpace */), + // Async-await + rule("SpaceBetweenAsyncAndOpenParen", 132 /* SyntaxKind.AsyncKeyword */, 20 /* SyntaxKind.OpenParenToken */, [isArrowFunctionContext, isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */), + rule("SpaceBetweenAsyncAndFunctionKeyword", 132 /* SyntaxKind.AsyncKeyword */, [98 /* SyntaxKind.FunctionKeyword */, 79 /* SyntaxKind.Identifier */], [isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */), + // Template string + rule("NoSpaceBetweenTagAndTemplateString", [79 /* SyntaxKind.Identifier */, 21 /* SyntaxKind.CloseParenToken */], [14 /* SyntaxKind.NoSubstitutionTemplateLiteral */, 15 /* SyntaxKind.TemplateHead */], [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + // JSX opening elements + rule("SpaceBeforeJsxAttribute", anyToken, 79 /* SyntaxKind.Identifier */, [isNextTokenParentJsxAttribute, isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */), + rule("SpaceBeforeSlashInJsxOpeningElement", anyToken, 43 /* SyntaxKind.SlashToken */, [isJsxSelfClosingElementContext, isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */), + rule("NoSpaceBeforeGreaterThanTokenInJsxOpeningElement", 43 /* SyntaxKind.SlashToken */, 31 /* SyntaxKind.GreaterThanToken */, [isJsxSelfClosingElementContext, isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + rule("NoSpaceBeforeEqualInJsxAttribute", anyToken, 63 /* SyntaxKind.EqualsToken */, [isJsxAttributeContext, isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + rule("NoSpaceAfterEqualInJsxAttribute", 63 /* SyntaxKind.EqualsToken */, anyToken, [isJsxAttributeContext, isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + // TypeScript-specific rules + // Use of module as a function call. e.g.: import m2 = module("m2"); + rule("NoSpaceAfterModuleImport", [142 /* SyntaxKind.ModuleKeyword */, 147 /* SyntaxKind.RequireKeyword */], 20 /* SyntaxKind.OpenParenToken */, [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + // Add a space around certain TypeScript keywords + rule("SpaceAfterCertainTypeScriptKeywords", [ + 126 /* SyntaxKind.AbstractKeyword */, + 127 /* SyntaxKind.AccessorKeyword */, + 84 /* SyntaxKind.ClassKeyword */, + 136 /* SyntaxKind.DeclareKeyword */, + 88 /* SyntaxKind.DefaultKeyword */, + 92 /* SyntaxKind.EnumKeyword */, + 93 /* SyntaxKind.ExportKeyword */, + 94 /* SyntaxKind.ExtendsKeyword */, + 137 /* SyntaxKind.GetKeyword */, + 117 /* SyntaxKind.ImplementsKeyword */, + 100 /* SyntaxKind.ImportKeyword */, + 118 /* SyntaxKind.InterfaceKeyword */, + 142 /* SyntaxKind.ModuleKeyword */, + 143 /* SyntaxKind.NamespaceKeyword */, + 121 /* SyntaxKind.PrivateKeyword */, + 123 /* SyntaxKind.PublicKeyword */, + 122 /* SyntaxKind.ProtectedKeyword */, + 146 /* SyntaxKind.ReadonlyKeyword */, + 151 /* SyntaxKind.SetKeyword */, + 124 /* SyntaxKind.StaticKeyword */, + 154 /* SyntaxKind.TypeKeyword */, + 158 /* SyntaxKind.FromKeyword */, + 141 /* SyntaxKind.KeyOfKeyword */, + 138 /* SyntaxKind.InferKeyword */, + ], anyToken, [isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */), + rule("SpaceBeforeCertainTypeScriptKeywords", anyToken, [94 /* SyntaxKind.ExtendsKeyword */, 117 /* SyntaxKind.ImplementsKeyword */, 158 /* SyntaxKind.FromKeyword */], [isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */), + // Treat string literals in module names as identifiers, and add a space between the literal and the opening Brace braces, e.g.: module "m2" { + rule("SpaceAfterModuleName", 10 /* SyntaxKind.StringLiteral */, 18 /* SyntaxKind.OpenBraceToken */, [isModuleDeclContext], 4 /* RuleAction.InsertSpace */), + // Lambda expressions + rule("SpaceBeforeArrow", anyToken, 38 /* SyntaxKind.EqualsGreaterThanToken */, [isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */), + rule("SpaceAfterArrow", 38 /* SyntaxKind.EqualsGreaterThanToken */, anyToken, [isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */), + // Optional parameters and let args + rule("NoSpaceAfterEllipsis", 25 /* SyntaxKind.DotDotDotToken */, 79 /* SyntaxKind.Identifier */, [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + rule("NoSpaceAfterOptionalParameters", 57 /* SyntaxKind.QuestionToken */, [21 /* SyntaxKind.CloseParenToken */, 27 /* SyntaxKind.CommaToken */], [isNonJsxSameLineTokenContext, isNotBinaryOpContext], 16 /* RuleAction.DeleteSpace */), + // Remove spaces in empty interface literals. e.g.: x: {} + rule("NoSpaceBetweenEmptyInterfaceBraceBrackets", 18 /* SyntaxKind.OpenBraceToken */, 19 /* SyntaxKind.CloseBraceToken */, [isNonJsxSameLineTokenContext, isObjectTypeContext], 16 /* RuleAction.DeleteSpace */), + // generics and type assertions + rule("NoSpaceBeforeOpenAngularBracket", typeNames, 29 /* SyntaxKind.LessThanToken */, [isNonJsxSameLineTokenContext, isTypeArgumentOrParameterOrAssertionContext], 16 /* RuleAction.DeleteSpace */), + rule("NoSpaceBetweenCloseParenAndAngularBracket", 21 /* SyntaxKind.CloseParenToken */, 29 /* SyntaxKind.LessThanToken */, [isNonJsxSameLineTokenContext, isTypeArgumentOrParameterOrAssertionContext], 16 /* RuleAction.DeleteSpace */), + rule("NoSpaceAfterOpenAngularBracket", 29 /* SyntaxKind.LessThanToken */, anyToken, [isNonJsxSameLineTokenContext, isTypeArgumentOrParameterOrAssertionContext], 16 /* RuleAction.DeleteSpace */), + rule("NoSpaceBeforeCloseAngularBracket", anyToken, 31 /* SyntaxKind.GreaterThanToken */, [isNonJsxSameLineTokenContext, isTypeArgumentOrParameterOrAssertionContext], 16 /* RuleAction.DeleteSpace */), + rule("NoSpaceAfterCloseAngularBracket", 31 /* SyntaxKind.GreaterThanToken */, [20 /* SyntaxKind.OpenParenToken */, 22 /* SyntaxKind.OpenBracketToken */, 31 /* SyntaxKind.GreaterThanToken */, 27 /* SyntaxKind.CommaToken */], [isNonJsxSameLineTokenContext, isTypeArgumentOrParameterOrAssertionContext, isNotFunctionDeclContext /*To prevent an interference with the SpaceBeforeOpenParenInFuncDecl rule*/], 16 /* RuleAction.DeleteSpace */), + // decorators + rule("SpaceBeforeAt", [21 /* SyntaxKind.CloseParenToken */, 79 /* SyntaxKind.Identifier */], 59 /* SyntaxKind.AtToken */, [isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */), + rule("NoSpaceAfterAt", 59 /* SyntaxKind.AtToken */, anyToken, [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + // Insert space after @ in decorator + rule("SpaceAfterDecorator", anyToken, [ + 126 /* SyntaxKind.AbstractKeyword */, + 79 /* SyntaxKind.Identifier */, + 93 /* SyntaxKind.ExportKeyword */, + 88 /* SyntaxKind.DefaultKeyword */, + 84 /* SyntaxKind.ClassKeyword */, + 124 /* SyntaxKind.StaticKeyword */, + 123 /* SyntaxKind.PublicKeyword */, + 121 /* SyntaxKind.PrivateKeyword */, + 122 /* SyntaxKind.ProtectedKeyword */, + 137 /* SyntaxKind.GetKeyword */, + 151 /* SyntaxKind.SetKeyword */, + 22 /* SyntaxKind.OpenBracketToken */, + 41 /* SyntaxKind.AsteriskToken */, + ], [isEndOfDecoratorContextOnSameLine], 4 /* RuleAction.InsertSpace */), + rule("NoSpaceBeforeNonNullAssertionOperator", anyToken, 53 /* SyntaxKind.ExclamationToken */, [isNonJsxSameLineTokenContext, isNonNullAssertionContext], 16 /* RuleAction.DeleteSpace */), + rule("NoSpaceAfterNewKeywordOnConstructorSignature", 103 /* SyntaxKind.NewKeyword */, 20 /* SyntaxKind.OpenParenToken */, [isNonJsxSameLineTokenContext, isConstructorSignatureContext], 16 /* RuleAction.DeleteSpace */), + rule("SpaceLessThanAndNonJSXTypeAnnotation", 29 /* SyntaxKind.LessThanToken */, 29 /* SyntaxKind.LessThanToken */, [isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */), + ]; + // These rules are applied after high priority + var userConfigurableRules = [ + // Treat constructor as an identifier in a function declaration, and remove spaces between constructor and following left parentheses + rule("SpaceAfterConstructor", 135 /* SyntaxKind.ConstructorKeyword */, 20 /* SyntaxKind.OpenParenToken */, [isOptionEnabled("insertSpaceAfterConstructor"), isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */), + rule("NoSpaceAfterConstructor", 135 /* SyntaxKind.ConstructorKeyword */, 20 /* SyntaxKind.OpenParenToken */, [isOptionDisabledOrUndefined("insertSpaceAfterConstructor"), isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + rule("SpaceAfterComma", 27 /* SyntaxKind.CommaToken */, anyToken, [isOptionEnabled("insertSpaceAfterCommaDelimiter"), isNonJsxSameLineTokenContext, isNonJsxElementOrFragmentContext, isNextTokenNotCloseBracket, isNextTokenNotCloseParen], 4 /* RuleAction.InsertSpace */), + rule("NoSpaceAfterComma", 27 /* SyntaxKind.CommaToken */, anyToken, [isOptionDisabledOrUndefined("insertSpaceAfterCommaDelimiter"), isNonJsxSameLineTokenContext, isNonJsxElementOrFragmentContext], 16 /* RuleAction.DeleteSpace */), + // Insert space after function keyword for anonymous functions + rule("SpaceAfterAnonymousFunctionKeyword", [98 /* SyntaxKind.FunctionKeyword */, 41 /* SyntaxKind.AsteriskToken */], 20 /* SyntaxKind.OpenParenToken */, [isOptionEnabled("insertSpaceAfterFunctionKeywordForAnonymousFunctions"), isFunctionDeclContext], 4 /* RuleAction.InsertSpace */), + rule("NoSpaceAfterAnonymousFunctionKeyword", [98 /* SyntaxKind.FunctionKeyword */, 41 /* SyntaxKind.AsteriskToken */], 20 /* SyntaxKind.OpenParenToken */, [isOptionDisabledOrUndefined("insertSpaceAfterFunctionKeywordForAnonymousFunctions"), isFunctionDeclContext], 16 /* RuleAction.DeleteSpace */), + // Insert space after keywords in control flow statements + rule("SpaceAfterKeywordInControl", keywords, 20 /* SyntaxKind.OpenParenToken */, [isOptionEnabled("insertSpaceAfterKeywordsInControlFlowStatements"), isControlDeclContext], 4 /* RuleAction.InsertSpace */), + rule("NoSpaceAfterKeywordInControl", keywords, 20 /* SyntaxKind.OpenParenToken */, [isOptionDisabledOrUndefined("insertSpaceAfterKeywordsInControlFlowStatements"), isControlDeclContext], 16 /* RuleAction.DeleteSpace */), + // Insert space after opening and before closing nonempty parenthesis + rule("SpaceAfterOpenParen", 20 /* SyntaxKind.OpenParenToken */, anyToken, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis"), isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */), + rule("SpaceBeforeCloseParen", anyToken, 21 /* SyntaxKind.CloseParenToken */, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis"), isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */), + rule("SpaceBetweenOpenParens", 20 /* SyntaxKind.OpenParenToken */, 20 /* SyntaxKind.OpenParenToken */, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis"), isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */), + rule("NoSpaceBetweenParens", 20 /* SyntaxKind.OpenParenToken */, 21 /* SyntaxKind.CloseParenToken */, [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + rule("NoSpaceAfterOpenParen", 20 /* SyntaxKind.OpenParenToken */, anyToken, [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis"), isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + rule("NoSpaceBeforeCloseParen", anyToken, 21 /* SyntaxKind.CloseParenToken */, [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis"), isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + // Insert space after opening and before closing nonempty brackets + rule("SpaceAfterOpenBracket", 22 /* SyntaxKind.OpenBracketToken */, anyToken, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets"), isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */), + rule("SpaceBeforeCloseBracket", anyToken, 23 /* SyntaxKind.CloseBracketToken */, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets"), isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */), + rule("NoSpaceBetweenBrackets", 22 /* SyntaxKind.OpenBracketToken */, 23 /* SyntaxKind.CloseBracketToken */, [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + rule("NoSpaceAfterOpenBracket", 22 /* SyntaxKind.OpenBracketToken */, anyToken, [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets"), isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + rule("NoSpaceBeforeCloseBracket", anyToken, 23 /* SyntaxKind.CloseBracketToken */, [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets"), isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + // Insert a space after { and before } in single-line contexts, but remove space from empty object literals {}. + rule("SpaceAfterOpenBrace", 18 /* SyntaxKind.OpenBraceToken */, anyToken, [isOptionEnabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces"), isBraceWrappedContext], 4 /* RuleAction.InsertSpace */), + rule("SpaceBeforeCloseBrace", anyToken, 19 /* SyntaxKind.CloseBraceToken */, [isOptionEnabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces"), isBraceWrappedContext], 4 /* RuleAction.InsertSpace */), + rule("NoSpaceBetweenEmptyBraceBrackets", 18 /* SyntaxKind.OpenBraceToken */, 19 /* SyntaxKind.CloseBraceToken */, [isNonJsxSameLineTokenContext, isObjectContext], 16 /* RuleAction.DeleteSpace */), + rule("NoSpaceAfterOpenBrace", 18 /* SyntaxKind.OpenBraceToken */, anyToken, [isOptionDisabled("insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces"), isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + rule("NoSpaceBeforeCloseBrace", anyToken, 19 /* SyntaxKind.CloseBraceToken */, [isOptionDisabled("insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces"), isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + // Insert a space after opening and before closing empty brace brackets + rule("SpaceBetweenEmptyBraceBrackets", 18 /* SyntaxKind.OpenBraceToken */, 19 /* SyntaxKind.CloseBraceToken */, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingEmptyBraces")], 4 /* RuleAction.InsertSpace */), + rule("NoSpaceBetweenEmptyBraceBrackets", 18 /* SyntaxKind.OpenBraceToken */, 19 /* SyntaxKind.CloseBraceToken */, [isOptionDisabled("insertSpaceAfterOpeningAndBeforeClosingEmptyBraces"), isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + // Insert space after opening and before closing template string braces + rule("SpaceAfterTemplateHeadAndMiddle", [15 /* SyntaxKind.TemplateHead */, 16 /* SyntaxKind.TemplateMiddle */], anyToken, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces"), isNonJsxTextContext], 4 /* RuleAction.InsertSpace */, 1 /* RuleFlags.CanDeleteNewLines */), + rule("SpaceBeforeTemplateMiddleAndTail", anyToken, [16 /* SyntaxKind.TemplateMiddle */, 17 /* SyntaxKind.TemplateTail */], [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces"), isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */), + rule("NoSpaceAfterTemplateHeadAndMiddle", [15 /* SyntaxKind.TemplateHead */, 16 /* SyntaxKind.TemplateMiddle */], anyToken, [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces"), isNonJsxTextContext], 16 /* RuleAction.DeleteSpace */, 1 /* RuleFlags.CanDeleteNewLines */), + rule("NoSpaceBeforeTemplateMiddleAndTail", anyToken, [16 /* SyntaxKind.TemplateMiddle */, 17 /* SyntaxKind.TemplateTail */], [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces"), isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + // No space after { and before } in JSX expression + rule("SpaceAfterOpenBraceInJsxExpression", 18 /* SyntaxKind.OpenBraceToken */, anyToken, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces"), isNonJsxSameLineTokenContext, isJsxExpressionContext], 4 /* RuleAction.InsertSpace */), + rule("SpaceBeforeCloseBraceInJsxExpression", anyToken, 19 /* SyntaxKind.CloseBraceToken */, [isOptionEnabled("insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces"), isNonJsxSameLineTokenContext, isJsxExpressionContext], 4 /* RuleAction.InsertSpace */), + rule("NoSpaceAfterOpenBraceInJsxExpression", 18 /* SyntaxKind.OpenBraceToken */, anyToken, [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces"), isNonJsxSameLineTokenContext, isJsxExpressionContext], 16 /* RuleAction.DeleteSpace */), + rule("NoSpaceBeforeCloseBraceInJsxExpression", anyToken, 19 /* SyntaxKind.CloseBraceToken */, [isOptionDisabledOrUndefined("insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces"), isNonJsxSameLineTokenContext, isJsxExpressionContext], 16 /* RuleAction.DeleteSpace */), + // Insert space after semicolon in for statement + rule("SpaceAfterSemicolonInFor", 26 /* SyntaxKind.SemicolonToken */, anyToken, [isOptionEnabled("insertSpaceAfterSemicolonInForStatements"), isNonJsxSameLineTokenContext, isForContext], 4 /* RuleAction.InsertSpace */), + rule("NoSpaceAfterSemicolonInFor", 26 /* SyntaxKind.SemicolonToken */, anyToken, [isOptionDisabledOrUndefined("insertSpaceAfterSemicolonInForStatements"), isNonJsxSameLineTokenContext, isForContext], 16 /* RuleAction.DeleteSpace */), + // Insert space before and after binary operators + rule("SpaceBeforeBinaryOperator", anyToken, binaryOperators, [isOptionEnabled("insertSpaceBeforeAndAfterBinaryOperators"), isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* RuleAction.InsertSpace */), + rule("SpaceAfterBinaryOperator", binaryOperators, anyToken, [isOptionEnabled("insertSpaceBeforeAndAfterBinaryOperators"), isNonJsxSameLineTokenContext, isBinaryOpContext], 4 /* RuleAction.InsertSpace */), + rule("NoSpaceBeforeBinaryOperator", anyToken, binaryOperators, [isOptionDisabledOrUndefined("insertSpaceBeforeAndAfterBinaryOperators"), isNonJsxSameLineTokenContext, isBinaryOpContext], 16 /* RuleAction.DeleteSpace */), + rule("NoSpaceAfterBinaryOperator", binaryOperators, anyToken, [isOptionDisabledOrUndefined("insertSpaceBeforeAndAfterBinaryOperators"), isNonJsxSameLineTokenContext, isBinaryOpContext], 16 /* RuleAction.DeleteSpace */), + rule("SpaceBeforeOpenParenInFuncDecl", anyToken, 20 /* SyntaxKind.OpenParenToken */, [isOptionEnabled("insertSpaceBeforeFunctionParenthesis"), isNonJsxSameLineTokenContext, isFunctionDeclContext], 4 /* RuleAction.InsertSpace */), + rule("NoSpaceBeforeOpenParenInFuncDecl", anyToken, 20 /* SyntaxKind.OpenParenToken */, [isOptionDisabledOrUndefined("insertSpaceBeforeFunctionParenthesis"), isNonJsxSameLineTokenContext, isFunctionDeclContext], 16 /* RuleAction.DeleteSpace */), + // Open Brace braces after control block + rule("NewLineBeforeOpenBraceInControl", controlOpenBraceLeftTokenRange, 18 /* SyntaxKind.OpenBraceToken */, [isOptionEnabled("placeOpenBraceOnNewLineForControlBlocks"), isControlDeclContext, isBeforeMultilineBlockContext], 8 /* RuleAction.InsertNewLine */, 1 /* RuleFlags.CanDeleteNewLines */), + // Open Brace braces after function + // TypeScript: Function can have return types, which can be made of tons of different token kinds + rule("NewLineBeforeOpenBraceInFunction", functionOpenBraceLeftTokenRange, 18 /* SyntaxKind.OpenBraceToken */, [isOptionEnabled("placeOpenBraceOnNewLineForFunctions"), isFunctionDeclContext, isBeforeMultilineBlockContext], 8 /* RuleAction.InsertNewLine */, 1 /* RuleFlags.CanDeleteNewLines */), + // Open Brace braces after TypeScript module/class/interface + rule("NewLineBeforeOpenBraceInTypeScriptDeclWithBlock", typeScriptOpenBraceLeftTokenRange, 18 /* SyntaxKind.OpenBraceToken */, [isOptionEnabled("placeOpenBraceOnNewLineForFunctions"), isTypeScriptDeclWithBlockContext, isBeforeMultilineBlockContext], 8 /* RuleAction.InsertNewLine */, 1 /* RuleFlags.CanDeleteNewLines */), + rule("SpaceAfterTypeAssertion", 31 /* SyntaxKind.GreaterThanToken */, anyToken, [isOptionEnabled("insertSpaceAfterTypeAssertion"), isNonJsxSameLineTokenContext, isTypeAssertionContext], 4 /* RuleAction.InsertSpace */), + rule("NoSpaceAfterTypeAssertion", 31 /* SyntaxKind.GreaterThanToken */, anyToken, [isOptionDisabledOrUndefined("insertSpaceAfterTypeAssertion"), isNonJsxSameLineTokenContext, isTypeAssertionContext], 16 /* RuleAction.DeleteSpace */), + rule("SpaceBeforeTypeAnnotation", anyToken, [57 /* SyntaxKind.QuestionToken */, 58 /* SyntaxKind.ColonToken */], [isOptionEnabled("insertSpaceBeforeTypeAnnotation"), isNonJsxSameLineTokenContext, isTypeAnnotationContext], 4 /* RuleAction.InsertSpace */), + rule("NoSpaceBeforeTypeAnnotation", anyToken, [57 /* SyntaxKind.QuestionToken */, 58 /* SyntaxKind.ColonToken */], [isOptionDisabledOrUndefined("insertSpaceBeforeTypeAnnotation"), isNonJsxSameLineTokenContext, isTypeAnnotationContext], 16 /* RuleAction.DeleteSpace */), + rule("NoOptionalSemicolon", 26 /* SyntaxKind.SemicolonToken */, anyTokenIncludingEOF, [optionEquals("semicolons", ts.SemicolonPreference.Remove), isSemicolonDeletionContext], 32 /* RuleAction.DeleteToken */), + rule("OptionalSemicolon", anyToken, anyTokenIncludingEOF, [optionEquals("semicolons", ts.SemicolonPreference.Insert), isSemicolonInsertionContext], 64 /* RuleAction.InsertTrailingSemicolon */), + ]; + // These rules are lower in priority than user-configurable. Rules earlier in this list have priority over rules later in the list. + var lowPriorityCommonRules = [ + // Space after keyword but not before ; or : or ? + rule("NoSpaceBeforeSemicolon", anyToken, 26 /* SyntaxKind.SemicolonToken */, [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + rule("SpaceBeforeOpenBraceInControl", controlOpenBraceLeftTokenRange, 18 /* SyntaxKind.OpenBraceToken */, [isOptionDisabledOrUndefinedOrTokensOnSameLine("placeOpenBraceOnNewLineForControlBlocks"), isControlDeclContext, isNotFormatOnEnter, isSameLineTokenOrBeforeBlockContext], 4 /* RuleAction.InsertSpace */, 1 /* RuleFlags.CanDeleteNewLines */), + rule("SpaceBeforeOpenBraceInFunction", functionOpenBraceLeftTokenRange, 18 /* SyntaxKind.OpenBraceToken */, [isOptionDisabledOrUndefinedOrTokensOnSameLine("placeOpenBraceOnNewLineForFunctions"), isFunctionDeclContext, isBeforeBlockContext, isNotFormatOnEnter, isSameLineTokenOrBeforeBlockContext], 4 /* RuleAction.InsertSpace */, 1 /* RuleFlags.CanDeleteNewLines */), + rule("SpaceBeforeOpenBraceInTypeScriptDeclWithBlock", typeScriptOpenBraceLeftTokenRange, 18 /* SyntaxKind.OpenBraceToken */, [isOptionDisabledOrUndefinedOrTokensOnSameLine("placeOpenBraceOnNewLineForFunctions"), isTypeScriptDeclWithBlockContext, isNotFormatOnEnter, isSameLineTokenOrBeforeBlockContext], 4 /* RuleAction.InsertSpace */, 1 /* RuleFlags.CanDeleteNewLines */), + rule("NoSpaceBeforeComma", anyToken, 27 /* SyntaxKind.CommaToken */, [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + // No space before and after indexer `x[]` + rule("NoSpaceBeforeOpenBracket", anyTokenExcept(132 /* SyntaxKind.AsyncKeyword */, 82 /* SyntaxKind.CaseKeyword */), 22 /* SyntaxKind.OpenBracketToken */, [isNonJsxSameLineTokenContext], 16 /* RuleAction.DeleteSpace */), + rule("NoSpaceAfterCloseBracket", 23 /* SyntaxKind.CloseBracketToken */, anyToken, [isNonJsxSameLineTokenContext, isNotBeforeBlockInFunctionDeclarationContext], 16 /* RuleAction.DeleteSpace */), + rule("SpaceAfterSemicolon", 26 /* SyntaxKind.SemicolonToken */, anyToken, [isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */), + // Remove extra space between for and await + rule("SpaceBetweenForAndAwaitKeyword", 97 /* SyntaxKind.ForKeyword */, 133 /* SyntaxKind.AwaitKeyword */, [isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */), + // Add a space between statements. All keywords except (do,else,case) has open/close parens after them. + // So, we have a rule to add a space for [),Any], [do,Any], [else,Any], and [case,Any] + rule("SpaceBetweenStatements", [21 /* SyntaxKind.CloseParenToken */, 90 /* SyntaxKind.DoKeyword */, 91 /* SyntaxKind.ElseKeyword */, 82 /* SyntaxKind.CaseKeyword */], anyToken, [isNonJsxSameLineTokenContext, isNonJsxElementOrFragmentContext, isNotForContext], 4 /* RuleAction.InsertSpace */), + // This low-pri rule takes care of "try {", "catch {" and "finally {" in case the rule SpaceBeforeOpenBraceInControl didn't execute on FormatOnEnter. + rule("SpaceAfterTryCatchFinally", [111 /* SyntaxKind.TryKeyword */, 83 /* SyntaxKind.CatchKeyword */, 96 /* SyntaxKind.FinallyKeyword */], 18 /* SyntaxKind.OpenBraceToken */, [isNonJsxSameLineTokenContext], 4 /* RuleAction.InsertSpace */), + ]; + return __spreadArray(__spreadArray(__spreadArray([], highPriorityCommonRules, true), userConfigurableRules, true), lowPriorityCommonRules, true); + } + formatting.getAllRules = getAllRules; + /** + * A rule takes a two tokens (left/right) and a particular context + * for which you're meant to look at them. You then declare what should the + * whitespace annotation be between these tokens via the action param. + * + * @param debugName Name to print + * @param left The left side of the comparison + * @param right The right side of the comparison + * @param context A set of filters to narrow down the space in which this formatter rule applies + * @param action a declaration of the expected whitespace + * @param flags whether the rule deletes a line or not, defaults to no-op + */ + function rule(debugName, left, right, context, action, flags) { + if (flags === void 0) { flags = 0 /* RuleFlags.None */; } + return { leftTokenRange: toTokenRange(left), rightTokenRange: toTokenRange(right), rule: { debugName: debugName, context: context, action: action, flags: flags } }; + } + function tokenRangeFrom(tokens) { + return { tokens: tokens, isSpecific: true }; + } + function toTokenRange(arg) { + return typeof arg === "number" ? tokenRangeFrom([arg]) : ts.isArray(arg) ? tokenRangeFrom(arg) : arg; + } + function tokenRangeFromRange(from, to, except) { + if (except === void 0) { except = []; } + var tokens = []; + for (var token = from; token <= to; token++) { + if (!ts.contains(except, token)) { + tokens.push(token); + } + } + return tokenRangeFrom(tokens); + } + /// + /// Contexts + /// + function optionEquals(optionName, optionValue) { + return function (context) { return context.options && context.options[optionName] === optionValue; }; + } + function isOptionEnabled(optionName) { + return function (context) { return context.options && ts.hasProperty(context.options, optionName) && !!context.options[optionName]; }; + } + function isOptionDisabled(optionName) { + return function (context) { return context.options && ts.hasProperty(context.options, optionName) && !context.options[optionName]; }; + } + function isOptionDisabledOrUndefined(optionName) { + return function (context) { return !context.options || !ts.hasProperty(context.options, optionName) || !context.options[optionName]; }; + } + function isOptionDisabledOrUndefinedOrTokensOnSameLine(optionName) { + return function (context) { return !context.options || !ts.hasProperty(context.options, optionName) || !context.options[optionName] || context.TokensAreOnSameLine(); }; + } + function isOptionEnabledOrUndefined(optionName) { + return function (context) { return !context.options || !ts.hasProperty(context.options, optionName) || !!context.options[optionName]; }; + } + function isForContext(context) { + return context.contextNode.kind === 245 /* SyntaxKind.ForStatement */; + } + function isNotForContext(context) { + return !isForContext(context); + } + function isBinaryOpContext(context) { + switch (context.contextNode.kind) { + case 223 /* SyntaxKind.BinaryExpression */: + return context.contextNode.operatorToken.kind !== 27 /* SyntaxKind.CommaToken */; + case 224 /* SyntaxKind.ConditionalExpression */: + case 191 /* SyntaxKind.ConditionalType */: + case 231 /* SyntaxKind.AsExpression */: + case 278 /* SyntaxKind.ExportSpecifier */: + case 273 /* SyntaxKind.ImportSpecifier */: + case 179 /* SyntaxKind.TypePredicate */: + case 189 /* SyntaxKind.UnionType */: + case 190 /* SyntaxKind.IntersectionType */: + case 235 /* SyntaxKind.SatisfiesExpression */: + return true; + // equals in binding elements: function foo([[x, y] = [1, 2]]) + case 205 /* SyntaxKind.BindingElement */: + // equals in type X = ... + // falls through + case 262 /* SyntaxKind.TypeAliasDeclaration */: + // equal in import a = module('a'); + // falls through + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + // equal in export = 1 + // falls through + case 274 /* SyntaxKind.ExportAssignment */: + // equal in let a = 0 + // falls through + case 257 /* SyntaxKind.VariableDeclaration */: + // equal in p = 0 + // falls through + case 166 /* SyntaxKind.Parameter */: + case 302 /* SyntaxKind.EnumMember */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 168 /* SyntaxKind.PropertySignature */: + return context.currentTokenSpan.kind === 63 /* SyntaxKind.EqualsToken */ || context.nextTokenSpan.kind === 63 /* SyntaxKind.EqualsToken */; + // "in" keyword in for (let x in []) { } + case 246 /* SyntaxKind.ForInStatement */: + // "in" keyword in [P in keyof T]: T[P] + // falls through + case 165 /* SyntaxKind.TypeParameter */: + return context.currentTokenSpan.kind === 101 /* SyntaxKind.InKeyword */ || context.nextTokenSpan.kind === 101 /* SyntaxKind.InKeyword */ || context.currentTokenSpan.kind === 63 /* SyntaxKind.EqualsToken */ || context.nextTokenSpan.kind === 63 /* SyntaxKind.EqualsToken */; + // Technically, "of" is not a binary operator, but format it the same way as "in" + case 247 /* SyntaxKind.ForOfStatement */: + return context.currentTokenSpan.kind === 162 /* SyntaxKind.OfKeyword */ || context.nextTokenSpan.kind === 162 /* SyntaxKind.OfKeyword */; + } + return false; + } + function isNotBinaryOpContext(context) { + return !isBinaryOpContext(context); + } + function isNotTypeAnnotationContext(context) { + return !isTypeAnnotationContext(context); + } + function isTypeAnnotationContext(context) { + var contextKind = context.contextNode.kind; + return contextKind === 169 /* SyntaxKind.PropertyDeclaration */ || + contextKind === 168 /* SyntaxKind.PropertySignature */ || + contextKind === 166 /* SyntaxKind.Parameter */ || + contextKind === 257 /* SyntaxKind.VariableDeclaration */ || + ts.isFunctionLikeKind(contextKind); + } + function isConditionalOperatorContext(context) { + return context.contextNode.kind === 224 /* SyntaxKind.ConditionalExpression */ || + context.contextNode.kind === 191 /* SyntaxKind.ConditionalType */; + } + function isSameLineTokenOrBeforeBlockContext(context) { + return context.TokensAreOnSameLine() || isBeforeBlockContext(context); + } + function isBraceWrappedContext(context) { + return context.contextNode.kind === 203 /* SyntaxKind.ObjectBindingPattern */ || + context.contextNode.kind === 197 /* SyntaxKind.MappedType */ || + isSingleLineBlockContext(context); + } + // This check is done before an open brace in a control construct, a function, or a typescript block declaration + function isBeforeMultilineBlockContext(context) { + return isBeforeBlockContext(context) && !(context.NextNodeAllOnSameLine() || context.NextNodeBlockIsOnOneLine()); + } + function isMultilineBlockContext(context) { + return isBlockContext(context) && !(context.ContextNodeAllOnSameLine() || context.ContextNodeBlockIsOnOneLine()); + } + function isSingleLineBlockContext(context) { + return isBlockContext(context) && (context.ContextNodeAllOnSameLine() || context.ContextNodeBlockIsOnOneLine()); + } + function isBlockContext(context) { + return nodeIsBlockContext(context.contextNode); + } + function isBeforeBlockContext(context) { + return nodeIsBlockContext(context.nextTokenParent); + } + // IMPORTANT!!! This method must return true ONLY for nodes with open and close braces as immediate children + function nodeIsBlockContext(node) { + if (nodeIsTypeScriptDeclWithBlockContext(node)) { + // This means we are in a context that looks like a block to the user, but in the grammar is actually not a node (it's a class, module, enum, object type literal, etc). + return true; + } + switch (node.kind) { + case 238 /* SyntaxKind.Block */: + case 266 /* SyntaxKind.CaseBlock */: + case 207 /* SyntaxKind.ObjectLiteralExpression */: + case 265 /* SyntaxKind.ModuleBlock */: + return true; + } + return false; + } + function isFunctionDeclContext(context) { + switch (context.contextNode.kind) { + case 259 /* SyntaxKind.FunctionDeclaration */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + // case SyntaxKind.MemberFunctionDeclaration: + // falls through + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + // case SyntaxKind.MethodSignature: + // falls through + case 176 /* SyntaxKind.CallSignature */: + case 215 /* SyntaxKind.FunctionExpression */: + case 173 /* SyntaxKind.Constructor */: + case 216 /* SyntaxKind.ArrowFunction */: + // case SyntaxKind.ConstructorDeclaration: + // case SyntaxKind.SimpleArrowFunctionExpression: + // case SyntaxKind.ParenthesizedArrowFunctionExpression: + // falls through + case 261 /* SyntaxKind.InterfaceDeclaration */: // This one is not truly a function, but for formatting purposes, it acts just like one + return true; + } + return false; + } + function isNotFunctionDeclContext(context) { + return !isFunctionDeclContext(context); + } + function isFunctionDeclarationOrFunctionExpressionContext(context) { + return context.contextNode.kind === 259 /* SyntaxKind.FunctionDeclaration */ || context.contextNode.kind === 215 /* SyntaxKind.FunctionExpression */; + } + function isTypeScriptDeclWithBlockContext(context) { + return nodeIsTypeScriptDeclWithBlockContext(context.contextNode); + } + function nodeIsTypeScriptDeclWithBlockContext(node) { + switch (node.kind) { + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 184 /* SyntaxKind.TypeLiteral */: + case 264 /* SyntaxKind.ModuleDeclaration */: + case 275 /* SyntaxKind.ExportDeclaration */: + case 276 /* SyntaxKind.NamedExports */: + case 269 /* SyntaxKind.ImportDeclaration */: + case 272 /* SyntaxKind.NamedImports */: + return true; + } + return false; + } + function isAfterCodeBlockContext(context) { + switch (context.currentTokenParent.kind) { + case 260 /* SyntaxKind.ClassDeclaration */: + case 264 /* SyntaxKind.ModuleDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 295 /* SyntaxKind.CatchClause */: + case 265 /* SyntaxKind.ModuleBlock */: + case 252 /* SyntaxKind.SwitchStatement */: + return true; + case 238 /* SyntaxKind.Block */: { + var blockParent = context.currentTokenParent.parent; + // In a codefix scenario, we can't rely on parents being set. So just always return true. + if (!blockParent || blockParent.kind !== 216 /* SyntaxKind.ArrowFunction */ && blockParent.kind !== 215 /* SyntaxKind.FunctionExpression */) { + return true; + } + } + } + return false; + } + function isControlDeclContext(context) { + switch (context.contextNode.kind) { + case 242 /* SyntaxKind.IfStatement */: + case 252 /* SyntaxKind.SwitchStatement */: + case 245 /* SyntaxKind.ForStatement */: + case 246 /* SyntaxKind.ForInStatement */: + case 247 /* SyntaxKind.ForOfStatement */: + case 244 /* SyntaxKind.WhileStatement */: + case 255 /* SyntaxKind.TryStatement */: + case 243 /* SyntaxKind.DoStatement */: + case 251 /* SyntaxKind.WithStatement */: + // TODO + // case SyntaxKind.ElseClause: + // falls through + case 295 /* SyntaxKind.CatchClause */: + return true; + default: + return false; + } + } + function isObjectContext(context) { + return context.contextNode.kind === 207 /* SyntaxKind.ObjectLiteralExpression */; + } + function isFunctionCallContext(context) { + return context.contextNode.kind === 210 /* SyntaxKind.CallExpression */; + } + function isNewContext(context) { + return context.contextNode.kind === 211 /* SyntaxKind.NewExpression */; + } + function isFunctionCallOrNewContext(context) { + return isFunctionCallContext(context) || isNewContext(context); + } + function isPreviousTokenNotComma(context) { + return context.currentTokenSpan.kind !== 27 /* SyntaxKind.CommaToken */; + } + function isNextTokenNotCloseBracket(context) { + return context.nextTokenSpan.kind !== 23 /* SyntaxKind.CloseBracketToken */; + } + function isNextTokenNotCloseParen(context) { + return context.nextTokenSpan.kind !== 21 /* SyntaxKind.CloseParenToken */; + } + function isArrowFunctionContext(context) { + return context.contextNode.kind === 216 /* SyntaxKind.ArrowFunction */; + } + function isImportTypeContext(context) { + return context.contextNode.kind === 202 /* SyntaxKind.ImportType */; + } + function isNonJsxSameLineTokenContext(context) { + return context.TokensAreOnSameLine() && context.contextNode.kind !== 11 /* SyntaxKind.JsxText */; + } + function isNonJsxTextContext(context) { + return context.contextNode.kind !== 11 /* SyntaxKind.JsxText */; + } + function isNonJsxElementOrFragmentContext(context) { + return context.contextNode.kind !== 281 /* SyntaxKind.JsxElement */ && context.contextNode.kind !== 285 /* SyntaxKind.JsxFragment */; + } + function isJsxExpressionContext(context) { + return context.contextNode.kind === 291 /* SyntaxKind.JsxExpression */ || context.contextNode.kind === 290 /* SyntaxKind.JsxSpreadAttribute */; + } + function isNextTokenParentJsxAttribute(context) { + return context.nextTokenParent.kind === 288 /* SyntaxKind.JsxAttribute */; + } + function isJsxAttributeContext(context) { + return context.contextNode.kind === 288 /* SyntaxKind.JsxAttribute */; + } + function isJsxSelfClosingElementContext(context) { + return context.contextNode.kind === 282 /* SyntaxKind.JsxSelfClosingElement */; + } + function isNotBeforeBlockInFunctionDeclarationContext(context) { + return !isFunctionDeclContext(context) && !isBeforeBlockContext(context); + } + function isEndOfDecoratorContextOnSameLine(context) { + return context.TokensAreOnSameLine() && + ts.hasDecorators(context.contextNode) && + nodeIsInDecoratorContext(context.currentTokenParent) && + !nodeIsInDecoratorContext(context.nextTokenParent); + } + function nodeIsInDecoratorContext(node) { + while (node && ts.isExpression(node)) { + node = node.parent; + } + return node && node.kind === 167 /* SyntaxKind.Decorator */; + } + function isStartOfVariableDeclarationList(context) { + return context.currentTokenParent.kind === 258 /* SyntaxKind.VariableDeclarationList */ && + context.currentTokenParent.getStart(context.sourceFile) === context.currentTokenSpan.pos; + } + function isNotFormatOnEnter(context) { + return context.formattingRequestKind !== 2 /* FormattingRequestKind.FormatOnEnter */; + } + function isModuleDeclContext(context) { + return context.contextNode.kind === 264 /* SyntaxKind.ModuleDeclaration */; + } + function isObjectTypeContext(context) { + return context.contextNode.kind === 184 /* SyntaxKind.TypeLiteral */; // && context.contextNode.parent.kind !== SyntaxKind.InterfaceDeclaration; + } + function isConstructorSignatureContext(context) { + return context.contextNode.kind === 177 /* SyntaxKind.ConstructSignature */; + } + function isTypeArgumentOrParameterOrAssertion(token, parent) { + if (token.kind !== 29 /* SyntaxKind.LessThanToken */ && token.kind !== 31 /* SyntaxKind.GreaterThanToken */) { + return false; + } + switch (parent.kind) { + case 180 /* SyntaxKind.TypeReference */: + case 213 /* SyntaxKind.TypeAssertionExpression */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + case 176 /* SyntaxKind.CallSignature */: + case 177 /* SyntaxKind.ConstructSignature */: + case 210 /* SyntaxKind.CallExpression */: + case 211 /* SyntaxKind.NewExpression */: + case 230 /* SyntaxKind.ExpressionWithTypeArguments */: + return true; + default: + return false; + } + } + function isTypeArgumentOrParameterOrAssertionContext(context) { + return isTypeArgumentOrParameterOrAssertion(context.currentTokenSpan, context.currentTokenParent) || + isTypeArgumentOrParameterOrAssertion(context.nextTokenSpan, context.nextTokenParent); + } + function isTypeAssertionContext(context) { + return context.contextNode.kind === 213 /* SyntaxKind.TypeAssertionExpression */; + } + function isVoidOpContext(context) { + return context.currentTokenSpan.kind === 114 /* SyntaxKind.VoidKeyword */ && context.currentTokenParent.kind === 219 /* SyntaxKind.VoidExpression */; + } + function isYieldOrYieldStarWithOperand(context) { + return context.contextNode.kind === 226 /* SyntaxKind.YieldExpression */ && context.contextNode.expression !== undefined; + } + function isNonNullAssertionContext(context) { + return context.contextNode.kind === 232 /* SyntaxKind.NonNullExpression */; + } + function isNotStatementConditionContext(context) { + return !isStatementConditionContext(context); + } + function isStatementConditionContext(context) { + switch (context.contextNode.kind) { + case 242 /* SyntaxKind.IfStatement */: + case 245 /* SyntaxKind.ForStatement */: + case 246 /* SyntaxKind.ForInStatement */: + case 247 /* SyntaxKind.ForOfStatement */: + case 243 /* SyntaxKind.DoStatement */: + case 244 /* SyntaxKind.WhileStatement */: + return true; + default: + return false; + } + } + function isSemicolonDeletionContext(context) { + var nextTokenKind = context.nextTokenSpan.kind; + var nextTokenStart = context.nextTokenSpan.pos; + if (ts.isTrivia(nextTokenKind)) { + var nextRealToken = context.nextTokenParent === context.currentTokenParent + ? ts.findNextToken(context.currentTokenParent, ts.findAncestor(context.currentTokenParent, function (a) { return !a.parent; }), context.sourceFile) + : context.nextTokenParent.getFirstToken(context.sourceFile); + if (!nextRealToken) { + return true; + } + nextTokenKind = nextRealToken.kind; + nextTokenStart = nextRealToken.getStart(context.sourceFile); + } + var startLine = context.sourceFile.getLineAndCharacterOfPosition(context.currentTokenSpan.pos).line; + var endLine = context.sourceFile.getLineAndCharacterOfPosition(nextTokenStart).line; + if (startLine === endLine) { + return nextTokenKind === 19 /* SyntaxKind.CloseBraceToken */ + || nextTokenKind === 1 /* SyntaxKind.EndOfFileToken */; + } + if (nextTokenKind === 237 /* SyntaxKind.SemicolonClassElement */ || + nextTokenKind === 26 /* SyntaxKind.SemicolonToken */) { + return false; + } + if (context.contextNode.kind === 261 /* SyntaxKind.InterfaceDeclaration */ || + context.contextNode.kind === 262 /* SyntaxKind.TypeAliasDeclaration */) { + // Can’t remove semicolon after `foo`; it would parse as a method declaration: + // + // interface I { + // foo; + // (): void + // } + return !ts.isPropertySignature(context.currentTokenParent) + || !!context.currentTokenParent.type + || nextTokenKind !== 20 /* SyntaxKind.OpenParenToken */; + } + if (ts.isPropertyDeclaration(context.currentTokenParent)) { + return !context.currentTokenParent.initializer; + } + return context.currentTokenParent.kind !== 245 /* SyntaxKind.ForStatement */ + && context.currentTokenParent.kind !== 239 /* SyntaxKind.EmptyStatement */ + && context.currentTokenParent.kind !== 237 /* SyntaxKind.SemicolonClassElement */ + && nextTokenKind !== 22 /* SyntaxKind.OpenBracketToken */ + && nextTokenKind !== 20 /* SyntaxKind.OpenParenToken */ + && nextTokenKind !== 39 /* SyntaxKind.PlusToken */ + && nextTokenKind !== 40 /* SyntaxKind.MinusToken */ + && nextTokenKind !== 43 /* SyntaxKind.SlashToken */ + && nextTokenKind !== 13 /* SyntaxKind.RegularExpressionLiteral */ + && nextTokenKind !== 27 /* SyntaxKind.CommaToken */ + && nextTokenKind !== 225 /* SyntaxKind.TemplateExpression */ + && nextTokenKind !== 15 /* SyntaxKind.TemplateHead */ + && nextTokenKind !== 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */ + && nextTokenKind !== 24 /* SyntaxKind.DotToken */; + } + function isSemicolonInsertionContext(context) { + return ts.positionIsASICandidate(context.currentTokenSpan.end, context.currentTokenParent, context.sourceFile); + } + function isNotPropertyAccessOnIntegerLiteral(context) { + return !ts.isPropertyAccessExpression(context.contextNode) + || !ts.isNumericLiteral(context.contextNode.expression) + || context.contextNode.expression.getText().indexOf(".") !== -1; + } + })(formatting = ts.formatting || (ts.formatting = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var formatting; + (function (formatting) { + function getFormatContext(options, host) { + return { options: options, getRules: getRulesMap(), host: host }; + } + formatting.getFormatContext = getFormatContext; + var rulesMapCache; + function getRulesMap() { + if (rulesMapCache === undefined) { + rulesMapCache = createRulesMap(formatting.getAllRules()); + } + return rulesMapCache; + } + /** + * For a given rule action, gets a mask of other rule actions that + * cannot be applied at the same position. + */ + function getRuleActionExclusion(ruleAction) { + var mask = 0; + if (ruleAction & 1 /* RuleAction.StopProcessingSpaceActions */) { + mask |= 28 /* RuleAction.ModifySpaceAction */; + } + if (ruleAction & 2 /* RuleAction.StopProcessingTokenActions */) { + mask |= 96 /* RuleAction.ModifyTokenAction */; + } + if (ruleAction & 28 /* RuleAction.ModifySpaceAction */) { + mask |= 28 /* RuleAction.ModifySpaceAction */; + } + if (ruleAction & 96 /* RuleAction.ModifyTokenAction */) { + mask |= 96 /* RuleAction.ModifyTokenAction */; + } + return mask; + } + function createRulesMap(rules) { + var map = buildMap(rules); + return function (context) { + var bucket = map[getRuleBucketIndex(context.currentTokenSpan.kind, context.nextTokenSpan.kind)]; + if (bucket) { + var rules_1 = []; + var ruleActionMask = 0; + for (var _i = 0, bucket_1 = bucket; _i < bucket_1.length; _i++) { + var rule = bucket_1[_i]; + var acceptRuleActions = ~getRuleActionExclusion(ruleActionMask); + if (rule.action & acceptRuleActions && ts.every(rule.context, function (c) { return c(context); })) { + rules_1.push(rule); + ruleActionMask |= rule.action; + } + } + if (rules_1.length) { + return rules_1; + } + } + }; + } + function buildMap(rules) { + // Map from bucket index to array of rules + var map = new Array(mapRowLength * mapRowLength); + // This array is used only during construction of the rulesbucket in the map + var rulesBucketConstructionStateList = new Array(map.length); + for (var _i = 0, rules_2 = rules; _i < rules_2.length; _i++) { + var rule = rules_2[_i]; + var specificRule = rule.leftTokenRange.isSpecific && rule.rightTokenRange.isSpecific; + for (var _a = 0, _b = rule.leftTokenRange.tokens; _a < _b.length; _a++) { + var left = _b[_a]; + for (var _c = 0, _d = rule.rightTokenRange.tokens; _c < _d.length; _c++) { + var right = _d[_c]; + var index = getRuleBucketIndex(left, right); + var rulesBucket = map[index]; + if (rulesBucket === undefined) { + rulesBucket = map[index] = []; + } + addRule(rulesBucket, rule.rule, specificRule, rulesBucketConstructionStateList, index); + } + } + } + return map; + } + function getRuleBucketIndex(row, column) { + ts.Debug.assert(row <= 162 /* SyntaxKind.LastKeyword */ && column <= 162 /* SyntaxKind.LastKeyword */, "Must compute formatting context from tokens"); + return (row * mapRowLength) + column; + } + var maskBitSize = 5; + var mask = 31; // MaskBitSize bits + var mapRowLength = 162 /* SyntaxKind.LastToken */ + 1; + var RulesPosition; + (function (RulesPosition) { + RulesPosition[RulesPosition["StopRulesSpecific"] = 0] = "StopRulesSpecific"; + RulesPosition[RulesPosition["StopRulesAny"] = maskBitSize * 1] = "StopRulesAny"; + RulesPosition[RulesPosition["ContextRulesSpecific"] = maskBitSize * 2] = "ContextRulesSpecific"; + RulesPosition[RulesPosition["ContextRulesAny"] = maskBitSize * 3] = "ContextRulesAny"; + RulesPosition[RulesPosition["NoContextRulesSpecific"] = maskBitSize * 4] = "NoContextRulesSpecific"; + RulesPosition[RulesPosition["NoContextRulesAny"] = maskBitSize * 5] = "NoContextRulesAny"; + })(RulesPosition || (RulesPosition = {})); + // The Rules list contains all the inserted rules into a rulebucket in the following order: + // 1- Ignore rules with specific token combination + // 2- Ignore rules with any token combination + // 3- Context rules with specific token combination + // 4- Context rules with any token combination + // 5- Non-context rules with specific token combination + // 6- Non-context rules with any token combination + // + // The member rulesInsertionIndexBitmap is used to describe the number of rules + // in each sub-bucket (above) hence can be used to know the index of where to insert + // the next rule. It's a bitmap which contains 6 different sections each is given 5 bits. + // + // Example: + // In order to insert a rule to the end of sub-bucket (3), we get the index by adding + // the values in the bitmap segments 3rd, 2nd, and 1st. + function addRule(rules, rule, specificTokens, constructionState, rulesBucketIndex) { + var position = rule.action & 3 /* RuleAction.StopAction */ ? + specificTokens ? RulesPosition.StopRulesSpecific : RulesPosition.StopRulesAny : + rule.context !== formatting.anyContext ? + specificTokens ? RulesPosition.ContextRulesSpecific : RulesPosition.ContextRulesAny : + specificTokens ? RulesPosition.NoContextRulesSpecific : RulesPosition.NoContextRulesAny; + var state = constructionState[rulesBucketIndex] || 0; + rules.splice(getInsertionIndex(state, position), 0, rule); + constructionState[rulesBucketIndex] = increaseInsertionIndex(state, position); + } + function getInsertionIndex(indexBitmap, maskPosition) { + var index = 0; + for (var pos = 0; pos <= maskPosition; pos += maskBitSize) { + index += indexBitmap & mask; + indexBitmap >>= maskBitSize; + } + return index; + } + function increaseInsertionIndex(indexBitmap, maskPosition) { + var value = ((indexBitmap >> maskPosition) & mask) + 1; + ts.Debug.assert((value & mask) === value, "Adding more rules into the sub-bucket than allowed. Maximum allowed is 32 rules."); + return (indexBitmap & ~(mask << maskPosition)) | (value << maskPosition); + } + })(formatting = ts.formatting || (ts.formatting = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var formatting; + (function (formatting) { + function createTextRangeWithKind(pos, end, kind) { + var textRangeWithKind = { pos: pos, end: end, kind: kind }; + if (ts.Debug.isDebugging) { + Object.defineProperty(textRangeWithKind, "__debugKind", { + get: function () { return ts.Debug.formatSyntaxKind(kind); }, + }); + } + return textRangeWithKind; + } + formatting.createTextRangeWithKind = createTextRangeWithKind; + var Constants; + (function (Constants) { + Constants[Constants["Unknown"] = -1] = "Unknown"; + })(Constants || (Constants = {})); + function formatOnEnter(position, sourceFile, formatContext) { + var line = sourceFile.getLineAndCharacterOfPosition(position).line; + if (line === 0) { + return []; + } + // After the enter key, the cursor is now at a new line. The new line may or may not contain non-whitespace characters. + // If the new line has only whitespaces, we won't want to format this line, because that would remove the indentation as + // trailing whitespaces. So the end of the formatting span should be the later one between: + // 1. the end of the previous line + // 2. the last non-whitespace character in the current line + var endOfFormatSpan = ts.getEndLinePosition(line, sourceFile); + while (ts.isWhiteSpaceSingleLine(sourceFile.text.charCodeAt(endOfFormatSpan))) { + endOfFormatSpan--; + } + // if the character at the end of the span is a line break, we shouldn't include it, because it indicates we don't want to + // touch the current line at all. Also, on some OSes the line break consists of two characters (\r\n), we should test if the + // previous character before the end of format span is line break character as well. + if (ts.isLineBreak(sourceFile.text.charCodeAt(endOfFormatSpan))) { + endOfFormatSpan--; + } + var span = { + // get start position for the previous line + pos: ts.getStartPositionOfLine(line - 1, sourceFile), + // end value is exclusive so add 1 to the result + end: endOfFormatSpan + 1 + }; + return formatSpan(span, sourceFile, formatContext, 2 /* FormattingRequestKind.FormatOnEnter */); + } + formatting.formatOnEnter = formatOnEnter; + function formatOnSemicolon(position, sourceFile, formatContext) { + var semicolon = findImmediatelyPrecedingTokenOfKind(position, 26 /* SyntaxKind.SemicolonToken */, sourceFile); + return formatNodeLines(findOutermostNodeWithinListLevel(semicolon), sourceFile, formatContext, 3 /* FormattingRequestKind.FormatOnSemicolon */); + } + formatting.formatOnSemicolon = formatOnSemicolon; + function formatOnOpeningCurly(position, sourceFile, formatContext) { + var openingCurly = findImmediatelyPrecedingTokenOfKind(position, 18 /* SyntaxKind.OpenBraceToken */, sourceFile); + if (!openingCurly) { + return []; + } + var curlyBraceRange = openingCurly.parent; + var outermostNode = findOutermostNodeWithinListLevel(curlyBraceRange); + /** + * We limit the span to end at the opening curly to handle the case where + * the brace matched to that just typed will be incorrect after further edits. + * For example, we could type the opening curly for the following method + * body without brace-matching activated: + * ``` + * class C { + * foo() + * } + * ``` + * and we wouldn't want to move the closing brace. + */ + var textRange = { + pos: ts.getLineStartPositionForPosition(outermostNode.getStart(sourceFile), sourceFile), + end: position + }; + return formatSpan(textRange, sourceFile, formatContext, 4 /* FormattingRequestKind.FormatOnOpeningCurlyBrace */); + } + formatting.formatOnOpeningCurly = formatOnOpeningCurly; + function formatOnClosingCurly(position, sourceFile, formatContext) { + var precedingToken = findImmediatelyPrecedingTokenOfKind(position, 19 /* SyntaxKind.CloseBraceToken */, sourceFile); + return formatNodeLines(findOutermostNodeWithinListLevel(precedingToken), sourceFile, formatContext, 5 /* FormattingRequestKind.FormatOnClosingCurlyBrace */); + } + formatting.formatOnClosingCurly = formatOnClosingCurly; + function formatDocument(sourceFile, formatContext) { + var span = { + pos: 0, + end: sourceFile.text.length + }; + return formatSpan(span, sourceFile, formatContext, 0 /* FormattingRequestKind.FormatDocument */); + } + formatting.formatDocument = formatDocument; + function formatSelection(start, end, sourceFile, formatContext) { + // format from the beginning of the line + var span = { + pos: ts.getLineStartPositionForPosition(start, sourceFile), + end: end, + }; + return formatSpan(span, sourceFile, formatContext, 1 /* FormattingRequestKind.FormatSelection */); + } + formatting.formatSelection = formatSelection; + /** + * Validating `expectedTokenKind` ensures the token was typed in the context we expect (eg: not a comment). + * @param expectedTokenKind The kind of the last token constituting the desired parent node. + */ + function findImmediatelyPrecedingTokenOfKind(end, expectedTokenKind, sourceFile) { + var precedingToken = ts.findPrecedingToken(end, sourceFile); + return precedingToken && precedingToken.kind === expectedTokenKind && end === precedingToken.getEnd() ? + precedingToken : + undefined; + } + /** + * Finds the highest node enclosing `node` at the same list level as `node` + * and whose end does not exceed `node.end`. + * + * Consider typing the following + * ``` + * let x = 1; + * while (true) { + * } + * ``` + * Upon typing the closing curly, we want to format the entire `while`-statement, but not the preceding + * variable declaration. + */ + function findOutermostNodeWithinListLevel(node) { + var current = node; + while (current && + current.parent && + current.parent.end === node.end && + !isListElement(current.parent, current)) { + current = current.parent; + } + return current; + } + // Returns true if node is a element in some list in parent + // i.e. parent is class declaration with the list of members and node is one of members. + function isListElement(parent, node) { + switch (parent.kind) { + case 260 /* SyntaxKind.ClassDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + return ts.rangeContainsRange(parent.members, node); + case 264 /* SyntaxKind.ModuleDeclaration */: + var body = parent.body; + return !!body && body.kind === 265 /* SyntaxKind.ModuleBlock */ && ts.rangeContainsRange(body.statements, node); + case 308 /* SyntaxKind.SourceFile */: + case 238 /* SyntaxKind.Block */: + case 265 /* SyntaxKind.ModuleBlock */: + return ts.rangeContainsRange(parent.statements, node); + case 295 /* SyntaxKind.CatchClause */: + return ts.rangeContainsRange(parent.block.statements, node); + } + return false; + } + /** find node that fully contains given text range */ + function findEnclosingNode(range, sourceFile) { + return find(sourceFile); + function find(n) { + var candidate = ts.forEachChild(n, function (c) { return ts.startEndContainsRange(c.getStart(sourceFile), c.end, range) && c; }); + if (candidate) { + var result = find(candidate); + if (result) { + return result; + } + } + return n; + } + } + /** formatting is not applied to ranges that contain parse errors. + * This function will return a predicate that for a given text range will tell + * if there are any parse errors that overlap with the range. + */ + function prepareRangeContainsErrorFunction(errors, originalRange) { + if (!errors.length) { + return rangeHasNoErrors; + } + // pick only errors that fall in range + var sorted = errors + .filter(function (d) { return ts.rangeOverlapsWithStartEnd(originalRange, d.start, d.start + d.length); }) // TODO: GH#18217 + .sort(function (e1, e2) { return e1.start - e2.start; }); + if (!sorted.length) { + return rangeHasNoErrors; + } + var index = 0; + return function (r) { + // in current implementation sequence of arguments [r1, r2...] is monotonically increasing. + // 'index' tracks the index of the most recent error that was checked. + while (true) { + if (index >= sorted.length) { + // all errors in the range were already checked -> no error in specified range + return false; + } + var error = sorted[index]; + if (r.end <= error.start) { + // specified range ends before the error referred by 'index' - no error in range + return false; + } + if (ts.startEndOverlapsWithStartEnd(r.pos, r.end, error.start, error.start + error.length)) { + // specified range overlaps with error range + return true; + } + index++; + } + }; + function rangeHasNoErrors() { + return false; + } + } + /** + * Start of the original range might fall inside the comment - scanner will not yield appropriate results + * This function will look for token that is located before the start of target range + * and return its end as start position for the scanner. + */ + function getScanStartPosition(enclosingNode, originalRange, sourceFile) { + var start = enclosingNode.getStart(sourceFile); + if (start === originalRange.pos && enclosingNode.end === originalRange.end) { + return start; + } + var precedingToken = ts.findPrecedingToken(originalRange.pos, sourceFile); + if (!precedingToken) { + // no preceding token found - start from the beginning of enclosing node + return enclosingNode.pos; + } + // preceding token ends after the start of original range (i.e when originalRange.pos falls in the middle of literal) + // start from the beginning of enclosingNode to handle the entire 'originalRange' + if (precedingToken.end >= originalRange.pos) { + return enclosingNode.pos; + } + return precedingToken.end; + } + /* + * For cases like + * if (a || + * b ||$ + * c) {...} + * If we hit Enter at $ we want line ' b ||' to be indented. + * Formatting will be applied to the last two lines. + * Node that fully encloses these lines is binary expression 'a ||...'. + * Initial indentation for this node will be 0. + * Binary expressions don't introduce new indentation scopes, however it is possible + * that some parent node on the same line does - like if statement in this case. + * Note that we are considering parents only from the same line with initial node - + * if parent is on the different line - its delta was already contributed + * to the initial indentation. + */ + function getOwnOrInheritedDelta(n, options, sourceFile) { + var previousLine = -1 /* Constants.Unknown */; + var child; + while (n) { + var line = sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile)).line; + if (previousLine !== -1 /* Constants.Unknown */ && line !== previousLine) { + break; + } + if (formatting.SmartIndenter.shouldIndentChildNode(options, n, child, sourceFile)) { + return options.indentSize; + } + previousLine = line; + child = n; + n = n.parent; + } + return 0; + } + function formatNodeGivenIndentation(node, sourceFileLike, languageVariant, initialIndentation, delta, formatContext) { + var range = { pos: node.pos, end: node.end }; + return formatting.getFormattingScanner(sourceFileLike.text, languageVariant, range.pos, range.end, function (scanner) { return formatSpanWorker(range, node, initialIndentation, delta, scanner, formatContext, 1 /* FormattingRequestKind.FormatSelection */, function (_) { return false; }, // assume that node does not have any errors + sourceFileLike); }); + } + formatting.formatNodeGivenIndentation = formatNodeGivenIndentation; + function formatNodeLines(node, sourceFile, formatContext, requestKind) { + if (!node) { + return []; + } + var span = { + pos: ts.getLineStartPositionForPosition(node.getStart(sourceFile), sourceFile), + end: node.end + }; + return formatSpan(span, sourceFile, formatContext, requestKind); + } + function formatSpan(originalRange, sourceFile, formatContext, requestKind) { + // find the smallest node that fully wraps the range and compute the initial indentation for the node + var enclosingNode = findEnclosingNode(originalRange, sourceFile); + return formatting.getFormattingScanner(sourceFile.text, sourceFile.languageVariant, getScanStartPosition(enclosingNode, originalRange, sourceFile), originalRange.end, function (scanner) { return formatSpanWorker(originalRange, enclosingNode, formatting.SmartIndenter.getIndentationForNode(enclosingNode, originalRange, sourceFile, formatContext.options), getOwnOrInheritedDelta(enclosingNode, formatContext.options, sourceFile), scanner, formatContext, requestKind, prepareRangeContainsErrorFunction(sourceFile.parseDiagnostics, originalRange), sourceFile); }); + } + function formatSpanWorker(originalRange, enclosingNode, initialIndentation, delta, formattingScanner, _a, requestKind, rangeContainsError, sourceFile) { + var _b; + var options = _a.options, getRules = _a.getRules, host = _a.host; + // formatting context is used by rules provider + var formattingContext = new formatting.FormattingContext(sourceFile, requestKind, options); + var previousRangeTriviaEnd; + var previousRange; + var previousParent; + var previousRangeStartLine; + var lastIndentedLine; + var indentationOnLastIndentedLine = -1 /* Constants.Unknown */; + var edits = []; + formattingScanner.advance(); + if (formattingScanner.isOnToken()) { + var startLine = sourceFile.getLineAndCharacterOfPosition(enclosingNode.getStart(sourceFile)).line; + var undecoratedStartLine = startLine; + if (ts.hasDecorators(enclosingNode)) { + undecoratedStartLine = sourceFile.getLineAndCharacterOfPosition(ts.getNonDecoratorTokenPosOfNode(enclosingNode, sourceFile)).line; + } + processNode(enclosingNode, enclosingNode, startLine, undecoratedStartLine, initialIndentation, delta); + } + if (!formattingScanner.isOnToken()) { + var indentation = formatting.SmartIndenter.nodeWillIndentChild(options, enclosingNode, /*child*/ undefined, sourceFile, /*indentByDefault*/ false) + ? initialIndentation + options.indentSize + : initialIndentation; + var leadingTrivia = formattingScanner.getCurrentLeadingTrivia(); + if (leadingTrivia) { + indentTriviaItems(leadingTrivia, indentation, /*indentNextTokenOrTrivia*/ false, function (item) { return processRange(item, sourceFile.getLineAndCharacterOfPosition(item.pos), enclosingNode, enclosingNode, /*dynamicIndentation*/ undefined); }); + if (options.trimTrailingWhitespace !== false) { + trimTrailingWhitespacesForRemainingRange(leadingTrivia); + } + } + } + if (previousRange && formattingScanner.getStartPos() >= originalRange.end) { + // Formatting edits happen by looking at pairs of contiguous tokens (see `processPair`), + // typically inserting or deleting whitespace between them. The recursive `processNode` + // logic above bails out as soon as it encounters a token that is beyond the end of the + // range we're supposed to format (or if we reach the end of the file). But this potentially + // leaves out an edit that would occur *inside* the requested range but cannot be discovered + // without looking at one token *beyond* the end of the range: consider the line `x = { }` + // with a selection from the beginning of the line to the space inside the curly braces, + // inclusive. We would expect a format-selection would delete the space (if rules apply), + // but in order to do that, we need to process the pair ["{", "}"], but we stopped processing + // just before getting there. This block handles this trailing edit. + var tokenInfo = formattingScanner.isOnEOF() ? formattingScanner.readEOFTokenRange() : + formattingScanner.isOnToken() ? formattingScanner.readTokenInfo(enclosingNode).token : + undefined; + if (tokenInfo && tokenInfo.pos === previousRangeTriviaEnd) { + // We need to check that tokenInfo and previousRange are contiguous: the `originalRange` + // may have ended in the middle of a token, which means we will have stopped formatting + // on that token, leaving `previousRange` pointing to the token before it, but already + // having moved the formatting scanner (where we just got `tokenInfo`) to the next token. + // If this happens, our supposed pair [previousRange, tokenInfo] actually straddles the + // token that intersects the end of the range we're supposed to format, so the pair will + // produce bogus edits if we try to `processPair`. Recall that the point of this logic is + // to perform a trailing edit at the end of the selection range: but there can be no valid + // edit in the middle of a token where the range ended, so if we have a non-contiguous + // pair here, we're already done and we can ignore it. + var parent = ((_b = ts.findPrecedingToken(tokenInfo.end, sourceFile, enclosingNode)) === null || _b === void 0 ? void 0 : _b.parent) || previousParent; + processPair(tokenInfo, sourceFile.getLineAndCharacterOfPosition(tokenInfo.pos).line, parent, previousRange, previousRangeStartLine, previousParent, parent, + /*dynamicIndentation*/ undefined); + } + } + return edits; + // local functions + /** Tries to compute the indentation for a list element. + * If list element is not in range then + * function will pick its actual indentation + * so it can be pushed downstream as inherited indentation. + * If list element is in the range - its indentation will be equal + * to inherited indentation from its predecessors. + */ + function tryComputeIndentationForListItem(startPos, endPos, parentStartLine, range, inheritedIndentation) { + if (ts.rangeOverlapsWithStartEnd(range, startPos, endPos) || + ts.rangeContainsStartEnd(range, startPos, endPos) /* Not to miss zero-range nodes e.g. JsxText */) { + if (inheritedIndentation !== -1 /* Constants.Unknown */) { + return inheritedIndentation; + } + } + else { + var startLine = sourceFile.getLineAndCharacterOfPosition(startPos).line; + var startLinePosition = ts.getLineStartPositionForPosition(startPos, sourceFile); + var column = formatting.SmartIndenter.findFirstNonWhitespaceColumn(startLinePosition, startPos, sourceFile, options); + if (startLine !== parentStartLine || startPos === column) { + // Use the base indent size if it is greater than + // the indentation of the inherited predecessor. + var baseIndentSize = formatting.SmartIndenter.getBaseIndentation(options); + return baseIndentSize > column ? baseIndentSize : column; + } + } + return -1 /* Constants.Unknown */; + } + function computeIndentation(node, startLine, inheritedIndentation, parent, parentDynamicIndentation, effectiveParentStartLine) { + var delta = formatting.SmartIndenter.shouldIndentChildNode(options, node) ? options.indentSize : 0; + if (effectiveParentStartLine === startLine) { + // if node is located on the same line with the parent + // - inherit indentation from the parent + // - push children if either parent of node itself has non-zero delta + return { + indentation: startLine === lastIndentedLine ? indentationOnLastIndentedLine : parentDynamicIndentation.getIndentation(), + delta: Math.min(options.indentSize, parentDynamicIndentation.getDelta(node) + delta) + }; + } + else if (inheritedIndentation === -1 /* Constants.Unknown */) { + if (node.kind === 20 /* SyntaxKind.OpenParenToken */ && startLine === lastIndentedLine) { + // the is used for chaining methods formatting + // - we need to get the indentation on last line and the delta of parent + return { indentation: indentationOnLastIndentedLine, delta: parentDynamicIndentation.getDelta(node) }; + } + else if (formatting.SmartIndenter.childStartsOnTheSameLineWithElseInIfStatement(parent, node, startLine, sourceFile) || + formatting.SmartIndenter.childIsUnindentedBranchOfConditionalExpression(parent, node, startLine, sourceFile) || + formatting.SmartIndenter.argumentStartsOnSameLineAsPreviousArgument(parent, node, startLine, sourceFile)) { + return { indentation: parentDynamicIndentation.getIndentation(), delta: delta }; + } + else { + return { indentation: parentDynamicIndentation.getIndentation() + parentDynamicIndentation.getDelta(node), delta: delta }; + } + } + else { + return { indentation: inheritedIndentation, delta: delta }; + } + } + function getFirstNonDecoratorTokenOfNode(node) { + if (ts.canHaveModifiers(node)) { + var modifier = ts.find(node.modifiers, ts.isModifier, ts.findIndex(node.modifiers, ts.isDecorator)); + if (modifier) + return modifier.kind; + } + switch (node.kind) { + case 260 /* SyntaxKind.ClassDeclaration */: return 84 /* SyntaxKind.ClassKeyword */; + case 261 /* SyntaxKind.InterfaceDeclaration */: return 118 /* SyntaxKind.InterfaceKeyword */; + case 259 /* SyntaxKind.FunctionDeclaration */: return 98 /* SyntaxKind.FunctionKeyword */; + case 263 /* SyntaxKind.EnumDeclaration */: return 263 /* SyntaxKind.EnumDeclaration */; + case 174 /* SyntaxKind.GetAccessor */: return 137 /* SyntaxKind.GetKeyword */; + case 175 /* SyntaxKind.SetAccessor */: return 151 /* SyntaxKind.SetKeyword */; + case 171 /* SyntaxKind.MethodDeclaration */: + if (node.asteriskToken) { + return 41 /* SyntaxKind.AsteriskToken */; + } + // falls through + case 169 /* SyntaxKind.PropertyDeclaration */: + case 166 /* SyntaxKind.Parameter */: + var name = ts.getNameOfDeclaration(node); + if (name) { + return name.kind; + } + } + } + function getDynamicIndentation(node, nodeStartLine, indentation, delta) { + return { + getIndentationForComment: function (kind, tokenIndentation, container) { + switch (kind) { + // preceding comment to the token that closes the indentation scope inherits the indentation from the scope + // .. { + // // comment + // } + case 19 /* SyntaxKind.CloseBraceToken */: + case 23 /* SyntaxKind.CloseBracketToken */: + case 21 /* SyntaxKind.CloseParenToken */: + return indentation + getDelta(container); + } + return tokenIndentation !== -1 /* Constants.Unknown */ ? tokenIndentation : indentation; + }, + // if list end token is LessThanToken '>' then its delta should be explicitly suppressed + // so that LessThanToken as a binary operator can still be indented. + // foo.then + // < + // number, + // string, + // >(); + // vs + // var a = xValue + // > yValue; + getIndentationForToken: function (line, kind, container, suppressDelta) { + return !suppressDelta && shouldAddDelta(line, kind, container) ? indentation + getDelta(container) : indentation; + }, + getIndentation: function () { return indentation; }, + getDelta: getDelta, + recomputeIndentation: function (lineAdded, parent) { + if (formatting.SmartIndenter.shouldIndentChildNode(options, parent, node, sourceFile)) { + indentation += lineAdded ? options.indentSize : -options.indentSize; + delta = formatting.SmartIndenter.shouldIndentChildNode(options, node) ? options.indentSize : 0; + } + } + }; + function shouldAddDelta(line, kind, container) { + switch (kind) { + // open and close brace, 'else' and 'while' (in do statement) tokens has indentation of the parent + case 18 /* SyntaxKind.OpenBraceToken */: + case 19 /* SyntaxKind.CloseBraceToken */: + case 21 /* SyntaxKind.CloseParenToken */: + case 91 /* SyntaxKind.ElseKeyword */: + case 115 /* SyntaxKind.WhileKeyword */: + case 59 /* SyntaxKind.AtToken */: + return false; + case 43 /* SyntaxKind.SlashToken */: + case 31 /* SyntaxKind.GreaterThanToken */: + switch (container.kind) { + case 283 /* SyntaxKind.JsxOpeningElement */: + case 284 /* SyntaxKind.JsxClosingElement */: + case 282 /* SyntaxKind.JsxSelfClosingElement */: + return false; + } + break; + case 22 /* SyntaxKind.OpenBracketToken */: + case 23 /* SyntaxKind.CloseBracketToken */: + if (container.kind !== 197 /* SyntaxKind.MappedType */) { + return false; + } + break; + } + // if token line equals to the line of containing node (this is a first token in the node) - use node indentation + return nodeStartLine !== line + // if this token is the first token following the list of decorators, we do not need to indent + && !(ts.hasDecorators(node) && kind === getFirstNonDecoratorTokenOfNode(node)); + } + function getDelta(child) { + // Delta value should be zero when the node explicitly prevents indentation of the child node + return formatting.SmartIndenter.nodeWillIndentChild(options, node, child, sourceFile, /*indentByDefault*/ true) ? delta : 0; + } + } + function processNode(node, contextNode, nodeStartLine, undecoratedNodeStartLine, indentation, delta) { + if (!ts.rangeOverlapsWithStartEnd(originalRange, node.getStart(sourceFile), node.getEnd())) { + return; + } + var nodeDynamicIndentation = getDynamicIndentation(node, nodeStartLine, indentation, delta); + // a useful observations when tracking context node + // / + // [a] + // / | \ + // [b] [c] [d] + // node 'a' is a context node for nodes 'b', 'c', 'd' + // except for the leftmost leaf token in [b] - in this case context node ('e') is located somewhere above 'a' + // this rule can be applied recursively to child nodes of 'a'. + // + // context node is set to parent node value after processing every child node + // context node is set to parent of the token after processing every token + var childContextNode = contextNode; + // if there are any tokens that logically belong to node and interleave child nodes + // such tokens will be consumed in processChildNode for the child that follows them + ts.forEachChild(node, function (child) { + processChildNode(child, /*inheritedIndentation*/ -1 /* Constants.Unknown */, node, nodeDynamicIndentation, nodeStartLine, undecoratedNodeStartLine, /*isListItem*/ false); + }, function (nodes) { + processChildNodes(nodes, node, nodeStartLine, nodeDynamicIndentation); + }); + // proceed any tokens in the node that are located after child nodes + while (formattingScanner.isOnToken() && formattingScanner.getStartPos() < originalRange.end) { + var tokenInfo = formattingScanner.readTokenInfo(node); + if (tokenInfo.token.end > Math.min(node.end, originalRange.end)) { + break; + } + consumeTokenAndAdvanceScanner(tokenInfo, node, nodeDynamicIndentation, node); + } + function processChildNode(child, inheritedIndentation, parent, parentDynamicIndentation, parentStartLine, undecoratedParentStartLine, isListItem, isFirstListItem) { + ts.Debug.assert(!ts.nodeIsSynthesized(child)); + if (ts.nodeIsMissing(child)) { + return inheritedIndentation; + } + var childStartPos = child.getStart(sourceFile); + var childStartLine = sourceFile.getLineAndCharacterOfPosition(childStartPos).line; + var undecoratedChildStartLine = childStartLine; + if (ts.hasDecorators(child)) { + undecoratedChildStartLine = sourceFile.getLineAndCharacterOfPosition(ts.getNonDecoratorTokenPosOfNode(child, sourceFile)).line; + } + // if child is a list item - try to get its indentation, only if parent is within the original range. + var childIndentationAmount = -1 /* Constants.Unknown */; + if (isListItem && ts.rangeContainsRange(originalRange, parent)) { + childIndentationAmount = tryComputeIndentationForListItem(childStartPos, child.end, parentStartLine, originalRange, inheritedIndentation); + if (childIndentationAmount !== -1 /* Constants.Unknown */) { + inheritedIndentation = childIndentationAmount; + } + } + // child node is outside the target range - do not dive inside + if (!ts.rangeOverlapsWithStartEnd(originalRange, child.pos, child.end)) { + if (child.end < originalRange.pos) { + formattingScanner.skipToEndOf(child); + } + return inheritedIndentation; + } + if (child.getFullWidth() === 0) { + return inheritedIndentation; + } + while (formattingScanner.isOnToken() && formattingScanner.getStartPos() < originalRange.end) { + // proceed any parent tokens that are located prior to child.getStart() + var tokenInfo = formattingScanner.readTokenInfo(node); + if (tokenInfo.token.end > originalRange.end) { + return inheritedIndentation; + } + if (tokenInfo.token.end > childStartPos) { + if (tokenInfo.token.pos > childStartPos) { + formattingScanner.skipToStartOf(child); + } + // stop when formatting scanner advances past the beginning of the child + break; + } + consumeTokenAndAdvanceScanner(tokenInfo, node, parentDynamicIndentation, node); + } + if (!formattingScanner.isOnToken() || formattingScanner.getStartPos() >= originalRange.end) { + return inheritedIndentation; + } + if (ts.isToken(child)) { + // if child node is a token, it does not impact indentation, proceed it using parent indentation scope rules + var tokenInfo = formattingScanner.readTokenInfo(child); + // JSX text shouldn't affect indenting + if (child.kind !== 11 /* SyntaxKind.JsxText */) { + ts.Debug.assert(tokenInfo.token.end === child.end, "Token end is child end"); + consumeTokenAndAdvanceScanner(tokenInfo, node, parentDynamicIndentation, child); + return inheritedIndentation; + } + } + var effectiveParentStartLine = child.kind === 167 /* SyntaxKind.Decorator */ ? childStartLine : undecoratedParentStartLine; + var childIndentation = computeIndentation(child, childStartLine, childIndentationAmount, node, parentDynamicIndentation, effectiveParentStartLine); + processNode(child, childContextNode, childStartLine, undecoratedChildStartLine, childIndentation.indentation, childIndentation.delta); + childContextNode = node; + if (isFirstListItem && parent.kind === 206 /* SyntaxKind.ArrayLiteralExpression */ && inheritedIndentation === -1 /* Constants.Unknown */) { + inheritedIndentation = childIndentation.indentation; + } + return inheritedIndentation; + } + function processChildNodes(nodes, parent, parentStartLine, parentDynamicIndentation) { + ts.Debug.assert(ts.isNodeArray(nodes)); + ts.Debug.assert(!ts.nodeIsSynthesized(nodes)); + var listStartToken = getOpenTokenForList(parent, nodes); + var listDynamicIndentation = parentDynamicIndentation; + var startLine = parentStartLine; + // node range is outside the target range - do not dive inside + if (!ts.rangeOverlapsWithStartEnd(originalRange, nodes.pos, nodes.end)) { + if (nodes.end < originalRange.pos) { + formattingScanner.skipToEndOf(nodes); + } + return; + } + if (listStartToken !== 0 /* SyntaxKind.Unknown */) { + // introduce a new indentation scope for lists (including list start and end tokens) + while (formattingScanner.isOnToken() && formattingScanner.getStartPos() < originalRange.end) { + var tokenInfo = formattingScanner.readTokenInfo(parent); + if (tokenInfo.token.end > nodes.pos) { + // stop when formatting scanner moves past the beginning of node list + break; + } + else if (tokenInfo.token.kind === listStartToken) { + // consume list start token + startLine = sourceFile.getLineAndCharacterOfPosition(tokenInfo.token.pos).line; + consumeTokenAndAdvanceScanner(tokenInfo, parent, parentDynamicIndentation, parent); + var indentationOnListStartToken = void 0; + if (indentationOnLastIndentedLine !== -1 /* Constants.Unknown */) { + // scanner just processed list start token so consider last indentation as list indentation + // function foo(): { // last indentation was 0, list item will be indented based on this value + // foo: number; + // }: {}; + indentationOnListStartToken = indentationOnLastIndentedLine; + } + else { + var startLinePosition = ts.getLineStartPositionForPosition(tokenInfo.token.pos, sourceFile); + indentationOnListStartToken = formatting.SmartIndenter.findFirstNonWhitespaceColumn(startLinePosition, tokenInfo.token.pos, sourceFile, options); + } + listDynamicIndentation = getDynamicIndentation(parent, parentStartLine, indentationOnListStartToken, options.indentSize); // TODO: GH#18217 + } + else { + // consume any tokens that precede the list as child elements of 'node' using its indentation scope + consumeTokenAndAdvanceScanner(tokenInfo, parent, parentDynamicIndentation, parent); + } + } + } + var inheritedIndentation = -1 /* Constants.Unknown */; + for (var i = 0; i < nodes.length; i++) { + var child = nodes[i]; + inheritedIndentation = processChildNode(child, inheritedIndentation, node, listDynamicIndentation, startLine, startLine, /*isListItem*/ true, /*isFirstListItem*/ i === 0); + } + var listEndToken = getCloseTokenForOpenToken(listStartToken); + if (listEndToken !== 0 /* SyntaxKind.Unknown */ && formattingScanner.isOnToken() && formattingScanner.getStartPos() < originalRange.end) { + var tokenInfo = formattingScanner.readTokenInfo(parent); + if (tokenInfo.token.kind === 27 /* SyntaxKind.CommaToken */) { + // consume the comma + consumeTokenAndAdvanceScanner(tokenInfo, parent, listDynamicIndentation, parent); + tokenInfo = formattingScanner.isOnToken() ? formattingScanner.readTokenInfo(parent) : undefined; + } + // consume the list end token only if it is still belong to the parent + // there might be the case when current token matches end token but does not considered as one + // function (x: function) <-- + // without this check close paren will be interpreted as list end token for function expression which is wrong + if (tokenInfo && tokenInfo.token.kind === listEndToken && ts.rangeContainsRange(parent, tokenInfo.token)) { + // consume list end token + consumeTokenAndAdvanceScanner(tokenInfo, parent, listDynamicIndentation, parent, /*isListEndToken*/ true); + } + } + } + function consumeTokenAndAdvanceScanner(currentTokenInfo, parent, dynamicIndentation, container, isListEndToken) { + ts.Debug.assert(ts.rangeContainsRange(parent, currentTokenInfo.token)); + var lastTriviaWasNewLine = formattingScanner.lastTrailingTriviaWasNewLine(); + var indentToken = false; + if (currentTokenInfo.leadingTrivia) { + processTrivia(currentTokenInfo.leadingTrivia, parent, childContextNode, dynamicIndentation); + } + var lineAction = 0 /* LineAction.None */; + var isTokenInRange = ts.rangeContainsRange(originalRange, currentTokenInfo.token); + var tokenStart = sourceFile.getLineAndCharacterOfPosition(currentTokenInfo.token.pos); + if (isTokenInRange) { + var rangeHasError = rangeContainsError(currentTokenInfo.token); + // save previousRange since processRange will overwrite this value with current one + var savePreviousRange = previousRange; + lineAction = processRange(currentTokenInfo.token, tokenStart, parent, childContextNode, dynamicIndentation); + // do not indent comments\token if token range overlaps with some error + if (!rangeHasError) { + if (lineAction === 0 /* LineAction.None */) { + // indent token only if end line of previous range does not match start line of the token + var prevEndLine = savePreviousRange && sourceFile.getLineAndCharacterOfPosition(savePreviousRange.end).line; + indentToken = lastTriviaWasNewLine && tokenStart.line !== prevEndLine; + } + else { + indentToken = lineAction === 1 /* LineAction.LineAdded */; + } + } + } + if (currentTokenInfo.trailingTrivia) { + previousRangeTriviaEnd = ts.last(currentTokenInfo.trailingTrivia).end; + processTrivia(currentTokenInfo.trailingTrivia, parent, childContextNode, dynamicIndentation); + } + if (indentToken) { + var tokenIndentation = (isTokenInRange && !rangeContainsError(currentTokenInfo.token)) ? + dynamicIndentation.getIndentationForToken(tokenStart.line, currentTokenInfo.token.kind, container, !!isListEndToken) : + -1 /* Constants.Unknown */; + var indentNextTokenOrTrivia = true; + if (currentTokenInfo.leadingTrivia) { + var commentIndentation_1 = dynamicIndentation.getIndentationForComment(currentTokenInfo.token.kind, tokenIndentation, container); + indentNextTokenOrTrivia = indentTriviaItems(currentTokenInfo.leadingTrivia, commentIndentation_1, indentNextTokenOrTrivia, function (item) { return insertIndentation(item.pos, commentIndentation_1, /*lineAdded*/ false); }); + } + // indent token only if is it is in target range and does not overlap with any error ranges + if (tokenIndentation !== -1 /* Constants.Unknown */ && indentNextTokenOrTrivia) { + insertIndentation(currentTokenInfo.token.pos, tokenIndentation, lineAction === 1 /* LineAction.LineAdded */); + lastIndentedLine = tokenStart.line; + indentationOnLastIndentedLine = tokenIndentation; + } + } + formattingScanner.advance(); + childContextNode = parent; + } + } + function indentTriviaItems(trivia, commentIndentation, indentNextTokenOrTrivia, indentSingleLine) { + for (var _i = 0, trivia_1 = trivia; _i < trivia_1.length; _i++) { + var triviaItem = trivia_1[_i]; + var triviaInRange = ts.rangeContainsRange(originalRange, triviaItem); + switch (triviaItem.kind) { + case 3 /* SyntaxKind.MultiLineCommentTrivia */: + if (triviaInRange) { + indentMultilineComment(triviaItem, commentIndentation, /*firstLineIsIndented*/ !indentNextTokenOrTrivia); + } + indentNextTokenOrTrivia = false; + break; + case 2 /* SyntaxKind.SingleLineCommentTrivia */: + if (indentNextTokenOrTrivia && triviaInRange) { + indentSingleLine(triviaItem); + } + indentNextTokenOrTrivia = false; + break; + case 4 /* SyntaxKind.NewLineTrivia */: + indentNextTokenOrTrivia = true; + break; + } + } + return indentNextTokenOrTrivia; + } + function processTrivia(trivia, parent, contextNode, dynamicIndentation) { + for (var _i = 0, trivia_2 = trivia; _i < trivia_2.length; _i++) { + var triviaItem = trivia_2[_i]; + if (ts.isComment(triviaItem.kind) && ts.rangeContainsRange(originalRange, triviaItem)) { + var triviaItemStart = sourceFile.getLineAndCharacterOfPosition(triviaItem.pos); + processRange(triviaItem, triviaItemStart, parent, contextNode, dynamicIndentation); + } + } + } + function processRange(range, rangeStart, parent, contextNode, dynamicIndentation) { + var rangeHasError = rangeContainsError(range); + var lineAction = 0 /* LineAction.None */; + if (!rangeHasError) { + if (!previousRange) { + // trim whitespaces starting from the beginning of the span up to the current line + var originalStart = sourceFile.getLineAndCharacterOfPosition(originalRange.pos); + trimTrailingWhitespacesForLines(originalStart.line, rangeStart.line); + } + else { + lineAction = + processPair(range, rangeStart.line, parent, previousRange, previousRangeStartLine, previousParent, contextNode, dynamicIndentation); + } + } + previousRange = range; + previousRangeTriviaEnd = range.end; + previousParent = parent; + previousRangeStartLine = rangeStart.line; + return lineAction; + } + function processPair(currentItem, currentStartLine, currentParent, previousItem, previousStartLine, previousParent, contextNode, dynamicIndentation) { + formattingContext.updateContext(previousItem, previousParent, currentItem, currentParent, contextNode); + var rules = getRules(formattingContext); + var trimTrailingWhitespaces = formattingContext.options.trimTrailingWhitespace !== false; + var lineAction = 0 /* LineAction.None */; + if (rules) { + // Apply rules in reverse order so that higher priority rules (which are first in the array) + // win in a conflict with lower priority rules. + ts.forEachRight(rules, function (rule) { + lineAction = applyRuleEdits(rule, previousItem, previousStartLine, currentItem, currentStartLine); + if (dynamicIndentation) { + switch (lineAction) { + case 2 /* LineAction.LineRemoved */: + // Handle the case where the next line is moved to be the end of this line. + // In this case we don't indent the next line in the next pass. + if (currentParent.getStart(sourceFile) === currentItem.pos) { + dynamicIndentation.recomputeIndentation(/*lineAddedByFormatting*/ false, contextNode); + } + break; + case 1 /* LineAction.LineAdded */: + // Handle the case where token2 is moved to the new line. + // In this case we indent token2 in the next pass but we set + // sameLineIndent flag to notify the indenter that the indentation is within the line. + if (currentParent.getStart(sourceFile) === currentItem.pos) { + dynamicIndentation.recomputeIndentation(/*lineAddedByFormatting*/ true, contextNode); + } + break; + default: + ts.Debug.assert(lineAction === 0 /* LineAction.None */); + } + } + // We need to trim trailing whitespace between the tokens if they were on different lines, and no rule was applied to put them on the same line + trimTrailingWhitespaces = trimTrailingWhitespaces && !(rule.action & 16 /* RuleAction.DeleteSpace */) && rule.flags !== 1 /* RuleFlags.CanDeleteNewLines */; + }); + } + else { + trimTrailingWhitespaces = trimTrailingWhitespaces && currentItem.kind !== 1 /* SyntaxKind.EndOfFileToken */; + } + if (currentStartLine !== previousStartLine && trimTrailingWhitespaces) { + // We need to trim trailing whitespace between the tokens if they were on different lines, and no rule was applied to put them on the same line + trimTrailingWhitespacesForLines(previousStartLine, currentStartLine, previousItem); + } + return lineAction; + } + function insertIndentation(pos, indentation, lineAdded) { + var indentationString = getIndentationString(indentation, options); + if (lineAdded) { + // new line is added before the token by the formatting rules + // insert indentation string at the very beginning of the token + recordReplace(pos, 0, indentationString); + } + else { + var tokenStart = sourceFile.getLineAndCharacterOfPosition(pos); + var startLinePosition = ts.getStartPositionOfLine(tokenStart.line, sourceFile); + if (indentation !== characterToColumn(startLinePosition, tokenStart.character) || indentationIsDifferent(indentationString, startLinePosition)) { + recordReplace(startLinePosition, tokenStart.character, indentationString); + } + } + } + function characterToColumn(startLinePosition, characterInLine) { + var column = 0; + for (var i = 0; i < characterInLine; i++) { + if (sourceFile.text.charCodeAt(startLinePosition + i) === 9 /* CharacterCodes.tab */) { + column += options.tabSize - column % options.tabSize; + } + else { + column++; + } + } + return column; + } + function indentationIsDifferent(indentationString, startLinePosition) { + return indentationString !== sourceFile.text.substr(startLinePosition, indentationString.length); + } + function indentMultilineComment(commentRange, indentation, firstLineIsIndented, indentFinalLine) { + if (indentFinalLine === void 0) { indentFinalLine = true; } + // split comment in lines + var startLine = sourceFile.getLineAndCharacterOfPosition(commentRange.pos).line; + var endLine = sourceFile.getLineAndCharacterOfPosition(commentRange.end).line; + if (startLine === endLine) { + if (!firstLineIsIndented) { + // treat as single line comment + insertIndentation(commentRange.pos, indentation, /*lineAdded*/ false); + } + return; + } + var parts = []; + var startPos = commentRange.pos; + for (var line = startLine; line < endLine; line++) { + var endOfLine = ts.getEndLinePosition(line, sourceFile); + parts.push({ pos: startPos, end: endOfLine }); + startPos = ts.getStartPositionOfLine(line + 1, sourceFile); + } + if (indentFinalLine) { + parts.push({ pos: startPos, end: commentRange.end }); + } + if (parts.length === 0) + return; + var startLinePos = ts.getStartPositionOfLine(startLine, sourceFile); + var nonWhitespaceColumnInFirstPart = formatting.SmartIndenter.findFirstNonWhitespaceCharacterAndColumn(startLinePos, parts[0].pos, sourceFile, options); + var startIndex = 0; + if (firstLineIsIndented) { + startIndex = 1; + startLine++; + } + // shift all parts on the delta size + var delta = indentation - nonWhitespaceColumnInFirstPart.column; + for (var i = startIndex; i < parts.length; i++, startLine++) { + var startLinePos_1 = ts.getStartPositionOfLine(startLine, sourceFile); + var nonWhitespaceCharacterAndColumn = i === 0 + ? nonWhitespaceColumnInFirstPart + : formatting.SmartIndenter.findFirstNonWhitespaceCharacterAndColumn(parts[i].pos, parts[i].end, sourceFile, options); + var newIndentation = nonWhitespaceCharacterAndColumn.column + delta; + if (newIndentation > 0) { + var indentationString = getIndentationString(newIndentation, options); + recordReplace(startLinePos_1, nonWhitespaceCharacterAndColumn.character, indentationString); + } + else { + recordDelete(startLinePos_1, nonWhitespaceCharacterAndColumn.character); + } + } + } + function trimTrailingWhitespacesForLines(line1, line2, range) { + for (var line = line1; line < line2; line++) { + var lineStartPosition = ts.getStartPositionOfLine(line, sourceFile); + var lineEndPosition = ts.getEndLinePosition(line, sourceFile); + // do not trim whitespaces in comments or template expression + if (range && (ts.isComment(range.kind) || ts.isStringOrRegularExpressionOrTemplateLiteral(range.kind)) && range.pos <= lineEndPosition && range.end > lineEndPosition) { + continue; + } + var whitespaceStart = getTrailingWhitespaceStartPosition(lineStartPosition, lineEndPosition); + if (whitespaceStart !== -1) { + ts.Debug.assert(whitespaceStart === lineStartPosition || !ts.isWhiteSpaceSingleLine(sourceFile.text.charCodeAt(whitespaceStart - 1))); + recordDelete(whitespaceStart, lineEndPosition + 1 - whitespaceStart); + } + } + } + /** + * @param start The position of the first character in range + * @param end The position of the last character in range + */ + function getTrailingWhitespaceStartPosition(start, end) { + var pos = end; + while (pos >= start && ts.isWhiteSpaceSingleLine(sourceFile.text.charCodeAt(pos))) { + pos--; + } + if (pos !== end) { + return pos + 1; + } + return -1; + } + /** + * Trimming will be done for lines after the previous range. + * Exclude comments as they had been previously processed. + */ + function trimTrailingWhitespacesForRemainingRange(trivias) { + var startPos = previousRange ? previousRange.end : originalRange.pos; + for (var _i = 0, trivias_1 = trivias; _i < trivias_1.length; _i++) { + var trivia = trivias_1[_i]; + if (ts.isComment(trivia.kind)) { + if (startPos < trivia.pos) { + trimTrailingWitespacesForPositions(startPos, trivia.pos - 1, previousRange); + } + startPos = trivia.end + 1; + } + } + if (startPos < originalRange.end) { + trimTrailingWitespacesForPositions(startPos, originalRange.end, previousRange); + } + } + function trimTrailingWitespacesForPositions(startPos, endPos, previousRange) { + var startLine = sourceFile.getLineAndCharacterOfPosition(startPos).line; + var endLine = sourceFile.getLineAndCharacterOfPosition(endPos).line; + trimTrailingWhitespacesForLines(startLine, endLine + 1, previousRange); + } + function recordDelete(start, len) { + if (len) { + edits.push(ts.createTextChangeFromStartLength(start, len, "")); + } + } + function recordReplace(start, len, newText) { + if (len || newText) { + edits.push(ts.createTextChangeFromStartLength(start, len, newText)); + } + } + function recordInsert(start, text) { + if (text) { + edits.push(ts.createTextChangeFromStartLength(start, 0, text)); + } + } + function applyRuleEdits(rule, previousRange, previousStartLine, currentRange, currentStartLine) { + var onLaterLine = currentStartLine !== previousStartLine; + switch (rule.action) { + case 1 /* RuleAction.StopProcessingSpaceActions */: + // no action required + return 0 /* LineAction.None */; + case 16 /* RuleAction.DeleteSpace */: + if (previousRange.end !== currentRange.pos) { + // delete characters starting from t1.end up to t2.pos exclusive + recordDelete(previousRange.end, currentRange.pos - previousRange.end); + return onLaterLine ? 2 /* LineAction.LineRemoved */ : 0 /* LineAction.None */; + } + break; + case 32 /* RuleAction.DeleteToken */: + recordDelete(previousRange.pos, previousRange.end - previousRange.pos); + break; + case 8 /* RuleAction.InsertNewLine */: + // exit early if we on different lines and rule cannot change number of newlines + // if line1 and line2 are on subsequent lines then no edits are required - ok to exit + // if line1 and line2 are separated with more than one newline - ok to exit since we cannot delete extra new lines + if (rule.flags !== 1 /* RuleFlags.CanDeleteNewLines */ && previousStartLine !== currentStartLine) { + return 0 /* LineAction.None */; + } + // edit should not be applied if we have one line feed between elements + var lineDelta = currentStartLine - previousStartLine; + if (lineDelta !== 1) { + recordReplace(previousRange.end, currentRange.pos - previousRange.end, ts.getNewLineOrDefaultFromHost(host, options)); + return onLaterLine ? 0 /* LineAction.None */ : 1 /* LineAction.LineAdded */; + } + break; + case 4 /* RuleAction.InsertSpace */: + // exit early if we on different lines and rule cannot change number of newlines + if (rule.flags !== 1 /* RuleFlags.CanDeleteNewLines */ && previousStartLine !== currentStartLine) { + return 0 /* LineAction.None */; + } + var posDelta = currentRange.pos - previousRange.end; + if (posDelta !== 1 || sourceFile.text.charCodeAt(previousRange.end) !== 32 /* CharacterCodes.space */) { + recordReplace(previousRange.end, currentRange.pos - previousRange.end, " "); + return onLaterLine ? 2 /* LineAction.LineRemoved */ : 0 /* LineAction.None */; + } + break; + case 64 /* RuleAction.InsertTrailingSemicolon */: + recordInsert(previousRange.end, ";"); + } + return 0 /* LineAction.None */; + } + } + var LineAction; + (function (LineAction) { + LineAction[LineAction["None"] = 0] = "None"; + LineAction[LineAction["LineAdded"] = 1] = "LineAdded"; + LineAction[LineAction["LineRemoved"] = 2] = "LineRemoved"; + })(LineAction || (LineAction = {})); + /** + * @param precedingToken pass `null` if preceding token was already computed and result was `undefined`. + */ + function getRangeOfEnclosingComment(sourceFile, position, precedingToken, tokenAtPosition) { + if (tokenAtPosition === void 0) { tokenAtPosition = ts.getTokenAtPosition(sourceFile, position); } + var jsdoc = ts.findAncestor(tokenAtPosition, ts.isJSDoc); + if (jsdoc) + tokenAtPosition = jsdoc.parent; + var tokenStart = tokenAtPosition.getStart(sourceFile); + if (tokenStart <= position && position < tokenAtPosition.getEnd()) { + return undefined; + } + // eslint-disable-next-line no-null/no-null + precedingToken = precedingToken === null ? undefined : precedingToken === undefined ? ts.findPrecedingToken(position, sourceFile) : precedingToken; + // Between two consecutive tokens, all comments are either trailing on the former + // or leading on the latter (and none are in both lists). + var trailingRangesOfPreviousToken = precedingToken && ts.getTrailingCommentRanges(sourceFile.text, precedingToken.end); + var leadingCommentRangesOfNextToken = ts.getLeadingCommentRangesOfNode(tokenAtPosition, sourceFile); + var commentRanges = ts.concatenate(trailingRangesOfPreviousToken, leadingCommentRangesOfNextToken); + return commentRanges && ts.find(commentRanges, function (range) { return ts.rangeContainsPositionExclusive(range, position) || + // The end marker of a single-line comment does not include the newline character. + // With caret at `^`, in the following case, we are inside a comment (^ denotes the cursor position): + // + // // asdf ^\n + // + // But for closed multi-line comments, we don't want to be inside the comment in the following case: + // + // /* asdf */^ + // + // However, unterminated multi-line comments *do* contain their end. + // + // Internally, we represent the end of the comment at the newline and closing '/', respectively. + // + position === range.end && (range.kind === 2 /* SyntaxKind.SingleLineCommentTrivia */ || position === sourceFile.getFullWidth()); }); + } + formatting.getRangeOfEnclosingComment = getRangeOfEnclosingComment; + function getOpenTokenForList(node, list) { + switch (node.kind) { + case 173 /* SyntaxKind.Constructor */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + case 216 /* SyntaxKind.ArrowFunction */: + case 176 /* SyntaxKind.CallSignature */: + case 177 /* SyntaxKind.ConstructSignature */: + case 181 /* SyntaxKind.FunctionType */: + case 182 /* SyntaxKind.ConstructorType */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + if (node.typeParameters === list) { + return 29 /* SyntaxKind.LessThanToken */; + } + else if (node.parameters === list) { + return 20 /* SyntaxKind.OpenParenToken */; + } + break; + case 210 /* SyntaxKind.CallExpression */: + case 211 /* SyntaxKind.NewExpression */: + if (node.typeArguments === list) { + return 29 /* SyntaxKind.LessThanToken */; + } + else if (node.arguments === list) { + return 20 /* SyntaxKind.OpenParenToken */; + } + break; + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + if (node.typeParameters === list) { + return 29 /* SyntaxKind.LessThanToken */; + } + break; + case 180 /* SyntaxKind.TypeReference */: + case 212 /* SyntaxKind.TaggedTemplateExpression */: + case 183 /* SyntaxKind.TypeQuery */: + case 230 /* SyntaxKind.ExpressionWithTypeArguments */: + case 202 /* SyntaxKind.ImportType */: + if (node.typeArguments === list) { + return 29 /* SyntaxKind.LessThanToken */; + } + break; + case 184 /* SyntaxKind.TypeLiteral */: + return 18 /* SyntaxKind.OpenBraceToken */; + } + return 0 /* SyntaxKind.Unknown */; + } + function getCloseTokenForOpenToken(kind) { + switch (kind) { + case 20 /* SyntaxKind.OpenParenToken */: + return 21 /* SyntaxKind.CloseParenToken */; + case 29 /* SyntaxKind.LessThanToken */: + return 31 /* SyntaxKind.GreaterThanToken */; + case 18 /* SyntaxKind.OpenBraceToken */: + return 19 /* SyntaxKind.CloseBraceToken */; + } + return 0 /* SyntaxKind.Unknown */; + } + var internedSizes; + var internedTabsIndentation; + var internedSpacesIndentation; + function getIndentationString(indentation, options) { + // reset interned strings if FormatCodeOptions were changed + var resetInternedStrings = !internedSizes || (internedSizes.tabSize !== options.tabSize || internedSizes.indentSize !== options.indentSize); + if (resetInternedStrings) { + internedSizes = { tabSize: options.tabSize, indentSize: options.indentSize }; + internedTabsIndentation = internedSpacesIndentation = undefined; + } + if (!options.convertTabsToSpaces) { + var tabs = Math.floor(indentation / options.tabSize); + var spaces = indentation - tabs * options.tabSize; + var tabString = void 0; + if (!internedTabsIndentation) { + internedTabsIndentation = []; + } + if (internedTabsIndentation[tabs] === undefined) { + internedTabsIndentation[tabs] = tabString = ts.repeatString("\t", tabs); + } + else { + tabString = internedTabsIndentation[tabs]; + } + return spaces ? tabString + ts.repeatString(" ", spaces) : tabString; + } + else { + var spacesString = void 0; + var quotient = Math.floor(indentation / options.indentSize); + var remainder = indentation % options.indentSize; + if (!internedSpacesIndentation) { + internedSpacesIndentation = []; + } + if (internedSpacesIndentation[quotient] === undefined) { + spacesString = ts.repeatString(" ", options.indentSize * quotient); + internedSpacesIndentation[quotient] = spacesString; + } + else { + spacesString = internedSpacesIndentation[quotient]; + } + return remainder ? spacesString + ts.repeatString(" ", remainder) : spacesString; + } + } + formatting.getIndentationString = getIndentationString; + })(formatting = ts.formatting || (ts.formatting = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var formatting; + (function (formatting) { + var SmartIndenter; + (function (SmartIndenter) { + var Value; + (function (Value) { + Value[Value["Unknown"] = -1] = "Unknown"; + })(Value || (Value = {})); + /** + * @param assumeNewLineBeforeCloseBrace + * `false` when called on text from a real source file. + * `true` when we need to assume `position` is on a newline. + * + * This is useful for codefixes. Consider + * ``` + * function f() { + * |} + * ``` + * with `position` at `|`. + * + * When inserting some text after an open brace, we would like to get indentation as if a newline was already there. + * By default indentation at `position` will be 0 so 'assumeNewLineBeforeCloseBrace' overrides this behavior. + */ + function getIndentation(position, sourceFile, options, assumeNewLineBeforeCloseBrace) { + if (assumeNewLineBeforeCloseBrace === void 0) { assumeNewLineBeforeCloseBrace = false; } + if (position > sourceFile.text.length) { + return getBaseIndentation(options); // past EOF + } + // no indentation when the indent style is set to none, + // so we can return fast + if (options.indentStyle === ts.IndentStyle.None) { + return 0; + } + var precedingToken = ts.findPrecedingToken(position, sourceFile, /*startNode*/ undefined, /*excludeJsdoc*/ true); + // eslint-disable-next-line no-null/no-null + var enclosingCommentRange = formatting.getRangeOfEnclosingComment(sourceFile, position, precedingToken || null); + if (enclosingCommentRange && enclosingCommentRange.kind === 3 /* SyntaxKind.MultiLineCommentTrivia */) { + return getCommentIndent(sourceFile, position, options, enclosingCommentRange); + } + if (!precedingToken) { + return getBaseIndentation(options); + } + // no indentation in string \regex\template literals + var precedingTokenIsLiteral = ts.isStringOrRegularExpressionOrTemplateLiteral(precedingToken.kind); + if (precedingTokenIsLiteral && precedingToken.getStart(sourceFile) <= position && position < precedingToken.end) { + return 0; + } + var lineAtPosition = sourceFile.getLineAndCharacterOfPosition(position).line; + // indentation is first non-whitespace character in a previous line + // for block indentation, we should look for a line which contains something that's not + // whitespace. + var currentToken = ts.getTokenAtPosition(sourceFile, position); + // For object literals, we want indentation to work just like with blocks. + // If the `{` starts in any position (even in the middle of a line), then + // the following indentation should treat `{` as the start of that line (including leading whitespace). + // ``` + // const a: { x: undefined, y: undefined } = {} // leading 4 whitespaces and { starts in the middle of line + // -> + // const a: { x: undefined, y: undefined } = { + // x: undefined, + // y: undefined, + // } + // --------------------- + // const a: {x : undefined, y: undefined } = + // {} + // -> + // const a: { x: undefined, y: undefined } = + // { // leading 5 whitespaces and { starts at 6 column + // x: undefined, + // y: undefined, + // } + // ``` + var isObjectLiteral = currentToken.kind === 18 /* SyntaxKind.OpenBraceToken */ && currentToken.parent.kind === 207 /* SyntaxKind.ObjectLiteralExpression */; + if (options.indentStyle === ts.IndentStyle.Block || isObjectLiteral) { + return getBlockIndent(sourceFile, position, options); + } + if (precedingToken.kind === 27 /* SyntaxKind.CommaToken */ && precedingToken.parent.kind !== 223 /* SyntaxKind.BinaryExpression */) { + // previous token is comma that separates items in list - find the previous item and try to derive indentation from it + var actualIndentation = getActualIndentationForListItemBeforeComma(precedingToken, sourceFile, options); + if (actualIndentation !== -1 /* Value.Unknown */) { + return actualIndentation; + } + } + var containerList = getListByPosition(position, precedingToken.parent, sourceFile); + // use list position if the preceding token is before any list items + if (containerList && !ts.rangeContainsRange(containerList, precedingToken)) { + var useTheSameBaseIndentation = [215 /* SyntaxKind.FunctionExpression */, 216 /* SyntaxKind.ArrowFunction */].indexOf(currentToken.parent.kind) !== -1; + var indentSize = useTheSameBaseIndentation ? 0 : options.indentSize; + return getActualIndentationForListStartLine(containerList, sourceFile, options) + indentSize; // TODO: GH#18217 + } + return getSmartIndent(sourceFile, position, precedingToken, lineAtPosition, assumeNewLineBeforeCloseBrace, options); + } + SmartIndenter.getIndentation = getIndentation; + function getCommentIndent(sourceFile, position, options, enclosingCommentRange) { + var previousLine = ts.getLineAndCharacterOfPosition(sourceFile, position).line - 1; + var commentStartLine = ts.getLineAndCharacterOfPosition(sourceFile, enclosingCommentRange.pos).line; + ts.Debug.assert(commentStartLine >= 0); + if (previousLine <= commentStartLine) { + return findFirstNonWhitespaceColumn(ts.getStartPositionOfLine(commentStartLine, sourceFile), position, sourceFile, options); + } + var startPositionOfLine = ts.getStartPositionOfLine(previousLine, sourceFile); + var _a = findFirstNonWhitespaceCharacterAndColumn(startPositionOfLine, position, sourceFile, options), column = _a.column, character = _a.character; + if (column === 0) { + return column; + } + var firstNonWhitespaceCharacterCode = sourceFile.text.charCodeAt(startPositionOfLine + character); + return firstNonWhitespaceCharacterCode === 42 /* CharacterCodes.asterisk */ ? column - 1 : column; + } + function getBlockIndent(sourceFile, position, options) { + // move backwards until we find a line with a non-whitespace character, + // then find the first non-whitespace character for that line. + var current = position; + while (current > 0) { + var char = sourceFile.text.charCodeAt(current); + if (!ts.isWhiteSpaceLike(char)) { + break; + } + current--; + } + var lineStart = ts.getLineStartPositionForPosition(current, sourceFile); + return findFirstNonWhitespaceColumn(lineStart, current, sourceFile, options); + } + function getSmartIndent(sourceFile, position, precedingToken, lineAtPosition, assumeNewLineBeforeCloseBrace, options) { + // try to find node that can contribute to indentation and includes 'position' starting from 'precedingToken' + // if such node is found - compute initial indentation for 'position' inside this node + var previous; + var current = precedingToken; + while (current) { + if (ts.positionBelongsToNode(current, position, sourceFile) && shouldIndentChildNode(options, current, previous, sourceFile, /*isNextChild*/ true)) { + var currentStart = getStartLineAndCharacterForNode(current, sourceFile); + var nextTokenKind = nextTokenIsCurlyBraceOnSameLineAsCursor(precedingToken, current, lineAtPosition, sourceFile); + var indentationDelta = nextTokenKind !== 0 /* NextTokenKind.Unknown */ + // handle cases when codefix is about to be inserted before the close brace + ? assumeNewLineBeforeCloseBrace && nextTokenKind === 2 /* NextTokenKind.CloseBrace */ ? options.indentSize : 0 + : lineAtPosition !== currentStart.line ? options.indentSize : 0; + return getIndentationForNodeWorker(current, currentStart, /*ignoreActualIndentationRange*/ undefined, indentationDelta, sourceFile, /*isNextChild*/ true, options); // TODO: GH#18217 + } + // check if current node is a list item - if yes, take indentation from it + // do not consider parent-child line sharing yet: + // function foo(a + // | preceding node 'a' does share line with its parent but indentation is expected + var actualIndentation = getActualIndentationForListItem(current, sourceFile, options, /*listIndentsChild*/ true); + if (actualIndentation !== -1 /* Value.Unknown */) { + return actualIndentation; + } + previous = current; + current = current.parent; + } + // no parent was found - return the base indentation of the SourceFile + return getBaseIndentation(options); + } + function getIndentationForNode(n, ignoreActualIndentationRange, sourceFile, options) { + var start = sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile)); + return getIndentationForNodeWorker(n, start, ignoreActualIndentationRange, /*indentationDelta*/ 0, sourceFile, /*isNextChild*/ false, options); + } + SmartIndenter.getIndentationForNode = getIndentationForNode; + function getBaseIndentation(options) { + return options.baseIndentSize || 0; + } + SmartIndenter.getBaseIndentation = getBaseIndentation; + function getIndentationForNodeWorker(current, currentStart, ignoreActualIndentationRange, indentationDelta, sourceFile, isNextChild, options) { + var _a; + var parent = current.parent; + // Walk up the tree and collect indentation for parent-child node pairs. Indentation is not added if + // * parent and child nodes start on the same line, or + // * parent is an IfStatement and child starts on the same line as an 'else clause'. + while (parent) { + var useActualIndentation = true; + if (ignoreActualIndentationRange) { + var start = current.getStart(sourceFile); + useActualIndentation = start < ignoreActualIndentationRange.pos || start > ignoreActualIndentationRange.end; + } + var containingListOrParentStart = getContainingListOrParentStart(parent, current, sourceFile); + var parentAndChildShareLine = containingListOrParentStart.line === currentStart.line || + childStartsOnTheSameLineWithElseInIfStatement(parent, current, currentStart.line, sourceFile); + if (useActualIndentation) { + // check if current node is a list item - if yes, take indentation from it + var firstListChild = (_a = getContainingList(current, sourceFile)) === null || _a === void 0 ? void 0 : _a[0]; + // A list indents its children if the children begin on a later line than the list itself: + // + // f1( L0 - List start + // { L1 - First child start: indented, along with all other children + // prop: 0 + // }, + // { + // prop: 1 + // } + // ) + // + // f2({ L0 - List start and first child start: children are not indented. + // prop: 0 Object properties are indented only one level, because the list + // }, { itself contributes nothing. + // prop: 1 L3 - The indentation of the second object literal is best understood by + // }) looking at the relationship between the list and *first* list item. + var listIndentsChild = !!firstListChild && getStartLineAndCharacterForNode(firstListChild, sourceFile).line > containingListOrParentStart.line; + var actualIndentation = getActualIndentationForListItem(current, sourceFile, options, listIndentsChild); + if (actualIndentation !== -1 /* Value.Unknown */) { + return actualIndentation + indentationDelta; + } + // try to fetch actual indentation for current node from source text + actualIndentation = getActualIndentationForNode(current, parent, currentStart, parentAndChildShareLine, sourceFile, options); + if (actualIndentation !== -1 /* Value.Unknown */) { + return actualIndentation + indentationDelta; + } + } + // increase indentation if parent node wants its content to be indented and parent and child nodes don't start on the same line + if (shouldIndentChildNode(options, parent, current, sourceFile, isNextChild) && !parentAndChildShareLine) { + indentationDelta += options.indentSize; + } + // In our AST, a call argument's `parent` is the call-expression, not the argument list. + // We would like to increase indentation based on the relationship between an argument and its argument-list, + // so we spoof the starting position of the (parent) call-expression to match the (non-parent) argument-list. + // But, the spoofed start-value could then cause a problem when comparing the start position of the call-expression + // to *its* parent (in the case of an iife, an expression statement), adding an extra level of indentation. + // + // Instead, when at an argument, we unspoof the starting position of the enclosing call expression + // *after* applying indentation for the argument. + var useTrueStart = isArgumentAndStartLineOverlapsExpressionBeingCalled(parent, current, currentStart.line, sourceFile); + current = parent; + parent = current.parent; + currentStart = useTrueStart ? sourceFile.getLineAndCharacterOfPosition(current.getStart(sourceFile)) : containingListOrParentStart; + } + return indentationDelta + getBaseIndentation(options); + } + function getContainingListOrParentStart(parent, child, sourceFile) { + var containingList = getContainingList(child, sourceFile); + var startPos = containingList ? containingList.pos : parent.getStart(sourceFile); + return sourceFile.getLineAndCharacterOfPosition(startPos); + } + /* + * Function returns Value.Unknown if indentation cannot be determined + */ + function getActualIndentationForListItemBeforeComma(commaToken, sourceFile, options) { + // previous token is comma that separates items in list - find the previous item and try to derive indentation from it + var commaItemInfo = ts.findListItemInfo(commaToken); + if (commaItemInfo && commaItemInfo.listItemIndex > 0) { + return deriveActualIndentationFromList(commaItemInfo.list.getChildren(), commaItemInfo.listItemIndex - 1, sourceFile, options); + } + else { + // handle broken code gracefully + return -1 /* Value.Unknown */; + } + } + /* + * Function returns Value.Unknown if actual indentation for node should not be used (i.e because node is nested expression) + */ + function getActualIndentationForNode(current, parent, currentLineAndChar, parentAndChildShareLine, sourceFile, options) { + // actual indentation is used for statements\declarations if one of cases below is true: + // - parent is SourceFile - by default immediate children of SourceFile are not indented except when user indents them manually + // - parent and child are not on the same line + var useActualIndentation = (ts.isDeclaration(current) || ts.isStatementButNotDeclaration(current)) && + (parent.kind === 308 /* SyntaxKind.SourceFile */ || !parentAndChildShareLine); + if (!useActualIndentation) { + return -1 /* Value.Unknown */; + } + return findColumnForFirstNonWhitespaceCharacterInLine(currentLineAndChar, sourceFile, options); + } + var NextTokenKind; + (function (NextTokenKind) { + NextTokenKind[NextTokenKind["Unknown"] = 0] = "Unknown"; + NextTokenKind[NextTokenKind["OpenBrace"] = 1] = "OpenBrace"; + NextTokenKind[NextTokenKind["CloseBrace"] = 2] = "CloseBrace"; + })(NextTokenKind || (NextTokenKind = {})); + function nextTokenIsCurlyBraceOnSameLineAsCursor(precedingToken, current, lineAtPosition, sourceFile) { + var nextToken = ts.findNextToken(precedingToken, current, sourceFile); + if (!nextToken) { + return 0 /* NextTokenKind.Unknown */; + } + if (nextToken.kind === 18 /* SyntaxKind.OpenBraceToken */) { + // open braces are always indented at the parent level + return 1 /* NextTokenKind.OpenBrace */; + } + else if (nextToken.kind === 19 /* SyntaxKind.CloseBraceToken */) { + // close braces are indented at the parent level if they are located on the same line with cursor + // this means that if new line will be added at $ position, this case will be indented + // class A { + // $ + // } + /// and this one - not + // class A { + // $} + var nextTokenStartLine = getStartLineAndCharacterForNode(nextToken, sourceFile).line; + return lineAtPosition === nextTokenStartLine ? 2 /* NextTokenKind.CloseBrace */ : 0 /* NextTokenKind.Unknown */; + } + return 0 /* NextTokenKind.Unknown */; + } + function getStartLineAndCharacterForNode(n, sourceFile) { + return sourceFile.getLineAndCharacterOfPosition(n.getStart(sourceFile)); + } + function isArgumentAndStartLineOverlapsExpressionBeingCalled(parent, child, childStartLine, sourceFile) { + if (!(ts.isCallExpression(parent) && ts.contains(parent.arguments, child))) { + return false; + } + var expressionOfCallExpressionEnd = parent.expression.getEnd(); + var expressionOfCallExpressionEndLine = ts.getLineAndCharacterOfPosition(sourceFile, expressionOfCallExpressionEnd).line; + return expressionOfCallExpressionEndLine === childStartLine; + } + SmartIndenter.isArgumentAndStartLineOverlapsExpressionBeingCalled = isArgumentAndStartLineOverlapsExpressionBeingCalled; + function childStartsOnTheSameLineWithElseInIfStatement(parent, child, childStartLine, sourceFile) { + if (parent.kind === 242 /* SyntaxKind.IfStatement */ && parent.elseStatement === child) { + var elseKeyword = ts.findChildOfKind(parent, 91 /* SyntaxKind.ElseKeyword */, sourceFile); + ts.Debug.assert(elseKeyword !== undefined); + var elseKeywordStartLine = getStartLineAndCharacterForNode(elseKeyword, sourceFile).line; + return elseKeywordStartLine === childStartLine; + } + return false; + } + SmartIndenter.childStartsOnTheSameLineWithElseInIfStatement = childStartsOnTheSameLineWithElseInIfStatement; + // A multiline conditional typically increases the indentation of its whenTrue and whenFalse children: + // + // condition + // ? whenTrue + // : whenFalse; + // + // However, that indentation does not apply if the subexpressions themselves span multiple lines, + // applying their own indentation: + // + // (() => { + // return complexCalculationForCondition(); + // })() ? { + // whenTrue: 'multiline object literal' + // } : ( + // whenFalse('multiline parenthesized expression') + // ); + // + // In these cases, we must discard the indentation increase that would otherwise be applied to the + // whenTrue and whenFalse children to avoid double-indenting their contents. To identify this scenario, + // we check for the whenTrue branch beginning on the line that the condition ends, and the whenFalse + // branch beginning on the line that the whenTrue branch ends. + function childIsUnindentedBranchOfConditionalExpression(parent, child, childStartLine, sourceFile) { + if (ts.isConditionalExpression(parent) && (child === parent.whenTrue || child === parent.whenFalse)) { + var conditionEndLine = ts.getLineAndCharacterOfPosition(sourceFile, parent.condition.end).line; + if (child === parent.whenTrue) { + return childStartLine === conditionEndLine; + } + else { + // On the whenFalse side, we have to look at the whenTrue side, because if that one was + // indented, whenFalse must also be indented: + // + // const y = true + // ? 1 : ( L1: whenTrue indented because it's on a new line + // 0 L2: indented two stops, one because whenTrue was indented + // ); and one because of the parentheses spanning multiple lines + var trueStartLine = getStartLineAndCharacterForNode(parent.whenTrue, sourceFile).line; + var trueEndLine = ts.getLineAndCharacterOfPosition(sourceFile, parent.whenTrue.end).line; + return conditionEndLine === trueStartLine && trueEndLine === childStartLine; + } + } + return false; + } + SmartIndenter.childIsUnindentedBranchOfConditionalExpression = childIsUnindentedBranchOfConditionalExpression; + function argumentStartsOnSameLineAsPreviousArgument(parent, child, childStartLine, sourceFile) { + if (ts.isCallOrNewExpression(parent)) { + if (!parent.arguments) + return false; + var currentNode = ts.find(parent.arguments, function (arg) { return arg.pos === child.pos; }); + // If it's not one of the arguments, don't look past this + if (!currentNode) + return false; + var currentIndex = parent.arguments.indexOf(currentNode); + if (currentIndex === 0) + return false; // Can't look at previous node if first + var previousNode = parent.arguments[currentIndex - 1]; + var lineOfPreviousNode = ts.getLineAndCharacterOfPosition(sourceFile, previousNode.getEnd()).line; + if (childStartLine === lineOfPreviousNode) { + return true; + } + } + return false; + } + SmartIndenter.argumentStartsOnSameLineAsPreviousArgument = argumentStartsOnSameLineAsPreviousArgument; + function getContainingList(node, sourceFile) { + return node.parent && getListByRange(node.getStart(sourceFile), node.getEnd(), node.parent, sourceFile); + } + SmartIndenter.getContainingList = getContainingList; + function getListByPosition(pos, node, sourceFile) { + return node && getListByRange(pos, pos, node, sourceFile); + } + function getListByRange(start, end, node, sourceFile) { + switch (node.kind) { + case 180 /* SyntaxKind.TypeReference */: + return getList(node.typeArguments); + case 207 /* SyntaxKind.ObjectLiteralExpression */: + return getList(node.properties); + case 206 /* SyntaxKind.ArrayLiteralExpression */: + return getList(node.elements); + case 184 /* SyntaxKind.TypeLiteral */: + return getList(node.members); + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + case 176 /* SyntaxKind.CallSignature */: + case 173 /* SyntaxKind.Constructor */: + case 182 /* SyntaxKind.ConstructorType */: + case 177 /* SyntaxKind.ConstructSignature */: + return getList(node.typeParameters) || getList(node.parameters); + case 174 /* SyntaxKind.GetAccessor */: + return getList(node.parameters); + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 347 /* SyntaxKind.JSDocTemplateTag */: + return getList(node.typeParameters); + case 211 /* SyntaxKind.NewExpression */: + case 210 /* SyntaxKind.CallExpression */: + return getList(node.typeArguments) || getList(node.arguments); + case 258 /* SyntaxKind.VariableDeclarationList */: + return getList(node.declarations); + case 272 /* SyntaxKind.NamedImports */: + case 276 /* SyntaxKind.NamedExports */: + return getList(node.elements); + case 203 /* SyntaxKind.ObjectBindingPattern */: + case 204 /* SyntaxKind.ArrayBindingPattern */: + return getList(node.elements); + } + function getList(list) { + return list && ts.rangeContainsStartEnd(getVisualListRange(node, list, sourceFile), start, end) ? list : undefined; + } + } + function getVisualListRange(node, list, sourceFile) { + var children = node.getChildren(sourceFile); + for (var i = 1; i < children.length - 1; i++) { + if (children[i].pos === list.pos && children[i].end === list.end) { + return { pos: children[i - 1].end, end: children[i + 1].getStart(sourceFile) }; + } + } + return list; + } + function getActualIndentationForListStartLine(list, sourceFile, options) { + if (!list) { + return -1 /* Value.Unknown */; + } + return findColumnForFirstNonWhitespaceCharacterInLine(sourceFile.getLineAndCharacterOfPosition(list.pos), sourceFile, options); + } + function getActualIndentationForListItem(node, sourceFile, options, listIndentsChild) { + if (node.parent && node.parent.kind === 258 /* SyntaxKind.VariableDeclarationList */) { + // VariableDeclarationList has no wrapping tokens + return -1 /* Value.Unknown */; + } + var containingList = getContainingList(node, sourceFile); + if (containingList) { + var index = containingList.indexOf(node); + if (index !== -1) { + var result = deriveActualIndentationFromList(containingList, index, sourceFile, options); + if (result !== -1 /* Value.Unknown */) { + return result; + } + } + return getActualIndentationForListStartLine(containingList, sourceFile, options) + (listIndentsChild ? options.indentSize : 0); // TODO: GH#18217 + } + return -1 /* Value.Unknown */; + } + function deriveActualIndentationFromList(list, index, sourceFile, options) { + ts.Debug.assert(index >= 0 && index < list.length); + var node = list[index]; + // walk toward the start of the list starting from current node and check if the line is the same for all items. + // if end line for item [i - 1] differs from the start line for item [i] - find column of the first non-whitespace character on the line of item [i] + var lineAndCharacter = getStartLineAndCharacterForNode(node, sourceFile); + for (var i = index - 1; i >= 0; i--) { + if (list[i].kind === 27 /* SyntaxKind.CommaToken */) { + continue; + } + // skip list items that ends on the same line with the current list element + var prevEndLine = sourceFile.getLineAndCharacterOfPosition(list[i].end).line; + if (prevEndLine !== lineAndCharacter.line) { + return findColumnForFirstNonWhitespaceCharacterInLine(lineAndCharacter, sourceFile, options); + } + lineAndCharacter = getStartLineAndCharacterForNode(list[i], sourceFile); + } + return -1 /* Value.Unknown */; + } + function findColumnForFirstNonWhitespaceCharacterInLine(lineAndCharacter, sourceFile, options) { + var lineStart = sourceFile.getPositionOfLineAndCharacter(lineAndCharacter.line, 0); + return findFirstNonWhitespaceColumn(lineStart, lineStart + lineAndCharacter.character, sourceFile, options); + } + /** + * Character is the actual index of the character since the beginning of the line. + * Column - position of the character after expanding tabs to spaces. + * "0\t2$" + * value of 'character' for '$' is 3 + * value of 'column' for '$' is 6 (assuming that tab size is 4) + */ + function findFirstNonWhitespaceCharacterAndColumn(startPos, endPos, sourceFile, options) { + var character = 0; + var column = 0; + for (var pos = startPos; pos < endPos; pos++) { + var ch = sourceFile.text.charCodeAt(pos); + if (!ts.isWhiteSpaceSingleLine(ch)) { + break; + } + if (ch === 9 /* CharacterCodes.tab */) { + column += options.tabSize + (column % options.tabSize); + } + else { + column++; + } + character++; + } + return { column: column, character: character }; + } + SmartIndenter.findFirstNonWhitespaceCharacterAndColumn = findFirstNonWhitespaceCharacterAndColumn; + function findFirstNonWhitespaceColumn(startPos, endPos, sourceFile, options) { + return findFirstNonWhitespaceCharacterAndColumn(startPos, endPos, sourceFile, options).column; + } + SmartIndenter.findFirstNonWhitespaceColumn = findFirstNonWhitespaceColumn; + function nodeWillIndentChild(settings, parent, child, sourceFile, indentByDefault) { + var childKind = child ? child.kind : 0 /* SyntaxKind.Unknown */; + switch (parent.kind) { + case 241 /* SyntaxKind.ExpressionStatement */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 206 /* SyntaxKind.ArrayLiteralExpression */: + case 238 /* SyntaxKind.Block */: + case 265 /* SyntaxKind.ModuleBlock */: + case 207 /* SyntaxKind.ObjectLiteralExpression */: + case 184 /* SyntaxKind.TypeLiteral */: + case 197 /* SyntaxKind.MappedType */: + case 186 /* SyntaxKind.TupleType */: + case 266 /* SyntaxKind.CaseBlock */: + case 293 /* SyntaxKind.DefaultClause */: + case 292 /* SyntaxKind.CaseClause */: + case 214 /* SyntaxKind.ParenthesizedExpression */: + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 210 /* SyntaxKind.CallExpression */: + case 211 /* SyntaxKind.NewExpression */: + case 240 /* SyntaxKind.VariableStatement */: + case 274 /* SyntaxKind.ExportAssignment */: + case 250 /* SyntaxKind.ReturnStatement */: + case 224 /* SyntaxKind.ConditionalExpression */: + case 204 /* SyntaxKind.ArrayBindingPattern */: + case 203 /* SyntaxKind.ObjectBindingPattern */: + case 283 /* SyntaxKind.JsxOpeningElement */: + case 286 /* SyntaxKind.JsxOpeningFragment */: + case 282 /* SyntaxKind.JsxSelfClosingElement */: + case 291 /* SyntaxKind.JsxExpression */: + case 170 /* SyntaxKind.MethodSignature */: + case 176 /* SyntaxKind.CallSignature */: + case 177 /* SyntaxKind.ConstructSignature */: + case 166 /* SyntaxKind.Parameter */: + case 181 /* SyntaxKind.FunctionType */: + case 182 /* SyntaxKind.ConstructorType */: + case 193 /* SyntaxKind.ParenthesizedType */: + case 212 /* SyntaxKind.TaggedTemplateExpression */: + case 220 /* SyntaxKind.AwaitExpression */: + case 276 /* SyntaxKind.NamedExports */: + case 272 /* SyntaxKind.NamedImports */: + case 278 /* SyntaxKind.ExportSpecifier */: + case 273 /* SyntaxKind.ImportSpecifier */: + case 169 /* SyntaxKind.PropertyDeclaration */: + return true; + case 257 /* SyntaxKind.VariableDeclaration */: + case 299 /* SyntaxKind.PropertyAssignment */: + case 223 /* SyntaxKind.BinaryExpression */: + if (!settings.indentMultiLineObjectLiteralBeginningOnBlankLine && sourceFile && childKind === 207 /* SyntaxKind.ObjectLiteralExpression */) { // TODO: GH#18217 + return rangeIsOnOneLine(sourceFile, child); + } + if (parent.kind === 223 /* SyntaxKind.BinaryExpression */ && sourceFile && child && childKind === 281 /* SyntaxKind.JsxElement */) { + var parentStartLine = sourceFile.getLineAndCharacterOfPosition(ts.skipTrivia(sourceFile.text, parent.pos)).line; + var childStartLine = sourceFile.getLineAndCharacterOfPosition(ts.skipTrivia(sourceFile.text, child.pos)).line; + return parentStartLine !== childStartLine; + } + if (parent.kind !== 223 /* SyntaxKind.BinaryExpression */) { + return true; + } + break; + case 243 /* SyntaxKind.DoStatement */: + case 244 /* SyntaxKind.WhileStatement */: + case 246 /* SyntaxKind.ForInStatement */: + case 247 /* SyntaxKind.ForOfStatement */: + case 245 /* SyntaxKind.ForStatement */: + case 242 /* SyntaxKind.IfStatement */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 173 /* SyntaxKind.Constructor */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + return childKind !== 238 /* SyntaxKind.Block */; + case 216 /* SyntaxKind.ArrowFunction */: + if (sourceFile && childKind === 214 /* SyntaxKind.ParenthesizedExpression */) { + return rangeIsOnOneLine(sourceFile, child); + } + return childKind !== 238 /* SyntaxKind.Block */; + case 275 /* SyntaxKind.ExportDeclaration */: + return childKind !== 276 /* SyntaxKind.NamedExports */; + case 269 /* SyntaxKind.ImportDeclaration */: + return childKind !== 270 /* SyntaxKind.ImportClause */ || + (!!child.namedBindings && child.namedBindings.kind !== 272 /* SyntaxKind.NamedImports */); + case 281 /* SyntaxKind.JsxElement */: + return childKind !== 284 /* SyntaxKind.JsxClosingElement */; + case 285 /* SyntaxKind.JsxFragment */: + return childKind !== 287 /* SyntaxKind.JsxClosingFragment */; + case 190 /* SyntaxKind.IntersectionType */: + case 189 /* SyntaxKind.UnionType */: + if (childKind === 184 /* SyntaxKind.TypeLiteral */ || childKind === 186 /* SyntaxKind.TupleType */) { + return false; + } + break; + } + // No explicit rule for given nodes so the result will follow the default value argument + return indentByDefault; + } + SmartIndenter.nodeWillIndentChild = nodeWillIndentChild; + function isControlFlowEndingStatement(kind, parent) { + switch (kind) { + case 250 /* SyntaxKind.ReturnStatement */: + case 254 /* SyntaxKind.ThrowStatement */: + case 248 /* SyntaxKind.ContinueStatement */: + case 249 /* SyntaxKind.BreakStatement */: + return parent.kind !== 238 /* SyntaxKind.Block */; + default: + return false; + } + } + /** + * True when the parent node should indent the given child by an explicit rule. + * @param isNextChild If true, we are judging indent of a hypothetical child *after* this one, not the current child. + */ + function shouldIndentChildNode(settings, parent, child, sourceFile, isNextChild) { + if (isNextChild === void 0) { isNextChild = false; } + return nodeWillIndentChild(settings, parent, child, sourceFile, /*indentByDefault*/ false) + && !(isNextChild && child && isControlFlowEndingStatement(child.kind, parent)); + } + SmartIndenter.shouldIndentChildNode = shouldIndentChildNode; + function rangeIsOnOneLine(sourceFile, range) { + var rangeStart = ts.skipTrivia(sourceFile.text, range.pos); + var startLine = sourceFile.getLineAndCharacterOfPosition(rangeStart).line; + var endLine = sourceFile.getLineAndCharacterOfPosition(range.end).line; + return startLine === endLine; + } + })(SmartIndenter = formatting.SmartIndenter || (formatting.SmartIndenter = {})); + })(formatting = ts.formatting || (ts.formatting = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var textChanges; + (function (textChanges_3) { + /** + * Currently for simplicity we store recovered positions on the node itself. + * It can be changed to side-table later if we decide that current design is too invasive. + */ + function getPos(n) { + var result = n.__pos; + ts.Debug.assert(typeof result === "number"); + return result; + } + function setPos(n, pos) { + ts.Debug.assert(typeof pos === "number"); + n.__pos = pos; + } + function getEnd(n) { + var result = n.__end; + ts.Debug.assert(typeof result === "number"); + return result; + } + function setEnd(n, end) { + ts.Debug.assert(typeof end === "number"); + n.__end = end; + } + var LeadingTriviaOption; + (function (LeadingTriviaOption) { + /** Exclude all leading trivia (use getStart()) */ + LeadingTriviaOption[LeadingTriviaOption["Exclude"] = 0] = "Exclude"; + /** Include leading trivia and, + * if there are no line breaks between the node and the previous token, + * include all trivia between the node and the previous token + */ + LeadingTriviaOption[LeadingTriviaOption["IncludeAll"] = 1] = "IncludeAll"; + /** + * Include attached JSDoc comments + */ + LeadingTriviaOption[LeadingTriviaOption["JSDoc"] = 2] = "JSDoc"; + /** + * Only delete trivia on the same line as getStart(). + * Used to avoid deleting leading comments + */ + LeadingTriviaOption[LeadingTriviaOption["StartLine"] = 3] = "StartLine"; + })(LeadingTriviaOption = textChanges_3.LeadingTriviaOption || (textChanges_3.LeadingTriviaOption = {})); + var TrailingTriviaOption; + (function (TrailingTriviaOption) { + /** Exclude all trailing trivia (use getEnd()) */ + TrailingTriviaOption[TrailingTriviaOption["Exclude"] = 0] = "Exclude"; + /** Doesn't include whitespace, but does strip comments */ + TrailingTriviaOption[TrailingTriviaOption["ExcludeWhitespace"] = 1] = "ExcludeWhitespace"; + /** Include trailing trivia */ + TrailingTriviaOption[TrailingTriviaOption["Include"] = 2] = "Include"; + })(TrailingTriviaOption = textChanges_3.TrailingTriviaOption || (textChanges_3.TrailingTriviaOption = {})); + function skipWhitespacesAndLineBreaks(text, start) { + return ts.skipTrivia(text, start, /*stopAfterLineBreak*/ false, /*stopAtComments*/ true); + } + function hasCommentsBeforeLineBreak(text, start) { + var i = start; + while (i < text.length) { + var ch = text.charCodeAt(i); + if (ts.isWhiteSpaceSingleLine(ch)) { + i++; + continue; + } + return ch === 47 /* CharacterCodes.slash */; + } + return false; + } + var useNonAdjustedPositions = { + leadingTriviaOption: LeadingTriviaOption.Exclude, + trailingTriviaOption: TrailingTriviaOption.Exclude, + }; + var ChangeKind; + (function (ChangeKind) { + ChangeKind[ChangeKind["Remove"] = 0] = "Remove"; + ChangeKind[ChangeKind["ReplaceWithSingleNode"] = 1] = "ReplaceWithSingleNode"; + ChangeKind[ChangeKind["ReplaceWithMultipleNodes"] = 2] = "ReplaceWithMultipleNodes"; + ChangeKind[ChangeKind["Text"] = 3] = "Text"; + })(ChangeKind || (ChangeKind = {})); + function getAdjustedRange(sourceFile, startNode, endNode, options) { + return { pos: getAdjustedStartPosition(sourceFile, startNode, options), end: getAdjustedEndPosition(sourceFile, endNode, options) }; + } + function getAdjustedStartPosition(sourceFile, node, options, hasTrailingComment) { + var _a, _b; + if (hasTrailingComment === void 0) { hasTrailingComment = false; } + var leadingTriviaOption = options.leadingTriviaOption; + if (leadingTriviaOption === LeadingTriviaOption.Exclude) { + return node.getStart(sourceFile); + } + if (leadingTriviaOption === LeadingTriviaOption.StartLine) { + var startPos = node.getStart(sourceFile); + var pos = ts.getLineStartPositionForPosition(startPos, sourceFile); + return ts.rangeContainsPosition(node, pos) ? pos : startPos; + } + if (leadingTriviaOption === LeadingTriviaOption.JSDoc) { + var JSDocComments = ts.getJSDocCommentRanges(node, sourceFile.text); + if (JSDocComments === null || JSDocComments === void 0 ? void 0 : JSDocComments.length) { + return ts.getLineStartPositionForPosition(JSDocComments[0].pos, sourceFile); + } + } + var fullStart = node.getFullStart(); + var start = node.getStart(sourceFile); + if (fullStart === start) { + return start; + } + var fullStartLine = ts.getLineStartPositionForPosition(fullStart, sourceFile); + var startLine = ts.getLineStartPositionForPosition(start, sourceFile); + if (startLine === fullStartLine) { + // full start and start of the node are on the same line + // a, b; + // ^ ^ + // | start + // fullstart + // when b is replaced - we usually want to keep the leading trvia + // when b is deleted - we delete it + return leadingTriviaOption === LeadingTriviaOption.IncludeAll ? fullStart : start; + } + // if node has a trailing comments, use comment end position as the text has already been included. + if (hasTrailingComment) { + // Check first for leading comments as if the node is the first import, we want to exclude the trivia; + // otherwise we get the trailing comments. + var comment = ((_a = ts.getLeadingCommentRanges(sourceFile.text, fullStart)) === null || _a === void 0 ? void 0 : _a[0]) || ((_b = ts.getTrailingCommentRanges(sourceFile.text, fullStart)) === null || _b === void 0 ? void 0 : _b[0]); + if (comment) { + return ts.skipTrivia(sourceFile.text, comment.end, /*stopAfterLineBreak*/ true, /*stopAtComments*/ true); + } + } + // get start position of the line following the line that contains fullstart position + // (but only if the fullstart isn't the very beginning of the file) + var nextLineStart = fullStart > 0 ? 1 : 0; + var adjustedStartPosition = ts.getStartPositionOfLine(ts.getLineOfLocalPosition(sourceFile, fullStartLine) + nextLineStart, sourceFile); + // skip whitespaces/newlines + adjustedStartPosition = skipWhitespacesAndLineBreaks(sourceFile.text, adjustedStartPosition); + return ts.getStartPositionOfLine(ts.getLineOfLocalPosition(sourceFile, adjustedStartPosition), sourceFile); + } + /** Return the end position of a multiline comment of it is on another line; otherwise returns `undefined`; */ + function getEndPositionOfMultilineTrailingComment(sourceFile, node, options) { + var end = node.end; + var trailingTriviaOption = options.trailingTriviaOption; + if (trailingTriviaOption === TrailingTriviaOption.Include) { + // If the trailing comment is a multiline comment that extends to the next lines, + // return the end of the comment and track it for the next nodes to adjust. + var comments = ts.getTrailingCommentRanges(sourceFile.text, end); + if (comments) { + var nodeEndLine = ts.getLineOfLocalPosition(sourceFile, node.end); + for (var _i = 0, comments_2 = comments; _i < comments_2.length; _i++) { + var comment = comments_2[_i]; + // Single line can break the loop as trivia will only be this line. + // Comments on subsequest lines are also ignored. + if (comment.kind === 2 /* SyntaxKind.SingleLineCommentTrivia */ || ts.getLineOfLocalPosition(sourceFile, comment.pos) > nodeEndLine) { + break; + } + // Get the end line of the comment and compare against the end line of the node. + // If the comment end line position and the multiline comment extends to multiple lines, + // then is safe to return the end position. + var commentEndLine = ts.getLineOfLocalPosition(sourceFile, comment.end); + if (commentEndLine > nodeEndLine) { + return ts.skipTrivia(sourceFile.text, comment.end, /*stopAfterLineBreak*/ true, /*stopAtComments*/ true); + } + } + } + } + return undefined; + } + function getAdjustedEndPosition(sourceFile, node, options) { + var _a; + var end = node.end; + var trailingTriviaOption = options.trailingTriviaOption; + if (trailingTriviaOption === TrailingTriviaOption.Exclude) { + return end; + } + if (trailingTriviaOption === TrailingTriviaOption.ExcludeWhitespace) { + var comments = ts.concatenate(ts.getTrailingCommentRanges(sourceFile.text, end), ts.getLeadingCommentRanges(sourceFile.text, end)); + var realEnd = (_a = comments === null || comments === void 0 ? void 0 : comments[comments.length - 1]) === null || _a === void 0 ? void 0 : _a.end; + if (realEnd) { + return realEnd; + } + return end; + } + var multilineEndPosition = getEndPositionOfMultilineTrailingComment(sourceFile, node, options); + if (multilineEndPosition) { + return multilineEndPosition; + } + var newEnd = ts.skipTrivia(sourceFile.text, end, /*stopAfterLineBreak*/ true); + return newEnd !== end && (trailingTriviaOption === TrailingTriviaOption.Include || ts.isLineBreak(sourceFile.text.charCodeAt(newEnd - 1))) + ? newEnd + : end; + } + /** + * Checks if 'candidate' argument is a legal separator in the list that contains 'node' as an element + */ + function isSeparator(node, candidate) { + return !!candidate && !!node.parent && (candidate.kind === 27 /* SyntaxKind.CommaToken */ || (candidate.kind === 26 /* SyntaxKind.SemicolonToken */ && node.parent.kind === 207 /* SyntaxKind.ObjectLiteralExpression */)); + } + function isThisTypeAnnotatable(containingFunction) { + return ts.isFunctionExpression(containingFunction) || ts.isFunctionDeclaration(containingFunction); + } + textChanges_3.isThisTypeAnnotatable = isThisTypeAnnotatable; + var ChangeTracker = /** @class */ (function () { + /** Public for tests only. Other callers should use `ChangeTracker.with`. */ + function ChangeTracker(newLineCharacter, formatContext) { + this.newLineCharacter = newLineCharacter; + this.formatContext = formatContext; + this.changes = []; + this.newFiles = []; + this.classesWithNodesInsertedAtStart = new ts.Map(); // Set implemented as Map + this.deletedNodes = []; + } + ChangeTracker.fromContext = function (context) { + return new ChangeTracker(ts.getNewLineOrDefaultFromHost(context.host, context.formatContext.options), context.formatContext); + }; + ChangeTracker.with = function (context, cb) { + var tracker = ChangeTracker.fromContext(context); + cb(tracker); + return tracker.getChanges(); + }; + ChangeTracker.prototype.pushRaw = function (sourceFile, change) { + ts.Debug.assertEqual(sourceFile.fileName, change.fileName); + for (var _i = 0, _a = change.textChanges; _i < _a.length; _i++) { + var c = _a[_i]; + this.changes.push({ + kind: ChangeKind.Text, + sourceFile: sourceFile, + text: c.newText, + range: ts.createTextRangeFromSpan(c.span), + }); + } + }; + ChangeTracker.prototype.deleteRange = function (sourceFile, range) { + this.changes.push({ kind: ChangeKind.Remove, sourceFile: sourceFile, range: range }); + }; + ChangeTracker.prototype.delete = function (sourceFile, node) { + this.deletedNodes.push({ sourceFile: sourceFile, node: node }); + }; + /** Stop! Consider using `delete` instead, which has logic for deleting nodes from delimited lists. */ + ChangeTracker.prototype.deleteNode = function (sourceFile, node, options) { + if (options === void 0) { options = { leadingTriviaOption: LeadingTriviaOption.IncludeAll }; } + this.deleteRange(sourceFile, getAdjustedRange(sourceFile, node, node, options)); + }; + ChangeTracker.prototype.deleteNodes = function (sourceFile, nodes, options, hasTrailingComment) { + if (options === void 0) { options = { leadingTriviaOption: LeadingTriviaOption.IncludeAll }; } + // When deleting multiple nodes we need to track if the end position is including multiline trailing comments. + for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) { + var node = nodes_1[_i]; + var pos = getAdjustedStartPosition(sourceFile, node, options, hasTrailingComment); + var end = getAdjustedEndPosition(sourceFile, node, options); + this.deleteRange(sourceFile, { pos: pos, end: end }); + hasTrailingComment = !!getEndPositionOfMultilineTrailingComment(sourceFile, node, options); + } + }; + ChangeTracker.prototype.deleteModifier = function (sourceFile, modifier) { + this.deleteRange(sourceFile, { pos: modifier.getStart(sourceFile), end: ts.skipTrivia(sourceFile.text, modifier.end, /*stopAfterLineBreak*/ true) }); + }; + ChangeTracker.prototype.deleteNodeRange = function (sourceFile, startNode, endNode, options) { + if (options === void 0) { options = { leadingTriviaOption: LeadingTriviaOption.IncludeAll }; } + var startPosition = getAdjustedStartPosition(sourceFile, startNode, options); + var endPosition = getAdjustedEndPosition(sourceFile, endNode, options); + this.deleteRange(sourceFile, { pos: startPosition, end: endPosition }); + }; + ChangeTracker.prototype.deleteNodeRangeExcludingEnd = function (sourceFile, startNode, afterEndNode, options) { + if (options === void 0) { options = { leadingTriviaOption: LeadingTriviaOption.IncludeAll }; } + var startPosition = getAdjustedStartPosition(sourceFile, startNode, options); + var endPosition = afterEndNode === undefined ? sourceFile.text.length : getAdjustedStartPosition(sourceFile, afterEndNode, options); + this.deleteRange(sourceFile, { pos: startPosition, end: endPosition }); + }; + ChangeTracker.prototype.replaceRange = function (sourceFile, range, newNode, options) { + if (options === void 0) { options = {}; } + this.changes.push({ kind: ChangeKind.ReplaceWithSingleNode, sourceFile: sourceFile, range: range, options: options, node: newNode }); + }; + ChangeTracker.prototype.replaceNode = function (sourceFile, oldNode, newNode, options) { + if (options === void 0) { options = useNonAdjustedPositions; } + this.replaceRange(sourceFile, getAdjustedRange(sourceFile, oldNode, oldNode, options), newNode, options); + }; + ChangeTracker.prototype.replaceNodeRange = function (sourceFile, startNode, endNode, newNode, options) { + if (options === void 0) { options = useNonAdjustedPositions; } + this.replaceRange(sourceFile, getAdjustedRange(sourceFile, startNode, endNode, options), newNode, options); + }; + ChangeTracker.prototype.replaceRangeWithNodes = function (sourceFile, range, newNodes, options) { + if (options === void 0) { options = {}; } + this.changes.push({ kind: ChangeKind.ReplaceWithMultipleNodes, sourceFile: sourceFile, range: range, options: options, nodes: newNodes }); + }; + ChangeTracker.prototype.replaceNodeWithNodes = function (sourceFile, oldNode, newNodes, options) { + if (options === void 0) { options = useNonAdjustedPositions; } + this.replaceRangeWithNodes(sourceFile, getAdjustedRange(sourceFile, oldNode, oldNode, options), newNodes, options); + }; + ChangeTracker.prototype.replaceNodeWithText = function (sourceFile, oldNode, text) { + this.replaceRangeWithText(sourceFile, getAdjustedRange(sourceFile, oldNode, oldNode, useNonAdjustedPositions), text); + }; + ChangeTracker.prototype.replaceNodeRangeWithNodes = function (sourceFile, startNode, endNode, newNodes, options) { + if (options === void 0) { options = useNonAdjustedPositions; } + this.replaceRangeWithNodes(sourceFile, getAdjustedRange(sourceFile, startNode, endNode, options), newNodes, options); + }; + ChangeTracker.prototype.nodeHasTrailingComment = function (sourceFile, oldNode, configurableEnd) { + if (configurableEnd === void 0) { configurableEnd = useNonAdjustedPositions; } + return !!getEndPositionOfMultilineTrailingComment(sourceFile, oldNode, configurableEnd); + }; + ChangeTracker.prototype.nextCommaToken = function (sourceFile, node) { + var next = ts.findNextToken(node, node.parent, sourceFile); + return next && next.kind === 27 /* SyntaxKind.CommaToken */ ? next : undefined; + }; + ChangeTracker.prototype.replacePropertyAssignment = function (sourceFile, oldNode, newNode) { + var suffix = this.nextCommaToken(sourceFile, oldNode) ? "" : ("," + this.newLineCharacter); + this.replaceNode(sourceFile, oldNode, newNode, { suffix: suffix }); + }; + ChangeTracker.prototype.insertNodeAt = function (sourceFile, pos, newNode, options) { + if (options === void 0) { options = {}; } + this.replaceRange(sourceFile, ts.createRange(pos), newNode, options); + }; + ChangeTracker.prototype.insertNodesAt = function (sourceFile, pos, newNodes, options) { + if (options === void 0) { options = {}; } + this.replaceRangeWithNodes(sourceFile, ts.createRange(pos), newNodes, options); + }; + ChangeTracker.prototype.insertNodeAtTopOfFile = function (sourceFile, newNode, blankLineBetween) { + this.insertAtTopOfFile(sourceFile, newNode, blankLineBetween); + }; + ChangeTracker.prototype.insertNodesAtTopOfFile = function (sourceFile, newNodes, blankLineBetween) { + this.insertAtTopOfFile(sourceFile, newNodes, blankLineBetween); + }; + ChangeTracker.prototype.insertAtTopOfFile = function (sourceFile, insert, blankLineBetween) { + var pos = getInsertionPositionAtSourceFileTop(sourceFile); + var options = { + prefix: pos === 0 ? undefined : this.newLineCharacter, + suffix: (ts.isLineBreak(sourceFile.text.charCodeAt(pos)) ? "" : this.newLineCharacter) + (blankLineBetween ? this.newLineCharacter : ""), + }; + if (ts.isArray(insert)) { + this.insertNodesAt(sourceFile, pos, insert, options); + } + else { + this.insertNodeAt(sourceFile, pos, insert, options); + } + }; + ChangeTracker.prototype.insertFirstParameter = function (sourceFile, parameters, newParam) { + var p0 = ts.firstOrUndefined(parameters); + if (p0) { + this.insertNodeBefore(sourceFile, p0, newParam); + } + else { + this.insertNodeAt(sourceFile, parameters.pos, newParam); + } + }; + ChangeTracker.prototype.insertNodeBefore = function (sourceFile, before, newNode, blankLineBetween, options) { + if (blankLineBetween === void 0) { blankLineBetween = false; } + if (options === void 0) { options = {}; } + this.insertNodeAt(sourceFile, getAdjustedStartPosition(sourceFile, before, options), newNode, this.getOptionsForInsertNodeBefore(before, newNode, blankLineBetween)); + }; + ChangeTracker.prototype.insertModifierAt = function (sourceFile, pos, modifier, options) { + if (options === void 0) { options = {}; } + this.insertNodeAt(sourceFile, pos, ts.factory.createToken(modifier), options); + }; + ChangeTracker.prototype.insertModifierBefore = function (sourceFile, modifier, before) { + return this.insertModifierAt(sourceFile, before.getStart(sourceFile), modifier, { suffix: " " }); + }; + ChangeTracker.prototype.insertCommentBeforeLine = function (sourceFile, lineNumber, position, commentText) { + var lineStartPosition = ts.getStartPositionOfLine(lineNumber, sourceFile); + var startPosition = ts.getFirstNonSpaceCharacterPosition(sourceFile.text, lineStartPosition); + // First try to see if we can put the comment on the previous line. + // We need to make sure that we are not in the middle of a string literal or a comment. + // If so, we do not want to separate the node from its comment if we can. + // Otherwise, add an extra new line immediately before the error span. + var insertAtLineStart = isValidLocationToAddComment(sourceFile, startPosition); + var token = ts.getTouchingToken(sourceFile, insertAtLineStart ? startPosition : position); + var indent = sourceFile.text.slice(lineStartPosition, startPosition); + var text = "".concat(insertAtLineStart ? "" : this.newLineCharacter, "//").concat(commentText).concat(this.newLineCharacter).concat(indent); + this.insertText(sourceFile, token.getStart(sourceFile), text); + }; + ChangeTracker.prototype.insertJsdocCommentBefore = function (sourceFile, node, tag) { + var fnStart = node.getStart(sourceFile); + if (node.jsDoc) { + for (var _i = 0, _a = node.jsDoc; _i < _a.length; _i++) { + var jsdoc = _a[_i]; + this.deleteRange(sourceFile, { + pos: ts.getLineStartPositionForPosition(jsdoc.getStart(sourceFile), sourceFile), + end: getAdjustedEndPosition(sourceFile, jsdoc, /*options*/ {}) + }); + } + } + var startPosition = ts.getPrecedingNonSpaceCharacterPosition(sourceFile.text, fnStart - 1); + var indent = sourceFile.text.slice(startPosition, fnStart); + this.insertNodeAt(sourceFile, fnStart, tag, { suffix: this.newLineCharacter + indent }); + }; + ChangeTracker.prototype.createJSDocText = function (sourceFile, node) { + var comments = ts.flatMap(node.jsDoc, function (jsDoc) { + return ts.isString(jsDoc.comment) ? ts.factory.createJSDocText(jsDoc.comment) : jsDoc.comment; + }); + var jsDoc = ts.singleOrUndefined(node.jsDoc); + return jsDoc && ts.positionsAreOnSameLine(jsDoc.pos, jsDoc.end, sourceFile) && ts.length(comments) === 0 ? undefined : + ts.factory.createNodeArray(ts.intersperse(comments, ts.factory.createJSDocText("\n"))); + }; + ChangeTracker.prototype.replaceJSDocComment = function (sourceFile, node, tags) { + this.insertJsdocCommentBefore(sourceFile, updateJSDocHost(node), ts.factory.createJSDocComment(this.createJSDocText(sourceFile, node), ts.factory.createNodeArray(tags))); + }; + ChangeTracker.prototype.addJSDocTags = function (sourceFile, parent, newTags) { + var oldTags = ts.flatMapToMutable(parent.jsDoc, function (j) { return j.tags; }); + var unmergedNewTags = newTags.filter(function (newTag) { return !oldTags.some(function (tag, i) { + var merged = tryMergeJsdocTags(tag, newTag); + if (merged) + oldTags[i] = merged; + return !!merged; + }); }); + this.replaceJSDocComment(sourceFile, parent, __spreadArray(__spreadArray([], oldTags, true), unmergedNewTags, true)); + }; + ChangeTracker.prototype.filterJSDocTags = function (sourceFile, parent, predicate) { + this.replaceJSDocComment(sourceFile, parent, ts.filter(ts.flatMapToMutable(parent.jsDoc, function (j) { return j.tags; }), predicate)); + }; + ChangeTracker.prototype.replaceRangeWithText = function (sourceFile, range, text) { + this.changes.push({ kind: ChangeKind.Text, sourceFile: sourceFile, range: range, text: text }); + }; + ChangeTracker.prototype.insertText = function (sourceFile, pos, text) { + this.replaceRangeWithText(sourceFile, ts.createRange(pos), text); + }; + /** Prefer this over replacing a node with another that has a type annotation, as it avoids reformatting the other parts of the node. */ + ChangeTracker.prototype.tryInsertTypeAnnotation = function (sourceFile, node, type) { + var _a; + var endNode; + if (ts.isFunctionLike(node)) { + endNode = ts.findChildOfKind(node, 21 /* SyntaxKind.CloseParenToken */, sourceFile); + if (!endNode) { + if (!ts.isArrowFunction(node)) + return false; // Function missing parentheses, give up + // If no `)`, is an arrow function `x => x`, so use the end of the first parameter + endNode = ts.first(node.parameters); + } + } + else { + endNode = (_a = (node.kind === 257 /* SyntaxKind.VariableDeclaration */ ? node.exclamationToken : node.questionToken)) !== null && _a !== void 0 ? _a : node.name; + } + this.insertNodeAt(sourceFile, endNode.end, type, { prefix: ": " }); + return true; + }; + ChangeTracker.prototype.tryInsertThisTypeAnnotation = function (sourceFile, node, type) { + var start = ts.findChildOfKind(node, 20 /* SyntaxKind.OpenParenToken */, sourceFile).getStart(sourceFile) + 1; + var suffix = node.parameters.length ? ", " : ""; + this.insertNodeAt(sourceFile, start, type, { prefix: "this: ", suffix: suffix }); + }; + ChangeTracker.prototype.insertTypeParameters = function (sourceFile, node, typeParameters) { + // If no `(`, is an arrow function `x => x`, so use the pos of the first parameter + var start = (ts.findChildOfKind(node, 20 /* SyntaxKind.OpenParenToken */, sourceFile) || ts.first(node.parameters)).getStart(sourceFile); + this.insertNodesAt(sourceFile, start, typeParameters, { prefix: "<", suffix: ">", joiner: ", " }); + }; + ChangeTracker.prototype.getOptionsForInsertNodeBefore = function (before, inserted, blankLineBetween) { + if (ts.isStatement(before) || ts.isClassElement(before)) { + return { suffix: blankLineBetween ? this.newLineCharacter + this.newLineCharacter : this.newLineCharacter }; + } + else if (ts.isVariableDeclaration(before)) { // insert `x = 1, ` into `const x = 1, y = 2; + return { suffix: ", " }; + } + else if (ts.isParameter(before)) { + return ts.isParameter(inserted) ? { suffix: ", " } : {}; + } + else if (ts.isStringLiteral(before) && ts.isImportDeclaration(before.parent) || ts.isNamedImports(before)) { + return { suffix: ", " }; + } + else if (ts.isImportSpecifier(before)) { + return { suffix: "," + (blankLineBetween ? this.newLineCharacter : " ") }; + } + return ts.Debug.failBadSyntaxKind(before); // We haven't handled this kind of node yet -- add it + }; + ChangeTracker.prototype.insertNodeAtConstructorStart = function (sourceFile, ctr, newStatement) { + var firstStatement = ts.firstOrUndefined(ctr.body.statements); + if (!firstStatement || !ctr.body.multiLine) { + this.replaceConstructorBody(sourceFile, ctr, __spreadArray([newStatement], ctr.body.statements, true)); + } + else { + this.insertNodeBefore(sourceFile, firstStatement, newStatement); + } + }; + ChangeTracker.prototype.insertNodeAtConstructorStartAfterSuperCall = function (sourceFile, ctr, newStatement) { + var superCallStatement = ts.find(ctr.body.statements, function (stmt) { return ts.isExpressionStatement(stmt) && ts.isSuperCall(stmt.expression); }); + if (!superCallStatement || !ctr.body.multiLine) { + this.replaceConstructorBody(sourceFile, ctr, __spreadArray(__spreadArray([], ctr.body.statements, true), [newStatement], false)); + } + else { + this.insertNodeAfter(sourceFile, superCallStatement, newStatement); + } + }; + ChangeTracker.prototype.insertNodeAtConstructorEnd = function (sourceFile, ctr, newStatement) { + var lastStatement = ts.lastOrUndefined(ctr.body.statements); + if (!lastStatement || !ctr.body.multiLine) { + this.replaceConstructorBody(sourceFile, ctr, __spreadArray(__spreadArray([], ctr.body.statements, true), [newStatement], false)); + } + else { + this.insertNodeAfter(sourceFile, lastStatement, newStatement); + } + }; + ChangeTracker.prototype.replaceConstructorBody = function (sourceFile, ctr, statements) { + this.replaceNode(sourceFile, ctr.body, ts.factory.createBlock(statements, /*multiLine*/ true)); + }; + ChangeTracker.prototype.insertNodeAtEndOfScope = function (sourceFile, scope, newNode) { + var pos = getAdjustedStartPosition(sourceFile, scope.getLastToken(), {}); + this.insertNodeAt(sourceFile, pos, newNode, { + prefix: ts.isLineBreak(sourceFile.text.charCodeAt(scope.getLastToken().pos)) ? this.newLineCharacter : this.newLineCharacter + this.newLineCharacter, + suffix: this.newLineCharacter + }); + }; + ChangeTracker.prototype.insertMemberAtStart = function (sourceFile, node, newElement) { + this.insertNodeAtStartWorker(sourceFile, node, newElement); + }; + ChangeTracker.prototype.insertNodeAtObjectStart = function (sourceFile, obj, newElement) { + this.insertNodeAtStartWorker(sourceFile, obj, newElement); + }; + ChangeTracker.prototype.insertNodeAtStartWorker = function (sourceFile, node, newElement) { + var _a; + var indentation = (_a = this.guessIndentationFromExistingMembers(sourceFile, node)) !== null && _a !== void 0 ? _a : this.computeIndentationForNewMember(sourceFile, node); + this.insertNodeAt(sourceFile, getMembersOrProperties(node).pos, newElement, this.getInsertNodeAtStartInsertOptions(sourceFile, node, indentation)); + }; + /** + * Tries to guess the indentation from the existing members of a class/interface/object. All members must be on + * new lines and must share the same indentation. + */ + ChangeTracker.prototype.guessIndentationFromExistingMembers = function (sourceFile, node) { + var indentation; + var lastRange = node; + for (var _i = 0, _a = getMembersOrProperties(node); _i < _a.length; _i++) { + var member = _a[_i]; + if (ts.rangeStartPositionsAreOnSameLine(lastRange, member, sourceFile)) { + // each indented member must be on a new line + return undefined; + } + var memberStart = member.getStart(sourceFile); + var memberIndentation = ts.formatting.SmartIndenter.findFirstNonWhitespaceColumn(ts.getLineStartPositionForPosition(memberStart, sourceFile), memberStart, sourceFile, this.formatContext.options); + if (indentation === undefined) { + indentation = memberIndentation; + } + else if (memberIndentation !== indentation) { + // indentation of multiple members is not consistent + return undefined; + } + lastRange = member; + } + return indentation; + }; + ChangeTracker.prototype.computeIndentationForNewMember = function (sourceFile, node) { + var _a; + var nodeStart = node.getStart(sourceFile); + return ts.formatting.SmartIndenter.findFirstNonWhitespaceColumn(ts.getLineStartPositionForPosition(nodeStart, sourceFile), nodeStart, sourceFile, this.formatContext.options) + + ((_a = this.formatContext.options.indentSize) !== null && _a !== void 0 ? _a : 4); + }; + ChangeTracker.prototype.getInsertNodeAtStartInsertOptions = function (sourceFile, node, indentation) { + // Rules: + // - Always insert leading newline. + // - For object literals: + // - Add a trailing comma if there are existing members in the node, or the source file is not a JSON file + // (because trailing commas are generally illegal in a JSON file). + // - Add a leading comma if the source file is not a JSON file, there are existing insertions, + // and the node is empty (because we didn't add a trailing comma per the previous rule). + // - Only insert a trailing newline if body is single-line and there are no other insertions for the node. + // NOTE: This is handled in `finishClassesWithNodesInsertedAtStart`. + var members = getMembersOrProperties(node); + var isEmpty = members.length === 0; + var isFirstInsertion = ts.addToSeen(this.classesWithNodesInsertedAtStart, ts.getNodeId(node), { node: node, sourceFile: sourceFile }); + var insertTrailingComma = ts.isObjectLiteralExpression(node) && (!ts.isJsonSourceFile(sourceFile) || !isEmpty); + var insertLeadingComma = ts.isObjectLiteralExpression(node) && ts.isJsonSourceFile(sourceFile) && isEmpty && !isFirstInsertion; + return { + indentation: indentation, + prefix: (insertLeadingComma ? "," : "") + this.newLineCharacter, + suffix: insertTrailingComma ? "," : ts.isInterfaceDeclaration(node) && isEmpty ? ";" : "" + }; + }; + ChangeTracker.prototype.insertNodeAfterComma = function (sourceFile, after, newNode) { + var endPosition = this.insertNodeAfterWorker(sourceFile, this.nextCommaToken(sourceFile, after) || after, newNode); + this.insertNodeAt(sourceFile, endPosition, newNode, this.getInsertNodeAfterOptions(sourceFile, after)); + }; + ChangeTracker.prototype.insertNodeAfter = function (sourceFile, after, newNode) { + var endPosition = this.insertNodeAfterWorker(sourceFile, after, newNode); + this.insertNodeAt(sourceFile, endPosition, newNode, this.getInsertNodeAfterOptions(sourceFile, after)); + }; + ChangeTracker.prototype.insertNodeAtEndOfList = function (sourceFile, list, newNode) { + this.insertNodeAt(sourceFile, list.end, newNode, { prefix: ", " }); + }; + ChangeTracker.prototype.insertNodesAfter = function (sourceFile, after, newNodes) { + var endPosition = this.insertNodeAfterWorker(sourceFile, after, ts.first(newNodes)); + this.insertNodesAt(sourceFile, endPosition, newNodes, this.getInsertNodeAfterOptions(sourceFile, after)); + }; + ChangeTracker.prototype.insertNodeAfterWorker = function (sourceFile, after, newNode) { + if (needSemicolonBetween(after, newNode)) { + // check if previous statement ends with semicolon + // if not - insert semicolon to preserve the code from changing the meaning due to ASI + if (sourceFile.text.charCodeAt(after.end - 1) !== 59 /* CharacterCodes.semicolon */) { + this.replaceRange(sourceFile, ts.createRange(after.end), ts.factory.createToken(26 /* SyntaxKind.SemicolonToken */)); + } + } + var endPosition = getAdjustedEndPosition(sourceFile, after, {}); + return endPosition; + }; + ChangeTracker.prototype.getInsertNodeAfterOptions = function (sourceFile, after) { + var options = this.getInsertNodeAfterOptionsWorker(after); + return __assign(__assign({}, options), { prefix: after.end === sourceFile.end && ts.isStatement(after) ? (options.prefix ? "\n".concat(options.prefix) : "\n") : options.prefix }); + }; + ChangeTracker.prototype.getInsertNodeAfterOptionsWorker = function (node) { + switch (node.kind) { + case 260 /* SyntaxKind.ClassDeclaration */: + case 264 /* SyntaxKind.ModuleDeclaration */: + return { prefix: this.newLineCharacter, suffix: this.newLineCharacter }; + case 257 /* SyntaxKind.VariableDeclaration */: + case 10 /* SyntaxKind.StringLiteral */: + case 79 /* SyntaxKind.Identifier */: + return { prefix: ", " }; + case 299 /* SyntaxKind.PropertyAssignment */: + return { suffix: "," + this.newLineCharacter }; + case 93 /* SyntaxKind.ExportKeyword */: + return { prefix: " " }; + case 166 /* SyntaxKind.Parameter */: + return {}; + default: + ts.Debug.assert(ts.isStatement(node) || ts.isClassOrTypeElement(node)); // Else we haven't handled this kind of node yet -- add it + return { suffix: this.newLineCharacter }; + } + }; + ChangeTracker.prototype.insertName = function (sourceFile, node, name) { + ts.Debug.assert(!node.name); + if (node.kind === 216 /* SyntaxKind.ArrowFunction */) { + var arrow = ts.findChildOfKind(node, 38 /* SyntaxKind.EqualsGreaterThanToken */, sourceFile); + var lparen = ts.findChildOfKind(node, 20 /* SyntaxKind.OpenParenToken */, sourceFile); + if (lparen) { + // `() => {}` --> `function f() {}` + this.insertNodesAt(sourceFile, lparen.getStart(sourceFile), [ts.factory.createToken(98 /* SyntaxKind.FunctionKeyword */), ts.factory.createIdentifier(name)], { joiner: " " }); + deleteNode(this, sourceFile, arrow); + } + else { + // `x => {}` -> `function f(x) {}` + this.insertText(sourceFile, ts.first(node.parameters).getStart(sourceFile), "function ".concat(name, "(")); + // Replacing full range of arrow to get rid of the leading space -- replace ` =>` with `)` + this.replaceRange(sourceFile, arrow, ts.factory.createToken(21 /* SyntaxKind.CloseParenToken */)); + } + if (node.body.kind !== 238 /* SyntaxKind.Block */) { + // `() => 0` => `function f() { return 0; }` + this.insertNodesAt(sourceFile, node.body.getStart(sourceFile), [ts.factory.createToken(18 /* SyntaxKind.OpenBraceToken */), ts.factory.createToken(105 /* SyntaxKind.ReturnKeyword */)], { joiner: " ", suffix: " " }); + this.insertNodesAt(sourceFile, node.body.end, [ts.factory.createToken(26 /* SyntaxKind.SemicolonToken */), ts.factory.createToken(19 /* SyntaxKind.CloseBraceToken */)], { joiner: " " }); + } + } + else { + var pos = ts.findChildOfKind(node, node.kind === 215 /* SyntaxKind.FunctionExpression */ ? 98 /* SyntaxKind.FunctionKeyword */ : 84 /* SyntaxKind.ClassKeyword */, sourceFile).end; + this.insertNodeAt(sourceFile, pos, ts.factory.createIdentifier(name), { prefix: " " }); + } + }; + ChangeTracker.prototype.insertExportModifier = function (sourceFile, node) { + this.insertText(sourceFile, node.getStart(sourceFile), "export "); + }; + ChangeTracker.prototype.insertImportSpecifierAtIndex = function (sourceFile, importSpecifier, namedImports, index) { + var prevSpecifier = namedImports.elements[index - 1]; + if (prevSpecifier) { + this.insertNodeInListAfter(sourceFile, prevSpecifier, importSpecifier); + } + else { + this.insertNodeBefore(sourceFile, namedImports.elements[0], importSpecifier, !ts.positionsAreOnSameLine(namedImports.elements[0].getStart(), namedImports.parent.parent.getStart(), sourceFile)); + } + }; + /** + * This function should be used to insert nodes in lists when nodes don't carry separators as the part of the node range, + * i.e. arguments in arguments lists, parameters in parameter lists etc. + * Note that separators are part of the node in statements and class elements. + */ + ChangeTracker.prototype.insertNodeInListAfter = function (sourceFile, after, newNode, containingList) { + if (containingList === void 0) { containingList = ts.formatting.SmartIndenter.getContainingList(after, sourceFile); } + if (!containingList) { + ts.Debug.fail("node is not a list element"); + return; + } + var index = ts.indexOfNode(containingList, after); + if (index < 0) { + return; + } + var end = after.getEnd(); + if (index !== containingList.length - 1) { + // any element except the last one + // use next sibling as an anchor + var nextToken = ts.getTokenAtPosition(sourceFile, after.end); + if (nextToken && isSeparator(after, nextToken)) { + // for list + // a, b, c + // create change for adding 'e' after 'a' as + // - find start of next element after a (it is b) + // - use next element start as start and end position in final change + // - build text of change by formatting the text of node + whitespace trivia of b + // in multiline case it will work as + // a, + // b, + // c, + // result - '*' denotes leading trivia that will be inserted after new text (displayed as '#') + // a, + // insertedtext# + // ###b, + // c, + var nextNode = containingList[index + 1]; + var startPos = skipWhitespacesAndLineBreaks(sourceFile.text, nextNode.getFullStart()); + // write separator and leading trivia of the next element as suffix + var suffix = "".concat(ts.tokenToString(nextToken.kind)).concat(sourceFile.text.substring(nextToken.end, startPos)); + this.insertNodesAt(sourceFile, startPos, [newNode], { suffix: suffix }); + } + } + else { + var afterStart = after.getStart(sourceFile); + var afterStartLinePosition = ts.getLineStartPositionForPosition(afterStart, sourceFile); + var separator = void 0; + var multilineList = false; + // insert element after the last element in the list that has more than one item + // pick the element preceding the after element to: + // - pick the separator + // - determine if list is a multiline + if (containingList.length === 1) { + // if list has only one element then we'll format is as multiline if node has comment in trailing trivia, or as singleline otherwise + // i.e. var x = 1 // this is x + // | new element will be inserted at this position + separator = 27 /* SyntaxKind.CommaToken */; + } + else { + // element has more than one element, pick separator from the list + var tokenBeforeInsertPosition = ts.findPrecedingToken(after.pos, sourceFile); + separator = isSeparator(after, tokenBeforeInsertPosition) ? tokenBeforeInsertPosition.kind : 27 /* SyntaxKind.CommaToken */; + // determine if list is multiline by checking lines of after element and element that precedes it. + var afterMinusOneStartLinePosition = ts.getLineStartPositionForPosition(containingList[index - 1].getStart(sourceFile), sourceFile); + multilineList = afterMinusOneStartLinePosition !== afterStartLinePosition; + } + if (hasCommentsBeforeLineBreak(sourceFile.text, after.end)) { + // in this case we'll always treat containing list as multiline + multilineList = true; + } + if (multilineList) { + // insert separator immediately following the 'after' node to preserve comments in trailing trivia + this.replaceRange(sourceFile, ts.createRange(end), ts.factory.createToken(separator)); + // use the same indentation as 'after' item + var indentation = ts.formatting.SmartIndenter.findFirstNonWhitespaceColumn(afterStartLinePosition, afterStart, sourceFile, this.formatContext.options); + // insert element before the line break on the line that contains 'after' element + var insertPos = ts.skipTrivia(sourceFile.text, end, /*stopAfterLineBreak*/ true, /*stopAtComments*/ false); + // find position before "\n" or "\r\n" + while (insertPos !== end && ts.isLineBreak(sourceFile.text.charCodeAt(insertPos - 1))) { + insertPos--; + } + this.replaceRange(sourceFile, ts.createRange(insertPos), newNode, { indentation: indentation, prefix: this.newLineCharacter }); + } + else { + this.replaceRange(sourceFile, ts.createRange(end), newNode, { prefix: "".concat(ts.tokenToString(separator), " ") }); + } + } + }; + ChangeTracker.prototype.parenthesizeExpression = function (sourceFile, expression) { + this.replaceRange(sourceFile, ts.rangeOfNode(expression), ts.factory.createParenthesizedExpression(expression)); + }; + ChangeTracker.prototype.finishClassesWithNodesInsertedAtStart = function () { + var _this = this; + this.classesWithNodesInsertedAtStart.forEach(function (_a) { + var node = _a.node, sourceFile = _a.sourceFile; + var _b = getClassOrObjectBraceEnds(node, sourceFile), openBraceEnd = _b[0], closeBraceEnd = _b[1]; + if (openBraceEnd !== undefined && closeBraceEnd !== undefined) { + var isEmpty = getMembersOrProperties(node).length === 0; + var isSingleLine = ts.positionsAreOnSameLine(openBraceEnd, closeBraceEnd, sourceFile); + if (isEmpty && isSingleLine && openBraceEnd !== closeBraceEnd - 1) { + // For `class C { }` remove the whitespace inside the braces. + _this.deleteRange(sourceFile, ts.createRange(openBraceEnd, closeBraceEnd - 1)); + } + if (isSingleLine) { + _this.insertText(sourceFile, closeBraceEnd - 1, _this.newLineCharacter); + } + } + }); + }; + ChangeTracker.prototype.finishDeleteDeclarations = function () { + var _this = this; + var deletedNodesInLists = new ts.Set(); // Stores nodes in lists that we already deleted. Used to avoid deleting `, ` twice in `a, b`. + var _loop_9 = function (sourceFile, node) { + if (!this_1.deletedNodes.some(function (d) { return d.sourceFile === sourceFile && ts.rangeContainsRangeExclusive(d.node, node); })) { + if (ts.isArray(node)) { + this_1.deleteRange(sourceFile, ts.rangeOfTypeParameters(sourceFile, node)); + } + else { + deleteDeclaration.deleteDeclaration(this_1, deletedNodesInLists, sourceFile, node); + } + } + }; + var this_1 = this; + for (var _i = 0, _a = this.deletedNodes; _i < _a.length; _i++) { + var _b = _a[_i], sourceFile = _b.sourceFile, node = _b.node; + _loop_9(sourceFile, node); + } + deletedNodesInLists.forEach(function (node) { + var sourceFile = node.getSourceFile(); + var list = ts.formatting.SmartIndenter.getContainingList(node, sourceFile); + if (node !== ts.last(list)) + return; + var lastNonDeletedIndex = ts.findLastIndex(list, function (n) { return !deletedNodesInLists.has(n); }, list.length - 2); + if (lastNonDeletedIndex !== -1) { + _this.deleteRange(sourceFile, { pos: list[lastNonDeletedIndex].end, end: startPositionToDeleteNodeInList(sourceFile, list[lastNonDeletedIndex + 1]) }); + } + }); + }; + /** + * Note: after calling this, the TextChanges object must be discarded! + * @param validate only for tests + * The reason we must validate as part of this method is that `getNonFormattedText` changes the node's positions, + * so we can only call this once and can't get the non-formatted text separately. + */ + ChangeTracker.prototype.getChanges = function (validate) { + this.finishDeleteDeclarations(); + this.finishClassesWithNodesInsertedAtStart(); + var changes = changesToText.getTextChangesFromChanges(this.changes, this.newLineCharacter, this.formatContext, validate); + for (var _i = 0, _a = this.newFiles; _i < _a.length; _i++) { + var _b = _a[_i], oldFile = _b.oldFile, fileName = _b.fileName, statements = _b.statements; + changes.push(changesToText.newFileChanges(oldFile, fileName, statements, this.newLineCharacter, this.formatContext)); + } + return changes; + }; + ChangeTracker.prototype.createNewFile = function (oldFile, fileName, statements) { + this.newFiles.push({ oldFile: oldFile, fileName: fileName, statements: statements }); + }; + return ChangeTracker; + }()); + textChanges_3.ChangeTracker = ChangeTracker; + function updateJSDocHost(parent) { + if (parent.kind !== 216 /* SyntaxKind.ArrowFunction */) { + return parent; + } + var jsDocNode = parent.parent.kind === 169 /* SyntaxKind.PropertyDeclaration */ ? + parent.parent : + parent.parent.parent; + jsDocNode.jsDoc = parent.jsDoc; + jsDocNode.jsDocCache = parent.jsDocCache; + return jsDocNode; + } + function tryMergeJsdocTags(oldTag, newTag) { + if (oldTag.kind !== newTag.kind) { + return undefined; + } + switch (oldTag.kind) { + case 343 /* SyntaxKind.JSDocParameterTag */: { + var oldParam = oldTag; + var newParam = newTag; + return ts.isIdentifier(oldParam.name) && ts.isIdentifier(newParam.name) && oldParam.name.escapedText === newParam.name.escapedText + ? ts.factory.createJSDocParameterTag(/*tagName*/ undefined, newParam.name, /*isBracketed*/ false, newParam.typeExpression, newParam.isNameFirst, oldParam.comment) + : undefined; + } + case 344 /* SyntaxKind.JSDocReturnTag */: + return ts.factory.createJSDocReturnTag(/*tagName*/ undefined, newTag.typeExpression, oldTag.comment); + case 346 /* SyntaxKind.JSDocTypeTag */: + return ts.factory.createJSDocTypeTag(/*tagName*/ undefined, newTag.typeExpression, oldTag.comment); + } + } + // find first non-whitespace position in the leading trivia of the node + function startPositionToDeleteNodeInList(sourceFile, node) { + return ts.skipTrivia(sourceFile.text, getAdjustedStartPosition(sourceFile, node, { leadingTriviaOption: LeadingTriviaOption.IncludeAll }), /*stopAfterLineBreak*/ false, /*stopAtComments*/ true); + } + function endPositionToDeleteNodeInList(sourceFile, node, prevNode, nextNode) { + var end = startPositionToDeleteNodeInList(sourceFile, nextNode); + if (prevNode === undefined || ts.positionsAreOnSameLine(getAdjustedEndPosition(sourceFile, node, {}), end, sourceFile)) { + return end; + } + var token = ts.findPrecedingToken(nextNode.getStart(sourceFile), sourceFile); + if (isSeparator(node, token)) { + var prevToken = ts.findPrecedingToken(node.getStart(sourceFile), sourceFile); + if (isSeparator(prevNode, prevToken)) { + var pos = ts.skipTrivia(sourceFile.text, token.getEnd(), /*stopAfterLineBreak*/ true, /*stopAtComments*/ true); + if (ts.positionsAreOnSameLine(prevToken.getStart(sourceFile), token.getStart(sourceFile), sourceFile)) { + return ts.isLineBreak(sourceFile.text.charCodeAt(pos - 1)) ? pos - 1 : pos; + } + if (ts.isLineBreak(sourceFile.text.charCodeAt(pos))) { + return pos; + } + } + } + return end; + } + function getClassOrObjectBraceEnds(cls, sourceFile) { + var open = ts.findChildOfKind(cls, 18 /* SyntaxKind.OpenBraceToken */, sourceFile); + var close = ts.findChildOfKind(cls, 19 /* SyntaxKind.CloseBraceToken */, sourceFile); + return [open === null || open === void 0 ? void 0 : open.end, close === null || close === void 0 ? void 0 : close.end]; + } + function getMembersOrProperties(node) { + return ts.isObjectLiteralExpression(node) ? node.properties : node.members; + } + function getNewFileText(statements, scriptKind, newLineCharacter, formatContext) { + return changesToText.newFileChangesWorker(/*oldFile*/ undefined, scriptKind, statements, newLineCharacter, formatContext); + } + textChanges_3.getNewFileText = getNewFileText; + var changesToText; + (function (changesToText) { + function getTextChangesFromChanges(changes, newLineCharacter, formatContext, validate) { + return ts.mapDefined(ts.group(changes, function (c) { return c.sourceFile.path; }), function (changesInFile) { + var sourceFile = changesInFile[0].sourceFile; + // order changes by start position + // If the start position is the same, put the shorter range first, since an empty range (x, x) may precede (x, y) but not vice-versa. + var normalized = ts.stableSort(changesInFile, function (a, b) { return (a.range.pos - b.range.pos) || (a.range.end - b.range.end); }); + var _loop_10 = function (i) { + ts.Debug.assert(normalized[i].range.end <= normalized[i + 1].range.pos, "Changes overlap", function () { + return "".concat(JSON.stringify(normalized[i].range), " and ").concat(JSON.stringify(normalized[i + 1].range)); + }); + }; + // verify that change intervals do not overlap, except possibly at end points. + for (var i = 0; i < normalized.length - 1; i++) { + _loop_10(i); + } + var textChanges = ts.mapDefined(normalized, function (c) { + var span = ts.createTextSpanFromRange(c.range); + var newText = computeNewText(c, sourceFile, newLineCharacter, formatContext, validate); + // Filter out redundant changes. + if (span.length === newText.length && ts.stringContainsAt(sourceFile.text, newText, span.start)) { + return undefined; + } + return ts.createTextChange(span, newText); + }); + return textChanges.length > 0 ? { fileName: sourceFile.fileName, textChanges: textChanges } : undefined; + }); + } + changesToText.getTextChangesFromChanges = getTextChangesFromChanges; + function newFileChanges(oldFile, fileName, statements, newLineCharacter, formatContext) { + var text = newFileChangesWorker(oldFile, ts.getScriptKindFromFileName(fileName), statements, newLineCharacter, formatContext); + return { fileName: fileName, textChanges: [ts.createTextChange(ts.createTextSpan(0, 0), text)], isNewFile: true }; + } + changesToText.newFileChanges = newFileChanges; + function newFileChangesWorker(oldFile, scriptKind, statements, newLineCharacter, formatContext) { + // TODO: this emits the file, parses it back, then formats it that -- may be a less roundabout way to do this + var nonFormattedText = statements.map(function (s) { return s === 4 /* SyntaxKind.NewLineTrivia */ ? "" : getNonformattedText(s, oldFile, newLineCharacter).text; }).join(newLineCharacter); + var sourceFile = ts.createSourceFile("any file name", nonFormattedText, 99 /* ScriptTarget.ESNext */, /*setParentNodes*/ true, scriptKind); + var changes = ts.formatting.formatDocument(sourceFile, formatContext); + return applyChanges(nonFormattedText, changes) + newLineCharacter; + } + changesToText.newFileChangesWorker = newFileChangesWorker; + function computeNewText(change, sourceFile, newLineCharacter, formatContext, validate) { + var _a; + if (change.kind === ChangeKind.Remove) { + return ""; + } + if (change.kind === ChangeKind.Text) { + return change.text; + } + var _b = change.options, options = _b === void 0 ? {} : _b, pos = change.range.pos; + var format = function (n) { return getFormattedTextOfNode(n, sourceFile, pos, options, newLineCharacter, formatContext, validate); }; + var text = change.kind === ChangeKind.ReplaceWithMultipleNodes + ? change.nodes.map(function (n) { return ts.removeSuffix(format(n), newLineCharacter); }).join(((_a = change.options) === null || _a === void 0 ? void 0 : _a.joiner) || newLineCharacter) + : format(change.node); + // strip initial indentation (spaces or tabs) if text will be inserted in the middle of the line + var noIndent = (options.indentation !== undefined || ts.getLineStartPositionForPosition(pos, sourceFile) === pos) ? text : text.replace(/^\s+/, ""); + return (options.prefix || "") + noIndent + + ((!options.suffix || ts.endsWith(noIndent, options.suffix)) + ? "" : options.suffix); + } + /** Note: this may mutate `nodeIn`. */ + function getFormattedTextOfNode(nodeIn, sourceFile, pos, _a, newLineCharacter, formatContext, validate) { + var indentation = _a.indentation, prefix = _a.prefix, delta = _a.delta; + var _b = getNonformattedText(nodeIn, sourceFile, newLineCharacter), node = _b.node, text = _b.text; + if (validate) + validate(node, text); + var formatOptions = ts.getFormatCodeSettingsForWriting(formatContext, sourceFile); + var initialIndentation = indentation !== undefined + ? indentation + : ts.formatting.SmartIndenter.getIndentation(pos, sourceFile, formatOptions, prefix === newLineCharacter || ts.getLineStartPositionForPosition(pos, sourceFile) === pos); + if (delta === undefined) { + delta = ts.formatting.SmartIndenter.shouldIndentChildNode(formatOptions, nodeIn) ? (formatOptions.indentSize || 0) : 0; + } + var file = { + text: text, + getLineAndCharacterOfPosition: function (pos) { + return ts.getLineAndCharacterOfPosition(this, pos); + } + }; + var changes = ts.formatting.formatNodeGivenIndentation(node, file, sourceFile.languageVariant, initialIndentation, delta, __assign(__assign({}, formatContext), { options: formatOptions })); + return applyChanges(text, changes); + } + /** Note: output node may be mutated input node. */ + function getNonformattedText(node, sourceFile, newLineCharacter) { + var writer = createWriter(newLineCharacter); + var newLine = ts.getNewLineKind(newLineCharacter); + ts.createPrinter({ + newLine: newLine, + neverAsciiEscape: true, + preserveSourceNewlines: true, + terminateUnterminatedLiterals: true + }, writer).writeNode(4 /* EmitHint.Unspecified */, node, sourceFile, writer); + return { text: writer.getText(), node: assignPositionsToNode(node) }; + } + changesToText.getNonformattedText = getNonformattedText; + })(changesToText || (changesToText = {})); + function applyChanges(text, changes) { + for (var i = changes.length - 1; i >= 0; i--) { + var _a = changes[i], span = _a.span, newText = _a.newText; + text = "".concat(text.substring(0, span.start)).concat(newText).concat(text.substring(ts.textSpanEnd(span))); + } + return text; + } + textChanges_3.applyChanges = applyChanges; + function isTrivia(s) { + return ts.skipTrivia(s, 0) === s.length; + } + // A transformation context that won't perform parenthesization, as some parenthesization rules + // are more aggressive than is strictly necessary. + var textChangesTransformationContext = __assign(__assign({}, ts.nullTransformationContext), { factory: ts.createNodeFactory(ts.nullTransformationContext.factory.flags | 1 /* NodeFactoryFlags.NoParenthesizerRules */, ts.nullTransformationContext.factory.baseFactory) }); + function assignPositionsToNode(node) { + var visited = ts.visitEachChild(node, assignPositionsToNode, textChangesTransformationContext, assignPositionsToNodeArray, assignPositionsToNode); + // create proxy node for non synthesized nodes + var newNode = ts.nodeIsSynthesized(visited) ? visited : Object.create(visited); + ts.setTextRangePosEnd(newNode, getPos(node), getEnd(node)); + return newNode; + } + textChanges_3.assignPositionsToNode = assignPositionsToNode; + function assignPositionsToNodeArray(nodes, visitor, test, start, count) { + var visited = ts.visitNodes(nodes, visitor, test, start, count); + if (!visited) { + return visited; + } + // clone nodearray if necessary + var nodeArray = visited === nodes ? ts.factory.createNodeArray(visited.slice(0)) : visited; + ts.setTextRangePosEnd(nodeArray, getPos(nodes), getEnd(nodes)); + return nodeArray; + } + function createWriter(newLine) { + var lastNonTriviaPosition = 0; + var writer = ts.createTextWriter(newLine); + var onBeforeEmitNode = function (node) { + if (node) { + setPos(node, lastNonTriviaPosition); + } + }; + var onAfterEmitNode = function (node) { + if (node) { + setEnd(node, lastNonTriviaPosition); + } + }; + var onBeforeEmitNodeArray = function (nodes) { + if (nodes) { + setPos(nodes, lastNonTriviaPosition); + } + }; + var onAfterEmitNodeArray = function (nodes) { + if (nodes) { + setEnd(nodes, lastNonTriviaPosition); + } + }; + var onBeforeEmitToken = function (node) { + if (node) { + setPos(node, lastNonTriviaPosition); + } + }; + var onAfterEmitToken = function (node) { + if (node) { + setEnd(node, lastNonTriviaPosition); + } + }; + function setLastNonTriviaPosition(s, force) { + if (force || !isTrivia(s)) { + lastNonTriviaPosition = writer.getTextPos(); + var i = 0; + while (ts.isWhiteSpaceLike(s.charCodeAt(s.length - i - 1))) { + i++; + } + // trim trailing whitespaces + lastNonTriviaPosition -= i; + } + } + function write(s) { + writer.write(s); + setLastNonTriviaPosition(s, /*force*/ false); + } + function writeComment(s) { + writer.writeComment(s); + } + function writeKeyword(s) { + writer.writeKeyword(s); + setLastNonTriviaPosition(s, /*force*/ false); + } + function writeOperator(s) { + writer.writeOperator(s); + setLastNonTriviaPosition(s, /*force*/ false); + } + function writePunctuation(s) { + writer.writePunctuation(s); + setLastNonTriviaPosition(s, /*force*/ false); + } + function writeTrailingSemicolon(s) { + writer.writeTrailingSemicolon(s); + setLastNonTriviaPosition(s, /*force*/ false); + } + function writeParameter(s) { + writer.writeParameter(s); + setLastNonTriviaPosition(s, /*force*/ false); + } + function writeProperty(s) { + writer.writeProperty(s); + setLastNonTriviaPosition(s, /*force*/ false); + } + function writeSpace(s) { + writer.writeSpace(s); + setLastNonTriviaPosition(s, /*force*/ false); + } + function writeStringLiteral(s) { + writer.writeStringLiteral(s); + setLastNonTriviaPosition(s, /*force*/ false); + } + function writeSymbol(s, sym) { + writer.writeSymbol(s, sym); + setLastNonTriviaPosition(s, /*force*/ false); + } + function writeLine(force) { + writer.writeLine(force); + } + function increaseIndent() { + writer.increaseIndent(); + } + function decreaseIndent() { + writer.decreaseIndent(); + } + function getText() { + return writer.getText(); + } + function rawWrite(s) { + writer.rawWrite(s); + setLastNonTriviaPosition(s, /*force*/ false); + } + function writeLiteral(s) { + writer.writeLiteral(s); + setLastNonTriviaPosition(s, /*force*/ true); + } + function getTextPos() { + return writer.getTextPos(); + } + function getLine() { + return writer.getLine(); + } + function getColumn() { + return writer.getColumn(); + } + function getIndent() { + return writer.getIndent(); + } + function isAtStartOfLine() { + return writer.isAtStartOfLine(); + } + function clear() { + writer.clear(); + lastNonTriviaPosition = 0; + } + return { + onBeforeEmitNode: onBeforeEmitNode, + onAfterEmitNode: onAfterEmitNode, + onBeforeEmitNodeArray: onBeforeEmitNodeArray, + onAfterEmitNodeArray: onAfterEmitNodeArray, + onBeforeEmitToken: onBeforeEmitToken, + onAfterEmitToken: onAfterEmitToken, + write: write, + writeComment: writeComment, + writeKeyword: writeKeyword, + writeOperator: writeOperator, + writePunctuation: writePunctuation, + writeTrailingSemicolon: writeTrailingSemicolon, + writeParameter: writeParameter, + writeProperty: writeProperty, + writeSpace: writeSpace, + writeStringLiteral: writeStringLiteral, + writeSymbol: writeSymbol, + writeLine: writeLine, + increaseIndent: increaseIndent, + decreaseIndent: decreaseIndent, + getText: getText, + rawWrite: rawWrite, + writeLiteral: writeLiteral, + getTextPos: getTextPos, + getLine: getLine, + getColumn: getColumn, + getIndent: getIndent, + isAtStartOfLine: isAtStartOfLine, + hasTrailingComment: function () { return writer.hasTrailingComment(); }, + hasTrailingWhitespace: function () { return writer.hasTrailingWhitespace(); }, + clear: clear + }; + } + textChanges_3.createWriter = createWriter; + function getInsertionPositionAtSourceFileTop(sourceFile) { + var lastPrologue; + for (var _i = 0, _a = sourceFile.statements; _i < _a.length; _i++) { + var node = _a[_i]; + if (ts.isPrologueDirective(node)) { + lastPrologue = node; + } + else { + break; + } + } + var position = 0; + var text = sourceFile.text; + if (lastPrologue) { + position = lastPrologue.end; + advancePastLineBreak(); + return position; + } + var shebang = ts.getShebang(text); + if (shebang !== undefined) { + position = shebang.length; + advancePastLineBreak(); + } + var ranges = ts.getLeadingCommentRanges(text, position); + if (!ranges) + return position; + // Find the first attached comment to the first node and add before it + var lastComment; + var firstNodeLine; + for (var _b = 0, ranges_1 = ranges; _b < ranges_1.length; _b++) { + var range = ranges_1[_b]; + if (range.kind === 3 /* SyntaxKind.MultiLineCommentTrivia */) { + if (ts.isPinnedComment(text, range.pos)) { + lastComment = { range: range, pinnedOrTripleSlash: true }; + continue; + } + } + else if (ts.isRecognizedTripleSlashComment(text, range.pos, range.end)) { + lastComment = { range: range, pinnedOrTripleSlash: true }; + continue; + } + if (lastComment) { + // Always insert after pinned or triple slash comments + if (lastComment.pinnedOrTripleSlash) + break; + // There was a blank line between the last comment and this comment. + // This comment is not part of the copyright comments + var commentLine = sourceFile.getLineAndCharacterOfPosition(range.pos).line; + var lastCommentEndLine = sourceFile.getLineAndCharacterOfPosition(lastComment.range.end).line; + if (commentLine >= lastCommentEndLine + 2) + break; + } + if (sourceFile.statements.length) { + if (firstNodeLine === undefined) + firstNodeLine = sourceFile.getLineAndCharacterOfPosition(sourceFile.statements[0].getStart()).line; + var commentEndLine = sourceFile.getLineAndCharacterOfPosition(range.end).line; + if (firstNodeLine < commentEndLine + 2) + break; + } + lastComment = { range: range, pinnedOrTripleSlash: false }; + } + if (lastComment) { + position = lastComment.range.end; + advancePastLineBreak(); + } + return position; + function advancePastLineBreak() { + if (position < text.length) { + var charCode = text.charCodeAt(position); + if (ts.isLineBreak(charCode)) { + position++; + if (position < text.length && charCode === 13 /* CharacterCodes.carriageReturn */ && text.charCodeAt(position) === 10 /* CharacterCodes.lineFeed */) { + position++; + } + } + } + } + } + function isValidLocationToAddComment(sourceFile, position) { + return !ts.isInComment(sourceFile, position) && !ts.isInString(sourceFile, position) && !ts.isInTemplateString(sourceFile, position) && !ts.isInJSXText(sourceFile, position); + } + textChanges_3.isValidLocationToAddComment = isValidLocationToAddComment; + function needSemicolonBetween(a, b) { + return (ts.isPropertySignature(a) || ts.isPropertyDeclaration(a)) && ts.isClassOrTypeElement(b) && b.name.kind === 164 /* SyntaxKind.ComputedPropertyName */ + || ts.isStatementButNotDeclaration(a) && ts.isStatementButNotDeclaration(b); // TODO: only if b would start with a `(` or `[` + } + var deleteDeclaration; + (function (deleteDeclaration_1) { + function deleteDeclaration(changes, deletedNodesInLists, sourceFile, node) { + switch (node.kind) { + case 166 /* SyntaxKind.Parameter */: { + var oldFunction = node.parent; + if (ts.isArrowFunction(oldFunction) && + oldFunction.parameters.length === 1 && + !ts.findChildOfKind(oldFunction, 20 /* SyntaxKind.OpenParenToken */, sourceFile)) { + // Lambdas with exactly one parameter are special because, after removal, there + // must be an empty parameter list (i.e. `()`) and this won't necessarily be the + // case if the parameter is simply removed (e.g. in `x => 1`). + changes.replaceNodeWithText(sourceFile, node, "()"); + } + else { + deleteNodeInList(changes, deletedNodesInLists, sourceFile, node); + } + break; + } + case 269 /* SyntaxKind.ImportDeclaration */: + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + var isFirstImport = sourceFile.imports.length && node === ts.first(sourceFile.imports).parent || node === ts.find(sourceFile.statements, ts.isAnyImportSyntax); + // For first import, leave header comment in place, otherwise only delete JSDoc comments + deleteNode(changes, sourceFile, node, { + leadingTriviaOption: isFirstImport ? LeadingTriviaOption.Exclude : ts.hasJSDocNodes(node) ? LeadingTriviaOption.JSDoc : LeadingTriviaOption.StartLine, + }); + break; + case 205 /* SyntaxKind.BindingElement */: + var pattern = node.parent; + var preserveComma = pattern.kind === 204 /* SyntaxKind.ArrayBindingPattern */ && node !== ts.last(pattern.elements); + if (preserveComma) { + deleteNode(changes, sourceFile, node); + } + else { + deleteNodeInList(changes, deletedNodesInLists, sourceFile, node); + } + break; + case 257 /* SyntaxKind.VariableDeclaration */: + deleteVariableDeclaration(changes, deletedNodesInLists, sourceFile, node); + break; + case 165 /* SyntaxKind.TypeParameter */: + deleteNodeInList(changes, deletedNodesInLists, sourceFile, node); + break; + case 273 /* SyntaxKind.ImportSpecifier */: + var namedImports = node.parent; + if (namedImports.elements.length === 1) { + deleteImportBinding(changes, sourceFile, namedImports); + } + else { + deleteNodeInList(changes, deletedNodesInLists, sourceFile, node); + } + break; + case 271 /* SyntaxKind.NamespaceImport */: + deleteImportBinding(changes, sourceFile, node); + break; + case 26 /* SyntaxKind.SemicolonToken */: + deleteNode(changes, sourceFile, node, { trailingTriviaOption: TrailingTriviaOption.Exclude }); + break; + case 98 /* SyntaxKind.FunctionKeyword */: + deleteNode(changes, sourceFile, node, { leadingTriviaOption: LeadingTriviaOption.Exclude }); + break; + case 260 /* SyntaxKind.ClassDeclaration */: + case 259 /* SyntaxKind.FunctionDeclaration */: + deleteNode(changes, sourceFile, node, { leadingTriviaOption: ts.hasJSDocNodes(node) ? LeadingTriviaOption.JSDoc : LeadingTriviaOption.StartLine }); + break; + default: + if (!node.parent) { + // a misbehaving client can reach here with the SourceFile node + deleteNode(changes, sourceFile, node); + } + else if (ts.isImportClause(node.parent) && node.parent.name === node) { + deleteDefaultImport(changes, sourceFile, node.parent); + } + else if (ts.isCallExpression(node.parent) && ts.contains(node.parent.arguments, node)) { + deleteNodeInList(changes, deletedNodesInLists, sourceFile, node); + } + else { + deleteNode(changes, sourceFile, node); + } + } + } + deleteDeclaration_1.deleteDeclaration = deleteDeclaration; + function deleteDefaultImport(changes, sourceFile, importClause) { + if (!importClause.namedBindings) { + // Delete the whole import + deleteNode(changes, sourceFile, importClause.parent); + } + else { + // import |d,| * as ns from './file' + var start = importClause.name.getStart(sourceFile); + var nextToken = ts.getTokenAtPosition(sourceFile, importClause.name.end); + if (nextToken && nextToken.kind === 27 /* SyntaxKind.CommaToken */) { + // shift first non-whitespace position after comma to the start position of the node + var end = ts.skipTrivia(sourceFile.text, nextToken.end, /*stopAfterLineBreaks*/ false, /*stopAtComments*/ true); + changes.deleteRange(sourceFile, { pos: start, end: end }); + } + else { + deleteNode(changes, sourceFile, importClause.name); + } + } + } + function deleteImportBinding(changes, sourceFile, node) { + if (node.parent.name) { + // Delete named imports while preserving the default import + // import d|, * as ns| from './file' + // import d|, { a }| from './file' + var previousToken = ts.Debug.checkDefined(ts.getTokenAtPosition(sourceFile, node.pos - 1)); + changes.deleteRange(sourceFile, { pos: previousToken.getStart(sourceFile), end: node.end }); + } + else { + // Delete the entire import declaration + // |import * as ns from './file'| + // |import { a } from './file'| + var importDecl = ts.getAncestor(node, 269 /* SyntaxKind.ImportDeclaration */); + deleteNode(changes, sourceFile, importDecl); + } + } + function deleteVariableDeclaration(changes, deletedNodesInLists, sourceFile, node) { + var parent = node.parent; + if (parent.kind === 295 /* SyntaxKind.CatchClause */) { + // TODO: There's currently no unused diagnostic for this, could be a suggestion + changes.deleteNodeRange(sourceFile, ts.findChildOfKind(parent, 20 /* SyntaxKind.OpenParenToken */, sourceFile), ts.findChildOfKind(parent, 21 /* SyntaxKind.CloseParenToken */, sourceFile)); + return; + } + if (parent.declarations.length !== 1) { + deleteNodeInList(changes, deletedNodesInLists, sourceFile, node); + return; + } + var gp = parent.parent; + switch (gp.kind) { + case 247 /* SyntaxKind.ForOfStatement */: + case 246 /* SyntaxKind.ForInStatement */: + changes.replaceNode(sourceFile, node, ts.factory.createObjectLiteralExpression()); + break; + case 245 /* SyntaxKind.ForStatement */: + deleteNode(changes, sourceFile, parent); + break; + case 240 /* SyntaxKind.VariableStatement */: + deleteNode(changes, sourceFile, gp, { leadingTriviaOption: ts.hasJSDocNodes(gp) ? LeadingTriviaOption.JSDoc : LeadingTriviaOption.StartLine }); + break; + default: + ts.Debug.assertNever(gp); + } + } + })(deleteDeclaration || (deleteDeclaration = {})); + /** Warning: This deletes comments too. See `copyComments` in `convertFunctionToEs6Class`. */ + // Exported for tests only! (TODO: improve tests to not need this) + function deleteNode(changes, sourceFile, node, options) { + if (options === void 0) { options = { leadingTriviaOption: LeadingTriviaOption.IncludeAll }; } + var startPosition = getAdjustedStartPosition(sourceFile, node, options); + var endPosition = getAdjustedEndPosition(sourceFile, node, options); + changes.deleteRange(sourceFile, { pos: startPosition, end: endPosition }); + } + textChanges_3.deleteNode = deleteNode; + function deleteNodeInList(changes, deletedNodesInLists, sourceFile, node) { + var containingList = ts.Debug.checkDefined(ts.formatting.SmartIndenter.getContainingList(node, sourceFile)); + var index = ts.indexOfNode(containingList, node); + ts.Debug.assert(index !== -1); + if (containingList.length === 1) { + deleteNode(changes, sourceFile, node); + return; + } + // Note: We will only delete a comma *after* a node. This will leave a trailing comma if we delete the last node. + // That's handled in the end by `finishTrailingCommaAfterDeletingNodesInList`. + ts.Debug.assert(!deletedNodesInLists.has(node), "Deleting a node twice"); + deletedNodesInLists.add(node); + changes.deleteRange(sourceFile, { + pos: startPositionToDeleteNodeInList(sourceFile, node), + end: index === containingList.length - 1 ? getAdjustedEndPosition(sourceFile, node, {}) : endPositionToDeleteNodeInList(sourceFile, node, containingList[index - 1], containingList[index + 1]), + }); + } + })(textChanges = ts.textChanges || (ts.textChanges = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var errorCodeToFixes = ts.createMultiMap(); + var fixIdToRegistration = new ts.Map(); + function createCodeFixActionWithoutFixAll(fixName, changes, description) { + return createCodeFixActionWorker(fixName, ts.diagnosticToString(description), changes, /*fixId*/ undefined, /*fixAllDescription*/ undefined); + } + codefix.createCodeFixActionWithoutFixAll = createCodeFixActionWithoutFixAll; + function createCodeFixAction(fixName, changes, description, fixId, fixAllDescription, command) { + return createCodeFixActionWorker(fixName, ts.diagnosticToString(description), changes, fixId, ts.diagnosticToString(fixAllDescription), command); + } + codefix.createCodeFixAction = createCodeFixAction; + function createCodeFixActionMaybeFixAll(fixName, changes, description, fixId, fixAllDescription, command) { + return createCodeFixActionWorker(fixName, ts.diagnosticToString(description), changes, fixId, fixAllDescription && ts.diagnosticToString(fixAllDescription), command); + } + codefix.createCodeFixActionMaybeFixAll = createCodeFixActionMaybeFixAll; + function createCodeFixActionWorker(fixName, description, changes, fixId, fixAllDescription, command) { + return { fixName: fixName, description: description, changes: changes, fixId: fixId, fixAllDescription: fixAllDescription, commands: command ? [command] : undefined }; + } + function registerCodeFix(reg) { + for (var _i = 0, _a = reg.errorCodes; _i < _a.length; _i++) { + var error = _a[_i]; + errorCodeToFixes.add(String(error), reg); + } + if (reg.fixIds) { + for (var _b = 0, _c = reg.fixIds; _b < _c.length; _b++) { + var fixId = _c[_b]; + ts.Debug.assert(!fixIdToRegistration.has(fixId)); + fixIdToRegistration.set(fixId, reg); + } + } + } + codefix.registerCodeFix = registerCodeFix; + function getSupportedErrorCodes() { + return ts.arrayFrom(errorCodeToFixes.keys()); + } + codefix.getSupportedErrorCodes = getSupportedErrorCodes; + function removeFixIdIfFixAllUnavailable(registration, diagnostics) { + var errorCodes = registration.errorCodes; + var maybeFixableDiagnostics = 0; + for (var _i = 0, diagnostics_1 = diagnostics; _i < diagnostics_1.length; _i++) { + var diag = diagnostics_1[_i]; + if (ts.contains(errorCodes, diag.code)) + maybeFixableDiagnostics++; + if (maybeFixableDiagnostics > 1) + break; + } + var fixAllUnavailable = maybeFixableDiagnostics < 2; + return function (_a) { + var fixId = _a.fixId, fixAllDescription = _a.fixAllDescription, action = __rest(_a, ["fixId", "fixAllDescription"]); + return fixAllUnavailable ? action : __assign(__assign({}, action), { fixId: fixId, fixAllDescription: fixAllDescription }); + }; + } + function getFixes(context) { + var diagnostics = getDiagnostics(context); + var registrations = errorCodeToFixes.get(String(context.errorCode)); + return ts.flatMap(registrations, function (f) { return ts.map(f.getCodeActions(context), removeFixIdIfFixAllUnavailable(f, diagnostics)); }); + } + codefix.getFixes = getFixes; + function getAllFixes(context) { + // Currently fixId is always a string. + return fixIdToRegistration.get(ts.cast(context.fixId, ts.isString)).getAllCodeActions(context); + } + codefix.getAllFixes = getAllFixes; + function createCombinedCodeActions(changes, commands) { + return { changes: changes, commands: commands }; + } + codefix.createCombinedCodeActions = createCombinedCodeActions; + function createFileTextChanges(fileName, textChanges) { + return { fileName: fileName, textChanges: textChanges }; + } + codefix.createFileTextChanges = createFileTextChanges; + function codeFixAll(context, errorCodes, use) { + var commands = []; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return eachDiagnostic(context, errorCodes, function (diag) { return use(t, diag, commands); }); }); + return createCombinedCodeActions(changes, commands.length === 0 ? undefined : commands); + } + codefix.codeFixAll = codeFixAll; + function eachDiagnostic(context, errorCodes, cb) { + for (var _i = 0, _a = getDiagnostics(context); _i < _a.length; _i++) { + var diag = _a[_i]; + if (ts.contains(errorCodes, diag.code)) { + cb(diag); + } + } + } + codefix.eachDiagnostic = eachDiagnostic; + function getDiagnostics(_a) { + var program = _a.program, sourceFile = _a.sourceFile, cancellationToken = _a.cancellationToken; + return __spreadArray(__spreadArray(__spreadArray([], program.getSemanticDiagnostics(sourceFile, cancellationToken), true), program.getSyntacticDiagnostics(sourceFile, cancellationToken), true), ts.computeSuggestionDiagnostics(sourceFile, program, cancellationToken), true); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var refactor; + (function (refactor_1) { + // A map with the refactor code as key, the refactor itself as value + // e.g. nonSuggestableRefactors[refactorCode] -> the refactor you want + var refactors = new ts.Map(); + /** @param name An unique code associated with each refactor. Does not have to be human-readable. */ + function registerRefactor(name, refactor) { + refactors.set(name, refactor); + } + refactor_1.registerRefactor = registerRefactor; + function getApplicableRefactors(context) { + return ts.arrayFrom(ts.flatMapIterator(refactors.values(), function (refactor) { + var _a; + return context.cancellationToken && context.cancellationToken.isCancellationRequested() || + !((_a = refactor.kinds) === null || _a === void 0 ? void 0 : _a.some(function (kind) { return refactor_1.refactorKindBeginsWith(kind, context.kind); })) ? undefined : + refactor.getAvailableActions(context); + })); + } + refactor_1.getApplicableRefactors = getApplicableRefactors; + function getEditsForRefactor(context, refactorName, actionName) { + var refactor = refactors.get(refactorName); + return refactor && refactor.getEditsForAction(context, actionName); + } + refactor_1.getEditsForRefactor = getEditsForRefactor; + })(refactor = ts.refactor || (ts.refactor = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "addConvertToUnknownForNonOverlappingTypes"; + var errorCodes = [ts.Diagnostics.Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first.code]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function getCodeActionsToAddConvertToUnknownForNonOverlappingTypes(context) { + var assertion = getAssertion(context.sourceFile, context.span.start); + if (assertion === undefined) + return undefined; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return makeChange(t, context.sourceFile, assertion); }); + return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Add_unknown_conversion_for_non_overlapping_types, fixId, ts.Diagnostics.Add_unknown_to_all_conversions_of_non_overlapping_types)]; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var assertion = getAssertion(diag.file, diag.start); + if (assertion) { + makeChange(changes, diag.file, assertion); + } + }); }, + }); + function makeChange(changeTracker, sourceFile, assertion) { + var replacement = ts.isAsExpression(assertion) + ? ts.factory.createAsExpression(assertion.expression, ts.factory.createKeywordTypeNode(157 /* SyntaxKind.UnknownKeyword */)) + : ts.factory.createTypeAssertion(ts.factory.createKeywordTypeNode(157 /* SyntaxKind.UnknownKeyword */), assertion.expression); + changeTracker.replaceNode(sourceFile, assertion.expression, replacement); + } + function getAssertion(sourceFile, pos) { + if (ts.isInJSFile(sourceFile)) + return undefined; + return ts.findAncestor(ts.getTokenAtPosition(sourceFile, pos), function (n) { return ts.isAsExpression(n) || ts.isTypeAssertionExpression(n); }); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + codefix.registerCodeFix({ + errorCodes: [ + ts.Diagnostics.await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module.code, + ts.Diagnostics.for_await_loops_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module.code, + ], + getCodeActions: function getCodeActionsToAddEmptyExportDeclaration(context) { + var sourceFile = context.sourceFile; + var changes = ts.textChanges.ChangeTracker.with(context, function (changes) { + var exportDeclaration = ts.factory.createExportDeclaration( + /*modifiers*/ undefined, + /*isTypeOnly*/ false, ts.factory.createNamedExports([]), + /*moduleSpecifier*/ undefined); + changes.insertNodeAtEndOfScope(sourceFile, sourceFile, exportDeclaration); + }); + return [codefix.createCodeFixActionWithoutFixAll("addEmptyExportDeclaration", changes, ts.Diagnostics.Add_export_to_make_this_file_into_a_module)]; + }, + }); + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "addMissingAsync"; + var errorCodes = [ + ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code, + ts.Diagnostics.Type_0_is_not_assignable_to_type_1.code, + ts.Diagnostics.Type_0_is_not_comparable_to_type_1.code + ]; + codefix.registerCodeFix({ + fixIds: [fixId], + errorCodes: errorCodes, + getCodeActions: function getCodeActionsToAddMissingAsync(context) { + var sourceFile = context.sourceFile, errorCode = context.errorCode, cancellationToken = context.cancellationToken, program = context.program, span = context.span; + var diagnostic = ts.find(program.getTypeChecker().getDiagnostics(sourceFile, cancellationToken), getIsMatchingAsyncError(span, errorCode)); + var directSpan = diagnostic && diagnostic.relatedInformation && ts.find(diagnostic.relatedInformation, function (r) { return r.code === ts.Diagnostics.Did_you_mean_to_mark_this_function_as_async.code; }); + var decl = getFixableErrorSpanDeclaration(sourceFile, directSpan); + if (!decl) { + return; + } + var trackChanges = function (cb) { return ts.textChanges.ChangeTracker.with(context, cb); }; + return [getFix(context, decl, trackChanges)]; + }, + getAllCodeActions: function (context) { + var sourceFile = context.sourceFile; + var fixedDeclarations = new ts.Set(); + return codefix.codeFixAll(context, errorCodes, function (t, diagnostic) { + var span = diagnostic.relatedInformation && ts.find(diagnostic.relatedInformation, function (r) { return r.code === ts.Diagnostics.Did_you_mean_to_mark_this_function_as_async.code; }); + var decl = getFixableErrorSpanDeclaration(sourceFile, span); + if (!decl) { + return; + } + var trackChanges = function (cb) { return (cb(t), []); }; + return getFix(context, decl, trackChanges, fixedDeclarations); + }); + }, + }); + function getFix(context, decl, trackChanges, fixedDeclarations) { + var changes = trackChanges(function (t) { return makeChange(t, context.sourceFile, decl, fixedDeclarations); }); + return codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Add_async_modifier_to_containing_function, fixId, ts.Diagnostics.Add_all_missing_async_modifiers); + } + function makeChange(changeTracker, sourceFile, insertionSite, fixedDeclarations) { + if (fixedDeclarations) { + if (fixedDeclarations.has(ts.getNodeId(insertionSite))) { + return; + } + } + fixedDeclarations === null || fixedDeclarations === void 0 ? void 0 : fixedDeclarations.add(ts.getNodeId(insertionSite)); + var cloneWithModifier = ts.factory.updateModifiers(ts.getSynthesizedDeepClone(insertionSite, /*includeTrivia*/ true), ts.factory.createNodeArray(ts.factory.createModifiersFromModifierFlags(ts.getSyntacticModifierFlags(insertionSite) | 512 /* ModifierFlags.Async */))); + changeTracker.replaceNode(sourceFile, insertionSite, cloneWithModifier); + } + function getFixableErrorSpanDeclaration(sourceFile, span) { + if (!span) + return undefined; + var token = ts.getTokenAtPosition(sourceFile, span.start); + // Checker has already done work to determine that async might be possible, and has attached + // related info to the node, so start by finding the signature that exactly matches up + // with the diagnostic range. + var decl = ts.findAncestor(token, function (node) { + if (node.getStart(sourceFile) < span.start || node.getEnd() > ts.textSpanEnd(span)) { + return "quit"; + } + return (ts.isArrowFunction(node) || ts.isMethodDeclaration(node) || ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node)) && ts.textSpansEqual(span, ts.createTextSpanFromNode(node, sourceFile)); + }); + return decl; + } + function getIsMatchingAsyncError(span, errorCode) { + return function (_a) { + var start = _a.start, length = _a.length, relatedInformation = _a.relatedInformation, code = _a.code; + return ts.isNumber(start) && ts.isNumber(length) && ts.textSpansEqual({ start: start, length: length }, span) && + code === errorCode && + !!relatedInformation && + ts.some(relatedInformation, function (related) { return related.code === ts.Diagnostics.Did_you_mean_to_mark_this_function_as_async.code; }); + }; + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "addMissingAwait"; + var propertyAccessCode = ts.Diagnostics.Property_0_does_not_exist_on_type_1.code; + var callableConstructableErrorCodes = [ + ts.Diagnostics.This_expression_is_not_callable.code, + ts.Diagnostics.This_expression_is_not_constructable.code, + ]; + var errorCodes = __spreadArray([ + ts.Diagnostics.An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type.code, + ts.Diagnostics.The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type.code, + ts.Diagnostics.The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type.code, + ts.Diagnostics.Operator_0_cannot_be_applied_to_type_1.code, + ts.Diagnostics.Operator_0_cannot_be_applied_to_types_1_and_2.code, + ts.Diagnostics.This_comparison_appears_to_be_unintentional_because_the_types_0_and_1_have_no_overlap.code, + ts.Diagnostics.This_condition_will_always_return_true_since_this_0_is_always_defined.code, + ts.Diagnostics.Type_0_is_not_an_array_type.code, + ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type.code, + ts.Diagnostics.Type_0_can_only_be_iterated_through_when_using_the_downlevelIteration_flag_or_with_a_target_of_es2015_or_higher.code, + ts.Diagnostics.Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator.code, + ts.Diagnostics.Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator.code, + ts.Diagnostics.Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator.code, + ts.Diagnostics.Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator.code, + ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code, + propertyAccessCode + ], callableConstructableErrorCodes, true); + codefix.registerCodeFix({ + fixIds: [fixId], + errorCodes: errorCodes, + getCodeActions: function getCodeActionsToAddMissingAwait(context) { + var sourceFile = context.sourceFile, errorCode = context.errorCode, span = context.span, cancellationToken = context.cancellationToken, program = context.program; + var expression = getAwaitErrorSpanExpression(sourceFile, errorCode, span, cancellationToken, program); + if (!expression) { + return; + } + var checker = context.program.getTypeChecker(); + var trackChanges = function (cb) { return ts.textChanges.ChangeTracker.with(context, cb); }; + return ts.compact([ + getDeclarationSiteFix(context, expression, errorCode, checker, trackChanges), + getUseSiteFix(context, expression, errorCode, checker, trackChanges) + ]); + }, + getAllCodeActions: function (context) { + var sourceFile = context.sourceFile, program = context.program, cancellationToken = context.cancellationToken; + var checker = context.program.getTypeChecker(); + var fixedDeclarations = new ts.Set(); + return codefix.codeFixAll(context, errorCodes, function (t, diagnostic) { + var expression = getAwaitErrorSpanExpression(sourceFile, diagnostic.code, diagnostic, cancellationToken, program); + if (!expression) { + return; + } + var trackChanges = function (cb) { return (cb(t), []); }; + return getDeclarationSiteFix(context, expression, diagnostic.code, checker, trackChanges, fixedDeclarations) + || getUseSiteFix(context, expression, diagnostic.code, checker, trackChanges, fixedDeclarations); + }); + }, + }); + function getAwaitErrorSpanExpression(sourceFile, errorCode, span, cancellationToken, program) { + var expression = ts.getFixableErrorSpanExpression(sourceFile, span); + return expression + && isMissingAwaitError(sourceFile, errorCode, span, cancellationToken, program) + && isInsideAwaitableBody(expression) ? expression : undefined; + } + function getDeclarationSiteFix(context, expression, errorCode, checker, trackChanges, fixedDeclarations) { + var sourceFile = context.sourceFile, program = context.program, cancellationToken = context.cancellationToken; + var awaitableInitializers = findAwaitableInitializers(expression, sourceFile, cancellationToken, program, checker); + if (awaitableInitializers) { + var initializerChanges = trackChanges(function (t) { + ts.forEach(awaitableInitializers.initializers, function (_a) { + var expression = _a.expression; + return makeChange(t, errorCode, sourceFile, checker, expression, fixedDeclarations); + }); + if (fixedDeclarations && awaitableInitializers.needsSecondPassForFixAll) { + makeChange(t, errorCode, sourceFile, checker, expression, fixedDeclarations); + } + }); + // No fix-all because it will already be included once with the use site fix, + // and for simplicity the fix-all doesn‘t let the user choose between use-site and declaration-site fixes. + return codefix.createCodeFixActionWithoutFixAll("addMissingAwaitToInitializer", initializerChanges, awaitableInitializers.initializers.length === 1 + ? [ts.Diagnostics.Add_await_to_initializer_for_0, awaitableInitializers.initializers[0].declarationSymbol.name] + : ts.Diagnostics.Add_await_to_initializers); + } + } + function getUseSiteFix(context, expression, errorCode, checker, trackChanges, fixedDeclarations) { + var changes = trackChanges(function (t) { return makeChange(t, errorCode, context.sourceFile, checker, expression, fixedDeclarations); }); + return codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Add_await, fixId, ts.Diagnostics.Fix_all_expressions_possibly_missing_await); + } + function isMissingAwaitError(sourceFile, errorCode, span, cancellationToken, program) { + var checker = program.getTypeChecker(); + var diagnostics = checker.getDiagnostics(sourceFile, cancellationToken); + return ts.some(diagnostics, function (_a) { + var start = _a.start, length = _a.length, relatedInformation = _a.relatedInformation, code = _a.code; + return ts.isNumber(start) && ts.isNumber(length) && ts.textSpansEqual({ start: start, length: length }, span) && + code === errorCode && + !!relatedInformation && + ts.some(relatedInformation, function (related) { return related.code === ts.Diagnostics.Did_you_forget_to_use_await.code; }); + }); + } + function findAwaitableInitializers(expression, sourceFile, cancellationToken, program, checker) { + var identifiers = getIdentifiersFromErrorSpanExpression(expression, checker); + if (!identifiers) { + return; + } + var isCompleteFix = identifiers.isCompleteFix; + var initializers; + var _loop_11 = function (identifier) { + var symbol = checker.getSymbolAtLocation(identifier); + if (!symbol) { + return "continue"; + } + var declaration = ts.tryCast(symbol.valueDeclaration, ts.isVariableDeclaration); + var variableName = declaration && ts.tryCast(declaration.name, ts.isIdentifier); + var variableStatement = ts.getAncestor(declaration, 240 /* SyntaxKind.VariableStatement */); + if (!declaration || !variableStatement || + declaration.type || + !declaration.initializer || + variableStatement.getSourceFile() !== sourceFile || + ts.hasSyntacticModifier(variableStatement, 1 /* ModifierFlags.Export */) || + !variableName || + !isInsideAwaitableBody(declaration.initializer)) { + isCompleteFix = false; + return "continue"; + } + var diagnostics = program.getSemanticDiagnostics(sourceFile, cancellationToken); + var isUsedElsewhere = ts.FindAllReferences.Core.eachSymbolReferenceInFile(variableName, checker, sourceFile, function (reference) { + return identifier !== reference && !symbolReferenceIsAlsoMissingAwait(reference, diagnostics, sourceFile, checker); + }); + if (isUsedElsewhere) { + isCompleteFix = false; + return "continue"; + } + (initializers || (initializers = [])).push({ + expression: declaration.initializer, + declarationSymbol: symbol, + }); + }; + for (var _i = 0, _a = identifiers.identifiers; _i < _a.length; _i++) { + var identifier = _a[_i]; + _loop_11(identifier); + } + return initializers && { + initializers: initializers, + needsSecondPassForFixAll: !isCompleteFix, + }; + } + function getIdentifiersFromErrorSpanExpression(expression, checker) { + if (ts.isPropertyAccessExpression(expression.parent) && ts.isIdentifier(expression.parent.expression)) { + return { identifiers: [expression.parent.expression], isCompleteFix: true }; + } + if (ts.isIdentifier(expression)) { + return { identifiers: [expression], isCompleteFix: true }; + } + if (ts.isBinaryExpression(expression)) { + var sides = void 0; + var isCompleteFix = true; + for (var _i = 0, _a = [expression.left, expression.right]; _i < _a.length; _i++) { + var side = _a[_i]; + var type = checker.getTypeAtLocation(side); + if (checker.getPromisedTypeOfPromise(type)) { + if (!ts.isIdentifier(side)) { + isCompleteFix = false; + continue; + } + (sides || (sides = [])).push(side); + } + } + return sides && { identifiers: sides, isCompleteFix: isCompleteFix }; + } + } + function symbolReferenceIsAlsoMissingAwait(reference, diagnostics, sourceFile, checker) { + var errorNode = ts.isPropertyAccessExpression(reference.parent) ? reference.parent.name : + ts.isBinaryExpression(reference.parent) ? reference.parent : + reference; + var diagnostic = ts.find(diagnostics, function (diagnostic) { + return diagnostic.start === errorNode.getStart(sourceFile) && + (diagnostic.start + diagnostic.length) === errorNode.getEnd(); + }); + return diagnostic && ts.contains(errorCodes, diagnostic.code) || + // A Promise is usually not correct in a binary expression (it’s not valid + // in an arithmetic expression and an equality comparison seems unusual), + // but if the other side of the binary expression has an error, the side + // is typed `any` which will squash the error that would identify this + // Promise as an invalid operand. So if the whole binary expression is + // typed `any` as a result, there is a strong likelihood that this Promise + // is accidentally missing `await`. + checker.getTypeAtLocation(errorNode).flags & 1 /* TypeFlags.Any */; + } + function isInsideAwaitableBody(node) { + return node.kind & 32768 /* NodeFlags.AwaitContext */ || !!ts.findAncestor(node, function (ancestor) { + return ancestor.parent && ts.isArrowFunction(ancestor.parent) && ancestor.parent.body === ancestor || + ts.isBlock(ancestor) && (ancestor.parent.kind === 259 /* SyntaxKind.FunctionDeclaration */ || + ancestor.parent.kind === 215 /* SyntaxKind.FunctionExpression */ || + ancestor.parent.kind === 216 /* SyntaxKind.ArrowFunction */ || + ancestor.parent.kind === 171 /* SyntaxKind.MethodDeclaration */); + }); + } + function makeChange(changeTracker, errorCode, sourceFile, checker, insertionSite, fixedDeclarations) { + if (ts.isForOfStatement(insertionSite.parent) && !insertionSite.parent.awaitModifier) { + var exprType = checker.getTypeAtLocation(insertionSite); + var asyncIter = checker.getAsyncIterableType(); + if (asyncIter && checker.isTypeAssignableTo(exprType, asyncIter)) { + var forOf = insertionSite.parent; + changeTracker.replaceNode(sourceFile, forOf, ts.factory.updateForOfStatement(forOf, ts.factory.createToken(133 /* SyntaxKind.AwaitKeyword */), forOf.initializer, forOf.expression, forOf.statement)); + return; + } + } + if (ts.isBinaryExpression(insertionSite)) { + for (var _i = 0, _a = [insertionSite.left, insertionSite.right]; _i < _a.length; _i++) { + var side = _a[_i]; + if (fixedDeclarations && ts.isIdentifier(side)) { + var symbol = checker.getSymbolAtLocation(side); + if (symbol && fixedDeclarations.has(ts.getSymbolId(symbol))) { + continue; + } + } + var type = checker.getTypeAtLocation(side); + var newNode = checker.getPromisedTypeOfPromise(type) ? ts.factory.createAwaitExpression(side) : side; + changeTracker.replaceNode(sourceFile, side, newNode); + } + } + else if (errorCode === propertyAccessCode && ts.isPropertyAccessExpression(insertionSite.parent)) { + if (fixedDeclarations && ts.isIdentifier(insertionSite.parent.expression)) { + var symbol = checker.getSymbolAtLocation(insertionSite.parent.expression); + if (symbol && fixedDeclarations.has(ts.getSymbolId(symbol))) { + return; + } + } + changeTracker.replaceNode(sourceFile, insertionSite.parent.expression, ts.factory.createParenthesizedExpression(ts.factory.createAwaitExpression(insertionSite.parent.expression))); + insertLeadingSemicolonIfNeeded(changeTracker, insertionSite.parent.expression, sourceFile); + } + else if (ts.contains(callableConstructableErrorCodes, errorCode) && ts.isCallOrNewExpression(insertionSite.parent)) { + if (fixedDeclarations && ts.isIdentifier(insertionSite)) { + var symbol = checker.getSymbolAtLocation(insertionSite); + if (symbol && fixedDeclarations.has(ts.getSymbolId(symbol))) { + return; + } + } + changeTracker.replaceNode(sourceFile, insertionSite, ts.factory.createParenthesizedExpression(ts.factory.createAwaitExpression(insertionSite))); + insertLeadingSemicolonIfNeeded(changeTracker, insertionSite, sourceFile); + } + else { + if (fixedDeclarations && ts.isVariableDeclaration(insertionSite.parent) && ts.isIdentifier(insertionSite.parent.name)) { + var symbol = checker.getSymbolAtLocation(insertionSite.parent.name); + if (symbol && !ts.tryAddToSet(fixedDeclarations, ts.getSymbolId(symbol))) { + return; + } + } + changeTracker.replaceNode(sourceFile, insertionSite, ts.factory.createAwaitExpression(insertionSite)); + } + } + function insertLeadingSemicolonIfNeeded(changeTracker, beforeNode, sourceFile) { + var precedingToken = ts.findPrecedingToken(beforeNode.pos, sourceFile); + if (precedingToken && ts.positionIsASICandidate(precedingToken.end, precedingToken.parent, sourceFile)) { + changeTracker.insertText(sourceFile, beforeNode.getStart(sourceFile), ";"); + } + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "addMissingConst"; + var errorCodes = [ + ts.Diagnostics.Cannot_find_name_0.code, + ts.Diagnostics.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer.code + ]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function getCodeActionsToAddMissingConst(context) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return makeChange(t, context.sourceFile, context.span.start, context.program); }); + if (changes.length > 0) { + return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Add_const_to_unresolved_variable, fixId, ts.Diagnostics.Add_const_to_all_unresolved_variables)]; + } + }, + fixIds: [fixId], + getAllCodeActions: function (context) { + var fixedNodes = new ts.Set(); + return codefix.codeFixAll(context, errorCodes, function (changes, diag) { return makeChange(changes, diag.file, diag.start, context.program, fixedNodes); }); + }, + }); + function makeChange(changeTracker, sourceFile, pos, program, fixedNodes) { + var token = ts.getTokenAtPosition(sourceFile, pos); + var forInitializer = ts.findAncestor(token, function (node) { + return ts.isForInOrOfStatement(node.parent) ? node.parent.initializer === node : + isPossiblyPartOfDestructuring(node) ? false : "quit"; + }); + if (forInitializer) + return applyChange(changeTracker, forInitializer, sourceFile, fixedNodes); + var parent = token.parent; + if (ts.isBinaryExpression(parent) && parent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ && ts.isExpressionStatement(parent.parent)) { + return applyChange(changeTracker, token, sourceFile, fixedNodes); + } + if (ts.isArrayLiteralExpression(parent)) { + var checker_1 = program.getTypeChecker(); + if (!ts.every(parent.elements, function (element) { return arrayElementCouldBeVariableDeclaration(element, checker_1); })) { + return; + } + return applyChange(changeTracker, parent, sourceFile, fixedNodes); + } + var commaExpression = ts.findAncestor(token, function (node) { + return ts.isExpressionStatement(node.parent) ? true : + isPossiblyPartOfCommaSeperatedInitializer(node) ? false : "quit"; + }); + if (commaExpression) { + var checker = program.getTypeChecker(); + if (!expressionCouldBeVariableDeclaration(commaExpression, checker)) { + return; + } + return applyChange(changeTracker, commaExpression, sourceFile, fixedNodes); + } + } + function applyChange(changeTracker, initializer, sourceFile, fixedNodes) { + if (!fixedNodes || ts.tryAddToSet(fixedNodes, initializer)) { + changeTracker.insertModifierBefore(sourceFile, 85 /* SyntaxKind.ConstKeyword */, initializer); + } + } + function isPossiblyPartOfDestructuring(node) { + switch (node.kind) { + case 79 /* SyntaxKind.Identifier */: + case 206 /* SyntaxKind.ArrayLiteralExpression */: + case 207 /* SyntaxKind.ObjectLiteralExpression */: + case 299 /* SyntaxKind.PropertyAssignment */: + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + return true; + default: + return false; + } + } + function arrayElementCouldBeVariableDeclaration(expression, checker) { + var identifier = ts.isIdentifier(expression) ? expression : + ts.isAssignmentExpression(expression, /*excludeCompoundAssignment*/ true) && ts.isIdentifier(expression.left) ? expression.left : + undefined; + return !!identifier && !checker.getSymbolAtLocation(identifier); + } + function isPossiblyPartOfCommaSeperatedInitializer(node) { + switch (node.kind) { + case 79 /* SyntaxKind.Identifier */: + case 223 /* SyntaxKind.BinaryExpression */: + case 27 /* SyntaxKind.CommaToken */: + return true; + default: + return false; + } + } + function expressionCouldBeVariableDeclaration(expression, checker) { + if (!ts.isBinaryExpression(expression)) { + return false; + } + if (expression.operatorToken.kind === 27 /* SyntaxKind.CommaToken */) { + return ts.every([expression.left, expression.right], function (expression) { return expressionCouldBeVariableDeclaration(expression, checker); }); + } + return expression.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ + && ts.isIdentifier(expression.left) + && !checker.getSymbolAtLocation(expression.left); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "addMissingDeclareProperty"; + var errorCodes = [ + ts.Diagnostics.Property_0_will_overwrite_the_base_property_in_1_If_this_is_intentional_add_an_initializer_Otherwise_add_a_declare_modifier_or_remove_the_redundant_declaration.code, + ]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function getCodeActionsToAddMissingDeclareOnProperty(context) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return makeChange(t, context.sourceFile, context.span.start); }); + if (changes.length > 0) { + return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Prefix_with_declare, fixId, ts.Diagnostics.Prefix_all_incorrect_property_declarations_with_declare)]; + } + }, + fixIds: [fixId], + getAllCodeActions: function (context) { + var fixedNodes = new ts.Set(); + return codefix.codeFixAll(context, errorCodes, function (changes, diag) { return makeChange(changes, diag.file, diag.start, fixedNodes); }); + }, + }); + function makeChange(changeTracker, sourceFile, pos, fixedNodes) { + var token = ts.getTokenAtPosition(sourceFile, pos); + if (!ts.isIdentifier(token)) { + return; + } + var declaration = token.parent; + if (declaration.kind === 169 /* SyntaxKind.PropertyDeclaration */ && + (!fixedNodes || ts.tryAddToSet(fixedNodes, declaration))) { + changeTracker.insertModifierBefore(sourceFile, 136 /* SyntaxKind.DeclareKeyword */, declaration); + } + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "addMissingInvocationForDecorator"; + var errorCodes = [ts.Diagnostics._0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write_0.code]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function getCodeActionsToAddMissingInvocationForDecorator(context) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return makeChange(t, context.sourceFile, context.span.start); }); + return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Call_decorator_expression, fixId, ts.Diagnostics.Add_to_all_uncalled_decorators)]; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { return makeChange(changes, diag.file, diag.start); }); }, + }); + function makeChange(changeTracker, sourceFile, pos) { + var token = ts.getTokenAtPosition(sourceFile, pos); + var decorator = ts.findAncestor(token, ts.isDecorator); + ts.Debug.assert(!!decorator, "Expected position to be owned by a decorator."); + var replacement = ts.factory.createCallExpression(decorator.expression, /*typeArguments*/ undefined, /*argumentsArray*/ undefined); + changeTracker.replaceNode(sourceFile, decorator.expression, replacement); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "addNameToNamelessParameter"; + var errorCodes = [ts.Diagnostics.Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1.code]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function getCodeActionsToAddNameToNamelessParameter(context) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return makeChange(t, context.sourceFile, context.span.start); }); + return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Add_parameter_name, fixId, ts.Diagnostics.Add_names_to_all_parameters_without_names)]; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { return makeChange(changes, diag.file, diag.start); }); }, + }); + function makeChange(changeTracker, sourceFile, pos) { + var token = ts.getTokenAtPosition(sourceFile, pos); + var param = token.parent; + if (!ts.isParameter(param)) { + return ts.Debug.fail("Tried to add a parameter name to a non-parameter: " + ts.Debug.formatSyntaxKind(token.kind)); + } + var i = param.parent.parameters.indexOf(param); + ts.Debug.assert(!param.type, "Tried to add a parameter name to a parameter that already had one."); + ts.Debug.assert(i > -1, "Parameter not found in parent parameter list."); + var typeNode = ts.factory.createTypeReferenceNode(param.name, /*typeArguments*/ undefined); + var replacement = ts.factory.createParameterDeclaration(param.modifiers, param.dotDotDotToken, "arg" + i, param.questionToken, param.dotDotDotToken ? ts.factory.createArrayTypeNode(typeNode) : typeNode, param.initializer); + changeTracker.replaceNode(sourceFile, param, replacement); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var addOptionalPropertyUndefined = "addOptionalPropertyUndefined"; + var errorCodes = [ + ts.Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_type_of_the_target.code, + ts.Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties.code, + ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties.code, + ]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var typeChecker = context.program.getTypeChecker(); + var toAdd = getPropertiesToAdd(context.sourceFile, context.span, typeChecker); + if (!toAdd.length) { + return undefined; + } + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addUndefinedToOptionalProperty(t, toAdd); }); + return [codefix.createCodeFixActionWithoutFixAll(addOptionalPropertyUndefined, changes, ts.Diagnostics.Add_undefined_to_optional_property_type)]; + }, + fixIds: [addOptionalPropertyUndefined], + }); + function getPropertiesToAdd(file, span, checker) { + var _a, _b; + var sourceTarget = getSourceTarget(ts.getFixableErrorSpanExpression(file, span), checker); + if (!sourceTarget) { + return ts.emptyArray; + } + var sourceNode = sourceTarget.source, targetNode = sourceTarget.target; + var target = shouldUseParentTypeOfProperty(sourceNode, targetNode, checker) + ? checker.getTypeAtLocation(targetNode.expression) + : checker.getTypeAtLocation(targetNode); + if ((_b = (_a = target.symbol) === null || _a === void 0 ? void 0 : _a.declarations) === null || _b === void 0 ? void 0 : _b.some(function (d) { return ts.getSourceFileOfNode(d).fileName.match(/\.d\.ts$/); })) { + return ts.emptyArray; + } + return checker.getExactOptionalProperties(target); + } + function shouldUseParentTypeOfProperty(sourceNode, targetNode, checker) { + return ts.isPropertyAccessExpression(targetNode) + && !!checker.getExactOptionalProperties(checker.getTypeAtLocation(targetNode.expression)).length + && checker.getTypeAtLocation(sourceNode) === checker.getUndefinedType(); + } + /** + * Find the source and target of the incorrect assignment. + * The call is recursive for property assignments. + */ + function getSourceTarget(errorNode, checker) { + var _a; + if (!errorNode) { + return undefined; + } + else if (ts.isBinaryExpression(errorNode.parent) && errorNode.parent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */) { + return { source: errorNode.parent.right, target: errorNode.parent.left }; + } + else if (ts.isVariableDeclaration(errorNode.parent) && errorNode.parent.initializer) { + return { source: errorNode.parent.initializer, target: errorNode.parent.name }; + } + else if (ts.isCallExpression(errorNode.parent)) { + var n = checker.getSymbolAtLocation(errorNode.parent.expression); + if (!(n === null || n === void 0 ? void 0 : n.valueDeclaration) || !ts.isFunctionLikeKind(n.valueDeclaration.kind)) + return undefined; + if (!ts.isExpression(errorNode)) + return undefined; + var i = errorNode.parent.arguments.indexOf(errorNode); + if (i === -1) + return undefined; + var name = n.valueDeclaration.parameters[i].name; + if (ts.isIdentifier(name)) + return { source: errorNode, target: name }; + } + else if (ts.isPropertyAssignment(errorNode.parent) && ts.isIdentifier(errorNode.parent.name) || + ts.isShorthandPropertyAssignment(errorNode.parent)) { + var parentTarget = getSourceTarget(errorNode.parent.parent, checker); + if (!parentTarget) + return undefined; + var prop = checker.getPropertyOfType(checker.getTypeAtLocation(parentTarget.target), errorNode.parent.name.text); + var declaration = (_a = prop === null || prop === void 0 ? void 0 : prop.declarations) === null || _a === void 0 ? void 0 : _a[0]; + if (!declaration) + return undefined; + return { + source: ts.isPropertyAssignment(errorNode.parent) ? errorNode.parent.initializer : errorNode.parent.name, + target: declaration + }; + } + return undefined; + } + function addUndefinedToOptionalProperty(changes, toAdd) { + for (var _i = 0, toAdd_1 = toAdd; _i < toAdd_1.length; _i++) { + var add = toAdd_1[_i]; + var d = add.valueDeclaration; + if (d && (ts.isPropertySignature(d) || ts.isPropertyDeclaration(d)) && d.type) { + var t = ts.factory.createUnionTypeNode(__spreadArray(__spreadArray([], d.type.kind === 189 /* SyntaxKind.UnionType */ ? d.type.types : [d.type], true), [ + ts.factory.createTypeReferenceNode("undefined") + ], false)); + changes.replaceNode(d.getSourceFile(), d.type, t); + } + } + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "annotateWithTypeFromJSDoc"; + var errorCodes = [ts.Diagnostics.JSDoc_types_may_be_moved_to_TypeScript_types.code]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var decl = getDeclaration(context.sourceFile, context.span.start); + if (!decl) + return; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, context.sourceFile, decl); }); + return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Annotate_with_type_from_JSDoc, fixId, ts.Diagnostics.Annotate_everything_with_types_from_JSDoc)]; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var decl = getDeclaration(diag.file, diag.start); + if (decl) + doChange(changes, diag.file, decl); + }); }, + }); + function getDeclaration(file, pos) { + var name = ts.getTokenAtPosition(file, pos); + // For an arrow function with no name, 'name' lands on the first parameter. + return ts.tryCast(ts.isParameter(name.parent) ? name.parent.parent : name.parent, parameterShouldGetTypeFromJSDoc); + } + function parameterShouldGetTypeFromJSDoc(node) { + return isDeclarationWithType(node) && hasUsableJSDoc(node); + } + codefix.parameterShouldGetTypeFromJSDoc = parameterShouldGetTypeFromJSDoc; + function hasUsableJSDoc(decl) { + return ts.isFunctionLikeDeclaration(decl) + ? decl.parameters.some(hasUsableJSDoc) || (!decl.type && !!ts.getJSDocReturnType(decl)) + : !decl.type && !!ts.getJSDocType(decl); + } + function doChange(changes, sourceFile, decl) { + if (ts.isFunctionLikeDeclaration(decl) && (ts.getJSDocReturnType(decl) || decl.parameters.some(function (p) { return !!ts.getJSDocType(p); }))) { + if (!decl.typeParameters) { + var typeParameters = ts.getJSDocTypeParameterDeclarations(decl); + if (typeParameters.length) + changes.insertTypeParameters(sourceFile, decl, typeParameters); + } + var needParens = ts.isArrowFunction(decl) && !ts.findChildOfKind(decl, 20 /* SyntaxKind.OpenParenToken */, sourceFile); + if (needParens) + changes.insertNodeBefore(sourceFile, ts.first(decl.parameters), ts.factory.createToken(20 /* SyntaxKind.OpenParenToken */)); + for (var _i = 0, _a = decl.parameters; _i < _a.length; _i++) { + var param = _a[_i]; + if (!param.type) { + var paramType = ts.getJSDocType(param); + if (paramType) + changes.tryInsertTypeAnnotation(sourceFile, param, transformJSDocType(paramType)); + } + } + if (needParens) + changes.insertNodeAfter(sourceFile, ts.last(decl.parameters), ts.factory.createToken(21 /* SyntaxKind.CloseParenToken */)); + if (!decl.type) { + var returnType = ts.getJSDocReturnType(decl); + if (returnType) + changes.tryInsertTypeAnnotation(sourceFile, decl, transformJSDocType(returnType)); + } + } + else { + var jsdocType = ts.Debug.checkDefined(ts.getJSDocType(decl), "A JSDocType for this declaration should exist"); // If not defined, shouldn't have been an error to fix + ts.Debug.assert(!decl.type, "The JSDocType decl should have a type"); // If defined, shouldn't have been an error to fix. + changes.tryInsertTypeAnnotation(sourceFile, decl, transformJSDocType(jsdocType)); + } + } + function isDeclarationWithType(node) { + return ts.isFunctionLikeDeclaration(node) || + node.kind === 257 /* SyntaxKind.VariableDeclaration */ || + node.kind === 168 /* SyntaxKind.PropertySignature */ || + node.kind === 169 /* SyntaxKind.PropertyDeclaration */; + } + function transformJSDocType(node) { + switch (node.kind) { + case 315 /* SyntaxKind.JSDocAllType */: + case 316 /* SyntaxKind.JSDocUnknownType */: + return ts.factory.createTypeReferenceNode("any", ts.emptyArray); + case 319 /* SyntaxKind.JSDocOptionalType */: + return transformJSDocOptionalType(node); + case 318 /* SyntaxKind.JSDocNonNullableType */: + return transformJSDocType(node.type); + case 317 /* SyntaxKind.JSDocNullableType */: + return transformJSDocNullableType(node); + case 321 /* SyntaxKind.JSDocVariadicType */: + return transformJSDocVariadicType(node); + case 320 /* SyntaxKind.JSDocFunctionType */: + return transformJSDocFunctionType(node); + case 180 /* SyntaxKind.TypeReference */: + return transformJSDocTypeReference(node); + default: + var visited = ts.visitEachChild(node, transformJSDocType, ts.nullTransformationContext); + ts.setEmitFlags(visited, 1 /* EmitFlags.SingleLine */); + return visited; + } + } + function transformJSDocOptionalType(node) { + return ts.factory.createUnionTypeNode([ts.visitNode(node.type, transformJSDocType), ts.factory.createTypeReferenceNode("undefined", ts.emptyArray)]); + } + function transformJSDocNullableType(node) { + return ts.factory.createUnionTypeNode([ts.visitNode(node.type, transformJSDocType), ts.factory.createTypeReferenceNode("null", ts.emptyArray)]); + } + function transformJSDocVariadicType(node) { + return ts.factory.createArrayTypeNode(ts.visitNode(node.type, transformJSDocType)); + } + function transformJSDocFunctionType(node) { + var _a; + // TODO: This does not properly handle `function(new:C, string)` per https://github.com/google/closure-compiler/wiki/Types-in-the-Closure-Type-System#the-javascript-type-language + // however we do handle it correctly in `serializeTypeForDeclaration` in checker.ts + return ts.factory.createFunctionTypeNode(ts.emptyArray, node.parameters.map(transformJSDocParameter), (_a = node.type) !== null && _a !== void 0 ? _a : ts.factory.createKeywordTypeNode(131 /* SyntaxKind.AnyKeyword */)); + } + function transformJSDocParameter(node) { + var index = node.parent.parameters.indexOf(node); + var isRest = node.type.kind === 321 /* SyntaxKind.JSDocVariadicType */ && index === node.parent.parameters.length - 1; // TODO: GH#18217 + var name = node.name || (isRest ? "rest" : "arg" + index); + var dotdotdot = isRest ? ts.factory.createToken(25 /* SyntaxKind.DotDotDotToken */) : node.dotDotDotToken; + return ts.factory.createParameterDeclaration(node.modifiers, dotdotdot, name, node.questionToken, ts.visitNode(node.type, transformJSDocType), node.initializer); + } + function transformJSDocTypeReference(node) { + var name = node.typeName; + var args = node.typeArguments; + if (ts.isIdentifier(node.typeName)) { + if (ts.isJSDocIndexSignature(node)) { + return transformJSDocIndexSignature(node); + } + var text = node.typeName.text; + switch (node.typeName.text) { + case "String": + case "Boolean": + case "Object": + case "Number": + text = text.toLowerCase(); + break; + case "array": + case "date": + case "promise": + text = text[0].toUpperCase() + text.slice(1); + break; + } + name = ts.factory.createIdentifier(text); + if ((text === "Array" || text === "Promise") && !node.typeArguments) { + args = ts.factory.createNodeArray([ts.factory.createTypeReferenceNode("any", ts.emptyArray)]); + } + else { + args = ts.visitNodes(node.typeArguments, transformJSDocType); + } + } + return ts.factory.createTypeReferenceNode(name, args); + } + function transformJSDocIndexSignature(node) { + var index = ts.factory.createParameterDeclaration( + /*modifiers*/ undefined, + /*dotDotDotToken*/ undefined, node.typeArguments[0].kind === 148 /* SyntaxKind.NumberKeyword */ ? "n" : "s", + /*questionToken*/ undefined, ts.factory.createTypeReferenceNode(node.typeArguments[0].kind === 148 /* SyntaxKind.NumberKeyword */ ? "number" : "string", []), + /*initializer*/ undefined); + var indexSignature = ts.factory.createTypeLiteralNode([ts.factory.createIndexSignature(/*modifiers*/ undefined, [index], node.typeArguments[1])]); + ts.setEmitFlags(indexSignature, 1 /* EmitFlags.SingleLine */); + return indexSignature; + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "convertFunctionToEs6Class"; + var errorCodes = [ts.Diagnostics.This_constructor_function_may_be_converted_to_a_class_declaration.code]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { + return doChange(t, context.sourceFile, context.span.start, context.program.getTypeChecker(), context.preferences, context.program.getCompilerOptions()); + }); + return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Convert_function_to_an_ES2015_class, fixId, ts.Diagnostics.Convert_all_constructor_functions_to_classes)]; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, err) { + return doChange(changes, err.file, err.start, context.program.getTypeChecker(), context.preferences, context.program.getCompilerOptions()); + }); }, + }); + function doChange(changes, sourceFile, position, checker, preferences, compilerOptions) { + var ctorSymbol = checker.getSymbolAtLocation(ts.getTokenAtPosition(sourceFile, position)); + if (!ctorSymbol || !ctorSymbol.valueDeclaration || !(ctorSymbol.flags & (16 /* SymbolFlags.Function */ | 3 /* SymbolFlags.Variable */))) { + // Bad input + return undefined; + } + var ctorDeclaration = ctorSymbol.valueDeclaration; + if (ts.isFunctionDeclaration(ctorDeclaration) || ts.isFunctionExpression(ctorDeclaration)) { + changes.replaceNode(sourceFile, ctorDeclaration, createClassFromFunction(ctorDeclaration)); + } + else if (ts.isVariableDeclaration(ctorDeclaration)) { + var classDeclaration = createClassFromVariableDeclaration(ctorDeclaration); + if (!classDeclaration) { + return undefined; + } + var ancestor = ctorDeclaration.parent.parent; + if (ts.isVariableDeclarationList(ctorDeclaration.parent) && ctorDeclaration.parent.declarations.length > 1) { + changes.delete(sourceFile, ctorDeclaration); + changes.insertNodeAfter(sourceFile, ancestor, classDeclaration); + } + else { + changes.replaceNode(sourceFile, ancestor, classDeclaration); + } + } + function createClassElementsFromSymbol(symbol) { + var memberElements = []; + // all static members are stored in the "exports" array of symbol + if (symbol.exports) { + symbol.exports.forEach(function (member) { + if (member.name === "prototype" && member.declarations) { + var firstDeclaration = member.declarations[0]; + // only one "x.prototype = { ... }" will pass + if (member.declarations.length === 1 && + ts.isPropertyAccessExpression(firstDeclaration) && + ts.isBinaryExpression(firstDeclaration.parent) && + firstDeclaration.parent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ && + ts.isObjectLiteralExpression(firstDeclaration.parent.right)) { + var prototypes = firstDeclaration.parent.right; + createClassElement(prototypes.symbol, /** modifiers */ undefined, memberElements); + } + } + else { + createClassElement(member, [ts.factory.createToken(124 /* SyntaxKind.StaticKeyword */)], memberElements); + } + }); + } + // all instance members are stored in the "member" array of symbol (done last so instance members pulled from prototype assignments have priority) + if (symbol.members) { + symbol.members.forEach(function (member, key) { + var _a, _b, _c, _d; + if (key === "constructor" && member.valueDeclaration) { + var prototypeAssignment = (_d = (_c = (_b = (_a = symbol.exports) === null || _a === void 0 ? void 0 : _a.get("prototype")) === null || _b === void 0 ? void 0 : _b.declarations) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.parent; + if (prototypeAssignment && ts.isBinaryExpression(prototypeAssignment) && ts.isObjectLiteralExpression(prototypeAssignment.right) && ts.some(prototypeAssignment.right.properties, isConstructorAssignment)) { + // fn.prototype = { constructor: fn } + // Already deleted in `createClassElement` in first pass + } + else { + // fn.prototype.constructor = fn + changes.delete(sourceFile, member.valueDeclaration.parent); + } + return; + } + createClassElement(member, /*modifiers*/ undefined, memberElements); + }); + } + return memberElements; + function shouldConvertDeclaration(_target, source) { + // Right now the only thing we can convert are function expressions, get/set accessors and methods + // other values like normal value fields ({a: 1}) shouldn't get transformed. + // We can update this once ES public class properties are available. + if (ts.isAccessExpression(_target)) { + if (ts.isPropertyAccessExpression(_target) && isConstructorAssignment(_target)) + return true; + return ts.isFunctionLike(source); + } + else { + return ts.every(_target.properties, function (property) { + // a() {} + if (ts.isMethodDeclaration(property) || ts.isGetOrSetAccessorDeclaration(property)) + return true; + // a: function() {} + if (ts.isPropertyAssignment(property) && ts.isFunctionExpression(property.initializer) && !!property.name) + return true; + // x.prototype.constructor = fn + if (isConstructorAssignment(property)) + return true; + return false; + }); + } + } + function createClassElement(symbol, modifiers, members) { + // Right now the only thing we can convert are function expressions, which are marked as methods + // or { x: y } type prototype assignments, which are marked as ObjectLiteral + if (!(symbol.flags & 8192 /* SymbolFlags.Method */) && !(symbol.flags & 4096 /* SymbolFlags.ObjectLiteral */)) { + return; + } + var memberDeclaration = symbol.valueDeclaration; + var assignmentBinaryExpression = memberDeclaration.parent; + var assignmentExpr = assignmentBinaryExpression.right; + if (!shouldConvertDeclaration(memberDeclaration, assignmentExpr)) { + return; + } + if (ts.some(members, function (m) { + var name = ts.getNameOfDeclaration(m); + if (name && ts.isIdentifier(name) && ts.idText(name) === ts.symbolName(symbol)) { + return true; // class member already made for this name + } + return false; + })) { + return; + } + // delete the entire statement if this expression is the sole expression to take care of the semicolon at the end + var nodeToDelete = assignmentBinaryExpression.parent && assignmentBinaryExpression.parent.kind === 241 /* SyntaxKind.ExpressionStatement */ + ? assignmentBinaryExpression.parent : assignmentBinaryExpression; + changes.delete(sourceFile, nodeToDelete); + if (!assignmentExpr) { + members.push(ts.factory.createPropertyDeclaration(modifiers, symbol.name, /*questionToken*/ undefined, + /*type*/ undefined, /*initializer*/ undefined)); + return; + } + // f.x = expr + if (ts.isAccessExpression(memberDeclaration) && (ts.isFunctionExpression(assignmentExpr) || ts.isArrowFunction(assignmentExpr))) { + var quotePreference = ts.getQuotePreference(sourceFile, preferences); + var name = tryGetPropertyName(memberDeclaration, compilerOptions, quotePreference); + if (name) { + createFunctionLikeExpressionMember(members, assignmentExpr, name); + } + return; + } + // f.prototype = { ... } + else if (ts.isObjectLiteralExpression(assignmentExpr)) { + ts.forEach(assignmentExpr.properties, function (property) { + if (ts.isMethodDeclaration(property) || ts.isGetOrSetAccessorDeclaration(property)) { + // MethodDeclaration and AccessorDeclaration can appear in a class directly + members.push(property); + } + if (ts.isPropertyAssignment(property) && ts.isFunctionExpression(property.initializer)) { + createFunctionLikeExpressionMember(members, property.initializer, property.name); + } + // Drop constructor assignments + if (isConstructorAssignment(property)) + return; + return; + }); + return; + } + else { + // Don't try to declare members in JavaScript files + if (ts.isSourceFileJS(sourceFile)) + return; + if (!ts.isPropertyAccessExpression(memberDeclaration)) + return; + var prop = ts.factory.createPropertyDeclaration(modifiers, memberDeclaration.name, /*questionToken*/ undefined, /*type*/ undefined, assignmentExpr); + ts.copyLeadingComments(assignmentBinaryExpression.parent, prop, sourceFile); + members.push(prop); + return; + } + function createFunctionLikeExpressionMember(members, expression, name) { + if (ts.isFunctionExpression(expression)) + return createFunctionExpressionMember(members, expression, name); + else + return createArrowFunctionExpressionMember(members, expression, name); + } + function createFunctionExpressionMember(members, functionExpression, name) { + var fullModifiers = ts.concatenate(modifiers, getModifierKindFromSource(functionExpression, 132 /* SyntaxKind.AsyncKeyword */)); + var method = ts.factory.createMethodDeclaration(fullModifiers, /*asteriskToken*/ undefined, name, /*questionToken*/ undefined, + /*typeParameters*/ undefined, functionExpression.parameters, /*type*/ undefined, functionExpression.body); + ts.copyLeadingComments(assignmentBinaryExpression, method, sourceFile); + members.push(method); + return; + } + function createArrowFunctionExpressionMember(members, arrowFunction, name) { + var arrowFunctionBody = arrowFunction.body; + var bodyBlock; + // case 1: () => { return [1,2,3] } + if (arrowFunctionBody.kind === 238 /* SyntaxKind.Block */) { + bodyBlock = arrowFunctionBody; + } + // case 2: () => [1,2,3] + else { + bodyBlock = ts.factory.createBlock([ts.factory.createReturnStatement(arrowFunctionBody)]); + } + var fullModifiers = ts.concatenate(modifiers, getModifierKindFromSource(arrowFunction, 132 /* SyntaxKind.AsyncKeyword */)); + var method = ts.factory.createMethodDeclaration(fullModifiers, /*asteriskToken*/ undefined, name, /*questionToken*/ undefined, + /*typeParameters*/ undefined, arrowFunction.parameters, /*type*/ undefined, bodyBlock); + ts.copyLeadingComments(assignmentBinaryExpression, method, sourceFile); + members.push(method); + } + } + } + function createClassFromVariableDeclaration(node) { + var initializer = node.initializer; + if (!initializer || !ts.isFunctionExpression(initializer) || !ts.isIdentifier(node.name)) { + return undefined; + } + var memberElements = createClassElementsFromSymbol(node.symbol); + if (initializer.body) { + memberElements.unshift(ts.factory.createConstructorDeclaration(/*modifiers*/ undefined, initializer.parameters, initializer.body)); + } + var modifiers = getModifierKindFromSource(node.parent.parent, 93 /* SyntaxKind.ExportKeyword */); + var cls = ts.factory.createClassDeclaration(modifiers, node.name, + /*typeParameters*/ undefined, /*heritageClauses*/ undefined, memberElements); + // Don't call copyComments here because we'll already leave them in place + return cls; + } + function createClassFromFunction(node) { + var memberElements = createClassElementsFromSymbol(ctorSymbol); + if (node.body) { + memberElements.unshift(ts.factory.createConstructorDeclaration(/*modifiers*/ undefined, node.parameters, node.body)); + } + var modifiers = getModifierKindFromSource(node, 93 /* SyntaxKind.ExportKeyword */); + var cls = ts.factory.createClassDeclaration(modifiers, node.name, + /*typeParameters*/ undefined, /*heritageClauses*/ undefined, memberElements); + // Don't call copyComments here because we'll already leave them in place + return cls; + } + } + function getModifierKindFromSource(source, kind) { + return ts.canHaveModifiers(source) ? ts.filter(source.modifiers, function (modifier) { return modifier.kind === kind; }) : undefined; + } + function isConstructorAssignment(x) { + if (!x.name) + return false; + if (ts.isIdentifier(x.name) && x.name.text === "constructor") + return true; + return false; + } + function tryGetPropertyName(node, compilerOptions, quotePreference) { + if (ts.isPropertyAccessExpression(node)) { + return node.name; + } + var propName = node.argumentExpression; + if (ts.isNumericLiteral(propName)) { + return propName; + } + if (ts.isStringLiteralLike(propName)) { + return ts.isIdentifierText(propName.text, ts.getEmitScriptTarget(compilerOptions)) ? ts.factory.createIdentifier(propName.text) + : ts.isNoSubstitutionTemplateLiteral(propName) ? ts.factory.createStringLiteral(propName.text, quotePreference === 0 /* QuotePreference.Single */) + : propName; + } + return undefined; + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "convertToAsyncFunction"; + var errorCodes = [ts.Diagnostics.This_may_be_converted_to_an_async_function.code]; + var codeActionSucceeded = true; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + codeActionSucceeded = true; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return convertToAsyncFunction(t, context.sourceFile, context.span.start, context.program.getTypeChecker()); }); + return codeActionSucceeded ? [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Convert_to_async_function, fixId, ts.Diagnostics.Convert_all_to_async_functions)] : []; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, err) { return convertToAsyncFunction(changes, err.file, err.start, context.program.getTypeChecker()); }); }, + }); + var SynthBindingNameKind; + (function (SynthBindingNameKind) { + SynthBindingNameKind[SynthBindingNameKind["Identifier"] = 0] = "Identifier"; + SynthBindingNameKind[SynthBindingNameKind["BindingPattern"] = 1] = "BindingPattern"; + })(SynthBindingNameKind || (SynthBindingNameKind = {})); + function convertToAsyncFunction(changes, sourceFile, position, checker) { + // get the function declaration - returns a promise + var tokenAtPosition = ts.getTokenAtPosition(sourceFile, position); + var functionToConvert; + // if the parent of a FunctionLikeDeclaration is a variable declaration, the convertToAsync diagnostic will be reported on the variable name + if (ts.isIdentifier(tokenAtPosition) && ts.isVariableDeclaration(tokenAtPosition.parent) && + tokenAtPosition.parent.initializer && ts.isFunctionLikeDeclaration(tokenAtPosition.parent.initializer)) { + functionToConvert = tokenAtPosition.parent.initializer; + } + else { + functionToConvert = ts.tryCast(ts.getContainingFunction(ts.getTokenAtPosition(sourceFile, position)), ts.canBeConvertedToAsync); + } + if (!functionToConvert) { + return; + } + var synthNamesMap = new ts.Map(); + var isInJavascript = ts.isInJSFile(functionToConvert); + var setOfExpressionsToReturn = getAllPromiseExpressionsToReturn(functionToConvert, checker); + var functionToConvertRenamed = renameCollidingVarNames(functionToConvert, checker, synthNamesMap); + if (!ts.returnsPromise(functionToConvertRenamed, checker)) { + return; + } + var returnStatements = functionToConvertRenamed.body && ts.isBlock(functionToConvertRenamed.body) ? getReturnStatementsWithPromiseHandlers(functionToConvertRenamed.body, checker) : ts.emptyArray; + var transformer = { checker: checker, synthNamesMap: synthNamesMap, setOfExpressionsToReturn: setOfExpressionsToReturn, isInJSFile: isInJavascript }; + if (!returnStatements.length) { + return; + } + var pos = ts.skipTrivia(sourceFile.text, ts.moveRangePastModifiers(functionToConvert).pos); + changes.insertModifierAt(sourceFile, pos, 132 /* SyntaxKind.AsyncKeyword */, { suffix: " " }); + var _loop_12 = function (returnStatement) { + ts.forEachChild(returnStatement, function visit(node) { + if (ts.isCallExpression(node)) { + var newNodes = transformExpression(node, node, transformer, /*hasContinuation*/ false); + if (hasFailed()) { + return true; // return something truthy to shortcut out of more work + } + changes.replaceNodeWithNodes(sourceFile, returnStatement, newNodes); + } + else if (!ts.isFunctionLike(node)) { + ts.forEachChild(node, visit); + if (hasFailed()) { + return true; // return something truthy to shortcut out of more work + } + } + }); + if (hasFailed()) { + return { value: void 0 }; + } + }; + for (var _i = 0, returnStatements_1 = returnStatements; _i < returnStatements_1.length; _i++) { + var returnStatement = returnStatements_1[_i]; + var state_5 = _loop_12(returnStatement); + if (typeof state_5 === "object") + return state_5.value; + } + } + function getReturnStatementsWithPromiseHandlers(body, checker) { + var res = []; + ts.forEachReturnStatement(body, function (ret) { + if (ts.isReturnStatementWithFixablePromiseHandler(ret, checker)) + res.push(ret); + }); + return res; + } + /* + Finds all of the expressions of promise type that should not be saved in a variable during the refactor + */ + function getAllPromiseExpressionsToReturn(func, checker) { + if (!func.body) { + return new ts.Set(); + } + var setOfExpressionsToReturn = new ts.Set(); + ts.forEachChild(func.body, function visit(node) { + if (isPromiseReturningCallExpression(node, checker, "then")) { + setOfExpressionsToReturn.add(ts.getNodeId(node)); + ts.forEach(node.arguments, visit); + } + else if (isPromiseReturningCallExpression(node, checker, "catch") || + isPromiseReturningCallExpression(node, checker, "finally")) { + setOfExpressionsToReturn.add(ts.getNodeId(node)); + // if .catch() or .finally() is the last call in the chain, move leftward in the chain until we hit something else that should be returned + ts.forEachChild(node, visit); + } + else if (isPromiseTypedExpression(node, checker)) { + setOfExpressionsToReturn.add(ts.getNodeId(node)); + // don't recurse here, since we won't refactor any children or arguments of the expression + } + else { + ts.forEachChild(node, visit); + } + }); + return setOfExpressionsToReturn; + } + function isPromiseReturningCallExpression(node, checker, name) { + if (!ts.isCallExpression(node)) + return false; + var isExpressionOfName = ts.hasPropertyAccessExpressionWithName(node, name); + var nodeType = isExpressionOfName && checker.getTypeAtLocation(node); + return !!(nodeType && checker.getPromisedTypeOfPromise(nodeType)); + } + // NOTE: this is a mostly copy of `isReferenceToType` from checker.ts. While this violates DRY, it keeps + // `isReferenceToType` in checker local to the checker to avoid the cost of a property lookup on `ts`. + function isReferenceToType(type, target) { + return (ts.getObjectFlags(type) & 4 /* ObjectFlags.Reference */) !== 0 + && type.target === target; + } + function getExplicitPromisedTypeOfPromiseReturningCallExpression(node, callback, checker) { + if (node.expression.name.escapedText === "finally") { + // for a `finally`, there's no type argument + return undefined; + } + // If the call to `then` or `catch` comes from the global `Promise` or `PromiseLike` type, we can safely use the + // type argument supplied for the callback. For other promise types we would need a more complex heuristic to determine + // which type argument is safe to use as an annotation. + var promiseType = checker.getTypeAtLocation(node.expression.expression); + if (isReferenceToType(promiseType, checker.getPromiseType()) || + isReferenceToType(promiseType, checker.getPromiseLikeType())) { + if (node.expression.name.escapedText === "then") { + if (callback === ts.elementAt(node.arguments, 0)) { + // for the `onfulfilled` callback, use the first type argument + return ts.elementAt(node.typeArguments, 0); + } + else if (callback === ts.elementAt(node.arguments, 1)) { + // for the `onrejected` callback, use the second type argument + return ts.elementAt(node.typeArguments, 1); + } + } + else { + return ts.elementAt(node.typeArguments, 0); + } + } + } + function isPromiseTypedExpression(node, checker) { + if (!ts.isExpression(node)) + return false; + return !!checker.getPromisedTypeOfPromise(checker.getTypeAtLocation(node)); + } + /* + Renaming of identifiers may be necessary as the refactor changes scopes - + This function collects all existing identifier names and names of identifiers that will be created in the refactor. + It then checks for any collisions and renames them through getSynthesizedDeepClone + */ + function renameCollidingVarNames(nodeToRename, checker, synthNamesMap) { + var identsToRenameMap = new ts.Map(); // key is the symbol id + var collidingSymbolMap = ts.createMultiMap(); + ts.forEachChild(nodeToRename, function visit(node) { + if (!ts.isIdentifier(node)) { + ts.forEachChild(node, visit); + return; + } + var symbol = checker.getSymbolAtLocation(node); + if (symbol) { + var type = checker.getTypeAtLocation(node); + // Note - the choice of the last call signature is arbitrary + var lastCallSignature = getLastCallSignature(type, checker); + var symbolIdString = ts.getSymbolId(symbol).toString(); + // If the identifier refers to a function, we want to add the new synthesized variable for the declaration. Example: + // fetch('...').then(response => { ... }) + // will eventually become + // const response = await fetch('...') + // so we push an entry for 'response'. + if (lastCallSignature && !ts.isParameter(node.parent) && !ts.isFunctionLikeDeclaration(node.parent) && !synthNamesMap.has(symbolIdString)) { + var firstParameter = ts.firstOrUndefined(lastCallSignature.parameters); + var ident = (firstParameter === null || firstParameter === void 0 ? void 0 : firstParameter.valueDeclaration) + && ts.isParameter(firstParameter.valueDeclaration) + && ts.tryCast(firstParameter.valueDeclaration.name, ts.isIdentifier) + || ts.factory.createUniqueName("result", 16 /* GeneratedIdentifierFlags.Optimistic */); + var synthName = getNewNameIfConflict(ident, collidingSymbolMap); + synthNamesMap.set(symbolIdString, synthName); + collidingSymbolMap.add(ident.text, symbol); + } + // We only care about identifiers that are parameters, variable declarations, or binding elements + else if (node.parent && (ts.isParameter(node.parent) || ts.isVariableDeclaration(node.parent) || ts.isBindingElement(node.parent))) { + var originalName = node.text; + var collidingSymbols = collidingSymbolMap.get(originalName); + // if the identifier name conflicts with a different identifier that we've already seen + if (collidingSymbols && collidingSymbols.some(function (prevSymbol) { return prevSymbol !== symbol; })) { + var newName = getNewNameIfConflict(node, collidingSymbolMap); + identsToRenameMap.set(symbolIdString, newName.identifier); + synthNamesMap.set(symbolIdString, newName); + collidingSymbolMap.add(originalName, symbol); + } + else { + var identifier = ts.getSynthesizedDeepClone(node); + synthNamesMap.set(symbolIdString, createSynthIdentifier(identifier)); + collidingSymbolMap.add(originalName, symbol); + } + } + } + }); + return ts.getSynthesizedDeepCloneWithReplacements(nodeToRename, /*includeTrivia*/ true, function (original) { + if (ts.isBindingElement(original) && ts.isIdentifier(original.name) && ts.isObjectBindingPattern(original.parent)) { + var symbol = checker.getSymbolAtLocation(original.name); + var renameInfo = symbol && identsToRenameMap.get(String(ts.getSymbolId(symbol))); + if (renameInfo && renameInfo.text !== (original.name || original.propertyName).getText()) { + return ts.factory.createBindingElement(original.dotDotDotToken, original.propertyName || original.name, renameInfo, original.initializer); + } + } + else if (ts.isIdentifier(original)) { + var symbol = checker.getSymbolAtLocation(original); + var renameInfo = symbol && identsToRenameMap.get(String(ts.getSymbolId(symbol))); + if (renameInfo) { + return ts.factory.createIdentifier(renameInfo.text); + } + } + }); + } + function getNewNameIfConflict(name, originalNames) { + var numVarsSameName = (originalNames.get(name.text) || ts.emptyArray).length; + var identifier = numVarsSameName === 0 ? name : ts.factory.createIdentifier(name.text + "_" + numVarsSameName); + return createSynthIdentifier(identifier); + } + function hasFailed() { + return !codeActionSucceeded; + } + function silentFail() { + codeActionSucceeded = false; + return ts.emptyArray; + } + // dispatch function to recursively build the refactoring + // should be kept up to date with isFixablePromiseHandler in suggestionDiagnostics.ts + /** + * @param hasContinuation Whether another `then`, `catch`, or `finally` continuation follows the continuation to which this expression belongs. + * @param continuationArgName The argument name for the continuation that follows this call. + */ + function transformExpression(returnContextNode, node, transformer, hasContinuation, continuationArgName) { + if (isPromiseReturningCallExpression(node, transformer.checker, "then")) { + return transformThen(node, ts.elementAt(node.arguments, 0), ts.elementAt(node.arguments, 1), transformer, hasContinuation, continuationArgName); + } + if (isPromiseReturningCallExpression(node, transformer.checker, "catch")) { + return transformCatch(node, ts.elementAt(node.arguments, 0), transformer, hasContinuation, continuationArgName); + } + if (isPromiseReturningCallExpression(node, transformer.checker, "finally")) { + return transformFinally(node, ts.elementAt(node.arguments, 0), transformer, hasContinuation, continuationArgName); + } + if (ts.isPropertyAccessExpression(node)) { + return transformExpression(returnContextNode, node.expression, transformer, hasContinuation, continuationArgName); + } + var nodeType = transformer.checker.getTypeAtLocation(node); + if (nodeType && transformer.checker.getPromisedTypeOfPromise(nodeType)) { + ts.Debug.assertNode(ts.getOriginalNode(node).parent, ts.isPropertyAccessExpression); + return transformPromiseExpressionOfPropertyAccess(returnContextNode, node, transformer, hasContinuation, continuationArgName); + } + return silentFail(); + } + function isNullOrUndefined(_a, node) { + var checker = _a.checker; + if (node.kind === 104 /* SyntaxKind.NullKeyword */) + return true; + if (ts.isIdentifier(node) && !ts.isGeneratedIdentifier(node) && ts.idText(node) === "undefined") { + var symbol = checker.getSymbolAtLocation(node); + return !symbol || checker.isUndefinedSymbol(symbol); + } + return false; + } + function createUniqueSynthName(prevArgName) { + var renamedPrevArg = ts.factory.createUniqueName(prevArgName.identifier.text, 16 /* GeneratedIdentifierFlags.Optimistic */); + return createSynthIdentifier(renamedPrevArg); + } + function getPossibleNameForVarDecl(node, transformer, continuationArgName) { + var possibleNameForVarDecl; + // If there is another call in the chain after the .catch() or .finally() we are transforming, we will need to save the result of both paths + // (try block and catch/finally block). To do this, we will need to synthesize a variable that we were not aware of while we were adding + // identifiers to the synthNamesMap. We will use the continuationArgName and then update the synthNamesMap with a new variable name for + // the next transformation step + if (continuationArgName && !shouldReturn(node, transformer)) { + if (isSynthIdentifier(continuationArgName)) { + possibleNameForVarDecl = continuationArgName; + transformer.synthNamesMap.forEach(function (val, key) { + if (val.identifier.text === continuationArgName.identifier.text) { + var newSynthName = createUniqueSynthName(continuationArgName); + transformer.synthNamesMap.set(key, newSynthName); + } + }); + } + else { + possibleNameForVarDecl = createSynthIdentifier(ts.factory.createUniqueName("result", 16 /* GeneratedIdentifierFlags.Optimistic */), continuationArgName.types); + } + // We are about to write a 'let' variable declaration, but `transformExpression` for both + // the try block and catch/finally block will assign to this name. Setting this flag indicates + // that future assignments should be written as `name = value` instead of `const name = value`. + declareSynthIdentifier(possibleNameForVarDecl); + } + return possibleNameForVarDecl; + } + function finishCatchOrFinallyTransform(node, transformer, tryStatement, possibleNameForVarDecl, continuationArgName) { + var statements = []; + // In order to avoid an implicit any, we will synthesize a type for the declaration using the unions of the types of both paths (try block and catch block) + var varDeclIdentifier; + if (possibleNameForVarDecl && !shouldReturn(node, transformer)) { + varDeclIdentifier = ts.getSynthesizedDeepClone(declareSynthIdentifier(possibleNameForVarDecl)); + var typeArray = possibleNameForVarDecl.types; + var unionType = transformer.checker.getUnionType(typeArray, 2 /* UnionReduction.Subtype */); + var unionTypeNode = transformer.isInJSFile ? undefined : transformer.checker.typeToTypeNode(unionType, /*enclosingDeclaration*/ undefined, /*flags*/ undefined); + var varDecl = [ts.factory.createVariableDeclaration(varDeclIdentifier, /*exclamationToken*/ undefined, unionTypeNode)]; + var varDeclList = ts.factory.createVariableStatement(/*modifiers*/ undefined, ts.factory.createVariableDeclarationList(varDecl, 1 /* NodeFlags.Let */)); + statements.push(varDeclList); + } + statements.push(tryStatement); + if (continuationArgName && varDeclIdentifier && isSynthBindingPattern(continuationArgName)) { + statements.push(ts.factory.createVariableStatement( + /*modifiers*/ undefined, ts.factory.createVariableDeclarationList([ + ts.factory.createVariableDeclaration(ts.getSynthesizedDeepClone(declareSynthBindingPattern(continuationArgName)), + /*exclamationToken*/ undefined, + /*type*/ undefined, varDeclIdentifier) + ], 2 /* NodeFlags.Const */))); + } + return statements; + } + /** + * @param hasContinuation Whether another `then`, `catch`, or `finally` continuation follows this continuation. + * @param continuationArgName The argument name for the continuation that follows this call. + */ + function transformFinally(node, onFinally, transformer, hasContinuation, continuationArgName) { + if (!onFinally || isNullOrUndefined(transformer, onFinally)) { + // Ignore this call as it has no effect on the result + return transformExpression(/* returnContextNode */ node, node.expression.expression, transformer, hasContinuation, continuationArgName); + } + var possibleNameForVarDecl = getPossibleNameForVarDecl(node, transformer, continuationArgName); + // Transform the left-hand-side of `.finally` into an array of inlined statements. We pass `true` for hasContinuation as `node` is the outer continuation. + var inlinedLeftHandSide = transformExpression(/*returnContextNode*/ node, node.expression.expression, transformer, /*hasContinuation*/ true, possibleNameForVarDecl); + if (hasFailed()) + return silentFail(); // shortcut out of more work + // Transform the callback argument into an array of inlined statements. We pass whether we have an outer continuation here + // as that indicates whether `return` is valid. + var inlinedCallback = transformCallbackArgument(onFinally, hasContinuation, /*continuationArgName*/ undefined, /*argName*/ undefined, node, transformer); + if (hasFailed()) + return silentFail(); // shortcut out of more work + var tryBlock = ts.factory.createBlock(inlinedLeftHandSide); + var finallyBlock = ts.factory.createBlock(inlinedCallback); + var tryStatement = ts.factory.createTryStatement(tryBlock, /*catchClause*/ undefined, finallyBlock); + return finishCatchOrFinallyTransform(node, transformer, tryStatement, possibleNameForVarDecl, continuationArgName); + } + /** + * @param hasContinuation Whether another `then`, `catch`, or `finally` continuation follows this continuation. + * @param continuationArgName The argument name for the continuation that follows this call. + */ + function transformCatch(node, onRejected, transformer, hasContinuation, continuationArgName) { + if (!onRejected || isNullOrUndefined(transformer, onRejected)) { + // Ignore this call as it has no effect on the result + return transformExpression(/* returnContextNode */ node, node.expression.expression, transformer, hasContinuation, continuationArgName); + } + var inputArgName = getArgBindingName(onRejected, transformer); + var possibleNameForVarDecl = getPossibleNameForVarDecl(node, transformer, continuationArgName); + // Transform the left-hand-side of `.then`/`.catch` into an array of inlined statements. We pass `true` for hasContinuation as `node` is the outer continuation. + var inlinedLeftHandSide = transformExpression(/*returnContextNode*/ node, node.expression.expression, transformer, /*hasContinuation*/ true, possibleNameForVarDecl); + if (hasFailed()) + return silentFail(); // shortcut out of more work + // Transform the callback argument into an array of inlined statements. We pass whether we have an outer continuation here + // as that indicates whether `return` is valid. + var inlinedCallback = transformCallbackArgument(onRejected, hasContinuation, possibleNameForVarDecl, inputArgName, node, transformer); + if (hasFailed()) + return silentFail(); // shortcut out of more work + var tryBlock = ts.factory.createBlock(inlinedLeftHandSide); + var catchClause = ts.factory.createCatchClause(inputArgName && ts.getSynthesizedDeepClone(declareSynthBindingName(inputArgName)), ts.factory.createBlock(inlinedCallback)); + var tryStatement = ts.factory.createTryStatement(tryBlock, catchClause, /*finallyBlock*/ undefined); + return finishCatchOrFinallyTransform(node, transformer, tryStatement, possibleNameForVarDecl, continuationArgName); + } + /** + * @param hasContinuation Whether another `then`, `catch`, or `finally` continuation follows this continuation. + * @param continuationArgName The argument name for the continuation that follows this call. + */ + function transformThen(node, onFulfilled, onRejected, transformer, hasContinuation, continuationArgName) { + if (!onFulfilled || isNullOrUndefined(transformer, onFulfilled)) { + // If we don't have an `onfulfilled` callback, try treating this as a `.catch`. + return transformCatch(node, onRejected, transformer, hasContinuation, continuationArgName); + } + // We don't currently support transforming a `.then` with both onfulfilled and onrejected handlers, per GH#38152. + if (onRejected && !isNullOrUndefined(transformer, onRejected)) { + return silentFail(); + } + var inputArgName = getArgBindingName(onFulfilled, transformer); + // Transform the left-hand-side of `.then` into an array of inlined statements. We pass `true` for hasContinuation as `node` is the outer continuation. + var inlinedLeftHandSide = transformExpression(node.expression.expression, node.expression.expression, transformer, /*hasContinuation*/ true, inputArgName); + if (hasFailed()) + return silentFail(); // shortcut out of more work + // Transform the callback argument into an array of inlined statements. We pass whether we have an outer continuation here + // as that indicates whether `return` is valid. + var inlinedCallback = transformCallbackArgument(onFulfilled, hasContinuation, continuationArgName, inputArgName, node, transformer); + if (hasFailed()) + return silentFail(); // shortcut out of more work + return ts.concatenate(inlinedLeftHandSide, inlinedCallback); + } + /** + * Transforms the 'x' part of `x.then(...)`, or the 'y()' part of `y().catch(...)`, where 'x' and 'y()' are Promises. + */ + function transformPromiseExpressionOfPropertyAccess(returnContextNode, node, transformer, hasContinuation, continuationArgName) { + if (shouldReturn(returnContextNode, transformer)) { + var returnValue = ts.getSynthesizedDeepClone(node); + if (hasContinuation) { + returnValue = ts.factory.createAwaitExpression(returnValue); + } + return [ts.factory.createReturnStatement(returnValue)]; + } + return createVariableOrAssignmentOrExpressionStatement(continuationArgName, ts.factory.createAwaitExpression(node), /*typeAnnotation*/ undefined); + } + function createVariableOrAssignmentOrExpressionStatement(variableName, rightHandSide, typeAnnotation) { + if (!variableName || isEmptyBindingName(variableName)) { + // if there's no argName to assign to, there still might be side effects + return [ts.factory.createExpressionStatement(rightHandSide)]; + } + if (isSynthIdentifier(variableName) && variableName.hasBeenDeclared) { + // if the variable has already been declared, we don't need "let" or "const" + return [ts.factory.createExpressionStatement(ts.factory.createAssignment(ts.getSynthesizedDeepClone(referenceSynthIdentifier(variableName)), rightHandSide))]; + } + return [ + ts.factory.createVariableStatement( + /*modifiers*/ undefined, ts.factory.createVariableDeclarationList([ + ts.factory.createVariableDeclaration(ts.getSynthesizedDeepClone(declareSynthBindingName(variableName)), + /*exclamationToken*/ undefined, typeAnnotation, rightHandSide) + ], 2 /* NodeFlags.Const */)) + ]; + } + function maybeAnnotateAndReturn(expressionToReturn, typeAnnotation) { + if (typeAnnotation && expressionToReturn) { + var name = ts.factory.createUniqueName("result", 16 /* GeneratedIdentifierFlags.Optimistic */); + return __spreadArray(__spreadArray([], createVariableOrAssignmentOrExpressionStatement(createSynthIdentifier(name), expressionToReturn, typeAnnotation), true), [ + ts.factory.createReturnStatement(name) + ], false); + } + return [ts.factory.createReturnStatement(expressionToReturn)]; + } + // should be kept up to date with isFixablePromiseArgument in suggestionDiagnostics.ts + /** + * @param hasContinuation Whether another `then`, `catch`, or `finally` continuation follows the continuation to which this callback belongs. + * @param continuationArgName The argument name for the continuation that follows this call. + * @param inputArgName The argument name provided to this call + */ + function transformCallbackArgument(func, hasContinuation, continuationArgName, inputArgName, parent, transformer) { + var _a; + switch (func.kind) { + case 104 /* SyntaxKind.NullKeyword */: + // do not produce a transformed statement for a null argument + break; + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 79 /* SyntaxKind.Identifier */: // identifier includes undefined + if (!inputArgName) { + // undefined was argument passed to promise handler + break; + } + var synthCall = ts.factory.createCallExpression(ts.getSynthesizedDeepClone(func), /*typeArguments*/ undefined, isSynthIdentifier(inputArgName) ? [referenceSynthIdentifier(inputArgName)] : []); + if (shouldReturn(parent, transformer)) { + return maybeAnnotateAndReturn(synthCall, getExplicitPromisedTypeOfPromiseReturningCallExpression(parent, func, transformer.checker)); + } + var type = transformer.checker.getTypeAtLocation(func); + var callSignatures = transformer.checker.getSignaturesOfType(type, 0 /* SignatureKind.Call */); + if (!callSignatures.length) { + // if identifier in handler has no call signatures, it's invalid + return silentFail(); + } + var returnType = callSignatures[0].getReturnType(); + var varDeclOrAssignment = createVariableOrAssignmentOrExpressionStatement(continuationArgName, ts.factory.createAwaitExpression(synthCall), getExplicitPromisedTypeOfPromiseReturningCallExpression(parent, func, transformer.checker)); + if (continuationArgName) { + continuationArgName.types.push(transformer.checker.getAwaitedType(returnType) || returnType); + } + return varDeclOrAssignment; + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: { + var funcBody = func.body; + var returnType_1 = (_a = getLastCallSignature(transformer.checker.getTypeAtLocation(func), transformer.checker)) === null || _a === void 0 ? void 0 : _a.getReturnType(); + // Arrow functions with block bodies { } will enter this control flow + if (ts.isBlock(funcBody)) { + var refactoredStmts = []; + var seenReturnStatement = false; + for (var _i = 0, _b = funcBody.statements; _i < _b.length; _i++) { + var statement = _b[_i]; + if (ts.isReturnStatement(statement)) { + seenReturnStatement = true; + if (ts.isReturnStatementWithFixablePromiseHandler(statement, transformer.checker)) { + refactoredStmts = refactoredStmts.concat(transformReturnStatementWithFixablePromiseHandler(transformer, statement, hasContinuation, continuationArgName)); + } + else { + var possiblyAwaitedRightHandSide = returnType_1 && statement.expression ? getPossiblyAwaitedRightHandSide(transformer.checker, returnType_1, statement.expression) : statement.expression; + refactoredStmts.push.apply(refactoredStmts, maybeAnnotateAndReturn(possiblyAwaitedRightHandSide, getExplicitPromisedTypeOfPromiseReturningCallExpression(parent, func, transformer.checker))); + } + } + else if (hasContinuation && ts.forEachReturnStatement(statement, ts.returnTrue)) { + // If there is a nested `return` in a callback that has a trailing continuation, we don't transform it as the resulting complexity is too great. For example: + // + // source | result + // -------------------------------------| --------------------------------------- + // function f(): Promise { | async function f9(): Promise { + // return foo().then(() => { | await foo(); + // if (Math.random()) { | if (Math.random()) { + // return 1; | return 1; // incorrect early return + // } | } + // return 2; | return 2; // incorrect early return + // }).then(a => { | const a = undefined; + // return a + 1; | return a + 1; + // }); | } + // } | + // + // However, branching returns in the outermost continuation are acceptable as no other continuation follows it: + // + // source | result + //--------------------------------------|--------------------------------------- + // function f() { | async function f() { + // return foo().then(res => { | const res = await foo(); + // if (res.ok) { | if (res.ok) { + // return 1; | return 1; + // } | } + // else { | else { + // if (res.buffer.length > 5) { | if (res.buffer.length > 5) { + // return 2; | return 2; + // } | } + // else { | else { + // return 3; | return 3; + // } | } + // } | } + // }); | } + // } | + // + // We may improve this in the future, but for now the heuristics are too complex + return silentFail(); + } + else { + refactoredStmts.push(statement); + } + } + return shouldReturn(parent, transformer) + ? refactoredStmts.map(function (s) { return ts.getSynthesizedDeepClone(s); }) + : removeReturns(refactoredStmts, continuationArgName, transformer, seenReturnStatement); + } + else { + var inlinedStatements = ts.isFixablePromiseHandler(funcBody, transformer.checker) ? + transformReturnStatementWithFixablePromiseHandler(transformer, ts.factory.createReturnStatement(funcBody), hasContinuation, continuationArgName) : + ts.emptyArray; + if (inlinedStatements.length > 0) { + return inlinedStatements; + } + if (returnType_1) { + var possiblyAwaitedRightHandSide = getPossiblyAwaitedRightHandSide(transformer.checker, returnType_1, funcBody); + if (!shouldReturn(parent, transformer)) { + var transformedStatement = createVariableOrAssignmentOrExpressionStatement(continuationArgName, possiblyAwaitedRightHandSide, /*typeAnnotation*/ undefined); + if (continuationArgName) { + continuationArgName.types.push(transformer.checker.getAwaitedType(returnType_1) || returnType_1); + } + return transformedStatement; + } + else { + return maybeAnnotateAndReturn(possiblyAwaitedRightHandSide, getExplicitPromisedTypeOfPromiseReturningCallExpression(parent, func, transformer.checker)); + } + } + else { + return silentFail(); + } + } + } + default: + // If no cases apply, we've found a transformation body we don't know how to handle, so the refactoring should no-op to avoid deleting code. + return silentFail(); + } + return ts.emptyArray; + } + function getPossiblyAwaitedRightHandSide(checker, type, expr) { + var rightHandSide = ts.getSynthesizedDeepClone(expr); + return !!checker.getPromisedTypeOfPromise(type) ? ts.factory.createAwaitExpression(rightHandSide) : rightHandSide; + } + function getLastCallSignature(type, checker) { + var callSignatures = checker.getSignaturesOfType(type, 0 /* SignatureKind.Call */); + return ts.lastOrUndefined(callSignatures); + } + function removeReturns(stmts, prevArgName, transformer, seenReturnStatement) { + var ret = []; + for (var _i = 0, stmts_1 = stmts; _i < stmts_1.length; _i++) { + var stmt = stmts_1[_i]; + if (ts.isReturnStatement(stmt)) { + if (stmt.expression) { + var possiblyAwaitedExpression = isPromiseTypedExpression(stmt.expression, transformer.checker) ? ts.factory.createAwaitExpression(stmt.expression) : stmt.expression; + if (prevArgName === undefined) { + ret.push(ts.factory.createExpressionStatement(possiblyAwaitedExpression)); + } + else if (isSynthIdentifier(prevArgName) && prevArgName.hasBeenDeclared) { + ret.push(ts.factory.createExpressionStatement(ts.factory.createAssignment(referenceSynthIdentifier(prevArgName), possiblyAwaitedExpression))); + } + else { + ret.push(ts.factory.createVariableStatement(/*modifiers*/ undefined, (ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(declareSynthBindingName(prevArgName), /*exclamationToken*/ undefined, /*type*/ undefined, possiblyAwaitedExpression)], 2 /* NodeFlags.Const */)))); + } + } + } + else { + ret.push(ts.getSynthesizedDeepClone(stmt)); + } + } + // if block has no return statement, need to define prevArgName as undefined to prevent undeclared variables + if (!seenReturnStatement && prevArgName !== undefined) { + ret.push(ts.factory.createVariableStatement(/*modifiers*/ undefined, (ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(declareSynthBindingName(prevArgName), /*exclamationToken*/ undefined, /*type*/ undefined, ts.factory.createIdentifier("undefined"))], 2 /* NodeFlags.Const */)))); + } + return ret; + } + /** + * @param hasContinuation Whether another `then`, `catch`, or `finally` continuation follows the continuation to which this statement belongs. + * @param continuationArgName The argument name for the continuation that follows this call. + */ + function transformReturnStatementWithFixablePromiseHandler(transformer, innerRetStmt, hasContinuation, continuationArgName) { + var innerCbBody = []; + ts.forEachChild(innerRetStmt, function visit(node) { + if (ts.isCallExpression(node)) { + var temp = transformExpression(node, node, transformer, hasContinuation, continuationArgName); + innerCbBody = innerCbBody.concat(temp); + if (innerCbBody.length > 0) { + return; + } + } + else if (!ts.isFunctionLike(node)) { + ts.forEachChild(node, visit); + } + }); + return innerCbBody; + } + function getArgBindingName(funcNode, transformer) { + var types = []; + var name; + if (ts.isFunctionLikeDeclaration(funcNode)) { + if (funcNode.parameters.length > 0) { + var param = funcNode.parameters[0].name; + name = getMappedBindingNameOrDefault(param); + } + } + else if (ts.isIdentifier(funcNode)) { + name = getMapEntryOrDefault(funcNode); + } + else if (ts.isPropertyAccessExpression(funcNode) && ts.isIdentifier(funcNode.name)) { + name = getMapEntryOrDefault(funcNode.name); + } + // return undefined argName when arg is null or undefined + // eslint-disable-next-line local/no-in-operator + if (!name || "identifier" in name && name.identifier.text === "undefined") { + return undefined; + } + return name; + function getMappedBindingNameOrDefault(bindingName) { + if (ts.isIdentifier(bindingName)) + return getMapEntryOrDefault(bindingName); + var elements = ts.flatMap(bindingName.elements, function (element) { + if (ts.isOmittedExpression(element)) + return []; + return [getMappedBindingNameOrDefault(element.name)]; + }); + return createSynthBindingPattern(bindingName, elements); + } + function getMapEntryOrDefault(identifier) { + var originalNode = getOriginalNode(identifier); + var symbol = getSymbol(originalNode); + if (!symbol) { + return createSynthIdentifier(identifier, types); + } + var mapEntry = transformer.synthNamesMap.get(ts.getSymbolId(symbol).toString()); + return mapEntry || createSynthIdentifier(identifier, types); + } + function getSymbol(node) { + return node.symbol ? node.symbol : transformer.checker.getSymbolAtLocation(node); + } + function getOriginalNode(node) { + return node.original ? node.original : node; + } + } + function isEmptyBindingName(bindingName) { + if (!bindingName) { + return true; + } + if (isSynthIdentifier(bindingName)) { + return !bindingName.identifier.text; + } + return ts.every(bindingName.elements, isEmptyBindingName); + } + function createSynthIdentifier(identifier, types) { + if (types === void 0) { types = []; } + return { kind: 0 /* SynthBindingNameKind.Identifier */, identifier: identifier, types: types, hasBeenDeclared: false, hasBeenReferenced: false }; + } + function createSynthBindingPattern(bindingPattern, elements, types) { + if (elements === void 0) { elements = ts.emptyArray; } + if (types === void 0) { types = []; } + return { kind: 1 /* SynthBindingNameKind.BindingPattern */, bindingPattern: bindingPattern, elements: elements, types: types }; + } + function referenceSynthIdentifier(synthId) { + synthId.hasBeenReferenced = true; + return synthId.identifier; + } + function declareSynthBindingName(synthName) { + return isSynthIdentifier(synthName) ? declareSynthIdentifier(synthName) : declareSynthBindingPattern(synthName); + } + function declareSynthBindingPattern(synthPattern) { + for (var _i = 0, _a = synthPattern.elements; _i < _a.length; _i++) { + var element = _a[_i]; + declareSynthBindingName(element); + } + return synthPattern.bindingPattern; + } + function declareSynthIdentifier(synthId) { + synthId.hasBeenDeclared = true; + return synthId.identifier; + } + function isSynthIdentifier(bindingName) { + return bindingName.kind === 0 /* SynthBindingNameKind.Identifier */; + } + function isSynthBindingPattern(bindingName) { + return bindingName.kind === 1 /* SynthBindingNameKind.BindingPattern */; + } + function shouldReturn(expression, transformer) { + return !!expression.original && transformer.setOfExpressionsToReturn.has(ts.getNodeId(expression.original)); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + codefix.registerCodeFix({ + errorCodes: [ts.Diagnostics.File_is_a_CommonJS_module_it_may_be_converted_to_an_ES_module.code], + getCodeActions: function (context) { + var sourceFile = context.sourceFile, program = context.program, preferences = context.preferences; + var changes = ts.textChanges.ChangeTracker.with(context, function (changes) { + var moduleExportsChangedToDefault = convertFileToEsModule(sourceFile, program.getTypeChecker(), changes, ts.getEmitScriptTarget(program.getCompilerOptions()), ts.getQuotePreference(sourceFile, preferences)); + if (moduleExportsChangedToDefault) { + for (var _i = 0, _a = program.getSourceFiles(); _i < _a.length; _i++) { + var importingFile = _a[_i]; + fixImportOfModuleExports(importingFile, sourceFile, changes, ts.getQuotePreference(importingFile, preferences)); + } + } + }); + // No support for fix-all since this applies to the whole file at once anyway. + return [codefix.createCodeFixActionWithoutFixAll("convertToEsModule", changes, ts.Diagnostics.Convert_to_ES_module)]; + }, + }); + function fixImportOfModuleExports(importingFile, exportingFile, changes, quotePreference) { + for (var _i = 0, _a = importingFile.imports; _i < _a.length; _i++) { + var moduleSpecifier = _a[_i]; + var imported = ts.getResolvedModule(importingFile, moduleSpecifier.text, ts.getModeForUsageLocation(importingFile, moduleSpecifier)); + if (!imported || imported.resolvedFileName !== exportingFile.fileName) { + continue; + } + var importNode = ts.importFromModuleSpecifier(moduleSpecifier); + switch (importNode.kind) { + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + changes.replaceNode(importingFile, importNode, ts.makeImport(importNode.name, /*namedImports*/ undefined, moduleSpecifier, quotePreference)); + break; + case 210 /* SyntaxKind.CallExpression */: + if (ts.isRequireCall(importNode, /*checkArgumentIsStringLiteralLike*/ false)) { + changes.replaceNode(importingFile, importNode, ts.factory.createPropertyAccessExpression(ts.getSynthesizedDeepClone(importNode), "default")); + } + break; + } + } + } + /** @returns Whether we converted a `module.exports =` to a default export. */ + function convertFileToEsModule(sourceFile, checker, changes, target, quotePreference) { + var identifiers = { original: collectFreeIdentifiers(sourceFile), additional: new ts.Set() }; + var exports = collectExportRenames(sourceFile, checker, identifiers); + convertExportsAccesses(sourceFile, exports, changes); + var moduleExportsChangedToDefault = false; + var useSitesToUnqualify; + // Process variable statements first to collect use sites that need to be updated inside other transformations + for (var _i = 0, _a = ts.filter(sourceFile.statements, ts.isVariableStatement); _i < _a.length; _i++) { + var statement = _a[_i]; + var newUseSites = convertVariableStatement(sourceFile, statement, changes, checker, identifiers, target, quotePreference); + if (newUseSites) { + ts.copyEntries(newUseSites, useSitesToUnqualify !== null && useSitesToUnqualify !== void 0 ? useSitesToUnqualify : (useSitesToUnqualify = new ts.Map())); + } + } + // `convertStatement` will delete entries from `useSitesToUnqualify` when containing statements are replaced + for (var _b = 0, _c = ts.filter(sourceFile.statements, function (s) { return !ts.isVariableStatement(s); }); _b < _c.length; _b++) { + var statement = _c[_b]; + var moduleExportsChanged = convertStatement(sourceFile, statement, checker, changes, identifiers, target, exports, useSitesToUnqualify, quotePreference); + moduleExportsChangedToDefault = moduleExportsChangedToDefault || moduleExportsChanged; + } + // Remaining use sites can be changed directly + useSitesToUnqualify === null || useSitesToUnqualify === void 0 ? void 0 : useSitesToUnqualify.forEach(function (replacement, original) { + changes.replaceNode(sourceFile, original, replacement); + }); + return moduleExportsChangedToDefault; + } + function collectExportRenames(sourceFile, checker, identifiers) { + var res = new ts.Map(); + forEachExportReference(sourceFile, function (node) { + var _a = node.name, text = _a.text, originalKeywordKind = _a.originalKeywordKind; + if (!res.has(text) && (originalKeywordKind !== undefined && ts.isNonContextualKeyword(originalKeywordKind) + || checker.resolveName(text, node, 111551 /* SymbolFlags.Value */, /*excludeGlobals*/ true))) { + // Unconditionally add an underscore in case `text` is a keyword. + res.set(text, makeUniqueName("_".concat(text), identifiers)); + } + }); + return res; + } + function convertExportsAccesses(sourceFile, exports, changes) { + forEachExportReference(sourceFile, function (node, isAssignmentLhs) { + if (isAssignmentLhs) { + return; + } + var text = node.name.text; + changes.replaceNode(sourceFile, node, ts.factory.createIdentifier(exports.get(text) || text)); + }); + } + function forEachExportReference(sourceFile, cb) { + sourceFile.forEachChild(function recur(node) { + if (ts.isPropertyAccessExpression(node) && ts.isExportsOrModuleExportsOrAlias(sourceFile, node.expression) && ts.isIdentifier(node.name)) { + var parent = node.parent; + cb(node, ts.isBinaryExpression(parent) && parent.left === node && parent.operatorToken.kind === 63 /* SyntaxKind.EqualsToken */); + } + node.forEachChild(recur); + }); + } + function convertStatement(sourceFile, statement, checker, changes, identifiers, target, exports, useSitesToUnqualify, quotePreference) { + switch (statement.kind) { + case 240 /* SyntaxKind.VariableStatement */: + convertVariableStatement(sourceFile, statement, changes, checker, identifiers, target, quotePreference); + return false; + case 241 /* SyntaxKind.ExpressionStatement */: { + var expression = statement.expression; + switch (expression.kind) { + case 210 /* SyntaxKind.CallExpression */: { + if (ts.isRequireCall(expression, /*checkArgumentIsStringLiteralLike*/ true)) { + // For side-effecting require() call, just make a side-effecting import. + changes.replaceNode(sourceFile, statement, ts.makeImport(/*name*/ undefined, /*namedImports*/ undefined, expression.arguments[0], quotePreference)); + } + return false; + } + case 223 /* SyntaxKind.BinaryExpression */: { + var operatorToken = expression.operatorToken; + return operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ && convertAssignment(sourceFile, checker, expression, changes, exports, useSitesToUnqualify); + } + } + } + // falls through + default: + return false; + } + } + function convertVariableStatement(sourceFile, statement, changes, checker, identifiers, target, quotePreference) { + var declarationList = statement.declarationList; + var foundImport = false; + var converted = ts.map(declarationList.declarations, function (decl) { + var name = decl.name, initializer = decl.initializer; + if (initializer) { + if (ts.isExportsOrModuleExportsOrAlias(sourceFile, initializer)) { + // `const alias = module.exports;` can be removed. + foundImport = true; + return convertedImports([]); + } + else if (ts.isRequireCall(initializer, /*checkArgumentIsStringLiteralLike*/ true)) { + foundImport = true; + return convertSingleImport(name, initializer.arguments[0], checker, identifiers, target, quotePreference); + } + else if (ts.isPropertyAccessExpression(initializer) && ts.isRequireCall(initializer.expression, /*checkArgumentIsStringLiteralLike*/ true)) { + foundImport = true; + return convertPropertyAccessImport(name, initializer.name.text, initializer.expression.arguments[0], identifiers, quotePreference); + } + } + // Move it out to its own variable statement. (This will not be used if `!foundImport`) + return convertedImports([ts.factory.createVariableStatement(/*modifiers*/ undefined, ts.factory.createVariableDeclarationList([decl], declarationList.flags))]); + }); + if (foundImport) { + // useNonAdjustedEndPosition to ensure we don't eat the newline after the statement. + changes.replaceNodeWithNodes(sourceFile, statement, ts.flatMap(converted, function (c) { return c.newImports; })); + var combinedUseSites_1; + ts.forEach(converted, function (c) { + if (c.useSitesToUnqualify) { + ts.copyEntries(c.useSitesToUnqualify, combinedUseSites_1 !== null && combinedUseSites_1 !== void 0 ? combinedUseSites_1 : (combinedUseSites_1 = new ts.Map())); + } + }); + return combinedUseSites_1; + } + } + /** Converts `const name = require("moduleSpecifier").propertyName` */ + function convertPropertyAccessImport(name, propertyName, moduleSpecifier, identifiers, quotePreference) { + switch (name.kind) { + case 203 /* SyntaxKind.ObjectBindingPattern */: + case 204 /* SyntaxKind.ArrayBindingPattern */: { + // `const [a, b] = require("c").d` --> `import { d } from "c"; const [a, b] = d;` + var tmp = makeUniqueName(propertyName, identifiers); + return convertedImports([ + makeSingleImport(tmp, propertyName, moduleSpecifier, quotePreference), + makeConst(/*modifiers*/ undefined, name, ts.factory.createIdentifier(tmp)), + ]); + } + case 79 /* SyntaxKind.Identifier */: + // `const a = require("b").c` --> `import { c as a } from "./b"; + return convertedImports([makeSingleImport(name.text, propertyName, moduleSpecifier, quotePreference)]); + default: + return ts.Debug.assertNever(name, "Convert to ES module got invalid syntax form ".concat(name.kind)); + } + } + function convertAssignment(sourceFile, checker, assignment, changes, exports, useSitesToUnqualify) { + var left = assignment.left, right = assignment.right; + if (!ts.isPropertyAccessExpression(left)) { + return false; + } + if (ts.isExportsOrModuleExportsOrAlias(sourceFile, left)) { + if (ts.isExportsOrModuleExportsOrAlias(sourceFile, right)) { + // `const alias = module.exports;` or `module.exports = alias;` can be removed. + changes.delete(sourceFile, assignment.parent); + } + else { + var replacement = ts.isObjectLiteralExpression(right) ? tryChangeModuleExportsObject(right, useSitesToUnqualify) + : ts.isRequireCall(right, /*checkArgumentIsStringLiteralLike*/ true) ? convertReExportAll(right.arguments[0], checker) + : undefined; + if (replacement) { + changes.replaceNodeWithNodes(sourceFile, assignment.parent, replacement[0]); + return replacement[1]; + } + else { + changes.replaceRangeWithText(sourceFile, ts.createRange(left.getStart(sourceFile), right.pos), "export default"); + return true; + } + } + } + else if (ts.isExportsOrModuleExportsOrAlias(sourceFile, left.expression)) { + convertNamedExport(sourceFile, assignment, changes, exports); + } + return false; + } + /** + * Convert `module.exports = { ... }` to individual exports.. + * We can't always do this if the module has interesting members -- then it will be a default export instead. + */ + function tryChangeModuleExportsObject(object, useSitesToUnqualify) { + var statements = ts.mapAllOrFail(object.properties, function (prop) { + switch (prop.kind) { + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + // TODO: Maybe we should handle this? See fourslash test `refactorConvertToEs6Module_export_object_shorthand.ts`. + // falls through + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + case 301 /* SyntaxKind.SpreadAssignment */: + return undefined; + case 299 /* SyntaxKind.PropertyAssignment */: + return !ts.isIdentifier(prop.name) ? undefined : convertExportsDotXEquals_replaceNode(prop.name.text, prop.initializer, useSitesToUnqualify); + case 171 /* SyntaxKind.MethodDeclaration */: + return !ts.isIdentifier(prop.name) ? undefined : functionExpressionToDeclaration(prop.name.text, [ts.factory.createToken(93 /* SyntaxKind.ExportKeyword */)], prop, useSitesToUnqualify); + default: + ts.Debug.assertNever(prop, "Convert to ES6 got invalid prop kind ".concat(prop.kind)); + } + }); + return statements && [statements, false]; + } + function convertNamedExport(sourceFile, assignment, changes, exports) { + // If "originalKeywordKind" was set, this is e.g. `exports. + var text = assignment.left.name.text; + var rename = exports.get(text); + if (rename !== undefined) { + /* + const _class = 0; + export { _class as class }; + */ + var newNodes = [ + makeConst(/*modifiers*/ undefined, rename, assignment.right), + makeExportDeclaration([ts.factory.createExportSpecifier(/*isTypeOnly*/ false, rename, text)]), + ]; + changes.replaceNodeWithNodes(sourceFile, assignment.parent, newNodes); + } + else { + convertExportsPropertyAssignment(assignment, sourceFile, changes); + } + } + function convertReExportAll(reExported, checker) { + // `module.exports = require("x");` ==> `export * from "x"; export { default } from "x";` + var moduleSpecifier = reExported.text; + var moduleSymbol = checker.getSymbolAtLocation(reExported); + var exports = moduleSymbol ? moduleSymbol.exports : ts.emptyMap; + return exports.has("export=" /* InternalSymbolName.ExportEquals */) ? [[reExportDefault(moduleSpecifier)], true] : + !exports.has("default" /* InternalSymbolName.Default */) ? [[reExportStar(moduleSpecifier)], false] : + // If there's some non-default export, must include both `export *` and `export default`. + exports.size > 1 ? [[reExportStar(moduleSpecifier), reExportDefault(moduleSpecifier)], true] : [[reExportDefault(moduleSpecifier)], true]; + } + function reExportStar(moduleSpecifier) { + return makeExportDeclaration(/*exportClause*/ undefined, moduleSpecifier); + } + function reExportDefault(moduleSpecifier) { + return makeExportDeclaration([ts.factory.createExportSpecifier(/*isTypeOnly*/ false, /*propertyName*/ undefined, "default")], moduleSpecifier); + } + function convertExportsPropertyAssignment(_a, sourceFile, changes) { + var left = _a.left, right = _a.right, parent = _a.parent; + var name = left.name.text; + if ((ts.isFunctionExpression(right) || ts.isArrowFunction(right) || ts.isClassExpression(right)) && (!right.name || right.name.text === name)) { + // `exports.f = function() {}` -> `export function f() {}` -- Replace `exports.f = ` with `export `, and insert the name after `function`. + changes.replaceRange(sourceFile, { pos: left.getStart(sourceFile), end: right.getStart(sourceFile) }, ts.factory.createToken(93 /* SyntaxKind.ExportKeyword */), { suffix: " " }); + if (!right.name) + changes.insertName(sourceFile, right, name); + var semi = ts.findChildOfKind(parent, 26 /* SyntaxKind.SemicolonToken */, sourceFile); + if (semi) + changes.delete(sourceFile, semi); + } + else { + // `exports.f = function g() {}` -> `export const f = function g() {}` -- just replace `exports.` with `export const ` + changes.replaceNodeRangeWithNodes(sourceFile, left.expression, ts.findChildOfKind(left, 24 /* SyntaxKind.DotToken */, sourceFile), [ts.factory.createToken(93 /* SyntaxKind.ExportKeyword */), ts.factory.createToken(85 /* SyntaxKind.ConstKeyword */)], { joiner: " ", suffix: " " }); + } + } + // TODO: GH#22492 this will cause an error if a change has been made inside the body of the node. + function convertExportsDotXEquals_replaceNode(name, exported, useSitesToUnqualify) { + var modifiers = [ts.factory.createToken(93 /* SyntaxKind.ExportKeyword */)]; + switch (exported.kind) { + case 215 /* SyntaxKind.FunctionExpression */: { + var expressionName = exported.name; + if (expressionName && expressionName.text !== name) { + // `exports.f = function g() {}` -> `export const f = function g() {}` + return exportConst(); + } + } + // falls through + case 216 /* SyntaxKind.ArrowFunction */: + // `exports.f = function() {}` --> `export function f() {}` + return functionExpressionToDeclaration(name, modifiers, exported, useSitesToUnqualify); + case 228 /* SyntaxKind.ClassExpression */: + // `exports.C = class {}` --> `export class C {}` + return classExpressionToDeclaration(name, modifiers, exported, useSitesToUnqualify); + default: + return exportConst(); + } + function exportConst() { + // `exports.x = 0;` --> `export const x = 0;` + return makeConst(modifiers, ts.factory.createIdentifier(name), replaceImportUseSites(exported, useSitesToUnqualify)); // TODO: GH#18217 + } + } + function replaceImportUseSites(nodeOrNodes, useSitesToUnqualify) { + if (!useSitesToUnqualify || !ts.some(ts.arrayFrom(useSitesToUnqualify.keys()), function (original) { return ts.rangeContainsRange(nodeOrNodes, original); })) { + return nodeOrNodes; + } + return ts.isArray(nodeOrNodes) + ? ts.getSynthesizedDeepClonesWithReplacements(nodeOrNodes, /*includeTrivia*/ true, replaceNode) + : ts.getSynthesizedDeepCloneWithReplacements(nodeOrNodes, /*includeTrivia*/ true, replaceNode); + function replaceNode(original) { + // We are replacing `mod.SomeExport` wih `SomeExport`, so we only need to look at PropertyAccessExpressions + if (original.kind === 208 /* SyntaxKind.PropertyAccessExpression */) { + var replacement = useSitesToUnqualify.get(original); + // Remove entry from `useSitesToUnqualify` so the refactor knows it's taken care of by the parent statement we're replacing + useSitesToUnqualify.delete(original); + return replacement; + } + } + } + /** + * Converts `const <> = require("x");`. + * Returns nodes that will replace the variable declaration for the commonjs import. + * May also make use `changes` to remove qualifiers at the use sites of imports, to change `mod.x` to `x`. + */ + function convertSingleImport(name, moduleSpecifier, checker, identifiers, target, quotePreference) { + switch (name.kind) { + case 203 /* SyntaxKind.ObjectBindingPattern */: { + var importSpecifiers = ts.mapAllOrFail(name.elements, function (e) { + return e.dotDotDotToken || e.initializer || e.propertyName && !ts.isIdentifier(e.propertyName) || !ts.isIdentifier(e.name) + ? undefined + : makeImportSpecifier(e.propertyName && e.propertyName.text, e.name.text); + }); + if (importSpecifiers) { + return convertedImports([ts.makeImport(/*name*/ undefined, importSpecifiers, moduleSpecifier, quotePreference)]); + } + } + // falls through -- object destructuring has an interesting pattern and must be a variable declaration + case 204 /* SyntaxKind.ArrayBindingPattern */: { + /* + import x from "x"; + const [a, b, c] = x; + */ + var tmp = makeUniqueName(codefix.moduleSpecifierToValidIdentifier(moduleSpecifier.text, target), identifiers); + return convertedImports([ + ts.makeImport(ts.factory.createIdentifier(tmp), /*namedImports*/ undefined, moduleSpecifier, quotePreference), + makeConst(/*modifiers*/ undefined, ts.getSynthesizedDeepClone(name), ts.factory.createIdentifier(tmp)), + ]); + } + case 79 /* SyntaxKind.Identifier */: + return convertSingleIdentifierImport(name, moduleSpecifier, checker, identifiers, quotePreference); + default: + return ts.Debug.assertNever(name, "Convert to ES module got invalid name kind ".concat(name.kind)); + } + } + /** + * Convert `import x = require("x").` + * Also: + * - Convert `x.default()` to `x()` to handle ES6 default export + * - Converts uses like `x.y()` to `y()` and uses a named import. + */ + function convertSingleIdentifierImport(name, moduleSpecifier, checker, identifiers, quotePreference) { + var nameSymbol = checker.getSymbolAtLocation(name); + // Maps from module property name to name actually used. (The same if there isn't shadowing.) + var namedBindingsNames = new ts.Map(); + // True if there is some non-property use like `x()` or `f(x)`. + var needDefaultImport = false; + var useSitesToUnqualify; + for (var _i = 0, _a = identifiers.original.get(name.text); _i < _a.length; _i++) { + var use = _a[_i]; + if (checker.getSymbolAtLocation(use) !== nameSymbol || use === name) { + // This was a use of a different symbol with the same name, due to shadowing. Ignore. + continue; + } + var parent = use.parent; + if (ts.isPropertyAccessExpression(parent)) { + var propertyName = parent.name.text; + if (propertyName === "default") { + needDefaultImport = true; + var importDefaultName = use.getText(); + (useSitesToUnqualify !== null && useSitesToUnqualify !== void 0 ? useSitesToUnqualify : (useSitesToUnqualify = new ts.Map())).set(parent, ts.factory.createIdentifier(importDefaultName)); + } + else { + ts.Debug.assert(parent.expression === use, "Didn't expect expression === use"); // Else shouldn't have been in `collectIdentifiers` + var idName = namedBindingsNames.get(propertyName); + if (idName === undefined) { + idName = makeUniqueName(propertyName, identifiers); + namedBindingsNames.set(propertyName, idName); + } + (useSitesToUnqualify !== null && useSitesToUnqualify !== void 0 ? useSitesToUnqualify : (useSitesToUnqualify = new ts.Map())).set(parent, ts.factory.createIdentifier(idName)); + } + } + else { + needDefaultImport = true; + } + } + var namedBindings = namedBindingsNames.size === 0 ? undefined : ts.arrayFrom(ts.mapIterator(namedBindingsNames.entries(), function (_a) { + var propertyName = _a[0], idName = _a[1]; + return ts.factory.createImportSpecifier(/*isTypeOnly*/ false, propertyName === idName ? undefined : ts.factory.createIdentifier(propertyName), ts.factory.createIdentifier(idName)); + })); + if (!namedBindings) { + // If it was unused, ensure that we at least import *something*. + needDefaultImport = true; + } + return convertedImports([ts.makeImport(needDefaultImport ? ts.getSynthesizedDeepClone(name) : undefined, namedBindings, moduleSpecifier, quotePreference)], useSitesToUnqualify); + } + // Identifiers helpers + function makeUniqueName(name, identifiers) { + while (identifiers.original.has(name) || identifiers.additional.has(name)) { + name = "_".concat(name); + } + identifiers.additional.add(name); + return name; + } + function collectFreeIdentifiers(file) { + var map = ts.createMultiMap(); + forEachFreeIdentifier(file, function (id) { return map.add(id.text, id); }); + return map; + } + /** + * A free identifier is an identifier that can be accessed through name lookup as a local variable. + * In the expression `x.y`, `x` is a free identifier, but `y` is not. + */ + function forEachFreeIdentifier(node, cb) { + if (ts.isIdentifier(node) && isFreeIdentifier(node)) + cb(node); + node.forEachChild(function (child) { return forEachFreeIdentifier(child, cb); }); + } + function isFreeIdentifier(node) { + var parent = node.parent; + switch (parent.kind) { + case 208 /* SyntaxKind.PropertyAccessExpression */: + return parent.name !== node; + case 205 /* SyntaxKind.BindingElement */: + return parent.propertyName !== node; + case 273 /* SyntaxKind.ImportSpecifier */: + return parent.propertyName !== node; + default: + return true; + } + } + // Node helpers + function functionExpressionToDeclaration(name, additionalModifiers, fn, useSitesToUnqualify) { + return ts.factory.createFunctionDeclaration(ts.concatenate(additionalModifiers, ts.getSynthesizedDeepClones(fn.modifiers)), ts.getSynthesizedDeepClone(fn.asteriskToken), name, ts.getSynthesizedDeepClones(fn.typeParameters), ts.getSynthesizedDeepClones(fn.parameters), ts.getSynthesizedDeepClone(fn.type), ts.factory.converters.convertToFunctionBlock(replaceImportUseSites(fn.body, useSitesToUnqualify))); + } + function classExpressionToDeclaration(name, additionalModifiers, cls, useSitesToUnqualify) { + return ts.factory.createClassDeclaration(ts.concatenate(additionalModifiers, ts.getSynthesizedDeepClones(cls.modifiers)), name, ts.getSynthesizedDeepClones(cls.typeParameters), ts.getSynthesizedDeepClones(cls.heritageClauses), replaceImportUseSites(cls.members, useSitesToUnqualify)); + } + function makeSingleImport(localName, propertyName, moduleSpecifier, quotePreference) { + return propertyName === "default" + ? ts.makeImport(ts.factory.createIdentifier(localName), /*namedImports*/ undefined, moduleSpecifier, quotePreference) + : ts.makeImport(/*name*/ undefined, [makeImportSpecifier(propertyName, localName)], moduleSpecifier, quotePreference); + } + function makeImportSpecifier(propertyName, name) { + return ts.factory.createImportSpecifier(/*isTypeOnly*/ false, propertyName !== undefined && propertyName !== name ? ts.factory.createIdentifier(propertyName) : undefined, ts.factory.createIdentifier(name)); + } + function makeConst(modifiers, name, init) { + return ts.factory.createVariableStatement(modifiers, ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(name, /*exclamationToken*/ undefined, /*type*/ undefined, init)], 2 /* NodeFlags.Const */)); + } + function makeExportDeclaration(exportSpecifiers, moduleSpecifier) { + return ts.factory.createExportDeclaration( + /*modifiers*/ undefined, + /*isTypeOnly*/ false, exportSpecifiers && ts.factory.createNamedExports(exportSpecifiers), moduleSpecifier === undefined ? undefined : ts.factory.createStringLiteral(moduleSpecifier)); + } + function convertedImports(newImports, useSitesToUnqualify) { + return { + newImports: newImports, + useSitesToUnqualify: useSitesToUnqualify + }; + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "correctQualifiedNameToIndexedAccessType"; + var errorCodes = [ts.Diagnostics.Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_property_1_in_0_with_0_1.code]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var qualifiedName = getQualifiedName(context.sourceFile, context.span.start); + if (!qualifiedName) + return undefined; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, context.sourceFile, qualifiedName); }); + var newText = "".concat(qualifiedName.left.text, "[\"").concat(qualifiedName.right.text, "\"]"); + return [codefix.createCodeFixAction(fixId, changes, [ts.Diagnostics.Rewrite_as_the_indexed_access_type_0, newText], fixId, ts.Diagnostics.Rewrite_all_as_indexed_access_types)]; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var q = getQualifiedName(diag.file, diag.start); + if (q) { + doChange(changes, diag.file, q); + } + }); }, + }); + function getQualifiedName(sourceFile, pos) { + var qualifiedName = ts.findAncestor(ts.getTokenAtPosition(sourceFile, pos), ts.isQualifiedName); + ts.Debug.assert(!!qualifiedName, "Expected position to be owned by a qualified name."); + return ts.isIdentifier(qualifiedName.left) ? qualifiedName : undefined; + } + function doChange(changeTracker, sourceFile, qualifiedName) { + var rightText = qualifiedName.right.text; + var replacement = ts.factory.createIndexedAccessTypeNode(ts.factory.createTypeReferenceNode(qualifiedName.left, /*typeArguments*/ undefined), ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral(rightText))); + changeTracker.replaceNode(sourceFile, qualifiedName, replacement); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var errorCodes = [ts.Diagnostics.Re_exporting_a_type_when_the_isolatedModules_flag_is_provided_requires_using_export_type.code]; + var fixId = "convertToTypeOnlyExport"; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function getCodeActionsToConvertToTypeOnlyExport(context) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return fixSingleExportDeclaration(t, getExportSpecifierForDiagnosticSpan(context.span, context.sourceFile), context); }); + if (changes.length) { + return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Convert_to_type_only_export, fixId, ts.Diagnostics.Convert_all_re_exported_types_to_type_only_exports)]; + } + }, + fixIds: [fixId], + getAllCodeActions: function getAllCodeActionsToConvertToTypeOnlyExport(context) { + var fixedExportDeclarations = new ts.Map(); + return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var exportSpecifier = getExportSpecifierForDiagnosticSpan(diag, context.sourceFile); + if (exportSpecifier && ts.addToSeen(fixedExportDeclarations, ts.getNodeId(exportSpecifier.parent.parent))) { + fixSingleExportDeclaration(changes, exportSpecifier, context); + } + }); + } + }); + function getExportSpecifierForDiagnosticSpan(span, sourceFile) { + return ts.tryCast(ts.getTokenAtPosition(sourceFile, span.start).parent, ts.isExportSpecifier); + } + function fixSingleExportDeclaration(changes, exportSpecifier, context) { + if (!exportSpecifier) { + return; + } + var exportClause = exportSpecifier.parent; + var exportDeclaration = exportClause.parent; + var typeExportSpecifiers = getTypeExportSpecifiers(exportSpecifier, context); + if (typeExportSpecifiers.length === exportClause.elements.length) { + changes.insertModifierBefore(context.sourceFile, 154 /* SyntaxKind.TypeKeyword */, exportClause); + } + else { + var valueExportDeclaration = ts.factory.updateExportDeclaration(exportDeclaration, exportDeclaration.modifiers, + /*isTypeOnly*/ false, ts.factory.updateNamedExports(exportClause, ts.filter(exportClause.elements, function (e) { return !ts.contains(typeExportSpecifiers, e); })), exportDeclaration.moduleSpecifier, + /*assertClause*/ undefined); + var typeExportDeclaration = ts.factory.createExportDeclaration( + /*modifiers*/ undefined, + /*isTypeOnly*/ true, ts.factory.createNamedExports(typeExportSpecifiers), exportDeclaration.moduleSpecifier, + /*assertClause*/ undefined); + changes.replaceNode(context.sourceFile, exportDeclaration, valueExportDeclaration, { + leadingTriviaOption: ts.textChanges.LeadingTriviaOption.IncludeAll, + trailingTriviaOption: ts.textChanges.TrailingTriviaOption.Exclude + }); + changes.insertNodeAfter(context.sourceFile, exportDeclaration, typeExportDeclaration); + } + } + function getTypeExportSpecifiers(originExportSpecifier, context) { + var exportClause = originExportSpecifier.parent; + if (exportClause.elements.length === 1) { + return exportClause.elements; + } + var diagnostics = ts.getDiagnosticsWithinSpan(ts.createTextSpanFromNode(exportClause), context.program.getSemanticDiagnostics(context.sourceFile, context.cancellationToken)); + return ts.filter(exportClause.elements, function (element) { + var _a; + return element === originExportSpecifier || ((_a = ts.findDiagnosticForNode(element, diagnostics)) === null || _a === void 0 ? void 0 : _a.code) === errorCodes[0]; + }); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var errorCodes = [ts.Diagnostics.This_import_is_never_used_as_a_value_and_must_use_import_type_because_importsNotUsedAsValues_is_set_to_error.code]; + var fixId = "convertToTypeOnlyImport"; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function getCodeActionsToConvertToTypeOnlyImport(context) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { + var importDeclaration = getImportDeclarationForDiagnosticSpan(context.span, context.sourceFile); + fixSingleImportDeclaration(t, importDeclaration, context); + }); + if (changes.length) { + return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Convert_to_type_only_import, fixId, ts.Diagnostics.Convert_all_imports_not_used_as_a_value_to_type_only_imports)]; + } + }, + fixIds: [fixId], + getAllCodeActions: function getAllCodeActionsToConvertToTypeOnlyImport(context) { + return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var importDeclaration = getImportDeclarationForDiagnosticSpan(diag, context.sourceFile); + fixSingleImportDeclaration(changes, importDeclaration, context); + }); + } + }); + function getImportDeclarationForDiagnosticSpan(span, sourceFile) { + return ts.tryCast(ts.getTokenAtPosition(sourceFile, span.start).parent, ts.isImportDeclaration); + } + function fixSingleImportDeclaration(changes, importDeclaration, context) { + if (!(importDeclaration === null || importDeclaration === void 0 ? void 0 : importDeclaration.importClause)) { + return; + } + var importClause = importDeclaration.importClause; + // `changes.insertModifierBefore` produces a range that might overlap further changes + changes.insertText(context.sourceFile, importDeclaration.getStart() + "import".length, " type"); + // `import type foo, { Bar }` is not allowed, so move `foo` to new declaration + if (importClause.name && importClause.namedBindings) { + changes.deleteNodeRangeExcludingEnd(context.sourceFile, importClause.name, importDeclaration.importClause.namedBindings); + changes.insertNodeBefore(context.sourceFile, importDeclaration, ts.factory.updateImportDeclaration(importDeclaration, + /*modifiers*/ undefined, ts.factory.createImportClause( + /*isTypeOnly*/ true, importClause.name, + /*namedBindings*/ undefined), importDeclaration.moduleSpecifier, + /*assertClause*/ undefined)); + } + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "convertLiteralTypeToMappedType"; + var errorCodes = [ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Did_you_mean_to_use_1_in_0.code]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function getCodeActionsToConvertLiteralTypeToMappedType(context) { + var sourceFile = context.sourceFile, span = context.span; + var info = getInfo(sourceFile, span.start); + if (!info) { + return undefined; + } + var name = info.name, constraint = info.constraint; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, sourceFile, info); }); + return [codefix.createCodeFixAction(fixId, changes, [ts.Diagnostics.Convert_0_to_1_in_0, constraint, name], fixId, ts.Diagnostics.Convert_all_type_literals_to_mapped_type)]; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var info = getInfo(diag.file, diag.start); + if (info) { + doChange(changes, diag.file, info); + } + }); } + }); + function getInfo(sourceFile, pos) { + var token = ts.getTokenAtPosition(sourceFile, pos); + if (ts.isIdentifier(token)) { + var propertySignature = ts.cast(token.parent.parent, ts.isPropertySignature); + var propertyName = token.getText(sourceFile); + return { + container: ts.cast(propertySignature.parent, ts.isTypeLiteralNode), + typeNode: propertySignature.type, + constraint: propertyName, + name: propertyName === "K" ? "P" : "K", + }; + } + return undefined; + } + function doChange(changes, sourceFile, _a) { + var container = _a.container, typeNode = _a.typeNode, constraint = _a.constraint, name = _a.name; + changes.replaceNode(sourceFile, container, ts.factory.createMappedTypeNode( + /*readonlyToken*/ undefined, ts.factory.createTypeParameterDeclaration(/*modifiers*/ undefined, name, ts.factory.createTypeReferenceNode(constraint)), + /*nameType*/ undefined, + /*questionToken*/ undefined, typeNode, + /*members*/ undefined)); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var errorCodes = [ + ts.Diagnostics.Class_0_incorrectly_implements_interface_1.code, + ts.Diagnostics.Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass.code + ]; + var fixId = "fixClassIncorrectlyImplementsInterface"; // TODO: share a group with fixClassDoesntImplementInheritedAbstractMember? + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var sourceFile = context.sourceFile, span = context.span; + var classDeclaration = getClass(sourceFile, span.start); + return ts.mapDefined(ts.getEffectiveImplementsTypeNodes(classDeclaration), function (implementedTypeNode) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addMissingDeclarations(context, implementedTypeNode, sourceFile, classDeclaration, t, context.preferences); }); + return changes.length === 0 ? undefined : codefix.createCodeFixAction(fixId, changes, [ts.Diagnostics.Implement_interface_0, implementedTypeNode.getText(sourceFile)], fixId, ts.Diagnostics.Implement_all_unimplemented_interfaces); + }); + }, + fixIds: [fixId], + getAllCodeActions: function (context) { + var seenClassDeclarations = new ts.Map(); + return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var classDeclaration = getClass(diag.file, diag.start); + if (ts.addToSeen(seenClassDeclarations, ts.getNodeId(classDeclaration))) { + for (var _i = 0, _a = ts.getEffectiveImplementsTypeNodes(classDeclaration); _i < _a.length; _i++) { + var implementedTypeNode = _a[_i]; + addMissingDeclarations(context, implementedTypeNode, diag.file, classDeclaration, changes, context.preferences); + } + } + }); + }, + }); + function getClass(sourceFile, pos) { + return ts.Debug.checkDefined(ts.getContainingClass(ts.getTokenAtPosition(sourceFile, pos)), "There should be a containing class"); + } + function symbolPointsToNonPrivateMember(symbol) { + return !symbol.valueDeclaration || !(ts.getEffectiveModifierFlags(symbol.valueDeclaration) & 8 /* ModifierFlags.Private */); + } + function addMissingDeclarations(context, implementedTypeNode, sourceFile, classDeclaration, changeTracker, preferences) { + var checker = context.program.getTypeChecker(); + var maybeHeritageClauseSymbol = getHeritageClauseSymbolTable(classDeclaration, checker); + // Note that this is ultimately derived from a map indexed by symbol names, + // so duplicates cannot occur. + var implementedType = checker.getTypeAtLocation(implementedTypeNode); + var implementedTypeSymbols = checker.getPropertiesOfType(implementedType); + var nonPrivateAndNotExistedInHeritageClauseMembers = implementedTypeSymbols.filter(ts.and(symbolPointsToNonPrivateMember, function (symbol) { return !maybeHeritageClauseSymbol.has(symbol.escapedName); })); + var classType = checker.getTypeAtLocation(classDeclaration); + var constructor = ts.find(classDeclaration.members, function (m) { return ts.isConstructorDeclaration(m); }); + if (!classType.getNumberIndexType()) { + createMissingIndexSignatureDeclaration(implementedType, 1 /* IndexKind.Number */); + } + if (!classType.getStringIndexType()) { + createMissingIndexSignatureDeclaration(implementedType, 0 /* IndexKind.String */); + } + var importAdder = codefix.createImportAdder(sourceFile, context.program, preferences, context.host); + codefix.createMissingMemberNodes(classDeclaration, nonPrivateAndNotExistedInHeritageClauseMembers, sourceFile, context, preferences, importAdder, function (member) { return insertInterfaceMemberNode(sourceFile, classDeclaration, member); }); + importAdder.writeFixes(changeTracker); + function createMissingIndexSignatureDeclaration(type, kind) { + var indexInfoOfKind = checker.getIndexInfoOfType(type, kind); + if (indexInfoOfKind) { + insertInterfaceMemberNode(sourceFile, classDeclaration, checker.indexInfoToIndexSignatureDeclaration(indexInfoOfKind, classDeclaration, /*flags*/ undefined, codefix.getNoopSymbolTrackerWithResolver(context))); + } + } + // Either adds the node at the top of the class, or if there's a constructor right after that + function insertInterfaceMemberNode(sourceFile, cls, newElement) { + if (constructor) { + changeTracker.insertNodeAfter(sourceFile, constructor, newElement); + } + else { + changeTracker.insertMemberAtStart(sourceFile, cls, newElement); + } + } + } + function getHeritageClauseSymbolTable(classDeclaration, checker) { + var heritageClauseNode = ts.getEffectiveBaseTypeNode(classDeclaration); + if (!heritageClauseNode) + return ts.createSymbolTable(); + var heritageClauseType = checker.getTypeAtLocation(heritageClauseNode); + var heritageClauseTypeSymbols = checker.getPropertiesOfType(heritageClauseType); + return ts.createSymbolTable(heritageClauseTypeSymbols.filter(symbolPointsToNonPrivateMember)); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + codefix.importFixName = "import"; + var importFixId = "fixMissingImport"; + var errorCodes = [ + ts.Diagnostics.Cannot_find_name_0.code, + ts.Diagnostics.Cannot_find_name_0_Did_you_mean_1.code, + ts.Diagnostics.Cannot_find_name_0_Did_you_mean_the_instance_member_this_0.code, + ts.Diagnostics.Cannot_find_name_0_Did_you_mean_the_static_member_1_0.code, + ts.Diagnostics.Cannot_find_namespace_0.code, + ts.Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead.code, + ts.Diagnostics._0_only_refers_to_a_type_but_is_being_used_as_a_value_here.code, + ts.Diagnostics.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer.code, + ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type.code, + ]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var errorCode = context.errorCode, preferences = context.preferences, sourceFile = context.sourceFile, span = context.span, program = context.program; + var info = getFixInfos(context, errorCode, span.start, /*useAutoImportProvider*/ true); + if (!info) + return undefined; + var quotePreference = ts.getQuotePreference(sourceFile, preferences); + return info.map(function (_a) { + var fix = _a.fix, symbolName = _a.symbolName, errorIdentifierText = _a.errorIdentifierText; + return codeActionForFix(context, sourceFile, symbolName, fix, + /*includeSymbolNameInDescription*/ symbolName !== errorIdentifierText, quotePreference, program.getCompilerOptions()); + }); + }, + fixIds: [importFixId], + getAllCodeActions: function (context) { + var sourceFile = context.sourceFile, program = context.program, preferences = context.preferences, host = context.host, cancellationToken = context.cancellationToken; + var importAdder = createImportAdderWorker(sourceFile, program, /*useAutoImportProvider*/ true, preferences, host, cancellationToken); + codefix.eachDiagnostic(context, errorCodes, function (diag) { return importAdder.addImportFromDiagnostic(diag, context); }); + return codefix.createCombinedCodeActions(ts.textChanges.ChangeTracker.with(context, importAdder.writeFixes)); + }, + }); + function createImportAdder(sourceFile, program, preferences, host, cancellationToken) { + return createImportAdderWorker(sourceFile, program, /*useAutoImportProvider*/ false, preferences, host, cancellationToken); + } + codefix.createImportAdder = createImportAdder; + function createImportAdderWorker(sourceFile, program, useAutoImportProvider, preferences, host, cancellationToken) { + var compilerOptions = program.getCompilerOptions(); + // Namespace fixes don't conflict, so just build a list. + var addToNamespace = []; + var importType = []; + /** Keys are import clause node IDs. */ + var addToExisting = new ts.Map(); + /** Use `getNewImportEntry` for access */ + var newImports = new ts.Map(); + return { addImportFromDiagnostic: addImportFromDiagnostic, addImportFromExportedSymbol: addImportFromExportedSymbol, writeFixes: writeFixes, hasFixes: hasFixes }; + function addImportFromDiagnostic(diagnostic, context) { + var info = getFixInfos(context, diagnostic.code, diagnostic.start, useAutoImportProvider); + if (!info || !info.length) + return; + addImport(ts.first(info)); + } + function addImportFromExportedSymbol(exportedSymbol, isValidTypeOnlyUseSite) { + var moduleSymbol = ts.Debug.checkDefined(exportedSymbol.parent); + var symbolName = ts.getNameForExportedSymbol(exportedSymbol, ts.getEmitScriptTarget(compilerOptions)); + var checker = program.getTypeChecker(); + var symbol = checker.getMergedSymbol(ts.skipAlias(exportedSymbol, checker)); + var exportInfo = getAllExportInfoForSymbol(sourceFile, symbol, symbolName, /*isJsxTagName*/ false, program, host, preferences, cancellationToken); + var useRequire = shouldUseRequire(sourceFile, program); + var fix = getImportFixForSymbol(sourceFile, ts.Debug.checkDefined(exportInfo), moduleSymbol, program, /*useNamespaceInfo*/ undefined, !!isValidTypeOnlyUseSite, useRequire, host, preferences); + if (fix) { + addImport({ fix: fix, symbolName: symbolName, errorIdentifierText: undefined }); + } + } + function addImport(info) { + var _a, _b; + var fix = info.fix, symbolName = info.symbolName; + switch (fix.kind) { + case 0 /* ImportFixKind.UseNamespace */: + addToNamespace.push(fix); + break; + case 1 /* ImportFixKind.JsdocTypeImport */: + importType.push(fix); + break; + case 2 /* ImportFixKind.AddToExisting */: { + var importClauseOrBindingPattern = fix.importClauseOrBindingPattern, importKind = fix.importKind, addAsTypeOnly = fix.addAsTypeOnly; + var key = String(ts.getNodeId(importClauseOrBindingPattern)); + var entry = addToExisting.get(key); + if (!entry) { + addToExisting.set(key, entry = { importClauseOrBindingPattern: importClauseOrBindingPattern, defaultImport: undefined, namedImports: new ts.Map() }); + } + if (importKind === 0 /* ImportKind.Named */) { + var prevValue = entry === null || entry === void 0 ? void 0 : entry.namedImports.get(symbolName); + entry.namedImports.set(symbolName, reduceAddAsTypeOnlyValues(prevValue, addAsTypeOnly)); + } + else { + ts.Debug.assert(entry.defaultImport === undefined || entry.defaultImport.name === symbolName, "(Add to Existing) Default import should be missing or match symbolName"); + entry.defaultImport = { + name: symbolName, + addAsTypeOnly: reduceAddAsTypeOnlyValues((_a = entry.defaultImport) === null || _a === void 0 ? void 0 : _a.addAsTypeOnly, addAsTypeOnly), + }; + } + break; + } + case 3 /* ImportFixKind.AddNew */: { + var moduleSpecifier = fix.moduleSpecifier, importKind = fix.importKind, useRequire = fix.useRequire, addAsTypeOnly = fix.addAsTypeOnly; + var entry = getNewImportEntry(moduleSpecifier, importKind, useRequire, addAsTypeOnly); + ts.Debug.assert(entry.useRequire === useRequire, "(Add new) Tried to add an `import` and a `require` for the same module"); + switch (importKind) { + case 1 /* ImportKind.Default */: + ts.Debug.assert(entry.defaultImport === undefined || entry.defaultImport.name === symbolName, "(Add new) Default import should be missing or match symbolName"); + entry.defaultImport = { name: symbolName, addAsTypeOnly: reduceAddAsTypeOnlyValues((_b = entry.defaultImport) === null || _b === void 0 ? void 0 : _b.addAsTypeOnly, addAsTypeOnly) }; + break; + case 0 /* ImportKind.Named */: + var prevValue = (entry.namedImports || (entry.namedImports = new ts.Map())).get(symbolName); + entry.namedImports.set(symbolName, reduceAddAsTypeOnlyValues(prevValue, addAsTypeOnly)); + break; + case 3 /* ImportKind.CommonJS */: + case 2 /* ImportKind.Namespace */: + ts.Debug.assert(entry.namespaceLikeImport === undefined || entry.namespaceLikeImport.name === symbolName, "Namespacelike import shoudl be missing or match symbolName"); + entry.namespaceLikeImport = { importKind: importKind, name: symbolName, addAsTypeOnly: addAsTypeOnly }; + break; + } + break; + } + case 4 /* ImportFixKind.PromoteTypeOnly */: + // Excluding from fix-all + break; + default: + ts.Debug.assertNever(fix, "fix wasn't never - got kind ".concat(fix.kind)); + } + function reduceAddAsTypeOnlyValues(prevValue, newValue) { + // `NotAllowed` overrides `Required` because one addition of a new import might be required to be type-only + // because of `--importsNotUsedAsValues=error`, but if a second addition of the same import is `NotAllowed` + // to be type-only, the reason the first one was `Required` - the unused runtime dependency - is now moot. + // Alternatively, if one addition is `Required` because it has no value meaning under `--preserveValueImports` + // and `--isolatedModules`, it should be impossible for another addition to be `NotAllowed` since that would + // mean a type is being referenced in a value location. + return Math.max(prevValue !== null && prevValue !== void 0 ? prevValue : 0, newValue); + } + function getNewImportEntry(moduleSpecifier, importKind, useRequire, addAsTypeOnly) { + // A default import that requires type-only makes the whole import type-only. + // (We could add `default` as a named import, but that style seems undesirable.) + // Under `--preserveValueImports` and `--importsNotUsedAsValues=error`, if a + // module default-exports a type but named-exports some values (weird), you would + // have to use a type-only default import and non-type-only named imports. These + // require two separate import declarations, so we build this into the map key. + var typeOnlyKey = newImportsKey(moduleSpecifier, /*topLevelTypeOnly*/ true); + var nonTypeOnlyKey = newImportsKey(moduleSpecifier, /*topLevelTypeOnly*/ false); + var typeOnlyEntry = newImports.get(typeOnlyKey); + var nonTypeOnlyEntry = newImports.get(nonTypeOnlyKey); + var newEntry = { + defaultImport: undefined, + namedImports: undefined, + namespaceLikeImport: undefined, + useRequire: useRequire + }; + if (importKind === 1 /* ImportKind.Default */ && addAsTypeOnly === 2 /* AddAsTypeOnly.Required */) { + if (typeOnlyEntry) + return typeOnlyEntry; + newImports.set(typeOnlyKey, newEntry); + return newEntry; + } + if (addAsTypeOnly === 1 /* AddAsTypeOnly.Allowed */ && (typeOnlyEntry || nonTypeOnlyEntry)) { + return (typeOnlyEntry || nonTypeOnlyEntry); + } + if (nonTypeOnlyEntry) { + return nonTypeOnlyEntry; + } + newImports.set(nonTypeOnlyKey, newEntry); + return newEntry; + } + function newImportsKey(moduleSpecifier, topLevelTypeOnly) { + return "".concat(topLevelTypeOnly ? 1 : 0, "|").concat(moduleSpecifier); + } + } + function writeFixes(changeTracker) { + var quotePreference = ts.getQuotePreference(sourceFile, preferences); + for (var _i = 0, addToNamespace_1 = addToNamespace; _i < addToNamespace_1.length; _i++) { + var fix = addToNamespace_1[_i]; + addNamespaceQualifier(changeTracker, sourceFile, fix); + } + for (var _a = 0, importType_1 = importType; _a < importType_1.length; _a++) { + var fix = importType_1[_a]; + addImportType(changeTracker, sourceFile, fix, quotePreference); + } + addToExisting.forEach(function (_a) { + var importClauseOrBindingPattern = _a.importClauseOrBindingPattern, defaultImport = _a.defaultImport, namedImports = _a.namedImports; + doAddExistingFix(changeTracker, sourceFile, importClauseOrBindingPattern, defaultImport, ts.arrayFrom(namedImports.entries(), function (_a) { + var name = _a[0], addAsTypeOnly = _a[1]; + return ({ addAsTypeOnly: addAsTypeOnly, name: name }); + }), compilerOptions); + }); + var newDeclarations; + newImports.forEach(function (_a, key) { + var useRequire = _a.useRequire, defaultImport = _a.defaultImport, namedImports = _a.namedImports, namespaceLikeImport = _a.namespaceLikeImport; + var moduleSpecifier = key.slice(2); // From `${0 | 1}|${moduleSpecifier}` format + var getDeclarations = useRequire ? getNewRequires : getNewImports; + var declarations = getDeclarations(moduleSpecifier, quotePreference, defaultImport, namedImports && ts.arrayFrom(namedImports.entries(), function (_a) { + var name = _a[0], addAsTypeOnly = _a[1]; + return ({ addAsTypeOnly: addAsTypeOnly, name: name }); + }), namespaceLikeImport); + newDeclarations = ts.combine(newDeclarations, declarations); + }); + if (newDeclarations) { + ts.insertImports(changeTracker, sourceFile, newDeclarations, /*blankLineBetween*/ true); + } + } + function hasFixes() { + return addToNamespace.length > 0 || importType.length > 0 || addToExisting.size > 0 || newImports.size > 0; + } + } + function createImportSpecifierResolver(importingFile, program, host, preferences) { + var packageJsonImportFilter = ts.createPackageJsonImportFilter(importingFile, preferences, host); + var importMap = createExistingImportMap(program.getTypeChecker(), importingFile, program.getCompilerOptions()); + return { getModuleSpecifierForBestExportInfo: getModuleSpecifierForBestExportInfo }; + function getModuleSpecifierForBestExportInfo(exportInfo, symbolName, position, isValidTypeOnlyUseSite, fromCacheOnly) { + var _a = getImportFixes(exportInfo, { symbolName: symbolName, position: position }, isValidTypeOnlyUseSite, + /*useRequire*/ false, program, importingFile, host, preferences, importMap, fromCacheOnly), fixes = _a.fixes, computedWithoutCacheCount = _a.computedWithoutCacheCount; + var result = getBestFix(fixes, importingFile, program, packageJsonImportFilter, host); + return result && __assign(__assign({}, result), { computedWithoutCacheCount: computedWithoutCacheCount }); + } + } + codefix.createImportSpecifierResolver = createImportSpecifierResolver; + // Sorted with the preferred fix coming first. + var ImportFixKind; + (function (ImportFixKind) { + ImportFixKind[ImportFixKind["UseNamespace"] = 0] = "UseNamespace"; + ImportFixKind[ImportFixKind["JsdocTypeImport"] = 1] = "JsdocTypeImport"; + ImportFixKind[ImportFixKind["AddToExisting"] = 2] = "AddToExisting"; + ImportFixKind[ImportFixKind["AddNew"] = 3] = "AddNew"; + ImportFixKind[ImportFixKind["PromoteTypeOnly"] = 4] = "PromoteTypeOnly"; + })(ImportFixKind || (ImportFixKind = {})); + // These should not be combined as bitflags, but are given powers of 2 values to + // easily detect conflicts between `NotAllowed` and `Required` by giving them a unique sum. + // They're also ordered in terms of increasing priority for a fix-all scenario (see + // `reduceAddAsTypeOnlyValues`). + var AddAsTypeOnly; + (function (AddAsTypeOnly) { + AddAsTypeOnly[AddAsTypeOnly["Allowed"] = 1] = "Allowed"; + AddAsTypeOnly[AddAsTypeOnly["Required"] = 2] = "Required"; + AddAsTypeOnly[AddAsTypeOnly["NotAllowed"] = 4] = "NotAllowed"; + })(AddAsTypeOnly || (AddAsTypeOnly = {})); + function getImportCompletionAction(targetSymbol, moduleSymbol, sourceFile, symbolName, isJsxTagName, host, program, formatContext, position, preferences, cancellationToken) { + var compilerOptions = program.getCompilerOptions(); + var exportInfos = ts.pathIsBareSpecifier(ts.stripQuotes(moduleSymbol.name)) + ? [getSingleExportInfoForSymbol(targetSymbol, moduleSymbol, program, host)] + : getAllExportInfoForSymbol(sourceFile, targetSymbol, symbolName, isJsxTagName, program, host, preferences, cancellationToken); + ts.Debug.assertIsDefined(exportInfos); + var useRequire = shouldUseRequire(sourceFile, program); + var isValidTypeOnlyUseSite = ts.isValidTypeOnlyAliasUseSite(ts.getTokenAtPosition(sourceFile, position)); + var fix = ts.Debug.checkDefined(getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, program, { symbolName: symbolName, position: position }, isValidTypeOnlyUseSite, useRequire, host, preferences)); + return { + moduleSpecifier: fix.moduleSpecifier, + codeAction: codeFixActionToCodeAction(codeActionForFix({ host: host, formatContext: formatContext, preferences: preferences }, sourceFile, symbolName, fix, + /*includeSymbolNameInDescription*/ false, ts.getQuotePreference(sourceFile, preferences), compilerOptions)) + }; + } + codefix.getImportCompletionAction = getImportCompletionAction; + function getPromoteTypeOnlyCompletionAction(sourceFile, symbolToken, program, host, formatContext, preferences) { + var compilerOptions = program.getCompilerOptions(); + var symbolName = ts.single(getSymbolNamesToImport(sourceFile, program.getTypeChecker(), symbolToken, compilerOptions)); + var fix = getTypeOnlyPromotionFix(sourceFile, symbolToken, symbolName, program); + var includeSymbolNameInDescription = symbolName !== symbolToken.text; + return fix && codeFixActionToCodeAction(codeActionForFix({ host: host, formatContext: formatContext, preferences: preferences }, sourceFile, symbolName, fix, includeSymbolNameInDescription, 1 /* QuotePreference.Double */, compilerOptions)); + } + codefix.getPromoteTypeOnlyCompletionAction = getPromoteTypeOnlyCompletionAction; + function getImportFixForSymbol(sourceFile, exportInfos, moduleSymbol, program, useNamespaceInfo, isValidTypeOnlyUseSite, useRequire, host, preferences) { + ts.Debug.assert(exportInfos.some(function (info) { return info.moduleSymbol === moduleSymbol || info.symbol.parent === moduleSymbol; }), "Some exportInfo should match the specified moduleSymbol"); + var packageJsonImportFilter = ts.createPackageJsonImportFilter(sourceFile, preferences, host); + return getBestFix(getImportFixes(exportInfos, useNamespaceInfo, isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences).fixes, sourceFile, program, packageJsonImportFilter, host); + } + function codeFixActionToCodeAction(_a) { + var description = _a.description, changes = _a.changes, commands = _a.commands; + return { description: description, changes: changes, commands: commands }; + } + function getAllExportInfoForSymbol(importingFile, symbol, symbolName, preferCapitalized, program, host, preferences, cancellationToken) { + var getChecker = createGetChecker(program, host); + return ts.getExportInfoMap(importingFile, host, program, preferences, cancellationToken) + .search(importingFile.path, preferCapitalized, function (name) { return name === symbolName; }, function (info) { + if (ts.skipAlias(info[0].symbol, getChecker(info[0].isFromPackageJson)) === symbol) { + return info; + } + }); + } + function getSingleExportInfoForSymbol(symbol, moduleSymbol, program, host) { + var _a, _b; + var compilerOptions = program.getCompilerOptions(); + var mainProgramInfo = getInfoWithChecker(program.getTypeChecker(), /*isFromPackageJson*/ false); + if (mainProgramInfo) { + return mainProgramInfo; + } + var autoImportProvider = (_b = (_a = host.getPackageJsonAutoImportProvider) === null || _a === void 0 ? void 0 : _a.call(host)) === null || _b === void 0 ? void 0 : _b.getTypeChecker(); + return ts.Debug.checkDefined(autoImportProvider && getInfoWithChecker(autoImportProvider, /*isFromPackageJson*/ true), "Could not find symbol in specified module for code actions"); + function getInfoWithChecker(checker, isFromPackageJson) { + var defaultInfo = ts.getDefaultLikeExportInfo(moduleSymbol, checker, compilerOptions); + if (defaultInfo && ts.skipAlias(defaultInfo.symbol, checker) === symbol) { + return { symbol: defaultInfo.symbol, moduleSymbol: moduleSymbol, moduleFileName: undefined, exportKind: defaultInfo.exportKind, targetFlags: ts.skipAlias(symbol, checker).flags, isFromPackageJson: isFromPackageJson }; + } + var named = checker.tryGetMemberInModuleExportsAndProperties(symbol.name, moduleSymbol); + if (named && ts.skipAlias(named, checker) === symbol) { + return { symbol: named, moduleSymbol: moduleSymbol, moduleFileName: undefined, exportKind: 0 /* ExportKind.Named */, targetFlags: ts.skipAlias(symbol, checker).flags, isFromPackageJson: isFromPackageJson }; + } + } + } + function getImportFixes(exportInfos, useNamespaceInfo, + /** undefined only for missing JSX namespace */ + isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences, importMap, fromCacheOnly) { + if (importMap === void 0) { importMap = createExistingImportMap(program.getTypeChecker(), sourceFile, program.getCompilerOptions()); } + var checker = program.getTypeChecker(); + var existingImports = ts.flatMap(exportInfos, importMap.getImportsForExportInfo); + var useNamespace = useNamespaceInfo && tryUseExistingNamespaceImport(existingImports, useNamespaceInfo.symbolName, useNamespaceInfo.position, checker); + var addToExisting = tryAddToExistingImport(existingImports, isValidTypeOnlyUseSite, checker, program.getCompilerOptions()); + if (addToExisting) { + // Don't bother providing an action to add a new import if we can add to an existing one. + return { + computedWithoutCacheCount: 0, + fixes: __spreadArray(__spreadArray([], (useNamespace ? [useNamespace] : ts.emptyArray), true), [addToExisting], false), + }; + } + var _a = getFixesForAddImport(exportInfos, existingImports, program, sourceFile, useNamespaceInfo === null || useNamespaceInfo === void 0 ? void 0 : useNamespaceInfo.position, isValidTypeOnlyUseSite, useRequire, host, preferences, fromCacheOnly), fixes = _a.fixes, _b = _a.computedWithoutCacheCount, computedWithoutCacheCount = _b === void 0 ? 0 : _b; + return { + computedWithoutCacheCount: computedWithoutCacheCount, + fixes: __spreadArray(__spreadArray([], (useNamespace ? [useNamespace] : ts.emptyArray), true), fixes, true), + }; + } + function tryUseExistingNamespaceImport(existingImports, symbolName, position, checker) { + // It is possible that multiple import statements with the same specifier exist in the file. + // e.g. + // + // import * as ns from "foo"; + // import { member1, member2 } from "foo"; + // + // member3/**/ <-- cusor here + // + // in this case we should provie 2 actions: + // 1. change "member3" to "ns.member3" + // 2. add "member3" to the second import statement's import list + // and it is up to the user to decide which one fits best. + return ts.firstDefined(existingImports, function (_a) { + var _b; + var declaration = _a.declaration; + var namespacePrefix = getNamespaceLikeImportText(declaration); + var moduleSpecifier = (_b = ts.tryGetModuleSpecifierFromDeclaration(declaration)) === null || _b === void 0 ? void 0 : _b.text; + if (namespacePrefix && moduleSpecifier) { + var moduleSymbol = getTargetModuleFromNamespaceLikeImport(declaration, checker); + if (moduleSymbol && moduleSymbol.exports.has(ts.escapeLeadingUnderscores(symbolName))) { + return { kind: 0 /* ImportFixKind.UseNamespace */, namespacePrefix: namespacePrefix, position: position, moduleSpecifier: moduleSpecifier }; + } + } + }); + } + function getTargetModuleFromNamespaceLikeImport(declaration, checker) { + var _a; + switch (declaration.kind) { + case 257 /* SyntaxKind.VariableDeclaration */: + return checker.resolveExternalModuleName(declaration.initializer.arguments[0]); + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return checker.getAliasedSymbol(declaration.symbol); + case 269 /* SyntaxKind.ImportDeclaration */: + var namespaceImport = ts.tryCast((_a = declaration.importClause) === null || _a === void 0 ? void 0 : _a.namedBindings, ts.isNamespaceImport); + return namespaceImport && checker.getAliasedSymbol(namespaceImport.symbol); + default: + return ts.Debug.assertNever(declaration); + } + } + function getNamespaceLikeImportText(declaration) { + var _a, _b, _c; + switch (declaration.kind) { + case 257 /* SyntaxKind.VariableDeclaration */: + return (_a = ts.tryCast(declaration.name, ts.isIdentifier)) === null || _a === void 0 ? void 0 : _a.text; + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return declaration.name.text; + case 269 /* SyntaxKind.ImportDeclaration */: + return (_c = ts.tryCast((_b = declaration.importClause) === null || _b === void 0 ? void 0 : _b.namedBindings, ts.isNamespaceImport)) === null || _c === void 0 ? void 0 : _c.name.text; + default: + return ts.Debug.assertNever(declaration); + } + } + function getAddAsTypeOnly(isValidTypeOnlyUseSite, isForNewImportDeclaration, symbol, targetFlags, checker, compilerOptions) { + if (!isValidTypeOnlyUseSite) { + // Can't use a type-only import if the usage is an emitting position + return 4 /* AddAsTypeOnly.NotAllowed */; + } + if (isForNewImportDeclaration && compilerOptions.importsNotUsedAsValues === 2 /* ImportsNotUsedAsValues.Error */) { + // Not writing a (top-level) type-only import here would create an error because the runtime dependency is unnecessary + return 2 /* AddAsTypeOnly.Required */; + } + if (compilerOptions.isolatedModules && compilerOptions.preserveValueImports && + (!(targetFlags & 111551 /* SymbolFlags.Value */) || !!checker.getTypeOnlyAliasDeclaration(symbol))) { + // A type-only import is required for this symbol if under these settings if the symbol will + // be erased, which will happen if the target symbol is purely a type or if it was exported/imported + // as type-only already somewhere between this import and the target. + return 2 /* AddAsTypeOnly.Required */; + } + return 1 /* AddAsTypeOnly.Allowed */; + } + function tryAddToExistingImport(existingImports, isValidTypeOnlyUseSite, checker, compilerOptions) { + return ts.firstDefined(existingImports, function (_a) { + var declaration = _a.declaration, importKind = _a.importKind, symbol = _a.symbol, targetFlags = _a.targetFlags; + if (importKind === 3 /* ImportKind.CommonJS */ || importKind === 2 /* ImportKind.Namespace */ || declaration.kind === 268 /* SyntaxKind.ImportEqualsDeclaration */) { + // These kinds of imports are not combinable with anything + return undefined; + } + if (declaration.kind === 257 /* SyntaxKind.VariableDeclaration */) { + return (importKind === 0 /* ImportKind.Named */ || importKind === 1 /* ImportKind.Default */) && declaration.name.kind === 203 /* SyntaxKind.ObjectBindingPattern */ + ? { kind: 2 /* ImportFixKind.AddToExisting */, importClauseOrBindingPattern: declaration.name, importKind: importKind, moduleSpecifier: declaration.initializer.arguments[0].text, addAsTypeOnly: 4 /* AddAsTypeOnly.NotAllowed */ } + : undefined; + } + var importClause = declaration.importClause; + if (!importClause || !ts.isStringLiteralLike(declaration.moduleSpecifier)) + return undefined; + var name = importClause.name, namedBindings = importClause.namedBindings; + // A type-only import may not have both a default and named imports, so the only way a name can + // be added to an existing type-only import is adding a named import to existing named bindings. + if (importClause.isTypeOnly && !(importKind === 0 /* ImportKind.Named */ && namedBindings)) + return undefined; + // N.B. we don't have to figure out whether to use the main program checker + // or the AutoImportProvider checker because we're adding to an existing import; the existence of + // the import guarantees the symbol came from the main program. + var addAsTypeOnly = getAddAsTypeOnly(isValidTypeOnlyUseSite, /*isForNewImportDeclaration*/ false, symbol, targetFlags, checker, compilerOptions); + if (importKind === 1 /* ImportKind.Default */ && (name || // Cannot add a default import to a declaration that already has one + addAsTypeOnly === 2 /* AddAsTypeOnly.Required */ && namedBindings // Cannot add a default import as type-only if the import already has named bindings + )) + return undefined; + if (importKind === 0 /* ImportKind.Named */ && + (namedBindings === null || namedBindings === void 0 ? void 0 : namedBindings.kind) === 271 /* SyntaxKind.NamespaceImport */ // Cannot add a named import to a declaration that has a namespace import + ) + return undefined; + return { + kind: 2 /* ImportFixKind.AddToExisting */, + importClauseOrBindingPattern: importClause, + importKind: importKind, + moduleSpecifier: declaration.moduleSpecifier.text, + addAsTypeOnly: addAsTypeOnly, + }; + }); + } + function createExistingImportMap(checker, importingFile, compilerOptions) { + var importMap; + for (var _i = 0, _a = importingFile.imports; _i < _a.length; _i++) { + var moduleSpecifier = _a[_i]; + var i = ts.importFromModuleSpecifier(moduleSpecifier); + if (ts.isVariableDeclarationInitializedToRequire(i.parent)) { + var moduleSymbol = checker.resolveExternalModuleName(moduleSpecifier); + if (moduleSymbol) { + (importMap || (importMap = ts.createMultiMap())).add(ts.getSymbolId(moduleSymbol), i.parent); + } + } + else if (i.kind === 269 /* SyntaxKind.ImportDeclaration */ || i.kind === 268 /* SyntaxKind.ImportEqualsDeclaration */) { + var moduleSymbol = checker.getSymbolAtLocation(moduleSpecifier); + if (moduleSymbol) { + (importMap || (importMap = ts.createMultiMap())).add(ts.getSymbolId(moduleSymbol), i); + } + } + } + return { + getImportsForExportInfo: function (_a) { + var moduleSymbol = _a.moduleSymbol, exportKind = _a.exportKind, targetFlags = _a.targetFlags, symbol = _a.symbol; + // Can't use an es6 import for a type in JS. + if (!(targetFlags & 111551 /* SymbolFlags.Value */) && ts.isSourceFileJS(importingFile)) + return ts.emptyArray; + var matchingDeclarations = importMap === null || importMap === void 0 ? void 0 : importMap.get(ts.getSymbolId(moduleSymbol)); + if (!matchingDeclarations) + return ts.emptyArray; + var importKind = getImportKind(importingFile, exportKind, compilerOptions); + return matchingDeclarations.map(function (declaration) { return ({ declaration: declaration, importKind: importKind, symbol: symbol, targetFlags: targetFlags }); }); + } + }; + } + function shouldUseRequire(sourceFile, program) { + // 1. TypeScript files don't use require variable declarations + if (!ts.isSourceFileJS(sourceFile)) { + return false; + } + // 2. If the current source file is unambiguously CJS or ESM, go with that + if (sourceFile.commonJsModuleIndicator && !sourceFile.externalModuleIndicator) + return true; + if (sourceFile.externalModuleIndicator && !sourceFile.commonJsModuleIndicator) + return false; + // 3. If there's a tsconfig/jsconfig, use its module setting + var compilerOptions = program.getCompilerOptions(); + if (compilerOptions.configFile) { + return ts.getEmitModuleKind(compilerOptions) < ts.ModuleKind.ES2015; + } + // 4. Match the first other JS file in the program that's unambiguously CJS or ESM + for (var _i = 0, _a = program.getSourceFiles(); _i < _a.length; _i++) { + var otherFile = _a[_i]; + if (otherFile === sourceFile || !ts.isSourceFileJS(otherFile) || program.isSourceFileFromExternalLibrary(otherFile)) + continue; + if (otherFile.commonJsModuleIndicator && !otherFile.externalModuleIndicator) + return true; + if (otherFile.externalModuleIndicator && !otherFile.commonJsModuleIndicator) + return false; + } + // 5. Literally nothing to go on + return true; + } + function createGetChecker(program, host) { + return ts.memoizeOne(function (isFromPackageJson) { return isFromPackageJson ? host.getPackageJsonAutoImportProvider().getTypeChecker() : program.getTypeChecker(); }); + } + function getNewImportFixes(program, sourceFile, position, isValidTypeOnlyUseSite, useRequire, exportInfo, host, preferences, fromCacheOnly) { + var isJs = ts.isSourceFileJS(sourceFile); + var compilerOptions = program.getCompilerOptions(); + var moduleSpecifierResolutionHost = ts.createModuleSpecifierResolutionHost(program, host); + var getChecker = createGetChecker(program, host); + var rejectNodeModulesRelativePaths = ts.moduleResolutionUsesNodeModules(ts.getEmitModuleResolutionKind(compilerOptions)); + var getModuleSpecifiers = fromCacheOnly + ? function (moduleSymbol) { return ({ moduleSpecifiers: ts.moduleSpecifiers.tryGetModuleSpecifiersFromCache(moduleSymbol, sourceFile, moduleSpecifierResolutionHost, preferences), computedWithoutCache: false }); } + : function (moduleSymbol, checker) { return ts.moduleSpecifiers.getModuleSpecifiersWithCacheInfo(moduleSymbol, checker, compilerOptions, sourceFile, moduleSpecifierResolutionHost, preferences); }; + var computedWithoutCacheCount = 0; + var fixes = ts.flatMap(exportInfo, function (exportInfo, i) { + var checker = getChecker(exportInfo.isFromPackageJson); + var _a = getModuleSpecifiers(exportInfo.moduleSymbol, checker), computedWithoutCache = _a.computedWithoutCache, moduleSpecifiers = _a.moduleSpecifiers; + var importedSymbolHasValueMeaning = !!(exportInfo.targetFlags & 111551 /* SymbolFlags.Value */); + var addAsTypeOnly = getAddAsTypeOnly(isValidTypeOnlyUseSite, /*isForNewImportDeclaration*/ true, exportInfo.symbol, exportInfo.targetFlags, checker, compilerOptions); + computedWithoutCacheCount += computedWithoutCache ? 1 : 0; + return ts.mapDefined(moduleSpecifiers, function (moduleSpecifier) { + return rejectNodeModulesRelativePaths && ts.pathContainsNodeModules(moduleSpecifier) ? undefined : + // `position` should only be undefined at a missing jsx namespace, in which case we shouldn't be looking for pure types. + !importedSymbolHasValueMeaning && isJs && position !== undefined ? { kind: 1 /* ImportFixKind.JsdocTypeImport */, moduleSpecifier: moduleSpecifier, position: position, exportInfo: exportInfo, isReExport: i > 0 } : + { + kind: 3 /* ImportFixKind.AddNew */, + moduleSpecifier: moduleSpecifier, + importKind: getImportKind(sourceFile, exportInfo.exportKind, compilerOptions), + useRequire: useRequire, + addAsTypeOnly: addAsTypeOnly, + exportInfo: exportInfo, + isReExport: i > 0, + }; + }); + }); + return { computedWithoutCacheCount: computedWithoutCacheCount, fixes: fixes }; + } + function getFixesForAddImport(exportInfos, existingImports, program, sourceFile, position, isValidTypeOnlyUseSite, useRequire, host, preferences, fromCacheOnly) { + var existingDeclaration = ts.firstDefined(existingImports, function (info) { return newImportInfoFromExistingSpecifier(info, isValidTypeOnlyUseSite, useRequire, program.getTypeChecker(), program.getCompilerOptions()); }); + return existingDeclaration ? { fixes: [existingDeclaration] } : getNewImportFixes(program, sourceFile, position, isValidTypeOnlyUseSite, useRequire, exportInfos, host, preferences, fromCacheOnly); + } + function newImportInfoFromExistingSpecifier(_a, isValidTypeOnlyUseSite, useRequire, checker, compilerOptions) { + var _b; + var declaration = _a.declaration, importKind = _a.importKind, symbol = _a.symbol, targetFlags = _a.targetFlags; + var moduleSpecifier = (_b = ts.tryGetModuleSpecifierFromDeclaration(declaration)) === null || _b === void 0 ? void 0 : _b.text; + if (moduleSpecifier) { + var addAsTypeOnly = useRequire + ? 4 /* AddAsTypeOnly.NotAllowed */ + : getAddAsTypeOnly(isValidTypeOnlyUseSite, /*isForNewImportDeclaration*/ true, symbol, targetFlags, checker, compilerOptions); + return { kind: 3 /* ImportFixKind.AddNew */, moduleSpecifier: moduleSpecifier, importKind: importKind, addAsTypeOnly: addAsTypeOnly, useRequire: useRequire }; + } + } + function getFixInfos(context, errorCode, pos, useAutoImportProvider) { + var symbolToken = ts.getTokenAtPosition(context.sourceFile, pos); + var info; + if (errorCode === ts.Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead.code) { + info = getFixesInfoForUMDImport(context, symbolToken); + } + else if (!ts.isIdentifier(symbolToken)) { + return undefined; + } + else if (errorCode === ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type.code) { + var symbolName_1 = ts.single(getSymbolNamesToImport(context.sourceFile, context.program.getTypeChecker(), symbolToken, context.program.getCompilerOptions())); + var fix = getTypeOnlyPromotionFix(context.sourceFile, symbolToken, symbolName_1, context.program); + return fix && [{ fix: fix, symbolName: symbolName_1, errorIdentifierText: symbolToken.text }]; + } + else { + info = getFixesInfoForNonUMDImport(context, symbolToken, useAutoImportProvider); + } + var packageJsonImportFilter = ts.createPackageJsonImportFilter(context.sourceFile, context.preferences, context.host); + return info && sortFixInfo(info, context.sourceFile, context.program, packageJsonImportFilter, context.host); + } + function sortFixInfo(fixes, sourceFile, program, packageJsonImportFilter, host) { + var _toPath = function (fileName) { return ts.toPath(fileName, host.getCurrentDirectory(), ts.hostGetCanonicalFileName(host)); }; + return ts.sort(fixes, function (a, b) { + return ts.compareBooleans(!!a.isJsxNamespaceFix, !!b.isJsxNamespaceFix) || + ts.compareValues(a.fix.kind, b.fix.kind) || + compareModuleSpecifiers(a.fix, b.fix, sourceFile, program, packageJsonImportFilter.allowsImportingSpecifier, _toPath); + }); + } + function getBestFix(fixes, sourceFile, program, packageJsonImportFilter, host) { + if (!ts.some(fixes)) + return; + // These will always be placed first if available, and are better than other kinds + if (fixes[0].kind === 0 /* ImportFixKind.UseNamespace */ || fixes[0].kind === 2 /* ImportFixKind.AddToExisting */) { + return fixes[0]; + } + return fixes.reduce(function (best, fix) { + // Takes true branch of conditional if `fix` is better than `best` + return compareModuleSpecifiers(fix, best, sourceFile, program, packageJsonImportFilter.allowsImportingSpecifier, function (fileName) { return ts.toPath(fileName, host.getCurrentDirectory(), ts.hostGetCanonicalFileName(host)); }) === -1 /* Comparison.LessThan */ ? fix : best; + }); + } + /** @returns `Comparison.LessThan` if `a` is better than `b`. */ + function compareModuleSpecifiers(a, b, importingFile, program, allowsImportingSpecifier, toPath) { + if (a.kind !== 0 /* ImportFixKind.UseNamespace */ && b.kind !== 0 /* ImportFixKind.UseNamespace */) { + return ts.compareBooleans(allowsImportingSpecifier(b.moduleSpecifier), allowsImportingSpecifier(a.moduleSpecifier)) + || compareNodeCoreModuleSpecifiers(a.moduleSpecifier, b.moduleSpecifier, importingFile, program) + || ts.compareBooleans(isFixPossiblyReExportingImportingFile(a, importingFile, program.getCompilerOptions(), toPath), isFixPossiblyReExportingImportingFile(b, importingFile, program.getCompilerOptions(), toPath)) + || ts.compareNumberOfDirectorySeparators(a.moduleSpecifier, b.moduleSpecifier); + } + return 0 /* Comparison.EqualTo */; + } + // This is a simple heuristic to try to avoid creating an import cycle with a barrel re-export. + // E.g., do not `import { Foo } from ".."` when you could `import { Foo } from "../Foo"`. + // This can produce false positives or negatives if re-exports cross into sibling directories + // (e.g. `export * from "../whatever"`) or are not named "index" (we don't even try to consider + // this if we're in a resolution mode where you can't drop trailing "/index" from paths). + function isFixPossiblyReExportingImportingFile(fix, importingFile, compilerOptions, toPath) { + var _a; + if (fix.isReExport && + ((_a = fix.exportInfo) === null || _a === void 0 ? void 0 : _a.moduleFileName) && + ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeJs && + isIndexFileName(fix.exportInfo.moduleFileName)) { + var reExportDir = toPath(ts.getDirectoryPath(fix.exportInfo.moduleFileName)); + return ts.startsWith((importingFile.path), reExportDir); + } + return false; + } + function isIndexFileName(fileName) { + return ts.getBaseFileName(fileName, [".js", ".jsx", ".d.ts", ".ts", ".tsx"], /*ignoreCase*/ true) === "index"; + } + function compareNodeCoreModuleSpecifiers(a, b, importingFile, program) { + if (ts.startsWith(a, "node:") && !ts.startsWith(b, "node:")) + return ts.shouldUseUriStyleNodeCoreModules(importingFile, program) ? -1 /* Comparison.LessThan */ : 1 /* Comparison.GreaterThan */; + if (ts.startsWith(b, "node:") && !ts.startsWith(a, "node:")) + return ts.shouldUseUriStyleNodeCoreModules(importingFile, program) ? 1 /* Comparison.GreaterThan */ : -1 /* Comparison.LessThan */; + return 0 /* Comparison.EqualTo */; + } + function getFixesInfoForUMDImport(_a, token) { + var sourceFile = _a.sourceFile, program = _a.program, host = _a.host, preferences = _a.preferences; + var checker = program.getTypeChecker(); + var umdSymbol = getUmdSymbol(token, checker); + if (!umdSymbol) + return undefined; + var symbol = checker.getAliasedSymbol(umdSymbol); + var symbolName = umdSymbol.name; + var exportInfo = [{ symbol: umdSymbol, moduleSymbol: symbol, moduleFileName: undefined, exportKind: 3 /* ExportKind.UMD */, targetFlags: symbol.flags, isFromPackageJson: false }]; + var useRequire = shouldUseRequire(sourceFile, program); + var position = ts.isIdentifier(token) ? token.getStart(sourceFile) : undefined; + var fixes = getImportFixes(exportInfo, position ? { position: position, symbolName: symbolName } : undefined, /*isValidTypeOnlyUseSite*/ false, useRequire, program, sourceFile, host, preferences).fixes; + return fixes.map(function (fix) { var _a; return ({ fix: fix, symbolName: symbolName, errorIdentifierText: (_a = ts.tryCast(token, ts.isIdentifier)) === null || _a === void 0 ? void 0 : _a.text }); }); + } + function getUmdSymbol(token, checker) { + // try the identifier to see if it is the umd symbol + var umdSymbol = ts.isIdentifier(token) ? checker.getSymbolAtLocation(token) : undefined; + if (ts.isUMDExportSymbol(umdSymbol)) + return umdSymbol; + // The error wasn't for the symbolAtLocation, it was for the JSX tag itself, which needs access to e.g. `React`. + var parent = token.parent; + return (ts.isJsxOpeningLikeElement(parent) && parent.tagName === token) || ts.isJsxOpeningFragment(parent) + ? ts.tryCast(checker.resolveName(checker.getJsxNamespace(parent), ts.isJsxOpeningLikeElement(parent) ? token : parent, 111551 /* SymbolFlags.Value */, /*excludeGlobals*/ false), ts.isUMDExportSymbol) + : undefined; + } + /** + * @param forceImportKeyword Indicates that the user has already typed `import`, so the result must start with `import`. + * (In other words, do not allow `const x = require("...")` for JS files.) + */ + function getImportKind(importingFile, exportKind, compilerOptions, forceImportKeyword) { + switch (exportKind) { + case 0 /* ExportKind.Named */: return 0 /* ImportKind.Named */; + case 1 /* ExportKind.Default */: return 1 /* ImportKind.Default */; + case 2 /* ExportKind.ExportEquals */: return getExportEqualsImportKind(importingFile, compilerOptions, !!forceImportKeyword); + case 3 /* ExportKind.UMD */: return getUmdImportKind(importingFile, compilerOptions, !!forceImportKeyword); + default: return ts.Debug.assertNever(exportKind); + } + } + codefix.getImportKind = getImportKind; + function getUmdImportKind(importingFile, compilerOptions, forceImportKeyword) { + // Import a synthetic `default` if enabled. + if (ts.getAllowSyntheticDefaultImports(compilerOptions)) { + return 1 /* ImportKind.Default */; + } + // When a synthetic `default` is unavailable, use `import..require` if the module kind supports it. + var moduleKind = ts.getEmitModuleKind(compilerOptions); + switch (moduleKind) { + case ts.ModuleKind.AMD: + case ts.ModuleKind.CommonJS: + case ts.ModuleKind.UMD: + if (ts.isInJSFile(importingFile)) { + return ts.isExternalModule(importingFile) || forceImportKeyword ? 2 /* ImportKind.Namespace */ : 3 /* ImportKind.CommonJS */; + } + return 3 /* ImportKind.CommonJS */; + case ts.ModuleKind.System: + case ts.ModuleKind.ES2015: + case ts.ModuleKind.ES2020: + case ts.ModuleKind.ES2022: + case ts.ModuleKind.ESNext: + case ts.ModuleKind.None: + // Fall back to the `import * as ns` style import. + return 2 /* ImportKind.Namespace */; + case ts.ModuleKind.Node16: + case ts.ModuleKind.NodeNext: + return importingFile.impliedNodeFormat === ts.ModuleKind.ESNext ? 2 /* ImportKind.Namespace */ : 3 /* ImportKind.CommonJS */; + default: + return ts.Debug.assertNever(moduleKind, "Unexpected moduleKind ".concat(moduleKind)); + } + } + function getFixesInfoForNonUMDImport(_a, symbolToken, useAutoImportProvider) { + var sourceFile = _a.sourceFile, program = _a.program, cancellationToken = _a.cancellationToken, host = _a.host, preferences = _a.preferences; + var checker = program.getTypeChecker(); + var compilerOptions = program.getCompilerOptions(); + return ts.flatMap(getSymbolNamesToImport(sourceFile, checker, symbolToken, compilerOptions), function (symbolName) { + // "default" is a keyword and not a legal identifier for the import, but appears as an identifier. + if (symbolName === "default" /* InternalSymbolName.Default */) { + return undefined; + } + var isValidTypeOnlyUseSite = ts.isValidTypeOnlyAliasUseSite(symbolToken); + var useRequire = shouldUseRequire(sourceFile, program); + var exportInfo = getExportInfos(symbolName, ts.isJSXTagName(symbolToken), ts.getMeaningFromLocation(symbolToken), cancellationToken, sourceFile, program, useAutoImportProvider, host, preferences); + var fixes = ts.arrayFrom(ts.flatMapIterator(exportInfo.entries(), function (_a) { + var _ = _a[0], exportInfos = _a[1]; + return getImportFixes(exportInfos, { symbolName: symbolName, position: symbolToken.getStart(sourceFile) }, isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences).fixes; + })); + return fixes.map(function (fix) { return ({ fix: fix, symbolName: symbolName, errorIdentifierText: symbolToken.text, isJsxNamespaceFix: symbolName !== symbolToken.text }); }); + }); + } + function getTypeOnlyPromotionFix(sourceFile, symbolToken, symbolName, program) { + var checker = program.getTypeChecker(); + var symbol = checker.resolveName(symbolName, symbolToken, 111551 /* SymbolFlags.Value */, /*excludeGlobals*/ true); + if (!symbol) + return undefined; + var typeOnlyAliasDeclaration = checker.getTypeOnlyAliasDeclaration(symbol); + if (!typeOnlyAliasDeclaration || ts.getSourceFileOfNode(typeOnlyAliasDeclaration) !== sourceFile) + return undefined; + return { kind: 4 /* ImportFixKind.PromoteTypeOnly */, typeOnlyAliasDeclaration: typeOnlyAliasDeclaration }; + } + function getSymbolNamesToImport(sourceFile, checker, symbolToken, compilerOptions) { + var parent = symbolToken.parent; + if ((ts.isJsxOpeningLikeElement(parent) || ts.isJsxClosingElement(parent)) && parent.tagName === symbolToken && ts.jsxModeNeedsExplicitImport(compilerOptions.jsx)) { + var jsxNamespace = checker.getJsxNamespace(sourceFile); + if (needsJsxNamespaceFix(jsxNamespace, symbolToken, checker)) { + var needsComponentNameFix = !ts.isIntrinsicJsxName(symbolToken.text) && !checker.resolveName(symbolToken.text, symbolToken, 111551 /* SymbolFlags.Value */, /*excludeGlobals*/ false); + return needsComponentNameFix ? [symbolToken.text, jsxNamespace] : [jsxNamespace]; + } + } + return [symbolToken.text]; + } + function needsJsxNamespaceFix(jsxNamespace, symbolToken, checker) { + if (ts.isIntrinsicJsxName(symbolToken.text)) + return true; // If we were triggered by a matching error code on an intrinsic, the error must have been about missing the JSX factory + var namespaceSymbol = checker.resolveName(jsxNamespace, symbolToken, 111551 /* SymbolFlags.Value */, /*excludeGlobals*/ true); + return !namespaceSymbol || ts.some(namespaceSymbol.declarations, ts.isTypeOnlyImportOrExportDeclaration) && !(namespaceSymbol.flags & 111551 /* SymbolFlags.Value */); + } + // Returns a map from an exported symbol's ID to a list of every way it's (re-)exported. + function getExportInfos(symbolName, isJsxTagName, currentTokenMeaning, cancellationToken, fromFile, program, useAutoImportProvider, host, preferences) { + var _a; + // For each original symbol, keep all re-exports of that symbol together so we can call `getCodeActionsForImport` on the whole group at once. + // Maps symbol id to info for modules providing that symbol (original export + re-exports). + var originalSymbolToExportInfos = ts.createMultiMap(); + var packageJsonFilter = ts.createPackageJsonImportFilter(fromFile, preferences, host); + var moduleSpecifierCache = (_a = host.getModuleSpecifierCache) === null || _a === void 0 ? void 0 : _a.call(host); + var getModuleSpecifierResolutionHost = ts.memoizeOne(function (isFromPackageJson) { + return ts.createModuleSpecifierResolutionHost(isFromPackageJson ? host.getPackageJsonAutoImportProvider() : program, host); + }); + function addSymbol(moduleSymbol, toFile, exportedSymbol, exportKind, program, isFromPackageJson) { + var moduleSpecifierResolutionHost = getModuleSpecifierResolutionHost(isFromPackageJson); + if (toFile && ts.isImportableFile(program, fromFile, toFile, preferences, packageJsonFilter, moduleSpecifierResolutionHost, moduleSpecifierCache) || + !toFile && packageJsonFilter.allowsImportingAmbientModule(moduleSymbol, moduleSpecifierResolutionHost)) { + var checker = program.getTypeChecker(); + originalSymbolToExportInfos.add(ts.getUniqueSymbolId(exportedSymbol, checker).toString(), { symbol: exportedSymbol, moduleSymbol: moduleSymbol, moduleFileName: toFile === null || toFile === void 0 ? void 0 : toFile.fileName, exportKind: exportKind, targetFlags: ts.skipAlias(exportedSymbol, checker).flags, isFromPackageJson: isFromPackageJson }); + } + } + ts.forEachExternalModuleToImportFrom(program, host, preferences, useAutoImportProvider, function (moduleSymbol, sourceFile, program, isFromPackageJson) { + var checker = program.getTypeChecker(); + cancellationToken.throwIfCancellationRequested(); + var compilerOptions = program.getCompilerOptions(); + var defaultInfo = ts.getDefaultLikeExportInfo(moduleSymbol, checker, compilerOptions); + if (defaultInfo && (defaultInfo.name === symbolName || moduleSymbolToValidIdentifier(moduleSymbol, ts.getEmitScriptTarget(compilerOptions), isJsxTagName) === symbolName) && symbolHasMeaning(defaultInfo.symbolForMeaning, currentTokenMeaning)) { + addSymbol(moduleSymbol, sourceFile, defaultInfo.symbol, defaultInfo.exportKind, program, isFromPackageJson); + } + // check exports with the same name + var exportSymbolWithIdenticalName = checker.tryGetMemberInModuleExportsAndProperties(symbolName, moduleSymbol); + if (exportSymbolWithIdenticalName && symbolHasMeaning(exportSymbolWithIdenticalName, currentTokenMeaning)) { + addSymbol(moduleSymbol, sourceFile, exportSymbolWithIdenticalName, 0 /* ExportKind.Named */, program, isFromPackageJson); + } + }); + return originalSymbolToExportInfos; + } + function getExportEqualsImportKind(importingFile, compilerOptions, forceImportKeyword) { + var allowSyntheticDefaults = ts.getAllowSyntheticDefaultImports(compilerOptions); + var isJS = ts.isInJSFile(importingFile); + // 1. 'import =' will not work in es2015+ TS files, so the decision is between a default + // and a namespace import, based on allowSyntheticDefaultImports/esModuleInterop. + if (!isJS && ts.getEmitModuleKind(compilerOptions) >= ts.ModuleKind.ES2015) { + return allowSyntheticDefaults ? 1 /* ImportKind.Default */ : 2 /* ImportKind.Namespace */; + } + // 2. 'import =' will not work in JavaScript, so the decision is between a default import, + // a namespace import, and const/require. + if (isJS) { + return ts.isExternalModule(importingFile) || forceImportKeyword + ? allowSyntheticDefaults ? 1 /* ImportKind.Default */ : 2 /* ImportKind.Namespace */ + : 3 /* ImportKind.CommonJS */; + } + // 3. At this point the most correct choice is probably 'import =', but people + // really hate that, so look to see if the importing file has any precedent + // on how to handle it. + for (var _i = 0, _a = importingFile.statements; _i < _a.length; _i++) { + var statement = _a[_i]; + // `import foo` parses as an ImportEqualsDeclaration even though it could be an ImportDeclaration + if (ts.isImportEqualsDeclaration(statement) && !ts.nodeIsMissing(statement.moduleReference)) { + return 3 /* ImportKind.CommonJS */; + } + } + // 4. We have no precedent to go on, so just use a default import if + // allowSyntheticDefaultImports/esModuleInterop is enabled. + return allowSyntheticDefaults ? 1 /* ImportKind.Default */ : 3 /* ImportKind.CommonJS */; + } + function codeActionForFix(context, sourceFile, symbolName, fix, includeSymbolNameInDescription, quotePreference, compilerOptions) { + var diag; + var changes = ts.textChanges.ChangeTracker.with(context, function (tracker) { + diag = codeActionForFixWorker(tracker, sourceFile, symbolName, fix, includeSymbolNameInDescription, quotePreference, compilerOptions); + }); + return codefix.createCodeFixAction(codefix.importFixName, changes, diag, importFixId, ts.Diagnostics.Add_all_missing_imports); + } + function codeActionForFixWorker(changes, sourceFile, symbolName, fix, includeSymbolNameInDescription, quotePreference, compilerOptions) { + switch (fix.kind) { + case 0 /* ImportFixKind.UseNamespace */: + addNamespaceQualifier(changes, sourceFile, fix); + return [ts.Diagnostics.Change_0_to_1, symbolName, "".concat(fix.namespacePrefix, ".").concat(symbolName)]; + case 1 /* ImportFixKind.JsdocTypeImport */: + addImportType(changes, sourceFile, fix, quotePreference); + return [ts.Diagnostics.Change_0_to_1, symbolName, getImportTypePrefix(fix.moduleSpecifier, quotePreference) + symbolName]; + case 2 /* ImportFixKind.AddToExisting */: { + var importClauseOrBindingPattern = fix.importClauseOrBindingPattern, importKind = fix.importKind, addAsTypeOnly = fix.addAsTypeOnly, moduleSpecifier = fix.moduleSpecifier; + doAddExistingFix(changes, sourceFile, importClauseOrBindingPattern, importKind === 1 /* ImportKind.Default */ ? { name: symbolName, addAsTypeOnly: addAsTypeOnly } : undefined, importKind === 0 /* ImportKind.Named */ ? [{ name: symbolName, addAsTypeOnly: addAsTypeOnly }] : ts.emptyArray, compilerOptions); + var moduleSpecifierWithoutQuotes = ts.stripQuotes(moduleSpecifier); + return includeSymbolNameInDescription + ? [ts.Diagnostics.Import_0_from_1, symbolName, moduleSpecifierWithoutQuotes] + : [ts.Diagnostics.Update_import_from_0, moduleSpecifierWithoutQuotes]; + } + case 3 /* ImportFixKind.AddNew */: { + var importKind = fix.importKind, moduleSpecifier = fix.moduleSpecifier, addAsTypeOnly = fix.addAsTypeOnly, useRequire = fix.useRequire; + var getDeclarations = useRequire ? getNewRequires : getNewImports; + var defaultImport = importKind === 1 /* ImportKind.Default */ ? { name: symbolName, addAsTypeOnly: addAsTypeOnly } : undefined; + var namedImports = importKind === 0 /* ImportKind.Named */ ? [{ name: symbolName, addAsTypeOnly: addAsTypeOnly }] : undefined; + var namespaceLikeImport = importKind === 2 /* ImportKind.Namespace */ || importKind === 3 /* ImportKind.CommonJS */ ? { importKind: importKind, name: symbolName, addAsTypeOnly: addAsTypeOnly } : undefined; + ts.insertImports(changes, sourceFile, getDeclarations(moduleSpecifier, quotePreference, defaultImport, namedImports, namespaceLikeImport), /*blankLineBetween*/ true); + return includeSymbolNameInDescription + ? [ts.Diagnostics.Import_0_from_1, symbolName, moduleSpecifier] + : [ts.Diagnostics.Add_import_from_0, moduleSpecifier]; + } + case 4 /* ImportFixKind.PromoteTypeOnly */: { + var typeOnlyAliasDeclaration = fix.typeOnlyAliasDeclaration; + var promotedDeclaration = promoteFromTypeOnly(changes, typeOnlyAliasDeclaration, compilerOptions, sourceFile); + return promotedDeclaration.kind === 273 /* SyntaxKind.ImportSpecifier */ + ? [ts.Diagnostics.Remove_type_from_import_of_0_from_1, symbolName, getModuleSpecifierText(promotedDeclaration.parent.parent)] + : [ts.Diagnostics.Remove_type_from_import_declaration_from_0, getModuleSpecifierText(promotedDeclaration)]; + } + default: + return ts.Debug.assertNever(fix, "Unexpected fix kind ".concat(fix.kind)); + } + } + function getModuleSpecifierText(promotedDeclaration) { + var _a, _b; + return promotedDeclaration.kind === 268 /* SyntaxKind.ImportEqualsDeclaration */ + ? ((_b = ts.tryCast((_a = ts.tryCast(promotedDeclaration.moduleReference, ts.isExternalModuleReference)) === null || _a === void 0 ? void 0 : _a.expression, ts.isStringLiteralLike)) === null || _b === void 0 ? void 0 : _b.text) || promotedDeclaration.moduleReference.getText() + : ts.cast(promotedDeclaration.parent.moduleSpecifier, ts.isStringLiteral).text; + } + function promoteFromTypeOnly(changes, aliasDeclaration, compilerOptions, sourceFile) { + // See comment in `doAddExistingFix` on constant with the same name. + var convertExistingToTypeOnly = compilerOptions.preserveValueImports && compilerOptions.isolatedModules; + switch (aliasDeclaration.kind) { + case 273 /* SyntaxKind.ImportSpecifier */: + if (aliasDeclaration.isTypeOnly) { + if (aliasDeclaration.parent.elements.length > 1 && ts.OrganizeImports.importSpecifiersAreSorted(aliasDeclaration.parent.elements)) { + changes.delete(sourceFile, aliasDeclaration); + var newSpecifier = ts.factory.updateImportSpecifier(aliasDeclaration, /*isTypeOnly*/ false, aliasDeclaration.propertyName, aliasDeclaration.name); + var insertionIndex = ts.OrganizeImports.getImportSpecifierInsertionIndex(aliasDeclaration.parent.elements, newSpecifier); + changes.insertImportSpecifierAtIndex(sourceFile, newSpecifier, aliasDeclaration.parent, insertionIndex); + } + else { + changes.deleteRange(sourceFile, aliasDeclaration.getFirstToken()); + } + return aliasDeclaration; + } + else { + ts.Debug.assert(aliasDeclaration.parent.parent.isTypeOnly); + promoteImportClause(aliasDeclaration.parent.parent); + return aliasDeclaration.parent.parent; + } + case 270 /* SyntaxKind.ImportClause */: + promoteImportClause(aliasDeclaration); + return aliasDeclaration; + case 271 /* SyntaxKind.NamespaceImport */: + promoteImportClause(aliasDeclaration.parent); + return aliasDeclaration.parent; + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + changes.deleteRange(sourceFile, aliasDeclaration.getChildAt(1)); + return aliasDeclaration; + default: + ts.Debug.failBadSyntaxKind(aliasDeclaration); + } + function promoteImportClause(importClause) { + changes.delete(sourceFile, ts.getTypeKeywordOfTypeOnlyImport(importClause, sourceFile)); + if (convertExistingToTypeOnly) { + var namedImports = ts.tryCast(importClause.namedBindings, ts.isNamedImports); + if (namedImports && namedImports.elements.length > 1) { + if (ts.OrganizeImports.importSpecifiersAreSorted(namedImports.elements) && + aliasDeclaration.kind === 273 /* SyntaxKind.ImportSpecifier */ && + namedImports.elements.indexOf(aliasDeclaration) !== 0) { + // The import specifier being promoted will be the only non-type-only, + // import in the NamedImports, so it should be moved to the front. + changes.delete(sourceFile, aliasDeclaration); + changes.insertImportSpecifierAtIndex(sourceFile, aliasDeclaration, namedImports, 0); + } + for (var _i = 0, _a = namedImports.elements; _i < _a.length; _i++) { + var element = _a[_i]; + if (element !== aliasDeclaration && !element.isTypeOnly) { + changes.insertModifierBefore(sourceFile, 154 /* SyntaxKind.TypeKeyword */, element); + } + } + } + } + } + } + function doAddExistingFix(changes, sourceFile, clause, defaultImport, namedImports, compilerOptions) { + var _a; + if (clause.kind === 203 /* SyntaxKind.ObjectBindingPattern */) { + if (defaultImport) { + addElementToBindingPattern(clause, defaultImport.name, "default"); + } + for (var _i = 0, namedImports_1 = namedImports; _i < namedImports_1.length; _i++) { + var specifier = namedImports_1[_i]; + addElementToBindingPattern(clause, specifier.name, /*propertyName*/ undefined); + } + return; + } + var promoteFromTypeOnly = clause.isTypeOnly && ts.some(__spreadArray([defaultImport], namedImports, true), function (i) { return (i === null || i === void 0 ? void 0 : i.addAsTypeOnly) === 4 /* AddAsTypeOnly.NotAllowed */; }); + var existingSpecifiers = clause.namedBindings && ((_a = ts.tryCast(clause.namedBindings, ts.isNamedImports)) === null || _a === void 0 ? void 0 : _a.elements); + // If we are promoting from a type-only import and `--isolatedModules` and `--preserveValueImports` + // are enabled, we need to make every existing import specifier type-only. It may be possible that + // some of them don't strictly need to be marked type-only (if they have a value meaning and are + // never used in an emitting position). These are allowed to be imported without being type-only, + // but the user has clearly already signified that they don't need them to be present at runtime + // by placing them in a type-only import. So, just mark each specifier as type-only. + var convertExistingToTypeOnly = promoteFromTypeOnly && compilerOptions.preserveValueImports && compilerOptions.isolatedModules; + if (defaultImport) { + ts.Debug.assert(!clause.name, "Cannot add a default import to an import clause that already has one"); + changes.insertNodeAt(sourceFile, clause.getStart(sourceFile), ts.factory.createIdentifier(defaultImport.name), { suffix: ", " }); + } + if (namedImports.length) { + var newSpecifiers = ts.stableSort(namedImports.map(function (namedImport) { return ts.factory.createImportSpecifier((!clause.isTypeOnly || promoteFromTypeOnly) && needsTypeOnly(namedImport), + /*propertyName*/ undefined, ts.factory.createIdentifier(namedImport.name)); }), ts.OrganizeImports.compareImportOrExportSpecifiers); + if ((existingSpecifiers === null || existingSpecifiers === void 0 ? void 0 : existingSpecifiers.length) && ts.OrganizeImports.importSpecifiersAreSorted(existingSpecifiers)) { + for (var _b = 0, newSpecifiers_1 = newSpecifiers; _b < newSpecifiers_1.length; _b++) { + var spec = newSpecifiers_1[_b]; + // Organize imports puts type-only import specifiers last, so if we're + // adding a non-type-only specifier and converting all the other ones to + // type-only, there's no need to ask for the insertion index - it's 0. + var insertionIndex = convertExistingToTypeOnly && !spec.isTypeOnly + ? 0 + : ts.OrganizeImports.getImportSpecifierInsertionIndex(existingSpecifiers, spec); + changes.insertImportSpecifierAtIndex(sourceFile, spec, clause.namedBindings, insertionIndex); + } + } + else if (existingSpecifiers === null || existingSpecifiers === void 0 ? void 0 : existingSpecifiers.length) { + for (var _c = 0, newSpecifiers_2 = newSpecifiers; _c < newSpecifiers_2.length; _c++) { + var spec = newSpecifiers_2[_c]; + changes.insertNodeInListAfter(sourceFile, ts.last(existingSpecifiers), spec, existingSpecifiers); + } + } + else { + if (newSpecifiers.length) { + var namedImports_2 = ts.factory.createNamedImports(newSpecifiers); + if (clause.namedBindings) { + changes.replaceNode(sourceFile, clause.namedBindings, namedImports_2); + } + else { + changes.insertNodeAfter(sourceFile, ts.Debug.checkDefined(clause.name, "Import clause must have either named imports or a default import"), namedImports_2); + } + } + } + } + if (promoteFromTypeOnly) { + changes.delete(sourceFile, ts.getTypeKeywordOfTypeOnlyImport(clause, sourceFile)); + if (convertExistingToTypeOnly && existingSpecifiers) { + for (var _d = 0, existingSpecifiers_1 = existingSpecifiers; _d < existingSpecifiers_1.length; _d++) { + var specifier = existingSpecifiers_1[_d]; + changes.insertModifierBefore(sourceFile, 154 /* SyntaxKind.TypeKeyword */, specifier); + } + } + } + function addElementToBindingPattern(bindingPattern, name, propertyName) { + var element = ts.factory.createBindingElement(/*dotDotDotToken*/ undefined, propertyName, name); + if (bindingPattern.elements.length) { + changes.insertNodeInListAfter(sourceFile, ts.last(bindingPattern.elements), element); + } + else { + changes.replaceNode(sourceFile, bindingPattern, ts.factory.createObjectBindingPattern([element])); + } + } + } + function addNamespaceQualifier(changes, sourceFile, _a) { + var namespacePrefix = _a.namespacePrefix, position = _a.position; + changes.insertText(sourceFile, position, namespacePrefix + "."); + } + function addImportType(changes, sourceFile, _a, quotePreference) { + var moduleSpecifier = _a.moduleSpecifier, position = _a.position; + changes.insertText(sourceFile, position, getImportTypePrefix(moduleSpecifier, quotePreference)); + } + function getImportTypePrefix(moduleSpecifier, quotePreference) { + var quote = ts.getQuoteFromPreference(quotePreference); + return "import(".concat(quote).concat(moduleSpecifier).concat(quote, ")."); + } + function needsTypeOnly(_a) { + var addAsTypeOnly = _a.addAsTypeOnly; + return addAsTypeOnly === 2 /* AddAsTypeOnly.Required */; + } + function getNewImports(moduleSpecifier, quotePreference, defaultImport, namedImports, namespaceLikeImport) { + var quotedModuleSpecifier = ts.makeStringLiteral(moduleSpecifier, quotePreference); + var statements; + if (defaultImport !== undefined || (namedImports === null || namedImports === void 0 ? void 0 : namedImports.length)) { + var topLevelTypeOnly_1 = (!defaultImport || needsTypeOnly(defaultImport)) && ts.every(namedImports, needsTypeOnly); + statements = ts.combine(statements, ts.makeImport(defaultImport && ts.factory.createIdentifier(defaultImport.name), namedImports === null || namedImports === void 0 ? void 0 : namedImports.map(function (_a) { + var addAsTypeOnly = _a.addAsTypeOnly, name = _a.name; + return ts.factory.createImportSpecifier(!topLevelTypeOnly_1 && addAsTypeOnly === 2 /* AddAsTypeOnly.Required */, + /*propertyName*/ undefined, ts.factory.createIdentifier(name)); + }), moduleSpecifier, quotePreference, topLevelTypeOnly_1)); + } + if (namespaceLikeImport) { + var declaration = namespaceLikeImport.importKind === 3 /* ImportKind.CommonJS */ + ? ts.factory.createImportEqualsDeclaration( + /*modifiers*/ undefined, needsTypeOnly(namespaceLikeImport), ts.factory.createIdentifier(namespaceLikeImport.name), ts.factory.createExternalModuleReference(quotedModuleSpecifier)) + : ts.factory.createImportDeclaration( + /*modifiers*/ undefined, ts.factory.createImportClause(needsTypeOnly(namespaceLikeImport), + /*name*/ undefined, ts.factory.createNamespaceImport(ts.factory.createIdentifier(namespaceLikeImport.name))), quotedModuleSpecifier, + /*assertClause*/ undefined); + statements = ts.combine(statements, declaration); + } + return ts.Debug.checkDefined(statements); + } + function getNewRequires(moduleSpecifier, quotePreference, defaultImport, namedImports, namespaceLikeImport) { + var quotedModuleSpecifier = ts.makeStringLiteral(moduleSpecifier, quotePreference); + var statements; + // const { default: foo, bar, etc } = require('./mod'); + if (defaultImport || (namedImports === null || namedImports === void 0 ? void 0 : namedImports.length)) { + var bindingElements = (namedImports === null || namedImports === void 0 ? void 0 : namedImports.map(function (_a) { + var name = _a.name; + return ts.factory.createBindingElement(/*dotDotDotToken*/ undefined, /*propertyName*/ undefined, name); + })) || []; + if (defaultImport) { + bindingElements.unshift(ts.factory.createBindingElement(/*dotDotDotToken*/ undefined, "default", defaultImport.name)); + } + var declaration = createConstEqualsRequireDeclaration(ts.factory.createObjectBindingPattern(bindingElements), quotedModuleSpecifier); + statements = ts.combine(statements, declaration); + } + // const foo = require('./mod'); + if (namespaceLikeImport) { + var declaration = createConstEqualsRequireDeclaration(namespaceLikeImport.name, quotedModuleSpecifier); + statements = ts.combine(statements, declaration); + } + return ts.Debug.checkDefined(statements); + } + function createConstEqualsRequireDeclaration(name, quotedModuleSpecifier) { + return ts.factory.createVariableStatement( + /*modifiers*/ undefined, ts.factory.createVariableDeclarationList([ + ts.factory.createVariableDeclaration(typeof name === "string" ? ts.factory.createIdentifier(name) : name, + /*exclamationToken*/ undefined, + /*type*/ undefined, ts.factory.createCallExpression(ts.factory.createIdentifier("require"), /*typeArguments*/ undefined, [quotedModuleSpecifier])) + ], 2 /* NodeFlags.Const */)); + } + function symbolHasMeaning(_a, meaning) { + var declarations = _a.declarations; + return ts.some(declarations, function (decl) { return !!(ts.getMeaningFromDeclaration(decl) & meaning); }); + } + function moduleSymbolToValidIdentifier(moduleSymbol, target, forceCapitalize) { + return moduleSpecifierToValidIdentifier(ts.removeFileExtension(ts.stripQuotes(moduleSymbol.name)), target, forceCapitalize); + } + codefix.moduleSymbolToValidIdentifier = moduleSymbolToValidIdentifier; + function moduleSpecifierToValidIdentifier(moduleSpecifier, target, forceCapitalize) { + var baseName = ts.getBaseFileName(ts.removeSuffix(moduleSpecifier, "/index")); + var res = ""; + var lastCharWasValid = true; + var firstCharCode = baseName.charCodeAt(0); + if (ts.isIdentifierStart(firstCharCode, target)) { + res += String.fromCharCode(firstCharCode); + if (forceCapitalize) { + res = res.toUpperCase(); + } + } + else { + lastCharWasValid = false; + } + for (var i = 1; i < baseName.length; i++) { + var ch = baseName.charCodeAt(i); + var isValid = ts.isIdentifierPart(ch, target); + if (isValid) { + var char = String.fromCharCode(ch); + if (!lastCharWasValid) { + char = char.toUpperCase(); + } + res += char; + } + lastCharWasValid = isValid; + } + // Need `|| "_"` to ensure result isn't empty. + return !ts.isStringANonContextualKeyword(res) ? res || "_" : "_".concat(res); + } + codefix.moduleSpecifierToValidIdentifier = moduleSpecifierToValidIdentifier; + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "addMissingConstraint"; + var errorCodes = [ + // We want errors this could be attached to: + // Diagnostics.This_type_parameter_probably_needs_an_extends_0_constraint + ts.Diagnostics.Type_0_is_not_comparable_to_type_1.code, + ts.Diagnostics.Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated.code, + ts.Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties.code, + ts.Diagnostics.Type_0_is_not_assignable_to_type_1.code, + ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_types_of_the_target_s_properties.code, + ts.Diagnostics.Property_0_is_incompatible_with_index_signature.code, + ts.Diagnostics.Property_0_in_type_1_is_not_assignable_to_type_2.code, + ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1.code, + ]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var sourceFile = context.sourceFile, span = context.span, program = context.program, preferences = context.preferences, host = context.host; + var info = getInfo(program, sourceFile, span); + if (info === undefined) + return; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addMissingConstraint(t, program, preferences, host, sourceFile, info); }); + return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Add_extends_constraint, fixId, ts.Diagnostics.Add_extends_constraint_to_all_type_parameters)]; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { + var program = context.program, preferences = context.preferences, host = context.host; + var seen = new ts.Map(); + return codefix.createCombinedCodeActions(ts.textChanges.ChangeTracker.with(context, function (changes) { + codefix.eachDiagnostic(context, errorCodes, function (diag) { + var info = getInfo(program, diag.file, ts.createTextSpan(diag.start, diag.length)); + if (info) { + if (ts.addToSeen(seen, ts.getNodeId(info.declaration))) { + return addMissingConstraint(changes, program, preferences, host, diag.file, info); + } + } + return undefined; + }); + })); + } + }); + function getInfo(program, sourceFile, span) { + var diag = ts.find(program.getSemanticDiagnostics(sourceFile), function (diag) { return diag.start === span.start && diag.length === span.length; }); + if (diag === undefined || diag.relatedInformation === undefined) + return; + var related = ts.find(diag.relatedInformation, function (related) { return related.code === ts.Diagnostics.This_type_parameter_might_need_an_extends_0_constraint.code; }); + if (related === undefined || related.file === undefined || related.start === undefined || related.length === undefined) + return; + var declaration = codefix.findAncestorMatchingSpan(related.file, ts.createTextSpan(related.start, related.length)); + if (declaration === undefined) + return; + if (ts.isIdentifier(declaration) && ts.isTypeParameterDeclaration(declaration.parent)) { + declaration = declaration.parent; + } + if (ts.isTypeParameterDeclaration(declaration)) { + // should only issue fix on type parameters written using `extends` + if (ts.isMappedTypeNode(declaration.parent)) + return; + var token = ts.getTokenAtPosition(sourceFile, span.start); + var checker = program.getTypeChecker(); + var constraint = tryGetConstraintType(checker, token) || tryGetConstraintFromDiagnosticMessage(related.messageText); + return { constraint: constraint, declaration: declaration, token: token }; + } + return undefined; + } + function addMissingConstraint(changes, program, preferences, host, sourceFile, info) { + var declaration = info.declaration, constraint = info.constraint; + var checker = program.getTypeChecker(); + if (ts.isString(constraint)) { + changes.insertText(sourceFile, declaration.name.end, " extends ".concat(constraint)); + } + else { + var scriptTarget = ts.getEmitScriptTarget(program.getCompilerOptions()); + var tracker = codefix.getNoopSymbolTrackerWithResolver({ program: program, host: host }); + var importAdder = codefix.createImportAdder(sourceFile, program, preferences, host); + var typeNode = codefix.typeToAutoImportableTypeNode(checker, importAdder, constraint, /*contextNode*/ undefined, scriptTarget, /*flags*/ undefined, tracker); + if (typeNode) { + changes.replaceNode(sourceFile, declaration, ts.factory.updateTypeParameterDeclaration(declaration, /*modifiers*/ undefined, declaration.name, typeNode, declaration.default)); + importAdder.writeFixes(changes); + } + } + } + function tryGetConstraintFromDiagnosticMessage(messageText) { + var _a = ts.flattenDiagnosticMessageText(messageText, "\n", 0).match(/`extends (.*)`/) || [], _ = _a[0], constraint = _a[1]; + return constraint; + } + function tryGetConstraintType(checker, node) { + if (ts.isTypeNode(node.parent)) { + return checker.getTypeArgumentConstraint(node.parent); + } + var contextualType = ts.isExpression(node) ? checker.getContextualType(node) : undefined; + return contextualType || checker.getTypeAtLocation(node); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var _a; + var fixName = "fixOverrideModifier"; + var fixAddOverrideId = "fixAddOverrideModifier"; + var fixRemoveOverrideId = "fixRemoveOverrideModifier"; + var errorCodes = [ + ts.Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0.code, + ts.Diagnostics.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class.code, + ts.Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0.code, + ts.Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0.code, + ts.Diagnostics.This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0.code, + ts.Diagnostics.This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code, + ts.Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class.code, + ts.Diagnostics.This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code, + ts.Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0.code, + ]; + var errorCodeFixIdMap = (_a = {}, + // case #1: + _a[ts.Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0.code] = { + descriptions: ts.Diagnostics.Add_override_modifier, + fixId: fixAddOverrideId, + fixAllDescriptions: ts.Diagnostics.Add_all_missing_override_modifiers, + }, + _a[ts.Diagnostics.This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code] = { + descriptions: ts.Diagnostics.Add_override_modifier, + fixId: fixAddOverrideId, + fixAllDescriptions: ts.Diagnostics.Add_all_missing_override_modifiers + }, + // case #2: + _a[ts.Diagnostics.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class.code] = { + descriptions: ts.Diagnostics.Remove_override_modifier, + fixId: fixRemoveOverrideId, + fixAllDescriptions: ts.Diagnostics.Remove_all_unnecessary_override_modifiers, + }, + _a[ts.Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class.code] = { + descriptions: ts.Diagnostics.Remove_override_modifier, + fixId: fixRemoveOverrideId, + fixAllDescriptions: ts.Diagnostics.Remove_override_modifier + }, + // case #3: + _a[ts.Diagnostics.This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0.code] = { + descriptions: ts.Diagnostics.Add_override_modifier, + fixId: fixAddOverrideId, + fixAllDescriptions: ts.Diagnostics.Add_all_missing_override_modifiers, + }, + _a[ts.Diagnostics.This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code] = { + descriptions: ts.Diagnostics.Add_override_modifier, + fixId: fixAddOverrideId, + fixAllDescriptions: ts.Diagnostics.Add_all_missing_override_modifiers, + }, + // case #4: + _a[ts.Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0.code] = { + descriptions: ts.Diagnostics.Add_override_modifier, + fixId: fixAddOverrideId, + fixAllDescriptions: ts.Diagnostics.Remove_all_unnecessary_override_modifiers, + }, + // case #5: + _a[ts.Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0.code] = { + descriptions: ts.Diagnostics.Remove_override_modifier, + fixId: fixRemoveOverrideId, + fixAllDescriptions: ts.Diagnostics.Remove_all_unnecessary_override_modifiers, + }, + _a[ts.Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0.code] = { + descriptions: ts.Diagnostics.Remove_override_modifier, + fixId: fixRemoveOverrideId, + fixAllDescriptions: ts.Diagnostics.Remove_all_unnecessary_override_modifiers, + }, + _a); + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function getCodeActionsToFixOverrideModifierIssues(context) { + var errorCode = context.errorCode, span = context.span; + var info = errorCodeFixIdMap[errorCode]; + if (!info) + return ts.emptyArray; + var descriptions = info.descriptions, fixId = info.fixId, fixAllDescriptions = info.fixAllDescriptions; + var changes = ts.textChanges.ChangeTracker.with(context, function (changes) { return dispatchChanges(changes, context, errorCode, span.start); }); + return [ + codefix.createCodeFixActionMaybeFixAll(fixName, changes, descriptions, fixId, fixAllDescriptions) + ]; + }, + fixIds: [fixName, fixAddOverrideId, fixRemoveOverrideId], + getAllCodeActions: function (context) { + return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var code = diag.code, start = diag.start; + var info = errorCodeFixIdMap[code]; + if (!info || info.fixId !== context.fixId) { + return; + } + dispatchChanges(changes, context, code, start); + }); + } + }); + function dispatchChanges(changeTracker, context, errorCode, pos) { + switch (errorCode) { + case ts.Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_a_member_in_the_base_class_0.code: + case ts.Diagnostics.This_member_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code: + case ts.Diagnostics.This_member_must_have_an_override_modifier_because_it_overrides_an_abstract_method_that_is_declared_in_the_base_class_0.code: + case ts.Diagnostics.This_parameter_property_must_have_an_override_modifier_because_it_overrides_a_member_in_base_class_0.code: + case ts.Diagnostics.This_parameter_property_must_have_a_JSDoc_comment_with_an_override_tag_because_it_overrides_a_member_in_the_base_class_0.code: + return doAddOverrideModifierChange(changeTracker, context.sourceFile, pos); + case ts.Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0.code: + case ts.Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0.code: + case ts.Diagnostics.This_member_cannot_have_an_override_modifier_because_its_containing_class_0_does_not_extend_another_class.code: + case ts.Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_its_containing_class_0_does_not_extend_another_class.code: + return doRemoveOverrideModifierChange(changeTracker, context.sourceFile, pos); + default: + ts.Debug.fail("Unexpected error code: " + errorCode); + } + } + function doAddOverrideModifierChange(changeTracker, sourceFile, pos) { + var classElement = findContainerClassElementLike(sourceFile, pos); + if (ts.isSourceFileJS(sourceFile)) { + changeTracker.addJSDocTags(sourceFile, classElement, [ts.factory.createJSDocOverrideTag(ts.factory.createIdentifier("override"))]); + return; + } + var modifiers = classElement.modifiers || ts.emptyArray; + var staticModifier = ts.find(modifiers, ts.isStaticModifier); + var abstractModifier = ts.find(modifiers, ts.isAbstractModifier); + var accessibilityModifier = ts.find(modifiers, function (m) { return ts.isAccessibilityModifier(m.kind); }); + var lastDecorator = ts.findLast(modifiers, ts.isDecorator); + var modifierPos = abstractModifier ? abstractModifier.end : + staticModifier ? staticModifier.end : + accessibilityModifier ? accessibilityModifier.end : + lastDecorator ? ts.skipTrivia(sourceFile.text, lastDecorator.end) : classElement.getStart(sourceFile); + var options = accessibilityModifier || staticModifier || abstractModifier ? { prefix: " " } : { suffix: " " }; + changeTracker.insertModifierAt(sourceFile, modifierPos, 161 /* SyntaxKind.OverrideKeyword */, options); + } + function doRemoveOverrideModifierChange(changeTracker, sourceFile, pos) { + var classElement = findContainerClassElementLike(sourceFile, pos); + if (ts.isSourceFileJS(sourceFile)) { + changeTracker.filterJSDocTags(sourceFile, classElement, ts.not(ts.isJSDocOverrideTag)); + return; + } + var overrideModifier = ts.find(classElement.modifiers, ts.isOverrideModifier); + ts.Debug.assertIsDefined(overrideModifier); + changeTracker.deleteModifier(sourceFile, overrideModifier); + } + function isClassElementLikeHasJSDoc(node) { + switch (node.kind) { + case 173 /* SyntaxKind.Constructor */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + return true; + case 166 /* SyntaxKind.Parameter */: + return ts.isParameterPropertyDeclaration(node, node.parent); + default: + return false; + } + } + function findContainerClassElementLike(sourceFile, pos) { + var token = ts.getTokenAtPosition(sourceFile, pos); + var classElement = ts.findAncestor(token, function (node) { + if (ts.isClassLike(node)) + return "quit"; + return isClassElementLikeHasJSDoc(node); + }); + ts.Debug.assert(classElement && isClassElementLikeHasJSDoc(classElement)); + return classElement; + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "fixNoPropertyAccessFromIndexSignature"; + var errorCodes = [ + ts.Diagnostics.Property_0_comes_from_an_index_signature_so_it_must_be_accessed_with_0.code + ]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + fixIds: [fixId], + getCodeActions: function (context) { + var sourceFile = context.sourceFile, span = context.span, preferences = context.preferences; + var property = getPropertyAccessExpression(sourceFile, span.start); + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, context.sourceFile, property, preferences); }); + return [codefix.createCodeFixAction(fixId, changes, [ts.Diagnostics.Use_element_access_for_0, property.name.text], fixId, ts.Diagnostics.Use_element_access_for_all_undeclared_properties)]; + }, + getAllCodeActions: function (context) { + return codefix.codeFixAll(context, errorCodes, function (changes, diag) { return doChange(changes, diag.file, getPropertyAccessExpression(diag.file, diag.start), context.preferences); }); + } + }); + function doChange(changes, sourceFile, node, preferences) { + var quotePreference = ts.getQuotePreference(sourceFile, preferences); + var argumentsExpression = ts.factory.createStringLiteral(node.name.text, quotePreference === 0 /* QuotePreference.Single */); + changes.replaceNode(sourceFile, node, ts.isPropertyAccessChain(node) ? + ts.factory.createElementAccessChain(node.expression, node.questionDotToken, argumentsExpression) : + ts.factory.createElementAccessExpression(node.expression, argumentsExpression)); + } + function getPropertyAccessExpression(sourceFile, pos) { + return ts.cast(ts.getTokenAtPosition(sourceFile, pos).parent, ts.isPropertyAccessExpression); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "fixImplicitThis"; + var errorCodes = [ts.Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function getCodeActionsToFixImplicitThis(context) { + var sourceFile = context.sourceFile, program = context.program, span = context.span; + var diagnostic; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { + diagnostic = doChange(t, sourceFile, span.start, program.getTypeChecker()); + }); + return diagnostic ? [codefix.createCodeFixAction(fixId, changes, diagnostic, fixId, ts.Diagnostics.Fix_all_implicit_this_errors)] : ts.emptyArray; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + doChange(changes, diag.file, diag.start, context.program.getTypeChecker()); + }); }, + }); + function doChange(changes, sourceFile, pos, checker) { + var token = ts.getTokenAtPosition(sourceFile, pos); + if (!ts.isThis(token)) + return undefined; + var fn = ts.getThisContainer(token, /*includeArrowFunctions*/ false); + if (!ts.isFunctionDeclaration(fn) && !ts.isFunctionExpression(fn)) + return undefined; + if (!ts.isSourceFile(ts.getThisContainer(fn, /*includeArrowFunctions*/ false))) { // 'this' is defined outside, convert to arrow function + var fnKeyword = ts.Debug.checkDefined(ts.findChildOfKind(fn, 98 /* SyntaxKind.FunctionKeyword */, sourceFile)); + var name = fn.name; + var body = ts.Debug.checkDefined(fn.body); // Should be defined because the function contained a 'this' expression + if (ts.isFunctionExpression(fn)) { + if (name && ts.FindAllReferences.Core.isSymbolReferencedInFile(name, checker, sourceFile, body)) { + // Function expression references itself. To fix we would have to extract it to a const. + return undefined; + } + // `function() {}` --> `() => {}` + changes.delete(sourceFile, fnKeyword); + if (name) { + changes.delete(sourceFile, name); + } + changes.insertText(sourceFile, body.pos, " =>"); + return [ts.Diagnostics.Convert_function_expression_0_to_arrow_function, name ? name.text : ts.ANONYMOUS]; + } + else { + // `function f() {}` => `const f = () => {}` + // `name` should be defined because we only do this in inner contexts, and name is only undefined for `export default function() {}`. + changes.replaceNode(sourceFile, fnKeyword, ts.factory.createToken(85 /* SyntaxKind.ConstKeyword */)); + changes.insertText(sourceFile, name.end, " = "); + changes.insertText(sourceFile, body.pos, " =>"); + return [ts.Diagnostics.Convert_function_declaration_0_to_arrow_function, name.text]; + } + } + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "fixImportNonExportedMember"; + var errorCodes = [ + ts.Diagnostics.Module_0_declares_1_locally_but_it_is_not_exported.code, + ]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + fixIds: [fixId], + getCodeActions: function (context) { + var sourceFile = context.sourceFile, span = context.span, program = context.program; + var info = getInfo(sourceFile, span.start, program); + if (info === undefined) + return undefined; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, program, info); }); + return [codefix.createCodeFixAction(fixId, changes, [ts.Diagnostics.Export_0_from_module_1, info.exportName.node.text, info.moduleSpecifier], fixId, ts.Diagnostics.Export_all_referenced_locals)]; + }, + getAllCodeActions: function (context) { + var program = context.program; + return codefix.createCombinedCodeActions(ts.textChanges.ChangeTracker.with(context, function (changes) { + var exports = new ts.Map(); + codefix.eachDiagnostic(context, errorCodes, function (diag) { + var info = getInfo(diag.file, diag.start, program); + if (info === undefined) + return undefined; + var exportName = info.exportName, node = info.node, moduleSourceFile = info.moduleSourceFile; + if (tryGetExportDeclaration(moduleSourceFile, exportName.isTypeOnly) === undefined && ts.canHaveExportModifier(node)) { + changes.insertExportModifier(moduleSourceFile, node); + } + else { + var moduleExports = exports.get(moduleSourceFile) || { typeOnlyExports: [], exports: [] }; + if (exportName.isTypeOnly) { + moduleExports.typeOnlyExports.push(exportName); + } + else { + moduleExports.exports.push(exportName); + } + exports.set(moduleSourceFile, moduleExports); + } + }); + exports.forEach(function (moduleExports, moduleSourceFile) { + var exportDeclaration = tryGetExportDeclaration(moduleSourceFile, /*isTypeOnly*/ true); + if (exportDeclaration && exportDeclaration.isTypeOnly) { + doChanges(changes, program, moduleSourceFile, moduleExports.typeOnlyExports, exportDeclaration); + doChanges(changes, program, moduleSourceFile, moduleExports.exports, tryGetExportDeclaration(moduleSourceFile, /*isTypeOnly*/ false)); + } + else { + doChanges(changes, program, moduleSourceFile, __spreadArray(__spreadArray([], moduleExports.exports, true), moduleExports.typeOnlyExports, true), exportDeclaration); + } + }); + })); + } + }); + function getInfo(sourceFile, pos, program) { + var _a; + var token = ts.getTokenAtPosition(sourceFile, pos); + if (ts.isIdentifier(token)) { + var importDeclaration = ts.findAncestor(token, ts.isImportDeclaration); + if (importDeclaration === undefined) + return undefined; + var moduleSpecifier = ts.isStringLiteral(importDeclaration.moduleSpecifier) ? importDeclaration.moduleSpecifier.text : undefined; + if (moduleSpecifier === undefined) + return undefined; + var resolvedModule = ts.getResolvedModule(sourceFile, moduleSpecifier, /*mode*/ undefined); + if (resolvedModule === undefined) + return undefined; + var moduleSourceFile = program.getSourceFile(resolvedModule.resolvedFileName); + if (moduleSourceFile === undefined || ts.isSourceFileFromLibrary(program, moduleSourceFile)) + return undefined; + var moduleSymbol = moduleSourceFile.symbol; + var locals = (_a = moduleSymbol.valueDeclaration) === null || _a === void 0 ? void 0 : _a.locals; + if (locals === undefined) + return undefined; + var localSymbol = locals.get(token.escapedText); + if (localSymbol === undefined) + return undefined; + var node = getNodeOfSymbol(localSymbol); + if (node === undefined) + return undefined; + var exportName = { node: token, isTypeOnly: ts.isTypeDeclaration(node) }; + return { exportName: exportName, node: node, moduleSourceFile: moduleSourceFile, moduleSpecifier: moduleSpecifier }; + } + return undefined; + } + function doChange(changes, program, _a) { + var exportName = _a.exportName, node = _a.node, moduleSourceFile = _a.moduleSourceFile; + var exportDeclaration = tryGetExportDeclaration(moduleSourceFile, exportName.isTypeOnly); + if (exportDeclaration) { + updateExport(changes, program, moduleSourceFile, exportDeclaration, [exportName]); + } + else if (ts.canHaveExportModifier(node)) { + changes.insertExportModifier(moduleSourceFile, node); + } + else { + createExport(changes, program, moduleSourceFile, [exportName]); + } + } + function doChanges(changes, program, sourceFile, moduleExports, node) { + if (ts.length(moduleExports)) { + if (node) { + updateExport(changes, program, sourceFile, node, moduleExports); + } + else { + createExport(changes, program, sourceFile, moduleExports); + } + } + } + function tryGetExportDeclaration(sourceFile, isTypeOnly) { + var predicate = function (node) { + return ts.isExportDeclaration(node) && (isTypeOnly && node.isTypeOnly || !node.isTypeOnly); + }; + return ts.findLast(sourceFile.statements, predicate); + } + function updateExport(changes, program, sourceFile, node, names) { + var namedExports = node.exportClause && ts.isNamedExports(node.exportClause) ? node.exportClause.elements : ts.factory.createNodeArray([]); + var allowTypeModifier = !node.isTypeOnly && !!(program.getCompilerOptions().isolatedModules || ts.find(namedExports, function (e) { return e.isTypeOnly; })); + changes.replaceNode(sourceFile, node, ts.factory.updateExportDeclaration(node, node.modifiers, node.isTypeOnly, ts.factory.createNamedExports(ts.factory.createNodeArray(__spreadArray(__spreadArray([], namedExports, true), createExportSpecifiers(names, allowTypeModifier), true), /*hasTrailingComma*/ namedExports.hasTrailingComma)), node.moduleSpecifier, node.assertClause)); + } + function createExport(changes, program, sourceFile, names) { + changes.insertNodeAtEndOfScope(sourceFile, sourceFile, ts.factory.createExportDeclaration(/*modifiers*/ undefined, /*isTypeOnly*/ false, ts.factory.createNamedExports(createExportSpecifiers(names, /*allowTypeModifier*/ !!program.getCompilerOptions().isolatedModules)), /*moduleSpecifier*/ undefined, /*assertClause*/ undefined)); + } + function createExportSpecifiers(names, allowTypeModifier) { + return ts.factory.createNodeArray(ts.map(names, function (n) { return ts.factory.createExportSpecifier(allowTypeModifier && n.isTypeOnly, /*propertyName*/ undefined, n.node); })); + } + function getNodeOfSymbol(symbol) { + if (symbol.valueDeclaration === undefined) { + return ts.firstOrUndefined(symbol.declarations); + } + var declaration = symbol.valueDeclaration; + var variableStatement = ts.isVariableDeclaration(declaration) ? ts.tryCast(declaration.parent.parent, ts.isVariableStatement) : undefined; + return variableStatement && ts.length(variableStatement.declarationList.declarations) === 1 ? variableStatement : declaration; + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "fixIncorrectNamedTupleSyntax"; + var errorCodes = [ + ts.Diagnostics.A_labeled_tuple_element_is_declared_as_optional_with_a_question_mark_after_the_name_and_before_the_colon_rather_than_after_the_type.code, + ts.Diagnostics.A_labeled_tuple_element_is_declared_as_rest_with_a_before_the_name_rather_than_before_the_type.code + ]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function getCodeActionsToFixIncorrectNamedTupleSyntax(context) { + var sourceFile = context.sourceFile, span = context.span; + var namedTupleMember = getNamedTupleMember(sourceFile, span.start); + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, sourceFile, namedTupleMember); }); + return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Move_labeled_tuple_element_modifiers_to_labels, fixId, ts.Diagnostics.Move_labeled_tuple_element_modifiers_to_labels)]; + }, + fixIds: [fixId] + }); + function getNamedTupleMember(sourceFile, pos) { + var token = ts.getTokenAtPosition(sourceFile, pos); + return ts.findAncestor(token, function (t) { return t.kind === 199 /* SyntaxKind.NamedTupleMember */; }); + } + function doChange(changes, sourceFile, namedTupleMember) { + if (!namedTupleMember) { + return; + } + var unwrappedType = namedTupleMember.type; + var sawOptional = false; + var sawRest = false; + while (unwrappedType.kind === 187 /* SyntaxKind.OptionalType */ || unwrappedType.kind === 188 /* SyntaxKind.RestType */ || unwrappedType.kind === 193 /* SyntaxKind.ParenthesizedType */) { + if (unwrappedType.kind === 187 /* SyntaxKind.OptionalType */) { + sawOptional = true; + } + else if (unwrappedType.kind === 188 /* SyntaxKind.RestType */) { + sawRest = true; + } + unwrappedType = unwrappedType.type; + } + var updated = ts.factory.updateNamedTupleMember(namedTupleMember, namedTupleMember.dotDotDotToken || (sawRest ? ts.factory.createToken(25 /* SyntaxKind.DotDotDotToken */) : undefined), namedTupleMember.name, namedTupleMember.questionToken || (sawOptional ? ts.factory.createToken(57 /* SyntaxKind.QuestionToken */) : undefined), unwrappedType); + if (updated === namedTupleMember) { + return; + } + changes.replaceNode(sourceFile, namedTupleMember, updated); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "fixSpelling"; + var errorCodes = [ + ts.Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2.code, + ts.Diagnostics.Property_0_may_not_exist_on_type_1_Did_you_mean_2.code, + ts.Diagnostics.Cannot_find_name_0_Did_you_mean_1.code, + ts.Diagnostics.Could_not_find_name_0_Did_you_mean_1.code, + ts.Diagnostics.Cannot_find_namespace_0_Did_you_mean_1.code, + ts.Diagnostics.Cannot_find_name_0_Did_you_mean_the_instance_member_this_0.code, + ts.Diagnostics.Cannot_find_name_0_Did_you_mean_the_static_member_1_0.code, + ts.Diagnostics._0_has_no_exported_member_named_1_Did_you_mean_2.code, + ts.Diagnostics.This_member_cannot_have_an_override_modifier_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1.code, + ts.Diagnostics.This_member_cannot_have_a_JSDoc_comment_with_an_override_tag_because_it_is_not_declared_in_the_base_class_0_Did_you_mean_1.code, + // for JSX class components + ts.Diagnostics.No_overload_matches_this_call.code, + // for JSX FC + ts.Diagnostics.Type_0_is_not_assignable_to_type_1.code, + ]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var sourceFile = context.sourceFile, errorCode = context.errorCode; + var info = getInfo(sourceFile, context.span.start, context, errorCode); + if (!info) + return undefined; + var node = info.node, suggestedSymbol = info.suggestedSymbol; + var target = ts.getEmitScriptTarget(context.host.getCompilationSettings()); + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, sourceFile, node, suggestedSymbol, target); }); + return [codefix.createCodeFixAction("spelling", changes, [ts.Diagnostics.Change_spelling_to_0, ts.symbolName(suggestedSymbol)], fixId, ts.Diagnostics.Fix_all_detected_spelling_errors)]; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var info = getInfo(diag.file, diag.start, context, diag.code); + var target = ts.getEmitScriptTarget(context.host.getCompilationSettings()); + if (info) + doChange(changes, context.sourceFile, info.node, info.suggestedSymbol, target); + }); }, + }); + function getInfo(sourceFile, pos, context, errorCode) { + // This is the identifier of the misspelled word. eg: + // this.speling = 1; + // ^^^^^^^ + var node = ts.getTokenAtPosition(sourceFile, pos); + var parent = node.parent; + // Only fix spelling for No_overload_matches_this_call emitted on the React class component + if ((errorCode === ts.Diagnostics.No_overload_matches_this_call.code || + errorCode === ts.Diagnostics.Type_0_is_not_assignable_to_type_1.code) && + !ts.isJsxAttribute(parent)) + return undefined; + var checker = context.program.getTypeChecker(); + var suggestedSymbol; + if (ts.isPropertyAccessExpression(parent) && parent.name === node) { + ts.Debug.assert(ts.isMemberName(node), "Expected an identifier for spelling (property access)"); + var containingType = checker.getTypeAtLocation(parent.expression); + if (parent.flags & 32 /* NodeFlags.OptionalChain */) { + containingType = checker.getNonNullableType(containingType); + } + suggestedSymbol = checker.getSuggestedSymbolForNonexistentProperty(node, containingType); + } + else if (ts.isBinaryExpression(parent) && parent.operatorToken.kind === 101 /* SyntaxKind.InKeyword */ && parent.left === node && ts.isPrivateIdentifier(node)) { + var receiverType = checker.getTypeAtLocation(parent.right); + suggestedSymbol = checker.getSuggestedSymbolForNonexistentProperty(node, receiverType); + } + else if (ts.isQualifiedName(parent) && parent.right === node) { + var symbol = checker.getSymbolAtLocation(parent.left); + if (symbol && symbol.flags & 1536 /* SymbolFlags.Module */) { + suggestedSymbol = checker.getSuggestedSymbolForNonexistentModule(parent.right, symbol); + } + } + else if (ts.isImportSpecifier(parent) && parent.name === node) { + ts.Debug.assertNode(node, ts.isIdentifier, "Expected an identifier for spelling (import)"); + var importDeclaration = ts.findAncestor(node, ts.isImportDeclaration); + var resolvedSourceFile = getResolvedSourceFileFromImportDeclaration(sourceFile, context, importDeclaration); + if (resolvedSourceFile && resolvedSourceFile.symbol) { + suggestedSymbol = checker.getSuggestedSymbolForNonexistentModule(node, resolvedSourceFile.symbol); + } + } + else if (ts.isJsxAttribute(parent) && parent.name === node) { + ts.Debug.assertNode(node, ts.isIdentifier, "Expected an identifier for JSX attribute"); + var tag = ts.findAncestor(node, ts.isJsxOpeningLikeElement); + var props = checker.getContextualTypeForArgumentAtIndex(tag, 0); + suggestedSymbol = checker.getSuggestedSymbolForNonexistentJSXAttribute(node, props); + } + else if (ts.hasSyntacticModifier(parent, 16384 /* ModifierFlags.Override */) && ts.isClassElement(parent) && parent.name === node) { + var baseDeclaration = ts.findAncestor(node, ts.isClassLike); + var baseTypeNode = baseDeclaration ? ts.getEffectiveBaseTypeNode(baseDeclaration) : undefined; + var baseType = baseTypeNode ? checker.getTypeAtLocation(baseTypeNode) : undefined; + if (baseType) { + suggestedSymbol = checker.getSuggestedSymbolForNonexistentClassMember(ts.getTextOfNode(node), baseType); + } + } + else { + var meaning = ts.getMeaningFromLocation(node); + var name = ts.getTextOfNode(node); + ts.Debug.assert(name !== undefined, "name should be defined"); + suggestedSymbol = checker.getSuggestedSymbolForNonexistentSymbol(node, name, convertSemanticMeaningToSymbolFlags(meaning)); + } + return suggestedSymbol === undefined ? undefined : { node: node, suggestedSymbol: suggestedSymbol }; + } + function doChange(changes, sourceFile, node, suggestedSymbol, target) { + var suggestion = ts.symbolName(suggestedSymbol); + if (!ts.isIdentifierText(suggestion, target) && ts.isPropertyAccessExpression(node.parent)) { + var valDecl = suggestedSymbol.valueDeclaration; + if (valDecl && ts.isNamedDeclaration(valDecl) && ts.isPrivateIdentifier(valDecl.name)) { + changes.replaceNode(sourceFile, node, ts.factory.createIdentifier(suggestion)); + } + else { + changes.replaceNode(sourceFile, node.parent, ts.factory.createElementAccessExpression(node.parent.expression, ts.factory.createStringLiteral(suggestion))); + } + } + else { + changes.replaceNode(sourceFile, node, ts.factory.createIdentifier(suggestion)); + } + } + function convertSemanticMeaningToSymbolFlags(meaning) { + var flags = 0; + if (meaning & 4 /* SemanticMeaning.Namespace */) { + flags |= 1920 /* SymbolFlags.Namespace */; + } + if (meaning & 2 /* SemanticMeaning.Type */) { + flags |= 788968 /* SymbolFlags.Type */; + } + if (meaning & 1 /* SemanticMeaning.Value */) { + flags |= 111551 /* SymbolFlags.Value */; + } + return flags; + } + function getResolvedSourceFileFromImportDeclaration(sourceFile, context, importDeclaration) { + if (!importDeclaration || !ts.isStringLiteralLike(importDeclaration.moduleSpecifier)) + return undefined; + var resolvedModule = ts.getResolvedModule(sourceFile, importDeclaration.moduleSpecifier.text, ts.getModeForUsageLocation(sourceFile, importDeclaration.moduleSpecifier)); + if (!resolvedModule) + return undefined; + return context.program.getSourceFile(resolvedModule.resolvedFileName); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "returnValueCorrect"; + var fixIdAddReturnStatement = "fixAddReturnStatement"; + var fixRemoveBracesFromArrowFunctionBody = "fixRemoveBracesFromArrowFunctionBody"; + var fixIdWrapTheBlockWithParen = "fixWrapTheBlockWithParen"; + var errorCodes = [ + ts.Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value.code, + ts.Diagnostics.Type_0_is_not_assignable_to_type_1.code, + ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code + ]; + var ProblemKind; + (function (ProblemKind) { + ProblemKind[ProblemKind["MissingReturnStatement"] = 0] = "MissingReturnStatement"; + ProblemKind[ProblemKind["MissingParentheses"] = 1] = "MissingParentheses"; + })(ProblemKind || (ProblemKind = {})); + codefix.registerCodeFix({ + errorCodes: errorCodes, + fixIds: [fixIdAddReturnStatement, fixRemoveBracesFromArrowFunctionBody, fixIdWrapTheBlockWithParen], + getCodeActions: function getCodeActionsToCorrectReturnValue(context) { + var program = context.program, sourceFile = context.sourceFile, start = context.span.start, errorCode = context.errorCode; + var info = getInfo(program.getTypeChecker(), sourceFile, start, errorCode); + if (!info) + return undefined; + if (info.kind === ProblemKind.MissingReturnStatement) { + return ts.append([getActionForfixAddReturnStatement(context, info.expression, info.statement)], ts.isArrowFunction(info.declaration) ? getActionForFixRemoveBracesFromArrowFunctionBody(context, info.declaration, info.expression, info.commentSource) : undefined); + } + else { + return [getActionForfixWrapTheBlockWithParen(context, info.declaration, info.expression)]; + } + }, + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var info = getInfo(context.program.getTypeChecker(), diag.file, diag.start, diag.code); + if (!info) + return undefined; + switch (context.fixId) { + case fixIdAddReturnStatement: + addReturnStatement(changes, diag.file, info.expression, info.statement); + break; + case fixRemoveBracesFromArrowFunctionBody: + if (!ts.isArrowFunction(info.declaration)) + return undefined; + removeBlockBodyBrace(changes, diag.file, info.declaration, info.expression, info.commentSource, /* withParen */ false); + break; + case fixIdWrapTheBlockWithParen: + if (!ts.isArrowFunction(info.declaration)) + return undefined; + wrapBlockWithParen(changes, diag.file, info.declaration, info.expression); + break; + default: + ts.Debug.fail(JSON.stringify(context.fixId)); + } + }); }, + }); + function createObjectTypeFromLabeledExpression(checker, label, expression) { + var member = checker.createSymbol(4 /* SymbolFlags.Property */, label.escapedText); + member.type = checker.getTypeAtLocation(expression); + var members = ts.createSymbolTable([member]); + return checker.createAnonymousType(/*symbol*/ undefined, members, [], [], []); + } + function getFixInfo(checker, declaration, expectType, isFunctionType) { + if (!declaration.body || !ts.isBlock(declaration.body) || ts.length(declaration.body.statements) !== 1) + return undefined; + var firstStatement = ts.first(declaration.body.statements); + if (ts.isExpressionStatement(firstStatement) && checkFixedAssignableTo(checker, declaration, checker.getTypeAtLocation(firstStatement.expression), expectType, isFunctionType)) { + return { + declaration: declaration, + kind: ProblemKind.MissingReturnStatement, + expression: firstStatement.expression, + statement: firstStatement, + commentSource: firstStatement.expression + }; + } + else if (ts.isLabeledStatement(firstStatement) && ts.isExpressionStatement(firstStatement.statement)) { + var node = ts.factory.createObjectLiteralExpression([ts.factory.createPropertyAssignment(firstStatement.label, firstStatement.statement.expression)]); + var nodeType = createObjectTypeFromLabeledExpression(checker, firstStatement.label, firstStatement.statement.expression); + if (checkFixedAssignableTo(checker, declaration, nodeType, expectType, isFunctionType)) { + return ts.isArrowFunction(declaration) ? { + declaration: declaration, + kind: ProblemKind.MissingParentheses, + expression: node, + statement: firstStatement, + commentSource: firstStatement.statement.expression + } : { + declaration: declaration, + kind: ProblemKind.MissingReturnStatement, + expression: node, + statement: firstStatement, + commentSource: firstStatement.statement.expression + }; + } + } + else if (ts.isBlock(firstStatement) && ts.length(firstStatement.statements) === 1) { + var firstBlockStatement = ts.first(firstStatement.statements); + if (ts.isLabeledStatement(firstBlockStatement) && ts.isExpressionStatement(firstBlockStatement.statement)) { + var node = ts.factory.createObjectLiteralExpression([ts.factory.createPropertyAssignment(firstBlockStatement.label, firstBlockStatement.statement.expression)]); + var nodeType = createObjectTypeFromLabeledExpression(checker, firstBlockStatement.label, firstBlockStatement.statement.expression); + if (checkFixedAssignableTo(checker, declaration, nodeType, expectType, isFunctionType)) { + return { + declaration: declaration, + kind: ProblemKind.MissingReturnStatement, + expression: node, + statement: firstStatement, + commentSource: firstBlockStatement + }; + } + } + } + return undefined; + } + function checkFixedAssignableTo(checker, declaration, exprType, type, isFunctionType) { + if (isFunctionType) { + var sig = checker.getSignatureFromDeclaration(declaration); + if (sig) { + if (ts.hasSyntacticModifier(declaration, 512 /* ModifierFlags.Async */)) { + exprType = checker.createPromiseType(exprType); + } + var newSig = checker.createSignature(declaration, sig.typeParameters, sig.thisParameter, sig.parameters, exprType, + /*typePredicate*/ undefined, sig.minArgumentCount, sig.flags); + exprType = checker.createAnonymousType( + /*symbol*/ undefined, ts.createSymbolTable(), [newSig], [], []); + } + else { + exprType = checker.getAnyType(); + } + } + return checker.isTypeAssignableTo(exprType, type); + } + function getInfo(checker, sourceFile, position, errorCode) { + var node = ts.getTokenAtPosition(sourceFile, position); + if (!node.parent) + return undefined; + var declaration = ts.findAncestor(node.parent, ts.isFunctionLikeDeclaration); + switch (errorCode) { + case ts.Diagnostics.A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value.code: + if (!declaration || !declaration.body || !declaration.type || !ts.rangeContainsRange(declaration.type, node)) + return undefined; + return getFixInfo(checker, declaration, checker.getTypeFromTypeNode(declaration.type), /* isFunctionType */ false); + case ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code: + if (!declaration || !ts.isCallExpression(declaration.parent) || !declaration.body) + return undefined; + var pos = declaration.parent.arguments.indexOf(declaration); + var type = checker.getContextualTypeForArgumentAtIndex(declaration.parent, pos); + if (!type) + return undefined; + return getFixInfo(checker, declaration, type, /* isFunctionType */ true); + case ts.Diagnostics.Type_0_is_not_assignable_to_type_1.code: + if (!ts.isDeclarationName(node) || !ts.isVariableLike(node.parent) && !ts.isJsxAttribute(node.parent)) + return undefined; + var initializer = getVariableLikeInitializer(node.parent); + if (!initializer || !ts.isFunctionLikeDeclaration(initializer) || !initializer.body) + return undefined; + return getFixInfo(checker, initializer, checker.getTypeAtLocation(node.parent), /* isFunctionType */ true); + } + return undefined; + } + function getVariableLikeInitializer(declaration) { + switch (declaration.kind) { + case 257 /* SyntaxKind.VariableDeclaration */: + case 166 /* SyntaxKind.Parameter */: + case 205 /* SyntaxKind.BindingElement */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 299 /* SyntaxKind.PropertyAssignment */: + return declaration.initializer; + case 288 /* SyntaxKind.JsxAttribute */: + return declaration.initializer && (ts.isJsxExpression(declaration.initializer) ? declaration.initializer.expression : undefined); + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + case 168 /* SyntaxKind.PropertySignature */: + case 302 /* SyntaxKind.EnumMember */: + case 350 /* SyntaxKind.JSDocPropertyTag */: + case 343 /* SyntaxKind.JSDocParameterTag */: + return undefined; + } + } + function addReturnStatement(changes, sourceFile, expression, statement) { + ts.suppressLeadingAndTrailingTrivia(expression); + var probablyNeedSemi = ts.probablyUsesSemicolons(sourceFile); + changes.replaceNode(sourceFile, statement, ts.factory.createReturnStatement(expression), { + leadingTriviaOption: ts.textChanges.LeadingTriviaOption.Exclude, + trailingTriviaOption: ts.textChanges.TrailingTriviaOption.Exclude, + suffix: probablyNeedSemi ? ";" : undefined + }); + } + function removeBlockBodyBrace(changes, sourceFile, declaration, expression, commentSource, withParen) { + var newBody = (withParen || ts.needsParentheses(expression)) ? ts.factory.createParenthesizedExpression(expression) : expression; + ts.suppressLeadingAndTrailingTrivia(commentSource); + ts.copyComments(commentSource, newBody); + changes.replaceNode(sourceFile, declaration.body, newBody); + } + function wrapBlockWithParen(changes, sourceFile, declaration, expression) { + changes.replaceNode(sourceFile, declaration.body, ts.factory.createParenthesizedExpression(expression)); + } + function getActionForfixAddReturnStatement(context, expression, statement) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addReturnStatement(t, context.sourceFile, expression, statement); }); + return codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Add_a_return_statement, fixIdAddReturnStatement, ts.Diagnostics.Add_all_missing_return_statement); + } + function getActionForFixRemoveBracesFromArrowFunctionBody(context, declaration, expression, commentSource) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return removeBlockBodyBrace(t, context.sourceFile, declaration, expression, commentSource, /* withParen */ false); }); + return codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Remove_braces_from_arrow_function_body, fixRemoveBracesFromArrowFunctionBody, ts.Diagnostics.Remove_braces_from_all_arrow_function_bodies_with_relevant_issues); + } + function getActionForfixWrapTheBlockWithParen(context, declaration, expression) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return wrapBlockWithParen(t, context.sourceFile, declaration, expression); }); + return codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Wrap_the_following_body_with_parentheses_which_should_be_an_object_literal, fixIdWrapTheBlockWithParen, ts.Diagnostics.Wrap_all_object_literal_with_parentheses); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixMissingMember = "fixMissingMember"; + var fixMissingProperties = "fixMissingProperties"; + var fixMissingAttributes = "fixMissingAttributes"; + var fixMissingFunctionDeclaration = "fixMissingFunctionDeclaration"; + var errorCodes = [ + ts.Diagnostics.Property_0_does_not_exist_on_type_1.code, + ts.Diagnostics.Property_0_does_not_exist_on_type_1_Did_you_mean_2.code, + ts.Diagnostics.Property_0_is_missing_in_type_1_but_required_in_type_2.code, + ts.Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2.code, + ts.Diagnostics.Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more.code, + ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code, + ts.Diagnostics.Cannot_find_name_0.code + ]; + var InfoKind; + (function (InfoKind) { + InfoKind[InfoKind["TypeLikeDeclaration"] = 0] = "TypeLikeDeclaration"; + InfoKind[InfoKind["Enum"] = 1] = "Enum"; + InfoKind[InfoKind["Function"] = 2] = "Function"; + InfoKind[InfoKind["ObjectLiteral"] = 3] = "ObjectLiteral"; + InfoKind[InfoKind["JsxAttributes"] = 4] = "JsxAttributes"; + InfoKind[InfoKind["Signature"] = 5] = "Signature"; + })(InfoKind || (InfoKind = {})); + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var typeChecker = context.program.getTypeChecker(); + var info = getInfo(context.sourceFile, context.span.start, context.errorCode, typeChecker, context.program); + if (!info) { + return undefined; + } + if (info.kind === InfoKind.ObjectLiteral) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addObjectLiteralProperties(t, context, info); }); + return [codefix.createCodeFixAction(fixMissingProperties, changes, ts.Diagnostics.Add_missing_properties, fixMissingProperties, ts.Diagnostics.Add_all_missing_properties)]; + } + if (info.kind === InfoKind.JsxAttributes) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addJsxAttributes(t, context, info); }); + return [codefix.createCodeFixAction(fixMissingAttributes, changes, ts.Diagnostics.Add_missing_attributes, fixMissingAttributes, ts.Diagnostics.Add_all_missing_attributes)]; + } + if (info.kind === InfoKind.Function || info.kind === InfoKind.Signature) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addFunctionDeclaration(t, context, info); }); + return [codefix.createCodeFixAction(fixMissingFunctionDeclaration, changes, [ts.Diagnostics.Add_missing_function_declaration_0, info.token.text], fixMissingFunctionDeclaration, ts.Diagnostics.Add_all_missing_function_declarations)]; + } + if (info.kind === InfoKind.Enum) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addEnumMemberDeclaration(t, context.program.getTypeChecker(), info); }); + return [codefix.createCodeFixAction(fixMissingMember, changes, [ts.Diagnostics.Add_missing_enum_member_0, info.token.text], fixMissingMember, ts.Diagnostics.Add_all_missing_members)]; + } + return ts.concatenate(getActionsForMissingMethodDeclaration(context, info), getActionsForMissingMemberDeclaration(context, info)); + }, + fixIds: [fixMissingMember, fixMissingFunctionDeclaration, fixMissingProperties, fixMissingAttributes], + getAllCodeActions: function (context) { + var program = context.program, fixId = context.fixId; + var checker = program.getTypeChecker(); + var seen = new ts.Map(); + var typeDeclToMembers = new ts.Map(); + return codefix.createCombinedCodeActions(ts.textChanges.ChangeTracker.with(context, function (changes) { + codefix.eachDiagnostic(context, errorCodes, function (diag) { + var info = getInfo(diag.file, diag.start, diag.code, checker, context.program); + if (!info || !ts.addToSeen(seen, ts.getNodeId(info.parentDeclaration) + "#" + info.token.text)) { + return; + } + if (fixId === fixMissingFunctionDeclaration && (info.kind === InfoKind.Function || info.kind === InfoKind.Signature)) { + addFunctionDeclaration(changes, context, info); + } + else if (fixId === fixMissingProperties && info.kind === InfoKind.ObjectLiteral) { + addObjectLiteralProperties(changes, context, info); + } + else if (fixId === fixMissingAttributes && info.kind === InfoKind.JsxAttributes) { + addJsxAttributes(changes, context, info); + } + else { + if (info.kind === InfoKind.Enum) { + addEnumMemberDeclaration(changes, checker, info); + } + if (info.kind === InfoKind.TypeLikeDeclaration) { + var parentDeclaration = info.parentDeclaration, token_1 = info.token; + var infos = ts.getOrUpdate(typeDeclToMembers, parentDeclaration, function () { return []; }); + if (!infos.some(function (i) { return i.token.text === token_1.text; })) { + infos.push(info); + } + } + } + }); + typeDeclToMembers.forEach(function (infos, declaration) { + var supers = ts.isTypeLiteralNode(declaration) ? undefined : codefix.getAllSupers(declaration, checker); + var _loop_13 = function (info) { + // If some superclass added this property, don't add it again. + if (supers === null || supers === void 0 ? void 0 : supers.some(function (superClassOrInterface) { + var superInfos = typeDeclToMembers.get(superClassOrInterface); + return !!superInfos && superInfos.some(function (_a) { + var token = _a.token; + return token.text === info.token.text; + }); + })) + return "continue"; + var parentDeclaration = info.parentDeclaration, declSourceFile = info.declSourceFile, modifierFlags = info.modifierFlags, token = info.token, call = info.call, isJSFile = info.isJSFile; + // Always prefer to add a method declaration if possible. + if (call && !ts.isPrivateIdentifier(token)) { + addMethodDeclaration(context, changes, call, token, modifierFlags & 32 /* ModifierFlags.Static */, parentDeclaration, declSourceFile); + } + else { + if (isJSFile && !ts.isInterfaceDeclaration(parentDeclaration) && !ts.isTypeLiteralNode(parentDeclaration)) { + addMissingMemberInJs(changes, declSourceFile, parentDeclaration, token, !!(modifierFlags & 32 /* ModifierFlags.Static */)); + } + else { + var typeNode = getTypeNode(checker, parentDeclaration, token); + addPropertyDeclaration(changes, declSourceFile, parentDeclaration, token.text, typeNode, modifierFlags & 32 /* ModifierFlags.Static */); + } + } + }; + for (var _i = 0, infos_1 = infos; _i < infos_1.length; _i++) { + var info = infos_1[_i]; + _loop_13(info); + } + }); + })); + }, + }); + function getInfo(sourceFile, tokenPos, errorCode, checker, program) { + // The identifier of the missing property. eg: + // this.missing = 1; + // ^^^^^^^ + var token = ts.getTokenAtPosition(sourceFile, tokenPos); + var parent = token.parent; + if (errorCode === ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code) { + if (!(token.kind === 18 /* SyntaxKind.OpenBraceToken */ && ts.isObjectLiteralExpression(parent) && ts.isCallExpression(parent.parent))) + return undefined; + var argIndex = ts.findIndex(parent.parent.arguments, function (arg) { return arg === parent; }); + if (argIndex < 0) + return undefined; + var signature = checker.getResolvedSignature(parent.parent); + if (!(signature && signature.declaration && signature.parameters[argIndex])) + return undefined; + var param = signature.parameters[argIndex].valueDeclaration; + if (!(param && ts.isParameter(param) && ts.isIdentifier(param.name))) + return undefined; + var properties = ts.arrayFrom(checker.getUnmatchedProperties(checker.getTypeAtLocation(parent), checker.getParameterType(signature, argIndex), /* requireOptionalProperties */ false, /* matchDiscriminantProperties */ false)); + if (!ts.length(properties)) + return undefined; + return { kind: InfoKind.ObjectLiteral, token: param.name, properties: properties, parentDeclaration: parent }; + } + if (!ts.isMemberName(token)) + return undefined; + if (ts.isIdentifier(token) && ts.hasInitializer(parent) && parent.initializer && ts.isObjectLiteralExpression(parent.initializer)) { + var properties = ts.arrayFrom(checker.getUnmatchedProperties(checker.getTypeAtLocation(parent.initializer), checker.getTypeAtLocation(token), /* requireOptionalProperties */ false, /* matchDiscriminantProperties */ false)); + if (!ts.length(properties)) + return undefined; + return { kind: InfoKind.ObjectLiteral, token: token, properties: properties, parentDeclaration: parent.initializer }; + } + if (ts.isIdentifier(token) && ts.isJsxOpeningLikeElement(token.parent)) { + var target = ts.getEmitScriptTarget(program.getCompilerOptions()); + var attributes = getUnmatchedAttributes(checker, target, token.parent); + if (!ts.length(attributes)) + return undefined; + return { kind: InfoKind.JsxAttributes, token: token, attributes: attributes, parentDeclaration: token.parent }; + } + if (ts.isIdentifier(token)) { + var type = checker.getContextualType(token); + if (type && ts.getObjectFlags(type) & 16 /* ObjectFlags.Anonymous */) { + var signature = ts.firstOrUndefined(checker.getSignaturesOfType(type, 0 /* SignatureKind.Call */)); + if (signature === undefined) + return undefined; + return { kind: InfoKind.Signature, token: token, signature: signature, sourceFile: sourceFile, parentDeclaration: findScope(token) }; + } + if (ts.isCallExpression(parent) && parent.expression === token) { + return { kind: InfoKind.Function, token: token, call: parent, sourceFile: sourceFile, modifierFlags: 0 /* ModifierFlags.None */, parentDeclaration: findScope(token) }; + } + } + if (!ts.isPropertyAccessExpression(parent)) + return undefined; + var leftExpressionType = ts.skipConstraint(checker.getTypeAtLocation(parent.expression)); + var symbol = leftExpressionType.symbol; + if (!symbol || !symbol.declarations) + return undefined; + if (ts.isIdentifier(token) && ts.isCallExpression(parent.parent)) { + var moduleDeclaration = ts.find(symbol.declarations, ts.isModuleDeclaration); + var moduleDeclarationSourceFile = moduleDeclaration === null || moduleDeclaration === void 0 ? void 0 : moduleDeclaration.getSourceFile(); + if (moduleDeclaration && moduleDeclarationSourceFile && !ts.isSourceFileFromLibrary(program, moduleDeclarationSourceFile)) { + return { kind: InfoKind.Function, token: token, call: parent.parent, sourceFile: sourceFile, modifierFlags: 1 /* ModifierFlags.Export */, parentDeclaration: moduleDeclaration }; + } + var moduleSourceFile = ts.find(symbol.declarations, ts.isSourceFile); + if (sourceFile.commonJsModuleIndicator) + return undefined; + if (moduleSourceFile && !ts.isSourceFileFromLibrary(program, moduleSourceFile)) { + return { kind: InfoKind.Function, token: token, call: parent.parent, sourceFile: moduleSourceFile, modifierFlags: 1 /* ModifierFlags.Export */, parentDeclaration: moduleSourceFile }; + } + } + var classDeclaration = ts.find(symbol.declarations, ts.isClassLike); + // Don't suggest adding private identifiers to anything other than a class. + if (!classDeclaration && ts.isPrivateIdentifier(token)) + return undefined; + // Prefer to change the class instead of the interface if they are merged + var declaration = classDeclaration || ts.find(symbol.declarations, function (d) { return ts.isInterfaceDeclaration(d) || ts.isTypeLiteralNode(d); }); + if (declaration && !ts.isSourceFileFromLibrary(program, declaration.getSourceFile())) { + var makeStatic = !ts.isTypeLiteralNode(declaration) && (leftExpressionType.target || leftExpressionType) !== checker.getDeclaredTypeOfSymbol(symbol); + if (makeStatic && (ts.isPrivateIdentifier(token) || ts.isInterfaceDeclaration(declaration))) + return undefined; + var declSourceFile = declaration.getSourceFile(); + var modifierFlags = ts.isTypeLiteralNode(declaration) ? 0 /* ModifierFlags.None */ : + (makeStatic ? 32 /* ModifierFlags.Static */ : 0 /* ModifierFlags.None */) | (ts.startsWithUnderscore(token.text) ? 8 /* ModifierFlags.Private */ : 0 /* ModifierFlags.None */); + var isJSFile = ts.isSourceFileJS(declSourceFile); + var call = ts.tryCast(parent.parent, ts.isCallExpression); + return { kind: InfoKind.TypeLikeDeclaration, token: token, call: call, modifierFlags: modifierFlags, parentDeclaration: declaration, declSourceFile: declSourceFile, isJSFile: isJSFile }; + } + var enumDeclaration = ts.find(symbol.declarations, ts.isEnumDeclaration); + if (enumDeclaration && !(leftExpressionType.flags & 1056 /* TypeFlags.EnumLike */) && !ts.isPrivateIdentifier(token) && !ts.isSourceFileFromLibrary(program, enumDeclaration.getSourceFile())) { + return { kind: InfoKind.Enum, token: token, parentDeclaration: enumDeclaration }; + } + return undefined; + } + function getActionsForMissingMemberDeclaration(context, info) { + return info.isJSFile ? ts.singleElementArray(createActionForAddMissingMemberInJavascriptFile(context, info)) : + createActionsForAddMissingMemberInTypeScriptFile(context, info); + } + function createActionForAddMissingMemberInJavascriptFile(context, _a) { + var parentDeclaration = _a.parentDeclaration, declSourceFile = _a.declSourceFile, modifierFlags = _a.modifierFlags, token = _a.token; + if (ts.isInterfaceDeclaration(parentDeclaration) || ts.isTypeLiteralNode(parentDeclaration)) { + return undefined; + } + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addMissingMemberInJs(t, declSourceFile, parentDeclaration, token, !!(modifierFlags & 32 /* ModifierFlags.Static */)); }); + if (changes.length === 0) { + return undefined; + } + var diagnostic = modifierFlags & 32 /* ModifierFlags.Static */ ? ts.Diagnostics.Initialize_static_property_0 : + ts.isPrivateIdentifier(token) ? ts.Diagnostics.Declare_a_private_field_named_0 : ts.Diagnostics.Initialize_property_0_in_the_constructor; + return codefix.createCodeFixAction(fixMissingMember, changes, [diagnostic, token.text], fixMissingMember, ts.Diagnostics.Add_all_missing_members); + } + function addMissingMemberInJs(changeTracker, sourceFile, classDeclaration, token, makeStatic) { + var tokenName = token.text; + if (makeStatic) { + if (classDeclaration.kind === 228 /* SyntaxKind.ClassExpression */) { + return; + } + var className = classDeclaration.name.getText(); + var staticInitialization = initializePropertyToUndefined(ts.factory.createIdentifier(className), tokenName); + changeTracker.insertNodeAfter(sourceFile, classDeclaration, staticInitialization); + } + else if (ts.isPrivateIdentifier(token)) { + var property = ts.factory.createPropertyDeclaration( + /*modifiers*/ undefined, tokenName, + /*questionToken*/ undefined, + /*type*/ undefined, + /*initializer*/ undefined); + var lastProp = getNodeToInsertPropertyAfter(classDeclaration); + if (lastProp) { + changeTracker.insertNodeAfter(sourceFile, lastProp, property); + } + else { + changeTracker.insertMemberAtStart(sourceFile, classDeclaration, property); + } + } + else { + var classConstructor = ts.getFirstConstructorWithBody(classDeclaration); + if (!classConstructor) { + return; + } + var propertyInitialization = initializePropertyToUndefined(ts.factory.createThis(), tokenName); + changeTracker.insertNodeAtConstructorEnd(sourceFile, classConstructor, propertyInitialization); + } + } + function initializePropertyToUndefined(obj, propertyName) { + return ts.factory.createExpressionStatement(ts.factory.createAssignment(ts.factory.createPropertyAccessExpression(obj, propertyName), createUndefined())); + } + function createActionsForAddMissingMemberInTypeScriptFile(context, _a) { + var parentDeclaration = _a.parentDeclaration, declSourceFile = _a.declSourceFile, modifierFlags = _a.modifierFlags, token = _a.token; + var memberName = token.text; + var isStatic = modifierFlags & 32 /* ModifierFlags.Static */; + var typeNode = getTypeNode(context.program.getTypeChecker(), parentDeclaration, token); + var addPropertyDeclarationChanges = function (modifierFlags) { return ts.textChanges.ChangeTracker.with(context, function (t) { return addPropertyDeclaration(t, declSourceFile, parentDeclaration, memberName, typeNode, modifierFlags); }); }; + var actions = [codefix.createCodeFixAction(fixMissingMember, addPropertyDeclarationChanges(modifierFlags & 32 /* ModifierFlags.Static */), [isStatic ? ts.Diagnostics.Declare_static_property_0 : ts.Diagnostics.Declare_property_0, memberName], fixMissingMember, ts.Diagnostics.Add_all_missing_members)]; + if (isStatic || ts.isPrivateIdentifier(token)) { + return actions; + } + if (modifierFlags & 8 /* ModifierFlags.Private */) { + actions.unshift(codefix.createCodeFixActionWithoutFixAll(fixMissingMember, addPropertyDeclarationChanges(8 /* ModifierFlags.Private */), [ts.Diagnostics.Declare_private_property_0, memberName])); + } + actions.push(createAddIndexSignatureAction(context, declSourceFile, parentDeclaration, token.text, typeNode)); + return actions; + } + function getTypeNode(checker, node, token) { + var typeNode; + if (token.parent.parent.kind === 223 /* SyntaxKind.BinaryExpression */) { + var binaryExpression = token.parent.parent; + var otherExpression = token.parent === binaryExpression.left ? binaryExpression.right : binaryExpression.left; + var widenedType = checker.getWidenedType(checker.getBaseTypeOfLiteralType(checker.getTypeAtLocation(otherExpression))); + typeNode = checker.typeToTypeNode(widenedType, node, 1 /* NodeBuilderFlags.NoTruncation */); + } + else { + var contextualType = checker.getContextualType(token.parent); + typeNode = contextualType ? checker.typeToTypeNode(contextualType, /*enclosingDeclaration*/ undefined, 1 /* NodeBuilderFlags.NoTruncation */) : undefined; + } + return typeNode || ts.factory.createKeywordTypeNode(131 /* SyntaxKind.AnyKeyword */); + } + function addPropertyDeclaration(changeTracker, sourceFile, node, tokenName, typeNode, modifierFlags) { + var modifiers = modifierFlags ? ts.factory.createNodeArray(ts.factory.createModifiersFromModifierFlags(modifierFlags)) : undefined; + var property = ts.isClassLike(node) + ? ts.factory.createPropertyDeclaration(modifiers, tokenName, /*questionToken*/ undefined, typeNode, /*initializer*/ undefined) + : ts.factory.createPropertySignature(/*modifiers*/ undefined, tokenName, /*questionToken*/ undefined, typeNode); + var lastProp = getNodeToInsertPropertyAfter(node); + if (lastProp) { + changeTracker.insertNodeAfter(sourceFile, lastProp, property); + } + else { + changeTracker.insertMemberAtStart(sourceFile, node, property); + } + } + // Gets the last of the first run of PropertyDeclarations, or undefined if the class does not start with a PropertyDeclaration. + function getNodeToInsertPropertyAfter(node) { + var res; + for (var _i = 0, _a = node.members; _i < _a.length; _i++) { + var member = _a[_i]; + if (!ts.isPropertyDeclaration(member)) + break; + res = member; + } + return res; + } + function createAddIndexSignatureAction(context, sourceFile, node, tokenName, typeNode) { + // Index signatures cannot have the static modifier. + var stringTypeNode = ts.factory.createKeywordTypeNode(152 /* SyntaxKind.StringKeyword */); + var indexingParameter = ts.factory.createParameterDeclaration( + /*modifiers*/ undefined, + /*dotDotDotToken*/ undefined, "x", + /*questionToken*/ undefined, stringTypeNode, + /*initializer*/ undefined); + var indexSignature = ts.factory.createIndexSignature( + /*modifiers*/ undefined, [indexingParameter], typeNode); + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return t.insertMemberAtStart(sourceFile, node, indexSignature); }); + // No fixId here because code-fix-all currently only works on adding individual named properties. + return codefix.createCodeFixActionWithoutFixAll(fixMissingMember, changes, [ts.Diagnostics.Add_index_signature_for_property_0, tokenName]); + } + function getActionsForMissingMethodDeclaration(context, info) { + var parentDeclaration = info.parentDeclaration, declSourceFile = info.declSourceFile, modifierFlags = info.modifierFlags, token = info.token, call = info.call; + if (call === undefined) { + return undefined; + } + // Private methods are not implemented yet. + if (ts.isPrivateIdentifier(token)) { + return undefined; + } + var methodName = token.text; + var addMethodDeclarationChanges = function (modifierFlags) { return ts.textChanges.ChangeTracker.with(context, function (t) { return addMethodDeclaration(context, t, call, token, modifierFlags, parentDeclaration, declSourceFile); }); }; + var actions = [codefix.createCodeFixAction(fixMissingMember, addMethodDeclarationChanges(modifierFlags & 32 /* ModifierFlags.Static */), [modifierFlags & 32 /* ModifierFlags.Static */ ? ts.Diagnostics.Declare_static_method_0 : ts.Diagnostics.Declare_method_0, methodName], fixMissingMember, ts.Diagnostics.Add_all_missing_members)]; + if (modifierFlags & 8 /* ModifierFlags.Private */) { + actions.unshift(codefix.createCodeFixActionWithoutFixAll(fixMissingMember, addMethodDeclarationChanges(8 /* ModifierFlags.Private */), [ts.Diagnostics.Declare_private_method_0, methodName])); + } + return actions; + } + function addMethodDeclaration(context, changes, callExpression, name, modifierFlags, parentDeclaration, sourceFile) { + var importAdder = codefix.createImportAdder(sourceFile, context.program, context.preferences, context.host); + var kind = ts.isClassLike(parentDeclaration) ? 171 /* SyntaxKind.MethodDeclaration */ : 170 /* SyntaxKind.MethodSignature */; + var signatureDeclaration = codefix.createSignatureDeclarationFromCallExpression(kind, context, importAdder, callExpression, name, modifierFlags, parentDeclaration); + var containingMethodDeclaration = tryGetContainingMethodDeclaration(parentDeclaration, callExpression); + if (containingMethodDeclaration) { + changes.insertNodeAfter(sourceFile, containingMethodDeclaration, signatureDeclaration); + } + else { + changes.insertMemberAtStart(sourceFile, parentDeclaration, signatureDeclaration); + } + importAdder.writeFixes(changes); + } + function addEnumMemberDeclaration(changes, checker, _a) { + var token = _a.token, parentDeclaration = _a.parentDeclaration; + /** + * create initializer only literal enum that has string initializer. + * value of initializer is a string literal that equal to name of enum member. + * numeric enum or empty enum will not create initializer. + */ + var hasStringInitializer = ts.some(parentDeclaration.members, function (member) { + var type = checker.getTypeAtLocation(member); + return !!(type && type.flags & 402653316 /* TypeFlags.StringLike */); + }); + var enumMember = ts.factory.createEnumMember(token, hasStringInitializer ? ts.factory.createStringLiteral(token.text) : undefined); + changes.replaceNode(parentDeclaration.getSourceFile(), parentDeclaration, ts.factory.updateEnumDeclaration(parentDeclaration, parentDeclaration.modifiers, parentDeclaration.name, ts.concatenate(parentDeclaration.members, ts.singleElementArray(enumMember))), { + leadingTriviaOption: ts.textChanges.LeadingTriviaOption.IncludeAll, + trailingTriviaOption: ts.textChanges.TrailingTriviaOption.Exclude + }); + } + function addFunctionDeclaration(changes, context, info) { + var quotePreference = ts.getQuotePreference(context.sourceFile, context.preferences); + var importAdder = codefix.createImportAdder(context.sourceFile, context.program, context.preferences, context.host); + var functionDeclaration = info.kind === InfoKind.Function + ? codefix.createSignatureDeclarationFromCallExpression(259 /* SyntaxKind.FunctionDeclaration */, context, importAdder, info.call, ts.idText(info.token), info.modifierFlags, info.parentDeclaration) + : codefix.createSignatureDeclarationFromSignature(259 /* SyntaxKind.FunctionDeclaration */, context, quotePreference, info.signature, codefix.createStubbedBody(ts.Diagnostics.Function_not_implemented.message, quotePreference), info.token, /*modifiers*/ undefined, /*optional*/ undefined, /*enclosingDeclaration*/ undefined, importAdder); + if (functionDeclaration === undefined) { + ts.Debug.fail("fixMissingFunctionDeclaration codefix got unexpected error."); + } + ts.isReturnStatement(info.parentDeclaration) + ? changes.insertNodeBefore(info.sourceFile, info.parentDeclaration, functionDeclaration, /*blankLineBetween*/ true) + : changes.insertNodeAtEndOfScope(info.sourceFile, info.parentDeclaration, functionDeclaration); + importAdder.writeFixes(changes); + } + function addJsxAttributes(changes, context, info) { + var importAdder = codefix.createImportAdder(context.sourceFile, context.program, context.preferences, context.host); + var quotePreference = ts.getQuotePreference(context.sourceFile, context.preferences); + var checker = context.program.getTypeChecker(); + var jsxAttributesNode = info.parentDeclaration.attributes; + var hasSpreadAttribute = ts.some(jsxAttributesNode.properties, ts.isJsxSpreadAttribute); + var attrs = ts.map(info.attributes, function (attr) { + var value = tryGetValueFromType(context, checker, importAdder, quotePreference, checker.getTypeOfSymbol(attr), info.parentDeclaration); + var name = ts.factory.createIdentifier(attr.name); + var jsxAttribute = ts.factory.createJsxAttribute(name, ts.factory.createJsxExpression(/*dotDotDotToken*/ undefined, value)); + // formattingScanner requires the Identifier to have a context for scanning attributes with "-" (data-foo). + ts.setParent(name, jsxAttribute); + return jsxAttribute; + }); + var jsxAttributes = ts.factory.createJsxAttributes(hasSpreadAttribute ? __spreadArray(__spreadArray([], attrs, true), jsxAttributesNode.properties, true) : __spreadArray(__spreadArray([], jsxAttributesNode.properties, true), attrs, true)); + var options = { prefix: jsxAttributesNode.pos === jsxAttributesNode.end ? " " : undefined }; + changes.replaceNode(context.sourceFile, jsxAttributesNode, jsxAttributes, options); + importAdder.writeFixes(changes); + } + function addObjectLiteralProperties(changes, context, info) { + var importAdder = codefix.createImportAdder(context.sourceFile, context.program, context.preferences, context.host); + var quotePreference = ts.getQuotePreference(context.sourceFile, context.preferences); + var target = ts.getEmitScriptTarget(context.program.getCompilerOptions()); + var checker = context.program.getTypeChecker(); + var props = ts.map(info.properties, function (prop) { + var initializer = tryGetValueFromType(context, checker, importAdder, quotePreference, checker.getTypeOfSymbol(prop), info.parentDeclaration); + return ts.factory.createPropertyAssignment(createPropertyNameFromSymbol(prop, target, quotePreference, checker), initializer); + }); + var options = { + leadingTriviaOption: ts.textChanges.LeadingTriviaOption.Exclude, + trailingTriviaOption: ts.textChanges.TrailingTriviaOption.Exclude, + indentation: info.indentation + }; + changes.replaceNode(context.sourceFile, info.parentDeclaration, ts.factory.createObjectLiteralExpression(__spreadArray(__spreadArray([], info.parentDeclaration.properties, true), props, true), /*multiLine*/ true), options); + importAdder.writeFixes(changes); + } + function tryGetValueFromType(context, checker, importAdder, quotePreference, type, enclosingDeclaration) { + if (type.flags & 3 /* TypeFlags.AnyOrUnknown */) { + return createUndefined(); + } + if (type.flags & (4 /* TypeFlags.String */ | 134217728 /* TypeFlags.TemplateLiteral */)) { + return ts.factory.createStringLiteral("", /* isSingleQuote */ quotePreference === 0 /* QuotePreference.Single */); + } + if (type.flags & 8 /* TypeFlags.Number */) { + return ts.factory.createNumericLiteral(0); + } + if (type.flags & 64 /* TypeFlags.BigInt */) { + return ts.factory.createBigIntLiteral("0n"); + } + if (type.flags & 16 /* TypeFlags.Boolean */) { + return ts.factory.createFalse(); + } + if (type.flags & 1056 /* TypeFlags.EnumLike */) { + var enumMember = type.symbol.exports ? ts.firstOrUndefined(ts.arrayFrom(type.symbol.exports.values())) : type.symbol; + var name = checker.symbolToExpression(type.symbol.parent ? type.symbol.parent : type.symbol, 111551 /* SymbolFlags.Value */, /*enclosingDeclaration*/ undefined, /*flags*/ undefined); + return enumMember === undefined || name === undefined ? ts.factory.createNumericLiteral(0) : ts.factory.createPropertyAccessExpression(name, checker.symbolToString(enumMember)); + } + if (type.flags & 256 /* TypeFlags.NumberLiteral */) { + return ts.factory.createNumericLiteral(type.value); + } + if (type.flags & 2048 /* TypeFlags.BigIntLiteral */) { + return ts.factory.createBigIntLiteral(type.value); + } + if (type.flags & 128 /* TypeFlags.StringLiteral */) { + return ts.factory.createStringLiteral(type.value, /* isSingleQuote */ quotePreference === 0 /* QuotePreference.Single */); + } + if (type.flags & 512 /* TypeFlags.BooleanLiteral */) { + return (type === checker.getFalseType() || type === checker.getFalseType(/*fresh*/ true)) ? ts.factory.createFalse() : ts.factory.createTrue(); + } + if (type.flags & 65536 /* TypeFlags.Null */) { + return ts.factory.createNull(); + } + if (type.flags & 1048576 /* TypeFlags.Union */) { + var expression = ts.firstDefined(type.types, function (t) { return tryGetValueFromType(context, checker, importAdder, quotePreference, t, enclosingDeclaration); }); + return expression !== null && expression !== void 0 ? expression : createUndefined(); + } + if (checker.isArrayLikeType(type)) { + return ts.factory.createArrayLiteralExpression(); + } + if (isObjectLiteralType(type)) { + var props = ts.map(checker.getPropertiesOfType(type), function (prop) { + var initializer = prop.valueDeclaration ? tryGetValueFromType(context, checker, importAdder, quotePreference, checker.getTypeAtLocation(prop.valueDeclaration), enclosingDeclaration) : createUndefined(); + return ts.factory.createPropertyAssignment(prop.name, initializer); + }); + return ts.factory.createObjectLiteralExpression(props, /*multiLine*/ true); + } + if (ts.getObjectFlags(type) & 16 /* ObjectFlags.Anonymous */) { + var decl = ts.find(type.symbol.declarations || ts.emptyArray, ts.or(ts.isFunctionTypeNode, ts.isMethodSignature, ts.isMethodDeclaration)); + if (decl === undefined) + return createUndefined(); + var signature = checker.getSignaturesOfType(type, 0 /* SignatureKind.Call */); + if (signature === undefined) + return createUndefined(); + var func = codefix.createSignatureDeclarationFromSignature(215 /* SyntaxKind.FunctionExpression */, context, quotePreference, signature[0], codefix.createStubbedBody(ts.Diagnostics.Function_not_implemented.message, quotePreference), /*name*/ undefined, /*modifiers*/ undefined, /*optional*/ undefined, /*enclosingDeclaration*/ enclosingDeclaration, importAdder); + return func !== null && func !== void 0 ? func : createUndefined(); + } + if (ts.getObjectFlags(type) & 1 /* ObjectFlags.Class */) { + var classDeclaration = ts.getClassLikeDeclarationOfSymbol(type.symbol); + if (classDeclaration === undefined || ts.hasAbstractModifier(classDeclaration)) + return createUndefined(); + var constructorDeclaration = ts.getFirstConstructorWithBody(classDeclaration); + if (constructorDeclaration && ts.length(constructorDeclaration.parameters)) + return createUndefined(); + return ts.factory.createNewExpression(ts.factory.createIdentifier(type.symbol.name), /*typeArguments*/ undefined, /*argumentsArray*/ undefined); + } + return createUndefined(); + } + function createUndefined() { + return ts.factory.createIdentifier("undefined"); + } + function isObjectLiteralType(type) { + return (type.flags & 524288 /* TypeFlags.Object */) && + ((ts.getObjectFlags(type) & 128 /* ObjectFlags.ObjectLiteral */) || (type.symbol && ts.tryCast(ts.singleOrUndefined(type.symbol.declarations), ts.isTypeLiteralNode))); + } + function getUnmatchedAttributes(checker, target, source) { + var attrsType = checker.getContextualType(source.attributes); + if (attrsType === undefined) + return ts.emptyArray; + var targetProps = attrsType.getProperties(); + if (!ts.length(targetProps)) + return ts.emptyArray; + var seenNames = new ts.Set(); + for (var _i = 0, _a = source.attributes.properties; _i < _a.length; _i++) { + var sourceProp = _a[_i]; + if (ts.isJsxAttribute(sourceProp)) { + seenNames.add(sourceProp.name.escapedText); + } + if (ts.isJsxSpreadAttribute(sourceProp)) { + var type = checker.getTypeAtLocation(sourceProp.expression); + for (var _b = 0, _c = type.getProperties(); _b < _c.length; _b++) { + var prop = _c[_b]; + seenNames.add(prop.escapedName); + } + } + } + return ts.filter(targetProps, function (targetProp) { + return ts.isIdentifierText(targetProp.name, target, 1 /* LanguageVariant.JSX */) && !((targetProp.flags & 16777216 /* SymbolFlags.Optional */ || ts.getCheckFlags(targetProp) & 48 /* CheckFlags.Partial */) || seenNames.has(targetProp.escapedName)); + }); + } + function tryGetContainingMethodDeclaration(node, callExpression) { + if (ts.isTypeLiteralNode(node)) { + return undefined; + } + var declaration = ts.findAncestor(callExpression, function (n) { return ts.isMethodDeclaration(n) || ts.isConstructorDeclaration(n); }); + return declaration && declaration.parent === node ? declaration : undefined; + } + function createPropertyNameFromSymbol(symbol, target, quotePreference, checker) { + if (ts.isTransientSymbol(symbol)) { + var prop = checker.symbolToNode(symbol, 111551 /* SymbolFlags.Value */, /*enclosingDeclaration*/ undefined, 1073741824 /* NodeBuilderFlags.WriteComputedProps */); + if (prop && ts.isComputedPropertyName(prop)) + return prop; + } + return ts.createPropertyNameNodeForIdentifierOrLiteral(symbol.name, target, quotePreference === 0 /* QuotePreference.Single */); + } + function findScope(node) { + if (ts.findAncestor(node, ts.isJsxExpression)) { + var returnStatement = ts.findAncestor(node.parent, ts.isReturnStatement); + if (returnStatement) + return returnStatement; + } + return ts.getSourceFileOfNode(node); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "addMissingNewOperator"; + var errorCodes = [ts.Diagnostics.Value_of_type_0_is_not_callable_Did_you_mean_to_include_new.code]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var sourceFile = context.sourceFile, span = context.span; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addMissingNewOperator(t, sourceFile, span); }); + return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Add_missing_new_operator_to_call, fixId, ts.Diagnostics.Add_missing_new_operator_to_all_calls)]; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + return addMissingNewOperator(changes, context.sourceFile, diag); + }); }, + }); + function addMissingNewOperator(changes, sourceFile, span) { + var call = ts.cast(findAncestorMatchingSpan(sourceFile, span), ts.isCallExpression); + var newExpression = ts.factory.createNewExpression(call.expression, call.typeArguments, call.arguments); + changes.replaceNode(sourceFile, call, newExpression); + } + function findAncestorMatchingSpan(sourceFile, span) { + var token = ts.getTokenAtPosition(sourceFile, span.start); + var end = ts.textSpanEnd(span); + while (token.end < end) { + token = token.parent; + } + return token; + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixName = "fixCannotFindModule"; + var fixIdInstallTypesPackage = "installTypesPackage"; + var errorCodeCannotFindModule = ts.Diagnostics.Cannot_find_module_0_or_its_corresponding_type_declarations.code; + var errorCodes = [ + errorCodeCannotFindModule, + ts.Diagnostics.Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type.code, + ]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function getCodeActionsToFixNotFoundModule(context) { + var host = context.host, sourceFile = context.sourceFile, start = context.span.start; + var packageName = tryGetImportedPackageName(sourceFile, start); + if (packageName === undefined) + return undefined; + var typesPackageName = getTypesPackageNameToInstall(packageName, host, context.errorCode); + return typesPackageName === undefined + ? [] + : [codefix.createCodeFixAction(fixName, /*changes*/ [], [ts.Diagnostics.Install_0, typesPackageName], fixIdInstallTypesPackage, ts.Diagnostics.Install_all_missing_types_packages, getInstallCommand(sourceFile.fileName, typesPackageName))]; + }, + fixIds: [fixIdInstallTypesPackage], + getAllCodeActions: function (context) { + return codefix.codeFixAll(context, errorCodes, function (_changes, diag, commands) { + var packageName = tryGetImportedPackageName(diag.file, diag.start); + if (packageName === undefined) + return undefined; + switch (context.fixId) { + case fixIdInstallTypesPackage: { + var pkg = getTypesPackageNameToInstall(packageName, context.host, diag.code); + if (pkg) { + commands.push(getInstallCommand(diag.file.fileName, pkg)); + } + break; + } + default: + ts.Debug.fail("Bad fixId: ".concat(context.fixId)); + } + }); + }, + }); + function getInstallCommand(fileName, packageName) { + return { type: "install package", file: fileName, packageName: packageName }; + } + function tryGetImportedPackageName(sourceFile, pos) { + var moduleSpecifierText = ts.tryCast(ts.getTokenAtPosition(sourceFile, pos), ts.isStringLiteral); + if (!moduleSpecifierText) + return undefined; + var moduleName = moduleSpecifierText.text; + var packageName = ts.parsePackageName(moduleName).packageName; + return ts.isExternalModuleNameRelative(packageName) ? undefined : packageName; + } + function getTypesPackageNameToInstall(packageName, host, diagCode) { + var _a; + return diagCode === errorCodeCannotFindModule + ? (ts.JsTyping.nodeCoreModules.has(packageName) ? "@types/node" : undefined) + : (((_a = host.isKnownTypesPackageName) === null || _a === void 0 ? void 0 : _a.call(host, packageName)) ? ts.getTypesPackageName(packageName) : undefined); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var errorCodes = [ + ts.Diagnostics.Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2.code, + ts.Diagnostics.Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1.code, + ]; + var fixId = "fixClassDoesntImplementInheritedAbstractMember"; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function getCodeActionsToFixClassNotImplementingInheritedMembers(context) { + var sourceFile = context.sourceFile, span = context.span; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { + return addMissingMembers(getClass(sourceFile, span.start), sourceFile, context, t, context.preferences); + }); + return changes.length === 0 ? undefined : [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Implement_inherited_abstract_class, fixId, ts.Diagnostics.Implement_all_inherited_abstract_classes)]; + }, + fixIds: [fixId], + getAllCodeActions: function getAllCodeActionsToFixClassDoesntImplementInheritedAbstractMember(context) { + var seenClassDeclarations = new ts.Map(); + return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var classDeclaration = getClass(diag.file, diag.start); + if (ts.addToSeen(seenClassDeclarations, ts.getNodeId(classDeclaration))) { + addMissingMembers(classDeclaration, context.sourceFile, context, changes, context.preferences); + } + }); + }, + }); + function getClass(sourceFile, pos) { + // Token is the identifier in the case of a class declaration + // or the class keyword token in the case of a class expression. + var token = ts.getTokenAtPosition(sourceFile, pos); + return ts.cast(token.parent, ts.isClassLike); + } + function addMissingMembers(classDeclaration, sourceFile, context, changeTracker, preferences) { + var extendsNode = ts.getEffectiveBaseTypeNode(classDeclaration); + var checker = context.program.getTypeChecker(); + var instantiatedExtendsType = checker.getTypeAtLocation(extendsNode); + // Note that this is ultimately derived from a map indexed by symbol names, + // so duplicates cannot occur. + var abstractAndNonPrivateExtendsSymbols = checker.getPropertiesOfType(instantiatedExtendsType).filter(symbolPointsToNonPrivateAndAbstractMember); + var importAdder = codefix.createImportAdder(sourceFile, context.program, preferences, context.host); + codefix.createMissingMemberNodes(classDeclaration, abstractAndNonPrivateExtendsSymbols, sourceFile, context, preferences, importAdder, function (member) { return changeTracker.insertMemberAtStart(sourceFile, classDeclaration, member); }); + importAdder.writeFixes(changeTracker); + } + function symbolPointsToNonPrivateAndAbstractMember(symbol) { + // See `codeFixClassExtendAbstractProtectedProperty.ts` in https://github.com/Microsoft/TypeScript/pull/11547/files + // (now named `codeFixClassExtendAbstractPrivateProperty.ts`) + var flags = ts.getSyntacticModifierFlags(ts.first(symbol.getDeclarations())); + return !(flags & 8 /* ModifierFlags.Private */) && !!(flags & 256 /* ModifierFlags.Abstract */); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "classSuperMustPrecedeThisAccess"; + var errorCodes = [ts.Diagnostics.super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class.code]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var sourceFile = context.sourceFile, span = context.span; + var nodes = getNodes(sourceFile, span.start); + if (!nodes) + return undefined; + var constructor = nodes.constructor, superCall = nodes.superCall; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, sourceFile, constructor, superCall); }); + return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Make_super_call_the_first_statement_in_the_constructor, fixId, ts.Diagnostics.Make_all_super_calls_the_first_statement_in_their_constructor)]; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { + var sourceFile = context.sourceFile; + var seenClasses = new ts.Map(); // Ensure we only do this once per class. + return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var nodes = getNodes(diag.file, diag.start); + if (!nodes) + return; + var constructor = nodes.constructor, superCall = nodes.superCall; + if (ts.addToSeen(seenClasses, ts.getNodeId(constructor.parent))) { + doChange(changes, sourceFile, constructor, superCall); + } + }); + }, + }); + function doChange(changes, sourceFile, constructor, superCall) { + changes.insertNodeAtConstructorStart(sourceFile, constructor, superCall); + changes.delete(sourceFile, superCall); + } + function getNodes(sourceFile, pos) { + var token = ts.getTokenAtPosition(sourceFile, pos); + if (token.kind !== 108 /* SyntaxKind.ThisKeyword */) + return undefined; + var constructor = ts.getContainingFunction(token); + var superCall = findSuperCall(constructor.body); + // figure out if the `this` access is actually inside the supercall + // i.e. super(this.a), since in that case we won't suggest a fix + return superCall && !superCall.expression.arguments.some(function (arg) { return ts.isPropertyAccessExpression(arg) && arg.expression === token; }) ? { constructor: constructor, superCall: superCall } : undefined; + } + function findSuperCall(n) { + return ts.isExpressionStatement(n) && ts.isSuperCall(n.expression) + ? n + : ts.isFunctionLike(n) + ? undefined + : ts.forEachChild(n, findSuperCall); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "constructorForDerivedNeedSuperCall"; + var errorCodes = [ts.Diagnostics.Constructors_for_derived_classes_must_contain_a_super_call.code]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var sourceFile = context.sourceFile, span = context.span; + var ctr = getNode(sourceFile, span.start); + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, sourceFile, ctr); }); + return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Add_missing_super_call, fixId, ts.Diagnostics.Add_all_missing_super_calls)]; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + return doChange(changes, context.sourceFile, getNode(diag.file, diag.start)); + }); }, + }); + function getNode(sourceFile, pos) { + var token = ts.getTokenAtPosition(sourceFile, pos); + ts.Debug.assert(ts.isConstructorDeclaration(token.parent), "token should be at the constructor declaration"); + return token.parent; + } + function doChange(changes, sourceFile, ctr) { + var superCall = ts.factory.createExpressionStatement(ts.factory.createCallExpression(ts.factory.createSuper(), /*typeArguments*/ undefined, /*argumentsArray*/ ts.emptyArray)); + changes.insertNodeAtConstructorStart(sourceFile, ctr, superCall); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "enableExperimentalDecorators"; + var errorCodes = [ + ts.Diagnostics.Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_the_experimentalDecorators_option_in_your_tsconfig_or_jsconfig_to_remove_this_warning.code + ]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function getCodeActionsToEnableExperimentalDecorators(context) { + var configFile = context.program.getCompilerOptions().configFile; + if (configFile === undefined) { + return undefined; + } + var changes = ts.textChanges.ChangeTracker.with(context, function (changeTracker) { return doChange(changeTracker, configFile); }); + return [codefix.createCodeFixActionWithoutFixAll(fixId, changes, ts.Diagnostics.Enable_the_experimentalDecorators_option_in_your_configuration_file)]; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes) { + var configFile = context.program.getCompilerOptions().configFile; + if (configFile === undefined) { + return undefined; + } + doChange(changes, configFile); + }); }, + }); + function doChange(changeTracker, configFile) { + codefix.setJsonCompilerOptionValue(changeTracker, configFile, "experimentalDecorators", ts.factory.createTrue()); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixID = "fixEnableJsxFlag"; + var errorCodes = [ts.Diagnostics.Cannot_use_JSX_unless_the_jsx_flag_is_provided.code]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function getCodeActionsToFixEnableJsxFlag(context) { + var configFile = context.program.getCompilerOptions().configFile; + if (configFile === undefined) { + return undefined; + } + var changes = ts.textChanges.ChangeTracker.with(context, function (changeTracker) { + return doChange(changeTracker, configFile); + }); + return [ + codefix.createCodeFixActionWithoutFixAll(fixID, changes, ts.Diagnostics.Enable_the_jsx_flag_in_your_configuration_file) + ]; + }, + fixIds: [fixID], + getAllCodeActions: function (context) { + return codefix.codeFixAll(context, errorCodes, function (changes) { + var configFile = context.program.getCompilerOptions().configFile; + if (configFile === undefined) { + return undefined; + } + doChange(changes, configFile); + }); + } + }); + function doChange(changeTracker, configFile) { + codefix.setJsonCompilerOptionValue(changeTracker, configFile, "jsx", ts.factory.createStringLiteral("react")); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "fixNaNEquality"; + var errorCodes = [ + ts.Diagnostics.This_condition_will_always_return_0.code, + ]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var sourceFile = context.sourceFile, span = context.span, program = context.program; + var info = getInfo(program, sourceFile, span); + if (info === undefined) + return; + var suggestion = info.suggestion, expression = info.expression, arg = info.arg; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, sourceFile, arg, expression); }); + return [codefix.createCodeFixAction(fixId, changes, [ts.Diagnostics.Use_0, suggestion], fixId, ts.Diagnostics.Use_Number_isNaN_in_all_conditions)]; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { + return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var info = getInfo(context.program, diag.file, ts.createTextSpan(diag.start, diag.length)); + if (info) { + doChange(changes, diag.file, info.arg, info.expression); + } + }); + } + }); + function getInfo(program, sourceFile, span) { + var diag = ts.find(program.getSemanticDiagnostics(sourceFile), function (diag) { return diag.start === span.start && diag.length === span.length; }); + if (diag === undefined || diag.relatedInformation === undefined) + return; + var related = ts.find(diag.relatedInformation, function (related) { return related.code === ts.Diagnostics.Did_you_mean_0.code; }); + if (related === undefined || related.file === undefined || related.start === undefined || related.length === undefined) + return; + var token = codefix.findAncestorMatchingSpan(related.file, ts.createTextSpan(related.start, related.length)); + if (token === undefined) + return; + if (ts.isExpression(token) && ts.isBinaryExpression(token.parent)) { + return { suggestion: getSuggestion(related.messageText), expression: token.parent, arg: token }; + } + return undefined; + } + function doChange(changes, sourceFile, arg, expression) { + var callExpression = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("Number"), ts.factory.createIdentifier("isNaN")), /*typeArguments*/ undefined, [arg]); + var operator = expression.operatorToken.kind; + changes.replaceNode(sourceFile, expression, operator === 37 /* SyntaxKind.ExclamationEqualsEqualsToken */ || operator === 35 /* SyntaxKind.ExclamationEqualsToken */ + ? ts.factory.createPrefixUnaryExpression(53 /* SyntaxKind.ExclamationToken */, callExpression) : callExpression); + } + function getSuggestion(messageText) { + var _a = ts.flattenDiagnosticMessageText(messageText, "\n", 0).match(/\'(.*)\'/) || [], _ = _a[0], suggestion = _a[1]; + return suggestion; + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + codefix.registerCodeFix({ + errorCodes: [ + ts.Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher.code, + ts.Diagnostics.Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_or_nodenext_and_the_target_option_is_set_to_es2017_or_higher.code, + ], + getCodeActions: function getCodeActionsToFixModuleAndTarget(context) { + var compilerOptions = context.program.getCompilerOptions(); + var configFile = compilerOptions.configFile; + if (configFile === undefined) { + return undefined; + } + var codeFixes = []; + var moduleKind = ts.getEmitModuleKind(compilerOptions); + var moduleOutOfRange = moduleKind >= ts.ModuleKind.ES2015 && moduleKind < ts.ModuleKind.ESNext; + if (moduleOutOfRange) { + var changes = ts.textChanges.ChangeTracker.with(context, function (changes) { + codefix.setJsonCompilerOptionValue(changes, configFile, "module", ts.factory.createStringLiteral("esnext")); + }); + codeFixes.push(codefix.createCodeFixActionWithoutFixAll("fixModuleOption", changes, [ts.Diagnostics.Set_the_module_option_in_your_configuration_file_to_0, "esnext"])); + } + var target = ts.getEmitScriptTarget(compilerOptions); + var targetOutOfRange = target < 4 /* ScriptTarget.ES2017 */ || target > 99 /* ScriptTarget.ESNext */; + if (targetOutOfRange) { + var changes = ts.textChanges.ChangeTracker.with(context, function (tracker) { + var configObject = ts.getTsConfigObjectLiteralExpression(configFile); + if (!configObject) + return; + var options = [["target", ts.factory.createStringLiteral("es2017")]]; + if (moduleKind === ts.ModuleKind.CommonJS) { + // Ensure we preserve the default module kind (commonjs), as targets >= ES2015 have a default module kind of es2015. + options.push(["module", ts.factory.createStringLiteral("commonjs")]); + } + codefix.setJsonCompilerOptionValues(tracker, configFile, options); + }); + codeFixes.push(codefix.createCodeFixActionWithoutFixAll("fixTargetOption", changes, [ts.Diagnostics.Set_the_target_option_in_your_configuration_file_to_0, "es2017"])); + } + return codeFixes.length ? codeFixes : undefined; + } + }); + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "fixPropertyAssignment"; + var errorCodes = [ + ts.Diagnostics.Did_you_mean_to_use_a_Colon_An_can_only_follow_a_property_name_when_the_containing_object_literal_is_part_of_a_destructuring_pattern.code + ]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + fixIds: [fixId], + getCodeActions: function (context) { + var sourceFile = context.sourceFile, span = context.span; + var property = getProperty(sourceFile, span.start); + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, context.sourceFile, property); }); + return [codefix.createCodeFixAction(fixId, changes, [ts.Diagnostics.Change_0_to_1, "=", ":"], fixId, [ts.Diagnostics.Switch_each_misused_0_to_1, "=", ":"])]; + }, + getAllCodeActions: function (context) { + return codefix.codeFixAll(context, errorCodes, function (changes, diag) { return doChange(changes, diag.file, getProperty(diag.file, diag.start)); }); + } + }); + function doChange(changes, sourceFile, node) { + changes.replaceNode(sourceFile, node, ts.factory.createPropertyAssignment(node.name, node.objectAssignmentInitializer)); + } + function getProperty(sourceFile, pos) { + return ts.cast(ts.getTokenAtPosition(sourceFile, pos).parent, ts.isShorthandPropertyAssignment); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "extendsInterfaceBecomesImplements"; + var errorCodes = [ts.Diagnostics.Cannot_extend_an_interface_0_Did_you_mean_implements.code]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var sourceFile = context.sourceFile; + var nodes = getNodes(sourceFile, context.span.start); + if (!nodes) + return undefined; + var extendsToken = nodes.extendsToken, heritageClauses = nodes.heritageClauses; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChanges(t, sourceFile, extendsToken, heritageClauses); }); + return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Change_extends_to_implements, fixId, ts.Diagnostics.Change_all_extended_interfaces_to_implements)]; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var nodes = getNodes(diag.file, diag.start); + if (nodes) + doChanges(changes, diag.file, nodes.extendsToken, nodes.heritageClauses); + }); }, + }); + function getNodes(sourceFile, pos) { + var token = ts.getTokenAtPosition(sourceFile, pos); + var heritageClauses = ts.getContainingClass(token).heritageClauses; + var extendsToken = heritageClauses[0].getFirstToken(); + return extendsToken.kind === 94 /* SyntaxKind.ExtendsKeyword */ ? { extendsToken: extendsToken, heritageClauses: heritageClauses } : undefined; + } + function doChanges(changes, sourceFile, extendsToken, heritageClauses) { + changes.replaceNode(sourceFile, extendsToken, ts.factory.createToken(117 /* SyntaxKind.ImplementsKeyword */)); + // If there is already an implements clause, replace the implements keyword with a comma. + if (heritageClauses.length === 2 && + heritageClauses[0].token === 94 /* SyntaxKind.ExtendsKeyword */ && + heritageClauses[1].token === 117 /* SyntaxKind.ImplementsKeyword */) { + var implementsToken = heritageClauses[1].getFirstToken(); + var implementsFullStart = implementsToken.getFullStart(); + changes.replaceRange(sourceFile, { pos: implementsFullStart, end: implementsFullStart }, ts.factory.createToken(27 /* SyntaxKind.CommaToken */)); + // Rough heuristic: delete trailing whitespace after keyword so that it's not excessive. + // (Trailing because leading might be indentation, which is more sensitive.) + var text = sourceFile.text; + var end = implementsToken.end; + while (end < text.length && ts.isWhiteSpaceSingleLine(text.charCodeAt(end))) { + end++; + } + changes.deleteRange(sourceFile, { pos: implementsToken.getStart(), end: end }); + } + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "forgottenThisPropertyAccess"; + var didYouMeanStaticMemberCode = ts.Diagnostics.Cannot_find_name_0_Did_you_mean_the_static_member_1_0.code; + var errorCodes = [ + ts.Diagnostics.Cannot_find_name_0_Did_you_mean_the_instance_member_this_0.code, + ts.Diagnostics.Private_identifiers_are_only_allowed_in_class_bodies_and_may_only_be_used_as_part_of_a_class_member_declaration_property_access_or_on_the_left_hand_side_of_an_in_expression.code, + didYouMeanStaticMemberCode, + ]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var sourceFile = context.sourceFile; + var info = getInfo(sourceFile, context.span.start, context.errorCode); + if (!info) { + return undefined; + } + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, sourceFile, info); }); + return [codefix.createCodeFixAction(fixId, changes, [ts.Diagnostics.Add_0_to_unresolved_variable, info.className || "this"], fixId, ts.Diagnostics.Add_qualifier_to_all_unresolved_variables_matching_a_member_name)]; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var info = getInfo(diag.file, diag.start, diag.code); + if (info) + doChange(changes, context.sourceFile, info); + }); }, + }); + function getInfo(sourceFile, pos, diagCode) { + var node = ts.getTokenAtPosition(sourceFile, pos); + if (ts.isIdentifier(node) || ts.isPrivateIdentifier(node)) { + return { node: node, className: diagCode === didYouMeanStaticMemberCode ? ts.getContainingClass(node).name.text : undefined }; + } + } + function doChange(changes, sourceFile, _a) { + var node = _a.node, className = _a.className; + // TODO (https://github.com/Microsoft/TypeScript/issues/21246): use shared helper + ts.suppressLeadingAndTrailingTrivia(node); + changes.replaceNode(sourceFile, node, ts.factory.createPropertyAccessExpression(className ? ts.factory.createIdentifier(className) : ts.factory.createThis(), node)); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixIdExpression = "fixInvalidJsxCharacters_expression"; + var fixIdHtmlEntity = "fixInvalidJsxCharacters_htmlEntity"; + var errorCodes = [ + ts.Diagnostics.Unexpected_token_Did_you_mean_or_gt.code, + ts.Diagnostics.Unexpected_token_Did_you_mean_or_rbrace.code + ]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + fixIds: [fixIdExpression, fixIdHtmlEntity], + getCodeActions: function (context) { + var sourceFile = context.sourceFile, preferences = context.preferences, span = context.span; + var changeToExpression = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, preferences, sourceFile, span.start, /* useHtmlEntity */ false); }); + var changeToHtmlEntity = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, preferences, sourceFile, span.start, /* useHtmlEntity */ true); }); + return [ + codefix.createCodeFixAction(fixIdExpression, changeToExpression, ts.Diagnostics.Wrap_invalid_character_in_an_expression_container, fixIdExpression, ts.Diagnostics.Wrap_all_invalid_characters_in_an_expression_container), + codefix.createCodeFixAction(fixIdHtmlEntity, changeToHtmlEntity, ts.Diagnostics.Convert_invalid_character_to_its_html_entity_code, fixIdHtmlEntity, ts.Diagnostics.Convert_all_invalid_characters_to_HTML_entity_code) + ]; + }, + getAllCodeActions: function (context) { + return codefix.codeFixAll(context, errorCodes, function (changes, diagnostic) { return doChange(changes, context.preferences, diagnostic.file, diagnostic.start, context.fixId === fixIdHtmlEntity); }); + } + }); + var htmlEntity = { + ">": ">", + "}": "}", + }; + function isValidCharacter(character) { + return ts.hasProperty(htmlEntity, character); + } + function doChange(changes, preferences, sourceFile, start, useHtmlEntity) { + var character = sourceFile.getText()[start]; + // sanity check + if (!isValidCharacter(character)) { + return; + } + var replacement = useHtmlEntity ? htmlEntity[character] : "{".concat(ts.quote(sourceFile, preferences, character), "}"); + changes.replaceRangeWithText(sourceFile, { pos: start, end: start + 1 }, replacement); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var deleteUnmatchedParameter = "deleteUnmatchedParameter"; + var renameUnmatchedParameter = "renameUnmatchedParameter"; + var errorCodes = [ + ts.Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name.code, + ]; + codefix.registerCodeFix({ + fixIds: [deleteUnmatchedParameter, renameUnmatchedParameter], + errorCodes: errorCodes, + getCodeActions: function getCodeActionsToFixUnmatchedParameter(context) { + var sourceFile = context.sourceFile, span = context.span; + var actions = []; + var info = getInfo(sourceFile, span.start); + if (info) { + ts.append(actions, getDeleteAction(context, info)); + ts.append(actions, getRenameAction(context, info)); + return actions; + } + return undefined; + }, + getAllCodeActions: function getAllCodeActionsToFixUnmatchedParameter(context) { + var tagsToSignature = new ts.Map(); + return codefix.createCombinedCodeActions(ts.textChanges.ChangeTracker.with(context, function (changes) { + codefix.eachDiagnostic(context, errorCodes, function (_a) { + var file = _a.file, start = _a.start; + var info = getInfo(file, start); + if (info) { + tagsToSignature.set(info.signature, ts.append(tagsToSignature.get(info.signature), info.jsDocParameterTag)); + } + }); + tagsToSignature.forEach(function (tags, signature) { + if (context.fixId === deleteUnmatchedParameter) { + var tagsSet_1 = new ts.Set(tags); + changes.filterJSDocTags(signature.getSourceFile(), signature, function (t) { return !tagsSet_1.has(t); }); + } + }); + })); + } + }); + function getDeleteAction(context, _a) { + var name = _a.name, signature = _a.signature, jsDocParameterTag = _a.jsDocParameterTag; + var changes = ts.textChanges.ChangeTracker.with(context, function (changeTracker) { + return changeTracker.filterJSDocTags(context.sourceFile, signature, function (t) { return t !== jsDocParameterTag; }); + }); + return codefix.createCodeFixAction(deleteUnmatchedParameter, changes, [ts.Diagnostics.Delete_unused_param_tag_0, name.getText(context.sourceFile)], deleteUnmatchedParameter, ts.Diagnostics.Delete_all_unused_param_tags); + } + function getRenameAction(context, _a) { + var name = _a.name, signature = _a.signature, jsDocParameterTag = _a.jsDocParameterTag; + if (!ts.length(signature.parameters)) + return undefined; + var sourceFile = context.sourceFile; + var tags = ts.getJSDocTags(signature); + var names = new ts.Set(); + for (var _i = 0, tags_2 = tags; _i < tags_2.length; _i++) { + var tag = tags_2[_i]; + if (ts.isJSDocParameterTag(tag) && ts.isIdentifier(tag.name)) { + names.add(tag.name.escapedText); + } + } + // @todo - match to all available names instead to the first parameter name + // @see /codeFixRenameUnmatchedParameter3.ts + var parameterName = ts.firstDefined(signature.parameters, function (p) { + return ts.isIdentifier(p.name) && !names.has(p.name.escapedText) ? p.name.getText(sourceFile) : undefined; + }); + if (parameterName === undefined) + return undefined; + var newJSDocParameterTag = ts.factory.updateJSDocParameterTag(jsDocParameterTag, jsDocParameterTag.tagName, ts.factory.createIdentifier(parameterName), jsDocParameterTag.isBracketed, jsDocParameterTag.typeExpression, jsDocParameterTag.isNameFirst, jsDocParameterTag.comment); + var changes = ts.textChanges.ChangeTracker.with(context, function (changeTracker) { + return changeTracker.replaceJSDocComment(sourceFile, signature, ts.map(tags, function (t) { return t === jsDocParameterTag ? newJSDocParameterTag : t; })); + }); + return codefix.createCodeFixActionWithoutFixAll(renameUnmatchedParameter, changes, [ts.Diagnostics.Rename_param_tag_name_0_to_1, name.getText(sourceFile), parameterName]); + } + function getInfo(sourceFile, pos) { + var token = ts.getTokenAtPosition(sourceFile, pos); + if (token.parent && ts.isJSDocParameterTag(token.parent) && ts.isIdentifier(token.parent.name)) { + var jsDocParameterTag = token.parent; + var signature = ts.getHostSignatureFromJSDoc(jsDocParameterTag); + if (signature) { + return { signature: signature, name: token.parent.name, jsDocParameterTag: jsDocParameterTag }; + } + } + return undefined; + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "fixUnreferenceableDecoratorMetadata"; + var errorCodes = [ts.Diagnostics.A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled.code]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var importDeclaration = getImportDeclaration(context.sourceFile, context.program, context.span.start); + if (!importDeclaration) + return; + var namespaceChanges = ts.textChanges.ChangeTracker.with(context, function (t) { return importDeclaration.kind === 273 /* SyntaxKind.ImportSpecifier */ && doNamespaceImportChange(t, context.sourceFile, importDeclaration, context.program); }); + var typeOnlyChanges = ts.textChanges.ChangeTracker.with(context, function (t) { return doTypeOnlyImportChange(t, context.sourceFile, importDeclaration, context.program); }); + var actions; + if (namespaceChanges.length) { + actions = ts.append(actions, codefix.createCodeFixActionWithoutFixAll(fixId, namespaceChanges, ts.Diagnostics.Convert_named_imports_to_namespace_import)); + } + if (typeOnlyChanges.length) { + actions = ts.append(actions, codefix.createCodeFixActionWithoutFixAll(fixId, typeOnlyChanges, ts.Diagnostics.Convert_to_type_only_import)); + } + return actions; + }, + fixIds: [fixId], + }); + function getImportDeclaration(sourceFile, program, start) { + var identifier = ts.tryCast(ts.getTokenAtPosition(sourceFile, start), ts.isIdentifier); + if (!identifier || identifier.parent.kind !== 180 /* SyntaxKind.TypeReference */) + return; + var checker = program.getTypeChecker(); + var symbol = checker.getSymbolAtLocation(identifier); + return ts.find((symbol === null || symbol === void 0 ? void 0 : symbol.declarations) || ts.emptyArray, ts.or(ts.isImportClause, ts.isImportSpecifier, ts.isImportEqualsDeclaration)); + } + // Converts the import declaration of the offending import to a type-only import, + // only if it can be done without affecting other imported names. If the conversion + // cannot be done cleanly, we could offer to *extract* the offending import to a + // new type-only import declaration, but honestly I doubt anyone will ever use this + // codefix at all, so it's probably not worth the lines of code. + function doTypeOnlyImportChange(changes, sourceFile, importDeclaration, program) { + if (importDeclaration.kind === 268 /* SyntaxKind.ImportEqualsDeclaration */) { + changes.insertModifierBefore(sourceFile, 154 /* SyntaxKind.TypeKeyword */, importDeclaration.name); + return; + } + var importClause = importDeclaration.kind === 270 /* SyntaxKind.ImportClause */ ? importDeclaration : importDeclaration.parent.parent; + if (importClause.name && importClause.namedBindings) { + // Cannot convert an import with a default import and named bindings to type-only + // (it's a grammar error). + return; + } + var checker = program.getTypeChecker(); + var importsValue = !!ts.forEachImportClauseDeclaration(importClause, function (decl) { + if (ts.skipAlias(decl.symbol, checker).flags & 111551 /* SymbolFlags.Value */) + return true; + }); + if (importsValue) { + // Assume that if someone wrote a non-type-only import that includes some values, + // they intend to use those values in value positions, even if they haven't yet. + // Don't convert it to type-only. + return; + } + changes.insertModifierBefore(sourceFile, 154 /* SyntaxKind.TypeKeyword */, importClause); + } + function doNamespaceImportChange(changes, sourceFile, importDeclaration, program) { + ts.refactor.doChangeNamedToNamespaceOrDefault(sourceFile, program, changes, importDeclaration.parent); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixName = "unusedIdentifier"; + var fixIdPrefix = "unusedIdentifier_prefix"; + var fixIdDelete = "unusedIdentifier_delete"; + var fixIdDeleteImports = "unusedIdentifier_deleteImports"; + var fixIdInfer = "unusedIdentifier_infer"; + var errorCodes = [ + ts.Diagnostics._0_is_declared_but_its_value_is_never_read.code, + ts.Diagnostics._0_is_declared_but_never_used.code, + ts.Diagnostics.Property_0_is_declared_but_its_value_is_never_read.code, + ts.Diagnostics.All_imports_in_import_declaration_are_unused.code, + ts.Diagnostics.All_destructured_elements_are_unused.code, + ts.Diagnostics.All_variables_are_unused.code, + ts.Diagnostics.All_type_parameters_are_unused.code, + ]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var errorCode = context.errorCode, sourceFile = context.sourceFile, program = context.program, cancellationToken = context.cancellationToken; + var checker = program.getTypeChecker(); + var sourceFiles = program.getSourceFiles(); + var token = ts.getTokenAtPosition(sourceFile, context.span.start); + if (ts.isJSDocTemplateTag(token)) { + return [createDeleteFix(ts.textChanges.ChangeTracker.with(context, function (t) { return t.delete(sourceFile, token); }), ts.Diagnostics.Remove_template_tag)]; + } + if (token.kind === 29 /* SyntaxKind.LessThanToken */) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return deleteTypeParameters(t, sourceFile, token); }); + return [createDeleteFix(changes, ts.Diagnostics.Remove_type_parameters)]; + } + var importDecl = tryGetFullImport(token); + if (importDecl) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return t.delete(sourceFile, importDecl); }); + return [codefix.createCodeFixAction(fixName, changes, [ts.Diagnostics.Remove_import_from_0, ts.showModuleSpecifier(importDecl)], fixIdDeleteImports, ts.Diagnostics.Delete_all_unused_imports)]; + } + else if (isImport(token)) { + var deletion = ts.textChanges.ChangeTracker.with(context, function (t) { return tryDeleteDeclaration(sourceFile, token, t, checker, sourceFiles, program, cancellationToken, /*isFixAll*/ false); }); + if (deletion.length) { + return [codefix.createCodeFixAction(fixName, deletion, [ts.Diagnostics.Remove_unused_declaration_for_Colon_0, token.getText(sourceFile)], fixIdDeleteImports, ts.Diagnostics.Delete_all_unused_imports)]; + } + } + if (ts.isObjectBindingPattern(token.parent) || ts.isArrayBindingPattern(token.parent)) { + if (ts.isParameter(token.parent.parent)) { + var elements = token.parent.elements; + var diagnostic = [ + elements.length > 1 ? ts.Diagnostics.Remove_unused_declarations_for_Colon_0 : ts.Diagnostics.Remove_unused_declaration_for_Colon_0, + ts.map(elements, function (e) { return e.getText(sourceFile); }).join(", ") + ]; + return [ + createDeleteFix(ts.textChanges.ChangeTracker.with(context, function (t) { + return deleteDestructuringElements(t, sourceFile, token.parent); + }), diagnostic) + ]; + } + return [ + createDeleteFix(ts.textChanges.ChangeTracker.with(context, function (t) { + return t.delete(sourceFile, token.parent.parent); + }), ts.Diagnostics.Remove_unused_destructuring_declaration) + ]; + } + if (canDeleteEntireVariableStatement(sourceFile, token)) { + return [ + createDeleteFix(ts.textChanges.ChangeTracker.with(context, function (t) { + return deleteEntireVariableStatement(t, sourceFile, token.parent); + }), ts.Diagnostics.Remove_variable_statement) + ]; + } + var result = []; + if (token.kind === 138 /* SyntaxKind.InferKeyword */) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return changeInferToUnknown(t, sourceFile, token); }); + var name = ts.cast(token.parent, ts.isInferTypeNode).typeParameter.name.text; + result.push(codefix.createCodeFixAction(fixName, changes, [ts.Diagnostics.Replace_infer_0_with_unknown, name], fixIdInfer, ts.Diagnostics.Replace_all_unused_infer_with_unknown)); + } + else { + var deletion = ts.textChanges.ChangeTracker.with(context, function (t) { + return tryDeleteDeclaration(sourceFile, token, t, checker, sourceFiles, program, cancellationToken, /*isFixAll*/ false); + }); + if (deletion.length) { + var name = ts.isComputedPropertyName(token.parent) ? token.parent : token; + result.push(createDeleteFix(deletion, [ts.Diagnostics.Remove_unused_declaration_for_Colon_0, name.getText(sourceFile)])); + } + } + var prefix = ts.textChanges.ChangeTracker.with(context, function (t) { return tryPrefixDeclaration(t, errorCode, sourceFile, token); }); + if (prefix.length) { + result.push(codefix.createCodeFixAction(fixName, prefix, [ts.Diagnostics.Prefix_0_with_an_underscore, token.getText(sourceFile)], fixIdPrefix, ts.Diagnostics.Prefix_all_unused_declarations_with_where_possible)); + } + return result; + }, + fixIds: [fixIdPrefix, fixIdDelete, fixIdDeleteImports, fixIdInfer], + getAllCodeActions: function (context) { + var sourceFile = context.sourceFile, program = context.program, cancellationToken = context.cancellationToken; + var checker = program.getTypeChecker(); + var sourceFiles = program.getSourceFiles(); + return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var token = ts.getTokenAtPosition(sourceFile, diag.start); + switch (context.fixId) { + case fixIdPrefix: + tryPrefixDeclaration(changes, diag.code, sourceFile, token); + break; + case fixIdDeleteImports: { + var importDecl = tryGetFullImport(token); + if (importDecl) { + changes.delete(sourceFile, importDecl); + } + else if (isImport(token)) { + tryDeleteDeclaration(sourceFile, token, changes, checker, sourceFiles, program, cancellationToken, /*isFixAll*/ true); + } + break; + } + case fixIdDelete: { + if (token.kind === 138 /* SyntaxKind.InferKeyword */ || isImport(token)) { + break; // Can't delete + } + else if (ts.isJSDocTemplateTag(token)) { + changes.delete(sourceFile, token); + } + else if (token.kind === 29 /* SyntaxKind.LessThanToken */) { + deleteTypeParameters(changes, sourceFile, token); + } + else if (ts.isObjectBindingPattern(token.parent)) { + if (token.parent.parent.initializer) { + break; + } + else if (!ts.isParameter(token.parent.parent) || isNotProvidedArguments(token.parent.parent, checker, sourceFiles)) { + changes.delete(sourceFile, token.parent.parent); + } + } + else if (ts.isArrayBindingPattern(token.parent.parent) && token.parent.parent.parent.initializer) { + break; + } + else if (canDeleteEntireVariableStatement(sourceFile, token)) { + deleteEntireVariableStatement(changes, sourceFile, token.parent); + } + else { + tryDeleteDeclaration(sourceFile, token, changes, checker, sourceFiles, program, cancellationToken, /*isFixAll*/ true); + } + break; + } + case fixIdInfer: + if (token.kind === 138 /* SyntaxKind.InferKeyword */) { + changeInferToUnknown(changes, sourceFile, token); + } + break; + default: + ts.Debug.fail(JSON.stringify(context.fixId)); + } + }); + }, + }); + function changeInferToUnknown(changes, sourceFile, token) { + changes.replaceNode(sourceFile, token.parent, ts.factory.createKeywordTypeNode(157 /* SyntaxKind.UnknownKeyword */)); + } + function createDeleteFix(changes, diag) { + return codefix.createCodeFixAction(fixName, changes, diag, fixIdDelete, ts.Diagnostics.Delete_all_unused_declarations); + } + function deleteTypeParameters(changes, sourceFile, token) { + changes.delete(sourceFile, ts.Debug.checkDefined(ts.cast(token.parent, ts.isDeclarationWithTypeParameterChildren).typeParameters, "The type parameter to delete should exist")); + } + function isImport(token) { + return token.kind === 100 /* SyntaxKind.ImportKeyword */ + || token.kind === 79 /* SyntaxKind.Identifier */ && (token.parent.kind === 273 /* SyntaxKind.ImportSpecifier */ || token.parent.kind === 270 /* SyntaxKind.ImportClause */); + } + /** Sometimes the diagnostic span is an entire ImportDeclaration, so we should remove the whole thing. */ + function tryGetFullImport(token) { + return token.kind === 100 /* SyntaxKind.ImportKeyword */ ? ts.tryCast(token.parent, ts.isImportDeclaration) : undefined; + } + function canDeleteEntireVariableStatement(sourceFile, token) { + return ts.isVariableDeclarationList(token.parent) && ts.first(token.parent.getChildren(sourceFile)) === token; + } + function deleteEntireVariableStatement(changes, sourceFile, node) { + changes.delete(sourceFile, node.parent.kind === 240 /* SyntaxKind.VariableStatement */ ? node.parent : node); + } + function deleteDestructuringElements(changes, sourceFile, node) { + ts.forEach(node.elements, function (n) { return changes.delete(sourceFile, n); }); + } + function tryPrefixDeclaration(changes, errorCode, sourceFile, token) { + // Don't offer to prefix a property. + if (errorCode === ts.Diagnostics.Property_0_is_declared_but_its_value_is_never_read.code) + return; + if (token.kind === 138 /* SyntaxKind.InferKeyword */) { + token = ts.cast(token.parent, ts.isInferTypeNode).typeParameter.name; + } + if (ts.isIdentifier(token) && canPrefix(token)) { + changes.replaceNode(sourceFile, token, ts.factory.createIdentifier("_".concat(token.text))); + if (ts.isParameter(token.parent)) { + ts.getJSDocParameterTags(token.parent).forEach(function (tag) { + if (ts.isIdentifier(tag.name)) { + changes.replaceNode(sourceFile, tag.name, ts.factory.createIdentifier("_".concat(tag.name.text))); + } + }); + } + } + } + function canPrefix(token) { + switch (token.parent.kind) { + case 166 /* SyntaxKind.Parameter */: + case 165 /* SyntaxKind.TypeParameter */: + return true; + case 257 /* SyntaxKind.VariableDeclaration */: { + var varDecl = token.parent; + switch (varDecl.parent.parent.kind) { + case 247 /* SyntaxKind.ForOfStatement */: + case 246 /* SyntaxKind.ForInStatement */: + return true; + } + } + } + return false; + } + function tryDeleteDeclaration(sourceFile, token, changes, checker, sourceFiles, program, cancellationToken, isFixAll) { + tryDeleteDeclarationWorker(token, changes, sourceFile, checker, sourceFiles, program, cancellationToken, isFixAll); + if (ts.isIdentifier(token)) { + ts.FindAllReferences.Core.eachSymbolReferenceInFile(token, checker, sourceFile, function (ref) { + if (ts.isPropertyAccessExpression(ref.parent) && ref.parent.name === ref) + ref = ref.parent; + if (!isFixAll && mayDeleteExpression(ref)) { + changes.delete(sourceFile, ref.parent.parent); + } + }); + } + } + function tryDeleteDeclarationWorker(token, changes, sourceFile, checker, sourceFiles, program, cancellationToken, isFixAll) { + var parent = token.parent; + if (ts.isParameter(parent)) { + tryDeleteParameter(changes, sourceFile, parent, checker, sourceFiles, program, cancellationToken, isFixAll); + } + else if (!(isFixAll && ts.isIdentifier(token) && ts.FindAllReferences.Core.isSymbolReferencedInFile(token, checker, sourceFile))) { + var node = ts.isImportClause(parent) ? token : ts.isComputedPropertyName(parent) ? parent.parent : parent; + ts.Debug.assert(node !== sourceFile, "should not delete whole source file"); + changes.delete(sourceFile, node); + } + } + function tryDeleteParameter(changes, sourceFile, parameter, checker, sourceFiles, program, cancellationToken, isFixAll) { + if (isFixAll === void 0) { isFixAll = false; } + if (mayDeleteParameter(checker, sourceFile, parameter, sourceFiles, program, cancellationToken, isFixAll)) { + if (parameter.modifiers && parameter.modifiers.length > 0 && + (!ts.isIdentifier(parameter.name) || ts.FindAllReferences.Core.isSymbolReferencedInFile(parameter.name, checker, sourceFile))) { + for (var _i = 0, _a = parameter.modifiers; _i < _a.length; _i++) { + var modifier = _a[_i]; + if (ts.isModifier(modifier)) { + changes.deleteModifier(sourceFile, modifier); + } + } + } + else if (!parameter.initializer && isNotProvidedArguments(parameter, checker, sourceFiles)) { + changes.delete(sourceFile, parameter); + } + } + } + function isNotProvidedArguments(parameter, checker, sourceFiles) { + var index = parameter.parent.parameters.indexOf(parameter); + // Just in case the call didn't provide enough arguments. + return !ts.FindAllReferences.Core.someSignatureUsage(parameter.parent, sourceFiles, checker, function (_, call) { return !call || call.arguments.length > index; }); + } + function mayDeleteParameter(checker, sourceFile, parameter, sourceFiles, program, cancellationToken, isFixAll) { + var parent = parameter.parent; + switch (parent.kind) { + case 171 /* SyntaxKind.MethodDeclaration */: + case 173 /* SyntaxKind.Constructor */: + var index = parent.parameters.indexOf(parameter); + var referent = ts.isMethodDeclaration(parent) ? parent.name : parent; + var entries = ts.FindAllReferences.Core.getReferencedSymbolsForNode(parent.pos, referent, program, sourceFiles, cancellationToken); + if (entries) { + for (var _i = 0, entries_2 = entries; _i < entries_2.length; _i++) { + var entry = entries_2[_i]; + for (var _a = 0, _b = entry.references; _a < _b.length; _a++) { + var reference = _b[_a]; + if (reference.kind === 1 /* FindAllReferences.EntryKind.Node */) { + // argument in super(...) + var isSuperCall_1 = ts.isSuperKeyword(reference.node) + && ts.isCallExpression(reference.node.parent) + && reference.node.parent.arguments.length > index; + // argument in super.m(...) + var isSuperMethodCall = ts.isPropertyAccessExpression(reference.node.parent) + && ts.isSuperKeyword(reference.node.parent.expression) + && ts.isCallExpression(reference.node.parent.parent) + && reference.node.parent.parent.arguments.length > index; + // parameter in overridden or overriding method + var isOverriddenMethod = (ts.isMethodDeclaration(reference.node.parent) || ts.isMethodSignature(reference.node.parent)) + && reference.node.parent !== parameter.parent + && reference.node.parent.parameters.length > index; + if (isSuperCall_1 || isSuperMethodCall || isOverriddenMethod) + return false; + } + } + } + } + return true; + case 259 /* SyntaxKind.FunctionDeclaration */: { + if (parent.name && isCallbackLike(checker, sourceFile, parent.name)) { + return isLastParameter(parent, parameter, isFixAll); + } + return true; + } + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + // Can't remove a non-last parameter in a callback. Can remove a parameter in code-fix-all if future parameters are also unused. + return isLastParameter(parent, parameter, isFixAll); + case 175 /* SyntaxKind.SetAccessor */: + // Setter must have a parameter + return false; + case 174 /* SyntaxKind.GetAccessor */: + // Getter cannot have parameters + return true; + default: + return ts.Debug.failBadSyntaxKind(parent); + } + } + function isCallbackLike(checker, sourceFile, name) { + return !!ts.FindAllReferences.Core.eachSymbolReferenceInFile(name, checker, sourceFile, function (reference) { + return ts.isIdentifier(reference) && ts.isCallExpression(reference.parent) && reference.parent.arguments.indexOf(reference) >= 0; + }); + } + function isLastParameter(func, parameter, isFixAll) { + var parameters = func.parameters; + var index = parameters.indexOf(parameter); + ts.Debug.assert(index !== -1, "The parameter should already be in the list"); + return isFixAll ? + parameters.slice(index + 1).every(function (p) { return ts.isIdentifier(p.name) && !p.symbol.isReferenced; }) : + index === parameters.length - 1; + } + function mayDeleteExpression(node) { + return ((ts.isBinaryExpression(node.parent) && node.parent.left === node) || + ((ts.isPostfixUnaryExpression(node.parent) || ts.isPrefixUnaryExpression(node.parent)) && node.parent.operand === node)) && ts.isExpressionStatement(node.parent.parent); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "fixUnreachableCode"; + var errorCodes = [ts.Diagnostics.Unreachable_code_detected.code]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var syntacticDiagnostics = context.program.getSyntacticDiagnostics(context.sourceFile, context.cancellationToken); + if (syntacticDiagnostics.length) + return; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, context.sourceFile, context.span.start, context.span.length, context.errorCode); }); + return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Remove_unreachable_code, fixId, ts.Diagnostics.Remove_all_unreachable_code)]; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { return doChange(changes, diag.file, diag.start, diag.length, diag.code); }); }, + }); + function doChange(changes, sourceFile, start, length, errorCode) { + var token = ts.getTokenAtPosition(sourceFile, start); + var statement = ts.findAncestor(token, ts.isStatement); + if (statement.getStart(sourceFile) !== token.getStart(sourceFile)) { + var logData = JSON.stringify({ + statementKind: ts.Debug.formatSyntaxKind(statement.kind), + tokenKind: ts.Debug.formatSyntaxKind(token.kind), + errorCode: errorCode, + start: start, + length: length + }); + ts.Debug.fail("Token and statement should start at the same point. " + logData); + } + var container = (ts.isBlock(statement.parent) ? statement.parent : statement).parent; + if (!ts.isBlock(statement.parent) || statement === ts.first(statement.parent.statements)) { + switch (container.kind) { + case 242 /* SyntaxKind.IfStatement */: + if (container.elseStatement) { + if (ts.isBlock(statement.parent)) { + break; + } + else { + changes.replaceNode(sourceFile, statement, ts.factory.createBlock(ts.emptyArray)); + } + return; + } + // falls through + case 244 /* SyntaxKind.WhileStatement */: + case 245 /* SyntaxKind.ForStatement */: + changes.delete(sourceFile, container); + return; + } + } + if (ts.isBlock(statement.parent)) { + var end_3 = start + length; + var lastStatement = ts.Debug.checkDefined(lastWhere(ts.sliceAfter(statement.parent.statements, statement), function (s) { return s.pos < end_3; }), "Some statement should be last"); + changes.deleteNodeRange(sourceFile, statement, lastStatement); + } + else { + changes.delete(sourceFile, statement); + } + } + function lastWhere(a, pred) { + var last; + for (var _i = 0, a_1 = a; _i < a_1.length; _i++) { + var value = a_1[_i]; + if (!pred(value)) + break; + last = value; + } + return last; + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "fixUnusedLabel"; + var errorCodes = [ts.Diagnostics.Unused_label.code]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, context.sourceFile, context.span.start); }); + return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Remove_unused_label, fixId, ts.Diagnostics.Remove_all_unused_labels)]; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { return doChange(changes, diag.file, diag.start); }); }, + }); + function doChange(changes, sourceFile, start) { + var token = ts.getTokenAtPosition(sourceFile, start); + var labeledStatement = ts.cast(token.parent, ts.isLabeledStatement); + var pos = token.getStart(sourceFile); + var statementPos = labeledStatement.statement.getStart(sourceFile); + // If label is on a separate line, just delete the rest of that line, but not the indentation of the labeled statement. + var end = ts.positionsAreOnSameLine(pos, statementPos, sourceFile) ? statementPos + : ts.skipTrivia(sourceFile.text, ts.findChildOfKind(labeledStatement, 58 /* SyntaxKind.ColonToken */, sourceFile).end, /*stopAfterLineBreak*/ true); + changes.deleteRange(sourceFile, { pos: pos, end: end }); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixIdPlain = "fixJSDocTypes_plain"; + var fixIdNullable = "fixJSDocTypes_nullable"; + var errorCodes = [ts.Diagnostics.JSDoc_types_can_only_be_used_inside_documentation_comments.code]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var sourceFile = context.sourceFile; + var checker = context.program.getTypeChecker(); + var info = getInfo(sourceFile, context.span.start, checker); + if (!info) + return undefined; + var typeNode = info.typeNode, type = info.type; + var original = typeNode.getText(sourceFile); + var actions = [fix(type, fixIdPlain, ts.Diagnostics.Change_all_jsdoc_style_types_to_TypeScript)]; + if (typeNode.kind === 317 /* SyntaxKind.JSDocNullableType */) { + // for nullable types, suggest the flow-compatible `T | null | undefined` + // in addition to the jsdoc/closure-compatible `T | null` + actions.push(fix(checker.getNullableType(type, 32768 /* TypeFlags.Undefined */), fixIdNullable, ts.Diagnostics.Change_all_jsdoc_style_types_to_TypeScript_and_add_undefined_to_nullable_types)); + } + return actions; + function fix(type, fixId, fixAllDescription) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, sourceFile, typeNode, type, checker); }); + return codefix.createCodeFixAction("jdocTypes", changes, [ts.Diagnostics.Change_0_to_1, original, checker.typeToString(type)], fixId, fixAllDescription); + } + }, + fixIds: [fixIdPlain, fixIdNullable], + getAllCodeActions: function (context) { + var fixId = context.fixId, program = context.program, sourceFile = context.sourceFile; + var checker = program.getTypeChecker(); + return codefix.codeFixAll(context, errorCodes, function (changes, err) { + var info = getInfo(err.file, err.start, checker); + if (!info) + return; + var typeNode = info.typeNode, type = info.type; + var fixedType = typeNode.kind === 317 /* SyntaxKind.JSDocNullableType */ && fixId === fixIdNullable ? checker.getNullableType(type, 32768 /* TypeFlags.Undefined */) : type; + doChange(changes, sourceFile, typeNode, fixedType, checker); + }); + } + }); + function doChange(changes, sourceFile, oldTypeNode, newType, checker) { + changes.replaceNode(sourceFile, oldTypeNode, checker.typeToTypeNode(newType, /*enclosingDeclaration*/ oldTypeNode, /*flags*/ undefined)); // TODO: GH#18217 + } + function getInfo(sourceFile, pos, checker) { + var decl = ts.findAncestor(ts.getTokenAtPosition(sourceFile, pos), isTypeContainer); + var typeNode = decl && decl.type; + return typeNode && { typeNode: typeNode, type: checker.getTypeFromTypeNode(typeNode) }; + } + function isTypeContainer(node) { + // NOTE: Some locations are not handled yet: + // MappedTypeNode.typeParameters and SignatureDeclaration.typeParameters, as well as CallExpression.typeArguments + switch (node.kind) { + case 231 /* SyntaxKind.AsExpression */: + case 176 /* SyntaxKind.CallSignature */: + case 177 /* SyntaxKind.ConstructSignature */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 174 /* SyntaxKind.GetAccessor */: + case 178 /* SyntaxKind.IndexSignature */: + case 197 /* SyntaxKind.MappedType */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + case 166 /* SyntaxKind.Parameter */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 168 /* SyntaxKind.PropertySignature */: + case 175 /* SyntaxKind.SetAccessor */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 213 /* SyntaxKind.TypeAssertionExpression */: + case 257 /* SyntaxKind.VariableDeclaration */: + return true; + default: + return false; + } + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "fixMissingCallParentheses"; + var errorCodes = [ + ts.Diagnostics.This_condition_will_always_return_true_since_this_function_is_always_defined_Did_you_mean_to_call_it_instead.code, + ]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + fixIds: [fixId], + getCodeActions: function (context) { + var sourceFile = context.sourceFile, span = context.span; + var callName = getCallName(sourceFile, span.start); + if (!callName) + return; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, context.sourceFile, callName); }); + return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Add_missing_call_parentheses, fixId, ts.Diagnostics.Add_all_missing_call_parentheses)]; + }, + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var callName = getCallName(diag.file, diag.start); + if (callName) + doChange(changes, diag.file, callName); + }); } + }); + function doChange(changes, sourceFile, name) { + changes.replaceNodeWithText(sourceFile, name, "".concat(name.text, "()")); + } + function getCallName(sourceFile, start) { + var token = ts.getTokenAtPosition(sourceFile, start); + if (ts.isPropertyAccessExpression(token.parent)) { + var current = token.parent; + while (ts.isPropertyAccessExpression(current.parent)) { + current = current.parent; + } + return current.name; + } + if (ts.isIdentifier(token)) { + return token; + } + return undefined; + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "fixAwaitInSyncFunction"; + var errorCodes = [ + ts.Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code, + ts.Diagnostics.for_await_loops_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code, + ts.Diagnostics.Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function.code + ]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var sourceFile = context.sourceFile, span = context.span; + var nodes = getNodes(sourceFile, span.start); + if (!nodes) + return undefined; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, sourceFile, nodes); }); + return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Add_async_modifier_to_containing_function, fixId, ts.Diagnostics.Add_all_missing_async_modifiers)]; + }, + fixIds: [fixId], + getAllCodeActions: function getAllCodeActionsToFixAwaitInSyncFunction(context) { + var seen = new ts.Map(); + return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var nodes = getNodes(diag.file, diag.start); + if (!nodes || !ts.addToSeen(seen, ts.getNodeId(nodes.insertBefore))) + return; + doChange(changes, context.sourceFile, nodes); + }); + }, + }); + function getReturnType(expr) { + if (expr.type) { + return expr.type; + } + if (ts.isVariableDeclaration(expr.parent) && + expr.parent.type && + ts.isFunctionTypeNode(expr.parent.type)) { + return expr.parent.type.type; + } + } + function getNodes(sourceFile, start) { + var token = ts.getTokenAtPosition(sourceFile, start); + var containingFunction = ts.getContainingFunction(token); + if (!containingFunction) { + return; + } + var insertBefore; + switch (containingFunction.kind) { + case 171 /* SyntaxKind.MethodDeclaration */: + insertBefore = containingFunction.name; + break; + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + insertBefore = ts.findChildOfKind(containingFunction, 98 /* SyntaxKind.FunctionKeyword */, sourceFile); + break; + case 216 /* SyntaxKind.ArrowFunction */: + var kind = containingFunction.typeParameters ? 29 /* SyntaxKind.LessThanToken */ : 20 /* SyntaxKind.OpenParenToken */; + insertBefore = ts.findChildOfKind(containingFunction, kind, sourceFile) || ts.first(containingFunction.parameters); + break; + default: + return; + } + return insertBefore && { + insertBefore: insertBefore, + returnType: getReturnType(containingFunction) + }; + } + function doChange(changes, sourceFile, _a) { + var insertBefore = _a.insertBefore, returnType = _a.returnType; + if (returnType) { + var entityName = ts.getEntityNameFromTypeNode(returnType); + if (!entityName || entityName.kind !== 79 /* SyntaxKind.Identifier */ || entityName.text !== "Promise") { + changes.replaceNode(sourceFile, returnType, ts.factory.createTypeReferenceNode("Promise", ts.factory.createNodeArray([returnType]))); + } + } + changes.insertModifierBefore(sourceFile, 132 /* SyntaxKind.AsyncKeyword */, insertBefore); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var errorCodes = [ + ts.Diagnostics._0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property.code, + ts.Diagnostics._0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor.code, + ]; + var fixId = "fixPropertyOverrideAccessor"; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var edits = doChange(context.sourceFile, context.span.start, context.span.length, context.errorCode, context); + if (edits) { + return [codefix.createCodeFixAction(fixId, edits, ts.Diagnostics.Generate_get_and_set_accessors, fixId, ts.Diagnostics.Generate_get_and_set_accessors_for_all_overriding_properties)]; + } + }, + fixIds: [fixId], + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var edits = doChange(diag.file, diag.start, diag.length, diag.code, context); + if (edits) { + for (var _i = 0, edits_2 = edits; _i < edits_2.length; _i++) { + var edit = edits_2[_i]; + changes.pushRaw(context.sourceFile, edit); + } + } + }); }, + }); + function doChange(file, start, length, code, context) { + var startPosition; + var endPosition; + if (code === ts.Diagnostics._0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property.code) { + startPosition = start; + endPosition = start + length; + } + else if (code === ts.Diagnostics._0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor.code) { + var checker = context.program.getTypeChecker(); + var node = ts.getTokenAtPosition(file, start).parent; + ts.Debug.assert(ts.isAccessor(node), "error span of fixPropertyOverrideAccessor should only be on an accessor"); + var containingClass = node.parent; + ts.Debug.assert(ts.isClassLike(containingClass), "erroneous accessors should only be inside classes"); + var base = ts.singleOrUndefined(codefix.getAllSupers(containingClass, checker)); + if (!base) + return []; + var name = ts.unescapeLeadingUnderscores(ts.getTextOfPropertyName(node.name)); + var baseProp = checker.getPropertyOfType(checker.getTypeAtLocation(base), name); + if (!baseProp || !baseProp.valueDeclaration) + return []; + startPosition = baseProp.valueDeclaration.pos; + endPosition = baseProp.valueDeclaration.end; + file = ts.getSourceFileOfNode(baseProp.valueDeclaration); + } + else { + ts.Debug.fail("fixPropertyOverrideAccessor codefix got unexpected error code " + code); + } + return codefix.generateAccessorFromProperty(file, context.program, startPosition, endPosition, context, ts.Diagnostics.Generate_get_and_set_accessors.message); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "inferFromUsage"; + var errorCodes = [ + // Variable declarations + ts.Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined.code, + // Variable uses + ts.Diagnostics.Variable_0_implicitly_has_an_1_type.code, + // Parameter declarations + ts.Diagnostics.Parameter_0_implicitly_has_an_1_type.code, + ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type.code, + // Get Accessor declarations + ts.Diagnostics.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation.code, + ts.Diagnostics._0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type.code, + // Set Accessor declarations + ts.Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation.code, + // Property declarations + ts.Diagnostics.Member_0_implicitly_has_an_1_type.code, + //// Suggestions + // Variable declarations + ts.Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_but_a_better_type_may_be_inferred_from_usage.code, + // Variable uses + ts.Diagnostics.Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage.code, + // Parameter declarations + ts.Diagnostics.Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage.code, + ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage.code, + // Get Accessor declarations + ts.Diagnostics.Property_0_implicitly_has_type_any_but_a_better_type_for_its_get_accessor_may_be_inferred_from_usage.code, + ts.Diagnostics._0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage.code, + // Set Accessor declarations + ts.Diagnostics.Property_0_implicitly_has_type_any_but_a_better_type_for_its_set_accessor_may_be_inferred_from_usage.code, + // Property declarations + ts.Diagnostics.Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage.code, + // Function expressions and declarations + ts.Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code, + ]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var sourceFile = context.sourceFile, program = context.program, start = context.span.start, errorCode = context.errorCode, cancellationToken = context.cancellationToken, host = context.host, preferences = context.preferences; + var token = ts.getTokenAtPosition(sourceFile, start); + var declaration; + var changes = ts.textChanges.ChangeTracker.with(context, function (changes) { + declaration = doChange(changes, sourceFile, token, errorCode, program, cancellationToken, /*markSeen*/ ts.returnTrue, host, preferences); + }); + var name = declaration && ts.getNameOfDeclaration(declaration); + return !name || changes.length === 0 ? undefined + : [codefix.createCodeFixAction(fixId, changes, [getDiagnostic(errorCode, token), ts.getTextOfNode(name)], fixId, ts.Diagnostics.Infer_all_types_from_usage)]; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { + var sourceFile = context.sourceFile, program = context.program, cancellationToken = context.cancellationToken, host = context.host, preferences = context.preferences; + var markSeen = ts.nodeSeenTracker(); + return codefix.codeFixAll(context, errorCodes, function (changes, err) { + doChange(changes, sourceFile, ts.getTokenAtPosition(err.file, err.start), err.code, program, cancellationToken, markSeen, host, preferences); + }); + }, + }); + function getDiagnostic(errorCode, token) { + switch (errorCode) { + case ts.Diagnostics.Parameter_0_implicitly_has_an_1_type.code: + case ts.Diagnostics.Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage.code: + return ts.isSetAccessorDeclaration(ts.getContainingFunction(token)) ? ts.Diagnostics.Infer_type_of_0_from_usage : ts.Diagnostics.Infer_parameter_types_from_usage; // TODO: GH#18217 + case ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type.code: + case ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage.code: + return ts.Diagnostics.Infer_parameter_types_from_usage; + case ts.Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code: + return ts.Diagnostics.Infer_this_type_of_0_from_usage; + default: + return ts.Diagnostics.Infer_type_of_0_from_usage; + } + } + /** Map suggestion code to error code */ + function mapSuggestionDiagnostic(errorCode) { + switch (errorCode) { + case ts.Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_but_a_better_type_may_be_inferred_from_usage.code: + return ts.Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined.code; + case ts.Diagnostics.Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage.code: + return ts.Diagnostics.Variable_0_implicitly_has_an_1_type.code; + case ts.Diagnostics.Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage.code: + return ts.Diagnostics.Parameter_0_implicitly_has_an_1_type.code; + case ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage.code: + return ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type.code; + case ts.Diagnostics.Property_0_implicitly_has_type_any_but_a_better_type_for_its_get_accessor_may_be_inferred_from_usage.code: + return ts.Diagnostics.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation.code; + case ts.Diagnostics._0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage.code: + return ts.Diagnostics._0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type.code; + case ts.Diagnostics.Property_0_implicitly_has_type_any_but_a_better_type_for_its_set_accessor_may_be_inferred_from_usage.code: + return ts.Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation.code; + case ts.Diagnostics.Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage.code: + return ts.Diagnostics.Member_0_implicitly_has_an_1_type.code; + } + return errorCode; + } + function doChange(changes, sourceFile, token, errorCode, program, cancellationToken, markSeen, host, preferences) { + if (!ts.isParameterPropertyModifier(token.kind) && token.kind !== 79 /* SyntaxKind.Identifier */ && token.kind !== 25 /* SyntaxKind.DotDotDotToken */ && token.kind !== 108 /* SyntaxKind.ThisKeyword */) { + return undefined; + } + var parent = token.parent; + var importAdder = codefix.createImportAdder(sourceFile, program, preferences, host); + errorCode = mapSuggestionDiagnostic(errorCode); + switch (errorCode) { + // Variable and Property declarations + case ts.Diagnostics.Member_0_implicitly_has_an_1_type.code: + case ts.Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined.code: + if ((ts.isVariableDeclaration(parent) && markSeen(parent)) || ts.isPropertyDeclaration(parent) || ts.isPropertySignature(parent)) { // handle bad location + annotateVariableDeclaration(changes, importAdder, sourceFile, parent, program, host, cancellationToken); + importAdder.writeFixes(changes); + return parent; + } + if (ts.isPropertyAccessExpression(parent)) { + var type = inferTypeForVariableFromUsage(parent.name, program, cancellationToken); + var typeNode = ts.getTypeNodeIfAccessible(type, parent, program, host); + if (typeNode) { + // Note that the codefix will never fire with an existing `@type` tag, so there is no need to merge tags + var typeTag = ts.factory.createJSDocTypeTag(/*tagName*/ undefined, ts.factory.createJSDocTypeExpression(typeNode), /*comment*/ undefined); + changes.addJSDocTags(sourceFile, ts.cast(parent.parent.parent, ts.isExpressionStatement), [typeTag]); + } + importAdder.writeFixes(changes); + return parent; + } + return undefined; + case ts.Diagnostics.Variable_0_implicitly_has_an_1_type.code: { + var symbol = program.getTypeChecker().getSymbolAtLocation(token); + if (symbol && symbol.valueDeclaration && ts.isVariableDeclaration(symbol.valueDeclaration) && markSeen(symbol.valueDeclaration)) { + annotateVariableDeclaration(changes, importAdder, ts.getSourceFileOfNode(symbol.valueDeclaration), symbol.valueDeclaration, program, host, cancellationToken); + importAdder.writeFixes(changes); + return symbol.valueDeclaration; + } + return undefined; + } + } + var containingFunction = ts.getContainingFunction(token); + if (containingFunction === undefined) { + return undefined; + } + var declaration; + switch (errorCode) { + // Parameter declarations + case ts.Diagnostics.Parameter_0_implicitly_has_an_1_type.code: + if (ts.isSetAccessorDeclaration(containingFunction)) { + annotateSetAccessor(changes, importAdder, sourceFile, containingFunction, program, host, cancellationToken); + declaration = containingFunction; + break; + } + // falls through + case ts.Diagnostics.Rest_parameter_0_implicitly_has_an_any_type.code: + if (markSeen(containingFunction)) { + var param = ts.cast(parent, ts.isParameter); + annotateParameters(changes, importAdder, sourceFile, param, containingFunction, program, host, cancellationToken); + declaration = param; + } + break; + // Get Accessor declarations + case ts.Diagnostics.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation.code: + case ts.Diagnostics._0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type.code: + if (ts.isGetAccessorDeclaration(containingFunction) && ts.isIdentifier(containingFunction.name)) { + annotate(changes, importAdder, sourceFile, containingFunction, inferTypeForVariableFromUsage(containingFunction.name, program, cancellationToken), program, host); + declaration = containingFunction; + } + break; + // Set Accessor declarations + case ts.Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation.code: + if (ts.isSetAccessorDeclaration(containingFunction)) { + annotateSetAccessor(changes, importAdder, sourceFile, containingFunction, program, host, cancellationToken); + declaration = containingFunction; + } + break; + // Function 'this' + case ts.Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code: + if (ts.textChanges.isThisTypeAnnotatable(containingFunction) && markSeen(containingFunction)) { + annotateThis(changes, sourceFile, containingFunction, program, host, cancellationToken); + declaration = containingFunction; + } + break; + default: + return ts.Debug.fail(String(errorCode)); + } + importAdder.writeFixes(changes); + return declaration; + } + function annotateVariableDeclaration(changes, importAdder, sourceFile, declaration, program, host, cancellationToken) { + if (ts.isIdentifier(declaration.name)) { + annotate(changes, importAdder, sourceFile, declaration, inferTypeForVariableFromUsage(declaration.name, program, cancellationToken), program, host); + } + } + function annotateParameters(changes, importAdder, sourceFile, parameterDeclaration, containingFunction, program, host, cancellationToken) { + if (!ts.isIdentifier(parameterDeclaration.name)) { + return; + } + var parameterInferences = inferTypeForParametersFromUsage(containingFunction, sourceFile, program, cancellationToken); + ts.Debug.assert(containingFunction.parameters.length === parameterInferences.length, "Parameter count and inference count should match"); + if (ts.isInJSFile(containingFunction)) { + annotateJSDocParameters(changes, sourceFile, parameterInferences, program, host); + } + else { + var needParens = ts.isArrowFunction(containingFunction) && !ts.findChildOfKind(containingFunction, 20 /* SyntaxKind.OpenParenToken */, sourceFile); + if (needParens) + changes.insertNodeBefore(sourceFile, ts.first(containingFunction.parameters), ts.factory.createToken(20 /* SyntaxKind.OpenParenToken */)); + for (var _i = 0, parameterInferences_1 = parameterInferences; _i < parameterInferences_1.length; _i++) { + var _a = parameterInferences_1[_i], declaration = _a.declaration, type = _a.type; + if (declaration && !declaration.type && !declaration.initializer) { + annotate(changes, importAdder, sourceFile, declaration, type, program, host); + } + } + if (needParens) + changes.insertNodeAfter(sourceFile, ts.last(containingFunction.parameters), ts.factory.createToken(21 /* SyntaxKind.CloseParenToken */)); + } + } + function annotateThis(changes, sourceFile, containingFunction, program, host, cancellationToken) { + var references = getFunctionReferences(containingFunction, sourceFile, program, cancellationToken); + if (!references || !references.length) { + return; + } + var thisInference = inferTypeFromReferences(program, references, cancellationToken).thisParameter(); + var typeNode = ts.getTypeNodeIfAccessible(thisInference, containingFunction, program, host); + if (!typeNode) { + return; + } + if (ts.isInJSFile(containingFunction)) { + annotateJSDocThis(changes, sourceFile, containingFunction, typeNode); + } + else { + changes.tryInsertThisTypeAnnotation(sourceFile, containingFunction, typeNode); + } + } + function annotateJSDocThis(changes, sourceFile, containingFunction, typeNode) { + changes.addJSDocTags(sourceFile, containingFunction, [ + ts.factory.createJSDocThisTag(/*tagName*/ undefined, ts.factory.createJSDocTypeExpression(typeNode)), + ]); + } + function annotateSetAccessor(changes, importAdder, sourceFile, setAccessorDeclaration, program, host, cancellationToken) { + var param = ts.firstOrUndefined(setAccessorDeclaration.parameters); + if (param && ts.isIdentifier(setAccessorDeclaration.name) && ts.isIdentifier(param.name)) { + var type = inferTypeForVariableFromUsage(setAccessorDeclaration.name, program, cancellationToken); + if (type === program.getTypeChecker().getAnyType()) { + type = inferTypeForVariableFromUsage(param.name, program, cancellationToken); + } + if (ts.isInJSFile(setAccessorDeclaration)) { + annotateJSDocParameters(changes, sourceFile, [{ declaration: param, type: type }], program, host); + } + else { + annotate(changes, importAdder, sourceFile, param, type, program, host); + } + } + } + function annotate(changes, importAdder, sourceFile, declaration, type, program, host) { + var typeNode = ts.getTypeNodeIfAccessible(type, declaration, program, host); + if (typeNode) { + if (ts.isInJSFile(sourceFile) && declaration.kind !== 168 /* SyntaxKind.PropertySignature */) { + var parent = ts.isVariableDeclaration(declaration) ? ts.tryCast(declaration.parent.parent, ts.isVariableStatement) : declaration; + if (!parent) { + return; + } + var typeExpression = ts.factory.createJSDocTypeExpression(typeNode); + var typeTag = ts.isGetAccessorDeclaration(declaration) ? ts.factory.createJSDocReturnTag(/*tagName*/ undefined, typeExpression, /*comment*/ undefined) : ts.factory.createJSDocTypeTag(/*tagName*/ undefined, typeExpression, /*comment*/ undefined); + changes.addJSDocTags(sourceFile, parent, [typeTag]); + } + else if (!tryReplaceImportTypeNodeWithAutoImport(typeNode, declaration, sourceFile, changes, importAdder, ts.getEmitScriptTarget(program.getCompilerOptions()))) { + changes.tryInsertTypeAnnotation(sourceFile, declaration, typeNode); + } + } + } + function tryReplaceImportTypeNodeWithAutoImport(typeNode, declaration, sourceFile, changes, importAdder, scriptTarget) { + var importableReference = codefix.tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget); + if (importableReference && changes.tryInsertTypeAnnotation(sourceFile, declaration, importableReference.typeNode)) { + ts.forEach(importableReference.symbols, function (s) { return importAdder.addImportFromExportedSymbol(s, /*usageIsTypeOnly*/ true); }); + return true; + } + return false; + } + function annotateJSDocParameters(changes, sourceFile, parameterInferences, program, host) { + var signature = parameterInferences.length && parameterInferences[0].declaration.parent; + if (!signature) { + return; + } + var inferences = ts.mapDefined(parameterInferences, function (inference) { + var param = inference.declaration; + // only infer parameters that have (1) no type and (2) an accessible inferred type + if (param.initializer || ts.getJSDocType(param) || !ts.isIdentifier(param.name)) { + return; + } + var typeNode = inference.type && ts.getTypeNodeIfAccessible(inference.type, param, program, host); + if (typeNode) { + var name = ts.factory.cloneNode(param.name); + ts.setEmitFlags(name, 1536 /* EmitFlags.NoComments */ | 2048 /* EmitFlags.NoNestedComments */); + return { name: ts.factory.cloneNode(param.name), param: param, isOptional: !!inference.isOptional, typeNode: typeNode }; + } + }); + if (!inferences.length) { + return; + } + if (ts.isArrowFunction(signature) || ts.isFunctionExpression(signature)) { + var needParens = ts.isArrowFunction(signature) && !ts.findChildOfKind(signature, 20 /* SyntaxKind.OpenParenToken */, sourceFile); + if (needParens) { + changes.insertNodeBefore(sourceFile, ts.first(signature.parameters), ts.factory.createToken(20 /* SyntaxKind.OpenParenToken */)); + } + ts.forEach(inferences, function (_a) { + var typeNode = _a.typeNode, param = _a.param; + var typeTag = ts.factory.createJSDocTypeTag(/*tagName*/ undefined, ts.factory.createJSDocTypeExpression(typeNode)); + var jsDoc = ts.factory.createJSDocComment(/*comment*/ undefined, [typeTag]); + changes.insertNodeAt(sourceFile, param.getStart(sourceFile), jsDoc, { suffix: " " }); + }); + if (needParens) { + changes.insertNodeAfter(sourceFile, ts.last(signature.parameters), ts.factory.createToken(21 /* SyntaxKind.CloseParenToken */)); + } + } + else { + var paramTags = ts.map(inferences, function (_a) { + var name = _a.name, typeNode = _a.typeNode, isOptional = _a.isOptional; + return ts.factory.createJSDocParameterTag(/*tagName*/ undefined, name, /*isBracketed*/ !!isOptional, ts.factory.createJSDocTypeExpression(typeNode), /* isNameFirst */ false, /*comment*/ undefined); + }); + changes.addJSDocTags(sourceFile, signature, paramTags); + } + } + function getReferences(token, program, cancellationToken) { + // Position shouldn't matter since token is not a SourceFile. + return ts.mapDefined(ts.FindAllReferences.getReferenceEntriesForNode(-1, token, program, program.getSourceFiles(), cancellationToken), function (entry) { + return entry.kind !== 0 /* FindAllReferences.EntryKind.Span */ ? ts.tryCast(entry.node, ts.isIdentifier) : undefined; + }); + } + function inferTypeForVariableFromUsage(token, program, cancellationToken) { + var references = getReferences(token, program, cancellationToken); + return inferTypeFromReferences(program, references, cancellationToken).single(); + } + function inferTypeForParametersFromUsage(func, sourceFile, program, cancellationToken) { + var references = getFunctionReferences(func, sourceFile, program, cancellationToken); + return references && inferTypeFromReferences(program, references, cancellationToken).parameters(func) || + func.parameters.map(function (p) { return ({ + declaration: p, + type: ts.isIdentifier(p.name) ? inferTypeForVariableFromUsage(p.name, program, cancellationToken) : program.getTypeChecker().getAnyType() + }); }); + } + function getFunctionReferences(containingFunction, sourceFile, program, cancellationToken) { + var searchToken; + switch (containingFunction.kind) { + case 173 /* SyntaxKind.Constructor */: + searchToken = ts.findChildOfKind(containingFunction, 135 /* SyntaxKind.ConstructorKeyword */, sourceFile); + break; + case 216 /* SyntaxKind.ArrowFunction */: + case 215 /* SyntaxKind.FunctionExpression */: + var parent = containingFunction.parent; + searchToken = (ts.isVariableDeclaration(parent) || ts.isPropertyDeclaration(parent)) && ts.isIdentifier(parent.name) ? + parent.name : + containingFunction.name; + break; + case 259 /* SyntaxKind.FunctionDeclaration */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + searchToken = containingFunction.name; + break; + } + if (!searchToken) { + return undefined; + } + return getReferences(searchToken, program, cancellationToken); + } + function inferTypeFromReferences(program, references, cancellationToken) { + var checker = program.getTypeChecker(); + var builtinConstructors = { + string: function () { return checker.getStringType(); }, + number: function () { return checker.getNumberType(); }, + Array: function (t) { return checker.createArrayType(t); }, + Promise: function (t) { return checker.createPromiseType(t); }, + }; + var builtins = [ + checker.getStringType(), + checker.getNumberType(), + checker.createArrayType(checker.getAnyType()), + checker.createPromiseType(checker.getAnyType()), + ]; + return { + single: single, + parameters: parameters, + thisParameter: thisParameter, + }; + function createEmptyUsage() { + return { + isNumber: undefined, + isString: undefined, + isNumberOrString: undefined, + candidateTypes: undefined, + properties: undefined, + calls: undefined, + constructs: undefined, + numberIndex: undefined, + stringIndex: undefined, + candidateThisTypes: undefined, + inferredTypes: undefined, + }; + } + function combineUsages(usages) { + var combinedProperties = new ts.Map(); + for (var _i = 0, usages_1 = usages; _i < usages_1.length; _i++) { + var u = usages_1[_i]; + if (u.properties) { + u.properties.forEach(function (p, name) { + if (!combinedProperties.has(name)) { + combinedProperties.set(name, []); + } + combinedProperties.get(name).push(p); + }); + } + } + var properties = new ts.Map(); + combinedProperties.forEach(function (ps, name) { + properties.set(name, combineUsages(ps)); + }); + return { + isNumber: usages.some(function (u) { return u.isNumber; }), + isString: usages.some(function (u) { return u.isString; }), + isNumberOrString: usages.some(function (u) { return u.isNumberOrString; }), + candidateTypes: ts.flatMap(usages, function (u) { return u.candidateTypes; }), + properties: properties, + calls: ts.flatMap(usages, function (u) { return u.calls; }), + constructs: ts.flatMap(usages, function (u) { return u.constructs; }), + numberIndex: ts.forEach(usages, function (u) { return u.numberIndex; }), + stringIndex: ts.forEach(usages, function (u) { return u.stringIndex; }), + candidateThisTypes: ts.flatMap(usages, function (u) { return u.candidateThisTypes; }), + inferredTypes: undefined, // clear type cache + }; + } + function single() { + return combineTypes(inferTypesFromReferencesSingle(references)); + } + function parameters(declaration) { + if (references.length === 0 || !declaration.parameters) { + return undefined; + } + var usage = createEmptyUsage(); + for (var _i = 0, references_3 = references; _i < references_3.length; _i++) { + var reference = references_3[_i]; + cancellationToken.throwIfCancellationRequested(); + calculateUsageOfNode(reference, usage); + } + var calls = __spreadArray(__spreadArray([], usage.constructs || [], true), usage.calls || [], true); + return declaration.parameters.map(function (parameter, parameterIndex) { + var types = []; + var isRest = ts.isRestParameter(parameter); + var isOptional = false; + for (var _i = 0, calls_1 = calls; _i < calls_1.length; _i++) { + var call = calls_1[_i]; + if (call.argumentTypes.length <= parameterIndex) { + isOptional = ts.isInJSFile(declaration); + types.push(checker.getUndefinedType()); + } + else if (isRest) { + for (var i = parameterIndex; i < call.argumentTypes.length; i++) { + types.push(checker.getBaseTypeOfLiteralType(call.argumentTypes[i])); + } + } + else { + types.push(checker.getBaseTypeOfLiteralType(call.argumentTypes[parameterIndex])); + } + } + if (ts.isIdentifier(parameter.name)) { + var inferred = inferTypesFromReferencesSingle(getReferences(parameter.name, program, cancellationToken)); + types.push.apply(types, (isRest ? ts.mapDefined(inferred, checker.getElementTypeOfArrayType) : inferred)); + } + var type = combineTypes(types); + return { + type: isRest ? checker.createArrayType(type) : type, + isOptional: isOptional && !isRest, + declaration: parameter + }; + }); + } + function thisParameter() { + var usage = createEmptyUsage(); + for (var _i = 0, references_4 = references; _i < references_4.length; _i++) { + var reference = references_4[_i]; + cancellationToken.throwIfCancellationRequested(); + calculateUsageOfNode(reference, usage); + } + return combineTypes(usage.candidateThisTypes || ts.emptyArray); + } + function inferTypesFromReferencesSingle(references) { + var usage = createEmptyUsage(); + for (var _i = 0, references_5 = references; _i < references_5.length; _i++) { + var reference = references_5[_i]; + cancellationToken.throwIfCancellationRequested(); + calculateUsageOfNode(reference, usage); + } + return inferTypes(usage); + } + function calculateUsageOfNode(node, usage) { + while (ts.isRightSideOfQualifiedNameOrPropertyAccess(node)) { + node = node.parent; + } + switch (node.parent.kind) { + case 241 /* SyntaxKind.ExpressionStatement */: + inferTypeFromExpressionStatement(node, usage); + break; + case 222 /* SyntaxKind.PostfixUnaryExpression */: + usage.isNumber = true; + break; + case 221 /* SyntaxKind.PrefixUnaryExpression */: + inferTypeFromPrefixUnaryExpression(node.parent, usage); + break; + case 223 /* SyntaxKind.BinaryExpression */: + inferTypeFromBinaryExpression(node, node.parent, usage); + break; + case 292 /* SyntaxKind.CaseClause */: + case 293 /* SyntaxKind.DefaultClause */: + inferTypeFromSwitchStatementLabel(node.parent, usage); + break; + case 210 /* SyntaxKind.CallExpression */: + case 211 /* SyntaxKind.NewExpression */: + if (node.parent.expression === node) { + inferTypeFromCallExpression(node.parent, usage); + } + else { + inferTypeFromContextualType(node, usage); + } + break; + case 208 /* SyntaxKind.PropertyAccessExpression */: + inferTypeFromPropertyAccessExpression(node.parent, usage); + break; + case 209 /* SyntaxKind.ElementAccessExpression */: + inferTypeFromPropertyElementExpression(node.parent, node, usage); + break; + case 299 /* SyntaxKind.PropertyAssignment */: + case 300 /* SyntaxKind.ShorthandPropertyAssignment */: + inferTypeFromPropertyAssignment(node.parent, usage); + break; + case 169 /* SyntaxKind.PropertyDeclaration */: + inferTypeFromPropertyDeclaration(node.parent, usage); + break; + case 257 /* SyntaxKind.VariableDeclaration */: { + var _a = node.parent, name = _a.name, initializer = _a.initializer; + if (node === name) { + if (initializer) { // This can happen for `let x = null;` which still has an implicit-any error. + addCandidateType(usage, checker.getTypeAtLocation(initializer)); + } + break; + } + } + // falls through + default: + return inferTypeFromContextualType(node, usage); + } + } + function inferTypeFromContextualType(node, usage) { + if (ts.isExpressionNode(node)) { + addCandidateType(usage, checker.getContextualType(node)); + } + } + function inferTypeFromExpressionStatement(node, usage) { + addCandidateType(usage, ts.isCallExpression(node) ? checker.getVoidType() : checker.getAnyType()); + } + function inferTypeFromPrefixUnaryExpression(node, usage) { + switch (node.operator) { + case 45 /* SyntaxKind.PlusPlusToken */: + case 46 /* SyntaxKind.MinusMinusToken */: + case 40 /* SyntaxKind.MinusToken */: + case 54 /* SyntaxKind.TildeToken */: + usage.isNumber = true; + break; + case 39 /* SyntaxKind.PlusToken */: + usage.isNumberOrString = true; + break; + // case SyntaxKind.ExclamationToken: + // no inferences here; + } + } + function inferTypeFromBinaryExpression(node, parent, usage) { + switch (parent.operatorToken.kind) { + // ExponentiationOperator + case 42 /* SyntaxKind.AsteriskAsteriskToken */: + // MultiplicativeOperator + // falls through + case 41 /* SyntaxKind.AsteriskToken */: + case 43 /* SyntaxKind.SlashToken */: + case 44 /* SyntaxKind.PercentToken */: + // ShiftOperator + // falls through + case 47 /* SyntaxKind.LessThanLessThanToken */: + case 48 /* SyntaxKind.GreaterThanGreaterThanToken */: + case 49 /* SyntaxKind.GreaterThanGreaterThanGreaterThanToken */: + // BitwiseOperator + // falls through + case 50 /* SyntaxKind.AmpersandToken */: + case 51 /* SyntaxKind.BarToken */: + case 52 /* SyntaxKind.CaretToken */: + // CompoundAssignmentOperator + // falls through + case 65 /* SyntaxKind.MinusEqualsToken */: + case 67 /* SyntaxKind.AsteriskAsteriskEqualsToken */: + case 66 /* SyntaxKind.AsteriskEqualsToken */: + case 68 /* SyntaxKind.SlashEqualsToken */: + case 69 /* SyntaxKind.PercentEqualsToken */: + case 73 /* SyntaxKind.AmpersandEqualsToken */: + case 74 /* SyntaxKind.BarEqualsToken */: + case 78 /* SyntaxKind.CaretEqualsToken */: + case 70 /* SyntaxKind.LessThanLessThanEqualsToken */: + case 72 /* SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken */: + case 71 /* SyntaxKind.GreaterThanGreaterThanEqualsToken */: + // AdditiveOperator + // falls through + case 40 /* SyntaxKind.MinusToken */: + // RelationalOperator + // falls through + case 29 /* SyntaxKind.LessThanToken */: + case 32 /* SyntaxKind.LessThanEqualsToken */: + case 31 /* SyntaxKind.GreaterThanToken */: + case 33 /* SyntaxKind.GreaterThanEqualsToken */: + var operandType = checker.getTypeAtLocation(parent.left === node ? parent.right : parent.left); + if (operandType.flags & 1056 /* TypeFlags.EnumLike */) { + addCandidateType(usage, operandType); + } + else { + usage.isNumber = true; + } + break; + case 64 /* SyntaxKind.PlusEqualsToken */: + case 39 /* SyntaxKind.PlusToken */: + var otherOperandType = checker.getTypeAtLocation(parent.left === node ? parent.right : parent.left); + if (otherOperandType.flags & 1056 /* TypeFlags.EnumLike */) { + addCandidateType(usage, otherOperandType); + } + else if (otherOperandType.flags & 296 /* TypeFlags.NumberLike */) { + usage.isNumber = true; + } + else if (otherOperandType.flags & 402653316 /* TypeFlags.StringLike */) { + usage.isString = true; + } + else if (otherOperandType.flags & 1 /* TypeFlags.Any */) { + // do nothing, maybe we'll learn something elsewhere + } + else { + usage.isNumberOrString = true; + } + break; + // AssignmentOperators + case 63 /* SyntaxKind.EqualsToken */: + case 34 /* SyntaxKind.EqualsEqualsToken */: + case 36 /* SyntaxKind.EqualsEqualsEqualsToken */: + case 37 /* SyntaxKind.ExclamationEqualsEqualsToken */: + case 35 /* SyntaxKind.ExclamationEqualsToken */: + addCandidateType(usage, checker.getTypeAtLocation(parent.left === node ? parent.right : parent.left)); + break; + case 101 /* SyntaxKind.InKeyword */: + if (node === parent.left) { + usage.isString = true; + } + break; + // LogicalOperator Or NullishCoalescing + case 56 /* SyntaxKind.BarBarToken */: + case 60 /* SyntaxKind.QuestionQuestionToken */: + if (node === parent.left && + (node.parent.parent.kind === 257 /* SyntaxKind.VariableDeclaration */ || ts.isAssignmentExpression(node.parent.parent, /*excludeCompoundAssignment*/ true))) { + // var x = x || {}; + // TODO: use getFalsyflagsOfType + addCandidateType(usage, checker.getTypeAtLocation(parent.right)); + } + break; + case 55 /* SyntaxKind.AmpersandAmpersandToken */: + case 27 /* SyntaxKind.CommaToken */: + case 102 /* SyntaxKind.InstanceOfKeyword */: + // nothing to infer here + break; + } + } + function inferTypeFromSwitchStatementLabel(parent, usage) { + addCandidateType(usage, checker.getTypeAtLocation(parent.parent.parent.expression)); + } + function inferTypeFromCallExpression(parent, usage) { + var call = { + argumentTypes: [], + return_: createEmptyUsage() + }; + if (parent.arguments) { + for (var _i = 0, _a = parent.arguments; _i < _a.length; _i++) { + var argument = _a[_i]; + call.argumentTypes.push(checker.getTypeAtLocation(argument)); + } + } + calculateUsageOfNode(parent, call.return_); + if (parent.kind === 210 /* SyntaxKind.CallExpression */) { + (usage.calls || (usage.calls = [])).push(call); + } + else { + (usage.constructs || (usage.constructs = [])).push(call); + } + } + function inferTypeFromPropertyAccessExpression(parent, usage) { + var name = ts.escapeLeadingUnderscores(parent.name.text); + if (!usage.properties) { + usage.properties = new ts.Map(); + } + var propertyUsage = usage.properties.get(name) || createEmptyUsage(); + calculateUsageOfNode(parent, propertyUsage); + usage.properties.set(name, propertyUsage); + } + function inferTypeFromPropertyElementExpression(parent, node, usage) { + if (node === parent.argumentExpression) { + usage.isNumberOrString = true; + return; + } + else { + var indexType = checker.getTypeAtLocation(parent.argumentExpression); + var indexUsage = createEmptyUsage(); + calculateUsageOfNode(parent, indexUsage); + if (indexType.flags & 296 /* TypeFlags.NumberLike */) { + usage.numberIndex = indexUsage; + } + else { + usage.stringIndex = indexUsage; + } + } + } + function inferTypeFromPropertyAssignment(assignment, usage) { + var nodeWithRealType = ts.isVariableDeclaration(assignment.parent.parent) ? + assignment.parent.parent : + assignment.parent; + addCandidateThisType(usage, checker.getTypeAtLocation(nodeWithRealType)); + } + function inferTypeFromPropertyDeclaration(declaration, usage) { + addCandidateThisType(usage, checker.getTypeAtLocation(declaration.parent)); + } + function removeLowPriorityInferences(inferences, priorities) { + var toRemove = []; + for (var _i = 0, inferences_1 = inferences; _i < inferences_1.length; _i++) { + var i = inferences_1[_i]; + for (var _a = 0, priorities_1 = priorities; _a < priorities_1.length; _a++) { + var _b = priorities_1[_a], high = _b.high, low = _b.low; + if (high(i)) { + ts.Debug.assert(!low(i), "Priority can't have both low and high"); + toRemove.push(low); + } + } + } + return inferences.filter(function (i) { return toRemove.every(function (f) { return !f(i); }); }); + } + function combineFromUsage(usage) { + return combineTypes(inferTypes(usage)); + } + function combineTypes(inferences) { + if (!inferences.length) + return checker.getAnyType(); + // 1. string or number individually override string | number + // 2. non-any, non-void overrides any or void + // 3. non-nullable, non-any, non-void, non-anonymous overrides anonymous types + var stringNumber = checker.getUnionType([checker.getStringType(), checker.getNumberType()]); + var priorities = [ + { + high: function (t) { return t === checker.getStringType() || t === checker.getNumberType(); }, + low: function (t) { return t === stringNumber; } + }, + { + high: function (t) { return !(t.flags & (1 /* TypeFlags.Any */ | 16384 /* TypeFlags.Void */)); }, + low: function (t) { return !!(t.flags & (1 /* TypeFlags.Any */ | 16384 /* TypeFlags.Void */)); } + }, + { + high: function (t) { return !(t.flags & (98304 /* TypeFlags.Nullable */ | 1 /* TypeFlags.Any */ | 16384 /* TypeFlags.Void */)) && !(ts.getObjectFlags(t) & 16 /* ObjectFlags.Anonymous */); }, + low: function (t) { return !!(ts.getObjectFlags(t) & 16 /* ObjectFlags.Anonymous */); } + } + ]; + var good = removeLowPriorityInferences(inferences, priorities); + var anons = good.filter(function (i) { return ts.getObjectFlags(i) & 16 /* ObjectFlags.Anonymous */; }); + if (anons.length) { + good = good.filter(function (i) { return !(ts.getObjectFlags(i) & 16 /* ObjectFlags.Anonymous */); }); + good.push(combineAnonymousTypes(anons)); + } + return checker.getWidenedType(checker.getUnionType(good.map(checker.getBaseTypeOfLiteralType), 2 /* UnionReduction.Subtype */)); + } + function combineAnonymousTypes(anons) { + if (anons.length === 1) { + return anons[0]; + } + var calls = []; + var constructs = []; + var stringIndices = []; + var numberIndices = []; + var stringIndexReadonly = false; + var numberIndexReadonly = false; + var props = ts.createMultiMap(); + for (var _i = 0, anons_1 = anons; _i < anons_1.length; _i++) { + var anon = anons_1[_i]; + for (var _a = 0, _b = checker.getPropertiesOfType(anon); _a < _b.length; _a++) { + var p = _b[_a]; + props.add(p.name, p.valueDeclaration ? checker.getTypeOfSymbolAtLocation(p, p.valueDeclaration) : checker.getAnyType()); + } + calls.push.apply(calls, checker.getSignaturesOfType(anon, 0 /* SignatureKind.Call */)); + constructs.push.apply(constructs, checker.getSignaturesOfType(anon, 1 /* SignatureKind.Construct */)); + var stringIndexInfo = checker.getIndexInfoOfType(anon, 0 /* IndexKind.String */); + if (stringIndexInfo) { + stringIndices.push(stringIndexInfo.type); + stringIndexReadonly = stringIndexReadonly || stringIndexInfo.isReadonly; + } + var numberIndexInfo = checker.getIndexInfoOfType(anon, 1 /* IndexKind.Number */); + if (numberIndexInfo) { + numberIndices.push(numberIndexInfo.type); + numberIndexReadonly = numberIndexReadonly || numberIndexInfo.isReadonly; + } + } + var members = ts.mapEntries(props, function (name, types) { + var isOptional = types.length < anons.length ? 16777216 /* SymbolFlags.Optional */ : 0; + var s = checker.createSymbol(4 /* SymbolFlags.Property */ | isOptional, name); + s.type = checker.getUnionType(types); + return [name, s]; + }); + var indexInfos = []; + if (stringIndices.length) + indexInfos.push(checker.createIndexInfo(checker.getStringType(), checker.getUnionType(stringIndices), stringIndexReadonly)); + if (numberIndices.length) + indexInfos.push(checker.createIndexInfo(checker.getNumberType(), checker.getUnionType(numberIndices), numberIndexReadonly)); + return checker.createAnonymousType(anons[0].symbol, members, calls, constructs, indexInfos); + } + function inferTypes(usage) { + var _a, _b, _c; + var types = []; + if (usage.isNumber) { + types.push(checker.getNumberType()); + } + if (usage.isString) { + types.push(checker.getStringType()); + } + if (usage.isNumberOrString) { + types.push(checker.getUnionType([checker.getStringType(), checker.getNumberType()])); + } + if (usage.numberIndex) { + types.push(checker.createArrayType(combineFromUsage(usage.numberIndex))); + } + if (((_a = usage.properties) === null || _a === void 0 ? void 0 : _a.size) || ((_b = usage.constructs) === null || _b === void 0 ? void 0 : _b.length) || usage.stringIndex) { + types.push(inferStructuralType(usage)); + } + var candidateTypes = (usage.candidateTypes || []).map(function (t) { return checker.getBaseTypeOfLiteralType(t); }); + var callsType = ((_c = usage.calls) === null || _c === void 0 ? void 0 : _c.length) ? inferStructuralType(usage) : undefined; + if (callsType && candidateTypes) { + types.push(checker.getUnionType(__spreadArray([callsType], candidateTypes, true), 2 /* UnionReduction.Subtype */)); + } + else { + if (callsType) { + types.push(callsType); + } + if (ts.length(candidateTypes)) { + types.push.apply(types, candidateTypes); + } + } + types.push.apply(types, inferNamedTypesFromProperties(usage)); + return types; + } + function inferStructuralType(usage) { + var members = new ts.Map(); + if (usage.properties) { + usage.properties.forEach(function (u, name) { + var symbol = checker.createSymbol(4 /* SymbolFlags.Property */, name); + symbol.type = combineFromUsage(u); + members.set(name, symbol); + }); + } + var callSignatures = usage.calls ? [getSignatureFromCalls(usage.calls)] : []; + var constructSignatures = usage.constructs ? [getSignatureFromCalls(usage.constructs)] : []; + var indexInfos = usage.stringIndex ? [checker.createIndexInfo(checker.getStringType(), combineFromUsage(usage.stringIndex), /*isReadonly*/ false)] : []; + return checker.createAnonymousType(/*symbol*/ undefined, members, callSignatures, constructSignatures, indexInfos); + } + function inferNamedTypesFromProperties(usage) { + if (!usage.properties || !usage.properties.size) + return []; + var types = builtins.filter(function (t) { return allPropertiesAreAssignableToUsage(t, usage); }); + if (0 < types.length && types.length < 3) { + return types.map(function (t) { return inferInstantiationFromUsage(t, usage); }); + } + return []; + } + function allPropertiesAreAssignableToUsage(type, usage) { + if (!usage.properties) + return false; + return !ts.forEachEntry(usage.properties, function (propUsage, name) { + var source = checker.getTypeOfPropertyOfType(type, name); + if (!source) { + return true; + } + if (propUsage.calls) { + var sigs = checker.getSignaturesOfType(source, 0 /* SignatureKind.Call */); + return !sigs.length || !checker.isTypeAssignableTo(source, getFunctionFromCalls(propUsage.calls)); + } + else { + return !checker.isTypeAssignableTo(source, combineFromUsage(propUsage)); + } + }); + } + /** + * inference is limited to + * 1. generic types with a single parameter + * 2. inference to/from calls with a single signature + */ + function inferInstantiationFromUsage(type, usage) { + if (!(ts.getObjectFlags(type) & 4 /* ObjectFlags.Reference */) || !usage.properties) { + return type; + } + var generic = type.target; + var singleTypeParameter = ts.singleOrUndefined(generic.typeParameters); + if (!singleTypeParameter) + return type; + var types = []; + usage.properties.forEach(function (propUsage, name) { + var genericPropertyType = checker.getTypeOfPropertyOfType(generic, name); + ts.Debug.assert(!!genericPropertyType, "generic should have all the properties of its reference."); + types.push.apply(types, inferTypeParameters(genericPropertyType, combineFromUsage(propUsage), singleTypeParameter)); + }); + return builtinConstructors[type.symbol.escapedName](combineTypes(types)); + } + function inferTypeParameters(genericType, usageType, typeParameter) { + if (genericType === typeParameter) { + return [usageType]; + } + else if (genericType.flags & 3145728 /* TypeFlags.UnionOrIntersection */) { + return ts.flatMap(genericType.types, function (t) { return inferTypeParameters(t, usageType, typeParameter); }); + } + else if (ts.getObjectFlags(genericType) & 4 /* ObjectFlags.Reference */ && ts.getObjectFlags(usageType) & 4 /* ObjectFlags.Reference */) { + // this is wrong because we need a reference to the targetType to, so we can check that it's also a reference + var genericArgs = checker.getTypeArguments(genericType); + var usageArgs = checker.getTypeArguments(usageType); + var types = []; + if (genericArgs && usageArgs) { + for (var i = 0; i < genericArgs.length; i++) { + if (usageArgs[i]) { + types.push.apply(types, inferTypeParameters(genericArgs[i], usageArgs[i], typeParameter)); + } + } + } + return types; + } + var genericSigs = checker.getSignaturesOfType(genericType, 0 /* SignatureKind.Call */); + var usageSigs = checker.getSignaturesOfType(usageType, 0 /* SignatureKind.Call */); + if (genericSigs.length === 1 && usageSigs.length === 1) { + return inferFromSignatures(genericSigs[0], usageSigs[0], typeParameter); + } + return []; + } + function inferFromSignatures(genericSig, usageSig, typeParameter) { + var types = []; + for (var i = 0; i < genericSig.parameters.length; i++) { + var genericParam = genericSig.parameters[i]; + var usageParam = usageSig.parameters[i]; + var isRest = genericSig.declaration && ts.isRestParameter(genericSig.declaration.parameters[i]); + if (!usageParam) { + break; + } + var genericParamType = genericParam.valueDeclaration ? checker.getTypeOfSymbolAtLocation(genericParam, genericParam.valueDeclaration) : checker.getAnyType(); + var elementType = isRest && checker.getElementTypeOfArrayType(genericParamType); + if (elementType) { + genericParamType = elementType; + } + var targetType = usageParam.type + || (usageParam.valueDeclaration ? checker.getTypeOfSymbolAtLocation(usageParam, usageParam.valueDeclaration) : checker.getAnyType()); + types.push.apply(types, inferTypeParameters(genericParamType, targetType, typeParameter)); + } + var genericReturn = checker.getReturnTypeOfSignature(genericSig); + var usageReturn = checker.getReturnTypeOfSignature(usageSig); + types.push.apply(types, inferTypeParameters(genericReturn, usageReturn, typeParameter)); + return types; + } + function getFunctionFromCalls(calls) { + return checker.createAnonymousType(/*symbol*/ undefined, ts.createSymbolTable(), [getSignatureFromCalls(calls)], ts.emptyArray, ts.emptyArray); + } + function getSignatureFromCalls(calls) { + var parameters = []; + var length = Math.max.apply(Math, calls.map(function (c) { return c.argumentTypes.length; })); + var _loop_14 = function (i) { + var symbol = checker.createSymbol(1 /* SymbolFlags.FunctionScopedVariable */, ts.escapeLeadingUnderscores("arg".concat(i))); + symbol.type = combineTypes(calls.map(function (call) { return call.argumentTypes[i] || checker.getUndefinedType(); })); + if (calls.some(function (call) { return call.argumentTypes[i] === undefined; })) { + symbol.flags |= 16777216 /* SymbolFlags.Optional */; + } + parameters.push(symbol); + }; + for (var i = 0; i < length; i++) { + _loop_14(i); + } + var returnType = combineFromUsage(combineUsages(calls.map(function (call) { return call.return_; }))); + return checker.createSignature(/*declaration*/ undefined, /*typeParameters*/ undefined, /*thisParameter*/ undefined, parameters, returnType, /*typePredicate*/ undefined, length, 0 /* SignatureFlags.None */); + } + function addCandidateType(usage, type) { + if (type && !(type.flags & 1 /* TypeFlags.Any */) && !(type.flags & 131072 /* TypeFlags.Never */)) { + (usage.candidateTypes || (usage.candidateTypes = [])).push(type); + } + } + function addCandidateThisType(usage, type) { + if (type && !(type.flags & 1 /* TypeFlags.Any */) && !(type.flags & 131072 /* TypeFlags.Never */)) { + (usage.candidateThisTypes || (usage.candidateThisTypes = [])).push(type); + } + } + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "fixReturnTypeInAsyncFunction"; + var errorCodes = [ + ts.Diagnostics.The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_Did_you_mean_to_write_Promise_0.code, + ]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + fixIds: [fixId], + getCodeActions: function getCodeActionsToFixReturnTypeInAsyncFunction(context) { + var sourceFile = context.sourceFile, program = context.program, span = context.span; + var checker = program.getTypeChecker(); + var info = getInfo(sourceFile, program.getTypeChecker(), span.start); + if (!info) { + return undefined; + } + var returnTypeNode = info.returnTypeNode, returnType = info.returnType, promisedTypeNode = info.promisedTypeNode, promisedType = info.promisedType; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, sourceFile, returnTypeNode, promisedTypeNode); }); + return [codefix.createCodeFixAction(fixId, changes, [ts.Diagnostics.Replace_0_with_Promise_1, + checker.typeToString(returnType), checker.typeToString(promisedType)], fixId, ts.Diagnostics.Fix_all_incorrect_return_type_of_an_async_functions)]; + }, + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var info = getInfo(diag.file, context.program.getTypeChecker(), diag.start); + if (info) { + doChange(changes, diag.file, info.returnTypeNode, info.promisedTypeNode); + } + }); } + }); + function getInfo(sourceFile, checker, pos) { + if (ts.isInJSFile(sourceFile)) { + return undefined; + } + var token = ts.getTokenAtPosition(sourceFile, pos); + var func = ts.findAncestor(token, ts.isFunctionLikeDeclaration); + var returnTypeNode = func === null || func === void 0 ? void 0 : func.type; + if (!returnTypeNode) { + return undefined; + } + var returnType = checker.getTypeFromTypeNode(returnTypeNode); + var promisedType = checker.getAwaitedType(returnType) || checker.getVoidType(); + var promisedTypeNode = checker.typeToTypeNode(promisedType, /*enclosingDeclaration*/ returnTypeNode, /*flags*/ undefined); + if (promisedTypeNode) { + return { returnTypeNode: returnTypeNode, returnType: returnType, promisedTypeNode: promisedTypeNode, promisedType: promisedType }; + } + } + function doChange(changes, sourceFile, returnTypeNode, promisedTypeNode) { + changes.replaceNode(sourceFile, returnTypeNode, ts.factory.createTypeReferenceNode("Promise", [promisedTypeNode])); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixName = "disableJsDiagnostics"; + var fixId = "disableJsDiagnostics"; + var errorCodes = ts.mapDefined(Object.keys(ts.Diagnostics), function (key) { + var diag = ts.Diagnostics[key]; + return diag.category === ts.DiagnosticCategory.Error ? diag.code : undefined; + }); + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function getCodeActionsToDisableJsDiagnostics(context) { + var sourceFile = context.sourceFile, program = context.program, span = context.span, host = context.host, formatContext = context.formatContext; + if (!ts.isInJSFile(sourceFile) || !ts.isCheckJsEnabledForFile(sourceFile, program.getCompilerOptions())) { + return undefined; + } + var newLineCharacter = sourceFile.checkJsDirective ? "" : ts.getNewLineOrDefaultFromHost(host, formatContext.options); + var fixes = [ + // fixId unnecessary because adding `// @ts-nocheck` even once will ignore every error in the file. + codefix.createCodeFixActionWithoutFixAll(fixName, [codefix.createFileTextChanges(sourceFile.fileName, [ + ts.createTextChange(sourceFile.checkJsDirective + ? ts.createTextSpanFromBounds(sourceFile.checkJsDirective.pos, sourceFile.checkJsDirective.end) + : ts.createTextSpan(0, 0), "// @ts-nocheck".concat(newLineCharacter)), + ])], ts.Diagnostics.Disable_checking_for_this_file), + ]; + if (ts.textChanges.isValidLocationToAddComment(sourceFile, span.start)) { + fixes.unshift(codefix.createCodeFixAction(fixName, ts.textChanges.ChangeTracker.with(context, function (t) { return makeChange(t, sourceFile, span.start); }), ts.Diagnostics.Ignore_this_error_message, fixId, ts.Diagnostics.Add_ts_ignore_to_all_error_messages)); + } + return fixes; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { + var seenLines = new ts.Set(); + return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + if (ts.textChanges.isValidLocationToAddComment(diag.file, diag.start)) { + makeChange(changes, diag.file, diag.start, seenLines); + } + }); + }, + }); + function makeChange(changes, sourceFile, position, seenLines) { + var lineNumber = ts.getLineAndCharacterOfPosition(sourceFile, position).line; + // Only need to add `// @ts-ignore` for a line once. + if (!seenLines || ts.tryAddToSet(seenLines, lineNumber)) { + changes.insertCommentBeforeLine(sourceFile, lineNumber, position, " @ts-ignore"); + } + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + /** + * Finds members of the resolved type that are missing in the class pointed to by class decl + * and generates source code for the missing members. + * @param possiblyMissingSymbols The collection of symbols to filter and then get insertions for. + * @param importAdder If provided, type annotations will use identifier type references instead of ImportTypeNodes, and the missing imports will be added to the importAdder. + * @returns Empty string iff there are no member insertions. + */ + function createMissingMemberNodes(classDeclaration, possiblyMissingSymbols, sourceFile, context, preferences, importAdder, addClassElement) { + var classMembers = classDeclaration.symbol.members; + for (var _i = 0, possiblyMissingSymbols_1 = possiblyMissingSymbols; _i < possiblyMissingSymbols_1.length; _i++) { + var symbol = possiblyMissingSymbols_1[_i]; + if (!classMembers.has(symbol.escapedName)) { + addNewNodeForMemberSymbol(symbol, classDeclaration, sourceFile, context, preferences, importAdder, addClassElement, /* body */ undefined); + } + } + } + codefix.createMissingMemberNodes = createMissingMemberNodes; + function getNoopSymbolTrackerWithResolver(context) { + return { + trackSymbol: function () { return false; }, + moduleResolverHost: ts.getModuleSpecifierResolverHost(context.program, context.host), + }; + } + codefix.getNoopSymbolTrackerWithResolver = getNoopSymbolTrackerWithResolver; + var PreserveOptionalFlags; + (function (PreserveOptionalFlags) { + PreserveOptionalFlags[PreserveOptionalFlags["Method"] = 1] = "Method"; + PreserveOptionalFlags[PreserveOptionalFlags["Property"] = 2] = "Property"; + PreserveOptionalFlags[PreserveOptionalFlags["All"] = 3] = "All"; + })(PreserveOptionalFlags = codefix.PreserveOptionalFlags || (codefix.PreserveOptionalFlags = {})); + /** + * `addClassElement` will not be called if we can't figure out a representation for `symbol` in `enclosingDeclaration`. + * @param body If defined, this will be the body of the member node passed to `addClassElement`. Otherwise, the body will default to a stub. + */ + function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, context, preferences, importAdder, addClassElement, body, preserveOptional, isAmbient) { + var _a; + if (preserveOptional === void 0) { preserveOptional = 3 /* PreserveOptionalFlags.All */; } + if (isAmbient === void 0) { isAmbient = false; } + var declarations = symbol.getDeclarations(); + var declaration = declarations === null || declarations === void 0 ? void 0 : declarations[0]; + var checker = context.program.getTypeChecker(); + var scriptTarget = ts.getEmitScriptTarget(context.program.getCompilerOptions()); + /** + * (#49811) + * Note that there are cases in which the symbol declaration is not present. For example, in the code below both + * `MappedIndirect.ax` and `MappedIndirect.ay` have no declaration node attached (due to their mapped-type + * parent): + * + * ```ts + * type Base = { ax: number; ay: string }; + * type BaseKeys = keyof Base; + * type MappedIndirect = { [K in BaseKeys]: boolean }; + * ``` + * + * In such cases, we assume the declaration to be a `PropertySignature`. + */ + var kind = (_a = declaration === null || declaration === void 0 ? void 0 : declaration.kind) !== null && _a !== void 0 ? _a : 168 /* SyntaxKind.PropertySignature */; + var declarationName = ts.getSynthesizedDeepClone(ts.getNameOfDeclaration(declaration), /*includeTrivia*/ false); + var effectiveModifierFlags = declaration ? ts.getEffectiveModifierFlags(declaration) : 0 /* ModifierFlags.None */; + var modifierFlags = effectiveModifierFlags & 4 /* ModifierFlags.Public */ ? 4 /* ModifierFlags.Public */ : + effectiveModifierFlags & 16 /* ModifierFlags.Protected */ ? 16 /* ModifierFlags.Protected */ : + 0 /* ModifierFlags.None */; + if (declaration && ts.isAutoAccessorPropertyDeclaration(declaration)) { + modifierFlags |= 128 /* ModifierFlags.Accessor */; + } + var modifiers = modifierFlags ? ts.factory.createNodeArray(ts.factory.createModifiersFromModifierFlags(modifierFlags)) : undefined; + var type = checker.getWidenedType(checker.getTypeOfSymbolAtLocation(symbol, enclosingDeclaration)); + var optional = !!(symbol.flags & 16777216 /* SymbolFlags.Optional */); + var ambient = !!(enclosingDeclaration.flags & 16777216 /* NodeFlags.Ambient */) || isAmbient; + var quotePreference = ts.getQuotePreference(sourceFile, preferences); + switch (kind) { + case 168 /* SyntaxKind.PropertySignature */: + case 169 /* SyntaxKind.PropertyDeclaration */: + var flags = quotePreference === 0 /* QuotePreference.Single */ ? 268435456 /* NodeBuilderFlags.UseSingleQuotesForStringLiteralType */ : undefined; + var typeNode = checker.typeToTypeNode(type, enclosingDeclaration, flags, getNoopSymbolTrackerWithResolver(context)); + if (importAdder) { + var importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget); + if (importableReference) { + typeNode = importableReference.typeNode; + importSymbols(importAdder, importableReference.symbols); + } + } + addClassElement(ts.factory.createPropertyDeclaration(modifiers, declaration ? createName(declarationName) : symbol.getName(), optional && (preserveOptional & 2 /* PreserveOptionalFlags.Property */) ? ts.factory.createToken(57 /* SyntaxKind.QuestionToken */) : undefined, typeNode, + /*initializer*/ undefined)); + break; + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: { + ts.Debug.assertIsDefined(declarations); + var typeNode_1 = checker.typeToTypeNode(type, enclosingDeclaration, /*flags*/ undefined, getNoopSymbolTrackerWithResolver(context)); + var allAccessors = ts.getAllAccessorDeclarations(declarations, declaration); + var orderedAccessors = allAccessors.secondAccessor + ? [allAccessors.firstAccessor, allAccessors.secondAccessor] + : [allAccessors.firstAccessor]; + if (importAdder) { + var importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode_1, scriptTarget); + if (importableReference) { + typeNode_1 = importableReference.typeNode; + importSymbols(importAdder, importableReference.symbols); + } + } + for (var _i = 0, orderedAccessors_1 = orderedAccessors; _i < orderedAccessors_1.length; _i++) { + var accessor = orderedAccessors_1[_i]; + if (ts.isGetAccessorDeclaration(accessor)) { + addClassElement(ts.factory.createGetAccessorDeclaration(modifiers, createName(declarationName), ts.emptyArray, createTypeNode(typeNode_1), createBody(body, quotePreference, ambient))); + } + else { + ts.Debug.assertNode(accessor, ts.isSetAccessorDeclaration, "The counterpart to a getter should be a setter"); + var parameter = ts.getSetAccessorValueParameter(accessor); + var parameterName = parameter && ts.isIdentifier(parameter.name) ? ts.idText(parameter.name) : undefined; + addClassElement(ts.factory.createSetAccessorDeclaration(modifiers, createName(declarationName), createDummyParameters(1, [parameterName], [createTypeNode(typeNode_1)], 1, /*inJs*/ false), createBody(body, quotePreference, ambient))); + } + } + break; + } + case 170 /* SyntaxKind.MethodSignature */: + case 171 /* SyntaxKind.MethodDeclaration */: + // The signature for the implementation appears as an entry in `signatures` iff + // there is only one signature. + // If there are overloads and an implementation signature, it appears as an + // extra declaration that isn't a signature for `type`. + // If there is more than one overload but no implementation signature + // (eg: an abstract method or interface declaration), there is a 1-1 + // correspondence of declarations and signatures. + ts.Debug.assertIsDefined(declarations); + var signatures = type.isUnion() ? ts.flatMap(type.types, function (t) { return t.getCallSignatures(); }) : type.getCallSignatures(); + if (!ts.some(signatures)) { + break; + } + if (declarations.length === 1) { + ts.Debug.assert(signatures.length === 1, "One declaration implies one signature"); + var signature = signatures[0]; + outputMethod(quotePreference, signature, modifiers, createName(declarationName), createBody(body, quotePreference, ambient)); + break; + } + for (var _b = 0, signatures_1 = signatures; _b < signatures_1.length; _b++) { + var signature = signatures_1[_b]; + // Ensure nodes are fresh so they can have different positions when going through formatting. + outputMethod(quotePreference, signature, modifiers, createName(declarationName)); + } + if (!ambient) { + if (declarations.length > signatures.length) { + var signature = checker.getSignatureFromDeclaration(declarations[declarations.length - 1]); + outputMethod(quotePreference, signature, modifiers, createName(declarationName), createBody(body, quotePreference)); + } + else { + ts.Debug.assert(declarations.length === signatures.length, "Declarations and signatures should match count"); + addClassElement(createMethodImplementingSignatures(checker, context, enclosingDeclaration, signatures, createName(declarationName), optional && !!(preserveOptional & 1 /* PreserveOptionalFlags.Method */), modifiers, quotePreference, body)); + } + } + break; + } + function outputMethod(quotePreference, signature, modifiers, name, body) { + var method = createSignatureDeclarationFromSignature(171 /* SyntaxKind.MethodDeclaration */, context, quotePreference, signature, body, name, modifiers, optional && !!(preserveOptional & 1 /* PreserveOptionalFlags.Method */), enclosingDeclaration, importAdder); + if (method) + addClassElement(method); + } + function createName(node) { + return ts.getSynthesizedDeepClone(node, /*includeTrivia*/ false); + } + function createBody(block, quotePreference, ambient) { + return ambient ? undefined : + ts.getSynthesizedDeepClone(block, /*includeTrivia*/ false) || createStubbedMethodBody(quotePreference); + } + function createTypeNode(typeNode) { + return ts.getSynthesizedDeepClone(typeNode, /*includeTrivia*/ false); + } + } + codefix.addNewNodeForMemberSymbol = addNewNodeForMemberSymbol; + function createSignatureDeclarationFromSignature(kind, context, quotePreference, signature, body, name, modifiers, optional, enclosingDeclaration, importAdder) { + var program = context.program; + var checker = program.getTypeChecker(); + var scriptTarget = ts.getEmitScriptTarget(program.getCompilerOptions()); + var flags = 1 /* NodeBuilderFlags.NoTruncation */ + | 256 /* NodeBuilderFlags.SuppressAnyReturnType */ + | 524288 /* NodeBuilderFlags.AllowEmptyTuple */ + | (quotePreference === 0 /* QuotePreference.Single */ ? 268435456 /* NodeBuilderFlags.UseSingleQuotesForStringLiteralType */ : 0 /* NodeBuilderFlags.None */); + var signatureDeclaration = checker.signatureToSignatureDeclaration(signature, kind, enclosingDeclaration, flags, getNoopSymbolTrackerWithResolver(context)); + if (!signatureDeclaration) { + return undefined; + } + var typeParameters = signatureDeclaration.typeParameters; + var parameters = signatureDeclaration.parameters; + var type = signatureDeclaration.type; + if (importAdder) { + if (typeParameters) { + var newTypeParameters = ts.sameMap(typeParameters, function (typeParameterDecl) { + var constraint = typeParameterDecl.constraint; + var defaultType = typeParameterDecl.default; + if (constraint) { + var importableReference = tryGetAutoImportableReferenceFromTypeNode(constraint, scriptTarget); + if (importableReference) { + constraint = importableReference.typeNode; + importSymbols(importAdder, importableReference.symbols); + } + } + if (defaultType) { + var importableReference = tryGetAutoImportableReferenceFromTypeNode(defaultType, scriptTarget); + if (importableReference) { + defaultType = importableReference.typeNode; + importSymbols(importAdder, importableReference.symbols); + } + } + return ts.factory.updateTypeParameterDeclaration(typeParameterDecl, typeParameterDecl.modifiers, typeParameterDecl.name, constraint, defaultType); + }); + if (typeParameters !== newTypeParameters) { + typeParameters = ts.setTextRange(ts.factory.createNodeArray(newTypeParameters, typeParameters.hasTrailingComma), typeParameters); + } + } + var newParameters = ts.sameMap(parameters, function (parameterDecl) { + var importableReference = tryGetAutoImportableReferenceFromTypeNode(parameterDecl.type, scriptTarget); + var type = parameterDecl.type; + if (importableReference) { + type = importableReference.typeNode; + importSymbols(importAdder, importableReference.symbols); + } + return ts.factory.updateParameterDeclaration(parameterDecl, parameterDecl.modifiers, parameterDecl.dotDotDotToken, parameterDecl.name, parameterDecl.questionToken, type, parameterDecl.initializer); + }); + if (parameters !== newParameters) { + parameters = ts.setTextRange(ts.factory.createNodeArray(newParameters, parameters.hasTrailingComma), parameters); + } + if (type) { + var importableReference = tryGetAutoImportableReferenceFromTypeNode(type, scriptTarget); + if (importableReference) { + type = importableReference.typeNode; + importSymbols(importAdder, importableReference.symbols); + } + } + } + var questionToken = optional ? ts.factory.createToken(57 /* SyntaxKind.QuestionToken */) : undefined; + var asteriskToken = signatureDeclaration.asteriskToken; + if (ts.isFunctionExpression(signatureDeclaration)) { + return ts.factory.updateFunctionExpression(signatureDeclaration, modifiers, signatureDeclaration.asteriskToken, ts.tryCast(name, ts.isIdentifier), typeParameters, parameters, type, body !== null && body !== void 0 ? body : signatureDeclaration.body); + } + if (ts.isArrowFunction(signatureDeclaration)) { + return ts.factory.updateArrowFunction(signatureDeclaration, modifiers, typeParameters, parameters, type, signatureDeclaration.equalsGreaterThanToken, body !== null && body !== void 0 ? body : signatureDeclaration.body); + } + if (ts.isMethodDeclaration(signatureDeclaration)) { + return ts.factory.updateMethodDeclaration(signatureDeclaration, modifiers, asteriskToken, name !== null && name !== void 0 ? name : ts.factory.createIdentifier(""), questionToken, typeParameters, parameters, type, body); + } + if (ts.isFunctionDeclaration(signatureDeclaration)) { + return ts.factory.updateFunctionDeclaration(signatureDeclaration, modifiers, signatureDeclaration.asteriskToken, ts.tryCast(name, ts.isIdentifier), typeParameters, parameters, type, body !== null && body !== void 0 ? body : signatureDeclaration.body); + } + return undefined; + } + codefix.createSignatureDeclarationFromSignature = createSignatureDeclarationFromSignature; + function createSignatureDeclarationFromCallExpression(kind, context, importAdder, call, name, modifierFlags, contextNode) { + var quotePreference = ts.getQuotePreference(context.sourceFile, context.preferences); + var scriptTarget = ts.getEmitScriptTarget(context.program.getCompilerOptions()); + var tracker = getNoopSymbolTrackerWithResolver(context); + var checker = context.program.getTypeChecker(); + var isJs = ts.isInJSFile(contextNode); + var typeArguments = call.typeArguments, args = call.arguments, parent = call.parent; + var contextualType = isJs ? undefined : checker.getContextualType(call); + var names = ts.map(args, function (arg) { + return ts.isIdentifier(arg) ? arg.text : ts.isPropertyAccessExpression(arg) && ts.isIdentifier(arg.name) ? arg.name.text : undefined; + }); + var instanceTypes = isJs ? [] : ts.map(args, function (arg) { return checker.getTypeAtLocation(arg); }); + var _a = getArgumentTypesAndTypeParameters(checker, importAdder, instanceTypes, contextNode, scriptTarget, /*flags*/ undefined, tracker), argumentTypeNodes = _a.argumentTypeNodes, argumentTypeParameters = _a.argumentTypeParameters; + var modifiers = modifierFlags + ? ts.factory.createNodeArray(ts.factory.createModifiersFromModifierFlags(modifierFlags)) + : undefined; + var asteriskToken = ts.isYieldExpression(parent) + ? ts.factory.createToken(41 /* SyntaxKind.AsteriskToken */) + : undefined; + var typeParameters = isJs ? undefined : createTypeParametersForArguments(checker, argumentTypeParameters, typeArguments); + var parameters = createDummyParameters(args.length, names, argumentTypeNodes, /*minArgumentCount*/ undefined, isJs); + var type = isJs || contextualType === undefined + ? undefined + : checker.typeToTypeNode(contextualType, contextNode, /*flags*/ undefined, tracker); + switch (kind) { + case 171 /* SyntaxKind.MethodDeclaration */: + return ts.factory.createMethodDeclaration(modifiers, asteriskToken, name, + /*questionToken*/ undefined, typeParameters, parameters, type, createStubbedMethodBody(quotePreference)); + case 170 /* SyntaxKind.MethodSignature */: + return ts.factory.createMethodSignature(modifiers, name, + /*questionToken*/ undefined, typeParameters, parameters, type === undefined ? ts.factory.createKeywordTypeNode(157 /* SyntaxKind.UnknownKeyword */) : type); + case 259 /* SyntaxKind.FunctionDeclaration */: + return ts.factory.createFunctionDeclaration(modifiers, asteriskToken, name, typeParameters, parameters, type, createStubbedBody(ts.Diagnostics.Function_not_implemented.message, quotePreference)); + default: + ts.Debug.fail("Unexpected kind"); + } + } + codefix.createSignatureDeclarationFromCallExpression = createSignatureDeclarationFromCallExpression; + function createTypeParametersForArguments(checker, argumentTypeParameters, typeArguments) { + var usedNames = new ts.Set(argumentTypeParameters.map(function (pair) { return pair[0]; })); + var constraintsByName = new ts.Map(argumentTypeParameters); + if (typeArguments) { + var typeArgumentsWithNewTypes = typeArguments.filter(function (typeArgument) { return !argumentTypeParameters.some(function (pair) { var _a; return checker.getTypeAtLocation(typeArgument) === ((_a = pair[1]) === null || _a === void 0 ? void 0 : _a.argumentType); }); }); + var targetSize = usedNames.size + typeArgumentsWithNewTypes.length; + for (var i = 0; usedNames.size < targetSize; i += 1) { + usedNames.add(createTypeParameterName(i)); + } + } + return ts.map(ts.arrayFrom(usedNames.values()), function (usedName) { var _a; return ts.factory.createTypeParameterDeclaration(/*modifiers*/ undefined, usedName, (_a = constraintsByName.get(usedName)) === null || _a === void 0 ? void 0 : _a.constraint); }); + } + function createTypeParameterName(index) { + return 84 /* CharacterCodes.T */ + index <= 90 /* CharacterCodes.Z */ + ? String.fromCharCode(84 /* CharacterCodes.T */ + index) + : "T".concat(index); + } + function typeToAutoImportableTypeNode(checker, importAdder, type, contextNode, scriptTarget, flags, tracker) { + var typeNode = checker.typeToTypeNode(type, contextNode, flags, tracker); + if (typeNode && ts.isImportTypeNode(typeNode)) { + var importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget); + if (importableReference) { + importSymbols(importAdder, importableReference.symbols); + typeNode = importableReference.typeNode; + } + } + // Ensure nodes are fresh so they can have different positions when going through formatting. + return ts.getSynthesizedDeepClone(typeNode); + } + codefix.typeToAutoImportableTypeNode = typeToAutoImportableTypeNode; + function typeContainsTypeParameter(type) { + if (type.isUnionOrIntersection()) { + return type.types.some(typeContainsTypeParameter); + } + return type.flags & 262144 /* TypeFlags.TypeParameter */; + } + function getArgumentTypesAndTypeParameters(checker, importAdder, instanceTypes, contextNode, scriptTarget, flags, tracker) { + // Types to be used as the types of the parameters in the new function + // E.g. from this source: + // added("", 0) + // The value will look like: + // [{ typeName: { text: "string" } }, { typeName: { text: "number" }] + // And in the output function will generate: + // function added(a: string, b: number) { ... } + var argumentTypeNodes = []; + // Names of type parameters provided as arguments to the call + // E.g. from this source: + // added(value); + // The value will look like: + // [ + // ["T", { argumentType: { typeName: { text: "T" } } } ], + // ["U", { argumentType: { typeName: { text: "U" } } } ], + // ] + // And in the output function will generate: + // function added() { ... } + var argumentTypeParameters = new ts.Map(); + for (var i = 0; i < instanceTypes.length; i += 1) { + var instanceType = instanceTypes[i]; + // If the instance type contains a deep reference to an existing type parameter, + // instead of copying the full union or intersection, create a new type parameter + // E.g. from this source: + // function existing(value: T | U & string) { + // added/*1*/(value); + // We don't want to output this: + // function added(value: T | U & string) { ... } + // We instead want to output: + // function added(value: T) { ... } + if (instanceType.isUnionOrIntersection() && instanceType.types.some(typeContainsTypeParameter)) { + var synthesizedTypeParameterName = createTypeParameterName(i); + argumentTypeNodes.push(ts.factory.createTypeReferenceNode(synthesizedTypeParameterName)); + argumentTypeParameters.set(synthesizedTypeParameterName, undefined); + continue; + } + // Widen the type so we don't emit nonsense annotations like "function fn(x: 3) {" + var widenedInstanceType = checker.getBaseTypeOfLiteralType(instanceType); + var argumentTypeNode = typeToAutoImportableTypeNode(checker, importAdder, widenedInstanceType, contextNode, scriptTarget, flags, tracker); + if (!argumentTypeNode) { + continue; + } + argumentTypeNodes.push(argumentTypeNode); + var argumentTypeParameter = getFirstTypeParameterName(instanceType); + // If the instance type is a type parameter with a constraint (other than an anonymous object), + // remember that constraint for when we create the new type parameter + // E.g. from this source: + // function existing(value: T) { + // added/*1*/(value); + // We don't want to output this: + // function added(value: T) { ... } + // We instead want to output: + // function added(value: T) { ... } + var instanceTypeConstraint = instanceType.isTypeParameter() && instanceType.constraint && !isAnonymousObjectConstraintType(instanceType.constraint) + ? typeToAutoImportableTypeNode(checker, importAdder, instanceType.constraint, contextNode, scriptTarget, flags, tracker) + : undefined; + if (argumentTypeParameter) { + argumentTypeParameters.set(argumentTypeParameter, { argumentType: instanceType, constraint: instanceTypeConstraint }); + } + } + return { argumentTypeNodes: argumentTypeNodes, argumentTypeParameters: ts.arrayFrom(argumentTypeParameters.entries()) }; + } + codefix.getArgumentTypesAndTypeParameters = getArgumentTypesAndTypeParameters; + function isAnonymousObjectConstraintType(type) { + return (type.flags & 524288 /* TypeFlags.Object */) && type.objectFlags === 16 /* ObjectFlags.Anonymous */; + } + function getFirstTypeParameterName(type) { + var _a; + if (type.flags & (1048576 /* TypeFlags.Union */ | 2097152 /* TypeFlags.Intersection */)) { + for (var _i = 0, _b = type.types; _i < _b.length; _i++) { + var subType = _b[_i]; + var subTypeName = getFirstTypeParameterName(subType); + if (subTypeName) { + return subTypeName; + } + } + } + return type.flags & 262144 /* TypeFlags.TypeParameter */ + ? (_a = type.getSymbol()) === null || _a === void 0 ? void 0 : _a.getName() + : undefined; + } + function createDummyParameters(argCount, names, types, minArgumentCount, inJs) { + var parameters = []; + var parameterNameCounts = new ts.Map(); + for (var i = 0; i < argCount; i++) { + var parameterName = (names === null || names === void 0 ? void 0 : names[i]) || "arg".concat(i); + var parameterNameCount = parameterNameCounts.get(parameterName); + parameterNameCounts.set(parameterName, (parameterNameCount || 0) + 1); + var newParameter = ts.factory.createParameterDeclaration( + /*modifiers*/ undefined, + /*dotDotDotToken*/ undefined, + /*name*/ parameterName + (parameterNameCount || ""), + /*questionToken*/ minArgumentCount !== undefined && i >= minArgumentCount ? ts.factory.createToken(57 /* SyntaxKind.QuestionToken */) : undefined, + /*type*/ inJs ? undefined : (types === null || types === void 0 ? void 0 : types[i]) || ts.factory.createKeywordTypeNode(157 /* SyntaxKind.UnknownKeyword */), + /*initializer*/ undefined); + parameters.push(newParameter); + } + return parameters; + } + function createMethodImplementingSignatures(checker, context, enclosingDeclaration, signatures, name, optional, modifiers, quotePreference, body) { + /** This is *a* signature with the maximal number of arguments, + * such that if there is a "maximal" signature without rest arguments, + * this is one of them. + */ + var maxArgsSignature = signatures[0]; + var minArgumentCount = signatures[0].minArgumentCount; + var someSigHasRestParameter = false; + for (var _i = 0, signatures_2 = signatures; _i < signatures_2.length; _i++) { + var sig = signatures_2[_i]; + minArgumentCount = Math.min(sig.minArgumentCount, minArgumentCount); + if (ts.signatureHasRestParameter(sig)) { + someSigHasRestParameter = true; + } + if (sig.parameters.length >= maxArgsSignature.parameters.length && (!ts.signatureHasRestParameter(sig) || ts.signatureHasRestParameter(maxArgsSignature))) { + maxArgsSignature = sig; + } + } + var maxNonRestArgs = maxArgsSignature.parameters.length - (ts.signatureHasRestParameter(maxArgsSignature) ? 1 : 0); + var maxArgsParameterSymbolNames = maxArgsSignature.parameters.map(function (symbol) { return symbol.name; }); + var parameters = createDummyParameters(maxNonRestArgs, maxArgsParameterSymbolNames, /* types */ undefined, minArgumentCount, /*inJs*/ false); + if (someSigHasRestParameter) { + var restParameter = ts.factory.createParameterDeclaration( + /*modifiers*/ undefined, ts.factory.createToken(25 /* SyntaxKind.DotDotDotToken */), maxArgsParameterSymbolNames[maxNonRestArgs] || "rest", + /*questionToken*/ maxNonRestArgs >= minArgumentCount ? ts.factory.createToken(57 /* SyntaxKind.QuestionToken */) : undefined, ts.factory.createArrayTypeNode(ts.factory.createKeywordTypeNode(157 /* SyntaxKind.UnknownKeyword */)), + /*initializer*/ undefined); + parameters.push(restParameter); + } + return createStubbedMethod(modifiers, name, optional, + /*typeParameters*/ undefined, parameters, getReturnTypeFromSignatures(signatures, checker, context, enclosingDeclaration), quotePreference, body); + } + function getReturnTypeFromSignatures(signatures, checker, context, enclosingDeclaration) { + if (ts.length(signatures)) { + var type = checker.getUnionType(ts.map(signatures, checker.getReturnTypeOfSignature)); + return checker.typeToTypeNode(type, enclosingDeclaration, /*flags*/ undefined, getNoopSymbolTrackerWithResolver(context)); + } + } + function createStubbedMethod(modifiers, name, optional, typeParameters, parameters, returnType, quotePreference, body) { + return ts.factory.createMethodDeclaration(modifiers, + /*asteriskToken*/ undefined, name, optional ? ts.factory.createToken(57 /* SyntaxKind.QuestionToken */) : undefined, typeParameters, parameters, returnType, body || createStubbedMethodBody(quotePreference)); + } + function createStubbedMethodBody(quotePreference) { + return createStubbedBody(ts.Diagnostics.Method_not_implemented.message, quotePreference); + } + function createStubbedBody(text, quotePreference) { + return ts.factory.createBlock([ts.factory.createThrowStatement(ts.factory.createNewExpression(ts.factory.createIdentifier("Error"), + /*typeArguments*/ undefined, + // TODO Handle auto quote preference. + [ts.factory.createStringLiteral(text, /*isSingleQuote*/ quotePreference === 0 /* QuotePreference.Single */)]))], + /*multiline*/ true); + } + codefix.createStubbedBody = createStubbedBody; + function setJsonCompilerOptionValues(changeTracker, configFile, options) { + var tsconfigObjectLiteral = ts.getTsConfigObjectLiteralExpression(configFile); + if (!tsconfigObjectLiteral) + return undefined; + var compilerOptionsProperty = findJsonProperty(tsconfigObjectLiteral, "compilerOptions"); + if (compilerOptionsProperty === undefined) { + changeTracker.insertNodeAtObjectStart(configFile, tsconfigObjectLiteral, createJsonPropertyAssignment("compilerOptions", ts.factory.createObjectLiteralExpression(options.map(function (_a) { + var optionName = _a[0], optionValue = _a[1]; + return createJsonPropertyAssignment(optionName, optionValue); + }), /*multiLine*/ true))); + return; + } + var compilerOptions = compilerOptionsProperty.initializer; + if (!ts.isObjectLiteralExpression(compilerOptions)) { + return; + } + for (var _i = 0, options_1 = options; _i < options_1.length; _i++) { + var _a = options_1[_i], optionName = _a[0], optionValue = _a[1]; + var optionProperty = findJsonProperty(compilerOptions, optionName); + if (optionProperty === undefined) { + changeTracker.insertNodeAtObjectStart(configFile, compilerOptions, createJsonPropertyAssignment(optionName, optionValue)); + } + else { + changeTracker.replaceNode(configFile, optionProperty.initializer, optionValue); + } + } + } + codefix.setJsonCompilerOptionValues = setJsonCompilerOptionValues; + function setJsonCompilerOptionValue(changeTracker, configFile, optionName, optionValue) { + setJsonCompilerOptionValues(changeTracker, configFile, [[optionName, optionValue]]); + } + codefix.setJsonCompilerOptionValue = setJsonCompilerOptionValue; + function createJsonPropertyAssignment(name, initializer) { + return ts.factory.createPropertyAssignment(ts.factory.createStringLiteral(name), initializer); + } + codefix.createJsonPropertyAssignment = createJsonPropertyAssignment; + function findJsonProperty(obj, name) { + return ts.find(obj.properties, function (p) { return ts.isPropertyAssignment(p) && !!p.name && ts.isStringLiteral(p.name) && p.name.text === name; }); + } + codefix.findJsonProperty = findJsonProperty; + /** + * Given a type node containing 'import("./a").SomeType>', + * returns an equivalent type reference node with any nested ImportTypeNodes also replaced + * with type references, and a list of symbols that must be imported to use the type reference. + */ + function tryGetAutoImportableReferenceFromTypeNode(importTypeNode, scriptTarget) { + var symbols; + var typeNode = ts.visitNode(importTypeNode, visit); + if (symbols && typeNode) { + return { typeNode: typeNode, symbols: symbols }; + } + function visit(node) { + var _a; + if (ts.isLiteralImportTypeNode(node) && node.qualifier) { + // Symbol for the left-most thing after the dot + var firstIdentifier = ts.getFirstIdentifier(node.qualifier); + var name = ts.getNameForExportedSymbol(firstIdentifier.symbol, scriptTarget); + var qualifier = name !== firstIdentifier.text + ? replaceFirstIdentifierOfEntityName(node.qualifier, ts.factory.createIdentifier(name)) + : node.qualifier; + symbols = ts.append(symbols, firstIdentifier.symbol); + var typeArguments = (_a = node.typeArguments) === null || _a === void 0 ? void 0 : _a.map(visit); + return ts.factory.createTypeReferenceNode(qualifier, typeArguments); + } + return ts.visitEachChild(node, visit, ts.nullTransformationContext); + } + } + codefix.tryGetAutoImportableReferenceFromTypeNode = tryGetAutoImportableReferenceFromTypeNode; + function replaceFirstIdentifierOfEntityName(name, newIdentifier) { + if (name.kind === 79 /* SyntaxKind.Identifier */) { + return newIdentifier; + } + return ts.factory.createQualifiedName(replaceFirstIdentifierOfEntityName(name.left, newIdentifier), name.right); + } + function importSymbols(importAdder, symbols) { + symbols.forEach(function (s) { return importAdder.addImportFromExportedSymbol(s, /*isValidTypeOnlyUseSite*/ true); }); + } + codefix.importSymbols = importSymbols; + function findAncestorMatchingSpan(sourceFile, span) { + var end = ts.textSpanEnd(span); + var token = ts.getTokenAtPosition(sourceFile, span.start); + while (token.end < end) { + token = token.parent; + } + return token; + } + codefix.findAncestorMatchingSpan = findAncestorMatchingSpan; + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + function generateAccessorFromProperty(file, program, start, end, context, _actionName) { + var fieldInfo = getAccessorConvertiblePropertyAtPosition(file, program, start, end); + if (!fieldInfo || ts.refactor.isRefactorErrorInfo(fieldInfo)) + return undefined; + var changeTracker = ts.textChanges.ChangeTracker.fromContext(context); + var isStatic = fieldInfo.isStatic, isReadonly = fieldInfo.isReadonly, fieldName = fieldInfo.fieldName, accessorName = fieldInfo.accessorName, originalName = fieldInfo.originalName, type = fieldInfo.type, container = fieldInfo.container, declaration = fieldInfo.declaration; + ts.suppressLeadingAndTrailingTrivia(fieldName); + ts.suppressLeadingAndTrailingTrivia(accessorName); + ts.suppressLeadingAndTrailingTrivia(declaration); + ts.suppressLeadingAndTrailingTrivia(container); + var accessorModifiers; + var fieldModifiers; + if (ts.isClassLike(container)) { + var modifierFlags = ts.getEffectiveModifierFlags(declaration); + if (ts.isSourceFileJS(file)) { + var modifiers = ts.factory.createModifiersFromModifierFlags(modifierFlags); + accessorModifiers = modifiers; + fieldModifiers = modifiers; + } + else { + accessorModifiers = ts.factory.createModifiersFromModifierFlags(prepareModifierFlagsForAccessor(modifierFlags)); + fieldModifiers = ts.factory.createModifiersFromModifierFlags(prepareModifierFlagsForField(modifierFlags)); + } + if (ts.canHaveDecorators(declaration)) { + fieldModifiers = ts.concatenate(ts.getDecorators(declaration), fieldModifiers); + } + } + updateFieldDeclaration(changeTracker, file, declaration, type, fieldName, fieldModifiers); + var getAccessor = generateGetAccessor(fieldName, accessorName, type, accessorModifiers, isStatic, container); + ts.suppressLeadingAndTrailingTrivia(getAccessor); + insertAccessor(changeTracker, file, getAccessor, declaration, container); + if (isReadonly) { + // readonly modifier only existed in classLikeDeclaration + var constructor = ts.getFirstConstructorWithBody(container); + if (constructor) { + updateReadonlyPropertyInitializerStatementConstructor(changeTracker, file, constructor, fieldName.text, originalName); + } + } + else { + var setAccessor = generateSetAccessor(fieldName, accessorName, type, accessorModifiers, isStatic, container); + ts.suppressLeadingAndTrailingTrivia(setAccessor); + insertAccessor(changeTracker, file, setAccessor, declaration, container); + } + return changeTracker.getChanges(); + } + codefix.generateAccessorFromProperty = generateAccessorFromProperty; + function isConvertibleName(name) { + return ts.isIdentifier(name) || ts.isStringLiteral(name); + } + function isAcceptedDeclaration(node) { + return ts.isParameterPropertyDeclaration(node, node.parent) || ts.isPropertyDeclaration(node) || ts.isPropertyAssignment(node); + } + function createPropertyName(name, originalName) { + return ts.isIdentifier(originalName) ? ts.factory.createIdentifier(name) : ts.factory.createStringLiteral(name); + } + function createAccessorAccessExpression(fieldName, isStatic, container) { + var leftHead = isStatic ? container.name : ts.factory.createThis(); // TODO: GH#18217 + return ts.isIdentifier(fieldName) ? ts.factory.createPropertyAccessExpression(leftHead, fieldName) : ts.factory.createElementAccessExpression(leftHead, ts.factory.createStringLiteralFromNode(fieldName)); + } + function prepareModifierFlagsForAccessor(modifierFlags) { + modifierFlags &= ~64 /* ModifierFlags.Readonly */; // avoid Readonly modifier because it will convert to get accessor + modifierFlags &= ~8 /* ModifierFlags.Private */; + if (!(modifierFlags & 16 /* ModifierFlags.Protected */)) { + modifierFlags |= 4 /* ModifierFlags.Public */; + } + return modifierFlags; + } + function prepareModifierFlagsForField(modifierFlags) { + modifierFlags &= ~4 /* ModifierFlags.Public */; + modifierFlags &= ~16 /* ModifierFlags.Protected */; + modifierFlags |= 8 /* ModifierFlags.Private */; + return modifierFlags; + } + function getAccessorConvertiblePropertyAtPosition(file, program, start, end, considerEmptySpans) { + if (considerEmptySpans === void 0) { considerEmptySpans = true; } + var node = ts.getTokenAtPosition(file, start); + var cursorRequest = start === end && considerEmptySpans; + var declaration = ts.findAncestor(node.parent, isAcceptedDeclaration); + // make sure declaration have AccessibilityModifier or Static Modifier or Readonly Modifier + var meaning = 28 /* ModifierFlags.AccessibilityModifier */ | 32 /* ModifierFlags.Static */ | 64 /* ModifierFlags.Readonly */; + if (!declaration || (!(ts.nodeOverlapsWithStartEnd(declaration.name, file, start, end) || cursorRequest))) { + return { + error: ts.getLocaleSpecificMessage(ts.Diagnostics.Could_not_find_property_for_which_to_generate_accessor) + }; + } + if (!isConvertibleName(declaration.name)) { + return { + error: ts.getLocaleSpecificMessage(ts.Diagnostics.Name_is_not_valid) + }; + } + if (((ts.getEffectiveModifierFlags(declaration) & 126975 /* ModifierFlags.Modifier */) | meaning) !== meaning) { + return { + error: ts.getLocaleSpecificMessage(ts.Diagnostics.Can_only_convert_property_with_modifier) + }; + } + var name = declaration.name.text; + var startWithUnderscore = ts.startsWithUnderscore(name); + var fieldName = createPropertyName(startWithUnderscore ? name : ts.getUniqueName("_".concat(name), file), declaration.name); + var accessorName = createPropertyName(startWithUnderscore ? ts.getUniqueName(name.substring(1), file) : name, declaration.name); + return { + isStatic: ts.hasStaticModifier(declaration), + isReadonly: ts.hasEffectiveReadonlyModifier(declaration), + type: getDeclarationType(declaration, program), + container: declaration.kind === 166 /* SyntaxKind.Parameter */ ? declaration.parent.parent : declaration.parent, + originalName: declaration.name.text, + declaration: declaration, + fieldName: fieldName, + accessorName: accessorName, + renameAccessor: startWithUnderscore + }; + } + codefix.getAccessorConvertiblePropertyAtPosition = getAccessorConvertiblePropertyAtPosition; + function generateGetAccessor(fieldName, accessorName, type, modifiers, isStatic, container) { + return ts.factory.createGetAccessorDeclaration(modifiers, accessorName, + /*parameters*/ undefined, // TODO: GH#18217 + type, ts.factory.createBlock([ + ts.factory.createReturnStatement(createAccessorAccessExpression(fieldName, isStatic, container)) + ], /*multiLine*/ true)); + } + function generateSetAccessor(fieldName, accessorName, type, modifiers, isStatic, container) { + return ts.factory.createSetAccessorDeclaration(modifiers, accessorName, [ts.factory.createParameterDeclaration( + /*modifiers*/ undefined, + /*dotDotDotToken*/ undefined, ts.factory.createIdentifier("value"), + /*questionToken*/ undefined, type)], ts.factory.createBlock([ + ts.factory.createExpressionStatement(ts.factory.createAssignment(createAccessorAccessExpression(fieldName, isStatic, container), ts.factory.createIdentifier("value"))) + ], /*multiLine*/ true)); + } + function updatePropertyDeclaration(changeTracker, file, declaration, type, fieldName, modifiers) { + var property = ts.factory.updatePropertyDeclaration(declaration, modifiers, fieldName, declaration.questionToken || declaration.exclamationToken, type, declaration.initializer); + changeTracker.replaceNode(file, declaration, property); + } + function updatePropertyAssignmentDeclaration(changeTracker, file, declaration, fieldName) { + var assignment = ts.factory.updatePropertyAssignment(declaration, fieldName, declaration.initializer); + changeTracker.replacePropertyAssignment(file, declaration, assignment); + } + function updateFieldDeclaration(changeTracker, file, declaration, type, fieldName, modifiers) { + if (ts.isPropertyDeclaration(declaration)) { + updatePropertyDeclaration(changeTracker, file, declaration, type, fieldName, modifiers); + } + else if (ts.isPropertyAssignment(declaration)) { + updatePropertyAssignmentDeclaration(changeTracker, file, declaration, fieldName); + } + else { + changeTracker.replaceNode(file, declaration, ts.factory.updateParameterDeclaration(declaration, modifiers, declaration.dotDotDotToken, ts.cast(fieldName, ts.isIdentifier), declaration.questionToken, declaration.type, declaration.initializer)); + } + } + function insertAccessor(changeTracker, file, accessor, declaration, container) { + ts.isParameterPropertyDeclaration(declaration, declaration.parent) ? changeTracker.insertMemberAtStart(file, container, accessor) : + ts.isPropertyAssignment(declaration) ? changeTracker.insertNodeAfterComma(file, declaration, accessor) : + changeTracker.insertNodeAfter(file, declaration, accessor); + } + function updateReadonlyPropertyInitializerStatementConstructor(changeTracker, file, constructor, fieldName, originalName) { + if (!constructor.body) + return; + constructor.body.forEachChild(function recur(node) { + if (ts.isElementAccessExpression(node) && + node.expression.kind === 108 /* SyntaxKind.ThisKeyword */ && + ts.isStringLiteral(node.argumentExpression) && + node.argumentExpression.text === originalName && + ts.isWriteAccess(node)) { + changeTracker.replaceNode(file, node.argumentExpression, ts.factory.createStringLiteral(fieldName)); + } + if (ts.isPropertyAccessExpression(node) && node.expression.kind === 108 /* SyntaxKind.ThisKeyword */ && node.name.text === originalName && ts.isWriteAccess(node)) { + changeTracker.replaceNode(file, node.name, ts.factory.createIdentifier(fieldName)); + } + if (!ts.isFunctionLike(node) && !ts.isClassLike(node)) { + node.forEachChild(recur); + } + }); + } + function getDeclarationType(declaration, program) { + var typeNode = ts.getTypeAnnotationNode(declaration); + if (ts.isPropertyDeclaration(declaration) && typeNode && declaration.questionToken) { + var typeChecker = program.getTypeChecker(); + var type = typeChecker.getTypeFromTypeNode(typeNode); + if (!typeChecker.isTypeAssignableTo(typeChecker.getUndefinedType(), type)) { + var types = ts.isUnionTypeNode(typeNode) ? typeNode.types : [typeNode]; + return ts.factory.createUnionTypeNode(__spreadArray(__spreadArray([], types, true), [ts.factory.createKeywordTypeNode(155 /* SyntaxKind.UndefinedKeyword */)], false)); + } + } + return typeNode; + } + function getAllSupers(decl, checker) { + var res = []; + while (decl) { + var superElement = ts.getClassExtendsHeritageElement(decl); + var superSymbol = superElement && checker.getSymbolAtLocation(superElement.expression); + if (!superSymbol) + break; + var symbol = superSymbol.flags & 2097152 /* SymbolFlags.Alias */ ? checker.getAliasedSymbol(superSymbol) : superSymbol; + var superDecl = symbol.declarations && ts.find(symbol.declarations, ts.isClassLike); + if (!superDecl) + break; + res.push(superDecl); + decl = superDecl; + } + return res; + } + codefix.getAllSupers = getAllSupers; + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixName = "invalidImportSyntax"; + function getCodeFixesForImportDeclaration(context, node) { + var sourceFile = ts.getSourceFileOfNode(node); + var namespace = ts.getNamespaceDeclarationNode(node); + var opts = context.program.getCompilerOptions(); + var variations = []; + // import Bluebird from "bluebird"; + variations.push(createAction(context, sourceFile, node, ts.makeImport(namespace.name, /*namedImports*/ undefined, node.moduleSpecifier, ts.getQuotePreference(sourceFile, context.preferences)))); + if (ts.getEmitModuleKind(opts) === ts.ModuleKind.CommonJS) { + // import Bluebird = require("bluebird"); + variations.push(createAction(context, sourceFile, node, ts.factory.createImportEqualsDeclaration( + /*modifiers*/ undefined, + /*isTypeOnly*/ false, namespace.name, ts.factory.createExternalModuleReference(node.moduleSpecifier)))); + } + return variations; + } + function createAction(context, sourceFile, node, replacement) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return t.replaceNode(sourceFile, node, replacement); }); + return codefix.createCodeFixActionWithoutFixAll(fixName, changes, [ts.Diagnostics.Replace_import_with_0, changes[0].textChanges[0].newText]); + } + codefix.registerCodeFix({ + errorCodes: [ + ts.Diagnostics.This_expression_is_not_callable.code, + ts.Diagnostics.This_expression_is_not_constructable.code, + ], + getCodeActions: getActionsForUsageOfInvalidImport + }); + function getActionsForUsageOfInvalidImport(context) { + var sourceFile = context.sourceFile; + var targetKind = ts.Diagnostics.This_expression_is_not_callable.code === context.errorCode ? 210 /* SyntaxKind.CallExpression */ : 211 /* SyntaxKind.NewExpression */; + var node = ts.findAncestor(ts.getTokenAtPosition(sourceFile, context.span.start), function (a) { return a.kind === targetKind; }); + if (!node) { + return []; + } + var expr = node.expression; + return getImportCodeFixesForExpression(context, expr); + } + codefix.registerCodeFix({ + errorCodes: [ + // The following error codes cover pretty much all assignability errors that could involve an expression + ts.Diagnostics.Argument_of_type_0_is_not_assignable_to_parameter_of_type_1.code, + ts.Diagnostics.Type_0_does_not_satisfy_the_constraint_1.code, + ts.Diagnostics.Type_0_is_not_assignable_to_type_1.code, + ts.Diagnostics.Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated.code, + ts.Diagnostics.Type_predicate_0_is_not_assignable_to_1.code, + ts.Diagnostics.Property_0_of_type_1_is_not_assignable_to_2_index_type_3.code, + ts.Diagnostics._0_index_type_1_is_not_assignable_to_2_index_type_3.code, + ts.Diagnostics.Property_0_in_type_1_is_not_assignable_to_the_same_property_in_base_type_2.code, + ts.Diagnostics.Property_0_in_type_1_is_not_assignable_to_type_2.code, + ts.Diagnostics.Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property.code, + ts.Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1.code, + ], + getCodeActions: getActionsForInvalidImportLocation + }); + function getActionsForInvalidImportLocation(context) { + var sourceFile = context.sourceFile; + var node = ts.findAncestor(ts.getTokenAtPosition(sourceFile, context.span.start), function (a) { return a.getStart() === context.span.start && a.getEnd() === (context.span.start + context.span.length); }); + if (!node) { + return []; + } + return getImportCodeFixesForExpression(context, node); + } + function getImportCodeFixesForExpression(context, expr) { + var type = context.program.getTypeChecker().getTypeAtLocation(expr); + if (!(type.symbol && type.symbol.originatingImport)) { + return []; + } + var fixes = []; + var relatedImport = type.symbol.originatingImport; // TODO: GH#18217 + if (!ts.isImportCall(relatedImport)) { + ts.addRange(fixes, getCodeFixesForImportDeclaration(context, relatedImport)); + } + if (ts.isExpression(expr) && !(ts.isNamedDeclaration(expr.parent) && expr.parent.name === expr)) { + var sourceFile_2 = context.sourceFile; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return t.replaceNode(sourceFile_2, expr, ts.factory.createPropertyAccessExpression(expr, "default"), {}); }); + fixes.push(codefix.createCodeFixActionWithoutFixAll(fixName, changes, ts.Diagnostics.Use_synthetic_default_member)); + } + return fixes; + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixName = "strictClassInitialization"; + var fixIdAddDefiniteAssignmentAssertions = "addMissingPropertyDefiniteAssignmentAssertions"; + var fixIdAddUndefinedType = "addMissingPropertyUndefinedType"; + var fixIdAddInitializer = "addMissingPropertyInitializer"; + var errorCodes = [ts.Diagnostics.Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor.code]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function getCodeActionsForStrictClassInitializationErrors(context) { + var info = getInfo(context.sourceFile, context.span.start); + if (!info) + return; + var result = []; + ts.append(result, getActionForAddMissingUndefinedType(context, info)); + ts.append(result, getActionForAddMissingDefiniteAssignmentAssertion(context, info)); + ts.append(result, getActionForAddMissingInitializer(context, info)); + return result; + }, + fixIds: [fixIdAddDefiniteAssignmentAssertions, fixIdAddUndefinedType, fixIdAddInitializer], + getAllCodeActions: function (context) { + return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var info = getInfo(diag.file, diag.start); + if (!info) + return; + switch (context.fixId) { + case fixIdAddDefiniteAssignmentAssertions: + addDefiniteAssignmentAssertion(changes, diag.file, info.prop); + break; + case fixIdAddUndefinedType: + addUndefinedType(changes, diag.file, info); + break; + case fixIdAddInitializer: + var checker = context.program.getTypeChecker(); + var initializer = getInitializer(checker, info.prop); + if (!initializer) + return; + addInitializer(changes, diag.file, info.prop, initializer); + break; + default: + ts.Debug.fail(JSON.stringify(context.fixId)); + } + }); + }, + }); + function getInfo(sourceFile, pos) { + var token = ts.getTokenAtPosition(sourceFile, pos); + if (ts.isIdentifier(token) && ts.isPropertyDeclaration(token.parent)) { + var type = ts.getEffectiveTypeAnnotationNode(token.parent); + if (type) { + return { type: type, prop: token.parent, isJs: ts.isInJSFile(token.parent) }; + } + } + return undefined; + } + function getActionForAddMissingDefiniteAssignmentAssertion(context, info) { + if (info.isJs) + return undefined; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addDefiniteAssignmentAssertion(t, context.sourceFile, info.prop); }); + return codefix.createCodeFixAction(fixName, changes, [ts.Diagnostics.Add_definite_assignment_assertion_to_property_0, info.prop.getText()], fixIdAddDefiniteAssignmentAssertions, ts.Diagnostics.Add_definite_assignment_assertions_to_all_uninitialized_properties); + } + function addDefiniteAssignmentAssertion(changeTracker, propertyDeclarationSourceFile, propertyDeclaration) { + ts.suppressLeadingAndTrailingTrivia(propertyDeclaration); + var property = ts.factory.updatePropertyDeclaration(propertyDeclaration, propertyDeclaration.modifiers, propertyDeclaration.name, ts.factory.createToken(53 /* SyntaxKind.ExclamationToken */), propertyDeclaration.type, propertyDeclaration.initializer); + changeTracker.replaceNode(propertyDeclarationSourceFile, propertyDeclaration, property); + } + function getActionForAddMissingUndefinedType(context, info) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addUndefinedType(t, context.sourceFile, info); }); + return codefix.createCodeFixAction(fixName, changes, [ts.Diagnostics.Add_undefined_type_to_property_0, info.prop.name.getText()], fixIdAddUndefinedType, ts.Diagnostics.Add_undefined_type_to_all_uninitialized_properties); + } + function addUndefinedType(changeTracker, sourceFile, info) { + var undefinedTypeNode = ts.factory.createKeywordTypeNode(155 /* SyntaxKind.UndefinedKeyword */); + var types = ts.isUnionTypeNode(info.type) ? info.type.types.concat(undefinedTypeNode) : [info.type, undefinedTypeNode]; + var unionTypeNode = ts.factory.createUnionTypeNode(types); + if (info.isJs) { + changeTracker.addJSDocTags(sourceFile, info.prop, [ts.factory.createJSDocTypeTag(/*tagName*/ undefined, ts.factory.createJSDocTypeExpression(unionTypeNode))]); + } + else { + changeTracker.replaceNode(sourceFile, info.type, unionTypeNode); + } + } + function getActionForAddMissingInitializer(context, info) { + if (info.isJs) + return undefined; + var checker = context.program.getTypeChecker(); + var initializer = getInitializer(checker, info.prop); + if (!initializer) + return undefined; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return addInitializer(t, context.sourceFile, info.prop, initializer); }); + return codefix.createCodeFixAction(fixName, changes, [ts.Diagnostics.Add_initializer_to_property_0, info.prop.name.getText()], fixIdAddInitializer, ts.Diagnostics.Add_initializers_to_all_uninitialized_properties); + } + function addInitializer(changeTracker, propertyDeclarationSourceFile, propertyDeclaration, initializer) { + ts.suppressLeadingAndTrailingTrivia(propertyDeclaration); + var property = ts.factory.updatePropertyDeclaration(propertyDeclaration, propertyDeclaration.modifiers, propertyDeclaration.name, propertyDeclaration.questionToken, propertyDeclaration.type, initializer); + changeTracker.replaceNode(propertyDeclarationSourceFile, propertyDeclaration, property); + } + function getInitializer(checker, propertyDeclaration) { + return getDefaultValueFromType(checker, checker.getTypeFromTypeNode(propertyDeclaration.type)); // TODO: GH#18217 + } + function getDefaultValueFromType(checker, type) { + if (type.flags & 512 /* TypeFlags.BooleanLiteral */) { + return (type === checker.getFalseType() || type === checker.getFalseType(/*fresh*/ true)) ? ts.factory.createFalse() : ts.factory.createTrue(); + } + else if (type.isStringLiteral()) { + return ts.factory.createStringLiteral(type.value); + } + else if (type.isNumberLiteral()) { + return ts.factory.createNumericLiteral(type.value); + } + else if (type.flags & 2048 /* TypeFlags.BigIntLiteral */) { + return ts.factory.createBigIntLiteral(type.value); + } + else if (type.isUnion()) { + return ts.firstDefined(type.types, function (t) { return getDefaultValueFromType(checker, t); }); + } + else if (type.isClass()) { + var classDeclaration = ts.getClassLikeDeclarationOfSymbol(type.symbol); + if (!classDeclaration || ts.hasSyntacticModifier(classDeclaration, 256 /* ModifierFlags.Abstract */)) + return undefined; + var constructorDeclaration = ts.getFirstConstructorWithBody(classDeclaration); + if (constructorDeclaration && constructorDeclaration.parameters.length) + return undefined; + return ts.factory.createNewExpression(ts.factory.createIdentifier(type.symbol.name), /*typeArguments*/ undefined, /*argumentsArray*/ undefined); + } + else if (checker.isArrayLikeType(type)) { + return ts.factory.createArrayLiteralExpression(); + } + return undefined; + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "requireInTs"; + var errorCodes = [ts.Diagnostics.require_call_may_be_converted_to_an_import.code]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var info = getInfo(context.sourceFile, context.program, context.span.start); + if (!info) { + return undefined; + } + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, context.sourceFile, info); }); + return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Convert_require_to_import, fixId, ts.Diagnostics.Convert_all_require_to_import)]; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var info = getInfo(diag.file, context.program, diag.start); + if (info) { + doChange(changes, context.sourceFile, info); + } + }); }, + }); + function doChange(changes, sourceFile, info) { + var allowSyntheticDefaults = info.allowSyntheticDefaults, defaultImportName = info.defaultImportName, namedImports = info.namedImports, statement = info.statement, required = info.required; + changes.replaceNode(sourceFile, statement, defaultImportName && !allowSyntheticDefaults + ? ts.factory.createImportEqualsDeclaration(/*modifiers*/ undefined, /*isTypeOnly*/ false, defaultImportName, ts.factory.createExternalModuleReference(required)) + : ts.factory.createImportDeclaration(/*modifiers*/ undefined, ts.factory.createImportClause(/*isTypeOnly*/ false, defaultImportName, namedImports), required, /*assertClause*/ undefined)); + } + function getInfo(sourceFile, program, pos) { + var parent = ts.getTokenAtPosition(sourceFile, pos).parent; + if (!ts.isRequireCall(parent, /*checkArgumentIsStringLiteralLike*/ true)) { + throw ts.Debug.failBadSyntaxKind(parent); + } + var decl = ts.cast(parent.parent, ts.isVariableDeclaration); + var defaultImportName = ts.tryCast(decl.name, ts.isIdentifier); + var namedImports = ts.isObjectBindingPattern(decl.name) ? tryCreateNamedImportsFromObjectBindingPattern(decl.name) : undefined; + if (defaultImportName || namedImports) { + return { + allowSyntheticDefaults: ts.getAllowSyntheticDefaultImports(program.getCompilerOptions()), + defaultImportName: defaultImportName, + namedImports: namedImports, + statement: ts.cast(decl.parent.parent, ts.isVariableStatement), + required: ts.first(parent.arguments) + }; + } + } + function tryCreateNamedImportsFromObjectBindingPattern(node) { + var importSpecifiers = []; + for (var _i = 0, _a = node.elements; _i < _a.length; _i++) { + var element = _a[_i]; + if (!ts.isIdentifier(element.name) || element.initializer) { + return undefined; + } + importSpecifiers.push(ts.factory.createImportSpecifier(/*isTypeOnly*/ false, ts.tryCast(element.propertyName, ts.isIdentifier), element.name)); + } + if (importSpecifiers.length) { + return ts.factory.createNamedImports(importSpecifiers); + } + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "useDefaultImport"; + var errorCodes = [ts.Diagnostics.Import_may_be_converted_to_a_default_import.code]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var sourceFile = context.sourceFile, start = context.span.start; + var info = getInfo(sourceFile, start); + if (!info) + return undefined; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, sourceFile, info, context.preferences); }); + return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Convert_to_default_import, fixId, ts.Diagnostics.Convert_all_to_default_imports)]; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var info = getInfo(diag.file, diag.start); + if (info) + doChange(changes, diag.file, info, context.preferences); + }); }, + }); + function getInfo(sourceFile, pos) { + var name = ts.getTokenAtPosition(sourceFile, pos); + if (!ts.isIdentifier(name)) + return undefined; // bad input + var parent = name.parent; + if (ts.isImportEqualsDeclaration(parent) && ts.isExternalModuleReference(parent.moduleReference)) { + return { importNode: parent, name: name, moduleSpecifier: parent.moduleReference.expression }; + } + else if (ts.isNamespaceImport(parent)) { + var importNode = parent.parent.parent; + return { importNode: importNode, name: name, moduleSpecifier: importNode.moduleSpecifier }; + } + } + function doChange(changes, sourceFile, info, preferences) { + changes.replaceNode(sourceFile, info.importNode, ts.makeImport(info.name, /*namedImports*/ undefined, info.moduleSpecifier, ts.getQuotePreference(sourceFile, preferences))); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "useBigintLiteral"; + var errorCodes = [ + ts.Diagnostics.Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers.code, + ]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function getCodeActionsToUseBigintLiteral(context) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return makeChange(t, context.sourceFile, context.span); }); + if (changes.length > 0) { + return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Convert_to_a_bigint_numeric_literal, fixId, ts.Diagnostics.Convert_all_to_bigint_numeric_literals)]; + } + }, + fixIds: [fixId], + getAllCodeActions: function (context) { + return codefix.codeFixAll(context, errorCodes, function (changes, diag) { return makeChange(changes, diag.file, diag); }); + }, + }); + function makeChange(changeTracker, sourceFile, span) { + var numericLiteral = ts.tryCast(ts.getTokenAtPosition(sourceFile, span.start), ts.isNumericLiteral); + if (!numericLiteral) { + return; + } + // We use .getText to overcome parser inaccuracies: https://github.com/microsoft/TypeScript/issues/33298 + var newText = numericLiteral.getText(sourceFile) + "n"; + changeTracker.replaceNode(sourceFile, numericLiteral, ts.factory.createBigIntLiteral(newText)); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixIdAddMissingTypeof = "fixAddModuleReferTypeMissingTypeof"; + var fixId = fixIdAddMissingTypeof; + var errorCodes = [ts.Diagnostics.Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0.code]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function getCodeActionsToAddMissingTypeof(context) { + var sourceFile = context.sourceFile, span = context.span; + var importType = getImportTypeNode(sourceFile, span.start); + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, sourceFile, importType); }); + return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Add_missing_typeof, fixId, ts.Diagnostics.Add_missing_typeof)]; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + return doChange(changes, context.sourceFile, getImportTypeNode(diag.file, diag.start)); + }); }, + }); + function getImportTypeNode(sourceFile, pos) { + var token = ts.getTokenAtPosition(sourceFile, pos); + ts.Debug.assert(token.kind === 100 /* SyntaxKind.ImportKeyword */, "This token should be an ImportKeyword"); + ts.Debug.assert(token.parent.kind === 202 /* SyntaxKind.ImportType */, "Token parent should be an ImportType"); + return token.parent; + } + function doChange(changes, sourceFile, importType) { + var newTypeNode = ts.factory.updateImportTypeNode(importType, importType.argument, importType.assertions, importType.qualifier, importType.typeArguments, /* isTypeOf */ true); + changes.replaceNode(sourceFile, importType, newTypeNode); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixID = "wrapJsxInFragment"; + var errorCodes = [ts.Diagnostics.JSX_expressions_must_have_one_parent_element.code]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function getCodeActionsToWrapJsxInFragment(context) { + var sourceFile = context.sourceFile, span = context.span; + var node = findNodeToFix(sourceFile, span.start); + if (!node) + return undefined; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, sourceFile, node); }); + return [codefix.createCodeFixAction(fixID, changes, ts.Diagnostics.Wrap_in_JSX_fragment, fixID, ts.Diagnostics.Wrap_all_unparented_JSX_in_JSX_fragment)]; + }, + fixIds: [fixID], + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var node = findNodeToFix(context.sourceFile, diag.start); + if (!node) + return undefined; + doChange(changes, context.sourceFile, node); + }); }, + }); + function findNodeToFix(sourceFile, pos) { + // The error always at 1st token that is "<" in "" + var lessThanToken = ts.getTokenAtPosition(sourceFile, pos); + var firstJsxElementOrOpenElement = lessThanToken.parent; + var binaryExpr = firstJsxElementOrOpenElement.parent; + if (!ts.isBinaryExpression(binaryExpr)) { + // In case the start element is a JsxSelfClosingElement, it the end. + // For JsxOpenElement, find one more parent + binaryExpr = binaryExpr.parent; + if (!ts.isBinaryExpression(binaryExpr)) + return undefined; + } + if (!ts.nodeIsMissing(binaryExpr.operatorToken)) + return undefined; + return binaryExpr; + } + function doChange(changeTracker, sf, node) { + var jsx = flattenInvalidBinaryExpr(node); + if (jsx) + changeTracker.replaceNode(sf, node, ts.factory.createJsxFragment(ts.factory.createJsxOpeningFragment(), jsx, ts.factory.createJsxJsxClosingFragment())); + } + // The invalid syntax is constructed as + // InvalidJsxTree :: One of + // JsxElement CommaToken InvalidJsxTree + // JsxElement CommaToken JsxElement + function flattenInvalidBinaryExpr(node) { + var children = []; + var current = node; + while (true) { + if (ts.isBinaryExpression(current) && ts.nodeIsMissing(current.operatorToken) && current.operatorToken.kind === 27 /* SyntaxKind.CommaToken */) { + children.push(current.left); + if (ts.isJsxChild(current.right)) { + children.push(current.right); + // Indicates the tree has go to the bottom + return children; + } + else if (ts.isBinaryExpression(current.right)) { + current = current.right; + continue; + } + // Unreachable case + else + return undefined; + } + // Unreachable case + else + return undefined; + } + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "fixConvertToMappedObjectType"; + var errorCodes = [ts.Diagnostics.An_index_signature_parameter_type_cannot_be_a_literal_type_or_generic_type_Consider_using_a_mapped_object_type_instead.code]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function getCodeActionsToConvertToMappedTypeObject(context) { + var sourceFile = context.sourceFile, span = context.span; + var info = getInfo(sourceFile, span.start); + if (!info) + return undefined; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, sourceFile, info); }); + var name = ts.idText(info.container.name); + return [codefix.createCodeFixAction(fixId, changes, [ts.Diagnostics.Convert_0_to_mapped_object_type, name], fixId, [ts.Diagnostics.Convert_0_to_mapped_object_type, name])]; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var info = getInfo(diag.file, diag.start); + if (info) + doChange(changes, diag.file, info); + }); } + }); + function getInfo(sourceFile, pos) { + var token = ts.getTokenAtPosition(sourceFile, pos); + var indexSignature = ts.tryCast(token.parent.parent, ts.isIndexSignatureDeclaration); + if (!indexSignature) + return undefined; + var container = ts.isInterfaceDeclaration(indexSignature.parent) ? indexSignature.parent : ts.tryCast(indexSignature.parent.parent, ts.isTypeAliasDeclaration); + if (!container) + return undefined; + return { indexSignature: indexSignature, container: container }; + } + function createTypeAliasFromInterface(declaration, type) { + return ts.factory.createTypeAliasDeclaration(declaration.modifiers, declaration.name, declaration.typeParameters, type); + } + function doChange(changes, sourceFile, _a) { + var indexSignature = _a.indexSignature, container = _a.container; + var members = ts.isInterfaceDeclaration(container) ? container.members : container.type.members; + var otherMembers = members.filter(function (member) { return !ts.isIndexSignatureDeclaration(member); }); + var parameter = ts.first(indexSignature.parameters); + var mappedTypeParameter = ts.factory.createTypeParameterDeclaration(/*modifiers*/ undefined, ts.cast(parameter.name, ts.isIdentifier), parameter.type); + var mappedIntersectionType = ts.factory.createMappedTypeNode(ts.hasEffectiveReadonlyModifier(indexSignature) ? ts.factory.createModifier(146 /* SyntaxKind.ReadonlyKeyword */) : undefined, mappedTypeParameter, + /*nameType*/ undefined, indexSignature.questionToken, indexSignature.type, + /*members*/ undefined); + var intersectionType = ts.factory.createIntersectionTypeNode(__spreadArray(__spreadArray(__spreadArray([], ts.getAllSuperTypeNodes(container), true), [ + mappedIntersectionType + ], false), (otherMembers.length ? [ts.factory.createTypeLiteralNode(otherMembers)] : ts.emptyArray), true)); + changes.replaceNode(sourceFile, container, createTypeAliasFromInterface(container, intersectionType)); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "removeAccidentalCallParentheses"; + var errorCodes = [ + ts.Diagnostics.This_expression_is_not_callable_because_it_is_a_get_accessor_Did_you_mean_to_use_it_without.code, + ]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var callExpression = ts.findAncestor(ts.getTokenAtPosition(context.sourceFile, context.span.start), ts.isCallExpression); + if (!callExpression) { + return undefined; + } + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { + t.deleteRange(context.sourceFile, { pos: callExpression.expression.end, end: callExpression.end }); + }); + return [codefix.createCodeFixActionWithoutFixAll(fixId, changes, ts.Diagnostics.Remove_parentheses)]; + }, + fixIds: [fixId], + }); + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "removeUnnecessaryAwait"; + var errorCodes = [ + ts.Diagnostics.await_has_no_effect_on_the_type_of_this_expression.code, + ]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function getCodeActionsToRemoveUnnecessaryAwait(context) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return makeChange(t, context.sourceFile, context.span); }); + if (changes.length > 0) { + return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Remove_unnecessary_await, fixId, ts.Diagnostics.Remove_all_unnecessary_uses_of_await)]; + } + }, + fixIds: [fixId], + getAllCodeActions: function (context) { + return codefix.codeFixAll(context, errorCodes, function (changes, diag) { return makeChange(changes, diag.file, diag); }); + }, + }); + function makeChange(changeTracker, sourceFile, span) { + var awaitKeyword = ts.tryCast(ts.getTokenAtPosition(sourceFile, span.start), function (node) { return node.kind === 133 /* SyntaxKind.AwaitKeyword */; }); + var awaitExpression = awaitKeyword && ts.tryCast(awaitKeyword.parent, ts.isAwaitExpression); + if (!awaitExpression) { + return; + } + var expressionToReplace = awaitExpression; + var hasSurroundingParens = ts.isParenthesizedExpression(awaitExpression.parent); + if (hasSurroundingParens) { + var leftMostExpression = ts.getLeftmostExpression(awaitExpression.expression, /*stopAtCallExpressions*/ false); + if (ts.isIdentifier(leftMostExpression)) { + var precedingToken = ts.findPrecedingToken(awaitExpression.parent.pos, sourceFile); + if (precedingToken && precedingToken.kind !== 103 /* SyntaxKind.NewKeyword */) { + expressionToReplace = awaitExpression.parent; + } + } + } + changeTracker.replaceNode(sourceFile, expressionToReplace, awaitExpression.expression); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var errorCodes = [ts.Diagnostics.A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both.code]; + var fixId = "splitTypeOnlyImport"; + codefix.registerCodeFix({ + errorCodes: errorCodes, + fixIds: [fixId], + getCodeActions: function getCodeActionsToSplitTypeOnlyImport(context) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { + return splitTypeOnlyImport(t, getImportDeclaration(context.sourceFile, context.span), context); + }); + if (changes.length) { + return [codefix.createCodeFixAction(fixId, changes, ts.Diagnostics.Split_into_two_separate_import_declarations, fixId, ts.Diagnostics.Split_all_invalid_type_only_imports)]; + } + }, + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, error) { + splitTypeOnlyImport(changes, getImportDeclaration(context.sourceFile, error), context); + }); }, + }); + function getImportDeclaration(sourceFile, span) { + return ts.findAncestor(ts.getTokenAtPosition(sourceFile, span.start), ts.isImportDeclaration); + } + function splitTypeOnlyImport(changes, importDeclaration, context) { + if (!importDeclaration) { + return; + } + var importClause = ts.Debug.checkDefined(importDeclaration.importClause); + changes.replaceNode(context.sourceFile, importDeclaration, ts.factory.updateImportDeclaration(importDeclaration, importDeclaration.modifiers, ts.factory.updateImportClause(importClause, importClause.isTypeOnly, importClause.name, /*namedBindings*/ undefined), importDeclaration.moduleSpecifier, importDeclaration.assertClause)); + changes.insertNodeAfter(context.sourceFile, importDeclaration, ts.factory.createImportDeclaration( + /*modifiers*/ undefined, ts.factory.updateImportClause(importClause, importClause.isTypeOnly, /*name*/ undefined, importClause.namedBindings), importDeclaration.moduleSpecifier, importDeclaration.assertClause)); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "fixConvertConstToLet"; + var errorCodes = [ts.Diagnostics.Cannot_assign_to_0_because_it_is_a_constant.code]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function getCodeActionsToConvertConstToLet(context) { + var sourceFile = context.sourceFile, span = context.span, program = context.program; + var info = getInfo(sourceFile, span.start, program); + if (info === undefined) + return; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, sourceFile, info.token); }); + return [codefix.createCodeFixActionMaybeFixAll(fixId, changes, ts.Diagnostics.Convert_const_to_let, fixId, ts.Diagnostics.Convert_all_const_to_let)]; + }, + getAllCodeActions: function (context) { + var program = context.program; + var seen = new ts.Map(); + return codefix.createCombinedCodeActions(ts.textChanges.ChangeTracker.with(context, function (changes) { + codefix.eachDiagnostic(context, errorCodes, function (diag) { + var info = getInfo(diag.file, diag.start, program); + if (info) { + if (ts.addToSeen(seen, ts.getSymbolId(info.symbol))) { + return doChange(changes, diag.file, info.token); + } + } + return undefined; + }); + })); + }, + fixIds: [fixId] + }); + function getInfo(sourceFile, pos, program) { + var _a; + var checker = program.getTypeChecker(); + var symbol = checker.getSymbolAtLocation(ts.getTokenAtPosition(sourceFile, pos)); + if (symbol === undefined) + return; + var declaration = ts.tryCast((_a = symbol === null || symbol === void 0 ? void 0 : symbol.valueDeclaration) === null || _a === void 0 ? void 0 : _a.parent, ts.isVariableDeclarationList); + if (declaration === undefined) + return; + var constToken = ts.findChildOfKind(declaration, 85 /* SyntaxKind.ConstKeyword */, sourceFile); + if (constToken === undefined) + return; + return { symbol: symbol, token: constToken }; + } + function doChange(changes, sourceFile, token) { + changes.replaceNode(sourceFile, token, ts.factory.createToken(119 /* SyntaxKind.LetKeyword */)); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixId = "fixExpectedComma"; + var expectedErrorCode = ts.Diagnostics._0_expected.code; + var errorCodes = [expectedErrorCode]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + getCodeActions: function (context) { + var sourceFile = context.sourceFile; + var info = getInfo(sourceFile, context.span.start, context.errorCode); + if (!info) + return undefined; + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, sourceFile, info); }); + return [codefix.createCodeFixAction(fixId, changes, [ts.Diagnostics.Change_0_to_1, ";", ","], fixId, [ts.Diagnostics.Change_0_to_1, ";", ","])]; + }, + fixIds: [fixId], + getAllCodeActions: function (context) { return codefix.codeFixAll(context, errorCodes, function (changes, diag) { + var info = getInfo(diag.file, diag.start, diag.code); + if (info) + doChange(changes, context.sourceFile, info); + }); }, + }); + function getInfo(sourceFile, pos, _) { + var node = ts.getTokenAtPosition(sourceFile, pos); + return (node.kind === 26 /* SyntaxKind.SemicolonToken */ && + node.parent && + (ts.isObjectLiteralExpression(node.parent) || + ts.isArrayLiteralExpression(node.parent))) ? { node: node } : undefined; + } + function doChange(changes, sourceFile, _a) { + var node = _a.node; + var newNode = ts.factory.createToken(27 /* SyntaxKind.CommaToken */); + changes.replaceNode(sourceFile, node, newNode); + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var codefix; + (function (codefix) { + var fixName = "addVoidToPromise"; + var fixId = "addVoidToPromise"; + var errorCodes = [ + ts.Diagnostics.Expected_1_argument_but_got_0_new_Promise_needs_a_JSDoc_hint_to_produce_a_resolve_that_can_be_called_without_arguments.code, + ts.Diagnostics.Expected_0_arguments_but_got_1_Did_you_forget_to_include_void_in_your_type_argument_to_Promise.code + ]; + codefix.registerCodeFix({ + errorCodes: errorCodes, + fixIds: [fixId], + getCodeActions: function (context) { + var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return makeChange(t, context.sourceFile, context.span, context.program); }); + if (changes.length > 0) { + return [codefix.createCodeFixAction(fixName, changes, ts.Diagnostics.Add_void_to_Promise_resolved_without_a_value, fixId, ts.Diagnostics.Add_void_to_all_Promises_resolved_without_a_value)]; + } + }, + getAllCodeActions: function (context) { + return codefix.codeFixAll(context, errorCodes, function (changes, diag) { return makeChange(changes, diag.file, diag, context.program, new ts.Set()); }); + } + }); + function makeChange(changes, sourceFile, span, program, seen) { + var node = ts.getTokenAtPosition(sourceFile, span.start); + if (!ts.isIdentifier(node) || !ts.isCallExpression(node.parent) || node.parent.expression !== node || node.parent.arguments.length !== 0) + return; + var checker = program.getTypeChecker(); + var symbol = checker.getSymbolAtLocation(node); + // decl should be `new Promise(() => {})` + var decl = symbol === null || symbol === void 0 ? void 0 : symbol.valueDeclaration; + if (!decl || !ts.isParameter(decl) || !ts.isNewExpression(decl.parent.parent)) + return; + // no need to make this change if we have already seen this parameter. + if (seen === null || seen === void 0 ? void 0 : seen.has(decl)) + return; + seen === null || seen === void 0 ? void 0 : seen.add(decl); + var typeArguments = getEffectiveTypeArguments(decl.parent.parent); + if (ts.some(typeArguments)) { + // append ` | void` to type argument + var typeArgument = typeArguments[0]; + var needsParens = !ts.isUnionTypeNode(typeArgument) && !ts.isParenthesizedTypeNode(typeArgument) && + ts.isParenthesizedTypeNode(ts.factory.createUnionTypeNode([typeArgument, ts.factory.createKeywordTypeNode(114 /* SyntaxKind.VoidKeyword */)]).types[0]); + if (needsParens) { + changes.insertText(sourceFile, typeArgument.pos, "("); + } + changes.insertText(sourceFile, typeArgument.end, needsParens ? ") | void" : " | void"); + } + else { + // make sure the Promise is type is untyped (i.e., `unknown`) + var signature = checker.getResolvedSignature(node.parent); + var parameter = signature === null || signature === void 0 ? void 0 : signature.parameters[0]; + var parameterType = parameter && checker.getTypeOfSymbolAtLocation(parameter, decl.parent.parent); + if (ts.isInJSFile(decl)) { + if (!parameterType || parameterType.flags & 3 /* TypeFlags.AnyOrUnknown */) { + // give the expression a type + changes.insertText(sourceFile, decl.parent.parent.end, ")"); + changes.insertText(sourceFile, ts.skipTrivia(sourceFile.text, decl.parent.parent.pos), "/** @type {Promise} */("); + } + } + else { + if (!parameterType || parameterType.flags & 2 /* TypeFlags.Unknown */) { + // add `void` type argument + changes.insertText(sourceFile, decl.parent.parent.expression.end, ""); + } + } + } + } + function getEffectiveTypeArguments(node) { + var _a; + if (ts.isInJSFile(node)) { + if (ts.isParenthesizedExpression(node.parent)) { + var jsDocType = (_a = ts.getJSDocTypeTag(node.parent)) === null || _a === void 0 ? void 0 : _a.typeExpression.type; + if (jsDocType && ts.isTypeReferenceNode(jsDocType) && ts.isIdentifier(jsDocType.typeName) && ts.idText(jsDocType.typeName) === "Promise") { + return jsDocType.typeArguments; + } + } + } + else { + return node.typeArguments; + } + } + })(codefix = ts.codefix || (ts.codefix = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var refactor; + (function (refactor) { + var refactorName = "Convert export"; + var defaultToNamedAction = { + name: "Convert default export to named export", + description: ts.Diagnostics.Convert_default_export_to_named_export.message, + kind: "refactor.rewrite.export.named" + }; + var namedToDefaultAction = { + name: "Convert named export to default export", + description: ts.Diagnostics.Convert_named_export_to_default_export.message, + kind: "refactor.rewrite.export.default" + }; + refactor.registerRefactor(refactorName, { + kinds: [ + defaultToNamedAction.kind, + namedToDefaultAction.kind + ], + getAvailableActions: function getRefactorActionsToConvertBetweenNamedAndDefaultExports(context) { + var info = getInfo(context, context.triggerReason === "invoked"); + if (!info) + return ts.emptyArray; + if (!refactor.isRefactorErrorInfo(info)) { + var action = info.wasDefault ? defaultToNamedAction : namedToDefaultAction; + return [{ name: refactorName, description: action.description, actions: [action] }]; + } + if (context.preferences.provideRefactorNotApplicableReason) { + return [ + { name: refactorName, description: ts.Diagnostics.Convert_default_export_to_named_export.message, actions: [ + __assign(__assign({}, defaultToNamedAction), { notApplicableReason: info.error }), + __assign(__assign({}, namedToDefaultAction), { notApplicableReason: info.error }), + ] } + ]; + } + return ts.emptyArray; + }, + getEditsForAction: function getRefactorEditsToConvertBetweenNamedAndDefaultExports(context, actionName) { + ts.Debug.assert(actionName === defaultToNamedAction.name || actionName === namedToDefaultAction.name, "Unexpected action name"); + var info = getInfo(context); + ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected applicable refactor info"); + var edits = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(context.file, context.program, info, t, context.cancellationToken); }); + return { edits: edits, renameFilename: undefined, renameLocation: undefined }; + }, + }); + function getInfo(context, considerPartialSpans) { + if (considerPartialSpans === void 0) { considerPartialSpans = true; } + var file = context.file, program = context.program; + var span = ts.getRefactorContextSpan(context); + var token = ts.getTokenAtPosition(file, span.start); + var exportNode = !!(token.parent && ts.getSyntacticModifierFlags(token.parent) & 1 /* ModifierFlags.Export */) && considerPartialSpans ? token.parent : ts.getParentNodeInSpan(token, file, span); + if (!exportNode || (!ts.isSourceFile(exportNode.parent) && !(ts.isModuleBlock(exportNode.parent) && ts.isAmbientModule(exportNode.parent.parent)))) { + return { error: ts.getLocaleSpecificMessage(ts.Diagnostics.Could_not_find_export_statement) }; + } + var checker = program.getTypeChecker(); + var exportingModuleSymbol = getExportingModuleSymbol(exportNode, checker); + var flags = ts.getSyntacticModifierFlags(exportNode) || ((ts.isExportAssignment(exportNode) && !exportNode.isExportEquals) ? 1025 /* ModifierFlags.ExportDefault */ : 0 /* ModifierFlags.None */); + var wasDefault = !!(flags & 1024 /* ModifierFlags.Default */); + // If source file already has a default export, don't offer refactor. + if (!(flags & 1 /* ModifierFlags.Export */) || !wasDefault && exportingModuleSymbol.exports.has("default" /* InternalSymbolName.Default */)) { + return { error: ts.getLocaleSpecificMessage(ts.Diagnostics.This_file_already_has_a_default_export) }; + } + var noSymbolError = function (id) { + return (ts.isIdentifier(id) && checker.getSymbolAtLocation(id)) ? undefined + : { error: ts.getLocaleSpecificMessage(ts.Diagnostics.Can_only_convert_named_export) }; + }; + switch (exportNode.kind) { + case 259 /* SyntaxKind.FunctionDeclaration */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 264 /* SyntaxKind.ModuleDeclaration */: { + var node = exportNode; + if (!node.name) + return undefined; + return noSymbolError(node.name) + || { exportNode: node, exportName: node.name, wasDefault: wasDefault, exportingModuleSymbol: exportingModuleSymbol }; + } + case 240 /* SyntaxKind.VariableStatement */: { + var vs = exportNode; + // Must be `export const x = something;`. + if (!(vs.declarationList.flags & 2 /* NodeFlags.Const */) || vs.declarationList.declarations.length !== 1) { + return undefined; + } + var decl = ts.first(vs.declarationList.declarations); + if (!decl.initializer) + return undefined; + ts.Debug.assert(!wasDefault, "Can't have a default flag here"); + return noSymbolError(decl.name) + || { exportNode: vs, exportName: decl.name, wasDefault: wasDefault, exportingModuleSymbol: exportingModuleSymbol }; + } + case 274 /* SyntaxKind.ExportAssignment */: { + var node = exportNode; + if (node.isExportEquals) + return undefined; + return noSymbolError(node.expression) + || { exportNode: node, exportName: node.expression, wasDefault: wasDefault, exportingModuleSymbol: exportingModuleSymbol }; + } + default: + return undefined; + } + } + function doChange(exportingSourceFile, program, info, changes, cancellationToken) { + changeExport(exportingSourceFile, info, changes, program.getTypeChecker()); + changeImports(program, info, changes, cancellationToken); + } + function changeExport(exportingSourceFile, _a, changes, checker) { + var wasDefault = _a.wasDefault, exportNode = _a.exportNode, exportName = _a.exportName; + if (wasDefault) { + if (ts.isExportAssignment(exportNode) && !exportNode.isExportEquals) { + var exp = exportNode.expression; + var spec = makeExportSpecifier(exp.text, exp.text); + changes.replaceNode(exportingSourceFile, exportNode, ts.factory.createExportDeclaration(/*modifiers*/ undefined, /*isTypeOnly*/ false, ts.factory.createNamedExports([spec]))); + } + else { + changes.delete(exportingSourceFile, ts.Debug.checkDefined(ts.findModifier(exportNode, 88 /* SyntaxKind.DefaultKeyword */), "Should find a default keyword in modifier list")); + } + } + else { + var exportKeyword = ts.Debug.checkDefined(ts.findModifier(exportNode, 93 /* SyntaxKind.ExportKeyword */), "Should find an export keyword in modifier list"); + switch (exportNode.kind) { + case 259 /* SyntaxKind.FunctionDeclaration */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + changes.insertNodeAfter(exportingSourceFile, exportKeyword, ts.factory.createToken(88 /* SyntaxKind.DefaultKeyword */)); + break; + case 240 /* SyntaxKind.VariableStatement */: + // If 'x' isn't used in this file and doesn't have type definition, `export const x = 0;` --> `export default 0;` + var decl = ts.first(exportNode.declarationList.declarations); + if (!ts.FindAllReferences.Core.isSymbolReferencedInFile(exportName, checker, exportingSourceFile) && !decl.type) { + // We checked in `getInfo` that an initializer exists. + changes.replaceNode(exportingSourceFile, exportNode, ts.factory.createExportDefault(ts.Debug.checkDefined(decl.initializer, "Initializer was previously known to be present"))); + break; + } + // falls through + case 263 /* SyntaxKind.EnumDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 264 /* SyntaxKind.ModuleDeclaration */: + // `export type T = number;` -> `type T = number; export default T;` + changes.deleteModifier(exportingSourceFile, exportKeyword); + changes.insertNodeAfter(exportingSourceFile, exportNode, ts.factory.createExportDefault(ts.factory.createIdentifier(exportName.text))); + break; + default: + ts.Debug.fail("Unexpected exportNode kind ".concat(exportNode.kind)); + } + } + } + function changeImports(program, _a, changes, cancellationToken) { + var wasDefault = _a.wasDefault, exportName = _a.exportName, exportingModuleSymbol = _a.exportingModuleSymbol; + var checker = program.getTypeChecker(); + var exportSymbol = ts.Debug.checkDefined(checker.getSymbolAtLocation(exportName), "Export name should resolve to a symbol"); + ts.FindAllReferences.Core.eachExportReference(program.getSourceFiles(), checker, cancellationToken, exportSymbol, exportingModuleSymbol, exportName.text, wasDefault, function (ref) { + if (exportName === ref) + return; + var importingSourceFile = ref.getSourceFile(); + if (wasDefault) { + changeDefaultToNamedImport(importingSourceFile, ref, changes, exportName.text); + } + else { + changeNamedToDefaultImport(importingSourceFile, ref, changes); + } + }); + } + function changeDefaultToNamedImport(importingSourceFile, ref, changes, exportName) { + var parent = ref.parent; + switch (parent.kind) { + case 208 /* SyntaxKind.PropertyAccessExpression */: + // `a.default` --> `a.foo` + changes.replaceNode(importingSourceFile, ref, ts.factory.createIdentifier(exportName)); + break; + case 273 /* SyntaxKind.ImportSpecifier */: + case 278 /* SyntaxKind.ExportSpecifier */: { + var spec = parent; + // `default as foo` --> `foo`, `default as bar` --> `foo as bar` + changes.replaceNode(importingSourceFile, spec, makeImportSpecifier(exportName, spec.name.text)); + break; + } + case 270 /* SyntaxKind.ImportClause */: { + var clause = parent; + ts.Debug.assert(clause.name === ref, "Import clause name should match provided ref"); + var spec = makeImportSpecifier(exportName, ref.text); + var namedBindings = clause.namedBindings; + if (!namedBindings) { + // `import foo from "./a";` --> `import { foo } from "./a";` + changes.replaceNode(importingSourceFile, ref, ts.factory.createNamedImports([spec])); + } + else if (namedBindings.kind === 271 /* SyntaxKind.NamespaceImport */) { + // `import foo, * as a from "./a";` --> `import * as a from ".a/"; import { foo } from "./a";` + changes.deleteRange(importingSourceFile, { pos: ref.getStart(importingSourceFile), end: namedBindings.getStart(importingSourceFile) }); + var quotePreference = ts.isStringLiteral(clause.parent.moduleSpecifier) ? ts.quotePreferenceFromString(clause.parent.moduleSpecifier, importingSourceFile) : 1 /* QuotePreference.Double */; + var newImport = ts.makeImport(/*default*/ undefined, [makeImportSpecifier(exportName, ref.text)], clause.parent.moduleSpecifier, quotePreference); + changes.insertNodeAfter(importingSourceFile, clause.parent, newImport); + } + else { + // `import foo, { bar } from "./a"` --> `import { bar, foo } from "./a";` + changes.delete(importingSourceFile, ref); + changes.insertNodeAtEndOfList(importingSourceFile, namedBindings.elements, spec); + } + break; + } + case 202 /* SyntaxKind.ImportType */: + var importTypeNode = parent; + changes.replaceNode(importingSourceFile, parent, ts.factory.createImportTypeNode(importTypeNode.argument, importTypeNode.assertions, ts.factory.createIdentifier(exportName), importTypeNode.typeArguments, importTypeNode.isTypeOf)); + break; + default: + ts.Debug.failBadSyntaxKind(parent); + } + } + function changeNamedToDefaultImport(importingSourceFile, ref, changes) { + var parent = ref.parent; + switch (parent.kind) { + case 208 /* SyntaxKind.PropertyAccessExpression */: + // `a.foo` --> `a.default` + changes.replaceNode(importingSourceFile, ref, ts.factory.createIdentifier("default")); + break; + case 273 /* SyntaxKind.ImportSpecifier */: { + // `import { foo } from "./a";` --> `import foo from "./a";` + // `import { foo as bar } from "./a";` --> `import bar from "./a";` + var defaultImport = ts.factory.createIdentifier(parent.name.text); + if (parent.parent.elements.length === 1) { + changes.replaceNode(importingSourceFile, parent.parent, defaultImport); + } + else { + changes.delete(importingSourceFile, parent); + changes.insertNodeBefore(importingSourceFile, parent.parent, defaultImport); + } + break; + } + case 278 /* SyntaxKind.ExportSpecifier */: { + // `export { foo } from "./a";` --> `export { default as foo } from "./a";` + // `export { foo as bar } from "./a";` --> `export { default as bar } from "./a";` + // `export { foo as default } from "./a";` --> `export { default } from "./a";` + // (Because `export foo from "./a";` isn't valid syntax.) + changes.replaceNode(importingSourceFile, parent, makeExportSpecifier("default", parent.name.text)); + break; + } + default: + ts.Debug.assertNever(parent, "Unexpected parent kind ".concat(parent.kind)); + } + } + function makeImportSpecifier(propertyName, name) { + return ts.factory.createImportSpecifier(/*isTypeOnly*/ false, propertyName === name ? undefined : ts.factory.createIdentifier(propertyName), ts.factory.createIdentifier(name)); + } + function makeExportSpecifier(propertyName, name) { + return ts.factory.createExportSpecifier(/*isTypeOnly*/ false, propertyName === name ? undefined : ts.factory.createIdentifier(propertyName), ts.factory.createIdentifier(name)); + } + function getExportingModuleSymbol(node, checker) { + var parent = node.parent; + if (ts.isSourceFile(parent)) { + return parent.symbol; + } + var symbol = parent.parent.symbol; + if (symbol.valueDeclaration && ts.isExternalModuleAugmentation(symbol.valueDeclaration)) { + return checker.getMergedSymbol(symbol); + } + return symbol; + } + })(refactor = ts.refactor || (ts.refactor = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var refactor; + (function (refactor) { + var _a; + var refactorName = "Convert import"; + var actions = (_a = {}, + _a[0 /* ImportKind.Named */] = { + name: "Convert namespace import to named imports", + description: ts.Diagnostics.Convert_namespace_import_to_named_imports.message, + kind: "refactor.rewrite.import.named", + }, + _a[2 /* ImportKind.Namespace */] = { + name: "Convert named imports to namespace import", + description: ts.Diagnostics.Convert_named_imports_to_namespace_import.message, + kind: "refactor.rewrite.import.namespace", + }, + _a[1 /* ImportKind.Default */] = { + name: "Convert named imports to default import", + description: ts.Diagnostics.Convert_named_imports_to_default_import.message, + kind: "refactor.rewrite.import.default", + }, + _a); + refactor.registerRefactor(refactorName, { + kinds: ts.getOwnValues(actions).map(function (a) { return a.kind; }), + getAvailableActions: function getRefactorActionsToConvertBetweenNamedAndNamespacedImports(context) { + var info = getImportConversionInfo(context, context.triggerReason === "invoked"); + if (!info) + return ts.emptyArray; + if (!refactor.isRefactorErrorInfo(info)) { + var action = actions[info.convertTo]; + return [{ name: refactorName, description: action.description, actions: [action] }]; + } + if (context.preferences.provideRefactorNotApplicableReason) { + return ts.getOwnValues(actions).map(function (action) { return ({ + name: refactorName, + description: action.description, + actions: [__assign(__assign({}, action), { notApplicableReason: info.error })] + }); }); + } + return ts.emptyArray; + }, + getEditsForAction: function getRefactorEditsToConvertBetweenNamedAndNamespacedImports(context, actionName) { + ts.Debug.assert(ts.some(ts.getOwnValues(actions), function (action) { return action.name === actionName; }), "Unexpected action name"); + var info = getImportConversionInfo(context); + ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected applicable refactor info"); + var edits = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(context.file, context.program, t, info); }); + return { edits: edits, renameFilename: undefined, renameLocation: undefined }; + } + }); + function getImportConversionInfo(context, considerPartialSpans) { + if (considerPartialSpans === void 0) { considerPartialSpans = true; } + var file = context.file; + var span = ts.getRefactorContextSpan(context); + var token = ts.getTokenAtPosition(file, span.start); + var importDecl = considerPartialSpans ? ts.findAncestor(token, ts.isImportDeclaration) : ts.getParentNodeInSpan(token, file, span); + if (!importDecl || !ts.isImportDeclaration(importDecl)) + return { error: "Selection is not an import declaration." }; + var end = span.start + span.length; + var nextToken = ts.findNextToken(importDecl, importDecl.parent, file); + if (nextToken && end > nextToken.getStart()) + return undefined; + var importClause = importDecl.importClause; + if (!importClause) { + return { error: ts.getLocaleSpecificMessage(ts.Diagnostics.Could_not_find_import_clause) }; + } + if (!importClause.namedBindings) { + return { error: ts.getLocaleSpecificMessage(ts.Diagnostics.Could_not_find_namespace_import_or_named_imports) }; + } + if (importClause.namedBindings.kind === 271 /* SyntaxKind.NamespaceImport */) { + return { convertTo: 0 /* ImportKind.Named */, import: importClause.namedBindings }; + } + var shouldUseDefault = getShouldUseDefault(context.program, importClause); + return shouldUseDefault + ? { convertTo: 1 /* ImportKind.Default */, import: importClause.namedBindings } + : { convertTo: 2 /* ImportKind.Namespace */, import: importClause.namedBindings }; + } + function getShouldUseDefault(program, importClause) { + return ts.getAllowSyntheticDefaultImports(program.getCompilerOptions()) + && isExportEqualsModule(importClause.parent.moduleSpecifier, program.getTypeChecker()); + } + function doChange(sourceFile, program, changes, info) { + var checker = program.getTypeChecker(); + if (info.convertTo === 0 /* ImportKind.Named */) { + doChangeNamespaceToNamed(sourceFile, checker, changes, info.import, ts.getAllowSyntheticDefaultImports(program.getCompilerOptions())); + } + else { + doChangeNamedToNamespaceOrDefault(sourceFile, program, changes, info.import, info.convertTo === 1 /* ImportKind.Default */); + } + } + function doChangeNamespaceToNamed(sourceFile, checker, changes, toConvert, allowSyntheticDefaultImports) { + var usedAsNamespaceOrDefault = false; + var nodesToReplace = []; + var conflictingNames = new ts.Map(); + ts.FindAllReferences.Core.eachSymbolReferenceInFile(toConvert.name, checker, sourceFile, function (id) { + if (!ts.isPropertyAccessOrQualifiedName(id.parent)) { + usedAsNamespaceOrDefault = true; + } + else { + var exportName = getRightOfPropertyAccessOrQualifiedName(id.parent).text; + if (checker.resolveName(exportName, id, 67108863 /* SymbolFlags.All */, /*excludeGlobals*/ true)) { + conflictingNames.set(exportName, true); + } + ts.Debug.assert(getLeftOfPropertyAccessOrQualifiedName(id.parent) === id, "Parent expression should match id"); + nodesToReplace.push(id.parent); + } + }); + // We may need to change `mod.x` to `_x` to avoid a name conflict. + var exportNameToImportName = new ts.Map(); + for (var _i = 0, nodesToReplace_1 = nodesToReplace; _i < nodesToReplace_1.length; _i++) { + var propertyAccessOrQualifiedName = nodesToReplace_1[_i]; + var exportName = getRightOfPropertyAccessOrQualifiedName(propertyAccessOrQualifiedName).text; + var importName = exportNameToImportName.get(exportName); + if (importName === undefined) { + exportNameToImportName.set(exportName, importName = conflictingNames.has(exportName) ? ts.getUniqueName(exportName, sourceFile) : exportName); + } + changes.replaceNode(sourceFile, propertyAccessOrQualifiedName, ts.factory.createIdentifier(importName)); + } + var importSpecifiers = []; + exportNameToImportName.forEach(function (name, propertyName) { + importSpecifiers.push(ts.factory.createImportSpecifier(/*isTypeOnly*/ false, name === propertyName ? undefined : ts.factory.createIdentifier(propertyName), ts.factory.createIdentifier(name))); + }); + var importDecl = toConvert.parent.parent; + if (usedAsNamespaceOrDefault && !allowSyntheticDefaultImports) { + // Need to leave the namespace import alone + changes.insertNodeAfter(sourceFile, importDecl, updateImport(importDecl, /*defaultImportName*/ undefined, importSpecifiers)); + } + else { + changes.replaceNode(sourceFile, importDecl, updateImport(importDecl, usedAsNamespaceOrDefault ? ts.factory.createIdentifier(toConvert.name.text) : undefined, importSpecifiers)); + } + } + function getRightOfPropertyAccessOrQualifiedName(propertyAccessOrQualifiedName) { + return ts.isPropertyAccessExpression(propertyAccessOrQualifiedName) ? propertyAccessOrQualifiedName.name : propertyAccessOrQualifiedName.right; + } + function getLeftOfPropertyAccessOrQualifiedName(propertyAccessOrQualifiedName) { + return ts.isPropertyAccessExpression(propertyAccessOrQualifiedName) ? propertyAccessOrQualifiedName.expression : propertyAccessOrQualifiedName.left; + } + function doChangeNamedToNamespaceOrDefault(sourceFile, program, changes, toConvert, shouldUseDefault) { + if (shouldUseDefault === void 0) { shouldUseDefault = getShouldUseDefault(program, toConvert.parent); } + var checker = program.getTypeChecker(); + var importDecl = toConvert.parent.parent; + var moduleSpecifier = importDecl.moduleSpecifier; + var toConvertSymbols = new ts.Set(); + toConvert.elements.forEach(function (namedImport) { + var symbol = checker.getSymbolAtLocation(namedImport.name); + if (symbol) { + toConvertSymbols.add(symbol); + } + }); + var preferredName = moduleSpecifier && ts.isStringLiteral(moduleSpecifier) ? ts.codefix.moduleSpecifierToValidIdentifier(moduleSpecifier.text, 99 /* ScriptTarget.ESNext */) : "module"; + function hasNamespaceNameConflict(namedImport) { + // We need to check if the preferred namespace name (`preferredName`) we'd like to use in the refactored code will present a name conflict. + // A name conflict means that, in a scope where we would like to use the preferred namespace name, there already exists a symbol with that name in that scope. + // We are going to use the namespace name in the scopes the named imports being refactored are referenced, + // so we look for conflicts by looking at every reference to those named imports. + return !!ts.FindAllReferences.Core.eachSymbolReferenceInFile(namedImport.name, checker, sourceFile, function (id) { + var symbol = checker.resolveName(preferredName, id, 67108863 /* SymbolFlags.All */, /*excludeGlobals*/ true); + if (symbol) { // There already is a symbol with the same name as the preferred namespace name. + if (toConvertSymbols.has(symbol)) { // `preferredName` resolves to a symbol for one of the named import references we are going to transform into namespace import references... + return ts.isExportSpecifier(id.parent); // ...but if this reference is an export specifier, it will not be transformed, so it is a conflict; otherwise, it will be renamed and is not a conflict. + } + return true; // `preferredName` resolves to any other symbol, which will be present in the refactored code and so poses a name conflict. + } + return false; // There is no symbol with the same name as the preferred namespace name, so no conflict. + }); + } + var namespaceNameConflicts = toConvert.elements.some(hasNamespaceNameConflict); + var namespaceImportName = namespaceNameConflicts ? ts.getUniqueName(preferredName, sourceFile) : preferredName; + // Imports that need to be kept as named imports in the refactored code, to avoid changing the semantics. + // More specifically, those are named imports that appear in named exports in the original code, e.g. `a` in `import { a } from "m"; export { a }`. + var neededNamedImports = new ts.Set(); + var _loop_15 = function (element) { + var propertyName = (element.propertyName || element.name).text; + ts.FindAllReferences.Core.eachSymbolReferenceInFile(element.name, checker, sourceFile, function (id) { + var access = ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier(namespaceImportName), propertyName); + if (ts.isShorthandPropertyAssignment(id.parent)) { + changes.replaceNode(sourceFile, id.parent, ts.factory.createPropertyAssignment(id.text, access)); + } + else if (ts.isExportSpecifier(id.parent)) { + neededNamedImports.add(element); + } + else { + changes.replaceNode(sourceFile, id, access); + } + }); + }; + for (var _i = 0, _a = toConvert.elements; _i < _a.length; _i++) { + var element = _a[_i]; + _loop_15(element); + } + changes.replaceNode(sourceFile, toConvert, shouldUseDefault + ? ts.factory.createIdentifier(namespaceImportName) + : ts.factory.createNamespaceImport(ts.factory.createIdentifier(namespaceImportName))); + if (neededNamedImports.size) { + var newNamedImports = ts.arrayFrom(neededNamedImports.values()).map(function (element) { + return ts.factory.createImportSpecifier(element.isTypeOnly, element.propertyName && ts.factory.createIdentifier(element.propertyName.text), ts.factory.createIdentifier(element.name.text)); + }); + changes.insertNodeAfter(sourceFile, toConvert.parent.parent, updateImport(importDecl, /*defaultImportName*/ undefined, newNamedImports)); + } + } + refactor.doChangeNamedToNamespaceOrDefault = doChangeNamedToNamespaceOrDefault; + function isExportEqualsModule(moduleSpecifier, checker) { + var externalModule = checker.resolveExternalModuleName(moduleSpecifier); + if (!externalModule) + return false; + var exportEquals = checker.resolveExternalModuleSymbol(externalModule); + return externalModule !== exportEquals; + } + function updateImport(old, defaultImportName, elements) { + return ts.factory.createImportDeclaration(/*modifiers*/ undefined, ts.factory.createImportClause(/*isTypeOnly*/ false, defaultImportName, elements && elements.length ? ts.factory.createNamedImports(elements) : undefined), old.moduleSpecifier, /*assertClause*/ undefined); + } + })(refactor = ts.refactor || (ts.refactor = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var refactor; + (function (refactor) { + var convertToOptionalChainExpression; + (function (convertToOptionalChainExpression) { + var refactorName = "Convert to optional chain expression"; + var convertToOptionalChainExpressionMessage = ts.getLocaleSpecificMessage(ts.Diagnostics.Convert_to_optional_chain_expression); + var toOptionalChainAction = { + name: refactorName, + description: convertToOptionalChainExpressionMessage, + kind: "refactor.rewrite.expression.optionalChain", + }; + refactor.registerRefactor(refactorName, { + kinds: [toOptionalChainAction.kind], + getEditsForAction: getRefactorEditsToConvertToOptionalChain, + getAvailableActions: getRefactorActionsToConvertToOptionalChain, + }); + function getRefactorActionsToConvertToOptionalChain(context) { + var info = getInfo(context, context.triggerReason === "invoked"); + if (!info) + return ts.emptyArray; + if (!refactor.isRefactorErrorInfo(info)) { + return [{ + name: refactorName, + description: convertToOptionalChainExpressionMessage, + actions: [toOptionalChainAction], + }]; + } + if (context.preferences.provideRefactorNotApplicableReason) { + return [{ + name: refactorName, + description: convertToOptionalChainExpressionMessage, + actions: [__assign(__assign({}, toOptionalChainAction), { notApplicableReason: info.error })], + }]; + } + return ts.emptyArray; + } + function getRefactorEditsToConvertToOptionalChain(context, actionName) { + var info = getInfo(context); + ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected applicable refactor info"); + var edits = ts.textChanges.ChangeTracker.with(context, function (t) { + return doChange(context.file, context.program.getTypeChecker(), t, info, actionName); + }); + return { edits: edits, renameFilename: undefined, renameLocation: undefined }; + } + function isValidExpression(node) { + return ts.isBinaryExpression(node) || ts.isConditionalExpression(node); + } + function isValidStatement(node) { + return ts.isExpressionStatement(node) || ts.isReturnStatement(node) || ts.isVariableStatement(node); + } + function isValidExpressionOrStatement(node) { + return isValidExpression(node) || isValidStatement(node); + } + function getInfo(context, considerEmptySpans) { + if (considerEmptySpans === void 0) { considerEmptySpans = true; } + var file = context.file, program = context.program; + var span = ts.getRefactorContextSpan(context); + var forEmptySpan = span.length === 0; + if (forEmptySpan && !considerEmptySpans) + return undefined; + // selecting fo[|o && foo.ba|]r should be valid, so adjust span to fit start and end tokens + var startToken = ts.getTokenAtPosition(file, span.start); + var endToken = ts.findTokenOnLeftOfPosition(file, span.start + span.length); + var adjustedSpan = ts.createTextSpanFromBounds(startToken.pos, endToken && endToken.end >= startToken.pos ? endToken.getEnd() : startToken.getEnd()); + var parent = forEmptySpan ? getValidParentNodeOfEmptySpan(startToken) : getValidParentNodeContainingSpan(startToken, adjustedSpan); + var expression = parent && isValidExpressionOrStatement(parent) ? getExpression(parent) : undefined; + if (!expression) + return { error: ts.getLocaleSpecificMessage(ts.Diagnostics.Could_not_find_convertible_access_expression) }; + var checker = program.getTypeChecker(); + return ts.isConditionalExpression(expression) ? getConditionalInfo(expression, checker) : getBinaryInfo(expression); + } + function getConditionalInfo(expression, checker) { + var condition = expression.condition; + var finalExpression = getFinalExpressionInChain(expression.whenTrue); + if (!finalExpression || checker.isNullableType(checker.getTypeAtLocation(finalExpression))) { + return { error: ts.getLocaleSpecificMessage(ts.Diagnostics.Could_not_find_convertible_access_expression) }; + } + if ((ts.isPropertyAccessExpression(condition) || ts.isIdentifier(condition)) + && getMatchingStart(condition, finalExpression.expression)) { + return { finalExpression: finalExpression, occurrences: [condition], expression: expression }; + } + else if (ts.isBinaryExpression(condition)) { + var occurrences = getOccurrencesInExpression(finalExpression.expression, condition); + return occurrences ? { finalExpression: finalExpression, occurrences: occurrences, expression: expression } : + { error: ts.getLocaleSpecificMessage(ts.Diagnostics.Could_not_find_matching_access_expressions) }; + } + } + function getBinaryInfo(expression) { + if (expression.operatorToken.kind !== 55 /* SyntaxKind.AmpersandAmpersandToken */) { + return { error: ts.getLocaleSpecificMessage(ts.Diagnostics.Can_only_convert_logical_AND_access_chains) }; + } + var finalExpression = getFinalExpressionInChain(expression.right); + if (!finalExpression) + return { error: ts.getLocaleSpecificMessage(ts.Diagnostics.Could_not_find_convertible_access_expression) }; + var occurrences = getOccurrencesInExpression(finalExpression.expression, expression.left); + return occurrences ? { finalExpression: finalExpression, occurrences: occurrences, expression: expression } : + { error: ts.getLocaleSpecificMessage(ts.Diagnostics.Could_not_find_matching_access_expressions) }; + } + /** + * Gets a list of property accesses that appear in matchTo and occur in sequence in expression. + */ + function getOccurrencesInExpression(matchTo, expression) { + var occurrences = []; + while (ts.isBinaryExpression(expression) && expression.operatorToken.kind === 55 /* SyntaxKind.AmpersandAmpersandToken */) { + var match = getMatchingStart(ts.skipParentheses(matchTo), ts.skipParentheses(expression.right)); + if (!match) { + break; + } + occurrences.push(match); + matchTo = match; + expression = expression.left; + } + var finalMatch = getMatchingStart(matchTo, expression); + if (finalMatch) { + occurrences.push(finalMatch); + } + return occurrences.length > 0 ? occurrences : undefined; + } + /** + * Returns subchain if chain begins with subchain syntactically. + */ + function getMatchingStart(chain, subchain) { + if (!ts.isIdentifier(subchain) && !ts.isPropertyAccessExpression(subchain) && !ts.isElementAccessExpression(subchain)) { + return undefined; + } + return chainStartsWith(chain, subchain) ? subchain : undefined; + } + /** + * Returns true if chain begins with subchain syntactically. + */ + function chainStartsWith(chain, subchain) { + // skip until we find a matching identifier. + while (ts.isCallExpression(chain) || ts.isPropertyAccessExpression(chain) || ts.isElementAccessExpression(chain)) { + if (getTextOfChainNode(chain) === getTextOfChainNode(subchain)) + break; + chain = chain.expression; + } + // check that the chains match at each access. Call chains in subchain are not valid. + while ((ts.isPropertyAccessExpression(chain) && ts.isPropertyAccessExpression(subchain)) || + (ts.isElementAccessExpression(chain) && ts.isElementAccessExpression(subchain))) { + if (getTextOfChainNode(chain) !== getTextOfChainNode(subchain)) + return false; + chain = chain.expression; + subchain = subchain.expression; + } + // check if we have reached a final identifier. + return ts.isIdentifier(chain) && ts.isIdentifier(subchain) && chain.getText() === subchain.getText(); + } + function getTextOfChainNode(node) { + if (ts.isIdentifier(node) || ts.isStringOrNumericLiteralLike(node)) { + return node.getText(); + } + if (ts.isPropertyAccessExpression(node)) { + return getTextOfChainNode(node.name); + } + if (ts.isElementAccessExpression(node)) { + return getTextOfChainNode(node.argumentExpression); + } + return undefined; + } + /** + * Find the least ancestor of the input node that is a valid type for extraction and contains the input span. + */ + function getValidParentNodeContainingSpan(node, span) { + while (node.parent) { + if (isValidExpressionOrStatement(node) && span.length !== 0 && node.end >= span.start + span.length) { + return node; + } + node = node.parent; + } + return undefined; + } + /** + * Finds an ancestor of the input node that is a valid type for extraction, skipping subexpressions. + */ + function getValidParentNodeOfEmptySpan(node) { + while (node.parent) { + if (isValidExpressionOrStatement(node) && !isValidExpressionOrStatement(node.parent)) { + return node; + } + node = node.parent; + } + return undefined; + } + /** + * Gets an expression of valid extraction type from a valid statement or expression. + */ + function getExpression(node) { + if (isValidExpression(node)) { + return node; + } + if (ts.isVariableStatement(node)) { + var variable = ts.getSingleVariableOfVariableStatement(node); + var initializer = variable === null || variable === void 0 ? void 0 : variable.initializer; + return initializer && isValidExpression(initializer) ? initializer : undefined; + } + return node.expression && isValidExpression(node.expression) ? node.expression : undefined; + } + /** + * Gets a property access expression which may be nested inside of a binary expression. The final + * expression in an && chain will occur as the right child of the parent binary expression, unless + * it is followed by a different binary operator. + * @param node the right child of a binary expression or a call expression. + */ + function getFinalExpressionInChain(node) { + // foo && |foo.bar === 1|; - here the right child of the && binary expression is another binary expression. + // the rightmost member of the && chain should be the leftmost child of that expression. + node = ts.skipParentheses(node); + if (ts.isBinaryExpression(node)) { + return getFinalExpressionInChain(node.left); + } + // foo && |foo.bar()()| - nested calls are treated like further accesses. + else if ((ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node) || ts.isCallExpression(node)) && !ts.isOptionalChain(node)) { + return node; + } + return undefined; + } + /** + * Creates an access chain from toConvert with '?.' accesses at expressions appearing in occurrences. + */ + function convertOccurrences(checker, toConvert, occurrences) { + if (ts.isPropertyAccessExpression(toConvert) || ts.isElementAccessExpression(toConvert) || ts.isCallExpression(toConvert)) { + var chain = convertOccurrences(checker, toConvert.expression, occurrences); + var lastOccurrence = occurrences.length > 0 ? occurrences[occurrences.length - 1] : undefined; + var isOccurrence = (lastOccurrence === null || lastOccurrence === void 0 ? void 0 : lastOccurrence.getText()) === toConvert.expression.getText(); + if (isOccurrence) + occurrences.pop(); + if (ts.isCallExpression(toConvert)) { + return isOccurrence ? + ts.factory.createCallChain(chain, ts.factory.createToken(28 /* SyntaxKind.QuestionDotToken */), toConvert.typeArguments, toConvert.arguments) : + ts.factory.createCallChain(chain, toConvert.questionDotToken, toConvert.typeArguments, toConvert.arguments); + } + else if (ts.isPropertyAccessExpression(toConvert)) { + return isOccurrence ? + ts.factory.createPropertyAccessChain(chain, ts.factory.createToken(28 /* SyntaxKind.QuestionDotToken */), toConvert.name) : + ts.factory.createPropertyAccessChain(chain, toConvert.questionDotToken, toConvert.name); + } + else if (ts.isElementAccessExpression(toConvert)) { + return isOccurrence ? + ts.factory.createElementAccessChain(chain, ts.factory.createToken(28 /* SyntaxKind.QuestionDotToken */), toConvert.argumentExpression) : + ts.factory.createElementAccessChain(chain, toConvert.questionDotToken, toConvert.argumentExpression); + } + } + return toConvert; + } + function doChange(sourceFile, checker, changes, info, _actionName) { + var finalExpression = info.finalExpression, occurrences = info.occurrences, expression = info.expression; + var firstOccurrence = occurrences[occurrences.length - 1]; + var convertedChain = convertOccurrences(checker, finalExpression, occurrences); + if (convertedChain && (ts.isPropertyAccessExpression(convertedChain) || ts.isElementAccessExpression(convertedChain) || ts.isCallExpression(convertedChain))) { + if (ts.isBinaryExpression(expression)) { + changes.replaceNodeRange(sourceFile, firstOccurrence, finalExpression, convertedChain); + } + else if (ts.isConditionalExpression(expression)) { + changes.replaceNode(sourceFile, expression, ts.factory.createBinaryExpression(convertedChain, ts.factory.createToken(60 /* SyntaxKind.QuestionQuestionToken */), expression.whenFalse)); + } + } + } + })(convertToOptionalChainExpression = refactor.convertToOptionalChainExpression || (refactor.convertToOptionalChainExpression = {})); + })(refactor = ts.refactor || (ts.refactor = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var refactor; + (function (refactor) { + var addOrRemoveBracesToArrowFunction; + (function (addOrRemoveBracesToArrowFunction) { + var refactorName = "Convert overload list to single signature"; + var refactorDescription = ts.Diagnostics.Convert_overload_list_to_single_signature.message; + var functionOverloadAction = { + name: refactorName, + description: refactorDescription, + kind: "refactor.rewrite.function.overloadList", + }; + refactor.registerRefactor(refactorName, { + kinds: [functionOverloadAction.kind], + getEditsForAction: getRefactorEditsToConvertOverloadsToOneSignature, + getAvailableActions: getRefactorActionsToConvertOverloadsToOneSignature + }); + function getRefactorActionsToConvertOverloadsToOneSignature(context) { + var file = context.file, startPosition = context.startPosition, program = context.program; + var info = getConvertableOverloadListAtPosition(file, startPosition, program); + if (!info) + return ts.emptyArray; + return [{ + name: refactorName, + description: refactorDescription, + actions: [functionOverloadAction] + }]; + } + function getRefactorEditsToConvertOverloadsToOneSignature(context) { + var file = context.file, startPosition = context.startPosition, program = context.program; + var signatureDecls = getConvertableOverloadListAtPosition(file, startPosition, program); + if (!signatureDecls) + return undefined; + var checker = program.getTypeChecker(); + var lastDeclaration = signatureDecls[signatureDecls.length - 1]; + var updated = lastDeclaration; + switch (lastDeclaration.kind) { + case 170 /* SyntaxKind.MethodSignature */: { + updated = ts.factory.updateMethodSignature(lastDeclaration, lastDeclaration.modifiers, lastDeclaration.name, lastDeclaration.questionToken, lastDeclaration.typeParameters, getNewParametersForCombinedSignature(signatureDecls), lastDeclaration.type); + break; + } + case 171 /* SyntaxKind.MethodDeclaration */: { + updated = ts.factory.updateMethodDeclaration(lastDeclaration, lastDeclaration.modifiers, lastDeclaration.asteriskToken, lastDeclaration.name, lastDeclaration.questionToken, lastDeclaration.typeParameters, getNewParametersForCombinedSignature(signatureDecls), lastDeclaration.type, lastDeclaration.body); + break; + } + case 176 /* SyntaxKind.CallSignature */: { + updated = ts.factory.updateCallSignature(lastDeclaration, lastDeclaration.typeParameters, getNewParametersForCombinedSignature(signatureDecls), lastDeclaration.type); + break; + } + case 173 /* SyntaxKind.Constructor */: { + updated = ts.factory.updateConstructorDeclaration(lastDeclaration, lastDeclaration.modifiers, getNewParametersForCombinedSignature(signatureDecls), lastDeclaration.body); + break; + } + case 177 /* SyntaxKind.ConstructSignature */: { + updated = ts.factory.updateConstructSignature(lastDeclaration, lastDeclaration.typeParameters, getNewParametersForCombinedSignature(signatureDecls), lastDeclaration.type); + break; + } + case 259 /* SyntaxKind.FunctionDeclaration */: { + updated = ts.factory.updateFunctionDeclaration(lastDeclaration, lastDeclaration.modifiers, lastDeclaration.asteriskToken, lastDeclaration.name, lastDeclaration.typeParameters, getNewParametersForCombinedSignature(signatureDecls), lastDeclaration.type, lastDeclaration.body); + break; + } + default: return ts.Debug.failBadSyntaxKind(lastDeclaration, "Unhandled signature kind in overload list conversion refactoring"); + } + if (updated === lastDeclaration) { + return; // No edits to apply, do nothing + } + var edits = ts.textChanges.ChangeTracker.with(context, function (t) { + t.replaceNodeRange(file, signatureDecls[0], signatureDecls[signatureDecls.length - 1], updated); + }); + return { renameFilename: undefined, renameLocation: undefined, edits: edits }; + function getNewParametersForCombinedSignature(signatureDeclarations) { + var lastSig = signatureDeclarations[signatureDeclarations.length - 1]; + if (ts.isFunctionLikeDeclaration(lastSig) && lastSig.body) { + // Trim away implementation signature arguments (they should already be compatible with overloads, but are likely less precise to guarantee compatability with the overloads) + signatureDeclarations = signatureDeclarations.slice(0, signatureDeclarations.length - 1); + } + return ts.factory.createNodeArray([ + ts.factory.createParameterDeclaration( + /*modifiers*/ undefined, ts.factory.createToken(25 /* SyntaxKind.DotDotDotToken */), "args", + /*questionToken*/ undefined, ts.factory.createUnionTypeNode(ts.map(signatureDeclarations, convertSignatureParametersToTuple))) + ]); + } + function convertSignatureParametersToTuple(decl) { + var members = ts.map(decl.parameters, convertParameterToNamedTupleMember); + return ts.setEmitFlags(ts.factory.createTupleTypeNode(members), ts.some(members, function (m) { return !!ts.length(ts.getSyntheticLeadingComments(m)); }) ? 0 /* EmitFlags.None */ : 1 /* EmitFlags.SingleLine */); + } + function convertParameterToNamedTupleMember(p) { + ts.Debug.assert(ts.isIdentifier(p.name)); // This is checked during refactoring applicability checking + var result = ts.setTextRange(ts.factory.createNamedTupleMember(p.dotDotDotToken, p.name, p.questionToken, p.type || ts.factory.createKeywordTypeNode(131 /* SyntaxKind.AnyKeyword */)), p); + var parameterDocComment = p.symbol && p.symbol.getDocumentationComment(checker); + if (parameterDocComment) { + var newComment = ts.displayPartsToString(parameterDocComment); + if (newComment.length) { + ts.setSyntheticLeadingComments(result, [{ + text: "*\n".concat(newComment.split("\n").map(function (c) { return " * ".concat(c); }).join("\n"), "\n "), + kind: 3 /* SyntaxKind.MultiLineCommentTrivia */, + pos: -1, + end: -1, + hasTrailingNewLine: true, + hasLeadingNewline: true, + }]); + } + } + return result; + } + } + function isConvertableSignatureDeclaration(d) { + switch (d.kind) { + case 170 /* SyntaxKind.MethodSignature */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 176 /* SyntaxKind.CallSignature */: + case 173 /* SyntaxKind.Constructor */: + case 177 /* SyntaxKind.ConstructSignature */: + case 259 /* SyntaxKind.FunctionDeclaration */: + return true; + } + return false; + } + function getConvertableOverloadListAtPosition(file, startPosition, program) { + var node = ts.getTokenAtPosition(file, startPosition); + var containingDecl = ts.findAncestor(node, isConvertableSignatureDeclaration); + if (!containingDecl) { + return; + } + if (ts.isFunctionLikeDeclaration(containingDecl) && containingDecl.body && ts.rangeContainsPosition(containingDecl.body, startPosition)) { + return; + } + var checker = program.getTypeChecker(); + var signatureSymbol = containingDecl.symbol; + if (!signatureSymbol) { + return; + } + var decls = signatureSymbol.declarations; + if (ts.length(decls) <= 1) { + return; + } + if (!ts.every(decls, function (d) { return ts.getSourceFileOfNode(d) === file; })) { + return; + } + if (!isConvertableSignatureDeclaration(decls[0])) { + return; + } + var kindOne = decls[0].kind; + if (!ts.every(decls, function (d) { return d.kind === kindOne; })) { + return; + } + var signatureDecls = decls; + if (ts.some(signatureDecls, function (d) { return !!d.typeParameters || ts.some(d.parameters, function (p) { return !!p.modifiers || !ts.isIdentifier(p.name); }); })) { + return; + } + var signatures = ts.mapDefined(signatureDecls, function (d) { return checker.getSignatureFromDeclaration(d); }); + if (ts.length(signatures) !== ts.length(decls)) { + return; + } + var returnOne = checker.getReturnTypeOfSignature(signatures[0]); + if (!ts.every(signatures, function (s) { return checker.getReturnTypeOfSignature(s) === returnOne; })) { + return; + } + return signatureDecls; + } + })(addOrRemoveBracesToArrowFunction = refactor.addOrRemoveBracesToArrowFunction || (refactor.addOrRemoveBracesToArrowFunction = {})); + })(refactor = ts.refactor || (ts.refactor = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var refactor; + (function (refactor) { + var extractSymbol; + (function (extractSymbol) { + var refactorName = "Extract Symbol"; + var extractConstantAction = { + name: "Extract Constant", + description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_constant), + kind: "refactor.extract.constant", + }; + var extractFunctionAction = { + name: "Extract Function", + description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_function), + kind: "refactor.extract.function", + }; + refactor.registerRefactor(refactorName, { + kinds: [ + extractConstantAction.kind, + extractFunctionAction.kind + ], + getEditsForAction: getRefactorEditsToExtractSymbol, + getAvailableActions: getRefactorActionsToExtractSymbol, + }); + /** + * Compute the associated code actions + * Exported for tests. + */ + function getRefactorActionsToExtractSymbol(context) { + var requestedRefactor = context.kind; + var rangeToExtract = getRangeToExtract(context.file, ts.getRefactorContextSpan(context), context.triggerReason === "invoked"); + var targetRange = rangeToExtract.targetRange; + if (targetRange === undefined) { + if (!rangeToExtract.errors || rangeToExtract.errors.length === 0 || !context.preferences.provideRefactorNotApplicableReason) { + return ts.emptyArray; + } + var errors = []; + if (refactor.refactorKindBeginsWith(extractFunctionAction.kind, requestedRefactor)) { + errors.push({ + name: refactorName, + description: extractFunctionAction.description, + actions: [__assign(__assign({}, extractFunctionAction), { notApplicableReason: getStringError(rangeToExtract.errors) })] + }); + } + if (refactor.refactorKindBeginsWith(extractConstantAction.kind, requestedRefactor)) { + errors.push({ + name: refactorName, + description: extractConstantAction.description, + actions: [__assign(__assign({}, extractConstantAction), { notApplicableReason: getStringError(rangeToExtract.errors) })] + }); + } + return errors; + } + var extractions = getPossibleExtractions(targetRange, context); + if (extractions === undefined) { + // No extractions possible + return ts.emptyArray; + } + var functionActions = []; + var usedFunctionNames = new ts.Map(); + var innermostErrorFunctionAction; + var constantActions = []; + var usedConstantNames = new ts.Map(); + var innermostErrorConstantAction; + var i = 0; + for (var _i = 0, extractions_1 = extractions; _i < extractions_1.length; _i++) { + var _a = extractions_1[_i], functionExtraction = _a.functionExtraction, constantExtraction = _a.constantExtraction; + if (refactor.refactorKindBeginsWith(extractFunctionAction.kind, requestedRefactor)) { + var description = functionExtraction.description; + if (functionExtraction.errors.length === 0) { + // Don't issue refactorings with duplicated names. + // Scopes come back in "innermost first" order, so extractions will + // preferentially go into nearer scopes + if (!usedFunctionNames.has(description)) { + usedFunctionNames.set(description, true); + functionActions.push({ + description: description, + name: "function_scope_".concat(i), + kind: extractFunctionAction.kind + }); + } + } + else if (!innermostErrorFunctionAction) { + innermostErrorFunctionAction = { + description: description, + name: "function_scope_".concat(i), + notApplicableReason: getStringError(functionExtraction.errors), + kind: extractFunctionAction.kind + }; + } + } + if (refactor.refactorKindBeginsWith(extractConstantAction.kind, requestedRefactor)) { + var description = constantExtraction.description; + if (constantExtraction.errors.length === 0) { + // Don't issue refactorings with duplicated names. + // Scopes come back in "innermost first" order, so extractions will + // preferentially go into nearer scopes + if (!usedConstantNames.has(description)) { + usedConstantNames.set(description, true); + constantActions.push({ + description: description, + name: "constant_scope_".concat(i), + kind: extractConstantAction.kind + }); + } + } + else if (!innermostErrorConstantAction) { + innermostErrorConstantAction = { + description: description, + name: "constant_scope_".concat(i), + notApplicableReason: getStringError(constantExtraction.errors), + kind: extractConstantAction.kind + }; + } + } + // *do* increment i anyway because we'll look for the i-th scope + // later when actually doing the refactoring if the user requests it + i++; + } + var infos = []; + if (functionActions.length) { + infos.push({ + name: refactorName, + description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_function), + actions: functionActions, + }); + } + else if (context.preferences.provideRefactorNotApplicableReason && innermostErrorFunctionAction) { + infos.push({ + name: refactorName, + description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_function), + actions: [innermostErrorFunctionAction] + }); + } + if (constantActions.length) { + infos.push({ + name: refactorName, + description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_constant), + actions: constantActions + }); + } + else if (context.preferences.provideRefactorNotApplicableReason && innermostErrorConstantAction) { + infos.push({ + name: refactorName, + description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_constant), + actions: [innermostErrorConstantAction] + }); + } + return infos.length ? infos : ts.emptyArray; + function getStringError(errors) { + var error = errors[0].messageText; + if (typeof error !== "string") { + error = error.messageText; + } + return error; + } + } + extractSymbol.getRefactorActionsToExtractSymbol = getRefactorActionsToExtractSymbol; + /* Exported for tests */ + function getRefactorEditsToExtractSymbol(context, actionName) { + var rangeToExtract = getRangeToExtract(context.file, ts.getRefactorContextSpan(context)); + var targetRange = rangeToExtract.targetRange; // TODO:GH#18217 + var parsedFunctionIndexMatch = /^function_scope_(\d+)$/.exec(actionName); + if (parsedFunctionIndexMatch) { + var index = +parsedFunctionIndexMatch[1]; + ts.Debug.assert(isFinite(index), "Expected to parse a finite number from the function scope index"); + return getFunctionExtractionAtIndex(targetRange, context, index); + } + var parsedConstantIndexMatch = /^constant_scope_(\d+)$/.exec(actionName); + if (parsedConstantIndexMatch) { + var index = +parsedConstantIndexMatch[1]; + ts.Debug.assert(isFinite(index), "Expected to parse a finite number from the constant scope index"); + return getConstantExtractionAtIndex(targetRange, context, index); + } + ts.Debug.fail("Unrecognized action name"); + } + extractSymbol.getRefactorEditsToExtractSymbol = getRefactorEditsToExtractSymbol; + // Move these into diagnostic messages if they become user-facing + var Messages; + (function (Messages) { + function createMessage(message) { + return { message: message, code: 0, category: ts.DiagnosticCategory.Message, key: message }; + } + Messages.cannotExtractRange = createMessage("Cannot extract range."); + Messages.cannotExtractImport = createMessage("Cannot extract import statement."); + Messages.cannotExtractSuper = createMessage("Cannot extract super call."); + Messages.cannotExtractJSDoc = createMessage("Cannot extract JSDoc."); + Messages.cannotExtractEmpty = createMessage("Cannot extract empty range."); + Messages.expressionExpected = createMessage("expression expected."); + Messages.uselessConstantType = createMessage("No reason to extract constant of type."); + Messages.statementOrExpressionExpected = createMessage("Statement or expression expected."); + Messages.cannotExtractRangeContainingConditionalBreakOrContinueStatements = createMessage("Cannot extract range containing conditional break or continue statements."); + Messages.cannotExtractRangeContainingConditionalReturnStatement = createMessage("Cannot extract range containing conditional return statement."); + Messages.cannotExtractRangeContainingLabeledBreakOrContinueStatementWithTargetOutsideOfTheRange = createMessage("Cannot extract range containing labeled break or continue with target outside of the range."); + Messages.cannotExtractRangeThatContainsWritesToReferencesLocatedOutsideOfTheTargetRangeInGenerators = createMessage("Cannot extract range containing writes to references located outside of the target range in generators."); + Messages.typeWillNotBeVisibleInTheNewScope = createMessage("Type will not visible in the new scope."); + Messages.functionWillNotBeVisibleInTheNewScope = createMessage("Function will not visible in the new scope."); + Messages.cannotExtractIdentifier = createMessage("Select more than a single identifier."); + Messages.cannotExtractExportedEntity = createMessage("Cannot extract exported declaration"); + Messages.cannotWriteInExpression = createMessage("Cannot write back side-effects when extracting an expression"); + Messages.cannotExtractReadonlyPropertyInitializerOutsideConstructor = createMessage("Cannot move initialization of read-only class property outside of the constructor"); + Messages.cannotExtractAmbientBlock = createMessage("Cannot extract code from ambient contexts"); + Messages.cannotAccessVariablesFromNestedScopes = createMessage("Cannot access variables from nested scopes"); + Messages.cannotExtractToJSClass = createMessage("Cannot extract constant to a class scope in JS"); + Messages.cannotExtractToExpressionArrowFunction = createMessage("Cannot extract constant to an arrow function without a block"); + Messages.cannotExtractFunctionsContainingThisToMethod = createMessage("Cannot extract functions containing this to method"); + })(Messages = extractSymbol.Messages || (extractSymbol.Messages = {})); + var RangeFacts; + (function (RangeFacts) { + RangeFacts[RangeFacts["None"] = 0] = "None"; + RangeFacts[RangeFacts["HasReturn"] = 1] = "HasReturn"; + RangeFacts[RangeFacts["IsGenerator"] = 2] = "IsGenerator"; + RangeFacts[RangeFacts["IsAsyncFunction"] = 4] = "IsAsyncFunction"; + RangeFacts[RangeFacts["UsesThis"] = 8] = "UsesThis"; + RangeFacts[RangeFacts["UsesThisInFunction"] = 16] = "UsesThisInFunction"; + /** + * The range is in a function which needs the 'static' modifier in a class + */ + RangeFacts[RangeFacts["InStaticRegion"] = 32] = "InStaticRegion"; + })(RangeFacts || (RangeFacts = {})); + /** + * getRangeToExtract takes a span inside a text file and returns either an expression or an array + * of statements representing the minimum set of nodes needed to extract the entire span. This + * process may fail, in which case a set of errors is returned instead. These errors are shown to + * users if they have the provideRefactorNotApplicableReason option set. + */ + // exported only for tests + function getRangeToExtract(sourceFile, span, invoked) { + if (invoked === void 0) { invoked = true; } + var length = span.length; + if (length === 0 && !invoked) { + return { errors: [ts.createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractEmpty)] }; + } + var cursorRequest = length === 0 && invoked; + var startToken = ts.findFirstNonJsxWhitespaceToken(sourceFile, span.start); + var endToken = ts.findTokenOnLeftOfPosition(sourceFile, ts.textSpanEnd(span)); + /* If the refactoring command is invoked through a keyboard action it's safe to assume that the user is actively looking for + refactoring actions at the span location. As they may not know the exact range that will trigger a refactoring, we expand the + searched span to cover a real node range making it more likely that something useful will show up. */ + var adjustedSpan = startToken && endToken && invoked ? getAdjustedSpanFromNodes(startToken, endToken, sourceFile) : span; + // Walk up starting from the the start position until we find a non-SourceFile node that subsumes the selected span. + // This may fail (e.g. you select two statements in the root of a source file) + var start = cursorRequest ? getExtractableParent(startToken) : ts.getParentNodeInSpan(startToken, sourceFile, adjustedSpan); + // Do the same for the ending position + var end = cursorRequest ? start : ts.getParentNodeInSpan(endToken, sourceFile, adjustedSpan); + // We'll modify these flags as we walk the tree to collect data + // about what things need to be done as part of the extraction. + var rangeFacts = RangeFacts.None; + var thisNode; + if (!start || !end) { + // cannot find either start or end node + return { errors: [ts.createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractRange)] }; + } + if (start.flags & 8388608 /* NodeFlags.JSDoc */) { + return { errors: [ts.createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractJSDoc)] }; + } + if (start.parent !== end.parent) { + // start and end nodes belong to different subtrees + return { errors: [ts.createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractRange)] }; + } + if (start !== end) { + // start and end should be statements and parent should be either block or a source file + if (!isBlockLike(start.parent)) { + return { errors: [ts.createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractRange)] }; + } + var statements = []; + for (var _i = 0, _a = start.parent.statements; _i < _a.length; _i++) { + var statement = _a[_i]; + if (statement === start || statements.length) { + var errors_1 = checkNode(statement); + if (errors_1) { + return { errors: errors_1 }; + } + statements.push(statement); + } + if (statement === end) { + break; + } + } + if (!statements.length) { + // https://github.com/Microsoft/TypeScript/issues/20559 + // Ranges like [|case 1: break;|] will fail to populate `statements` because + // they will never find `start` in `start.parent.statements`. + // Consider: We could support ranges like [|case 1:|] by refining them to just + // the expression. + return { errors: [ts.createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractRange)] }; + } + return { targetRange: { range: statements, facts: rangeFacts, thisNode: thisNode } }; + } + if (ts.isReturnStatement(start) && !start.expression) { + // Makes no sense to extract an expression-less return statement. + return { errors: [ts.createFileDiagnostic(sourceFile, span.start, length, Messages.cannotExtractRange)] }; + } + // We have a single node (start) + var node = refineNode(start); + var errors = checkRootNode(node) || checkNode(node); + if (errors) { + return { errors: errors }; + } + return { targetRange: { range: getStatementOrExpressionRange(node), facts: rangeFacts, thisNode: thisNode } }; // TODO: GH#18217 + /** + * Attempt to refine the extraction node (generally, by shrinking it) to produce better results. + * @param node The unrefined extraction node. + */ + function refineNode(node) { + if (ts.isReturnStatement(node)) { + if (node.expression) { + return node.expression; + } + } + else if (ts.isVariableStatement(node) || ts.isVariableDeclarationList(node)) { + var declarations = ts.isVariableStatement(node) ? node.declarationList.declarations : node.declarations; + var numInitializers = 0; + var lastInitializer = void 0; + for (var _i = 0, declarations_5 = declarations; _i < declarations_5.length; _i++) { + var declaration = declarations_5[_i]; + if (declaration.initializer) { + numInitializers++; + lastInitializer = declaration.initializer; + } + } + if (numInitializers === 1) { + return lastInitializer; + } + // No special handling if there are multiple initializers. + } + else if (ts.isVariableDeclaration(node)) { + if (node.initializer) { + return node.initializer; + } + } + return node; + } + function checkRootNode(node) { + if (ts.isIdentifier(ts.isExpressionStatement(node) ? node.expression : node)) { + return [ts.createDiagnosticForNode(node, Messages.cannotExtractIdentifier)]; + } + return undefined; + } + function checkForStaticContext(nodeToCheck, containingClass) { + var current = nodeToCheck; + while (current !== containingClass) { + if (current.kind === 169 /* SyntaxKind.PropertyDeclaration */) { + if (ts.isStatic(current)) { + rangeFacts |= RangeFacts.InStaticRegion; + } + break; + } + else if (current.kind === 166 /* SyntaxKind.Parameter */) { + var ctorOrMethod = ts.getContainingFunction(current); + if (ctorOrMethod.kind === 173 /* SyntaxKind.Constructor */) { + rangeFacts |= RangeFacts.InStaticRegion; + } + break; + } + else if (current.kind === 171 /* SyntaxKind.MethodDeclaration */) { + if (ts.isStatic(current)) { + rangeFacts |= RangeFacts.InStaticRegion; + } + } + current = current.parent; + } + } + // Verifies whether we can actually extract this node or not. + function checkNode(nodeToCheck) { + var PermittedJumps; + (function (PermittedJumps) { + PermittedJumps[PermittedJumps["None"] = 0] = "None"; + PermittedJumps[PermittedJumps["Break"] = 1] = "Break"; + PermittedJumps[PermittedJumps["Continue"] = 2] = "Continue"; + PermittedJumps[PermittedJumps["Return"] = 4] = "Return"; + })(PermittedJumps || (PermittedJumps = {})); + // We believe it's true because the node is from the (unmodified) tree. + ts.Debug.assert(nodeToCheck.pos <= nodeToCheck.end, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809 (1)"); + // For understanding how skipTrivia functioned: + ts.Debug.assert(!ts.positionIsSynthesized(nodeToCheck.pos), "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809 (2)"); + if (!ts.isStatement(nodeToCheck) && !(ts.isExpressionNode(nodeToCheck) && isExtractableExpression(nodeToCheck)) && !isStringLiteralJsxAttribute(nodeToCheck)) { + return [ts.createDiagnosticForNode(nodeToCheck, Messages.statementOrExpressionExpected)]; + } + if (nodeToCheck.flags & 16777216 /* NodeFlags.Ambient */) { + return [ts.createDiagnosticForNode(nodeToCheck, Messages.cannotExtractAmbientBlock)]; + } + // If we're in a class, see whether we're in a static region (static property initializer, static method, class constructor parameter default) + var containingClass = ts.getContainingClass(nodeToCheck); + if (containingClass) { + checkForStaticContext(nodeToCheck, containingClass); + } + var errors; + var permittedJumps = 4 /* PermittedJumps.Return */; + var seenLabels; + visit(nodeToCheck); + if (rangeFacts & RangeFacts.UsesThis) { + var container = ts.getThisContainer(nodeToCheck, /** includeArrowFunctions */ false); + if (container.kind === 259 /* SyntaxKind.FunctionDeclaration */ || + (container.kind === 171 /* SyntaxKind.MethodDeclaration */ && container.parent.kind === 207 /* SyntaxKind.ObjectLiteralExpression */) || + container.kind === 215 /* SyntaxKind.FunctionExpression */) { + rangeFacts |= RangeFacts.UsesThisInFunction; + } + } + return errors; + function visit(node) { + if (errors) { + // already found an error - can stop now + return true; + } + if (ts.isDeclaration(node)) { + var declaringNode = (node.kind === 257 /* SyntaxKind.VariableDeclaration */) ? node.parent.parent : node; + if (ts.hasSyntacticModifier(declaringNode, 1 /* ModifierFlags.Export */)) { + // TODO: GH#18217 Silly to use `errors ||` since it's definitely not defined (see top of `visit`) + // Also, if we're only pushing one error, just use `let error: Diagnostic | undefined`! + // Also TODO: GH#19956 + (errors || (errors = [])).push(ts.createDiagnosticForNode(node, Messages.cannotExtractExportedEntity)); + return true; + } + } + // Some things can't be extracted in certain situations + switch (node.kind) { + case 269 /* SyntaxKind.ImportDeclaration */: + (errors || (errors = [])).push(ts.createDiagnosticForNode(node, Messages.cannotExtractImport)); + return true; + case 274 /* SyntaxKind.ExportAssignment */: + (errors || (errors = [])).push(ts.createDiagnosticForNode(node, Messages.cannotExtractExportedEntity)); + return true; + case 106 /* SyntaxKind.SuperKeyword */: + // For a super *constructor call*, we have to be extracting the entire class, + // but a super *method call* simply implies a 'this' reference + if (node.parent.kind === 210 /* SyntaxKind.CallExpression */) { + // Super constructor call + var containingClass_1 = ts.getContainingClass(node); + if (containingClass_1 === undefined || containingClass_1.pos < span.start || containingClass_1.end >= (span.start + span.length)) { + (errors || (errors = [])).push(ts.createDiagnosticForNode(node, Messages.cannotExtractSuper)); + return true; + } + } + else { + rangeFacts |= RangeFacts.UsesThis; + thisNode = node; + } + break; + case 216 /* SyntaxKind.ArrowFunction */: + // check if arrow function uses this + ts.forEachChild(node, function check(n) { + if (ts.isThis(n)) { + rangeFacts |= RangeFacts.UsesThis; + thisNode = node; + } + else if (ts.isClassLike(n) || (ts.isFunctionLike(n) && !ts.isArrowFunction(n))) { + return false; + } + else { + ts.forEachChild(n, check); + } + }); + // falls through + case 260 /* SyntaxKind.ClassDeclaration */: + case 259 /* SyntaxKind.FunctionDeclaration */: + if (ts.isSourceFile(node.parent) && node.parent.externalModuleIndicator === undefined) { + // You cannot extract global declarations + (errors || (errors = [])).push(ts.createDiagnosticForNode(node, Messages.functionWillNotBeVisibleInTheNewScope)); + } + // falls through + case 228 /* SyntaxKind.ClassExpression */: + case 215 /* SyntaxKind.FunctionExpression */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 173 /* SyntaxKind.Constructor */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + // do not dive into functions or classes + return false; + } + var savedPermittedJumps = permittedJumps; + switch (node.kind) { + case 242 /* SyntaxKind.IfStatement */: + permittedJumps &= ~4 /* PermittedJumps.Return */; + break; + case 255 /* SyntaxKind.TryStatement */: + // forbid all jumps inside try blocks + permittedJumps = 0 /* PermittedJumps.None */; + break; + case 238 /* SyntaxKind.Block */: + if (node.parent && node.parent.kind === 255 /* SyntaxKind.TryStatement */ && node.parent.finallyBlock === node) { + // allow unconditional returns from finally blocks + permittedJumps = 4 /* PermittedJumps.Return */; + } + break; + case 293 /* SyntaxKind.DefaultClause */: + case 292 /* SyntaxKind.CaseClause */: + // allow unlabeled break inside case clauses + permittedJumps |= 1 /* PermittedJumps.Break */; + break; + default: + if (ts.isIterationStatement(node, /*lookInLabeledStatements*/ false)) { + // allow unlabeled break/continue inside loops + permittedJumps |= 1 /* PermittedJumps.Break */ | 2 /* PermittedJumps.Continue */; + } + break; + } + switch (node.kind) { + case 194 /* SyntaxKind.ThisType */: + case 108 /* SyntaxKind.ThisKeyword */: + rangeFacts |= RangeFacts.UsesThis; + thisNode = node; + break; + case 253 /* SyntaxKind.LabeledStatement */: { + var label = node.label; + (seenLabels || (seenLabels = [])).push(label.escapedText); + ts.forEachChild(node, visit); + seenLabels.pop(); + break; + } + case 249 /* SyntaxKind.BreakStatement */: + case 248 /* SyntaxKind.ContinueStatement */: { + var label = node.label; + if (label) { + if (!ts.contains(seenLabels, label.escapedText)) { + // attempts to jump to label that is not in range to be extracted + (errors || (errors = [])).push(ts.createDiagnosticForNode(node, Messages.cannotExtractRangeContainingLabeledBreakOrContinueStatementWithTargetOutsideOfTheRange)); + } + } + else { + if (!(permittedJumps & (node.kind === 249 /* SyntaxKind.BreakStatement */ ? 1 /* PermittedJumps.Break */ : 2 /* PermittedJumps.Continue */))) { + // attempt to break or continue in a forbidden context + (errors || (errors = [])).push(ts.createDiagnosticForNode(node, Messages.cannotExtractRangeContainingConditionalBreakOrContinueStatements)); + } + } + break; + } + case 220 /* SyntaxKind.AwaitExpression */: + rangeFacts |= RangeFacts.IsAsyncFunction; + break; + case 226 /* SyntaxKind.YieldExpression */: + rangeFacts |= RangeFacts.IsGenerator; + break; + case 250 /* SyntaxKind.ReturnStatement */: + if (permittedJumps & 4 /* PermittedJumps.Return */) { + rangeFacts |= RangeFacts.HasReturn; + } + else { + (errors || (errors = [])).push(ts.createDiagnosticForNode(node, Messages.cannotExtractRangeContainingConditionalReturnStatement)); + } + break; + default: + ts.forEachChild(node, visit); + break; + } + permittedJumps = savedPermittedJumps; + } + } + } + extractSymbol.getRangeToExtract = getRangeToExtract; + /** + * Includes the final semicolon so that the span covers statements in cases where it would otherwise + * only cover the declaration list. + */ + function getAdjustedSpanFromNodes(startNode, endNode, sourceFile) { + var start = startNode.getStart(sourceFile); + var end = endNode.getEnd(); + if (sourceFile.text.charCodeAt(end) === 59 /* CharacterCodes.semicolon */) { + end++; + } + return { start: start, length: end - start }; + } + function getStatementOrExpressionRange(node) { + if (ts.isStatement(node)) { + return [node]; + } + if (ts.isExpressionNode(node)) { + // If our selection is the expression in an ExpressionStatement, expand + // the selection to include the enclosing Statement (this stops us + // from trying to care about the return value of the extracted function + // and eliminates double semicolon insertion in certain scenarios) + return ts.isExpressionStatement(node.parent) ? [node.parent] : node; + } + if (isStringLiteralJsxAttribute(node)) { + return node; + } + return undefined; + } + function isScope(node) { + return ts.isArrowFunction(node) ? ts.isFunctionBody(node.body) : + ts.isFunctionLikeDeclaration(node) || ts.isSourceFile(node) || ts.isModuleBlock(node) || ts.isClassLike(node); + } + /** + * Computes possible places we could extract the function into. For example, + * you may be able to extract into a class method *or* local closure *or* namespace function, + * depending on what's in the extracted body. + */ + function collectEnclosingScopes(range) { + var current = isReadonlyArray(range.range) ? ts.first(range.range) : range.range; + if (range.facts & RangeFacts.UsesThis && !(range.facts & RangeFacts.UsesThisInFunction)) { + // if range uses this as keyword or as type inside the class then it can only be extracted to a method of the containing class + var containingClass = ts.getContainingClass(current); + if (containingClass) { + var containingFunction = ts.findAncestor(current, ts.isFunctionLikeDeclaration); + return containingFunction + ? [containingFunction, containingClass] + : [containingClass]; + } + } + var scopes = []; + while (true) { + current = current.parent; + // A function parameter's initializer is actually in the outer scope, not the function declaration + if (current.kind === 166 /* SyntaxKind.Parameter */) { + // Skip all the way to the outer scope of the function that declared this parameter + current = ts.findAncestor(current, function (parent) { return ts.isFunctionLikeDeclaration(parent); }).parent; + } + // We want to find the nearest parent where we can place an "equivalent" sibling to the node we're extracting out of. + // Walk up to the closest parent of a place where we can logically put a sibling: + // * Function declaration + // * Class declaration or expression + // * Module/namespace or source file + if (isScope(current)) { + scopes.push(current); + if (current.kind === 308 /* SyntaxKind.SourceFile */) { + return scopes; + } + } + } + } + function getFunctionExtractionAtIndex(targetRange, context, requestedChangesIndex) { + var _a = getPossibleExtractionsWorker(targetRange, context), scopes = _a.scopes, _b = _a.readsAndWrites, target = _b.target, usagesPerScope = _b.usagesPerScope, functionErrorsPerScope = _b.functionErrorsPerScope, exposedVariableDeclarations = _b.exposedVariableDeclarations; + ts.Debug.assert(!functionErrorsPerScope[requestedChangesIndex].length, "The extraction went missing? How?"); + context.cancellationToken.throwIfCancellationRequested(); // TODO: GH#18217 + return extractFunctionInScope(target, scopes[requestedChangesIndex], usagesPerScope[requestedChangesIndex], exposedVariableDeclarations, targetRange, context); + } + function getConstantExtractionAtIndex(targetRange, context, requestedChangesIndex) { + var _a = getPossibleExtractionsWorker(targetRange, context), scopes = _a.scopes, _b = _a.readsAndWrites, target = _b.target, usagesPerScope = _b.usagesPerScope, constantErrorsPerScope = _b.constantErrorsPerScope, exposedVariableDeclarations = _b.exposedVariableDeclarations; + ts.Debug.assert(!constantErrorsPerScope[requestedChangesIndex].length, "The extraction went missing? How?"); + ts.Debug.assert(exposedVariableDeclarations.length === 0, "Extract constant accepted a range containing a variable declaration?"); + context.cancellationToken.throwIfCancellationRequested(); + var expression = ts.isExpression(target) + ? target + : target.statements[0].expression; + return extractConstantInScope(expression, scopes[requestedChangesIndex], usagesPerScope[requestedChangesIndex], targetRange.facts, context); + } + /** + * Given a piece of text to extract ('targetRange'), computes a list of possible extractions. + * Each returned ExtractResultForScope corresponds to a possible target scope and is either a set of changes + * or an error explaining why we can't extract into that scope. + */ + function getPossibleExtractions(targetRange, context) { + var _a = getPossibleExtractionsWorker(targetRange, context), scopes = _a.scopes, _b = _a.readsAndWrites, functionErrorsPerScope = _b.functionErrorsPerScope, constantErrorsPerScope = _b.constantErrorsPerScope; + // Need the inner type annotation to avoid https://github.com/Microsoft/TypeScript/issues/7547 + var extractions = scopes.map(function (scope, i) { + var functionDescriptionPart = getDescriptionForFunctionInScope(scope); + var constantDescriptionPart = getDescriptionForConstantInScope(scope); + var scopeDescription = ts.isFunctionLikeDeclaration(scope) + ? getDescriptionForFunctionLikeDeclaration(scope) + : ts.isClassLike(scope) + ? getDescriptionForClassLikeDeclaration(scope) + : getDescriptionForModuleLikeDeclaration(scope); + var functionDescription; + var constantDescription; + if (scopeDescription === 1 /* SpecialScope.Global */) { + functionDescription = ts.formatStringFromArgs(ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_to_0_in_1_scope), [functionDescriptionPart, "global"]); + constantDescription = ts.formatStringFromArgs(ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_to_0_in_1_scope), [constantDescriptionPart, "global"]); + } + else if (scopeDescription === 0 /* SpecialScope.Module */) { + functionDescription = ts.formatStringFromArgs(ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_to_0_in_1_scope), [functionDescriptionPart, "module"]); + constantDescription = ts.formatStringFromArgs(ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_to_0_in_1_scope), [constantDescriptionPart, "module"]); + } + else { + functionDescription = ts.formatStringFromArgs(ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_to_0_in_1), [functionDescriptionPart, scopeDescription]); + constantDescription = ts.formatStringFromArgs(ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_to_0_in_1), [constantDescriptionPart, scopeDescription]); + } + // Customize the phrasing for the innermost scope to increase clarity. + if (i === 0 && !ts.isClassLike(scope)) { + constantDescription = ts.formatStringFromArgs(ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_to_0_in_enclosing_scope), [constantDescriptionPart]); + } + return { + functionExtraction: { + description: functionDescription, + errors: functionErrorsPerScope[i], + }, + constantExtraction: { + description: constantDescription, + errors: constantErrorsPerScope[i], + }, + }; + }); + return extractions; + } + function getPossibleExtractionsWorker(targetRange, context) { + var sourceFile = context.file; + var scopes = collectEnclosingScopes(targetRange); + var enclosingTextRange = getEnclosingTextRange(targetRange, sourceFile); + var readsAndWrites = collectReadsAndWrites(targetRange, scopes, enclosingTextRange, sourceFile, context.program.getTypeChecker(), context.cancellationToken); + return { scopes: scopes, readsAndWrites: readsAndWrites }; + } + function getDescriptionForFunctionInScope(scope) { + return ts.isFunctionLikeDeclaration(scope) + ? "inner function" + : ts.isClassLike(scope) + ? "method" + : "function"; + } + function getDescriptionForConstantInScope(scope) { + return ts.isClassLike(scope) + ? "readonly field" + : "constant"; + } + function getDescriptionForFunctionLikeDeclaration(scope) { + switch (scope.kind) { + case 173 /* SyntaxKind.Constructor */: + return "constructor"; + case 215 /* SyntaxKind.FunctionExpression */: + case 259 /* SyntaxKind.FunctionDeclaration */: + return scope.name + ? "function '".concat(scope.name.text, "'") + : ts.ANONYMOUS; + case 216 /* SyntaxKind.ArrowFunction */: + return "arrow function"; + case 171 /* SyntaxKind.MethodDeclaration */: + return "method '".concat(scope.name.getText(), "'"); + case 174 /* SyntaxKind.GetAccessor */: + return "'get ".concat(scope.name.getText(), "'"); + case 175 /* SyntaxKind.SetAccessor */: + return "'set ".concat(scope.name.getText(), "'"); + default: + throw ts.Debug.assertNever(scope, "Unexpected scope kind ".concat(scope.kind)); + } + } + function getDescriptionForClassLikeDeclaration(scope) { + return scope.kind === 260 /* SyntaxKind.ClassDeclaration */ + ? scope.name ? "class '".concat(scope.name.text, "'") : "anonymous class declaration" + : scope.name ? "class expression '".concat(scope.name.text, "'") : "anonymous class expression"; + } + function getDescriptionForModuleLikeDeclaration(scope) { + return scope.kind === 265 /* SyntaxKind.ModuleBlock */ + ? "namespace '".concat(scope.parent.name.getText(), "'") + : scope.externalModuleIndicator ? 0 /* SpecialScope.Module */ : 1 /* SpecialScope.Global */; + } + var SpecialScope; + (function (SpecialScope) { + SpecialScope[SpecialScope["Module"] = 0] = "Module"; + SpecialScope[SpecialScope["Global"] = 1] = "Global"; + })(SpecialScope || (SpecialScope = {})); + /** + * Result of 'extractRange' operation for a specific scope. + * Stores either a list of changes that should be applied to extract a range or a list of errors + */ + function extractFunctionInScope(node, scope, _a, exposedVariableDeclarations, range, context) { + var usagesInScope = _a.usages, typeParameterUsages = _a.typeParameterUsages, substitutions = _a.substitutions; + var checker = context.program.getTypeChecker(); + var scriptTarget = ts.getEmitScriptTarget(context.program.getCompilerOptions()); + var importAdder = ts.codefix.createImportAdder(context.file, context.program, context.preferences, context.host); + // Make a unique name for the extracted function + var file = scope.getSourceFile(); + var functionNameText = ts.getUniqueName(ts.isClassLike(scope) ? "newMethod" : "newFunction", file); + var isJS = ts.isInJSFile(scope); + var functionName = ts.factory.createIdentifier(functionNameText); + var returnType; + var parameters = []; + var callArguments = []; + var writes; + usagesInScope.forEach(function (usage, name) { + var typeNode; + if (!isJS) { + var type = checker.getTypeOfSymbolAtLocation(usage.symbol, usage.node); + // Widen the type so we don't emit nonsense annotations like "function fn(x: 3) {" + type = checker.getBaseTypeOfLiteralType(type); + typeNode = ts.codefix.typeToAutoImportableTypeNode(checker, importAdder, type, scope, scriptTarget, 1 /* NodeBuilderFlags.NoTruncation */); + } + var paramDecl = ts.factory.createParameterDeclaration( + /*modifiers*/ undefined, + /*dotDotDotToken*/ undefined, + /*name*/ name, + /*questionToken*/ undefined, typeNode); + parameters.push(paramDecl); + if (usage.usage === 2 /* Usage.Write */) { + (writes || (writes = [])).push(usage); + } + callArguments.push(ts.factory.createIdentifier(name)); + }); + var typeParametersAndDeclarations = ts.arrayFrom(typeParameterUsages.values()).map(function (type) { return ({ type: type, declaration: getFirstDeclaration(type) }); }); + var sortedTypeParametersAndDeclarations = typeParametersAndDeclarations.sort(compareTypesByDeclarationOrder); + var typeParameters = sortedTypeParametersAndDeclarations.length === 0 + ? undefined + : sortedTypeParametersAndDeclarations.map(function (t) { return t.declaration; }); + // Strictly speaking, we should check whether each name actually binds to the appropriate type + // parameter. In cases of shadowing, they may not. + var callTypeArguments = typeParameters !== undefined + ? typeParameters.map(function (decl) { return ts.factory.createTypeReferenceNode(decl.name, /*typeArguments*/ undefined); }) + : undefined; + // Provide explicit return types for contextually-typed functions + // to avoid problems when there are literal types present + if (ts.isExpression(node) && !isJS) { + var contextualType = checker.getContextualType(node); + returnType = checker.typeToTypeNode(contextualType, scope, 1 /* NodeBuilderFlags.NoTruncation */); // TODO: GH#18217 + } + var _b = transformFunctionBody(node, exposedVariableDeclarations, writes, substitutions, !!(range.facts & RangeFacts.HasReturn)), body = _b.body, returnValueProperty = _b.returnValueProperty; + ts.suppressLeadingAndTrailingTrivia(body); + var newFunction; + var callThis = !!(range.facts & RangeFacts.UsesThisInFunction); + if (ts.isClassLike(scope)) { + // always create private method in TypeScript files + var modifiers = isJS ? [] : [ts.factory.createModifier(121 /* SyntaxKind.PrivateKeyword */)]; + if (range.facts & RangeFacts.InStaticRegion) { + modifiers.push(ts.factory.createModifier(124 /* SyntaxKind.StaticKeyword */)); + } + if (range.facts & RangeFacts.IsAsyncFunction) { + modifiers.push(ts.factory.createModifier(132 /* SyntaxKind.AsyncKeyword */)); + } + newFunction = ts.factory.createMethodDeclaration(modifiers.length ? modifiers : undefined, range.facts & RangeFacts.IsGenerator ? ts.factory.createToken(41 /* SyntaxKind.AsteriskToken */) : undefined, functionName, + /*questionToken*/ undefined, typeParameters, parameters, returnType, body); + } + else { + if (callThis) { + parameters.unshift(ts.factory.createParameterDeclaration( + /*modifiers*/ undefined, + /*dotDotDotToken*/ undefined, + /*name*/ "this", + /*questionToken*/ undefined, checker.typeToTypeNode(checker.getTypeAtLocation(range.thisNode), scope, 1 /* NodeBuilderFlags.NoTruncation */), + /*initializer*/ undefined)); + } + newFunction = ts.factory.createFunctionDeclaration(range.facts & RangeFacts.IsAsyncFunction ? [ts.factory.createToken(132 /* SyntaxKind.AsyncKeyword */)] : undefined, range.facts & RangeFacts.IsGenerator ? ts.factory.createToken(41 /* SyntaxKind.AsteriskToken */) : undefined, functionName, typeParameters, parameters, returnType, body); + } + var changeTracker = ts.textChanges.ChangeTracker.fromContext(context); + var minInsertionPos = (isReadonlyArray(range.range) ? ts.last(range.range) : range.range).end; + var nodeToInsertBefore = getNodeToInsertFunctionBefore(minInsertionPos, scope); + if (nodeToInsertBefore) { + changeTracker.insertNodeBefore(context.file, nodeToInsertBefore, newFunction, /*blankLineBetween*/ true); + } + else { + changeTracker.insertNodeAtEndOfScope(context.file, scope, newFunction); + } + importAdder.writeFixes(changeTracker); + var newNodes = []; + // replace range with function call + var called = getCalledExpression(scope, range, functionNameText); + if (callThis) { + callArguments.unshift(ts.factory.createIdentifier("this")); + } + var call = ts.factory.createCallExpression(callThis ? ts.factory.createPropertyAccessExpression(called, "call") : called, callTypeArguments, // Note that no attempt is made to take advantage of type argument inference + callArguments); + if (range.facts & RangeFacts.IsGenerator) { + call = ts.factory.createYieldExpression(ts.factory.createToken(41 /* SyntaxKind.AsteriskToken */), call); + } + if (range.facts & RangeFacts.IsAsyncFunction) { + call = ts.factory.createAwaitExpression(call); + } + if (isInJSXContent(node)) { + call = ts.factory.createJsxExpression(/*dotDotDotToken*/ undefined, call); + } + if (exposedVariableDeclarations.length && !writes) { + // No need to mix declarations and writes. + // How could any variables be exposed if there's a return statement? + ts.Debug.assert(!returnValueProperty, "Expected no returnValueProperty"); + ts.Debug.assert(!(range.facts & RangeFacts.HasReturn), "Expected RangeFacts.HasReturn flag to be unset"); + if (exposedVariableDeclarations.length === 1) { + // Declaring exactly one variable: let x = newFunction(); + var variableDeclaration = exposedVariableDeclarations[0]; + newNodes.push(ts.factory.createVariableStatement( + /*modifiers*/ undefined, ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(ts.getSynthesizedDeepClone(variableDeclaration.name), /*exclamationToken*/ undefined, /*type*/ ts.getSynthesizedDeepClone(variableDeclaration.type), /*initializer*/ call)], // TODO (acasey): test binding patterns + variableDeclaration.parent.flags))); + } + else { + // Declaring multiple variables / return properties: + // let {x, y} = newFunction(); + var bindingElements = []; + var typeElements = []; + var commonNodeFlags = exposedVariableDeclarations[0].parent.flags; + var sawExplicitType = false; + for (var _i = 0, exposedVariableDeclarations_1 = exposedVariableDeclarations; _i < exposedVariableDeclarations_1.length; _i++) { + var variableDeclaration = exposedVariableDeclarations_1[_i]; + bindingElements.push(ts.factory.createBindingElement( + /*dotDotDotToken*/ undefined, + /*propertyName*/ undefined, + /*name*/ ts.getSynthesizedDeepClone(variableDeclaration.name))); + // Being returned through an object literal will have widened the type. + var variableType = checker.typeToTypeNode(checker.getBaseTypeOfLiteralType(checker.getTypeAtLocation(variableDeclaration)), scope, 1 /* NodeBuilderFlags.NoTruncation */); + typeElements.push(ts.factory.createPropertySignature( + /*modifiers*/ undefined, + /*name*/ variableDeclaration.symbol.name, + /*questionToken*/ undefined, + /*type*/ variableType)); + sawExplicitType = sawExplicitType || variableDeclaration.type !== undefined; + commonNodeFlags = commonNodeFlags & variableDeclaration.parent.flags; + } + var typeLiteral = sawExplicitType ? ts.factory.createTypeLiteralNode(typeElements) : undefined; + if (typeLiteral) { + ts.setEmitFlags(typeLiteral, 1 /* EmitFlags.SingleLine */); + } + newNodes.push(ts.factory.createVariableStatement( + /*modifiers*/ undefined, ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(ts.factory.createObjectBindingPattern(bindingElements), + /*exclamationToken*/ undefined, + /*type*/ typeLiteral, + /*initializer*/ call)], commonNodeFlags))); + } + } + else if (exposedVariableDeclarations.length || writes) { + if (exposedVariableDeclarations.length) { + // CONSIDER: we're going to create one statement per variable, but we could actually preserve their original grouping. + for (var _c = 0, exposedVariableDeclarations_2 = exposedVariableDeclarations; _c < exposedVariableDeclarations_2.length; _c++) { + var variableDeclaration = exposedVariableDeclarations_2[_c]; + var flags = variableDeclaration.parent.flags; + if (flags & 2 /* NodeFlags.Const */) { + flags = (flags & ~2 /* NodeFlags.Const */) | 1 /* NodeFlags.Let */; + } + newNodes.push(ts.factory.createVariableStatement( + /*modifiers*/ undefined, ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(variableDeclaration.symbol.name, /*exclamationToken*/ undefined, getTypeDeepCloneUnionUndefined(variableDeclaration.type))], flags))); + } + } + if (returnValueProperty) { + // has both writes and return, need to create variable declaration to hold return value; + newNodes.push(ts.factory.createVariableStatement( + /*modifiers*/ undefined, ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(returnValueProperty, /*exclamationToken*/ undefined, getTypeDeepCloneUnionUndefined(returnType))], 1 /* NodeFlags.Let */))); + } + var assignments = getPropertyAssignmentsForWritesAndVariableDeclarations(exposedVariableDeclarations, writes); + if (returnValueProperty) { + assignments.unshift(ts.factory.createShorthandPropertyAssignment(returnValueProperty)); + } + // propagate writes back + if (assignments.length === 1) { + // We would only have introduced a return value property if there had been + // other assignments to make. + ts.Debug.assert(!returnValueProperty, "Shouldn't have returnValueProperty here"); + newNodes.push(ts.factory.createExpressionStatement(ts.factory.createAssignment(assignments[0].name, call))); + if (range.facts & RangeFacts.HasReturn) { + newNodes.push(ts.factory.createReturnStatement()); + } + } + else { + // emit e.g. + // { a, b, __return } = newFunction(a, b); + // return __return; + newNodes.push(ts.factory.createExpressionStatement(ts.factory.createAssignment(ts.factory.createObjectLiteralExpression(assignments), call))); + if (returnValueProperty) { + newNodes.push(ts.factory.createReturnStatement(ts.factory.createIdentifier(returnValueProperty))); + } + } + } + else { + if (range.facts & RangeFacts.HasReturn) { + newNodes.push(ts.factory.createReturnStatement(call)); + } + else if (isReadonlyArray(range.range)) { + newNodes.push(ts.factory.createExpressionStatement(call)); + } + else { + newNodes.push(call); + } + } + if (isReadonlyArray(range.range)) { + changeTracker.replaceNodeRangeWithNodes(context.file, ts.first(range.range), ts.last(range.range), newNodes); + } + else { + changeTracker.replaceNodeWithNodes(context.file, range.range, newNodes); + } + var edits = changeTracker.getChanges(); + var renameRange = isReadonlyArray(range.range) ? ts.first(range.range) : range.range; + var renameFilename = renameRange.getSourceFile().fileName; + var renameLocation = ts.getRenameLocation(edits, renameFilename, functionNameText, /*isDeclaredBeforeUse*/ false); + return { renameFilename: renameFilename, renameLocation: renameLocation, edits: edits }; + function getTypeDeepCloneUnionUndefined(typeNode) { + if (typeNode === undefined) { + return undefined; + } + var clone = ts.getSynthesizedDeepClone(typeNode); + var withoutParens = clone; + while (ts.isParenthesizedTypeNode(withoutParens)) { + withoutParens = withoutParens.type; + } + return ts.isUnionTypeNode(withoutParens) && ts.find(withoutParens.types, function (t) { return t.kind === 155 /* SyntaxKind.UndefinedKeyword */; }) + ? clone + : ts.factory.createUnionTypeNode([clone, ts.factory.createKeywordTypeNode(155 /* SyntaxKind.UndefinedKeyword */)]); + } + } + /** + * Result of 'extractRange' operation for a specific scope. + * Stores either a list of changes that should be applied to extract a range or a list of errors + */ + function extractConstantInScope(node, scope, _a, rangeFacts, context) { + var _b; + var substitutions = _a.substitutions; + var checker = context.program.getTypeChecker(); + // Make a unique name for the extracted variable + var file = scope.getSourceFile(); + var localNameText = ts.isPropertyAccessExpression(node) && !ts.isClassLike(scope) && !checker.resolveName(node.name.text, node, 111551 /* SymbolFlags.Value */, /*excludeGlobals*/ false) && !ts.isPrivateIdentifier(node.name) && !ts.isKeyword(node.name.originalKeywordKind) + ? node.name.text + : ts.getUniqueName(ts.isClassLike(scope) ? "newProperty" : "newLocal", file); + var isJS = ts.isInJSFile(scope); + var variableType = isJS || !checker.isContextSensitive(node) + ? undefined + : checker.typeToTypeNode(checker.getContextualType(node), scope, 1 /* NodeBuilderFlags.NoTruncation */); // TODO: GH#18217 + var initializer = transformConstantInitializer(ts.skipParentheses(node), substitutions); + (_b = transformFunctionInitializerAndType(variableType, initializer), variableType = _b.variableType, initializer = _b.initializer); + ts.suppressLeadingAndTrailingTrivia(initializer); + var changeTracker = ts.textChanges.ChangeTracker.fromContext(context); + if (ts.isClassLike(scope)) { + ts.Debug.assert(!isJS, "Cannot extract to a JS class"); // See CannotExtractToJSClass + var modifiers = []; + modifiers.push(ts.factory.createModifier(121 /* SyntaxKind.PrivateKeyword */)); + if (rangeFacts & RangeFacts.InStaticRegion) { + modifiers.push(ts.factory.createModifier(124 /* SyntaxKind.StaticKeyword */)); + } + modifiers.push(ts.factory.createModifier(146 /* SyntaxKind.ReadonlyKeyword */)); + var newVariable = ts.factory.createPropertyDeclaration(modifiers, localNameText, + /*questionToken*/ undefined, variableType, initializer); + var localReference = ts.factory.createPropertyAccessExpression(rangeFacts & RangeFacts.InStaticRegion + ? ts.factory.createIdentifier(scope.name.getText()) // TODO: GH#18217 + : ts.factory.createThis(), ts.factory.createIdentifier(localNameText)); + if (isInJSXContent(node)) { + localReference = ts.factory.createJsxExpression(/*dotDotDotToken*/ undefined, localReference); + } + // Declare + var maxInsertionPos = node.pos; + var nodeToInsertBefore = getNodeToInsertPropertyBefore(maxInsertionPos, scope); + changeTracker.insertNodeBefore(context.file, nodeToInsertBefore, newVariable, /*blankLineBetween*/ true); + // Consume + changeTracker.replaceNode(context.file, node, localReference); + } + else { + var newVariableDeclaration = ts.factory.createVariableDeclaration(localNameText, /*exclamationToken*/ undefined, variableType, initializer); + // If the node is part of an initializer in a list of variable declarations, insert a new + // variable declaration into the list (in case it depends on earlier ones). + // CONSIDER: If the declaration list isn't const, we might want to split it into multiple + // lists so that the newly extracted one can be const. + var oldVariableDeclaration = getContainingVariableDeclarationIfInList(node, scope); + if (oldVariableDeclaration) { + // Declare + // CONSIDER: could detect that each is on a separate line (See `extractConstant_VariableList_MultipleLines` in `extractConstants.ts`) + changeTracker.insertNodeBefore(context.file, oldVariableDeclaration, newVariableDeclaration); + // Consume + var localReference = ts.factory.createIdentifier(localNameText); + changeTracker.replaceNode(context.file, node, localReference); + } + else if (node.parent.kind === 241 /* SyntaxKind.ExpressionStatement */ && scope === ts.findAncestor(node, isScope)) { + // If the parent is an expression statement and the target scope is the immediately enclosing one, + // replace the statement with the declaration. + var newVariableStatement = ts.factory.createVariableStatement( + /*modifiers*/ undefined, ts.factory.createVariableDeclarationList([newVariableDeclaration], 2 /* NodeFlags.Const */)); + changeTracker.replaceNode(context.file, node.parent, newVariableStatement); + } + else { + var newVariableStatement = ts.factory.createVariableStatement( + /*modifiers*/ undefined, ts.factory.createVariableDeclarationList([newVariableDeclaration], 2 /* NodeFlags.Const */)); + // Declare + var nodeToInsertBefore = getNodeToInsertConstantBefore(node, scope); + if (nodeToInsertBefore.pos === 0) { + changeTracker.insertNodeAtTopOfFile(context.file, newVariableStatement, /*blankLineBetween*/ false); + } + else { + changeTracker.insertNodeBefore(context.file, nodeToInsertBefore, newVariableStatement, /*blankLineBetween*/ false); + } + // Consume + if (node.parent.kind === 241 /* SyntaxKind.ExpressionStatement */) { + // If the parent is an expression statement, delete it. + changeTracker.delete(context.file, node.parent); + } + else { + var localReference = ts.factory.createIdentifier(localNameText); + // When extract to a new variable in JSX content, need to wrap a {} out of the new variable + // or it will become a plain text + if (isInJSXContent(node)) { + localReference = ts.factory.createJsxExpression(/*dotDotDotToken*/ undefined, localReference); + } + changeTracker.replaceNode(context.file, node, localReference); + } + } + } + var edits = changeTracker.getChanges(); + var renameFilename = node.getSourceFile().fileName; + var renameLocation = ts.getRenameLocation(edits, renameFilename, localNameText, /*isDeclaredBeforeUse*/ true); + return { renameFilename: renameFilename, renameLocation: renameLocation, edits: edits }; + function transformFunctionInitializerAndType(variableType, initializer) { + // If no contextual type exists there is nothing to transfer to the function signature + if (variableType === undefined) + return { variableType: variableType, initializer: initializer }; + // Only do this for function expressions and arrow functions that are not generic + if (!ts.isFunctionExpression(initializer) && !ts.isArrowFunction(initializer) || !!initializer.typeParameters) + return { variableType: variableType, initializer: initializer }; + var functionType = checker.getTypeAtLocation(node); + var functionSignature = ts.singleOrUndefined(checker.getSignaturesOfType(functionType, 0 /* SignatureKind.Call */)); + // If no function signature, maybe there was an error, do nothing + if (!functionSignature) + return { variableType: variableType, initializer: initializer }; + // If the function signature has generic type parameters we don't attempt to move the parameters + if (!!functionSignature.getTypeParameters()) + return { variableType: variableType, initializer: initializer }; + // We add parameter types if needed + var parameters = []; + var hasAny = false; + for (var _i = 0, _a = initializer.parameters; _i < _a.length; _i++) { + var p = _a[_i]; + if (p.type) { + parameters.push(p); + } + else { + var paramType = checker.getTypeAtLocation(p); + if (paramType === checker.getAnyType()) + hasAny = true; + parameters.push(ts.factory.updateParameterDeclaration(p, p.modifiers, p.dotDotDotToken, p.name, p.questionToken, p.type || checker.typeToTypeNode(paramType, scope, 1 /* NodeBuilderFlags.NoTruncation */), p.initializer)); + } + } + // If a parameter was inferred as any we skip adding function parameters at all. + // Turning an implicit any (which under common settings is a error) to an explicit + // is probably actually a worse refactor outcome. + if (hasAny) + return { variableType: variableType, initializer: initializer }; + variableType = undefined; + if (ts.isArrowFunction(initializer)) { + initializer = ts.factory.updateArrowFunction(initializer, ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined, initializer.typeParameters, parameters, initializer.type || checker.typeToTypeNode(functionSignature.getReturnType(), scope, 1 /* NodeBuilderFlags.NoTruncation */), initializer.equalsGreaterThanToken, initializer.body); + } + else { + if (functionSignature && !!functionSignature.thisParameter) { + var firstParameter = ts.firstOrUndefined(parameters); + // If the function signature has a this parameter and if the first defined parameter is not the this parameter, we must add it + // Note: If this parameter was already there, it would have been previously updated with the type if not type was present + if ((!firstParameter || (ts.isIdentifier(firstParameter.name) && firstParameter.name.escapedText !== "this"))) { + var thisType = checker.getTypeOfSymbolAtLocation(functionSignature.thisParameter, node); + parameters.splice(0, 0, ts.factory.createParameterDeclaration( + /* modifiers */ undefined, + /* dotDotDotToken */ undefined, "this", + /* questionToken */ undefined, checker.typeToTypeNode(thisType, scope, 1 /* NodeBuilderFlags.NoTruncation */))); + } + } + initializer = ts.factory.updateFunctionExpression(initializer, ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined, initializer.asteriskToken, initializer.name, initializer.typeParameters, parameters, initializer.type || checker.typeToTypeNode(functionSignature.getReturnType(), scope, 1 /* NodeBuilderFlags.NoTruncation */), initializer.body); + } + return { variableType: variableType, initializer: initializer }; + } + } + function getContainingVariableDeclarationIfInList(node, scope) { + var prevNode; + while (node !== undefined && node !== scope) { + if (ts.isVariableDeclaration(node) && + node.initializer === prevNode && + ts.isVariableDeclarationList(node.parent) && + node.parent.declarations.length > 1) { + return node; + } + prevNode = node; + node = node.parent; + } + } + function getFirstDeclaration(type) { + var firstDeclaration; + var symbol = type.symbol; + if (symbol && symbol.declarations) { + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var declaration = _a[_i]; + if (firstDeclaration === undefined || declaration.pos < firstDeclaration.pos) { + firstDeclaration = declaration; + } + } + } + return firstDeclaration; + } + function compareTypesByDeclarationOrder(_a, _b) { + var type1 = _a.type, declaration1 = _a.declaration; + var type2 = _b.type, declaration2 = _b.declaration; + return ts.compareProperties(declaration1, declaration2, "pos", ts.compareValues) + || ts.compareStringsCaseSensitive(type1.symbol ? type1.symbol.getName() : "", type2.symbol ? type2.symbol.getName() : "") + || ts.compareValues(type1.id, type2.id); + } + function getCalledExpression(scope, range, functionNameText) { + var functionReference = ts.factory.createIdentifier(functionNameText); + if (ts.isClassLike(scope)) { + var lhs = range.facts & RangeFacts.InStaticRegion ? ts.factory.createIdentifier(scope.name.text) : ts.factory.createThis(); // TODO: GH#18217 + return ts.factory.createPropertyAccessExpression(lhs, functionReference); + } + else { + return functionReference; + } + } + function transformFunctionBody(body, exposedVariableDeclarations, writes, substitutions, hasReturn) { + var hasWritesOrVariableDeclarations = writes !== undefined || exposedVariableDeclarations.length > 0; + if (ts.isBlock(body) && !hasWritesOrVariableDeclarations && substitutions.size === 0) { + // already block, no declarations or writes to propagate back, no substitutions - can use node as is + return { body: ts.factory.createBlock(body.statements, /*multLine*/ true), returnValueProperty: undefined }; + } + var returnValueProperty; + var ignoreReturns = false; + var statements = ts.factory.createNodeArray(ts.isBlock(body) ? body.statements.slice(0) : [ts.isStatement(body) ? body : ts.factory.createReturnStatement(ts.skipParentheses(body))]); + // rewrite body if either there are writes that should be propagated back via return statements or there are substitutions + if (hasWritesOrVariableDeclarations || substitutions.size) { + var rewrittenStatements = ts.visitNodes(statements, visitor).slice(); + if (hasWritesOrVariableDeclarations && !hasReturn && ts.isStatement(body)) { + // add return at the end to propagate writes back in case if control flow falls out of the function body + // it is ok to know that range has at least one return since it we only allow unconditional returns + var assignments = getPropertyAssignmentsForWritesAndVariableDeclarations(exposedVariableDeclarations, writes); + if (assignments.length === 1) { + rewrittenStatements.push(ts.factory.createReturnStatement(assignments[0].name)); + } + else { + rewrittenStatements.push(ts.factory.createReturnStatement(ts.factory.createObjectLiteralExpression(assignments))); + } + } + return { body: ts.factory.createBlock(rewrittenStatements, /*multiLine*/ true), returnValueProperty: returnValueProperty }; + } + else { + return { body: ts.factory.createBlock(statements, /*multiLine*/ true), returnValueProperty: undefined }; + } + function visitor(node) { + if (!ignoreReturns && ts.isReturnStatement(node) && hasWritesOrVariableDeclarations) { + var assignments = getPropertyAssignmentsForWritesAndVariableDeclarations(exposedVariableDeclarations, writes); + if (node.expression) { + if (!returnValueProperty) { + returnValueProperty = "__return"; + } + assignments.unshift(ts.factory.createPropertyAssignment(returnValueProperty, ts.visitNode(node.expression, visitor))); + } + if (assignments.length === 1) { + return ts.factory.createReturnStatement(assignments[0].name); + } + else { + return ts.factory.createReturnStatement(ts.factory.createObjectLiteralExpression(assignments)); + } + } + else { + var oldIgnoreReturns = ignoreReturns; + ignoreReturns = ignoreReturns || ts.isFunctionLikeDeclaration(node) || ts.isClassLike(node); + var substitution = substitutions.get(ts.getNodeId(node).toString()); + var result = substitution ? ts.getSynthesizedDeepClone(substitution) : ts.visitEachChild(node, visitor, ts.nullTransformationContext); + ignoreReturns = oldIgnoreReturns; + return result; + } + } + } + function transformConstantInitializer(initializer, substitutions) { + return substitutions.size + ? visitor(initializer) + : initializer; + function visitor(node) { + var substitution = substitutions.get(ts.getNodeId(node).toString()); + return substitution ? ts.getSynthesizedDeepClone(substitution) : ts.visitEachChild(node, visitor, ts.nullTransformationContext); + } + } + function getStatementsOrClassElements(scope) { + if (ts.isFunctionLikeDeclaration(scope)) { + var body = scope.body; // TODO: GH#18217 + if (ts.isBlock(body)) { + return body.statements; + } + } + else if (ts.isModuleBlock(scope) || ts.isSourceFile(scope)) { + return scope.statements; + } + else if (ts.isClassLike(scope)) { + return scope.members; + } + else { + ts.assertType(scope); + } + return ts.emptyArray; + } + /** + * If `scope` contains a function after `minPos`, then return the first such function. + * Otherwise, return `undefined`. + */ + function getNodeToInsertFunctionBefore(minPos, scope) { + return ts.find(getStatementsOrClassElements(scope), function (child) { + return child.pos >= minPos && ts.isFunctionLikeDeclaration(child) && !ts.isConstructorDeclaration(child); + }); + } + function getNodeToInsertPropertyBefore(maxPos, scope) { + var members = scope.members; + ts.Debug.assert(members.length > 0, "Found no members"); // There must be at least one child, since we extracted from one. + var prevMember; + var allProperties = true; + for (var _i = 0, members_1 = members; _i < members_1.length; _i++) { + var member = members_1[_i]; + if (member.pos > maxPos) { + return prevMember || members[0]; + } + if (allProperties && !ts.isPropertyDeclaration(member)) { + // If it is non-vacuously true that all preceding members are properties, + // insert before the current member (i.e. at the end of the list of properties). + if (prevMember !== undefined) { + return member; + } + allProperties = false; + } + prevMember = member; + } + if (prevMember === undefined) + return ts.Debug.fail(); // If the loop didn't return, then it did set prevMember. + return prevMember; + } + function getNodeToInsertConstantBefore(node, scope) { + ts.Debug.assert(!ts.isClassLike(scope)); + var prevScope; + for (var curr = node; curr !== scope; curr = curr.parent) { + if (isScope(curr)) { + prevScope = curr; + } + } + for (var curr = (prevScope || node).parent;; curr = curr.parent) { + if (isBlockLike(curr)) { + var prevStatement = void 0; + for (var _i = 0, _a = curr.statements; _i < _a.length; _i++) { + var statement = _a[_i]; + if (statement.pos > node.pos) { + break; + } + prevStatement = statement; + } + if (!prevStatement && ts.isCaseClause(curr)) { + // We must have been in the expression of the case clause. + ts.Debug.assert(ts.isSwitchStatement(curr.parent.parent), "Grandparent isn't a switch statement"); + return curr.parent.parent; + } + // There must be at least one statement since we started in one. + return ts.Debug.checkDefined(prevStatement, "prevStatement failed to get set"); + } + ts.Debug.assert(curr !== scope, "Didn't encounter a block-like before encountering scope"); + } + } + function getPropertyAssignmentsForWritesAndVariableDeclarations(exposedVariableDeclarations, writes) { + var variableAssignments = ts.map(exposedVariableDeclarations, function (v) { return ts.factory.createShorthandPropertyAssignment(v.symbol.name); }); + var writeAssignments = ts.map(writes, function (w) { return ts.factory.createShorthandPropertyAssignment(w.symbol.name); }); + // TODO: GH#18217 `variableAssignments` not possibly undefined! + return variableAssignments === undefined + ? writeAssignments + : writeAssignments === undefined + ? variableAssignments + : variableAssignments.concat(writeAssignments); + } + function isReadonlyArray(v) { + return ts.isArray(v); + } + /** + * Produces a range that spans the entirety of nodes, given a selection + * that might start/end in the middle of nodes. + * + * For example, when the user makes a selection like this + * v---v + * var someThing = foo + bar; + * this returns ^-------^ + */ + function getEnclosingTextRange(targetRange, sourceFile) { + return isReadonlyArray(targetRange.range) + ? { pos: ts.first(targetRange.range).getStart(sourceFile), end: ts.last(targetRange.range).getEnd() } + : targetRange.range; + } + var Usage; + (function (Usage) { + // value should be passed to extracted method + Usage[Usage["Read"] = 1] = "Read"; + // value should be passed to extracted method and propagated back + Usage[Usage["Write"] = 2] = "Write"; + })(Usage || (Usage = {})); + function collectReadsAndWrites(targetRange, scopes, enclosingTextRange, sourceFile, checker, cancellationToken) { + var allTypeParameterUsages = new ts.Map(); // Key is type ID + var usagesPerScope = []; + var substitutionsPerScope = []; + var functionErrorsPerScope = []; + var constantErrorsPerScope = []; + var visibleDeclarationsInExtractedRange = []; + var exposedVariableSymbolSet = new ts.Map(); // Key is symbol ID + var exposedVariableDeclarations = []; + var firstExposedNonVariableDeclaration; + var expression = !isReadonlyArray(targetRange.range) + ? targetRange.range + : targetRange.range.length === 1 && ts.isExpressionStatement(targetRange.range[0]) + ? targetRange.range[0].expression + : undefined; + var expressionDiagnostic; + if (expression === undefined) { + var statements = targetRange.range; + var start = ts.first(statements).getStart(); + var end = ts.last(statements).end; + expressionDiagnostic = ts.createFileDiagnostic(sourceFile, start, end - start, Messages.expressionExpected); + } + else if (checker.getTypeAtLocation(expression).flags & (16384 /* TypeFlags.Void */ | 131072 /* TypeFlags.Never */)) { + expressionDiagnostic = ts.createDiagnosticForNode(expression, Messages.uselessConstantType); + } + // initialize results + for (var _i = 0, scopes_1 = scopes; _i < scopes_1.length; _i++) { + var scope = scopes_1[_i]; + usagesPerScope.push({ usages: new ts.Map(), typeParameterUsages: new ts.Map(), substitutions: new ts.Map() }); + substitutionsPerScope.push(new ts.Map()); + functionErrorsPerScope.push([]); + var constantErrors = []; + if (expressionDiagnostic) { + constantErrors.push(expressionDiagnostic); + } + if (ts.isClassLike(scope) && ts.isInJSFile(scope)) { + constantErrors.push(ts.createDiagnosticForNode(scope, Messages.cannotExtractToJSClass)); + } + if (ts.isArrowFunction(scope) && !ts.isBlock(scope.body)) { + // TODO (https://github.com/Microsoft/TypeScript/issues/18924): allow this + constantErrors.push(ts.createDiagnosticForNode(scope, Messages.cannotExtractToExpressionArrowFunction)); + } + constantErrorsPerScope.push(constantErrors); + } + var seenUsages = new ts.Map(); + var target = isReadonlyArray(targetRange.range) ? ts.factory.createBlock(targetRange.range) : targetRange.range; + var unmodifiedNode = isReadonlyArray(targetRange.range) ? ts.first(targetRange.range) : targetRange.range; + var inGenericContext = isInGenericContext(unmodifiedNode); + collectUsages(target); + // Unfortunately, this code takes advantage of the knowledge that the generated method + // will use the contextual type of an expression as the return type of the extracted + // method (and will therefore "use" all the types involved). + if (inGenericContext && !isReadonlyArray(targetRange.range) && !ts.isJsxAttribute(targetRange.range)) { + var contextualType = checker.getContextualType(targetRange.range); // TODO: GH#18217 + recordTypeParameterUsages(contextualType); + } + if (allTypeParameterUsages.size > 0) { + var seenTypeParameterUsages = new ts.Map(); // Key is type ID + var i_2 = 0; + for (var curr = unmodifiedNode; curr !== undefined && i_2 < scopes.length; curr = curr.parent) { + if (curr === scopes[i_2]) { + // Copy current contents of seenTypeParameterUsages into scope. + seenTypeParameterUsages.forEach(function (typeParameter, id) { + usagesPerScope[i_2].typeParameterUsages.set(id, typeParameter); + }); + i_2++; + } + // Note that we add the current node's type parameters *after* updating the corresponding scope. + if (ts.isDeclarationWithTypeParameters(curr)) { + for (var _a = 0, _b = ts.getEffectiveTypeParameterDeclarations(curr); _a < _b.length; _a++) { + var typeParameterDecl = _b[_a]; + var typeParameter = checker.getTypeAtLocation(typeParameterDecl); + if (allTypeParameterUsages.has(typeParameter.id.toString())) { + seenTypeParameterUsages.set(typeParameter.id.toString(), typeParameter); + } + } + } + } + // If we didn't get through all the scopes, then there were some that weren't in our + // parent chain (impossible at time of writing). A conservative solution would be to + // copy allTypeParameterUsages into all remaining scopes. + ts.Debug.assert(i_2 === scopes.length, "Should have iterated all scopes"); + } + // If there are any declarations in the extracted block that are used in the same enclosing + // lexical scope, we can't move the extraction "up" as those declarations will become unreachable + if (visibleDeclarationsInExtractedRange.length) { + var containingLexicalScopeOfExtraction = ts.isBlockScope(scopes[0], scopes[0].parent) + ? scopes[0] + : ts.getEnclosingBlockScopeContainer(scopes[0]); + ts.forEachChild(containingLexicalScopeOfExtraction, checkForUsedDeclarations); + } + var _loop_16 = function (i) { + var scopeUsages = usagesPerScope[i]; + // Special case: in the innermost scope, all usages are available. + // (The computed value reflects the value at the top-level of the scope, but the + // local will actually be declared at the same level as the extracted expression). + if (i > 0 && (scopeUsages.usages.size > 0 || scopeUsages.typeParameterUsages.size > 0)) { + var errorNode = isReadonlyArray(targetRange.range) ? targetRange.range[0] : targetRange.range; + constantErrorsPerScope[i].push(ts.createDiagnosticForNode(errorNode, Messages.cannotAccessVariablesFromNestedScopes)); + } + if (targetRange.facts & RangeFacts.UsesThisInFunction && ts.isClassLike(scopes[i])) { + functionErrorsPerScope[i].push(ts.createDiagnosticForNode(targetRange.thisNode, Messages.cannotExtractFunctionsContainingThisToMethod)); + } + var hasWrite = false; + var readonlyClassPropertyWrite; + usagesPerScope[i].usages.forEach(function (value) { + if (value.usage === 2 /* Usage.Write */) { + hasWrite = true; + if (value.symbol.flags & 106500 /* SymbolFlags.ClassMember */ && + value.symbol.valueDeclaration && + ts.hasEffectiveModifier(value.symbol.valueDeclaration, 64 /* ModifierFlags.Readonly */)) { + readonlyClassPropertyWrite = value.symbol.valueDeclaration; + } + } + }); + // If an expression was extracted, then there shouldn't have been any variable declarations. + ts.Debug.assert(isReadonlyArray(targetRange.range) || exposedVariableDeclarations.length === 0, "No variable declarations expected if something was extracted"); + if (hasWrite && !isReadonlyArray(targetRange.range)) { + var diag = ts.createDiagnosticForNode(targetRange.range, Messages.cannotWriteInExpression); + functionErrorsPerScope[i].push(diag); + constantErrorsPerScope[i].push(diag); + } + else if (readonlyClassPropertyWrite && i > 0) { + var diag = ts.createDiagnosticForNode(readonlyClassPropertyWrite, Messages.cannotExtractReadonlyPropertyInitializerOutsideConstructor); + functionErrorsPerScope[i].push(diag); + constantErrorsPerScope[i].push(diag); + } + else if (firstExposedNonVariableDeclaration) { + var diag = ts.createDiagnosticForNode(firstExposedNonVariableDeclaration, Messages.cannotExtractExportedEntity); + functionErrorsPerScope[i].push(diag); + constantErrorsPerScope[i].push(diag); + } + }; + for (var i = 0; i < scopes.length; i++) { + _loop_16(i); + } + return { target: target, usagesPerScope: usagesPerScope, functionErrorsPerScope: functionErrorsPerScope, constantErrorsPerScope: constantErrorsPerScope, exposedVariableDeclarations: exposedVariableDeclarations }; + function isInGenericContext(node) { + return !!ts.findAncestor(node, function (n) { return ts.isDeclarationWithTypeParameters(n) && ts.getEffectiveTypeParameterDeclarations(n).length !== 0; }); + } + function recordTypeParameterUsages(type) { + // PERF: This is potentially very expensive. `type` could be a library type with + // a lot of properties, each of which the walker will visit. Unfortunately, the + // solution isn't as trivial as filtering to user types because of (e.g.) Array. + var symbolWalker = checker.getSymbolWalker(function () { return (cancellationToken.throwIfCancellationRequested(), true); }); + var visitedTypes = symbolWalker.walkType(type).visitedTypes; + for (var _i = 0, visitedTypes_1 = visitedTypes; _i < visitedTypes_1.length; _i++) { + var visitedType = visitedTypes_1[_i]; + if (visitedType.isTypeParameter()) { + allTypeParameterUsages.set(visitedType.id.toString(), visitedType); + } + } + } + function collectUsages(node, valueUsage) { + if (valueUsage === void 0) { valueUsage = 1 /* Usage.Read */; } + if (inGenericContext) { + var type = checker.getTypeAtLocation(node); + recordTypeParameterUsages(type); + } + if (ts.isDeclaration(node) && node.symbol) { + visibleDeclarationsInExtractedRange.push(node); + } + if (ts.isAssignmentExpression(node)) { + // use 'write' as default usage for values + collectUsages(node.left, 2 /* Usage.Write */); + collectUsages(node.right); + } + else if (ts.isUnaryExpressionWithWrite(node)) { + collectUsages(node.operand, 2 /* Usage.Write */); + } + else if (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) { + // use 'write' as default usage for values + ts.forEachChild(node, collectUsages); + } + else if (ts.isIdentifier(node)) { + if (!node.parent) { + return; + } + if (ts.isQualifiedName(node.parent) && node !== node.parent.left) { + return; + } + if (ts.isPropertyAccessExpression(node.parent) && node !== node.parent.expression) { + return; + } + recordUsage(node, valueUsage, /*isTypeNode*/ ts.isPartOfTypeNode(node)); + } + else { + ts.forEachChild(node, collectUsages); + } + } + function recordUsage(n, usage, isTypeNode) { + var symbolId = recordUsagebySymbol(n, usage, isTypeNode); + if (symbolId) { + for (var i = 0; i < scopes.length; i++) { + // push substitution from map to map to simplify rewriting + var substitution = substitutionsPerScope[i].get(symbolId); + if (substitution) { + usagesPerScope[i].substitutions.set(ts.getNodeId(n).toString(), substitution); + } + } + } + } + function recordUsagebySymbol(identifier, usage, isTypeName) { + var symbol = getSymbolReferencedByIdentifier(identifier); + if (!symbol) { + // cannot find symbol - do nothing + return undefined; + } + var symbolId = ts.getSymbolId(symbol).toString(); + var lastUsage = seenUsages.get(symbolId); + // there are two kinds of value usages + // - reads - if range contains a read from the value located outside of the range then value should be passed as a parameter + // - writes - if range contains a write to a value located outside the range the value should be passed as a parameter and + // returned as a return value + // 'write' case is a superset of 'read' so if we already have processed 'write' of some symbol there is not need to handle 'read' + // since all information is already recorded + if (lastUsage && lastUsage >= usage) { + return symbolId; + } + seenUsages.set(symbolId, usage); + if (lastUsage) { + // if we get here this means that we are trying to handle 'write' and 'read' was already processed + // walk scopes and update existing records. + for (var _i = 0, usagesPerScope_1 = usagesPerScope; _i < usagesPerScope_1.length; _i++) { + var perScope = usagesPerScope_1[_i]; + var prevEntry = perScope.usages.get(identifier.text); + if (prevEntry) { + perScope.usages.set(identifier.text, { usage: usage, symbol: symbol, node: identifier }); + } + } + return symbolId; + } + // find first declaration in this file + var decls = symbol.getDeclarations(); + var declInFile = decls && ts.find(decls, function (d) { return d.getSourceFile() === sourceFile; }); + if (!declInFile) { + return undefined; + } + if (ts.rangeContainsStartEnd(enclosingTextRange, declInFile.getStart(), declInFile.end)) { + // declaration is located in range to be extracted - do nothing + return undefined; + } + if (targetRange.facts & RangeFacts.IsGenerator && usage === 2 /* Usage.Write */) { + // this is write to a reference located outside of the target scope and range is extracted into generator + // currently this is unsupported scenario + var diag = ts.createDiagnosticForNode(identifier, Messages.cannotExtractRangeThatContainsWritesToReferencesLocatedOutsideOfTheTargetRangeInGenerators); + for (var _a = 0, functionErrorsPerScope_1 = functionErrorsPerScope; _a < functionErrorsPerScope_1.length; _a++) { + var errors = functionErrorsPerScope_1[_a]; + errors.push(diag); + } + for (var _b = 0, constantErrorsPerScope_1 = constantErrorsPerScope; _b < constantErrorsPerScope_1.length; _b++) { + var errors = constantErrorsPerScope_1[_b]; + errors.push(diag); + } + } + for (var i = 0; i < scopes.length; i++) { + var scope = scopes[i]; + var resolvedSymbol = checker.resolveName(symbol.name, scope, symbol.flags, /*excludeGlobals*/ false); + if (resolvedSymbol === symbol) { + continue; + } + if (!substitutionsPerScope[i].has(symbolId)) { + var substitution = tryReplaceWithQualifiedNameOrPropertyAccess(symbol.exportSymbol || symbol, scope, isTypeName); + if (substitution) { + substitutionsPerScope[i].set(symbolId, substitution); + } + else if (isTypeName) { + // If the symbol is a type parameter that won't be in scope, we'll pass it as a type argument + // so there's no problem. + if (!(symbol.flags & 262144 /* SymbolFlags.TypeParameter */)) { + var diag = ts.createDiagnosticForNode(identifier, Messages.typeWillNotBeVisibleInTheNewScope); + functionErrorsPerScope[i].push(diag); + constantErrorsPerScope[i].push(diag); + } + } + else { + usagesPerScope[i].usages.set(identifier.text, { usage: usage, symbol: symbol, node: identifier }); + } + } + } + return symbolId; + } + function checkForUsedDeclarations(node) { + // If this node is entirely within the original extraction range, we don't need to do anything. + if (node === targetRange.range || (isReadonlyArray(targetRange.range) && targetRange.range.indexOf(node) >= 0)) { + return; + } + // Otherwise check and recurse. + var sym = ts.isIdentifier(node) + ? getSymbolReferencedByIdentifier(node) + : checker.getSymbolAtLocation(node); + if (sym) { + var decl = ts.find(visibleDeclarationsInExtractedRange, function (d) { return d.symbol === sym; }); + if (decl) { + if (ts.isVariableDeclaration(decl)) { + var idString = decl.symbol.id.toString(); + if (!exposedVariableSymbolSet.has(idString)) { + exposedVariableDeclarations.push(decl); + exposedVariableSymbolSet.set(idString, true); + } + } + else { + // CONSIDER: this includes binding elements, which we could + // expose in the same way as variables. + firstExposedNonVariableDeclaration = firstExposedNonVariableDeclaration || decl; + } + } + } + ts.forEachChild(node, checkForUsedDeclarations); + } + /** + * Return the symbol referenced by an identifier (even if it declares a different symbol). + */ + function getSymbolReferencedByIdentifier(identifier) { + // If the identifier is both a property name and its value, we're only interested in its value + // (since the name is a declaration and will be included in the extracted range). + return identifier.parent && ts.isShorthandPropertyAssignment(identifier.parent) && identifier.parent.name === identifier + ? checker.getShorthandAssignmentValueSymbol(identifier.parent) + : checker.getSymbolAtLocation(identifier); + } + function tryReplaceWithQualifiedNameOrPropertyAccess(symbol, scopeDecl, isTypeNode) { + if (!symbol) { + return undefined; + } + var decls = symbol.getDeclarations(); + if (decls && decls.some(function (d) { return d.parent === scopeDecl; })) { + return ts.factory.createIdentifier(symbol.name); + } + var prefix = tryReplaceWithQualifiedNameOrPropertyAccess(symbol.parent, scopeDecl, isTypeNode); + if (prefix === undefined) { + return undefined; + } + return isTypeNode + ? ts.factory.createQualifiedName(prefix, ts.factory.createIdentifier(symbol.name)) + : ts.factory.createPropertyAccessExpression(prefix, symbol.name); + } + } + function getExtractableParent(node) { + return ts.findAncestor(node, function (node) { return node.parent && isExtractableExpression(node) && !ts.isBinaryExpression(node.parent); }); + } + /** + * Computes whether or not a node represents an expression in a position where it could + * be extracted. + * The isExpression() in utilities.ts returns some false positives we need to handle, + * such as `import x from 'y'` -- the 'y' is a StringLiteral but is *not* an expression + * in the sense of something that you could extract on + */ + function isExtractableExpression(node) { + var parent = node.parent; + switch (parent.kind) { + case 302 /* SyntaxKind.EnumMember */: + return false; + } + switch (node.kind) { + case 10 /* SyntaxKind.StringLiteral */: + return parent.kind !== 269 /* SyntaxKind.ImportDeclaration */ && + parent.kind !== 273 /* SyntaxKind.ImportSpecifier */; + case 227 /* SyntaxKind.SpreadElement */: + case 203 /* SyntaxKind.ObjectBindingPattern */: + case 205 /* SyntaxKind.BindingElement */: + return false; + case 79 /* SyntaxKind.Identifier */: + return parent.kind !== 205 /* SyntaxKind.BindingElement */ && + parent.kind !== 273 /* SyntaxKind.ImportSpecifier */ && + parent.kind !== 278 /* SyntaxKind.ExportSpecifier */; + } + return true; + } + function isBlockLike(node) { + switch (node.kind) { + case 238 /* SyntaxKind.Block */: + case 308 /* SyntaxKind.SourceFile */: + case 265 /* SyntaxKind.ModuleBlock */: + case 292 /* SyntaxKind.CaseClause */: + return true; + default: + return false; + } + } + function isInJSXContent(node) { + return isStringLiteralJsxAttribute(node) || + (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node) || ts.isJsxFragment(node)) && (ts.isJsxElement(node.parent) || ts.isJsxFragment(node.parent)); + } + function isStringLiteralJsxAttribute(node) { + return ts.isStringLiteral(node) && node.parent && ts.isJsxAttribute(node.parent); + } + })(extractSymbol = refactor.extractSymbol || (refactor.extractSymbol = {})); + })(refactor = ts.refactor || (ts.refactor = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var refactor; + (function (refactor) { + var refactorName = "Extract type"; + var extractToTypeAliasAction = { + name: "Extract to type alias", + description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_to_type_alias), + kind: "refactor.extract.type", + }; + var extractToInterfaceAction = { + name: "Extract to interface", + description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_to_interface), + kind: "refactor.extract.interface", + }; + var extractToTypeDefAction = { + name: "Extract to typedef", + description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_to_typedef), + kind: "refactor.extract.typedef" + }; + refactor.registerRefactor(refactorName, { + kinds: [ + extractToTypeAliasAction.kind, + extractToInterfaceAction.kind, + extractToTypeDefAction.kind + ], + getAvailableActions: function getRefactorActionsToExtractType(context) { + var info = getRangeToExtract(context, context.triggerReason === "invoked"); + if (!info) + return ts.emptyArray; + if (!refactor.isRefactorErrorInfo(info)) { + return [{ + name: refactorName, + description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_type), + actions: info.isJS ? + [extractToTypeDefAction] : ts.append([extractToTypeAliasAction], info.typeElements && extractToInterfaceAction) + }]; + } + if (context.preferences.provideRefactorNotApplicableReason) { + return [{ + name: refactorName, + description: ts.getLocaleSpecificMessage(ts.Diagnostics.Extract_type), + actions: [ + __assign(__assign({}, extractToTypeDefAction), { notApplicableReason: info.error }), + __assign(__assign({}, extractToTypeAliasAction), { notApplicableReason: info.error }), + __assign(__assign({}, extractToInterfaceAction), { notApplicableReason: info.error }), + ] + }]; + } + return ts.emptyArray; + }, + getEditsForAction: function getRefactorEditsToExtractType(context, actionName) { + var file = context.file; + var info = getRangeToExtract(context); + ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected to find a range to extract"); + var name = ts.getUniqueName("NewType", file); + var edits = ts.textChanges.ChangeTracker.with(context, function (changes) { + switch (actionName) { + case extractToTypeAliasAction.name: + ts.Debug.assert(!info.isJS, "Invalid actionName/JS combo"); + return doTypeAliasChange(changes, file, name, info); + case extractToTypeDefAction.name: + ts.Debug.assert(info.isJS, "Invalid actionName/JS combo"); + return doTypedefChange(changes, file, name, info); + case extractToInterfaceAction.name: + ts.Debug.assert(!info.isJS && !!info.typeElements, "Invalid actionName/JS combo"); + return doInterfaceChange(changes, file, name, info); + default: + ts.Debug.fail("Unexpected action name"); + } + }); + var renameFilename = file.fileName; + var renameLocation = ts.getRenameLocation(edits, renameFilename, name, /*preferLastLocation*/ false); + return { edits: edits, renameFilename: renameFilename, renameLocation: renameLocation }; + } + }); + function getRangeToExtract(context, considerEmptySpans) { + if (considerEmptySpans === void 0) { considerEmptySpans = true; } + var file = context.file, startPosition = context.startPosition; + var isJS = ts.isSourceFileJS(file); + var current = ts.getTokenAtPosition(file, startPosition); + var range = ts.createTextRangeFromSpan(ts.getRefactorContextSpan(context)); + var cursorRequest = range.pos === range.end && considerEmptySpans; + var selection = ts.findAncestor(current, (function (node) { return node.parent && ts.isTypeNode(node) && !rangeContainsSkipTrivia(range, node.parent, file) && + (cursorRequest || ts.nodeOverlapsWithStartEnd(current, file, range.pos, range.end)); })); + if (!selection || !ts.isTypeNode(selection)) + return { error: ts.getLocaleSpecificMessage(ts.Diagnostics.Selection_is_not_a_valid_type_node) }; + var checker = context.program.getTypeChecker(); + var firstStatement = ts.Debug.checkDefined(ts.findAncestor(selection, ts.isStatement), "Should find a statement"); + var typeParameters = collectTypeParameters(checker, selection, firstStatement, file); + if (!typeParameters) + return { error: ts.getLocaleSpecificMessage(ts.Diagnostics.No_type_could_be_extracted_from_this_type_node) }; + var typeElements = flattenTypeLiteralNodeReference(checker, selection); + return { isJS: isJS, selection: selection, firstStatement: firstStatement, typeParameters: typeParameters, typeElements: typeElements }; + } + function flattenTypeLiteralNodeReference(checker, node) { + if (!node) + return undefined; + if (ts.isIntersectionTypeNode(node)) { + var result = []; + var seen_1 = new ts.Map(); + for (var _i = 0, _a = node.types; _i < _a.length; _i++) { + var type = _a[_i]; + var flattenedTypeMembers = flattenTypeLiteralNodeReference(checker, type); + if (!flattenedTypeMembers || !flattenedTypeMembers.every(function (type) { return type.name && ts.addToSeen(seen_1, ts.getNameFromPropertyName(type.name)); })) { + return undefined; + } + ts.addRange(result, flattenedTypeMembers); + } + return result; + } + else if (ts.isParenthesizedTypeNode(node)) { + return flattenTypeLiteralNodeReference(checker, node.type); + } + else if (ts.isTypeLiteralNode(node)) { + return node.members; + } + return undefined; + } + function rangeContainsSkipTrivia(r1, node, file) { + return ts.rangeContainsStartEnd(r1, ts.skipTrivia(file.text, node.pos), node.end); + } + function collectTypeParameters(checker, selection, statement, file) { + var result = []; + return visitor(selection) ? undefined : result; + function visitor(node) { + if (ts.isTypeReferenceNode(node)) { + if (ts.isIdentifier(node.typeName)) { + var typeName = node.typeName; + var symbol = checker.resolveName(typeName.text, typeName, 262144 /* SymbolFlags.TypeParameter */, /* excludeGlobals */ true); + for (var _i = 0, _a = (symbol === null || symbol === void 0 ? void 0 : symbol.declarations) || ts.emptyArray; _i < _a.length; _i++) { + var decl = _a[_i]; + if (ts.isTypeParameterDeclaration(decl) && decl.getSourceFile() === file) { + // skip extraction if the type node is in the range of the type parameter declaration. + // function foo(): void; + if (decl.name.escapedText === typeName.escapedText && rangeContainsSkipTrivia(decl, selection, file)) { + return true; + } + if (rangeContainsSkipTrivia(statement, decl, file) && !rangeContainsSkipTrivia(selection, decl, file)) { + ts.pushIfUnique(result, decl); + break; + } + } + } + } + } + else if (ts.isInferTypeNode(node)) { + var conditionalTypeNode = ts.findAncestor(node, function (n) { return ts.isConditionalTypeNode(n) && rangeContainsSkipTrivia(n.extendsType, node, file); }); + if (!conditionalTypeNode || !rangeContainsSkipTrivia(selection, conditionalTypeNode, file)) { + return true; + } + } + else if ((ts.isTypePredicateNode(node) || ts.isThisTypeNode(node))) { + var functionLikeNode = ts.findAncestor(node.parent, ts.isFunctionLike); + if (functionLikeNode && functionLikeNode.type && rangeContainsSkipTrivia(functionLikeNode.type, node, file) && !rangeContainsSkipTrivia(selection, functionLikeNode, file)) { + return true; + } + } + else if (ts.isTypeQueryNode(node)) { + if (ts.isIdentifier(node.exprName)) { + var symbol = checker.resolveName(node.exprName.text, node.exprName, 111551 /* SymbolFlags.Value */, /* excludeGlobals */ false); + if ((symbol === null || symbol === void 0 ? void 0 : symbol.valueDeclaration) && rangeContainsSkipTrivia(statement, symbol.valueDeclaration, file) && !rangeContainsSkipTrivia(selection, symbol.valueDeclaration, file)) { + return true; + } + } + else { + if (ts.isThisIdentifier(node.exprName.left) && !rangeContainsSkipTrivia(selection, node.parent, file)) { + return true; + } + } + } + if (file && ts.isTupleTypeNode(node) && (ts.getLineAndCharacterOfPosition(file, node.pos).line === ts.getLineAndCharacterOfPosition(file, node.end).line)) { + ts.setEmitFlags(node, 1 /* EmitFlags.SingleLine */); + } + return ts.forEachChild(node, visitor); + } + } + function doTypeAliasChange(changes, file, name, info) { + var firstStatement = info.firstStatement, selection = info.selection, typeParameters = info.typeParameters; + var newTypeNode = ts.factory.createTypeAliasDeclaration( + /* modifiers */ undefined, name, typeParameters.map(function (id) { return ts.factory.updateTypeParameterDeclaration(id, id.modifiers, id.name, id.constraint, /* defaultType */ undefined); }), selection); + changes.insertNodeBefore(file, firstStatement, ts.ignoreSourceNewlines(newTypeNode), /* blankLineBetween */ true); + changes.replaceNode(file, selection, ts.factory.createTypeReferenceNode(name, typeParameters.map(function (id) { return ts.factory.createTypeReferenceNode(id.name, /* typeArguments */ undefined); })), { leadingTriviaOption: ts.textChanges.LeadingTriviaOption.Exclude, trailingTriviaOption: ts.textChanges.TrailingTriviaOption.ExcludeWhitespace }); + } + function doInterfaceChange(changes, file, name, info) { + var _a; + var firstStatement = info.firstStatement, selection = info.selection, typeParameters = info.typeParameters, typeElements = info.typeElements; + var newTypeNode = ts.factory.createInterfaceDeclaration( + /* modifiers */ undefined, name, typeParameters, + /* heritageClauses */ undefined, typeElements); + ts.setTextRange(newTypeNode, (_a = typeElements[0]) === null || _a === void 0 ? void 0 : _a.parent); + changes.insertNodeBefore(file, firstStatement, ts.ignoreSourceNewlines(newTypeNode), /* blankLineBetween */ true); + changes.replaceNode(file, selection, ts.factory.createTypeReferenceNode(name, typeParameters.map(function (id) { return ts.factory.createTypeReferenceNode(id.name, /* typeArguments */ undefined); })), { leadingTriviaOption: ts.textChanges.LeadingTriviaOption.Exclude, trailingTriviaOption: ts.textChanges.TrailingTriviaOption.ExcludeWhitespace }); + } + function doTypedefChange(changes, file, name, info) { + var firstStatement = info.firstStatement, selection = info.selection, typeParameters = info.typeParameters; + ts.setEmitFlags(selection, 1536 /* EmitFlags.NoComments */ | 2048 /* EmitFlags.NoNestedComments */); + var node = ts.factory.createJSDocTypedefTag(ts.factory.createIdentifier("typedef"), ts.factory.createJSDocTypeExpression(selection), ts.factory.createIdentifier(name)); + var templates = []; + ts.forEach(typeParameters, function (typeParameter) { + var constraint = ts.getEffectiveConstraintOfTypeParameter(typeParameter); + var parameter = ts.factory.createTypeParameterDeclaration(/*modifiers*/ undefined, typeParameter.name); + var template = ts.factory.createJSDocTemplateTag(ts.factory.createIdentifier("template"), constraint && ts.cast(constraint, ts.isJSDocTypeExpression), [parameter]); + templates.push(template); + }); + changes.insertNodeBefore(file, firstStatement, ts.factory.createJSDocComment(/* comment */ undefined, ts.factory.createNodeArray(ts.concatenate(templates, [node]))), /* blankLineBetween */ true); + changes.replaceNode(file, selection, ts.factory.createTypeReferenceNode(name, typeParameters.map(function (id) { return ts.factory.createTypeReferenceNode(id.name, /* typeArguments */ undefined); }))); + } + })(refactor = ts.refactor || (ts.refactor = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var refactor; + (function (refactor) { + var generateGetAccessorAndSetAccessor; + (function (generateGetAccessorAndSetAccessor) { + var actionName = "Generate 'get' and 'set' accessors"; + var actionDescription = ts.Diagnostics.Generate_get_and_set_accessors.message; + var generateGetSetAction = { + name: actionName, + description: actionDescription, + kind: "refactor.rewrite.property.generateAccessors", + }; + refactor.registerRefactor(actionName, { + kinds: [generateGetSetAction.kind], + getEditsForAction: function getRefactorActionsToGenerateGetAndSetAccessors(context, actionName) { + if (!context.endPosition) + return undefined; + var info = ts.codefix.getAccessorConvertiblePropertyAtPosition(context.file, context.program, context.startPosition, context.endPosition); + ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected applicable refactor info"); + var edits = ts.codefix.generateAccessorFromProperty(context.file, context.program, context.startPosition, context.endPosition, context, actionName); + if (!edits) + return undefined; + var renameFilename = context.file.fileName; + var nameNeedRename = info.renameAccessor ? info.accessorName : info.fieldName; + var renameLocationOffset = ts.isIdentifier(nameNeedRename) ? 0 : -1; + var renameLocation = renameLocationOffset + ts.getRenameLocation(edits, renameFilename, nameNeedRename.text, /*preferLastLocation*/ ts.isParameter(info.declaration)); + return { renameFilename: renameFilename, renameLocation: renameLocation, edits: edits }; + }, + getAvailableActions: function (context) { + if (!context.endPosition) + return ts.emptyArray; + var info = ts.codefix.getAccessorConvertiblePropertyAtPosition(context.file, context.program, context.startPosition, context.endPosition, context.triggerReason === "invoked"); + if (!info) + return ts.emptyArray; + if (!refactor.isRefactorErrorInfo(info)) { + return [{ + name: actionName, + description: actionDescription, + actions: [generateGetSetAction], + }]; + } + if (context.preferences.provideRefactorNotApplicableReason) { + return [{ + name: actionName, + description: actionDescription, + actions: [__assign(__assign({}, generateGetSetAction), { notApplicableReason: info.error })], + }]; + } + return ts.emptyArray; + } + }); + })(generateGetAccessorAndSetAccessor = refactor.generateGetAccessorAndSetAccessor || (refactor.generateGetAccessorAndSetAccessor = {})); + })(refactor = ts.refactor || (ts.refactor = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var refactor; + (function (refactor) { + /** + * Checks if some refactor info has refactor error info. + */ + function isRefactorErrorInfo(info) { + return info.error !== undefined; + } + refactor.isRefactorErrorInfo = isRefactorErrorInfo; + /** + * Checks if string "known" begins with string "requested". + * Used to match requested kinds with a known kind. + */ + function refactorKindBeginsWith(known, requested) { + if (!requested) + return true; + return known.substr(0, requested.length) === requested; + } + refactor.refactorKindBeginsWith = refactorKindBeginsWith; + })(refactor = ts.refactor || (ts.refactor = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var refactor; + (function (refactor) { + var refactorName = "Move to a new file"; + var description = ts.getLocaleSpecificMessage(ts.Diagnostics.Move_to_a_new_file); + var moveToNewFileAction = { + name: refactorName, + description: description, + kind: "refactor.move.newFile", + }; + refactor.registerRefactor(refactorName, { + kinds: [moveToNewFileAction.kind], + getAvailableActions: function getRefactorActionsToMoveToNewFile(context) { + var statements = getStatementsToMove(context); + if (context.preferences.allowTextChangesInNewFiles && statements) { + return [{ name: refactorName, description: description, actions: [moveToNewFileAction] }]; + } + if (context.preferences.provideRefactorNotApplicableReason) { + return [{ name: refactorName, description: description, actions: [__assign(__assign({}, moveToNewFileAction), { notApplicableReason: ts.getLocaleSpecificMessage(ts.Diagnostics.Selection_is_not_a_valid_statement_or_statements) })] + }]; + } + return ts.emptyArray; + }, + getEditsForAction: function getRefactorEditsToMoveToNewFile(context, actionName) { + ts.Debug.assert(actionName === refactorName, "Wrong refactor invoked"); + var statements = ts.Debug.checkDefined(getStatementsToMove(context)); + var edits = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(context.file, context.program, statements, t, context.host, context.preferences); }); + return { edits: edits, renameFilename: undefined, renameLocation: undefined }; + } + }); + function getRangeToMove(context) { + var file = context.file; + var range = ts.createTextRangeFromSpan(ts.getRefactorContextSpan(context)); + var statements = file.statements; + var startNodeIndex = ts.findIndex(statements, function (s) { return s.end > range.pos; }); + if (startNodeIndex === -1) + return undefined; + var startStatement = statements[startNodeIndex]; + if (ts.isNamedDeclaration(startStatement) && startStatement.name && ts.rangeContainsRange(startStatement.name, range)) { + return { toMove: [statements[startNodeIndex]], afterLast: statements[startNodeIndex + 1] }; + } + // Can't only partially include the start node or be partially into the next node + if (range.pos > startStatement.getStart(file)) + return undefined; + var afterEndNodeIndex = ts.findIndex(statements, function (s) { return s.end > range.end; }, startNodeIndex); + // Can't be partially into the next node + if (afterEndNodeIndex !== -1 && (afterEndNodeIndex === 0 || statements[afterEndNodeIndex].getStart(file) < range.end)) + return undefined; + return { + toMove: statements.slice(startNodeIndex, afterEndNodeIndex === -1 ? statements.length : afterEndNodeIndex), + afterLast: afterEndNodeIndex === -1 ? undefined : statements[afterEndNodeIndex], + }; + } + function doChange(oldFile, program, toMove, changes, host, preferences) { + var checker = program.getTypeChecker(); + var usage = getUsageInfo(oldFile, toMove.all, checker); + var currentDirectory = ts.getDirectoryPath(oldFile.fileName); + var extension = ts.extensionFromPath(oldFile.fileName); + var newModuleName = makeUniqueModuleName(getNewModuleName(usage.oldFileImportsFromNewFile, usage.movedSymbols), extension, currentDirectory, host); + var newFileNameWithExtension = newModuleName + extension; + // If previous file was global, this is easy. + changes.createNewFile(oldFile, ts.combinePaths(currentDirectory, newFileNameWithExtension), getNewStatementsAndRemoveFromOldFile(oldFile, usage, changes, toMove, program, newModuleName, preferences)); + addNewFileToTsconfig(program, changes, oldFile.fileName, newFileNameWithExtension, ts.hostGetCanonicalFileName(host)); + } + function getStatementsToMove(context) { + var rangeToMove = getRangeToMove(context); + if (rangeToMove === undefined) + return undefined; + var all = []; + var ranges = []; + var toMove = rangeToMove.toMove, afterLast = rangeToMove.afterLast; + ts.getRangesWhere(toMove, isAllowedStatementToMove, function (start, afterEndIndex) { + for (var i = start; i < afterEndIndex; i++) + all.push(toMove[i]); + ranges.push({ first: toMove[start], afterLast: afterLast }); + }); + return all.length === 0 ? undefined : { all: all, ranges: ranges }; + } + function isAllowedStatementToMove(statement) { + // Filters imports and prologue directives out of the range of statements to move. + // Imports will be copied to the new file anyway, and may still be needed in the old file. + // Prologue directives will be copied to the new file and should be left in the old file. + return !isPureImport(statement) && !ts.isPrologueDirective(statement); + } + function isPureImport(node) { + switch (node.kind) { + case 269 /* SyntaxKind.ImportDeclaration */: + return true; + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return !ts.hasSyntacticModifier(node, 1 /* ModifierFlags.Export */); + case 240 /* SyntaxKind.VariableStatement */: + return node.declarationList.declarations.every(function (d) { return !!d.initializer && ts.isRequireCall(d.initializer, /*checkArgumentIsStringLiteralLike*/ true); }); + default: + return false; + } + } + function addNewFileToTsconfig(program, changes, oldFileName, newFileNameWithExtension, getCanonicalFileName) { + var cfg = program.getCompilerOptions().configFile; + if (!cfg) + return; + var newFileAbsolutePath = ts.normalizePath(ts.combinePaths(oldFileName, "..", newFileNameWithExtension)); + var newFilePath = ts.getRelativePathFromFile(cfg.fileName, newFileAbsolutePath, getCanonicalFileName); + var cfgObject = cfg.statements[0] && ts.tryCast(cfg.statements[0].expression, ts.isObjectLiteralExpression); + var filesProp = cfgObject && ts.find(cfgObject.properties, function (prop) { + return ts.isPropertyAssignment(prop) && ts.isStringLiteral(prop.name) && prop.name.text === "files"; + }); + if (filesProp && ts.isArrayLiteralExpression(filesProp.initializer)) { + changes.insertNodeInListAfter(cfg, ts.last(filesProp.initializer.elements), ts.factory.createStringLiteral(newFilePath), filesProp.initializer.elements); + } + } + function getNewStatementsAndRemoveFromOldFile(oldFile, usage, changes, toMove, program, newModuleName, preferences) { + var checker = program.getTypeChecker(); + var prologueDirectives = ts.takeWhile(oldFile.statements, ts.isPrologueDirective); + if (oldFile.externalModuleIndicator === undefined && oldFile.commonJsModuleIndicator === undefined && usage.oldImportsNeededByNewFile.size() === 0) { + deleteMovedStatements(oldFile, toMove.ranges, changes); + return __spreadArray(__spreadArray([], prologueDirectives, true), toMove.all, true); + } + var useEsModuleSyntax = !!oldFile.externalModuleIndicator; + var quotePreference = ts.getQuotePreference(oldFile, preferences); + var importsFromNewFile = createOldFileImportsFromNewFile(usage.oldFileImportsFromNewFile, newModuleName, useEsModuleSyntax, quotePreference); + if (importsFromNewFile) { + ts.insertImports(changes, oldFile, importsFromNewFile, /*blankLineBetween*/ true); + } + deleteUnusedOldImports(oldFile, toMove.all, changes, usage.unusedImportsFromOldFile, checker); + deleteMovedStatements(oldFile, toMove.ranges, changes); + updateImportsInOtherFiles(changes, program, oldFile, usage.movedSymbols, newModuleName); + var imports = getNewFileImportsAndAddExportInOldFile(oldFile, usage.oldImportsNeededByNewFile, usage.newFileImportsFromOldFile, changes, checker, useEsModuleSyntax, quotePreference); + var body = addExports(oldFile, toMove.all, usage.oldFileImportsFromNewFile, useEsModuleSyntax); + if (imports.length && body.length) { + return __spreadArray(__spreadArray(__spreadArray(__spreadArray([], prologueDirectives, true), imports, true), [ + 4 /* SyntaxKind.NewLineTrivia */ + ], false), body, true); + } + return __spreadArray(__spreadArray(__spreadArray([], prologueDirectives, true), imports, true), body, true); + } + function deleteMovedStatements(sourceFile, moved, changes) { + for (var _i = 0, moved_1 = moved; _i < moved_1.length; _i++) { + var _a = moved_1[_i], first_1 = _a.first, afterLast = _a.afterLast; + changes.deleteNodeRangeExcludingEnd(sourceFile, first_1, afterLast); + } + } + function deleteUnusedOldImports(oldFile, toMove, changes, toDelete, checker) { + for (var _i = 0, _a = oldFile.statements; _i < _a.length; _i++) { + var statement = _a[_i]; + if (ts.contains(toMove, statement)) + continue; + forEachImportInStatement(statement, function (i) { return deleteUnusedImports(oldFile, i, changes, function (name) { return toDelete.has(checker.getSymbolAtLocation(name)); }); }); + } + } + function updateImportsInOtherFiles(changes, program, oldFile, movedSymbols, newModuleName) { + var checker = program.getTypeChecker(); + var _loop_17 = function (sourceFile) { + if (sourceFile === oldFile) + return "continue"; + var _loop_18 = function (statement) { + forEachImportInStatement(statement, function (importNode) { + if (checker.getSymbolAtLocation(moduleSpecifierFromImport(importNode)) !== oldFile.symbol) + return; + var shouldMove = function (name) { + var symbol = ts.isBindingElement(name.parent) + ? ts.getPropertySymbolFromBindingElement(checker, name.parent) + : ts.skipAlias(checker.getSymbolAtLocation(name), checker); // TODO: GH#18217 + return !!symbol && movedSymbols.has(symbol); + }; + deleteUnusedImports(sourceFile, importNode, changes, shouldMove); // These will be changed to imports from the new file + var newModuleSpecifier = ts.combinePaths(ts.getDirectoryPath(moduleSpecifierFromImport(importNode).text), newModuleName); + var newImportDeclaration = filterImport(importNode, ts.factory.createStringLiteral(newModuleSpecifier), shouldMove); + if (newImportDeclaration) + changes.insertNodeAfter(sourceFile, statement, newImportDeclaration); + var ns = getNamespaceLikeImport(importNode); + if (ns) + updateNamespaceLikeImport(changes, sourceFile, checker, movedSymbols, newModuleName, newModuleSpecifier, ns, importNode); + }); + }; + for (var _b = 0, _c = sourceFile.statements; _b < _c.length; _b++) { + var statement = _c[_b]; + _loop_18(statement); + } + }; + for (var _i = 0, _a = program.getSourceFiles(); _i < _a.length; _i++) { + var sourceFile = _a[_i]; + _loop_17(sourceFile); + } + } + function getNamespaceLikeImport(node) { + switch (node.kind) { + case 269 /* SyntaxKind.ImportDeclaration */: + return node.importClause && node.importClause.namedBindings && node.importClause.namedBindings.kind === 271 /* SyntaxKind.NamespaceImport */ ? + node.importClause.namedBindings.name : undefined; + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return node.name; + case 257 /* SyntaxKind.VariableDeclaration */: + return ts.tryCast(node.name, ts.isIdentifier); + default: + return ts.Debug.assertNever(node, "Unexpected node kind ".concat(node.kind)); + } + } + function updateNamespaceLikeImport(changes, sourceFile, checker, movedSymbols, newModuleName, newModuleSpecifier, oldImportId, oldImportNode) { + var preferredNewNamespaceName = ts.codefix.moduleSpecifierToValidIdentifier(newModuleName, 99 /* ScriptTarget.ESNext */); + var needUniqueName = false; + var toChange = []; + ts.FindAllReferences.Core.eachSymbolReferenceInFile(oldImportId, checker, sourceFile, function (ref) { + if (!ts.isPropertyAccessExpression(ref.parent)) + return; + needUniqueName = needUniqueName || !!checker.resolveName(preferredNewNamespaceName, ref, 67108863 /* SymbolFlags.All */, /*excludeGlobals*/ true); + if (movedSymbols.has(checker.getSymbolAtLocation(ref.parent.name))) { + toChange.push(ref); + } + }); + if (toChange.length) { + var newNamespaceName = needUniqueName ? ts.getUniqueName(preferredNewNamespaceName, sourceFile) : preferredNewNamespaceName; + for (var _i = 0, toChange_1 = toChange; _i < toChange_1.length; _i++) { + var ref = toChange_1[_i]; + changes.replaceNode(sourceFile, ref, ts.factory.createIdentifier(newNamespaceName)); + } + changes.insertNodeAfter(sourceFile, oldImportNode, updateNamespaceLikeImportNode(oldImportNode, newModuleName, newModuleSpecifier)); + } + } + function updateNamespaceLikeImportNode(node, newNamespaceName, newModuleSpecifier) { + var newNamespaceId = ts.factory.createIdentifier(newNamespaceName); + var newModuleString = ts.factory.createStringLiteral(newModuleSpecifier); + switch (node.kind) { + case 269 /* SyntaxKind.ImportDeclaration */: + return ts.factory.createImportDeclaration( + /*modifiers*/ undefined, ts.factory.createImportClause(/*isTypeOnly*/ false, /*name*/ undefined, ts.factory.createNamespaceImport(newNamespaceId)), newModuleString, + /*assertClause*/ undefined); + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return ts.factory.createImportEqualsDeclaration(/*modifiers*/ undefined, /*isTypeOnly*/ false, newNamespaceId, ts.factory.createExternalModuleReference(newModuleString)); + case 257 /* SyntaxKind.VariableDeclaration */: + return ts.factory.createVariableDeclaration(newNamespaceId, /*exclamationToken*/ undefined, /*type*/ undefined, createRequireCall(newModuleString)); + default: + return ts.Debug.assertNever(node, "Unexpected node kind ".concat(node.kind)); + } + } + function moduleSpecifierFromImport(i) { + return (i.kind === 269 /* SyntaxKind.ImportDeclaration */ ? i.moduleSpecifier + : i.kind === 268 /* SyntaxKind.ImportEqualsDeclaration */ ? i.moduleReference.expression + : i.initializer.arguments[0]); + } + function forEachImportInStatement(statement, cb) { + if (ts.isImportDeclaration(statement)) { + if (ts.isStringLiteral(statement.moduleSpecifier)) + cb(statement); + } + else if (ts.isImportEqualsDeclaration(statement)) { + if (ts.isExternalModuleReference(statement.moduleReference) && ts.isStringLiteralLike(statement.moduleReference.expression)) { + cb(statement); + } + } + else if (ts.isVariableStatement(statement)) { + for (var _i = 0, _a = statement.declarationList.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + if (decl.initializer && ts.isRequireCall(decl.initializer, /*checkArgumentIsStringLiteralLike*/ true)) { + cb(decl); + } + } + } + } + function createOldFileImportsFromNewFile(newFileNeedExport, newFileNameWithExtension, useEs6Imports, quotePreference) { + var defaultImport; + var imports = []; + newFileNeedExport.forEach(function (symbol) { + if (symbol.escapedName === "default" /* InternalSymbolName.Default */) { + defaultImport = ts.factory.createIdentifier(ts.symbolNameNoDefault(symbol)); // TODO: GH#18217 + } + else { + imports.push(symbol.name); + } + }); + return makeImportOrRequire(defaultImport, imports, newFileNameWithExtension, useEs6Imports, quotePreference); + } + function makeImportOrRequire(defaultImport, imports, path, useEs6Imports, quotePreference) { + path = ts.ensurePathIsNonModuleName(path); + if (useEs6Imports) { + var specifiers = imports.map(function (i) { return ts.factory.createImportSpecifier(/*isTypeOnly*/ false, /*propertyName*/ undefined, ts.factory.createIdentifier(i)); }); + return ts.makeImportIfNecessary(defaultImport, specifiers, path, quotePreference); + } + else { + ts.Debug.assert(!defaultImport, "No default import should exist"); // If there's a default export, it should have been an es6 module. + var bindingElements = imports.map(function (i) { return ts.factory.createBindingElement(/*dotDotDotToken*/ undefined, /*propertyName*/ undefined, i); }); + return bindingElements.length + ? makeVariableStatement(ts.factory.createObjectBindingPattern(bindingElements), /*type*/ undefined, createRequireCall(ts.factory.createStringLiteral(path))) + : undefined; + } + } + function makeVariableStatement(name, type, initializer, flags) { + if (flags === void 0) { flags = 2 /* NodeFlags.Const */; } + return ts.factory.createVariableStatement(/*modifiers*/ undefined, ts.factory.createVariableDeclarationList([ts.factory.createVariableDeclaration(name, /*exclamationToken*/ undefined, type, initializer)], flags)); + } + function createRequireCall(moduleSpecifier) { + return ts.factory.createCallExpression(ts.factory.createIdentifier("require"), /*typeArguments*/ undefined, [moduleSpecifier]); + } + function addExports(sourceFile, toMove, needExport, useEs6Exports) { + return ts.flatMap(toMove, function (statement) { + if (isTopLevelDeclarationStatement(statement) && + !isExported(sourceFile, statement, useEs6Exports) && + forEachTopLevelDeclaration(statement, function (d) { return needExport.has(ts.Debug.checkDefined(d.symbol)); })) { + var exports = addExport(statement, useEs6Exports); + if (exports) + return exports; + } + return statement; + }); + } + function deleteUnusedImports(sourceFile, importDecl, changes, isUnused) { + switch (importDecl.kind) { + case 269 /* SyntaxKind.ImportDeclaration */: + deleteUnusedImportsInDeclaration(sourceFile, importDecl, changes, isUnused); + break; + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + if (isUnused(importDecl.name)) { + changes.delete(sourceFile, importDecl); + } + break; + case 257 /* SyntaxKind.VariableDeclaration */: + deleteUnusedImportsInVariableDeclaration(sourceFile, importDecl, changes, isUnused); + break; + default: + ts.Debug.assertNever(importDecl, "Unexpected import decl kind ".concat(importDecl.kind)); + } + } + function deleteUnusedImportsInDeclaration(sourceFile, importDecl, changes, isUnused) { + if (!importDecl.importClause) + return; + var _a = importDecl.importClause, name = _a.name, namedBindings = _a.namedBindings; + var defaultUnused = !name || isUnused(name); + var namedBindingsUnused = !namedBindings || + (namedBindings.kind === 271 /* SyntaxKind.NamespaceImport */ ? isUnused(namedBindings.name) : namedBindings.elements.length !== 0 && namedBindings.elements.every(function (e) { return isUnused(e.name); })); + if (defaultUnused && namedBindingsUnused) { + changes.delete(sourceFile, importDecl); + } + else { + if (name && defaultUnused) { + changes.delete(sourceFile, name); + } + if (namedBindings) { + if (namedBindingsUnused) { + changes.replaceNode(sourceFile, importDecl.importClause, ts.factory.updateImportClause(importDecl.importClause, importDecl.importClause.isTypeOnly, name, /*namedBindings*/ undefined)); + } + else if (namedBindings.kind === 272 /* SyntaxKind.NamedImports */) { + for (var _i = 0, _b = namedBindings.elements; _i < _b.length; _i++) { + var element = _b[_i]; + if (isUnused(element.name)) + changes.delete(sourceFile, element); + } + } + } + } + } + function deleteUnusedImportsInVariableDeclaration(sourceFile, varDecl, changes, isUnused) { + var name = varDecl.name; + switch (name.kind) { + case 79 /* SyntaxKind.Identifier */: + if (isUnused(name)) { + if (varDecl.initializer && ts.isRequireCall(varDecl.initializer, /*requireStringLiteralLikeArgument*/ true)) { + changes.delete(sourceFile, ts.isVariableDeclarationList(varDecl.parent) && ts.length(varDecl.parent.declarations) === 1 ? varDecl.parent.parent : varDecl); + } + else { + changes.delete(sourceFile, name); + } + } + break; + case 204 /* SyntaxKind.ArrayBindingPattern */: + break; + case 203 /* SyntaxKind.ObjectBindingPattern */: + if (name.elements.every(function (e) { return ts.isIdentifier(e.name) && isUnused(e.name); })) { + changes.delete(sourceFile, ts.isVariableDeclarationList(varDecl.parent) && varDecl.parent.declarations.length === 1 ? varDecl.parent.parent : varDecl); + } + else { + for (var _i = 0, _a = name.elements; _i < _a.length; _i++) { + var element = _a[_i]; + if (ts.isIdentifier(element.name) && isUnused(element.name)) { + changes.delete(sourceFile, element.name); + } + } + } + break; + } + } + function getNewFileImportsAndAddExportInOldFile(oldFile, importsToCopy, newFileImportsFromOldFile, changes, checker, useEsModuleSyntax, quotePreference) { + var copiedOldImports = []; + for (var _i = 0, _a = oldFile.statements; _i < _a.length; _i++) { + var oldStatement = _a[_i]; + forEachImportInStatement(oldStatement, function (i) { + ts.append(copiedOldImports, filterImport(i, moduleSpecifierFromImport(i), function (name) { return importsToCopy.has(checker.getSymbolAtLocation(name)); })); + }); + } + // Also, import things used from the old file, and insert 'export' modifiers as necessary in the old file. + var oldFileDefault; + var oldFileNamedImports = []; + var markSeenTop = ts.nodeSeenTracker(); // Needed because multiple declarations may appear in `const x = 0, y = 1;`. + newFileImportsFromOldFile.forEach(function (symbol) { + if (!symbol.declarations) { + return; + } + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + if (!isTopLevelDeclaration(decl)) + continue; + var name = nameOfTopLevelDeclaration(decl); + if (!name) + continue; + var top = getTopLevelDeclarationStatement(decl); + if (markSeenTop(top)) { + addExportToChanges(oldFile, top, name, changes, useEsModuleSyntax); + } + if (ts.hasSyntacticModifier(decl, 1024 /* ModifierFlags.Default */)) { + oldFileDefault = name; + } + else { + oldFileNamedImports.push(name.text); + } + } + }); + ts.append(copiedOldImports, makeImportOrRequire(oldFileDefault, oldFileNamedImports, ts.removeFileExtension(ts.getBaseFileName(oldFile.fileName)), useEsModuleSyntax, quotePreference)); + return copiedOldImports; + } + function makeUniqueModuleName(moduleName, extension, inDirectory, host) { + var newModuleName = moduleName; + for (var i = 1;; i++) { + var name = ts.combinePaths(inDirectory, newModuleName + extension); + if (!host.fileExists(name)) + return newModuleName; + newModuleName = "".concat(moduleName, ".").concat(i); + } + } + function getNewModuleName(importsFromNewFile, movedSymbols) { + return importsFromNewFile.forEachEntry(ts.symbolNameNoDefault) || movedSymbols.forEachEntry(ts.symbolNameNoDefault) || "newFile"; + } + function getUsageInfo(oldFile, toMove, checker) { + var movedSymbols = new SymbolSet(); + var oldImportsNeededByNewFile = new SymbolSet(); + var newFileImportsFromOldFile = new SymbolSet(); + var containsJsx = ts.find(toMove, function (statement) { return !!(statement.transformFlags & 2 /* TransformFlags.ContainsJsx */); }); + var jsxNamespaceSymbol = getJsxNamespaceSymbol(containsJsx); + if (jsxNamespaceSymbol) { // Might not exist (e.g. in non-compiling code) + oldImportsNeededByNewFile.add(jsxNamespaceSymbol); + } + for (var _i = 0, toMove_1 = toMove; _i < toMove_1.length; _i++) { + var statement = toMove_1[_i]; + forEachTopLevelDeclaration(statement, function (decl) { + movedSymbols.add(ts.Debug.checkDefined(ts.isExpressionStatement(decl) ? checker.getSymbolAtLocation(decl.expression.left) : decl.symbol, "Need a symbol here")); + }); + } + for (var _a = 0, toMove_2 = toMove; _a < toMove_2.length; _a++) { + var statement = toMove_2[_a]; + forEachReference(statement, checker, function (symbol) { + if (!symbol.declarations) + return; + for (var _i = 0, _a = symbol.declarations; _i < _a.length; _i++) { + var decl = _a[_i]; + if (isInImport(decl)) { + oldImportsNeededByNewFile.add(symbol); + } + else if (isTopLevelDeclaration(decl) && sourceFileOfTopLevelDeclaration(decl) === oldFile && !movedSymbols.has(symbol)) { + newFileImportsFromOldFile.add(symbol); + } + } + }); + } + var unusedImportsFromOldFile = oldImportsNeededByNewFile.clone(); + var oldFileImportsFromNewFile = new SymbolSet(); + for (var _b = 0, _c = oldFile.statements; _b < _c.length; _b++) { + var statement = _c[_b]; + if (ts.contains(toMove, statement)) + continue; + // jsxNamespaceSymbol will only be set iff it is in oldImportsNeededByNewFile. + if (jsxNamespaceSymbol && !!(statement.transformFlags & 2 /* TransformFlags.ContainsJsx */)) { + unusedImportsFromOldFile.delete(jsxNamespaceSymbol); + } + forEachReference(statement, checker, function (symbol) { + if (movedSymbols.has(symbol)) + oldFileImportsFromNewFile.add(symbol); + unusedImportsFromOldFile.delete(symbol); + }); + } + return { movedSymbols: movedSymbols, newFileImportsFromOldFile: newFileImportsFromOldFile, oldFileImportsFromNewFile: oldFileImportsFromNewFile, oldImportsNeededByNewFile: oldImportsNeededByNewFile, unusedImportsFromOldFile: unusedImportsFromOldFile }; + function getJsxNamespaceSymbol(containsJsx) { + if (containsJsx === undefined) { + return undefined; + } + var jsxNamespace = checker.getJsxNamespace(containsJsx); + // Strictly speaking, this could resolve to a symbol other than the JSX namespace. + // This will produce erroneous output (probably, an incorrectly copied import) but + // is expected to be very rare and easily reversible. + var jsxNamespaceSymbol = checker.resolveName(jsxNamespace, containsJsx, 1920 /* SymbolFlags.Namespace */, /*excludeGlobals*/ true); + return !!jsxNamespaceSymbol && ts.some(jsxNamespaceSymbol.declarations, isInImport) + ? jsxNamespaceSymbol + : undefined; + } + } + // Below should all be utilities + function isInImport(decl) { + switch (decl.kind) { + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + case 273 /* SyntaxKind.ImportSpecifier */: + case 270 /* SyntaxKind.ImportClause */: + case 271 /* SyntaxKind.NamespaceImport */: + return true; + case 257 /* SyntaxKind.VariableDeclaration */: + return isVariableDeclarationInImport(decl); + case 205 /* SyntaxKind.BindingElement */: + return ts.isVariableDeclaration(decl.parent.parent) && isVariableDeclarationInImport(decl.parent.parent); + default: + return false; + } + } + function isVariableDeclarationInImport(decl) { + return ts.isSourceFile(decl.parent.parent.parent) && + !!decl.initializer && ts.isRequireCall(decl.initializer, /*checkArgumentIsStringLiteralLike*/ true); + } + function filterImport(i, moduleSpecifier, keep) { + switch (i.kind) { + case 269 /* SyntaxKind.ImportDeclaration */: { + var clause = i.importClause; + if (!clause) + return undefined; + var defaultImport = clause.name && keep(clause.name) ? clause.name : undefined; + var namedBindings = clause.namedBindings && filterNamedBindings(clause.namedBindings, keep); + return defaultImport || namedBindings + ? ts.factory.createImportDeclaration(/*modifiers*/ undefined, ts.factory.createImportClause(/*isTypeOnly*/ false, defaultImport, namedBindings), moduleSpecifier, /*assertClause*/ undefined) + : undefined; + } + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return keep(i.name) ? i : undefined; + case 257 /* SyntaxKind.VariableDeclaration */: { + var name = filterBindingName(i.name, keep); + return name ? makeVariableStatement(name, i.type, createRequireCall(moduleSpecifier), i.parent.flags) : undefined; + } + default: + return ts.Debug.assertNever(i, "Unexpected import kind ".concat(i.kind)); + } + } + function filterNamedBindings(namedBindings, keep) { + if (namedBindings.kind === 271 /* SyntaxKind.NamespaceImport */) { + return keep(namedBindings.name) ? namedBindings : undefined; + } + else { + var newElements = namedBindings.elements.filter(function (e) { return keep(e.name); }); + return newElements.length ? ts.factory.createNamedImports(newElements) : undefined; + } + } + function filterBindingName(name, keep) { + switch (name.kind) { + case 79 /* SyntaxKind.Identifier */: + return keep(name) ? name : undefined; + case 204 /* SyntaxKind.ArrayBindingPattern */: + return name; + case 203 /* SyntaxKind.ObjectBindingPattern */: { + // We can't handle nested destructurings or property names well here, so just copy them all. + var newElements = name.elements.filter(function (prop) { return prop.propertyName || !ts.isIdentifier(prop.name) || keep(prop.name); }); + return newElements.length ? ts.factory.createObjectBindingPattern(newElements) : undefined; + } + } + } + function forEachReference(node, checker, onReference) { + node.forEachChild(function cb(node) { + if (ts.isIdentifier(node) && !ts.isDeclarationName(node)) { + var sym = checker.getSymbolAtLocation(node); + if (sym) + onReference(sym); + } + else { + node.forEachChild(cb); + } + }); + } + var SymbolSet = /** @class */ (function () { + function SymbolSet() { + this.map = new ts.Map(); + } + SymbolSet.prototype.add = function (symbol) { + this.map.set(String(ts.getSymbolId(symbol)), symbol); + }; + SymbolSet.prototype.has = function (symbol) { + return this.map.has(String(ts.getSymbolId(symbol))); + }; + SymbolSet.prototype.delete = function (symbol) { + this.map.delete(String(ts.getSymbolId(symbol))); + }; + SymbolSet.prototype.forEach = function (cb) { + this.map.forEach(cb); + }; + SymbolSet.prototype.forEachEntry = function (cb) { + return ts.forEachEntry(this.map, cb); + }; + SymbolSet.prototype.clone = function () { + var clone = new SymbolSet(); + ts.copyEntries(this.map, clone.map); + return clone; + }; + SymbolSet.prototype.size = function () { + return this.map.size; + }; + return SymbolSet; + }()); + function isTopLevelDeclaration(node) { + return isNonVariableTopLevelDeclaration(node) && ts.isSourceFile(node.parent) || ts.isVariableDeclaration(node) && ts.isSourceFile(node.parent.parent.parent); + } + function sourceFileOfTopLevelDeclaration(node) { + return ts.isVariableDeclaration(node) ? node.parent.parent.parent : node.parent; + } + function isTopLevelDeclarationStatement(node) { + ts.Debug.assert(ts.isSourceFile(node.parent), "Node parent should be a SourceFile"); + return isNonVariableTopLevelDeclaration(node) || ts.isVariableStatement(node); + } + function isNonVariableTopLevelDeclaration(node) { + switch (node.kind) { + case 259 /* SyntaxKind.FunctionDeclaration */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 264 /* SyntaxKind.ModuleDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return true; + default: + return false; + } + } + function forEachTopLevelDeclaration(statement, cb) { + switch (statement.kind) { + case 259 /* SyntaxKind.FunctionDeclaration */: + case 260 /* SyntaxKind.ClassDeclaration */: + case 264 /* SyntaxKind.ModuleDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return cb(statement); + case 240 /* SyntaxKind.VariableStatement */: + return ts.firstDefined(statement.declarationList.declarations, function (decl) { return forEachTopLevelDeclarationInBindingName(decl.name, cb); }); + case 241 /* SyntaxKind.ExpressionStatement */: { + var expression = statement.expression; + return ts.isBinaryExpression(expression) && ts.getAssignmentDeclarationKind(expression) === 1 /* AssignmentDeclarationKind.ExportsProperty */ + ? cb(statement) + : undefined; + } + } + } + function forEachTopLevelDeclarationInBindingName(name, cb) { + switch (name.kind) { + case 79 /* SyntaxKind.Identifier */: + return cb(ts.cast(name.parent, function (x) { return ts.isVariableDeclaration(x) || ts.isBindingElement(x); })); + case 204 /* SyntaxKind.ArrayBindingPattern */: + case 203 /* SyntaxKind.ObjectBindingPattern */: + return ts.firstDefined(name.elements, function (em) { return ts.isOmittedExpression(em) ? undefined : forEachTopLevelDeclarationInBindingName(em.name, cb); }); + default: + return ts.Debug.assertNever(name, "Unexpected name kind ".concat(name.kind)); + } + } + function nameOfTopLevelDeclaration(d) { + return ts.isExpressionStatement(d) ? ts.tryCast(d.expression.left.name, ts.isIdentifier) : ts.tryCast(d.name, ts.isIdentifier); + } + function getTopLevelDeclarationStatement(d) { + switch (d.kind) { + case 257 /* SyntaxKind.VariableDeclaration */: + return d.parent.parent; + case 205 /* SyntaxKind.BindingElement */: + return getTopLevelDeclarationStatement(ts.cast(d.parent.parent, function (p) { return ts.isVariableDeclaration(p) || ts.isBindingElement(p); })); + default: + return d; + } + } + function addExportToChanges(sourceFile, decl, name, changes, useEs6Exports) { + if (isExported(sourceFile, decl, useEs6Exports, name)) + return; + if (useEs6Exports) { + if (!ts.isExpressionStatement(decl)) + changes.insertExportModifier(sourceFile, decl); + } + else { + var names = getNamesToExportInCommonJS(decl); + if (names.length !== 0) + changes.insertNodesAfter(sourceFile, decl, names.map(createExportAssignment)); + } + } + function isExported(sourceFile, decl, useEs6Exports, name) { + var _a; + if (useEs6Exports) { + return !ts.isExpressionStatement(decl) && ts.hasSyntacticModifier(decl, 1 /* ModifierFlags.Export */) || !!(name && ((_a = sourceFile.symbol.exports) === null || _a === void 0 ? void 0 : _a.has(name.escapedText))); + } + return !!sourceFile.symbol && !!sourceFile.symbol.exports && + getNamesToExportInCommonJS(decl).some(function (name) { return sourceFile.symbol.exports.has(ts.escapeLeadingUnderscores(name)); }); + } + function addExport(decl, useEs6Exports) { + return useEs6Exports ? [addEs6Export(decl)] : addCommonjsExport(decl); + } + function addEs6Export(d) { + var modifiers = ts.canHaveModifiers(d) ? ts.concatenate([ts.factory.createModifier(93 /* SyntaxKind.ExportKeyword */)], ts.getModifiers(d)) : undefined; + switch (d.kind) { + case 259 /* SyntaxKind.FunctionDeclaration */: + return ts.factory.updateFunctionDeclaration(d, modifiers, d.asteriskToken, d.name, d.typeParameters, d.parameters, d.type, d.body); + case 260 /* SyntaxKind.ClassDeclaration */: + var decorators = ts.canHaveDecorators(d) ? ts.getDecorators(d) : undefined; + return ts.factory.updateClassDeclaration(d, ts.concatenate(decorators, modifiers), d.name, d.typeParameters, d.heritageClauses, d.members); + case 240 /* SyntaxKind.VariableStatement */: + return ts.factory.updateVariableStatement(d, modifiers, d.declarationList); + case 264 /* SyntaxKind.ModuleDeclaration */: + return ts.factory.updateModuleDeclaration(d, modifiers, d.name, d.body); + case 263 /* SyntaxKind.EnumDeclaration */: + return ts.factory.updateEnumDeclaration(d, modifiers, d.name, d.members); + case 262 /* SyntaxKind.TypeAliasDeclaration */: + return ts.factory.updateTypeAliasDeclaration(d, modifiers, d.name, d.typeParameters, d.type); + case 261 /* SyntaxKind.InterfaceDeclaration */: + return ts.factory.updateInterfaceDeclaration(d, modifiers, d.name, d.typeParameters, d.heritageClauses, d.members); + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return ts.factory.updateImportEqualsDeclaration(d, modifiers, d.isTypeOnly, d.name, d.moduleReference); + case 241 /* SyntaxKind.ExpressionStatement */: + return ts.Debug.fail(); // Shouldn't try to add 'export' keyword to `exports.x = ...` + default: + return ts.Debug.assertNever(d, "Unexpected declaration kind ".concat(d.kind)); + } + } + function addCommonjsExport(decl) { + return __spreadArray([decl], getNamesToExportInCommonJS(decl).map(createExportAssignment), true); + } + function getNamesToExportInCommonJS(decl) { + switch (decl.kind) { + case 259 /* SyntaxKind.FunctionDeclaration */: + case 260 /* SyntaxKind.ClassDeclaration */: + return [decl.name.text]; // TODO: GH#18217 + case 240 /* SyntaxKind.VariableStatement */: + return ts.mapDefined(decl.declarationList.declarations, function (d) { return ts.isIdentifier(d.name) ? d.name.text : undefined; }); + case 264 /* SyntaxKind.ModuleDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + return ts.emptyArray; + case 241 /* SyntaxKind.ExpressionStatement */: + return ts.Debug.fail("Can't export an ExpressionStatement"); // Shouldn't try to add 'export' keyword to `exports.x = ...` + default: + return ts.Debug.assertNever(decl, "Unexpected decl kind ".concat(decl.kind)); + } + } + /** Creates `exports.x = x;` */ + function createExportAssignment(name) { + return ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier("exports"), ts.factory.createIdentifier(name)), 63 /* SyntaxKind.EqualsToken */, ts.factory.createIdentifier(name))); + } + })(refactor = ts.refactor || (ts.refactor = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var refactor; + (function (refactor) { + var addOrRemoveBracesToArrowFunction; + (function (addOrRemoveBracesToArrowFunction) { + var refactorName = "Add or remove braces in an arrow function"; + var refactorDescription = ts.Diagnostics.Add_or_remove_braces_in_an_arrow_function.message; + var addBracesAction = { + name: "Add braces to arrow function", + description: ts.Diagnostics.Add_braces_to_arrow_function.message, + kind: "refactor.rewrite.arrow.braces.add", + }; + var removeBracesAction = { + name: "Remove braces from arrow function", + description: ts.Diagnostics.Remove_braces_from_arrow_function.message, + kind: "refactor.rewrite.arrow.braces.remove" + }; + refactor.registerRefactor(refactorName, { + kinds: [removeBracesAction.kind], + getEditsForAction: getRefactorEditsToRemoveFunctionBraces, + getAvailableActions: getRefactorActionsToRemoveFunctionBraces + }); + function getRefactorActionsToRemoveFunctionBraces(context) { + var file = context.file, startPosition = context.startPosition, triggerReason = context.triggerReason; + var info = getConvertibleArrowFunctionAtPosition(file, startPosition, triggerReason === "invoked"); + if (!info) + return ts.emptyArray; + if (!refactor.isRefactorErrorInfo(info)) { + return [{ + name: refactorName, + description: refactorDescription, + actions: [ + info.addBraces ? addBracesAction : removeBracesAction + ] + }]; + } + if (context.preferences.provideRefactorNotApplicableReason) { + return [{ + name: refactorName, + description: refactorDescription, + actions: [ + __assign(__assign({}, addBracesAction), { notApplicableReason: info.error }), + __assign(__assign({}, removeBracesAction), { notApplicableReason: info.error }), + ] + }]; + } + return ts.emptyArray; + } + function getRefactorEditsToRemoveFunctionBraces(context, actionName) { + var file = context.file, startPosition = context.startPosition; + var info = getConvertibleArrowFunctionAtPosition(file, startPosition); + ts.Debug.assert(info && !refactor.isRefactorErrorInfo(info), "Expected applicable refactor info"); + var expression = info.expression, returnStatement = info.returnStatement, func = info.func; + var body; + if (actionName === addBracesAction.name) { + var returnStatement_1 = ts.factory.createReturnStatement(expression); + body = ts.factory.createBlock([returnStatement_1], /* multiLine */ true); + ts.copyLeadingComments(expression, returnStatement_1, file, 3 /* SyntaxKind.MultiLineCommentTrivia */, /* hasTrailingNewLine */ true); + } + else if (actionName === removeBracesAction.name && returnStatement) { + var actualExpression = expression || ts.factory.createVoidZero(); + body = ts.needsParentheses(actualExpression) ? ts.factory.createParenthesizedExpression(actualExpression) : actualExpression; + ts.copyTrailingAsLeadingComments(returnStatement, body, file, 3 /* SyntaxKind.MultiLineCommentTrivia */, /* hasTrailingNewLine */ false); + ts.copyLeadingComments(returnStatement, body, file, 3 /* SyntaxKind.MultiLineCommentTrivia */, /* hasTrailingNewLine */ false); + ts.copyTrailingComments(returnStatement, body, file, 3 /* SyntaxKind.MultiLineCommentTrivia */, /* hasTrailingNewLine */ false); + } + else { + ts.Debug.fail("invalid action"); + } + var edits = ts.textChanges.ChangeTracker.with(context, function (t) { + t.replaceNode(file, func.body, body); + }); + return { renameFilename: undefined, renameLocation: undefined, edits: edits }; + } + function getConvertibleArrowFunctionAtPosition(file, startPosition, considerFunctionBodies, kind) { + if (considerFunctionBodies === void 0) { considerFunctionBodies = true; } + var node = ts.getTokenAtPosition(file, startPosition); + var func = ts.getContainingFunction(node); + if (!func) { + return { + error: ts.getLocaleSpecificMessage(ts.Diagnostics.Could_not_find_a_containing_arrow_function) + }; + } + if (!ts.isArrowFunction(func)) { + return { + error: ts.getLocaleSpecificMessage(ts.Diagnostics.Containing_function_is_not_an_arrow_function) + }; + } + if ((!ts.rangeContainsRange(func, node) || ts.rangeContainsRange(func.body, node) && !considerFunctionBodies)) { + return undefined; + } + if (refactor.refactorKindBeginsWith(addBracesAction.kind, kind) && ts.isExpression(func.body)) { + return { func: func, addBraces: true, expression: func.body }; + } + else if (refactor.refactorKindBeginsWith(removeBracesAction.kind, kind) && ts.isBlock(func.body) && func.body.statements.length === 1) { + var firstStatement = ts.first(func.body.statements); + if (ts.isReturnStatement(firstStatement)) { + return { func: func, addBraces: false, expression: firstStatement.expression, returnStatement: firstStatement }; + } + } + return undefined; + } + })(addOrRemoveBracesToArrowFunction = refactor.addOrRemoveBracesToArrowFunction || (refactor.addOrRemoveBracesToArrowFunction = {})); + })(refactor = ts.refactor || (ts.refactor = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var refactor; + (function (refactor) { + var convertParamsToDestructuredObject; + (function (convertParamsToDestructuredObject) { + var refactorName = "Convert parameters to destructured object"; + var minimumParameterLength = 1; + var refactorDescription = ts.getLocaleSpecificMessage(ts.Diagnostics.Convert_parameters_to_destructured_object); + var toDestructuredAction = { + name: refactorName, + description: refactorDescription, + kind: "refactor.rewrite.parameters.toDestructured" + }; + refactor.registerRefactor(refactorName, { + kinds: [toDestructuredAction.kind], + getEditsForAction: getRefactorEditsToConvertParametersToDestructuredObject, + getAvailableActions: getRefactorActionsToConvertParametersToDestructuredObject + }); + function getRefactorActionsToConvertParametersToDestructuredObject(context) { + var file = context.file, startPosition = context.startPosition; + var isJSFile = ts.isSourceFileJS(file); + if (isJSFile) + return ts.emptyArray; // TODO: GH#30113 + var functionDeclaration = getFunctionDeclarationAtPosition(file, startPosition, context.program.getTypeChecker()); + if (!functionDeclaration) + return ts.emptyArray; + return [{ + name: refactorName, + description: refactorDescription, + actions: [toDestructuredAction] + }]; + } + function getRefactorEditsToConvertParametersToDestructuredObject(context, actionName) { + ts.Debug.assert(actionName === refactorName, "Unexpected action name"); + var file = context.file, startPosition = context.startPosition, program = context.program, cancellationToken = context.cancellationToken, host = context.host; + var functionDeclaration = getFunctionDeclarationAtPosition(file, startPosition, program.getTypeChecker()); + if (!functionDeclaration || !cancellationToken) + return undefined; + var groupedReferences = getGroupedReferences(functionDeclaration, program, cancellationToken); + if (groupedReferences.valid) { + var edits = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(file, program, host, t, functionDeclaration, groupedReferences); }); + return { renameFilename: undefined, renameLocation: undefined, edits: edits }; + } + return { edits: [] }; // TODO: GH#30113 + } + function doChange(sourceFile, program, host, changes, functionDeclaration, groupedReferences) { + var signature = groupedReferences.signature; + var newFunctionDeclarationParams = ts.map(createNewParameters(functionDeclaration, program, host), function (param) { return ts.getSynthesizedDeepClone(param); }); + if (signature) { + var newSignatureParams = ts.map(createNewParameters(signature, program, host), function (param) { return ts.getSynthesizedDeepClone(param); }); + replaceParameters(signature, newSignatureParams); + } + replaceParameters(functionDeclaration, newFunctionDeclarationParams); + var functionCalls = ts.sortAndDeduplicate(groupedReferences.functionCalls, /*comparer*/ function (a, b) { return ts.compareValues(a.pos, b.pos); }); + for (var _i = 0, functionCalls_1 = functionCalls; _i < functionCalls_1.length; _i++) { + var call = functionCalls_1[_i]; + if (call.arguments && call.arguments.length) { + var newArgument = ts.getSynthesizedDeepClone(createNewArgument(functionDeclaration, call.arguments), /*includeTrivia*/ true); + changes.replaceNodeRange(ts.getSourceFileOfNode(call), ts.first(call.arguments), ts.last(call.arguments), newArgument, { leadingTriviaOption: ts.textChanges.LeadingTriviaOption.IncludeAll, trailingTriviaOption: ts.textChanges.TrailingTriviaOption.Include }); + } + } + function replaceParameters(declarationOrSignature, parameterDeclarations) { + changes.replaceNodeRangeWithNodes(sourceFile, ts.first(declarationOrSignature.parameters), ts.last(declarationOrSignature.parameters), parameterDeclarations, { + joiner: ", ", + // indentation is set to 0 because otherwise the object parameter will be indented if there is a `this` parameter + indentation: 0, + leadingTriviaOption: ts.textChanges.LeadingTriviaOption.IncludeAll, + trailingTriviaOption: ts.textChanges.TrailingTriviaOption.Include + }); + } + } + function getGroupedReferences(functionDeclaration, program, cancellationToken) { + var functionNames = getFunctionNames(functionDeclaration); + var classNames = ts.isConstructorDeclaration(functionDeclaration) ? getClassNames(functionDeclaration) : []; + var names = ts.deduplicate(__spreadArray(__spreadArray([], functionNames, true), classNames, true), ts.equateValues); + var checker = program.getTypeChecker(); + var references = ts.flatMap(names, /*mapfn*/ function (/*mapfn*/ name) { return ts.FindAllReferences.getReferenceEntriesForNode(-1, name, program, program.getSourceFiles(), cancellationToken); }); + var groupedReferences = groupReferences(references); + if (!ts.every(groupedReferences.declarations, /*callback*/ function (/*callback*/ decl) { return ts.contains(names, decl); })) { + groupedReferences.valid = false; + } + return groupedReferences; + function groupReferences(referenceEntries) { + var classReferences = { accessExpressions: [], typeUsages: [] }; + var groupedReferences = { functionCalls: [], declarations: [], classReferences: classReferences, valid: true }; + var functionSymbols = ts.map(functionNames, getSymbolTargetAtLocation); + var classSymbols = ts.map(classNames, getSymbolTargetAtLocation); + var isConstructor = ts.isConstructorDeclaration(functionDeclaration); + var contextualSymbols = ts.map(functionNames, function (name) { return getSymbolForContextualType(name, checker); }); + for (var _i = 0, referenceEntries_1 = referenceEntries; _i < referenceEntries_1.length; _i++) { + var entry = referenceEntries_1[_i]; + if (entry.kind === 0 /* FindAllReferences.EntryKind.Span */) { + groupedReferences.valid = false; + continue; + } + /* Declarations in object literals may be implementations of method signatures which have a different symbol from the declaration + For example: + interface IFoo { m(a: number): void } + const foo: IFoo = { m(a: number): void {} } + In these cases we get the symbol for the signature from the contextual type. + */ + if (ts.contains(contextualSymbols, getSymbolTargetAtLocation(entry.node))) { + if (isValidMethodSignature(entry.node.parent)) { + groupedReferences.signature = entry.node.parent; + continue; + } + var call = entryToFunctionCall(entry); + if (call) { + groupedReferences.functionCalls.push(call); + continue; + } + } + var contextualSymbol = getSymbolForContextualType(entry.node, checker); + if (contextualSymbol && ts.contains(contextualSymbols, contextualSymbol)) { + var decl = entryToDeclaration(entry); + if (decl) { + groupedReferences.declarations.push(decl); + continue; + } + } + /* We compare symbols because in some cases find all references wil return a reference that may or may not be to the refactored function. + Example from the refactorConvertParamsToDestructuredObject_methodCallUnion.ts test: + class A { foo(a: number, b: number) { return a + b; } } + class B { foo(c: number, d: number) { return c + d; } } + declare const ab: A | B; + ab.foo(1, 2); + Find all references will return `ab.foo(1, 2)` as a reference to A's `foo` but we could be calling B's `foo`. + When looking for constructor calls, however, the symbol on the constructor call reference is going to be the corresponding class symbol. + So we need to add a special case for this because when calling a constructor of a class through one of its subclasses, + the symbols are going to be different. + */ + if (ts.contains(functionSymbols, getSymbolTargetAtLocation(entry.node)) || ts.isNewExpressionTarget(entry.node)) { + var importOrExportReference = entryToImportOrExport(entry); + if (importOrExportReference) { + continue; + } + var decl = entryToDeclaration(entry); + if (decl) { + groupedReferences.declarations.push(decl); + continue; + } + var call = entryToFunctionCall(entry); + if (call) { + groupedReferences.functionCalls.push(call); + continue; + } + } + // if the refactored function is a constructor, we must also check if the references to its class are valid + if (isConstructor && ts.contains(classSymbols, getSymbolTargetAtLocation(entry.node))) { + var importOrExportReference = entryToImportOrExport(entry); + if (importOrExportReference) { + continue; + } + var decl = entryToDeclaration(entry); + if (decl) { + groupedReferences.declarations.push(decl); + continue; + } + var accessExpression = entryToAccessExpression(entry); + if (accessExpression) { + classReferences.accessExpressions.push(accessExpression); + continue; + } + // Only class declarations are allowed to be used as a type (in a heritage clause), + // otherwise `findAllReferences` might not be able to track constructor calls. + if (ts.isClassDeclaration(functionDeclaration.parent)) { + var type = entryToType(entry); + if (type) { + classReferences.typeUsages.push(type); + continue; + } + } + } + groupedReferences.valid = false; + } + return groupedReferences; + } + function getSymbolTargetAtLocation(node) { + var symbol = checker.getSymbolAtLocation(node); + return symbol && ts.getSymbolTarget(symbol, checker); + } + } + /** + * Gets the symbol for the contextual type of the node if it is not a union or intersection. + */ + function getSymbolForContextualType(node, checker) { + var element = ts.getContainingObjectLiteralElement(node); + if (element) { + var contextualType = checker.getContextualTypeForObjectLiteralElement(element); + var symbol = contextualType === null || contextualType === void 0 ? void 0 : contextualType.getSymbol(); + if (symbol && !(ts.getCheckFlags(symbol) & 6 /* CheckFlags.Synthetic */)) { + return symbol; + } + } + } + function entryToImportOrExport(entry) { + var node = entry.node; + if (ts.isImportSpecifier(node.parent) + || ts.isImportClause(node.parent) + || ts.isImportEqualsDeclaration(node.parent) + || ts.isNamespaceImport(node.parent)) { + return node; + } + if (ts.isExportSpecifier(node.parent) || ts.isExportAssignment(node.parent)) { + return node; + } + return undefined; + } + function entryToDeclaration(entry) { + if (ts.isDeclaration(entry.node.parent)) { + return entry.node; + } + return undefined; + } + function entryToFunctionCall(entry) { + if (entry.node.parent) { + var functionReference = entry.node; + var parent = functionReference.parent; + switch (parent.kind) { + // foo(...) or super(...) or new Foo(...) + case 210 /* SyntaxKind.CallExpression */: + case 211 /* SyntaxKind.NewExpression */: + var callOrNewExpression = ts.tryCast(parent, ts.isCallOrNewExpression); + if (callOrNewExpression && callOrNewExpression.expression === functionReference) { + return callOrNewExpression; + } + break; + // x.foo(...) + case 208 /* SyntaxKind.PropertyAccessExpression */: + var propertyAccessExpression = ts.tryCast(parent, ts.isPropertyAccessExpression); + if (propertyAccessExpression && propertyAccessExpression.parent && propertyAccessExpression.name === functionReference) { + var callOrNewExpression_1 = ts.tryCast(propertyAccessExpression.parent, ts.isCallOrNewExpression); + if (callOrNewExpression_1 && callOrNewExpression_1.expression === propertyAccessExpression) { + return callOrNewExpression_1; + } + } + break; + // x["foo"](...) + case 209 /* SyntaxKind.ElementAccessExpression */: + var elementAccessExpression = ts.tryCast(parent, ts.isElementAccessExpression); + if (elementAccessExpression && elementAccessExpression.parent && elementAccessExpression.argumentExpression === functionReference) { + var callOrNewExpression_2 = ts.tryCast(elementAccessExpression.parent, ts.isCallOrNewExpression); + if (callOrNewExpression_2 && callOrNewExpression_2.expression === elementAccessExpression) { + return callOrNewExpression_2; + } + } + break; + } + } + return undefined; + } + function entryToAccessExpression(entry) { + if (entry.node.parent) { + var reference = entry.node; + var parent = reference.parent; + switch (parent.kind) { + // `C.foo` + case 208 /* SyntaxKind.PropertyAccessExpression */: + var propertyAccessExpression = ts.tryCast(parent, ts.isPropertyAccessExpression); + if (propertyAccessExpression && propertyAccessExpression.expression === reference) { + return propertyAccessExpression; + } + break; + // `C["foo"]` + case 209 /* SyntaxKind.ElementAccessExpression */: + var elementAccessExpression = ts.tryCast(parent, ts.isElementAccessExpression); + if (elementAccessExpression && elementAccessExpression.expression === reference) { + return elementAccessExpression; + } + break; + } + } + return undefined; + } + function entryToType(entry) { + var reference = entry.node; + if (ts.getMeaningFromLocation(reference) === 2 /* SemanticMeaning.Type */ || ts.isExpressionWithTypeArgumentsInClassExtendsClause(reference.parent)) { + return reference; + } + return undefined; + } + function getFunctionDeclarationAtPosition(file, startPosition, checker) { + var node = ts.getTouchingToken(file, startPosition); + var functionDeclaration = ts.getContainingFunctionDeclaration(node); + // don't offer refactor on top-level JSDoc + if (isTopLevelJSDoc(node)) + return undefined; + if (functionDeclaration + && isValidFunctionDeclaration(functionDeclaration, checker) + && ts.rangeContainsRange(functionDeclaration, node) + && !(functionDeclaration.body && ts.rangeContainsRange(functionDeclaration.body, node))) + return functionDeclaration; + return undefined; + } + function isTopLevelJSDoc(node) { + var containingJSDoc = ts.findAncestor(node, ts.isJSDocNode); + if (containingJSDoc) { + var containingNonJSDoc = ts.findAncestor(containingJSDoc, function (n) { return !ts.isJSDocNode(n); }); + return !!containingNonJSDoc && ts.isFunctionLikeDeclaration(containingNonJSDoc); + } + return false; + } + function isValidMethodSignature(node) { + return ts.isMethodSignature(node) && (ts.isInterfaceDeclaration(node.parent) || ts.isTypeLiteralNode(node.parent)); + } + function isValidFunctionDeclaration(functionDeclaration, checker) { + var _a; + if (!isValidParameterNodeArray(functionDeclaration.parameters, checker)) + return false; + switch (functionDeclaration.kind) { + case 259 /* SyntaxKind.FunctionDeclaration */: + return hasNameOrDefault(functionDeclaration) && isSingleImplementation(functionDeclaration, checker); + case 171 /* SyntaxKind.MethodDeclaration */: + if (ts.isObjectLiteralExpression(functionDeclaration.parent)) { + var contextualSymbol = getSymbolForContextualType(functionDeclaration.name, checker); + // don't offer the refactor when there are multiple signatures since we won't know which ones the user wants to change + return ((_a = contextualSymbol === null || contextualSymbol === void 0 ? void 0 : contextualSymbol.declarations) === null || _a === void 0 ? void 0 : _a.length) === 1 && isSingleImplementation(functionDeclaration, checker); + } + return isSingleImplementation(functionDeclaration, checker); + case 173 /* SyntaxKind.Constructor */: + if (ts.isClassDeclaration(functionDeclaration.parent)) { + return hasNameOrDefault(functionDeclaration.parent) && isSingleImplementation(functionDeclaration, checker); + } + else { + return isValidVariableDeclaration(functionDeclaration.parent.parent) + && isSingleImplementation(functionDeclaration, checker); + } + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + return isValidVariableDeclaration(functionDeclaration.parent); + } + return false; + } + function isSingleImplementation(functionDeclaration, checker) { + return !!functionDeclaration.body && !checker.isImplementationOfOverload(functionDeclaration); + } + function hasNameOrDefault(functionOrClassDeclaration) { + if (!functionOrClassDeclaration.name) { + var defaultKeyword = ts.findModifier(functionOrClassDeclaration, 88 /* SyntaxKind.DefaultKeyword */); + return !!defaultKeyword; + } + return true; + } + function isValidParameterNodeArray(parameters, checker) { + return getRefactorableParametersLength(parameters) >= minimumParameterLength + && ts.every(parameters, /*callback*/ function (/*callback*/ paramDecl) { return isValidParameterDeclaration(paramDecl, checker); }); + } + function isValidParameterDeclaration(parameterDeclaration, checker) { + if (ts.isRestParameter(parameterDeclaration)) { + var type = checker.getTypeAtLocation(parameterDeclaration); + if (!checker.isArrayType(type) && !checker.isTupleType(type)) + return false; + } + return !parameterDeclaration.modifiers && ts.isIdentifier(parameterDeclaration.name); + } + function isValidVariableDeclaration(node) { + return ts.isVariableDeclaration(node) && ts.isVarConst(node) && ts.isIdentifier(node.name) && !node.type; // TODO: GH#30113 + } + function hasThisParameter(parameters) { + return parameters.length > 0 && ts.isThis(parameters[0].name); + } + function getRefactorableParametersLength(parameters) { + if (hasThisParameter(parameters)) { + return parameters.length - 1; + } + return parameters.length; + } + function getRefactorableParameters(parameters) { + if (hasThisParameter(parameters)) { + parameters = ts.factory.createNodeArray(parameters.slice(1), parameters.hasTrailingComma); + } + return parameters; + } + function createPropertyOrShorthandAssignment(name, initializer) { + if (ts.isIdentifier(initializer) && ts.getTextOfIdentifierOrLiteral(initializer) === name) { + return ts.factory.createShorthandPropertyAssignment(name); + } + return ts.factory.createPropertyAssignment(name, initializer); + } + function createNewArgument(functionDeclaration, functionArguments) { + var parameters = getRefactorableParameters(functionDeclaration.parameters); + var hasRestParameter = ts.isRestParameter(ts.last(parameters)); + var nonRestArguments = hasRestParameter ? functionArguments.slice(0, parameters.length - 1) : functionArguments; + var properties = ts.map(nonRestArguments, function (arg, i) { + var parameterName = getParameterName(parameters[i]); + var property = createPropertyOrShorthandAssignment(parameterName, arg); + ts.suppressLeadingAndTrailingTrivia(property.name); + if (ts.isPropertyAssignment(property)) + ts.suppressLeadingAndTrailingTrivia(property.initializer); + ts.copyComments(arg, property); + return property; + }); + if (hasRestParameter && functionArguments.length >= parameters.length) { + var restArguments = functionArguments.slice(parameters.length - 1); + var restProperty = ts.factory.createPropertyAssignment(getParameterName(ts.last(parameters)), ts.factory.createArrayLiteralExpression(restArguments)); + properties.push(restProperty); + } + var objectLiteral = ts.factory.createObjectLiteralExpression(properties, /*multiLine*/ false); + return objectLiteral; + } + function createNewParameters(functionDeclaration, program, host) { + var checker = program.getTypeChecker(); + var refactorableParameters = getRefactorableParameters(functionDeclaration.parameters); + var bindingElements = ts.map(refactorableParameters, createBindingElementFromParameterDeclaration); + var objectParameterName = ts.factory.createObjectBindingPattern(bindingElements); + var objectParameterType = createParameterTypeNode(refactorableParameters); + var objectInitializer; + // If every parameter in the original function was optional, add an empty object initializer to the new object parameter + if (ts.every(refactorableParameters, isOptionalParameter)) { + objectInitializer = ts.factory.createObjectLiteralExpression(); + } + var objectParameter = ts.factory.createParameterDeclaration( + /*modifiers*/ undefined, + /*dotDotDotToken*/ undefined, objectParameterName, + /*questionToken*/ undefined, objectParameterType, objectInitializer); + if (hasThisParameter(functionDeclaration.parameters)) { + var thisParameter = functionDeclaration.parameters[0]; + var newThisParameter = ts.factory.createParameterDeclaration( + /*modifiers*/ undefined, + /*dotDotDotToken*/ undefined, thisParameter.name, + /*questionToken*/ undefined, thisParameter.type); + ts.suppressLeadingAndTrailingTrivia(newThisParameter.name); + ts.copyComments(thisParameter.name, newThisParameter.name); + if (thisParameter.type) { + ts.suppressLeadingAndTrailingTrivia(newThisParameter.type); + ts.copyComments(thisParameter.type, newThisParameter.type); + } + return ts.factory.createNodeArray([newThisParameter, objectParameter]); + } + return ts.factory.createNodeArray([objectParameter]); + function createBindingElementFromParameterDeclaration(parameterDeclaration) { + var element = ts.factory.createBindingElement( + /*dotDotDotToken*/ undefined, + /*propertyName*/ undefined, getParameterName(parameterDeclaration), ts.isRestParameter(parameterDeclaration) && isOptionalParameter(parameterDeclaration) ? ts.factory.createArrayLiteralExpression() : parameterDeclaration.initializer); + ts.suppressLeadingAndTrailingTrivia(element); + if (parameterDeclaration.initializer && element.initializer) { + ts.copyComments(parameterDeclaration.initializer, element.initializer); + } + return element; + } + function createParameterTypeNode(parameters) { + var members = ts.map(parameters, createPropertySignatureFromParameterDeclaration); + var typeNode = ts.addEmitFlags(ts.factory.createTypeLiteralNode(members), 1 /* EmitFlags.SingleLine */); + return typeNode; + } + function createPropertySignatureFromParameterDeclaration(parameterDeclaration) { + var parameterType = parameterDeclaration.type; + if (!parameterType && (parameterDeclaration.initializer || ts.isRestParameter(parameterDeclaration))) { + parameterType = getTypeNode(parameterDeclaration); + } + var propertySignature = ts.factory.createPropertySignature( + /*modifiers*/ undefined, getParameterName(parameterDeclaration), isOptionalParameter(parameterDeclaration) ? ts.factory.createToken(57 /* SyntaxKind.QuestionToken */) : parameterDeclaration.questionToken, parameterType); + ts.suppressLeadingAndTrailingTrivia(propertySignature); + ts.copyComments(parameterDeclaration.name, propertySignature.name); + if (parameterDeclaration.type && propertySignature.type) { + ts.copyComments(parameterDeclaration.type, propertySignature.type); + } + return propertySignature; + } + function getTypeNode(node) { + var type = checker.getTypeAtLocation(node); + return ts.getTypeNodeIfAccessible(type, node, program, host); + } + function isOptionalParameter(parameterDeclaration) { + if (ts.isRestParameter(parameterDeclaration)) { + var type = checker.getTypeAtLocation(parameterDeclaration); + return !checker.isTupleType(type); + } + return checker.isOptionalParameter(parameterDeclaration); + } + } + function getParameterName(paramDeclaration) { + return ts.getTextOfIdentifierOrLiteral(paramDeclaration.name); + } + function getClassNames(constructorDeclaration) { + switch (constructorDeclaration.parent.kind) { + case 260 /* SyntaxKind.ClassDeclaration */: + var classDeclaration = constructorDeclaration.parent; + if (classDeclaration.name) + return [classDeclaration.name]; + // If the class declaration doesn't have a name, it should have a default modifier. + // We validated this in `isValidFunctionDeclaration` through `hasNameOrDefault` + var defaultModifier = ts.Debug.checkDefined(ts.findModifier(classDeclaration, 88 /* SyntaxKind.DefaultKeyword */), "Nameless class declaration should be a default export"); + return [defaultModifier]; + case 228 /* SyntaxKind.ClassExpression */: + var classExpression = constructorDeclaration.parent; + var variableDeclaration = constructorDeclaration.parent.parent; + var className = classExpression.name; + if (className) + return [className, variableDeclaration.name]; + return [variableDeclaration.name]; + } + } + function getFunctionNames(functionDeclaration) { + switch (functionDeclaration.kind) { + case 259 /* SyntaxKind.FunctionDeclaration */: + if (functionDeclaration.name) + return [functionDeclaration.name]; + // If the function declaration doesn't have a name, it should have a default modifier. + // We validated this in `isValidFunctionDeclaration` through `hasNameOrDefault` + var defaultModifier = ts.Debug.checkDefined(ts.findModifier(functionDeclaration, 88 /* SyntaxKind.DefaultKeyword */), "Nameless function declaration should be a default export"); + return [defaultModifier]; + case 171 /* SyntaxKind.MethodDeclaration */: + return [functionDeclaration.name]; + case 173 /* SyntaxKind.Constructor */: + var ctrKeyword = ts.Debug.checkDefined(ts.findChildOfKind(functionDeclaration, 135 /* SyntaxKind.ConstructorKeyword */, functionDeclaration.getSourceFile()), "Constructor declaration should have constructor keyword"); + if (functionDeclaration.parent.kind === 228 /* SyntaxKind.ClassExpression */) { + var variableDeclaration = functionDeclaration.parent.parent; + return [variableDeclaration.name, ctrKeyword]; + } + return [ctrKeyword]; + case 216 /* SyntaxKind.ArrowFunction */: + return [functionDeclaration.parent.name]; + case 215 /* SyntaxKind.FunctionExpression */: + if (functionDeclaration.name) + return [functionDeclaration.name, functionDeclaration.parent.name]; + return [functionDeclaration.parent.name]; + default: + return ts.Debug.assertNever(functionDeclaration, "Unexpected function declaration kind ".concat(functionDeclaration.kind)); + } + } + })(convertParamsToDestructuredObject = refactor.convertParamsToDestructuredObject || (refactor.convertParamsToDestructuredObject = {})); + })(refactor = ts.refactor || (ts.refactor = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var refactor; + (function (refactor) { + var convertStringOrTemplateLiteral; + (function (convertStringOrTemplateLiteral) { + var refactorName = "Convert to template string"; + var refactorDescription = ts.getLocaleSpecificMessage(ts.Diagnostics.Convert_to_template_string); + var convertStringAction = { + name: refactorName, + description: refactorDescription, + kind: "refactor.rewrite.string" + }; + refactor.registerRefactor(refactorName, { + kinds: [convertStringAction.kind], + getEditsForAction: getRefactorEditsToConvertToTemplateString, + getAvailableActions: getRefactorActionsToConvertToTemplateString + }); + function getRefactorActionsToConvertToTemplateString(context) { + var file = context.file, startPosition = context.startPosition; + var node = getNodeOrParentOfParentheses(file, startPosition); + var maybeBinary = getParentBinaryExpression(node); + var refactorInfo = { name: refactorName, description: refactorDescription, actions: [] }; + if (ts.isBinaryExpression(maybeBinary) && treeToArray(maybeBinary).isValidConcatenation) { + refactorInfo.actions.push(convertStringAction); + return [refactorInfo]; + } + else if (context.preferences.provideRefactorNotApplicableReason) { + refactorInfo.actions.push(__assign(__assign({}, convertStringAction), { notApplicableReason: ts.getLocaleSpecificMessage(ts.Diagnostics.Can_only_convert_string_concatenation) })); + return [refactorInfo]; + } + return ts.emptyArray; + } + function getNodeOrParentOfParentheses(file, startPosition) { + var node = ts.getTokenAtPosition(file, startPosition); + var nestedBinary = getParentBinaryExpression(node); + var isNonStringBinary = !treeToArray(nestedBinary).isValidConcatenation; + if (isNonStringBinary && + ts.isParenthesizedExpression(nestedBinary.parent) && + ts.isBinaryExpression(nestedBinary.parent.parent)) { + return nestedBinary.parent.parent; + } + return node; + } + function getRefactorEditsToConvertToTemplateString(context, actionName) { + var file = context.file, startPosition = context.startPosition; + var node = getNodeOrParentOfParentheses(file, startPosition); + switch (actionName) { + case refactorDescription: + return { edits: getEditsForToTemplateLiteral(context, node) }; + default: + return ts.Debug.fail("invalid action"); + } + } + function getEditsForToTemplateLiteral(context, node) { + var maybeBinary = getParentBinaryExpression(node); + var file = context.file; + var templateLiteral = nodesToTemplate(treeToArray(maybeBinary), file); + var trailingCommentRanges = ts.getTrailingCommentRanges(file.text, maybeBinary.end); + if (trailingCommentRanges) { + var lastComment = trailingCommentRanges[trailingCommentRanges.length - 1]; + var trailingRange_1 = { pos: trailingCommentRanges[0].pos, end: lastComment.end }; + // since suppressTrailingTrivia(maybeBinary) does not work, the trailing comment is removed manually + // otherwise it would have the trailing comment twice + return ts.textChanges.ChangeTracker.with(context, function (t) { + t.deleteRange(file, trailingRange_1); + t.replaceNode(file, maybeBinary, templateLiteral); + }); + } + else { + return ts.textChanges.ChangeTracker.with(context, function (t) { return t.replaceNode(file, maybeBinary, templateLiteral); }); + } + } + function isNotEqualsOperator(node) { + return node.operatorToken.kind !== 63 /* SyntaxKind.EqualsToken */; + } + function getParentBinaryExpression(expr) { + var container = ts.findAncestor(expr.parent, function (n) { + switch (n.kind) { + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 209 /* SyntaxKind.ElementAccessExpression */: + return false; + case 225 /* SyntaxKind.TemplateExpression */: + case 223 /* SyntaxKind.BinaryExpression */: + return !(ts.isBinaryExpression(n.parent) && isNotEqualsOperator(n.parent)); + default: + return "quit"; + } + }); + return (container || expr); + } + function treeToArray(current) { + var loop = function (current) { + if (!ts.isBinaryExpression(current)) { + return { nodes: [current], operators: [], validOperators: true, + hasString: ts.isStringLiteral(current) || ts.isNoSubstitutionTemplateLiteral(current) }; + } + var _a = loop(current.left), nodes = _a.nodes, operators = _a.operators, leftHasString = _a.hasString, leftOperatorValid = _a.validOperators; + if (!(leftHasString || ts.isStringLiteral(current.right) || ts.isTemplateExpression(current.right))) { + return { nodes: [current], operators: [], hasString: false, validOperators: true }; + } + var currentOperatorValid = current.operatorToken.kind === 39 /* SyntaxKind.PlusToken */; + var validOperators = leftOperatorValid && currentOperatorValid; + nodes.push(current.right); + operators.push(current.operatorToken); + return { nodes: nodes, operators: operators, hasString: true, validOperators: validOperators }; + }; + var _a = loop(current), nodes = _a.nodes, operators = _a.operators, validOperators = _a.validOperators, hasString = _a.hasString; + return { nodes: nodes, operators: operators, isValidConcatenation: validOperators && hasString }; + } + // to copy comments following the operator + // "foo" + /* comment */ "bar" + var copyTrailingOperatorComments = function (operators, file) { return function (index, targetNode) { + if (index < operators.length) { + ts.copyTrailingComments(operators[index], targetNode, file, 3 /* SyntaxKind.MultiLineCommentTrivia */, /* hasTrailingNewLine */ false); + } + }; }; + // to copy comments following the string + // "foo" /* comment */ + "bar" /* comment */ + "bar2" + var copyCommentFromMultiNode = function (nodes, file, copyOperatorComments) { + return function (indexes, targetNode) { + while (indexes.length > 0) { + var index = indexes.shift(); + ts.copyTrailingComments(nodes[index], targetNode, file, 3 /* SyntaxKind.MultiLineCommentTrivia */, /* hasTrailingNewLine */ false); + copyOperatorComments(index, targetNode); + } + }; + }; + function escapeRawStringForTemplate(s) { + // Escaping for $s in strings that are to be used in template strings + // Naive implementation: replace \x by itself and otherwise $ and ` by \$ and \`. + // But to complicate it a bit, this should work for raw strings too. + return s.replace(/\\.|[$`]/g, function (m) { return m[0] === "\\" ? m : "\\" + m; }); + // Finally, a less-backslash-happy version can work too, doing only ${ instead of all $s: + // s.replace(/\\.|\${|`/g, m => m[0] === "\\" ? m : "\\" + m); + // but `\$${foo}` is likely more clear than the more-confusing-but-still-working `$${foo}`. + } + function getRawTextOfTemplate(node) { + // in these cases the right side is ${ + var rightShaving = ts.isTemplateHead(node) || ts.isTemplateMiddle(node) ? -2 : -1; + return ts.getTextOfNode(node).slice(1, rightShaving); + } + function concatConsecutiveString(index, nodes) { + var indexes = []; + var text = "", rawText = ""; + while (index < nodes.length) { + var node = nodes[index]; + if (ts.isStringLiteralLike(node)) { // includes isNoSubstitutionTemplateLiteral(node) + text += node.text; + rawText += escapeRawStringForTemplate(ts.getTextOfNode(node).slice(1, -1)); + indexes.push(index); + index++; + } + else if (ts.isTemplateExpression(node)) { + text += node.head.text; + rawText += getRawTextOfTemplate(node.head); + break; + } + else { + break; + } + } + return [index, text, rawText, indexes]; + } + function nodesToTemplate(_a, file) { + var nodes = _a.nodes, operators = _a.operators; + var copyOperatorComments = copyTrailingOperatorComments(operators, file); + var copyCommentFromStringLiterals = copyCommentFromMultiNode(nodes, file, copyOperatorComments); + var _b = concatConsecutiveString(0, nodes), begin = _b[0], headText = _b[1], rawHeadText = _b[2], headIndexes = _b[3]; + if (begin === nodes.length) { + var noSubstitutionTemplateLiteral = ts.factory.createNoSubstitutionTemplateLiteral(headText, rawHeadText); + copyCommentFromStringLiterals(headIndexes, noSubstitutionTemplateLiteral); + return noSubstitutionTemplateLiteral; + } + var templateSpans = []; + var templateHead = ts.factory.createTemplateHead(headText, rawHeadText); + copyCommentFromStringLiterals(headIndexes, templateHead); + var _loop_19 = function (i) { + var currentNode = getExpressionFromParenthesesOrExpression(nodes[i]); + copyOperatorComments(i, currentNode); + var _c = concatConsecutiveString(i + 1, nodes), newIndex = _c[0], subsequentText = _c[1], rawSubsequentText = _c[2], stringIndexes = _c[3]; + i = newIndex - 1; + var isLast = i === nodes.length - 1; + if (ts.isTemplateExpression(currentNode)) { + var spans = ts.map(currentNode.templateSpans, function (span, index) { + copyExpressionComments(span); + var isLastSpan = index === currentNode.templateSpans.length - 1; + var text = span.literal.text + (isLastSpan ? subsequentText : ""); + var rawText = getRawTextOfTemplate(span.literal) + (isLastSpan ? rawSubsequentText : ""); + return ts.factory.createTemplateSpan(span.expression, isLast && isLastSpan + ? ts.factory.createTemplateTail(text, rawText) + : ts.factory.createTemplateMiddle(text, rawText)); + }); + templateSpans.push.apply(templateSpans, spans); + } + else { + var templatePart = isLast + ? ts.factory.createTemplateTail(subsequentText, rawSubsequentText) + : ts.factory.createTemplateMiddle(subsequentText, rawSubsequentText); + copyCommentFromStringLiterals(stringIndexes, templatePart); + templateSpans.push(ts.factory.createTemplateSpan(currentNode, templatePart)); + } + out_i_1 = i; + }; + var out_i_1; + for (var i = begin; i < nodes.length; i++) { + _loop_19(i); + i = out_i_1; + } + return ts.factory.createTemplateExpression(templateHead, templateSpans); + } + // to copy comments following the opening & closing parentheses + // "foo" + ( /* comment */ 5 + 5 ) /* comment */ + "bar" + function copyExpressionComments(node) { + var file = node.getSourceFile(); + ts.copyTrailingComments(node, node.expression, file, 3 /* SyntaxKind.MultiLineCommentTrivia */, /* hasTrailingNewLine */ false); + ts.copyTrailingAsLeadingComments(node.expression, node.expression, file, 3 /* SyntaxKind.MultiLineCommentTrivia */, /* hasTrailingNewLine */ false); + } + function getExpressionFromParenthesesOrExpression(node) { + if (ts.isParenthesizedExpression(node)) { + copyExpressionComments(node); + node = node.expression; + } + return node; + } + })(convertStringOrTemplateLiteral = refactor.convertStringOrTemplateLiteral || (refactor.convertStringOrTemplateLiteral = {})); + })(refactor = ts.refactor || (ts.refactor = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var refactor; + (function (refactor) { + var convertArrowFunctionOrFunctionExpression; + (function (convertArrowFunctionOrFunctionExpression) { + var refactorName = "Convert arrow function or function expression"; + var refactorDescription = ts.getLocaleSpecificMessage(ts.Diagnostics.Convert_arrow_function_or_function_expression); + var toAnonymousFunctionAction = { + name: "Convert to anonymous function", + description: ts.getLocaleSpecificMessage(ts.Diagnostics.Convert_to_anonymous_function), + kind: "refactor.rewrite.function.anonymous", + }; + var toNamedFunctionAction = { + name: "Convert to named function", + description: ts.getLocaleSpecificMessage(ts.Diagnostics.Convert_to_named_function), + kind: "refactor.rewrite.function.named", + }; + var toArrowFunctionAction = { + name: "Convert to arrow function", + description: ts.getLocaleSpecificMessage(ts.Diagnostics.Convert_to_arrow_function), + kind: "refactor.rewrite.function.arrow", + }; + refactor.registerRefactor(refactorName, { + kinds: [ + toAnonymousFunctionAction.kind, + toNamedFunctionAction.kind, + toArrowFunctionAction.kind + ], + getEditsForAction: getRefactorEditsToConvertFunctionExpressions, + getAvailableActions: getRefactorActionsToConvertFunctionExpressions + }); + function getRefactorActionsToConvertFunctionExpressions(context) { + var file = context.file, startPosition = context.startPosition, program = context.program, kind = context.kind; + var info = getFunctionInfo(file, startPosition, program); + if (!info) + return ts.emptyArray; + var selectedVariableDeclaration = info.selectedVariableDeclaration, func = info.func; + var possibleActions = []; + var errors = []; + if (refactor.refactorKindBeginsWith(toNamedFunctionAction.kind, kind)) { + var error = selectedVariableDeclaration || (ts.isArrowFunction(func) && ts.isVariableDeclaration(func.parent)) ? + undefined : ts.getLocaleSpecificMessage(ts.Diagnostics.Could_not_convert_to_named_function); + if (error) { + errors.push(__assign(__assign({}, toNamedFunctionAction), { notApplicableReason: error })); + } + else { + possibleActions.push(toNamedFunctionAction); + } + } + if (refactor.refactorKindBeginsWith(toAnonymousFunctionAction.kind, kind)) { + var error = !selectedVariableDeclaration && ts.isArrowFunction(func) ? + undefined : ts.getLocaleSpecificMessage(ts.Diagnostics.Could_not_convert_to_anonymous_function); + if (error) { + errors.push(__assign(__assign({}, toAnonymousFunctionAction), { notApplicableReason: error })); + } + else { + possibleActions.push(toAnonymousFunctionAction); + } + } + if (refactor.refactorKindBeginsWith(toArrowFunctionAction.kind, kind)) { + var error = ts.isFunctionExpression(func) ? undefined : ts.getLocaleSpecificMessage(ts.Diagnostics.Could_not_convert_to_arrow_function); + if (error) { + errors.push(__assign(__assign({}, toArrowFunctionAction), { notApplicableReason: error })); + } + else { + possibleActions.push(toArrowFunctionAction); + } + } + return [{ + name: refactorName, + description: refactorDescription, + actions: possibleActions.length === 0 && context.preferences.provideRefactorNotApplicableReason ? + errors : possibleActions + }]; + } + function getRefactorEditsToConvertFunctionExpressions(context, actionName) { + var file = context.file, startPosition = context.startPosition, program = context.program; + var info = getFunctionInfo(file, startPosition, program); + if (!info) + return undefined; + var func = info.func; + var edits = []; + switch (actionName) { + case toAnonymousFunctionAction.name: + edits.push.apply(edits, getEditInfoForConvertToAnonymousFunction(context, func)); + break; + case toNamedFunctionAction.name: + var variableInfo = getVariableInfo(func); + if (!variableInfo) + return undefined; + edits.push.apply(edits, getEditInfoForConvertToNamedFunction(context, func, variableInfo)); + break; + case toArrowFunctionAction.name: + if (!ts.isFunctionExpression(func)) + return undefined; + edits.push.apply(edits, getEditInfoForConvertToArrowFunction(context, func)); + break; + default: + return ts.Debug.fail("invalid action"); + } + return { renameFilename: undefined, renameLocation: undefined, edits: edits }; + } + function containingThis(node) { + var containsThis = false; + node.forEachChild(function checkThis(child) { + if (ts.isThis(child)) { + containsThis = true; + return; + } + if (!ts.isClassLike(child) && !ts.isFunctionDeclaration(child) && !ts.isFunctionExpression(child)) { + ts.forEachChild(child, checkThis); + } + }); + return containsThis; + } + function getFunctionInfo(file, startPosition, program) { + var token = ts.getTokenAtPosition(file, startPosition); + var typeChecker = program.getTypeChecker(); + var func = tryGetFunctionFromVariableDeclaration(file, typeChecker, token.parent); + if (func && !containingThis(func.body) && !typeChecker.containsArgumentsReference(func)) { + return { selectedVariableDeclaration: true, func: func }; + } + var maybeFunc = ts.getContainingFunction(token); + if (maybeFunc && + (ts.isFunctionExpression(maybeFunc) || ts.isArrowFunction(maybeFunc)) && + !ts.rangeContainsRange(maybeFunc.body, token) && + !containingThis(maybeFunc.body) && + !typeChecker.containsArgumentsReference(maybeFunc)) { + if (ts.isFunctionExpression(maybeFunc) && isFunctionReferencedInFile(file, typeChecker, maybeFunc)) + return undefined; + return { selectedVariableDeclaration: false, func: maybeFunc }; + } + return undefined; + } + function isSingleVariableDeclaration(parent) { + return ts.isVariableDeclaration(parent) || (ts.isVariableDeclarationList(parent) && parent.declarations.length === 1); + } + function tryGetFunctionFromVariableDeclaration(sourceFile, typeChecker, parent) { + if (!isSingleVariableDeclaration(parent)) { + return undefined; + } + var variableDeclaration = ts.isVariableDeclaration(parent) ? parent : ts.first(parent.declarations); + var initializer = variableDeclaration.initializer; + if (initializer && (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer) && !isFunctionReferencedInFile(sourceFile, typeChecker, initializer))) { + return initializer; + } + return undefined; + } + function convertToBlock(body) { + if (ts.isExpression(body)) { + var returnStatement = ts.factory.createReturnStatement(body); + var file = body.getSourceFile(); + ts.suppressLeadingAndTrailingTrivia(returnStatement); + ts.copyTrailingAsLeadingComments(body, returnStatement, file, /* commentKind */ undefined, /* hasTrailingNewLine */ true); + return ts.factory.createBlock([returnStatement], /* multiLine */ true); + } + else { + return body; + } + } + function getVariableInfo(func) { + var variableDeclaration = func.parent; + if (!ts.isVariableDeclaration(variableDeclaration) || !ts.isVariableDeclarationInVariableStatement(variableDeclaration)) + return undefined; + var variableDeclarationList = variableDeclaration.parent; + var statement = variableDeclarationList.parent; + if (!ts.isVariableDeclarationList(variableDeclarationList) || !ts.isVariableStatement(statement) || !ts.isIdentifier(variableDeclaration.name)) + return undefined; + return { variableDeclaration: variableDeclaration, variableDeclarationList: variableDeclarationList, statement: statement, name: variableDeclaration.name }; + } + function getEditInfoForConvertToAnonymousFunction(context, func) { + var file = context.file; + var body = convertToBlock(func.body); + var newNode = ts.factory.createFunctionExpression(func.modifiers, func.asteriskToken, /* name */ undefined, func.typeParameters, func.parameters, func.type, body); + return ts.textChanges.ChangeTracker.with(context, function (t) { return t.replaceNode(file, func, newNode); }); + } + function getEditInfoForConvertToNamedFunction(context, func, variableInfo) { + var file = context.file; + var body = convertToBlock(func.body); + var variableDeclaration = variableInfo.variableDeclaration, variableDeclarationList = variableInfo.variableDeclarationList, statement = variableInfo.statement, name = variableInfo.name; + ts.suppressLeadingTrivia(statement); + var modifiersFlags = (ts.getCombinedModifierFlags(variableDeclaration) & 1 /* ModifierFlags.Export */) | ts.getEffectiveModifierFlags(func); + var modifiers = ts.factory.createModifiersFromModifierFlags(modifiersFlags); + var newNode = ts.factory.createFunctionDeclaration(ts.length(modifiers) ? modifiers : undefined, func.asteriskToken, name, func.typeParameters, func.parameters, func.type, body); + if (variableDeclarationList.declarations.length === 1) { + return ts.textChanges.ChangeTracker.with(context, function (t) { return t.replaceNode(file, statement, newNode); }); + } + else { + return ts.textChanges.ChangeTracker.with(context, function (t) { + t.delete(file, variableDeclaration); + t.insertNodeAfter(file, statement, newNode); + }); + } + } + function getEditInfoForConvertToArrowFunction(context, func) { + var file = context.file; + var statements = func.body.statements; + var head = statements[0]; + var body; + if (canBeConvertedToExpression(func.body, head)) { + body = head.expression; + ts.suppressLeadingAndTrailingTrivia(body); + ts.copyComments(head, body); + } + else { + body = func.body; + } + var newNode = ts.factory.createArrowFunction(func.modifiers, func.typeParameters, func.parameters, func.type, ts.factory.createToken(38 /* SyntaxKind.EqualsGreaterThanToken */), body); + return ts.textChanges.ChangeTracker.with(context, function (t) { return t.replaceNode(file, func, newNode); }); + } + function canBeConvertedToExpression(body, head) { + return body.statements.length === 1 && ((ts.isReturnStatement(head) && !!head.expression)); + } + function isFunctionReferencedInFile(sourceFile, typeChecker, node) { + return !!node.name && ts.FindAllReferences.Core.isSymbolReferencedInFile(node.name, typeChecker, sourceFile); + } + })(convertArrowFunctionOrFunctionExpression = refactor.convertArrowFunctionOrFunctionExpression || (refactor.convertArrowFunctionOrFunctionExpression = {})); + })(refactor = ts.refactor || (ts.refactor = {})); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var refactor; + (function (refactor) { + var inferFunctionReturnType; + (function (inferFunctionReturnType) { + var refactorName = "Infer function return type"; + var refactorDescription = ts.Diagnostics.Infer_function_return_type.message; + var inferReturnTypeAction = { + name: refactorName, + description: refactorDescription, + kind: "refactor.rewrite.function.returnType" + }; + refactor.registerRefactor(refactorName, { + kinds: [inferReturnTypeAction.kind], + getEditsForAction: getRefactorEditsToInferReturnType, + getAvailableActions: getRefactorActionsToInferReturnType + }); + function getRefactorEditsToInferReturnType(context) { + var info = getInfo(context); + if (info && !refactor.isRefactorErrorInfo(info)) { + var edits = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(context.file, t, info.declaration, info.returnTypeNode); }); + return { renameFilename: undefined, renameLocation: undefined, edits: edits }; + } + return undefined; + } + function getRefactorActionsToInferReturnType(context) { + var info = getInfo(context); + if (!info) + return ts.emptyArray; + if (!refactor.isRefactorErrorInfo(info)) { + return [{ + name: refactorName, + description: refactorDescription, + actions: [inferReturnTypeAction] + }]; + } + if (context.preferences.provideRefactorNotApplicableReason) { + return [{ + name: refactorName, + description: refactorDescription, + actions: [__assign(__assign({}, inferReturnTypeAction), { notApplicableReason: info.error })] + }]; + } + return ts.emptyArray; + } + function doChange(sourceFile, changes, declaration, typeNode) { + var closeParen = ts.findChildOfKind(declaration, 21 /* SyntaxKind.CloseParenToken */, sourceFile); + var needParens = ts.isArrowFunction(declaration) && closeParen === undefined; + var endNode = needParens ? ts.first(declaration.parameters) : closeParen; + if (endNode) { + if (needParens) { + changes.insertNodeBefore(sourceFile, endNode, ts.factory.createToken(20 /* SyntaxKind.OpenParenToken */)); + changes.insertNodeAfter(sourceFile, endNode, ts.factory.createToken(21 /* SyntaxKind.CloseParenToken */)); + } + changes.insertNodeAt(sourceFile, endNode.end, typeNode, { prefix: ": " }); + } + } + function getInfo(context) { + if (ts.isInJSFile(context.file) || !refactor.refactorKindBeginsWith(inferReturnTypeAction.kind, context.kind)) + return; + var token = ts.getTokenAtPosition(context.file, context.startPosition); + var declaration = ts.findAncestor(token, function (n) { + return ts.isBlock(n) || n.parent && ts.isArrowFunction(n.parent) && (n.kind === 38 /* SyntaxKind.EqualsGreaterThanToken */ || n.parent.body === n) ? "quit" : + isConvertibleDeclaration(n); + }); + if (!declaration || !declaration.body || declaration.type) { + return { error: ts.getLocaleSpecificMessage(ts.Diagnostics.Return_type_must_be_inferred_from_a_function) }; + } + var typeChecker = context.program.getTypeChecker(); + var returnType = tryGetReturnType(typeChecker, declaration); + if (!returnType) { + return { error: ts.getLocaleSpecificMessage(ts.Diagnostics.Could_not_determine_function_return_type) }; + } + var returnTypeNode = typeChecker.typeToTypeNode(returnType, declaration, 1 /* NodeBuilderFlags.NoTruncation */); + if (returnTypeNode) { + return { declaration: declaration, returnTypeNode: returnTypeNode }; + } + } + function isConvertibleDeclaration(node) { + switch (node.kind) { + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + case 171 /* SyntaxKind.MethodDeclaration */: + return true; + default: + return false; + } + } + function tryGetReturnType(typeChecker, node) { + if (typeChecker.isImplementationOfOverload(node)) { + var signatures = typeChecker.getTypeAtLocation(node).getCallSignatures(); + if (signatures.length > 1) { + return typeChecker.getUnionType(ts.mapDefined(signatures, function (s) { return s.getReturnType(); })); + } + } + var signature = typeChecker.getSignatureFromDeclaration(node); + if (signature) { + return typeChecker.getReturnTypeOfSignature(signature); + } + } + })(inferFunctionReturnType = refactor.inferFunctionReturnType || (refactor.inferFunctionReturnType = {})); + })(refactor = ts.refactor || (ts.refactor = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + /** The version of the language service API */ + ts.servicesVersion = "0.8"; + function createNode(kind, pos, end, parent) { + var node = ts.isNodeKind(kind) ? new NodeObject(kind, pos, end) : + kind === 79 /* SyntaxKind.Identifier */ ? new IdentifierObject(79 /* SyntaxKind.Identifier */, pos, end) : + kind === 80 /* SyntaxKind.PrivateIdentifier */ ? new PrivateIdentifierObject(80 /* SyntaxKind.PrivateIdentifier */, pos, end) : + new TokenObject(kind, pos, end); + node.parent = parent; + node.flags = parent.flags & 50720768 /* NodeFlags.ContextFlags */; + return node; + } + var NodeObject = /** @class */ (function () { + function NodeObject(kind, pos, end) { + this.pos = pos; + this.end = end; + this.flags = 0 /* NodeFlags.None */; + this.modifierFlagsCache = 0 /* ModifierFlags.None */; + this.transformFlags = 0 /* TransformFlags.None */; + this.parent = undefined; + this.kind = kind; + } + NodeObject.prototype.assertHasRealPosition = function (message) { + // eslint-disable-next-line local/debug-assert + ts.Debug.assert(!ts.positionIsSynthesized(this.pos) && !ts.positionIsSynthesized(this.end), message || "Node must have a real position for this operation"); + }; + NodeObject.prototype.getSourceFile = function () { + return ts.getSourceFileOfNode(this); + }; + NodeObject.prototype.getStart = function (sourceFile, includeJsDocComment) { + this.assertHasRealPosition(); + return ts.getTokenPosOfNode(this, sourceFile, includeJsDocComment); + }; + NodeObject.prototype.getFullStart = function () { + this.assertHasRealPosition(); + return this.pos; + }; + NodeObject.prototype.getEnd = function () { + this.assertHasRealPosition(); + return this.end; + }; + NodeObject.prototype.getWidth = function (sourceFile) { + this.assertHasRealPosition(); + return this.getEnd() - this.getStart(sourceFile); + }; + NodeObject.prototype.getFullWidth = function () { + this.assertHasRealPosition(); + return this.end - this.pos; + }; + NodeObject.prototype.getLeadingTriviaWidth = function (sourceFile) { + this.assertHasRealPosition(); + return this.getStart(sourceFile) - this.pos; + }; + NodeObject.prototype.getFullText = function (sourceFile) { + this.assertHasRealPosition(); + return (sourceFile || this.getSourceFile()).text.substring(this.pos, this.end); + }; + NodeObject.prototype.getText = function (sourceFile) { + this.assertHasRealPosition(); + if (!sourceFile) { + sourceFile = this.getSourceFile(); + } + return sourceFile.text.substring(this.getStart(sourceFile), this.getEnd()); + }; + NodeObject.prototype.getChildCount = function (sourceFile) { + return this.getChildren(sourceFile).length; + }; + NodeObject.prototype.getChildAt = function (index, sourceFile) { + return this.getChildren(sourceFile)[index]; + }; + NodeObject.prototype.getChildren = function (sourceFile) { + this.assertHasRealPosition("Node without a real position cannot be scanned and thus has no token nodes - use forEachChild and collect the result if that's fine"); + return this._children || (this._children = createChildren(this, sourceFile)); + }; + NodeObject.prototype.getFirstToken = function (sourceFile) { + this.assertHasRealPosition(); + var children = this.getChildren(sourceFile); + if (!children.length) { + return undefined; + } + var child = ts.find(children, function (kid) { return kid.kind < 312 /* SyntaxKind.FirstJSDocNode */ || kid.kind > 350 /* SyntaxKind.LastJSDocNode */; }); + return child.kind < 163 /* SyntaxKind.FirstNode */ ? + child : + child.getFirstToken(sourceFile); + }; + NodeObject.prototype.getLastToken = function (sourceFile) { + this.assertHasRealPosition(); + var children = this.getChildren(sourceFile); + var child = ts.lastOrUndefined(children); + if (!child) { + return undefined; + } + return child.kind < 163 /* SyntaxKind.FirstNode */ ? child : child.getLastToken(sourceFile); + }; + NodeObject.prototype.forEachChild = function (cbNode, cbNodeArray) { + return ts.forEachChild(this, cbNode, cbNodeArray); + }; + return NodeObject; + }()); + function createChildren(node, sourceFile) { + if (!ts.isNodeKind(node.kind)) { + return ts.emptyArray; + } + var children = []; + if (ts.isJSDocCommentContainingNode(node)) { + /** Don't add trivia for "tokens" since this is in a comment. */ + node.forEachChild(function (child) { + children.push(child); + }); + return children; + } + ts.scanner.setText((sourceFile || node.getSourceFile()).text); + var pos = node.pos; + var processNode = function (child) { + addSyntheticNodes(children, pos, child.pos, node); + children.push(child); + pos = child.end; + }; + var processNodes = function (nodes) { + addSyntheticNodes(children, pos, nodes.pos, node); + children.push(createSyntaxList(nodes, node)); + pos = nodes.end; + }; + // jsDocComments need to be the first children + ts.forEach(node.jsDoc, processNode); + // For syntactic classifications, all trivia are classified together, including jsdoc comments. + // For that to work, the jsdoc comments should still be the leading trivia of the first child. + // Restoring the scanner position ensures that. + pos = node.pos; + node.forEachChild(processNode, processNodes); + addSyntheticNodes(children, pos, node.end, node); + ts.scanner.setText(undefined); + return children; + } + function addSyntheticNodes(nodes, pos, end, parent) { + ts.scanner.setTextPos(pos); + while (pos < end) { + var token = ts.scanner.scan(); + var textPos = ts.scanner.getTextPos(); + if (textPos <= end) { + if (token === 79 /* SyntaxKind.Identifier */) { + ts.Debug.fail("Did not expect ".concat(ts.Debug.formatSyntaxKind(parent.kind), " to have an Identifier in its trivia")); + } + nodes.push(createNode(token, pos, textPos, parent)); + } + pos = textPos; + if (token === 1 /* SyntaxKind.EndOfFileToken */) { + break; + } + } + } + function createSyntaxList(nodes, parent) { + var list = createNode(351 /* SyntaxKind.SyntaxList */, nodes.pos, nodes.end, parent); + list._children = []; + var pos = nodes.pos; + for (var _i = 0, nodes_2 = nodes; _i < nodes_2.length; _i++) { + var node = nodes_2[_i]; + addSyntheticNodes(list._children, pos, node.pos, parent); + list._children.push(node); + pos = node.end; + } + addSyntheticNodes(list._children, pos, nodes.end, parent); + return list; + } + var TokenOrIdentifierObject = /** @class */ (function () { + function TokenOrIdentifierObject(pos, end) { + // Set properties in same order as NodeObject + this.pos = pos; + this.end = end; + this.flags = 0 /* NodeFlags.None */; + this.modifierFlagsCache = 0 /* ModifierFlags.None */; + this.transformFlags = 0 /* TransformFlags.None */; + this.parent = undefined; + } + TokenOrIdentifierObject.prototype.getSourceFile = function () { + return ts.getSourceFileOfNode(this); + }; + TokenOrIdentifierObject.prototype.getStart = function (sourceFile, includeJsDocComment) { + return ts.getTokenPosOfNode(this, sourceFile, includeJsDocComment); + }; + TokenOrIdentifierObject.prototype.getFullStart = function () { + return this.pos; + }; + TokenOrIdentifierObject.prototype.getEnd = function () { + return this.end; + }; + TokenOrIdentifierObject.prototype.getWidth = function (sourceFile) { + return this.getEnd() - this.getStart(sourceFile); + }; + TokenOrIdentifierObject.prototype.getFullWidth = function () { + return this.end - this.pos; + }; + TokenOrIdentifierObject.prototype.getLeadingTriviaWidth = function (sourceFile) { + return this.getStart(sourceFile) - this.pos; + }; + TokenOrIdentifierObject.prototype.getFullText = function (sourceFile) { + return (sourceFile || this.getSourceFile()).text.substring(this.pos, this.end); + }; + TokenOrIdentifierObject.prototype.getText = function (sourceFile) { + if (!sourceFile) { + sourceFile = this.getSourceFile(); + } + return sourceFile.text.substring(this.getStart(sourceFile), this.getEnd()); + }; + TokenOrIdentifierObject.prototype.getChildCount = function () { + return this.getChildren().length; + }; + TokenOrIdentifierObject.prototype.getChildAt = function (index) { + return this.getChildren()[index]; + }; + TokenOrIdentifierObject.prototype.getChildren = function () { + return this.kind === 1 /* SyntaxKind.EndOfFileToken */ ? this.jsDoc || ts.emptyArray : ts.emptyArray; + }; + TokenOrIdentifierObject.prototype.getFirstToken = function () { + return undefined; + }; + TokenOrIdentifierObject.prototype.getLastToken = function () { + return undefined; + }; + TokenOrIdentifierObject.prototype.forEachChild = function () { + return undefined; + }; + return TokenOrIdentifierObject; + }()); + var SymbolObject = /** @class */ (function () { + function SymbolObject(flags, name) { + this.flags = flags; + this.escapedName = name; + } + SymbolObject.prototype.getFlags = function () { + return this.flags; + }; + Object.defineProperty(SymbolObject.prototype, "name", { + get: function () { + return ts.symbolName(this); + }, + enumerable: false, + configurable: true + }); + SymbolObject.prototype.getEscapedName = function () { + return this.escapedName; + }; + SymbolObject.prototype.getName = function () { + return this.name; + }; + SymbolObject.prototype.getDeclarations = function () { + return this.declarations; + }; + SymbolObject.prototype.getDocumentationComment = function (checker) { + if (!this.documentationComment) { + this.documentationComment = ts.emptyArray; // Set temporarily to avoid an infinite loop finding inherited docs + if (!this.declarations && this.target && this.target.tupleLabelDeclaration) { + var labelDecl = this.target.tupleLabelDeclaration; + this.documentationComment = getDocumentationComment([labelDecl], checker); + } + else { + this.documentationComment = getDocumentationComment(this.declarations, checker); + } + } + return this.documentationComment; + }; + SymbolObject.prototype.getContextualDocumentationComment = function (context, checker) { + if (context) { + if (ts.isGetAccessor(context)) { + if (!this.contextualGetAccessorDocumentationComment) { + this.contextualGetAccessorDocumentationComment = getDocumentationComment(ts.filter(this.declarations, ts.isGetAccessor), checker); + } + if (ts.length(this.contextualGetAccessorDocumentationComment)) { + return this.contextualGetAccessorDocumentationComment; + } + } + if (ts.isSetAccessor(context)) { + if (!this.contextualSetAccessorDocumentationComment) { + this.contextualSetAccessorDocumentationComment = getDocumentationComment(ts.filter(this.declarations, ts.isSetAccessor), checker); + } + if (ts.length(this.contextualSetAccessorDocumentationComment)) { + return this.contextualSetAccessorDocumentationComment; + } + } + } + return this.getDocumentationComment(checker); + }; + SymbolObject.prototype.getJsDocTags = function (checker) { + if (this.tags === undefined) { + this.tags = getJsDocTagsOfDeclarations(this.declarations, checker); + } + return this.tags; + }; + SymbolObject.prototype.getContextualJsDocTags = function (context, checker) { + if (context) { + if (ts.isGetAccessor(context)) { + if (!this.contextualGetAccessorTags) { + this.contextualGetAccessorTags = getJsDocTagsOfDeclarations(ts.filter(this.declarations, ts.isGetAccessor), checker); + } + if (ts.length(this.contextualGetAccessorTags)) { + return this.contextualGetAccessorTags; + } + } + if (ts.isSetAccessor(context)) { + if (!this.contextualSetAccessorTags) { + this.contextualSetAccessorTags = getJsDocTagsOfDeclarations(ts.filter(this.declarations, ts.isSetAccessor), checker); + } + if (ts.length(this.contextualSetAccessorTags)) { + return this.contextualSetAccessorTags; + } + } + } + return this.getJsDocTags(checker); + }; + return SymbolObject; + }()); + var TokenObject = /** @class */ (function (_super) { + __extends(TokenObject, _super); + function TokenObject(kind, pos, end) { + var _this = _super.call(this, pos, end) || this; + _this.kind = kind; + return _this; + } + return TokenObject; + }(TokenOrIdentifierObject)); + var IdentifierObject = /** @class */ (function (_super) { + __extends(IdentifierObject, _super); + function IdentifierObject(_kind, pos, end) { + var _this = _super.call(this, pos, end) || this; + _this.kind = 79 /* SyntaxKind.Identifier */; + return _this; + } + Object.defineProperty(IdentifierObject.prototype, "text", { + get: function () { + return ts.idText(this); + }, + enumerable: false, + configurable: true + }); + return IdentifierObject; + }(TokenOrIdentifierObject)); + IdentifierObject.prototype.kind = 79 /* SyntaxKind.Identifier */; + var PrivateIdentifierObject = /** @class */ (function (_super) { + __extends(PrivateIdentifierObject, _super); + function PrivateIdentifierObject(_kind, pos, end) { + return _super.call(this, pos, end) || this; + } + Object.defineProperty(PrivateIdentifierObject.prototype, "text", { + get: function () { + return ts.idText(this); + }, + enumerable: false, + configurable: true + }); + return PrivateIdentifierObject; + }(TokenOrIdentifierObject)); + PrivateIdentifierObject.prototype.kind = 80 /* SyntaxKind.PrivateIdentifier */; + var TypeObject = /** @class */ (function () { + function TypeObject(checker, flags) { + this.checker = checker; + this.flags = flags; + } + TypeObject.prototype.getFlags = function () { + return this.flags; + }; + TypeObject.prototype.getSymbol = function () { + return this.symbol; + }; + TypeObject.prototype.getProperties = function () { + return this.checker.getPropertiesOfType(this); + }; + TypeObject.prototype.getProperty = function (propertyName) { + return this.checker.getPropertyOfType(this, propertyName); + }; + TypeObject.prototype.getApparentProperties = function () { + return this.checker.getAugmentedPropertiesOfType(this); + }; + TypeObject.prototype.getCallSignatures = function () { + return this.checker.getSignaturesOfType(this, 0 /* SignatureKind.Call */); + }; + TypeObject.prototype.getConstructSignatures = function () { + return this.checker.getSignaturesOfType(this, 1 /* SignatureKind.Construct */); + }; + TypeObject.prototype.getStringIndexType = function () { + return this.checker.getIndexTypeOfType(this, 0 /* IndexKind.String */); + }; + TypeObject.prototype.getNumberIndexType = function () { + return this.checker.getIndexTypeOfType(this, 1 /* IndexKind.Number */); + }; + TypeObject.prototype.getBaseTypes = function () { + return this.isClassOrInterface() ? this.checker.getBaseTypes(this) : undefined; + }; + TypeObject.prototype.isNullableType = function () { + return this.checker.isNullableType(this); + }; + TypeObject.prototype.getNonNullableType = function () { + return this.checker.getNonNullableType(this); + }; + TypeObject.prototype.getNonOptionalType = function () { + return this.checker.getNonOptionalType(this); + }; + TypeObject.prototype.getConstraint = function () { + return this.checker.getBaseConstraintOfType(this); + }; + TypeObject.prototype.getDefault = function () { + return this.checker.getDefaultFromTypeParameter(this); + }; + TypeObject.prototype.isUnion = function () { + return !!(this.flags & 1048576 /* TypeFlags.Union */); + }; + TypeObject.prototype.isIntersection = function () { + return !!(this.flags & 2097152 /* TypeFlags.Intersection */); + }; + TypeObject.prototype.isUnionOrIntersection = function () { + return !!(this.flags & 3145728 /* TypeFlags.UnionOrIntersection */); + }; + TypeObject.prototype.isLiteral = function () { + return !!(this.flags & 384 /* TypeFlags.StringOrNumberLiteral */); + }; + TypeObject.prototype.isStringLiteral = function () { + return !!(this.flags & 128 /* TypeFlags.StringLiteral */); + }; + TypeObject.prototype.isNumberLiteral = function () { + return !!(this.flags & 256 /* TypeFlags.NumberLiteral */); + }; + TypeObject.prototype.isTypeParameter = function () { + return !!(this.flags & 262144 /* TypeFlags.TypeParameter */); + }; + TypeObject.prototype.isClassOrInterface = function () { + return !!(ts.getObjectFlags(this) & 3 /* ObjectFlags.ClassOrInterface */); + }; + TypeObject.prototype.isClass = function () { + return !!(ts.getObjectFlags(this) & 1 /* ObjectFlags.Class */); + }; + TypeObject.prototype.isIndexType = function () { + return !!(this.flags & 4194304 /* TypeFlags.Index */); + }; + Object.defineProperty(TypeObject.prototype, "typeArguments", { + /** + * This polyfills `referenceType.typeArguments` for API consumers + */ + get: function () { + if (ts.getObjectFlags(this) & 4 /* ObjectFlags.Reference */) { + return this.checker.getTypeArguments(this); + } + return undefined; + }, + enumerable: false, + configurable: true + }); + return TypeObject; + }()); + var SignatureObject = /** @class */ (function () { + function SignatureObject(checker, flags) { + this.checker = checker; + this.flags = flags; + } + SignatureObject.prototype.getDeclaration = function () { + return this.declaration; + }; + SignatureObject.prototype.getTypeParameters = function () { + return this.typeParameters; + }; + SignatureObject.prototype.getParameters = function () { + return this.parameters; + }; + SignatureObject.prototype.getReturnType = function () { + return this.checker.getReturnTypeOfSignature(this); + }; + SignatureObject.prototype.getTypeParameterAtPosition = function (pos) { + var type = this.checker.getParameterType(this, pos); + if (type.isIndexType() && ts.isThisTypeParameter(type.type)) { + var constraint = type.type.getConstraint(); + if (constraint) { + return this.checker.getIndexType(constraint); + } + } + return type; + }; + SignatureObject.prototype.getDocumentationComment = function () { + return this.documentationComment || (this.documentationComment = getDocumentationComment(ts.singleElementArray(this.declaration), this.checker)); + }; + SignatureObject.prototype.getJsDocTags = function () { + return this.jsDocTags || (this.jsDocTags = getJsDocTagsOfDeclarations(ts.singleElementArray(this.declaration), this.checker)); + }; + return SignatureObject; + }()); + /** + * Returns whether or not the given node has a JSDoc "inheritDoc" tag on it. + * @param node the Node in question. + * @returns `true` if `node` has a JSDoc "inheritDoc" tag on it, otherwise `false`. + */ + function hasJSDocInheritDocTag(node) { + return ts.getJSDocTags(node).some(function (tag) { return tag.tagName.text === "inheritDoc" || tag.tagName.text === "inheritdoc"; }); + } + function getJsDocTagsOfDeclarations(declarations, checker) { + if (!declarations) + return ts.emptyArray; + var tags = ts.JsDoc.getJsDocTagsFromDeclarations(declarations, checker); + if (checker && (tags.length === 0 || declarations.some(hasJSDocInheritDocTag))) { + var seenSymbols_1 = new ts.Set(); + var _loop_20 = function (declaration) { + var inheritedTags = findBaseOfDeclaration(checker, declaration, function (symbol) { + var _a; + if (!seenSymbols_1.has(symbol)) { + seenSymbols_1.add(symbol); + if (declaration.kind === 174 /* SyntaxKind.GetAccessor */ || declaration.kind === 175 /* SyntaxKind.SetAccessor */) { + return symbol.getContextualJsDocTags(declaration, checker); + } + return ((_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a.length) === 1 ? symbol.getJsDocTags() : undefined; + } + }); + if (inheritedTags) { + tags = __spreadArray(__spreadArray([], inheritedTags, true), tags, true); + } + }; + for (var _i = 0, declarations_6 = declarations; _i < declarations_6.length; _i++) { + var declaration = declarations_6[_i]; + _loop_20(declaration); + } + } + return tags; + } + function getDocumentationComment(declarations, checker) { + if (!declarations) + return ts.emptyArray; + var doc = ts.JsDoc.getJsDocCommentsFromDeclarations(declarations, checker); + if (checker && (doc.length === 0 || declarations.some(hasJSDocInheritDocTag))) { + var seenSymbols_2 = new ts.Set(); + var _loop_21 = function (declaration) { + var inheritedDocs = findBaseOfDeclaration(checker, declaration, function (symbol) { + if (!seenSymbols_2.has(symbol)) { + seenSymbols_2.add(symbol); + if (declaration.kind === 174 /* SyntaxKind.GetAccessor */ || declaration.kind === 175 /* SyntaxKind.SetAccessor */) { + return symbol.getContextualDocumentationComment(declaration, checker); + } + return symbol.getDocumentationComment(checker); + } + }); + // TODO: GH#16312 Return a ReadonlyArray, avoid copying inheritedDocs + if (inheritedDocs) + doc = doc.length === 0 ? inheritedDocs.slice() : inheritedDocs.concat(ts.lineBreakPart(), doc); + }; + for (var _i = 0, declarations_7 = declarations; _i < declarations_7.length; _i++) { + var declaration = declarations_7[_i]; + _loop_21(declaration); + } + } + return doc; + } + function findBaseOfDeclaration(checker, declaration, cb) { + var _a; + var classOrInterfaceDeclaration = ((_a = declaration.parent) === null || _a === void 0 ? void 0 : _a.kind) === 173 /* SyntaxKind.Constructor */ ? declaration.parent.parent : declaration.parent; + if (!classOrInterfaceDeclaration) + return; + var isStaticMember = ts.hasStaticModifier(declaration); + return ts.firstDefined(ts.getAllSuperTypeNodes(classOrInterfaceDeclaration), function (superTypeNode) { + var baseType = checker.getTypeAtLocation(superTypeNode); + var type = isStaticMember && baseType.symbol ? checker.getTypeOfSymbol(baseType.symbol) : baseType; + var symbol = checker.getPropertyOfType(type, declaration.symbol.name); + return symbol ? cb(symbol) : undefined; + }); + } + var SourceFileObject = /** @class */ (function (_super) { + __extends(SourceFileObject, _super); + function SourceFileObject(kind, pos, end) { + var _this = _super.call(this, kind, pos, end) || this; + _this.kind = 308 /* SyntaxKind.SourceFile */; + return _this; + } + SourceFileObject.prototype.update = function (newText, textChangeRange) { + return ts.updateSourceFile(this, newText, textChangeRange); + }; + SourceFileObject.prototype.getLineAndCharacterOfPosition = function (position) { + return ts.getLineAndCharacterOfPosition(this, position); + }; + SourceFileObject.prototype.getLineStarts = function () { + return ts.getLineStarts(this); + }; + SourceFileObject.prototype.getPositionOfLineAndCharacter = function (line, character, allowEdits) { + return ts.computePositionOfLineAndCharacter(ts.getLineStarts(this), line, character, this.text, allowEdits); + }; + SourceFileObject.prototype.getLineEndOfPosition = function (pos) { + var line = this.getLineAndCharacterOfPosition(pos).line; + var lineStarts = this.getLineStarts(); + var lastCharPos; + if (line + 1 >= lineStarts.length) { + lastCharPos = this.getEnd(); + } + if (!lastCharPos) { + lastCharPos = lineStarts[line + 1] - 1; + } + var fullText = this.getFullText(); + // if the new line is "\r\n", we should return the last non-new-line-character position + return fullText[lastCharPos] === "\n" && fullText[lastCharPos - 1] === "\r" ? lastCharPos - 1 : lastCharPos; + }; + SourceFileObject.prototype.getNamedDeclarations = function () { + if (!this.namedDeclarations) { + this.namedDeclarations = this.computeNamedDeclarations(); + } + return this.namedDeclarations; + }; + SourceFileObject.prototype.computeNamedDeclarations = function () { + var result = ts.createMultiMap(); + this.forEachChild(visit); + return result; + function addDeclaration(declaration) { + var name = getDeclarationName(declaration); + if (name) { + result.add(name, declaration); + } + } + function getDeclarations(name) { + var declarations = result.get(name); + if (!declarations) { + result.set(name, declarations = []); + } + return declarations; + } + function getDeclarationName(declaration) { + var name = ts.getNonAssignedNameOfDeclaration(declaration); + return name && (ts.isComputedPropertyName(name) && ts.isPropertyAccessExpression(name.expression) ? name.expression.name.text + : ts.isPropertyName(name) ? ts.getNameFromPropertyName(name) : undefined); + } + function visit(node) { + switch (node.kind) { + case 259 /* SyntaxKind.FunctionDeclaration */: + case 215 /* SyntaxKind.FunctionExpression */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + var functionDeclaration = node; + var declarationName = getDeclarationName(functionDeclaration); + if (declarationName) { + var declarations = getDeclarations(declarationName); + var lastDeclaration = ts.lastOrUndefined(declarations); + // Check whether this declaration belongs to an "overload group". + if (lastDeclaration && functionDeclaration.parent === lastDeclaration.parent && functionDeclaration.symbol === lastDeclaration.symbol) { + // Overwrite the last declaration if it was an overload + // and this one is an implementation. + if (functionDeclaration.body && !lastDeclaration.body) { + declarations[declarations.length - 1] = functionDeclaration; + } + } + else { + declarations.push(functionDeclaration); + } + } + ts.forEachChild(node, visit); + break; + case 260 /* SyntaxKind.ClassDeclaration */: + case 228 /* SyntaxKind.ClassExpression */: + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 264 /* SyntaxKind.ModuleDeclaration */: + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + case 278 /* SyntaxKind.ExportSpecifier */: + case 273 /* SyntaxKind.ImportSpecifier */: + case 270 /* SyntaxKind.ImportClause */: + case 271 /* SyntaxKind.NamespaceImport */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 184 /* SyntaxKind.TypeLiteral */: + addDeclaration(node); + ts.forEachChild(node, visit); + break; + case 166 /* SyntaxKind.Parameter */: + // Only consider parameter properties + if (!ts.hasSyntacticModifier(node, 16476 /* ModifierFlags.ParameterPropertyModifier */)) { + break; + } + // falls through + case 257 /* SyntaxKind.VariableDeclaration */: + case 205 /* SyntaxKind.BindingElement */: { + var decl = node; + if (ts.isBindingPattern(decl.name)) { + ts.forEachChild(decl.name, visit); + break; + } + if (decl.initializer) { + visit(decl.initializer); + } + } + // falls through + case 302 /* SyntaxKind.EnumMember */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 168 /* SyntaxKind.PropertySignature */: + addDeclaration(node); + break; + case 275 /* SyntaxKind.ExportDeclaration */: + // Handle named exports case e.g.: + // export {a, b as B} from "mod"; + var exportDeclaration = node; + if (exportDeclaration.exportClause) { + if (ts.isNamedExports(exportDeclaration.exportClause)) { + ts.forEach(exportDeclaration.exportClause.elements, visit); + } + else { + visit(exportDeclaration.exportClause.name); + } + } + break; + case 269 /* SyntaxKind.ImportDeclaration */: + var importClause = node.importClause; + if (importClause) { + // Handle default import case e.g.: + // import d from "mod"; + if (importClause.name) { + addDeclaration(importClause.name); + } + // Handle named bindings in imports e.g.: + // import * as NS from "mod"; + // import {a, b as B} from "mod"; + if (importClause.namedBindings) { + if (importClause.namedBindings.kind === 271 /* SyntaxKind.NamespaceImport */) { + addDeclaration(importClause.namedBindings); + } + else { + ts.forEach(importClause.namedBindings.elements, visit); + } + } + } + break; + case 223 /* SyntaxKind.BinaryExpression */: + if (ts.getAssignmentDeclarationKind(node) !== 0 /* AssignmentDeclarationKind.None */) { + addDeclaration(node); + } + // falls through + default: + ts.forEachChild(node, visit); + } + } + }; + return SourceFileObject; + }(NodeObject)); + var SourceMapSourceObject = /** @class */ (function () { + function SourceMapSourceObject(fileName, text, skipTrivia) { + this.fileName = fileName; + this.text = text; + this.skipTrivia = skipTrivia; + } + SourceMapSourceObject.prototype.getLineAndCharacterOfPosition = function (pos) { + return ts.getLineAndCharacterOfPosition(this, pos); + }; + return SourceMapSourceObject; + }()); + function getServicesObjectAllocator() { + return { + getNodeConstructor: function () { return NodeObject; }, + getTokenConstructor: function () { return TokenObject; }, + getIdentifierConstructor: function () { return IdentifierObject; }, + getPrivateIdentifierConstructor: function () { return PrivateIdentifierObject; }, + getSourceFileConstructor: function () { return SourceFileObject; }, + getSymbolConstructor: function () { return SymbolObject; }, + getTypeConstructor: function () { return TypeObject; }, + getSignatureConstructor: function () { return SignatureObject; }, + getSourceMapSourceConstructor: function () { return SourceMapSourceObject; }, + }; + } + function toEditorSettings(optionsAsMap) { + var allPropertiesAreCamelCased = true; + for (var key in optionsAsMap) { + if (ts.hasProperty(optionsAsMap, key) && !isCamelCase(key)) { + allPropertiesAreCamelCased = false; + break; + } + } + if (allPropertiesAreCamelCased) { + return optionsAsMap; + } + var settings = {}; + for (var key in optionsAsMap) { + if (ts.hasProperty(optionsAsMap, key)) { + var newKey = isCamelCase(key) ? key : key.charAt(0).toLowerCase() + key.substr(1); + settings[newKey] = optionsAsMap[key]; + } + } + return settings; + } + ts.toEditorSettings = toEditorSettings; + function isCamelCase(s) { + return !s.length || s.charAt(0) === s.charAt(0).toLowerCase(); + } + function displayPartsToString(displayParts) { + if (displayParts) { + return ts.map(displayParts, function (displayPart) { return displayPart.text; }).join(""); + } + return ""; + } + ts.displayPartsToString = displayPartsToString; + function getDefaultCompilerOptions() { + // Always default to "ScriptTarget.ES5" for the language service + return { + target: 1 /* ScriptTarget.ES5 */, + jsx: 1 /* JsxEmit.Preserve */ + }; + } + ts.getDefaultCompilerOptions = getDefaultCompilerOptions; + function getSupportedCodeFixes() { + return ts.codefix.getSupportedErrorCodes(); + } + ts.getSupportedCodeFixes = getSupportedCodeFixes; + var SyntaxTreeCache = /** @class */ (function () { + function SyntaxTreeCache(host) { + this.host = host; + } + SyntaxTreeCache.prototype.getCurrentSourceFile = function (fileName) { + var _a, _b, _c, _d, _e, _f, _g, _h; + var scriptSnapshot = this.host.getScriptSnapshot(fileName); + if (!scriptSnapshot) { + // The host does not know about this file. + throw new Error("Could not find file: '" + fileName + "'."); + } + var scriptKind = ts.getScriptKind(fileName, this.host); + var version = this.host.getScriptVersion(fileName); + var sourceFile; + if (this.currentFileName !== fileName) { + // This is a new file, just parse it + var options = { + languageVersion: 99 /* ScriptTarget.Latest */, + impliedNodeFormat: ts.getImpliedNodeFormatForFile(ts.toPath(fileName, this.host.getCurrentDirectory(), ((_c = (_b = (_a = this.host).getCompilerHost) === null || _b === void 0 ? void 0 : _b.call(_a)) === null || _c === void 0 ? void 0 : _c.getCanonicalFileName) || ts.hostGetCanonicalFileName(this.host)), (_h = (_g = (_f = (_e = (_d = this.host).getCompilerHost) === null || _e === void 0 ? void 0 : _e.call(_d)) === null || _f === void 0 ? void 0 : _f.getModuleResolutionCache) === null || _g === void 0 ? void 0 : _g.call(_f)) === null || _h === void 0 ? void 0 : _h.getPackageJsonInfoCache(), this.host, this.host.getCompilationSettings()), + setExternalModuleIndicator: ts.getSetExternalModuleIndicator(this.host.getCompilationSettings()) + }; + sourceFile = createLanguageServiceSourceFile(fileName, scriptSnapshot, options, version, /*setNodeParents*/ true, scriptKind); + } + else if (this.currentFileVersion !== version) { + // This is the same file, just a newer version. Incrementally parse the file. + var editRange = scriptSnapshot.getChangeRange(this.currentFileScriptSnapshot); + sourceFile = updateLanguageServiceSourceFile(this.currentSourceFile, scriptSnapshot, version, editRange); + } + if (sourceFile) { + // All done, ensure state is up to date + this.currentFileVersion = version; + this.currentFileName = fileName; + this.currentFileScriptSnapshot = scriptSnapshot; + this.currentSourceFile = sourceFile; + } + return this.currentSourceFile; + }; + return SyntaxTreeCache; + }()); + function setSourceFileFields(sourceFile, scriptSnapshot, version) { + sourceFile.version = version; + sourceFile.scriptSnapshot = scriptSnapshot; + } + function createLanguageServiceSourceFile(fileName, scriptSnapshot, scriptTargetOrOptions, version, setNodeParents, scriptKind) { + var sourceFile = ts.createSourceFile(fileName, ts.getSnapshotText(scriptSnapshot), scriptTargetOrOptions, setNodeParents, scriptKind); + setSourceFileFields(sourceFile, scriptSnapshot, version); + return sourceFile; + } + ts.createLanguageServiceSourceFile = createLanguageServiceSourceFile; + function updateLanguageServiceSourceFile(sourceFile, scriptSnapshot, version, textChangeRange, aggressiveChecks) { + // If we were given a text change range, and our version or open-ness changed, then + // incrementally parse this file. + if (textChangeRange) { + if (version !== sourceFile.version) { + var newText = void 0; + // grab the fragment from the beginning of the original text to the beginning of the span + var prefix = textChangeRange.span.start !== 0 + ? sourceFile.text.substr(0, textChangeRange.span.start) + : ""; + // grab the fragment from the end of the span till the end of the original text + var suffix = ts.textSpanEnd(textChangeRange.span) !== sourceFile.text.length + ? sourceFile.text.substr(ts.textSpanEnd(textChangeRange.span)) + : ""; + if (textChangeRange.newLength === 0) { + // edit was a deletion - just combine prefix and suffix + newText = prefix && suffix ? prefix + suffix : prefix || suffix; + } + else { + // it was actual edit, fetch the fragment of new text that correspond to new span + var changedText = scriptSnapshot.getText(textChangeRange.span.start, textChangeRange.span.start + textChangeRange.newLength); + // combine prefix, changed text and suffix + newText = prefix && suffix + ? prefix + changedText + suffix + : prefix + ? (prefix + changedText) + : (changedText + suffix); + } + var newSourceFile = ts.updateSourceFile(sourceFile, newText, textChangeRange, aggressiveChecks); + setSourceFileFields(newSourceFile, scriptSnapshot, version); + // after incremental parsing nameTable might not be up-to-date + // drop it so it can be lazily recreated later + newSourceFile.nameTable = undefined; + // dispose all resources held by old script snapshot + if (sourceFile !== newSourceFile && sourceFile.scriptSnapshot) { + if (sourceFile.scriptSnapshot.dispose) { + sourceFile.scriptSnapshot.dispose(); + } + sourceFile.scriptSnapshot = undefined; + } + return newSourceFile; + } + } + var options = { + languageVersion: sourceFile.languageVersion, + impliedNodeFormat: sourceFile.impliedNodeFormat, + setExternalModuleIndicator: sourceFile.setExternalModuleIndicator, + }; + // Otherwise, just create a new source file. + return createLanguageServiceSourceFile(sourceFile.fileName, scriptSnapshot, options, version, /*setNodeParents*/ true, sourceFile.scriptKind); + } + ts.updateLanguageServiceSourceFile = updateLanguageServiceSourceFile; + var NoopCancellationToken = { + isCancellationRequested: ts.returnFalse, + throwIfCancellationRequested: ts.noop, + }; + var CancellationTokenObject = /** @class */ (function () { + function CancellationTokenObject(cancellationToken) { + this.cancellationToken = cancellationToken; + } + CancellationTokenObject.prototype.isCancellationRequested = function () { + return this.cancellationToken.isCancellationRequested(); + }; + CancellationTokenObject.prototype.throwIfCancellationRequested = function () { + if (this.isCancellationRequested()) { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("session" /* tracing.Phase.Session */, "cancellationThrown", { kind: "CancellationTokenObject" }); + throw new ts.OperationCanceledException(); + } + }; + return CancellationTokenObject; + }()); + /* @internal */ + /** A cancellation that throttles calls to the host */ + var ThrottledCancellationToken = /** @class */ (function () { + function ThrottledCancellationToken(hostCancellationToken, throttleWaitMilliseconds) { + if (throttleWaitMilliseconds === void 0) { throttleWaitMilliseconds = 20; } + this.hostCancellationToken = hostCancellationToken; + this.throttleWaitMilliseconds = throttleWaitMilliseconds; + // Store when we last tried to cancel. Checking cancellation can be expensive (as we have + // to marshall over to the host layer). So we only bother actually checking once enough + // time has passed. + this.lastCancellationCheckTime = 0; + } + ThrottledCancellationToken.prototype.isCancellationRequested = function () { + var time = ts.timestamp(); + var duration = Math.abs(time - this.lastCancellationCheckTime); + if (duration >= this.throttleWaitMilliseconds) { + // Check no more than once every throttle wait milliseconds + this.lastCancellationCheckTime = time; + return this.hostCancellationToken.isCancellationRequested(); + } + return false; + }; + ThrottledCancellationToken.prototype.throwIfCancellationRequested = function () { + if (this.isCancellationRequested()) { + ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.instant("session" /* tracing.Phase.Session */, "cancellationThrown", { kind: "ThrottledCancellationToken" }); + throw new ts.OperationCanceledException(); + } + }; + return ThrottledCancellationToken; + }()); + ts.ThrottledCancellationToken = ThrottledCancellationToken; + var invalidOperationsInPartialSemanticMode = [ + "getSemanticDiagnostics", + "getSuggestionDiagnostics", + "getCompilerOptionsDiagnostics", + "getSemanticClassifications", + "getEncodedSemanticClassifications", + "getCodeFixesAtPosition", + "getCombinedCodeFix", + "applyCodeActionCommand", + "organizeImports", + "getEditsForFileRename", + "getEmitOutput", + "getApplicableRefactors", + "getEditsForRefactor", + "prepareCallHierarchy", + "provideCallHierarchyIncomingCalls", + "provideCallHierarchyOutgoingCalls", + "provideInlayHints" + ]; + var invalidOperationsInSyntacticMode = __spreadArray(__spreadArray([], invalidOperationsInPartialSemanticMode, true), [ + "getCompletionsAtPosition", + "getCompletionEntryDetails", + "getCompletionEntrySymbol", + "getSignatureHelpItems", + "getQuickInfoAtPosition", + "getDefinitionAtPosition", + "getDefinitionAndBoundSpan", + "getImplementationAtPosition", + "getTypeDefinitionAtPosition", + "getReferencesAtPosition", + "findReferences", + "getOccurrencesAtPosition", + "getDocumentHighlights", + "getNavigateToItems", + "getRenameInfo", + "findRenameLocations", + "getApplicableRefactors", + ], false); + function createLanguageService(host, documentRegistry, syntaxOnlyOrLanguageServiceMode) { + var _a; + var _b; + if (documentRegistry === void 0) { documentRegistry = ts.createDocumentRegistry(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames(), host.getCurrentDirectory()); } + var languageServiceMode; + if (syntaxOnlyOrLanguageServiceMode === undefined) { + languageServiceMode = ts.LanguageServiceMode.Semantic; + } + else if (typeof syntaxOnlyOrLanguageServiceMode === "boolean") { + // languageServiceMode = SyntaxOnly + languageServiceMode = syntaxOnlyOrLanguageServiceMode ? ts.LanguageServiceMode.Syntactic : ts.LanguageServiceMode.Semantic; + } + else { + languageServiceMode = syntaxOnlyOrLanguageServiceMode; + } + var syntaxTreeCache = new SyntaxTreeCache(host); + var program; + var lastProjectVersion; + var lastTypesRootVersion = 0; + var cancellationToken = host.getCancellationToken + ? new CancellationTokenObject(host.getCancellationToken()) + : NoopCancellationToken; + var currentDirectory = host.getCurrentDirectory(); + // Checks if the localized messages json is set, and if not, query the host for it + ts.maybeSetLocalizedDiagnosticMessages((_b = host.getLocalizedDiagnosticMessages) === null || _b === void 0 ? void 0 : _b.bind(host)); + function log(message) { + if (host.log) { + host.log(message); + } + } + var useCaseSensitiveFileNames = ts.hostUsesCaseSensitiveFileNames(host); + var getCanonicalFileName = ts.createGetCanonicalFileName(useCaseSensitiveFileNames); + var sourceMapper = ts.getSourceMapper({ + useCaseSensitiveFileNames: function () { return useCaseSensitiveFileNames; }, + getCurrentDirectory: function () { return currentDirectory; }, + getProgram: getProgram, + fileExists: ts.maybeBind(host, host.fileExists), + readFile: ts.maybeBind(host, host.readFile), + getDocumentPositionMapper: ts.maybeBind(host, host.getDocumentPositionMapper), + getSourceFileLike: ts.maybeBind(host, host.getSourceFileLike), + log: log + }); + function getValidSourceFile(fileName) { + var sourceFile = program.getSourceFile(fileName); + if (!sourceFile) { + var error = new Error("Could not find source file: '".concat(fileName, "'.")); + // We've been having trouble debugging this, so attach sidecar data for the tsserver log. + // See https://github.com/microsoft/TypeScript/issues/30180. + error.ProgramFiles = program.getSourceFiles().map(function (f) { return f.fileName; }); + throw error; + } + return sourceFile; + } + function synchronizeHostData() { + var _a, _b, _c; + ts.Debug.assert(languageServiceMode !== ts.LanguageServiceMode.Syntactic); + // perform fast check if host supports it + if (host.getProjectVersion) { + var hostProjectVersion = host.getProjectVersion(); + if (hostProjectVersion) { + if (lastProjectVersion === hostProjectVersion && !((_a = host.hasChangedAutomaticTypeDirectiveNames) === null || _a === void 0 ? void 0 : _a.call(host))) { + return; + } + lastProjectVersion = hostProjectVersion; + } + } + var typeRootsVersion = host.getTypeRootsVersion ? host.getTypeRootsVersion() : 0; + if (lastTypesRootVersion !== typeRootsVersion) { + log("TypeRoots version has changed; provide new program"); + program = undefined; // TODO: GH#18217 + lastTypesRootVersion = typeRootsVersion; + } + // This array is retained by the program and will be used to determine if the program is up to date, + // so we need to make a copy in case the host mutates the underlying array - otherwise it would look + // like every program always has the host's current list of root files. + var rootFileNames = host.getScriptFileNames().slice(); + // Get a fresh cache of the host information + var newSettings = host.getCompilationSettings() || getDefaultCompilerOptions(); + var hasInvalidatedResolutions = host.hasInvalidatedResolutions || ts.returnFalse; + var hasChangedAutomaticTypeDirectiveNames = ts.maybeBind(host, host.hasChangedAutomaticTypeDirectiveNames); + var projectReferences = (_b = host.getProjectReferences) === null || _b === void 0 ? void 0 : _b.call(host); + var parsedCommandLines; + // Now create a new compiler + var compilerHost = { + getSourceFile: getOrCreateSourceFile, + getSourceFileByPath: getOrCreateSourceFileByPath, + getCancellationToken: function () { return cancellationToken; }, + getCanonicalFileName: getCanonicalFileName, + useCaseSensitiveFileNames: function () { return useCaseSensitiveFileNames; }, + getNewLine: function () { return ts.getNewLineCharacter(newSettings, function () { return ts.getNewLineOrDefaultFromHost(host); }); }, + getDefaultLibFileName: function (options) { return host.getDefaultLibFileName(options); }, + writeFile: ts.noop, + getCurrentDirectory: function () { return currentDirectory; }, + fileExists: function (fileName) { return host.fileExists(fileName); }, + readFile: function (fileName) { return host.readFile && host.readFile(fileName); }, + getSymlinkCache: ts.maybeBind(host, host.getSymlinkCache), + realpath: ts.maybeBind(host, host.realpath), + directoryExists: function (directoryName) { + return ts.directoryProbablyExists(directoryName, host); + }, + getDirectories: function (path) { + return host.getDirectories ? host.getDirectories(path) : []; + }, + readDirectory: function (path, extensions, exclude, include, depth) { + ts.Debug.checkDefined(host.readDirectory, "'LanguageServiceHost.readDirectory' must be implemented to correctly process 'projectReferences'"); + return host.readDirectory(path, extensions, exclude, include, depth); + }, + onReleaseOldSourceFile: onReleaseOldSourceFile, + onReleaseParsedCommandLine: onReleaseParsedCommandLine, + hasInvalidatedResolutions: hasInvalidatedResolutions, + hasChangedAutomaticTypeDirectiveNames: hasChangedAutomaticTypeDirectiveNames, + trace: ts.maybeBind(host, host.trace), + resolveModuleNames: ts.maybeBind(host, host.resolveModuleNames), + getModuleResolutionCache: ts.maybeBind(host, host.getModuleResolutionCache), + resolveTypeReferenceDirectives: ts.maybeBind(host, host.resolveTypeReferenceDirectives), + useSourceOfProjectReferenceRedirect: ts.maybeBind(host, host.useSourceOfProjectReferenceRedirect), + getParsedCommandLine: getParsedCommandLine, + }; + var originalGetSourceFile = compilerHost.getSourceFile; + var getSourceFileWithCache = ts.changeCompilerHostLikeToUseCache(compilerHost, function (fileName) { return ts.toPath(fileName, currentDirectory, getCanonicalFileName); }, function () { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + return originalGetSourceFile.call.apply(originalGetSourceFile, __spreadArray([compilerHost], args, false)); + }).getSourceFileWithCache; + compilerHost.getSourceFile = getSourceFileWithCache; + (_c = host.setCompilerHost) === null || _c === void 0 ? void 0 : _c.call(host, compilerHost); + var parseConfigHost = { + useCaseSensitiveFileNames: useCaseSensitiveFileNames, + fileExists: function (fileName) { return compilerHost.fileExists(fileName); }, + readFile: function (fileName) { return compilerHost.readFile(fileName); }, + readDirectory: function () { + var _a; + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + return (_a = compilerHost).readDirectory.apply(_a, args); + }, + trace: compilerHost.trace, + getCurrentDirectory: compilerHost.getCurrentDirectory, + onUnRecoverableConfigFileDiagnostic: ts.noop, + }; + // The call to isProgramUptoDate below may refer back to documentRegistryBucketKey; + // calculate this early so it's not undefined if downleveled to a var (or, if emitted + // as a const variable without downleveling, doesn't crash). + var documentRegistryBucketKey = documentRegistry.getKeyForCompilationSettings(newSettings); + // If the program is already up-to-date, we can reuse it + if (ts.isProgramUptoDate(program, rootFileNames, newSettings, function (_path, fileName) { return host.getScriptVersion(fileName); }, function (fileName) { return compilerHost.fileExists(fileName); }, hasInvalidatedResolutions, hasChangedAutomaticTypeDirectiveNames, getParsedCommandLine, projectReferences)) { + return; + } + // IMPORTANT - It is critical from this moment onward that we do not check + // cancellation tokens. We are about to mutate source files from a previous program + // instance. If we cancel midway through, we may end up in an inconsistent state where + // the program points to old source files that have been invalidated because of + // incremental parsing. + var options = { + rootNames: rootFileNames, + options: newSettings, + host: compilerHost, + oldProgram: program, + projectReferences: projectReferences + }; + program = ts.createProgram(options); + // 'getOrCreateSourceFile' depends on caching but should be used past this point. + // After this point, the cache needs to be cleared to allow all collected snapshots to be released + compilerHost = undefined; + parsedCommandLines = undefined; + // We reset this cache on structure invalidation so we don't hold on to outdated files for long; however we can't use the `compilerHost` above, + // Because it only functions until `hostCache` is cleared, while we'll potentially need the functionality to lazily read sourcemap files during + // the course of whatever called `synchronizeHostData` + sourceMapper.clearCache(); + // Make sure all the nodes in the program are both bound, and have their parent + // pointers set property. + program.getTypeChecker(); + return; + function getParsedCommandLine(fileName) { + var path = ts.toPath(fileName, currentDirectory, getCanonicalFileName); + var existing = parsedCommandLines === null || parsedCommandLines === void 0 ? void 0 : parsedCommandLines.get(path); + if (existing !== undefined) + return existing || undefined; + var result = host.getParsedCommandLine ? + host.getParsedCommandLine(fileName) : + getParsedCommandLineOfConfigFileUsingSourceFile(fileName); + (parsedCommandLines || (parsedCommandLines = new ts.Map())).set(path, result || false); + return result; + } + function getParsedCommandLineOfConfigFileUsingSourceFile(configFileName) { + var result = getOrCreateSourceFile(configFileName, 100 /* ScriptTarget.JSON */); + if (!result) + return undefined; + result.path = ts.toPath(configFileName, currentDirectory, getCanonicalFileName); + result.resolvedPath = result.path; + result.originalFileName = result.fileName; + return ts.parseJsonSourceFileConfigFileContent(result, parseConfigHost, ts.getNormalizedAbsolutePath(ts.getDirectoryPath(configFileName), currentDirectory), + /*optionsToExtend*/ undefined, ts.getNormalizedAbsolutePath(configFileName, currentDirectory)); + } + function onReleaseParsedCommandLine(configFileName, oldResolvedRef, oldOptions) { + var _a; + if (host.getParsedCommandLine) { + (_a = host.onReleaseParsedCommandLine) === null || _a === void 0 ? void 0 : _a.call(host, configFileName, oldResolvedRef, oldOptions); + } + else if (oldResolvedRef) { + onReleaseOldSourceFile(oldResolvedRef.sourceFile, oldOptions); + } + } + // Release any files we have acquired in the old program but are + // not part of the new program. + function onReleaseOldSourceFile(oldSourceFile, oldOptions) { + var oldSettingsKey = documentRegistry.getKeyForCompilationSettings(oldOptions); + documentRegistry.releaseDocumentWithKey(oldSourceFile.resolvedPath, oldSettingsKey, oldSourceFile.scriptKind, oldSourceFile.impliedNodeFormat); + } + function getOrCreateSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) { + return getOrCreateSourceFileByPath(fileName, ts.toPath(fileName, currentDirectory, getCanonicalFileName), languageVersionOrOptions, onError, shouldCreateNewSourceFile); + } + function getOrCreateSourceFileByPath(fileName, path, languageVersionOrOptions, _onError, shouldCreateNewSourceFile) { + ts.Debug.assert(compilerHost, "getOrCreateSourceFileByPath called after typical CompilerHost lifetime, check the callstack something with a reference to an old host."); + // The program is asking for this file, check first if the host can locate it. + // If the host can not locate the file, then it does not exist. return undefined + // to the program to allow reporting of errors for missing files. + var scriptSnapshot = host.getScriptSnapshot(fileName); + if (!scriptSnapshot) { + return undefined; + } + var scriptKind = ts.getScriptKind(fileName, host); + var scriptVersion = host.getScriptVersion(fileName); + // Check if the language version has changed since we last created a program; if they are the same, + // it is safe to reuse the sourceFiles; if not, then the shape of the AST can change, and the oldSourceFile + // can not be reused. we have to dump all syntax trees and create new ones. + if (!shouldCreateNewSourceFile) { + // Check if the old program had this file already + var oldSourceFile = program && program.getSourceFileByPath(path); + if (oldSourceFile) { + // We already had a source file for this file name. Go to the registry to + // ensure that we get the right up to date version of it. We need this to + // address the following race-condition. Specifically, say we have the following: + // + // LS1 + // \ + // DocumentRegistry + // / + // LS2 + // + // Each LS has a reference to file 'foo.ts' at version 1. LS2 then updates + // it's version of 'foo.ts' to version 2. This will cause LS2 and the + // DocumentRegistry to have version 2 of the document. However, LS1 will + // have version 1. And *importantly* this source file will be *corrupt*. + // The act of creating version 2 of the file irrevocably damages the version + // 1 file. + // + // So, later when we call into LS1, we need to make sure that it doesn't use + // it's source file any more, and instead defers to DocumentRegistry to get + // either version 1, version 2 (or some other version) depending on what the + // host says should be used. + // We do not support the scenario where a host can modify a registered + // file's script kind, i.e. in one project some file is treated as ".ts" + // and in another as ".js" + if (scriptKind === oldSourceFile.scriptKind) { + return documentRegistry.updateDocumentWithKey(fileName, path, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind, languageVersionOrOptions); + } + else { + // Release old source file and fall through to aquire new file with new script kind + documentRegistry.releaseDocumentWithKey(oldSourceFile.resolvedPath, documentRegistry.getKeyForCompilationSettings(program.getCompilerOptions()), oldSourceFile.scriptKind, oldSourceFile.impliedNodeFormat); + } + } + // We didn't already have the file. Fall through and acquire it from the registry. + } + // Could not find this file in the old program, create a new SourceFile for it. + return documentRegistry.acquireDocumentWithKey(fileName, path, host, documentRegistryBucketKey, scriptSnapshot, scriptVersion, scriptKind, languageVersionOrOptions); + } + } + // TODO: GH#18217 frequently asserted as defined + function getProgram() { + if (languageServiceMode === ts.LanguageServiceMode.Syntactic) { + ts.Debug.assert(program === undefined); + return undefined; + } + synchronizeHostData(); + return program; + } + function getAutoImportProvider() { + var _a; + return (_a = host.getPackageJsonAutoImportProvider) === null || _a === void 0 ? void 0 : _a.call(host); + } + function updateIsDefinitionOfReferencedSymbols(referencedSymbols, knownSymbolSpans) { + var checker = program.getTypeChecker(); + var symbol = getSymbolForProgram(); + if (!symbol) + return false; + for (var _i = 0, referencedSymbols_1 = referencedSymbols; _i < referencedSymbols_1.length; _i++) { + var referencedSymbol = referencedSymbols_1[_i]; + for (var _a = 0, _b = referencedSymbol.references; _a < _b.length; _a++) { + var ref = _b[_a]; + var refNode = getNodeForSpan(ref); + ts.Debug.assertIsDefined(refNode); + if (knownSymbolSpans.has(ref) || ts.FindAllReferences.isDeclarationOfSymbol(refNode, symbol)) { + knownSymbolSpans.add(ref); + ref.isDefinition = true; + var mappedSpan = ts.getMappedDocumentSpan(ref, sourceMapper, ts.maybeBind(host, host.fileExists)); + if (mappedSpan) { + knownSymbolSpans.add(mappedSpan); + } + } + else { + ref.isDefinition = false; + } + } + } + return true; + function getSymbolForProgram() { + for (var _i = 0, referencedSymbols_2 = referencedSymbols; _i < referencedSymbols_2.length; _i++) { + var referencedSymbol = referencedSymbols_2[_i]; + for (var _a = 0, _b = referencedSymbol.references; _a < _b.length; _a++) { + var ref = _b[_a]; + if (knownSymbolSpans.has(ref)) { + var refNode = getNodeForSpan(ref); + ts.Debug.assertIsDefined(refNode); + return checker.getSymbolAtLocation(refNode); + } + var mappedSpan = ts.getMappedDocumentSpan(ref, sourceMapper, ts.maybeBind(host, host.fileExists)); + if (mappedSpan && knownSymbolSpans.has(mappedSpan)) { + var refNode = getNodeForSpan(mappedSpan); + if (refNode) { + return checker.getSymbolAtLocation(refNode); + } + } + } + } + return undefined; + } + function getNodeForSpan(docSpan) { + var sourceFile = program.getSourceFile(docSpan.fileName); + if (!sourceFile) + return undefined; + var rawNode = ts.getTouchingPropertyName(sourceFile, docSpan.textSpan.start); + var adjustedNode = ts.FindAllReferences.Core.getAdjustedNode(rawNode, { use: 1 /* FindAllReferences.FindReferencesUse.References */ }); + return adjustedNode; + } + } + function cleanupSemanticCache() { + program = undefined; // TODO: GH#18217 + } + function dispose() { + if (program) { + // Use paths to ensure we are using correct key and paths as document registry could be created with different current directory than host + var key_1 = documentRegistry.getKeyForCompilationSettings(program.getCompilerOptions()); + ts.forEach(program.getSourceFiles(), function (f) { + return documentRegistry.releaseDocumentWithKey(f.resolvedPath, key_1, f.scriptKind, f.impliedNodeFormat); + }); + program = undefined; // TODO: GH#18217 + } + host = undefined; + } + /// Diagnostics + function getSyntacticDiagnostics(fileName) { + synchronizeHostData(); + return program.getSyntacticDiagnostics(getValidSourceFile(fileName), cancellationToken).slice(); + } + /** + * getSemanticDiagnostics return array of Diagnostics. If '-d' is not enabled, only report semantic errors + * If '-d' enabled, report both semantic and emitter errors + */ + function getSemanticDiagnostics(fileName) { + synchronizeHostData(); + var targetSourceFile = getValidSourceFile(fileName); + // Only perform the action per file regardless of '-out' flag as LanguageServiceHost is expected to call this function per file. + // Therefore only get diagnostics for given file. + var semanticDiagnostics = program.getSemanticDiagnostics(targetSourceFile, cancellationToken); + if (!ts.getEmitDeclarations(program.getCompilerOptions())) { + return semanticDiagnostics.slice(); + } + // If '-d' is enabled, check for emitter error. One example of emitter error is export class implements non-export interface + var declarationDiagnostics = program.getDeclarationDiagnostics(targetSourceFile, cancellationToken); + return __spreadArray(__spreadArray([], semanticDiagnostics, true), declarationDiagnostics, true); + } + function getSuggestionDiagnostics(fileName) { + synchronizeHostData(); + return ts.computeSuggestionDiagnostics(getValidSourceFile(fileName), program, cancellationToken); + } + function getCompilerOptionsDiagnostics() { + synchronizeHostData(); + return __spreadArray(__spreadArray([], program.getOptionsDiagnostics(cancellationToken), true), program.getGlobalDiagnostics(cancellationToken), true); + } + function getCompletionsAtPosition(fileName, position, options, formattingSettings) { + if (options === void 0) { options = ts.emptyOptions; } + // Convert from deprecated options names to new names + var fullPreferences = __assign(__assign({}, ts.identity(options)), { includeCompletionsForModuleExports: options.includeCompletionsForModuleExports || options.includeExternalModuleExports, includeCompletionsWithInsertText: options.includeCompletionsWithInsertText || options.includeInsertTextCompletions }); + synchronizeHostData(); + return ts.Completions.getCompletionsAtPosition(host, program, log, getValidSourceFile(fileName), position, fullPreferences, options.triggerCharacter, options.triggerKind, cancellationToken, formattingSettings && ts.formatting.getFormatContext(formattingSettings, host)); + } + function getCompletionEntryDetails(fileName, position, name, formattingOptions, source, preferences, data) { + if (preferences === void 0) { preferences = ts.emptyOptions; } + synchronizeHostData(); + return ts.Completions.getCompletionEntryDetails(program, log, getValidSourceFile(fileName), position, { name: name, source: source, data: data }, host, (formattingOptions && ts.formatting.getFormatContext(formattingOptions, host)), // TODO: GH#18217 + preferences, cancellationToken); + } + function getCompletionEntrySymbol(fileName, position, name, source, preferences) { + if (preferences === void 0) { preferences = ts.emptyOptions; } + synchronizeHostData(); + return ts.Completions.getCompletionEntrySymbol(program, log, getValidSourceFile(fileName), position, { name: name, source: source }, host, preferences); + } + function getQuickInfoAtPosition(fileName, position) { + synchronizeHostData(); + var sourceFile = getValidSourceFile(fileName); + var node = ts.getTouchingPropertyName(sourceFile, position); + if (node === sourceFile) { + // Avoid giving quickInfo for the sourceFile as a whole. + return undefined; + } + var typeChecker = program.getTypeChecker(); + var nodeForQuickInfo = getNodeForQuickInfo(node); + var symbol = getSymbolAtLocationForQuickInfo(nodeForQuickInfo, typeChecker); + if (!symbol || typeChecker.isUnknownSymbol(symbol)) { + var type_2 = shouldGetType(sourceFile, nodeForQuickInfo, position) ? typeChecker.getTypeAtLocation(nodeForQuickInfo) : undefined; + return type_2 && { + kind: "" /* ScriptElementKind.unknown */, + kindModifiers: "" /* ScriptElementKindModifier.none */, + textSpan: ts.createTextSpanFromNode(nodeForQuickInfo, sourceFile), + displayParts: typeChecker.runWithCancellationToken(cancellationToken, function (typeChecker) { return ts.typeToDisplayParts(typeChecker, type_2, ts.getContainerNode(nodeForQuickInfo)); }), + documentation: type_2.symbol ? type_2.symbol.getDocumentationComment(typeChecker) : undefined, + tags: type_2.symbol ? type_2.symbol.getJsDocTags(typeChecker) : undefined + }; + } + var _a = typeChecker.runWithCancellationToken(cancellationToken, function (typeChecker) { + return ts.SymbolDisplay.getSymbolDisplayPartsDocumentationAndSymbolKind(typeChecker, symbol, sourceFile, ts.getContainerNode(nodeForQuickInfo), nodeForQuickInfo); + }), symbolKind = _a.symbolKind, displayParts = _a.displayParts, documentation = _a.documentation, tags = _a.tags; + return { + kind: symbolKind, + kindModifiers: ts.SymbolDisplay.getSymbolModifiers(typeChecker, symbol), + textSpan: ts.createTextSpanFromNode(nodeForQuickInfo, sourceFile), + displayParts: displayParts, + documentation: documentation, + tags: tags, + }; + } + function getNodeForQuickInfo(node) { + if (ts.isNewExpression(node.parent) && node.pos === node.parent.pos) { + return node.parent.expression; + } + if (ts.isNamedTupleMember(node.parent) && node.pos === node.parent.pos) { + return node.parent; + } + if (ts.isImportMeta(node.parent) && node.parent.name === node) { + return node.parent; + } + return node; + } + function shouldGetType(sourceFile, node, position) { + switch (node.kind) { + case 79 /* SyntaxKind.Identifier */: + return !ts.isLabelName(node) && !ts.isTagName(node) && !ts.isConstTypeReference(node.parent); + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 163 /* SyntaxKind.QualifiedName */: + // Don't return quickInfo if inside the comment in `a/**/.b` + return !ts.isInComment(sourceFile, position); + case 108 /* SyntaxKind.ThisKeyword */: + case 194 /* SyntaxKind.ThisType */: + case 106 /* SyntaxKind.SuperKeyword */: + case 199 /* SyntaxKind.NamedTupleMember */: + return true; + case 233 /* SyntaxKind.MetaProperty */: + return ts.isImportMeta(node); + default: + return false; + } + } + /// Goto definition + function getDefinitionAtPosition(fileName, position, searchOtherFilesOnly, stopAtAlias) { + synchronizeHostData(); + return ts.GoToDefinition.getDefinitionAtPosition(program, getValidSourceFile(fileName), position, searchOtherFilesOnly, stopAtAlias); + } + function getDefinitionAndBoundSpan(fileName, position) { + synchronizeHostData(); + return ts.GoToDefinition.getDefinitionAndBoundSpan(program, getValidSourceFile(fileName), position); + } + function getTypeDefinitionAtPosition(fileName, position) { + synchronizeHostData(); + return ts.GoToDefinition.getTypeDefinitionAtPosition(program.getTypeChecker(), getValidSourceFile(fileName), position); + } + /// Goto implementation + function getImplementationAtPosition(fileName, position) { + synchronizeHostData(); + return ts.FindAllReferences.getImplementationsAtPosition(program, cancellationToken, program.getSourceFiles(), getValidSourceFile(fileName), position); + } + /// References and Occurrences + function getOccurrencesAtPosition(fileName, position) { + return ts.flatMap(getDocumentHighlights(fileName, position, [fileName]), function (entry) { return entry.highlightSpans.map(function (highlightSpan) { return (__assign(__assign({ fileName: entry.fileName, textSpan: highlightSpan.textSpan, isWriteAccess: highlightSpan.kind === "writtenReference" /* HighlightSpanKind.writtenReference */ }, highlightSpan.isInString && { isInString: true }), highlightSpan.contextSpan && { contextSpan: highlightSpan.contextSpan })); }); }); + } + function getDocumentHighlights(fileName, position, filesToSearch) { + var normalizedFileName = ts.normalizePath(fileName); + ts.Debug.assert(filesToSearch.some(function (f) { return ts.normalizePath(f) === normalizedFileName; })); + synchronizeHostData(); + var sourceFilesToSearch = ts.mapDefined(filesToSearch, function (fileName) { return program.getSourceFile(fileName); }); + var sourceFile = getValidSourceFile(fileName); + return ts.DocumentHighlights.getDocumentHighlights(program, cancellationToken, sourceFile, position, sourceFilesToSearch); + } + function findRenameLocations(fileName, position, findInStrings, findInComments, providePrefixAndSuffixTextForRename) { + synchronizeHostData(); + var sourceFile = getValidSourceFile(fileName); + var node = ts.getAdjustedRenameLocation(ts.getTouchingPropertyName(sourceFile, position)); + if (!ts.Rename.nodeIsEligibleForRename(node)) + return undefined; + if (ts.isIdentifier(node) && (ts.isJsxOpeningElement(node.parent) || ts.isJsxClosingElement(node.parent)) && ts.isIntrinsicJsxName(node.escapedText)) { + var _a = node.parent.parent, openingElement = _a.openingElement, closingElement = _a.closingElement; + return [openingElement, closingElement].map(function (node) { + var textSpan = ts.createTextSpanFromNode(node.tagName, sourceFile); + return __assign({ fileName: sourceFile.fileName, textSpan: textSpan }, ts.FindAllReferences.toContextSpan(textSpan, sourceFile, node.parent)); + }); + } + else { + return getReferencesWorker(node, position, { findInStrings: findInStrings, findInComments: findInComments, providePrefixAndSuffixTextForRename: providePrefixAndSuffixTextForRename, use: 2 /* FindAllReferences.FindReferencesUse.Rename */ }, function (entry, originalNode, checker) { return ts.FindAllReferences.toRenameLocation(entry, originalNode, checker, providePrefixAndSuffixTextForRename || false); }); + } + } + function getReferencesAtPosition(fileName, position) { + synchronizeHostData(); + return getReferencesWorker(ts.getTouchingPropertyName(getValidSourceFile(fileName), position), position, { use: 1 /* FindAllReferences.FindReferencesUse.References */ }, ts.FindAllReferences.toReferenceEntry); + } + function getReferencesWorker(node, position, options, cb) { + synchronizeHostData(); + // Exclude default library when renaming as commonly user don't want to change that file. + var sourceFiles = options && options.use === 2 /* FindAllReferences.FindReferencesUse.Rename */ + ? program.getSourceFiles().filter(function (sourceFile) { return !program.isSourceFileDefaultLibrary(sourceFile); }) + : program.getSourceFiles(); + return ts.FindAllReferences.findReferenceOrRenameEntries(program, cancellationToken, sourceFiles, node, position, options, cb); + } + function findReferences(fileName, position) { + synchronizeHostData(); + return ts.FindAllReferences.findReferencedSymbols(program, cancellationToken, program.getSourceFiles(), getValidSourceFile(fileName), position); + } + function getFileReferences(fileName) { + synchronizeHostData(); + return ts.FindAllReferences.Core.getReferencesForFileName(fileName, program, program.getSourceFiles()).map(ts.FindAllReferences.toReferenceEntry); + } + function getNavigateToItems(searchValue, maxResultCount, fileName, excludeDtsFiles) { + if (excludeDtsFiles === void 0) { excludeDtsFiles = false; } + synchronizeHostData(); + var sourceFiles = fileName ? [getValidSourceFile(fileName)] : program.getSourceFiles(); + return ts.NavigateTo.getNavigateToItems(sourceFiles, program.getTypeChecker(), cancellationToken, searchValue, maxResultCount, excludeDtsFiles); + } + function getEmitOutput(fileName, emitOnlyDtsFiles, forceDtsEmit) { + synchronizeHostData(); + var sourceFile = getValidSourceFile(fileName); + var customTransformers = host.getCustomTransformers && host.getCustomTransformers(); + return ts.getFileEmitOutput(program, sourceFile, !!emitOnlyDtsFiles, cancellationToken, customTransformers, forceDtsEmit); + } + // Signature help + /** + * This is a semantic operation. + */ + function getSignatureHelpItems(fileName, position, _a) { + var _b = _a === void 0 ? ts.emptyOptions : _a, triggerReason = _b.triggerReason; + synchronizeHostData(); + var sourceFile = getValidSourceFile(fileName); + return ts.SignatureHelp.getSignatureHelpItems(program, sourceFile, position, triggerReason, cancellationToken); + } + /// Syntactic features + function getNonBoundSourceFile(fileName) { + return syntaxTreeCache.getCurrentSourceFile(fileName); + } + function getNameOrDottedNameSpan(fileName, startPos, _endPos) { + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + // Get node at the location + var node = ts.getTouchingPropertyName(sourceFile, startPos); + if (node === sourceFile) { + return undefined; + } + switch (node.kind) { + case 208 /* SyntaxKind.PropertyAccessExpression */: + case 163 /* SyntaxKind.QualifiedName */: + case 10 /* SyntaxKind.StringLiteral */: + case 95 /* SyntaxKind.FalseKeyword */: + case 110 /* SyntaxKind.TrueKeyword */: + case 104 /* SyntaxKind.NullKeyword */: + case 106 /* SyntaxKind.SuperKeyword */: + case 108 /* SyntaxKind.ThisKeyword */: + case 194 /* SyntaxKind.ThisType */: + case 79 /* SyntaxKind.Identifier */: + break; + // Cant create the text span + default: + return undefined; + } + var nodeForStartPos = node; + while (true) { + if (ts.isRightSideOfPropertyAccess(nodeForStartPos) || ts.isRightSideOfQualifiedName(nodeForStartPos)) { + // If on the span is in right side of the the property or qualified name, return the span from the qualified name pos to end of this node + nodeForStartPos = nodeForStartPos.parent; + } + else if (ts.isNameOfModuleDeclaration(nodeForStartPos)) { + // If this is name of a module declarations, check if this is right side of dotted module name + // If parent of the module declaration which is parent of this node is module declaration and its body is the module declaration that this node is name of + // Then this name is name from dotted module + if (nodeForStartPos.parent.parent.kind === 264 /* SyntaxKind.ModuleDeclaration */ && + nodeForStartPos.parent.parent.body === nodeForStartPos.parent) { + // Use parent module declarations name for start pos + nodeForStartPos = nodeForStartPos.parent.parent.name; + } + else { + // We have to use this name for start pos + break; + } + } + else { + // Is not a member expression so we have found the node for start pos + break; + } + } + return ts.createTextSpanFromBounds(nodeForStartPos.getStart(), node.getEnd()); + } + function getBreakpointStatementAtPosition(fileName, position) { + // doesn't use compiler - no need to synchronize with host + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + return ts.BreakpointResolver.spanInSourceFileAtLocation(sourceFile, position); + } + function getNavigationBarItems(fileName) { + return ts.NavigationBar.getNavigationBarItems(syntaxTreeCache.getCurrentSourceFile(fileName), cancellationToken); + } + function getNavigationTree(fileName) { + return ts.NavigationBar.getNavigationTree(syntaxTreeCache.getCurrentSourceFile(fileName), cancellationToken); + } + function getSemanticClassifications(fileName, span, format) { + synchronizeHostData(); + var responseFormat = format || "original" /* SemanticClassificationFormat.Original */; + if (responseFormat === "2020" /* SemanticClassificationFormat.TwentyTwenty */) { + return ts.classifier.v2020.getSemanticClassifications(program, cancellationToken, getValidSourceFile(fileName), span); + } + else { + return ts.getSemanticClassifications(program.getTypeChecker(), cancellationToken, getValidSourceFile(fileName), program.getClassifiableNames(), span); + } + } + function getEncodedSemanticClassifications(fileName, span, format) { + synchronizeHostData(); + var responseFormat = format || "original" /* SemanticClassificationFormat.Original */; + if (responseFormat === "original" /* SemanticClassificationFormat.Original */) { + return ts.getEncodedSemanticClassifications(program.getTypeChecker(), cancellationToken, getValidSourceFile(fileName), program.getClassifiableNames(), span); + } + else { + return ts.classifier.v2020.getEncodedSemanticClassifications(program, cancellationToken, getValidSourceFile(fileName), span); + } + } + function getSyntacticClassifications(fileName, span) { + // doesn't use compiler - no need to synchronize with host + return ts.getSyntacticClassifications(cancellationToken, syntaxTreeCache.getCurrentSourceFile(fileName), span); + } + function getEncodedSyntacticClassifications(fileName, span) { + // doesn't use compiler - no need to synchronize with host + return ts.getEncodedSyntacticClassifications(cancellationToken, syntaxTreeCache.getCurrentSourceFile(fileName), span); + } + function getOutliningSpans(fileName) { + // doesn't use compiler - no need to synchronize with host + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + return ts.OutliningElementsCollector.collectElements(sourceFile, cancellationToken); + } + var braceMatching = new ts.Map(ts.getEntries((_a = {}, + _a[18 /* SyntaxKind.OpenBraceToken */] = 19 /* SyntaxKind.CloseBraceToken */, + _a[20 /* SyntaxKind.OpenParenToken */] = 21 /* SyntaxKind.CloseParenToken */, + _a[22 /* SyntaxKind.OpenBracketToken */] = 23 /* SyntaxKind.CloseBracketToken */, + _a[31 /* SyntaxKind.GreaterThanToken */] = 29 /* SyntaxKind.LessThanToken */, + _a))); + braceMatching.forEach(function (value, key) { return braceMatching.set(value.toString(), Number(key)); }); + function getBraceMatchingAtPosition(fileName, position) { + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + var token = ts.getTouchingToken(sourceFile, position); + var matchKind = token.getStart(sourceFile) === position ? braceMatching.get(token.kind.toString()) : undefined; + var match = matchKind && ts.findChildOfKind(token.parent, matchKind, sourceFile); + // We want to order the braces when we return the result. + return match ? [ts.createTextSpanFromNode(token, sourceFile), ts.createTextSpanFromNode(match, sourceFile)].sort(function (a, b) { return a.start - b.start; }) : ts.emptyArray; + } + function getIndentationAtPosition(fileName, position, editorOptions) { + var start = ts.timestamp(); + var settings = toEditorSettings(editorOptions); + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + log("getIndentationAtPosition: getCurrentSourceFile: " + (ts.timestamp() - start)); + start = ts.timestamp(); + var result = ts.formatting.SmartIndenter.getIndentation(position, sourceFile, settings); + log("getIndentationAtPosition: computeIndentation : " + (ts.timestamp() - start)); + return result; + } + function getFormattingEditsForRange(fileName, start, end, options) { + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + return ts.formatting.formatSelection(start, end, sourceFile, ts.formatting.getFormatContext(toEditorSettings(options), host)); + } + function getFormattingEditsForDocument(fileName, options) { + return ts.formatting.formatDocument(syntaxTreeCache.getCurrentSourceFile(fileName), ts.formatting.getFormatContext(toEditorSettings(options), host)); + } + function getFormattingEditsAfterKeystroke(fileName, position, key, options) { + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + var formatContext = ts.formatting.getFormatContext(toEditorSettings(options), host); + if (!ts.isInComment(sourceFile, position)) { + switch (key) { + case "{": + return ts.formatting.formatOnOpeningCurly(position, sourceFile, formatContext); + case "}": + return ts.formatting.formatOnClosingCurly(position, sourceFile, formatContext); + case ";": + return ts.formatting.formatOnSemicolon(position, sourceFile, formatContext); + case "\n": + return ts.formatting.formatOnEnter(position, sourceFile, formatContext); + } + } + return []; + } + function getCodeFixesAtPosition(fileName, start, end, errorCodes, formatOptions, preferences) { + if (preferences === void 0) { preferences = ts.emptyOptions; } + synchronizeHostData(); + var sourceFile = getValidSourceFile(fileName); + var span = ts.createTextSpanFromBounds(start, end); + var formatContext = ts.formatting.getFormatContext(formatOptions, host); + return ts.flatMap(ts.deduplicate(errorCodes, ts.equateValues, ts.compareValues), function (errorCode) { + cancellationToken.throwIfCancellationRequested(); + return ts.codefix.getFixes({ errorCode: errorCode, sourceFile: sourceFile, span: span, program: program, host: host, cancellationToken: cancellationToken, formatContext: formatContext, preferences: preferences }); + }); + } + function getCombinedCodeFix(scope, fixId, formatOptions, preferences) { + if (preferences === void 0) { preferences = ts.emptyOptions; } + synchronizeHostData(); + ts.Debug.assert(scope.type === "file"); + var sourceFile = getValidSourceFile(scope.fileName); + var formatContext = ts.formatting.getFormatContext(formatOptions, host); + return ts.codefix.getAllFixes({ fixId: fixId, sourceFile: sourceFile, program: program, host: host, cancellationToken: cancellationToken, formatContext: formatContext, preferences: preferences }); + } + function organizeImports(args, formatOptions, preferences) { + var _a; + if (preferences === void 0) { preferences = ts.emptyOptions; } + synchronizeHostData(); + ts.Debug.assert(args.type === "file"); + var sourceFile = getValidSourceFile(args.fileName); + var formatContext = ts.formatting.getFormatContext(formatOptions, host); + var mode = (_a = args.mode) !== null && _a !== void 0 ? _a : (args.skipDestructiveCodeActions ? "SortAndCombine" /* OrganizeImportsMode.SortAndCombine */ : "All" /* OrganizeImportsMode.All */); + return ts.OrganizeImports.organizeImports(sourceFile, formatContext, host, program, preferences, mode); + } + function getEditsForFileRename(oldFilePath, newFilePath, formatOptions, preferences) { + if (preferences === void 0) { preferences = ts.emptyOptions; } + return ts.getEditsForFileRename(getProgram(), oldFilePath, newFilePath, host, ts.formatting.getFormatContext(formatOptions, host), preferences, sourceMapper); + } + function applyCodeActionCommand(fileName, actionOrFormatSettingsOrUndefined) { + var action = typeof fileName === "string" ? actionOrFormatSettingsOrUndefined : fileName; + return ts.isArray(action) ? Promise.all(action.map(function (a) { return applySingleCodeActionCommand(a); })) : applySingleCodeActionCommand(action); + } + function applySingleCodeActionCommand(action) { + var getPath = function (path) { return ts.toPath(path, currentDirectory, getCanonicalFileName); }; + ts.Debug.assertEqual(action.type, "install package"); + return host.installPackage + ? host.installPackage({ fileName: getPath(action.file), packageName: action.packageName }) + : Promise.reject("Host does not implement `installPackage`"); + } + function getDocCommentTemplateAtPosition(fileName, position, options) { + return ts.JsDoc.getDocCommentTemplateAtPosition(ts.getNewLineOrDefaultFromHost(host), syntaxTreeCache.getCurrentSourceFile(fileName), position, options); + } + function isValidBraceCompletionAtPosition(fileName, position, openingBrace) { + // '<' is currently not supported, figuring out if we're in a Generic Type vs. a comparison is too + // expensive to do during typing scenarios + // i.e. whether we're dealing with: + // var x = new foo<| ( with class foo{} ) + // or + // var y = 3 <| + if (openingBrace === 60 /* CharacterCodes.lessThan */) { + return false; + } + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + // Check if in a context where we don't want to perform any insertion + if (ts.isInString(sourceFile, position)) { + return false; + } + if (ts.isInsideJsxElementOrAttribute(sourceFile, position)) { + return openingBrace === 123 /* CharacterCodes.openBrace */; + } + if (ts.isInTemplateString(sourceFile, position)) { + return false; + } + switch (openingBrace) { + case 39 /* CharacterCodes.singleQuote */: + case 34 /* CharacterCodes.doubleQuote */: + case 96 /* CharacterCodes.backtick */: + return !ts.isInComment(sourceFile, position); + } + return true; + } + function getJsxClosingTagAtPosition(fileName, position) { + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + var token = ts.findPrecedingToken(position, sourceFile); + if (!token) + return undefined; + var element = token.kind === 31 /* SyntaxKind.GreaterThanToken */ && ts.isJsxOpeningElement(token.parent) ? token.parent.parent + : ts.isJsxText(token) && ts.isJsxElement(token.parent) ? token.parent : undefined; + if (element && isUnclosedTag(element)) { + return { newText: "") }; + } + var fragment = token.kind === 31 /* SyntaxKind.GreaterThanToken */ && ts.isJsxOpeningFragment(token.parent) ? token.parent.parent + : ts.isJsxText(token) && ts.isJsxFragment(token.parent) ? token.parent : undefined; + if (fragment && isUnclosedFragment(fragment)) { + return { newText: "" }; + } + } + function getLinesForRange(sourceFile, textRange) { + return { + lineStarts: sourceFile.getLineStarts(), + firstLine: sourceFile.getLineAndCharacterOfPosition(textRange.pos).line, + lastLine: sourceFile.getLineAndCharacterOfPosition(textRange.end).line + }; + } + function toggleLineComment(fileName, textRange, insertComment) { + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + var textChanges = []; + var _a = getLinesForRange(sourceFile, textRange), lineStarts = _a.lineStarts, firstLine = _a.firstLine, lastLine = _a.lastLine; + var isCommenting = insertComment || false; + var leftMostPosition = Number.MAX_VALUE; + var lineTextStarts = new ts.Map(); + var firstNonWhitespaceCharacterRegex = new RegExp(/\S/); + var isJsx = ts.isInsideJsxElement(sourceFile, lineStarts[firstLine]); + var openComment = isJsx ? "{/*" : "//"; + // Check each line before any text changes. + for (var i = firstLine; i <= lastLine; i++) { + var lineText = sourceFile.text.substring(lineStarts[i], sourceFile.getLineEndOfPosition(lineStarts[i])); + // Find the start of text and the left-most character. No-op on empty lines. + var regExec = firstNonWhitespaceCharacterRegex.exec(lineText); + if (regExec) { + leftMostPosition = Math.min(leftMostPosition, regExec.index); + lineTextStarts.set(i.toString(), regExec.index); + if (lineText.substr(regExec.index, openComment.length) !== openComment) { + isCommenting = insertComment === undefined || insertComment; + } + } + } + // Push all text changes. + for (var i = firstLine; i <= lastLine; i++) { + // If the range is multiline and ends on a beginning of a line, don't comment/uncomment. + if (firstLine !== lastLine && lineStarts[i] === textRange.end) { + continue; + } + var lineTextStart = lineTextStarts.get(i.toString()); + // If the line is not an empty line; otherwise no-op. + if (lineTextStart !== undefined) { + if (isJsx) { + textChanges.push.apply(textChanges, toggleMultilineComment(fileName, { pos: lineStarts[i] + leftMostPosition, end: sourceFile.getLineEndOfPosition(lineStarts[i]) }, isCommenting, isJsx)); + } + else if (isCommenting) { + textChanges.push({ + newText: openComment, + span: { + length: 0, + start: lineStarts[i] + leftMostPosition + } + }); + } + else if (sourceFile.text.substr(lineStarts[i] + lineTextStart, openComment.length) === openComment) { + textChanges.push({ + newText: "", + span: { + length: openComment.length, + start: lineStarts[i] + lineTextStart + } + }); + } + } + } + return textChanges; + } + function toggleMultilineComment(fileName, textRange, insertComment, isInsideJsx) { + var _a; + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + var textChanges = []; + var text = sourceFile.text; + var hasComment = false; + var isCommenting = insertComment || false; + var positions = []; + var pos = textRange.pos; + var isJsx = isInsideJsx !== undefined ? isInsideJsx : ts.isInsideJsxElement(sourceFile, pos); + var openMultiline = isJsx ? "{/*" : "/*"; + var closeMultiline = isJsx ? "*/}" : "*/"; + var openMultilineRegex = isJsx ? "\\{\\/\\*" : "\\/\\*"; + var closeMultilineRegex = isJsx ? "\\*\\/\\}" : "\\*\\/"; + // Get all comment positions + while (pos <= textRange.end) { + // Start of comment is considered inside comment. + var offset = text.substr(pos, openMultiline.length) === openMultiline ? openMultiline.length : 0; + var commentRange = ts.isInComment(sourceFile, pos + offset); + // If position is in a comment add it to the positions array. + if (commentRange) { + // Comment range doesn't include the brace character. Increase it to include them. + if (isJsx) { + commentRange.pos--; + commentRange.end++; + } + positions.push(commentRange.pos); + if (commentRange.kind === 3 /* SyntaxKind.MultiLineCommentTrivia */) { + positions.push(commentRange.end); + } + hasComment = true; + pos = commentRange.end + 1; + } + else { // If it's not in a comment range, then we need to comment the uncommented portions. + var newPos = text.substring(pos, textRange.end).search("(".concat(openMultilineRegex, ")|(").concat(closeMultilineRegex, ")")); + isCommenting = insertComment !== undefined + ? insertComment + : isCommenting || !ts.isTextWhiteSpaceLike(text, pos, newPos === -1 ? textRange.end : pos + newPos); // If isCommenting is already true we don't need to check whitespace again. + pos = newPos === -1 ? textRange.end + 1 : pos + newPos + closeMultiline.length; + } + } + // If it didn't found a comment and isCommenting is false means is only empty space. + // We want to insert comment in this scenario. + if (isCommenting || !hasComment) { + if (((_a = ts.isInComment(sourceFile, textRange.pos)) === null || _a === void 0 ? void 0 : _a.kind) !== 2 /* SyntaxKind.SingleLineCommentTrivia */) { + ts.insertSorted(positions, textRange.pos, ts.compareValues); + } + ts.insertSorted(positions, textRange.end, ts.compareValues); + // Insert open comment if the first position is not a comment already. + var firstPos = positions[0]; + if (text.substr(firstPos, openMultiline.length) !== openMultiline) { + textChanges.push({ + newText: openMultiline, + span: { + length: 0, + start: firstPos + } + }); + } + // Insert open and close comment to all positions between first and last. Exclusive. + for (var i = 1; i < positions.length - 1; i++) { + if (text.substr(positions[i] - closeMultiline.length, closeMultiline.length) !== closeMultiline) { + textChanges.push({ + newText: closeMultiline, + span: { + length: 0, + start: positions[i] + } + }); + } + if (text.substr(positions[i], openMultiline.length) !== openMultiline) { + textChanges.push({ + newText: openMultiline, + span: { + length: 0, + start: positions[i] + } + }); + } + } + // Insert open comment if the last position is not a comment already. + if (textChanges.length % 2 !== 0) { + textChanges.push({ + newText: closeMultiline, + span: { + length: 0, + start: positions[positions.length - 1] + } + }); + } + } + else { + // If is not commenting then remove all comments found. + for (var _i = 0, positions_1 = positions; _i < positions_1.length; _i++) { + var pos_2 = positions_1[_i]; + var from = pos_2 - closeMultiline.length > 0 ? pos_2 - closeMultiline.length : 0; + var offset = text.substr(from, closeMultiline.length) === closeMultiline ? closeMultiline.length : 0; + textChanges.push({ + newText: "", + span: { + length: openMultiline.length, + start: pos_2 - offset + } + }); + } + } + return textChanges; + } + function commentSelection(fileName, textRange) { + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + var _a = getLinesForRange(sourceFile, textRange), firstLine = _a.firstLine, lastLine = _a.lastLine; + // If there is a selection that is on the same line, add multiline. + return firstLine === lastLine && textRange.pos !== textRange.end + ? toggleMultilineComment(fileName, textRange, /*insertComment*/ true) + : toggleLineComment(fileName, textRange, /*insertComment*/ true); + } + function uncommentSelection(fileName, textRange) { + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + var textChanges = []; + var pos = textRange.pos; + var end = textRange.end; + // If cursor is not a selection we need to increase the end position + // to include the start of the comment. + if (pos === end) { + end += ts.isInsideJsxElement(sourceFile, pos) ? 2 : 1; + } + for (var i = pos; i <= end; i++) { + var commentRange = ts.isInComment(sourceFile, i); + if (commentRange) { + switch (commentRange.kind) { + case 2 /* SyntaxKind.SingleLineCommentTrivia */: + textChanges.push.apply(textChanges, toggleLineComment(fileName, { end: commentRange.end, pos: commentRange.pos + 1 }, /*insertComment*/ false)); + break; + case 3 /* SyntaxKind.MultiLineCommentTrivia */: + textChanges.push.apply(textChanges, toggleMultilineComment(fileName, { end: commentRange.end, pos: commentRange.pos + 1 }, /*insertComment*/ false)); + } + i = commentRange.end + 1; + } + } + return textChanges; + } + function isUnclosedTag(_a) { + var openingElement = _a.openingElement, closingElement = _a.closingElement, parent = _a.parent; + return !ts.tagNamesAreEquivalent(openingElement.tagName, closingElement.tagName) || + ts.isJsxElement(parent) && ts.tagNamesAreEquivalent(openingElement.tagName, parent.openingElement.tagName) && isUnclosedTag(parent); + } + function isUnclosedFragment(_a) { + var closingFragment = _a.closingFragment, parent = _a.parent; + return !!(closingFragment.flags & 131072 /* NodeFlags.ThisNodeHasError */) || (ts.isJsxFragment(parent) && isUnclosedFragment(parent)); + } + function getSpanOfEnclosingComment(fileName, position, onlyMultiLine) { + var sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); + var range = ts.formatting.getRangeOfEnclosingComment(sourceFile, position); + return range && (!onlyMultiLine || range.kind === 3 /* SyntaxKind.MultiLineCommentTrivia */) ? ts.createTextSpanFromRange(range) : undefined; + } + function getTodoComments(fileName, descriptors) { + // Note: while getting todo comments seems like a syntactic operation, we actually + // treat it as a semantic operation here. This is because we expect our host to call + // this on every single file. If we treat this syntactically, then that will cause + // us to populate and throw away the tree in our syntax tree cache for each file. By + // treating this as a semantic operation, we can access any tree without throwing + // anything away. + synchronizeHostData(); + var sourceFile = getValidSourceFile(fileName); + cancellationToken.throwIfCancellationRequested(); + var fileContents = sourceFile.text; + var result = []; + // Exclude node_modules files as we don't want to show the todos of external libraries. + if (descriptors.length > 0 && !isNodeModulesFile(sourceFile.fileName)) { + var regExp = getTodoCommentsRegExp(); + var matchArray = void 0; + while (matchArray = regExp.exec(fileContents)) { + cancellationToken.throwIfCancellationRequested(); + // If we got a match, here is what the match array will look like. Say the source text is: + // + // " // hack 1" + // + // The result array with the regexp: will be: + // + // ["// hack 1", "// ", "hack 1", undefined, "hack"] + // + // Here are the relevant capture groups: + // 0) The full match for the entire regexp. + // 1) The preamble to the message portion. + // 2) The message portion. + // 3...N) The descriptor that was matched - by index. 'undefined' for each + // descriptor that didn't match. an actual value if it did match. + // + // i.e. 'undefined' in position 3 above means TODO(jason) didn't match. + // "hack" in position 4 means HACK did match. + var firstDescriptorCaptureIndex = 3; + ts.Debug.assert(matchArray.length === descriptors.length + firstDescriptorCaptureIndex); + var preamble = matchArray[1]; + var matchPosition = matchArray.index + preamble.length; + // OK, we have found a match in the file. This is only an acceptable match if + // it is contained within a comment. + if (!ts.isInComment(sourceFile, matchPosition)) { + continue; + } + var descriptor = void 0; + for (var i = 0; i < descriptors.length; i++) { + if (matchArray[i + firstDescriptorCaptureIndex]) { + descriptor = descriptors[i]; + } + } + if (descriptor === undefined) + return ts.Debug.fail(); + // We don't want to match something like 'TODOBY', so we make sure a non + // letter/digit follows the match. + if (isLetterOrDigit(fileContents.charCodeAt(matchPosition + descriptor.text.length))) { + continue; + } + var message = matchArray[2]; + result.push({ descriptor: descriptor, message: message, position: matchPosition }); + } + } + return result; + function escapeRegExp(str) { + return str.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"); + } + function getTodoCommentsRegExp() { + // NOTE: `?:` means 'non-capture group'. It allows us to have groups without having to + // filter them out later in the final result array. + // TODO comments can appear in one of the following forms: + // + // 1) // TODO or /////////// TODO + // + // 2) /* TODO or /********** TODO + // + // 3) /* + // * TODO + // */ + // + // The following three regexps are used to match the start of the text up to the TODO + // comment portion. + var singleLineCommentStart = /(?:\/\/+\s*)/.source; + var multiLineCommentStart = /(?:\/\*+\s*)/.source; + var anyNumberOfSpacesAndAsterisksAtStartOfLine = /(?:^(?:\s|\*)*)/.source; + // Match any of the above three TODO comment start regexps. + // Note that the outermost group *is* a capture group. We want to capture the preamble + // so that we can determine the starting position of the TODO comment match. + var preamble = "(" + anyNumberOfSpacesAndAsterisksAtStartOfLine + "|" + singleLineCommentStart + "|" + multiLineCommentStart + ")"; + // Takes the descriptors and forms a regexp that matches them as if they were literals. + // For example, if the descriptors are "TODO(jason)" and "HACK", then this will be: + // + // (?:(TODO\(jason\))|(HACK)) + // + // Note that the outermost group is *not* a capture group, but the innermost groups + // *are* capture groups. By capturing the inner literals we can determine after + // matching which descriptor we are dealing with. + var literals = "(?:" + ts.map(descriptors, function (d) { return "(" + escapeRegExp(d.text) + ")"; }).join("|") + ")"; + // After matching a descriptor literal, the following regexp matches the rest of the + // text up to the end of the line (or */). + var endOfLineOrEndOfComment = /(?:$|\*\/)/.source; + var messageRemainder = /(?:.*?)/.source; + // This is the portion of the match we'll return as part of the TODO comment result. We + // match the literal portion up to the end of the line or end of comment. + var messagePortion = "(" + literals + messageRemainder + ")"; + var regExpString = preamble + messagePortion + endOfLineOrEndOfComment; + // The final regexp will look like this: + // /((?:\/\/+\s*)|(?:\/\*+\s*)|(?:^(?:\s|\*)*))((?:(TODO\(jason\))|(HACK))(?:.*?))(?:$|\*\/)/gim + // The flags of the regexp are important here. + // 'g' is so that we are doing a global search and can find matches several times + // in the input. + // + // 'i' is for case insensitivity (We do this to match C# TODO comment code). + // + // 'm' is so we can find matches in a multi-line input. + return new RegExp(regExpString, "gim"); + } + function isLetterOrDigit(char) { + return (char >= 97 /* CharacterCodes.a */ && char <= 122 /* CharacterCodes.z */) || + (char >= 65 /* CharacterCodes.A */ && char <= 90 /* CharacterCodes.Z */) || + (char >= 48 /* CharacterCodes._0 */ && char <= 57 /* CharacterCodes._9 */); + } + function isNodeModulesFile(path) { + return ts.stringContains(path, "/node_modules/"); + } + } + function getRenameInfo(fileName, position, preferences) { + synchronizeHostData(); + return ts.Rename.getRenameInfo(program, getValidSourceFile(fileName), position, preferences || {}); + } + function getRefactorContext(file, positionOrRange, preferences, formatOptions, triggerReason, kind) { + var _a = typeof positionOrRange === "number" ? [positionOrRange, undefined] : [positionOrRange.pos, positionOrRange.end], startPosition = _a[0], endPosition = _a[1]; + return { + file: file, + startPosition: startPosition, + endPosition: endPosition, + program: getProgram(), + host: host, + formatContext: ts.formatting.getFormatContext(formatOptions, host), + cancellationToken: cancellationToken, + preferences: preferences, + triggerReason: triggerReason, + kind: kind + }; + } + function getInlayHintsContext(file, span, preferences) { + return { + file: file, + program: getProgram(), + host: host, + span: span, + preferences: preferences, + cancellationToken: cancellationToken, + }; + } + function getSmartSelectionRange(fileName, position) { + return ts.SmartSelectionRange.getSmartSelectionRange(position, syntaxTreeCache.getCurrentSourceFile(fileName)); + } + function getApplicableRefactors(fileName, positionOrRange, preferences, triggerReason, kind) { + if (preferences === void 0) { preferences = ts.emptyOptions; } + synchronizeHostData(); + var file = getValidSourceFile(fileName); + return ts.refactor.getApplicableRefactors(getRefactorContext(file, positionOrRange, preferences, ts.emptyOptions, triggerReason, kind)); + } + function getEditsForRefactor(fileName, formatOptions, positionOrRange, refactorName, actionName, preferences) { + if (preferences === void 0) { preferences = ts.emptyOptions; } + synchronizeHostData(); + var file = getValidSourceFile(fileName); + return ts.refactor.getEditsForRefactor(getRefactorContext(file, positionOrRange, preferences, formatOptions), refactorName, actionName); + } + function toLineColumnOffset(fileName, position) { + // Go to Definition supports returning a zero-length span at position 0 for + // non-existent files. We need to special-case the conversion of position 0 + // to avoid a crash trying to get the text for that file, since this function + // otherwise assumes that 'fileName' is the name of a file that exists. + if (position === 0) { + return { line: 0, character: 0 }; + } + return sourceMapper.toLineColumnOffset(fileName, position); + } + function prepareCallHierarchy(fileName, position) { + synchronizeHostData(); + var declarations = ts.CallHierarchy.resolveCallHierarchyDeclaration(program, ts.getTouchingPropertyName(getValidSourceFile(fileName), position)); + return declarations && ts.mapOneOrMany(declarations, function (declaration) { return ts.CallHierarchy.createCallHierarchyItem(program, declaration); }); + } + function provideCallHierarchyIncomingCalls(fileName, position) { + synchronizeHostData(); + var sourceFile = getValidSourceFile(fileName); + var declaration = ts.firstOrOnly(ts.CallHierarchy.resolveCallHierarchyDeclaration(program, position === 0 ? sourceFile : ts.getTouchingPropertyName(sourceFile, position))); + return declaration ? ts.CallHierarchy.getIncomingCalls(program, declaration, cancellationToken) : []; + } + function provideCallHierarchyOutgoingCalls(fileName, position) { + synchronizeHostData(); + var sourceFile = getValidSourceFile(fileName); + var declaration = ts.firstOrOnly(ts.CallHierarchy.resolveCallHierarchyDeclaration(program, position === 0 ? sourceFile : ts.getTouchingPropertyName(sourceFile, position))); + return declaration ? ts.CallHierarchy.getOutgoingCalls(program, declaration) : []; + } + function provideInlayHints(fileName, span, preferences) { + if (preferences === void 0) { preferences = ts.emptyOptions; } + synchronizeHostData(); + var sourceFile = getValidSourceFile(fileName); + return ts.InlayHints.provideInlayHints(getInlayHintsContext(sourceFile, span, preferences)); + } + var ls = { + dispose: dispose, + cleanupSemanticCache: cleanupSemanticCache, + getSyntacticDiagnostics: getSyntacticDiagnostics, + getSemanticDiagnostics: getSemanticDiagnostics, + getSuggestionDiagnostics: getSuggestionDiagnostics, + getCompilerOptionsDiagnostics: getCompilerOptionsDiagnostics, + getSyntacticClassifications: getSyntacticClassifications, + getSemanticClassifications: getSemanticClassifications, + getEncodedSyntacticClassifications: getEncodedSyntacticClassifications, + getEncodedSemanticClassifications: getEncodedSemanticClassifications, + getCompletionsAtPosition: getCompletionsAtPosition, + getCompletionEntryDetails: getCompletionEntryDetails, + getCompletionEntrySymbol: getCompletionEntrySymbol, + getSignatureHelpItems: getSignatureHelpItems, + getQuickInfoAtPosition: getQuickInfoAtPosition, + getDefinitionAtPosition: getDefinitionAtPosition, + getDefinitionAndBoundSpan: getDefinitionAndBoundSpan, + getImplementationAtPosition: getImplementationAtPosition, + getTypeDefinitionAtPosition: getTypeDefinitionAtPosition, + getReferencesAtPosition: getReferencesAtPosition, + findReferences: findReferences, + getFileReferences: getFileReferences, + getOccurrencesAtPosition: getOccurrencesAtPosition, + getDocumentHighlights: getDocumentHighlights, + getNameOrDottedNameSpan: getNameOrDottedNameSpan, + getBreakpointStatementAtPosition: getBreakpointStatementAtPosition, + getNavigateToItems: getNavigateToItems, + getRenameInfo: getRenameInfo, + getSmartSelectionRange: getSmartSelectionRange, + findRenameLocations: findRenameLocations, + getNavigationBarItems: getNavigationBarItems, + getNavigationTree: getNavigationTree, + getOutliningSpans: getOutliningSpans, + getTodoComments: getTodoComments, + getBraceMatchingAtPosition: getBraceMatchingAtPosition, + getIndentationAtPosition: getIndentationAtPosition, + getFormattingEditsForRange: getFormattingEditsForRange, + getFormattingEditsForDocument: getFormattingEditsForDocument, + getFormattingEditsAfterKeystroke: getFormattingEditsAfterKeystroke, + getDocCommentTemplateAtPosition: getDocCommentTemplateAtPosition, + isValidBraceCompletionAtPosition: isValidBraceCompletionAtPosition, + getJsxClosingTagAtPosition: getJsxClosingTagAtPosition, + getSpanOfEnclosingComment: getSpanOfEnclosingComment, + getCodeFixesAtPosition: getCodeFixesAtPosition, + getCombinedCodeFix: getCombinedCodeFix, + applyCodeActionCommand: applyCodeActionCommand, + organizeImports: organizeImports, + getEditsForFileRename: getEditsForFileRename, + getEmitOutput: getEmitOutput, + getNonBoundSourceFile: getNonBoundSourceFile, + getProgram: getProgram, + getCurrentProgram: function () { return program; }, + getAutoImportProvider: getAutoImportProvider, + updateIsDefinitionOfReferencedSymbols: updateIsDefinitionOfReferencedSymbols, + getApplicableRefactors: getApplicableRefactors, + getEditsForRefactor: getEditsForRefactor, + toLineColumnOffset: toLineColumnOffset, + getSourceMapper: function () { return sourceMapper; }, + clearSourceMapperCache: function () { return sourceMapper.clearCache(); }, + prepareCallHierarchy: prepareCallHierarchy, + provideCallHierarchyIncomingCalls: provideCallHierarchyIncomingCalls, + provideCallHierarchyOutgoingCalls: provideCallHierarchyOutgoingCalls, + toggleLineComment: toggleLineComment, + toggleMultilineComment: toggleMultilineComment, + commentSelection: commentSelection, + uncommentSelection: uncommentSelection, + provideInlayHints: provideInlayHints, + }; + switch (languageServiceMode) { + case ts.LanguageServiceMode.Semantic: + break; + case ts.LanguageServiceMode.PartialSemantic: + invalidOperationsInPartialSemanticMode.forEach(function (key) { + return ls[key] = function () { + throw new Error("LanguageService Operation: ".concat(key, " not allowed in LanguageServiceMode.PartialSemantic")); + }; + }); + break; + case ts.LanguageServiceMode.Syntactic: + invalidOperationsInSyntacticMode.forEach(function (key) { + return ls[key] = function () { + throw new Error("LanguageService Operation: ".concat(key, " not allowed in LanguageServiceMode.Syntactic")); + }; + }); + break; + default: + ts.Debug.assertNever(languageServiceMode); + } + return ls; + } + ts.createLanguageService = createLanguageService; + /* @internal */ + /** Names in the name table are escaped, so an identifier `__foo` will have a name table entry `___foo`. */ + function getNameTable(sourceFile) { + if (!sourceFile.nameTable) { + initializeNameTable(sourceFile); + } + return sourceFile.nameTable; // TODO: GH#18217 + } + ts.getNameTable = getNameTable; + function initializeNameTable(sourceFile) { + var nameTable = sourceFile.nameTable = new ts.Map(); + sourceFile.forEachChild(function walk(node) { + if (ts.isIdentifier(node) && !ts.isTagName(node) && node.escapedText || ts.isStringOrNumericLiteralLike(node) && literalIsName(node)) { + var text = ts.getEscapedTextOfIdentifierOrLiteral(node); + nameTable.set(text, nameTable.get(text) === undefined ? node.pos : -1); + } + else if (ts.isPrivateIdentifier(node)) { + var text = node.escapedText; + nameTable.set(text, nameTable.get(text) === undefined ? node.pos : -1); + } + ts.forEachChild(node, walk); + if (ts.hasJSDocNodes(node)) { + for (var _i = 0, _a = node.jsDoc; _i < _a.length; _i++) { + var jsDoc = _a[_i]; + ts.forEachChild(jsDoc, walk); + } + } + }); + } + /** + * We want to store any numbers/strings if they were a name that could be + * related to a declaration. So, if we have 'import x = require("something")' + * then we want 'something' to be in the name table. Similarly, if we have + * "a['propname']" then we want to store "propname" in the name table. + */ + function literalIsName(node) { + return ts.isDeclarationName(node) || + node.parent.kind === 280 /* SyntaxKind.ExternalModuleReference */ || + isArgumentOfElementAccessExpression(node) || + ts.isLiteralComputedPropertyDeclarationName(node); + } + /** + * Returns the containing object literal property declaration given a possible name node, e.g. "a" in x = { "a": 1 } + */ + /* @internal */ + function getContainingObjectLiteralElement(node) { + var element = getContainingObjectLiteralElementWorker(node); + return element && (ts.isObjectLiteralExpression(element.parent) || ts.isJsxAttributes(element.parent)) ? element : undefined; + } + ts.getContainingObjectLiteralElement = getContainingObjectLiteralElement; + function getContainingObjectLiteralElementWorker(node) { + switch (node.kind) { + case 10 /* SyntaxKind.StringLiteral */: + case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */: + case 8 /* SyntaxKind.NumericLiteral */: + if (node.parent.kind === 164 /* SyntaxKind.ComputedPropertyName */) { + return ts.isObjectLiteralElement(node.parent.parent) ? node.parent.parent : undefined; + } + // falls through + case 79 /* SyntaxKind.Identifier */: + return ts.isObjectLiteralElement(node.parent) && + (node.parent.parent.kind === 207 /* SyntaxKind.ObjectLiteralExpression */ || node.parent.parent.kind === 289 /* SyntaxKind.JsxAttributes */) && + node.parent.name === node ? node.parent : undefined; + } + return undefined; + } + function getSymbolAtLocationForQuickInfo(node, checker) { + var object = getContainingObjectLiteralElement(node); + if (object) { + var contextualType = checker.getContextualType(object.parent); + var properties = contextualType && getPropertySymbolsFromContextualType(object, checker, contextualType, /*unionSymbolOk*/ false); + if (properties && properties.length === 1) { + return ts.first(properties); + } + } + return checker.getSymbolAtLocation(node); + } + /** Gets all symbols for one property. Does not get symbols for every property. */ + /* @internal */ + function getPropertySymbolsFromContextualType(node, checker, contextualType, unionSymbolOk) { + var name = ts.getNameFromPropertyName(node.name); + if (!name) + return ts.emptyArray; + if (!contextualType.isUnion()) { + var symbol = contextualType.getProperty(name); + return symbol ? [symbol] : ts.emptyArray; + } + var discriminatedPropertySymbols = ts.mapDefined(contextualType.types, function (t) { return (ts.isObjectLiteralExpression(node.parent) || ts.isJsxAttributes(node.parent)) && checker.isTypeInvalidDueToUnionDiscriminant(t, node.parent) ? undefined : t.getProperty(name); }); + if (unionSymbolOk && (discriminatedPropertySymbols.length === 0 || discriminatedPropertySymbols.length === contextualType.types.length)) { + var symbol = contextualType.getProperty(name); + if (symbol) + return [symbol]; + } + if (discriminatedPropertySymbols.length === 0) { + // Bad discriminant -- do again without discriminating + return ts.mapDefined(contextualType.types, function (t) { return t.getProperty(name); }); + } + return discriminatedPropertySymbols; + } + ts.getPropertySymbolsFromContextualType = getPropertySymbolsFromContextualType; + function isArgumentOfElementAccessExpression(node) { + return node && + node.parent && + node.parent.kind === 209 /* SyntaxKind.ElementAccessExpression */ && + node.parent.argumentExpression === node; + } + /** + * Get the path of the default library files (lib.d.ts) as distributed with the typescript + * node package. + * The functionality is not supported if the ts module is consumed outside of a node module. + */ + function getDefaultLibFilePath(options) { + // Check __dirname is defined and that we are on a node.js system. + if (typeof __dirname !== "undefined") { + return ts.combinePaths(__dirname, ts.getDefaultLibFileName(options)); + } + throw new Error("getDefaultLibFilePath is only supported when consumed as a node module. "); + } + ts.getDefaultLibFilePath = getDefaultLibFilePath; + ts.setObjectAllocator(getServicesObjectAllocator()); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + var BreakpointResolver; + (function (BreakpointResolver) { + /** + * Get the breakpoint span in given sourceFile + */ + function spanInSourceFileAtLocation(sourceFile, position) { + // Cannot set breakpoint in dts file + if (sourceFile.isDeclarationFile) { + return undefined; + } + var tokenAtLocation = ts.getTokenAtPosition(sourceFile, position); + var lineOfPosition = sourceFile.getLineAndCharacterOfPosition(position).line; + if (sourceFile.getLineAndCharacterOfPosition(tokenAtLocation.getStart(sourceFile)).line > lineOfPosition) { + // Get previous token if the token is returned starts on new line + // eg: let x =10; |--- cursor is here + // let y = 10; + // token at position will return let keyword on second line as the token but we would like to use + // token on same line if trailing trivia (comments or white spaces on same line) part of the last token on that line + var preceding = ts.findPrecedingToken(tokenAtLocation.pos, sourceFile); + // It's a blank line + if (!preceding || sourceFile.getLineAndCharacterOfPosition(preceding.getEnd()).line !== lineOfPosition) { + return undefined; + } + tokenAtLocation = preceding; + } + // Cannot set breakpoint in ambient declarations + if (tokenAtLocation.flags & 16777216 /* NodeFlags.Ambient */) { + return undefined; + } + // Get the span in the node based on its syntax + return spanInNode(tokenAtLocation); + function textSpan(startNode, endNode) { + var lastDecorator = ts.canHaveDecorators(startNode) ? ts.findLast(startNode.modifiers, ts.isDecorator) : undefined; + var start = lastDecorator ? + ts.skipTrivia(sourceFile.text, lastDecorator.end) : + startNode.getStart(sourceFile); + return ts.createTextSpanFromBounds(start, (endNode || startNode).getEnd()); + } + function textSpanEndingAtNextToken(startNode, previousTokenToFindNextEndToken) { + return textSpan(startNode, ts.findNextToken(previousTokenToFindNextEndToken, previousTokenToFindNextEndToken.parent, sourceFile)); + } + function spanInNodeIfStartsOnSameLine(node, otherwiseOnNode) { + if (node && lineOfPosition === sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line) { + return spanInNode(node); + } + return spanInNode(otherwiseOnNode); + } + function spanInNodeArray(nodeArray, node, match) { + if (nodeArray) { + var index = nodeArray.indexOf(node); + if (index >= 0) { + var start = index; + var end = index + 1; + while (start > 0 && match(nodeArray[start - 1])) + start--; + while (end < nodeArray.length && match(nodeArray[end])) + end++; + return ts.createTextSpanFromBounds(ts.skipTrivia(sourceFile.text, nodeArray[start].pos), nodeArray[end - 1].end); + } + } + return textSpan(node); + } + function spanInPreviousNode(node) { + return spanInNode(ts.findPrecedingToken(node.pos, sourceFile)); + } + function spanInNextNode(node) { + return spanInNode(ts.findNextToken(node, node.parent, sourceFile)); + } + function spanInNode(node) { + if (node) { + var parent = node.parent; + switch (node.kind) { + case 240 /* SyntaxKind.VariableStatement */: + // Span on first variable declaration + return spanInVariableDeclaration(node.declarationList.declarations[0]); + case 257 /* SyntaxKind.VariableDeclaration */: + case 169 /* SyntaxKind.PropertyDeclaration */: + case 168 /* SyntaxKind.PropertySignature */: + return spanInVariableDeclaration(node); + case 166 /* SyntaxKind.Parameter */: + return spanInParameterDeclaration(node); + case 259 /* SyntaxKind.FunctionDeclaration */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 173 /* SyntaxKind.Constructor */: + case 215 /* SyntaxKind.FunctionExpression */: + case 216 /* SyntaxKind.ArrowFunction */: + return spanInFunctionDeclaration(node); + case 238 /* SyntaxKind.Block */: + if (ts.isFunctionBlock(node)) { + return spanInFunctionBlock(node); + } + // falls through + case 265 /* SyntaxKind.ModuleBlock */: + return spanInBlock(node); + case 295 /* SyntaxKind.CatchClause */: + return spanInBlock(node.block); + case 241 /* SyntaxKind.ExpressionStatement */: + // span on the expression + return textSpan(node.expression); + case 250 /* SyntaxKind.ReturnStatement */: + // span on return keyword and expression if present + return textSpan(node.getChildAt(0), node.expression); + case 244 /* SyntaxKind.WhileStatement */: + // Span on while(...) + return textSpanEndingAtNextToken(node, node.expression); + case 243 /* SyntaxKind.DoStatement */: + // span in statement of the do statement + return spanInNode(node.statement); + case 256 /* SyntaxKind.DebuggerStatement */: + // span on debugger keyword + return textSpan(node.getChildAt(0)); + case 242 /* SyntaxKind.IfStatement */: + // set on if(..) span + return textSpanEndingAtNextToken(node, node.expression); + case 253 /* SyntaxKind.LabeledStatement */: + // span in statement + return spanInNode(node.statement); + case 249 /* SyntaxKind.BreakStatement */: + case 248 /* SyntaxKind.ContinueStatement */: + // On break or continue keyword and label if present + return textSpan(node.getChildAt(0), node.label); + case 245 /* SyntaxKind.ForStatement */: + return spanInForStatement(node); + case 246 /* SyntaxKind.ForInStatement */: + // span of for (a in ...) + return textSpanEndingAtNextToken(node, node.expression); + case 247 /* SyntaxKind.ForOfStatement */: + // span in initializer + return spanInInitializerOfForLike(node); + case 252 /* SyntaxKind.SwitchStatement */: + // span on switch(...) + return textSpanEndingAtNextToken(node, node.expression); + case 292 /* SyntaxKind.CaseClause */: + case 293 /* SyntaxKind.DefaultClause */: + // span in first statement of the clause + return spanInNode(node.statements[0]); + case 255 /* SyntaxKind.TryStatement */: + // span in try block + return spanInBlock(node.tryBlock); + case 254 /* SyntaxKind.ThrowStatement */: + // span in throw ... + return textSpan(node, node.expression); + case 274 /* SyntaxKind.ExportAssignment */: + // span on export = id + return textSpan(node, node.expression); + case 268 /* SyntaxKind.ImportEqualsDeclaration */: + // import statement without including semicolon + return textSpan(node, node.moduleReference); + case 269 /* SyntaxKind.ImportDeclaration */: + // import statement without including semicolon + return textSpan(node, node.moduleSpecifier); + case 275 /* SyntaxKind.ExportDeclaration */: + // import statement without including semicolon + return textSpan(node, node.moduleSpecifier); + case 264 /* SyntaxKind.ModuleDeclaration */: + // span on complete module if it is instantiated + if (ts.getModuleInstanceState(node) !== 1 /* ModuleInstanceState.Instantiated */) { + return undefined; + } + // falls through + case 260 /* SyntaxKind.ClassDeclaration */: + case 263 /* SyntaxKind.EnumDeclaration */: + case 302 /* SyntaxKind.EnumMember */: + case 205 /* SyntaxKind.BindingElement */: + // span on complete node + return textSpan(node); + case 251 /* SyntaxKind.WithStatement */: + // span in statement + return spanInNode(node.statement); + case 167 /* SyntaxKind.Decorator */: + return spanInNodeArray(parent.modifiers, node, ts.isDecorator); + case 203 /* SyntaxKind.ObjectBindingPattern */: + case 204 /* SyntaxKind.ArrayBindingPattern */: + return spanInBindingPattern(node); + // No breakpoint in interface, type alias + case 261 /* SyntaxKind.InterfaceDeclaration */: + case 262 /* SyntaxKind.TypeAliasDeclaration */: + return undefined; + // Tokens: + case 26 /* SyntaxKind.SemicolonToken */: + case 1 /* SyntaxKind.EndOfFileToken */: + return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(node.pos, sourceFile)); + case 27 /* SyntaxKind.CommaToken */: + return spanInPreviousNode(node); + case 18 /* SyntaxKind.OpenBraceToken */: + return spanInOpenBraceToken(node); + case 19 /* SyntaxKind.CloseBraceToken */: + return spanInCloseBraceToken(node); + case 23 /* SyntaxKind.CloseBracketToken */: + return spanInCloseBracketToken(node); + case 20 /* SyntaxKind.OpenParenToken */: + return spanInOpenParenToken(node); + case 21 /* SyntaxKind.CloseParenToken */: + return spanInCloseParenToken(node); + case 58 /* SyntaxKind.ColonToken */: + return spanInColonToken(node); + case 31 /* SyntaxKind.GreaterThanToken */: + case 29 /* SyntaxKind.LessThanToken */: + return spanInGreaterThanOrLessThanToken(node); + // Keywords: + case 115 /* SyntaxKind.WhileKeyword */: + return spanInWhileKeyword(node); + case 91 /* SyntaxKind.ElseKeyword */: + case 83 /* SyntaxKind.CatchKeyword */: + case 96 /* SyntaxKind.FinallyKeyword */: + return spanInNextNode(node); + case 162 /* SyntaxKind.OfKeyword */: + return spanInOfKeyword(node); + default: + // Destructuring pattern in destructuring assignment + // [a, b, c] of + // [a, b, c] = expression + if (ts.isArrayLiteralOrObjectLiteralDestructuringPattern(node)) { + return spanInArrayLiteralOrObjectLiteralDestructuringPattern(node); + } + // Set breakpoint on identifier element of destructuring pattern + // `a` or `...c` or `d: x` from + // `[a, b, ...c]` or `{ a, b }` or `{ d: x }` from destructuring pattern + if ((node.kind === 79 /* SyntaxKind.Identifier */ || + node.kind === 227 /* SyntaxKind.SpreadElement */ || + node.kind === 299 /* SyntaxKind.PropertyAssignment */ || + node.kind === 300 /* SyntaxKind.ShorthandPropertyAssignment */) && + ts.isArrayLiteralOrObjectLiteralDestructuringPattern(parent)) { + return textSpan(node); + } + if (node.kind === 223 /* SyntaxKind.BinaryExpression */) { + var _a = node, left = _a.left, operatorToken = _a.operatorToken; + // Set breakpoint in destructuring pattern if its destructuring assignment + // [a, b, c] or {a, b, c} of + // [a, b, c] = expression or + // {a, b, c} = expression + if (ts.isArrayLiteralOrObjectLiteralDestructuringPattern(left)) { + return spanInArrayLiteralOrObjectLiteralDestructuringPattern(left); + } + if (operatorToken.kind === 63 /* SyntaxKind.EqualsToken */ && ts.isArrayLiteralOrObjectLiteralDestructuringPattern(node.parent)) { + // Set breakpoint on assignment expression element of destructuring pattern + // a = expression of + // [a = expression, b, c] = someExpression or + // { a = expression, b, c } = someExpression + return textSpan(node); + } + if (operatorToken.kind === 27 /* SyntaxKind.CommaToken */) { + return spanInNode(left); + } + } + if (ts.isExpressionNode(node)) { + switch (parent.kind) { + case 243 /* SyntaxKind.DoStatement */: + // Set span as if on while keyword + return spanInPreviousNode(node); + case 167 /* SyntaxKind.Decorator */: + // Set breakpoint on the decorator emit + return spanInNode(node.parent); + case 245 /* SyntaxKind.ForStatement */: + case 247 /* SyntaxKind.ForOfStatement */: + return textSpan(node); + case 223 /* SyntaxKind.BinaryExpression */: + if (node.parent.operatorToken.kind === 27 /* SyntaxKind.CommaToken */) { + // If this is a comma expression, the breakpoint is possible in this expression + return textSpan(node); + } + break; + case 216 /* SyntaxKind.ArrowFunction */: + if (node.parent.body === node) { + // If this is body of arrow function, it is allowed to have the breakpoint + return textSpan(node); + } + break; + } + } + switch (node.parent.kind) { + case 299 /* SyntaxKind.PropertyAssignment */: + // If this is name of property assignment, set breakpoint in the initializer + if (node.parent.name === node && + !ts.isArrayLiteralOrObjectLiteralDestructuringPattern(node.parent.parent)) { + return spanInNode(node.parent.initializer); + } + break; + case 213 /* SyntaxKind.TypeAssertionExpression */: + // Breakpoint in type assertion goes to its operand + if (node.parent.type === node) { + return spanInNextNode(node.parent.type); + } + break; + case 257 /* SyntaxKind.VariableDeclaration */: + case 166 /* SyntaxKind.Parameter */: { + // initializer of variable/parameter declaration go to previous node + var _b = node.parent, initializer = _b.initializer, type = _b.type; + if (initializer === node || type === node || ts.isAssignmentOperator(node.kind)) { + return spanInPreviousNode(node); + } + break; + } + case 223 /* SyntaxKind.BinaryExpression */: { + var left = node.parent.left; + if (ts.isArrayLiteralOrObjectLiteralDestructuringPattern(left) && node !== left) { + // If initializer of destructuring assignment move to previous token + return spanInPreviousNode(node); + } + break; + } + default: + // return type of function go to previous token + if (ts.isFunctionLike(node.parent) && node.parent.type === node) { + return spanInPreviousNode(node); + } + } + // Default go to parent to set the breakpoint + return spanInNode(node.parent); + } + } + function textSpanFromVariableDeclaration(variableDeclaration) { + if (ts.isVariableDeclarationList(variableDeclaration.parent) && variableDeclaration.parent.declarations[0] === variableDeclaration) { + // First declaration - include let keyword + return textSpan(ts.findPrecedingToken(variableDeclaration.pos, sourceFile, variableDeclaration.parent), variableDeclaration); + } + else { + // Span only on this declaration + return textSpan(variableDeclaration); + } + } + function spanInVariableDeclaration(variableDeclaration) { + // If declaration of for in statement, just set the span in parent + if (variableDeclaration.parent.parent.kind === 246 /* SyntaxKind.ForInStatement */) { + return spanInNode(variableDeclaration.parent.parent); + } + var parent = variableDeclaration.parent; + // If this is a destructuring pattern, set breakpoint in binding pattern + if (ts.isBindingPattern(variableDeclaration.name)) { + return spanInBindingPattern(variableDeclaration.name); + } + // Breakpoint is possible in variableDeclaration only if there is initialization + // or its declaration from 'for of' + if ((ts.hasOnlyExpressionInitializer(variableDeclaration) && variableDeclaration.initializer) || + ts.hasSyntacticModifier(variableDeclaration, 1 /* ModifierFlags.Export */) || + parent.parent.kind === 247 /* SyntaxKind.ForOfStatement */) { + return textSpanFromVariableDeclaration(variableDeclaration); + } + if (ts.isVariableDeclarationList(variableDeclaration.parent) && + variableDeclaration.parent.declarations[0] !== variableDeclaration) { + // If we cannot set breakpoint on this declaration, set it on previous one + // Because the variable declaration may be binding pattern and + // we would like to set breakpoint in last binding element if that's the case, + // use preceding token instead + return spanInNode(ts.findPrecedingToken(variableDeclaration.pos, sourceFile, variableDeclaration.parent)); + } + } + function canHaveSpanInParameterDeclaration(parameter) { + // Breakpoint is possible on parameter only if it has initializer, is a rest parameter, or has public or private modifier + return !!parameter.initializer || parameter.dotDotDotToken !== undefined || + ts.hasSyntacticModifier(parameter, 4 /* ModifierFlags.Public */ | 8 /* ModifierFlags.Private */); + } + function spanInParameterDeclaration(parameter) { + if (ts.isBindingPattern(parameter.name)) { + // Set breakpoint in binding pattern + return spanInBindingPattern(parameter.name); + } + else if (canHaveSpanInParameterDeclaration(parameter)) { + return textSpan(parameter); + } + else { + var functionDeclaration = parameter.parent; + var indexOfParameter = functionDeclaration.parameters.indexOf(parameter); + ts.Debug.assert(indexOfParameter !== -1); + if (indexOfParameter !== 0) { + // Not a first parameter, go to previous parameter + return spanInParameterDeclaration(functionDeclaration.parameters[indexOfParameter - 1]); + } + else { + // Set breakpoint in the function declaration body + return spanInNode(functionDeclaration.body); + } + } + } + function canFunctionHaveSpanInWholeDeclaration(functionDeclaration) { + return ts.hasSyntacticModifier(functionDeclaration, 1 /* ModifierFlags.Export */) || + (functionDeclaration.parent.kind === 260 /* SyntaxKind.ClassDeclaration */ && functionDeclaration.kind !== 173 /* SyntaxKind.Constructor */); + } + function spanInFunctionDeclaration(functionDeclaration) { + // No breakpoints in the function signature + if (!functionDeclaration.body) { + return undefined; + } + if (canFunctionHaveSpanInWholeDeclaration(functionDeclaration)) { + // Set the span on whole function declaration + return textSpan(functionDeclaration); + } + // Set span in function body + return spanInNode(functionDeclaration.body); + } + function spanInFunctionBlock(block) { + var nodeForSpanInBlock = block.statements.length ? block.statements[0] : block.getLastToken(); + if (canFunctionHaveSpanInWholeDeclaration(block.parent)) { + return spanInNodeIfStartsOnSameLine(block.parent, nodeForSpanInBlock); + } + return spanInNode(nodeForSpanInBlock); + } + function spanInBlock(block) { + switch (block.parent.kind) { + case 264 /* SyntaxKind.ModuleDeclaration */: + if (ts.getModuleInstanceState(block.parent) !== 1 /* ModuleInstanceState.Instantiated */) { + return undefined; + } + // Set on parent if on same line otherwise on first statement + // falls through + case 244 /* SyntaxKind.WhileStatement */: + case 242 /* SyntaxKind.IfStatement */: + case 246 /* SyntaxKind.ForInStatement */: + return spanInNodeIfStartsOnSameLine(block.parent, block.statements[0]); + // Set span on previous token if it starts on same line otherwise on the first statement of the block + case 245 /* SyntaxKind.ForStatement */: + case 247 /* SyntaxKind.ForOfStatement */: + return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(block.pos, sourceFile, block.parent), block.statements[0]); + } + // Default action is to set on first statement + return spanInNode(block.statements[0]); + } + function spanInInitializerOfForLike(forLikeStatement) { + if (forLikeStatement.initializer.kind === 258 /* SyntaxKind.VariableDeclarationList */) { + // Declaration list - set breakpoint in first declaration + var variableDeclarationList = forLikeStatement.initializer; + if (variableDeclarationList.declarations.length > 0) { + return spanInNode(variableDeclarationList.declarations[0]); + } + } + else { + // Expression - set breakpoint in it + return spanInNode(forLikeStatement.initializer); + } + } + function spanInForStatement(forStatement) { + if (forStatement.initializer) { + return spanInInitializerOfForLike(forStatement); + } + if (forStatement.condition) { + return textSpan(forStatement.condition); + } + if (forStatement.incrementor) { + return textSpan(forStatement.incrementor); + } + } + function spanInBindingPattern(bindingPattern) { + // Set breakpoint in first binding element + var firstBindingElement = ts.forEach(bindingPattern.elements, function (element) { return element.kind !== 229 /* SyntaxKind.OmittedExpression */ ? element : undefined; }); + if (firstBindingElement) { + return spanInNode(firstBindingElement); + } + // Empty binding pattern of binding element, set breakpoint on binding element + if (bindingPattern.parent.kind === 205 /* SyntaxKind.BindingElement */) { + return textSpan(bindingPattern.parent); + } + // Variable declaration is used as the span + return textSpanFromVariableDeclaration(bindingPattern.parent); + } + function spanInArrayLiteralOrObjectLiteralDestructuringPattern(node) { + ts.Debug.assert(node.kind !== 204 /* SyntaxKind.ArrayBindingPattern */ && node.kind !== 203 /* SyntaxKind.ObjectBindingPattern */); + var elements = node.kind === 206 /* SyntaxKind.ArrayLiteralExpression */ ? node.elements : node.properties; + var firstBindingElement = ts.forEach(elements, function (element) { return element.kind !== 229 /* SyntaxKind.OmittedExpression */ ? element : undefined; }); + if (firstBindingElement) { + return spanInNode(firstBindingElement); + } + // Could be ArrayLiteral from destructuring assignment or + // just nested element in another destructuring assignment + // set breakpoint on assignment when parent is destructuring assignment + // Otherwise set breakpoint for this element + return textSpan(node.parent.kind === 223 /* SyntaxKind.BinaryExpression */ ? node.parent : node); + } + // Tokens: + function spanInOpenBraceToken(node) { + switch (node.parent.kind) { + case 263 /* SyntaxKind.EnumDeclaration */: + var enumDeclaration = node.parent; + return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(node.pos, sourceFile, node.parent), enumDeclaration.members.length ? enumDeclaration.members[0] : enumDeclaration.getLastToken(sourceFile)); + case 260 /* SyntaxKind.ClassDeclaration */: + var classDeclaration = node.parent; + return spanInNodeIfStartsOnSameLine(ts.findPrecedingToken(node.pos, sourceFile, node.parent), classDeclaration.members.length ? classDeclaration.members[0] : classDeclaration.getLastToken(sourceFile)); + case 266 /* SyntaxKind.CaseBlock */: + return spanInNodeIfStartsOnSameLine(node.parent.parent, node.parent.clauses[0]); + } + // Default to parent node + return spanInNode(node.parent); + } + function spanInCloseBraceToken(node) { + switch (node.parent.kind) { + case 265 /* SyntaxKind.ModuleBlock */: + // If this is not an instantiated module block, no bp span + if (ts.getModuleInstanceState(node.parent.parent) !== 1 /* ModuleInstanceState.Instantiated */) { + return undefined; + } + // falls through + case 263 /* SyntaxKind.EnumDeclaration */: + case 260 /* SyntaxKind.ClassDeclaration */: + // Span on close brace token + return textSpan(node); + case 238 /* SyntaxKind.Block */: + if (ts.isFunctionBlock(node.parent)) { + // Span on close brace token + return textSpan(node); + } + // falls through + case 295 /* SyntaxKind.CatchClause */: + return spanInNode(ts.lastOrUndefined(node.parent.statements)); + case 266 /* SyntaxKind.CaseBlock */: + // breakpoint in last statement of the last clause + var caseBlock = node.parent; + var lastClause = ts.lastOrUndefined(caseBlock.clauses); + if (lastClause) { + return spanInNode(ts.lastOrUndefined(lastClause.statements)); + } + return undefined; + case 203 /* SyntaxKind.ObjectBindingPattern */: + // Breakpoint in last binding element or binding pattern if it contains no elements + var bindingPattern = node.parent; + return spanInNode(ts.lastOrUndefined(bindingPattern.elements) || bindingPattern); + // Default to parent node + default: + if (ts.isArrayLiteralOrObjectLiteralDestructuringPattern(node.parent)) { + // Breakpoint in last binding element or binding pattern if it contains no elements + var objectLiteral = node.parent; + return textSpan(ts.lastOrUndefined(objectLiteral.properties) || objectLiteral); + } + return spanInNode(node.parent); + } + } + function spanInCloseBracketToken(node) { + switch (node.parent.kind) { + case 204 /* SyntaxKind.ArrayBindingPattern */: + // Breakpoint in last binding element or binding pattern if it contains no elements + var bindingPattern = node.parent; + return textSpan(ts.lastOrUndefined(bindingPattern.elements) || bindingPattern); + default: + if (ts.isArrayLiteralOrObjectLiteralDestructuringPattern(node.parent)) { + // Breakpoint in last binding element or binding pattern if it contains no elements + var arrayLiteral = node.parent; + return textSpan(ts.lastOrUndefined(arrayLiteral.elements) || arrayLiteral); + } + // Default to parent node + return spanInNode(node.parent); + } + } + function spanInOpenParenToken(node) { + if (node.parent.kind === 243 /* SyntaxKind.DoStatement */ || // Go to while keyword and do action instead + node.parent.kind === 210 /* SyntaxKind.CallExpression */ || + node.parent.kind === 211 /* SyntaxKind.NewExpression */) { + return spanInPreviousNode(node); + } + if (node.parent.kind === 214 /* SyntaxKind.ParenthesizedExpression */) { + return spanInNextNode(node); + } + // Default to parent node + return spanInNode(node.parent); + } + function spanInCloseParenToken(node) { + // Is this close paren token of parameter list, set span in previous token + switch (node.parent.kind) { + case 215 /* SyntaxKind.FunctionExpression */: + case 259 /* SyntaxKind.FunctionDeclaration */: + case 216 /* SyntaxKind.ArrowFunction */: + case 171 /* SyntaxKind.MethodDeclaration */: + case 170 /* SyntaxKind.MethodSignature */: + case 174 /* SyntaxKind.GetAccessor */: + case 175 /* SyntaxKind.SetAccessor */: + case 173 /* SyntaxKind.Constructor */: + case 244 /* SyntaxKind.WhileStatement */: + case 243 /* SyntaxKind.DoStatement */: + case 245 /* SyntaxKind.ForStatement */: + case 247 /* SyntaxKind.ForOfStatement */: + case 210 /* SyntaxKind.CallExpression */: + case 211 /* SyntaxKind.NewExpression */: + case 214 /* SyntaxKind.ParenthesizedExpression */: + return spanInPreviousNode(node); + // Default to parent node + default: + return spanInNode(node.parent); + } + } + function spanInColonToken(node) { + // Is this : specifying return annotation of the function declaration + if (ts.isFunctionLike(node.parent) || + node.parent.kind === 299 /* SyntaxKind.PropertyAssignment */ || + node.parent.kind === 166 /* SyntaxKind.Parameter */) { + return spanInPreviousNode(node); + } + return spanInNode(node.parent); + } + function spanInGreaterThanOrLessThanToken(node) { + if (node.parent.kind === 213 /* SyntaxKind.TypeAssertionExpression */) { + return spanInNextNode(node); + } + return spanInNode(node.parent); + } + function spanInWhileKeyword(node) { + if (node.parent.kind === 243 /* SyntaxKind.DoStatement */) { + // Set span on while expression + return textSpanEndingAtNextToken(node, node.parent.expression); + } + // Default to parent node + return spanInNode(node.parent); + } + function spanInOfKeyword(node) { + if (node.parent.kind === 247 /* SyntaxKind.ForOfStatement */) { + // Set using next token + return spanInNextNode(node); + } + // Default to parent node + return spanInNode(node.parent); + } + } + } + BreakpointResolver.spanInSourceFileAtLocation = spanInSourceFileAtLocation; + })(BreakpointResolver = ts.BreakpointResolver || (ts.BreakpointResolver = {})); +})(ts || (ts = {})); +var ts; +(function (ts) { + /** + * Transform one or more nodes using the supplied transformers. + * @param source A single `Node` or an array of `Node` objects. + * @param transformers An array of `TransformerFactory` callbacks used to process the transformation. + * @param compilerOptions Optional compiler options. + */ + function transform(source, transformers, compilerOptions) { + var diagnostics = []; + compilerOptions = ts.fixupCompilerOptions(compilerOptions, diagnostics); // TODO: GH#18217 + var nodes = ts.isArray(source) ? source : [source]; + var result = ts.transformNodes(/*resolver*/ undefined, /*emitHost*/ undefined, ts.factory, compilerOptions, nodes, transformers, /*allowDtsFiles*/ true); + result.diagnostics = ts.concatenate(result.diagnostics, diagnostics); + return result; + } + ts.transform = transform; +})(ts || (ts = {})); +// +// Copyright (c) Microsoft Corporation. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/* @internal */ +var debugObjectHost = (function () { + return this; +})(); +// We need to use 'null' to interface with the managed side. +/* eslint-disable local/no-in-operator */ +/* @internal */ +var ts; +(function (ts) { + function logInternalError(logger, err) { + if (logger) { + logger.log("*INTERNAL ERROR* - Exception in typescript services: " + err.message); + } + } + var ScriptSnapshotShimAdapter = /** @class */ (function () { + function ScriptSnapshotShimAdapter(scriptSnapshotShim) { + this.scriptSnapshotShim = scriptSnapshotShim; + } + ScriptSnapshotShimAdapter.prototype.getText = function (start, end) { + return this.scriptSnapshotShim.getText(start, end); + }; + ScriptSnapshotShimAdapter.prototype.getLength = function () { + return this.scriptSnapshotShim.getLength(); + }; + ScriptSnapshotShimAdapter.prototype.getChangeRange = function (oldSnapshot) { + var oldSnapshotShim = oldSnapshot; + var encoded = this.scriptSnapshotShim.getChangeRange(oldSnapshotShim.scriptSnapshotShim); + /* eslint-disable no-null/no-null */ + if (encoded === null) { + return null; // TODO: GH#18217 + } + /* eslint-enable no-null/no-null */ + var decoded = JSON.parse(encoded); // TODO: GH#18217 + return ts.createTextChangeRange(ts.createTextSpan(decoded.span.start, decoded.span.length), decoded.newLength); + }; + ScriptSnapshotShimAdapter.prototype.dispose = function () { + // if scriptSnapshotShim is a COM object then property check becomes method call with no arguments + // 'in' does not have this effect + if ("dispose" in this.scriptSnapshotShim) { + this.scriptSnapshotShim.dispose(); // TODO: GH#18217 Can we just use `if (this.scriptSnapshotShim.dispose)`? + } + }; + return ScriptSnapshotShimAdapter; + }()); + var LanguageServiceShimHostAdapter = /** @class */ (function () { + function LanguageServiceShimHostAdapter(shimHost) { + var _this = this; + this.shimHost = shimHost; + this.loggingEnabled = false; + this.tracingEnabled = false; + // if shimHost is a COM object then property check will become method call with no arguments. + // 'in' does not have this effect. + if ("getModuleResolutionsForFile" in this.shimHost) { + this.resolveModuleNames = function (moduleNames, containingFile) { + var resolutionsInFile = JSON.parse(_this.shimHost.getModuleResolutionsForFile(containingFile)); // TODO: GH#18217 + return ts.map(moduleNames, function (name) { + var result = ts.getProperty(resolutionsInFile, name); + return result ? { resolvedFileName: result, extension: ts.extensionFromPath(result), isExternalLibraryImport: false } : undefined; + }); + }; + } + if ("directoryExists" in this.shimHost) { + this.directoryExists = function (directoryName) { return _this.shimHost.directoryExists(directoryName); }; + } + if ("getTypeReferenceDirectiveResolutionsForFile" in this.shimHost) { + this.resolveTypeReferenceDirectives = function (typeDirectiveNames, containingFile) { + var typeDirectivesForFile = JSON.parse(_this.shimHost.getTypeReferenceDirectiveResolutionsForFile(containingFile)); // TODO: GH#18217 + return ts.map(typeDirectiveNames, function (name) { return ts.getProperty(typeDirectivesForFile, ts.isString(name) ? name : name.fileName.toLowerCase()); }); + }; + } + } + LanguageServiceShimHostAdapter.prototype.log = function (s) { + if (this.loggingEnabled) { + this.shimHost.log(s); + } + }; + LanguageServiceShimHostAdapter.prototype.trace = function (s) { + if (this.tracingEnabled) { + this.shimHost.trace(s); + } + }; + LanguageServiceShimHostAdapter.prototype.error = function (s) { + this.shimHost.error(s); + }; + LanguageServiceShimHostAdapter.prototype.getProjectVersion = function () { + if (!this.shimHost.getProjectVersion) { + // shimmed host does not support getProjectVersion + return undefined; // TODO: GH#18217 + } + return this.shimHost.getProjectVersion(); + }; + LanguageServiceShimHostAdapter.prototype.getTypeRootsVersion = function () { + if (!this.shimHost.getTypeRootsVersion) { + return 0; + } + return this.shimHost.getTypeRootsVersion(); + }; + LanguageServiceShimHostAdapter.prototype.useCaseSensitiveFileNames = function () { + return this.shimHost.useCaseSensitiveFileNames ? this.shimHost.useCaseSensitiveFileNames() : false; + }; + LanguageServiceShimHostAdapter.prototype.getCompilationSettings = function () { + var settingsJson = this.shimHost.getCompilationSettings(); + // eslint-disable-next-line no-null/no-null + if (settingsJson === null || settingsJson === "") { + throw Error("LanguageServiceShimHostAdapter.getCompilationSettings: empty compilationSettings"); + } + var compilerOptions = JSON.parse(settingsJson); + // permit language service to handle all files (filtering should be performed on the host side) + compilerOptions.allowNonTsExtensions = true; + return compilerOptions; + }; + LanguageServiceShimHostAdapter.prototype.getScriptFileNames = function () { + var encoded = this.shimHost.getScriptFileNames(); + return JSON.parse(encoded); + }; + LanguageServiceShimHostAdapter.prototype.getScriptSnapshot = function (fileName) { + var scriptSnapshot = this.shimHost.getScriptSnapshot(fileName); + return scriptSnapshot && new ScriptSnapshotShimAdapter(scriptSnapshot); + }; + LanguageServiceShimHostAdapter.prototype.getScriptKind = function (fileName) { + if ("getScriptKind" in this.shimHost) { + return this.shimHost.getScriptKind(fileName); // TODO: GH#18217 + } + else { + return 0 /* ScriptKind.Unknown */; + } + }; + LanguageServiceShimHostAdapter.prototype.getScriptVersion = function (fileName) { + return this.shimHost.getScriptVersion(fileName); + }; + LanguageServiceShimHostAdapter.prototype.getLocalizedDiagnosticMessages = function () { + /* eslint-disable no-null/no-null */ + var diagnosticMessagesJson = this.shimHost.getLocalizedDiagnosticMessages(); + if (diagnosticMessagesJson === null || diagnosticMessagesJson === "") { + return null; + } + try { + return JSON.parse(diagnosticMessagesJson); + } + catch (e) { + this.log(e.description || "diagnosticMessages.generated.json has invalid JSON format"); + return null; + } + /* eslint-enable no-null/no-null */ + }; + LanguageServiceShimHostAdapter.prototype.getCancellationToken = function () { + var hostCancellationToken = this.shimHost.getCancellationToken(); + return new ts.ThrottledCancellationToken(hostCancellationToken); + }; + LanguageServiceShimHostAdapter.prototype.getCurrentDirectory = function () { + return this.shimHost.getCurrentDirectory(); + }; + LanguageServiceShimHostAdapter.prototype.getDirectories = function (path) { + return JSON.parse(this.shimHost.getDirectories(path)); + }; + LanguageServiceShimHostAdapter.prototype.getDefaultLibFileName = function (options) { + return this.shimHost.getDefaultLibFileName(JSON.stringify(options)); + }; + LanguageServiceShimHostAdapter.prototype.readDirectory = function (path, extensions, exclude, include, depth) { + var pattern = ts.getFileMatcherPatterns(path, exclude, include, this.shimHost.useCaseSensitiveFileNames(), this.shimHost.getCurrentDirectory()); // TODO: GH#18217 + return JSON.parse(this.shimHost.readDirectory(path, JSON.stringify(extensions), JSON.stringify(pattern.basePaths), pattern.excludePattern, pattern.includeFilePattern, pattern.includeDirectoryPattern, depth)); + }; + LanguageServiceShimHostAdapter.prototype.readFile = function (path, encoding) { + return this.shimHost.readFile(path, encoding); + }; + LanguageServiceShimHostAdapter.prototype.fileExists = function (path) { + return this.shimHost.fileExists(path); + }; + return LanguageServiceShimHostAdapter; + }()); + ts.LanguageServiceShimHostAdapter = LanguageServiceShimHostAdapter; + var CoreServicesShimHostAdapter = /** @class */ (function () { + function CoreServicesShimHostAdapter(shimHost) { + var _this = this; + this.shimHost = shimHost; + this.useCaseSensitiveFileNames = this.shimHost.useCaseSensitiveFileNames ? this.shimHost.useCaseSensitiveFileNames() : false; + if ("directoryExists" in this.shimHost) { + this.directoryExists = function (directoryName) { return _this.shimHost.directoryExists(directoryName); }; + } + else { + this.directoryExists = undefined; // TODO: GH#18217 + } + if ("realpath" in this.shimHost) { + this.realpath = function (path) { return _this.shimHost.realpath(path); }; // TODO: GH#18217 + } + else { + this.realpath = undefined; // TODO: GH#18217 + } + } + CoreServicesShimHostAdapter.prototype.readDirectory = function (rootDir, extensions, exclude, include, depth) { + var pattern = ts.getFileMatcherPatterns(rootDir, exclude, include, this.shimHost.useCaseSensitiveFileNames(), this.shimHost.getCurrentDirectory()); // TODO: GH#18217 + return JSON.parse(this.shimHost.readDirectory(rootDir, JSON.stringify(extensions), JSON.stringify(pattern.basePaths), pattern.excludePattern, pattern.includeFilePattern, pattern.includeDirectoryPattern, depth)); + }; + CoreServicesShimHostAdapter.prototype.fileExists = function (fileName) { + return this.shimHost.fileExists(fileName); + }; + CoreServicesShimHostAdapter.prototype.readFile = function (fileName) { + return this.shimHost.readFile(fileName); + }; + CoreServicesShimHostAdapter.prototype.getDirectories = function (path) { + return JSON.parse(this.shimHost.getDirectories(path)); + }; + return CoreServicesShimHostAdapter; + }()); + ts.CoreServicesShimHostAdapter = CoreServicesShimHostAdapter; + function simpleForwardCall(logger, actionDescription, action, logPerformance) { + var start; + if (logPerformance) { + logger.log(actionDescription); + start = ts.timestamp(); + } + var result = action(); + if (logPerformance) { + var end = ts.timestamp(); + logger.log("".concat(actionDescription, " completed in ").concat(end - start, " msec")); + if (ts.isString(result)) { + var str = result; + if (str.length > 128) { + str = str.substring(0, 128) + "..."; + } + logger.log(" result.length=".concat(str.length, ", result='").concat(JSON.stringify(str), "'")); + } + } + return result; + } + function forwardJSONCall(logger, actionDescription, action, logPerformance) { + return forwardCall(logger, actionDescription, /*returnJson*/ true, action, logPerformance); + } + function forwardCall(logger, actionDescription, returnJson, action, logPerformance) { + try { + var result = simpleForwardCall(logger, actionDescription, action, logPerformance); + return returnJson ? JSON.stringify({ result: result }) : result; + } + catch (err) { + if (err instanceof ts.OperationCanceledException) { + return JSON.stringify({ canceled: true }); + } + logInternalError(logger, err); + err.description = actionDescription; + return JSON.stringify({ error: err }); + } + } + var ShimBase = /** @class */ (function () { + function ShimBase(factory) { + this.factory = factory; + factory.registerShim(this); + } + ShimBase.prototype.dispose = function (_dummy) { + this.factory.unregisterShim(this); + }; + return ShimBase; + }()); + function realizeDiagnostics(diagnostics, newLine) { + return diagnostics.map(function (d) { return realizeDiagnostic(d, newLine); }); + } + ts.realizeDiagnostics = realizeDiagnostics; + function realizeDiagnostic(diagnostic, newLine) { + return { + message: ts.flattenDiagnosticMessageText(diagnostic.messageText, newLine), + start: diagnostic.start, + length: diagnostic.length, + category: ts.diagnosticCategoryName(diagnostic), + code: diagnostic.code, + reportsUnnecessary: diagnostic.reportsUnnecessary, + reportsDeprecated: diagnostic.reportsDeprecated + }; + } + var LanguageServiceShimObject = /** @class */ (function (_super) { + __extends(LanguageServiceShimObject, _super); + function LanguageServiceShimObject(factory, host, languageService) { + var _this = _super.call(this, factory) || this; + _this.host = host; + _this.languageService = languageService; + _this.logPerformance = false; + _this.logger = _this.host; + return _this; + } + LanguageServiceShimObject.prototype.forwardJSONCall = function (actionDescription, action) { + return forwardJSONCall(this.logger, actionDescription, action, this.logPerformance); + }; + /// DISPOSE + /** + * Ensure (almost) deterministic release of internal Javascript resources when + * some external native objects holds onto us (e.g. Com/Interop). + */ + LanguageServiceShimObject.prototype.dispose = function (dummy) { + this.logger.log("dispose()"); + this.languageService.dispose(); + this.languageService = null; // eslint-disable-line no-null/no-null + // force a GC + if (debugObjectHost && debugObjectHost.CollectGarbage) { + debugObjectHost.CollectGarbage(); + this.logger.log("CollectGarbage()"); + } + this.logger = null; // eslint-disable-line no-null/no-null + _super.prototype.dispose.call(this, dummy); + }; + /// REFRESH + /** + * Update the list of scripts known to the compiler + */ + LanguageServiceShimObject.prototype.refresh = function (throwOnError) { + this.forwardJSONCall("refresh(".concat(throwOnError, ")"), function () { return null; } // eslint-disable-line no-null/no-null + ); + }; + LanguageServiceShimObject.prototype.cleanupSemanticCache = function () { + var _this = this; + this.forwardJSONCall("cleanupSemanticCache()", function () { + _this.languageService.cleanupSemanticCache(); + return null; // eslint-disable-line no-null/no-null + }); + }; + LanguageServiceShimObject.prototype.realizeDiagnostics = function (diagnostics) { + var newLine = ts.getNewLineOrDefaultFromHost(this.host); + return realizeDiagnostics(diagnostics, newLine); + }; + LanguageServiceShimObject.prototype.getSyntacticClassifications = function (fileName, start, length) { + var _this = this; + return this.forwardJSONCall("getSyntacticClassifications('".concat(fileName, "', ").concat(start, ", ").concat(length, ")"), function () { return _this.languageService.getSyntacticClassifications(fileName, ts.createTextSpan(start, length)); }); + }; + LanguageServiceShimObject.prototype.getSemanticClassifications = function (fileName, start, length) { + var _this = this; + return this.forwardJSONCall("getSemanticClassifications('".concat(fileName, "', ").concat(start, ", ").concat(length, ")"), function () { return _this.languageService.getSemanticClassifications(fileName, ts.createTextSpan(start, length)); }); + }; + LanguageServiceShimObject.prototype.getEncodedSyntacticClassifications = function (fileName, start, length) { + var _this = this; + return this.forwardJSONCall("getEncodedSyntacticClassifications('".concat(fileName, "', ").concat(start, ", ").concat(length, ")"), + // directly serialize the spans out to a string. This is much faster to decode + // on the managed side versus a full JSON array. + function () { return convertClassifications(_this.languageService.getEncodedSyntacticClassifications(fileName, ts.createTextSpan(start, length))); }); + }; + LanguageServiceShimObject.prototype.getEncodedSemanticClassifications = function (fileName, start, length) { + var _this = this; + return this.forwardJSONCall("getEncodedSemanticClassifications('".concat(fileName, "', ").concat(start, ", ").concat(length, ")"), + // directly serialize the spans out to a string. This is much faster to decode + // on the managed side versus a full JSON array. + function () { return convertClassifications(_this.languageService.getEncodedSemanticClassifications(fileName, ts.createTextSpan(start, length))); }); + }; + LanguageServiceShimObject.prototype.getSyntacticDiagnostics = function (fileName) { + var _this = this; + return this.forwardJSONCall("getSyntacticDiagnostics('".concat(fileName, "')"), function () { + var diagnostics = _this.languageService.getSyntacticDiagnostics(fileName); + return _this.realizeDiagnostics(diagnostics); + }); + }; + LanguageServiceShimObject.prototype.getSemanticDiagnostics = function (fileName) { + var _this = this; + return this.forwardJSONCall("getSemanticDiagnostics('".concat(fileName, "')"), function () { + var diagnostics = _this.languageService.getSemanticDiagnostics(fileName); + return _this.realizeDiagnostics(diagnostics); + }); + }; + LanguageServiceShimObject.prototype.getSuggestionDiagnostics = function (fileName) { + var _this = this; + return this.forwardJSONCall("getSuggestionDiagnostics('".concat(fileName, "')"), function () { return _this.realizeDiagnostics(_this.languageService.getSuggestionDiagnostics(fileName)); }); + }; + LanguageServiceShimObject.prototype.getCompilerOptionsDiagnostics = function () { + var _this = this; + return this.forwardJSONCall("getCompilerOptionsDiagnostics()", function () { + var diagnostics = _this.languageService.getCompilerOptionsDiagnostics(); + return _this.realizeDiagnostics(diagnostics); + }); + }; + /// QUICKINFO + /** + * Computes a string representation of the type at the requested position + * in the active file. + */ + LanguageServiceShimObject.prototype.getQuickInfoAtPosition = function (fileName, position) { + var _this = this; + return this.forwardJSONCall("getQuickInfoAtPosition('".concat(fileName, "', ").concat(position, ")"), function () { return _this.languageService.getQuickInfoAtPosition(fileName, position); }); + }; + /// NAMEORDOTTEDNAMESPAN + /** + * Computes span information of the name or dotted name at the requested position + * in the active file. + */ + LanguageServiceShimObject.prototype.getNameOrDottedNameSpan = function (fileName, startPos, endPos) { + var _this = this; + return this.forwardJSONCall("getNameOrDottedNameSpan('".concat(fileName, "', ").concat(startPos, ", ").concat(endPos, ")"), function () { return _this.languageService.getNameOrDottedNameSpan(fileName, startPos, endPos); }); + }; + /** + * STATEMENTSPAN + * Computes span information of statement at the requested position in the active file. + */ + LanguageServiceShimObject.prototype.getBreakpointStatementAtPosition = function (fileName, position) { + var _this = this; + return this.forwardJSONCall("getBreakpointStatementAtPosition('".concat(fileName, "', ").concat(position, ")"), function () { return _this.languageService.getBreakpointStatementAtPosition(fileName, position); }); + }; + /// SIGNATUREHELP + LanguageServiceShimObject.prototype.getSignatureHelpItems = function (fileName, position, options) { + var _this = this; + return this.forwardJSONCall("getSignatureHelpItems('".concat(fileName, "', ").concat(position, ")"), function () { return _this.languageService.getSignatureHelpItems(fileName, position, options); }); + }; + /// GOTO DEFINITION + /** + * Computes the definition location and file for the symbol + * at the requested position. + */ + LanguageServiceShimObject.prototype.getDefinitionAtPosition = function (fileName, position) { + var _this = this; + return this.forwardJSONCall("getDefinitionAtPosition('".concat(fileName, "', ").concat(position, ")"), function () { return _this.languageService.getDefinitionAtPosition(fileName, position); }); + }; + /** + * Computes the definition location and file for the symbol + * at the requested position. + */ + LanguageServiceShimObject.prototype.getDefinitionAndBoundSpan = function (fileName, position) { + var _this = this; + return this.forwardJSONCall("getDefinitionAndBoundSpan('".concat(fileName, "', ").concat(position, ")"), function () { return _this.languageService.getDefinitionAndBoundSpan(fileName, position); }); + }; + /// GOTO Type + /** + * Computes the definition location of the type of the symbol + * at the requested position. + */ + LanguageServiceShimObject.prototype.getTypeDefinitionAtPosition = function (fileName, position) { + var _this = this; + return this.forwardJSONCall("getTypeDefinitionAtPosition('".concat(fileName, "', ").concat(position, ")"), function () { return _this.languageService.getTypeDefinitionAtPosition(fileName, position); }); + }; + /// GOTO Implementation + /** + * Computes the implementation location of the symbol + * at the requested position. + */ + LanguageServiceShimObject.prototype.getImplementationAtPosition = function (fileName, position) { + var _this = this; + return this.forwardJSONCall("getImplementationAtPosition('".concat(fileName, "', ").concat(position, ")"), function () { return _this.languageService.getImplementationAtPosition(fileName, position); }); + }; + LanguageServiceShimObject.prototype.getRenameInfo = function (fileName, position, preferences) { + var _this = this; + return this.forwardJSONCall("getRenameInfo('".concat(fileName, "', ").concat(position, ")"), function () { return _this.languageService.getRenameInfo(fileName, position, preferences); }); + }; + LanguageServiceShimObject.prototype.getSmartSelectionRange = function (fileName, position) { + var _this = this; + return this.forwardJSONCall("getSmartSelectionRange('".concat(fileName, "', ").concat(position, ")"), function () { return _this.languageService.getSmartSelectionRange(fileName, position); }); + }; + LanguageServiceShimObject.prototype.findRenameLocations = function (fileName, position, findInStrings, findInComments, providePrefixAndSuffixTextForRename) { + var _this = this; + return this.forwardJSONCall("findRenameLocations('".concat(fileName, "', ").concat(position, ", ").concat(findInStrings, ", ").concat(findInComments, ", ").concat(providePrefixAndSuffixTextForRename, ")"), function () { return _this.languageService.findRenameLocations(fileName, position, findInStrings, findInComments, providePrefixAndSuffixTextForRename); }); + }; + /// GET BRACE MATCHING + LanguageServiceShimObject.prototype.getBraceMatchingAtPosition = function (fileName, position) { + var _this = this; + return this.forwardJSONCall("getBraceMatchingAtPosition('".concat(fileName, "', ").concat(position, ")"), function () { return _this.languageService.getBraceMatchingAtPosition(fileName, position); }); + }; + LanguageServiceShimObject.prototype.isValidBraceCompletionAtPosition = function (fileName, position, openingBrace) { + var _this = this; + return this.forwardJSONCall("isValidBraceCompletionAtPosition('".concat(fileName, "', ").concat(position, ", ").concat(openingBrace, ")"), function () { return _this.languageService.isValidBraceCompletionAtPosition(fileName, position, openingBrace); }); + }; + LanguageServiceShimObject.prototype.getSpanOfEnclosingComment = function (fileName, position, onlyMultiLine) { + var _this = this; + return this.forwardJSONCall("getSpanOfEnclosingComment('".concat(fileName, "', ").concat(position, ")"), function () { return _this.languageService.getSpanOfEnclosingComment(fileName, position, onlyMultiLine); }); + }; + /// GET SMART INDENT + LanguageServiceShimObject.prototype.getIndentationAtPosition = function (fileName, position, options /*Services.EditorOptions*/) { + var _this = this; + return this.forwardJSONCall("getIndentationAtPosition('".concat(fileName, "', ").concat(position, ")"), function () { + var localOptions = JSON.parse(options); + return _this.languageService.getIndentationAtPosition(fileName, position, localOptions); + }); + }; + /// GET REFERENCES + LanguageServiceShimObject.prototype.getReferencesAtPosition = function (fileName, position) { + var _this = this; + return this.forwardJSONCall("getReferencesAtPosition('".concat(fileName, "', ").concat(position, ")"), function () { return _this.languageService.getReferencesAtPosition(fileName, position); }); + }; + LanguageServiceShimObject.prototype.findReferences = function (fileName, position) { + var _this = this; + return this.forwardJSONCall("findReferences('".concat(fileName, "', ").concat(position, ")"), function () { return _this.languageService.findReferences(fileName, position); }); + }; + LanguageServiceShimObject.prototype.getFileReferences = function (fileName) { + var _this = this; + return this.forwardJSONCall("getFileReferences('".concat(fileName, ")"), function () { return _this.languageService.getFileReferences(fileName); }); + }; + LanguageServiceShimObject.prototype.getOccurrencesAtPosition = function (fileName, position) { + var _this = this; + return this.forwardJSONCall("getOccurrencesAtPosition('".concat(fileName, "', ").concat(position, ")"), function () { return _this.languageService.getOccurrencesAtPosition(fileName, position); }); + }; + LanguageServiceShimObject.prototype.getDocumentHighlights = function (fileName, position, filesToSearch) { + var _this = this; + return this.forwardJSONCall("getDocumentHighlights('".concat(fileName, "', ").concat(position, ")"), function () { + var results = _this.languageService.getDocumentHighlights(fileName, position, JSON.parse(filesToSearch)); + // workaround for VS document highlighting issue - keep only items from the initial file + var normalizedName = ts.toFileNameLowerCase(ts.normalizeSlashes(fileName)); + return ts.filter(results, function (r) { return ts.toFileNameLowerCase(ts.normalizeSlashes(r.fileName)) === normalizedName; }); + }); + }; + /// COMPLETION LISTS + /** + * Get a string based representation of the completions + * to provide at the given source position and providing a member completion + * list if requested. + */ + LanguageServiceShimObject.prototype.getCompletionsAtPosition = function (fileName, position, preferences, formattingSettings) { + var _this = this; + return this.forwardJSONCall("getCompletionsAtPosition('".concat(fileName, "', ").concat(position, ", ").concat(preferences, ", ").concat(formattingSettings, ")"), function () { return _this.languageService.getCompletionsAtPosition(fileName, position, preferences, formattingSettings); }); + }; + /** Get a string based representation of a completion list entry details */ + LanguageServiceShimObject.prototype.getCompletionEntryDetails = function (fileName, position, entryName, formatOptions, source, preferences, data) { + var _this = this; + return this.forwardJSONCall("getCompletionEntryDetails('".concat(fileName, "', ").concat(position, ", '").concat(entryName, "')"), function () { + var localOptions = formatOptions === undefined ? undefined : JSON.parse(formatOptions); + return _this.languageService.getCompletionEntryDetails(fileName, position, entryName, localOptions, source, preferences, data); + }); + }; + LanguageServiceShimObject.prototype.getFormattingEditsForRange = function (fileName, start, end, options /*Services.FormatCodeOptions*/) { + var _this = this; + return this.forwardJSONCall("getFormattingEditsForRange('".concat(fileName, "', ").concat(start, ", ").concat(end, ")"), function () { + var localOptions = JSON.parse(options); + return _this.languageService.getFormattingEditsForRange(fileName, start, end, localOptions); + }); + }; + LanguageServiceShimObject.prototype.getFormattingEditsForDocument = function (fileName, options /*Services.FormatCodeOptions*/) { + var _this = this; + return this.forwardJSONCall("getFormattingEditsForDocument('".concat(fileName, "')"), function () { + var localOptions = JSON.parse(options); + return _this.languageService.getFormattingEditsForDocument(fileName, localOptions); + }); + }; + LanguageServiceShimObject.prototype.getFormattingEditsAfterKeystroke = function (fileName, position, key, options /*Services.FormatCodeOptions*/) { + var _this = this; + return this.forwardJSONCall("getFormattingEditsAfterKeystroke('".concat(fileName, "', ").concat(position, ", '").concat(key, "')"), function () { + var localOptions = JSON.parse(options); + return _this.languageService.getFormattingEditsAfterKeystroke(fileName, position, key, localOptions); + }); + }; + LanguageServiceShimObject.prototype.getDocCommentTemplateAtPosition = function (fileName, position, options) { + var _this = this; + return this.forwardJSONCall("getDocCommentTemplateAtPosition('".concat(fileName, "', ").concat(position, ")"), function () { return _this.languageService.getDocCommentTemplateAtPosition(fileName, position, options); }); + }; + /// NAVIGATE TO + /** Return a list of symbols that are interesting to navigate to */ + LanguageServiceShimObject.prototype.getNavigateToItems = function (searchValue, maxResultCount, fileName) { + var _this = this; + return this.forwardJSONCall("getNavigateToItems('".concat(searchValue, "', ").concat(maxResultCount, ", ").concat(fileName, ")"), function () { return _this.languageService.getNavigateToItems(searchValue, maxResultCount, fileName); }); + }; + LanguageServiceShimObject.prototype.getNavigationBarItems = function (fileName) { + var _this = this; + return this.forwardJSONCall("getNavigationBarItems('".concat(fileName, "')"), function () { return _this.languageService.getNavigationBarItems(fileName); }); + }; + LanguageServiceShimObject.prototype.getNavigationTree = function (fileName) { + var _this = this; + return this.forwardJSONCall("getNavigationTree('".concat(fileName, "')"), function () { return _this.languageService.getNavigationTree(fileName); }); + }; + LanguageServiceShimObject.prototype.getOutliningSpans = function (fileName) { + var _this = this; + return this.forwardJSONCall("getOutliningSpans('".concat(fileName, "')"), function () { return _this.languageService.getOutliningSpans(fileName); }); + }; + LanguageServiceShimObject.prototype.getTodoComments = function (fileName, descriptors) { + var _this = this; + return this.forwardJSONCall("getTodoComments('".concat(fileName, "')"), function () { return _this.languageService.getTodoComments(fileName, JSON.parse(descriptors)); }); + }; + /// CALL HIERARCHY + LanguageServiceShimObject.prototype.prepareCallHierarchy = function (fileName, position) { + var _this = this; + return this.forwardJSONCall("prepareCallHierarchy('".concat(fileName, "', ").concat(position, ")"), function () { return _this.languageService.prepareCallHierarchy(fileName, position); }); + }; + LanguageServiceShimObject.prototype.provideCallHierarchyIncomingCalls = function (fileName, position) { + var _this = this; + return this.forwardJSONCall("provideCallHierarchyIncomingCalls('".concat(fileName, "', ").concat(position, ")"), function () { return _this.languageService.provideCallHierarchyIncomingCalls(fileName, position); }); + }; + LanguageServiceShimObject.prototype.provideCallHierarchyOutgoingCalls = function (fileName, position) { + var _this = this; + return this.forwardJSONCall("provideCallHierarchyOutgoingCalls('".concat(fileName, "', ").concat(position, ")"), function () { return _this.languageService.provideCallHierarchyOutgoingCalls(fileName, position); }); + }; + LanguageServiceShimObject.prototype.provideInlayHints = function (fileName, span, preference) { + var _this = this; + return this.forwardJSONCall("provideInlayHints('".concat(fileName, "', '").concat(JSON.stringify(span), "', ").concat(JSON.stringify(preference), ")"), function () { return _this.languageService.provideInlayHints(fileName, span, preference); }); + }; + /// Emit + LanguageServiceShimObject.prototype.getEmitOutput = function (fileName) { + var _this = this; + return this.forwardJSONCall("getEmitOutput('".concat(fileName, "')"), function () { + var _a = _this.languageService.getEmitOutput(fileName), diagnostics = _a.diagnostics, rest = __rest(_a, ["diagnostics"]); + return __assign(__assign({}, rest), { diagnostics: _this.realizeDiagnostics(diagnostics) }); + }); + }; + LanguageServiceShimObject.prototype.getEmitOutputObject = function (fileName) { + var _this = this; + return forwardCall(this.logger, "getEmitOutput('".concat(fileName, "')"), + /*returnJson*/ false, function () { return _this.languageService.getEmitOutput(fileName); }, this.logPerformance); + }; + LanguageServiceShimObject.prototype.toggleLineComment = function (fileName, textRange) { + var _this = this; + return this.forwardJSONCall("toggleLineComment('".concat(fileName, "', '").concat(JSON.stringify(textRange), "')"), function () { return _this.languageService.toggleLineComment(fileName, textRange); }); + }; + LanguageServiceShimObject.prototype.toggleMultilineComment = function (fileName, textRange) { + var _this = this; + return this.forwardJSONCall("toggleMultilineComment('".concat(fileName, "', '").concat(JSON.stringify(textRange), "')"), function () { return _this.languageService.toggleMultilineComment(fileName, textRange); }); + }; + LanguageServiceShimObject.prototype.commentSelection = function (fileName, textRange) { + var _this = this; + return this.forwardJSONCall("commentSelection('".concat(fileName, "', '").concat(JSON.stringify(textRange), "')"), function () { return _this.languageService.commentSelection(fileName, textRange); }); + }; + LanguageServiceShimObject.prototype.uncommentSelection = function (fileName, textRange) { + var _this = this; + return this.forwardJSONCall("uncommentSelection('".concat(fileName, "', '").concat(JSON.stringify(textRange), "')"), function () { return _this.languageService.uncommentSelection(fileName, textRange); }); + }; + return LanguageServiceShimObject; + }(ShimBase)); + function convertClassifications(classifications) { + return { spans: classifications.spans.join(","), endOfLineState: classifications.endOfLineState }; + } + var ClassifierShimObject = /** @class */ (function (_super) { + __extends(ClassifierShimObject, _super); + function ClassifierShimObject(factory, logger) { + var _this = _super.call(this, factory) || this; + _this.logger = logger; + _this.logPerformance = false; + _this.classifier = ts.createClassifier(); + return _this; + } + ClassifierShimObject.prototype.getEncodedLexicalClassifications = function (text, lexState, syntacticClassifierAbsent) { + var _this = this; + if (syntacticClassifierAbsent === void 0) { syntacticClassifierAbsent = false; } + return forwardJSONCall(this.logger, "getEncodedLexicalClassifications", function () { return convertClassifications(_this.classifier.getEncodedLexicalClassifications(text, lexState, syntacticClassifierAbsent)); }, this.logPerformance); + }; + /// COLORIZATION + ClassifierShimObject.prototype.getClassificationsForLine = function (text, lexState, classifyKeywordsInGenerics) { + if (classifyKeywordsInGenerics === void 0) { classifyKeywordsInGenerics = false; } + var classification = this.classifier.getClassificationsForLine(text, lexState, classifyKeywordsInGenerics); + var result = ""; + for (var _i = 0, _a = classification.entries; _i < _a.length; _i++) { + var item = _a[_i]; + result += item.length + "\n"; + result += item.classification + "\n"; + } + result += classification.finalLexState; + return result; + }; + return ClassifierShimObject; + }(ShimBase)); + var CoreServicesShimObject = /** @class */ (function (_super) { + __extends(CoreServicesShimObject, _super); + function CoreServicesShimObject(factory, logger, host) { + var _this = _super.call(this, factory) || this; + _this.logger = logger; + _this.host = host; + _this.logPerformance = false; + return _this; + } + CoreServicesShimObject.prototype.forwardJSONCall = function (actionDescription, action) { + return forwardJSONCall(this.logger, actionDescription, action, this.logPerformance); + }; + CoreServicesShimObject.prototype.resolveModuleName = function (fileName, moduleName, compilerOptionsJson) { + var _this = this; + return this.forwardJSONCall("resolveModuleName('".concat(fileName, "')"), function () { + var compilerOptions = JSON.parse(compilerOptionsJson); + var result = ts.resolveModuleName(moduleName, ts.normalizeSlashes(fileName), compilerOptions, _this.host); + var resolvedFileName = result.resolvedModule ? result.resolvedModule.resolvedFileName : undefined; + if (result.resolvedModule && result.resolvedModule.extension !== ".ts" /* Extension.Ts */ && result.resolvedModule.extension !== ".tsx" /* Extension.Tsx */ && result.resolvedModule.extension !== ".d.ts" /* Extension.Dts */) { + resolvedFileName = undefined; + } + return { + resolvedFileName: resolvedFileName, + failedLookupLocations: result.failedLookupLocations, + affectingLocations: result.affectingLocations, + }; + }); + }; + CoreServicesShimObject.prototype.resolveTypeReferenceDirective = function (fileName, typeReferenceDirective, compilerOptionsJson) { + var _this = this; + return this.forwardJSONCall("resolveTypeReferenceDirective(".concat(fileName, ")"), function () { + var compilerOptions = JSON.parse(compilerOptionsJson); + var result = ts.resolveTypeReferenceDirective(typeReferenceDirective, ts.normalizeSlashes(fileName), compilerOptions, _this.host); + return { + resolvedFileName: result.resolvedTypeReferenceDirective ? result.resolvedTypeReferenceDirective.resolvedFileName : undefined, + primary: result.resolvedTypeReferenceDirective ? result.resolvedTypeReferenceDirective.primary : true, + failedLookupLocations: result.failedLookupLocations + }; + }); + }; + CoreServicesShimObject.prototype.getPreProcessedFileInfo = function (fileName, sourceTextSnapshot) { + var _this = this; + return this.forwardJSONCall("getPreProcessedFileInfo('".concat(fileName, "')"), function () { + // for now treat files as JavaScript + var result = ts.preProcessFile(ts.getSnapshotText(sourceTextSnapshot), /* readImportFiles */ true, /* detectJavaScriptImports */ true); + return { + referencedFiles: _this.convertFileReferences(result.referencedFiles), + importedFiles: _this.convertFileReferences(result.importedFiles), + ambientExternalModules: result.ambientExternalModules, + isLibFile: result.isLibFile, + typeReferenceDirectives: _this.convertFileReferences(result.typeReferenceDirectives), + libReferenceDirectives: _this.convertFileReferences(result.libReferenceDirectives) + }; + }); + }; + CoreServicesShimObject.prototype.getAutomaticTypeDirectiveNames = function (compilerOptionsJson) { + var _this = this; + return this.forwardJSONCall("getAutomaticTypeDirectiveNames('".concat(compilerOptionsJson, "')"), function () { + var compilerOptions = JSON.parse(compilerOptionsJson); + return ts.getAutomaticTypeDirectiveNames(compilerOptions, _this.host); + }); + }; + CoreServicesShimObject.prototype.convertFileReferences = function (refs) { + if (!refs) { + return undefined; + } + var result = []; + for (var _i = 0, refs_1 = refs; _i < refs_1.length; _i++) { + var ref = refs_1[_i]; + result.push({ + path: ts.normalizeSlashes(ref.fileName), + position: ref.pos, + length: ref.end - ref.pos + }); + } + return result; + }; + CoreServicesShimObject.prototype.getTSConfigFileInfo = function (fileName, sourceTextSnapshot) { + var _this = this; + return this.forwardJSONCall("getTSConfigFileInfo('".concat(fileName, "')"), function () { + var result = ts.parseJsonText(fileName, ts.getSnapshotText(sourceTextSnapshot)); + var normalizedFileName = ts.normalizeSlashes(fileName); + var configFile = ts.parseJsonSourceFileConfigFileContent(result, _this.host, ts.getDirectoryPath(normalizedFileName), /*existingOptions*/ {}, normalizedFileName); + return { + options: configFile.options, + typeAcquisition: configFile.typeAcquisition, + files: configFile.fileNames, + raw: configFile.raw, + errors: realizeDiagnostics(__spreadArray(__spreadArray([], result.parseDiagnostics, true), configFile.errors, true), "\r\n") + }; + }); + }; + CoreServicesShimObject.prototype.getDefaultCompilationSettings = function () { + return this.forwardJSONCall("getDefaultCompilationSettings()", function () { return ts.getDefaultCompilerOptions(); }); + }; + CoreServicesShimObject.prototype.discoverTypings = function (discoverTypingsJson) { + var _this = this; + var getCanonicalFileName = ts.createGetCanonicalFileName(/*useCaseSensitivefileNames:*/ false); + return this.forwardJSONCall("discoverTypings()", function () { + var info = JSON.parse(discoverTypingsJson); + if (_this.safeList === undefined) { + _this.safeList = ts.JsTyping.loadSafeList(_this.host, ts.toPath(info.safeListPath, info.safeListPath, getCanonicalFileName)); + } + return ts.JsTyping.discoverTypings(_this.host, function (msg) { return _this.logger.log(msg); }, info.fileNames, ts.toPath(info.projectRootPath, info.projectRootPath, getCanonicalFileName), _this.safeList, info.packageNameToTypingLocation, info.typeAcquisition, info.unresolvedImports, info.typesRegistry, ts.emptyOptions); + }); + }; + return CoreServicesShimObject; + }(ShimBase)); + var TypeScriptServicesFactory = /** @class */ (function () { + function TypeScriptServicesFactory() { + this._shims = []; + } + /* + * Returns script API version. + */ + TypeScriptServicesFactory.prototype.getServicesVersion = function () { + return ts.servicesVersion; + }; + TypeScriptServicesFactory.prototype.createLanguageServiceShim = function (host) { + try { + if (this.documentRegistry === undefined) { + this.documentRegistry = ts.createDocumentRegistry(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames(), host.getCurrentDirectory()); + } + var hostAdapter = new LanguageServiceShimHostAdapter(host); + var languageService = ts.createLanguageService(hostAdapter, this.documentRegistry, /*syntaxOnly*/ false); + return new LanguageServiceShimObject(this, host, languageService); + } + catch (err) { + logInternalError(host, err); + throw err; + } + }; + TypeScriptServicesFactory.prototype.createClassifierShim = function (logger) { + try { + return new ClassifierShimObject(this, logger); + } + catch (err) { + logInternalError(logger, err); + throw err; + } + }; + TypeScriptServicesFactory.prototype.createCoreServicesShim = function (host) { + try { + var adapter = new CoreServicesShimHostAdapter(host); + return new CoreServicesShimObject(this, host, adapter); + } + catch (err) { + logInternalError(host, err); + throw err; + } + }; + TypeScriptServicesFactory.prototype.close = function () { + // Forget all the registered shims + ts.clear(this._shims); + this.documentRegistry = undefined; + }; + TypeScriptServicesFactory.prototype.registerShim = function (shim) { + this._shims.push(shim); + }; + TypeScriptServicesFactory.prototype.unregisterShim = function (shim) { + for (var i = 0; i < this._shims.length; i++) { + if (this._shims[i] === shim) { + delete this._shims[i]; + return; + } + } + throw new Error("Invalid operation"); + }; + return TypeScriptServicesFactory; + }()); + ts.TypeScriptServicesFactory = TypeScriptServicesFactory; +})(ts || (ts = {})); +/* eslint-enable local/no-in-operator */ +// We polyfill `globalThis` here so re can reliably patch the global scope +// in the contexts we want to in the same way across script and module formats +/* eslint-enable no-var */ +((function () { + if (typeof globalThis === "object") + return; + try { + Object.defineProperty(Object.prototype, "__magic__", { + get: function () { + return this; + }, + configurable: true + }); + //@ts-ignore + __magic__.globalThis = __magic__; + // The previous line should have made `globalThis` globally + // available, but it fails in Internet Explorer 10 and older. + // Detect this failure and fall back. + if (typeof globalThis === "undefined") { + // Assume `window` exists. + //@ts-ignore + window.globalThis = window; + } + //@ts-ignore + delete Object.prototype.__magic__; + } + catch (error) { + // In IE8, Object.defineProperty only works on DOM objects. + // If we hit this code path, assume `window` exists. + //@ts-ignore + window.globalThis = window; + } +})()); +// #endregion The polyfill ends here. +// if `process` is undefined, we're probably not running in node - patch legacy members onto the global scope +// @ts-ignore +if (typeof process === "undefined" || process.browser) { + /// TODO: this is used by VS, clean this up on both sides of the interface + //@ts-ignore + globalThis.TypeScript = globalThis.TypeScript || {}; + //@ts-ignore + globalThis.TypeScript.Services = globalThis.TypeScript.Services || {}; + //@ts-ignore + globalThis.TypeScript.Services.TypeScriptServicesFactory = ts.TypeScriptServicesFactory; + // 'toolsVersion' gets consumed by the managed side, so it's not unused. + // TODO: it should be moved into a namespace though. + //@ts-ignore + globalThis.toolsVersion = ts.versionMajorMinor; +} +if (typeof module !== "undefined" && module.exports) { + module.exports = ts; +} +// The following are deprecations for the public API. Deprecated exports are removed from the compiler itself +// and compatible implementations are added here, along with an appropriate deprecation warning using +// the `@deprecated` JSDoc tag as well as the `Debug.deprecate` API. +// +// Deprecations fall into one of three categories: +// +// - "soft" - Soft deprecations are indicated with the `@deprecated` JSDoc Tag. +// - "warn" - Warning deprecations are indicated with the `@deprecated` JSDoc Tag and a diagnostic message (assuming a compatible host). +// - "error" - Error deprecations are either indicated with the `@deprecated` JSDoc tag and will throw a `TypeError` when invoked, or removed from the API entirely. +// +// Once we have determined enough time has passed after a deprecation has been marked as `"warn"` or `"error"`, it will be removed from the public API. +/* @internal */ +var ts; +(function (ts) { + function createOverload(name, overloads, binder, deprecations) { + Object.defineProperty(call, "name", __assign(__assign({}, Object.getOwnPropertyDescriptor(call, "name")), { value: name })); + if (deprecations) { + for (var _i = 0, _a = Object.keys(deprecations); _i < _a.length; _i++) { + var key = _a[_i]; + var index = +key; + if (!isNaN(index) && ts.hasProperty(overloads, "".concat(index))) { + overloads[index] = ts.Debug.deprecate(overloads[index], __assign(__assign({}, deprecations[index]), { name: name })); + } + } + } + var bind = createBinder(overloads, binder); + return call; + function call() { + var args = []; + for (var _i = 0; _i < arguments.length; _i++) { + args[_i] = arguments[_i]; + } + var index = bind(args); + var fn = index !== undefined ? overloads[index] : undefined; + if (typeof fn === "function") { + return fn.apply(void 0, args); + } + throw new TypeError("Invalid arguments"); + } + } + ts.createOverload = createOverload; + function createBinder(overloads, binder) { + return function (args) { + for (var i = 0; ts.hasProperty(overloads, "".concat(i)) && ts.hasProperty(binder, "".concat(i)); i++) { + var fn = binder[i]; + if (fn(args)) { + return i; + } + } + }; + } + // NOTE: We only use this "builder" because we don't infer correctly when calling `createOverload` directly in < TS 4.7, + // but lib is currently at TS 4.4. We can switch to directly calling `createOverload` when we update LKG in main. + function buildOverload(name) { + return { + overload: function (overloads) { return ({ + bind: function (binder) { return ({ + finish: function () { return createOverload(name, overloads, binder); }, + deprecate: function (deprecations) { return ({ + finish: function () { return createOverload(name, overloads, binder, deprecations); } + }); } + }); } + }); } + }; + } + ts.buildOverload = buildOverload; +})(ts || (ts = {})); +// DEPRECATION: Node factory top-level exports +// DEPRECATION PLAN: +// - soft: 4.0 +// - warn: 4.1 +// - error: 5.0 +var ts; +(function (ts) { + // NOTE: These exports are deprecated in favor of using a `NodeFactory` instance and exist here purely for backwards compatibility reasons. + var factoryDeprecation = { since: "4.0", warnAfter: "4.1", message: "Use the appropriate method on 'ts.factory' or the 'factory' supplied by your transformation context instead." }; + /** @deprecated Use `factory.createNodeArray` or the factory supplied by your transformation context instead. */ + ts.createNodeArray = ts.Debug.deprecate(ts.factory.createNodeArray, factoryDeprecation); + /** @deprecated Use `factory.createNumericLiteral` or the factory supplied by your transformation context instead. */ + ts.createNumericLiteral = ts.Debug.deprecate(ts.factory.createNumericLiteral, factoryDeprecation); + /** @deprecated Use `factory.createBigIntLiteral` or the factory supplied by your transformation context instead. */ + ts.createBigIntLiteral = ts.Debug.deprecate(ts.factory.createBigIntLiteral, factoryDeprecation); + /** @deprecated Use `factory.createStringLiteral` or the factory supplied by your transformation context instead. */ + ts.createStringLiteral = ts.Debug.deprecate(ts.factory.createStringLiteral, factoryDeprecation); + /** @deprecated Use `factory.createStringLiteralFromNode` or the factory supplied by your transformation context instead. */ + ts.createStringLiteralFromNode = ts.Debug.deprecate(ts.factory.createStringLiteralFromNode, factoryDeprecation); + /** @deprecated Use `factory.createRegularExpressionLiteral` or the factory supplied by your transformation context instead. */ + ts.createRegularExpressionLiteral = ts.Debug.deprecate(ts.factory.createRegularExpressionLiteral, factoryDeprecation); + /** @deprecated Use `factory.createLoopVariable` or the factory supplied by your transformation context instead. */ + ts.createLoopVariable = ts.Debug.deprecate(ts.factory.createLoopVariable, factoryDeprecation); + /** @deprecated Use `factory.createUniqueName` or the factory supplied by your transformation context instead. */ + ts.createUniqueName = ts.Debug.deprecate(ts.factory.createUniqueName, factoryDeprecation); + /** @deprecated Use `factory.createPrivateIdentifier` or the factory supplied by your transformation context instead. */ + ts.createPrivateIdentifier = ts.Debug.deprecate(ts.factory.createPrivateIdentifier, factoryDeprecation); + /** @deprecated Use `factory.createSuper` or the factory supplied by your transformation context instead. */ + ts.createSuper = ts.Debug.deprecate(ts.factory.createSuper, factoryDeprecation); + /** @deprecated Use `factory.createThis` or the factory supplied by your transformation context instead. */ + ts.createThis = ts.Debug.deprecate(ts.factory.createThis, factoryDeprecation); + /** @deprecated Use `factory.createNull` or the factory supplied by your transformation context instead. */ + ts.createNull = ts.Debug.deprecate(ts.factory.createNull, factoryDeprecation); + /** @deprecated Use `factory.createTrue` or the factory supplied by your transformation context instead. */ + ts.createTrue = ts.Debug.deprecate(ts.factory.createTrue, factoryDeprecation); + /** @deprecated Use `factory.createFalse` or the factory supplied by your transformation context instead. */ + ts.createFalse = ts.Debug.deprecate(ts.factory.createFalse, factoryDeprecation); + /** @deprecated Use `factory.createModifier` or the factory supplied by your transformation context instead. */ + ts.createModifier = ts.Debug.deprecate(ts.factory.createModifier, factoryDeprecation); + /** @deprecated Use `factory.createModifiersFromModifierFlags` or the factory supplied by your transformation context instead. */ + ts.createModifiersFromModifierFlags = ts.Debug.deprecate(ts.factory.createModifiersFromModifierFlags, factoryDeprecation); + /** @deprecated Use `factory.createQualifiedName` or the factory supplied by your transformation context instead. */ + ts.createQualifiedName = ts.Debug.deprecate(ts.factory.createQualifiedName, factoryDeprecation); + /** @deprecated Use `factory.updateQualifiedName` or the factory supplied by your transformation context instead. */ + ts.updateQualifiedName = ts.Debug.deprecate(ts.factory.updateQualifiedName, factoryDeprecation); + /** @deprecated Use `factory.createComputedPropertyName` or the factory supplied by your transformation context instead. */ + ts.createComputedPropertyName = ts.Debug.deprecate(ts.factory.createComputedPropertyName, factoryDeprecation); + /** @deprecated Use `factory.updateComputedPropertyName` or the factory supplied by your transformation context instead. */ + ts.updateComputedPropertyName = ts.Debug.deprecate(ts.factory.updateComputedPropertyName, factoryDeprecation); + /** @deprecated Use `factory.createTypeParameterDeclaration` or the factory supplied by your transformation context instead. */ + ts.createTypeParameterDeclaration = ts.Debug.deprecate(ts.factory.createTypeParameterDeclaration, factoryDeprecation); + /** @deprecated Use `factory.updateTypeParameterDeclaration` or the factory supplied by your transformation context instead. */ + ts.updateTypeParameterDeclaration = ts.Debug.deprecate(ts.factory.updateTypeParameterDeclaration, factoryDeprecation); + /** @deprecated Use `factory.createParameterDeclaration` or the factory supplied by your transformation context instead. */ + ts.createParameter = ts.Debug.deprecate(ts.factory.createParameterDeclaration, factoryDeprecation); + /** @deprecated Use `factory.updateParameterDeclaration` or the factory supplied by your transformation context instead. */ + ts.updateParameter = ts.Debug.deprecate(ts.factory.updateParameterDeclaration, factoryDeprecation); + /** @deprecated Use `factory.createDecorator` or the factory supplied by your transformation context instead. */ + ts.createDecorator = ts.Debug.deprecate(ts.factory.createDecorator, factoryDeprecation); + /** @deprecated Use `factory.updateDecorator` or the factory supplied by your transformation context instead. */ + ts.updateDecorator = ts.Debug.deprecate(ts.factory.updateDecorator, factoryDeprecation); + /** @deprecated Use `factory.createPropertyDeclaration` or the factory supplied by your transformation context instead. */ + ts.createProperty = ts.Debug.deprecate(ts.factory.createPropertyDeclaration, factoryDeprecation); + /** @deprecated Use `factory.updatePropertyDeclaration` or the factory supplied by your transformation context instead. */ + ts.updateProperty = ts.Debug.deprecate(ts.factory.updatePropertyDeclaration, factoryDeprecation); + /** @deprecated Use `factory.createMethodDeclaration` or the factory supplied by your transformation context instead. */ + ts.createMethod = ts.Debug.deprecate(ts.factory.createMethodDeclaration, factoryDeprecation); + /** @deprecated Use `factory.updateMethodDeclaration` or the factory supplied by your transformation context instead. */ + ts.updateMethod = ts.Debug.deprecate(ts.factory.updateMethodDeclaration, factoryDeprecation); + /** @deprecated Use `factory.createConstructorDeclaration` or the factory supplied by your transformation context instead. */ + ts.createConstructor = ts.Debug.deprecate(ts.factory.createConstructorDeclaration, factoryDeprecation); + /** @deprecated Use `factory.updateConstructorDeclaration` or the factory supplied by your transformation context instead. */ + ts.updateConstructor = ts.Debug.deprecate(ts.factory.updateConstructorDeclaration, factoryDeprecation); + /** @deprecated Use `factory.createGetAccessorDeclaration` or the factory supplied by your transformation context instead. */ + ts.createGetAccessor = ts.Debug.deprecate(ts.factory.createGetAccessorDeclaration, factoryDeprecation); + /** @deprecated Use `factory.updateGetAccessorDeclaration` or the factory supplied by your transformation context instead. */ + ts.updateGetAccessor = ts.Debug.deprecate(ts.factory.updateGetAccessorDeclaration, factoryDeprecation); + /** @deprecated Use `factory.createSetAccessorDeclaration` or the factory supplied by your transformation context instead. */ + ts.createSetAccessor = ts.Debug.deprecate(ts.factory.createSetAccessorDeclaration, factoryDeprecation); + /** @deprecated Use `factory.updateSetAccessorDeclaration` or the factory supplied by your transformation context instead. */ + ts.updateSetAccessor = ts.Debug.deprecate(ts.factory.updateSetAccessorDeclaration, factoryDeprecation); + /** @deprecated Use `factory.createCallSignature` or the factory supplied by your transformation context instead. */ + ts.createCallSignature = ts.Debug.deprecate(ts.factory.createCallSignature, factoryDeprecation); + /** @deprecated Use `factory.updateCallSignature` or the factory supplied by your transformation context instead. */ + ts.updateCallSignature = ts.Debug.deprecate(ts.factory.updateCallSignature, factoryDeprecation); + /** @deprecated Use `factory.createConstructSignature` or the factory supplied by your transformation context instead. */ + ts.createConstructSignature = ts.Debug.deprecate(ts.factory.createConstructSignature, factoryDeprecation); + /** @deprecated Use `factory.updateConstructSignature` or the factory supplied by your transformation context instead. */ + ts.updateConstructSignature = ts.Debug.deprecate(ts.factory.updateConstructSignature, factoryDeprecation); + /** @deprecated Use `factory.updateIndexSignature` or the factory supplied by your transformation context instead. */ + ts.updateIndexSignature = ts.Debug.deprecate(ts.factory.updateIndexSignature, factoryDeprecation); + /** @deprecated Use `factory.createKeywordTypeNode` or the factory supplied by your transformation context instead. */ + ts.createKeywordTypeNode = ts.Debug.deprecate(ts.factory.createKeywordTypeNode, factoryDeprecation); + /** @deprecated Use `factory.createTypePredicateNode` or the factory supplied by your transformation context instead. */ + ts.createTypePredicateNodeWithModifier = ts.Debug.deprecate(ts.factory.createTypePredicateNode, factoryDeprecation); + /** @deprecated Use `factory.updateTypePredicateNode` or the factory supplied by your transformation context instead. */ + ts.updateTypePredicateNodeWithModifier = ts.Debug.deprecate(ts.factory.updateTypePredicateNode, factoryDeprecation); + /** @deprecated Use `factory.createTypeReferenceNode` or the factory supplied by your transformation context instead. */ + ts.createTypeReferenceNode = ts.Debug.deprecate(ts.factory.createTypeReferenceNode, factoryDeprecation); + /** @deprecated Use `factory.updateTypeReferenceNode` or the factory supplied by your transformation context instead. */ + ts.updateTypeReferenceNode = ts.Debug.deprecate(ts.factory.updateTypeReferenceNode, factoryDeprecation); + /** @deprecated Use `factory.createFunctionTypeNode` or the factory supplied by your transformation context instead. */ + ts.createFunctionTypeNode = ts.Debug.deprecate(ts.factory.createFunctionTypeNode, factoryDeprecation); + /** @deprecated Use `factory.updateFunctionTypeNode` or the factory supplied by your transformation context instead. */ + ts.updateFunctionTypeNode = ts.Debug.deprecate(ts.factory.updateFunctionTypeNode, factoryDeprecation); + /** @deprecated Use `factory.createConstructorTypeNode` or the factory supplied by your transformation context instead. */ + ts.createConstructorTypeNode = ts.Debug.deprecate(function (typeParameters, parameters, type) { + return ts.factory.createConstructorTypeNode(/*modifiers*/ undefined, typeParameters, parameters, type); + }, factoryDeprecation); + /** @deprecated Use `factory.updateConstructorTypeNode` or the factory supplied by your transformation context instead. */ + ts.updateConstructorTypeNode = ts.Debug.deprecate(function (node, typeParameters, parameters, type) { + return ts.factory.updateConstructorTypeNode(node, node.modifiers, typeParameters, parameters, type); + }, factoryDeprecation); + /** @deprecated Use `factory.createTypeQueryNode` or the factory supplied by your transformation context instead. */ + ts.createTypeQueryNode = ts.Debug.deprecate(ts.factory.createTypeQueryNode, factoryDeprecation); + /** @deprecated Use `factory.updateTypeQueryNode` or the factory supplied by your transformation context instead. */ + ts.updateTypeQueryNode = ts.Debug.deprecate(ts.factory.updateTypeQueryNode, factoryDeprecation); + /** @deprecated Use `factory.createTypeLiteralNode` or the factory supplied by your transformation context instead. */ + ts.createTypeLiteralNode = ts.Debug.deprecate(ts.factory.createTypeLiteralNode, factoryDeprecation); + /** @deprecated Use `factory.updateTypeLiteralNode` or the factory supplied by your transformation context instead. */ + ts.updateTypeLiteralNode = ts.Debug.deprecate(ts.factory.updateTypeLiteralNode, factoryDeprecation); + /** @deprecated Use `factory.createArrayTypeNode` or the factory supplied by your transformation context instead. */ + ts.createArrayTypeNode = ts.Debug.deprecate(ts.factory.createArrayTypeNode, factoryDeprecation); + /** @deprecated Use `factory.updateArrayTypeNode` or the factory supplied by your transformation context instead. */ + ts.updateArrayTypeNode = ts.Debug.deprecate(ts.factory.updateArrayTypeNode, factoryDeprecation); + /** @deprecated Use `factory.createTupleTypeNode` or the factory supplied by your transformation context instead. */ + ts.createTupleTypeNode = ts.Debug.deprecate(ts.factory.createTupleTypeNode, factoryDeprecation); + /** @deprecated Use `factory.updateTupleTypeNode` or the factory supplied by your transformation context instead. */ + ts.updateTupleTypeNode = ts.Debug.deprecate(ts.factory.updateTupleTypeNode, factoryDeprecation); + /** @deprecated Use `factory.createOptionalTypeNode` or the factory supplied by your transformation context instead. */ + ts.createOptionalTypeNode = ts.Debug.deprecate(ts.factory.createOptionalTypeNode, factoryDeprecation); + /** @deprecated Use `factory.updateOptionalTypeNode` or the factory supplied by your transformation context instead. */ + ts.updateOptionalTypeNode = ts.Debug.deprecate(ts.factory.updateOptionalTypeNode, factoryDeprecation); + /** @deprecated Use `factory.createRestTypeNode` or the factory supplied by your transformation context instead. */ + ts.createRestTypeNode = ts.Debug.deprecate(ts.factory.createRestTypeNode, factoryDeprecation); + /** @deprecated Use `factory.updateRestTypeNode` or the factory supplied by your transformation context instead. */ + ts.updateRestTypeNode = ts.Debug.deprecate(ts.factory.updateRestTypeNode, factoryDeprecation); + /** @deprecated Use `factory.createUnionTypeNode` or the factory supplied by your transformation context instead. */ + ts.createUnionTypeNode = ts.Debug.deprecate(ts.factory.createUnionTypeNode, factoryDeprecation); + /** @deprecated Use `factory.updateUnionTypeNode` or the factory supplied by your transformation context instead. */ + ts.updateUnionTypeNode = ts.Debug.deprecate(ts.factory.updateUnionTypeNode, factoryDeprecation); + /** @deprecated Use `factory.createIntersectionTypeNode` or the factory supplied by your transformation context instead. */ + ts.createIntersectionTypeNode = ts.Debug.deprecate(ts.factory.createIntersectionTypeNode, factoryDeprecation); + /** @deprecated Use `factory.updateIntersectionTypeNode` or the factory supplied by your transformation context instead. */ + ts.updateIntersectionTypeNode = ts.Debug.deprecate(ts.factory.updateIntersectionTypeNode, factoryDeprecation); + /** @deprecated Use `factory.createConditionalTypeNode` or the factory supplied by your transformation context instead. */ + ts.createConditionalTypeNode = ts.Debug.deprecate(ts.factory.createConditionalTypeNode, factoryDeprecation); + /** @deprecated Use `factory.updateConditionalTypeNode` or the factory supplied by your transformation context instead. */ + ts.updateConditionalTypeNode = ts.Debug.deprecate(ts.factory.updateConditionalTypeNode, factoryDeprecation); + /** @deprecated Use `factory.createInferTypeNode` or the factory supplied by your transformation context instead. */ + ts.createInferTypeNode = ts.Debug.deprecate(ts.factory.createInferTypeNode, factoryDeprecation); + /** @deprecated Use `factory.updateInferTypeNode` or the factory supplied by your transformation context instead. */ + ts.updateInferTypeNode = ts.Debug.deprecate(ts.factory.updateInferTypeNode, factoryDeprecation); + /** @deprecated Use `factory.createImportTypeNode` or the factory supplied by your transformation context instead. */ + ts.createImportTypeNode = ts.Debug.deprecate(ts.factory.createImportTypeNode, factoryDeprecation); + /** @deprecated Use `factory.updateImportTypeNode` or the factory supplied by your transformation context instead. */ + ts.updateImportTypeNode = ts.Debug.deprecate(ts.factory.updateImportTypeNode, factoryDeprecation); + /** @deprecated Use `factory.createParenthesizedType` or the factory supplied by your transformation context instead. */ + ts.createParenthesizedType = ts.Debug.deprecate(ts.factory.createParenthesizedType, factoryDeprecation); + /** @deprecated Use `factory.updateParenthesizedType` or the factory supplied by your transformation context instead. */ + ts.updateParenthesizedType = ts.Debug.deprecate(ts.factory.updateParenthesizedType, factoryDeprecation); + /** @deprecated Use `factory.createThisTypeNode` or the factory supplied by your transformation context instead. */ + ts.createThisTypeNode = ts.Debug.deprecate(ts.factory.createThisTypeNode, factoryDeprecation); + /** @deprecated Use `factory.updateTypeOperatorNode` or the factory supplied by your transformation context instead. */ + ts.updateTypeOperatorNode = ts.Debug.deprecate(ts.factory.updateTypeOperatorNode, factoryDeprecation); + /** @deprecated Use `factory.createIndexedAccessTypeNode` or the factory supplied by your transformation context instead. */ + ts.createIndexedAccessTypeNode = ts.Debug.deprecate(ts.factory.createIndexedAccessTypeNode, factoryDeprecation); + /** @deprecated Use `factory.updateIndexedAccessTypeNode` or the factory supplied by your transformation context instead. */ + ts.updateIndexedAccessTypeNode = ts.Debug.deprecate(ts.factory.updateIndexedAccessTypeNode, factoryDeprecation); + /** @deprecated Use `factory.createMappedTypeNode` or the factory supplied by your transformation context instead. */ + ts.createMappedTypeNode = ts.Debug.deprecate(ts.factory.createMappedTypeNode, factoryDeprecation); + /** @deprecated Use `factory.updateMappedTypeNode` or the factory supplied by your transformation context instead. */ + ts.updateMappedTypeNode = ts.Debug.deprecate(ts.factory.updateMappedTypeNode, factoryDeprecation); + /** @deprecated Use `factory.createLiteralTypeNode` or the factory supplied by your transformation context instead. */ + ts.createLiteralTypeNode = ts.Debug.deprecate(ts.factory.createLiteralTypeNode, factoryDeprecation); + /** @deprecated Use `factory.updateLiteralTypeNode` or the factory supplied by your transformation context instead. */ + ts.updateLiteralTypeNode = ts.Debug.deprecate(ts.factory.updateLiteralTypeNode, factoryDeprecation); + /** @deprecated Use `factory.createObjectBindingPattern` or the factory supplied by your transformation context instead. */ + ts.createObjectBindingPattern = ts.Debug.deprecate(ts.factory.createObjectBindingPattern, factoryDeprecation); + /** @deprecated Use `factory.updateObjectBindingPattern` or the factory supplied by your transformation context instead. */ + ts.updateObjectBindingPattern = ts.Debug.deprecate(ts.factory.updateObjectBindingPattern, factoryDeprecation); + /** @deprecated Use `factory.createArrayBindingPattern` or the factory supplied by your transformation context instead. */ + ts.createArrayBindingPattern = ts.Debug.deprecate(ts.factory.createArrayBindingPattern, factoryDeprecation); + /** @deprecated Use `factory.updateArrayBindingPattern` or the factory supplied by your transformation context instead. */ + ts.updateArrayBindingPattern = ts.Debug.deprecate(ts.factory.updateArrayBindingPattern, factoryDeprecation); + /** @deprecated Use `factory.createBindingElement` or the factory supplied by your transformation context instead. */ + ts.createBindingElement = ts.Debug.deprecate(ts.factory.createBindingElement, factoryDeprecation); + /** @deprecated Use `factory.updateBindingElement` or the factory supplied by your transformation context instead. */ + ts.updateBindingElement = ts.Debug.deprecate(ts.factory.updateBindingElement, factoryDeprecation); + /** @deprecated Use `factory.createArrayLiteralExpression` or the factory supplied by your transformation context instead. */ + ts.createArrayLiteral = ts.Debug.deprecate(ts.factory.createArrayLiteralExpression, factoryDeprecation); + /** @deprecated Use `factory.updateArrayLiteralExpression` or the factory supplied by your transformation context instead. */ + ts.updateArrayLiteral = ts.Debug.deprecate(ts.factory.updateArrayLiteralExpression, factoryDeprecation); + /** @deprecated Use `factory.createObjectLiteralExpression` or the factory supplied by your transformation context instead. */ + ts.createObjectLiteral = ts.Debug.deprecate(ts.factory.createObjectLiteralExpression, factoryDeprecation); + /** @deprecated Use `factory.updateObjectLiteralExpression` or the factory supplied by your transformation context instead. */ + ts.updateObjectLiteral = ts.Debug.deprecate(ts.factory.updateObjectLiteralExpression, factoryDeprecation); + /** @deprecated Use `factory.createPropertyAccessExpression` or the factory supplied by your transformation context instead. */ + ts.createPropertyAccess = ts.Debug.deprecate(ts.factory.createPropertyAccessExpression, factoryDeprecation); + /** @deprecated Use `factory.updatePropertyAccessExpression` or the factory supplied by your transformation context instead. */ + ts.updatePropertyAccess = ts.Debug.deprecate(ts.factory.updatePropertyAccessExpression, factoryDeprecation); + /** @deprecated Use `factory.createPropertyAccessChain` or the factory supplied by your transformation context instead. */ + ts.createPropertyAccessChain = ts.Debug.deprecate(ts.factory.createPropertyAccessChain, factoryDeprecation); + /** @deprecated Use `factory.updatePropertyAccessChain` or the factory supplied by your transformation context instead. */ + ts.updatePropertyAccessChain = ts.Debug.deprecate(ts.factory.updatePropertyAccessChain, factoryDeprecation); + /** @deprecated Use `factory.createElementAccessExpression` or the factory supplied by your transformation context instead. */ + ts.createElementAccess = ts.Debug.deprecate(ts.factory.createElementAccessExpression, factoryDeprecation); + /** @deprecated Use `factory.updateElementAccessExpression` or the factory supplied by your transformation context instead. */ + ts.updateElementAccess = ts.Debug.deprecate(ts.factory.updateElementAccessExpression, factoryDeprecation); + /** @deprecated Use `factory.createElementAccessChain` or the factory supplied by your transformation context instead. */ + ts.createElementAccessChain = ts.Debug.deprecate(ts.factory.createElementAccessChain, factoryDeprecation); + /** @deprecated Use `factory.updateElementAccessChain` or the factory supplied by your transformation context instead. */ + ts.updateElementAccessChain = ts.Debug.deprecate(ts.factory.updateElementAccessChain, factoryDeprecation); + /** @deprecated Use `factory.createCallExpression` or the factory supplied by your transformation context instead. */ + ts.createCall = ts.Debug.deprecate(ts.factory.createCallExpression, factoryDeprecation); + /** @deprecated Use `factory.updateCallExpression` or the factory supplied by your transformation context instead. */ + ts.updateCall = ts.Debug.deprecate(ts.factory.updateCallExpression, factoryDeprecation); + /** @deprecated Use `factory.createCallChain` or the factory supplied by your transformation context instead. */ + ts.createCallChain = ts.Debug.deprecate(ts.factory.createCallChain, factoryDeprecation); + /** @deprecated Use `factory.updateCallChain` or the factory supplied by your transformation context instead. */ + ts.updateCallChain = ts.Debug.deprecate(ts.factory.updateCallChain, factoryDeprecation); + /** @deprecated Use `factory.createNewExpression` or the factory supplied by your transformation context instead. */ + ts.createNew = ts.Debug.deprecate(ts.factory.createNewExpression, factoryDeprecation); + /** @deprecated Use `factory.updateNewExpression` or the factory supplied by your transformation context instead. */ + ts.updateNew = ts.Debug.deprecate(ts.factory.updateNewExpression, factoryDeprecation); + /** @deprecated Use `factory.createTypeAssertion` or the factory supplied by your transformation context instead. */ + ts.createTypeAssertion = ts.Debug.deprecate(ts.factory.createTypeAssertion, factoryDeprecation); + /** @deprecated Use `factory.updateTypeAssertion` or the factory supplied by your transformation context instead. */ + ts.updateTypeAssertion = ts.Debug.deprecate(ts.factory.updateTypeAssertion, factoryDeprecation); + /** @deprecated Use `factory.createParenthesizedExpression` or the factory supplied by your transformation context instead. */ + ts.createParen = ts.Debug.deprecate(ts.factory.createParenthesizedExpression, factoryDeprecation); + /** @deprecated Use `factory.updateParenthesizedExpression` or the factory supplied by your transformation context instead. */ + ts.updateParen = ts.Debug.deprecate(ts.factory.updateParenthesizedExpression, factoryDeprecation); + /** @deprecated Use `factory.createFunctionExpression` or the factory supplied by your transformation context instead. */ + ts.createFunctionExpression = ts.Debug.deprecate(ts.factory.createFunctionExpression, factoryDeprecation); + /** @deprecated Use `factory.updateFunctionExpression` or the factory supplied by your transformation context instead. */ + ts.updateFunctionExpression = ts.Debug.deprecate(ts.factory.updateFunctionExpression, factoryDeprecation); + /** @deprecated Use `factory.createDeleteExpression` or the factory supplied by your transformation context instead. */ + ts.createDelete = ts.Debug.deprecate(ts.factory.createDeleteExpression, factoryDeprecation); + /** @deprecated Use `factory.updateDeleteExpression` or the factory supplied by your transformation context instead. */ + ts.updateDelete = ts.Debug.deprecate(ts.factory.updateDeleteExpression, factoryDeprecation); + /** @deprecated Use `factory.createTypeOfExpression` or the factory supplied by your transformation context instead. */ + ts.createTypeOf = ts.Debug.deprecate(ts.factory.createTypeOfExpression, factoryDeprecation); + /** @deprecated Use `factory.updateTypeOfExpression` or the factory supplied by your transformation context instead. */ + ts.updateTypeOf = ts.Debug.deprecate(ts.factory.updateTypeOfExpression, factoryDeprecation); + /** @deprecated Use `factory.createVoidExpression` or the factory supplied by your transformation context instead. */ + ts.createVoid = ts.Debug.deprecate(ts.factory.createVoidExpression, factoryDeprecation); + /** @deprecated Use `factory.updateVoidExpression` or the factory supplied by your transformation context instead. */ + ts.updateVoid = ts.Debug.deprecate(ts.factory.updateVoidExpression, factoryDeprecation); + /** @deprecated Use `factory.createAwaitExpression` or the factory supplied by your transformation context instead. */ + ts.createAwait = ts.Debug.deprecate(ts.factory.createAwaitExpression, factoryDeprecation); + /** @deprecated Use `factory.updateAwaitExpression` or the factory supplied by your transformation context instead. */ + ts.updateAwait = ts.Debug.deprecate(ts.factory.updateAwaitExpression, factoryDeprecation); + /** @deprecated Use `factory.createPrefixExpression` or the factory supplied by your transformation context instead. */ + ts.createPrefix = ts.Debug.deprecate(ts.factory.createPrefixUnaryExpression, factoryDeprecation); + /** @deprecated Use `factory.updatePrefixExpression` or the factory supplied by your transformation context instead. */ + ts.updatePrefix = ts.Debug.deprecate(ts.factory.updatePrefixUnaryExpression, factoryDeprecation); + /** @deprecated Use `factory.createPostfixUnaryExpression` or the factory supplied by your transformation context instead. */ + ts.createPostfix = ts.Debug.deprecate(ts.factory.createPostfixUnaryExpression, factoryDeprecation); + /** @deprecated Use `factory.updatePostfixUnaryExpression` or the factory supplied by your transformation context instead. */ + ts.updatePostfix = ts.Debug.deprecate(ts.factory.updatePostfixUnaryExpression, factoryDeprecation); + /** @deprecated Use `factory.createBinaryExpression` or the factory supplied by your transformation context instead. */ + ts.createBinary = ts.Debug.deprecate(ts.factory.createBinaryExpression, factoryDeprecation); + /** @deprecated Use `factory.updateConditionalExpression` or the factory supplied by your transformation context instead. */ + ts.updateConditional = ts.Debug.deprecate(ts.factory.updateConditionalExpression, factoryDeprecation); + /** @deprecated Use `factory.createTemplateExpression` or the factory supplied by your transformation context instead. */ + ts.createTemplateExpression = ts.Debug.deprecate(ts.factory.createTemplateExpression, factoryDeprecation); + /** @deprecated Use `factory.updateTemplateExpression` or the factory supplied by your transformation context instead. */ + ts.updateTemplateExpression = ts.Debug.deprecate(ts.factory.updateTemplateExpression, factoryDeprecation); + /** @deprecated Use `factory.createTemplateHead` or the factory supplied by your transformation context instead. */ + ts.createTemplateHead = ts.Debug.deprecate(ts.factory.createTemplateHead, factoryDeprecation); + /** @deprecated Use `factory.createTemplateMiddle` or the factory supplied by your transformation context instead. */ + ts.createTemplateMiddle = ts.Debug.deprecate(ts.factory.createTemplateMiddle, factoryDeprecation); + /** @deprecated Use `factory.createTemplateTail` or the factory supplied by your transformation context instead. */ + ts.createTemplateTail = ts.Debug.deprecate(ts.factory.createTemplateTail, factoryDeprecation); + /** @deprecated Use `factory.createNoSubstitutionTemplateLiteral` or the factory supplied by your transformation context instead. */ + ts.createNoSubstitutionTemplateLiteral = ts.Debug.deprecate(ts.factory.createNoSubstitutionTemplateLiteral, factoryDeprecation); + /** @deprecated Use `factory.updateYieldExpression` or the factory supplied by your transformation context instead. */ + ts.updateYield = ts.Debug.deprecate(ts.factory.updateYieldExpression, factoryDeprecation); + /** @deprecated Use `factory.createSpreadExpression` or the factory supplied by your transformation context instead. */ + ts.createSpread = ts.Debug.deprecate(ts.factory.createSpreadElement, factoryDeprecation); + /** @deprecated Use `factory.updateSpreadExpression` or the factory supplied by your transformation context instead. */ + ts.updateSpread = ts.Debug.deprecate(ts.factory.updateSpreadElement, factoryDeprecation); + /** @deprecated Use `factory.createOmittedExpression` or the factory supplied by your transformation context instead. */ + ts.createOmittedExpression = ts.Debug.deprecate(ts.factory.createOmittedExpression, factoryDeprecation); + /** @deprecated Use `factory.createAsExpression` or the factory supplied by your transformation context instead. */ + ts.createAsExpression = ts.Debug.deprecate(ts.factory.createAsExpression, factoryDeprecation); + /** @deprecated Use `factory.updateAsExpression` or the factory supplied by your transformation context instead. */ + ts.updateAsExpression = ts.Debug.deprecate(ts.factory.updateAsExpression, factoryDeprecation); + /** @deprecated Use `factory.createNonNullExpression` or the factory supplied by your transformation context instead. */ + ts.createNonNullExpression = ts.Debug.deprecate(ts.factory.createNonNullExpression, factoryDeprecation); + /** @deprecated Use `factory.updateNonNullExpression` or the factory supplied by your transformation context instead. */ + ts.updateNonNullExpression = ts.Debug.deprecate(ts.factory.updateNonNullExpression, factoryDeprecation); + /** @deprecated Use `factory.createNonNullChain` or the factory supplied by your transformation context instead. */ + ts.createNonNullChain = ts.Debug.deprecate(ts.factory.createNonNullChain, factoryDeprecation); + /** @deprecated Use `factory.updateNonNullChain` or the factory supplied by your transformation context instead. */ + ts.updateNonNullChain = ts.Debug.deprecate(ts.factory.updateNonNullChain, factoryDeprecation); + /** @deprecated Use `factory.createMetaProperty` or the factory supplied by your transformation context instead. */ + ts.createMetaProperty = ts.Debug.deprecate(ts.factory.createMetaProperty, factoryDeprecation); + /** @deprecated Use `factory.updateMetaProperty` or the factory supplied by your transformation context instead. */ + ts.updateMetaProperty = ts.Debug.deprecate(ts.factory.updateMetaProperty, factoryDeprecation); + /** @deprecated Use `factory.createTemplateSpan` or the factory supplied by your transformation context instead. */ + ts.createTemplateSpan = ts.Debug.deprecate(ts.factory.createTemplateSpan, factoryDeprecation); + /** @deprecated Use `factory.updateTemplateSpan` or the factory supplied by your transformation context instead. */ + ts.updateTemplateSpan = ts.Debug.deprecate(ts.factory.updateTemplateSpan, factoryDeprecation); + /** @deprecated Use `factory.createSemicolonClassElement` or the factory supplied by your transformation context instead. */ + ts.createSemicolonClassElement = ts.Debug.deprecate(ts.factory.createSemicolonClassElement, factoryDeprecation); + /** @deprecated Use `factory.createBlock` or the factory supplied by your transformation context instead. */ + ts.createBlock = ts.Debug.deprecate(ts.factory.createBlock, factoryDeprecation); + /** @deprecated Use `factory.updateBlock` or the factory supplied by your transformation context instead. */ + ts.updateBlock = ts.Debug.deprecate(ts.factory.updateBlock, factoryDeprecation); + /** @deprecated Use `factory.createVariableStatement` or the factory supplied by your transformation context instead. */ + ts.createVariableStatement = ts.Debug.deprecate(ts.factory.createVariableStatement, factoryDeprecation); + /** @deprecated Use `factory.updateVariableStatement` or the factory supplied by your transformation context instead. */ + ts.updateVariableStatement = ts.Debug.deprecate(ts.factory.updateVariableStatement, factoryDeprecation); + /** @deprecated Use `factory.createEmptyStatement` or the factory supplied by your transformation context instead. */ + ts.createEmptyStatement = ts.Debug.deprecate(ts.factory.createEmptyStatement, factoryDeprecation); + /** @deprecated Use `factory.createExpressionStatement` or the factory supplied by your transformation context instead. */ + ts.createExpressionStatement = ts.Debug.deprecate(ts.factory.createExpressionStatement, factoryDeprecation); + /** @deprecated Use `factory.updateExpressionStatement` or the factory supplied by your transformation context instead. */ + ts.updateExpressionStatement = ts.Debug.deprecate(ts.factory.updateExpressionStatement, factoryDeprecation); + /** @deprecated Use `factory.createExpressionStatement` or the factory supplied by your transformation context instead. */ + ts.createStatement = ts.Debug.deprecate(ts.factory.createExpressionStatement, factoryDeprecation); + /** @deprecated Use `factory.updateExpressionStatement` or the factory supplied by your transformation context instead. */ + ts.updateStatement = ts.Debug.deprecate(ts.factory.updateExpressionStatement, factoryDeprecation); + /** @deprecated Use `factory.createIfStatement` or the factory supplied by your transformation context instead. */ + ts.createIf = ts.Debug.deprecate(ts.factory.createIfStatement, factoryDeprecation); + /** @deprecated Use `factory.updateIfStatement` or the factory supplied by your transformation context instead. */ + ts.updateIf = ts.Debug.deprecate(ts.factory.updateIfStatement, factoryDeprecation); + /** @deprecated Use `factory.createDoStatement` or the factory supplied by your transformation context instead. */ + ts.createDo = ts.Debug.deprecate(ts.factory.createDoStatement, factoryDeprecation); + /** @deprecated Use `factory.updateDoStatement` or the factory supplied by your transformation context instead. */ + ts.updateDo = ts.Debug.deprecate(ts.factory.updateDoStatement, factoryDeprecation); + /** @deprecated Use `factory.createWhileStatement` or the factory supplied by your transformation context instead. */ + ts.createWhile = ts.Debug.deprecate(ts.factory.createWhileStatement, factoryDeprecation); + /** @deprecated Use `factory.updateWhileStatement` or the factory supplied by your transformation context instead. */ + ts.updateWhile = ts.Debug.deprecate(ts.factory.updateWhileStatement, factoryDeprecation); + /** @deprecated Use `factory.createForStatement` or the factory supplied by your transformation context instead. */ + ts.createFor = ts.Debug.deprecate(ts.factory.createForStatement, factoryDeprecation); + /** @deprecated Use `factory.updateForStatement` or the factory supplied by your transformation context instead. */ + ts.updateFor = ts.Debug.deprecate(ts.factory.updateForStatement, factoryDeprecation); + /** @deprecated Use `factory.createForInStatement` or the factory supplied by your transformation context instead. */ + ts.createForIn = ts.Debug.deprecate(ts.factory.createForInStatement, factoryDeprecation); + /** @deprecated Use `factory.updateForInStatement` or the factory supplied by your transformation context instead. */ + ts.updateForIn = ts.Debug.deprecate(ts.factory.updateForInStatement, factoryDeprecation); + /** @deprecated Use `factory.createForOfStatement` or the factory supplied by your transformation context instead. */ + ts.createForOf = ts.Debug.deprecate(ts.factory.createForOfStatement, factoryDeprecation); + /** @deprecated Use `factory.updateForOfStatement` or the factory supplied by your transformation context instead. */ + ts.updateForOf = ts.Debug.deprecate(ts.factory.updateForOfStatement, factoryDeprecation); + /** @deprecated Use `factory.createContinueStatement` or the factory supplied by your transformation context instead. */ + ts.createContinue = ts.Debug.deprecate(ts.factory.createContinueStatement, factoryDeprecation); + /** @deprecated Use `factory.updateContinueStatement` or the factory supplied by your transformation context instead. */ + ts.updateContinue = ts.Debug.deprecate(ts.factory.updateContinueStatement, factoryDeprecation); + /** @deprecated Use `factory.createBreakStatement` or the factory supplied by your transformation context instead. */ + ts.createBreak = ts.Debug.deprecate(ts.factory.createBreakStatement, factoryDeprecation); + /** @deprecated Use `factory.updateBreakStatement` or the factory supplied by your transformation context instead. */ + ts.updateBreak = ts.Debug.deprecate(ts.factory.updateBreakStatement, factoryDeprecation); + /** @deprecated Use `factory.createReturnStatement` or the factory supplied by your transformation context instead. */ + ts.createReturn = ts.Debug.deprecate(ts.factory.createReturnStatement, factoryDeprecation); + /** @deprecated Use `factory.updateReturnStatement` or the factory supplied by your transformation context instead. */ + ts.updateReturn = ts.Debug.deprecate(ts.factory.updateReturnStatement, factoryDeprecation); + /** @deprecated Use `factory.createWithStatement` or the factory supplied by your transformation context instead. */ + ts.createWith = ts.Debug.deprecate(ts.factory.createWithStatement, factoryDeprecation); + /** @deprecated Use `factory.updateWithStatement` or the factory supplied by your transformation context instead. */ + ts.updateWith = ts.Debug.deprecate(ts.factory.updateWithStatement, factoryDeprecation); + /** @deprecated Use `factory.createSwitchStatement` or the factory supplied by your transformation context instead. */ + ts.createSwitch = ts.Debug.deprecate(ts.factory.createSwitchStatement, factoryDeprecation); + /** @deprecated Use `factory.updateSwitchStatement` or the factory supplied by your transformation context instead. */ + ts.updateSwitch = ts.Debug.deprecate(ts.factory.updateSwitchStatement, factoryDeprecation); + /** @deprecated Use `factory.createLabelStatement` or the factory supplied by your transformation context instead. */ + ts.createLabel = ts.Debug.deprecate(ts.factory.createLabeledStatement, factoryDeprecation); + /** @deprecated Use `factory.updateLabelStatement` or the factory supplied by your transformation context instead. */ + ts.updateLabel = ts.Debug.deprecate(ts.factory.updateLabeledStatement, factoryDeprecation); + /** @deprecated Use `factory.createThrowStatement` or the factory supplied by your transformation context instead. */ + ts.createThrow = ts.Debug.deprecate(ts.factory.createThrowStatement, factoryDeprecation); + /** @deprecated Use `factory.updateThrowStatement` or the factory supplied by your transformation context instead. */ + ts.updateThrow = ts.Debug.deprecate(ts.factory.updateThrowStatement, factoryDeprecation); + /** @deprecated Use `factory.createTryStatement` or the factory supplied by your transformation context instead. */ + ts.createTry = ts.Debug.deprecate(ts.factory.createTryStatement, factoryDeprecation); + /** @deprecated Use `factory.updateTryStatement` or the factory supplied by your transformation context instead. */ + ts.updateTry = ts.Debug.deprecate(ts.factory.updateTryStatement, factoryDeprecation); + /** @deprecated Use `factory.createDebuggerStatement` or the factory supplied by your transformation context instead. */ + ts.createDebuggerStatement = ts.Debug.deprecate(ts.factory.createDebuggerStatement, factoryDeprecation); + /** @deprecated Use `factory.createVariableDeclarationList` or the factory supplied by your transformation context instead. */ + ts.createVariableDeclarationList = ts.Debug.deprecate(ts.factory.createVariableDeclarationList, factoryDeprecation); + /** @deprecated Use `factory.updateVariableDeclarationList` or the factory supplied by your transformation context instead. */ + ts.updateVariableDeclarationList = ts.Debug.deprecate(ts.factory.updateVariableDeclarationList, factoryDeprecation); + /** @deprecated Use `factory.createFunctionDeclaration` or the factory supplied by your transformation context instead. */ + ts.createFunctionDeclaration = ts.Debug.deprecate(ts.factory.createFunctionDeclaration, factoryDeprecation); + /** @deprecated Use `factory.updateFunctionDeclaration` or the factory supplied by your transformation context instead. */ + ts.updateFunctionDeclaration = ts.Debug.deprecate(ts.factory.updateFunctionDeclaration, factoryDeprecation); + /** @deprecated Use `factory.createClassDeclaration` or the factory supplied by your transformation context instead. */ + ts.createClassDeclaration = ts.Debug.deprecate(ts.factory.createClassDeclaration, factoryDeprecation); + /** @deprecated Use `factory.updateClassDeclaration` or the factory supplied by your transformation context instead. */ + ts.updateClassDeclaration = ts.Debug.deprecate(ts.factory.updateClassDeclaration, factoryDeprecation); + /** @deprecated Use `factory.createInterfaceDeclaration` or the factory supplied by your transformation context instead. */ + ts.createInterfaceDeclaration = ts.Debug.deprecate(ts.factory.createInterfaceDeclaration, factoryDeprecation); + /** @deprecated Use `factory.updateInterfaceDeclaration` or the factory supplied by your transformation context instead. */ + ts.updateInterfaceDeclaration = ts.Debug.deprecate(ts.factory.updateInterfaceDeclaration, factoryDeprecation); + /** @deprecated Use `factory.createTypeAliasDeclaration` or the factory supplied by your transformation context instead. */ + ts.createTypeAliasDeclaration = ts.Debug.deprecate(ts.factory.createTypeAliasDeclaration, factoryDeprecation); + /** @deprecated Use `factory.updateTypeAliasDeclaration` or the factory supplied by your transformation context instead. */ + ts.updateTypeAliasDeclaration = ts.Debug.deprecate(ts.factory.updateTypeAliasDeclaration, factoryDeprecation); + /** @deprecated Use `factory.createEnumDeclaration` or the factory supplied by your transformation context instead. */ + ts.createEnumDeclaration = ts.Debug.deprecate(ts.factory.createEnumDeclaration, factoryDeprecation); + /** @deprecated Use `factory.updateEnumDeclaration` or the factory supplied by your transformation context instead. */ + ts.updateEnumDeclaration = ts.Debug.deprecate(ts.factory.updateEnumDeclaration, factoryDeprecation); + /** @deprecated Use `factory.createModuleDeclaration` or the factory supplied by your transformation context instead. */ + ts.createModuleDeclaration = ts.Debug.deprecate(ts.factory.createModuleDeclaration, factoryDeprecation); + /** @deprecated Use `factory.updateModuleDeclaration` or the factory supplied by your transformation context instead. */ + ts.updateModuleDeclaration = ts.Debug.deprecate(ts.factory.updateModuleDeclaration, factoryDeprecation); + /** @deprecated Use `factory.createModuleBlock` or the factory supplied by your transformation context instead. */ + ts.createModuleBlock = ts.Debug.deprecate(ts.factory.createModuleBlock, factoryDeprecation); + /** @deprecated Use `factory.updateModuleBlock` or the factory supplied by your transformation context instead. */ + ts.updateModuleBlock = ts.Debug.deprecate(ts.factory.updateModuleBlock, factoryDeprecation); + /** @deprecated Use `factory.createCaseBlock` or the factory supplied by your transformation context instead. */ + ts.createCaseBlock = ts.Debug.deprecate(ts.factory.createCaseBlock, factoryDeprecation); + /** @deprecated Use `factory.updateCaseBlock` or the factory supplied by your transformation context instead. */ + ts.updateCaseBlock = ts.Debug.deprecate(ts.factory.updateCaseBlock, factoryDeprecation); + /** @deprecated Use `factory.createNamespaceExportDeclaration` or the factory supplied by your transformation context instead. */ + ts.createNamespaceExportDeclaration = ts.Debug.deprecate(ts.factory.createNamespaceExportDeclaration, factoryDeprecation); + /** @deprecated Use `factory.updateNamespaceExportDeclaration` or the factory supplied by your transformation context instead. */ + ts.updateNamespaceExportDeclaration = ts.Debug.deprecate(ts.factory.updateNamespaceExportDeclaration, factoryDeprecation); + /** @deprecated Use `factory.createImportEqualsDeclaration` or the factory supplied by your transformation context instead. */ + ts.createImportEqualsDeclaration = ts.Debug.deprecate(ts.factory.createImportEqualsDeclaration, factoryDeprecation); + /** @deprecated Use `factory.updateImportEqualsDeclaration` or the factory supplied by your transformation context instead. */ + ts.updateImportEqualsDeclaration = ts.Debug.deprecate(ts.factory.updateImportEqualsDeclaration, factoryDeprecation); + /** @deprecated Use `factory.createImportDeclaration` or the factory supplied by your transformation context instead. */ + ts.createImportDeclaration = ts.Debug.deprecate(ts.factory.createImportDeclaration, factoryDeprecation); + /** @deprecated Use `factory.updateImportDeclaration` or the factory supplied by your transformation context instead. */ + ts.updateImportDeclaration = ts.Debug.deprecate(ts.factory.updateImportDeclaration, factoryDeprecation); + /** @deprecated Use `factory.createNamespaceImport` or the factory supplied by your transformation context instead. */ + ts.createNamespaceImport = ts.Debug.deprecate(ts.factory.createNamespaceImport, factoryDeprecation); + /** @deprecated Use `factory.updateNamespaceImport` or the factory supplied by your transformation context instead. */ + ts.updateNamespaceImport = ts.Debug.deprecate(ts.factory.updateNamespaceImport, factoryDeprecation); + /** @deprecated Use `factory.createNamedImports` or the factory supplied by your transformation context instead. */ + ts.createNamedImports = ts.Debug.deprecate(ts.factory.createNamedImports, factoryDeprecation); + /** @deprecated Use `factory.updateNamedImports` or the factory supplied by your transformation context instead. */ + ts.updateNamedImports = ts.Debug.deprecate(ts.factory.updateNamedImports, factoryDeprecation); + /** @deprecated Use `factory.createImportSpecifier` or the factory supplied by your transformation context instead. */ + ts.createImportSpecifier = ts.Debug.deprecate(ts.factory.createImportSpecifier, factoryDeprecation); + /** @deprecated Use `factory.updateImportSpecifier` or the factory supplied by your transformation context instead. */ + ts.updateImportSpecifier = ts.Debug.deprecate(ts.factory.updateImportSpecifier, factoryDeprecation); + /** @deprecated Use `factory.createExportAssignment` or the factory supplied by your transformation context instead. */ + ts.createExportAssignment = ts.Debug.deprecate(ts.factory.createExportAssignment, factoryDeprecation); + /** @deprecated Use `factory.updateExportAssignment` or the factory supplied by your transformation context instead. */ + ts.updateExportAssignment = ts.Debug.deprecate(ts.factory.updateExportAssignment, factoryDeprecation); + /** @deprecated Use `factory.createNamedExports` or the factory supplied by your transformation context instead. */ + ts.createNamedExports = ts.Debug.deprecate(ts.factory.createNamedExports, factoryDeprecation); + /** @deprecated Use `factory.updateNamedExports` or the factory supplied by your transformation context instead. */ + ts.updateNamedExports = ts.Debug.deprecate(ts.factory.updateNamedExports, factoryDeprecation); + /** @deprecated Use `factory.createExportSpecifier` or the factory supplied by your transformation context instead. */ + ts.createExportSpecifier = ts.Debug.deprecate(ts.factory.createExportSpecifier, factoryDeprecation); + /** @deprecated Use `factory.updateExportSpecifier` or the factory supplied by your transformation context instead. */ + ts.updateExportSpecifier = ts.Debug.deprecate(ts.factory.updateExportSpecifier, factoryDeprecation); + /** @deprecated Use `factory.createExternalModuleReference` or the factory supplied by your transformation context instead. */ + ts.createExternalModuleReference = ts.Debug.deprecate(ts.factory.createExternalModuleReference, factoryDeprecation); + /** @deprecated Use `factory.updateExternalModuleReference` or the factory supplied by your transformation context instead. */ + ts.updateExternalModuleReference = ts.Debug.deprecate(ts.factory.updateExternalModuleReference, factoryDeprecation); + /** @deprecated Use `factory.createJSDocTypeExpression` or the factory supplied by your transformation context instead. */ + ts.createJSDocTypeExpression = ts.Debug.deprecate(ts.factory.createJSDocTypeExpression, factoryDeprecation); + /** @deprecated Use `factory.createJSDocTypeTag` or the factory supplied by your transformation context instead. */ + ts.createJSDocTypeTag = ts.Debug.deprecate(ts.factory.createJSDocTypeTag, factoryDeprecation); + /** @deprecated Use `factory.createJSDocReturnTag` or the factory supplied by your transformation context instead. */ + ts.createJSDocReturnTag = ts.Debug.deprecate(ts.factory.createJSDocReturnTag, factoryDeprecation); + /** @deprecated Use `factory.createJSDocThisTag` or the factory supplied by your transformation context instead. */ + ts.createJSDocThisTag = ts.Debug.deprecate(ts.factory.createJSDocThisTag, factoryDeprecation); + /** @deprecated Use `factory.createJSDocComment` or the factory supplied by your transformation context instead. */ + ts.createJSDocComment = ts.Debug.deprecate(ts.factory.createJSDocComment, factoryDeprecation); + /** @deprecated Use `factory.createJSDocParameterTag` or the factory supplied by your transformation context instead. */ + ts.createJSDocParameterTag = ts.Debug.deprecate(ts.factory.createJSDocParameterTag, factoryDeprecation); + /** @deprecated Use `factory.createJSDocClassTag` or the factory supplied by your transformation context instead. */ + ts.createJSDocClassTag = ts.Debug.deprecate(ts.factory.createJSDocClassTag, factoryDeprecation); + /** @deprecated Use `factory.createJSDocAugmentsTag` or the factory supplied by your transformation context instead. */ + ts.createJSDocAugmentsTag = ts.Debug.deprecate(ts.factory.createJSDocAugmentsTag, factoryDeprecation); + /** @deprecated Use `factory.createJSDocEnumTag` or the factory supplied by your transformation context instead. */ + ts.createJSDocEnumTag = ts.Debug.deprecate(ts.factory.createJSDocEnumTag, factoryDeprecation); + /** @deprecated Use `factory.createJSDocTemplateTag` or the factory supplied by your transformation context instead. */ + ts.createJSDocTemplateTag = ts.Debug.deprecate(ts.factory.createJSDocTemplateTag, factoryDeprecation); + /** @deprecated Use `factory.createJSDocTypedefTag` or the factory supplied by your transformation context instead. */ + ts.createJSDocTypedefTag = ts.Debug.deprecate(ts.factory.createJSDocTypedefTag, factoryDeprecation); + /** @deprecated Use `factory.createJSDocCallbackTag` or the factory supplied by your transformation context instead. */ + ts.createJSDocCallbackTag = ts.Debug.deprecate(ts.factory.createJSDocCallbackTag, factoryDeprecation); + /** @deprecated Use `factory.createJSDocSignature` or the factory supplied by your transformation context instead. */ + ts.createJSDocSignature = ts.Debug.deprecate(ts.factory.createJSDocSignature, factoryDeprecation); + /** @deprecated Use `factory.createJSDocPropertyTag` or the factory supplied by your transformation context instead. */ + ts.createJSDocPropertyTag = ts.Debug.deprecate(ts.factory.createJSDocPropertyTag, factoryDeprecation); + /** @deprecated Use `factory.createJSDocTypeLiteral` or the factory supplied by your transformation context instead. */ + ts.createJSDocTypeLiteral = ts.Debug.deprecate(ts.factory.createJSDocTypeLiteral, factoryDeprecation); + /** @deprecated Use `factory.createJSDocImplementsTag` or the factory supplied by your transformation context instead. */ + ts.createJSDocImplementsTag = ts.Debug.deprecate(ts.factory.createJSDocImplementsTag, factoryDeprecation); + /** @deprecated Use `factory.createJSDocAuthorTag` or the factory supplied by your transformation context instead. */ + ts.createJSDocAuthorTag = ts.Debug.deprecate(ts.factory.createJSDocAuthorTag, factoryDeprecation); + /** @deprecated Use `factory.createJSDocPublicTag` or the factory supplied by your transformation context instead. */ + ts.createJSDocPublicTag = ts.Debug.deprecate(ts.factory.createJSDocPublicTag, factoryDeprecation); + /** @deprecated Use `factory.createJSDocPrivateTag` or the factory supplied by your transformation context instead. */ + ts.createJSDocPrivateTag = ts.Debug.deprecate(ts.factory.createJSDocPrivateTag, factoryDeprecation); + /** @deprecated Use `factory.createJSDocProtectedTag` or the factory supplied by your transformation context instead. */ + ts.createJSDocProtectedTag = ts.Debug.deprecate(ts.factory.createJSDocProtectedTag, factoryDeprecation); + /** @deprecated Use `factory.createJSDocReadonlyTag` or the factory supplied by your transformation context instead. */ + ts.createJSDocReadonlyTag = ts.Debug.deprecate(ts.factory.createJSDocReadonlyTag, factoryDeprecation); + /** @deprecated Use `factory.createJSDocUnknownTag` or the factory supplied by your transformation context instead. */ + ts.createJSDocTag = ts.Debug.deprecate(ts.factory.createJSDocUnknownTag, factoryDeprecation); + /** @deprecated Use `factory.createJsxElement` or the factory supplied by your transformation context instead. */ + ts.createJsxElement = ts.Debug.deprecate(ts.factory.createJsxElement, factoryDeprecation); + /** @deprecated Use `factory.updateJsxElement` or the factory supplied by your transformation context instead. */ + ts.updateJsxElement = ts.Debug.deprecate(ts.factory.updateJsxElement, factoryDeprecation); + /** @deprecated Use `factory.createJsxSelfClosingElement` or the factory supplied by your transformation context instead. */ + ts.createJsxSelfClosingElement = ts.Debug.deprecate(ts.factory.createJsxSelfClosingElement, factoryDeprecation); + /** @deprecated Use `factory.updateJsxSelfClosingElement` or the factory supplied by your transformation context instead. */ + ts.updateJsxSelfClosingElement = ts.Debug.deprecate(ts.factory.updateJsxSelfClosingElement, factoryDeprecation); + /** @deprecated Use `factory.createJsxOpeningElement` or the factory supplied by your transformation context instead. */ + ts.createJsxOpeningElement = ts.Debug.deprecate(ts.factory.createJsxOpeningElement, factoryDeprecation); + /** @deprecated Use `factory.updateJsxOpeningElement` or the factory supplied by your transformation context instead. */ + ts.updateJsxOpeningElement = ts.Debug.deprecate(ts.factory.updateJsxOpeningElement, factoryDeprecation); + /** @deprecated Use `factory.createJsxClosingElement` or the factory supplied by your transformation context instead. */ + ts.createJsxClosingElement = ts.Debug.deprecate(ts.factory.createJsxClosingElement, factoryDeprecation); + /** @deprecated Use `factory.updateJsxClosingElement` or the factory supplied by your transformation context instead. */ + ts.updateJsxClosingElement = ts.Debug.deprecate(ts.factory.updateJsxClosingElement, factoryDeprecation); + /** @deprecated Use `factory.createJsxFragment` or the factory supplied by your transformation context instead. */ + ts.createJsxFragment = ts.Debug.deprecate(ts.factory.createJsxFragment, factoryDeprecation); + /** @deprecated Use `factory.createJsxText` or the factory supplied by your transformation context instead. */ + ts.createJsxText = ts.Debug.deprecate(ts.factory.createJsxText, factoryDeprecation); + /** @deprecated Use `factory.updateJsxText` or the factory supplied by your transformation context instead. */ + ts.updateJsxText = ts.Debug.deprecate(ts.factory.updateJsxText, factoryDeprecation); + /** @deprecated Use `factory.createJsxOpeningFragment` or the factory supplied by your transformation context instead. */ + ts.createJsxOpeningFragment = ts.Debug.deprecate(ts.factory.createJsxOpeningFragment, factoryDeprecation); + /** @deprecated Use `factory.createJsxJsxClosingFragment` or the factory supplied by your transformation context instead. */ + ts.createJsxJsxClosingFragment = ts.Debug.deprecate(ts.factory.createJsxJsxClosingFragment, factoryDeprecation); + /** @deprecated Use `factory.updateJsxFragment` or the factory supplied by your transformation context instead. */ + ts.updateJsxFragment = ts.Debug.deprecate(ts.factory.updateJsxFragment, factoryDeprecation); + /** @deprecated Use `factory.createJsxAttribute` or the factory supplied by your transformation context instead. */ + ts.createJsxAttribute = ts.Debug.deprecate(ts.factory.createJsxAttribute, factoryDeprecation); + /** @deprecated Use `factory.updateJsxAttribute` or the factory supplied by your transformation context instead. */ + ts.updateJsxAttribute = ts.Debug.deprecate(ts.factory.updateJsxAttribute, factoryDeprecation); + /** @deprecated Use `factory.createJsxAttributes` or the factory supplied by your transformation context instead. */ + ts.createJsxAttributes = ts.Debug.deprecate(ts.factory.createJsxAttributes, factoryDeprecation); + /** @deprecated Use `factory.updateJsxAttributes` or the factory supplied by your transformation context instead. */ + ts.updateJsxAttributes = ts.Debug.deprecate(ts.factory.updateJsxAttributes, factoryDeprecation); + /** @deprecated Use `factory.createJsxSpreadAttribute` or the factory supplied by your transformation context instead. */ + ts.createJsxSpreadAttribute = ts.Debug.deprecate(ts.factory.createJsxSpreadAttribute, factoryDeprecation); + /** @deprecated Use `factory.updateJsxSpreadAttribute` or the factory supplied by your transformation context instead. */ + ts.updateJsxSpreadAttribute = ts.Debug.deprecate(ts.factory.updateJsxSpreadAttribute, factoryDeprecation); + /** @deprecated Use `factory.createJsxExpression` or the factory supplied by your transformation context instead. */ + ts.createJsxExpression = ts.Debug.deprecate(ts.factory.createJsxExpression, factoryDeprecation); + /** @deprecated Use `factory.updateJsxExpression` or the factory supplied by your transformation context instead. */ + ts.updateJsxExpression = ts.Debug.deprecate(ts.factory.updateJsxExpression, factoryDeprecation); + /** @deprecated Use `factory.createCaseClause` or the factory supplied by your transformation context instead. */ + ts.createCaseClause = ts.Debug.deprecate(ts.factory.createCaseClause, factoryDeprecation); + /** @deprecated Use `factory.updateCaseClause` or the factory supplied by your transformation context instead. */ + ts.updateCaseClause = ts.Debug.deprecate(ts.factory.updateCaseClause, factoryDeprecation); + /** @deprecated Use `factory.createDefaultClause` or the factory supplied by your transformation context instead. */ + ts.createDefaultClause = ts.Debug.deprecate(ts.factory.createDefaultClause, factoryDeprecation); + /** @deprecated Use `factory.updateDefaultClause` or the factory supplied by your transformation context instead. */ + ts.updateDefaultClause = ts.Debug.deprecate(ts.factory.updateDefaultClause, factoryDeprecation); + /** @deprecated Use `factory.createHeritageClause` or the factory supplied by your transformation context instead. */ + ts.createHeritageClause = ts.Debug.deprecate(ts.factory.createHeritageClause, factoryDeprecation); + /** @deprecated Use `factory.updateHeritageClause` or the factory supplied by your transformation context instead. */ + ts.updateHeritageClause = ts.Debug.deprecate(ts.factory.updateHeritageClause, factoryDeprecation); + /** @deprecated Use `factory.createCatchClause` or the factory supplied by your transformation context instead. */ + ts.createCatchClause = ts.Debug.deprecate(ts.factory.createCatchClause, factoryDeprecation); + /** @deprecated Use `factory.updateCatchClause` or the factory supplied by your transformation context instead. */ + ts.updateCatchClause = ts.Debug.deprecate(ts.factory.updateCatchClause, factoryDeprecation); + /** @deprecated Use `factory.createPropertyAssignment` or the factory supplied by your transformation context instead. */ + ts.createPropertyAssignment = ts.Debug.deprecate(ts.factory.createPropertyAssignment, factoryDeprecation); + /** @deprecated Use `factory.updatePropertyAssignment` or the factory supplied by your transformation context instead. */ + ts.updatePropertyAssignment = ts.Debug.deprecate(ts.factory.updatePropertyAssignment, factoryDeprecation); + /** @deprecated Use `factory.createShorthandPropertyAssignment` or the factory supplied by your transformation context instead. */ + ts.createShorthandPropertyAssignment = ts.Debug.deprecate(ts.factory.createShorthandPropertyAssignment, factoryDeprecation); + /** @deprecated Use `factory.updateShorthandPropertyAssignment` or the factory supplied by your transformation context instead. */ + ts.updateShorthandPropertyAssignment = ts.Debug.deprecate(ts.factory.updateShorthandPropertyAssignment, factoryDeprecation); + /** @deprecated Use `factory.createSpreadAssignment` or the factory supplied by your transformation context instead. */ + ts.createSpreadAssignment = ts.Debug.deprecate(ts.factory.createSpreadAssignment, factoryDeprecation); + /** @deprecated Use `factory.updateSpreadAssignment` or the factory supplied by your transformation context instead. */ + ts.updateSpreadAssignment = ts.Debug.deprecate(ts.factory.updateSpreadAssignment, factoryDeprecation); + /** @deprecated Use `factory.createEnumMember` or the factory supplied by your transformation context instead. */ + ts.createEnumMember = ts.Debug.deprecate(ts.factory.createEnumMember, factoryDeprecation); + /** @deprecated Use `factory.updateEnumMember` or the factory supplied by your transformation context instead. */ + ts.updateEnumMember = ts.Debug.deprecate(ts.factory.updateEnumMember, factoryDeprecation); + /** @deprecated Use `factory.updateSourceFile` or the factory supplied by your transformation context instead. */ + ts.updateSourceFileNode = ts.Debug.deprecate(ts.factory.updateSourceFile, factoryDeprecation); + /** @deprecated Use `factory.createNotEmittedStatement` or the factory supplied by your transformation context instead. */ + ts.createNotEmittedStatement = ts.Debug.deprecate(ts.factory.createNotEmittedStatement, factoryDeprecation); + /** @deprecated Use `factory.createPartiallyEmittedExpression` or the factory supplied by your transformation context instead. */ + ts.createPartiallyEmittedExpression = ts.Debug.deprecate(ts.factory.createPartiallyEmittedExpression, factoryDeprecation); + /** @deprecated Use `factory.updatePartiallyEmittedExpression` or the factory supplied by your transformation context instead. */ + ts.updatePartiallyEmittedExpression = ts.Debug.deprecate(ts.factory.updatePartiallyEmittedExpression, factoryDeprecation); + /** @deprecated Use `factory.createCommaListExpression` or the factory supplied by your transformation context instead. */ + ts.createCommaList = ts.Debug.deprecate(ts.factory.createCommaListExpression, factoryDeprecation); + /** @deprecated Use `factory.updateCommaListExpression` or the factory supplied by your transformation context instead. */ + ts.updateCommaList = ts.Debug.deprecate(ts.factory.updateCommaListExpression, factoryDeprecation); + /** @deprecated Use `factory.createBundle` or the factory supplied by your transformation context instead. */ + ts.createBundle = ts.Debug.deprecate(ts.factory.createBundle, factoryDeprecation); + /** @deprecated Use `factory.updateBundle` or the factory supplied by your transformation context instead. */ + ts.updateBundle = ts.Debug.deprecate(ts.factory.updateBundle, factoryDeprecation); + /** @deprecated Use `factory.createImmediatelyInvokedFunctionExpression` or the factory supplied by your transformation context instead. */ + ts.createImmediatelyInvokedFunctionExpression = ts.Debug.deprecate(ts.factory.createImmediatelyInvokedFunctionExpression, factoryDeprecation); + /** @deprecated Use `factory.createImmediatelyInvokedArrowFunction` or the factory supplied by your transformation context instead. */ + ts.createImmediatelyInvokedArrowFunction = ts.Debug.deprecate(ts.factory.createImmediatelyInvokedArrowFunction, factoryDeprecation); + /** @deprecated Use `factory.createVoidZero` or the factory supplied by your transformation context instead. */ + ts.createVoidZero = ts.Debug.deprecate(ts.factory.createVoidZero, factoryDeprecation); + /** @deprecated Use `factory.createExportDefault` or the factory supplied by your transformation context instead. */ + ts.createExportDefault = ts.Debug.deprecate(ts.factory.createExportDefault, factoryDeprecation); + /** @deprecated Use `factory.createExternalModuleExport` or the factory supplied by your transformation context instead. */ + ts.createExternalModuleExport = ts.Debug.deprecate(ts.factory.createExternalModuleExport, factoryDeprecation); + /** @deprecated Use `factory.createNamespaceExport` or the factory supplied by your transformation context instead. */ + ts.createNamespaceExport = ts.Debug.deprecate(ts.factory.createNamespaceExport, factoryDeprecation); + /** @deprecated Use `factory.updateNamespaceExport` or the factory supplied by your transformation context instead. */ + ts.updateNamespaceExport = ts.Debug.deprecate(ts.factory.updateNamespaceExport, factoryDeprecation); + /** @deprecated Use `factory.createToken` or the factory supplied by your transformation context instead. */ + ts.createToken = ts.Debug.deprecate(function createToken(kind) { + return ts.factory.createToken(kind); + }, factoryDeprecation); + /** @deprecated Use `factory.createIdentifier` or the factory supplied by your transformation context instead. */ + ts.createIdentifier = ts.Debug.deprecate(function createIdentifier(text) { + return ts.factory.createIdentifier(text, /*typeArguments*/ undefined, /*originalKeywordKind*/ undefined); + }, factoryDeprecation); + /** @deprecated Use `factory.createTempVariable` or the factory supplied by your transformation context instead. */ + ts.createTempVariable = ts.Debug.deprecate(function createTempVariable(recordTempVariable) { + return ts.factory.createTempVariable(recordTempVariable, /*reserveInNestedScopes*/ undefined); + }, factoryDeprecation); + /** @deprecated Use `factory.getGeneratedNameForNode` or the factory supplied by your transformation context instead. */ + ts.getGeneratedNameForNode = ts.Debug.deprecate(function getGeneratedNameForNode(node) { + return ts.factory.getGeneratedNameForNode(node, /*flags*/ undefined); + }, factoryDeprecation); + /** @deprecated Use `factory.createUniqueName(text, GeneratedIdentifierFlags.Optimistic)` or the factory supplied by your transformation context instead. */ + ts.createOptimisticUniqueName = ts.Debug.deprecate(function createOptimisticUniqueName(text) { + return ts.factory.createUniqueName(text, 16 /* GeneratedIdentifierFlags.Optimistic */); + }, factoryDeprecation); + /** @deprecated Use `factory.createUniqueName(text, GeneratedIdentifierFlags.Optimistic | GeneratedIdentifierFlags.FileLevel)` or the factory supplied by your transformation context instead. */ + ts.createFileLevelUniqueName = ts.Debug.deprecate(function createFileLevelUniqueName(text) { + return ts.factory.createUniqueName(text, 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */); + }, factoryDeprecation); + /** @deprecated Use `factory.createIndexSignature` or the factory supplied by your transformation context instead. */ + ts.createIndexSignature = ts.Debug.deprecate(function createIndexSignature(decorators, modifiers, parameters, type) { + return ts.factory.createIndexSignature(decorators, modifiers, parameters, type); + }, factoryDeprecation); + /** @deprecated Use `factory.createTypePredicateNode` or the factory supplied by your transformation context instead. */ + ts.createTypePredicateNode = ts.Debug.deprecate(function createTypePredicateNode(parameterName, type) { + return ts.factory.createTypePredicateNode(/*assertsModifier*/ undefined, parameterName, type); + }, factoryDeprecation); + /** @deprecated Use `factory.updateTypePredicateNode` or the factory supplied by your transformation context instead. */ + ts.updateTypePredicateNode = ts.Debug.deprecate(function updateTypePredicateNode(node, parameterName, type) { + return ts.factory.updateTypePredicateNode(node, /*assertsModifier*/ undefined, parameterName, type); + }, factoryDeprecation); + /** @deprecated Use `factory.createStringLiteral`, `factory.createStringLiteralFromNode`, `factory.createNumericLiteral`, `factory.createBigIntLiteral`, `factory.createTrue`, `factory.createFalse`, or the factory supplied by your transformation context instead. */ + ts.createLiteral = ts.Debug.deprecate(function createLiteral(value) { + if (typeof value === "number") { + return ts.factory.createNumericLiteral(value); + } + // eslint-disable-next-line local/no-in-operator + if (typeof value === "object" && "base10Value" in value) { // PseudoBigInt + return ts.factory.createBigIntLiteral(value); + } + if (typeof value === "boolean") { + return value ? ts.factory.createTrue() : ts.factory.createFalse(); + } + if (typeof value === "string") { + return ts.factory.createStringLiteral(value, /*isSingleQuote*/ undefined); + } + return ts.factory.createStringLiteralFromNode(value); + }, { since: "4.0", warnAfter: "4.1", message: "Use `factory.createStringLiteral`, `factory.createStringLiteralFromNode`, `factory.createNumericLiteral`, `factory.createBigIntLiteral`, `factory.createTrue`, `factory.createFalse`, or the factory supplied by your transformation context instead." }); + /** @deprecated Use `factory.createMethodSignature` or the factory supplied by your transformation context instead. */ + ts.createMethodSignature = ts.Debug.deprecate(function createMethodSignature(typeParameters, parameters, type, name, questionToken) { + return ts.factory.createMethodSignature(/*modifiers*/ undefined, name, questionToken, typeParameters, parameters, type); + }, factoryDeprecation); + /** @deprecated Use `factory.updateMethodSignature` or the factory supplied by your transformation context instead. */ + ts.updateMethodSignature = ts.Debug.deprecate(function updateMethodSignature(node, typeParameters, parameters, type, name, questionToken) { + return ts.factory.updateMethodSignature(node, node.modifiers, name, questionToken, typeParameters, parameters, type); + }, factoryDeprecation); + /** @deprecated Use `factory.createTypeOperatorNode` or the factory supplied by your transformation context instead. */ + ts.createTypeOperatorNode = ts.Debug.deprecate(function createTypeOperatorNode(operatorOrType, type) { + var operator; + if (type) { + operator = operatorOrType; + } + else { + type = operatorOrType; + operator = 141 /* SyntaxKind.KeyOfKeyword */; + } + return ts.factory.createTypeOperatorNode(operator, type); + }, factoryDeprecation); + /** @deprecated Use `factory.createTaggedTemplate` or the factory supplied by your transformation context instead. */ + ts.createTaggedTemplate = ts.Debug.deprecate(function createTaggedTemplate(tag, typeArgumentsOrTemplate, template) { + var typeArguments; + if (template) { + typeArguments = typeArgumentsOrTemplate; + } + else { + template = typeArgumentsOrTemplate; + } + return ts.factory.createTaggedTemplateExpression(tag, typeArguments, template); + }, factoryDeprecation); + /** @deprecated Use `factory.updateTaggedTemplate` or the factory supplied by your transformation context instead. */ + ts.updateTaggedTemplate = ts.Debug.deprecate(function updateTaggedTemplate(node, tag, typeArgumentsOrTemplate, template) { + var typeArguments; + if (template) { + typeArguments = typeArgumentsOrTemplate; + } + else { + template = typeArgumentsOrTemplate; + } + return ts.factory.updateTaggedTemplateExpression(node, tag, typeArguments, template); + }, factoryDeprecation); + /** @deprecated Use `factory.updateBinary` or the factory supplied by your transformation context instead. */ + ts.updateBinary = ts.Debug.deprecate(function updateBinary(node, left, right, operator) { + if (operator === void 0) { operator = node.operatorToken; } + if (typeof operator === "number") { + operator = operator === node.operatorToken.kind ? node.operatorToken : ts.factory.createToken(operator); + } + return ts.factory.updateBinaryExpression(node, left, operator, right); + }, factoryDeprecation); + /** @deprecated Use `factory.createConditional` or the factory supplied by your transformation context instead. */ + ts.createConditional = ts.Debug.deprecate(function createConditional(condition, questionTokenOrWhenTrue, whenTrueOrWhenFalse, colonToken, whenFalse) { + return arguments.length === 5 ? ts.factory.createConditionalExpression(condition, questionTokenOrWhenTrue, whenTrueOrWhenFalse, colonToken, whenFalse) : + arguments.length === 3 ? ts.factory.createConditionalExpression(condition, ts.factory.createToken(57 /* SyntaxKind.QuestionToken */), questionTokenOrWhenTrue, ts.factory.createToken(58 /* SyntaxKind.ColonToken */), whenTrueOrWhenFalse) : + ts.Debug.fail("Argument count mismatch"); + }, factoryDeprecation); + /** @deprecated Use `factory.createYield` or the factory supplied by your transformation context instead. */ + ts.createYield = ts.Debug.deprecate(function createYield(asteriskTokenOrExpression, expression) { + var asteriskToken; + if (expression) { + asteriskToken = asteriskTokenOrExpression; + } + else { + expression = asteriskTokenOrExpression; + } + return ts.factory.createYieldExpression(asteriskToken, expression); + }, factoryDeprecation); + /** @deprecated Use `factory.createClassExpression` or the factory supplied by your transformation context instead. */ + ts.createClassExpression = ts.Debug.deprecate(function createClassExpression(modifiers, name, typeParameters, heritageClauses, members) { + return ts.factory.createClassExpression(/*decorators*/ undefined, modifiers, name, typeParameters, heritageClauses, members); + }, factoryDeprecation); + /** @deprecated Use `factory.updateClassExpression` or the factory supplied by your transformation context instead. */ + ts.updateClassExpression = ts.Debug.deprecate(function updateClassExpression(node, modifiers, name, typeParameters, heritageClauses, members) { + return ts.factory.updateClassExpression(node, /*decorators*/ undefined, modifiers, name, typeParameters, heritageClauses, members); + }, factoryDeprecation); + /** @deprecated Use `factory.createPropertySignature` or the factory supplied by your transformation context instead. */ + ts.createPropertySignature = ts.Debug.deprecate(function createPropertySignature(modifiers, name, questionToken, type, initializer) { + var node = ts.factory.createPropertySignature(modifiers, name, questionToken, type); + node.initializer = initializer; + return node; + }, factoryDeprecation); + /** @deprecated Use `factory.updatePropertySignature` or the factory supplied by your transformation context instead. */ + ts.updatePropertySignature = ts.Debug.deprecate(function updatePropertySignature(node, modifiers, name, questionToken, type, initializer) { + var updated = ts.factory.updatePropertySignature(node, modifiers, name, questionToken, type); + if (node.initializer !== initializer) { + if (updated === node) { + updated = ts.factory.cloneNode(node); + } + updated.initializer = initializer; + } + return updated; + }, factoryDeprecation); + /** @deprecated Use `factory.createExpressionWithTypeArguments` or the factory supplied by your transformation context instead. */ + ts.createExpressionWithTypeArguments = ts.Debug.deprecate(function createExpressionWithTypeArguments(typeArguments, expression) { + return ts.factory.createExpressionWithTypeArguments(expression, typeArguments); + }, factoryDeprecation); + /** @deprecated Use `factory.updateExpressionWithTypeArguments` or the factory supplied by your transformation context instead. */ + ts.updateExpressionWithTypeArguments = ts.Debug.deprecate(function updateExpressionWithTypeArguments(node, typeArguments, expression) { + return ts.factory.updateExpressionWithTypeArguments(node, expression, typeArguments); + }, factoryDeprecation); + /** @deprecated Use `factory.createArrowFunction` or the factory supplied by your transformation context instead. */ + ts.createArrowFunction = ts.Debug.deprecate(function createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanTokenOrBody, body) { + return arguments.length === 6 ? ts.factory.createArrowFunction(modifiers, typeParameters, parameters, type, equalsGreaterThanTokenOrBody, body) : + arguments.length === 5 ? ts.factory.createArrowFunction(modifiers, typeParameters, parameters, type, /*equalsGreaterThanToken*/ undefined, equalsGreaterThanTokenOrBody) : + ts.Debug.fail("Argument count mismatch"); + }, factoryDeprecation); + /** @deprecated Use `factory.updateArrowFunction` or the factory supplied by your transformation context instead. */ + ts.updateArrowFunction = ts.Debug.deprecate(function updateArrowFunction(node, modifiers, typeParameters, parameters, type, equalsGreaterThanTokenOrBody, body) { + return arguments.length === 7 ? ts.factory.updateArrowFunction(node, modifiers, typeParameters, parameters, type, equalsGreaterThanTokenOrBody, body) : + arguments.length === 6 ? ts.factory.updateArrowFunction(node, modifiers, typeParameters, parameters, type, node.equalsGreaterThanToken, equalsGreaterThanTokenOrBody) : + ts.Debug.fail("Argument count mismatch"); + }, factoryDeprecation); + /** @deprecated Use `factory.createVariableDeclaration` or the factory supplied by your transformation context instead. */ + ts.createVariableDeclaration = ts.Debug.deprecate(function createVariableDeclaration(name, exclamationTokenOrType, typeOrInitializer, initializer) { + return arguments.length === 4 ? ts.factory.createVariableDeclaration(name, exclamationTokenOrType, typeOrInitializer, initializer) : + arguments.length >= 1 && arguments.length <= 3 ? ts.factory.createVariableDeclaration(name, /*exclamationToken*/ undefined, exclamationTokenOrType, typeOrInitializer) : + ts.Debug.fail("Argument count mismatch"); + }, factoryDeprecation); + /** @deprecated Use `factory.updateVariableDeclaration` or the factory supplied by your transformation context instead. */ + ts.updateVariableDeclaration = ts.Debug.deprecate(function updateVariableDeclaration(node, name, exclamationTokenOrType, typeOrInitializer, initializer) { + return arguments.length === 5 ? ts.factory.updateVariableDeclaration(node, name, exclamationTokenOrType, typeOrInitializer, initializer) : + arguments.length === 4 ? ts.factory.updateVariableDeclaration(node, name, node.exclamationToken, exclamationTokenOrType, typeOrInitializer) : + ts.Debug.fail("Argument count mismatch"); + }, factoryDeprecation); + /** @deprecated Use `factory.createImportClause` or the factory supplied by your transformation context instead. */ + ts.createImportClause = ts.Debug.deprecate(function createImportClause(name, namedBindings, isTypeOnly) { + if (isTypeOnly === void 0) { isTypeOnly = false; } + return ts.factory.createImportClause(isTypeOnly, name, namedBindings); + }, factoryDeprecation); + /** @deprecated Use `factory.updateImportClause` or the factory supplied by your transformation context instead. */ + ts.updateImportClause = ts.Debug.deprecate(function updateImportClause(node, name, namedBindings, isTypeOnly) { + return ts.factory.updateImportClause(node, isTypeOnly, name, namedBindings); + }, factoryDeprecation); + /** @deprecated Use `factory.createExportDeclaration` or the factory supplied by your transformation context instead. */ + ts.createExportDeclaration = ts.Debug.deprecate(function createExportDeclaration(decorators, modifiers, exportClause, moduleSpecifier, isTypeOnly) { + if (isTypeOnly === void 0) { isTypeOnly = false; } + return ts.factory.createExportDeclaration(decorators, modifiers, isTypeOnly, exportClause, moduleSpecifier); + }, factoryDeprecation); + /** @deprecated Use `factory.updateExportDeclaration` or the factory supplied by your transformation context instead. */ + ts.updateExportDeclaration = ts.Debug.deprecate(function updateExportDeclaration(node, decorators, modifiers, exportClause, moduleSpecifier, isTypeOnly) { + return ts.factory.updateExportDeclaration(node, decorators, modifiers, isTypeOnly, exportClause, moduleSpecifier, node.assertClause); + }, factoryDeprecation); + /** @deprecated Use `factory.createJSDocParameterTag` or the factory supplied by your transformation context instead. */ + ts.createJSDocParamTag = ts.Debug.deprecate(function createJSDocParamTag(name, isBracketed, typeExpression, comment) { + return ts.factory.createJSDocParameterTag(/*tagName*/ undefined, name, isBracketed, typeExpression, /*isNameFirst*/ false, comment ? ts.factory.createNodeArray([ts.factory.createJSDocText(comment)]) : undefined); + }, factoryDeprecation); + /** @deprecated Use `factory.createComma` or the factory supplied by your transformation context instead. */ + ts.createComma = ts.Debug.deprecate(function createComma(left, right) { + return ts.factory.createComma(left, right); + }, factoryDeprecation); + /** @deprecated Use `factory.createLessThan` or the factory supplied by your transformation context instead. */ + ts.createLessThan = ts.Debug.deprecate(function createLessThan(left, right) { + return ts.factory.createLessThan(left, right); + }, factoryDeprecation); + /** @deprecated Use `factory.createAssignment` or the factory supplied by your transformation context instead. */ + ts.createAssignment = ts.Debug.deprecate(function createAssignment(left, right) { + return ts.factory.createAssignment(left, right); + }, factoryDeprecation); + /** @deprecated Use `factory.createStrictEquality` or the factory supplied by your transformation context instead. */ + ts.createStrictEquality = ts.Debug.deprecate(function createStrictEquality(left, right) { + return ts.factory.createStrictEquality(left, right); + }, factoryDeprecation); + /** @deprecated Use `factory.createStrictInequality` or the factory supplied by your transformation context instead. */ + ts.createStrictInequality = ts.Debug.deprecate(function createStrictInequality(left, right) { + return ts.factory.createStrictInequality(left, right); + }, factoryDeprecation); + /** @deprecated Use `factory.createAdd` or the factory supplied by your transformation context instead. */ + ts.createAdd = ts.Debug.deprecate(function createAdd(left, right) { + return ts.factory.createAdd(left, right); + }, factoryDeprecation); + /** @deprecated Use `factory.createSubtract` or the factory supplied by your transformation context instead. */ + ts.createSubtract = ts.Debug.deprecate(function createSubtract(left, right) { + return ts.factory.createSubtract(left, right); + }, factoryDeprecation); + /** @deprecated Use `factory.createLogicalAnd` or the factory supplied by your transformation context instead. */ + ts.createLogicalAnd = ts.Debug.deprecate(function createLogicalAnd(left, right) { + return ts.factory.createLogicalAnd(left, right); + }, factoryDeprecation); + /** @deprecated Use `factory.createLogicalOr` or the factory supplied by your transformation context instead. */ + ts.createLogicalOr = ts.Debug.deprecate(function createLogicalOr(left, right) { + return ts.factory.createLogicalOr(left, right); + }, factoryDeprecation); + /** @deprecated Use `factory.createPostfixIncrement` or the factory supplied by your transformation context instead. */ + ts.createPostfixIncrement = ts.Debug.deprecate(function createPostfixIncrement(operand) { + return ts.factory.createPostfixIncrement(operand); + }, factoryDeprecation); + /** @deprecated Use `factory.createLogicalNot` or the factory supplied by your transformation context instead. */ + ts.createLogicalNot = ts.Debug.deprecate(function createLogicalNot(operand) { + return ts.factory.createLogicalNot(operand); + }, factoryDeprecation); + /** @deprecated Use an appropriate `factory` method instead. */ + ts.createNode = ts.Debug.deprecate(function createNode(kind, pos, end) { + if (pos === void 0) { pos = 0; } + if (end === void 0) { end = 0; } + return ts.setTextRangePosEnd(kind === 308 /* SyntaxKind.SourceFile */ ? ts.parseBaseNodeFactory.createBaseSourceFileNode(kind) : + kind === 79 /* SyntaxKind.Identifier */ ? ts.parseBaseNodeFactory.createBaseIdentifierNode(kind) : + kind === 80 /* SyntaxKind.PrivateIdentifier */ ? ts.parseBaseNodeFactory.createBasePrivateIdentifierNode(kind) : + !ts.isNodeKind(kind) ? ts.parseBaseNodeFactory.createBaseTokenNode(kind) : + ts.parseBaseNodeFactory.createBaseNode(kind), pos, end); + }, { since: "4.0", warnAfter: "4.1", message: "Use an appropriate `factory` method instead." }); + /** + * Creates a shallow, memberwise clone of a node ~for mutation~ with its `pos`, `end`, and `parent` set. + * + * NOTE: It is unsafe to change any properties of a `Node` that relate to its AST children, as those changes won't be + * captured with respect to transformations. + * + * @deprecated Use an appropriate `factory.update...` method instead, use `setCommentRange` or `setSourceMapRange`, and avoid setting `parent`. + */ + ts.getMutableClone = ts.Debug.deprecate(function getMutableClone(node) { + var clone = ts.factory.cloneNode(node); + ts.setTextRange(clone, node); + ts.setParent(clone, node.parent); + return clone; + }, { since: "4.0", warnAfter: "4.1", message: "Use an appropriate `factory.update...` method instead, use `setCommentRange` or `setSourceMapRange`, and avoid setting `parent`." }); +})(ts || (ts = {})); +// DEPRECATION: Renamed node tests +// DEPRECATION PLAN: +// - soft: 4.0 +// - warn: 4.1 +// - error: TBD +var ts; +(function (ts) { + /** @deprecated Use `isTypeAssertionExpression` instead. */ + ts.isTypeAssertion = ts.Debug.deprecate(function isTypeAssertion(node) { + return node.kind === 213 /* SyntaxKind.TypeAssertionExpression */; + }, { + since: "4.0", + warnAfter: "4.1", + message: "Use `isTypeAssertionExpression` instead." + }); +})(ts || (ts = {})); +// DEPRECATION: Renamed node tests +// DEPRECATION PLAN: +// - soft: 4.2 +// - warn: 4.3 +// - error: 5.0 +var ts; +(function (ts) { + /** + * @deprecated Use `isMemberName` instead. + */ + ts.isIdentifierOrPrivateIdentifier = ts.Debug.deprecate(function isIdentifierOrPrivateIdentifier(node) { + return ts.isMemberName(node); + }, { + since: "4.2", + warnAfter: "4.3", + message: "Use `isMemberName` instead." + }); +})(ts || (ts = {})); +// DEPRECATION: Overloads for createConstructorTypeNode/updateConstructorTypeNode that do not accept 'modifiers' +// DEPRECATION PLAN: +// - soft: 4.2 +// - warn: 4.3 +// - error: 5.0 +var ts; +(function (ts) { + function patchNodeFactory(factory) { + var createConstructorTypeNode = factory.createConstructorTypeNode, updateConstructorTypeNode = factory.updateConstructorTypeNode; + factory.createConstructorTypeNode = ts.buildOverload("createConstructorTypeNode") + .overload({ + 0: function (modifiers, typeParameters, parameters, type) { + return createConstructorTypeNode(modifiers, typeParameters, parameters, type); + }, + 1: function (typeParameters, parameters, type) { + return createConstructorTypeNode(/*modifiers*/ undefined, typeParameters, parameters, type); + }, + }) + .bind({ + 0: function (args) { return args.length === 4; }, + 1: function (args) { return args.length === 3; }, + }) + .deprecate({ + 1: { since: "4.2", warnAfter: "4.3", message: "Use the overload that accepts 'modifiers'" } + }) + .finish(); + factory.updateConstructorTypeNode = ts.buildOverload("updateConstructorTypeNode") + .overload({ + 0: function (node, modifiers, typeParameters, parameters, type) { + return updateConstructorTypeNode(node, modifiers, typeParameters, parameters, type); + }, + 1: function (node, typeParameters, parameters, type) { + return updateConstructorTypeNode(node, node.modifiers, typeParameters, parameters, type); + } + }) + .bind({ + 0: function (args) { return args.length === 5; }, + 1: function (args) { return args.length === 4; }, + }) + .deprecate({ + 1: { since: "4.2", warnAfter: "4.3", message: "Use the overload that accepts 'modifiers'" } + }) + .finish(); + } + // Patch `createNodeFactory` because it creates the factories that are provided to transformers + // in the public API. + var prevCreateNodeFactory = ts.createNodeFactory; + // eslint-disable-next-line @typescript-eslint/no-unnecessary-qualifier + ts.createNodeFactory = function (flags, baseFactory) { + var factory = prevCreateNodeFactory(flags, baseFactory); + patchNodeFactory(factory); + return factory; + }; + // Patch `ts.factory` because its public + patchNodeFactory(ts.factory); +})(ts || (ts = {})); +// DEPRECATION: Overloads to createImportTypeNode/updateImportTypeNode that do not accept `assertions` +// DEPRECATION PLAN: +// - soft: 4.6 +// - warn: 4.7 +// - error: 5.0 +var ts; +(function (ts) { + function patchNodeFactory(factory) { + var createImportTypeNode = factory.createImportTypeNode, updateImportTypeNode = factory.updateImportTypeNode; + factory.createImportTypeNode = ts.buildOverload("createImportTypeNode") + .overload({ + 0: function (argument, assertions, qualifier, typeArguments, isTypeOf) { + return createImportTypeNode(argument, assertions, qualifier, typeArguments, isTypeOf); + }, + 1: function (argument, qualifier, typeArguments, isTypeOf) { + return createImportTypeNode(argument, /*assertions*/ undefined, qualifier, typeArguments, isTypeOf); + }, + }) + .bind({ + 0: function (_a) { + var assertions = _a[1], qualifier = _a[2], typeArguments = _a[3], isTypeOf = _a[4]; + return (assertions === undefined || ts.isImportTypeAssertionContainer(assertions)) && + (qualifier === undefined || !ts.isArray(qualifier)) && + (typeArguments === undefined || ts.isArray(typeArguments)) && + (isTypeOf === undefined || typeof isTypeOf === "boolean"); + }, + 1: function (_a) { + var qualifier = _a[1], typeArguments = _a[2], isTypeOf = _a[3], other = _a[4]; + return (other === undefined) && + (qualifier === undefined || ts.isEntityName(qualifier)) && + (typeArguments === undefined || ts.isArray(typeArguments)) && + (isTypeOf === undefined || typeof isTypeOf === "boolean"); + }, + }) + .deprecate({ + 1: { since: "4.6", warnAfter: "4.7", message: "Use the overload that accepts 'assertions'" } + }) + .finish(); + factory.updateImportTypeNode = ts.buildOverload("updateImportTypeNode") + .overload({ + 0: function (node, argument, assertions, qualifier, typeArguments, isTypeOf) { + return updateImportTypeNode(node, argument, assertions, qualifier, typeArguments, isTypeOf); + }, + 1: function (node, argument, qualifier, typeArguments, isTypeOf) { + return updateImportTypeNode(node, argument, node.assertions, qualifier, typeArguments, isTypeOf); + }, + }) + .bind({ + 0: function (_a) { + var assertions = _a[2], qualifier = _a[3], typeArguments = _a[4], isTypeOf = _a[5]; + return (assertions === undefined || ts.isImportTypeAssertionContainer(assertions)) && + (qualifier === undefined || !ts.isArray(qualifier)) && + (typeArguments === undefined || ts.isArray(typeArguments)) && + (isTypeOf === undefined || typeof isTypeOf === "boolean"); + }, + 1: function (_a) { + var qualifier = _a[2], typeArguments = _a[3], isTypeOf = _a[4], other = _a[5]; + return (other === undefined) && + (qualifier === undefined || ts.isEntityName(qualifier)) && + (typeArguments === undefined || ts.isArray(typeArguments)) && + (isTypeOf === undefined || typeof isTypeOf === "boolean"); + }, + }). + deprecate({ + 1: { since: "4.6", warnAfter: "4.7", message: "Use the overload that accepts 'assertions'" } + }) + .finish(); + } + // Patch `createNodeFactory` because it creates the factories that are provided to transformers + // in the public API. + var prevCreateNodeFactory = ts.createNodeFactory; + // eslint-disable-next-line @typescript-eslint/no-unnecessary-qualifier + ts.createNodeFactory = function (flags, baseFactory) { + var factory = prevCreateNodeFactory(flags, baseFactory); + patchNodeFactory(factory); + return factory; + }; + // Patch `ts.factory` because its public + patchNodeFactory(ts.factory); +})(ts || (ts = {})); +// DEPRECATION: Overloads to createTypeParameter/updateTypeParameter that does not accept `modifiers` +// DEPRECATION PLAN: +// - soft: 4.7 +// - warn: 4.8 +// - error: 5.0 +var ts; +(function (ts) { + function patchNodeFactory(factory) { + var createTypeParameterDeclaration = factory.createTypeParameterDeclaration, updateTypeParameterDeclaration = factory.updateTypeParameterDeclaration; + factory.createTypeParameterDeclaration = ts.buildOverload("createTypeParameterDeclaration") + .overload({ + 0: function (modifiers, name, constraint, defaultType) { + return createTypeParameterDeclaration(modifiers, name, constraint, defaultType); + }, + 1: function (name, constraint, defaultType) { + return createTypeParameterDeclaration(/*modifiers*/ undefined, name, constraint, defaultType); + }, + }) + .bind({ + 0: function (_a) { + var modifiers = _a[0]; + return (modifiers === undefined || ts.isArray(modifiers)); + }, + 1: function (_a) { + var name = _a[0]; + return (name !== undefined && !ts.isArray(name)); + }, + }) + .deprecate({ + 1: { since: "4.7", warnAfter: "4.8", message: "Use the overload that accepts 'modifiers'" } + }) + .finish(); + factory.updateTypeParameterDeclaration = ts.buildOverload("updateTypeParameterDeclaration") + .overload({ + 0: function (node, modifiers, name, constraint, defaultType) { + return updateTypeParameterDeclaration(node, modifiers, name, constraint, defaultType); + }, + 1: function (node, name, constraint, defaultType) { + return updateTypeParameterDeclaration(node, node.modifiers, name, constraint, defaultType); + }, + }) + .bind({ + 0: function (_a) { + var modifiers = _a[1]; + return (modifiers === undefined || ts.isArray(modifiers)); + }, + 1: function (_a) { + var name = _a[1]; + return (name !== undefined && !ts.isArray(name)); + }, + }) + .deprecate({ + 1: { since: "4.7", warnAfter: "4.8", message: "Use the overload that accepts 'modifiers'" } + }) + .finish(); + } + // Patch `createNodeFactory` because it creates the factories that are provided to transformers + // in the public API. + var prevCreateNodeFactory = ts.createNodeFactory; + // eslint-disable-next-line @typescript-eslint/no-unnecessary-qualifier + ts.createNodeFactory = function (flags, baseFactory) { + var factory = prevCreateNodeFactory(flags, baseFactory); + patchNodeFactory(factory); + return factory; + }; + // Patch `ts.factory` because its public + patchNodeFactory(ts.factory); +})(ts || (ts = {})); +// DEPRECATION: Deprecate passing `decorators` separate from `modifiers` +// DEPRECATION PLAN: +// - soft: 4.8 +// - warn: 4.9 +// - error: 5.0 +var ts; +(function (ts) { + var MUST_MERGE = { since: "4.8", warnAfter: "4.9.0-0", message: "Decorators have been combined with modifiers. Callers should switch to an overload that does not accept a 'decorators' parameter." }; + var DISALLOW_DECORATORS = { since: "4.8", warnAfter: "4.9.0-0", message: "Decorators are no longer supported for this function. Callers should switch to an overload that does not accept a 'decorators' parameter." }; + var DISALLOW_DECORATORS_AND_MODIFIERS = { since: "4.8", warnAfter: "4.9.0-0", message: "Decorators and modifiers are no longer supported for this function. Callers should switch to an overload that does not accept the 'decorators' and 'modifiers' parameters." }; + function patchNodeFactory(factory) { + var createParameterDeclaration = factory.createParameterDeclaration, updateParameterDeclaration = factory.updateParameterDeclaration, createPropertyDeclaration = factory.createPropertyDeclaration, updatePropertyDeclaration = factory.updatePropertyDeclaration, createMethodDeclaration = factory.createMethodDeclaration, updateMethodDeclaration = factory.updateMethodDeclaration, createConstructorDeclaration = factory.createConstructorDeclaration, updateConstructorDeclaration = factory.updateConstructorDeclaration, createGetAccessorDeclaration = factory.createGetAccessorDeclaration, updateGetAccessorDeclaration = factory.updateGetAccessorDeclaration, createSetAccessorDeclaration = factory.createSetAccessorDeclaration, updateSetAccessorDeclaration = factory.updateSetAccessorDeclaration, createIndexSignature = factory.createIndexSignature, updateIndexSignature = factory.updateIndexSignature, createClassStaticBlockDeclaration = factory.createClassStaticBlockDeclaration, updateClassStaticBlockDeclaration = factory.updateClassStaticBlockDeclaration, createClassExpression = factory.createClassExpression, updateClassExpression = factory.updateClassExpression, createFunctionDeclaration = factory.createFunctionDeclaration, updateFunctionDeclaration = factory.updateFunctionDeclaration, createClassDeclaration = factory.createClassDeclaration, updateClassDeclaration = factory.updateClassDeclaration, createInterfaceDeclaration = factory.createInterfaceDeclaration, updateInterfaceDeclaration = factory.updateInterfaceDeclaration, createTypeAliasDeclaration = factory.createTypeAliasDeclaration, updateTypeAliasDeclaration = factory.updateTypeAliasDeclaration, createEnumDeclaration = factory.createEnumDeclaration, updateEnumDeclaration = factory.updateEnumDeclaration, createModuleDeclaration = factory.createModuleDeclaration, updateModuleDeclaration = factory.updateModuleDeclaration, createImportEqualsDeclaration = factory.createImportEqualsDeclaration, updateImportEqualsDeclaration = factory.updateImportEqualsDeclaration, createImportDeclaration = factory.createImportDeclaration, updateImportDeclaration = factory.updateImportDeclaration, createExportAssignment = factory.createExportAssignment, updateExportAssignment = factory.updateExportAssignment, createExportDeclaration = factory.createExportDeclaration, updateExportDeclaration = factory.updateExportDeclaration; + factory.createParameterDeclaration = ts.buildOverload("createParameterDeclaration") + .overload({ + 0: function (modifiers, dotDotDotToken, name, questionToken, type, initializer) { + return createParameterDeclaration(modifiers, dotDotDotToken, name, questionToken, type, initializer); + }, + 1: function (decorators, modifiers, dotDotDotToken, name, questionToken, type, initializer) { + return createParameterDeclaration(ts.concatenate(decorators, modifiers), dotDotDotToken, name, questionToken, type, initializer); + }, + }) + .bind({ + 0: function (_a) { + var dotDotDotToken = _a[1], name = _a[2], questionToken = _a[3], type = _a[4], initializer = _a[5], other = _a[6]; + return (other === undefined) && + (dotDotDotToken === undefined || !ts.isArray(dotDotDotToken)) && + (name === undefined || typeof name === "string" || ts.isBindingName(name)) && + (questionToken === undefined || typeof questionToken === "object" && ts.isQuestionToken(questionToken)) && + (type === undefined || ts.isTypeNode(type)) && + (initializer === undefined || ts.isExpression(initializer)); + }, + 1: function (_a) { + var modifiers = _a[1], dotDotDotToken = _a[2], name = _a[3], questionToken = _a[4], type = _a[5], initializer = _a[6]; + return (modifiers === undefined || ts.isArray(modifiers)) && + (dotDotDotToken === undefined || typeof dotDotDotToken === "object" && ts.isDotDotDotToken(dotDotDotToken)) && + (name === undefined || typeof name === "string" || ts.isBindingName(name)) && + (questionToken === undefined || ts.isQuestionToken(questionToken)) && + (type === undefined || ts.isTypeNode(type)) && + (initializer === undefined || ts.isExpression(initializer)); + }, + }) + .deprecate({ + 1: MUST_MERGE + }) + .finish(); + factory.updateParameterDeclaration = ts.buildOverload("updateParameterDeclaration") + .overload({ + 0: function (node, modifiers, dotDotDotToken, name, questionToken, type, initializer) { + return updateParameterDeclaration(node, modifiers, dotDotDotToken, name, questionToken, type, initializer); + }, + 1: function (node, decorators, modifiers, dotDotDotToken, name, questionToken, type, initializer) { + return updateParameterDeclaration(node, ts.concatenate(decorators, modifiers), dotDotDotToken, name, questionToken, type, initializer); + }, + }) + .bind({ + 0: function (_a) { + var dotDotDotToken = _a[2], name = _a[3], questionToken = _a[4], type = _a[5], initializer = _a[6], other = _a[7]; + return (other === undefined) && + (dotDotDotToken === undefined || !ts.isArray(dotDotDotToken)) && + (name === undefined || typeof name === "string" || ts.isBindingName(name)) && + (questionToken === undefined || typeof questionToken === "object" && ts.isQuestionToken(questionToken)) && + (type === undefined || ts.isTypeNode(type)) && + (initializer === undefined || ts.isExpression(initializer)); + }, + 1: function (_a) { + var modifiers = _a[2], dotDotDotToken = _a[3], name = _a[4], questionToken = _a[5], type = _a[6], initializer = _a[7]; + return (modifiers === undefined || ts.isArray(modifiers)) && + (dotDotDotToken === undefined || typeof dotDotDotToken === "object" && ts.isDotDotDotToken(dotDotDotToken)) && + (name === undefined || typeof name === "string" || ts.isBindingName(name)) && + (questionToken === undefined || ts.isQuestionToken(questionToken)) && + (type === undefined || ts.isTypeNode(type)) && + (initializer === undefined || ts.isExpression(initializer)); + }, + }) + .deprecate({ + 1: MUST_MERGE + }) + .finish(); + factory.createPropertyDeclaration = ts.buildOverload("createPropertyDeclaration") + .overload({ + 0: function (modifiers, name, questionOrExclamationToken, type, initializer) { + return createPropertyDeclaration(modifiers, name, questionOrExclamationToken, type, initializer); + }, + 1: function (decorators, modifiers, name, questionOrExclamationToken, type, initializer) { + return createPropertyDeclaration(ts.concatenate(decorators, modifiers), name, questionOrExclamationToken, type, initializer); + }, + }) + .bind({ + 0: function (_a) { + var name = _a[1], questionOrExclamationToken = _a[2], type = _a[3], initializer = _a[4], other = _a[5]; + return (other === undefined) && + (name === undefined || !ts.isArray(name)) && + (questionOrExclamationToken === undefined || typeof questionOrExclamationToken === "object" && ts.isQuestionOrExclamationToken(questionOrExclamationToken)) && + (type === undefined || ts.isTypeNode(type)) && + (initializer === undefined || ts.isExpression(initializer)); + }, + 1: function (_a) { + var modifiers = _a[1], name = _a[2], questionOrExclamationToken = _a[3], type = _a[4], initializer = _a[5]; + return (modifiers === undefined || ts.isArray(modifiers)) && + (name === undefined || typeof name === "string" || ts.isPropertyName(name)) && + (questionOrExclamationToken === undefined || ts.isQuestionOrExclamationToken(questionOrExclamationToken)) && + (type === undefined || ts.isTypeNode(type)) && + (initializer === undefined || ts.isExpression(initializer)); + }, + }) + .deprecate({ + 1: MUST_MERGE + }) + .finish(); + factory.updatePropertyDeclaration = ts.buildOverload("updatePropertyDeclaration") + .overload({ + 0: function (node, modifiers, name, questionOrExclamationToken, type, initializer) { + return updatePropertyDeclaration(node, modifiers, name, questionOrExclamationToken, type, initializer); + }, + 1: function (node, decorators, modifiers, name, questionOrExclamationToken, type, initializer) { + return updatePropertyDeclaration(node, ts.concatenate(decorators, modifiers), name, questionOrExclamationToken, type, initializer); + }, + }) + .bind({ + 0: function (_a) { + var name = _a[2], questionOrExclamationToken = _a[3], type = _a[4], initializer = _a[5], other = _a[6]; + return (other === undefined) && + (name === undefined || !ts.isArray(name)) && + (questionOrExclamationToken === undefined || typeof questionOrExclamationToken === "object" && ts.isQuestionOrExclamationToken(questionOrExclamationToken)) && + (type === undefined || ts.isTypeNode(type)) && + (initializer === undefined || ts.isExpression(initializer)); + }, + 1: function (_a) { + var modifiers = _a[2], name = _a[3], questionOrExclamationToken = _a[4], type = _a[5], initializer = _a[6]; + return (modifiers === undefined || ts.isArray(modifiers)) && + (name === undefined || typeof name === "string" || ts.isPropertyName(name)) && + (questionOrExclamationToken === undefined || ts.isQuestionOrExclamationToken(questionOrExclamationToken)) && + (type === undefined || ts.isTypeNode(type)) && + (initializer === undefined || ts.isExpression(initializer)); + }, + }) + .deprecate({ + 1: MUST_MERGE + }) + .finish(); + factory.createMethodDeclaration = ts.buildOverload("createMethodDeclaration") + .overload({ + 0: function (modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body) { + return createMethodDeclaration(modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body); + }, + 1: function (decorators, modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body) { + return createMethodDeclaration(ts.concatenate(decorators, modifiers), asteriskToken, name, questionToken, typeParameters, parameters, type, body); + }, + }) + .bind({ + 0: function (_a) { + var asteriskToken = _a[1], name = _a[2], questionToken = _a[3], typeParameters = _a[4], parameters = _a[5], type = _a[6], body = _a[7], other = _a[8]; + return (other === undefined) && + (asteriskToken === undefined || !ts.isArray(asteriskToken)) && + (name === undefined || typeof name === "string" || ts.isPropertyName(name)) && + (questionToken === undefined || typeof questionToken === "object" && ts.isQuestionToken(questionToken)) && + (typeParameters === undefined || ts.isArray(typeParameters)) && + (parameters === undefined || !ts.some(parameters, ts.isTypeParameterDeclaration)) && + (type === undefined || !ts.isArray(type)) && + (body === undefined || ts.isBlock(body)); + }, + 1: function (_a) { + var modifiers = _a[1], asteriskToken = _a[2], name = _a[3], questionToken = _a[4], typeParameters = _a[5], parameters = _a[6], type = _a[7], body = _a[8]; + return (modifiers === undefined || ts.isArray(modifiers)) && + (asteriskToken === undefined || typeof asteriskToken === "object" && ts.isAsteriskToken(asteriskToken)) && + (name === undefined || typeof name === "string" || ts.isPropertyName(name)) && + (questionToken === undefined || !ts.isArray(questionToken)) && + (typeParameters === undefined || !ts.some(typeParameters, ts.isParameter)) && + (parameters === undefined || ts.isArray(parameters)) && + (type === undefined || ts.isTypeNode(type)) && + (body === undefined || ts.isBlock(body)); + }, + }) + .deprecate({ + 1: MUST_MERGE + }) + .finish(); + factory.updateMethodDeclaration = ts.buildOverload("updateMethodDeclaration") + .overload({ + 0: function (node, modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body) { + return updateMethodDeclaration(node, modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body); + }, + 1: function (node, decorators, modifiers, asteriskToken, name, questionToken, typeParameters, parameters, type, body) { + return updateMethodDeclaration(node, ts.concatenate(decorators, modifiers), asteriskToken, name, questionToken, typeParameters, parameters, type, body); + }, + }) + .bind({ + 0: function (_a) { + var asteriskToken = _a[2], name = _a[3], questionToken = _a[4], typeParameters = _a[5], parameters = _a[6], type = _a[7], body = _a[8], other = _a[9]; + return (other === undefined) && + (asteriskToken === undefined || !ts.isArray(asteriskToken)) && + (name === undefined || typeof name === "string" || ts.isPropertyName(name)) && + (questionToken === undefined || typeof questionToken === "object" && ts.isQuestionToken(questionToken)) && + (typeParameters === undefined || ts.isArray(typeParameters)) && + (parameters === undefined || !ts.some(parameters, ts.isTypeParameterDeclaration)) && + (type === undefined || !ts.isArray(type)) && + (body === undefined || ts.isBlock(body)); + }, + 1: function (_a) { + var modifiers = _a[2], asteriskToken = _a[3], name = _a[4], questionToken = _a[5], typeParameters = _a[6], parameters = _a[7], type = _a[8], body = _a[9]; + return (modifiers === undefined || ts.isArray(modifiers)) && + (asteriskToken === undefined || typeof asteriskToken === "object" && ts.isAsteriskToken(asteriskToken)) && + (name === undefined || typeof name === "string" || ts.isPropertyName(name)) && + (questionToken === undefined || !ts.isArray(questionToken)) && + (typeParameters === undefined || !ts.some(typeParameters, ts.isParameter)) && + (parameters === undefined || ts.isArray(parameters)) && + (type === undefined || ts.isTypeNode(type)) && + (body === undefined || ts.isBlock(body)); + }, + }) + .deprecate({ + 1: MUST_MERGE + }) + .finish(); + factory.createConstructorDeclaration = ts.buildOverload("createConstructorDeclaration") + .overload({ + 0: function (modifiers, parameters, body) { + return createConstructorDeclaration(modifiers, parameters, body); + }, + 1: function (_decorators, modifiers, parameters, body) { + return createConstructorDeclaration(modifiers, parameters, body); + }, + }) + .bind({ + 0: function (_a) { + var modifiers = _a[0], parameters = _a[1], body = _a[2], other = _a[3]; + return (other === undefined) && + (modifiers === undefined || !ts.some(modifiers, ts.isDecorator)) && + (parameters === undefined || !ts.some(parameters, ts.isModifier)) && + (body === undefined || !ts.isArray(body)); + }, + 1: function (_a) { + var decorators = _a[0], modifiers = _a[1], parameters = _a[2], body = _a[3]; + return (decorators === undefined || !ts.some(decorators, ts.isModifier)) && + (modifiers === undefined || !ts.some(modifiers, ts.isParameter)) && + (parameters === undefined || ts.isArray(parameters)) && + (body === undefined || ts.isBlock(body)); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS + }) + .finish(); + factory.updateConstructorDeclaration = ts.buildOverload("updateConstructorDeclaration") + .overload({ + 0: function (node, modifiers, parameters, body) { + return updateConstructorDeclaration(node, modifiers, parameters, body); + }, + 1: function (node, _decorators, modifiers, parameters, body) { + return updateConstructorDeclaration(node, modifiers, parameters, body); + }, + }) + .bind({ + 0: function (_a) { + var modifiers = _a[1], parameters = _a[2], body = _a[3], other = _a[4]; + return (other === undefined) && + (modifiers === undefined || !ts.some(modifiers, ts.isDecorator)) && + (parameters === undefined || !ts.some(parameters, ts.isModifier)) && + (body === undefined || !ts.isArray(body)); + }, + 1: function (_a) { + var decorators = _a[1], modifiers = _a[2], parameters = _a[3], body = _a[4]; + return (decorators === undefined || !ts.some(decorators, ts.isModifier)) && + (modifiers === undefined || !ts.some(modifiers, ts.isParameter)) && + (parameters === undefined || ts.isArray(parameters)) && + (body === undefined || ts.isBlock(body)); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS + }) + .finish(); + factory.createGetAccessorDeclaration = ts.buildOverload("createGetAccessorDeclaration") + .overload({ + 0: function (modifiers, name, parameters, type, body) { + return createGetAccessorDeclaration(modifiers, name, parameters, type, body); + }, + 1: function (decorators, modifiers, name, parameters, type, body) { + return createGetAccessorDeclaration(ts.concatenate(decorators, modifiers), name, parameters, type, body); + }, + }) + .bind({ + 0: function (_a) { + var name = _a[1], parameters = _a[2], type = _a[3], body = _a[4], other = _a[5]; + return (other === undefined) && + (name === undefined || !ts.isArray(name)) && + (parameters === undefined || ts.isArray(parameters)) && + (type === undefined || !ts.isArray(type)) && + (body === undefined || ts.isBlock(body)); + }, + 1: function (_a) { + var modifiers = _a[1], name = _a[2], parameters = _a[3], type = _a[4], body = _a[5]; + return (modifiers === undefined || ts.isArray(modifiers)) && + (name === undefined || !ts.isArray(name)) && + (parameters === undefined || ts.isArray(parameters)) && + (type === undefined || ts.isTypeNode(type)) && + (body === undefined || ts.isBlock(body)); + }, + }) + .deprecate({ + 1: MUST_MERGE + }) + .finish(); + factory.updateGetAccessorDeclaration = ts.buildOverload("updateGetAccessorDeclaration") + .overload({ + 0: function (node, modifiers, name, parameters, type, body) { + return updateGetAccessorDeclaration(node, modifiers, name, parameters, type, body); + }, + 1: function (node, decorators, modifiers, name, parameters, type, body) { + return updateGetAccessorDeclaration(node, ts.concatenate(decorators, modifiers), name, parameters, type, body); + }, + }) + .bind({ + 0: function (_a) { + var name = _a[2], parameters = _a[3], type = _a[4], body = _a[5], other = _a[6]; + return (other === undefined) && + (name === undefined || !ts.isArray(name)) && + (parameters === undefined || ts.isArray(parameters)) && + (type === undefined || !ts.isArray(type)) && + (body === undefined || ts.isBlock(body)); + }, + 1: function (_a) { + var modifiers = _a[2], name = _a[3], parameters = _a[4], type = _a[5], body = _a[6]; + return (modifiers === undefined || ts.isArray(modifiers)) && + (name === undefined || !ts.isArray(name)) && + (parameters === undefined || ts.isArray(parameters)) && + (type === undefined || ts.isTypeNode(type)) && + (body === undefined || ts.isBlock(body)); + }, + }) + .deprecate({ + 1: MUST_MERGE + }) + .finish(); + factory.createSetAccessorDeclaration = ts.buildOverload("createSetAccessorDeclaration") + .overload({ + 0: function (modifiers, name, parameters, body) { + return createSetAccessorDeclaration(modifiers, name, parameters, body); + }, + 1: function (decorators, modifiers, name, parameters, body) { + return createSetAccessorDeclaration(ts.concatenate(decorators, modifiers), name, parameters, body); + }, + }) + .bind({ + 0: function (_a) { + var name = _a[1], parameters = _a[2], body = _a[3], other = _a[4]; + return (other === undefined) && + (name === undefined || !ts.isArray(name)) && + (parameters === undefined || ts.isArray(parameters)) && + (body === undefined || !ts.isArray(body)); + }, + 1: function (_a) { + var modifiers = _a[1], name = _a[2], parameters = _a[3], body = _a[4]; + return (modifiers === undefined || ts.isArray(modifiers)) && + (name === undefined || !ts.isArray(name)) && + (parameters === undefined || ts.isArray(parameters)) && + (body === undefined || ts.isBlock(body)); + }, + }) + .deprecate({ + 1: MUST_MERGE + }) + .finish(); + factory.updateSetAccessorDeclaration = ts.buildOverload("updateSetAccessorDeclaration") + .overload({ + 0: function (node, modifiers, name, parameters, body) { + return updateSetAccessorDeclaration(node, modifiers, name, parameters, body); + }, + 1: function (node, decorators, modifiers, name, parameters, body) { + return updateSetAccessorDeclaration(node, ts.concatenate(decorators, modifiers), name, parameters, body); + }, + }) + .bind({ + 0: function (_a) { + var name = _a[2], parameters = _a[3], body = _a[4], other = _a[5]; + return (other === undefined) && + (name === undefined || !ts.isArray(name)) && + (parameters === undefined || ts.isArray(parameters)) && + (body === undefined || !ts.isArray(body)); + }, + 1: function (_a) { + var modifiers = _a[2], name = _a[3], parameters = _a[4], body = _a[5]; + return (modifiers === undefined || ts.isArray(modifiers)) && + (name === undefined || !ts.isArray(name)) && + (parameters === undefined || ts.isArray(parameters)) && + (body === undefined || ts.isBlock(body)); + }, + }) + .deprecate({ + 1: MUST_MERGE + }) + .finish(); + factory.createIndexSignature = ts.buildOverload("createIndexSignature") + .overload({ + 0: function (modifiers, parameters, type) { + return createIndexSignature(modifiers, parameters, type); + }, + 1: function (_decorators, modifiers, parameters, type) { + return createIndexSignature(modifiers, parameters, type); + }, + }) + .bind({ + 0: function (_a) { + var modifiers = _a[0], parameters = _a[1], type = _a[2], other = _a[3]; + return (other === undefined) && + (modifiers === undefined || ts.every(modifiers, ts.isModifier)) && + (parameters === undefined || ts.every(parameters, ts.isParameter)) && + (type === undefined || !ts.isArray(type)); + }, + 1: function (_a) { + var decorators = _a[0], modifiers = _a[1], parameters = _a[2], type = _a[3]; + return (decorators === undefined || ts.every(decorators, ts.isDecorator)) && + (modifiers === undefined || ts.every(modifiers, ts.isModifier)) && + (parameters === undefined || ts.isArray(parameters)) && + (type === undefined || ts.isTypeNode(type)); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS + }) + .finish(); + factory.updateIndexSignature = ts.buildOverload("updateIndexSignature") + .overload({ + 0: function (node, modifiers, parameters, type) { + return updateIndexSignature(node, modifiers, parameters, type); + }, + 1: function (node, _decorators, modifiers, parameters, type) { + return updateIndexSignature(node, modifiers, parameters, type); + }, + }) + .bind({ + 0: function (_a) { + var modifiers = _a[1], parameters = _a[2], type = _a[3], other = _a[4]; + return (other === undefined) && + (modifiers === undefined || ts.every(modifiers, ts.isModifier)) && + (parameters === undefined || ts.every(parameters, ts.isParameter)) && + (type === undefined || !ts.isArray(type)); + }, + 1: function (_a) { + var decorators = _a[1], modifiers = _a[2], parameters = _a[3], type = _a[4]; + return (decorators === undefined || ts.every(decorators, ts.isDecorator)) && + (modifiers === undefined || ts.every(modifiers, ts.isModifier)) && + (parameters === undefined || ts.isArray(parameters)) && + (type === undefined || ts.isTypeNode(type)); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS + }) + .finish(); + factory.createClassStaticBlockDeclaration = ts.buildOverload("createClassStaticBlockDeclaration") + .overload({ + 0: function (body) { + return createClassStaticBlockDeclaration(body); + }, + 1: function (_decorators, _modifiers, body) { + return createClassStaticBlockDeclaration(body); + }, + }) + .bind({ + 0: function (_a) { + var body = _a[0], other1 = _a[1], other2 = _a[2]; + return (other1 === undefined) && + (other2 === undefined) && + (body === undefined || !ts.isArray(body)); + }, + 1: function (_a) { + var decorators = _a[0], modifiers = _a[1], body = _a[2]; + return (decorators === undefined || ts.isArray(decorators)) && + (modifiers === undefined || ts.isArray(decorators)) && + (body === undefined || ts.isBlock(body)); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS_AND_MODIFIERS + }) + .finish(); + factory.updateClassStaticBlockDeclaration = ts.buildOverload("updateClassStaticBlockDeclaration") + .overload({ + 0: function (node, body) { + return updateClassStaticBlockDeclaration(node, body); + }, + 1: function (node, _decorators, _modifiers, body) { + return updateClassStaticBlockDeclaration(node, body); + }, + }) + .bind({ + 0: function (_a) { + var body = _a[1], other1 = _a[2], other2 = _a[3]; + return (other1 === undefined) && + (other2 === undefined) && + (body === undefined || !ts.isArray(body)); + }, + 1: function (_a) { + var decorators = _a[1], modifiers = _a[2], body = _a[3]; + return (decorators === undefined || ts.isArray(decorators)) && + (modifiers === undefined || ts.isArray(decorators)) && + (body === undefined || ts.isBlock(body)); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS_AND_MODIFIERS + }) + .finish(); + factory.createClassExpression = ts.buildOverload("createClassExpression") + .overload({ + 0: function (modifiers, name, typeParameters, heritageClauses, members) { + return createClassExpression(modifiers, name, typeParameters, heritageClauses, members); + }, + 1: function (decorators, modifiers, name, typeParameters, heritageClauses, members) { + return createClassExpression(ts.concatenate(decorators, modifiers), name, typeParameters, heritageClauses, members); + }, + }) + .bind({ + 0: function (_a) { + var name = _a[1], typeParameters = _a[2], heritageClauses = _a[3], members = _a[4], other = _a[5]; + return (other === undefined) && + (name === undefined || !ts.isArray(name)) && + (typeParameters === undefined || ts.isArray(typeParameters)) && + (heritageClauses === undefined || ts.every(heritageClauses, ts.isHeritageClause)) && + (members === undefined || ts.every(members, ts.isClassElement)); + }, + 1: function (_a) { + var modifiers = _a[1], name = _a[2], typeParameters = _a[3], heritageClauses = _a[4], members = _a[5]; + return (modifiers === undefined || ts.isArray(modifiers)) && + (name === undefined || !ts.isArray(name)) && + (typeParameters === undefined || ts.every(typeParameters, ts.isTypeParameterDeclaration)) && + (heritageClauses === undefined || ts.every(heritageClauses, ts.isHeritageClause)) && + (members === undefined || ts.isArray(members)); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS + }) + .finish(); + factory.updateClassExpression = ts.buildOverload("updateClassExpression") + .overload({ + 0: function (node, modifiers, name, typeParameters, heritageClauses, members) { + return updateClassExpression(node, modifiers, name, typeParameters, heritageClauses, members); + }, + 1: function (node, decorators, modifiers, name, typeParameters, heritageClauses, members) { + return updateClassExpression(node, ts.concatenate(decorators, modifiers), name, typeParameters, heritageClauses, members); + }, + }) + .bind({ + 0: function (_a) { + var name = _a[2], typeParameters = _a[3], heritageClauses = _a[4], members = _a[5], other = _a[6]; + return (other === undefined) && + (name === undefined || !ts.isArray(name)) && + (typeParameters === undefined || ts.isArray(typeParameters)) && + (heritageClauses === undefined || ts.every(heritageClauses, ts.isHeritageClause)) && + (members === undefined || ts.every(members, ts.isClassElement)); + }, + 1: function (_a) { + var modifiers = _a[2], name = _a[3], typeParameters = _a[4], heritageClauses = _a[5], members = _a[6]; + return (modifiers === undefined || ts.isArray(modifiers)) && + (name === undefined || !ts.isArray(name)) && + (typeParameters === undefined || ts.every(typeParameters, ts.isTypeParameterDeclaration)) && + (heritageClauses === undefined || ts.every(heritageClauses, ts.isHeritageClause)) && + (members === undefined || ts.isArray(members)); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS + }) + .finish(); + factory.createFunctionDeclaration = ts.buildOverload("createFunctionDeclaration") + .overload({ + 0: function (modifiers, asteriskToken, name, typeParameters, parameters, type, body) { + return createFunctionDeclaration(modifiers, asteriskToken, name, typeParameters, parameters, type, body); + }, + 1: function (_decorators, modifiers, asteriskToken, name, typeParameters, parameters, type, body) { + return createFunctionDeclaration(modifiers, asteriskToken, name, typeParameters, parameters, type, body); + }, + }) + .bind({ + 0: function (_a) { + var asteriskToken = _a[1], name = _a[2], typeParameters = _a[3], parameters = _a[4], type = _a[5], body = _a[6], other = _a[7]; + return (other === undefined) && + (asteriskToken === undefined || !ts.isArray(asteriskToken)) && + (name === undefined || typeof name === "string" || ts.isIdentifier(name)) && + (typeParameters === undefined || ts.isArray(typeParameters)) && + (parameters === undefined || ts.every(parameters, ts.isParameter)) && + (type === undefined || !ts.isArray(type)) && + (body === undefined || ts.isBlock(body)); + }, + 1: function (_a) { + var modifiers = _a[1], asteriskToken = _a[2], name = _a[3], typeParameters = _a[4], parameters = _a[5], type = _a[6], body = _a[7]; + return (modifiers === undefined || ts.isArray(modifiers)) && + (asteriskToken === undefined || typeof asteriskToken !== "string" && ts.isAsteriskToken(asteriskToken)) && + (name === undefined || !ts.isArray(name)) && + (typeParameters === undefined || ts.every(typeParameters, ts.isTypeParameterDeclaration)) && + (parameters === undefined || ts.isArray(parameters)) && + (type === undefined || ts.isTypeNode(type)) && + (body === undefined || ts.isBlock(body)); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS + }) + .finish(); + factory.updateFunctionDeclaration = ts.buildOverload("updateFunctionDeclaration") + .overload({ + 0: function (node, modifiers, asteriskToken, name, typeParameters, parameters, type, body) { + return updateFunctionDeclaration(node, modifiers, asteriskToken, name, typeParameters, parameters, type, body); + }, + 1: function (node, _decorators, modifiers, asteriskToken, name, typeParameters, parameters, type, body) { + return updateFunctionDeclaration(node, modifiers, asteriskToken, name, typeParameters, parameters, type, body); + }, + }) + .bind({ + 0: function (_a) { + var asteriskToken = _a[2], name = _a[3], typeParameters = _a[4], parameters = _a[5], type = _a[6], body = _a[7], other = _a[8]; + return (other === undefined) && + (asteriskToken === undefined || !ts.isArray(asteriskToken)) && + (name === undefined || ts.isIdentifier(name)) && + (typeParameters === undefined || ts.isArray(typeParameters)) && + (parameters === undefined || ts.every(parameters, ts.isParameter)) && + (type === undefined || !ts.isArray(type)) && + (body === undefined || ts.isBlock(body)); + }, + 1: function (_a) { + var modifiers = _a[2], asteriskToken = _a[3], name = _a[4], typeParameters = _a[5], parameters = _a[6], type = _a[7], body = _a[8]; + return (modifiers === undefined || ts.isArray(modifiers)) && + (asteriskToken === undefined || typeof asteriskToken !== "string" && ts.isAsteriskToken(asteriskToken)) && + (name === undefined || !ts.isArray(name)) && + (typeParameters === undefined || ts.every(typeParameters, ts.isTypeParameterDeclaration)) && + (parameters === undefined || ts.isArray(parameters)) && + (type === undefined || ts.isTypeNode(type)) && + (body === undefined || ts.isBlock(body)); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS + }) + .finish(); + factory.createClassDeclaration = ts.buildOverload("createClassDeclaration") + .overload({ + 0: function (modifiers, name, typeParameters, heritageClauses, members) { + return createClassDeclaration(modifiers, name, typeParameters, heritageClauses, members); + }, + 1: function (decorators, modifiers, name, typeParameters, heritageClauses, members) { + return createClassDeclaration(ts.concatenate(decorators, modifiers), name, typeParameters, heritageClauses, members); + }, + }) + .bind({ + 0: function (_a) { + var name = _a[1], typeParameters = _a[2], heritageClauses = _a[3], members = _a[4], other = _a[5]; + return (other === undefined) && + (name === undefined || !ts.isArray(name)) && + (typeParameters === undefined || ts.isArray(typeParameters)) && + (heritageClauses === undefined || ts.every(heritageClauses, ts.isHeritageClause)) && + (members === undefined || ts.every(members, ts.isClassElement)); + }, + 1: function () { return true; }, + }) + .deprecate({ + 1: MUST_MERGE + }) + .finish(); + factory.updateClassDeclaration = ts.buildOverload("updateClassDeclaration") + .overload({ + 0: function (node, modifiers, name, typeParameters, heritageClauses, members) { + return updateClassDeclaration(node, modifiers, name, typeParameters, heritageClauses, members); + }, + 1: function (node, decorators, modifiers, name, typeParameters, heritageClauses, members) { + return updateClassDeclaration(node, ts.concatenate(decorators, modifiers), name, typeParameters, heritageClauses, members); + }, + }) + .bind({ + 0: function (_a) { + var name = _a[2], typeParameters = _a[3], heritageClauses = _a[4], members = _a[5], other = _a[6]; + return (other === undefined) && + (name === undefined || !ts.isArray(name)) && + (typeParameters === undefined || ts.isArray(typeParameters)) && + (heritageClauses === undefined || ts.every(heritageClauses, ts.isHeritageClause)) && + (members === undefined || ts.every(members, ts.isClassElement)); + }, + 1: function (_a) { + var modifiers = _a[2], name = _a[3], typeParameters = _a[4], heritageClauses = _a[5], members = _a[6]; + return (modifiers === undefined || ts.isArray(modifiers)) && + (name === undefined || !ts.isArray(name)) && + (typeParameters === undefined || ts.every(typeParameters, ts.isTypeParameterDeclaration)) && + (heritageClauses === undefined || ts.every(heritageClauses, ts.isHeritageClause)) && + (members === undefined || ts.isArray(members)); + }, + }) + .deprecate({ + 1: MUST_MERGE + }) + .finish(); + factory.createInterfaceDeclaration = ts.buildOverload("createInterfaceDeclaration") + .overload({ + 0: function (modifiers, name, typeParameters, heritageClauses, members) { + return createInterfaceDeclaration(modifiers, name, typeParameters, heritageClauses, members); + }, + 1: function (_decorators, modifiers, name, typeParameters, heritageClauses, members) { + return createInterfaceDeclaration(modifiers, name, typeParameters, heritageClauses, members); + }, + }) + .bind({ + 0: function (_a) { + var modifiers = _a[0], name = _a[1], typeParameters = _a[2], heritageClauses = _a[3], members = _a[4], other = _a[5]; + return (other === undefined) && + (modifiers === undefined || ts.every(modifiers, ts.isModifier)) && + (name === undefined || !ts.isArray(name)) && + (typeParameters === undefined || ts.isArray(typeParameters)) && + (heritageClauses === undefined || ts.every(heritageClauses, ts.isHeritageClause)) && + (members === undefined || ts.every(members, ts.isTypeElement)); + }, + 1: function (_a) { + var decorators = _a[0], modifiers = _a[1], name = _a[2], typeParameters = _a[3], heritageClauses = _a[4], members = _a[5]; + return (decorators === undefined || ts.every(decorators, ts.isDecorator)) && + (modifiers === undefined || ts.isArray(modifiers)) && + (name === undefined || !ts.isArray(name)) && + (typeParameters === undefined || ts.every(typeParameters, ts.isTypeParameterDeclaration)) && + (heritageClauses === undefined || ts.every(heritageClauses, ts.isHeritageClause)) && + (members === undefined || ts.every(members, ts.isTypeElement)); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS + }) + .finish(); + factory.updateInterfaceDeclaration = ts.buildOverload("updateInterfaceDeclaration") + .overload({ + 0: function (node, modifiers, name, typeParameters, heritageClauses, members) { + return updateInterfaceDeclaration(node, modifiers, name, typeParameters, heritageClauses, members); + }, + 1: function (node, _decorators, modifiers, name, typeParameters, heritageClauses, members) { + return updateInterfaceDeclaration(node, modifiers, name, typeParameters, heritageClauses, members); + }, + }) + .bind({ + 0: function (_a) { + var modifiers = _a[1], name = _a[2], typeParameters = _a[3], heritageClauses = _a[4], members = _a[5], other = _a[6]; + return (other === undefined) && + (modifiers === undefined || ts.every(modifiers, ts.isModifier)) && + (name === undefined || !ts.isArray(name)) && + (typeParameters === undefined || ts.isArray(typeParameters)) && + (heritageClauses === undefined || ts.every(heritageClauses, ts.isHeritageClause)) && + (members === undefined || ts.every(members, ts.isTypeElement)); + }, + 1: function (_a) { + var decorators = _a[1], modifiers = _a[2], name = _a[3], typeParameters = _a[4], heritageClauses = _a[5], members = _a[6]; + return (decorators === undefined || ts.every(decorators, ts.isDecorator)) && + (modifiers === undefined || ts.isArray(modifiers)) && + (name === undefined || !ts.isArray(name)) && + (typeParameters === undefined || ts.every(typeParameters, ts.isTypeParameterDeclaration)) && + (heritageClauses === undefined || ts.every(heritageClauses, ts.isHeritageClause)) && + (members === undefined || ts.every(members, ts.isTypeElement)); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS + }) + .finish(); + factory.createTypeAliasDeclaration = ts.buildOverload("createTypeAliasDeclaration") + .overload({ + 0: function (modifiers, name, typeParameters, type) { + return createTypeAliasDeclaration(modifiers, name, typeParameters, type); + }, + 1: function (_decorators, modifiers, name, typeParameters, type) { + return createTypeAliasDeclaration(modifiers, name, typeParameters, type); + }, + }) + .bind({ + 0: function (_a) { + var modifiers = _a[0], name = _a[1], typeParameters = _a[2], type = _a[3], other = _a[4]; + return (other === undefined) && + (modifiers === undefined || ts.every(modifiers, ts.isModifier)) && + (name === undefined || !ts.isArray(name)) && + (typeParameters === undefined || ts.isArray(typeParameters)) && + (type === undefined || !ts.isArray(type)); + }, + 1: function (_a) { + var decorators = _a[0], modifiers = _a[1], name = _a[2], typeParameters = _a[3], type = _a[4]; + return (decorators === undefined || ts.every(decorators, ts.isDecorator)) && + (modifiers === undefined || ts.isArray(modifiers)) && + (name === undefined || !ts.isArray(name)) && + (typeParameters === undefined || ts.isArray(typeParameters)) && + (type === undefined || ts.isTypeNode(type)); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS + }) + .finish(); + factory.updateTypeAliasDeclaration = ts.buildOverload("updateTypeAliasDeclaration") + .overload({ + 0: function (node, modifiers, name, typeParameters, type) { + return updateTypeAliasDeclaration(node, modifiers, name, typeParameters, type); + }, + 1: function (node, _decorators, modifiers, name, typeParameters, type) { + return updateTypeAliasDeclaration(node, modifiers, name, typeParameters, type); + }, + }) + .bind({ + 0: function (_a) { + var modifiers = _a[1], name = _a[2], typeParameters = _a[3], type = _a[4], other = _a[5]; + return (other === undefined) && + (modifiers === undefined || ts.every(modifiers, ts.isModifier)) && + (name === undefined || !ts.isArray(name)) && + (typeParameters === undefined || ts.isArray(typeParameters)) && + (type === undefined || !ts.isArray(type)); + }, + 1: function (_a) { + var decorators = _a[1], modifiers = _a[2], name = _a[3], typeParameters = _a[4], type = _a[5]; + return (decorators === undefined || ts.every(decorators, ts.isDecorator)) && + (modifiers === undefined || ts.isArray(modifiers)) && + (name === undefined || !ts.isArray(name)) && + (typeParameters === undefined || ts.isArray(typeParameters)) && + (type === undefined || ts.isTypeNode(type)); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS + }) + .finish(); + factory.createEnumDeclaration = ts.buildOverload("createEnumDeclaration") + .overload({ + 0: function (modifiers, name, members) { + return createEnumDeclaration(modifiers, name, members); + }, + 1: function (_decorators, modifiers, name, members) { + return createEnumDeclaration(modifiers, name, members); + }, + }) + .bind({ + 0: function (_a) { + var modifiers = _a[0], name = _a[1], members = _a[2], other = _a[3]; + return (other === undefined) && + (modifiers === undefined || ts.every(modifiers, ts.isModifier)) && + (name === undefined || !ts.isArray(name)) && + (members === undefined || ts.isArray(members)); + }, + 1: function (_a) { + var decorators = _a[0], modifiers = _a[1], name = _a[2], members = _a[3]; + return (decorators === undefined || ts.every(decorators, ts.isDecorator)) && + (modifiers === undefined || ts.isArray(modifiers)) && + (name === undefined || !ts.isArray(name)) && + (members === undefined || ts.isArray(members)); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS + }) + .finish(); + factory.updateEnumDeclaration = ts.buildOverload("updateEnumDeclaration") + .overload({ + 0: function (node, modifiers, name, members) { + return updateEnumDeclaration(node, modifiers, name, members); + }, + 1: function (node, _decorators, modifiers, name, members) { + return updateEnumDeclaration(node, modifiers, name, members); + }, + }) + .bind({ + 0: function (_a) { + var modifiers = _a[1], name = _a[2], members = _a[3], other = _a[4]; + return (other === undefined) && + (modifiers === undefined || ts.every(modifiers, ts.isModifier)) && + (name === undefined || !ts.isArray(name)) && + (members === undefined || ts.isArray(members)); + }, + 1: function (_a) { + var decorators = _a[1], modifiers = _a[2], name = _a[3], members = _a[4]; + return (decorators === undefined || ts.every(decorators, ts.isDecorator)) && + (modifiers === undefined || ts.isArray(modifiers)) && + (name === undefined || !ts.isArray(name)) && + (members === undefined || ts.isArray(members)); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS + }) + .finish(); + factory.createModuleDeclaration = ts.buildOverload("createModuleDeclaration") + .overload({ + 0: function (modifiers, name, body, flags) { + return createModuleDeclaration(modifiers, name, body, flags); + }, + 1: function (_decorators, modifiers, name, body, flags) { + return createModuleDeclaration(modifiers, name, body, flags); + }, + }) + .bind({ + 0: function (_a) { + var modifiers = _a[0], name = _a[1], body = _a[2], flags = _a[3], other = _a[4]; + return (other === undefined) && + (modifiers === undefined || ts.every(modifiers, ts.isModifier)) && + (name !== undefined && !ts.isArray(name)) && + (body === undefined || ts.isModuleBody(body)) && + (flags === undefined || typeof flags === "number"); + }, + 1: function (_a) { + var decorators = _a[0], modifiers = _a[1], name = _a[2], body = _a[3], flags = _a[4]; + return (decorators === undefined || ts.every(decorators, ts.isDecorator)) && + (modifiers === undefined || ts.isArray(modifiers)) && + (name !== undefined && ts.isModuleName(name)) && + (body === undefined || typeof body === "object") && + (flags === undefined || typeof flags === "number"); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS + }) + .finish(); + factory.updateModuleDeclaration = ts.buildOverload("updateModuleDeclaration") + .overload({ + 0: function (node, modifiers, name, body) { + return updateModuleDeclaration(node, modifiers, name, body); + }, + 1: function (node, _decorators, modifiers, name, body) { + return updateModuleDeclaration(node, modifiers, name, body); + }, + }) + .bind({ + 0: function (_a) { + var modifiers = _a[1], name = _a[2], body = _a[3], other = _a[4]; + return (other === undefined) && + (modifiers === undefined || ts.every(modifiers, ts.isModifier)) && + (name === undefined || !ts.isArray(name)) && + (body === undefined || ts.isModuleBody(body)); + }, + 1: function (_a) { + var decorators = _a[1], modifiers = _a[2], name = _a[3], body = _a[4]; + return (decorators === undefined || ts.every(decorators, ts.isDecorator)) && + (modifiers === undefined || ts.isArray(modifiers)) && + (name !== undefined && ts.isModuleName(name)) && + (body === undefined || ts.isModuleBody(body)); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS + }) + .finish(); + factory.createImportEqualsDeclaration = ts.buildOverload("createImportEqualsDeclaration") + .overload({ + 0: function (modifiers, isTypeOnly, name, moduleReference) { + return createImportEqualsDeclaration(modifiers, isTypeOnly, name, moduleReference); + }, + 1: function (_decorators, modifiers, isTypeOnly, name, moduleReference) { + return createImportEqualsDeclaration(modifiers, isTypeOnly, name, moduleReference); + }, + }) + .bind({ + 0: function (_a) { + var modifiers = _a[0], isTypeOnly = _a[1], name = _a[2], moduleReference = _a[3], other = _a[4]; + return (other === undefined) && + (modifiers === undefined || ts.every(modifiers, ts.isModifier)) && + (isTypeOnly === undefined || typeof isTypeOnly === "boolean") && + (typeof name !== "boolean") && + (typeof moduleReference !== "string"); + }, + 1: function (_a) { + var decorators = _a[0], modifiers = _a[1], isTypeOnly = _a[2], name = _a[3], moduleReference = _a[4]; + return (decorators === undefined || ts.every(decorators, ts.isDecorator)) && + (modifiers === undefined || ts.isArray(modifiers)) && + (isTypeOnly === undefined || typeof isTypeOnly === "boolean") && + (typeof name === "string" || ts.isIdentifier(name)) && + (moduleReference !== undefined && ts.isModuleReference(moduleReference)); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS + }) + .finish(); + factory.updateImportEqualsDeclaration = ts.buildOverload("updateImportEqualsDeclaration") + .overload({ + 0: function (node, modifiers, isTypeOnly, name, moduleReference) { + return updateImportEqualsDeclaration(node, modifiers, isTypeOnly, name, moduleReference); + }, + 1: function (node, _decorators, modifiers, isTypeOnly, name, moduleReference) { + return updateImportEqualsDeclaration(node, modifiers, isTypeOnly, name, moduleReference); + }, + }) + .bind({ + 0: function (_a) { + var modifiers = _a[1], isTypeOnly = _a[2], name = _a[3], moduleReference = _a[4], other = _a[5]; + return (other === undefined) && + (modifiers === undefined || ts.every(modifiers, ts.isModifier)) && + (isTypeOnly === undefined || typeof isTypeOnly === "boolean") && + (typeof name !== "boolean") && + (typeof moduleReference !== "string"); + }, + 1: function (_a) { + var decorators = _a[1], modifiers = _a[2], isTypeOnly = _a[3], name = _a[4], moduleReference = _a[5]; + return (decorators === undefined || ts.every(decorators, ts.isDecorator)) && + (modifiers === undefined || ts.isArray(modifiers)) && + (isTypeOnly === undefined || typeof isTypeOnly === "boolean") && + (typeof name === "string" || ts.isIdentifier(name)) && + (moduleReference !== undefined && ts.isModuleReference(moduleReference)); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS + }) + .finish(); + factory.createImportDeclaration = ts.buildOverload("createImportDeclaration") + .overload({ + 0: function (modifiers, importClause, moduleSpecifier, assertClause) { + return createImportDeclaration(modifiers, importClause, moduleSpecifier, assertClause); + }, + 1: function (_decorators, modifiers, importClause, moduleSpecifier, assertClause) { + return createImportDeclaration(modifiers, importClause, moduleSpecifier, assertClause); + }, + }) + .bind({ + 0: function (_a) { + var modifiers = _a[0], importClause = _a[1], moduleSpecifier = _a[2], assertClause = _a[3], other = _a[4]; + return (other === undefined) && + (modifiers === undefined || ts.every(modifiers, ts.isModifier)) && + (importClause === undefined || !ts.isArray(importClause)) && + (moduleSpecifier !== undefined && ts.isExpression(moduleSpecifier)) && + (assertClause === undefined || ts.isAssertClause(assertClause)); + }, + 1: function (_a) { + var decorators = _a[0], modifiers = _a[1], importClause = _a[2], moduleSpecifier = _a[3], assertClause = _a[4]; + return (decorators === undefined || ts.every(decorators, ts.isDecorator)) && + (modifiers === undefined || ts.isArray(modifiers)) && + (importClause === undefined || ts.isImportClause(importClause)) && + (moduleSpecifier !== undefined && ts.isExpression(moduleSpecifier)) && + (assertClause === undefined || ts.isAssertClause(assertClause)); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS + }) + .finish(); + factory.updateImportDeclaration = ts.buildOverload("updateImportDeclaration") + .overload({ + 0: function (node, modifiers, importClause, moduleSpecifier, assertClause) { + return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause); + }, + 1: function (node, _decorators, modifiers, importClause, moduleSpecifier, assertClause) { + return updateImportDeclaration(node, modifiers, importClause, moduleSpecifier, assertClause); + }, + }) + .bind({ + 0: function (_a) { + var modifiers = _a[1], importClause = _a[2], moduleSpecifier = _a[3], assertClause = _a[4], other = _a[5]; + return (other === undefined) && + (modifiers === undefined || ts.every(modifiers, ts.isModifier)) && + (importClause === undefined || !ts.isArray(importClause)) && + (moduleSpecifier === undefined || ts.isExpression(moduleSpecifier)) && + (assertClause === undefined || ts.isAssertClause(assertClause)); + }, + 1: function (_a) { + var decorators = _a[1], modifiers = _a[2], importClause = _a[3], moduleSpecifier = _a[4], assertClause = _a[5]; + return (decorators === undefined || ts.every(decorators, ts.isDecorator)) && + (modifiers === undefined || ts.isArray(modifiers)) && + (importClause === undefined || ts.isImportClause(importClause)) && + (moduleSpecifier !== undefined && ts.isExpression(moduleSpecifier)) && + (assertClause === undefined || ts.isAssertClause(assertClause)); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS + }) + .finish(); + factory.createExportAssignment = ts.buildOverload("createExportAssignment") + .overload({ + 0: function (modifiers, isExportEquals, expression) { + return createExportAssignment(modifiers, isExportEquals, expression); + }, + 1: function (_decorators, modifiers, isExportEquals, expression) { + return createExportAssignment(modifiers, isExportEquals, expression); + }, + }) + .bind({ + 0: function (_a) { + var modifiers = _a[0], isExportEquals = _a[1], expression = _a[2], other = _a[3]; + return (other === undefined) && + (modifiers === undefined || ts.every(modifiers, ts.isModifier)) && + (isExportEquals === undefined || typeof isExportEquals === "boolean") && + (typeof expression === "object"); + }, + 1: function (_a) { + var decorators = _a[0], modifiers = _a[1], isExportEquals = _a[2], expression = _a[3]; + return (decorators === undefined || ts.every(decorators, ts.isDecorator)) && + (modifiers === undefined || ts.isArray(modifiers)) && + (isExportEquals === undefined || typeof isExportEquals === "boolean") && + (expression !== undefined && ts.isExpression(expression)); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS + }) + .finish(); + factory.updateExportAssignment = ts.buildOverload("updateExportAssignment") + .overload({ + 0: function (node, modifiers, expression) { + return updateExportAssignment(node, modifiers, expression); + }, + 1: function (node, _decorators, modifiers, expression) { + return updateExportAssignment(node, modifiers, expression); + }, + }) + .bind({ + 0: function (_a) { + var modifiers = _a[1], expression = _a[2], other = _a[3]; + return (other === undefined) && + (modifiers === undefined || ts.every(modifiers, ts.isModifier)) && + (expression !== undefined && !ts.isArray(expression)); + }, + 1: function (_a) { + var decorators = _a[1], modifiers = _a[2], expression = _a[3]; + return (decorators === undefined || ts.every(decorators, ts.isDecorator)) && + (modifiers === undefined || ts.isArray(modifiers)) && + (expression !== undefined && ts.isExpression(expression)); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS + }) + .finish(); + factory.createExportDeclaration = ts.buildOverload("createExportDeclaration") + .overload({ + 0: function (modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause) { + return createExportDeclaration(modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause); + }, + 1: function (_decorators, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause) { + return createExportDeclaration(modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause); + }, + }) + .bind({ + 0: function (_a) { + var modifiers = _a[0], isTypeOnly = _a[1], exportClause = _a[2], moduleSpecifier = _a[3], assertClause = _a[4], other = _a[5]; + return (other === undefined) && + (modifiers === undefined || ts.every(modifiers, ts.isModifier)) && + (typeof isTypeOnly === "boolean") && + (typeof exportClause !== "boolean") && + (moduleSpecifier === undefined || ts.isExpression(moduleSpecifier)) && + (assertClause === undefined || ts.isAssertClause(assertClause)); + }, + 1: function (_a) { + var decorators = _a[0], modifiers = _a[1], isTypeOnly = _a[2], exportClause = _a[3], moduleSpecifier = _a[4], assertClause = _a[5]; + return (decorators === undefined || ts.every(decorators, ts.isDecorator)) && + (modifiers === undefined || ts.isArray(modifiers)) && + (typeof isTypeOnly === "boolean") && + (exportClause === undefined || ts.isNamedExportBindings(exportClause)) && + (moduleSpecifier === undefined || ts.isExpression(moduleSpecifier)) && + (assertClause === undefined || ts.isAssertClause(assertClause)); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS + }) + .finish(); + factory.updateExportDeclaration = ts.buildOverload("updateExportDeclaration") + .overload({ + 0: function (node, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause) { + return updateExportDeclaration(node, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause); + }, + 1: function (node, _decorators, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause) { + return updateExportDeclaration(node, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause); + }, + }) + .bind({ + 0: function (_a) { + var modifiers = _a[1], isTypeOnly = _a[2], exportClause = _a[3], moduleSpecifier = _a[4], assertClause = _a[5], other = _a[6]; + return (other === undefined) && + (modifiers === undefined || ts.every(modifiers, ts.isModifier)) && + (typeof isTypeOnly === "boolean") && + (typeof exportClause !== "boolean") && + (moduleSpecifier === undefined || ts.isExpression(moduleSpecifier)) && + (assertClause === undefined || ts.isAssertClause(assertClause)); + }, + 1: function (_a) { + var decorators = _a[1], modifiers = _a[2], isTypeOnly = _a[3], exportClause = _a[4], moduleSpecifier = _a[5], assertClause = _a[6]; + return (decorators === undefined || ts.every(decorators, ts.isDecorator)) && + (modifiers === undefined || ts.isArray(modifiers)) && + (typeof isTypeOnly === "boolean") && + (exportClause === undefined || ts.isNamedExportBindings(exportClause)) && + (moduleSpecifier === undefined || ts.isExpression(moduleSpecifier)) && + (assertClause === undefined || ts.isAssertClause(assertClause)); + }, + }) + .deprecate({ + 1: DISALLOW_DECORATORS + }) + .finish(); + } + // Patch `createNodeFactory` because it creates the factories that are provided to transformers + // in the public API. + var prevCreateNodeFactory = ts.createNodeFactory; + // eslint-disable-next-line @typescript-eslint/no-unnecessary-qualifier + ts.createNodeFactory = function (flags, baseFactory) { + var factory = prevCreateNodeFactory(flags, baseFactory); + patchNodeFactory(factory); + return factory; + }; + // Patch `ts.factory` because its public + patchNodeFactory(ts.factory); +})(ts || (ts = {})); +/* @internal */ +var ts; +(function (ts) { + if (typeof console !== "undefined") { + ts.Debug.loggingHost = { + log: function (level, s) { + switch (level) { + case ts.LogLevel.Error: return console.error(s); + case ts.LogLevel.Warning: return console.warn(s); + case ts.LogLevel.Info: return console.log(s); + case ts.LogLevel.Verbose: return console.log(s); + } + } + }; + } +})(ts || (ts = {})); \ No newline at end of file